6cbd570 No more repo ident/name. — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -277,7 +277,6 @@ static int

 pkg_vset(struct pkg *pkg, va_list ap)
 {
 	int attr;
 	struct pkg_repo *r;
 	char *buf = NULL;
 	const char *data;
 	const char *str;

@@ -299,13 +298,6 @@ pkg_vset(struct pkg *pkg, va_list ap)

 				data = buf;
 			}
 			if (attr == PKG_REPOURL) {
 				r = pkg_repo_find_ident(str);
 				if (r == NULL)
 					break;
 				data = pkg_repo_url(r);
 			}
 			if (data == NULL)
 				ucl_object_delete_key(pkg->fields, pkg_keys[attr].name);
 			else

modified libpkg/pkg.h.in

@@ -1572,16 +1572,13 @@ int pkg_repos_total_count(void);

 int pkg_repos_activated_count(void);
 int pkg_repos(struct pkg_repo **);
 const char *pkg_repo_url(struct pkg_repo *r);
 const char *pkg_repo_ident(struct pkg_repo *r);
 const char *pkg_repo_name(struct pkg_repo *r);
 const char * pkg_repo_ident_from_name(const char *repo_name);
 const char *pkg_repo_key(struct pkg_repo *r);
 const char *pkg_repo_fingerprints(struct pkg_repo *r);
 signature_t pkg_repo_signature_type(struct pkg_repo *r);
 bool pkg_repo_enabled(struct pkg_repo *r);
 mirror_t pkg_repo_mirror_type(struct pkg_repo *r);
 struct pkg_repo *pkg_repo_find_ident(const char *ident);
 struct pkg_repo *pkg_repo_find_name(const char *name);
 struct pkg_repo *pkg_repo_find(const char *name);
 /**
  * pkg_printf() and friends.  These parallel the similarly named libc

modified libpkg/pkg_checksum.c

@@ -373,7 +373,7 @@ pkg_checksum_calculate(struct pkg *pkg, struct pkgdb *db)

 	pkg_get(pkg, PKG_REPONAME, &reponame);
 	if (reponame != NULL) {
 		repo = pkg_repo_find_name(reponame);
 		repo = pkg_repo_find(reponame);
 		if (repo != NULL)
 			type = repo->meta->digest_format;

modified libpkg/pkg_config.c

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

 #include "private/event.h"
 #include "pkg_repos.h"
 #define REPO_NAME_PREFIX "repo-"
 #ifndef PORTSDIR
 #define PORTSDIR "/usr/ports"
 #endif

@@ -522,7 +521,7 @@ walk_repo_obj(const ucl_object_t *obj, const char *file)

 	while ((cur = ucl_iterate_object(obj, &it, true))) {
 		key = ucl_object_key(cur);
 		pkg_debug(1, "PkgConfig: parsing key '%s'", key);
 		r = pkg_repo_find_ident(key);
 		r = pkg_repo_find(key);
 		if (r != NULL)
 			pkg_debug(1, "PkgConfig: overwriting repository %s", key);
 		if (cur->type == UCL_OBJECT)

@@ -951,7 +950,7 @@ pkg_repo_new(const char *name, const char *url, const char *type)

 	r->mirror_type = NOMIRROR;
 	r->enable = true;
 	r->meta = pkg_repo_meta_default();
 	asprintf(&r->name, REPO_NAME_PREFIX"%s", name);
 	r->name = strdup(name);
 	HASH_ADD_KEYPTR(hh, repos, r->name, strlen(r->name), r);
 	return (r);

@@ -1021,23 +1020,6 @@ pkg_repo_url(struct pkg_repo *r)

 	return (r->url);
 }
 /* The repo identifier from pkg.conf(5): without the 'repo-' prefix */
 const char *
 pkg_repo_ident(struct pkg_repo *r)
 {
 	return (r->name + strlen(REPO_NAME_PREFIX));
 }
 /* Ditto: The repo identifier from pkg.conf(5): without the 'repo-' prefix */
 const char *
 pkg_repo_ident_from_name(const char *repo_name)
 {
 	if (repo_name == NULL)
 		return "local";
 	return (repo_name + strlen(REPO_NAME_PREFIX));
 }
 /* The basename of the sqlite DB file and the database name */
 const char *
 pkg_repo_name(struct pkg_repo *r)

@@ -1075,27 +1057,10 @@ pkg_repo_mirror_type(struct pkg_repo *r)

 	return (r->mirror_type);
 }
 /* Locate the repo by the identifying tag from pkg.conf(5) */
 struct pkg_repo *
 pkg_repo_find_ident(const char *repoident)
 {
 	struct pkg_repo *r;
 	char *name;
 	asprintf(&name, REPO_NAME_PREFIX"%s", repoident);
 	if (name == NULL)
 		return (NULL);	/* Out of memory */
 	r = pkg_repo_find_name(name);
 	free(name);
 	return (r);
 }
 /* Locate the repo by the file basename / database name */
 struct pkg_repo *
 pkg_repo_find_name(const char *reponame)
 pkg_repo_find(const char *reponame)
 {
 	struct pkg_repo *r;

modified libpkg/pkg_jobs.c

@@ -87,7 +87,7 @@ pkg_jobs_set_flags(struct pkg_jobs *j, pkg_flags flags)

 int
 pkg_jobs_set_repository(struct pkg_jobs *j, const char *ident)
 {
 	if ((pkg_repo_find_ident(ident)) == NULL) {
 	if ((pkg_repo_find(ident)) == NULL) {
 		pkg_emit_error("Unknown repository: %s", ident);
 		return (EPKG_FATAL);
 	}

modified libpkg/pkg_printf.c

@@ -1313,7 +1313,7 @@ format_repo_ident(struct sbuf *sbuf, const void *data, struct percent_esc *p)

 	const char		*reponame;
 	pkg_get(pkg, PKG_REPONAME, &reponame);
 	return (string_val(sbuf, pkg_repo_ident_from_name(reponame), p));
 	return (string_val(sbuf, reponame, p));
 }
 /*

modified libpkg/pkg_repo.c

@@ -153,7 +153,7 @@ pkg_repo_fetch_package(struct pkg *pkg)

 	 * For a single attached database the repository URL should be
 	 * defined by PACKAGESITE.
 	 */
 	repo = pkg_repo_find_name(reponame);
 	repo = pkg_repo_find(reponame);
 	packagesite = pkg_repo_url(repo);
 	if (packagesite == NULL || packagesite[0] == '\0') {

modified libpkg/pkgdb.c

@@ -876,7 +876,7 @@ pkgdb_open_multirepos(const char *dbdir, struct pkgdb *db,

 	while (pkg_repos(&r) == EPKG_OK) {
 		if (reponame != NULL) {
 			if (strcmp(pkg_repo_ident(r), reponame) != 0)
 			if (strcmp(r->name, reponame) != 0)
 				continue;
 		} else {
 			if (!pkg_repo_enabled(r))

@@ -886,7 +886,7 @@ pkgdb_open_multirepos(const char *dbdir, struct pkgdb *db,

 		/* is it already attached? */
 		if (pkgdb_is_attached(db->sqlite, pkg_repo_name(r))) {
 			pkg_emit_error("repository '%s' is already "
 			    "listed, ignoring", pkg_repo_ident(r));
 			    "listed, ignoring", r->name);
 			continue;
 		}

@@ -894,13 +894,13 @@ pkgdb_open_multirepos(const char *dbdir, struct pkgdb *db,

 			 dbdir, pkg_repo_name(r));
 		if (access(remotepath, R_OK) != 0) {
 			pkg_emit_noremotedb(pkg_repo_ident(r));
 			pkg_emit_noremotedb(r->name);
 			pkgdb_close(db);
 			return (EPKG_ENODB);
 		}
 		ret = sql_exec(db->sqlite, "ATTACH '%s' AS '%s';",
 		          remotepath, pkg_repo_name(r));
 		          remotepath, r->name);
 		if (ret != EPKG_OK) {
 			pkgdb_close(db);
 			return (EPKG_FATAL);

modified libpkg/pkgdb_repo.c

@@ -89,7 +89,7 @@ pkgdb_get_reponame(struct pkgdb *db, const char *repo)

 	assert(db->type == PKGDB_REMOTE);
 	if (repo != NULL) {
 		if ((r = pkg_repo_find_ident(repo)) == NULL) {
 		if ((r = pkg_repo_find(repo)) == NULL) {
 			pkg_emit_error("repository '%s' does not exist", repo);
 			return (NULL);
 		}

modified libpkg/repo/binary/binary_private.h

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

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

@@ -615,5 +617,9 @@ static sql_prstmt sql_prepared_statements[PRSTMT_LAST] = {

 };
 int pkg_repo_binary_run_prstatement(sql_prstmt_index s, ...);
 /*
  * Warning: returns a pointer to static array
  */
 const char * pkg_repo_binary_get_filename(const char *name);
 #endif /* INIT_PRIVATE_H_ */

modified libpkg/repo/binary/common.c

@@ -70,3 +70,15 @@ pkg_repo_binary_run_prstatement(sql_prstmt_index s, ...)

 	return (retcode);
 }
 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);
 }

modified libpkg/repo/binary/init.c

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

 	sqlite3_initialize();
 	dbdir = pkg_object_string(pkg_config_get("PKG_DBDIR"));
 	snprintf(filepath, sizeof(filepath), "%s/%s.sqlite", dbdir, pkg_repo_name(repo));
 	snprintf(filepath, sizeof(filepath), "%s/%s",
 		dbdir, pkg_repo_binary_get_filename(pkg_repo_name(repo)));
 	/* Always want read mode here */
 	if (access(filepath, R_OK | mode) != 0)

@@ -405,7 +406,8 @@ pkg_repo_binary_create(struct pkg_repo *repo)

 	sqlite3_initialize();
 	dbdir = pkg_object_string(pkg_config_get("PKG_DBDIR"));
 	snprintf(filepath, sizeof(filepath), "%s/%s.sqlite", dbdir, pkg_repo_name(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)
 		return (EPKG_CONFLICT);

@@ -518,7 +520,8 @@ pkg_repo_binary_access(struct pkg_repo *repo, unsigned mode)

 	o = pkg_config_get("PKG_DBDIR");
 	dbdir = pkg_object_string(o);
 	ret = pkgdb_check_access(mode, dbdir, pkg_repo_name(repo));
 	ret = pkgdb_check_access(mode, dbdir,
 		pkg_repo_binary_get_filename(pkg_repo_name(repo)));
 	return (ret);
 }

modified libpkg/repo/binary/update.c

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

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

modified src/main.c

@@ -325,7 +325,7 @@ show_repository_info(void)

 		}
 		printf("  %s: { \n    %-16s: \"%s\",\n    %-16s: %s",
 		    pkg_repo_ident(repo),
 		    pkg_repo_name(repo),
                     "url", pkg_repo_url(repo),
 		    "enabled", pkg_repo_enabled(repo) ? "yes" : "no");
 		if (pkg_repo_mirror_type(repo) != NOMIRROR)

modified src/update.c

@@ -71,7 +71,7 @@ pkgcli_update(bool force, const char *reponame)

 	while (pkg_repos(&r) == EPKG_OK) {
 		if (reponame != NULL) {
 			if (strcmp(pkg_repo_ident(r), reponame) != 0)
 			if (strcmp(pkg_repo_name(r), reponame) != 0)
 				continue;
 		} else {
 			if (!pkg_repo_enabled(r))

@@ -83,7 +83,7 @@ pkgcli_update(bool force, const char *reponame)

 			if (!quiet)
 				printf("%s repository catalogue is "
 				       "up-to-date, no need to fetch "
 				       "fresh copy\n", pkg_repo_ident(r));
 				       "fresh copy\n", pkg_repo_name(r));
 				retcode = EPKG_OK;
 		}
 		if (retcode != EPKG_OK)