ffa5b3d Merge remote-tracking branch 'upstream/master' — HardenedBSD-pkg

HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

Merge remote-tracking branch 'upstream/master'

Shawn Webb committed 2 years ago

commit ffa5b3dbdcce41310c4a4045bf0a4002b5ed8c17
parent c608efa

6 files changed +37 -656

modified libpkg/pkgdb.c

@@ -848,11 +848,21 @@ pkgdb_open_repos(struct pkgdb *db, const char *reponame)

 static const char*
 _dbdir_trim_path(const char*path)
 {
 	const char *p = strrchr(path, '/');
 	static size_t l = 0;
 	const char *p;
 	if(p == NULL)
 		return (path);
 	return (p + 1);
 	if (l == 0)
 		l = strlen(ctx.dbdir);
 	if (strncmp(ctx.dbdir, path, l) == 0) {
 		p = path + l;
 		while (*p == '/')
 			p++;
 		return (p);
 	}
 	if (*path == '/')
 		return (path + 1);
 	return (path);
 }
 static int

modified libpkg/private/pkg.h

@@ -557,6 +557,7 @@ struct pkg_repo {

 	ip_version_t ip;
 	kvlist_t env;
 	int dfd;
 	char *dbpath;
 	/* Opaque repository data */
 	void *priv;

modified libpkg/repo/binary/binary_private.h

@@ -187,446 +187,6 @@ static const char binary_repo_initsql[] = ""

 	"PRAGMA user_version=%d;"
 	;
 struct repo_changes {
 	int version;		/* The repo schema this change applies to */
 	int next_version;	/* The repo schema this change creates */
 	const char *message;
 	const char *sql;
 };
 /* How to upgrade an older repo to match what the current system
    expects */
 static const struct repo_changes repo_upgrades[] = {
 	{2001,
 ,
 	 "Modify shlib tracking to add \'provided\' capability",
 	 "CREATE TABLE pkg_shlibs_required ("
 		"package_id INTEGER NOT NULL REFERENCES packages(id)"
 		" ON DELETE CASCADE ON UPDATE CASCADE,"
 		"shlib_id INTEGER NOT NULL REFERENCES shlibs(id)"
 		" ON DELETE RESTRICT ON UPDATE RESTRICT,"
 		"UNIQUE (package_id, shlib_id)"
 	 ");"
 	 "CREATE TABLE pkg_shlibs_provided ("
 		"package_id INTEGER NOT NULL REFERENCES packages(id)"
 		" ON DELETE CASCADE ON UPDATE CASCADE,"
 		"shlib_id INTEGER NOT NULL REFERENCES shlibs(id)"
 		" ON DELETE RESTRICT ON UPDATE RESTRICT,"
 		"UNIQUE (package_id, shlib_id)"
 	 ");"
 	 "INSERT INTO pkg_shlibs_required (package_id, shlib_id)"
 		" SELECT package_id, shlib_id FROM pkg_shlibs;"
 	 "DROP TABLE pkg_shlibs;"
 	},
 	{2002,
 ,
 	 "Add abstract metadata capability",
 	 "CREATE TABLE abstract ("
 		"abstract_id INTEGER PRIMARY KEY,"
 		"abstract TEXT NOT NULL UNIQUE"
 	 ");"
 	 "CREATE TABLE pkg_abstract ("
 		"package_id INTEGER REFERENCES packages(id)"
 		" ON DELETE CASCADE ON UPDATE RESTRICT,"
 		"key_id INTEGER NOT NULL REFERENCES abstract(abstract_id)"
 		" ON DELETE CASCADE ON UPDATE RESTRICT,"
 		"value_id INTEGER NOT NULL REFERENCES abstract(abstract_id)"
 		" ON DELETE CASCADE ON UPDATE RESTRICT"
 	 ");"
 	},
 	{2003,
 ,
 	"Add manifest digest field",
 	"ALTER TABLE packages ADD COLUMN manifestdigest TEXT NULL;"
 	"CREATE INDEX IF NOT EXISTS pkg_digest_id ON packages(origin, manifestdigest);"
 	},
 	{2004,
 ,
 	 "Rename 'abstract metadata' to 'annotations'",
 	 "CREATE TABLE annotation ("
 	        "annotation_id INTEGER PRIMARY KEY,"
 	        "annotation TEXT NOT NULL UNIQUE"
 	 ");"
 	 "CREATE TABLE pkg_annotation ("
 	        "package_id INTEGER REFERENCES packages(id)"
 	        " ON DELETE CASCADE ON UPDATE RESTRICT,"
 	        "tag_id INTEGER NOT NULL REFERENCES annotation(annotation_id)"
 	        " ON DELETE CASCADE ON UPDATE RESTRICT,"
 	        "value_id INTEGER NOT NULL REFERENCES annotation(annotation_id)"
 	        " ON DELETE CASCADE ON UPDATE RESTRICT,"
 	        "UNIQUE (package_id, tag_id)"
 	 ");"
 	 "INSERT INTO annotation (annotation_id, annotation)"
 	        " SELECT abstract_id, abstract FROM abstract;"
 	 "INSERT INTO pkg_annotation (package_id,tag_id,value_id)"
 	        " SELECT package_id,key_id,value_id FROM pkg_abstract;"
 	 "DROP TABLE pkg_abstract;"
 	 "DROP TABLE abstract;"
 	},
 	{2005,
 ,
 	 "Add capability to track option descriptions and defaults",
 	 "CREATE TABLE option ("
 		"option_id INTEGER PRIMARY KEY,"
 		"option TEXT NOT NULL UNIQUE"
 	 ");"
 	 "CREATE TABLE option_desc ("
 		"option_desc_id INTEGER PRIMARY KEY,"
 		"option_desc TEXT NOT NULL UNIQUE"
 	 ");"
 	 "CREATE TABLE pkg_option ("
 		"package_id INTEGER NOT NULL REFERENCES packages(id) "
 			"ON DELETE CASCADE ON UPDATE CASCADE,"
 		"option_id INTEGER NOT NULL REFERENCES option(option_id) "
 			"ON DELETE RESTRICT ON UPDATE CASCADE,"
 		"value TEXT NOT NULL,"
 		"PRIMARY KEY(package_id, option_id)"
 	 ");"
 	 "CREATE TABLE pkg_option_desc ("
 		"package_id INTEGER NOT NULL REFERENCES packages(id) "
 			"ON DELETE CASCADE ON UPDATE CASCADE,"
 		"option_id INTEGER NOT NULL REFERENCES option(option_id) "
 			"ON DELETE RESTRICT ON UPDATE CASCADE,"
 		"option_desc_id INTEGER NOT NULL "
 			"REFERENCES option_desc(option_desc_id) "
 			"ON DELETE RESTRICT ON UPDATE CASCADE,"
 		"PRIMARY KEY(package_id, option_id)"
 	 ");"
 	 "CREATE TABLE pkg_option_default ("
 		"package_id INTEGER NOT NULL REFERENCES packages(id) "
 			"ON DELETE CASCADE ON UPDATE CASCADE,"
 		"option_id INTEGER NOT NULL REFERENCES option(option_id) "
 			"ON DELETE RESTRICT ON UPDATE CASCADE,"
 		"default_value TEXT NOT NULL,"
 		"PRIMARY KEY(package_id, option_id)"
 	 ");"
 	 "INSERT INTO option (option) "
 		"SELECT DISTINCT option FROM options;"
 	 "INSERT INTO pkg_option(package_id, option_id, value) "
 		"SELECT package_id, option_id, value "
 		"FROM options oo JOIN option o "
 			"ON (oo.option = o.option);"
 	 "DROP TABLE options;",
 	},
 	{2006,
 ,
 	 "Add conflicts and provides",
 	"CREATE TABLE pkg_conflicts ("
 	    "package_id INTEGER NOT NULL REFERENCES packages(id)"
 	    "  ON DELETE CASCADE ON UPDATE CASCADE,"
 	    "conflict_id INTEGER NOT NULL,"
 	    "UNIQUE(package_id, conflict_id)"
 	");"
 	"CREATE TABLE provides("
 	"    id INTEGER PRIMARY KEY,"
 	"    provide TEXT NOT NULL"
 	");"
 	"CREATE TABLE pkg_provides ("
 	    "package_id INTEGER NOT NULL REFERENCES packages(id)"
 	    "  ON DELETE CASCADE ON UPDATE CASCADE,"
 	    "provide_id INTEGER NOT NULL REFERENCES provides(id)"
 	    "  ON DELETE RESTRICT ON UPDATE RESTRICT,"
 	    "UNIQUE(package_id, provide_id)"
 	");"
 	},
 	{2007,
 ,
 	 "Add FTS index",
 	 "CREATE VIRTUAL TABLE pkg_search USING fts4(id, name, origin);"
 	 "INSERT INTO pkg_search SELECT id, name || '-' || version, origin FROM packages;"
 	 "CREATE INDEX packages_origin ON packages(origin COLLATE NOCASE);"
 	 "CREATE INDEX packages_name ON packages(name COLLATE NOCASE);"
 	},
 	{2008,
 ,
 	 "Optimize indicies",
 	 "CREATE INDEX IF NOT EXISTS packages_uid_nocase ON packages(name COLLATE NOCASE, origin COLLATE NOCASE);"
 	 "CREATE INDEX IF NOT EXISTS packages_version_nocase ON packages(name COLLATE NOCASE, version);"
 	 "CREATE INDEX IF NOT EXISTS packages_uid ON packages(name, origin);"
 	 "CREATE INDEX IF NOT EXISTS packages_version ON packages(name, version);"
 	 "CREATE UNIQUE INDEX IF NOT EXISTS packages_digest ON packages(manifestdigest);"
 	},
 	{2009,
 ,
 	 "Add legacy digest field",
 	 "ALTER TABLE packages ADD COLUMN olddigest TEXT NULL;"
 	 "UPDATE packages SET olddigest=manifestdigest WHERE olddigest=NULL;"
 	},
 	/* XXX: no 2011 migration! */
 	{2011,
 ,
 	 "Add depends formula field",
 	 "ALTER TABLE packages ADD COLUMN dep_formula TEXT NULL;"
 	},
 	{2012,
 ,
 	 "Add vital field",
 	 "ALTER TABLE packages ADD COLUMN vital INTEGER NOT NULL DEFAULT 0;"
 	},
 	{2013,
 ,
 	 "Drop 'pkg_search'",
 	 "DROP TABLE pkg_search;"
 	},
 	/* Mark the end of the array */
 	{ -1, -1, NULL, NULL, }
 };
 /* How to downgrade a newer repo to match what the current system
    expects */
 static const struct repo_changes repo_downgrades[] = {
 	{2013,
 ,
 	 "Drop vital column",
 	 "ALTER TABLE packages RENAME TO packages_old;"
 	 "CREATE TABLE packages ("
 		"id INTEGER PRIMARY KEY,"
 		"origin TEXT UNIQUE,"
 		"name TEXT NOT NULL,"
 		"version TEXT NOT NULL,"
 		"comment TEXT NOT NULL,"
 		"desc TEXT NOT NULL,"
 		"osversion TEXT,"
 		"arch TEXT NOT NULL,"
 		"maintainer TEXT NOT NULL,"
 		"www TEXT,"
 		"prefix TEXT NOT NULL,"
 		"pkgsize INTEGER NOT NULL,"
 		"flatsize INTEGER NOT NULL,"
 		"licenselogic INTEGER NOT NULL,"
 		"cksum TEXT NOT NULL,"
 		"path TEXT NOT NULL,"
 		"pkg_format_version INTEGER,"
 		"manifestdigest TEXT NULL,"
 		"olddigest TEXT NULL,"
 		"dep_formula TEXT NULL,"
 	");"
 	"INSERT INTO packages (id, origin, name, version, comment, desc,"
 	"osversion, arch, maintainer, www, prefix, pkgsize, flatsize,"
 	"licenselogic, cksum, path, pkg_format_version, manifestdigest, olddigest) "
 	"SELECT id, origin, name, version, comment, desc,"
 	"osversion, arch, maintainer, www, prefix, pkgsize, flatsize,"
 	"licenselogic, cksum, path, pkg_format_version, manifestdigest, olddigest FROM "
 	"packages_old;"
 	"DROP TABLE packages_old;"
 	"CREATE INDEX packages_origin ON packages(origin COLLATE NOCASE);"
 	"CREATE INDEX packages_name ON packages(name COLLATE NOCASE);"
 	"CREATE INDEX packages_uid_nocase ON packages(name COLLATE NOCASE, origin COLLATE NOCASE);"
 	"CREATE INDEX packages_version_nocase ON packages(name COLLATE NOCASE, version);"
 	"CREATE INDEX packages_uid ON packages(name, origin);"
 	"CREATE INDEX packages_version ON packages(name, version);"
 	"CREATE UNIQUE INDEX packages_digest ON packages(manifestdigest);"
 	},
 	{2012,
 ,
 	 "Drop dep_formula field",
 	 "ALTER TABLE packages RENAME TO packages_old;"
 	 "CREATE TABLE packages ("
 		"id INTEGER PRIMARY KEY,"
 		"origin TEXT UNIQUE,"
 		"name TEXT NOT NULL,"
 		"version TEXT NOT NULL,"
 		"comment TEXT NOT NULL,"
 		"desc TEXT NOT NULL,"
 		"osversion TEXT,"
 		"arch TEXT NOT NULL,"
 		"maintainer TEXT NOT NULL,"
 		"www TEXT,"
 		"prefix TEXT NOT NULL,"
 		"pkgsize INTEGER NOT NULL,"
 		"flatsize INTEGER NOT NULL,"
 		"licenselogic INTEGER NOT NULL,"
 		"cksum TEXT NOT NULL,"
 		"path TEXT NOT NULL,"
 		"pkg_format_version INTEGER,"
 		"manifestdigest TEXT NULL,"
 		"olddigest TEXT NULL,"
 	");"
 	"INSERT INTO packages (id, origin, name, version, comment, desc,"
 	"osversion, arch, maintainer, www, prefix, pkgsize, flatsize,"
 	"licenselogic, cksum, path, pkg_format_version, manifestdigest, olddigest) "
 	"SELECT id, origin, name, version, comment, desc,"
 	"osversion, arch, maintainer, www, prefix, pkgsize, flatsize,"
 	"licenselogic, cksum, path, pkg_format_version, manifestdigest, olddigest FROM "
 	"packages_old;"
 	"DROP TABLE packages_old;"
 	"CREATE INDEX packages_origin ON packages(origin COLLATE NOCASE);"
 	"CREATE INDEX packages_name ON packages(name COLLATE NOCASE);"
 	"CREATE INDEX packages_uid_nocase ON packages(name COLLATE NOCASE, origin COLLATE NOCASE);"
 	"CREATE INDEX packages_version_nocase ON packages(name COLLATE NOCASE, version);"
 	"CREATE INDEX packages_uid ON packages(name, origin);"
 	"CREATE INDEX packages_version ON packages(name, version);"
 	"CREATE UNIQUE INDEX packages_digest ON packages(manifestdigest);"
 	},
 	/* XXX: no 2011 migration! */
 	{2010,
 ,
 	 "Drop olddigest field",
 	 "ALTER TABLE packages RENAME TO packages_old;"
 	 "CREATE TABLE packages ("
 	    "id INTEGER PRIMARY KEY,"
 	    "origin TEXT UNIQUE,"
 	    "name TEXT NOT NULL,"
 	    "version TEXT NOT NULL,"
 	    "comment TEXT NOT NULL,"
 	    "desc TEXT NOT NULL,"
 	    "osversion TEXT,"
 	    "arch TEXT NOT NULL,"
 	    "maintainer TEXT NOT NULL,"
 	    "www TEXT,"
 	    "prefix TEXT NOT NULL,"
 	    "pkgsize INTEGER NOT NULL,"
 	    "flatsize INTEGER NOT NULL,"
 	    "licenselogic INTEGER NOT NULL,"
 	    "cksum TEXT NOT NULL,"
 	    "path TEXT NOT NULL,"
 	    "pkg_format_version INTEGER,"
 	    "manifestdigest TEXT NULL,"
 	");"
 	"INSERT INTO packages (id, origin, name, version, comment, desc,"
 	"osversion, arch, maintainer, www, prefix, pkgsize, flatsize,"
 	"licenselogic, cksum, path, pkg_format_version, manifestdigest) "
 	"SELECT id, origin, name, version, comment, desc,"
 	"osversion, arch, maintainer, www, prefix, pkgsize, flatsize,"
 	"licenselogic, cksum, path, pkg_format_version, manifestdigest FROM "
 	"packages_old;"
 	"DROP TABLE packages_old;"
 	"CREATE INDEX packages_origin ON packages(origin COLLATE NOCASE);"
 	"CREATE INDEX packages_name ON packages(name COLLATE NOCASE);"
 	"CREATE INDEX packages_uid_nocase ON packages(name COLLATE NOCASE, origin COLLATE NOCASE);"
 	"CREATE INDEX packages_version_nocase ON packages(name COLLATE NOCASE, version);"
 	"CREATE INDEX packages_uid ON packages(name, origin);"
 	"CREATE INDEX packages_version ON packages(name, version);"
 	"CREATE UNIQUE INDEX packages_digest ON packages(manifestdigest);"
 	},
 	{2009,
 ,
 	 "Drop indicies",
 	 "DROP INDEX packages_uid_nocase;"
 	 "DROP INDEX packages_version_nocase;"
 	 "DROP INDEX packages_uid;"
 	 "DROP INDEX packages_version;"
 	 "DROP INDEX packages_digest;"
 	},
 	{2008,
 ,
 	 "Drop FTS index",
 	 "DROP TABLE pkg_search;"
 	},
 	{2007,
 ,
 	 "Revert conflicts and provides creation",
 	 "DROP TABLE pkg_provides;"
 	 "DROP TABLE provides;"
 	 "DROP TABLE conflicts;"
 	},
 	{2006,
 ,
 	 "Revert addition of extra options related data",
 	 "CREATE TABLE options ("
 		"package_id INTEGER REFERENCES packages(id) "
 			"ON DELETE CASCADE ON UPDATE CASCADE,"
 		"option TEXT,"
 		"value TEXT,"
 		"PRIMARY KEY(package_id,option)"
 	 ");"
 	 "INSERT INTO options (package_id, option, value) "
 		 "SELECT package_id, option, value "
 		"FROM pkg_option JOIN option USING(option_id);"
 	 "DROP TABLE pkg_option;"
 	 "DROP TABLE pkg_option_default;"
 	 "DROP TABLE option;"
 	 "DROP TABLE pkg_option_desc;"
 	 "DROP TABLE option_desc;",
 	},
 	{2005,
 ,
 	 "Revert rename of 'abstract metadata' to 'annotations'",
 	 "CREATE TABLE abstract ("
 	        "abstract_id INTEGER PRIMARY KEY,"
 	        "abstract TEXT NOT NULL UNIQUE"
 	 ");"
 	 "CREATE TABLE pkg_abstract ("
 	        "package_id INTEGER REFERENCES packages(id)"
 	        " ON DELETE CASCADE ON UPDATE RESTRICT,"
 	        "key_id INTEGER NOT NULL REFERENCES abstract(abstract_id)"
 	        " ON DELETE CASCADE ON UPDATE RESTRICT,"
 	        "value_id INTEGER NOT NULL REFERENCES abstract(abstract_id)"
 	        " ON DELETE CASCADE ON UPDATE RESTRICT"
 	 ");"
 	 "INSERT INTO abstract (abstract_id, abstract)"
 	        " SELECT annotation_id, annotation FROM annotation;"
 	 "INSERT INTO pkg_abstract (package_id,key_id,value_id)"
 	        " SELECT package_id,tag_id,value_id FROM pkg_annotation;"
 	 "DROP TABLE pkg_annotation;"
 	 "DROP TABLE annotation;"
 	},
 	{2004,
 ,
 	 "Drop manifest digest index",
 	 "DROP INDEX pkg_digest_id;"
 	},
 	{2003,
 ,
 	 "Drop abstract metadata",
 	 "DROP TABLE pkg_abstract;"
 	 "DROP TABLE abstract;"
 	},
 	{2002,
 ,
 	 "Drop \'shlibs provided\' but retain \'shlibs required\'",
 	 "CREATE TABLE pkg_shlibs_required ("
 		"package_id INTEGER NOT NULL REFERENCES packages(id)"
 		" ON DELETE CASCADE ON UPDATE CASCADE,"
 		"shlib_id INTEGER NOT NULL REFERENCES shlibs(id)"
 		" ON DELETE RESTRICT ON UPDATE RESTRICT,"
 		"UNIQUE (package_id, shlib_id)"
 	 ");"
 	 "CREATE TABLE pkg_shlibs ("
 		"package_id INTEGER REFERENCES packages(id)"
 		" ON DELETE CASCADE ON UPDATE CASCADE,"
 		"shlib_id INTEGER REFERENCES shlibs(id)"
 		" ON DELETE RESTRICT ON UPDATE RESTRICT,"
 		"PRIMARY KEY (package_id, shlib_id)"
 	 ");"
 	 "INSERT INTO pkg_shlibs (package_id, shlib_id)"
 		" SELECT package_id, shlib_id FROM pkg_shlibs_required;"
 	 "DELETE FROM shlibs WHERE id NOT IN"
 		" (SELECT shlib_id FROM pkg_shlibs);"
 	 "DROP TABLE pkg_shlibs_provided;"
 	 "DROP TABLE pkg_shlibs_required;"
 	},
 	/* Mark the end of the array */
 	{ -1, -1, NULL, NULL, }
 };
 /* The package repo schema major revision */
 #define REPO_SCHEMA_MAJOR 2

@@ -637,8 +197,6 @@ static const struct repo_changes repo_downgrades[] = {

 #define REPO_SCHEMA_VERSION (REPO_SCHEMA_MAJOR * 1000 + REPO_SCHEMA_MINOR)
 #define REPO_NAME_PREFIX "repo-"
 typedef enum _sql_prstmt_index {
 	PKG = 0,
 	DEPS,

@@ -671,7 +229,6 @@ void pkg_repo_binary_finalize_prstatements(void);

 /*
  * Warning: returns a pointer to static array
  */
 const char * pkg_repo_binary_get_filename(const char *name);
 const char * pkg_repo_binary_get_groups_filename(const char *name);
 const char * pkg_repo_binary_get_filename(struct pkg_repo *);
 #endif /* INIT_PRIVATE_H_ */

modified libpkg/repo/binary/common.c

@@ -231,26 +231,13 @@ pkg_repo_binary_run_prstatement(sql_prstmt_index s, ...)

 }
 const char *
 pkg_repo_binary_get_groups_filename(const char *name)
 pkg_repo_binary_get_filename(struct pkg_repo *repo)
 {
 	static char buf[MAXPATHLEN];
 	if (repo->dbpath == NULL)
 		xasprintf(&repo->dbpath, "%s/repos/%s/db", ctx.dbdir,
 		    repo->name);
 	snprintf(buf, sizeof(buf), REPO_NAME_PREFIX "%s-groups.ucl",
 			name);
 	return (buf);
 }
 const char *
 pkg_repo_binary_get_filename(const char *name)
 {
 	static char reponame[MAXPATHLEN];
 	snprintf(reponame, sizeof(reponame), REPO_NAME_PREFIX "%s.sqlite",
 			name);
 	return (reponame);
 	return (repo->dbpath);
 }
 void

modified libpkg/repo/binary/init.c

@@ -50,34 +50,6 @@

 extern struct pkg_ctx ctx;
 static void
 sqlite_file_exists(sqlite3_context *ctx, int argc, sqlite3_value **argv)
 {
 	char	 fpath[MAXPATHLEN];
 	sqlite3	*db = sqlite3_context_db_handle(ctx);
 	char	*path = get_dirname(xstrdup(sqlite3_db_filename(db, "main")));
 	char	*cksum;
 	if (argc != 2) {
 		sqlite3_result_error(ctx, "file_exists needs two argument", -1);
 		return;
 	}
 	snprintf(fpath, sizeof(fpath), "%s/%s", path, sqlite3_value_text(argv[0]));
 	if (access(fpath, R_OK) == 0) {
 		cksum = pkg_checksum_file(fpath, PKG_HASH_TYPE_SHA256_HEX);
 		if (cksum && strcmp(cksum, sqlite3_value_text(argv[1])) == 0)
 			sqlite3_result_int(ctx, 1);
 		else
 			sqlite3_result_int(ctx, 0);
 		free(cksum);
 	} else {
 		sqlite3_result_int(ctx, 0);
 	}
 	free(path);
 }
 static int
 pkg_repo_binary_get_user_version(sqlite3 *sqlite, int *reposcver)
 {

@@ -101,123 +73,6 @@ pkg_repo_binary_get_user_version(sqlite3 *sqlite, int *reposcver)

 	return (retcode);
 }
 static int
 pkg_repo_binary_set_version(sqlite3 *sqlite, int reposcver)
 {
 	const char	*sql = "PRAGMA user_version = %d;";
 	if (sql_exec(sqlite, sql, reposcver) != EPKG_OK) {
 		ERROR_SQLITE(sqlite, sql);
 		return (EPKG_FATAL);
 	}
 	return (EPKG_OK);
 }
 static int
 pkg_repo_binary_apply_change(struct pkg_repo *repo, sqlite3 *sqlite,
 		  const struct repo_changes *repo_changes, const char *updown,
 		  int version, int *next_version)
 {
 	const struct repo_changes	*change;
 	bool			 found = false, in_trans = false;
 	int			 ret = EPKG_OK;
 	char			*errmsg;
 	for (change = repo_changes; change->version != -1; change++) {
 		if (change->version == version) {
 			found = true;
 			break;
 		}
 	}
 	if (!found) {
 		pkg_emit_error("Unable to %s \"%s\" repo schema "
 			"version %d (target version %d) "
 			"-- change not found", updown, repo->name, version,
 			REPO_SCHEMA_VERSION);
 		return (EPKG_FATAL);
 	}
 	/* begin transaction */
 	if ((ret = pkgdb_transaction_begin_sqlite(sqlite, "SCHEMA")) == EPKG_OK)
 		in_trans = true;
 	/* apply change */
 	if (ret == EPKG_OK) {
 		pkg_debug(4, "Pkgdb: running '%s'", change->sql);
 		ret = sqlite3_exec(sqlite, change->sql, NULL, NULL, &errmsg);
 		if (ret != SQLITE_OK) {
 			pkg_emit_error("sqlite: %s", errmsg);
 			sqlite3_free(errmsg);
 			ret = EPKG_FATAL;
 		}
 	}
 	/* update repo user_version */
 	if (ret == EPKG_OK) {
 		*next_version = change->next_version;
 		ret = pkg_repo_binary_set_version(sqlite, *next_version);
 	}
 	/* commit or rollback */
 	if (in_trans) {
 		if (ret != EPKG_OK)
 			pkgdb_transaction_rollback_sqlite(sqlite, "SCHEMA");
 		if (pkgdb_transaction_commit_sqlite(sqlite, "SCHEMA") != EPKG_OK)
 			ret = EPKG_FATAL;
 	}
 	if (ret == EPKG_OK) {
 		pkg_emit_notice("Repo \"%s\" %s schema %d to %d: %s",
 				repo->name, updown, version,
 				change->next_version, change->message);
 	}
 	return (ret);
 }
 static int
 pkg_repo_binary_upgrade(struct pkg_repo *repo, sqlite3 *sqlite, int current_version)
 {
 	int version;
 	int next_version;
 	int ret = EPKG_OK;
 	for (version = current_version;
 	     version < REPO_SCHEMA_VERSION;
 	     version = next_version)  {
 		ret = pkg_repo_binary_apply_change(repo, sqlite, repo_upgrades,
 					"upgrade", version, &next_version);
 		if (ret != EPKG_OK)
 			break;
 		pkg_debug(1, "Upgrading repo database schema from %d to %d",
 				version, next_version);
 	}
 	return (ret);
 }
 static int
 pkg_repo_binary_downgrade(struct pkg_repo *repo, sqlite3 *sqlite, int current_version)
 {
 	int version;
 	int next_version;
 	int ret = EPKG_OK;
 	for (version = current_version;
 	     version > REPO_SCHEMA_VERSION;
 	     version = next_version)  {
 		ret = pkg_repo_binary_apply_change(repo, sqlite, repo_downgrades,
 					"downgrade", version, &next_version);
 		if (ret != EPKG_OK)
 			break;
 		pkg_debug(1, "Downgrading repo database schema from %d to %d",
 				version, next_version);
 	}
 	return (ret);
 }
 int
 pkg_repo_binary_check_version(struct pkg_repo *repo, sqlite3 *sqlite)
 {

@@ -273,34 +128,15 @@ pkg_repo_binary_check_version(struct pkg_repo *repo, sqlite3 *sqlite)

 	/* This is a repo schema version we can work with */
 	ret = EPKG_OK;
 	if (reposcver < REPO_SCHEMA_VERSION) {
 		if (sqlite3_db_readonly(sqlite, "main")) {
 			pkg_emit_error("Repo %s needs schema upgrade from "
 			    "%d to %d but it is opened readonly", repo->name,
 			    reposcver, REPO_SCHEMA_VERSION);
 			ret = EPKG_FATAL;
 		} else
 			ret = pkg_repo_binary_upgrade(repo, sqlite, reposcver);
 	} else if (reposcver > REPO_SCHEMA_VERSION) {
 		if (sqlite3_db_readonly(sqlite, "main")) {
 			pkg_emit_error("Repo %s needs schema downgrade from "
 			"%d to %d but it is opened readonly", repo->name,
 			       reposcver, REPO_SCHEMA_VERSION
 			);
 			ret = EPKG_FATAL;
 		} else
 			ret = pkg_repo_binary_downgrade(repo, sqlite, reposcver);
 	}
 	return (ret);
 	if (reposcver != REPO_SCHEMA_VERSION)
 		return (EPKG_REPOSCHEMA);
 	return (EPKG_OK);
 }
 int
 pkg_repo_binary_open(struct pkg_repo *repo, unsigned mode)
 {
 	char filepath[MAXPATHLEN];
 	const char *filepath;
 	sqlite3 *sqlite = NULL;
 	int flags, dbdirfd, fd, reposfd, thisrepofd;
 	int64_t res;

@@ -331,8 +167,7 @@ pkg_repo_binary_open(struct pkg_repo *repo, unsigned mode)

 		close(fd);
 	}
 	snprintf(filepath, sizeof(filepath), "%s",
 		pkg_repo_binary_get_filename(pkg_repo_name(repo)));
 	filepath = pkg_repo_binary_get_filename(repo);
 	/* Always want read mode here */
 	if (faccessat(dbdirfd, filepath, R_OK | mode, 0) != 0) {

@@ -421,8 +256,7 @@ pkg_repo_binary_create(struct pkg_repo *repo)

 	sqlite3_initialize();
 	dbdirfd = pkg_get_dbdirfd();
 	snprintf(filepath, sizeof(filepath), "%s",
 		pkg_repo_binary_get_filename(pkg_repo_name(repo)));
 	snprintf(filepath, sizeof(filepath), "repos/%s/db", repo->name);
 	/* Should never ever happen */
 	if (faccessat(dbdirfd, filepath, R_OK, 0) == 0)
 		return (EPKG_CONFLICT);

@@ -484,9 +318,6 @@ pkg_repo_binary_init(struct pkg_repo *repo)

 	int retcode = EPKG_OK;
 	sqlite3 *sqlite = PRIV_GET(repo);
 	sqlite3_create_function(sqlite, "file_exists", 2, SQLITE_ANY, NULL,
 		    sqlite_file_exists, NULL, NULL);
 	retcode = sql_exec(sqlite, "PRAGMA journal_mode=TRUNCATE;");
 	if (retcode != EPKG_OK)
 		return (retcode);

@@ -540,7 +371,7 @@ pkg_repo_binary_access(struct pkg_repo *repo, unsigned mode)

 	int			 ret = EPKG_OK;
 	ret = pkgdb_check_access(mode,
 		pkg_repo_binary_get_filename(pkg_repo_name(repo)));
 		pkg_repo_binary_get_filename(repo));
 	return (ret);
 }

modified libpkg/repo/binary/update.c

@@ -49,7 +49,7 @@

 #include "binary_private.h"
 static int
 pkg_repo_binary_init_update(struct pkg_repo *repo, const char *name)
 pkg_repo_binary_init_update(struct pkg_repo *repo)
 {
 	sqlite3 *sqlite;
 	const char update_check_sql[] = ""

@@ -528,7 +528,7 @@ pkg_repo_binary_update_proceed(const char *name, struct pkg_repo *repo,

 	size_t linecap = 0;
 	ssize_t linelen, totallen = 0;
 	struct pkg_repo_content prc;
 	ucl_object_t *data;
 	ucl_object_t *data = NULL;
 	pkg_debug(1, "Pkgrepo, begin update of '%s'", name);

@@ -560,6 +560,7 @@ pkg_repo_binary_update_proceed(const char *name, struct pkg_repo *repo,

 			    ucl_parser_get_error(p));
 			ucl_parser_free(p);
 			close(prc.data_fd);
 			rc = EPKG_FATAL;
 			goto cleanup;
 		}
 		data = ucl_parser_get_object(p);

@@ -583,7 +584,7 @@ pkg_repo_binary_update_proceed(const char *name, struct pkg_repo *repo,

 	xasprintf(&path, "%s-pkgtemp", name);
 	rename(name, path);
 	pkg_register_cleanup_callback(rollback_repo, (void *)name);
 	rc = pkg_repo_binary_init_update(repo, name);
 	rc = pkg_repo_binary_init_update(repo);
 	if (rc != EPKG_OK) {
 		rc = EPKG_FATAL;
 		goto cleanup;

@@ -681,7 +682,6 @@ cleanup:

 int
 pkg_repo_binary_update(struct pkg_repo *repo, bool force)
 {
 	char filepath[MAXPATHLEN];
 	char *lockpath = NULL;
 	const char update_finish_sql[] = ""
 		"DROP TABLE repo_update;";

@@ -701,7 +701,7 @@ pkg_repo_binary_update(struct pkg_repo *repo, bool force)

 	pkg_debug(1, "PkgRepo: verifying update for %s", repo->name);
 	filename = pkg_repo_binary_get_filename(repo->name);
 	filename = pkg_repo_binary_get_filename(repo);
 	/* First of all, try to open and init repo and check whether it is fine */
 	if (repo->dfd == -1 && pkg_repo_open(repo) == EPKG_FATAL)

@@ -711,8 +711,6 @@ pkg_repo_binary_update(struct pkg_repo *repo, bool force)

 		pkg_debug(1, "PkgRepo: need forced update of %s", repo->name);
 		t = 0;
 		force = true;
 		snprintf(filepath, sizeof(filepath), "%s/%s", ctx.dbdir,
 		    filename);
 	}
 	else {
 		repo->ops->close(repo, false);

@@ -721,9 +719,7 @@ pkg_repo_binary_update(struct pkg_repo *repo, bool force)

 			got_meta = true;
 		}
 		snprintf(filepath, sizeof(filepath), "%s/%s", ctx.dbdir,
 			filename);
 		if (got_meta && stat(filepath, &st) != -1) {
 		if (got_meta && stat(filename, &st) != -1) {
 			if (!force)
 				t = st.st_mtime;
 		}

@@ -731,8 +727,7 @@ pkg_repo_binary_update(struct pkg_repo *repo, bool force)

 	ld = openat(repo->dfd, "lock", O_CREAT|O_TRUNC|O_WRONLY, 00644);
 	if (ld == -1) {
 		pkg_emit_errno("plop", "plop");
 		pkg_emit_error("plop, %d\n", repo->dfd);
 		pkg_emit_errno("openat", "lock");
 	}
 	if (flock(ld, LOCK_EX|LOCK_NB) == -1) {
 		/* lock blocking anyway to let the other end finish */

@@ -744,7 +739,7 @@ pkg_repo_binary_update(struct pkg_repo *repo, bool force)

 		goto cleanup;
 	}
 	res = pkg_repo_binary_update_proceed(filepath, repo, &t, force);
 	res = pkg_repo_binary_update_proceed(filename, repo, &t, force);
 	if (res != EPKG_OK && res != EPKG_UPTODATE) {
 		pkg_emit_notice("Unable to update repository %s", repo->name);
 		goto cleanup;

@@ -778,7 +773,7 @@ cleanup:

 			}
 		};
 		utimes(filepath, ftimes);
 		utimes(filename, ftimes);
 		if (got_meta)
 			futimesat(repo->dfd, "meta", ftimes);
 	}