25254bb Make -e option orthogonal to other filter options — HardenedBSD-pkg

modified libpkg/pkg.h.in

@@ -189,10 +189,6 @@ typedef enum {

 	 * case insensitive according to pkgdb_case_sensitive()
 	 */
 	MATCH_REGEX,
 	/**
 	 * The argument is a WHERE clause to use as condition
 	 */
 	MATCH_CONDITION,
 } match_t;
 /**

@@ -909,8 +905,12 @@ bool pkgdb_case_sensitive(void);

  */
 struct pkgdb_it * pkgdb_query(struct pkgdb *db, const char *pattern,
     match_t type);
 struct pkgdb_it * pkgdb_query_cond(struct pkgdb *db, const char *cond,
     const char *pattern, match_t type);
 struct pkgdb_it * pkgdb_repo_query(struct pkgdb *db, const char *pattern,
     match_t type, const char *reponame);
 struct pkgdb_it *pkgdb_repo_query_cond(struct pkgdb *db, const char *cond,
 	const char *pattern, match_t type, const char *reponame);
 struct pkgdb_it * pkgdb_repo_search(struct pkgdb *db, const char *pattern,
     match_t type, pkgdb_field field, pkgdb_field sort, const char *reponame);

modified libpkg/pkg_jobs.c

@@ -70,6 +70,8 @@ extern struct pkg_ctx ctx;

 static int pkg_jobs_installed_local_pkg(struct pkg_jobs *j, struct pkg *pkg);
 static int pkg_jobs_find_upgrade(struct pkg_jobs *j, const char *pattern, match_t m);
 static int pkg_jobs_find_upgrade_cond(struct pkg_jobs *j, const char *cond,
 	const char *pattern, match_t m);
 static int pkg_jobs_fetch(struct pkg_jobs *j);
 static bool new_pkg_version(struct pkg_jobs *j);
 static int pkg_jobs_check_conflicts(struct pkg_jobs *j);

@@ -801,7 +803,7 @@ pkg_jobs_has_replacement(struct pkg_jobs *j, const char *uid)

 }
 static int
 pkg_jobs_try_remote_candidate(struct pkg_jobs *j, const char *pattern,
 pkg_jobs_try_remote_candidate(struct pkg_jobs *j, const char *cond, const char *pattern,
     const char *uid, match_t m)
 {
 	struct pkg *p = NULL;

@@ -814,7 +816,7 @@ pkg_jobs_try_remote_candidate(struct pkg_jobs *j, const char *pattern,

 	xstring *qmsg = NULL;
 	struct pkg_job_universe_item *unit;
 	if ((it = pkgdb_repo_query(j->db, pattern, m, j->reponame)) == NULL)
 	if ((it = pkgdb_repo_query_cond(j->db, cond, pattern, m, j->reponame)) == NULL)
 		return (EPKG_FATAL);
 	while (it != NULL && pkgdb_it_next(it, &p, flags) == EPKG_OK) {

@@ -868,7 +870,7 @@ pkg_jobs_guess_upgrade_candidate(struct pkg_jobs *j, const char *pattern)

 	/* First of all, try to search a package with the same name */
 	pos = strchr(pattern, '/');
 	if (pos != NULL && pos[1] != '\0') {
 		if (pkg_jobs_try_remote_candidate(j, pos + 1, opattern, MATCH_EXACT)
 		if (pkg_jobs_try_remote_candidate(j, pos + 1, NULL, opattern, MATCH_EXACT)
 						== EPKG_OK)
 			return (EPKG_OK);

@@ -891,12 +893,12 @@ pkg_jobs_guess_upgrade_candidate(struct pkg_jobs *j, const char *pattern)

 		/* Try exact pattern without numbers */
 		cpy = xmalloc(len + 1);
 		strlcpy(cpy, pos, len + 1);
 		if (pkg_jobs_try_remote_candidate(j, cpy, opattern, MATCH_EXACT) != EPKG_OK) {
 		if (pkg_jobs_try_remote_candidate(j, cpy, NULL, opattern, MATCH_EXACT) != EPKG_OK) {
 			free(cpy);
 			cpy = sqlite3_mprintf(" WHERE name REGEXP ('^' || %.*Q || '[0-9.]*$')",
 					len, pos);
 			if (pkg_jobs_try_remote_candidate(j, cpy, opattern, MATCH_CONDITION)
 			if (pkg_jobs_try_remote_candidate(j, cpy, opattern, NULL, MATCH_ALL)
 					== EPKG_OK)
 				rc = EPKG_OK;
 			sqlite3_free(cpy);

@@ -911,7 +913,7 @@ pkg_jobs_guess_upgrade_candidate(struct pkg_jobs *j, const char *pattern)

 }
 static int
 pkg_jobs_find_upgrade(struct pkg_jobs *j, const char *pattern, match_t m)
 pkg_jobs_find_upgrade_cond(struct pkg_jobs *j, const char *cond, const char *pattern, match_t m)
 {
 	struct pkg *p = NULL;
 	struct pkgdb_it *it;

@@ -989,6 +991,12 @@ pkg_jobs_find_upgrade(struct pkg_jobs *j, const char *pattern, match_t m)

 }
 static int
 pkg_jobs_find_upgrade(struct pkg_jobs *j, const char *pattern, match_t m)
 {
 	return pkg_jobs_find_upgrade_cond(j, NULL, pattern, m);
 }
 static int
 pkg_jobs_check_local_pkg(struct pkg_jobs *j, struct job_pattern *jp)
 {
 	struct pkgdb_it *it;

@@ -1460,7 +1468,7 @@ jobs_solve_autoremove(struct pkg_jobs *j)

 	struct pkg *pkg = NULL;
 	struct pkgdb_it *it;
 	if ((it = pkgdb_query(j->db, " WHERE automatic=1 AND vital=0 ", MATCH_CONDITION)) == NULL)
 	if ((it = pkgdb_query_cond(j->db, " WHERE automatic=1 AND vital=0 ", NULL, MATCH_ALL)) == NULL)
 		return (EPKG_FATAL);
 	while (pkgdb_it_next(it, &pkg,

@@ -1584,7 +1592,7 @@ jobs_solve_full_upgrade(struct pkg_jobs *j)

 		pkg_emit_progress_tick(++elt_num, jcount);
 		sqlite3_snprintf(sizeof(sqlbuf), sqlbuf, " WHERE id=%" PRId64,
 		    c->id);
 		if ((it = pkgdb_query(j->db, sqlbuf, MATCH_CONDITION)) == NULL)
 		if ((it = pkgdb_query_cond(j->db, sqlbuf, NULL, MATCH_ALL)) == NULL)
 			return (EPKG_FATAL);
 		pkg = NULL;

modified libpkg/pkgdb.c

@@ -3107,8 +3107,8 @@ pkgdb_begin_solver(struct pkgdb *db)

 	int rc = EPKG_OK;
 	int64_t cnt = 0, cur = 0;
 	it = pkgdb_query(db, " WHERE manifestdigest IS NULL OR manifestdigest==''",
 		MATCH_CONDITION);
 	it = pkgdb_query_cond(db, " WHERE manifestdigest IS NULL OR manifestdigest==''",
 		NULL, MATCH_ALL);
 	if (it != NULL) {
 		kv_init(pkglist);
 		while (pkgdb_it_next(it, &p, PKG_LOAD_BASIC|PKG_LOAD_OPTIONS) == EPKG_OK) {

modified libpkg/pkgdb_query.c

@@ -79,9 +79,9 @@ pkgdb_get_pattern_query(const char *pattern, match_t match)

 		if (pkgdb_case_sensitive()) {
 			if (checkuid == NULL) {
 				if (checkorigin == NULL)
 					comp = " WHERE name = ?1 "
 					comp = " WHERE (name = ?1 "
 					    "OR (name = SPLIT_VERSION('name', ?1) AND "
 					    " version = SPLIT_VERSION('version', ?1))";
 					    " version = SPLIT_VERSION('version', ?1)))";
 				else
 					comp = " WHERE origin = ?1";
 			} else {

@@ -90,9 +90,9 @@ pkgdb_get_pattern_query(const char *pattern, match_t match)

 		} else {
 			if (checkuid == NULL) {
 				if (checkorigin == NULL)
 					comp = " WHERE name = ?1 COLLATE NOCASE "
 					comp = " WHERE (name = ?1 COLLATE NOCASE "
 							"OR (name = SPLIT_VERSION('name', ?1) COLLATE NOCASE AND "
 							" version = SPLIT_VERSION('version', ?1))";
 							" version = SPLIT_VERSION('version', ?1)))";
 				else
 					comp = " WHERE origin = ?1 COLLATE NOCASE";
 			} else {

@@ -103,8 +103,8 @@ pkgdb_get_pattern_query(const char *pattern, match_t match)

 	case MATCH_GLOB:
 		if (checkuid == NULL) {
 			if (checkorigin == NULL)
 				comp = " WHERE name GLOB ?1 "
 					"OR name || '-' || version GLOB ?1";
 				comp = " WHERE (name GLOB ?1 "
 					"OR name || '-' || version GLOB ?1)";
 			else
 				comp = " WHERE origin GLOB ?1";
 		} else {

@@ -114,24 +114,21 @@ pkgdb_get_pattern_query(const char *pattern, match_t match)

 	case MATCH_REGEX:
 		if (checkuid == NULL) {
 			if (checkorigin == NULL)
 				comp = " WHERE name REGEXP ?1 "
 				    "OR name || '-' || version REGEXP ?1";
 				comp = " WHERE (name REGEXP ?1 "
 				    "OR name || '-' || version REGEXP ?1)";
 			else
 				comp = " WHERE origin REGEXP ?1";
 		} else {
 			comp = " WHERE name = ?1";
 		}
 		break;
 	case MATCH_CONDITION:
 		comp = pattern;
 		break;
 	}
 	return (comp);
 }
 struct pkgdb_it *
 pkgdb_query(struct pkgdb *db, const char *pattern, match_t match)
 pkgdb_query_cond(struct pkgdb *db, const char *cond, const char *pattern, match_t match)
 {
 	char		 sql[BUFSIZ];
 	sqlite3_stmt	*stmt;

@@ -144,14 +141,24 @@ pkgdb_query(struct pkgdb *db, const char *pattern, match_t match)

 	comp = pkgdb_get_pattern_query(pattern, match);
 	sqlite3_snprintf(sizeof(sql), sql,
 			"SELECT id, origin, name, name as uniqueid, "
 				"version, comment, desc, "
 				"message, arch, maintainer, www, "
 				"prefix, flatsize, licenselogic, automatic, "
 				"locked, time, manifestdigest, vital "
 			"FROM packages AS p%s "
 			"ORDER BY p.name;", comp);
 	if (cond)
 		sqlite3_snprintf(sizeof(sql), sql,
 				"SELECT id, origin, name, name as uniqueid, "
 					"version, comment, desc, "
 					"message, arch, maintainer, www, "
 					"prefix, flatsize, licenselogic, automatic, "
 					"locked, time, manifestdigest, vital "
 					"FROM packages AS p%s %s (%s) ORDER BY p.name;",
 					comp, pattern == NULL ? "WHERE" : "AND", cond + 7);
 	else
 		sqlite3_snprintf(sizeof(sql), sql,
 				"SELECT id, origin, name, name as uniqueid, "
 					"version, comment, desc, "
 					"message, arch, maintainer, www, "
 					"prefix, flatsize, licenselogic, automatic, "
 					"locked, time, manifestdigest, vital "
 				"FROM packages AS p%s "
 				"ORDER BY p.name;", comp);
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {

@@ -159,12 +166,18 @@ pkgdb_query(struct pkgdb *db, const char *pattern, match_t match)

 		return (NULL);
 	}
 	if (match != MATCH_ALL && match != MATCH_CONDITION)
 	if (match != MATCH_ALL || cond != NULL)
 		sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT);
 	return (pkgdb_it_new_sqlite(db, stmt, PKG_INSTALLED, PKGDB_IT_FLAG_ONCE));
 }
 struct pkgdb_it *
 pkgdb_query(struct pkgdb *db, const char *pattern, match_t match)
 {
 	return pkgdb_query_cond(db, NULL, pattern, match);
 }
 bool
 pkgdb_file_exists(struct pkgdb *db, const char *path)
 {

@@ -335,7 +348,7 @@ pkgdb_query_provide(struct pkgdb *db, const char *req)

 }
 struct pkgdb_it *
 pkgdb_repo_query(struct pkgdb *db, const char *pattern, match_t match,
 pkgdb_repo_query_cond(struct pkgdb *db, const char *cond, const char *pattern, match_t match,
     const char *repo)
 {
 	struct pkgdb_it *it;

@@ -348,7 +361,7 @@ pkgdb_repo_query(struct pkgdb *db, const char *pattern, match_t match,

 	LL_FOREACH(db->repos, cur) {
 		if (repo == NULL || strcasecmp(cur->repo->name, repo) == 0) {
 			rit = cur->repo->ops->query(cur->repo, pattern, match);
 			rit = cur->repo->ops->query(cur->repo, NULL, pattern, match);
 			if (rit != NULL)
 				pkgdb_it_repo_attach(it, rit);
 		}

@@ -357,6 +370,12 @@ pkgdb_repo_query(struct pkgdb *db, const char *pattern, match_t match,

 	return (it);
 }
 struct pkgdb_it *pkgdb_repo_query(struct pkgdb *db, const char *pattern,
 	match_t match, const char *repo)
 {
 	return pkgdb_repo_query_cond(db, NULL, pattern, match, repo);
 }
 struct pkgdb_it *
 pkgdb_repo_shlib_require(struct pkgdb *db, const char *require, const char *repo)
 {

modified libpkg/private/pkg.h

@@ -565,7 +565,7 @@ struct pkg_repo_ops {

 	/* Query repo */
 	struct pkg_repo_it * (*query)(struct pkg_repo *,
 					const char *, match_t);
 					const char*, const char *, match_t);
 	struct pkg_repo_it * (*shlib_required)(struct pkg_repo *,
 					const char *);
 	struct pkg_repo_it * (*shlib_provided)(struct pkg_repo *,

modified libpkg/repo/binary/binary.h

@@ -40,7 +40,7 @@ int pkg_repo_binary_create(struct pkg_repo *repo);

 int pkg_repo_binary_open(struct pkg_repo *repo, unsigned mode);
 struct pkg_repo_it *pkg_repo_binary_query(struct pkg_repo *repo,
 	const char *pattern, match_t match);
 	const char *cond, const char *pattern, match_t match);
 struct pkg_repo_it *pkg_repo_binary_shlib_provide(struct pkg_repo *repo,
 	const char *require);
 struct pkg_repo_it *pkg_repo_binary_provide(struct pkg_repo *repo,

modified libpkg/repo/binary/init.c

@@ -386,7 +386,7 @@ pkg_repo_binary_open(struct pkg_repo *repo, unsigned mode)

 	repo->priv = sqlite;
 	/* Check digests format */
 	if ((it = pkg_repo_binary_query(repo, NULL, MATCH_ALL)) == NULL)
 	if ((it = pkg_repo_binary_query(repo, NULL, NULL, MATCH_ALL)) == NULL)
 		return (EPKG_OK);
 	if (it->ops->next(it, &pkg, PKG_LOAD_BASIC) != EPKG_OK) {

modified libpkg/repo/binary/query.c

@@ -96,7 +96,7 @@ pkg_repo_binary_it_reset(struct pkg_repo_it *it)

 }
 struct pkg_repo_it *
 pkg_repo_binary_query(struct pkg_repo *repo, const char *pattern, match_t match)
 pkg_repo_binary_query(struct pkg_repo *repo, const char *cond, const char *pattern, match_t match)
 {
 	sqlite3 *sqlite = PRIV_GET(repo);
 	sqlite3_stmt	*stmt = NULL;

@@ -122,7 +122,7 @@ pkg_repo_binary_query(struct pkg_repo *repo, const char *pattern, match_t match)

 	if (stmt == NULL)
 		return (NULL);
 	if (match != MATCH_ALL && match != MATCH_CONDITION)
 	if (match != MATCH_ALL && cond == NULL)
 		sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT);
 	return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));

@@ -267,10 +267,6 @@ pkg_repo_binary_search_how(match_t match)

 	case MATCH_REGEX:
 		how = "%s REGEXP ?1";
 		break;
 	case MATCH_CONDITION:
 		/* Should not be called by pkgdb_get_match_how(). */
 		assert(0);
 		break;
 	}
 	return (how);

modified src/lock.c

@@ -154,7 +154,7 @@ list_locked(struct pkgdb *db, bool has_locked)

 	struct pkg	*pkg = NULL;
 	bool		 gotone = false;
 	if ((it = pkgdb_query(db, " where locked=1", MATCH_CONDITION)) == NULL) {
 	if ((it = pkgdb_query_cond(db, " WHERE locked=1", NULL, MATCH_ALL)) == NULL) {
 		pkgdb_close(db);
 		return (EXIT_FAILURE);
 	}

modified src/query.c

@@ -127,7 +127,7 @@ format_str(struct pkg *pkg, xstring *dest, const char *qstr, const void *data)

 				break;
 			case 's':
 				qstr++;
 				if (qstr[0] == 'h')
 				if (qstr[0] == 'h')
 					pkg_fprintf(dest->fp, "%#sB", pkg);
 			        else if (qstr[0] == 'b')
 					pkg_fprintf(dest->fp, "%s", pkg);

@@ -869,7 +869,9 @@ exec_query(int argc, char **argv)

 	int			 retcode = EXIT_SUCCESS;
 	int			 i;
 	char			 multiline = 0;
 	int			 nprinted = 0;
 	char			*condition = NULL;
 	const char 		*condition_sql = NULL;
 	xstring			*sqlcond = NULL;
 	const unsigned int	 q_flags_len = NELEM(accepted_query_flags);

@@ -893,7 +895,6 @@ exec_query(int argc, char **argv)

 			pkgdb_set_case_sensitivity(true);
 			break;
 		case 'e':
 			match = MATCH_CONDITION;
 			condition = optarg;
 			break;
 		case 'F':

@@ -923,7 +924,7 @@ exec_query(int argc, char **argv)

 	}
 	/* Default to all packages if no pkg provided */
 	if (argc == 1 && pkgname == NULL && condition == NULL && match == MATCH_EXACT) {
 	if (argc == 1 && pkgname == NULL && match == MATCH_EXACT) {
 		match = MATCH_ALL;
 	} else if (((argc == 1) ^ (match == MATCH_ALL)) && pkgname == NULL
 			&& condition == NULL) {

@@ -995,49 +996,38 @@ exec_query(int argc, char **argv)

 		return (EXIT_FAILURE);
 	}
 	if (match == MATCH_ALL || match == MATCH_CONDITION) {
 		const char *condition_sql = NULL;
 		if (match == MATCH_CONDITION && sqlcond) {
 			fflush(sqlcond->fp);
 			condition_sql = sqlcond->buf;
 	if (sqlcond) {
 		fflush(sqlcond->fp);
 		condition_sql = sqlcond->buf;
 	}
         i = 1;
         do {
 		pkgname = i < argc ? argv[i] : NULL;
 		if ((it = pkgdb_query_cond(db, condition_sql, pkgname, match)) == NULL) {
 			warnx("DEBUG: %s/%s\n", condition_sql ? condition_sql : "-", pkgname ? pkgname : "-");
 			retcode = EXIT_FAILURE;
 			goto cleanup;
 		}
 		if ((it = pkgdb_query(db, condition_sql, match)) == NULL)
 			return (EXIT_FAILURE);
 		while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK)
 			print_query(pkg, argv[0],  multiline);
 		while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
 			nprinted++;
 			print_query(pkg, argv[0], multiline);
 		}
 		if (ret != EPKG_END)
 		if (ret != EPKG_END) {
 			retcode = EXIT_FAILURE;
 			break;
 		}
 		pkgdb_it_free(it);
 	} else {
 		int nprinted = 0;
 		for (i = 1; i < argc; i++) {
 			pkgname = argv[i];
 			if ((it = pkgdb_query(db, pkgname, match)) == NULL) {
 				retcode = EXIT_FAILURE;
 				goto cleanup;
 			}
 		i++;
 	} while (i < argc);
 			while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
 				nprinted++;
 				print_query(pkg, argv[0], multiline);
 			}
 			if (ret != EPKG_END) {
 				retcode = EXIT_FAILURE;
 				break;
 			}
 			pkgdb_it_free(it);
 		}
 		if (nprinted == 0 && retcode == EXIT_SUCCESS) {
 			/* ensure to return a non-zero status when no package
 			 were found. */
 			retcode = EXIT_FAILURE;
 		}
 	if (nprinted == 0 && condition_sql == NULL && retcode == EXIT_SUCCESS) {
 		/* ensure to return a non-zero status when no package
 		 were found. */
 		retcode = EXIT_FAILURE;
 	}
 cleanup:

modified src/rquery.c

@@ -146,7 +146,6 @@ exec_rquery(int argc, char **argv)

 			pkgdb_set_case_sensitivity(true);
 			break;
 		case 'e':
 			match = MATCH_CONDITION;
 			condition = optarg;
 			break;
 		case 'g':

@@ -183,7 +182,7 @@ exec_rquery(int argc, char **argv)

 	/* Default to all packages if no pkg provided */
 	if (!index_output) {
 		if (argc == 1 && condition == NULL && match == MATCH_EXACT) {
 		if (argc == 1 && match == MATCH_EXACT) {
 			match = MATCH_ALL;
 		} else if (((argc == 1) ^ (match == MATCH_ALL )) && condition == NULL) {
 			usage_rquery();

@@ -234,13 +233,13 @@ exec_rquery(int argc, char **argv)

 	if (index_output)
 		query_flags = PKG_LOAD_BASIC|PKG_LOAD_CATEGORIES|PKG_LOAD_DEPS;
 	if (match == MATCH_ALL || match == MATCH_CONDITION) {
 		const char *condition_sql = NULL;
 		if (match == MATCH_CONDITION && sqlcond) {
 			fflush(sqlcond->fp);
 			condition_sql = sqlcond->buf;
 		}
 		if ((it = pkgdb_repo_query(db, condition_sql, match, reponame)) == NULL) {
 	const char *condition_sql = NULL;
 	if (sqlcond) {
 		fflush(sqlcond->fp);
 		condition_sql = sqlcond->buf;
 	}
 	if (match == MATCH_ALL) {
 		if ((it = pkgdb_repo_query_cond(db, condition_sql, NULL, match, reponame)) == NULL) {
 			xstring_free(sqlcond);
 			return (EXIT_FAILURE);
 		}

@@ -260,7 +259,7 @@ exec_rquery(int argc, char **argv)

 		for (i = (index_output ? 0 : 1); i < argc; i++) {
 			pkgname = argv[i];
 			if ((it = pkgdb_repo_query(db, pkgname, match, reponame)) == NULL) {
 			if ((it = pkgdb_repo_query_cond(db, condition_sql, pkgname, match, reponame)) == NULL) {
 				xstring_free(sqlcond);
 				return (EXIT_FAILURE);
 			}