5fa4f5e Repo names vs. identifiers — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -268,8 +268,8 @@ pkg_set_repourl(struct pkg *pkg, const char *str)

 {
 	struct pkg_repo *r;
 	r = pkg_repo_find(str);
 	if (r != 0)
 	r = pkg_repo_find_ident(str);
 	if (r != NULL)
 		pkg_set(pkg, PKG_REPOURL, pkg_repo_url(r));
 }

modified libpkg/pkg.h.in

@@ -1358,9 +1358,11 @@ int pkg_sshserve(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_key(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(const char *reponame);
 struct pkg_repo *pkg_repo_find_ident(const char *ident);
 struct pkg_repo *pkg_repo_find_name(const char *name);
 #endif

modified libpkg/pkg_config.c

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

 #include "private/event.h"
 #define ABI_VAR_STRING "${ABI}"
 #define REPO_NAME_PREFIX "repo-"
 int eventpipe = -1;

@@ -738,8 +739,7 @@ add_repo(yaml_document_t *doc, yaml_node_t *repo, yaml_node_t *node)

 		return;
 	r = calloc(1, sizeof(struct pkg_repo));
 	r->name = strdup(repo->data.scalar.value);
 	asprintf(&r->reponame, "repo-%s", repo->data.scalar.value);
 	asprintf(&r->name, REPO_NAME_PREFIX"%s", repo->data.scalar.value);
 	r->url = subst_packagesite_str(url);
 	if (pubkey != NULL)
 		r->pubkey = strdup(pubkey);

@@ -784,7 +784,7 @@ parse_repo_file(yaml_document_t *doc, yaml_node_t *node)

 			++pair;
 			continue;
 		}
 		HASH_FIND_STR(repos, (char *)key->data.scalar.value, r);
 		r = pkg_repo_find_ident((char *)key->data.scalar.value);
 		if (r != NULL) {
 			pkg_emit_error("a repository named '%s' is already configured, skipping...");
 			++pair;

@@ -860,8 +860,7 @@ load_repositories(void)

 	if (url != NULL) {
 		r = calloc(1, sizeof(struct pkg_repo));
 		r->name = strdup("packagesite");
 		r->reponame = strdup("repo-packagesite");
 		r->name = strdup(REPO_NAME_PREFIX"packagesite");
 		r->url = subst_packagesite_str(url);
 		if (pub != NULL)
 			r->pubkey = strdup(pub);

@@ -1191,6 +1190,14 @@ 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));
 }
 /* The basename of the sqlite DB file and the database name */
 const char *
 pkg_repo_name(struct pkg_repo *r)
 {

@@ -1215,8 +1222,27 @@ 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(const char *reponame)
 pkg_repo_find_name(const char *reponame)
 {
 	struct pkg_repo *r;

modified libpkg/pkg_jobs.c

@@ -75,16 +75,16 @@ pkg_jobs_set_flags(struct pkg_jobs *j, pkg_flags flags)

 }
 int
 pkg_jobs_set_repository(struct pkg_jobs *j, const char *name)
 pkg_jobs_set_repository(struct pkg_jobs *j, const char *ident)
 {
 	struct pkg_repo *r;
 	if ((r = pkg_repo_find("name")) == NULL) {
 		pkg_emit_error("Unknown repository: %s", name);
 	if ((r = pkg_repo_find_ident(ident)) == NULL) {
 		pkg_emit_error("Unknown repository: %s", ident);
 		return (EPKG_FATAL);
 	}
 	j->reponame = r->reponame;
 	j->reponame = pkg_repo_name(r);
 	return (EPKG_OK);
 }

modified libpkg/pkg_repo.c

@@ -92,7 +92,7 @@ pkg_repo_fetch(struct pkg *pkg)

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

modified libpkg/pkgdb.c

@@ -215,13 +215,13 @@ pkgdb_get_reponame(struct pkgdb *db, const char *repo)

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

@@ -769,36 +769,36 @@ pkgdb_open_multirepos(const char *dbdir, struct pkgdb *db)

 			continue;
 		/* is it already attached? */
 		if (is_attached(db->sqlite, r->reponame)) {
 		if (is_attached(db->sqlite, pkg_repo_name(r))) {
 			pkg_emit_error("repository '%s' is already "
 			    "listed, ignoring", r->name);
 			    "listed, ignoring", pkg_repo_ident(r));
 			continue;
 		}
 		snprintf(remotepath, sizeof(remotepath), "%s/%s.sqlite",
 		    dbdir, r->reponame);
 			 dbdir, pkg_repo_name(r));
 		if (access(remotepath, R_OK) != 0) {
 			pkg_emit_noremotedb(r->name);
 			pkg_emit_noremotedb(pkg_repo_ident(r));
 			pkgdb_close(db);
 			return (EPKG_ENODB);
 		}
 		ret = sql_exec(db->sqlite, "ATTACH '%s' AS '%s';",
 		    remotepath, r->reponame);
 		          remotepath, pkg_repo_name(r));
 		if (ret != EPKG_OK) {
 			pkgdb_close(db);
 			return (EPKG_FATAL);
 		}
 		switch (pkgdb_repo_check_version(db, r->reponame)) {
 		switch (pkgdb_repo_check_version(db, pkg_repo_name(r))) {
 		case EPKG_FATAL:
 			pkgdb_close(db);
 			return (EPKG_FATAL);
 			break;
 		case EPKG_REPOSCHEMA:
 			ret = sql_exec(db->sqlite, "DETACH DATABASE '%s'",
 			    r->reponame);
 				  pkg_repo_name(r));
 			if (ret != EPKG_OK) {
 				pkgdb_close(db);
 				return (EPKG_FATAL);

@@ -992,7 +992,7 @@ pkgdb_access(unsigned mode, unsigned database)

 		struct pkg_repo	*r = NULL;
 		while (pkg_repos(&r) == EPKG_OK) {
 			retval = database_access(mode, dbdir, r->reponame);
 			retval = database_access(mode, dbdir, pkg_repo_name(r));
 			if (retval != EPKG_OK)
 				return (retval);
 		}

modified libpkg/private/pkg.h

@@ -254,7 +254,6 @@ struct http_mirror {

 struct pkg_repo {
 	char *name;
 	char *reponame;
 	char *url;
 	char *pubkey;
 	mirror_t mirror_type;

modified libpkg/update.c

@@ -260,7 +260,7 @@ pkg_update_full(const char *repofile, struct pkg_repo *repo, time_t *mtime)

 		goto cleanup;
 	}
 	/* check is the repository is for valid architecture */
 	/* check if the repository is for valid architecture */
 	if (access(repofile_unchecked, R_OK|W_OK) == -1) {
 		pkg_emit_error("Archive file does not have repo.sqlite file");
 		rc = EPKG_FATAL;

@@ -611,7 +611,7 @@ pkg_update(struct pkg_repo *repo, bool force)

 		return (EPKG_FATAL);
 	}
 	snprintf(repofile, sizeof(repofile), "%s/repo-%s.sqlite", dbdir, pkg_repo_name(repo));
 	snprintf(repofile, sizeof(repofile), "%s/%s.sqlite", dbdir, pkg_repo_name(repo));
 	if (stat(repofile, &st) != -1)
 		t = force ? 0 : st.st_mtime;

modified pkg/main.c

@@ -485,7 +485,7 @@ main(int argc, char **argv)

 				break;
 			}
 			printf("  %s:\n    url: %s\n    key: %s\n    enabled: %s\n    mirror_type: %s\n",
 			    pkg_repo_name(repo), pkg_repo_url(repo),
 			    pkg_repo_ident(repo), pkg_repo_url(repo),
 			    pkg_repo_key(repo) == NULL ? "" : pkg_repo_key(repo),
 			    pkg_repo_enabled(repo) ? "yes" : "no",
 			    buf);

modified pkg/update.c

@@ -63,7 +63,7 @@ pkgcli_update(bool force) {

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