Radish alpha
H
HardenedBSD-pkg
rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9
HardenedBSD Package Manager
Radicle
Git
Commits › bba3943
Merge remote-tracking branch 'upstream/master'
Matthew Seaman committed 13 years ago
commit bba3943a007698d5d6bb833b9b299a59d248bd77
parent 9148d6d
24 files changed +272 -133
modified README.md
@@ -152,12 +152,12 @@ show pkg-message, ...
`pkg add` can install a package archive from the local disk, or from a

remote FTP/HTTP server.
- 
If only a package name is given, it will search the remote repository
+ 
If only a package name is given, it will search the repository catalogue

and download and install the package if it exists. The dependencies will be

downloaded and installed first.



This is possible because we have the dependency information in the
- 
remote repository database.
+ 
catalogue of the remote repository.



`pkg add` will check if the user attempts to install a package built for another

arch or release.
@@ -292,7 +292,7 @@ your remote server with packages, like for example (or use ${LOCALBASE}/etc/pkg.


	# export PACKAGESITE=http://example.org/pkgng-repo/
- 
Then fetch the remote repository using the below command:
+ 
Then fetch the repository catalogue using the command:



	# pkg update
@@ -308,7 +308,7 @@ pkgng is also able to work with multiple remote repositories. In the previous se
we are using only a single remote repository, which is defined by the _PACKAGESITE_ option.



In order to be able to work with multiple remote repositories and instead of changing
- 
each time _PACKAGESITE_, you can tell *pkg(1)* to work in multi-repos mode as well.
+ 
_PACKAGESITE_ each time, you can tell *pkg(1)* to work in multi-repos mode as well.



To do this, simply enable multi-repos in *pkg.conf(5)* like this:
@@ -327,7 +327,7 @@ the *default* repository.
It is important that you always define a *default* repository - this is the repository that is being

used when no remote repositories are specified via the `-r <repo>` flag.
- 
Next, fetch the remote repositories:
+ 
Next, fetch all the repository catalogues:



	# pkg update
modified docs/GOALS
@@ -62,7 +62,7 @@ Table of Contents:


- search:
- 
	- Will search the remote repository to provide information
+ 
	- Will search the repository catalogue to provide information

	  to the users.



- info:
@@ -87,8 +87,8 @@ Table of Contents:


- upgrade:
- 
	- Will compute the remote repository to check if there are new upgrades
- 
	  available and apply them.
+ 
	- Will examine the repository catalogue to check if there are
+ 
	  any upgrades available and apply them.



- update:
modified libpkg/pkg.c
@@ -548,7 +548,7 @@ pkg_adddep(struct pkg *pkg, const char *name, const char *origin, const char *ve
	assert(version != NULL && version[0] != '\0');



	while (pkg_deps(pkg, &d) != EPKG_END) {
- 
		if (!strcmp(origin, pkg_dep_get(d, PKG_DEP_ORIGIN))) {
+ 
		if (!strcmp(origin, pkg_dep_origin(d))) {

			pkg_emit_error("duplicate dependency listing: %s-%s, ignoring", name, version);

			return (EPKG_OK);

		}
@@ -602,8 +602,8 @@ pkg_addfile_attr(struct pkg *pkg, const char *path, const char *sha256, const ch


	if (check_duplicates) {

		while (pkg_files(pkg, &f) != EPKG_END) {
- 
			if (!strcmp(path, pkg_file_get(f, PKG_FILE_PATH))) {
- 
				pkg_emit_error("duplicate file listing: %s, ignoring", pkg_file_get(f, PKG_FILE_PATH));
+ 
			if (!strcmp(path, pkg_file_path(f))) {
+ 
				pkg_emit_error("duplicate file listing: %s, ignoring", pkg_file_path(f));

				return (EPKG_OK);

			}

		}
@@ -1061,8 +1061,8 @@ pkg_copy_tree(struct pkg *pkg, const char *src, const char *dest)
	}



	while (pkg_files(pkg, &file) == EPKG_OK) {
- 
		snprintf(spath, sizeof(spath), "%s%s", src, pkg_file_get(file, PKG_FILE_PATH));
- 
		snprintf(dpath, sizeof(dpath), "%s%s", dest, pkg_file_get(file, PKG_FILE_PATH));
+ 
		snprintf(spath, sizeof(spath), "%s%s", src, pkg_file_path(file));
+ 
		snprintf(dpath, sizeof(dpath), "%s%s", dest, pkg_file_path(file));

		packing_append_file(pack, spath, dpath);

	}
@@ -1081,8 +1081,8 @@ pkg_test_filesum(struct pkg *pkg)
	assert(pkg != NULL);



	while (pkg_files(pkg, &f) == EPKG_OK) {
- 
		path = pkg_file_get(f, PKG_FILE_PATH);
- 
		sum = pkg_file_get(f, PKG_FILE_SUM);
+ 
		path = pkg_file_path(f);
+ 
		sum = pkg_file_cksum(f);

		if (*sum != '\0') {

			sha256_file(path, sha256);

			if (strcmp(sha256, sum) != 0)
@@ -1105,8 +1105,8 @@ pkg_recompute(struct pkgdb *db, struct pkg *pkg)
	char sha256[SHA256_DIGEST_LENGTH * 2 + 1];



	while (pkg_files(pkg, &f) == EPKG_OK) {
- 
		path = pkg_file_get(f, PKG_FILE_PATH);
- 
		sum = pkg_file_get(f, PKG_FILE_SUM);
+ 
		path = pkg_file_path(f);
+ 
		sum = pkg_file_cksum(f);

		if (lstat(path, &st) == 0) {

			regular = true;

			if (S_ISLNK(st.st_mode)) {
modified libpkg/pkg.h
@@ -607,30 +607,49 @@ int pkg_emit_manifest(struct pkg *pkg, char **buf);
/* pkg_dep */

const char *pkg_dep_get(struct pkg_dep const * const , const pkg_dep_attr);
+ 
const char *pkg_dep_name(struct pkg_dep const * const);
+ 
const char *pkg_dep_origin(struct pkg_dep const * const);
+ 
const char *pkg_dep_version(struct pkg_dep const * const);
+ 


/* pkg_file */

const char *pkg_file_get(struct pkg_file const * const, const pkg_file_attr);
- 
const char *pkg_dir_path(struct pkg_dir *);
- 
bool pkg_dir_try(struct pkg_dir *);
+ 
const char *pkg_file_path(struct pkg_file const * const);
+ 
const char *pkg_file_cksum(struct pkg_file const * const);
+ 
const char *pkg_file_uname(struct pkg_file const * const);
+ 
const char *pkg_file_gname(struct pkg_file const * const);
+ 
mode_t pkg_file_mode(struct pkg_file const * const);
+
+ 
/* pkg_dir */
+ 
const char *pkg_dir_path(struct pkg_dir const * const);
+ 
const char *pkg_dir_uname(struct pkg_dir const * const);
+ 
const char *pkg_dir_gname(struct pkg_dir const * const);
+ 
mode_t pkg_dir_mode(struct pkg_dir const * const);
+ 
bool pkg_dir_try(struct pkg_dir const * const);
+
+ 
/* pkg_category */
+ 
const char *pkg_category_name(struct pkg_category const * const);
- 
const char *pkg_category_name(struct pkg_category *);
+ 
/* pkg_license */
+ 
const char *pkg_license_name(struct pkg_license const * const);
- 
const char *pkg_license_name(struct pkg_license *);
+ 
/* pkg_user */
+ 
const char *pkg_user_name(struct pkg_user const * const);
+ 
const char *pkg_user_uidstr(struct pkg_user const * const);
- 
const char *pkg_user_name(struct pkg_user *);
- 
const char *pkg_user_uidstr(struct pkg_user *);
- 
const char *pkg_group_name(struct pkg_group *);
- 
const char *pkg_group_gidstr(struct pkg_group *);
+ 
/* pkg_group */
+ 
const char *pkg_group_name(struct pkg_group const * const);
+ 
const char *pkg_group_gidstr(struct pkg_group const * const);



/* pkg_script */
- 
const char *pkg_script_get(struct pkg *, pkg_script type);
+ 
const char *pkg_script_get(struct pkg const * const, pkg_script);



/* pkg_option */
- 
const char *pkg_option_opt(struct pkg_option *);
- 
const char *pkg_option_value(struct pkg_option *);
+ 
const char *pkg_option_opt(struct pkg_option const * const);
+ 
const char *pkg_option_value(struct pkg_option const * const);



/* pkg_shlib */
- 
const char *pkg_shlib_name(struct pkg_shlib *);
+ 
const char *pkg_shlib_name(struct pkg_shlib const * const);



/**

 * @param db A pointer to a struct pkgdb object
modified libpkg/pkg_add.c
@@ -47,7 +47,7 @@ dep_installed(struct pkg_dep *dep, struct pkgdb *db) {
	struct pkgdb_it *it;

	int ret = EPKG_FATAL;
- 
	it = pkgdb_query(db, pkg_dep_get(dep, PKG_DEP_ORIGIN), MATCH_EXACT);
+ 
	it = pkgdb_query(db, pkg_dep_origin(dep), MATCH_EXACT);



	if (pkgdb_it_next(it, &p, PKG_LOAD_BASIC) == EPKG_OK)

		ret = EPKG_OK;
@@ -201,7 +201,7 @@ pkg_add(struct pkgdb *db, const char *path, int flags)
	while (pkg_deps(pkg, &dep) == EPKG_OK) {

		if (dep_installed(dep, db) != EPKG_OK) {

			snprintf(dpath, sizeof(dpath), "%s/%s-%s%s", basedir,
- 
					 pkg_dep_get(dep, PKG_DEP_NAME), pkg_dep_get(dep, PKG_DEP_VERSION),
+ 
					 pkg_dep_name(dep), pkg_dep_version(dep),

					 ext);



			if ((flags & PKG_ADD_UPGRADE) == 0 && access(dpath, F_OK) == 0) {
modified libpkg/pkg_attributes.c
@@ -74,6 +74,30 @@ pkg_dep_get(struct pkg_dep const * const d, const pkg_dep_attr attr)
	}

}
+ 
const char *
+ 
pkg_dep_name(struct pkg_dep const * const d)
+ 
{
+ 
	assert( d != NULL);
+
+ 
	return (sbuf_get(d->name));
+ 
}
+
+ 
const char *
+ 
pkg_dep_origin(struct pkg_dep const * const d)
+ 
{
+ 
	assert( d != NULL);
+
+ 
	return (sbuf_get(d->origin));
+ 
}
+
+ 
const char *
+ 
pkg_dep_version(struct pkg_dep const * const d)
+ 
{
+ 
	assert( d != NULL);
+
+ 
	return (sbuf_get(d->version));
+ 
}
+ 


/*

 * File

 */
@@ -120,6 +144,46 @@ pkg_file_get(struct pkg_file const * const f, const pkg_file_attr attr)
	}

}
+ 
const char *
+ 
pkg_file_path(struct pkg_file const * const f)
+ 
{
+ 
	assert(f != NULL);
+
+ 
	return (f->path);
+ 
}
+
+ 
const char *
+ 
pkg_file_cksum(struct pkg_file const * const f)
+ 
{
+ 
	assert(f != NULL);
+
+ 
	return (f->sum);
+ 
}
+
+ 
const char *
+ 
pkg_file_uname(struct pkg_file const * const f)
+ 
{
+ 
	assert(f != NULL);
+
+ 
	return (f->uname);
+ 
}
+
+ 
const char *
+ 
pkg_file_gname(struct pkg_file const * const f)
+ 
{
+ 
	assert(f != NULL);
+
+ 
	return (f->gname);
+ 
}
+
+ 
mode_t
+ 
pkg_file_mode(struct pkg_file const * const f)
+ 
{
+ 
	assert(f != NULL);
+
+ 
	return (f->perm);
+ 
}
+ 


/*

 * Dir

 */
@@ -144,17 +208,49 @@ pkg_dir_free(struct pkg_dir *d)
}



const char *
- 
pkg_dir_path(struct pkg_dir *d)
+ 
pkg_dir_path(struct pkg_dir const * const d)

{
+ 
	assert(d != NULL);
+ 


	return (d->path);

}
+ 
const char *
+ 
pkg_dir_uname(struct pkg_dir const * const d)
+ 
{
+ 
	assert(d != NULL);
+
+ 
	return (d->uname);
+ 
}
+
+ 
const char *
+ 
pkg_dir_gname(struct pkg_dir const * const d)
+ 
{
+ 
	assert(d != NULL);
+
+ 
	return (d->gname);
+ 
}
+
+ 
mode_t
+ 
pkg_dir_mode(struct pkg_dir const * const d)
+ 
{
+ 
	assert(d != NULL);
+
+ 
	return (d->perm);
+ 
}
+ 


bool
- 
pkg_dir_try(struct pkg_dir *d)
+ 
pkg_dir_try(struct pkg_dir const * const d)

{
+ 
	assert(d != NULL);
+ 


	return (d->try);

}
+ 
/*
+ 
 * Category
+ 
 */
+ 


int

pkg_category_new(struct pkg_category **c)

{
@@ -165,8 +261,10 @@ pkg_category_new(struct pkg_category **c)
}



const char *
- 
pkg_category_name(struct pkg_category *c)
+ 
pkg_category_name(struct pkg_category const * const c)

{
+ 
	assert(c != NULL);
+ 


	return (sbuf_get(c->name));

}
@@ -206,13 +304,15 @@ pkg_license_free(struct pkg_license *l)
}



const char *
- 
pkg_license_name(struct pkg_license *l)
+ 
pkg_license_name(struct pkg_license const * const l)

{
+ 
	assert(l != NULL);
+ 


	return (sbuf_get(l->name));

}



/*
- 
 * user
+ 
 * User

 */



int
@@ -236,19 +336,23 @@ pkg_user_free(struct pkg_user *u)
}



const char *
- 
pkg_user_name(struct pkg_user *u)
+ 
pkg_user_name(struct pkg_user const * const u)

{
+ 
	assert(u != NULL);
+ 


	return (u->name);

}



const char *
- 
pkg_user_uidstr(struct pkg_user *u)
+ 
pkg_user_uidstr(struct pkg_user const * const u)

{
+ 
	assert(u != NULL);
+ 


	return (u->uidstr);

}



/*
- 
 * group
+ 
 * Group

 */



int
@@ -272,19 +376,27 @@ pkg_group_free(struct pkg_group *g)
}



const char *
- 
pkg_group_name(struct pkg_group *g)
+ 
pkg_group_name(struct pkg_group const * const g)

{
+ 
	assert(g != NULL);
+ 


	return (g->name);

}



const char *
- 
pkg_group_gidstr(struct pkg_group *g)
+ 
pkg_group_gidstr(struct pkg_group const * const g)

{
+ 
	assert(g != NULL);
+ 


	return (g->gidstr);

}
+ 
/*
+ 
 * Script
+ 
 */
+ 


const char *
- 
pkg_script_get(struct pkg *p, pkg_script i)
+ 
pkg_script_get(struct pkg const * const p, pkg_script i)

{

	if (p->scripts[i] == NULL)

		return (NULL);
@@ -318,14 +430,18 @@ pkg_option_free(struct pkg_option *option)
}



const char *
- 
pkg_option_opt(struct pkg_option *option)
+ 
pkg_option_opt(struct pkg_option const * const option)

{
+ 
	assert(option != NULL);
+ 


	return (sbuf_get(option->key));

}



const char *
- 
pkg_option_value(struct pkg_option *option)
+ 
pkg_option_value(struct pkg_option const * const option)

{
+ 
	assert(option != NULL);
+ 


	return (sbuf_get(option->value));

}
@@ -341,12 +457,6 @@ pkg_shlib_new(struct pkg_shlib **sl)
	return (EPKG_OK);

}
- 
const char *
- 
pkg_shlib_name(struct pkg_shlib *sl)
- 
{
- 
	return (sbuf_get(sl->name));
- 
}
- 


void

pkg_shlib_free(struct pkg_shlib *sl)

{
@@ -356,3 +466,11 @@ pkg_shlib_free(struct pkg_shlib *sl)
	sbuf_free(sl->name);

	free(sl);

}
+
+ 
const char *
+ 
pkg_shlib_name(struct pkg_shlib const * const sl)
+ 
{
+ 
	assert(sl != NULL);
+
+ 
	return (sbuf_get(sl->name));
+ 
}
modified libpkg/pkg_create.c
@@ -62,11 +62,11 @@ pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archi
	 */

	while (pkg_files(pkg, &file) == EPKG_OK) {

		if (root != NULL)
- 
			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_file_get(file, PKG_FILE_PATH));
+ 
			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_file_path(file));

		else
- 
			strlcpy(fpath, pkg_file_get(file, PKG_FILE_PATH), sizeof(fpath));
+ 
			strlcpy(fpath, pkg_file_path(file), sizeof(fpath));
- 
		if ((pkg_file_get(file, PKG_FILE_SUM) == NULL || pkg_file_get(file, PKG_FILE_SUM)[0] == '\0') && lstat(fpath, &st) == 0 && !S_ISLNK(st.st_mode)) {
+ 
		if ((pkg_file_cksum(file) == NULL || pkg_file_cksum(file)[0] == '\0') && lstat(fpath, &st) == 0 && !S_ISLNK(st.st_mode)) {

			if (sha256_file(fpath, sha256) != EPKG_OK)

				return (EPKG_FATAL);

			strlcpy(file->sum, sha256, sizeof(file->sum));
@@ -83,11 +83,11 @@ pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archi


	while (pkg_files(pkg, &file) == EPKG_OK) {

		if (root != NULL)
- 
			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_file_get(file, PKG_FILE_PATH));
+ 
			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_file_path(file));

		else
- 
			strlcpy(fpath, pkg_file_get(file, PKG_FILE_PATH), sizeof(fpath));
+ 
			strlcpy(fpath, pkg_file_path(file), sizeof(fpath));
- 
		ret = packing_append_file_attr(pkg_archive, fpath, pkg_file_get(file, PKG_FILE_PATH), file->uname, file->gname, file->perm);
+ 
		ret = packing_append_file_attr(pkg_archive, fpath, pkg_file_path(file), file->uname, file->gname, file->perm);

		pkg_config_bool(PKG_CONFIG_DEVELOPER_MODE, &developer);

		if (developer && ret != EPKG_OK)

			return (ret);
modified libpkg/pkg_delete.c
@@ -125,14 +125,14 @@ pkg_delete_files(struct pkg *pkg, int force)
		if (file->keep == 1)

			continue;
- 
		path = pkg_file_get(file, PKG_FILE_PATH);
+ 
		path = pkg_file_path(file);



		/* Regular files and links */

		/* check sha256 */
- 
		if (!force && pkg_file_get(file, PKG_FILE_SUM)[0] != '\0') {
+ 
		if (!force && pkg_file_cksum(file)[0] != '\0') {

			if (sha256_file(path, sha256) != EPKG_OK)

				continue;
- 
			if (strcmp(sha256, pkg_file_get(file, PKG_FILE_SUM)) != 0) {
+ 
			if (strcmp(sha256, pkg_file_cksum(file)) != 0) {

				pkg_emit_error("%s fails original SHA256 checksum,"

							   " not removing", path);

				continue;
modified libpkg/pkg_elf.c
@@ -100,7 +100,7 @@ test_depends(struct pkgdb *db, struct pkg *pkg, const char *name)
		dep = NULL;

		found = false;

		while (pkg_deps(pkg, &dep) == EPKG_OK) {
- 
			if (strcmp(pkg_dep_get(dep, PKG_DEP_ORIGIN), deporigin) == 0) {
+ 
			if (strcmp(pkg_dep_origin(dep), deporigin) == 0) {

				found = true;

				break;

			}
@@ -295,7 +295,7 @@ pkg_analyse_files(struct pkgdb *db, struct pkg *pkg)
				PKG_CONTAINS_H_OR_LA);



	while (pkg_files(pkg, &file) == EPKG_OK) {
- 
		fpath = pkg_file_get(file, PKG_FILE_PATH);
+ 
		fpath = pkg_file_path(file);

		ret = analyse_elf(db, pkg, fpath);

		if (developer) {

			if (ret != EPKG_OK && ret != EPKG_END)
modified libpkg/pkg_jobs.c
@@ -129,7 +129,7 @@ pkg_jobs_keep_files_to_del(struct pkg *p1, struct pkg *p2)


		f2 = NULL;

		while (pkg_files(p2, &f2) == EPKG_OK) {
- 
			if (strcmp(pkg_file_get(f1, PKG_FILE_PATH), pkg_file_get(f2, PKG_FILE_PATH)) == 0) {
+ 
			if (strcmp(pkg_file_path(f1), pkg_file_path(f2)) == 0) {

				f1->keep = 1;

				break;

			}
modified libpkg/pkg_manifest.c
@@ -736,9 +736,9 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)
		if (map == -1)

			manifest_append_map(map, mapping, "deps", BLOCK);
- 
		manifest_append_map(depkv, map, pkg_dep_get(dep, PKG_DEP_NAME), FLOW);
- 
		manifest_append_kv(depkv, "origin", pkg_dep_get(dep, PKG_DEP_ORIGIN), PLAIN);
- 
		manifest_append_kv(depkv, "version", pkg_dep_get(dep, PKG_DEP_VERSION), PLAIN);
+ 
		manifest_append_map(depkv, map, pkg_dep_name(dep), FLOW);
+ 
		manifest_append_kv(depkv, "origin", pkg_dep_origin(dep), PLAIN);
+ 
		manifest_append_kv(depkv, "version", pkg_dep_version(dep), PLAIN);

	}



	seq = -1;
@@ -787,8 +787,8 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)
	while (pkg_files(pkg, &file) == EPKG_OK) {

		if (map == -1)

			manifest_append_map(map, mapping, "files", BLOCK);
- 
		urlencode(pkg_file_get(file, PKG_FILE_PATH), &tmpsbuf);
- 
		manifest_append_kv(map, sbuf_get(tmpsbuf), pkg_file_get(file, PKG_FILE_SUM) && strlen(pkg_file_get(file, PKG_FILE_SUM)) > 0 ? pkg_file_get(file, PKG_FILE_SUM) : "-", PLAIN);
+ 
		urlencode(pkg_file_path(file), &tmpsbuf);
+ 
		manifest_append_kv(map, sbuf_get(tmpsbuf), pkg_file_cksum(file) && strlen(pkg_file_cksum(file)) > 0 ? pkg_file_cksum(file) : "-", PLAIN);

	}



	seq = -1;
modified libpkg/pkg_repo.c
@@ -691,9 +691,9 @@ pkg_create_repo(char *path, bool force, void (progress)(struct pkg *pkg, void *d
		dep = NULL;

		while (pkg_deps(pkg, &dep) == EPKG_OK) {

			if (run_prepared_statement(DEPS,
- 
			    pkg_dep_get(dep, PKG_DEP_ORIGIN),
- 
			    pkg_dep_get(dep, PKG_DEP_NAME),
- 
			    pkg_dep_get(dep, PKG_DEP_VERSION),
+ 
			    pkg_dep_origin(dep),
+ 
			    pkg_dep_name(dep),
+ 
			    pkg_dep_version(dep),

			    package_id) != SQLITE_DONE) {

				ERROR_SQLITE(sqlite);

				retcode = EPKG_FATAL;
modified libpkg/pkgdb.c
@@ -1801,8 +1801,8 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)
	 */



	while (pkg_deps(pkg, &dep) == EPKG_OK) {
- 
		if (run_prstmt(DEPS, pkg_dep_get(dep, PKG_DEP_ORIGIN),
- 
		    pkg_dep_get(dep, PKG_DEP_NAME), pkg_dep_get(dep, PKG_DEP_VERSION),
+ 
		if (run_prstmt(DEPS, pkg_dep_origin(dep),
+ 
		    pkg_dep_name(dep), pkg_dep_version(dep),

		    package_id) != SQLITE_DONE) {

			ERROR_SQLITE(s);

			goto cleanup;
@@ -1814,10 +1814,10 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)
	 */



	while (pkg_files(pkg, &file) == EPKG_OK) {
- 
		if ((ret = run_prstmt(FILES, pkg_file_get(file, PKG_FILE_PATH),
- 
		    pkg_file_get(file, PKG_FILE_SUM), package_id)) != SQLITE_DONE) {
+ 
		if ((ret = run_prstmt(FILES, pkg_file_path(file),
+ 
		    pkg_file_cksum(file), package_id)) != SQLITE_DONE) {

			if (ret == SQLITE_CONSTRAINT) {
- 
				if ((it = pkgdb_query_which(db, pkg_file_get(file, PKG_FILE_PATH))) == NULL) {
+ 
				if ((it = pkgdb_query_which(db, pkg_file_path(file))) == NULL) {

					ERROR_SQLITE(s);

				}

				if ((ret = pkgdb_it_next(it, &pkg2, PKG_LOAD_BASIC)) == EPKG_OK) {
@@ -1826,7 +1826,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)
					    " (installs files into the same place). "

					    " Problematic file: %s",

					    name, version, name2, version2,
- 
					    pkg_file_get(file, PKG_FILE_PATH));
+ 
					    pkg_file_path(file));

					pkg_free(pkg2);

				} else {

					ERROR_SQLITE(s);
@@ -2967,13 +2967,13 @@ pkgdb_integrity_append(struct pkgdb *db, struct pkg *p)
		sqlite3_bind_text(stmt, 1, name, -1, SQLITE_STATIC);

		sqlite3_bind_text(stmt, 2, origin, -1, SQLITE_STATIC);

		sqlite3_bind_text(stmt, 3, version, -1, SQLITE_STATIC);
- 
		sqlite3_bind_text(stmt, 4, pkg_file_get(file, PKG_FILE_PATH), -1, SQLITE_STATIC);
+ 
		sqlite3_bind_text(stmt, 4, pkg_file_path(file), -1, SQLITE_STATIC);



		if (sqlite3_step(stmt) != SQLITE_DONE) {

			sbuf_clear(conflictmsg);

			sbuf_printf(conflictmsg, "WARNING: %s-%s conflict on %s with: \n",

			    name, version,
- 
			    pkg_file_get(file, PKG_FILE_PATH));
+ 
			    pkg_file_path(file));



			if (sqlite3_prepare_v2(db->sqlite, sql_conflicts, -1, &stmt_conflicts, NULL) != SQLITE_OK) {

				ERROR_SQLITE(db->sqlite);
@@ -2982,7 +2982,7 @@ pkgdb_integrity_append(struct pkgdb *db, struct pkg *p)
				return (EPKG_FATAL);

			}
- 
			sqlite3_bind_text(stmt_conflicts, 1, pkg_file_get(file, PKG_FILE_PATH), -1, SQLITE_STATIC);
+ 
			sqlite3_bind_text(stmt_conflicts, 1, pkg_file_path(file), -1, SQLITE_STATIC);



			while (sqlite3_step(stmt_conflicts) != SQLITE_DONE) {

				sbuf_printf(conflictmsg, "\t- %s-%s\n",
@@ -3195,7 +3195,7 @@ pkgdb_file_set_cksum(struct pkgdb *db, struct pkg_file *file, const char *sha256
		return (EPKG_FATAL);

	}

	sqlite3_bind_text(stmt, 1, sha256, -1, SQLITE_STATIC);
- 
	sqlite3_bind_text(stmt, 2, pkg_file_get(file, PKG_FILE_PATH), -1, SQLITE_STATIC);
+ 
	sqlite3_bind_text(stmt, 2, pkg_file_path(file), -1, SQLITE_STATIC);



	if (sqlite3_step(stmt) != SQLITE_DONE) {

		ERROR_SQLITE(db->sqlite);
modified libpkg/rcscripts.c
@@ -54,8 +54,8 @@ pkg_start_stop_rc_scripts(struct pkg *pkg, pkg_rc_attr attr)
	len = strlen(rc_d_path);



	while (pkg_files(pkg, &file) == EPKG_OK) {
- 
		if (strncmp(rc_d_path, pkg_file_get(file, PKG_FILE_PATH), len) == 0) {
- 
			rcfile = pkg_file_get(file, PKG_FILE_PATH);
+ 
		if (strncmp(rc_d_path, pkg_file_path(file), len) == 0) {
+ 
			rcfile = pkg_file_path(file);

			rcfile += len;

			rc = strrchr(rcfile, '/');

			rc++;
modified pkg/check.c
@@ -71,9 +71,9 @@ check_deps(struct pkgdb *db, struct pkg *p, struct deps_head *dh)


	while (pkg_deps(p, &dep) == EPKG_OK) {

		/* do we have a missing dependency? */
- 
		if (pkg_is_installed(db, pkg_dep_get(dep, PKG_DEP_ORIGIN)) != EPKG_OK) {
+ 
		if (pkg_is_installed(db, pkg_dep_origin(dep)) != EPKG_OK) {

			printf("%s has a missing dependency: %s\n", origin,
- 
			       pkg_dep_get(dep, PKG_DEP_ORIGIN)),
+ 
			       pkg_dep_origin(dep)),

			add_missing_dep(dep, dh, &nbpkgs);

		}

	}
@@ -90,7 +90,7 @@ add_missing_dep(struct pkg_dep *d, struct deps_head *dh, int *nbpkgs)
	assert(d != NULL);



	/* do not add duplicate entries in the queue */
- 
	origin = pkg_dep_get(d, PKG_DEP_ORIGIN);
+ 
	origin = pkg_dep_origin(d);



	STAILQ_FOREACH(e, dh, next)

		if (strcmp(e->origin, origin) == 0)
@@ -99,9 +99,9 @@ add_missing_dep(struct pkg_dep *d, struct deps_head *dh, int *nbpkgs)
	if ((e = calloc(1, sizeof(struct deps_entry))) == NULL)

		err(1, "calloc(deps_entry)");
- 
	e->name = strdup(pkg_dep_get(d, PKG_DEP_NAME));
- 
	e->version = strdup(pkg_dep_get(d, PKG_DEP_VERSION));
- 
	e->origin = strdup(pkg_dep_get(d, PKG_DEP_ORIGIN));
+ 
	e->name = strdup(pkg_dep_name(d));
+ 
	e->version = strdup(pkg_dep_version(d));
+ 
	e->origin = strdup(pkg_dep_origin(d));



	(*nbpkgs)++;
modified pkg/event.c
@@ -144,7 +144,7 @@ event_callback(void *data, struct pkg_event *ev)
		pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version);

		fprintf(stderr, "%s-%s is required by:", name, version);

		while (pkg_rdeps(pkg, &dep) == EPKG_OK) {
- 
			fprintf(stderr, " %s-%s", pkg_dep_get(dep, PKG_DEP_NAME), pkg_dep_get(dep, PKG_DEP_VERSION));
+ 
			fprintf(stderr, " %s-%s", pkg_dep_name(dep), pkg_dep_version(dep));

		}

		if (ev->e_required.force == 1)

			fprintf(stderr, ", deleting anyway\n");
@@ -158,8 +158,8 @@ event_callback(void *data, struct pkg_event *ev)
		printf("%s-%s already installed\n", name, version);

		break;

	case PKG_EVENT_MISSING_DEP:
- 
		fprintf(stderr, "missing dependency %s-%s", pkg_dep_get(ev->e_missing_dep.dep, PKG_DEP_NAME),
- 
		    pkg_dep_get(ev->e_missing_dep.dep, PKG_DEP_VERSION));
+ 
		fprintf(stderr, "missing dependency %s-%s", pkg_dep_name(ev->e_missing_dep.dep),
+ 
		    pkg_dep_version(ev->e_missing_dep.dep));

		break;

	case PKG_EVENT_NOREMOTEDB:

		fprintf(stderr, "Unable to open remote database \"%s\". Try running '%s update' first.\n", ev->e_remotedb.repo, getprogname());
@@ -175,7 +175,7 @@ event_callback(void *data, struct pkg_event *ev)
		break;

	case PKG_EVENT_FILE_MISMATCH:

		pkg_get(ev->e_file_mismatch.pkg, PKG_NAME, &name, PKG_VERSION, &version);
- 
		fprintf(stderr, "%s-%s: checksum mismatch for %s\n", name, version, pkg_file_get(ev->e_file_mismatch.file, PKG_FILE_PATH));
+ 
		fprintf(stderr, "%s-%s: checksum mismatch for %s\n", name, version, pkg_file_path(ev->e_file_mismatch.file));

	default:

		break;

	}
modified pkg/main.c
@@ -62,29 +62,29 @@ static struct commands {
	{ "add", "Registers a package and installs it on the system", exec_add, usage_add},

	{ "audit", "Reports vulnerable packages", exec_audit, usage_audit},

	{ "autoremove", "Removes orphan packages", exec_autoremove, usage_autoremove},
- 
	{ "backup", "Backup and restore the local package database", exec_backup, usage_backup},
- 
	{ "check", "Check for missing dependencies and database consistency", exec_check, usage_check},
+ 
	{ "backup", "Backs-up and restores the local package database", exec_backup, usage_backup},
+ 
	{ "check", "Checks for missing dependencies and database consistency", exec_check, usage_check},

	{ "clean", "Cleans old packages from the cache", exec_clean, usage_clean},

	{ "create", "Creates software package distributions", exec_create, usage_create},

	{ "delete", "Deletes packages from the database and the system", exec_delete, usage_delete},

	{ "fetch", "Fetches packages from a remote repository", exec_fetch, usage_fetch},

	{ "help", "Displays help information", exec_help, usage_help},
- 
	{ "info", "Displays information for installed packages", exec_info, usage_info},
+ 
	{ "info", "Displays information about installed packages", exec_info, usage_info},

	{ "install", "Installs packages from remote package repositories", exec_install, usage_install},
- 
	{ "query", "Query information for installed packages", exec_query, usage_query},
- 
	{ "search", "Performs a search in remote package repositories", exec_search, usage_search},
- 
	{ "set", "Modify local database informations", exec_set, usage_set},
- 
	{ "register", "Registers a package into the local package database", exec_register, usage_register},
+ 
	{ "query", "Queries information about installed packages", exec_query, usage_query},
+ 
	{ "search", "Performs a search of package repository catalogues", exec_search, usage_search},
+ 
	{ "set", "Modifies information about packages in the local database", exec_set, usage_set},
+ 
	{ "register", "Registers a package into the local database", exec_register, usage_register},

	{ "remove", "Deletes packages from the database and the system", exec_delete, usage_delete},
- 
	{ "repo", "Creates a package database repository", exec_repo, usage_repo},
- 
	{ "rquery", "Query information from the remote repository", exec_rquery, usage_rquery},
- 
	{ "shell", "Open a debug shell", exec_shell, usage_shell},
- 
	{ "shlib", "Displays which package links against a specific shared library", exec_shlib, usage_shlib},
- 
	{ "stats", "Display package database statistics", exec_stats, usage_stats},
- 
	{ "update", "Updates remote package repository databases", exec_update, usage_update},
+ 
	{ "repo", "Creates a package repository catalogue", exec_repo, usage_repo},
+ 
	{ "rquery", "Queries information in repository catalogues", exec_rquery, usage_rquery},
+ 
	{ "shell", "Opens a debug shell", exec_shell, usage_shell},
+ 
	{ "shlib", "Displays which packages link against a specific shared library", exec_shlib, usage_shlib},
+ 
	{ "stats", "Displays package database statistics", exec_stats, usage_stats},
+ 
	{ "update", "Updates package repository catalogues", exec_update, usage_update},

	{ "updating", "Displays UPDATING information for a package", exec_updating, usage_updating},
- 
	{ "upgrade", "Performs upgrades of package software distributions", exec_upgrade, usage_upgrade},
- 
	{ "version", "Summarize installed versions of packages", exec_version, usage_version},
+ 
	{ "upgrade", "Performs upgrades of packaged software distributions", exec_upgrade, usage_upgrade},
+ 
	{ "version", "Displays the versions of installed packages", exec_version, usage_version},

	{ "which", "Displays which package installed a specific file", exec_which, usage_which},

};
modified pkg/pkg-fetch.8
@@ -33,7 +33,7 @@ is used to download binary packages from a remote repository.
.Pp

One or more packages, or patterns can be specified.

.Pp
- 
The remote repository will automatically be updated using
+ 
Repository catalogues will be updated automatically using

.Xr pkg-update 8 .

This can be disabled with the

.Fl L
modified pkg/pkg-update.8
@@ -33,12 +33,12 @@ Updates to catalogues are normally downloaded
only when the master copy on the remote package repository is newer than the

local copy.

.Pp
- 
The remote repository catalogues to be updated are defined in the
+ 
The repository catalogues to be updated are defined in the

.Xr pkg.conf 5

file.

.Pp
- 
It is always a good idea to update your remote package
- 
repository catalogues before doing a remote install via
+ 
It is always a good idea to update your package repository catalogues
+ 
before doing a remote install via

.Xr pkg-install 8

or upgrades via

.Xr pkg-upgrade 8 .
@@ -46,7 +46,7 @@ or upgrades via
.Ss Signed repositories

If the repository catalogue is signed and

.Ev PUBKEY
- 
is defined, it will be verified after being downloaded.
+ 
is defined, the signature will be verified after download.

See

.Xr pkg.conf 5

for more information.
modified pkg/pkg-upgrade.8
@@ -28,7 +28,7 @@
.Nm

is used for upgrading of package software distributions.

.Pp
- 
Currently only one remote package repository database can be
+ 
Currently only one package repository can be

used during package upgrades as defined by the environment variable

.Ev PACKAGESITE .

.Pp
@@ -36,7 +36,7 @@ Soon enough
.Nm

will be able to perform package upgrades from multiple repositories.

.Pp
- 
The remote repository will automatically be updated using
+ 
Repository catalogues will automatically be updated using

.Xr pkg-update 8 .

This can be disabled with the

.Fl L
modified pkg/pkg.8
@@ -111,9 +111,8 @@ Display information about installed packages.
Install a package from a remote package repository.

If a package is found in more than one remote repository,

then installation happens from the first one.
- 
If a package
- 
fails to fetch from the remote repository, the next one in
- 
the list is tried, until the package is fetched.
+ 
Downloading a package is tried from each package repository in turn,
+ 
until the package is successfully fetched.

.It Ic query

Query information about installed packages.

.It Ic register
modified pkg/query.c
@@ -198,20 +198,20 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)
				case 'd':

					qstr++;

					if (qstr[0] == 'n')
- 
						sbuf_cat(dest, pkg_dep_get((struct pkg_dep *)data, PKG_DEP_NAME));
+ 
						sbuf_cat(dest, pkg_dep_name((struct pkg_dep *)data));

					else if (qstr[0] == 'o')
- 
						sbuf_cat(dest, pkg_dep_get((struct pkg_dep *)data, PKG_DEP_ORIGIN));
+ 
						sbuf_cat(dest, pkg_dep_origin((struct pkg_dep *)data));

					else if (qstr[0] == 'v')
- 
						sbuf_cat(dest, pkg_dep_get((struct pkg_dep *)data, PKG_DEP_VERSION));
+ 
						sbuf_cat(dest, pkg_dep_version((struct pkg_dep *)data));

					break;

				case 'r':

					qstr++;

					if (qstr[0] == 'n')
- 
						sbuf_cat(dest, pkg_dep_get((struct pkg_dep *)data, PKG_DEP_NAME));
+ 
						sbuf_cat(dest, pkg_dep_name((struct pkg_dep *)data));

					else if (qstr[0] == 'o')
- 
						sbuf_cat(dest, pkg_dep_get((struct pkg_dep *)data, PKG_DEP_ORIGIN));
+ 
						sbuf_cat(dest, pkg_dep_origin((struct pkg_dep *)data));

					else if (qstr[0] == 'v')
- 
						sbuf_cat(dest, pkg_dep_get((struct pkg_dep *)data, PKG_DEP_VERSION));
+ 
						sbuf_cat(dest, pkg_dep_version((struct pkg_dep *)data));

					break;

				case 'C':

					sbuf_cat(dest, pkg_category_name((struct pkg_category *)data));
@@ -219,9 +219,9 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)
				case 'F':

					qstr++;

					if (qstr[0] == 'p')
- 
						sbuf_cat(dest, pkg_file_get((struct pkg_file *)data, PKG_FILE_PATH));
+ 
						sbuf_cat(dest, pkg_file_path((struct pkg_file *)data));

					else if (qstr[0] == 's')
- 
						sbuf_cat(dest, pkg_file_get((struct pkg_file *)data, PKG_FILE_SUM));
+ 
						sbuf_cat(dest, pkg_file_cksum((struct pkg_file *)data));

					break;

				case 'O':

					qstr++;
modified pkg/update.c
@@ -41,7 +41,7 @@
#include "pkgcli.h"



/**
- 
 * Fetch remote databases.
+ 
 * Fetch repository calalogues.

 */

int

pkgcli_update(bool force) {
@@ -52,7 +52,7 @@ pkgcli_update(bool force) {
	int retcode;



	if (!quiet)
- 
		printf("Updating remote repository\n");
+ 
		printf("Updating repository catalogue\n");



	pkg_config_bool(PKG_CONFIG_MULTIREPOS, &multi_repos);
@@ -72,7 +72,8 @@ pkgcli_update(bool force) {
		retcode = pkg_update("repo", packagesite, force);

		if (retcode == EPKG_UPTODATE) {

			if (!quiet)
- 
				printf("Remote repository up-to-date, no need to upgrade\n");
+ 
				printf("Repository catalogue is up-to-date, "
+ 
				       "no need to fetch fresh copy\n");

			retcode = EPKG_OK;

		}

	} else {
@@ -84,7 +85,9 @@ pkgcli_update(bool force) {
			retcode = pkg_update(repo_name, packagesite, force);

			if (retcode == EPKG_UPTODATE) {

				if (!quiet)
- 
					printf("%s repository up-to-date, no need to upgrade\n", repo_name);
+ 
					printf("%s repository catalogue is "
+ 
					       "up-to-date, no need to fetch "
+ 
					       "fresh copy\n", repo_name);

				retcode = EPKG_OK;

			}

		}
@@ -130,7 +133,7 @@ exec_update(int argc, char **argv)
	}



	if (geteuid() != 0) {
- 
		warnx("Updating the remote database can only be done as root");
+ 
		warnx("Updating repository catalogues can only be done as root");

		return (EX_NOPERM);

	}
modified pkg/utils.c
@@ -220,7 +220,7 @@ print_info(struct pkg * const pkg, unsigned int opt)
			printf("%s-%s depends on:\n", name, version);



                while (pkg_deps(pkg, &dep) == EPKG_OK) {
- 
                        printf("%s-%s\n", pkg_dep_get(dep, PKG_DEP_NAME), pkg_dep_get(dep, PKG_DEP_VERSION));
+ 
                        printf("%s-%s\n", pkg_dep_name(dep), pkg_dep_version(dep));

                }



                if (!(opt & INFO_QUIET))
@@ -233,7 +233,7 @@ print_info(struct pkg * const pkg, unsigned int opt)
			printf("%s-%s is required by:\n", name, version);



                while (pkg_rdeps(pkg, &dep) == EPKG_OK) {
- 
                        printf("%s-%s\n", pkg_dep_get(dep, PKG_DEP_NAME), pkg_dep_get(dep, PKG_DEP_VERSION));
+ 
                        printf("%s-%s\n", pkg_dep_name(dep), pkg_dep_version(dep));

                }



                if (!(opt & INFO_QUIET))
@@ -243,7 +243,7 @@ print_info(struct pkg * const pkg, unsigned int opt)
			printf("%s-%s owns the following files:\n", name, version);



                while (pkg_files(pkg, &file) == EPKG_OK) {
- 
                        printf("%s\n", pkg_file_get(file, PKG_FILE_PATH));
+ 
                        printf("%s\n", pkg_file_path(file));

                }



                if (!(opt & INFO_QUIET))