9852eca Merge branch 'master' of github.com:freebsd/pkg — HardenedBSD-pkg

modified configure.ac

@@ -185,6 +185,14 @@ AC_CHECK_HEADER([sys/sbuf.h], [

 	LIBSBUF_INCLUDE="-I\$(top_srcdir)/external/libsbuf"
 ])
 AC_CHECK_HEADER([execinfo.h], [
 	AC_DEFINE(HAVE_EXECINFO_H, 1, [Define to 1 if you have the <execinfo.h> header file.])
 	AC_CHECK_LIB(execinfo, backtrace, [
 		AC_DEFINE(HAVE_LIBEXECINFO, 1, [Define to 1 if you have the 'execinfo' library (-lexecinfo).])
 		LIBEXECINFO_LIB="-lexecinfo"
 	])
 ],)
 AC_CHECK_HEADER([atf-c.h], [
 	 TESTS="\$(test_program)"
  ])

@@ -196,7 +204,6 @@ AC_CHECK_HEADER([sys/capability.h], [

 ])
 AC_SUBST([LIBELF_LIB])
 AC_SUBST([LIBELF_BUNDLED])
 AC_SUBST([LIBELF_INCLUDE])

@@ -204,6 +211,7 @@ AC_SUBST([LIBSBUF_LIB])

 AC_SUBST([LIBSBUF_BUNDLED])
 AC_SUBST([LIBSBUF_INCLUDE])
 AC_SUBST([LIBJAIL_LIB])
 AC_SUBST([LIBEXECINFO_LIB])
 AC_SUBST([TESTS])
 AC_CONFIG_FILES(Makefile \

modified libpkg/Makefile.am

@@ -52,6 +52,7 @@ libpkg_la_LIBADD= $(top_builddir)/external/libucl.la \

 			$(top_builddir)/external/libexpat.la \
 			@LIBELF_LIB@ \
 			@LIBSBUF_LIB@ \
 			@LIBEXECINFO_LIB@ \
 			-larchive \
 			-lfetch \
 			-lutil \

modified libpkg/backup.c

@@ -98,7 +98,7 @@ copy_database(sqlite3 *src, sqlite3 *dst, const char *name)

 			if (ret == SQLITE_BUSY) {
 				sqlite3_sleep(250);
 			} else {
 				ERROR_SQLITE(dst);
 				ERROR_SQLITE(dst, "PRAGMA page_size");
 				break;
 			}
 		}

@@ -152,7 +152,7 @@ pkgdb_dump(struct pkgdb *db, const char *dest)

 	ret = sqlite3_open(dest, &backup);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(backup);
 		ERROR_SQLITE(backup, "sqlite3_open");
 		sqlite3_close(backup);
 		return (EPKG_FATAL);
 	}

@@ -178,7 +178,7 @@ pkgdb_load(struct pkgdb *db, const char *src)

 	ret = sqlite3_open(src, &restore);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(restore);
 		ERROR_SQLITE(restore, "sqlite3_open");
 		sqlite3_close(restore);
 		return (EPKG_FATAL);
 	}

modified libpkg/pkg_event.c

@@ -408,6 +408,7 @@ pkg_emit_error(const char *fmt, ...)

 	pkg_emit_event(&ev);
 	free(ev.e_pkg_error.msg);
 	print_trace();
 }
 void

@@ -453,6 +454,7 @@ pkg_emit_errno(const char *func, const char *arg)

 	ev.e_errno.no = errno;
 	pkg_emit_event(&ev);
 	print_trace();
 }
 void

modified libpkg/pkg_repo_update.c

@@ -67,14 +67,14 @@ pkg_repo_register(struct pkg_repo *repo, sqlite3 *sqlite)

 	}
 	if (sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(sqlite);
 		ERROR_SQLITE(sqlite, sql);
 		return (EPKG_FATAL);
 	}
 	sqlite3_bind_text(stmt, 1, pkg_repo_url(repo), -1, SQLITE_STATIC);
 	if (sqlite3_step(stmt) != SQLITE_DONE) {
 		ERROR_SQLITE(sqlite);
 		ERROR_SQLITE(sqlite, sql);
 		sqlite3_finalize(stmt);
 		return (EPKG_FATAL);
 	}

@@ -402,8 +402,6 @@ pkg_repo_update_incremental(const char *name, struct pkg_repo *repo, time_t *mti

 cleanup:
 	if (rc == EPKG_OK)
 		sql_exec(sqlite, "DROP TABLE repo_update;");
 	if (in_trans) {
 		if (rc != EPKG_OK)
 			pkgdb_transaction_rollback(sqlite, "REPO");

@@ -411,6 +409,11 @@ cleanup:

 		if (pkgdb_transaction_commit(sqlite, "REPO") != EPKG_OK)
 			rc = EPKG_FATAL;
 	}
 	pkgdb_repo_finalize_statements();
 	if (rc == EPKG_OK)
 		sql_exec(sqlite, "DROP TABLE repo_update;");
 	if (pkg != NULL)
 		pkg_free(pkg);
 	if (it != NULL)

@@ -426,7 +429,7 @@ cleanup:

 	if (linebuf != NULL)
 		free(linebuf);
 	pkgdb_repo_close(sqlite, rc == EPKG_OK);
 	sqlite3_close(sqlite);
 	return (rc);
 }

modified libpkg/pkgdb.c

@@ -147,7 +147,7 @@ load_val(sqlite3 *db, struct pkg *pkg, const char *sql, unsigned flags,

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db);
 		ERROR_SQLITE(db, sql);
 		return (EPKG_FATAL);
 	}

@@ -163,7 +163,7 @@ load_val(sqlite3 *db, struct pkg *pkg, const char *sql, unsigned flags,

 	if (ret != SQLITE_DONE) {
 		if (list != -1)
 			pkg_list_free(pkg, list);
 		ERROR_SQLITE(db);
 		ERROR_SQLITE(db, sql);
 		return (EPKG_FATAL);
 	}

@@ -187,7 +187,7 @@ load_tag_val(sqlite3 *db, struct pkg *pkg, const char *sql, unsigned flags,

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db);
 		ERROR_SQLITE(db, sql);
 		return (EPKG_FATAL);
 	}

@@ -203,7 +203,7 @@ load_tag_val(sqlite3 *db, struct pkg *pkg, const char *sql, unsigned flags,

 	if (ret != SQLITE_DONE) {
 		if (list != -1)
 			pkg_list_free(pkg, list);
 		ERROR_SQLITE(db);
 		ERROR_SQLITE(db, sql);
 		return (EPKG_FATAL);
 	}

@@ -1139,7 +1139,7 @@ pkgdb_open_all(struct pkgdb **db_p, pkgdb_t type, const char *reponame)

 		}
 		if (sqlite3_open(localpath, &db->sqlite) != SQLITE_OK) {
 			ERROR_SQLITE(db->sqlite);
 			ERROR_SQLITE(db->sqlite, "sqlite open");
 			pkgdb_close(db);
 			return (EPKG_FATAL);
 		}

@@ -1224,13 +1224,14 @@ pkgdb_transaction_begin(sqlite3 *sqlite, const char *savepoint)

 	int		 ret;
 	int		 tries;
 	sqlite3_stmt	*stmt;
 	const char *psql;
 	assert(sqlite != NULL);
 	if (savepoint == NULL || savepoint[0] == '\0') {
 		const char sql[] = "BEGIN IMMEDIATE TRANSACTION";
 		psql = sql;
 		pkg_debug(4, "Pkgdb: running '%s'", sql);
 		ret = sqlite3_prepare_v2(sqlite, sql, strlen(sql) + 1,
 					 &stmt, NULL);

@@ -1239,6 +1240,7 @@ pkgdb_transaction_begin(sqlite3 *sqlite, const char *savepoint)

 		strlcat(sql, savepoint, sizeof(sql));
 		psql = sql;
 		pkg_debug(4, "Pkgdb: running '%s'", sql);
 		ret = sqlite3_prepare_v2(sqlite, sql, strlen(sql) + 1,
 					 &stmt, NULL);

@@ -1255,7 +1257,7 @@ pkgdb_transaction_begin(sqlite3 *sqlite, const char *savepoint)

 	sqlite3_finalize(stmt);
 	if (ret != SQLITE_OK && ret != SQLITE_DONE)
 		ERROR_SQLITE(sqlite);
 		ERROR_SQLITE(sqlite, psql);
 	return (ret == SQLITE_OK || ret == SQLITE_DONE ? EPKG_OK : EPKG_FATAL);
 }

@@ -1266,11 +1268,13 @@ pkgdb_transaction_commit(sqlite3 *sqlite, const char *savepoint)

 	int		 ret;
 	int		 tries;
 	sqlite3_stmt	*stmt;
 	const char *psql;
 	assert(sqlite != NULL);
 	if (savepoint == NULL || savepoint[0] == '\0') {
 		const char sql[] = "COMMIT TRANSACTION";
 		psql = sql;
 		pkg_debug(4, "Pkgdb: running '%s'", sql);
 		ret = sqlite3_prepare_v2(sqlite, sql, strlen(sql) + 1,

@@ -1280,6 +1284,8 @@ pkgdb_transaction_commit(sqlite3 *sqlite, const char *savepoint)

 		strlcat(sql, savepoint, sizeof(sql));
 		psql = sql;
 		pkg_debug(4, "Pkgdb: running '%s'", sql);
 		ret = sqlite3_prepare_v2(sqlite, sql, strlen(sql) + 1,
 					 &stmt, NULL);

@@ -1296,7 +1302,7 @@ pkgdb_transaction_commit(sqlite3 *sqlite, const char *savepoint)

 	sqlite3_finalize(stmt);
 	if (ret != SQLITE_OK && ret != SQLITE_DONE)
 		ERROR_SQLITE(sqlite);
 		ERROR_SQLITE(sqlite, psql);
 	return (ret == SQLITE_OK || ret == SQLITE_DONE ? EPKG_OK : EPKG_FATAL);
 }

@@ -1307,12 +1313,14 @@ pkgdb_transaction_rollback(sqlite3 *sqlite, const char *savepoint)

 	int		 ret;
 	int		 tries;
 	sqlite3_stmt	*stmt;
 	const char *psql;
 	assert(sqlite != NULL);
 	if (savepoint == NULL || savepoint[0] == '\0') {
 		const char sql[] = "ROLLBACK TRANSACTION";
 		psql = sql;
 		pkg_debug(4, "Pkgdb: running '%s'", sql);
 		ret = sqlite3_prepare_v2(sqlite, sql, strlen(sql) + 1,
 					 &stmt, NULL);

@@ -1321,6 +1329,7 @@ pkgdb_transaction_rollback(sqlite3 *sqlite, const char *savepoint)

 		strlcat(sql, savepoint, sizeof(sql));
 		psql = sql;
 		pkg_debug(4, "Pkgdb: running '%s'", sql);
 		ret = sqlite3_prepare_v2(sqlite, sql, strlen(sql) + 1,
 					 &stmt, NULL);

@@ -1337,7 +1346,7 @@ pkgdb_transaction_rollback(sqlite3 *sqlite, const char *savepoint)

 	sqlite3_finalize(stmt);
 	if (ret != SQLITE_OK && ret != SQLITE_DONE)
 		ERROR_SQLITE(sqlite);
 		ERROR_SQLITE(sqlite, psql);
 	return (ret == SQLITE_OK || ret == SQLITE_DONE ? EPKG_OK : EPKG_FATAL);
 }

@@ -1442,7 +1451,7 @@ pkgdb_it_next(struct pkgdb_it *it, struct pkg **pkg_p, unsigned flags)

 		}
 		break;
 	default:
 		ERROR_SQLITE(it->sqlite);
 		ERROR_SQLITE(it->sqlite, "iterator");
 		return (EPKG_FATAL);
 	}
 }

@@ -1599,7 +1608,7 @@ pkgdb_query(struct pkgdb *db, const char *pattern, match_t match)

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (NULL);
 	}

@@ -1627,7 +1636,7 @@ pkgdb_query_which(struct pkgdb *db, const char *path, bool glob)

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (NULL);
 	}

@@ -1653,7 +1662,7 @@ pkgdb_query_shlib_required(struct pkgdb *db, const char *shlib)

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (NULL);
 	}

@@ -1679,7 +1688,7 @@ pkgdb_query_shlib_provided(struct pkgdb *db, const char *shlib)

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (NULL);
 	}

@@ -1701,7 +1710,7 @@ pkgdb_is_dir_used(struct pkgdb *db, const char *dir, int64_t *res)

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -1715,7 +1724,7 @@ pkgdb_is_dir_used(struct pkgdb *db, const char *dir, int64_t *res)

 	sqlite3_finalize(stmt);
 	if (ret != SQLITE_ROW) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -1758,7 +1767,7 @@ pkgdb_load_deps(struct pkgdb *db, struct pkg *pkg)

 	}
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -1775,7 +1784,7 @@ pkgdb_load_deps(struct pkgdb *db, struct pkg *pkg)

 	if (ret != SQLITE_DONE) {
 		pkg_list_free(pkg, PKG_DEPS);
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -1819,7 +1828,7 @@ pkgdb_load_rdeps(struct pkgdb *db, struct pkg *pkg)

 	}
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, mainsql);
 		return (EPKG_FATAL);
 	}

@@ -1836,7 +1845,7 @@ pkgdb_load_rdeps(struct pkgdb *db, struct pkg *pkg)

 	if (ret != SQLITE_DONE) {
 		pkg_list_free(pkg, PKG_RDEPS);
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, mainsql);
 		return (EPKG_FATAL);
 	}

@@ -1864,7 +1873,7 @@ pkgdb_load_files(struct pkgdb *db, struct pkg *pkg)

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -1879,7 +1888,7 @@ pkgdb_load_files(struct pkgdb *db, struct pkg *pkg)

 	if (ret != SQLITE_DONE) {
 		pkg_list_free(pkg, PKG_FILES);
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -1908,7 +1917,7 @@ pkgdb_load_dirs(struct pkgdb *db, struct pkg *pkg)

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -1923,7 +1932,7 @@ pkgdb_load_dirs(struct pkgdb *db, struct pkg *pkg)

 	sqlite3_finalize(stmt);
 	if (ret != SQLITE_DONE) {
 		pkg_list_free(pkg, PKG_DIRS);
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -2139,7 +2148,7 @@ pkgdb_load_scripts(struct pkgdb *db, struct pkg *pkg)

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -2153,7 +2162,7 @@ pkgdb_load_scripts(struct pkgdb *db, struct pkg *pkg)

 	sqlite3_finalize(stmt);
 	if (ret != SQLITE_DONE) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -2566,7 +2575,7 @@ prstmt_initialize(struct pkgdb *db)

 		pkg_debug(4, "Pkgdb: running '%s'", SQL(i));
 		ret = sqlite3_prepare_v2(sqlite, SQL(i), -1, &STMT(i), NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(sqlite);
 			ERROR_SQLITE(sqlite, SQL(i));
 			return (EPKG_FATAL);
 		}
 	}

@@ -2697,7 +2706,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 	 */
 	if (run_prstmt(MTREE, mtree) != SQLITE_DONE) {
 		ERROR_SQLITE(s);
 		ERROR_SQLITE(s, SQL(MTREE));
 		goto cleanup;
 	}

@@ -2708,14 +2717,14 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 	    arch, maintainer, www, prefix, flatsize, (int64_t)automatic,
 	    (int64_t)licenselogic, mtree, digest);
 	if (ret != SQLITE_DONE) {
 		ERROR_SQLITE(s);
 		ERROR_SQLITE(s, SQL(PKG));
 		goto cleanup;
 	}
 	package_id = sqlite3_last_insert_rowid(s);
 	if (run_prstmt(FTS_APPEND, package_id, name, version, origin) != SQLITE_DONE) {
 		ERROR_SQLITE(s);
 		ERROR_SQLITE(s, SQL(FTS_APPEND));
 		goto cleanup;
 	}

@@ -2725,7 +2734,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 	 */
 	if (run_prstmt(DEPS_UPDATE, name, version, origin) != SQLITE_DONE) {
 		ERROR_SQLITE(s);
 		ERROR_SQLITE(s, SQL(DEPS_UPDATE));
 		goto cleanup;
 	}

@@ -2737,7 +2746,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 		if (run_prstmt(DEPS, pkg_dep_origin(dep),
 		    pkg_dep_name(dep), pkg_dep_version(dep),
 		    package_id) != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(DEPS));
 			goto cleanup;
 		}
 	}

@@ -2756,12 +2765,12 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 		if (ret == SQLITE_DONE)
 			continue;
 		if (ret != SQLITE_CONSTRAINT) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(FILES));
 			goto cleanup;
 		}
 		it = pkgdb_query_which(db, pkg_path, false);
 		if (it == NULL) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, "pkg which");
 			goto cleanup;
 		}
 		pkg2 = NULL;

@@ -2775,13 +2784,13 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 			if (ret == SQLITE_DONE)
 				continue;
 			else {
 				ERROR_SQLITE(s);
 				ERROR_SQLITE(s, SQL(FILES_REPLACE));
 				goto cleanup;
 			}
 		}
 		if (ret != EPKG_OK && ret != EPKG_END) {
 			pkgdb_it_free(it);
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(FILES_REPLACE));
 			goto cleanup;
 		}
 		pkg_get(pkg2, PKG_NAME, &name2, PKG_VERSION, &version2);

@@ -2815,7 +2824,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 	while (pkg_dirs(pkg, &dir) == EPKG_OK) {
 		if (run_prstmt(DIRS1, pkg_dir_path(dir)) != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(DIRS1));
 			goto cleanup;
 		}
 		if ((ret = run_prstmt(DIRS2, package_id, pkg_dir_path(dir),

@@ -2825,7 +2834,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 				    "providing directory: %s",
 				    pkg_dir_path(dir));
 			} else
 				ERROR_SQLITE(s);
 				ERROR_SQLITE(s, SQL(DIRS2));
 			goto cleanup;
 		}
 	}

@@ -2840,7 +2849,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 		if (ret == SQLITE_DONE)
 			ret = run_prstmt(CATEGORY2, package_id, pkg_object_string(obj));
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(CATEGORY2));
 			goto cleanup;
 		}
 	}

@@ -2856,7 +2865,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 		    ||
 		    run_prstmt(LICENSES2, package_id, pkg_object_string(obj))
 		    != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(LICENSES2));
 			goto cleanup;
 		}
 	}

@@ -2871,7 +2880,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 		    ||
 		    run_prstmt(USERS2, package_id, pkg_user_name(user))
 		    != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(USERS2));
 			goto cleanup;
 		}
 	}

@@ -2886,7 +2895,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 		    ||
 		    run_prstmt(GROUPS2, package_id, pkg_group_name(group))
 		    != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(GROUPS2));
 			goto cleanup;
 		}
 	}

@@ -2907,7 +2916,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 		    ||
 		    run_prstmt(OPTION2, package_id, pkg_option_opt(option),
 			       pkg_option_value(option)) != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(OPTION2));
 			goto cleanup;
 		}
 	}

@@ -2932,7 +2941,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 	while (pkg_conflicts(pkg, &conflict) == EPKG_OK) {
 		if (run_prstmt(CONFLICT, package_id, pkg_conflict_origin(conflict))
 				!= SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(CONFLICT));
 			goto cleanup;
 		}
 	}

@@ -2964,7 +2973,7 @@ pkgdb_insert_scripts(struct pkg *pkg, int64_t package_id, sqlite3 *s)

 		if (run_prstmt(SCRIPT1, script) != SQLITE_DONE
 		    ||
 		    run_prstmt(SCRIPT2, script, package_id, i) != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(SCRIPT2));
 			return (EPKG_FATAL);
 		}
 	}

@@ -2983,7 +2992,7 @@ pkgdb_update_shlibs_required(struct pkg *pkg, int64_t package_id, sqlite3 *s)

 		    ||
 		    run_prstmt(SHLIBS_REQD, package_id, pkg_shlib_name(shlib))
 		    != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(SHLIBS_REQD));
 			return (EPKG_FATAL);
 		}
 	}

@@ -3002,7 +3011,7 @@ pkgdb_update_shlibs_provided(struct pkg *pkg, int64_t package_id, sqlite3 *s)

 		    ||
 		    run_prstmt(SHLIBS_PROV, package_id, pkg_shlib_name(shlib))
 		    != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(SHLIBS_PROV));
 			return (EPKG_FATAL);
 		}
 	}

@@ -3021,7 +3030,7 @@ pkgdb_update_provides(struct pkg *pkg, int64_t package_id, sqlite3 *s)

 		    ||
 		    run_prstmt(PKG_PROVIDE, package_id, pkg_provide_name(provide))
 		    != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(PKG_PROVIDE));
 			return (EPKG_FATAL);
 		}
 	}

@@ -3047,7 +3056,7 @@ pkgdb_insert_annotations(struct pkg *pkg, int64_t package_id, sqlite3 *s)

 			pkg_object_key(note),
 			pkg_object_string(note))
 		    != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, SQL(ANNOTATE2));
 			return (EPKG_FATAL);
 		}
 	}

@@ -3096,7 +3105,7 @@ pkgdb_reanalyse_shlibs(struct pkgdb *db, struct pkg *pkg)

 			if (sqlite3_prepare_v2(db->sqlite, sql[i], -1,
 					       &stmt_del, NULL)
 			    != SQLITE_OK) {
 				ERROR_SQLITE(db->sqlite);
 				ERROR_SQLITE(db->sqlite, sql[i]);
 				return (EPKG_FATAL);
 			}

@@ -3106,7 +3115,7 @@ pkgdb_reanalyse_shlibs(struct pkgdb *db, struct pkg *pkg)

 			sqlite3_finalize(stmt_del);
 			if (ret != SQLITE_DONE) {
 				ERROR_SQLITE(db->sqlite);
 				ERROR_SQLITE(db->sqlite, sql[i]);
 				return (EPKG_FATAL);
 			}
 		}

@@ -3145,7 +3154,7 @@ pkgdb_add_annotation(struct pkgdb *db, struct pkg *pkg, const char *tag,

 	    ||
 	    run_prstmt(ANNOTATE_ADD1, pkgorigin, tag, value)
 	    != SQLITE_DONE) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, SQL(ANNOTATE_ADD1));
 		pkgdb_transaction_rollback(db->sqlite, NULL);
 		return (EPKG_FATAL);
 	}

@@ -3187,7 +3196,7 @@ pkgdb_modify_annotation(struct pkgdb *db, struct pkg *pkg, const char *tag,

 	        SQLITE_DONE
 	    ||
 	    run_prstmt(ANNOTATE_DEL2) != SQLITE_DONE) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, SQL(ANNOTATE_DEL2));
 		pkgdb_transaction_rollback(db->sqlite, NULL);
 		return (EPKG_FATAL);

@@ -3229,7 +3238,7 @@ pkgdb_delete_annotation(struct pkgdb *db, struct pkg *pkg, const char *tag)

 	if (!result
 	    ||
 	    run_prstmt(ANNOTATE_DEL2) != SQLITE_DONE) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, SQL(ANNOTATE_DEL2));
 		pkgdb_transaction_rollback(db->sqlite, NULL);
 		return (EPKG_FATAL);
 	}

@@ -3309,7 +3318,7 @@ pkgdb_unregister_pkg(struct pkgdb *db, const char *origin)

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt_del, NULL)
 	    != SQLITE_OK){
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -3319,7 +3328,7 @@ pkgdb_unregister_pkg(struct pkgdb *db, const char *origin)

 	sqlite3_finalize(stmt_del);
 	if (ret != SQLITE_DONE) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -3354,7 +3363,7 @@ sql_exec(sqlite3 *s, const char *sql, ...)

 	pkg_debug(4, "Pkgdb: executing '%s'", sql_to_exec);
 	if (sqlite3_exec(s, sql_to_exec, NULL, NULL, &errmsg) != SQLITE_OK) {
 		ERROR_SQLITE(s);
 		ERROR_SQLITE(s, sql_to_exec);
 		sqlite3_free(errmsg);
 		goto cleanup;
 	}

@@ -3379,7 +3388,7 @@ pkgdb_is_attached(sqlite3 *s, const char *name)

 	ret = sqlite3_prepare_v2(s, "PRAGMA database_list;", -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(s);
 		ERROR_SQLITE(s, "PRAGMA database_list;");
 		return false;
 	}

@@ -3410,7 +3419,7 @@ pkgdb_sql_all_attached(sqlite3 *s, struct sbuf *sql, const char *multireposql,

 	ret = sqlite3_prepare_v2(s, "PRAGMA database_list;", -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(s);
 		ERROR_SQLITE(s, "PRAGMA database_list;");
 		return (EPKG_FATAL);
 	}

@@ -3450,7 +3459,7 @@ pkgdb_detach_remotes(sqlite3 *s)

 	ret = sqlite3_prepare_v2(s, "PRAGMA database_list;", -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(s);
 		ERROR_SQLITE(s, "PRAGMA database_list;");
 		return;
 	}

@@ -3485,7 +3494,7 @@ get_pragma(sqlite3 *s, const char *sql, int64_t *res, bool silence)

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(s, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		if (!silence)
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, sql);
 		return (EPKG_OK);
 	}

@@ -3503,7 +3512,7 @@ get_pragma(sqlite3 *s, const char *sql, int64_t *res, bool silence)

 	if (ret != SQLITE_ROW) {
 		if (!silence)
 			ERROR_SQLITE(s);
 			ERROR_SQLITE(s, sql);
 		return (EPKG_FATAL);
 	}

@@ -3520,7 +3529,7 @@ get_sql_string(sqlite3 *s, const char *sql, char **res)

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(s, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(s);
 		ERROR_SQLITE(s, sql);
 		return (EPKG_OK);
 	}

@@ -3538,7 +3547,7 @@ get_sql_string(sqlite3 *s, const char *sql, char **res)

 	sqlite3_finalize(stmt);
 	if (ret != SQLITE_ROW && ret != SQLITE_DONE) {
 		ERROR_SQLITE(s);
 		ERROR_SQLITE(s, sql);
 		return (EPKG_FATAL);
 	}

@@ -3698,7 +3707,7 @@ pkgdb_search(struct pkgdb *db, const char *pattern, match_t match,

 	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);
 		ERROR_SQLITE(db->sqlite, sbuf_get(sql));
 		sbuf_delete(sql);
 		return (NULL);
 	}

@@ -3738,7 +3747,7 @@ pkgdb_integrity_append(struct pkgdb *db, struct pkg *p,

 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL)
 	    != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -3762,7 +3771,7 @@ pkgdb_integrity_append(struct pkgdb *db, struct pkg *p,

 			pkg_debug(4, "Pkgdb: running '%s'", sql_conflicts);
 			if (sqlite3_prepare_v2(db->sqlite, sql_conflicts,
 			    -1, &stmt_conflicts, NULL) != SQLITE_OK) {
 				ERROR_SQLITE(db->sqlite);
 				ERROR_SQLITE(db->sqlite, sql_conflicts);
 				sqlite3_finalize(stmt);
 				return (EPKG_FATAL);
 			}

@@ -3832,7 +3841,7 @@ pkgdb_integrity_check(struct pkgdb *db, conflict_func_cb cb, void *cbdata)

 	if (sqlite3_prepare_v2(db->sqlite,
 		sql_integrity_prepare,
 		-1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql_integrity_prepare);
 		return (EPKG_FATAL);
 	}

@@ -3847,7 +3856,7 @@ pkgdb_integrity_check(struct pkgdb *db, conflict_func_cb cb, void *cbdata)

 		ret = sqlite3_prepare_v2(db->sqlite, sql_local_conflict, -1,
 		    &stmt_conflicts, NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(db->sqlite);
 			ERROR_SQLITE(db->sqlite, sql_local_conflict);
 			sqlite3_finalize(stmt);
 			sbuf_delete(origin);
 			sbuf_delete(conflictmsg);

@@ -3871,7 +3880,7 @@ pkgdb_integrity_check(struct pkgdb *db, conflict_func_cb cb, void *cbdata)

 		ret = sqlite3_prepare_v2(db->sqlite, sql_conflicts, -1,
 		    &stmt_conflicts, NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(db->sqlite);
 			ERROR_SQLITE(db->sqlite, sql_conflicts);
 			sqlite3_finalize(stmt);
 			sbuf_delete(conflictmsg);
 			sbuf_delete(origin);

@@ -3925,7 +3934,7 @@ pkgdb_integrity_conflict_local(struct pkgdb *db, const char *origin)

 	pkg_debug(4, "Pkgdb: running '%s'", sql_conflicts);
 	ret = sqlite3_prepare_v2(db->sqlite, sql_conflicts, -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql_conflicts);
 		return (NULL);
 	}

@@ -3965,7 +3974,7 @@ pkgdb_vset(struct pkgdb *db, int64_t id, va_list ap)

 		pkg_debug(4, "Pkgdb: running '%s'", sql[attr]);
 		if (sqlite3_prepare_v2(db->sqlite, sql[attr], -1, &stmt, NULL)
 		    != SQLITE_OK) {
 			ERROR_SQLITE(db->sqlite);
 			ERROR_SQLITE(db->sqlite, sql[attr]);
 			return (EPKG_FATAL);
 		}

@@ -4006,7 +4015,7 @@ pkgdb_vset(struct pkgdb *db, int64_t id, va_list ap)

 		}
 		if (sqlite3_step(stmt) != SQLITE_DONE) {
 			ERROR_SQLITE(db->sqlite);
 			ERROR_SQLITE(db->sqlite, sql[attr]);
 			sqlite3_finalize(stmt);
 			return (EPKG_FATAL);
 		}

@@ -4046,14 +4055,14 @@ pkgdb_file_set_cksum(struct pkgdb *db, struct pkg_file *file,

 	pkg_debug(4, "Pkgdb: running '%s'", sql_file_update);
 	ret = sqlite3_prepare_v2(db->sqlite, sql_file_update, -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql_file_update);
 		return (EPKG_FATAL);
 	}
 	sqlite3_bind_text(stmt, 1, sha256, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt, 2, pkg_file_path(file), -1, SQLITE_STATIC);
 	if (sqlite3_step(stmt) != SQLITE_DONE) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sql_file_update);
 		sqlite3_finalize(stmt);
 		return (EPKG_FATAL);
 	}

@@ -4114,13 +4123,13 @@ pkgdb_write_lock_pid(struct pkgdb *db)

 	ret = sqlite3_prepare_v2(db->sqlite, lock_pid_sql, -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, lock_pid_sql);
 		return (EPKG_FATAL);
 	}
 	sqlite3_bind_int64(stmt, 1, (int64_t)getpid());
 	if (sqlite3_step(stmt) != SQLITE_DONE) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, lock_pid_sql);
 		sqlite3_finalize(stmt);
 		return (EPKG_FATAL);
 	}

@@ -4139,13 +4148,13 @@ pkgdb_remove_lock_pid(struct pkgdb *db, int64_t pid)

 	ret = sqlite3_prepare_v2(db->sqlite, lock_pid_sql, -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, lock_pid_sql);
 		return (EPKG_FATAL);
 	}
 	sqlite3_bind_int64(stmt, 1, pid);
 	if (sqlite3_step(stmt) != SQLITE_DONE) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, lock_pid_sql);
 		sqlite3_finalize(stmt);
 		return (EPKG_FATAL);
 	}

@@ -4160,11 +4169,12 @@ pkgdb_check_lock_pid(struct pkgdb *db)

 	sqlite3_stmt	*stmt = NULL;
 	int ret, found = 0;
 	int64_t pid, lpid;
 	const char query[] = "SELECT pid FROM pkg_lock_pid;";
 	ret = sqlite3_prepare_v2(db->sqlite, "SELECT pid FROM pkg_lock_pid;", -1,
 	ret = sqlite3_prepare_v2(db->sqlite, query, -1,
 			&stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, query);
 		return (EPKG_FATAL);
 	}

@@ -4307,14 +4317,14 @@ pkgdb_obtain_lock(struct pkgdb *db, pkgdb_lock_t type)

 		/* Need to initialize */
 		ret = sqlite3_exec(db->sqlite, init_sql, NULL, NULL, NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(db->sqlite);
 			ERROR_SQLITE(db->sqlite, init_sql);
 			return (EPKG_FATAL);
 		}
 	}
 	ret = sqlite3_exec(db->sqlite, pid_sql, NULL, NULL, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, pid_sql);
 		return (EPKG_FATAL);
 	}

@@ -4474,7 +4484,7 @@ pkgdb_stats(struct pkgdb *db, pkg_stats_t type)

 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_data(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		sbuf_free(sql);
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sbuf_data(sql));
 		return (-1);
 	}

modified libpkg/pkgdb_repo.c

@@ -231,7 +231,7 @@ get_repo_user_version(sqlite3 *sqlite, const char *database, int *reposcver)

 	sqlite3_snprintf(sizeof(sql), sql, fmt, database);
 	if (sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(sqlite);
 		ERROR_SQLITE(sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -257,7 +257,7 @@ initialize_prepared_statements(sqlite3 *sqlite)

 	for (i = 0; i < last; i++) {
 		ret = sqlite3_prepare_v2(sqlite, SQL(i), -1, &STMT(i), NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(sqlite);
 			ERROR_SQLITE(sqlite, SQL(i));
 			return (EPKG_FATAL);
 		}
 	}

@@ -301,8 +301,8 @@ run_prepared_statement(sql_prstmt_index s, ...)

 	return (retcode);
 }
 static void
 finalize_prepared_statements(void)
 void
 pkgdb_repo_finalize_statements(void)
 {
 	sql_prstmt_index i, last;

@@ -377,7 +377,7 @@ pkgdb_repo_init(sqlite3 *sqlite)

 {
 	int retcode = EPKG_OK;
 	retcode = sql_exec(sqlite, "PRAGMA synchronous=off");
 	retcode = sql_exec(sqlite, "PRAGMA synchronous=default");
 	if (retcode != EPKG_OK)
 		return (retcode);

@@ -389,10 +389,6 @@ pkgdb_repo_init(sqlite3 *sqlite)

 	if (retcode != EPKG_OK)
 		return (retcode);
 	retcode = pkgdb_transaction_begin(sqlite, NULL);
 	if (retcode != EPKG_OK)
 		return (retcode);
 	return (EPKG_OK);
 }

@@ -412,7 +408,7 @@ pkgdb_repo_close(sqlite3 *sqlite, bool commit)

 		if (pkgdb_transaction_rollback(sqlite, NULL) != SQLITE_OK)
 				retcode = EPKG_FATAL;
 	}
 	finalize_prepared_statements();
 	pkgdb_repo_finalize_statements();
 	return (retcode);
 }

@@ -461,7 +457,7 @@ int

 pkgdb_repo_cksum_exists(sqlite3 *sqlite, const char *cksum)
 {
 	if (run_prepared_statement(EXISTS, cksum) != SQLITE_ROW) {
 		ERROR_SQLITE(sqlite);
 		ERROR_SQLITE(sqlite, SQL(EXISTS));
 		return (EPKG_FATAL);
 	}
 	if (sqlite3_column_int(STMT(EXISTS), 0) > 0) {

@@ -505,7 +501,7 @@ try_again:

 			switch(maybe_delete_conflicting(origin,
 					version, pkg_path, forced)) {
 			case EPKG_FATAL: /* sqlite error */
 				ERROR_SQLITE(sqlite);
 				ERROR_SQLITE(sqlite, SQL(PKG));
 				return (EPKG_FATAL);
 				break;
 			case EPKG_END: /* repo already has newer */

@@ -516,7 +512,7 @@ try_again:

 				break;
 			}
 		} else {
 			ERROR_SQLITE(sqlite);
 			ERROR_SQLITE(sqlite, SQL(PKG));
 			return (EPKG_FATAL);
 		}
 	}

@@ -524,7 +520,7 @@ try_again:

 	if (run_prepared_statement (FTS_APPEND, package_id,
 			name, version, origin) != SQLITE_DONE) {
 		ERROR_SQLITE(sqlite);
 		ERROR_SQLITE(sqlite, SQL(FTS_APPEND));
 		return (EPKG_FATAL);
 	}

@@ -535,7 +531,7 @@ try_again:

 				pkg_dep_name(dep),
 				pkg_dep_version(dep),
 				package_id) != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite);
 			ERROR_SQLITE(sqlite, SQL(DEPS));
 			return (EPKG_FATAL);
 		}
 	}

@@ -548,7 +544,7 @@ try_again:

 			    pkg_object_string(obj));
 		if (ret != SQLITE_DONE)
 		{
 			ERROR_SQLITE(sqlite);
 			ERROR_SQLITE(sqlite, SQL(CAT2));
 			return (EPKG_FATAL);
 		}
 	}

@@ -560,7 +556,7 @@ try_again:

 			ret = run_prepared_statement(LIC2, package_id,
 			    pkg_object_string(obj));
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite);
 			ERROR_SQLITE(sqlite, SQL(LIC2));
 			return (EPKG_FATAL);
 		}
 	}

@@ -571,7 +567,7 @@ try_again:

 		    ret = run_prepared_statement(OPT2, pkg_option_opt(option),
 				pkg_option_value(option), package_id);
 		if(ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite);
 			ERROR_SQLITE(sqlite, SQL(OPT2));
 			return (EPKG_FATAL);
 		}
 	}

@@ -585,7 +581,7 @@ try_again:

 			ret = run_prepared_statement(SHLIB_REQD, package_id,
 					shlib_name);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite);
 			ERROR_SQLITE(sqlite, SQL(SHLIB_REQD));
 			return (EPKG_FATAL);
 		}
 	}

@@ -599,7 +595,7 @@ try_again:

 			ret = run_prepared_statement(SHLIB_PROV, package_id,
 					shlib_name);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite);
 			ERROR_SQLITE(sqlite, SQL(SHLIB_PROV));
 			return (EPKG_FATAL);
 		}
 	}

@@ -616,7 +612,7 @@ try_again:

 			ret = run_prepared_statement(ANNOTATE2, package_id,
 				  note_tag, note_val);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite);
 			ERROR_SQLITE(sqlite, SQL(ANNOTATE2));
 			return (EPKG_FATAL);
 		}
 	}

@@ -919,7 +915,7 @@ pkgdb_repo_origins(sqlite3 *sqlite)

 	ret = sqlite3_prepare_v2(sqlite, query_sql, -1,
 			&stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(sqlite);
 		ERROR_SQLITE(sqlite, query_sql);
 		return (NULL);
 	}
 	repodb.sqlite = sqlite;

@@ -948,7 +944,7 @@ pkgdb_repo_register_conflicts(const char *origin, char **conflicts,

 	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);
 		ERROR_SQLITE(sqlite, select_id_sql);
 		return (EPKG_FATAL);
 	}

@@ -959,14 +955,14 @@ pkgdb_repo_register_conflicts(const char *origin, char **conflicts,

 		origin_id = sqlite3_column_int64(stmt, 0);
 	}
 	else {
 		ERROR_SQLITE(sqlite);
 		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);
 		ERROR_SQLITE(sqlite, clean_conflicts_sql);
 		return (EPKG_FATAL);
 	}

@@ -980,7 +976,7 @@ pkgdb_repo_register_conflicts(const char *origin, char **conflicts,

 		/* 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);
 			ERROR_SQLITE(sqlite, select_id_sql);
 			return (EPKG_FATAL);
 		}

@@ -991,7 +987,7 @@ pkgdb_repo_register_conflicts(const char *origin, char **conflicts,

 			conflict_id = sqlite3_column_int64(stmt, 0);
 		}
 		else {
 			ERROR_SQLITE(sqlite);
 			ERROR_SQLITE(sqlite, select_id_sql);
 			return (EPKG_FATAL);
 		}

@@ -1000,7 +996,7 @@ pkgdb_repo_register_conflicts(const char *origin, char **conflicts,

 		/* 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);
 			ERROR_SQLITE(sqlite, insert_conflict_sql);
 			return (EPKG_FATAL);
 		}

@@ -1009,7 +1005,7 @@ pkgdb_repo_register_conflicts(const char *origin, char **conflicts,

 		ret = sqlite3_step(stmt);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite);
 			ERROR_SQLITE(sqlite, insert_conflict_sql);
 			return (EPKG_FATAL);
 		}

@@ -1098,7 +1094,7 @@ pkgdb_rquery(struct pkgdb *db, const char *pattern, match_t match,

 	pkg_debug(4, "Pkgdb: running '%s'", sbuf_get(sql));
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), sbuf_size(sql), &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		ERROR_SQLITE(db->sqlite, sbuf_get(sql));
 		sbuf_delete(sql);
 		return (NULL);
 	}

@@ -1154,7 +1150,7 @@ pkgdb_rquery_provide(struct pkgdb *db, const char *provide, const char *repo)

 	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);
 		ERROR_SQLITE(db->sqlite, sbuf_get(sql));
 		sbuf_delete(sql);
 		return (NULL);
 	}

@@ -1207,7 +1203,7 @@ pkgdb_find_shlib_provide(struct pkgdb *db, const char *require, const char *repo

 	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);
 		ERROR_SQLITE(db->sqlite, sbuf_get(sql));
 		sbuf_delete(sql);
 		return (NULL);
 	}

@@ -1260,7 +1256,7 @@ pkgdb_find_shlib_require(struct pkgdb *db, const char *provide, const char *repo

 	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);
 		ERROR_SQLITE(db->sqlite, sbuf_get(sql));
 		sbuf_delete(sql);
 		return (NULL);
 	}

modified libpkg/private/pkgdb.h

@@ -84,6 +84,11 @@ int pkgdb_repo_open(const char *repodb, bool force, sqlite3 **sqlite);

 int pkgdb_repo_init(sqlite3 *sqlite);
 /**
  * Finalize prepared statements for a repo
  */
 void pkgdb_repo_finalize_statements(void);
 /**
  * Close repodb and commit/rollback transaction started
  * @param sqlite sqlite pointer
  * @param commit commit transaction if true, rollback otherwise

modified libpkg/private/utils.h

@@ -41,8 +41,9 @@

 #define STARTS_WITH(string, needle) (strncasecmp(string, needle, strlen(needle)) == 0)
 #define ERROR_SQLITE(db) \
 	pkg_emit_error("sqlite error in file %s:%d: %s", __FILE__, __LINE__, sqlite3_errmsg(db))
 #define ERROR_SQLITE(db, query) \
 	pkg_emit_error("sqlite error while executing %s in file %s:%d: %s", (query), \
 	__FILE__, __LINE__, sqlite3_errmsg(db))
 #define HASH_FIND_INO(head,ino,out)                                          \
 	HASH_FIND(hh,head,ino,sizeof(ino_t),out)

@@ -114,6 +115,7 @@ int set_nameserver(const char *nsname);

 ucl_object_t *yaml_to_ucl(const char *file, const char *buffer, size_t len);
 void set_blocking(int fd);
 void set_nonblocking(int fd);
 void print_trace(void);
 pid_t process_spawn_pipe(FILE *inout[2], const char *command);

modified libpkg/utils.c

@@ -26,12 +26,17 @@

  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <pkg_config.h>
 #include <sys/stat.h>
 #include <sys/param.h>
 #include <stdio.h>
 #include <assert.h>
 #include <errno.h>
 #ifdef HAVE_EXECINFO_H
 #include <execinfo.h>
 #endif
 #include <fcntl.h>
 #include <stdlib.h>
 #include <unistd.h>

@@ -849,3 +854,22 @@ ucl_object_emit_sbuf(const ucl_object_t *obj, enum ucl_emitter emit_type,

 	return (ret);
 }
 void
 print_trace(void)
 {
 #ifdef HAVE_EXECINFO_H
 	void *array[10];
 	size_t size;
 	char **strings;
 	size_t i;
 	size = backtrace(array, 10);
 	strings = backtrace_symbols(array, size);
 	for (i = 0; i < size; i++)
 		fprintf(stderr, "%s\n", strings[i]);
 	free(strings);
 #endif
 }

modified src/Makefile.am

@@ -48,6 +48,7 @@ pkg_static_LDADD= $(top_builddir)/libpkg/libpkg_static.la \

 			$(pkg_OBJECTS) \
 			@LIBJAIL_LIB@ \
 			@LIBSBUF_LIB@ \
 			@LIBEXECINFO_LIB@ \
 			@LIBELF_LIB@ \
 			-lfetch \
 			-larchive \

modified src/event.c

@@ -34,6 +34,7 @@

 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/sysctl.h>
 #include <sys/wait.h>
 #include <sys/socket.h>

@@ -68,6 +69,25 @@ print_status_end(struct sbuf *msg)

 static void
 print_status_begin(struct sbuf *msg)
 {
 #ifdef HAVE_LIBJAIL
 	static char hostname[MAXHOSTNAMELEN] = "";
 	static int jailed = -1;
 	size_t intlen;
 	if (jailed == -1) {
 		intlen = sizeof(jailed);
 		if (sysctlbyname("security.jail.jailed", &jailed, &intlen,
 		    NULL, 0) == -1)
 			jailed = 0;
 	}
 	if (jailed == 1) {
 		if (hostname[0] == '\0')
 			gethostname(hostname, sizeof(hostname));
 		sbuf_printf(msg, "[%s] ", hostname);
 	}
 #endif
 	if (nbactions > 0)
 		sbuf_printf(msg, "[%d/%d] ", nbdone, nbactions);