8a45247 Fix issues with update and prepared statements. — HardenedBSD-pkg

HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

Fix issues with update and prepared statements.

Vsevolod Stakhov committed 11 years ago

commit 8a45247a6e4ef666fc2d4f025d5207e9a9b70f4b
parent 4e63930

5 files changed +207 -169

modified libpkg/repo/binary/binary_private.h

@@ -510,113 +510,11 @@ typedef enum _sql_prstmt_index {

 	PRSTMT_LAST,
 } sql_prstmt_index;
 static sql_prstmt sql_prepared_statements[PRSTMT_LAST] = {
 	[PKG] = {
 		NULL,
 		"INSERT INTO packages ("
 		"origin, name, version, comment, desc, arch, maintainer, www, "
 		"prefix, pkgsize, flatsize, licenselogic, cksum, path, manifestdigest, olddigest"
 		")"
 		"VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16)",
 		"TTTTTTTTTIIITTTT",
 	},
 	[DEPS] = {
 		NULL,
 		"INSERT INTO deps (origin, name, version, package_id) "
 		"VALUES (?1, ?2, ?3, ?4)",
 		"TTTI",
 	},
 	[CAT1] = {
 		NULL,
 		"INSERT OR IGNORE INTO categories(name) VALUES(?1)",
 		"T",
 	},
 	[CAT2] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_categories(package_id, category_id) "
 		"VALUES (?1, (SELECT id FROM categories WHERE name = ?2))",
 		"IT",
 	},
 	[LIC1] = {
 		NULL,
 		"INSERT OR IGNORE INTO licenses(name) VALUES(?1)",
 		"T",
 	},
 	[LIC2] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_licenses(package_id, license_id) "
 		"VALUES (?1, (SELECT id FROM licenses WHERE name = ?2))",
 		"IT",
 	},
 	[OPT1] = {
 		NULL,
 		"INSERT OR IGNORE INTO option(option) "
 		"VALUES (?1)",
 		"T",
 	},
 	[OPT2] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_option (option_id, value, package_id) "
 		"VALUES (( SELECT option_id FROM option WHERE option = ?1), ?2, ?3)",
 		"TTI",
 	},
 	[SHLIB1] = {
 		NULL,
 		"INSERT OR IGNORE INTO shlibs(name) VALUES(?1)",
 		"T",
 	},
 	[SHLIB_REQD] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_shlibs_required(package_id, shlib_id) "
 		"VALUES (?1, (SELECT id FROM shlibs WHERE name = ?2))",
 		"IT",
 	},
 	[SHLIB_PROV] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_shlibs_provided(package_id, shlib_id) "
 		"VALUES (?1, (SELECT id FROM shlibs WHERE name = ?2))",
 		"IT",
 	},
 	[EXISTS] = {
 		NULL,
 		"SELECT count(*) FROM packages WHERE cksum=?1",
 		"T",
 	},
 	[ANNOTATE1] = {
 		NULL,
 		"INSERT OR IGNORE INTO annotation(annotation) "
 		"VALUES (?1)",
 		"T",
 	},
 	[ANNOTATE2] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_annotation(package_id, tag_id, value_id) "
 		"VALUES (?1,"
 		" (SELECT annotation_id FROM annotation WHERE annotation=?2),"
 		" (SELECT annotation_id FROM annotation WHERE annotation=?3))",
 		"ITT",
 	},
 	[VERSION] = {
 		NULL,
 		"SELECT version FROM packages WHERE origin=?1",
 		"T",
 	},
 	[DELETE] = {
 		NULL,
 		"DELETE FROM packages WHERE origin=?1;"
 		"DELETE FROM pkg_search WHERE origin=?1;",
 		"TT",
 	},
 	[FTS_APPEND] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_search(id, name, origin) "
 		"VALUES (?1, ?2 || '-' || ?3, ?4);",
 		"ITTT"
 	}
 	/* PRSTMT_LAST */
 };
 int pkg_repo_binary_init_prstatements(sqlite3 *sqlite);
 int pkg_repo_binary_run_prstatement(sql_prstmt_index s, ...);
 const char * pkg_repo_binary_sql_prstatement(sql_prstmt_index s);
 sqlite3_stmt* pkg_repo_binary_stmt_prstatement(sql_prstmt_index s);
 void pkg_repo_binary_finalize_prstatements(void);
 /*
  * Warning: returns a pointer to static array
  */

modified libpkg/repo/binary/common.c

@@ -35,6 +35,149 @@

 #include "private/utils.h"
 #include "binary_private.h"
 static sql_prstmt sql_prepared_statements[PRSTMT_LAST] = {
 	[PKG] = {
 		NULL,
 		"INSERT INTO packages ("
 		"origin, name, version, comment, desc, arch, maintainer, www, "
 		"prefix, pkgsize, flatsize, licenselogic, cksum, path, manifestdigest, olddigest"
 		")"
 		"VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16)",
 		"TTTTTTTTTIIITTTT",
 	},
 	[DEPS] = {
 		NULL,
 		"INSERT INTO deps (origin, name, version, package_id) "
 		"VALUES (?1, ?2, ?3, ?4)",
 		"TTTI",
 	},
 	[CAT1] = {
 		NULL,
 		"INSERT OR IGNORE INTO categories(name) VALUES(?1)",
 		"T",
 	},
 	[CAT2] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_categories(package_id, category_id) "
 		"VALUES (?1, (SELECT id FROM categories WHERE name = ?2))",
 		"IT",
 	},
 	[LIC1] = {
 		NULL,
 		"INSERT OR IGNORE INTO licenses(name) VALUES(?1)",
 		"T",
 	},
 	[LIC2] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_licenses(package_id, license_id) "
 		"VALUES (?1, (SELECT id FROM licenses WHERE name = ?2))",
 		"IT",
 	},
 	[OPT1] = {
 		NULL,
 		"INSERT OR IGNORE INTO option(option) "
 		"VALUES (?1)",
 		"T",
 	},
 	[OPT2] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_option (option_id, value, package_id) "
 		"VALUES (( SELECT option_id FROM option WHERE option = ?1), ?2, ?3)",
 		"TTI",
 	},
 	[SHLIB1] = {
 		NULL,
 		"INSERT OR IGNORE INTO shlibs(name) VALUES(?1)",
 		"T",
 	},
 	[SHLIB_REQD] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_shlibs_required(package_id, shlib_id) "
 		"VALUES (?1, (SELECT id FROM shlibs WHERE name = ?2))",
 		"IT",
 	},
 	[SHLIB_PROV] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_shlibs_provided(package_id, shlib_id) "
 		"VALUES (?1, (SELECT id FROM shlibs WHERE name = ?2))",
 		"IT",
 	},
 	[EXISTS] = {
 		NULL,
 		"SELECT count(*) FROM packages WHERE cksum=?1",
 		"T",
 	},
 	[ANNOTATE1] = {
 		NULL,
 		"INSERT OR IGNORE INTO annotation(annotation) "
 		"VALUES (?1)",
 		"T",
 	},
 	[ANNOTATE2] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_annotation(package_id, tag_id, value_id) "
 		"VALUES (?1,"
 		" (SELECT annotation_id FROM annotation WHERE annotation=?2),"
 		" (SELECT annotation_id FROM annotation WHERE annotation=?3))",
 		"ITT",
 	},
 	[VERSION] = {
 		NULL,
 		"SELECT version FROM packages WHERE origin=?1",
 		"T",
 	},
 	[DELETE] = {
 		NULL,
 		"DELETE FROM packages WHERE origin=?1;"
 		"DELETE FROM pkg_search WHERE origin=?1;",
 		"TT",
 	},
 	[FTS_APPEND] = {
 		NULL,
 		"INSERT OR ROLLBACK INTO pkg_search(id, name, origin) "
 		"VALUES (?1, ?2 || '-' || ?3, ?4);",
 		"ITTT"
 	}
 	/* PRSTMT_LAST */
 };
 const char *
 pkg_repo_binary_sql_prstatement(sql_prstmt_index s)
 {
 	if (s < PRSTMT_LAST)
 		return (sql_prepared_statements[s].sql);
 	else
 		return ("unknown");
 }
 sqlite3_stmt*
 pkg_repo_binary_stmt_prstatement(sql_prstmt_index s)
 {
 	if (s < PRSTMT_LAST)
 		return (sql_prepared_statements[s].stmt);
 	else
 		return (NULL);
 }
 int
 pkg_repo_binary_init_prstatements(sqlite3 *sqlite)
 {
 	sql_prstmt_index i, last;
 	int ret;
 	last = PRSTMT_LAST;
 	for (i = 0; i < last; i++) {
 		ret = sqlite3_prepare_v2(sqlite, SQL(i), -1, &STMT(i), NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(sqlite, SQL(i));
 			return (EPKG_FATAL);
 		}
 	}
 	return (EPKG_OK);
 }
 int
 pkg_repo_binary_run_prstatement(sql_prstmt_index s, ...)
 {

@@ -82,3 +225,20 @@ pkg_repo_binary_get_filename(const char *name)

 	return (reponame);
 }
 void
 pkg_repo_binary_finalize_prstatements(void)
 {
 	sql_prstmt_index i, last;
 	last = PRSTMT_LAST;
 	for (i = 0; i < last; i++)
 	{
 		if (STMT(i) != NULL) {
 			sqlite3_finalize(STMT(i));
 			STMT(i) = NULL;
 		}
 	}
 	return;
 }

modified libpkg/repo/binary/init.c

@@ -95,42 +95,6 @@ pkg_repo_binary_get_user_version(sqlite3 *sqlite, int *reposcver)

 }
 static int
 pkg_repo_binary_init_prstatements(sqlite3 *sqlite)
 {
 	sql_prstmt_index i, last;
 	int ret;
 	last = PRSTMT_LAST;
 	for (i = 0; i < last; i++) {
 		ret = sqlite3_prepare_v2(sqlite, SQL(i), -1, &STMT(i), NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(sqlite, SQL(i));
 			return (EPKG_FATAL);
 		}
 	}
 	return (EPKG_OK);
 }
 void
 pkg_repo_binary_finalize_prstatements(void)
 {
 	sql_prstmt_index i, last;
 	last = PRSTMT_LAST;
 	for (i = 0; i < last; i++)
 	{
 		if (STMT(i) != NULL) {
 			sqlite3_finalize(STMT(i));
 			STMT(i) = NULL;
 		}
 	}
 	return;
 }
 static int
 pkg_repo_binary_set_version(sqlite3 *sqlite, int reposcver)
 {
 	int		 retcode = EPKG_OK;

@@ -409,7 +373,7 @@ pkg_repo_binary_create(struct pkg_repo *repo)

 	snprintf(filepath, sizeof(filepath), "%s/%s",
 		dbdir, pkg_repo_binary_get_filename(pkg_repo_name(repo)));
 	/* Should never ever happen */
 	if (access(filepath, R_OK) != 0)
 	if (access(filepath, R_OK) == 0)
 		return (EPKG_CONFLICT);
 	/* Open for read/write/create */

@@ -475,12 +439,12 @@ pkg_repo_binary_init(struct pkg_repo *repo)

 	if (retcode != EPKG_OK)
 		return (retcode);
 	pkgdb_sqlcmd_init(sqlite, NULL, NULL);
 	retcode = pkg_repo_binary_init_prstatements(sqlite);
 	if (retcode != EPKG_OK)
 		return (retcode);
 	pkgdb_sqlcmd_init(sqlite, NULL, NULL);
 	repo->priv = sqlite;
 	return (EPKG_OK);

modified libpkg/repo/binary/query.c

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

 		"SELECT id, origin, name, version, comment, "
 		"prefix, desc, arch, maintainer, www, "
 		"licenselogic, flatsize, pkgsize, "
 		"cksum, path, '%1$s' AS dbname "
 		"cksum, path AS repopath, '%1$s' AS dbname "
 		"FROM packages ";
 	assert(pattern != NULL && pattern[0] != '\0');

modified libpkg/repo/binary/update.c

@@ -57,7 +57,7 @@ pkg_repo_binary_delete_conflicting(const char *origin, const char *version,

 	if (pkg_repo_binary_run_prstatement(VERSION, origin) != SQLITE_ROW)
 		return (EPKG_FATAL); /* sqlite error */
 	oversion = sqlite3_column_text(STMT(VERSION), 0);
 	oversion = sqlite3_column_text(pkg_repo_binary_stmt_prstatement(VERSION), 0);
 	if (!forced) {
 		switch(pkg_version_cmp(oversion, version)) {
 		case -1:

@@ -125,7 +125,7 @@ try_again:

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

@@ -136,7 +136,7 @@ try_again:

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

@@ -144,7 +144,7 @@ try_again:

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

@@ -155,7 +155,7 @@ try_again:

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

@@ -168,7 +168,7 @@ try_again:

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

@@ -180,7 +180,7 @@ try_again:

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

@@ -191,7 +191,7 @@ try_again:

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

@@ -205,7 +205,7 @@ try_again:

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

@@ -219,7 +219,7 @@ try_again:

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

@@ -236,7 +236,7 @@ try_again:

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

@@ -479,6 +479,7 @@ pkg_repo_binary_get_origins(sqlite3 *sqlite)

 		"FROM packages "
 		"ORDER BY origin;";
 	pkg_debug(4, "binary_repo: running '%s'", query_sql);
 	ret = sqlite3_prepare_v2(sqlite, query_sql, -1,
 			&stmt, NULL);
 	if (ret != SQLITE_OK) {

@@ -520,12 +521,6 @@ pkg_repo_binary_update_incremental(const char *name, struct pkg_repo *repo,

 	pkg_debug(1, "Pkgrepo, begin incremental update of '%s'", name);
 	stmt = pkg_repo_binary_get_origins(sqlite);
 	if (stmt == NULL) {
 		rc = EPKG_FATAL;
 		goto cleanup;
 	}
 	if (pkg_repo_fetch_meta(repo, NULL) == EPKG_FATAL)
 		pkg_emit_notice("repository %s has no meta file, using "
 		    "default settings", repo->name);

@@ -578,13 +573,22 @@ pkg_repo_binary_update_incremental(const char *name, struct pkg_repo *repo,

 	fseek(fdigests, 0, SEEK_SET);
 	/* Load local repo data */
 	stmt = pkg_repo_binary_get_origins(sqlite);
 	if (stmt == NULL) {
 		rc = EPKG_FATAL;
 		goto cleanup;
 	}
 	fakedb.sqlite = sqlite;
 	it = pkgdb_it_new_sqlite(&fakedb, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE);
 	while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == EPKG_OK) {
 		pkg_get(pkg, PKG_ORIGIN, &origin, legacy_repo ? PKG_OLD_DIGEST : PKG_DIGEST,
 				&digest);
 		pkg_repo_binary_update_item_new(&ldel, origin, digest, 4, 0);
 	if (it != NULL) {
 		while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == EPKG_OK) {
 			pkg_get(pkg, PKG_ORIGIN, &origin, legacy_repo ? PKG_OLD_DIGEST : PKG_DIGEST,
 							&digest);
 			pkg_repo_binary_update_item_new(&ldel, origin, digest, 4, 0);
 		}
 		pkgdb_it_free(it);
 	}
 	pkg_debug(1, "Pkgrepo, reading new packagesite.yaml for '%s'", name);

@@ -723,8 +727,6 @@ cleanup:

 	if (pkg != NULL)
 		pkg_free(pkg);
 	if (it != NULL)
 		pkgdb_it_free(it);
 	if (map == MAP_FAILED && fmanifest)
 		fclose(fmanifest);
 	if (fdigests)

@@ -790,6 +792,20 @@ pkg_repo_binary_update(struct pkg_repo *repo, bool force)

 			}
 		}
 	}
 	else {
 		/* [Re]create repo */
 		unlink(filepath);
 		if (repo->ops->create(repo) != EPKG_OK) {
 			pkg_emit_notice("Unable to create repository %s", repo->name);
 			goto cleanup;
 		}
 		if (repo->ops->open(repo, R_OK|W_OK) != EPKG_OK) {
 			pkg_emit_notice("Unable to open created repository %s", repo->name);
 			goto cleanup;
 		}
 	}
 	repo->ops->init(repo);
 	res = pkg_repo_binary_update_incremental(filepath, repo, &t);
 	if (res != EPKG_OK && res != EPKG_UPTODATE) {