281bca8 Add new %?* to query to determine if a list is empty or not — HardenedBSD-pkg

HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

Add new %?* to query to determine if a list is empty or not

Baptiste Daroussin committed 14 years ago

commit 281bca8355db3c0443b0e40673b192c43728ac2f
parent c37f90c

3 files changed +205 -83

modified libpkg/pkg.c

@@ -793,6 +793,30 @@ pkg_addoption(struct pkg *pkg, const char *key, const char *value)

 	return (EPKG_OK);
 }
 int
 pkg_list_empty(struct pkg *pkg, pkg_list list) {
 	switch (list) {
 		case PKG_DEPS:
 			return (STAILQ_EMPTY(&pkg->deps));
 		case PKG_RDEPS:
 			return (STAILQ_EMPTY(&pkg->rdeps));
 		case PKG_LICENSES:
 			return (STAILQ_EMPTY(&pkg->licenses));
 		case PKG_OPTIONS:
 			return (STAILQ_EMPTY(&pkg->options));
 		case PKG_CATEGORIES:
 			return (STAILQ_EMPTY(&pkg->categories));
 		case PKG_FILES:
 			return (STAILQ_EMPTY(&pkg->files));
 		case PKG_DIRS:
 			return (STAILQ_EMPTY(&pkg->dirs));
 		case PKG_USERS:
 			return (STAILQ_EMPTY(&pkg->users));
 		case PKG_GROUPS:
 			return (STAILQ_EMPTY(&pkg->groups));
 	}
 }
 void
 pkg_freedeps(struct pkg *pkg)
 {

modified libpkg/pkg.h

@@ -132,6 +132,18 @@ typedef enum {

 	PKG_NEWVERSION,
 } pkg_attr;
 typedef enum {
 	PKG_DEPS = 0,
 	PKG_RDEPS,
 	PKG_LICENSES,
 	PKG_OPTIONS,
 	PKG_CATEGORIES,
 	PKG_FILES,
 	PKG_DIRS,
 	PKG_USERS,
 	PKG_GROUPS
 } pkg_list;
 /**
  * Determine the type of a pkg_script.
  */

@@ -234,7 +246,7 @@ int64_t pkg_new_flatsize(struct pkg *);

  */
 int64_t pkg_new_pkgsize(struct pkg *);
 int pkg_list_empty(struct pkg *, pkg_list);
 /**
  * Iterates over the dependencies of the package.
  * @param dep Must be set to NULL for the first call.

modified pkg/query.c

@@ -43,6 +43,9 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)

 				case 'w':
 					sbuf_cat(dest, pkg_get(pkg, PKG_WWW));
 					break;
 				case 'a':
 					sbuf_printf(dest, "%d", pkg_isautomatic(pkg));
 					break;
 				case 's':
 					qstr++;
 					if (qstr[0] == 'h') {

@@ -52,6 +55,38 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)

 						sbuf_printf(dest, "%" PRId64, pkg_flatsize(pkg));
 					}
 					break;
 				case '?':
 					qstr++;
 					switch (qstr[0]) {
 						case 'd':
 							sbuf_printf(dest, "%d", !pkg_list_empty(pkg, PKG_DEPS));
 							break;
 						case 'r':
 							sbuf_printf(dest, "%d", !pkg_list_empty(pkg, PKG_RDEPS));
 							break;
 						case 'C':
 							sbuf_printf(dest, "%d", !pkg_list_empty(pkg, PKG_CATEGORIES));
 							break;
 						case 'F':
 							sbuf_printf(dest, "%d", !pkg_list_empty(pkg, PKG_FILES));
 							break;
 						case 'O':
 							sbuf_printf(dest, "%d", !pkg_list_empty(pkg, PKG_OPTIONS));
 							break;
 						case 'D':
 							sbuf_printf(dest, "%d", !pkg_list_empty(pkg, PKG_DIRS));
 							break;
 						case 'L':
 							sbuf_printf(dest, "%d", !pkg_list_empty(pkg, PKG_LICENSES));
 							break;
 						case 'U':
 							sbuf_printf(dest, "%d", !pkg_list_empty(pkg, PKG_USERS));
 							break;
 						case 'G':
 							sbuf_printf(dest, "%d", !pkg_list_empty(pkg, PKG_GROUPS));
 							break;
 					}
 					break;
 				case 'l':
 					if (pkg_licenselogic(pkg))
 						sbuf_putc(dest, pkg_licenselogic(pkg));

@@ -115,7 +150,7 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)

 	sbuf_finish(dest);
 }
 static void
 print_query(struct pkg *pkg, char *qstr, match_t query_flags)
 print_query(struct pkg *pkg, char *qstr, char multiline)
 {
 	struct sbuf *output = sbuf_new_auto();
 	struct pkg_dep *dep = NULL;

@@ -127,62 +162,71 @@ print_query(struct pkg *pkg, char *qstr, match_t query_flags)

 	struct pkg_user *user = NULL;
 	struct pkg_group *group = NULL;
 	if (query_flags & PKG_LOAD_DEPS) {
 		while (pkg_deps(pkg, &dep) == EPKG_OK) {
 			format_str(pkg, output, qstr, dep);
 			printf("%s\n", sbuf_data(output));
 	switch (multiline) {
 		case 'd':
 			while (pkg_deps(pkg, &dep) == EPKG_OK) {
 				format_str(pkg, output, qstr, dep);
 				printf("%s\n", sbuf_data(output));
 				break;
 		}
 	} else if (query_flags & PKG_LOAD_RDEPS) {
 		while (pkg_rdeps(pkg, &dep) == EPKG_OK) {
 		case 'r':
 			while (pkg_rdeps(pkg, &dep) == EPKG_OK) {
 				format_str(pkg, output, qstr, dep);
 				printf("%s\n", sbuf_data(output));
 			}
 			break;
 		case 'C':
 			while (pkg_categories(pkg, &cat) == EPKG_OK) {
 				format_str(pkg, output, qstr, cat);
 				printf("%s\n", sbuf_data(output));
 			}
 			break;
 		case 'O':
 			while (pkg_options(pkg, &option) == EPKG_OK) {
 				format_str(pkg, output, qstr, option);
 				printf("%s\n", sbuf_data(output));
 			}
 			break;
 		case 'F':
 			while (pkg_files(pkg, &file) == EPKG_OK) {
 				format_str(pkg, output, qstr, file);
 				printf("%s\n", sbuf_data(output));
 			}
 			break;
 		case 'D':
 			while (pkg_dirs(pkg, &dir) == EPKG_OK) {
 				format_str(pkg, output, qstr, dir);
 				printf("%s\n", sbuf_data(output));
 			}
 			break;
 		case 'L':
 			while (pkg_licenses(pkg, &lic) == EPKG_OK) {
 				format_str(pkg, output, qstr, lic);
 				printf("%s\n", sbuf_data(output));
 			}
 			break;
 		case 'U':
 			while (pkg_users(pkg, &user) == EPKG_OK) {
 				format_str(pkg, output, qstr, user);
 				printf("%s\n", sbuf_data(output));
 			}
 			break;
 		case 'G':
 			while (pkg_users(pkg, &user) == EPKG_OK) {
 				format_str(pkg, output, qstr, group);
 				printf("%s\n", sbuf_data(output));
 			}
 			break;
 		default:
 			format_str(pkg, output, qstr, dep);
 			printf("%s\n", sbuf_data(output));
 		}
 	} else if (query_flags & PKG_LOAD_CATEGORIES) {
 		while (pkg_categories(pkg, &cat) == EPKG_OK) {
 			format_str(pkg, output, qstr, cat);
 			printf("%s\n", sbuf_data(output));
 		}
 	} else if (query_flags & PKG_LOAD_OPTIONS) {
 		while (pkg_options(pkg, &option) == EPKG_OK) {
 			format_str(pkg, output, qstr, option);
 			printf("%s\n", sbuf_data(output));
 		}
 	} else if (query_flags & PKG_LOAD_FILES) {
 		while (pkg_files(pkg, &file) == EPKG_OK) {
 			format_str(pkg, output, qstr, file);
 			printf("%s\n", sbuf_data(output));
 		}
 	} else if (query_flags & PKG_LOAD_DIRS) {
 		while (pkg_dirs(pkg, &dir) == EPKG_OK) {
 			format_str(pkg, output, qstr, dir);
 			printf("%s\n", sbuf_data(output));
 		}
 	} else if (query_flags & PKG_LOAD_LICENSES) {
 		while (pkg_licenses(pkg, &lic) == EPKG_OK) {
 			format_str(pkg, output, qstr, lic);
 			printf("%s\n", sbuf_data(output));
 		}
 	} else if (query_flags & PKG_LOAD_USERS) {
 		while (pkg_users(pkg, &user) == EPKG_OK) {
 			format_str(pkg, output, qstr, user);
 			printf("%s\n", sbuf_data(output));
 		}
 	} else if (query_flags & PKG_LOAD_GROUPS) {
 		while (pkg_users(pkg, &user) == EPKG_OK) {
 			format_str(pkg, output, qstr, group);
 			printf("%s\n", sbuf_data(output));
 		}
 	} else {
 		format_str(pkg, output, qstr, dep);
 		printf("%s\n", sbuf_data(output));
 			break;
 	}
 	sbuf_delete(output);
 }
 static int
 analyse_query_string(char *qstr, int *flags)
 analyse_query_string(char *qstr, int *flags, char *multiline)
 {
 	char multiline = 0;
 	while (qstr[0] != '\0') {
 		if (qstr[0] == '%') {
 			qstr++;

@@ -193,11 +237,11 @@ analyse_query_string(char *qstr, int *flags)

 						fprintf(stderr, "Invalid query: %%d should be followed by: n, o or v\n");
 						return (EPKG_FATAL);
 					}
 					if (multiline != 0 && multiline != 'd') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%d' at the same time\n", multiline);
 					if (*multiline != 0 && *multiline != 'd') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%d' at the same time\n", *multiline);
 						return (EPKG_FATAL);
 					}
 					multiline = 'd';
 					*multiline = 'd';
 					*flags |= PKG_LOAD_DEPS;
 					break;
 				case 'r':

@@ -206,19 +250,19 @@ analyse_query_string(char *qstr, int *flags)

 						fprintf(stderr, "Invalid query: %%r should be followed by: n, o or v\n");
 						return (EPKG_FATAL);
 					}
 					if (multiline != 0 && multiline != 'r') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%r' at the same time\n", multiline);
 					if (*multiline != 0 && *multiline != 'r') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%r' at the same time\n", *multiline);
 						return (EPKG_FATAL);
 					}
 					multiline = 'r';
 					*multiline = 'r';
 					*flags |= PKG_LOAD_RDEPS;
 					break;
 				case 'C':
 					if (multiline != 0 && multiline != 'C') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%c' at the same time\n", multiline);
 					if (*multiline != 0 && *multiline != 'C') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%c' at the same time\n", *multiline);
 						return (EPKG_FATAL);
 					}
 					multiline = 'C';
 					*multiline = 'C';
 					*flags |= PKG_LOAD_CATEGORIES;
 					break;
 				case 'F':

@@ -227,19 +271,19 @@ analyse_query_string(char *qstr, int *flags)

 						fprintf(stderr, "Invalid query: %%F should be followed by: p or s\n");
 						return (EPKG_FATAL);
 					}
 					if (multiline != 0 && multiline != 'F') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%F' at the same time\n", multiline);
 					if (*multiline != 0 && *multiline != 'F') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%F' at the same time\n", *multiline);
 						return (EPKG_FATAL);
 					}
 					multiline = 'F';
 					*multiline = 'F';
 					*flags |= PKG_LOAD_FILES;
 					break;
 				case 'S':
 					if (multiline != 0 && multiline != 'S') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%S' at the same time\n", multiline);
 					if (*multiline != 0 && *multiline != 'S') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%S' at the same time\n", *multiline);
 						return (EPKG_FATAL);
 					}
 					multiline = 'S';
 					*multiline = 'S';
 					*flags |= PKG_LOAD_SCRIPTS;
 					break;
 				case 'O':

@@ -248,43 +292,43 @@ analyse_query_string(char *qstr, int *flags)

 						fprintf(stderr, "Invalid query: %%O should be followed by: k or v\n");
 						return (EPKG_FATAL);
 					}
 					if (multiline != 0 && multiline != 'O') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%O' at the same time\n", multiline);
 					if (*multiline != 0 && *multiline != 'O') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%O' at the same time\n", *multiline);
 						return (EPKG_FATAL);
 					}
 					multiline = 'O';
 					*multiline = 'O';
 					*flags |= PKG_LOAD_OPTIONS;
 					break;
 				case 'D':
 					if (multiline != 0 && multiline != 'D') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%D' at the same time\n", multiline);
 					if (*multiline != 0 && *multiline != 'D') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%D' at the same time\n", *multiline);
 						return (EPKG_FATAL);
 					}
 					multiline = 'D';
 					*multiline = 'D';
 					*flags |= PKG_LOAD_DIRS;
 					break;
 				case 'L':
 					if (multiline != 0 && multiline != 'L') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%L' at the same time\n", multiline);
 					if (*multiline != 0 && *multiline != 'L') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%L' at the same time\n", *multiline);
 						return (EPKG_FATAL);
 					}
 					multiline = 'M';
 					*multiline = 'M';
 					*flags |= PKG_LOAD_LICENSES;
 					break;
 				case 'U':
 					if (multiline != 0 && multiline != 'U') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%U' at the same time\n", multiline);
 					if (*multiline != 0 && *multiline != 'U') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%U' at the same time\n", *multiline);
 						return (EPKG_FATAL);
 					}
 					multiline = 'U';
 					*multiline = 'U';
 					*flags |= PKG_LOAD_USERS;
 					break;
 				case 'G':
 					if (multiline != 0 && multiline != 'G') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%G' at the same time\n", multiline);
 					if (*multiline != 0 && *multiline != 'G') {
 						fprintf(stderr, "Invalid query format string, you can't query '%%%c' and '%%G' at the same time\n", *multiline);
 						return (EPKG_FATAL);
 					}
 					multiline = 'G';
 					*multiline = 'G';
 					*flags |= PKG_LOAD_GROUPS;
 					break;
 				case 's':

@@ -294,6 +338,46 @@ analyse_query_string(char *qstr, int *flags)

 						return (EPKG_FATAL);
 					}
 					break;
 				case '?':
 					qstr++;
 					if (qstr[0] != 'd' && qstr[0] != 'r' && qstr[0] != 'C' &&
 							qstr[0] != 'F' && qstr[0] != '0' &&
 							qstr[0] != 'D' && qstr[0] != 'L' &&
 							qstr[0] != 'U' && qstr[0] != 'G') {
 						fprintf(stderr, "Invalid query: %%? should be followed by: d, r, C, F, O, D, L, U or G\n");
 						return (EPKG_FATAL);
 					}
 					switch (qstr[0]) {
 						case 'd':
 							*flags |= PKG_LOAD_DEPS;
 							break;
 						case 'r':
 							*flags |= PKG_LOAD_RDEPS;
 							break;
 						case 'C':
 							*flags |= PKG_LOAD_CATEGORIES;
 							break;
 						case 'F':
 							*flags |= PKG_LOAD_FILES;
 							break;
 						case 'O':
 							*flags |= PKG_LOAD_OPTIONS;
 							break;
 						case 'D':
 							*flags |= PKG_LOAD_DIRS;
 							break;
 						case 'L':
 							*flags |= PKG_LOAD_LICENSES;
 							break;
 						case 'U':
 							*flags |= PKG_LOAD_USERS;
 							break;
 						case 'G':
 							*flags |= PKG_LOAD_GROUPS;
 							break;
 					}
 					break;
 				case 'n':
 				case 'v':
 				case 'o':

@@ -302,6 +386,7 @@ analyse_query_string(char *qstr, int *flags)

 				case 'c':
 				case 'w':
 				case 'l':
 				case 'a':
 					/* this is ok */
 					break;
 				default:

@@ -335,6 +420,7 @@ exec_query(int argc, char **argv)

 	int ret = EPKG_OK;
 	int retcode = EXIT_SUCCESS;
 	int i;
 	char multiline = 0;
 	while ((ch = getopt(argc, argv, "agxX")) != -1) {
 		switch (ch) {

@@ -369,7 +455,7 @@ exec_query(int argc, char **argv)

 		return (EX_USAGE);
 	}
 	if (analyse_query_string(argv[0], &query_flags) != EPKG_OK)
 	if (analyse_query_string(argv[0], &query_flags, &multiline) != EPKG_OK)
 		return (EX_USAGE);
 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)

@@ -380,7 +466,7 @@ exec_query(int argc, char **argv)

 			return (EX_IOERR);
 		while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK)
 			print_query(pkg, argv[0], query_flags);
 			print_query(pkg, argv[0],  multiline);
 		if (ret != EPKG_END)
 			retcode = EX_SOFTWARE;

@@ -398,7 +484,7 @@ exec_query(int argc, char **argv)

 				return (EX_IOERR);
 			while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK)
 				print_query(pkg, argv[0], query_flags);
 				print_query(pkg, argv[0], multiline);
 			if (ret != EPKG_END) {
 				retcode = EX_SOFTWARE;