6757141 Use a single function to retrive pkg informations: — HardenedBSD-pkg

modified libpkg/backup.c

@@ -27,15 +27,18 @@ pkgdb_dump(struct pkgdb *db, char *dest)

 	}
 	while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
 		const char *name, *version, *mtree;
 		pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version, PKG_MTREE, &mtree);
 		pkg_emit_manifest(pkg, &m);
 		sbuf_clear(path);
 		sbuf_printf(path, "%s-%s.yaml", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 		sbuf_printf(path, "%s-%s.yaml", name, version);
 		packing_append_buffer(pack, m, sbuf_data(path), strlen(m));
 		free(m);
 		if (pkg_get(pkg, PKG_MTREE) != NULL) {
 		if (mtree != NULL) {
 			sbuf_clear(path);
 			sbuf_printf(path, "%s-%s.mtree", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 			packing_append_buffer(pack, pkg_get(pkg, PKG_MTREE), sbuf_data(path), strlen(pkg_get(pkg, PKG_MTREE)));
 			sbuf_printf(path, "%s-%s.mtree", name, version);
 			packing_append_buffer(pack, mtree, sbuf_data(path), strlen(mtree));
 		}
 	}

modified libpkg/pkg.c

@@ -151,16 +151,54 @@ pkg_is_valid(struct pkg *pkg)

 	return (ret);
 }
 const char *
 pkg_get(struct pkg const * const pkg, const pkg_attr attr)
 static int
 pkg_vget(struct pkg const *const pkg, va_list ap)
 {
 	int attr;
 	while ((attr = va_arg(ap, int)) != -1) {
 		if (attr < PKG_NUM_FIELDS) {
 			*va_arg(ap, const char **) = sbuf_get(pkg->fields[attr]);
 			continue;
 		}
 		switch (attr) {
 			case PKG_FLATSIZE:
 				*va_arg(ap, int64_t *) = pkg->flatsize;
 				break;
 			case PKG_NEW_FLATSIZE:
 				*va_arg(ap, int64_t *) = pkg->new_flatsize;
 				break;
 			case PKG_NEW_PKGSIZE:
 				*va_arg(ap, int64_t *) = pkg->new_pkgsize;
 				break;
 			case PKG_LICENSE_LOGIC:
 				*va_arg(ap, lic_t *) = pkg->licenselogic;
 				break;
 			case PKG_AUTOMATIC:
 				*va_arg(ap, bool *) = pkg->automatic;
 				break;
 			default:
 				va_arg(ap, void *); /* ignore */
 				break;
 		}
 	}
 	return (EPKG_OK);
 }
 int
 pkg_get2(struct pkg const *const pkg, ...)
 {
 	int ret = EPKG_OK;
 	va_list ap;
 	assert(pkg != NULL);
 	assert(attr < PKG_NUM_FIELDS);
 	if ((fields[attr].type & pkg->type) == 0)
 		pkg_emit_error("wrong usage of `attr` for this type of `pkg`");
 	va_start(ap, pkg);
 	ret = pkg_vget(pkg, ap);
 	va_end(ap);
 	return (sbuf_get(pkg->fields[attr]));
 	return (ret);
 }
 int

@@ -222,14 +260,6 @@ pkg_set_from_file(struct pkg *pkg, pkg_attr attr, const char *path)

 	return (ret);
 }
 int64_t
 pkg_flatsize(struct pkg *pkg)
 {
 	assert(pkg != NULL);
 	return (pkg->flatsize);
 }
 int
 pkg_set_automatic(struct pkg *pkg)
 {

@@ -241,30 +271,6 @@ pkg_set_automatic(struct pkg *pkg)

 }
 int
 pkg_is_automatic(struct pkg *pkg)
 {
 	assert(pkg != NULL);
 	return (pkg->automatic);
 }
 int64_t
 pkg_new_flatsize(struct pkg *pkg)
 {
 	assert(pkg != NULL);
 	return (pkg->new_flatsize);
 }
 int64_t
 pkg_new_pkgsize(struct pkg *pkg)
 {
 	assert(pkg != NULL);
 	return (pkg->new_pkgsize);
 }
 int
 pkg_set_flatsize(struct pkg *pkg, int64_t size)
 {
 	assert(pkg != NULL);

@@ -304,14 +310,6 @@ pkg_set_licenselogic(struct pkg *pkg, int64_t logic)

 	return (EPKG_OK);
 }
 lic_t
 pkg_licenselogic(struct pkg *pkg)
 {
 	assert(pkg != NULL);
 	return (pkg->licenselogic);
 }
 int
 pkg_set_rowid(struct pkg *pkg, int64_t rowid) {
 	assert(pkg != NULL);

@@ -425,10 +423,12 @@ pkg_addlicense(struct pkg *pkg, const char *name)

 	assert(pkg != NULL);
 	assert(name != NULL && name[0] != '\0');
 	const char *pkgname;
 	if (pkg->licenselogic == LICENSE_SINGLE && !STAILQ_EMPTY(&pkg->licenses)) {
 		pkg_get(pkg, PKG_NAME, &pkgname);
 		pkg_emit_error("%s is have a single license which is already set",
 					   pkg_get(pkg, PKG_NAME));
 		    pkgname);
 		return (EPKG_FATAL);
 	}

modified libpkg/pkg.h

@@ -133,7 +133,12 @@ typedef enum {

 	PKG_CKSUM,
 	PKG_NEWVERSION,
 	PKG_REPONAME,
 	PKG_REPOURL
 	PKG_REPOURL, /* end of fields */
 	PKG_FLATSIZE,
 	PKG_NEW_FLATSIZE,
 	PKG_NEW_PKGSIZE,
 	PKG_LICENSE_LOGIC,
 	PKG_AUTOMATIC
 } pkg_attr;
 /**

@@ -268,22 +273,8 @@ pkg_t pkg_type(struct pkg const * const);

  * @return NULL-terminated string.
  * @warning May return a NULL pointer.
  */
 const char *pkg_get(struct pkg const * const , const pkg_attr);
 /**
  * @return the size of the uncompressed package.
  */
 int64_t pkg_flatsize(struct pkg *);
 /**
  * @return the size of the uncompressed new package (PKG_REMOTE).
  */
 int64_t pkg_new_flatsize(struct pkg *);
 /**
  * @return the size of the compressed new package (PKG_REMOTE).
  */
 int64_t pkg_new_pkgsize(struct pkg *);
 int pkg_get2(struct pkg const *const, ...);
 #define pkg_get(pkg, ...) pkg_get2(pkg, __VA_ARGS__, -1)
 int pkg_list_is_empty(struct pkg *, pkg_list);
 /**

@@ -381,7 +372,6 @@ int pkg_set_mtree(struct pkg *pkg, const char *value);

 int pkg_set_from_file(struct pkg *pkg, pkg_attr attr, const char *file);
 int pkg_set_automatic(struct pkg *pkg);
 int pkg_is_automatic(struct pkg *pkg);
 /**
  * set the logic for license combinaison

@@ -389,11 +379,6 @@ int pkg_is_automatic(struct pkg *pkg);

 int pkg_set_licenselogic(struct pkg *pkg, int64_t licenselogic);
 /**
  * get the logic for license combinaison
  */
 lic_t pkg_licenselogic(struct pkg *pkg);
 /**
  * Set the uncompressed size of the package.
  * @return An error code.
  */

@@ -420,6 +405,7 @@ int pkg_adddep(struct pkg *pkg, const char *name, const char *origin, const

 int pkg_addrdep(struct pkg *pkg, const char *name, const char *origin, const
 			   char *version);
 //int pkg_addfile(struct pkg *, const char *fmt);
 /**
  * Allocate a new struct pkg_file and add it to the files of pkg.
  * @param sha256 The ascii representation of the sha256 or a NULL pointer.

modified libpkg/pkg_add.c

@@ -81,6 +81,8 @@ do_extract(struct archive *a, struct archive_entry *ae)

 int
 pkg_add(struct pkgdb *db, const char *path, int flags)
 {
 	const char *arch;
 	const char *origin;
 	struct archive *a;
 	struct archive_entry *ae;
 	struct pkgdb_it *it;

@@ -122,9 +124,12 @@ pkg_add(struct pkgdb *db, const char *path, int flags)

 	/*
 	 * Check the architecture
 	 */
 	if (strcmp(u.machine, pkg_get(pkg, PKG_ARCH)) != 0) {
 	pkg_get(pkg, PKG_ARCH, &arch, PKG_ORIGIN, &origin);
 	if (strcmp(u.machine, arch) != 0) {
 		pkg_emit_error("wrong architecture: %s instead of %s",
 					   pkg_get(pkg, PKG_ARCH), u.machine);
 		    arch, u.machine);
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}

@@ -136,7 +141,7 @@ pkg_add(struct pkgdb *db, const char *path, int flags)

 	/*
 	 * Check if the package is already installed
 	 */
 	it = pkgdb_query(db, pkg_get(pkg, PKG_ORIGIN), MATCH_EXACT);
 	it = pkgdb_query(db, origin, MATCH_EXACT);
 	if (it == NULL) {
 		retcode = EPKG_FATAL;
 		goto cleanup;

modified libpkg/pkg_create.c

@@ -48,7 +48,7 @@ pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archi

 	packing_append_buffer(pkg_archive, m, "+MANIFEST", strlen(m));
 	free(m);
 	mtree = pkg_get(pkg, PKG_MTREE);
 	pkg_get(pkg, PKG_MTREE, &mtree);
 	if (mtree != NULL)
 		packing_append_buffer(pkg_archive, mtree, "+MTREE_DIRS", strlen(mtree));

@@ -78,6 +78,7 @@ pkg_create_archive(const char *outdir, struct pkg *pkg, pkg_formats format, int

 {
 	char *pkg_path = NULL;
 	struct packing *pkg_archive = NULL;
 	const char *pkgname, *pkgversion;
 	/*
 	 * Ensure that we have all the information we need

@@ -87,7 +88,8 @@ pkg_create_archive(const char *outdir, struct pkg *pkg, pkg_formats format, int

 	if (mkdirs(outdir) != EPKG_OK)
 		return NULL;
 	if (asprintf(&pkg_path, "%s/%s-%s", outdir, pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION)) == -1) {
 	pkg_get(pkg, PKG_NAME, &pkgname, PKG_VERSION, &pkgversion);
 	if (asprintf(&pkg_path, "%s/%s-%s", outdir, pkgname, pkgversion) == -1) {
 		pkg_emit_errno("asprintf", "");
 		return (NULL);
 	}

modified libpkg/pkg_delete.c

@@ -18,6 +18,7 @@ pkg_delete(struct pkg *pkg, struct pkgdb *db, int flags)

 	struct pkg_dep *rdep = NULL;
 	int ret;
 	bool handle_rc = false;
 	const char *origin;
 	assert(pkg != NULL);
 	assert(db != NULL);

@@ -83,7 +84,8 @@ pkg_delete(struct pkg *pkg, struct pkgdb *db, int flags)

 	if (flags ^ PKG_DELETE_UPGRADE)
 		pkg_emit_deinstall_finished(pkg);
 	return (pkgdb_unregister_pkg(db, pkg_get(pkg, PKG_ORIGIN)));
 	pkg_get(pkg, PKG_ORIGIN, &origin);
 	return (pkgdb_unregister_pkg(db, origin));
 }
 int

modified libpkg/pkg_elf.c

@@ -21,6 +21,8 @@ analyse_elf(struct pkgdb *db, struct pkg *pkg, const char *fpath)

 	GElf_Shdr shdr;
 	Elf_Data *data;
 	GElf_Dyn *dyn, dyn_mem;
 	const char *pkgorigin, *pkgname, *pkgversion;
 	size_t numdyn;
 	size_t dynidx;
 	void *handle;

@@ -30,6 +32,7 @@ analyse_elf(struct pkgdb *db, struct pkg *pkg, const char *fpath)

 	int fd;
 	pkg_get(pkg, PKG_ORIGIN, &pkgorigin, PKG_NAME, &pkgname, PKG_VERSION, &pkgversion);
 	if ((fd = open(fpath, O_RDONLY, 0)) < 0)
 		return (EPKG_FATAL);

@@ -71,14 +74,13 @@ analyse_elf(struct pkgdb *db, struct pkg *pkg, const char *fpath)

 			if (pkgdb_it_next(it, &p, PKG_LOAD_BASIC) == EPKG_OK) {
 				found = false;
 				while (pkg_deps(pkg, &dep) == EPKG_OK) {
 					if (strcmp(pkg_dep_get(dep, PKG_DEP_ORIGIN), pkg_get(p, PKG_ORIGIN)) == 0)
 					if (strcmp(pkg_dep_get(dep, PKG_DEP_ORIGIN), pkgorigin) == 0)
 						found = true;
 				}
 				if (!found) {
 					pkg_emit_error("adding forgotten depends (%s): %s-%s",
 								   map->l_name, pkg_get(p, PKG_NAME),
 								   pkg_get(p, PKG_VERSION));
 					pkg_adddep(pkg, pkg_get(p, PKG_NAME), pkg_get(p, PKG_ORIGIN), pkg_get(p, PKG_VERSION));
 					    map->l_name, pkgname, pkgversion);
 					pkg_adddep(pkg, pkgname, pkgorigin, pkgversion);
 				}
 			}
 			dlclose(handle);

modified libpkg/pkg_jobs.c

@@ -138,8 +138,11 @@ pkg_jobs_install(struct pkg_jobs *j)

 	STAILQ_INIT(&pkg_queue);
 	/* check for available size to fetch */
 	while (pkg_jobs(j, &p) == EPKG_OK)
 		dlsize += pkg_new_pkgsize(p);
 	while (pkg_jobs(j, &p) == EPKG_OK) {
 		int64_t pkgsize;
 		pkg_get(pkg, PKG_NEW_PKGSIZE, &pkgsize);
 		dlsize += pkgsize;
 	}
 	if (pkg_config_string(PKG_CONFIG_CACHEDIR, &cachedir) != EPKG_OK)
 		return (EPKG_FATAL);

@@ -173,8 +176,11 @@ pkg_jobs_install(struct pkg_jobs *j)

 	pkg_emit_integritycheck_begin();
 	while (pkg_jobs(j, &p) == EPKG_OK) {
 		const char *pkgrepopath;
 		pkg_get(pkg, PKG_REPOPATH, &pkgrepopath, -1);
 		snprintf(path, sizeof(path), "%s/%s", cachedir,
 				pkg_get(p, PKG_REPOPATH));
 		    pkgrepopath);
 		if (pkg_open(&pkg, path, buf) != EPKG_OK)
 			return (EPKG_FATAL);

@@ -193,24 +199,29 @@ pkg_jobs_install(struct pkg_jobs *j)

 	/* Install */
 	sql_exec(j->db->sqlite, "SAVEPOINT upgrade;");
 	while (pkg_jobs(j, &p) == EPKG_OK) {
 		const char *pkgorigin, *pkgrepopath, *newversion, *origin;
 		bool automatic;
 		flags = 0;
 		it = pkgdb_integrity_conflict_local(j->db, pkg_get(p, PKG_ORIGIN));
 		pkg_get(p, PKG_ORIGIN, &pkgorigin, PKG_REPOPATH, &pkgrepopath,
 		    PKG_NEWVERSION, &newversion, PKG_AUTOMATIC, &automatic);
 		it = pkgdb_integrity_conflict_local(j->db, pkgorigin);
 		if (it != NULL) {
 			pkg = NULL;
 			while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC|PKG_LOAD_FILES|PKG_LOAD_SCRIPTS|PKG_LOAD_DIRS) == EPKG_OK) {
 				STAILQ_INSERT_TAIL(&pkg_queue, pkg, next);
 				pkg_script_run(pkg, PKG_SCRIPT_PRE_DEINSTALL);
 				pkgdb_unregister_pkg(j->db, pkg_get(pkg, PKG_ORIGIN));
 				pkg_get(pkg, PKG_ORIGIN, &origin);
 				pkgdb_unregister_pkg(j->db, origin);
 				pkg = NULL;
 			}
 			pkgdb_it_free(it);
 		}
 		snprintf(path, sizeof(path), "%s/%s", cachedir,
 				 pkg_get(p, PKG_REPOPATH));
 		snprintf(path, sizeof(path), "%s/%s", cachedir, pkgrepopath);
 		pkg_open(&newpkg, path, NULL);
 		if (pkg_get(p, PKG_NEWVERSION) != NULL) {
 		if (newversion != NULL) {
 			pkg_emit_upgrade_begin(p);
 		} else {
 			pkg_emit_install_begin(newpkg);

@@ -219,7 +230,8 @@ pkg_jobs_install(struct pkg_jobs *j)

 			pkg_jobs_keep_files_to_del(pkg, newpkg);
 		STAILQ_FOREACH_SAFE(pkg, &pkg_queue, next, pkg_temp) {
 			if (strcmp(pkg_get(p, PKG_ORIGIN), pkg_get(pkg, PKG_ORIGIN)) == 0) {
 			pkg_get(pkg, PKG_ORIGIN, &origin);
 			if (strcmp(pkgorigin, origin) == 0) {
 				STAILQ_REMOVE(&pkg_queue, pkg, pkg, next);
 				pkg_delete_files(pkg, 1);
 				pkg_script_run(pkg, PKG_SCRIPT_POST_DEINSTALL);

@@ -230,7 +242,7 @@ pkg_jobs_install(struct pkg_jobs *j)

 		}
 		flags |= PKG_ADD_UPGRADE;
 		if (pkg_is_automatic(p))
 		if (automatic)
 			flags |= PKG_ADD_AUTOMATIC;
 		if (pkg_add(j->db, path, flags) != EPKG_OK) {

@@ -238,7 +250,7 @@ pkg_jobs_install(struct pkg_jobs *j)

 			return (EPKG_FATAL);
 		}
 		if (pkg_get(p, PKG_NEWVERSION) != NULL)
 		if (newversion != NULL)
 			pkg_emit_upgrade_finished(p);
 		else
 			pkg_emit_install_finished(newpkg);

modified libpkg/pkg_manifest.c

@@ -655,6 +655,10 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 	int scripts = -1;
 	const char *script_types = NULL;
 	struct sbuf *destbuf = sbuf_new_auto();
 	const char *name, *version, *pkgorigin, *comment, *pkgarch, *osversion, *www, *pkgmaintainer, *prefix;
 	const char *desc, *message;
 	lic_t licenselogic;
 	int64_t flatsize;
 	yaml_emitter_initialize(&emitter);
 	yaml_emitter_set_unicode(&emitter, 1);

@@ -671,16 +675,21 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 	yaml_document_initialize(&doc, NULL, NULL, NULL, 1, 1);
 	mapping = yaml_document_add_mapping(&doc, NULL, YAML_BLOCK_MAPPING_STYLE);
 	manifest_append_kv(mapping, "name", pkg_get(pkg, PKG_NAME));
 	manifest_append_kv(mapping, "version", pkg_get(pkg, PKG_VERSION));
 	manifest_append_kv(mapping, "origin", pkg_get(pkg, PKG_ORIGIN));
 	manifest_append_kv(mapping, "comment", pkg_get(pkg, PKG_COMMENT));
 	manifest_append_kv(mapping, "arch", pkg_get(pkg, PKG_ARCH));
 	manifest_append_kv(mapping, "osversion", pkg_get(pkg, PKG_OSVERSION));
 	manifest_append_kv(mapping, "www", pkg_get(pkg, PKG_WWW));
 	manifest_append_kv(mapping, "maintainer", pkg_get(pkg, PKG_MAINTAINER));
 	manifest_append_kv(mapping, "prefix", pkg_get(pkg, PKG_PREFIX));
 	switch (pkg_licenselogic(pkg)) {
 	pkg_get(pkg, PKG_NAME, &name, PKG_ORIGIN, &pkgorigin, PKG_COMMENT, &comment,
 	    PKG_ARCH, &pkgarch, PKG_OSVERSION, osversion, PKG_WWW, &www,
 	    PKG_MAINTAINER, &pkgmaintainer, PKG_PREFIX, &prefix,
 	    PKG_LICENSE_LOGIC, &licenselogic, PKG_DESC, &desc,
 	    PKG_FLATSIZE, &flatsize);
 	manifest_append_kv(mapping, "name", name);
 	manifest_append_kv(mapping, "version", version);
 	manifest_append_kv(mapping, "origin", pkgorigin);
 	manifest_append_kv(mapping, "comment", comment);
 	manifest_append_kv(mapping, "arch", pkgarch);
 	manifest_append_kv(mapping, "osversion", osversion);
 	manifest_append_kv(mapping, "www", www);
 	manifest_append_kv(mapping, "maintainer", pkgmaintainer);
 	manifest_append_kv(mapping, "prefix", prefix);
 	switch (licenselogic) {
 		case LICENSE_SINGLE:
 			manifest_append_kv(mapping, "licenselogic", "single");
 			break;

@@ -696,9 +705,9 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 	while (pkg_licenses(pkg, &license) == EPKG_OK)
 		manifest_append_seqval(&doc, mapping, &seq, "licenses", pkg_license_name(license));
 	snprintf(tmpbuf, BUFSIZ, "%" PRId64, pkg_flatsize(pkg));
 	snprintf(tmpbuf, BUFSIZ, "%" PRId64, flatsize);
 	manifest_append_kv(mapping, "flatsize", tmpbuf);
 	urlencode(pkg_get(pkg, PKG_DESC), &tmpsbuf);
 	urlencode(desc, &tmpsbuf);
 	manifest_append_kv_literal(mapping, "desc", sbuf_data(tmpsbuf));
 	while (pkg_deps(pkg, &dep) == EPKG_OK) {

@@ -817,8 +826,8 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 		}
 		manifest_append_kv_literal(scripts, script_types, pkg_script_data(script));
 	}
 	if (pkg_get(pkg, PKG_MESSAGE) != NULL && pkg_get(pkg, PKG_MESSAGE)[0] != '\0')
 		manifest_append_kv_literal(mapping, "message", pkg_get(pkg, PKG_MESSAGE));
 	if (message != NULL && *message != '\0')
 		manifest_append_kv_literal(mapping, "message", message);
 	if (!yaml_emitter_dump(&emitter, &doc))
 		rc = EPKG_FATAL;

modified libpkg/pkg_ports.c

@@ -66,7 +66,7 @@ ports_parse_plist(struct pkg *pkg, char *plist)

 	if ((ret = file_to_buffer(plist, &plist_buf, &sz)) != EPKG_OK)
 		return (ret);
 	prefix = pkg_get(pkg, PKG_PREFIX);
 	pkg_get(pkg, PKG_PREFIX, &prefix);
 	slash = prefix[strlen(prefix) - 1] == '/' ? "" : "/";
 	nbel = split_chr(plist_buf, '\n');

@@ -87,7 +87,7 @@ ports_parse_plist(struct pkg *pkg, char *plist)

 				/* with no arguments default to the original
 				 * prefix */
 				if (buf[0] == '\0')
 					prefix = pkg_get(pkg, PKG_PREFIX);
 					pkg_get(pkg, PKG_PREFIX, &prefix);
 				else
 					prefix = buf;
 				slash = prefix[strlen(prefix) - 1] == '/' ? "" : "/";

modified libpkg/pkg_repo.c

@@ -76,14 +76,15 @@ pkg_repo_fetch(struct pkg *pkg)

 	const char *cachedir = NULL;
 	bool multirepos_enabled = false;
 	int retcode = EPKG_OK;
 	const char *repopath, *repourl, *sum, *name, *version;
 	assert((pkg->type & PKG_REMOTE) == PKG_REMOTE);
 	if (pkg_config_string(PKG_CONFIG_CACHEDIR, &cachedir) != EPKG_OK)
 		return (EPKG_FATAL);
 	snprintf(dest, sizeof(dest), "%s/%s", cachedir,
 			 pkg_get(pkg, PKG_REPOPATH));
 	pkg_get(pkg, PKG_REPOPATH, &repopath, PKG_REPOURL, &repourl,
 	    PKG_CKSUM, &sum);
 	/* If it is already in the local cachedir, dont bother to download it */
 	if (access(dest, F_OK) == 0)

@@ -107,7 +108,7 @@ pkg_repo_fetch(struct pkg *pkg)

 	pkg_config_bool(PKG_CONFIG_MULTIREPOS, &multirepos_enabled);
 	if (multirepos_enabled) {
 		packagesite = pkg_get(pkg, PKG_REPOURL);
 		packagesite = repourl;
 	} else {
 		pkg_config_string(PKG_CONFIG_REPO, &packagesite);
 	}

@@ -119,9 +120,9 @@ pkg_repo_fetch(struct pkg *pkg)

 	}
 	if (packagesite[strlen(packagesite) - 1] == '/')
 		snprintf(url, sizeof(url), "%s%s", packagesite, pkg_get(pkg, PKG_REPOPATH));
 		snprintf(url, sizeof(url), "%s%s", packagesite, repopath);
 	else
 		snprintf(url, sizeof(url), "%s/%s", packagesite, pkg_get(pkg, PKG_REPOPATH));
 		snprintf(url, sizeof(url), "%s/%s", packagesite, repopath);
 	retcode = pkg_fetch_file(url, dest);
 	fetched = 1;

@@ -132,14 +133,14 @@ pkg_repo_fetch(struct pkg *pkg)

 	checksum:
 	retcode = sha256_file(dest, cksum);
 	if (retcode == EPKG_OK)
 		if (strcmp(cksum, pkg_get(pkg, PKG_CKSUM))) {
 		if (strcmp(cksum, sum)) {
 			if (fetched == 1) {
 				pkg_emit_error("%s-%s failed checksum from repository",
 						pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 				    name, version);
 				retcode = EPKG_FATAL;
 			} else {
 				pkg_emit_error("cached package %s-%s: checksum mismatch, fetching from remote",
 						pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 				    name, version);
 				unlink(dest);
 				return (pkg_repo_fetch(pkg));
 			}

@@ -155,14 +156,14 @@ pkg_repo_fetch(struct pkg *pkg)

 int
 pkg_repos_new(struct pkg_repos **repos)
 {
         if ((*repos = calloc(1, sizeof(struct pkg_repos))) == NULL) {
                 pkg_emit_errno("calloc", "pkg_repos");
                 return (EPKG_FATAL);
         }
 	if ((*repos = calloc(1, sizeof(struct pkg_repos))) == NULL) {
 		pkg_emit_errno("calloc", "pkg_repos");
 		return (EPKG_FATAL);
 	}
         STAILQ_INIT(&(*repos)->nodes);
 	STAILQ_INIT(&(*repos)->nodes);
         return (EPKG_OK);
 	return (EPKG_OK);
 }
 int

@@ -618,6 +619,11 @@ pkg_create_repo(char *path, void (progress)(struct pkg *pkg, void *data), void *

 	}
 	while ((ent = fts_read(fts)) != NULL) {
 		const char *name, *version, *origin, *comment, *desc;
 		const char *arch, *osversion, *maintainer, *www, *prefix;
 		int64_t flatsize;
 		lic_t licenselogic;
 		cksum[0] = '\0';
 		/* skip everything that is not a file */
 		if (ent->fts_info != FTS_F)

@@ -650,20 +656,25 @@ pkg_create_repo(char *path, void (progress)(struct pkg *pkg, void *data), void *

 		if (progress != NULL)
 			progress(pkg, data);
 		sqlite3_bind_text(stmt_pkg, 1, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 2, pkg_get(pkg, PKG_NAME), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 3, pkg_get(pkg, PKG_VERSION), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 4, pkg_get(pkg, PKG_COMMENT), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 5, pkg_get(pkg, PKG_DESC), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 6, pkg_get(pkg, PKG_ARCH), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 7, pkg_get(pkg, PKG_OSVERSION), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 8, pkg_get(pkg, PKG_MAINTAINER), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 9, pkg_get(pkg, PKG_WWW), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 10, pkg_get(pkg, PKG_PREFIX), -1, SQLITE_STATIC);
 		pkg_get(pkg, PKG_ORIGIN, &origin, PKG_NAME, &name, PKG_VERSION, &version,
 		    PKG_COMMENT, &comment, PKG_DESC, &desc, PKG_ARCH, &arch,
 		    PKG_MAINTAINER, &maintainer, PKG_WWW, &www, PKG_PREFIX, &prefix,
 		    PKG_FLATSIZE, &flatsize, PKG_LICENSE_LOGIC, &licenselogic,
 		    -1);
 		sqlite3_bind_text(stmt_pkg, 1, origin, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 2, name, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 3, version, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 4, comment, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 5, desc, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 6, arch, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 7, osversion, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 8, maintainer, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 9, www, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 10, prefix, -1, SQLITE_STATIC);
 		sqlite3_bind_int64(stmt_pkg, 11, ent->fts_statp->st_size);
 		sqlite3_bind_int64(stmt_pkg, 12, pkg_flatsize(pkg));
 		sqlite3_bind_int64(stmt_pkg, 12, flatsize);
 		sha256_file(ent->fts_accpath, cksum);
 		sqlite3_bind_int64(stmt_pkg, 13, pkg_licenselogic(pkg));
 		sqlite3_bind_int64(stmt_pkg, 13, licenselogic);
 		sqlite3_bind_text(stmt_pkg, 14, cksum, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 15, pkg_path, -1, SQLITE_STATIC);

modified libpkg/pkgdb.c

@@ -956,6 +956,7 @@ pkgdb_load_deps(struct pkgdb *db, struct pkg *pkg)

 	sqlite3_stmt *stmt = NULL;
 	int ret = EPKG_OK;
 	char sql[BUFSIZ];
 	const char *repourl;
 	const char *basesql = ""
 			"SELECT d.name, d.origin, d.version "
 			"FROM '%s'.deps AS d "

@@ -963,8 +964,10 @@ pkgdb_load_deps(struct pkgdb *db, struct pkg *pkg)

 	assert(db != NULL && pkg != NULL);
 	pkg_get(pkg, PKG_REPOURL, &repourl);
 	if (pkg->type == PKG_REMOTE)
 		snprintf(sql, sizeof(sql), basesql, pkg_get(pkg, PKG_REPONAME));
 		snprintf(sql, sizeof(sql), basesql, repourl);
 	else
 		snprintf(sql, sizeof(sql), basesql, "main");

@@ -999,6 +1002,7 @@ pkgdb_load_rdeps(struct pkgdb *db, struct pkg *pkg)

 {
 	sqlite3_stmt *stmt = NULL;
 	int ret;
 	const char *origin;
 	const char sql[] = ""
 		"SELECT p.name, p.origin, p.version "
 		"FROM packages AS p, deps AS d "

@@ -1016,7 +1020,8 @@ pkgdb_load_rdeps(struct pkgdb *db, struct pkg *pkg)

 		return (EPKG_FATAL);
 	}
 	sqlite3_bind_text(stmt, 1, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
 	pkg_get(pkg, PKG_ORIGIN, &origin);
 	sqlite3_bind_text(stmt, 1, origin, -1, SQLITE_STATIC);
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
 		pkg_addrdep(pkg, sqlite3_column_text(stmt, 0), sqlite3_column_text(stmt, 1),

@@ -1128,7 +1133,7 @@ pkgdb_load_license(struct pkgdb *db, struct pkg *pkg)

 	assert(db != NULL && pkg != NULL);
 	if (pkg->type == PKG_REMOTE) {
 		reponame = pkg_get(pkg, PKG_REPONAME);
 		pkg_get(pkg, PKG_REPONAME, &reponame);
 		snprintf(sql, sizeof(sql), basesql, reponame, reponame);
 	} else
 		snprintf(sql, sizeof(sql), basesql, "main", "main");

@@ -1151,7 +1156,7 @@ pkgdb_load_category(struct pkgdb *db, struct pkg *pkg)

 	assert(db != NULL && pkg != NULL);
 	if (pkg->type == PKG_REMOTE) {
 		reponame = pkg_get(pkg, PKG_REPONAME);
 		pkg_get(pkg, PKG_REPONAME, &reponame);
 		snprintf(sql, sizeof(sql), basesql, reponame, reponame);
 	} else
 		snprintf(sql, sizeof(sql), basesql, "main", "main");

@@ -1273,6 +1278,7 @@ pkgdb_load_options(struct pkgdb *db, struct pkg *pkg)

 {
 	sqlite3_stmt *stmt = NULL;
 	int ret = EPKG_OK;
 	const char *reponame;
 	char sql[BUFSIZ];
 	const char *basesql = ""
 		"SELECT option, value "

@@ -1284,10 +1290,12 @@ pkgdb_load_options(struct pkgdb *db, struct pkg *pkg)

 	if (pkg->flags & PKG_LOAD_OPTIONS)
 		return (EPKG_OK);
 	if (pkg->type == PKG_REMOTE)
 		snprintf(sql, sizeof(sql), basesql, pkg_get(pkg, PKG_REPONAME));
 	else
 	if (pkg->type == PKG_REMOTE) {
 		pkg_get(pkg, PKG_REPONAME, &reponame);
 		snprintf(sql, sizeof(sql), basesql, reponame);
 	} else {
 		snprintf(sql, sizeof(sql), basesql, "main");
 	}
 	if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);

@@ -1425,6 +1433,13 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 		"INSERT OR ROLLBACK INTO pkg_groups(package_id, group_id) "
 		"VALUES (?1, (SELECT id FROM groups WHERE name = ?2));";
 	const char *mtree, *origin, *name, *version, *comment, *desc, *message;
 	const char *arch, *osversion, *maintainer, *www, *prefix;
 	bool automatic;
 	int64_t flatsize;
 	lic_t licenselogic;
 	assert(db != NULL);
 	if (!complete && pkgdb_has_flag(db, PKGDB_FLAG_IN_FLIGHT)) {

@@ -1445,7 +1460,13 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 		goto cleanup;
 	}
 	sqlite3_bind_text(stmt_mtree, 1, pkg_get(pkg, PKG_MTREE), -1, SQLITE_STATIC);
 	pkg_get(pkg, PKG_MTREE, &mtree, PKG_ORIGIN, &origin, PKG_VERSION, &version,
 	    PKG_COMMENT, &comment, PKG_DESC, &desc, PKG_MESSAGE, &message,
 	    PKG_ARCH, &arch, PKG_OSVERSION, &osversion, PKG_MAINTAINER, &maintainer,
 	    PKG_WWW, &www, PKG_PREFIX, &prefix, PKG_FLATSIZE, &flatsize,
 	    PKG_AUTOMATIC, &automatic, PKG_LICENSE_LOGIC, &licenselogic);
 	sqlite3_bind_text(stmt_mtree, 1, mtree, -1, SQLITE_STATIC);
 	if ((ret = sqlite3_step(stmt_mtree)) != SQLITE_DONE) {
 		ERROR_SQLITE(s);

@@ -1457,21 +1478,21 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 		ERROR_SQLITE(s);
 		goto cleanup;
 	}
 	sqlite3_bind_text(stmt_pkg, 1, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 2, pkg_get(pkg, PKG_NAME), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 3, pkg_get(pkg, PKG_VERSION), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 4, pkg_get(pkg, PKG_COMMENT), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 5, pkg_get(pkg, PKG_DESC), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 6, pkg_get(pkg, PKG_MESSAGE), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 7, pkg_get(pkg, PKG_ARCH), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 8, pkg_get(pkg, PKG_OSVERSION), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 9, pkg_get(pkg, PKG_MAINTAINER), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 10, pkg_get(pkg, PKG_WWW), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 11, pkg_get(pkg, PKG_PREFIX), -1, SQLITE_STATIC);
 	sqlite3_bind_int64(stmt_pkg, 12, pkg_flatsize(pkg));
 	sqlite3_bind_int(stmt_pkg, 13, pkg_is_automatic(pkg));
 	sqlite3_bind_int64(stmt_pkg, 14, pkg_licenselogic(pkg));
 	sqlite3_bind_text(stmt_pkg, 15, pkg_get(pkg, PKG_MTREE), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 1, origin, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 2, name, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 3, version, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 4, comment, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 5, desc, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 6, message, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 7, arch, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 8, osversion, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 9, maintainer, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 10, www,  -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 11, prefix, -1, SQLITE_STATIC);
 	sqlite3_bind_int64(stmt_pkg, 12, flatsize);
 	sqlite3_bind_int(stmt_pkg, 13, automatic);
 	sqlite3_bind_int64(stmt_pkg, 14, licenselogic);
 	sqlite3_bind_text(stmt_pkg, 15, mtree, -1, SQLITE_STATIC);
 	if ((ret = sqlite3_step(stmt_pkg)) != SQLITE_DONE) {
 		ERROR_SQLITE(s);

@@ -2615,16 +2636,19 @@ pkgdb_integrity_append(struct pkgdb *db, struct pkg *p)

 		return (EPKG_FATAL);
 	}
 	while (pkg_files(p, &file) == EPKG_OK) {
 		sqlite3_bind_text(stmt, 1, pkg_get(p, PKG_NAME), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt, 2, pkg_get(p, PKG_ORIGIN), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt, 3, pkg_get(p, PKG_VERSION), -1, SQLITE_STATIC);
 		const char *name, *origin, *version;
 		pkg_get(p, PKG_NAME, &name, PKG_ORIGIN, &origin, PKG_VERSION, &version);
 		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);
 		if (sqlite3_step(stmt) != SQLITE_DONE) {
 			sbuf_clear(conflictmsg);
 			sbuf_printf(conflictmsg, "WARNING: %s-%s conflict on %s with: \n",
 					pkg_get(p, PKG_NAME), pkg_get(p, PKG_VERSION),
 					pkg_file_get(file, PKG_FILE_PATH));
 			    name, version,
 			    pkg_file_get(file, PKG_FILE_PATH));
 			if (sqlite3_prepare_v2(db->sqlite, sql_conflicts, -1, &stmt_conflicts, NULL) != SQLITE_OK) {
 				ERROR_SQLITE(db->sqlite);

modified libpkg/rcscripts.c

@@ -21,8 +21,11 @@ pkg_stop_rc_scripts(struct pkg *pkg)

 	const char *rcfile;
 	size_t len = 0;
 	int ret = 0;
 	const char *prefix;
 	snprintf(rc_d_path, PATH_MAX, "%s/etc/rc.d/", pkg_get(pkg, PKG_PREFIX));
 	pkg_get(pkg, PKG_PREFIX, &prefix, -1);
 	snprintf(rc_d_path, PATH_MAX, "%s/etc/rc.d/", prefix);
 	len = strlen(rc_d_path);
 	while (pkg_files(pkg, &file) == EPKG_OK) {

@@ -45,8 +48,10 @@ pkg_start_rc_scripts(struct pkg *pkg)

 	const char *rcfile;
 	size_t len = 0;
 	int ret = 0;
 	const char *prefix;
 	snprintf(rc_d_path, PATH_MAX, "%s/etc/rc.d/", pkg_get(pkg, PKG_PREFIX));
 	pkg_get(pkg, PKG_PREFIX, &prefix);
 	snprintf(rc_d_path, PATH_MAX, "%s/etc/rc.d/", prefix);
 	len = strlen(rc_d_path);
 	while (pkg_files(pkg, &file) == EPKG_OK) {

modified libpkg/scripts.c

@@ -10,6 +10,7 @@ pkg_script_run(struct pkg * const pkg, pkg_script_t type)

 	pkg_script_t stype;
 	struct sbuf * const script_cmd = sbuf_new_auto();
 	size_t i;
 	const char *name, *prefix, *version;
 	struct {
 		const char * const arg;

@@ -25,6 +26,8 @@ pkg_script_run(struct pkg * const pkg, pkg_script_t type)

 		{"POST-DEINSTALL", PKG_SCRIPT_DEINSTALL, PKG_SCRIPT_POST_DEINSTALL},
 	};
 	pkg_get(pkg, PKG_PREFIX, &prefix, PKG_NAME, &name, PKG_VERSION, &version);
 	for (i = 0; i < sizeof(map) / sizeof(map[0]); i++) {
 		if (map[i].a == type)
 			break;

@@ -39,8 +42,7 @@ pkg_script_run(struct pkg * const pkg, pkg_script_t type)

 		if (stype == map[i].a || stype == map[i].b) {
 			sbuf_reset(script_cmd);
 			sbuf_printf(script_cmd, "PKG_PREFIX=%s\nset -- %s-%s",
 				pkg_get(pkg, PKG_PREFIX), pkg_get(pkg, PKG_NAME),
 				pkg_get(pkg, PKG_VERSION));
 			    prefix, name, version);
 			if (stype == map[i].b) {
 				/* add arg **/

modified pkg/autoremove.c

@@ -31,6 +31,7 @@ exec_autoremove(int argc, char **argv)

 	struct pkg_jobs *jobs = NULL;
 	int retcode = EPKG_OK;
 	int64_t oldsize = 0, newsize = 0;
 	int64_t flatsize, newflatsize;
 	char size[7];
 	int ch;
 	bool yes = false;

@@ -73,8 +74,9 @@ exec_autoremove(int argc, char **argv)

 	}
 	while ((retcode = pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC)) == EPKG_OK) {
 		oldsize += pkg_flatsize(pkg);
 		newsize += pkg_new_flatsize(pkg);
 		pkg_get(pkg, PKG_FLATSIZE, &flatsize, PKG_NEW_FLATSIZE, &newflatsize);
 		oldsize += flatsize;
 		newsize += newflatsize;
 		pkg_jobs_add(jobs, pkg);
 		pkg = NULL;
 	}

@@ -94,8 +96,11 @@ exec_autoremove(int argc, char **argv)

 	pkg = NULL;
 	printf("Packages to be autoremoved: \n");
 	while (pkg_jobs(jobs, &pkg) == EPKG_OK)
 		printf("\t%s-%s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 	while (pkg_jobs(jobs, &pkg) == EPKG_OK) {
 		const char *name, *version;
 		pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version);
 		printf("\t%s-%s\n", name, version);
 	}
 	if (oldsize > newsize)
 		printf("\nThe autoremove will save %s\n", size);

modified pkg/clean.c

@@ -53,6 +53,8 @@ exec_clean(int argc, char **argv)

 	}
 	while ((ent = fts_read(fts)) != NULL) {
 		const char *origin, *pkgrepopath;
 		if (ent->fts_info != FTS_F)
 			continue;

@@ -65,8 +67,8 @@ exec_clean(int argc, char **argv)

 			continue;
 		}
 		it = pkgdb_rquery(db, pkg_get(pkg, PKG_ORIGIN), MATCH_EXACT,
 							FIELD_ORIGIN, NULL);
 		pkg_get(pkg, PKG_ORIGIN, &origin);
 		it = pkgdb_rquery(db, origin, MATCH_EXACT, FIELD_ORIGIN, NULL);
 		if (it == NULL) {
 			warnx("skipping %s", ent->fts_path);

@@ -75,13 +77,14 @@ exec_clean(int argc, char **argv)

 		ret = pkgdb_it_next(it, &p, PKG_LOAD_BASIC);
 		to_delete = false;
 		pkg_get(pkg, PKG_REPOPATH, &pkgrepopath);
 		if (ret == EPKG_FATAL) {
 			warnx("skipping %s", ent->fts_path);
 			continue;
 		} else if (ret == EPKG_END) {
 			to_delete = true;
 			printf("%s does not exist anymore, deleting\n", repopath);
 		} else if (strcmp(repopath, pkg_get(p, PKG_REPOPATH))) {
 		} else if (strcmp(repopath, pkgrepopath)) {
 			printf("%s is out-of-date, deleting\n", repopath);
 			to_delete = true;
 		}

modified pkg/create.c

@@ -26,6 +26,7 @@ pkg_create_matches(int argc, char **argv, match_t match, pkg_formats fmt, const

 	struct pkgdb *db = NULL;
 	struct pkgdb_it *it = NULL;
 	struct pkg *pkg = NULL;
 	const char *name, *version;
 	int query_flags = PKG_LOAD_DEPS | PKG_LOAD_CONFLICTS | PKG_LOAD_FILES | PKG_LOAD_CATEGORIES |
 					  PKG_LOAD_DIRS | PKG_LOAD_SCRIPTS | PKG_LOAD_OPTIONS |
 					  PKG_LOAD_MTREE | PKG_LOAD_LICENSES | PKG_LOAD_USERS | PKG_LOAD_GROUPS;

@@ -41,11 +42,10 @@ pkg_create_matches(int argc, char **argv, match_t match, pkg_formats fmt, const

 				goto cleanup;
 			}
 			while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
 				printf("Creating package for %s-%s\n", pkg_get(pkg, PKG_NAME),
 				    pkg_get(pkg, PKG_VERSION));
 				if (pkg_create_installed(outdir, fmt, rootdir, pkg) != EPKG_OK) {
 				pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version);
 				printf("Creating package for %s-%s\n", name, version);
 				if (pkg_create_installed(outdir, fmt, rootdir, pkg) != EPKG_OK)
 					retcode++;
 				}
 			}
 		}
 	} else {

@@ -53,11 +53,10 @@ pkg_create_matches(int argc, char **argv, match_t match, pkg_formats fmt, const

 			goto cleanup;
 		}
 		while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
 			printf("Creating package for %s-%s\n", pkg_get(pkg, PKG_NAME),
 					pkg_get(pkg, PKG_VERSION));
 			if (pkg_create_installed(outdir, fmt, rootdir, pkg) != EPKG_OK) {
 			pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version);
 			printf("Creating package for %s-%s\n", name, version);
 			if (pkg_create_installed(outdir, fmt, rootdir, pkg) != EPKG_OK)
 				retcode++;
 			}
 		}
 	}

modified pkg/delete.c

@@ -92,8 +92,9 @@ exec_delete(int argc, char **argv)

 		goto cleanup;
 	while (pkgdb_it_next(it, &pkg, flags) == EPKG_OK) {
 		oldsize += pkg_flatsize(pkg);
 		newsize += pkg_new_flatsize(pkg);
 		int64_t flatsize, newflatsize;
 		oldsize += flatsize;
 		newsize += newflatsize;
 		pkg_jobs_add(jobs, pkg);
 		pkg = NULL;
 	}

@@ -114,8 +115,12 @@ exec_delete(int argc, char **argv)

 	pkg = NULL;
 	printf("The following packages will be deinstalled:\n");
 	while (pkg_jobs(jobs, &pkg) == EPKG_OK)
 		printf("\t%s-%s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 	while (pkg_jobs(jobs, &pkg) == EPKG_OK) {
 		const char *name, *version;
 		pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version);
 		printf("\t%s-%s\n", name, version);
 	}
 	if (oldsize > newsize)
 		printf("\nThe deinstallation will save %s\n", size);

@@ -137,7 +142,7 @@ exec_delete(int argc, char **argv)

 	retcode = 0;
 	cleanup:
 cleanup:
 	pkgdb_it_free(it);
 	pkgdb_close(db);
 	pkg_jobs_free(jobs);

modified pkg/event.c

@@ -17,6 +17,7 @@ event_callback(void *data, struct pkg_event *ev)

 	const char *message;
 	int *debug = data;
 	(void)debug;
 	const char *name, *version, *newversion;
 	switch(ev->type) {
 	case PKG_EVENT_ERRNO:

@@ -37,14 +38,13 @@ event_callback(void *data, struct pkg_event *ev)

 		}
 		break;
 	case PKG_EVENT_INSTALL_BEGIN:
 		printf("Installing %s-%s...",
 			   pkg_get(ev->e_install_begin.pkg, PKG_NAME),
 			   pkg_get(ev->e_install_begin.pkg, PKG_VERSION));
 		pkg_get(ev->e_install_begin.pkg, PKG_NAME, &name, PKG_VERSION, &version);
 		printf("Installing %s-%s...", name, version);
 		fflush(stdout);
 		break;
 	case PKG_EVENT_INSTALL_FINISHED:
 		printf(" done\n");
 		message = pkg_get(ev->e_install_finished.pkg, PKG_MESSAGE);
 		pkg_get(ev->e_install_finished.pkg, PKG_MESSAGE, &message);
 		if (message != NULL && message[0] != '\0')
 			printf("%s\n", message);
 		break;

@@ -56,19 +56,17 @@ event_callback(void *data, struct pkg_event *ev)

 		printf(" done\n");
 		break;
 	case PKG_EVENT_DEINSTALL_BEGIN:
 		printf("Deinstalling %s-%s...",
 			   pkg_get(ev->e_deinstall_begin.pkg, PKG_NAME),
 			   pkg_get(ev->e_deinstall_begin.pkg, PKG_VERSION));
 		pkg_get(ev->e_deinstall_begin.pkg, PKG_NAME, &name, PKG_VERSION, &version);
 		printf("Deinstalling %s-%s...", name, version);
 		fflush(stdout);
 		break;
 	case PKG_EVENT_DEINSTALL_FINISHED:
 		printf(" done\n");
 		break;
 	case PKG_EVENT_UPGRADE_BEGIN:
 		printf("Upgrading %s from %s to %s...",
 				pkg_get(ev->e_upgrade_finished.pkg, PKG_NAME),
 				pkg_get(ev->e_upgrade_finished.pkg, PKG_VERSION),
 				pkg_get(ev->e_upgrade_finished.pkg, PKG_NEWVERSION));
 		pkg_get(ev->e_upgrade_finished.pkg, PKG_NAME, &name, PKG_VERSION, &version,
 		    PKG_NEWVERSION, &newversion);
 		printf("Upgrading %s from %s to %s...", name, version, newversion);
 		fflush(stdout);
 		break;
 	case PKG_EVENT_UPGRADE_FINISHED:

@@ -76,8 +74,8 @@ event_callback(void *data, struct pkg_event *ev)

 		break;
 	case PKG_EVENT_REQUIRED:
 		pkg = ev->e_required.pkg;
 		fprintf(stderr, "%s-%s is required by:", pkg_get(pkg, PKG_NAME),
 				pkg_get(pkg, PKG_VERSION));
 		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_ORIGIN));
 		}

@@ -87,9 +85,8 @@ event_callback(void *data, struct pkg_event *ev)

 			fprintf(stderr, "\n");
 		break;
 	case PKG_EVENT_ALREADY_INSTALLED:
 		printf("%s-%s already installed\n",
 				pkg_get(ev->e_already_installed.pkg, PKG_NAME),
 				pkg_get(ev->e_already_installed.pkg, PKG_VERSION));
 		pkg_get(ev->e_already_installed.pkg, PKG_NAME, &name, PKG_VERSION, &version);
 		printf("%s-%s already installed\n", name, version);
 		break;
 	default:
 		break;

modified pkg/info.c

@@ -202,8 +202,11 @@ exec_info(int argc, char **argv)

 		while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
 			gotone = true;
 			const char *version;
 			pkg_get(pkg, PKG_VERSION, &version);
 			if (pkgversion != NULL && pkgversion[0] != '0') { /* FIXME special workaround for >=0 */
 				switch (pkg_version_cmp(pkg_get(pkg, PKG_VERSION), pkgversion)) {
 				switch (pkg_version_cmp(version, pkgversion)) {
 					case -1:
 						if (sign != LT && sign != LE) {
 							gotone = false;

modified pkg/install.c

@@ -99,14 +99,19 @@ exec_install(int argc, char **argv)

 	printf("The following packages will be installed:\n");
 	while (pkg_jobs(jobs, &pkg) == EPKG_OK) {
 		dlsize += pkg_new_pkgsize(pkg);
 		if (pkg_get(pkg, PKG_NEWVERSION) != NULL) {
 			printf("\tUpgrading %s: %s -> %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_get(pkg,PKG_NEWVERSION));
 			oldsize += pkg_flatsize(pkg);
 			newsize += pkg_new_flatsize(pkg);
 		const char *name, *version, *newversion;
 		int64_t flatsize, newflatsize, pkgsize;
 		pkg_get(pkg, PKG_NEWVERSION, &newversion, PKG_NAME, &name,
 		    PKG_VERSION, &version, PKG_FLATSIZE, &flatsize,
 		    PKG_NEW_FLATSIZE, &newflatsize, PKG_NEW_PKGSIZE, &pkgsize);
 		dlsize += pkgsize;
 		if (newversion != NULL) {
 			printf("\tUpgrading %s: %s -> %s\n", name, version, newversion);
 			oldsize += flatsize;
 			newsize += flatsize;
 		} else {
 			newsize += pkg_flatsize(pkg);
 			printf("\tInstalling %s: %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 			newsize += flatsize;
 			printf("\tInstalling %s: %s\n", name, version);
 		}
 	}

modified pkg/query.c

@@ -48,6 +48,10 @@ static void

 format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)
 {
 	char size[7];
 	const char *tmp;
 	bool automatic;
 	int64_t flatsize;
 	lic_t licenselogic;
 	sbuf_clear(dest);

@@ -56,36 +60,45 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)

 			qstr++;
 			switch (qstr[0]) {
 				case 'n':
 					sbuf_cat(dest, pkg_get(pkg, PKG_NAME));
 					pkg_get(pkg, PKG_NAME, &tmp);
 					sbuf_cat(dest, tmp);
 					break;
 				case 'v':
 					sbuf_cat(dest, pkg_get(pkg, PKG_VERSION));
 					pkg_get(pkg, PKG_VERSION, &tmp);
 					sbuf_cat(dest, tmp);
 					break;
 				case 'o':
 					sbuf_cat(dest, pkg_get(pkg, PKG_ORIGIN));
 					pkg_get(pkg, PKG_ORIGIN, &tmp);
 					sbuf_cat(dest, tmp);
 					break;
 				case 'p':
 					sbuf_cat(dest, pkg_get(pkg, PKG_PREFIX));
 					pkg_get(pkg, PKG_PREFIX, &tmp);
 					sbuf_cat(dest, tmp);
 					break;
 				case 'm':
 					sbuf_cat(dest, pkg_get(pkg, PKG_MAINTAINER));
 					pkg_get(pkg, PKG_MAINTAINER, &tmp);
 					sbuf_cat(dest, tmp);
 					break;
 				case 'c':
 					sbuf_cat(dest, pkg_get(pkg, PKG_COMMENT));
 					pkg_get(pkg, PKG_COMMENT, &tmp);
 					sbuf_cat(dest, tmp);
 					break;
 				case 'w':
 					sbuf_cat(dest, pkg_get(pkg, PKG_WWW));
 					pkg_get(pkg, PKG_WWW, &tmp);
 					sbuf_cat(dest, tmp);
 					break;
 				case 'a':
 					sbuf_printf(dest, "%d", pkg_is_automatic(pkg));
 					pkg_get(pkg, PKG_AUTOMATIC, &automatic);
 					sbuf_printf(dest, "%d", automatic);
 					break;
 				case 's':
 					qstr++;
 					pkg_get(pkg, PKG_FLATSIZE, &flatsize);
 					if (qstr[0] == 'h') {
 						humanize_number(size, sizeof(size), pkg_flatsize(pkg), "B", HN_AUTOSCALE, 0);
 						humanize_number(size, sizeof(size), flatsize, "B", HN_AUTOSCALE, 0);
 						sbuf_cat(dest, size);
 					} else if (qstr[0] == 'b') {
 						sbuf_printf(dest, "%" PRId64, pkg_flatsize(pkg));
 						sbuf_printf(dest, "%" PRId64, flatsize);
 					}
 					break;
 				case '?':

@@ -124,8 +137,18 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)

 					}
 					break;
 				case 'l':
 					if (pkg_licenselogic(pkg))
 						sbuf_putc(dest, pkg_licenselogic(pkg));
 					pkg_get(pkg, PKG_LICENSE_LOGIC, &licenselogic);
 					switch (licenselogic) {
 						case LICENSE_SINGLE:
 							sbuf_cat(dest, "single");
 							break;
 						case LICENSE_OR:
 							sbuf_cat(dest, "or");
 							break;
 						case LICENSE_AND:
 							sbuf_cat(dest, "and");
 							break;
 					}
 					break;
 				case 'd':
 					qstr++;

modified pkg/register.c

@@ -64,6 +64,7 @@ exec_register(int argc, char **argv)

 	char *input_path = NULL;
 	char fpath[MAXPATHLEN + 1];
 	const char *message;
 	const char *desc = NULL;
 	size_t size;

@@ -149,7 +150,7 @@ exec_register(int argc, char **argv)

 	/* if www is not given then try to determine it from description */
 	if (www == NULL) {
 		desc = pkg_get(pkg, PKG_DESC);
 		pkg_get(pkg, PKG_DESC, &desc);
 		regcomp(&preg, "^WWW:[[:space:]]*(.*)$", REG_EXTENDED|REG_ICASE|REG_NEWLINE);
 		if (regexec(&preg, desc, 2, pmatch, 0) == 0) {
 			size = pmatch[1].rm_eo - pmatch[1].rm_so;

@@ -198,8 +199,9 @@ exec_register(int argc, char **argv)

 		retcode = EPKG_FATAL;
 	}
 	if (pkg_get(pkg, PKG_MESSAGE) != NULL && !legacy)
 		printf("%s\n", pkg_get(pkg, PKG_MESSAGE));
 	pkg_get(pkg, PKG_MESSAGE, message);
 	if (message != NULL && !legacy)
 		printf("%s\n", message);
 	pkgdb_close(db);
 	pkg_free(pkg);

modified pkg/updating.c

@@ -41,6 +41,7 @@ exec_updating(int argc, char **argv)

 	struct pkgdb *db = NULL;
 	struct pkg *pkg = NULL;
 	struct pkgdb_it *it = NULL;
 	const char *origin;
 	FILE *fd;
 	while ((ch = getopt(argc, argv, "d:f:")) != -1) {

@@ -74,7 +75,8 @@ exec_updating(int argc, char **argv)

 		while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == EPKG_OK) {
 			port = malloc(sizeof(struct installed_ports));
 			port->origin = strdup(pkg_get(pkg, PKG_ORIGIN));
 			pkg_get(pkg, PKG_ORIGIN, &origin);
 			port->origin = strdup(origin);
 			SLIST_INSERT_HEAD(&origins, port, next);
 		}
 	} else {

modified pkg/upgrade.c

@@ -88,14 +88,20 @@ exec_upgrade(int argc, char **argv)

 	printf("The following packages will be upgraded: \n");
 	pkg = NULL;
 	while (pkg_jobs(jobs, &pkg) == EPKG_OK) {
 		dlsize += pkg_new_pkgsize(pkg);
 		if (pkg_get(pkg, PKG_NEWVERSION) != NULL) {
 			printf("\tUpgrading %s: %s -> %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_get(pkg,PKG_NEWVERSION));
 			oldsize += pkg_flatsize(pkg);
 			newsize += pkg_new_flatsize(pkg);
 		const char *newversion, *name, *version;
 		int64_t newpkgsize, flatsize, newflatsize;
 		pkg_get(pkg, PKG_NEWVERSION, &newversion, PKG_NAME, &name, PKG_VERSION, &version,
 		    PKG_NEW_PKGSIZE, &newpkgsize, PKG_NEW_FLATSIZE, &newflatsize,
 		    PKG_FLATSIZE, &flatsize);
 		dlsize += newpkgsize;
 		if (newversion != NULL) {
 			printf("\tUpgrading %s: %s -> %s\n", name, version, newversion);
 			oldsize += flatsize;
 			newsize += newflatsize;
 		} else {
 			newsize += pkg_flatsize(pkg);
 			printf("\tInstalling %s: %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 			newsize += flatsize;
 			printf("\tInstalling %s: %s\n", name, version);
 		}
 	}

@@ -110,12 +116,12 @@ exec_upgrade(int argc, char **argv)

 	humanize_number(size, sizeof(size), dlsize, "B", HN_AUTOSCALE, 0);
 	printf("%s to be downloaded\n", size);
 	if (yes == false)
 	if (!yes)
 		pkg_config_bool(PKG_CONFIG_ASSUME_ALWAYS_YES, &yes);
 	if (yes == false)
 	if (!yes)
 		yes = query_yesno("\nProceed with upgrading packages [y/N]: ");
 	if (yes == true)
 	if (yes)
 		if (pkg_jobs_apply(jobs, 0) != EPKG_OK)
 			goto cleanup;

modified pkg/utils.c

@@ -32,27 +32,36 @@ query_yesno(const char *msg)

 int
 print_info(struct pkg * const pkg, unsigned int opt)
 {
         struct pkg_dep *dep = NULL;
         struct pkg_file *file = NULL;
         struct pkg_category *cat = NULL;
         struct pkg_license *lic = NULL;
         struct pkg_option *option = NULL;
 	struct pkg_dep *dep = NULL;
 	struct pkg_file *file = NULL;
 	struct pkg_category *cat = NULL;
 	struct pkg_license *lic = NULL;
 	struct pkg_option *option = NULL;
 	bool multirepos_enabled = false;
         char size[7];
 	char size[7];
 	const char *name, *version, *prefix, *origin, *reponame, *repourl;
 	const char *maintainer, *www, *comment, *desc;
 	int64_t flatsize, newflatsize, newpkgsize;
 	lic_t licenselogic;
 	pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version, PKG_PREFIX, &prefix,
 	    PKG_ORIGIN, &origin, PKG_REPONAME, &reponame, PKG_REPOURL, &repourl,
 	    PKG_MAINTAINER, &maintainer, PKG_WWW, &www, PKG_COMMENT, &comment,
 	    PKG_DESC, &desc, PKG_FLATSIZE, &flatsize, PKG_NEW_FLATSIZE, &newflatsize,
 	    PKG_NEW_PKGSIZE, &newpkgsize, PKG_LICENSE_LOGIC, &licenselogic);
         if (opt & INFO_FULL) {
                 printf("%-15s: %s\n", "Name", pkg_get(pkg, PKG_NAME));
                 printf("%-15s: %s\n", "Version", pkg_get(pkg, PKG_VERSION));
                 printf("%-15s: %s\n", "Origin", pkg_get(pkg, PKG_ORIGIN));
                 printf("%-15s: %s\n", "Prefix", pkg_get(pkg, PKG_PREFIX));
 		printf("%-15s: %s\n", "Name", name);
 		printf("%-15s: %s\n", "Version", version);
 		printf("%-15s: %s\n", "Origin", origin);
 		printf("%-15s: %s\n", "Prefix", prefix);
 		if (pkg_type(pkg) == PKG_REMOTE) {
 			pkg_config_bool(PKG_CONFIG_MULTIREPOS, &multirepos_enabled);
 			if (multirepos_enabled) {
 				printf("%-15s: %s [%s]\n", "Repository",
 						pkg_get(pkg, PKG_REPONAME),
 						pkg_get(pkg, PKG_REPOURL));
 						reponame, repourl);
 			}
 		}

@@ -63,20 +72,21 @@ print_info(struct pkg * const pkg, unsigned int opt)

                         printf("\n");
                 }
                 if (!pkg_list_is_empty(pkg, PKG_LICENSES)) {
                         printf("%-15s:", "Licenses");
                         while (pkg_licenses(pkg, &lic) == EPKG_OK) {
                                 printf(" %s", pkg_license_name(lic));
                                 if (pkg_licenselogic(pkg) != 1)
                                         printf(" %c", pkg_licenselogic(pkg));
                                 else
                                         printf(" ");
                         }
                         printf("\b \n");
                 }
                 printf("%-15s: %s\n", "Maintainer", pkg_get(pkg, PKG_MAINTAINER));
                 printf("%-15s: %s\n", "WWW", pkg_get(pkg, PKG_WWW));
                 printf("%-15s: %s\n", "Comment", pkg_get(pkg, PKG_COMMENT));
 		if (!pkg_list_is_empty(pkg, PKG_LICENSES)) {
 			printf("%-15s:", "Licenses");
 			while (pkg_licenses(pkg, &lic) == EPKG_OK) {
 				printf(" %s", pkg_license_name(lic));
 				if (licenselogic != 1)
 					printf(" %c", licenselogic);
 				else
 					printf(" ");
 			}
 			printf("\b \n");
 		}
 		printf("%-15s: %s\n", "Maintainer", maintainer);
 		printf("%-15s: %s\n", "WWW", www);
 		printf("%-15s: %s\n", "Comment", comment);
                 if (!pkg_list_is_empty(pkg, PKG_OPTIONS)) {
                         printf("%-15s: \n", "Options");

@@ -85,20 +95,20 @@ print_info(struct pkg * const pkg, unsigned int opt)

                 }
 		if (pkg_type(pkg) == PKG_INSTALLED || pkg_type(pkg) == PKG_FILE) {
 			humanize_number(size, sizeof(size), pkg_flatsize(pkg), "B", HN_AUTOSCALE, 0);
 			humanize_number(size, sizeof(size), flatsize, "B", HN_AUTOSCALE, 0);
 			printf("%-15s: %s\n", "Flat size", size);
 		} else {
 			humanize_number(size, sizeof(size), pkg_new_flatsize(pkg), "B", HN_AUTOSCALE, 0);
 			humanize_number(size, sizeof(size), newflatsize, "B", HN_AUTOSCALE, 0);
 			printf("%-15s: %s\n", "Flat size", size);
 			humanize_number(size, sizeof(size), pkg_new_pkgsize(pkg), "B", HN_AUTOSCALE, 0);
 			humanize_number(size, sizeof(size), newpkgsize, "B", HN_AUTOSCALE, 0);
 			printf("%-15s: %s\n", "Pkg size", size);
 		}
                 printf("%-15s: \n%s\n", "Description", pkg_get(pkg, PKG_DESC));
                 printf("\n");
         } else if (opt & INFO_PRINT_DEP) {
                 if (!(opt & INFO_QUIET))
                         printf("%s-%s depends on:\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 		printf("%-15s: \n%s\n", "Description", desc);
 		printf("\n");
 	} else if (opt & INFO_PRINT_DEP) {
 		if (!(opt & INFO_QUIET))
 			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));

@@ -106,9 +116,9 @@ print_info(struct pkg * const pkg, unsigned int opt)

                 if (!(opt & INFO_QUIET))
                         printf("\n");
         } else if (opt & INFO_PRINT_RDEP) {
                 if (!(opt & INFO_QUIET))
                         printf("%s-%s is required by:\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 	} else if (opt & INFO_PRINT_RDEP) {
 		if (!(opt & INFO_QUIET))
 			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));

@@ -116,9 +126,9 @@ print_info(struct pkg * const pkg, unsigned int opt)

                 if (!(opt & INFO_QUIET))
                         printf("\n");
         } else if (opt & INFO_LIST_FILES) {
                 if (!(opt & INFO_QUIET))
                         printf("%s-%s owns the following files:\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 	} else if (opt & INFO_LIST_FILES) {
 		if (!(opt & INFO_QUIET))
 			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));

@@ -128,29 +138,29 @@ print_info(struct pkg * const pkg, unsigned int opt)

                         printf("\n");
         } else if (opt & INFO_SIZE) {
 		if (pkg_type(pkg) == PKG_INSTALLED) {
 			humanize_number(size, sizeof(size), pkg_flatsize(pkg), "B", HN_AUTOSCALE, 0);
 			printf("%s-%s size is: %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), size);
 			humanize_number(size, sizeof(size), flatsize, "B", HN_AUTOSCALE, 0);
 			printf("%s-%s size is: %s\n", name, version, size);
 		} else {
 			humanize_number(size, sizeof(size), pkg_new_flatsize(pkg), "B", HN_AUTOSCALE, 0);
 			printf("%s-%s flat size is: %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), size);
 			humanize_number(size, sizeof(size), pkg_new_pkgsize(pkg), "B", HN_AUTOSCALE, 0);
 			printf("%s-%s package size is: %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), size);
 			humanize_number(size, sizeof(size), newflatsize, "B", HN_AUTOSCALE, 0);
 			printf("%s-%s flat size is: %s\n", name, version, size);
 			humanize_number(size, sizeof(size), newpkgsize, "B", HN_AUTOSCALE, 0);
 			printf("%s-%s package size is: %s\n", name, version, size);
 		}
         } else if (opt & INFO_ORIGIN) {
                 if (opt & INFO_QUIET)
                         printf("%s\n", pkg_get(pkg, PKG_ORIGIN));
                         printf("%s\n", origin);
                 else
                         printf("%s-%s: %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_get(pkg, PKG_ORIGIN));
                         printf("%s-%s: %s\n", name, version, origin);
         } else if (opt & INFO_PREFIX) {
                 if (opt & INFO_QUIET)
                         printf("%s\n", pkg_get(pkg, PKG_PREFIX));
                         printf("%s\n", prefix);
                 else
                         printf("%s-%s: %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_get(pkg, PKG_PREFIX));
                         printf("%s-%s: %s\n", name, version, prefix);
         } else {
                 if (opt & INFO_QUIET)
                         printf("%s-%s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
                         printf("%s-%s\n", name, version);
                 else
                         printf("%s-%s: %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_get(pkg, PKG_COMMENT));
                         printf("%s-%s: %s\n", name, version, comment);
         }
         return (0);

modified pkg/version.c

@@ -61,14 +61,16 @@ print_version(struct pkg *pkg, const char *source, const char *ver, char limchar

 {
 	bool to_print = true;
 	char key;
 	const char *version, *name, *origin;
 	pkg_get(pkg, PKG_VERSION, &version, PKG_NAME, &name, PKG_ORIGIN, &origin);
 	if (ver == NULL) {
 		if (source == NULL)
 			key = '!';
 		else
 			key = '?';
 	} else {
 		switch (pkg_version_cmp(pkg_get(pkg, PKG_VERSION), ver)) {
 		switch (pkg_version_cmp(version, ver)) {
 			case -1:
 				key = '<';
 				break;

@@ -94,7 +96,7 @@ print_version(struct pkg *pkg, const char *source, const char *ver, char limchar

 	if (to_print == false)
 		return;
 	printf("%-34s %c", pkg_get(pkg, PKG_NAME), key);
 	printf("%-34s %c", name, key);
 	if (opt & VERSION_VERBOSE) {
 		switch(key) {

@@ -108,7 +110,7 @@ print_version(struct pkg *pkg, const char *source, const char *ver, char limchar

 			printf("   succeeds %s (%s has %s)", source, source, ver);
 			break;
 		case '?':
 			printf("   orphaned: %s", pkg_get(pkg, PKG_ORIGIN));
 			printf("   orphaned: %s", origin);
 		case '!':
 			printf("   Comparison failed");
 		}

@@ -140,6 +142,7 @@ exec_version(int argc, char **argv)

 	struct sbuf *cmd;
 	struct sbuf *res;
 	const char *portsdir;
 	const char *origin;
 	SLIST_INIT(&indexhead);

@@ -262,7 +265,8 @@ exec_version(int argc, char **argv)

 		while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == EPKG_OK) {
 			SLIST_FOREACH(entry, &indexhead, next) {
 				if (!strcmp(entry->origin, pkg_get(pkg, PKG_ORIGIN))) {
 				pkg_get(pkg, PKG_ORIGIN, &origin);
 				if (!strcmp(entry->origin, origin)) {
 					print_version(pkg, "index", entry->version, limchar, opt);
 					break;
 				}

@@ -278,7 +282,7 @@ exec_version(int argc, char **argv)

 		while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == EPKG_OK) {
 			cmd = sbuf_new_auto();
 			sbuf_printf(cmd, "make -C %s/%s -VPKGVERSION", portsdir, pkg_get(pkg, PKG_ORIGIN));
 			sbuf_printf(cmd, "make -C %s/%s -VPKGVERSION", portsdir, origin);
 			sbuf_finish(cmd);
 			if ((res = exec_buf(sbuf_data(cmd))) != NULL) {
 				buf = sbuf_data(res);

modified pkg/which.c

@@ -27,6 +27,7 @@ exec_which(int argc, char **argv)

 	char pathabs[MAXPATHLEN + 1];
 	char pathabsdir[MAXPATHLEN + 1];
 	int ret = EPKG_OK, retcode = EPKG_OK;
 	const char *name, *version;
 	if (argc != 2) {
 		usage_which();

@@ -47,8 +48,8 @@ exec_which(int argc, char **argv)

 	if (( ret = pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC)) == EPKG_OK) {
 		retcode = EPKG_OK;
 		printf("%s was installed by package %s-%s\n", pathabs, pkg_get(pkg, PKG_NAME),
 			   pkg_get(pkg, PKG_VERSION));
 		pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version);
 		printf("%s was installed by package %s-%s\n", pathabs, name, version);
 	} else if (ret != EPKG_END) {
 		retcode = EPKG_WARN;
 	} else {