a449c8a Implement repo query. — HardenedBSD-pkg

HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

Implement repo query.

Vsevolod Stakhov committed 11 years ago

commit a449c8acef5e1f74dbf3a7b881aec5c46d22b305
parent 565be35

8 files changed +133 -186

modified libpkg/pkg_jobs.c

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

 	const char *fuid;
 	struct pkg_job_universe_item *unit;
 	if ((it = pkgdb_repo_query(j->db, pattern, m, j->reponame)) == NULL)
 	if ((it = pkg_repo_query(j->db, pattern, m, j->reponame)) == NULL)
 		return (EPKG_FATAL);
 	qmsg = sbuf_new_auto();

@@ -1103,7 +1103,7 @@ pkg_jobs_find_remote_pkg(struct pkg_jobs *j, const char *pattern,

 	if (j->type == PKG_JOBS_UPGRADE && (j->flags & PKG_FLAG_FORCE) == PKG_FLAG_FORCE)
 		force = true;
 	if ((it = pkgdb_repo_query(j->db, pattern, m, j->reponame)) == NULL)
 	if ((it = pkg_repo_query(j->db, pattern, m, j->reponame)) == NULL)
 		rc = EPKG_FATAL;
 	while (it != NULL && pkgdb_it_next(it, &p, flags) == EPKG_OK) {

@@ -1264,7 +1264,7 @@ get_remote_pkg(struct pkg_jobs *j, const char *uid, unsigned flag)

 				PKG_LOAD_ANNOTATIONS|PKG_LOAD_CONFLICTS;
 	}
 	if ((it = pkgdb_repo_query(j->db, uid, MATCH_EXACT, j->reponame)) == NULL)
 	if ((it = pkg_repo_query(j->db, uid, MATCH_EXACT, j->reponame)) == NULL)
 		return (NULL);
 	if (pkgdb_it_next(it, &pkg, flag) != EPKG_OK)

@@ -1898,7 +1898,7 @@ pkg_jobs_check_remote_candidate(struct pkg_jobs *j, struct pkg *pkg)

 	sqlite3_snprintf(sizeof(sqlbuf), sqlbuf, " WHERE manifestdigest=%Q", digest);
 	it = pkgdb_repo_query(j->db, sqlbuf, MATCH_CONDITION, j->reponame);
 	it = pkg_repo_query(j->db, sqlbuf, MATCH_CONDITION, j->reponame);
 	if (it != NULL) {
 		/*
 		 * If we have the same package in a remote repo, it is not an

modified libpkg/pkgdb_query.c

@@ -285,7 +285,7 @@ pkgdb_query_shlib_provide(struct pkgdb *db, const char *shlib)

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

modified libpkg/pkgdb_repo.c

@@ -53,180 +53,3 @@

 #include "private/pkgdb.h"
 #include "private/repodb.h"
 struct pkgdb_it *
 pkgdb_repo_query(struct pkgdb *db, const char *pattern, match_t match,
     const char *repo)
 {
 	sqlite3_stmt	*stmt = NULL;
 	struct sbuf	*sql = NULL;
 	const char	*reponame = NULL;
 	const char	*comp = NULL;
 	int		 ret;
 	char		 basesql[BUFSIZ] = ""
 		"SELECT id, origin, name, name || '~' || origin as uniqueid, version, comment, "
 		"prefix, desc, arch, maintainer, www, "
 		"licenselogic, flatsize, pkgsize, "
 		"cksum, manifestdigest, path AS repopath, '%1$s' AS dbname "
 		"FROM '%1$s'.packages p";
 	assert(db != NULL);
 	assert(match == MATCH_ALL || (pattern != NULL && pattern[0] != '\0'));
 	/*
 	 * If we have no remote repos loaded, we just return nothing instead of failing
 	 * an assert deep inside pkgdb_get_reponame
 	 */
 	if (db->type != PKGDB_REMOTE)
 		return (NULL);
 	reponame = pkgdb_get_reponame(db, repo);
 	sql = sbuf_new_auto();
 	comp = pkgdb_get_pattern_query(pattern, match);
 	if (comp && comp[0])
 		strlcat(basesql, comp, sizeof(basesql));
 	/*
 	 * Working on multiple remote repositories
 	 */
 	if (reponame == NULL) {
 		/* duplicate the query via UNION for all the attached
 		 * databases */
 		ret = pkgdb_sql_all_attached(db->sqlite, sql,
 		    basesql, " UNION ALL ");
 		if (ret != EPKG_OK) {
 			sbuf_delete(sql);
 			return (NULL);
 		}
 	} else
 		sbuf_printf(sql, basesql, reponame, reponame);
 	sbuf_cat(sql, " ORDER BY name;");
 	sbuf_finish(sql);
 	pkg_debug(4, "Pkgdb: running '%s' query for %s", sbuf_get(sql), pattern);
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), sbuf_size(sql), &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite, sbuf_get(sql));
 		sbuf_delete(sql);
 		return (NULL);
 	}
 	sbuf_delete(sql);
 	if (match != MATCH_ALL && match != MATCH_CONDITION)
 		sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT);
 	return (pkgdb_it_new_sqlite(db, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE));
 }
 struct pkgdb_it *
 pkgdb_repo_shlib_provide(struct pkgdb *db, const char *require, const char *repo)
 {
 	sqlite3_stmt	*stmt;
 	struct sbuf	*sql = NULL;
 	const char	*reponame = NULL;
 	int		 ret;
 	const char	 basesql[] = ""
 			"SELECT p.id, p.origin, p.name, p.version, p.comment, "
 			"p.name || '~' || p.origin as uniqueid, "
 			"p.prefix, p.desc, p.arch, p.maintainer, p.www, "
 			"p.licenselogic, p.flatsize, p.pkgsize, "
 			"p.cksum, p.manifestdigest, p.path AS repopath, '%1$s' AS dbname "
 			"FROM '%1$s'.packages AS p INNER JOIN '%1$s'.pkg_shlibs_provided AS ps ON "
 			"p.id = ps.package_id "
 			"WHERE ps.shlib_id IN (SELECT id FROM '%1$s'.shlibs WHERE "
 			"name BETWEEN ?1 AND ?1 || '.9');";
 	assert(db != NULL);
 	reponame = pkgdb_get_reponame(db, repo);
 	sql = sbuf_new_auto();
 	/*
 	 * Working on multiple remote repositories
 	 */
 	if (reponame == NULL) {
 		/* duplicate the query via UNION for all the attached
 		 * databases */
 		ret = pkgdb_sql_all_attached(db->sqlite, sql,
 				basesql, " UNION ALL ");
 		if (ret != EPKG_OK) {
 			sbuf_delete(sql);
 			return (NULL);
 		}
 	} else
 		sbuf_printf(sql, basesql, reponame);
 	sbuf_finish(sql);
 	pkg_debug(4, "Pkgdb: running '%s'", sbuf_get(sql));
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite, sbuf_get(sql));
 		sbuf_delete(sql);
 		return (NULL);
 	}
 	sbuf_delete(sql);
 	sqlite3_bind_text(stmt, 1, require, -1, SQLITE_TRANSIENT);
 	return (pkgdb_it_new_sqlite(db, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE));
 }
 struct pkgdb_it *
 pkgdb_repo_shlib_require(struct pkgdb *db, const char *provide, const char *repo)
 {
 	sqlite3_stmt	*stmt;
 	struct sbuf	*sql = NULL;
 	const char	*reponame = NULL;
 	int		 ret;
 	const char	 basesql[] = ""
 			"SELECT p.id, p.origin, p.name, p.version, p.comment, "
 			"p.name || '~' || p.origin as uniqueid, "
 			"p.prefix, p.desc, p.arch, p.maintainer, p.www, "
 			"p.licenselogic, p.flatsize, p.pkgsize, "
 			"p.cksum, p.manifestdigest, p.path AS repopath, '%1$s' AS dbname "
 			"FROM '%1$s'.packages AS p INNER JOIN '%1$s'.pkg_shlibs_required AS ps ON "
 			"p.id = ps.package_id "
 			"WHERE ps.shlib_id = (SELECT id FROM '%1$s'.shlibs WHERE name=?1);";
 	assert(db != NULL);
 	reponame = pkgdb_get_reponame(db, repo);
 	sql = sbuf_new_auto();
 	/*
 	 * Working on multiple remote repositories
 	 */
 	if (reponame == NULL) {
 		/* duplicate the query via UNION for all the attached
 		 * databases */
 		ret = pkgdb_sql_all_attached(db->sqlite, sql,
 				basesql, " UNION ALL ");
 		if (ret != EPKG_OK) {
 			sbuf_delete(sql);
 			return (NULL);
 		}
 	} else
 		sbuf_printf(sql, basesql, reponame);
 	sbuf_finish(sql);
 	pkg_debug(4, "Pkgdb: running '%s'", sbuf_get(sql));
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite, sbuf_get(sql));
 		sbuf_delete(sql);
 		return (NULL);
 	}
 	sbuf_delete(sql);
 	sqlite3_bind_text(stmt, 1, provide, -1, SQLITE_TRANSIENT);
 	return (pkgdb_it_new_sqlite(db, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE));
 }

modified libpkg/repo/binary/binary.c

@@ -31,6 +31,8 @@ struct pkg_repo_ops pkg_repo_binary_ops = {

 	.create = pkg_repo_binary_create,
 	.close = pkg_repo_binary_close,
 	.update = pkg_repo_binary_update,
 	.query = NULL,
 	.query = pkg_repo_binary_query,
 	.shlib_provided = pkg_repo_binary_shlib_provide,
 	.shlib_required = pkg_repo_binary_shlib_require,
 	.fetch_pkg = NULL
 };

modified libpkg/repo/binary/binary.h

@@ -38,4 +38,11 @@ int pkg_repo_binary_access(struct pkg_repo *repo, unsigned mode);

 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);
 struct pkg_repo_it *pkg_repo_binary_shlib_provide(struct pkg_repo *repo,
 	const char *require);
 struct pkg_repo_it *pkg_repo_binary_shlib_require(struct pkg_repo *repo,
 	const char *provide);
 #endif /* BINARY_H_ */

modified libpkg/repo/binary/query.c

@@ -100,3 +100,118 @@ pkg_repo_binary_it_reset(struct pkg_repo_it *it)

 	pkgdb_it_reset(it->data);
 }
 struct pkg_repo_it *
 pkg_repo_binary_query(struct pkg_repo *repo, const char *pattern, match_t match)
 {
 	sqlite3 *sqlite = PRIV_GET(repo);
 	sqlite3_stmt	*stmt = NULL;
 	struct sbuf	*sql = NULL;
 	const char	*comp = NULL;
 	int		 ret;
 	char		 basesql[BUFSIZ] = ""
 		"SELECT id, origin, name, name || '~' || origin as uniqueid, version, comment, "
 		"prefix, desc, arch, maintainer, www, "
 		"licenselogic, flatsize, pkgsize, "
 		"cksum, manifestdigest, path AS repopath, '%1$s' AS dbname "
 		"FROM packages";
 	assert(match == MATCH_ALL || (pattern != NULL && pattern[0] != '\0'));
 	sql = sbuf_new_auto();
 	comp = pkgdb_get_pattern_query(pattern, match);
 	if (comp && comp[0])
 		strlcat(basesql, comp, sizeof(basesql));
 	sbuf_printf(sql, basesql, repo->name);
 	sbuf_cat(sql, " ORDER BY name;");
 	sbuf_finish(sql);
 	pkg_debug(4, "Pkgdb: running '%s' query for %s", sbuf_get(sql), pattern);
 	ret = sqlite3_prepare_v2(sqlite, sbuf_get(sql), sbuf_size(sql), &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(sqlite, sbuf_get(sql));
 		sbuf_delete(sql);
 		return (NULL);
 	}
 	sbuf_delete(sql);
 	if (match != MATCH_ALL && match != MATCH_CONDITION)
 		sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT);
 	return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));
 }
 struct pkg_repo_it *
 pkg_repo_binary_shlib_provide(struct pkg_repo *repo, const char *require)
 {
 	sqlite3_stmt	*stmt;
 	sqlite3 *sqlite = PRIV_GET(repo);
 	struct sbuf	*sql = NULL;
 	int		 ret;
 	const char	 basesql[] = ""
 			"SELECT p.id, p.origin, p.name, p.version, p.comment, "
 			"p.name || '~' || p.origin as uniqueid, "
 			"p.prefix, p.desc, p.arch, p.maintainer, p.www, "
 			"p.licenselogic, p.flatsize, p.pkgsize, "
 			"p.cksum, p.manifestdigest, p.path AS repopath, '%1$s' AS dbname "
 			"FROM '%1$s'.packages AS p INNER JOIN '%1$s'.pkg_shlibs_provided AS ps ON "
 			"p.id = ps.package_id "
 			"WHERE ps.shlib_id IN (SELECT id FROM '%1$s'.shlibs WHERE "
 			"name BETWEEN ?1 AND ?1 || '.9');";
 	sbuf_printf(sql, basesql, repo->name);
 	sbuf_finish(sql);
 	pkg_debug(4, "Pkgdb: running '%s'", sbuf_get(sql));
 	ret = sqlite3_prepare_v2(sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(sqlite, sbuf_get(sql));
 		sbuf_delete(sql);
 		return (NULL);
 	}
 	sbuf_delete(sql);
 	sqlite3_bind_text(stmt, 1, require, -1, SQLITE_TRANSIENT);
 	return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));
 }
 struct pkg_repo_it *
 pkg_repo_binary_shlib_require(struct pkg_repo *repo, const char *provide)
 {
 	sqlite3_stmt	*stmt;
 	sqlite3 *sqlite = PRIV_GET(repo);
 	struct sbuf	*sql = NULL;
 	int		 ret;
 	const char	 basesql[] = ""
 			"SELECT p.id, p.origin, p.name, p.version, p.comment, "
 			"p.name || '~' || p.origin as uniqueid, "
 			"p.prefix, p.desc, p.arch, p.maintainer, p.www, "
 			"p.licenselogic, p.flatsize, p.pkgsize, "
 			"p.cksum, p.manifestdigest, p.path AS repopath, '%1$s' AS dbname "
 			"FROM '%1$s'.packages AS p INNER JOIN '%1$s'.pkg_shlibs_required AS ps ON "
 			"p.id = ps.package_id "
 			"WHERE ps.shlib_id = (SELECT id FROM '%1$s'.shlibs WHERE name=?1);";
 	sbuf_printf(sql, basesql, repo->name);
 	sbuf_finish(sql);
 	pkg_debug(4, "Pkgdb: running '%s'", sbuf_get(sql));
 	ret = sqlite3_prepare_v2(sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(sqlite, sbuf_get(sql));
 		sbuf_delete(sql);
 		return (NULL);
 	}
 	sbuf_delete(sql);
 	sqlite3_bind_text(stmt, 1, provide, -1, SQLITE_TRANSIENT);
 	return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));
 }

modified src/rquery.c

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

 		const char *condition_sql = NULL;
 		if (match == MATCH_CONDITION && sqlcond)
 			condition_sql = sbuf_data(sqlcond);
 		if ((it = pkgdb_repo_query(db, condition_sql, match, reponame)) == NULL)
 		if ((it = pkg_repo_query(db, condition_sql, match, reponame)) == NULL)
 			return (EX_IOERR);
 		while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {

@@ -250,7 +250,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 = pkg_repo_query(db, pkgname, match, reponame)) == NULL)
 				return (EX_IOERR);
 			while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {

modified src/version.c

@@ -476,7 +476,7 @@ do_source_remote(unsigned int opt, char limchar, char *pattern, match_t match,

 		    strcmp(origin, matchorigin) != 0)
 			continue;
 		it_remote = pkgdb_repo_query(db, origin, MATCH_EXACT, reponame);
 		it_remote = pkg_repo_query(db, origin, MATCH_EXACT, reponame);
 		if (it_remote == NULL) {
 			retcode = EX_IOERR;
 			goto cleanup;