2427355 pkgdb: use the new pkgdb_debug — HardenedBSD-pkg

modified libpkg/pkg_jobs_conflicts.c

@@ -288,7 +288,6 @@ pkg_conflicts_check_local_path(const char *path, const char *uid,

 	int ret;
 	struct pkg *p = NULL;
 	pkg_debug(4, "Pkgdb: running '%s'", sql_local_conflict);
 	ret = sqlite3_prepare_v2(j->db->sqlite, sql_local_conflict, -1,
 		&stmt, NULL);
 	if (ret != SQLITE_OK) {

@@ -300,6 +299,7 @@ pkg_conflicts_check_local_path(const char *path, const char *uid,

 		path, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt, 2,
 		uid, -1, SQLITE_STATIC);
 	pkgdb_debug(4, stmt);
 	if (sqlite3_step(stmt) == SQLITE_ROW) {
 		/*

modified libpkg/pkgdb.c

@@ -1,5 +1,5 @@

 /*-
  * Copyright (c) 2011-2016 Baptiste Daroussin <bapt@FreeBSD.org>
  * Copyright (c) 2011-2023 Baptiste Daroussin <bapt@FreeBSD.org>
  * Copyright (c) 2011-2012 Julien Laffaye <jlaffaye@FreeBSD.org>
  * Copyright (c) 2011 Will Andrews <will@FreeBSD.org>
  * Copyright (c) 2011 Philippe Pepiot <phil@philpep.org>

@@ -1135,8 +1135,8 @@ run_transaction(sqlite3 *sqlite, const char *query, const char *savepoint)

 	assert(sqlite != NULL);
 	xasprintf(&sql, "%s %s", query, savepoint != NULL ? savepoint : "");
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	ret = sqlite3_prepare_v2(sqlite, sql, strlen(sql) + 1, &stmt, NULL);
 	pkgdb_debug(4, stmt);
 	if (ret == SQLITE_OK) {
 		PKGDB_SQLITE_RETRY_ON_BUSY(ret)

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

 				return (EPKG_FATAL);
 			sqlite3_bind_int64(stmt_del, 1, package_id);
 			pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt_del));
 			pkgdb_debug(4, stmt_del);
 			ret = sqlite3_step(stmt_del);

@@ -2291,7 +2291,7 @@ pkgdb_unregister_pkg(struct pkgdb *db, int64_t id)

 		return (EPKG_FATAL);
 	sqlite3_bind_int64(stmt_del, 1, id);
 	pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt_del));
 	pkgdb_debug(4, stmt_del);
 	ret = sqlite3_step(stmt_del);

@@ -2355,12 +2355,12 @@ get_pragma(sqlite3 *s, const char *sql, int64_t *res, bool silence)

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

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

 			break;
 		}
 		pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
 		pkgdb_debug(4, stmt);
 		if (sqlite3_step(stmt) != SQLITE_DONE) {
 			ERROR_STMT_SQLITE(db->sqlite, stmt);
 			sqlite3_finalize(stmt);

@@ -2522,7 +2522,7 @@ pkgdb_file_set_cksum(struct pkgdb *db, struct pkg_file *file,

 		return (EPKG_FATAL);
 	sqlite3_bind_text(stmt, 1, sum, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt, 2, file->path, -1, SQLITE_STATIC);
 	pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
 	pkgdb_debug(4, stmt);
 	if (sqlite3_step(stmt) != SQLITE_DONE) {
 		ERROR_STMT_SQLITE(db->sqlite, stmt);

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

 	while (sqlite3_step(stmt) != SQLITE_DONE) {
 		stats = sqlite3_column_int64(stmt, 0);
 		pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
 		pkgdb_debug(4, stmt);
 	}
 	sqlite3_finalize(stmt);

@@ -3037,6 +3037,7 @@ void

 pkgdb_debug(int level, sqlite3_stmt *stmt)
 {
 	char *str;
 	if (ctx.debug_level < level)
 		return;

modified libpkg/pkgdb_iterator.c

@@ -1,5 +1,5 @@

 /*-
  * Copyright (c) 2011-2015 Baptiste Daroussin <bapt@FreeBSD.org>
  * Copyright (c) 2011-2023 Baptiste Daroussin <bapt@FreeBSD.org>
  * Copyright (c) 2011-2012 Julien Laffaye <jlaffaye@FreeBSD.org>
  * Copyright (c) 2011 Will Andrews <will@FreeBSD.org>
  * Copyright (c) 2011 Philippe Pepiot <phil@philpep.org>

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

 {
 	sqlite3_stmt	*stmt;
 	int		 ret;
 	char *str;
 	assert(db != NULL && pkg != NULL);

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

 	}
 	sqlite3_bind_int64(stmt, 1, pkg->id);
 	str = sqlite3_expanded_sql(stmt);
 	pkg_debug(4, "Pkgdb: running '%s'", str);
 	sqlite3_free(str);
 	pkgdb_debug(4, stmt);
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
 		pkg_adddata(pkg, sqlite3_column_text(stmt, 0));
 	}

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

 {
 	sqlite3_stmt	*stmt;
 	int		 ret;
 	char *str;
 	assert(db != NULL && pkg != NULL);

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

 	}
 	sqlite3_bind_int64(stmt, 1, pkg->id);
 	str = sqlite3_expanded_sql(stmt);
 	pkg_debug(4, "Pkgdb: running '%s'", str);
 	sqlite3_free(str);
 	pkgdb_debug(4, stmt);
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
 		pkg_addtagval(pkg, sqlite3_column_text(stmt, 0),

@@ -249,7 +242,6 @@ pkgdb_load_deps(sqlite3 *sqlite, struct pkg *pkg)

 		"    JOIN pkg_option USING(option_id)"
 		"  WHERE package_id = ?1"
 		"  ORDER BY option";
 	char *str;
 	assert(pkg != NULL);

@@ -265,9 +257,7 @@ pkgdb_load_deps(sqlite3 *sqlite, struct pkg *pkg)

 	}
 	sqlite3_bind_int64(stmt, 1, pkg->id);
 	str =sqlite3_expanded_sql(stmt);
 	pkg_debug(4, "Pkgdb: running '%s'", str);
 	sqlite3_free(str);
 	pkgdb_debug(4, stmt);
 	/* XXX: why we used locked here ? */
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {

@@ -296,9 +286,7 @@ pkgdb_load_deps(sqlite3 *sqlite, struct pkg *pkg)

 				if (clause) {
 					xasprintf(&formula_sql, "%s%s", formula_preamble, clause);
 					pkg_debug(4, "Pkgdb: running '%s'", sql);
 					ret = sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL);
 					if (ret != SQLITE_OK) {
 						ERROR_SQLITE(sqlite, sql);
 						free(clause);

@@ -306,6 +294,7 @@ pkgdb_load_deps(sqlite3 *sqlite, struct pkg *pkg)

 						pkg_deps_formula_free(f);
 						return (EPKG_FATAL);
 					}
 					pkgdb_debug(4, stmt);
 					/* Fetch matching packages */
 					chain = NULL;

@@ -318,12 +307,12 @@ pkgdb_load_deps(sqlite3 *sqlite, struct pkg *pkg)

 						options_match = true;
 						if (fit->options) {
 							pkg_debug(4, "Pkgdb: running '%s'", options_sql);
 							if (sqlite3_prepare_v2(sqlite, options_sql, -1,
 									&opt_stmt, NULL) != SQLITE_OK) {
 								ERROR_SQLITE(sqlite, options_sql);
 								return (EPKG_FATAL);
 							}
 							pkgdb_debug(4, opt_stmt);
 							sqlite3_bind_int64(opt_stmt, 1,
 									sqlite3_column_int64(stmt, 0));

@@ -387,7 +376,6 @@ pkgdb_load_rdeps(sqlite3 *sqlite, struct pkg *pkg)

 		"  FROM packages AS p"
 		"    INNER JOIN deps AS d ON (p.id = d.package_id)"
 		"  WHERE d.name = ?1";
 	char *str;
 	assert(pkg != NULL);

@@ -403,9 +391,7 @@ pkgdb_load_rdeps(sqlite3 *sqlite, struct pkg *pkg)

 	}
 	sqlite3_bind_text(stmt, 1, pkg->uid, -1, SQLITE_STATIC);
 	str = sqlite3_expanded_sql(stmt);
 	pkg_debug(4, "Pkgdb: running '%s'", str);
 	sqlite3_free(str);
 	pkgdb_debug(4, stmt);
 	/* XXX: why we used locked here ? */
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {

@@ -442,7 +428,6 @@ pkgdb_load_files(sqlite3 *sqlite, struct pkg *pkg)

 		"  FROM config_files"
 		"  WHERE package_id = ?1"
 		"  ORDER BY PATH ASC";
 	char *str;
 	assert( pkg != NULL);
 	assert(pkg->type == PKG_INSTALLED);

@@ -456,9 +441,7 @@ pkgdb_load_files(sqlite3 *sqlite, struct pkg *pkg)

 	}
 	sqlite3_bind_int64(stmt, 1, pkg->id);
 	str = sqlite3_expanded_sql(stmt);
 	pkg_debug(4, "Pkgdb: running '%s'", str);
 	sqlite3_free(str);
 	pkgdb_debug(4, stmt);
 	while (sqlite3_step(stmt) == SQLITE_ROW) {
 		pkg_addfile(pkg, sqlite3_column_text(stmt, 0),

@@ -472,9 +455,7 @@ pkgdb_load_files(sqlite3 *sqlite, struct pkg *pkg)

 	}
 	sqlite3_bind_int64(stmt, 1, pkg->id);
 	str = sqlite3_expanded_sql(stmt);
 	pkg_debug(4, "Pkgdb: running '%s'", str);
 	sqlite3_free(str);
 	pkgdb_debug(4, stmt);
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
 		pkg_addconfig_file(pkg, sqlite3_column_text(stmt, 0),

@@ -504,7 +485,6 @@ pkgdb_load_dirs(sqlite3 *sqlite, struct pkg *pkg)

 		"  ORDER by path DESC";
 	sqlite3_stmt	*stmt;
 	int		 ret;
 	char *str;
 	assert(pkg != NULL);
 	assert(pkg->type == PKG_INSTALLED);

@@ -518,9 +498,7 @@ pkgdb_load_dirs(sqlite3 *sqlite, struct pkg *pkg)

 	}
 	sqlite3_bind_int64(stmt, 1, pkg->id);
 	str = sqlite3_expanded_sql(stmt);
 	pkg_debug(4, "Pkgdb: running '%s'", str);
 	sqlite3_free(str);
 	pkgdb_debug(4, stmt);
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
 		pkg_adddir(pkg, sqlite3_column_text(stmt, 0), false);

@@ -669,7 +647,6 @@ pkgdb_load_lua_scripts(sqlite3 *sqlite, struct pkg *pkg)

 		"  FROM lua_script"
 		"    JOIN pkg_lua_script USING(lua_script_id)"
 		"  WHERE package_id = ?1";
 	char *str;
 	assert(pkg != NULL);
 	assert(pkg->type == PKG_INSTALLED);

@@ -684,9 +661,7 @@ pkgdb_load_lua_scripts(sqlite3 *sqlite, struct pkg *pkg)

 	sqlite3_bind_int64(stmt, 1, pkg->id);
 	str = sqlite3_expanded_sql(stmt);
 	pkg_debug(4, "Pkgdb: running '%s'", str);
 	sqlite3_free(str);
 	pkgdb_debug(4, stmt);
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
 		pkg_add_lua_script(pkg, sqlite3_column_text(stmt, 0),

@@ -714,7 +689,6 @@ pkgdb_load_scripts(sqlite3 *sqlite, struct pkg *pkg)

 		"  FROM pkg_script"
 		"    JOIN script USING(script_id)"
 		"  WHERE package_id = ?1";
 	char *str;
 	assert(pkg != NULL);
 	assert(pkg->type == PKG_INSTALLED);

@@ -728,9 +702,7 @@ pkgdb_load_scripts(sqlite3 *sqlite, struct pkg *pkg)

 	}
 	sqlite3_bind_int64(stmt, 1, pkg->id);
 	str = sqlite3_expanded_sql(stmt);
 	pkg_debug(4, "Pkgdb: running '%s'", str);
 	sqlite3_free(str);
 	pkgdb_debug(4, stmt);
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
 		pkg_addscript(pkg, sqlite3_column_text(stmt, 0),

modified libpkg/pkgdb_query.c

@@ -200,7 +200,7 @@ pkgdb_query_cond(struct pkgdb *db, const char *cond, const char *pattern, match_

 	if (match != MATCH_ALL)
 		sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT);
 	pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
 	pkgdb_debug(4, stmt);
 	return (pkgdb_it_new_sqlite(db, stmt, PKG_INSTALLED, PKGDB_IT_FLAG_ONCE));
 }

@@ -225,13 +225,13 @@ pkgdb_file_exists(struct pkgdb *db, const char *path)

 	sqlite3_snprintf(sizeof(sql), sql,
 	    "select path from files where path = ?1;");
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite, sql);
 	}
 	sqlite3_bind_text(stmt, 1, path, -1, SQLITE_TRANSIENT);
 	pkgdb_debug(4, stmt);
 	if (sqlite3_step(stmt) != SQLITE_DONE) {
 		ret = true;

@@ -261,13 +261,13 @@ pkgdb_query_which(struct pkgdb *db, const char *path, bool glob)

 			"LEFT JOIN files AS f ON p.id = f.package_id "
 			"WHERE f.path %s ?1 GROUP BY p.id;", glob ? "GLOB" : "=");
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite, sql);
 		return (NULL);
 	}
 	sqlite3_bind_text(stmt, 1, path, -1, SQLITE_TRANSIENT);
 	pkgdb_debug(4, stmt);
 	return (pkgdb_it_new_sqlite(db, stmt, PKG_INSTALLED, PKGDB_IT_FLAG_ONCE));
 }

@@ -288,13 +288,13 @@ pkgdb_query_shlib_require(struct pkgdb *db, const char *shlib)

 	assert(db != NULL);
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite, sql);
 		return (NULL);
 	}
 	sqlite3_bind_text(stmt, 1, shlib, -1, SQLITE_TRANSIENT);
 	pkgdb_debug(4, stmt);
 	return (pkgdb_it_new_sqlite(db, stmt, PKG_INSTALLED, PKGDB_IT_FLAG_ONCE));
 }

@@ -315,13 +315,13 @@ pkgdb_query_shlib_provide(struct pkgdb *db, const char *shlib)

 	assert(db != NULL);
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite, sql);
 		return (NULL);
 	}
 	sqlite3_bind_text(stmt, 1, shlib, -1, SQLITE_TRANSIENT);
 	pkgdb_debug(4, stmt);
 	return (pkgdb_it_new_sqlite(db, stmt, PKG_INSTALLED, PKGDB_IT_FLAG_ONCE));
 }

@@ -342,13 +342,13 @@ pkgdb_query_require(struct pkgdb *db, const char *req)

 	assert(db != NULL);
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite, sql);
 		return (NULL);
 	}
 	sqlite3_bind_text(stmt, 1, req, -1, SQLITE_TRANSIENT);
 	pkgdb_debug(4, stmt);
 	return (pkgdb_it_new_sqlite(db, stmt, PKG_INSTALLED, PKGDB_IT_FLAG_ONCE));
 }

@@ -369,13 +369,13 @@ pkgdb_query_provide(struct pkgdb *db, const char *req)

 	assert(db != NULL);
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite, sql);
 		return (NULL);
 	}
 	sqlite3_bind_text(stmt, 1, req, -1, SQLITE_TRANSIENT);
 	pkgdb_debug(4, stmt);
 	return (pkgdb_it_new_sqlite(db, stmt, PKG_INSTALLED, PKGDB_IT_FLAG_ONCE));
 }

modified libpkg/repo/binary/query.c

@@ -155,7 +155,7 @@ pkg_repo_binary_query(struct pkg_repo *repo, const char *cond, const char *patte

 	if (match != MATCH_ALL)
 		sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT);
 	pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
 	pkgdb_debug(4, stmt);
 	return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));
 }

@@ -179,13 +179,13 @@ pkg_repo_binary_shlib_provide(struct pkg_repo *repo, const char *require)

 	xasprintf(&sql, basesql, repo->name);
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	stmt = prepare_sql(sqlite, sql);
 	free(sql);
 	if (stmt == NULL)
 		return (NULL);
 	sqlite3_bind_text(stmt, 1, require, -1, SQLITE_TRANSIENT);
 	pkgdb_debug(4, stmt);
 	return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));
 }

@@ -209,13 +209,13 @@ pkg_repo_binary_provide(struct pkg_repo *repo, const char *require)

 	xasprintf(&sql, basesql, repo->name);
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	stmt = prepare_sql(sqlite, sql);
 	free(sql);
 	if (stmt == NULL)
 		return (NULL);
 	sqlite3_bind_text(stmt, 1, require, -1, SQLITE_TRANSIENT);
 	pkgdb_debug(4, stmt);
 	return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));
 }

@@ -238,7 +238,6 @@ pkg_repo_binary_shlib_require(struct pkg_repo *repo, const char *provide)

 	xasprintf(&sql, basesql, repo->name);
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	stmt = prepare_sql(sqlite, sql);
 	free(sql);
 	if (stmt == NULL)

@@ -246,6 +245,7 @@ pkg_repo_binary_shlib_require(struct pkg_repo *repo, const char *provide)

 	pkg_debug(1, "> loading provides");
 	sqlite3_bind_text(stmt, 1, provide, -1, SQLITE_TRANSIENT);
 	pkgdb_debug(4, stmt);
 	return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));
 }

@@ -268,13 +268,13 @@ pkg_repo_binary_require(struct pkg_repo *repo, const char *provide)

 	xasprintf(&sql, basesql, repo->name);
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	stmt = prepare_sql(sqlite, sql);
 	free(sql);
 	if (stmt == NULL)
 		return (NULL);
 	sqlite3_bind_text(stmt, 1, provide, -1, SQLITE_TRANSIENT);
 	pkgdb_debug(4, stmt);
 	return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));
 }

@@ -418,7 +418,7 @@ pkg_repo_binary_search(struct pkg_repo *repo, const char *pattern, match_t match

 		return (NULL);
 	sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT);
 	pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
 	pkgdb_debug(4, stmt);
 	return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));
 }