2dd7bca More cleanups. — HardenedBSD-pkg

HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

More cleanups.

Vsevolod Stakhov committed 11 years ago

commit 2dd7bcaf745d927a132d833c86efbb6c3dba6796
parent 88fcfaf

5 files changed +301 -394

modified libpkg/pkgdb_repo.c

@@ -53,280 +53,6 @@

 #include "private/pkgdb.h"
 #include "private/repodb.h"
 static int
 maybe_delete_conflicting(const char *origin, const char *version,
 			 const char *pkg_path, bool forced)
 {
 	int ret = EPKG_FATAL;
 	const char *oversion;
 	if (run_prepared_statement(VERSION, origin) != SQLITE_ROW)
 		return (EPKG_FATAL); /* sqlite error */
 	oversion = sqlite3_column_text(STMT(VERSION), 0);
 	if (!forced) {
 		switch(pkg_version_cmp(oversion, version)) {
 		case -1:
 			pkg_emit_error("duplicate package origin: replacing older "
 					"version %s in repo with package %s for "
 					"origin %s", oversion, pkg_path, origin);
 			if (run_prepared_statement(DELETE, origin, origin) != SQLITE_DONE)
 				return (EPKG_FATAL); /* sqlite error */
 			ret = EPKG_OK;	/* conflict cleared */
 			break;
 		case 0:
 		case 1:
 			pkg_emit_error("duplicate package origin: package %s is not "
 					"newer than version %s already in repo for "
 					"origin %s", pkg_path, oversion, origin);
 			ret = EPKG_END;	/* keep what is already in the repo */
 			break;
 		}
 	}
 	else {
 		if (run_prepared_statement(DELETE, origin, origin) != SQLITE_DONE)
 			return (EPKG_FATAL); /* sqlite error */
 		ret = EPKG_OK;
 	}
 	return (ret);
 }
 int
 pkgdb_repo_cksum_exists(sqlite3 *sqlite, const char *cksum)
 {
 	if (run_prepared_statement(EXISTS, cksum) != SQLITE_ROW) {
 		ERROR_SQLITE(sqlite, SQL(EXISTS));
 		return (EPKG_FATAL);
 	}
 	if (sqlite3_column_int(STMT(EXISTS), 0) > 0) {
 		return (EPKG_OK);
 	}
 	return (EPKG_END);
 }
 int
 pkgdb_repo_add_package(struct pkg *pkg, const char *pkg_path,
 		sqlite3 *sqlite, bool forced)
 {
 	const char *name, *version, *origin, *comment, *desc;
 	const char *arch, *maintainer, *www, *prefix, *sum, *rpath;
 	const char *olddigest, *manifestdigest;
 	int64_t			 flatsize, pkgsize;
 	int64_t			 licenselogic;
 	int			 ret;
 	struct pkg_dep		*dep      = NULL;
 	struct pkg_option	*option   = NULL;
 	struct pkg_shlib	*shlib    = NULL;
 	const pkg_object	*obj, *licenses, *categories, *annotations;
 	pkg_iter		 it;
 	int64_t			 package_id;
 	pkg_get(pkg, PKG_ORIGIN, &origin, PKG_NAME, &name,
 			    PKG_VERSION, &version, PKG_COMMENT, &comment,
 			    PKG_DESC, &desc, PKG_ARCH, &arch,
 			    PKG_MAINTAINER, &maintainer, PKG_WWW, &www,
 			    PKG_PREFIX, &prefix, PKG_FLATSIZE, &flatsize,
 			    PKG_LICENSE_LOGIC, &licenselogic, PKG_CKSUM, &sum,
 			    PKG_PKGSIZE, &pkgsize, PKG_REPOPATH, &rpath,
 			    PKG_LICENSES, &licenses, PKG_CATEGORIES, &categories,
 			    PKG_ANNOTATIONS, &annotations, PKG_OLD_DIGEST, &olddigest,
 			    PKG_DIGEST, &manifestdigest);
 try_again:
 	if ((ret = run_prepared_statement(PKG, origin, name, version,
 			comment, desc, arch, maintainer, www, prefix,
 			pkgsize, flatsize, (int64_t)licenselogic, sum,
 			rpath, manifestdigest, olddigest)) != SQLITE_DONE) {
 		if (ret == SQLITE_CONSTRAINT) {
 			switch(maybe_delete_conflicting(origin,
 					version, pkg_path, forced)) {
 			case EPKG_FATAL: /* sqlite error */
 				ERROR_SQLITE(sqlite, SQL(PKG));
 				return (EPKG_FATAL);
 				break;
 			case EPKG_END: /* repo already has newer */
 				return (EPKG_END);
 				break;
 			default: /* conflict cleared, try again */
 				goto try_again;
 				break;
 			}
 		} else {
 			ERROR_SQLITE(sqlite, SQL(PKG));
 			return (EPKG_FATAL);
 		}
 	}
 	package_id = sqlite3_last_insert_rowid(sqlite);
 	if (run_prepared_statement (FTS_APPEND, package_id,
 			name, version, origin) != SQLITE_DONE) {
 		ERROR_SQLITE(sqlite, SQL(FTS_APPEND));
 		return (EPKG_FATAL);
 	}
 	dep = NULL;
 	while (pkg_deps(pkg, &dep) == EPKG_OK) {
 		if (run_prepared_statement(DEPS,
 				pkg_dep_origin(dep),
 				pkg_dep_name(dep),
 				pkg_dep_version(dep),
 				package_id) != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, SQL(DEPS));
 			return (EPKG_FATAL);
 		}
 	}
 	it = NULL;
 	while ((obj = pkg_object_iterate(categories, &it))) {
 		ret = run_prepared_statement(CAT1, pkg_object_string(obj));
 		if (ret == SQLITE_DONE)
 			ret = run_prepared_statement(CAT2, package_id,
 			    pkg_object_string(obj));
 		if (ret != SQLITE_DONE)
 		{
 			ERROR_SQLITE(sqlite, SQL(CAT2));
 			return (EPKG_FATAL);
 		}
 	}
 	it = NULL;
 	while ((obj = pkg_object_iterate(licenses, &it))) {
 		ret = run_prepared_statement(LIC1, pkg_object_string(obj));
 		if (ret == SQLITE_DONE)
 			ret = run_prepared_statement(LIC2, package_id,
 			    pkg_object_string(obj));
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, SQL(LIC2));
 			return (EPKG_FATAL);
 		}
 	}
 	option = NULL;
 	while (pkg_options(pkg, &option) == EPKG_OK) {
 		ret = run_prepared_statement(OPT1, pkg_option_opt(option));
 		if (ret == SQLITE_DONE)
 		    ret = run_prepared_statement(OPT2, pkg_option_opt(option),
 				pkg_option_value(option), package_id);
 		if(ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, SQL(OPT2));
 			return (EPKG_FATAL);
 		}
 	}
 	shlib = NULL;
 	while (pkg_shlibs_required(pkg, &shlib) == EPKG_OK) {
 		const char *shlib_name = pkg_shlib_name(shlib);
 		ret = run_prepared_statement(SHLIB1, shlib_name);
 		if (ret == SQLITE_DONE)
 			ret = run_prepared_statement(SHLIB_REQD, package_id,
 					shlib_name);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, SQL(SHLIB_REQD));
 			return (EPKG_FATAL);
 		}
 	}
 	shlib = NULL;
 	while (pkg_shlibs_provided(pkg, &shlib) == EPKG_OK) {
 		const char *shlib_name = pkg_shlib_name(shlib);
 		ret = run_prepared_statement(SHLIB1, shlib_name);
 		if (ret == SQLITE_DONE)
 			ret = run_prepared_statement(SHLIB_PROV, package_id,
 					shlib_name);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, SQL(SHLIB_PROV));
 			return (EPKG_FATAL);
 		}
 	}
 	it = NULL;
 	while ((obj = pkg_object_iterate(annotations, &it))) {
 		const char *note_tag = pkg_object_key(obj);
 		const char *note_val = pkg_object_string(obj);
 		ret = run_prepared_statement(ANNOTATE1, note_tag);
 		if (ret == SQLITE_DONE)
 			ret = run_prepared_statement(ANNOTATE1, note_val);
 		if (ret == SQLITE_DONE)
 			ret = run_prepared_statement(ANNOTATE2, package_id,
 				  note_tag, note_val);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, SQL(ANNOTATE2));
 			return (EPKG_FATAL);
 		}
 	}
 	return (EPKG_OK);
 }
 int
 pkgdb_repo_remove_package(const char *origin)
 {
 	if (run_prepared_statement(DELETE, origin, origin) != SQLITE_DONE)
 		return (EPKG_FATAL); /* sqlite error */
 	return (EPKG_OK);
 }
 /* We want to replace some arbitrary number of instances of the placeholder
    %Q in the SQL with the name of the database. */
 static int
 substitute_into_sql(char *sqlbuf, size_t buflen, const char *fmt,
 		    const char *replacement)
 {
 	char	*f;
 	char	*f0;
 	char	*tofree;
 	char	*quoted;
 	size_t	 len;
 	int	 ret = EPKG_OK;
 	tofree = f = strdup(fmt);
 	if (tofree == NULL)
 		return (EPKG_FATAL); /* out of memory */
 	quoted = sqlite3_mprintf("%Q", replacement);
 	if (quoted == NULL) {
 		free(tofree);
 		return (EPKG_FATAL); /* out of memory */
 	}
 	sqlbuf[0] = '\0';
 	while ((f0 = strsep(&f, "%")) != NULL) {
 		len = strlcat(sqlbuf, f0, buflen);
 		if (len >= buflen) {
 			/* Overflowed the buffer */
 			ret = EPKG_FATAL;
 			break;
 		}
 		if (f == NULL)
 			break;	/* done */
 		if (f[0] == 'Q') {
 			len = strlcat(sqlbuf, quoted, buflen);
 			f++;	/* Jump the Q */
 		} else {
 			len = strlcat(sqlbuf, "%", buflen);
 		}
 		if (len >= buflen) {
 			/* Overflowed the buffer */
 			ret = EPKG_FATAL;
 			break;
 		}
 	}
 	free(tofree);
 	sqlite3_free(quoted);
 	return (ret);
 }
 struct pkgdb_it *
 pkgdb_repo_origins(sqlite3 *sqlite)

@@ -354,97 +80,6 @@ pkgdb_repo_origins(sqlite3 *sqlite)

 	return pkgdb_it_new(&repodb, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE);
 }
 int
 pkgdb_repo_register_conflicts(const char *origin, char **conflicts,
 		int conflicts_num, sqlite3 *sqlite)
 {
 	const char clean_conflicts_sql[] = ""
 			"DELETE FROM pkg_conflicts "
 			"WHERE package_id = ?1;";
 	const char select_id_sql[] = ""
 			"SELECT id FROM packages "
 			"WHERE origin = ?1;";
 	const char insert_conflict_sql[] = ""
 			"INSERT INTO pkg_conflicts "
 			"(package_id, conflict_id) "
 			"VALUES (?1, ?2);";
 	sqlite3_stmt *stmt = NULL;
 	int ret, i;
 	int64_t origin_id, conflict_id;
 	pkg_debug(4, "pkgdb_repo_register_conflicts: running '%s'", select_id_sql);
 	if (sqlite3_prepare_v2(sqlite, select_id_sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(sqlite, select_id_sql);
 		return (EPKG_FATAL);
 	}
 	sqlite3_bind_text(stmt, 1, origin, -1, SQLITE_TRANSIENT);
 	ret = sqlite3_step(stmt);
 	if (ret == SQLITE_ROW) {
 		origin_id = sqlite3_column_int64(stmt, 0);
 	}
 	else {
 		ERROR_SQLITE(sqlite, select_id_sql);
 		return (EPKG_FATAL);
 	}
 	sqlite3_finalize(stmt);
 	pkg_debug(4, "pkgdb_repo_register_conflicts: running '%s'", clean_conflicts_sql);
 	if (sqlite3_prepare_v2(sqlite, clean_conflicts_sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(sqlite, clean_conflicts_sql);
 		return (EPKG_FATAL);
 	}
 	sqlite3_bind_int64(stmt, 1, origin_id);
 	/* Ignore cleanup result */
 	(void)sqlite3_step(stmt);
 	sqlite3_finalize(stmt);
 	for (i = 0; i < conflicts_num; i ++) {
 		/* Select a conflict */
 		pkg_debug(4, "pkgdb_repo_register_conflicts: running '%s'", select_id_sql);
 		if (sqlite3_prepare_v2(sqlite, select_id_sql, -1, &stmt, NULL) != SQLITE_OK) {
 			ERROR_SQLITE(sqlite, select_id_sql);
 			return (EPKG_FATAL);
 		}
 		sqlite3_bind_text(stmt, 1, conflicts[i], -1, SQLITE_TRANSIENT);
 		ret = sqlite3_step(stmt);
 		if (ret == SQLITE_ROW) {
 			conflict_id = sqlite3_column_int64(stmt, 0);
 		}
 		else {
 			ERROR_SQLITE(sqlite, select_id_sql);
 			return (EPKG_FATAL);
 		}
 		sqlite3_finalize(stmt);
 		/* Insert a pair */
 		pkg_debug(4, "pkgdb_repo_register_conflicts: running '%s'", insert_conflict_sql);
 		if (sqlite3_prepare_v2(sqlite, insert_conflict_sql, -1, &stmt, NULL) != SQLITE_OK) {
 			ERROR_SQLITE(sqlite, insert_conflict_sql);
 			return (EPKG_FATAL);
 		}
 		sqlite3_bind_int64(stmt, 1, origin_id);
 		sqlite3_bind_int64(stmt, 2, conflict_id);
 		ret = sqlite3_step(stmt);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, insert_conflict_sql);
 			return (EPKG_FATAL);
 		}
 		sqlite3_finalize(stmt);
 	}
 	return (EPKG_OK);
 }
 const char *
 pkgdb_get_reponame(struct pkgdb *db, const char *repo)
 {

modified libpkg/private/pkgdb.h

@@ -68,33 +68,6 @@ struct pkgdb_it *pkgdb_it_new(struct pkgdb *db, sqlite3_stmt *s, int type, short

 void pkgshell_open(const char **r);
 /**
  * Check whether a package with the cehcksum specified exists in pkg_repo
  * @param sqlite sqlite pointer
  * @param cksum sha256 printed checksum
  * @return EPKG_OK if checksum exists, EPKG_END if not and EPKG_FATAL if error occurred
  */
 int pkgdb_repo_cksum_exists(sqlite3 *sqlite, const char *cksum);
 /**
  * Add a package to pkg_repo
  * @param pkg package structure
  * @param pkg_path path triggered package addition
  * @param sqlite sqlite pointer
  * @param forced force adding of package even if it is outdated
  * @return EPKG_OK if package added, EPKG_END if package already exists and is newer than
  * inserted one, EPKG_FATAL if error occurred
  */
 int pkgdb_repo_add_package(struct pkg *pkg, const char *pkg_path,
 		sqlite3 *sqlite, bool forced);
 /**
  * Remove specified pkg from repo
  * @param origin the origin of package to remove
  * @return EPKG_OK if succeeded
  */
 int pkgdb_repo_remove_package(const char *origin);
 /**
  * Returns a list of all packages sorted by origin
  * @param sqlite database
  * @return new iterator

modified libpkg/repo/binary/Makefile.am

@@ -8,6 +8,7 @@ pkg_common_cflags= -I$(top_srcdir)/libpkg \

 			-Wno-pointer-sign
 librepo_binary_la_SOURCES=	binary.c \
 							common.c \
 							init.c \
 							update.c
 librepo_binary_la_CFLAGS=	$(pkg_common_cflags) -shared

modified libpkg/repo/binary/binary_private.h

@@ -614,4 +614,6 @@ static sql_prstmt sql_prepared_statements[PRSTMT_LAST] = {

 	/* PRSTMT_LAST */
 };
 int pkg_repo_binary_run_prstatement(sql_prstmt_index s, ...);
 #endif /* INIT_PRIVATE_H_ */

modified libpkg/repo/binary/update.c

@@ -46,7 +46,303 @@

 #include "private/repodb.h"
 #include "private/pkg.h"
 #include "binary.h"
 #include "binary_private.h"
 static int
 pkg_repo_binary_delete_conflicting(const char *origin, const char *version,
 			 const char *pkg_path, bool forced)
 {
 	int ret = EPKG_FATAL;
 	const char *oversion;
 	if (pkg_repo_binary_run_prstatement(VERSION, origin) != SQLITE_ROW)
 		return (EPKG_FATAL); /* sqlite error */
 	oversion = sqlite3_column_text(STMT(VERSION), 0);
 	if (!forced) {
 		switch(pkg_version_cmp(oversion, version)) {
 		case -1:
 			pkg_emit_error("duplicate package origin: replacing older "
 					"version %s in repo with package %s for "
 					"origin %s", oversion, pkg_path, origin);
 			if (pkg_repo_binary_run_prstatement(DELETE, origin, origin) != SQLITE_DONE)
 				return (EPKG_FATAL); /* sqlite error */
 			ret = EPKG_OK;	/* conflict cleared */
 			break;
 		case 0:
 		case 1:
 			pkg_emit_error("duplicate package origin: package %s is not "
 					"newer than version %s already in repo for "
 					"origin %s", pkg_path, oversion, origin);
 			ret = EPKG_END;	/* keep what is already in the repo */
 			break;
 		}
 	}
 	else {
 		if (pkg_repo_binary_run_prstatement(DELETE, origin, origin) != SQLITE_DONE)
 			return (EPKG_FATAL); /* sqlite error */
 		ret = EPKG_OK;
 	}
 	return (ret);
 }
 static int
 pkg_repo_binary_add_pkg(struct pkg *pkg, const char *pkg_path,
 		sqlite3 *sqlite, bool forced)
 {
 	const char *name, *version, *origin, *comment, *desc;
 	const char *arch, *maintainer, *www, *prefix, *sum, *rpath;
 	const char *olddigest, *manifestdigest;
 	int64_t			 flatsize, pkgsize;
 	int64_t			 licenselogic;
 	int			 ret;
 	struct pkg_dep		*dep      = NULL;
 	struct pkg_option	*option   = NULL;
 	struct pkg_shlib	*shlib    = NULL;
 	const pkg_object	*obj, *licenses, *categories, *annotations;
 	pkg_iter		 it;
 	int64_t			 package_id;
 	pkg_get(pkg, PKG_ORIGIN, &origin, PKG_NAME, &name,
 			    PKG_VERSION, &version, PKG_COMMENT, &comment,
 			    PKG_DESC, &desc, PKG_ARCH, &arch,
 			    PKG_MAINTAINER, &maintainer, PKG_WWW, &www,
 			    PKG_PREFIX, &prefix, PKG_FLATSIZE, &flatsize,
 			    PKG_LICENSE_LOGIC, &licenselogic, PKG_CKSUM, &sum,
 			    PKG_PKGSIZE, &pkgsize, PKG_REPOPATH, &rpath,
 			    PKG_LICENSES, &licenses, PKG_CATEGORIES, &categories,
 			    PKG_ANNOTATIONS, &annotations, PKG_OLD_DIGEST, &olddigest,
 			    PKG_DIGEST, &manifestdigest);
 try_again:
 	if ((ret = pkg_repo_binary_run_prstatement(PKG, origin, name, version,
 			comment, desc, arch, maintainer, www, prefix,
 			pkgsize, flatsize, (int64_t)licenselogic, sum,
 			rpath, manifestdigest, olddigest)) != SQLITE_DONE) {
 		if (ret == SQLITE_CONSTRAINT) {
 			switch(pkg_repo_binary_delete_conflicting(origin,
 					version, pkg_path, forced)) {
 			case EPKG_FATAL: /* sqlite error */
 				ERROR_SQLITE(sqlite, SQL(PKG));
 				return (EPKG_FATAL);
 				break;
 			case EPKG_END: /* repo already has newer */
 				return (EPKG_END);
 				break;
 			default: /* conflict cleared, try again */
 				goto try_again;
 				break;
 			}
 		} else {
 			ERROR_SQLITE(sqlite, SQL(PKG));
 			return (EPKG_FATAL);
 		}
 	}
 	package_id = sqlite3_last_insert_rowid(sqlite);
 	if (pkg_repo_binary_run_prstatement (FTS_APPEND, package_id,
 			name, version, origin) != SQLITE_DONE) {
 		ERROR_SQLITE(sqlite, SQL(FTS_APPEND));
 		return (EPKG_FATAL);
 	}
 	dep = NULL;
 	while (pkg_deps(pkg, &dep) == EPKG_OK) {
 		if (pkg_repo_binary_run_prstatement(DEPS,
 				pkg_dep_origin(dep),
 				pkg_dep_name(dep),
 				pkg_dep_version(dep),
 				package_id) != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, SQL(DEPS));
 			return (EPKG_FATAL);
 		}
 	}
 	it = NULL;
 	while ((obj = pkg_object_iterate(categories, &it))) {
 		ret = pkg_repo_binary_run_prstatement(CAT1, pkg_object_string(obj));
 		if (ret == SQLITE_DONE)
 			ret = pkg_repo_binary_run_prstatement(CAT2, package_id,
 			    pkg_object_string(obj));
 		if (ret != SQLITE_DONE)
 		{
 			ERROR_SQLITE(sqlite, SQL(CAT2));
 			return (EPKG_FATAL);
 		}
 	}
 	it = NULL;
 	while ((obj = pkg_object_iterate(licenses, &it))) {
 		ret = pkg_repo_binary_run_prstatement(LIC1, pkg_object_string(obj));
 		if (ret == SQLITE_DONE)
 			ret = pkg_repo_binary_run_prstatement(LIC2, package_id,
 			    pkg_object_string(obj));
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, SQL(LIC2));
 			return (EPKG_FATAL);
 		}
 	}
 	option = NULL;
 	while (pkg_options(pkg, &option) == EPKG_OK) {
 		ret = pkg_repo_binary_run_prstatement(OPT1, pkg_option_opt(option));
 		if (ret == SQLITE_DONE)
 		    ret = pkg_repo_binary_run_prstatement(OPT2, pkg_option_opt(option),
 				pkg_option_value(option), package_id);
 		if(ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, SQL(OPT2));
 			return (EPKG_FATAL);
 		}
 	}
 	shlib = NULL;
 	while (pkg_shlibs_required(pkg, &shlib) == EPKG_OK) {
 		const char *shlib_name = pkg_shlib_name(shlib);
 		ret = pkg_repo_binary_run_prstatement(SHLIB1, shlib_name);
 		if (ret == SQLITE_DONE)
 			ret = pkg_repo_binary_run_prstatement(SHLIB_REQD, package_id,
 					shlib_name);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, SQL(SHLIB_REQD));
 			return (EPKG_FATAL);
 		}
 	}
 	shlib = NULL;
 	while (pkg_shlibs_provided(pkg, &shlib) == EPKG_OK) {
 		const char *shlib_name = pkg_shlib_name(shlib);
 		ret = pkg_repo_binary_run_prstatement(SHLIB1, shlib_name);
 		if (ret == SQLITE_DONE)
 			ret = pkg_repo_binary_run_prstatement(SHLIB_PROV, package_id,
 					shlib_name);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, SQL(SHLIB_PROV));
 			return (EPKG_FATAL);
 		}
 	}
 	it = NULL;
 	while ((obj = pkg_object_iterate(annotations, &it))) {
 		const char *note_tag = pkg_object_key(obj);
 		const char *note_val = pkg_object_string(obj);
 		ret = pkg_repo_binary_run_prstatement(ANNOTATE1, note_tag);
 		if (ret == SQLITE_DONE)
 			ret = pkg_repo_binary_run_prstatement(ANNOTATE1, note_val);
 		if (ret == SQLITE_DONE)
 			ret = pkg_repo_binary_run_prstatement(ANNOTATE2, package_id,
 				  note_tag, note_val);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, SQL(ANNOTATE2));
 			return (EPKG_FATAL);
 		}
 	}
 	return (EPKG_OK);
 }
 int
 pkgdb_repo_remove_package(const char *origin)
 {
 	if (pkg_repo_binary_run_prstatement(DELETE, origin, origin) != SQLITE_DONE)
 		return (EPKG_FATAL); /* sqlite error */
 	return (EPKG_OK);
 }
 static int
 pkg_repo_binary_register_conflicts(const char *origin, char **conflicts,
 		int conflicts_num, sqlite3 *sqlite)
 {
 	const char clean_conflicts_sql[] = ""
 			"DELETE FROM pkg_conflicts "
 			"WHERE package_id = ?1;";
 	const char select_id_sql[] = ""
 			"SELECT id FROM packages "
 			"WHERE origin = ?1;";
 	const char insert_conflict_sql[] = ""
 			"INSERT INTO pkg_conflicts "
 			"(package_id, conflict_id) "
 			"VALUES (?1, ?2);";
 	sqlite3_stmt *stmt = NULL;
 	int ret, i;
 	int64_t origin_id, conflict_id;
 	pkg_debug(4, "pkgdb_repo_register_conflicts: running '%s'", select_id_sql);
 	if (sqlite3_prepare_v2(sqlite, select_id_sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(sqlite, select_id_sql);
 		return (EPKG_FATAL);
 	}
 	sqlite3_bind_text(stmt, 1, origin, -1, SQLITE_TRANSIENT);
 	ret = sqlite3_step(stmt);
 	if (ret == SQLITE_ROW) {
 		origin_id = sqlite3_column_int64(stmt, 0);
 	}
 	else {
 		ERROR_SQLITE(sqlite, select_id_sql);
 		return (EPKG_FATAL);
 	}
 	sqlite3_finalize(stmt);
 	pkg_debug(4, "pkgdb_repo_register_conflicts: running '%s'", clean_conflicts_sql);
 	if (sqlite3_prepare_v2(sqlite, clean_conflicts_sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(sqlite, clean_conflicts_sql);
 		return (EPKG_FATAL);
 	}
 	sqlite3_bind_int64(stmt, 1, origin_id);
 	/* Ignore cleanup result */
 	(void)sqlite3_step(stmt);
 	sqlite3_finalize(stmt);
 	for (i = 0; i < conflicts_num; i ++) {
 		/* Select a conflict */
 		pkg_debug(4, "pkgdb_repo_register_conflicts: running '%s'", select_id_sql);
 		if (sqlite3_prepare_v2(sqlite, select_id_sql, -1, &stmt, NULL) != SQLITE_OK) {
 			ERROR_SQLITE(sqlite, select_id_sql);
 			return (EPKG_FATAL);
 		}
 		sqlite3_bind_text(stmt, 1, conflicts[i], -1, SQLITE_TRANSIENT);
 		ret = sqlite3_step(stmt);
 		if (ret == SQLITE_ROW) {
 			conflict_id = sqlite3_column_int64(stmt, 0);
 		}
 		else {
 			ERROR_SQLITE(sqlite, select_id_sql);
 			return (EPKG_FATAL);
 		}
 		sqlite3_finalize(stmt);
 		/* Insert a pair */
 		pkg_debug(4, "pkgdb_repo_register_conflicts: running '%s'", insert_conflict_sql);
 		if (sqlite3_prepare_v2(sqlite, insert_conflict_sql, -1, &stmt, NULL) != SQLITE_OK) {
 			ERROR_SQLITE(sqlite, insert_conflict_sql);
 			return (EPKG_FATAL);
 		}
 		sqlite3_bind_int64(stmt, 1, origin_id);
 		sqlite3_bind_int64(stmt, 2, conflict_id);
 		ret = sqlite3_step(stmt);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, insert_conflict_sql);
 			return (EPKG_FATAL);
 		}
 		sqlite3_finalize(stmt);
 	}
 	return (EPKG_OK);
 }
 static int
 pkg_repo_binary_add_from_manifest(char *buf, const char *origin, const char *digest,

@@ -101,7 +397,7 @@ pkg_repo_binary_add_from_manifest(char *buf, const char *origin, const char *dig

 		pkg_set(pkg, PKG_DIGEST, digest);
 	}
 	rc = pkgdb_repo_add_package(pkg, NULL, sqlite, true);
 	rc = pkg_repo_binary_add_pkg(pkg, NULL, sqlite, true);
 cleanup:
 	return (rc);

@@ -162,7 +458,7 @@ pkg_repo_binary_parse_conflicts(FILE *f, sqlite3 *sqlite)

 		for (i = 0; i < ndep; i ++) {
 			deps[i] = strsep(&p, ",\n");
 		}
 		pkgdb_repo_register_conflicts(origin, deps, ndep, sqlite);
 		pkg_repo_binary_register_conflicts(origin, deps, ndep, sqlite);
 		free(deps);
 	}