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

modified libpkg/backup.c

@@ -55,7 +55,8 @@ 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_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", name, version);

@@ -66,7 +67,8 @@ pkgdb_dump(struct pkgdb *db, char *dest)

 			sbuf_clear(path);
 			sbuf_printf(path, "%s-%s.mtree", name, version);
 			sbuf_finish(path);
 			packing_append_buffer(pack, mtree, sbuf_get(path), strlen(mtree));
 			packing_append_buffer(pack, mtree, sbuf_get(path),
 			    strlen(mtree));
 		}
 	}

@@ -107,7 +109,8 @@ pkgdb_load(struct pkgdb *db, char *dest)

 			if (pkg == NULL) {
 				pkg_new(&pkg, PKG_FILE);
 			} else {
 				pkgdb_register_finale(db, pkgdb_register_pkg(db, pkg, 0));
 				int reg_result = pkgdb_register_pkg(db, pkg, 0);
 				pkgdb_register_finale(db, reg_result);
 				pkg_reset(pkg, PKG_FILE);
 			}
 			size = archive_entry_size(ae);

modified libpkg/fetch.c

@@ -78,7 +78,8 @@ pkg_fetch_file(const char *url, const char *dest, time_t t)

 			pkg_config_bool(PKG_CONFIG_SRV_MIRROR, &srv);
 			if (srv) {
 				if (strcmp(u->scheme, "file") != 0) {
 					snprintf(zone, sizeof(zone), "_%s._tcp.%s", u->scheme, u->host);
 					snprintf(zone, sizeof(zone),
 					    "_%s._tcp.%s", u->scheme, u->host);
 					mirrors = dns_getsrvinfo(zone);
 					current = mirrors;
 				}

@@ -92,7 +93,8 @@ pkg_fetch_file(const char *url, const char *dest, time_t t)

 		if (remote == NULL) {
 			--retry;
 			if (retry == 0) {
 				pkg_emit_error("%s: %s", url, fetchLastErrString);
 				pkg_emit_error("%s: %s", url,
 				    fetchLastErrString);
 				retcode = EPKG_FATAL;
 				goto cleanup;
 			}

modified libpkg/packing.c

@@ -67,13 +67,15 @@ packing_init(struct packing **pack, const char *path, pkg_formats format)

 	if (!is_dir(path)) {
 		(*pack)->awrite = archive_write_new();
 		archive_write_set_format_pax_restricted((*pack)->awrite);
 		if ((ext = packing_set_format((*pack)->awrite, format)) == NULL) {
 		ext = packing_set_format((*pack)->awrite, format);
 		if (ext == NULL) {
 			archive_read_finish((*pack)->aread);
 			archive_write_finish((*pack)->awrite);
 			*pack = NULL;
 			return EPKG_FATAL; /* error set by _set_format() */
 		}
 		snprintf(archive_path, sizeof(archive_path), "%s.%s", path, ext);
 		snprintf(archive_path, sizeof(archive_path), "%s.%s", path,
 		    ext);
 		if (archive_write_open_filename(
 		    (*pack)->awrite, archive_path) != ARCHIVE_OK) {

@@ -86,16 +88,19 @@ packing_init(struct packing **pack, const char *path, pkg_formats format)

 		}
 	} else { /* pass mode directly write to the disk */
 		(*pack)->awrite = archive_write_disk_new();
 		archive_write_disk_set_options((*pack)->awrite, EXTRACT_ARCHIVE_FLAGS);
 		archive_write_disk_set_options((*pack)->awrite,
 		    EXTRACT_ARCHIVE_FLAGS);
 	}
 	(*pack)->resolver = archive_entry_linkresolver_new();
 	archive_entry_linkresolver_set_strategy((*pack)->resolver, ARCHIVE_FORMAT_TAR_PAX_RESTRICTED);
 	archive_entry_linkresolver_set_strategy((*pack)->resolver,
 	    ARCHIVE_FORMAT_TAR_PAX_RESTRICTED);
 	return (EPKG_OK);
 }
 int
 packing_append_buffer(struct packing *pack, const char *buffer, const char *path, int size)
 packing_append_buffer(struct packing *pack, const char *buffer,
     const char *path, int size)
 {
 	struct archive_entry *entry;

@@ -116,14 +121,16 @@ packing_append_buffer(struct packing *pack, const char *buffer, const char *path

 }
 int
 packing_append_file(struct packing *pack, const char *filepath, const char *newpath)
 packing_append_file(struct packing *pack, const char *filepath,
     const char *newpath)
 {
 	return (packing_append_file_attr(pack, filepath, newpath, NULL, NULL, 0));
 	return (packing_append_file_attr(pack, filepath, newpath,
 	    NULL, NULL, 0));
 }
 int
 packing_append_file_attr(struct packing *pack, const char *filepath, const char *newpath,
 		const char *uname, const char *gname, mode_t perm)
 packing_append_file_attr(struct packing *pack, const char *filepath,
     const char *newpath, const char *uname, const char *gname, mode_t perm)
 {
 	int fd;
 	int len;

@@ -214,7 +221,8 @@ packing_append_file_attr(struct packing *pack, const char *filepath, const char

 }
 int
 packing_append_tree(struct packing *pack, const char *treepath, const char *newroot)
 packing_append_tree(struct packing *pack, const char *treepath,
     const char *newroot)
 {
 	FTS *fts = NULL;
 	FTSENT *fts_e = NULL;

@@ -235,16 +243,18 @@ packing_append_tree(struct packing *pack, const char *treepath, const char *newr

 		case FTS_F:
 		case FTS_SL:
 		case FTS_SLNONE:
 			 /* Skip entries that are shorter than the tree itself */
 			 /* Entries not within this tree are irrelevant. */
 			 if (fts_e->fts_pathlen <= treelen)
 				  break;
 			 sbuf_clear(sb);
 			 /* Strip the prefix to obtain the target path */
 			 if (newroot) /* Prepend a root if one is specified */
 				  sbuf_cat(sb, newroot);
 			 sbuf_cat(sb, fts_e->fts_path + treelen + 1 /* skip trailing slash */);
 			 /* +1 = skip trailing slash */
 			 sbuf_cat(sb, fts_e->fts_path + treelen + 1);
 			 sbuf_finish(sb);
 			 packing_append_file(pack, fts_e->fts_name, sbuf_get(sb));
 			 packing_append_file(pack, fts_e->fts_name,
 			    sbuf_get(sb));
 			 break;
 		case FTS_DC:
 		case FTS_DNR:

@@ -281,28 +291,27 @@ packing_finish(struct packing *pack)

 static const char *
 packing_set_format(struct archive *a, pkg_formats format)
 {
 	const char *notsupp_fmt = "%s is not supported, trying %s";
 	switch (format) {
 		case TXZ:
 			if (archive_write_set_compression_xz(a) == ARCHIVE_OK) {
 				return ("txz");
 			} else {
 				pkg_emit_error("%s", "xz is not supported, trying bzip2");
 			}
 		case TBZ:
 			if (archive_write_set_compression_bzip2(a) == ARCHIVE_OK) {
 				return ("tbz");
 			} else {
 				pkg_emit_error("%s", "bzip2 is not supported, trying gzip");
 			}
 		case TGZ:
 			if (archive_write_set_compression_gzip(a) == ARCHIVE_OK) {
 				return ("tgz");
 			} else {
 				pkg_emit_error("%s", "gzip is not supported, trying plain tar");
 			}
 		case TAR:
 			archive_write_set_compression_none(a);
 			return ("tar");
 	case TXZ:
 		if (archive_write_set_compression_xz(a) == ARCHIVE_OK)
 			return ("txz");
 		else
 			pkg_emit_error(notsupp_fmt, "xz", "bzip2");
 	case TBZ:
 		if (archive_write_set_compression_bzip2(a) == ARCHIVE_OK)
 			return ("tbz");
 		else
 			pkg_emit_error(notsupp_fmt, "bzip2", "gzip");
 	case TGZ:
 		if (archive_write_set_compression_gzip(a) == ARCHIVE_OK)
 			return ("tgz");
 		else
 			pkg_emit_error(notsupp_fmt, "gzip", "plain tar");
 	case TAR:
 		archive_write_set_compression_none(a);
 		return ("tar");
 	}
 	return (NULL);
 }

modified libpkg/pkg.c

@@ -167,14 +167,16 @@ pkg_is_valid(struct pkg *pkg)

 		return (EPKG_FATAL);
 	}
 	/* Ensure that required fields are set. */
 	for (i = 0; i < PKG_NUM_FIELDS; i++) {
 		if (fields[i].type & pkg->type && fields[i].optional == 0) {
 			if (pkg->fields[i] == NULL || sbuf_get(pkg->fields[i])[0] == '\0') {
 				pkg_emit_error("package field incomplete: %s",
 				    fields[i].human_desc);
 				return (EPKG_FATAL);
 			}
 		}
 		if ((fields[i].type & pkg->type) == 0 ||
 		    fields[i].optional ||
 		    pkg->fields[i] != NULL ||
 		    sbuf_get(pkg->fields[i])[0] != '\0')
 			continue;
 		pkg_emit_error("package field incomplete: %s",
 		    fields[i].human_desc);
 		return (EPKG_FATAL);
 	}
 	return (EPKG_OK);

@@ -187,7 +189,8 @@ pkg_vget(struct pkg const *const pkg, va_list ap)

 	while ((attr = va_arg(ap, int)) > 0) {
 		if (attr < PKG_NUM_FIELDS) {
 			*va_arg(ap, const char **) = (pkg->fields[attr] != NULL)?
 			const char **var = va_arg(ap, const char **);
 			*var = (pkg->fields[attr] != NULL) ?
 			    sbuf_get(pkg->fields[attr]) : NULL;
 			continue;
 		}

@@ -237,10 +240,22 @@ pkg_get2(struct pkg const *const pkg, ...)

 	return (ret);
 }
 static void
 pkg_set_repourl(struct pkg *pkg, const char *str)
 {
 	struct pkg_config_kv *rkv = NULL;
 	while (pkg_config_list(PKG_CONFIG_REPOS, &rkv) == EPKG_OK) {
 		const char *key = pkg_config_kv_get(rkv, PKG_CONFIG_KV_KEY);
 		const char *val = pkg_config_kv_get(rkv, PKG_CONFIG_KV_VALUE);
 		if (strcmp(str, key) == 0)
 			pkg_set(pkg, PKG_REPOURL, val);
 	}
 }
 static int
 pkg_vset(struct pkg *pkg, va_list ap)
 {
 	struct pkg_config_kv *repokv = NULL;
 	bool multirepos_enabled = false;
 	int attr;

@@ -263,41 +278,38 @@ pkg_vset(struct pkg *pkg, va_list ap)

 				continue;
 			}
 			if (attr == PKG_REPONAME && multirepos_enabled) {
 				while (pkg_config_list(PKG_CONFIG_REPOS, &repokv) == EPKG_OK) {
 					if (strcmp(str, pkg_config_kv_get(repokv, PKG_CONFIG_KV_KEY)) == 0)
 						pkg_set(pkg, PKG_REPOURL, pkg_config_kv_get(repokv, PKG_CONFIG_KV_VALUE));
 				}
 			}
 			if (attr == PKG_REPONAME && multirepos_enabled)
 				pkg_set_repourl(pkg, str);
 			sbuf_set(sbuf, str);
 			continue;
 		}
 		switch (attr) {
 			case PKG_AUTOMATIC:
 				pkg->automatic = (int)va_arg(ap, int64_t);
 				break;
 			case PKG_LICENSE_LOGIC:
 				pkg->licenselogic = (lic_t)va_arg(ap, int64_t);
 				break;
 			case PKG_FLATSIZE:
 				pkg->flatsize = va_arg(ap, int64_t);
 				break;
 			case PKG_NEW_FLATSIZE:
 				pkg->new_flatsize = va_arg(ap, int64_t);
 				break;
 			case PKG_NEW_PKGSIZE:
 				pkg->new_pkgsize = va_arg(ap, int64_t);
 				break;
 			case PKG_TIME:
 				pkg->time = va_arg(ap, int64_t);
 				break;
 			case PKG_ROWID:
 				pkg->rowid = va_arg(ap, int64_t);
 				break;
 			default:
 				va_arg(ap, void *); /* ignore */
 				break;
 		case PKG_AUTOMATIC:
 			pkg->automatic = (int)va_arg(ap, int64_t);
 			break;
 		case PKG_LICENSE_LOGIC:
 			pkg->licenselogic = (lic_t)va_arg(ap, int64_t);
 			break;
 		case PKG_FLATSIZE:
 			pkg->flatsize = va_arg(ap, int64_t);
 			break;
 		case PKG_NEW_FLATSIZE:
 			pkg->new_flatsize = va_arg(ap, int64_t);
 			break;
 		case PKG_NEW_PKGSIZE:
 			pkg->new_pkgsize = va_arg(ap, int64_t);
 			break;
 		case PKG_TIME:
 			pkg->time = va_arg(ap, int64_t);
 			break;
 		case PKG_ROWID:
 			pkg->rowid = va_arg(ap, int64_t);
 			break;
 		default:
 			/* XXX emit an error? */
 			(void) va_arg(ap, void *);
 			break;
 		}
 	}

modified libpkg/pkg_add.c

@@ -67,7 +67,10 @@ do_extract(struct archive *a, struct archive_entry *ae)

 	struct stat st;
 	do {
 		if (archive_read_extract(a, ae, EXTRACT_ARCHIVE_FLAGS) != ARCHIVE_OK) {
 		const char *pathname = archive_entry_pathname(ae);
 		ret = archive_read_extract(a, ae, EXTRACT_ARCHIVE_FLAGS);
 		if (ret != ARCHIVE_OK) {
 			/*
 			 * show error except when the failure is during
 			 * extracting a directory and that the directory already

@@ -75,8 +78,8 @@ do_extract(struct archive *a, struct archive_entry *ae)

 			 * this allow to install packages linux_base from
 			 * package for example
 			 */
 			if (!(archive_entry_filetype(ae) == AE_IFDIR &&
 			    is_dir(archive_entry_pathname(ae)))) {
 			if (archive_entry_filetype(ae) != AE_IFDIR ||
 			    !is_dir(pathname)) {
 				pkg_emit_error("archive_read_extract(): %s",
 				    archive_error_string(a));
 				retcode = EPKG_FATAL;

@@ -92,12 +95,13 @@ do_extract(struct archive *a, struct archive_entry *ae)

 		 * if conf1.cfg doesn't exists create it based on
 		 * conf1.cfg.pkgconf
 		 */
 		if (is_conf_file(archive_entry_pathname(ae), path, sizeof(path))
 		if (is_conf_file(pathname, path, sizeof(path))
 		    && lstat(path, &st) == ENOENT) {
 			archive_entry_set_pathname(ae, path);
 			if (archive_read_extract(a, ae, EXTRACT_ARCHIVE_FLAGS) != ARCHIVE_OK) {
 			ret = archive_read_extract(a,ae, EXTRACT_ARCHIVE_FLAGS);
 			if (ret != ARCHIVE_OK) {
 				pkg_emit_error("archive_read_extract(): %s",
 							   archive_error_string(a));
 				    archive_error_string(a));
 				retcode = EPKG_FATAL;
 				break;
 			}

@@ -106,7 +110,7 @@ do_extract(struct archive *a, struct archive_entry *ae)

 	if (ret != ARCHIVE_EOF) {
 		pkg_emit_error("archive_read_next_header(): %s",
 					   archive_error_string(a));
 		    archive_error_string(a));
 		retcode = EPKG_FATAL;
 	}

@@ -200,12 +204,16 @@ pkg_add(struct pkgdb *db, const char *path, int flags)

 	while (pkg_deps(pkg, &dep) == EPKG_OK) {
 		if (dep_installed(dep, db) != EPKG_OK) {
 			const char *dep_name = pkg_dep_name(dep);
 			const char *dep_ver = pkg_dep_version(dep);
 			snprintf(dpath, sizeof(dpath), "%s/%s-%s%s", basedir,
 					 pkg_dep_name(dep), pkg_dep_version(dep),
 					 ext);
 			    dep_name, dep_ver, ext);
 			if ((flags & PKG_ADD_UPGRADE) == 0 && access(dpath, F_OK) == 0) {
 				if (pkg_add(db, dpath, PKG_ADD_AUTOMATIC) != EPKG_OK) {
 			if ((flags & PKG_ADD_UPGRADE) == 0 &&
 			    access(dpath, F_OK) == 0) {
 				ret = pkg_add(db, dpath, PKG_ADD_AUTOMATIC);
 				if (ret != EPKG_OK) {
 					retcode = EPKG_FATAL;
 					goto cleanup;
 				}

modified libpkg/pkg_config.c

@@ -177,18 +177,39 @@ static bool parsed = false;

 static size_t c_size = sizeof(c) / sizeof(struct config_entry);
 static void
 parse_configuration(yaml_document_t *doc, yaml_node_t *node)
 parse_config_mapping(yaml_document_t *doc, yaml_node_t *map, size_t ent)
 {
 	size_t i;
 	yaml_node_pair_t *subpair = map->data.mapping.pairs.start;
 	yaml_node_t *subkey, *subval;
 	struct pkg_config_kv *kv;
 	yaml_node_pair_t *pair, *subpair;
 	yaml_node_t *key, *subkey;
 	yaml_node_t *val, *subval;
 	STAILQ_INIT(&c[ent].list);
 	while (subpair < map->data.mapping.pairs.top) {
 		subkey = yaml_document_get_node(doc, subpair->key);
 		subval = yaml_document_get_node(doc, subpair->value);
 		if (subkey->type != YAML_SCALAR_NODE ||
 		    subval->type != YAML_SCALAR_NODE) {
 			++subpair;
 			continue;
 		}
 		kv = malloc(sizeof(struct pkg_config_kv));
 		kv->key = strdup(subkey->data.scalar.value);
 		kv->value = strdup(subval->data.scalar.value);
 		STAILQ_INSERT_TAIL(&(c[ent].list), kv, next);
 		++subpair;
 	}
 }
 static void
 parse_configuration(yaml_document_t *doc, yaml_node_t *node)
 {
 	size_t ent;
 	yaml_node_pair_t *pair;
 	pair = node->data.mapping.pairs.start;
 	while (pair < node->data.mapping.pairs.top) {
 		key = yaml_document_get_node(doc, pair->key);
 		val = yaml_document_get_node(doc, pair->value);
 		yaml_node_t *key = yaml_document_get_node(doc, pair->key);
 		yaml_node_t *val = yaml_document_get_node(doc, pair->value);
 		if (key->data.scalar.length <= 0) {
 			/*

@@ -198,7 +219,9 @@ parse_configuration(yaml_document_t *doc, yaml_node_t *node)

 			continue;
 		}
 		if (val->type == YAML_NO_NODE || (val->type == YAML_SCALAR_NODE && val->data.scalar.length <= 0)) {
 		if (val->type == YAML_NO_NODE ||
 		    (val->type == YAML_SCALAR_NODE &&
 		     val->data.scalar.length <= 0)) {
 			/*
 			 * silently skip on purpose to allow user to leave
 			 * empty lines for examples without complaining

@@ -206,38 +229,21 @@ parse_configuration(yaml_document_t *doc, yaml_node_t *node)

 			++pair;
 			continue;
 		}
 		for (i = 0; i < c_size; i++) {
 			if (!strcasecmp(key->data.scalar.value, c[i].key)) {
 				if (c[i].val != NULL) {
 					/*
 					 * skip env var already set
 					 * Env vars have the priority over the
 					 * configuration files
 					 */
 					++pair;
 					continue;
 				}
 				if (val->type == YAML_SCALAR_NODE) {
 					c[i].val = strdup(val->data.scalar.value);
 				} else if (val->type == YAML_MAPPING_NODE) {
 					subpair = val->data.mapping.pairs.start;
 					STAILQ_INIT(&c[i].list);
 					while (subpair < val->data.mapping.pairs.top) {
 						subkey = yaml_document_get_node(doc, subpair->key);
 						subval = yaml_document_get_node(doc, subpair->value);
 						if (subkey->type != YAML_SCALAR_NODE || subval->type != YAML_SCALAR_NODE) {
 							++subpair;
 							continue;
 						}
 						kv = malloc(sizeof(struct pkg_config_kv));
 						kv->key = strdup(subkey->data.scalar.value);
 						kv->value = strdup(subval->data.scalar.value);
 						STAILQ_INSERT_TAIL(&(c[i].list), kv, next);
 						++subpair;
 					}
 				}
 				break;
 		for (ent = 0; ent < c_size; ent++) {
 			if (strcasecmp(key->data.scalar.value, c[ent].key))
 				continue;
 			if (c[ent].val != NULL) {
 				/*
 				 * skip env var already set
 				 * Env vars have priority over config files
 				 */
 				++pair;
 				continue;
 			}
 			if (val->type == YAML_SCALAR_NODE)
 				c[ent].val = strdup(val->data.scalar.value);
 			else if (val->type == YAML_MAPPING_NODE)
 				parse_config_mapping(doc, val, ent);
 		}
 		/*
 		 * unknown values are just silently ignored, because we don't

modified libpkg/pkg_create.c

@@ -41,7 +41,8 @@

 static int pkg_create_from_dir(struct pkg *, const char *, struct packing *);
 static int
 pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archive)
 pkg_create_from_dir(struct pkg *pkg, const char *root,
     struct packing *pkg_archive)
 {
 	char fpath[MAXPATHLEN + 1];
 	struct pkg_file *file = NULL;

@@ -61,12 +62,16 @@ pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archi

 	 * if the checksum is not provided in the manifest recompute it
 	 */
 	while (pkg_files(pkg, &file) == EPKG_OK) {
 		const char *pkg_path = pkg_file_path(file);
 		const char *pkg_sum = pkg_file_cksum(file);
 		if (root != NULL)
 			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_file_path(file));
 			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_path);
 		else
 			strlcpy(fpath, pkg_file_path(file), sizeof(fpath));
 			strlcpy(fpath, pkg_path, sizeof(fpath));
 		if ((pkg_file_cksum(file) == NULL || pkg_file_cksum(file)[0] == '\0') && lstat(fpath, &st) == 0 && !S_ISLNK(st.st_mode)) {
 		if ((pkg_sum == NULL || pkg_sum[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));

@@ -79,27 +84,33 @@ pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archi

 	pkg_get(pkg, PKG_MTREE, &mtree);
 	if (mtree != NULL)
 		packing_append_buffer(pkg_archive, mtree, "+MTREE_DIRS", strlen(mtree));
 		packing_append_buffer(pkg_archive, mtree, "+MTREE_DIRS",
 		    strlen(mtree));
 	while (pkg_files(pkg, &file) == EPKG_OK) {
 		const char *pkg_path = pkg_file_path(file);
 		if (root != NULL)
 			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_file_path(file));
 			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_path);
 		else
 			strlcpy(fpath, pkg_file_path(file), sizeof(fpath));
 			strlcpy(fpath, pkg_path, sizeof(fpath));
 		ret = packing_append_file_attr(pkg_archive, fpath, pkg_file_path(file), file->uname, file->gname, file->perm);
 		ret = packing_append_file_attr(pkg_archive, fpath, pkg_path,
 		    file->uname, file->gname, file->perm);
 		pkg_config_bool(PKG_CONFIG_DEVELOPER_MODE, &developer);
 		if (developer && ret != EPKG_OK)
 			return (ret);
 	}
 	while (pkg_dirs(pkg, &dir) == EPKG_OK) {
 		const char *pkg_path = pkg_dir_path(dir);
 		if (root != NULL)
 			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_dir_path(dir));
 			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_path);
 		else
 			strlcpy(fpath, pkg_dir_path(dir), sizeof(fpath));
 		ret = packing_append_file_attr(pkg_archive, fpath, pkg_dir_path(dir), dir->uname, dir->gname, dir->perm);
 		ret = packing_append_file_attr(pkg_archive, fpath, pkg_path,
 		    dir->uname, dir->gname, dir->perm);
 		pkg_config_bool(PKG_CONFIG_DEVELOPER_MODE, &developer);
 		if (developer && ret != EPKG_OK)
 			return (ret);

@@ -109,7 +120,8 @@ pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archi

 }
 static struct packing *
 pkg_create_archive(const char *outdir, struct pkg *pkg, pkg_formats format, int required_flags)
 pkg_create_archive(const char *outdir, struct pkg *pkg, pkg_formats format,
     int required_flags)
 {
 	char *pkg_path = NULL;
 	struct packing *pkg_archive = NULL;

@@ -162,7 +174,8 @@ static const char * const scripts[] = {

 };
 int
 pkg_create_staged(const char *outdir, pkg_formats format, const char *rootdir, const char *metadatadir, char *plist)
 pkg_create_staged(const char *outdir, pkg_formats format, const char *rootdir,
     const char *md_dir, char *plist)
 {
 	struct pkg *pkg = NULL;
 	struct pkg_file *file = NULL;

@@ -180,7 +193,7 @@ pkg_create_staged(const char *outdir, pkg_formats format, const char *rootdir, c

 	char *www;
 	/* Load the manifest from the metadata directory */
 	if (snprintf(path, sizeof(path), "%s/+MANIFEST", metadatadir) == -1)
 	if (snprintf(path, sizeof(path), "%s/+MANIFEST", md_dir) == -1)
 		goto cleanup;
 	pkg_new(&pkg, PKG_FILE);

@@ -196,7 +209,7 @@ pkg_create_staged(const char *outdir, pkg_formats format, const char *rootdir, c

 	pkg_get(pkg, PKG_DESC, &buf);
 	if (buf == NULL) {
 		if (snprintf(path, sizeof(path), "%s/+DESC", metadatadir) == -1)
 		if (snprintf(path, sizeof(path), "%s/+DESC", md_dir) == -1)
 			goto cleanup;
 		if (access(path, F_OK) == 0)
 			pkg_set_from_file(pkg, PKG_DESC, path);

@@ -205,7 +218,8 @@ pkg_create_staged(const char *outdir, pkg_formats format, const char *rootdir, c

 	/* if no message try to get it from a file */
 	pkg_get(pkg, PKG_MESSAGE, &buf);
 	if (buf == NULL) {
 		if (snprintf(path, sizeof(path), "%s/+DISPLAY", metadatadir) == -1)
 		ret = snprintf(path, sizeof(path), "%s/+DISPLAY", md_dir);
 		if (ret == -1)
 			goto cleanup;
 		if (access(path, F_OK) == 0)
 			pkg_set_from_file(pkg, PKG_MESSAGE, path);

@@ -221,19 +235,21 @@ pkg_create_staged(const char *outdir, pkg_formats format, const char *rootdir, c

 	/* if no mtree try to get it from a file */
 	pkg_get(pkg, PKG_MTREE, &buf);
 	if (buf == NULL) {
 		if (snprintf(path, sizeof(path), "%s/+MTREE_DIRS", metadatadir) == -1)
 		ret = snprintf(path, sizeof(path), "%s/+MTREE_DIRS", md_dir);
 		if (ret == -1)
 			goto cleanup;
 		if (access(path, F_OK) == 0)
 			pkg_set_from_file(pkg, PKG_MTREE, path);
 	}
 	for (i = 0; scripts[i] != NULL; i++) {
 		snprintf(path, sizeof(path), "%s/%s", metadatadir, scripts[i]);
 		snprintf(path, sizeof(path), "%s/%s", md_dir, scripts[i]);
 		if (access(path, F_OK) == 0)
 			pkg_addscript_file(pkg, path);
 	}
 	if (plist != NULL && ports_parse_plist(pkg, plist, rootdir) != EPKG_OK) {
 	if (plist != NULL &&
 	    ports_parse_plist(pkg, plist, rootdir) != EPKG_OK) {
 		ret = EPKG_FATAL;
 		goto cleanup;
 	}

@@ -242,7 +258,8 @@ pkg_create_staged(const char *outdir, pkg_formats format, const char *rootdir, c

 	pkg_get(pkg, PKG_WWW, &www);
 	if (www == NULL) {
 		pkg_get(pkg, PKG_DESC, &buf);
 		regcomp(&preg, "^WWW:[[:space:]]*(.*)$", REG_EXTENDED|REG_ICASE|REG_NEWLINE);
 		regcomp(&preg, "^WWW:[[:space:]]*(.*)$",
 		    REG_EXTENDED|REG_ICASE|REG_NEWLINE);
 		if (regexec(&preg, buf, 2, pmatch, 0) == 0) {
 			size = pmatch[1].rm_eo - pmatch[1].rm_so;
 			www = strndup(&buf[pmatch[1].rm_so], size);

@@ -264,9 +281,10 @@ pkg_create_staged(const char *outdir, pkg_formats format, const char *rootdir, c

 		goto cleanup;
 	}
 	if (pkg_files(pkg, &file) != EPKG_OK && pkg_dirs(pkg, &dir) != EPKG_OK) {
 	if (pkg_files(pkg, &file) != EPKG_OK &&
 	    pkg_dirs(pkg, &dir) != EPKG_OK) {
 		/* Now traverse the file directories, adding to the archive */
 		packing_append_tree(pkg_archive, metadatadir, NULL);
 		packing_append_tree(pkg_archive, md_dir, NULL);
 		packing_append_tree(pkg_archive, rootdir, "/");
 	} else {
 		pkg_create_from_dir(pkg, rootdir, pkg_archive);

@@ -285,12 +303,13 @@ cleanup:

 }
 int
 pkg_create_installed(const char *outdir, pkg_formats format, const char *rootdir, struct pkg *pkg)
 pkg_create_installed(const char *outdir, pkg_formats format,
     const char *rootdir, struct pkg *pkg)
 {
 	struct packing *pkg_archive;
 	int required_flags = PKG_LOAD_DEPS | PKG_LOAD_FILES | PKG_LOAD_CATEGORIES |
 	    PKG_LOAD_DIRS | PKG_LOAD_SCRIPTS | PKG_LOAD_OPTIONS |
 	    PKG_LOAD_MTREE | PKG_LOAD_LICENSES ;
 	int required_flags = PKG_LOAD_DEPS | PKG_LOAD_FILES |
 	    PKG_LOAD_CATEGORIES | PKG_LOAD_DIRS | PKG_LOAD_SCRIPTS |
 	    PKG_LOAD_OPTIONS | PKG_LOAD_MTREE | PKG_LOAD_LICENSES ;
 	assert(pkg->type == PKG_INSTALLED);

modified libpkg/pkg_delete.c

@@ -90,21 +90,26 @@ pkg_delete(struct pkg *pkg, struct pkgdb *db, int flags)

 		pkg_start_stop_rc_scripts(pkg, PKG_RC_STOP);
 	if (flags & PKG_DELETE_UPGRADE) {
 		if ((ret = pkg_script_run(pkg, PKG_SCRIPT_PRE_UPGRADE)) != EPKG_OK)
 		ret = pkg_script_run(pkg, PKG_SCRIPT_PRE_UPGRADE);
 		if (ret != EPKG_OK)
 			return (ret);
 	} else {
 		if ((ret = pkg_script_run(pkg, PKG_SCRIPT_PRE_DEINSTALL)) != EPKG_OK)
 		ret = pkg_script_run(pkg, PKG_SCRIPT_PRE_DEINSTALL);
 		if (ret != EPKG_OK)
 			return (ret);
 	}
 	if ((ret = pkg_delete_files(pkg, flags & PKG_DELETE_FORCE)) != EPKG_OK)
 		return (ret);
 	if (flags ^ PKG_DELETE_UPGRADE)
 		if ((ret = pkg_script_run(pkg, PKG_SCRIPT_POST_DEINSTALL)) != EPKG_OK)
 	if (flags ^ PKG_DELETE_UPGRADE) {
 		ret = pkg_script_run(pkg, PKG_SCRIPT_POST_DEINSTALL);
 		if (ret != EPKG_OK)
 			return (ret);
 	}
 	if ((ret = pkg_delete_dirs(db, pkg, flags & PKG_DELETE_FORCE)) != EPKG_OK)
 	ret = pkg_delete_dirs(db, pkg, flags & PKG_DELETE_FORCE);
 	if (ret != EPKG_OK)
 		return (ret);
 	if (flags ^ PKG_DELETE_UPGRADE)

@@ -122,6 +127,8 @@ pkg_delete_files(struct pkg *pkg, int force)

 	const char *path;
 	while (pkg_files(pkg, &file) == EPKG_OK) {
 		const char *sum = pkg_file_cksum(file);
 		if (file->keep == 1)
 			continue;

@@ -129,12 +136,12 @@ pkg_delete_files(struct pkg *pkg, int force)

 		/* Regular files and links */
 		/* check sha256 */
 		if (!force && pkg_file_cksum(file)[0] != '\0') {
 		if (!force && sum[0] != '\0') {
 			if (sha256_file(path, sha256) != EPKG_OK)
 				continue;
 			if (strcmp(sha256, pkg_file_cksum(file)) != 0) {
 				pkg_emit_error("%s fails original SHA256 checksum,"
 							   " not removing", path);
 			if (strcmp(sha256, sum)) {
 				pkg_emit_error("%s fails original SHA256 "
 				    "checksum, not removing", path);
 				continue;
 			}
 		}

@@ -152,26 +159,14 @@ int

 pkg_delete_dirs(__unused struct pkgdb *db, struct pkg *pkg, int force)
 {
 	struct pkg_dir *dir = NULL;
 /*	int64_t nbpackage; */
 	while (pkg_dirs(pkg, &dir) == EPKG_OK) {
 		if (dir->keep == 1)
 			continue;
 		/*
 		 * To reactivate when stage install will be in otherwise
 		 * This code left cruft on server because sometime package
 		 */
 /*		nbpackage = 0;
 		if (pkgdb_is_dir_used(db, pkg_dir_path(dir), &nbpackage) != EPKG_OK)
 			return (EPKG_FATAL);
 		if (nbpackage > 1)
 			continue; */
 		if (pkg_dir_try(dir)) {
 			if (rmdir(pkg_dir_path(dir)) == -1 && errno != ENOTEMPTY && force != 1)
 			if (rmdir(pkg_dir_path(dir)) == -1 &&
 			    errno != ENOTEMPTY && force != 1)
 				pkg_emit_errno("rmdir", pkg_dir_path(dir));
 		} else {
 			if (rmdir(pkg_dir_path(dir)) == -1 && force != 1)

modified libpkg/pkg_elf.c

@@ -67,14 +67,16 @@ test_depends(struct pkgdb *db, struct pkg *pkg, const char *name)

 	pkg_config_bool(PKG_CONFIG_SHLIBS, &shlibs);
 	if ((handle = dlopen(name, RTLD_LAZY)) == NULL) {
 		pkg_emit_error("accessing shared library %s failed -- %s", name, dlerror());
 		pkg_emit_error("accessing shared library %s failed -- %s",
 		    name, dlerror());
 		return (EPKG_FATAL);
 	}
 	dlinfo(handle, RTLD_DI_LINKMAP, &map);
 	/* match /lib, /lib32, /usr/lib and /usr/lib32 */
 	if (strncmp(map->l_name, "/lib", 4) == 0 || strncmp(map->l_name, "/usr/lib", 7) == 0) {
 	if (strncmp(map->l_name, "/lib", 4) == 0 ||
 	    strncmp(map->l_name, "/usr/lib", 7) == 0) {
 		/* ignore libs from base */
 		dlclose(handle);
 		return (EPKG_OK);

@@ -95,7 +97,8 @@ test_depends(struct pkgdb *db, struct pkg *pkg, const char *name)

 	d = NULL;
 	if (pkgdb_it_next(it, &d, PKG_LOAD_BASIC) == EPKG_OK) {
 		found = false;
 		pkg_get(d, PKG_ORIGIN, &deporigin, PKG_NAME, &depname, PKG_VERSION, &depversion);
 		pkg_get(d, PKG_ORIGIN, &deporigin, PKG_NAME, &depname,
 		    PKG_VERSION, &depversion);
 		dep = NULL;
 		found = false;

@@ -159,7 +162,8 @@ analyse_elf(struct pkgdb *db, struct pkg *pkg, const char *fpath)

 	if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
 		ret = EPKG_FATAL;
 		pkg_emit_error("elf_begin() for %s failed: %s", fpath, elf_errmsg(-1));
 		pkg_emit_error("elf_begin() for %s failed: %s", fpath,
 		    elf_errmsg(-1));
 		goto cleanup;
 	}

@@ -185,7 +189,8 @@ analyse_elf(struct pkgdb *db, struct pkg *pkg, const char *fpath)

 	while ((scn = elf_nextscn(e, scn)) != NULL) {
 		if (gelf_getshdr(scn, &shdr) != &shdr) {
 			ret = EPKG_FATAL;
 			pkg_emit_error("getshdr() for %s failed: %s", fpath, elf_errmsg(-1));
 			pkg_emit_error("getshdr() for %s failed: %s", fpath,
 			    elf_errmsg(-1));
 			goto cleanup;
 		}
 		switch (shdr.sh_type) {

@@ -230,7 +235,8 @@ analyse_elf(struct pkgdb *db, struct pkg *pkg, const char *fpath)

 	for (dynidx = 0; dynidx < numdyn; dynidx++) {
 		if ((dyn = gelf_getdyn(data, dynidx, &dyn_mem)) == NULL) {
 			ret = EPKG_FATAL;
 			pkg_emit_error("getdyn() failed for %s: %s", fpath, elf_errmsg(-1));
 			pkg_emit_error("getdyn() failed for %s: %s", fpath,
 			    elf_errmsg(-1));
 			goto cleanup;
 		}

@@ -335,10 +341,11 @@ pkg_get_myarch(char *dest, size_t sz)

 	uint32_t version = 0;
 	int ret = EPKG_OK;
 	int i;
 	const char *abi;
 	const char *abi, *endian_corres_str, *wordsize_corres_str;
 	if (elf_version(EV_CURRENT) == EV_NONE) {
 		pkg_emit_error("ELF library initialization failed: %s", elf_errmsg(-1));
 		pkg_emit_error("ELF library initialization failed: %s",
 		    elf_errmsg(-1));
 		return (EPKG_FATAL);
 	}

@@ -396,44 +403,53 @@ pkg_get_myarch(char *dest, size_t sz)

 	for (i = 0; osname[i] != '\0'; i++)
 		osname[i] = (char)tolower(osname[i]);
 	wordsize_corres_str = elf_corres_to_string(wordsize_corres,
 	    (int)elfhdr.e_ident[EI_CLASS]);
 	snprintf(dest, sz, "%s:%d:%s:%s",
 	    osname,
 	    version / 100000,
 	    osname, version / 100000,
 	    elf_corres_to_string(mach_corres, (int) elfhdr.e_machine),
 	    elf_corres_to_string(wordsize_corres, (int)elfhdr.e_ident[EI_CLASS]));
 	    wordsize_corres_str);
 	switch (elfhdr.e_machine) {
 		case EM_ARM:
 			snprintf(dest + strlen(dest), sz - strlen(dest), ":%s:%s:%s",
 			    elf_corres_to_string(endian_corres, (int) elfhdr.e_ident[EI_DATA]),
 			    (elfhdr.e_flags & EF_ARM_NEW_ABI) > 0 ? "eabi" : "oabi",
 			    (elfhdr.e_flags & EF_ARM_VFP_FLOAT) > 0 ? "softfp" : "vfp");
 			break;
 		case EM_MIPS:
 			/*
 			 * this is taken from binutils sources:
 			 * include/elf/mips.h
 			 * mapping is figured out from binutils:
 			 * gas/config/tc-mips.c
 			 */
 			switch (elfhdr.e_flags & EF_MIPS_ABI) {
 				case E_MIPS_ABI_O32:
 	case EM_ARM:
 		endian_corres_str = elf_corres_to_string(endian_corres,
 		    (int)elfhdr.e_ident[EI_DATA]);
 		snprintf(dest + strlen(dest), sz - strlen(dest), ":%s:%s:%s",
 		    endian_corres_str,
 		    (elfhdr.e_flags & EF_ARM_NEW_ABI) > 0 ? "eabi" : "oabi",
 		    (elfhdr.e_flags & EF_ARM_VFP_FLOAT) > 0 ? "softfp" : "vfp");
 		break;
 	case EM_MIPS:
 		/*
 		 * this is taken from binutils sources:
 		 * include/elf/mips.h
 		 * mapping is figured out from binutils:
 		 * gas/config/tc-mips.c
 		 */
 		switch (elfhdr.e_flags & EF_MIPS_ABI) {
 			case E_MIPS_ABI_O32:
 				abi = "o32";
 				break;
 			case E_MIPS_ABI_N32:
 				abi = "n32";
 				break;
 			default:
 				if (elfhdr.e_ident[EI_DATA] == ELFCLASS32)
 					abi = "o32";
 					break;
 				case E_MIPS_ABI_N32:
 					abi = "n32";
 					break;
 				default:
 					if (elfhdr.e_ident[EI_DATA] == ELFCLASS32)
 						abi = "o32";
 					else if (elfhdr.e_ident[EI_DATA] == ELFCLASS64)
 						abi = "n64";
 					break;
 			}
 			snprintf(dest + strlen(dest), sz - strlen(dest), ":%s:%s",
 			    elf_corres_to_string(endian_corres, (int) elfhdr.e_ident[EI_DATA]),
 			    abi);
 			break;
 				else if (elfhdr.e_ident[EI_DATA] == ELFCLASS64)
 					abi = "n64";
 				break;
 		}
 		endian_corres_str = elf_corres_to_string(endian_corres,
 		    (int)elfhdr.e_ident[EI_DATA]);
 		snprintf(dest + strlen(dest), sz - strlen(dest), ":%s:%s",
 		    endian_corres_str, abi);
 		break;
 	default:
 		break;
 	}
 cleanup:

@@ -452,25 +468,31 @@ pkg_suggest_arch(struct pkg *pkg, const char *arch, bool isdefault)

 	iswildcard = (strchr(arch, 'c') != NULL);
 	if (iswildcard && isdefault)
 		pkg_emit_error("Configuration error: arch \"%s\" cannot use wildcards as default", arch);
 		pkg_emit_error("Configuration error: arch \"%s\" cannot use "
 		    "wildcards as default", arch);
 	if (pkg->flags & (PKG_CONTAINS_ELF_OBJECTS|PKG_CONTAINS_STATIC_LIBS)) {
 		if (iswildcard) {
 			/* Definitely has to be arch specific */
 			pkg_emit_error("Error: arch \"%s\" -- package installs architecture specific files", arch);
 			pkg_emit_error("Error: arch \"%s\" -- package installs "
 			    "architecture specific files", arch);
 		}
 	} else {
 		if (pkg->flags & PKG_CONTAINS_H_OR_LA) {
 			if (iswildcard) {
 				/* Could well be arch specific */
 				pkg_emit_error("Warning: arch \"%s\" -- package installs C/C++ headers or libtool files,\n"
 					       "**** which are often architecture specific.", arch);
 				pkg_emit_error("Warning: arch \"%s\" -- package"
 				    " installs C/C++ headers or libtool "
 				    "files,\n**** which are often architecture "
 				    "specific", arch);
 			}
 		} else {
 			/* Might be arch independent */
 			if (!iswildcard)
 				pkg_emit_error("Notice: arch \"%s\" -- no architecture specific files found:\n"
 					       "**** could this package use a wildcard architecture?", arch);
 				pkg_emit_error("Notice: arch \"%s\" -- no "
 				    "architecture specific files found:\n"
 				    "**** could this package use a wildcard "
 				    "architecture?", arch);
 		}
 	}
 	return (EPKG_OK);

modified libpkg/pkg_event.c

@@ -201,18 +201,18 @@ pkg_emit_upgrade_finished(struct pkg *p)

 	pkg_config_bool(PKG_CONFIG_SYSLOG, &syslog_enabled);
 	if (syslog_enabled) {
 		pkg_get(p, PKG_NAME, &name, PKG_VERSION, &version, PKG_NEWVERSION, &newversion);
 		switch (pkg_version_cmp(version, newversion)) {
 			case 1:
 				syslog(LOG_NOTICE, "%s downgraded: %s -> %s ", name, version, newversion);
 				break;
 			case 0:
 				syslog(LOG_NOTICE, "%s reinstalled: %s -> %s ", name, version, newversion);
 				break;
 			case -1:
 				syslog(LOG_NOTICE, "%s upgraded: %s -> %s ", name, version, newversion);
 				break;
 		}
 		const char *actions[] = {
 		    "upgraded", "reinstalled", "downgraded"
 		};
 		int num_actions = sizeof(actions) / sizeof(*actions);
 		int action;
 		pkg_get(p, PKG_NAME, &name, PKG_VERSION, &version,
 		    PKG_NEWVERSION, &newversion);
 		action = pkg_version_cmp(version, newversion) + 1;
 		if (action >= 0 && action < num_actions)
 			syslog(LOG_NOTICE, "%s %s: %s -> %s ",
 			    name, actions[action], version, newversion);
 	}
 	pkg_emit_event(&ev);

modified libpkg/pkg_jobs.c

@@ -164,7 +164,8 @@ pkg_jobs_install(struct pkg_jobs *j, bool force)

 	const char *cachedir = NULL;
 	int flags = 0;
 	int retcode = EPKG_FATAL;
 	int lflags = PKG_LOAD_BASIC | PKG_LOAD_FILES | PKG_LOAD_SCRIPTS |
 	    PKG_LOAD_DIRS;
 	bool handle_rc = false;
 	STAILQ_INIT(&pkg_queue);

@@ -176,6 +177,8 @@ pkg_jobs_install(struct pkg_jobs *j, bool force)

 	if (pkg_config_string(PKG_CONFIG_CACHEDIR, &cachedir) != EPKG_OK)
 		return (EPKG_FATAL);
 	pkg_config_bool(PKG_CONFIG_HANDLE_RC_SCRIPTS, &handle_rc);
 	p = NULL;
 	/* Install */
 	sql_exec(j->db->sqlite, "SAVEPOINT upgrade;");

@@ -191,17 +194,19 @@ pkg_jobs_install(struct pkg_jobs *j, bool force)

 			pkg = NULL;
 			it = pkgdb_query(j->db, pkgorigin, MATCH_EXACT);
 			if (it != NULL) {
 				if (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC|PKG_LOAD_FILES|PKG_LOAD_SCRIPTS|PKG_LOAD_DIRS) == EPKG_OK) {
 				if (pkgdb_it_next(it, &pkg, lflags) == EPKG_OK) {
 					STAILQ_INSERT_TAIL(&pkg_queue, pkg, next);
 					pkg_script_run(pkg, PKG_SCRIPT_PRE_DEINSTALL);
 					pkg_script_run(pkg,
 					    PKG_SCRIPT_PRE_DEINSTALL);
 					pkg_get(pkg, PKG_ORIGIN, &origin);
 					/*
 					 * stop the different related services if the users do want that
 					 * and that the service is running
 					 * stop the different related services
 					 * if the user wants that and the
 					 * service is running
 					 */
 					pkg_config_bool(PKG_CONFIG_HANDLE_RC_SCRIPTS, &handle_rc);
 					if (handle_rc)
 						pkg_start_stop_rc_scripts(pkg, PKG_RC_STOP);
 						pkg_start_stop_rc_scripts(pkg,
 						    PKG_RC_STOP);
 					pkgdb_unregister_pkg(j->db, origin);
 					pkg = NULL;
 				}

@@ -213,17 +218,17 @@ pkg_jobs_install(struct pkg_jobs *j, bool force)

 		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) {
 			while (pkgdb_it_next(it, &pkg, lflags) == EPKG_OK) {
 				STAILQ_INSERT_TAIL(&pkg_queue, pkg, next);
 				pkg_script_run(pkg, PKG_SCRIPT_PRE_DEINSTALL);
 				pkg_get(pkg, PKG_ORIGIN, &origin);
 				/*
 				 * stop the different related services if the users do want that
 				 * and that the service is running
 				 * stop the different related services if the
 				 * user wants that and the service is running
 				 */
 				pkg_config_bool(PKG_CONFIG_HANDLE_RC_SCRIPTS, &handle_rc);
 				if (handle_rc)
 					pkg_start_stop_rc_scripts(pkg, PKG_RC_STOP);
 					pkg_start_stop_rc_scripts(pkg,
 					    PKG_RC_STOP);
 				pkgdb_unregister_pkg(j->db, origin);
 				pkg = NULL;
 			}

@@ -337,8 +342,6 @@ pkg_jobs_fetch(struct pkg_jobs *j)

 	const char *cachedir = NULL;
 	const char *repopath = NULL;
 	char cachedpath[MAXPATHLEN];
 	char dlsz[7];
 	char fsz[7];
 	int ret = EPKG_OK;
 	if (pkg_config_string(PKG_CONFIG_CACHEDIR, &cachedir) != EPKG_OK)

@@ -366,9 +369,13 @@ pkg_jobs_fetch(struct pkg_jobs *j)

 	}
 	if (dlsize > ((int64_t)fs.f_bsize * (int64_t)fs.f_bfree)) {
 		int64_t fsize = (int64_t)fs.f_bsize * (int64_t)fs.f_bfree;
 		char dlsz[7], fsz[7];
 		humanize_number(dlsz, sizeof(dlsz), dlsize, "B", HN_AUTOSCALE, 0);
 		humanize_number(fsz, sizeof(fsz), (int64_t)fs.f_bsize * (int64_t)fs.f_bfree, "B", HN_AUTOSCALE, 0);
 		pkg_emit_error("Not enough space in %s, needed %s available %s", cachedir, dlsz, fsz);
 		humanize_number(fsz, sizeof(fsz), fsize, "B", HN_AUTOSCALE, 0);
 		pkg_emit_error("Not enough space in %s, needed %s available %s",
 		    cachedir, dlsz, fsz);
 		return (EPKG_FATAL);
 	}

modified libpkg/pkg_manifest.c

@@ -90,15 +90,23 @@ static struct manifest_key {

 	{ "infos", PKG_INFOS, YAML_SCALAR_NODE, pkg_set_from_node},
 	{ "categories", PKG_CATEGORIES, YAML_SEQUENCE_NODE, parse_sequence},
 	{ "options", PKG_OPTIONS, YAML_MAPPING_NODE, parse_mapping},
 	{ "users", PKG_USERS, YAML_SEQUENCE_NODE, parse_sequence}, /* compatibility with old format */
 	/* compatibility with old format */
 	{ "users", PKG_USERS, YAML_SEQUENCE_NODE, parse_sequence},
 	{ "users", PKG_USERS, YAML_MAPPING_NODE, parse_mapping},
 	{ "groups", PKG_GROUPS, YAML_SEQUENCE_NODE, parse_sequence},
 	{ "groups", PKG_GROUPS, YAML_MAPPING_NODE, parse_mapping}, /* compatibility with old format */
 	/* compatibility with old format */
 	{ "groups", PKG_GROUPS, YAML_MAPPING_NODE, parse_mapping},
 	{ "shlibs", PKG_SHLIBS, YAML_SEQUENCE_NODE, parse_sequence},
 	{ NULL, -99, -99, NULL}
 };
 static int
 is_valid_yaml_scalar(yaml_node_t *val)
 {
 	return (val->type == YAML_SCALAR_NODE && val->data.scalar.length > 0);
 }
 static int
 urlencode(const char *src, struct sbuf **dest)
 {
 	size_t len;

@@ -176,12 +184,13 @@ pkg_load_manifest_file(struct pkg *pkg, const char *fpath)

 }
 static int
 pkg_set_from_node(struct pkg *pkg, yaml_node_t *val, __unused yaml_document_t *doc, int attr)
 pkg_set_from_node(struct pkg *pkg, yaml_node_t *val,
     __unused yaml_document_t *doc, int attr)
 {
 	int ret = EPKG_OK;
 	while (val->data.scalar.length > 0 &&
 			val->data.scalar.value[val->data.scalar.length - 1] == '\n') {
 	    val->data.scalar.value[val->data.scalar.length - 1] == '\n') {
 		val->data.scalar.value[val->data.scalar.length - 1] = '\0';
 		val->data.scalar.length--;
 	}

@@ -192,7 +201,8 @@ pkg_set_from_node(struct pkg *pkg, yaml_node_t *val, __unused yaml_document_t *d

 }
 static int
 pkg_set_flatsize_from_node(struct pkg *pkg, yaml_node_t *val, __unused yaml_document_t *doc, __unused int attr)
 pkg_set_flatsize_from_node(struct pkg *pkg, yaml_node_t *val,
     __unused yaml_document_t *doc, __unused int attr)
 {
 	int64_t flatsize;
 	const char *errstr = NULL;

@@ -206,23 +216,28 @@ pkg_set_flatsize_from_node(struct pkg *pkg, yaml_node_t *val, __unused yaml_docu

 	return (pkg_set(pkg, PKG_FLATSIZE, flatsize));
 }
 static int
 pkg_set_licenselogic_from_node(struct pkg *pkg, yaml_node_t *val, __unused yaml_document_t *doc, __unused int attr)
 pkg_set_licenselogic_from_node(struct pkg *pkg, yaml_node_t *val,
     __unused yaml_document_t *doc, __unused int attr)
 {
 	if (!strcmp(val->data.scalar.value, "single"))
 		pkg_set(pkg, PKG_LICENSE_LOGIC, (int64_t) LICENSE_SINGLE);
 	else if (!strcmp(val->data.scalar.value, "and") || !strcmp(val->data.scalar.value, "dual"))
 	else if (!strcmp(val->data.scalar.value, "and") ||
 	    !strcmp(val->data.scalar.value, "dual"))
 		pkg_set(pkg, PKG_LICENSE_LOGIC, (int64_t)LICENSE_AND);
 	else if (!strcmp(val->data.scalar.value, "or") || !strcmp(val->data.scalar.value, "multi"))
 	else if (!strcmp(val->data.scalar.value, "or") ||
 	    !strcmp(val->data.scalar.value, "multi"))
 		pkg_set(pkg, PKG_LICENSE_LOGIC, (int64_t)LICENSE_OR);
 	else {
 		pkg_emit_error("Unknown license logic: %s", val->data.scalar.value);
 		pkg_emit_error("Unknown license logic: %s",
 		    val->data.scalar.value);
 		return (EPKG_FATAL);
 	}
 	return (EPKG_OK);
 }
 static int
 parse_sequence(struct pkg * pkg, yaml_node_t *node, yaml_document_t *doc, int attr)
 parse_sequence(struct pkg * pkg, yaml_node_t *node, yaml_document_t *doc,
     int attr)
 {
 	yaml_node_item_t *item;
 	yaml_node_t *val;

@@ -231,47 +246,47 @@ parse_sequence(struct pkg * pkg, yaml_node_t *node, yaml_document_t *doc, int at

 	while (item < node->data.sequence.items.top) {
 		val = yaml_document_get_node(doc, *item);
 		switch (attr) {
 			case PKG_CATEGORIES:
 				if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0)
 					pkg_emit_error("Skipping malformed category");
 				else
 					pkg_addcategory(pkg, val->data.scalar.value);
 				break;
 			case PKG_LICENSES:
 				if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0)
 					pkg_emit_error("Skipping malformed license");
 				else
 					pkg_addlicense(pkg, val->data.scalar.value);
 				break;
 			case PKG_USERS:
 				if (val->type == YAML_SCALAR_NODE && val->data.scalar.length > 0)
 					pkg_adduser(pkg, val->data.scalar.value);
 				else if (val->type == YAML_MAPPING_NODE)
 					parse_mapping(pkg, val, doc, attr);
 				else
 					pkg_emit_error("Skipping malformed license");
 				break;
 			case PKG_GROUPS:
 				if (val->type == YAML_SCALAR_NODE && val->data.scalar.length > 0)
 					pkg_addgroup(pkg, val->data.scalar.value);
 				else if (val->type == YAML_MAPPING_NODE)
 					parse_mapping(pkg, val, doc, attr);
 				else
 					pkg_emit_error("Skipping malformed license");
 				break;
 			case PKG_DIRS:
 				if (val->type == YAML_SCALAR_NODE && val->data.scalar.length > 0)
 					pkg_adddir(pkg, val->data.scalar.value, 1);
 				else if (val->type == YAML_MAPPING_NODE)
 					parse_mapping(pkg, val, doc, attr);
 				else
 					pkg_emit_error("Skipping malformed dirs");
 				break;
 			case PKG_SHLIBS:
 				if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0)
 					pkg_emit_error("Skipping malformed shared library");
 				else
 					pkg_addshlib(pkg, val->data.scalar.value);
 		case PKG_CATEGORIES:
 			if (!is_valid_yaml_scalar(val))
 				pkg_emit_error("Skipping malformed category");
 			else
 				pkg_addcategory(pkg, val->data.scalar.value);
 			break;
 		case PKG_LICENSES:
 			if (!is_valid_yaml_scalar(val))
 				pkg_emit_error("Skipping malformed license");
 			else
 				pkg_addlicense(pkg, val->data.scalar.value);
 			break;
 		case PKG_USERS:
 			if (is_valid_yaml_scalar(val))
 				pkg_adduser(pkg, val->data.scalar.value);
 			else if (val->type == YAML_MAPPING_NODE)
 				parse_mapping(pkg, val, doc, attr);
 			else
 				pkg_emit_error("Skipping malformed license");
 			break;
 		case PKG_GROUPS:
 			if (is_valid_yaml_scalar(val))
 				pkg_addgroup(pkg, val->data.scalar.value);
 			else if (val->type == YAML_MAPPING_NODE)
 				parse_mapping(pkg, val, doc, attr);
 			else
 				pkg_emit_error("Skipping malformed license");
 			break;
 		case PKG_DIRS:
 			if (is_valid_yaml_scalar(val))
 				pkg_adddir(pkg, val->data.scalar.value, 1);
 			else if (val->type == YAML_MAPPING_NODE)
 				parse_mapping(pkg, val, doc, attr);
 			else
 				pkg_emit_error("Skipping malformed dirs");
 			break;
 		case PKG_SHLIBS:
 			if (!is_valid_yaml_scalar(val))
 				pkg_emit_error("Skipping malformed shared library");
 			else
 				pkg_addshlib(pkg, val->data.scalar.value);
 		}
 		++item;
 	}

@@ -279,6 +294,30 @@ parse_sequence(struct pkg * pkg, yaml_node_t *node, yaml_document_t *doc, int at

 }
 static int
 script_type_str(const char *str)
 {
 	if (strcmp(str, "pre-install") == 0)
 		return (PKG_SCRIPT_PRE_INSTALL);
 	if (strcmp(str, "install") == 0)
 		return (PKG_SCRIPT_INSTALL);
 	if (strcmp(str, "post-install") == 0)
 		return (PKG_SCRIPT_POST_INSTALL);
 	if (strcmp(str, "pre-upgrade") == 0)
 		return (PKG_SCRIPT_PRE_UPGRADE);
 	if (strcmp(str, "upgrade") == 0)
 		return (PKG_SCRIPT_UPGRADE);
 	if (strcmp(str, "post-upgrade") == 0)
 		return (PKG_SCRIPT_POST_UPGRADE);
 	if (strcmp(str, "pre-deinstall") == 0)
 		return (PKG_SCRIPT_PRE_DEINSTALL);
 	if (strcmp(str, "deinstall") == 0)
 		return (PKG_SCRIPT_DEINSTALL);
 	if (strcmp(str, "post-deinstall") == 0)
 		return (PKG_SCRIPT_POST_DEINSTALL);
 	return (INT_MAX);
 }
 static int
 parse_mapping(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc, int attr)
 {
 	struct sbuf *tmp = NULL;

@@ -300,96 +339,89 @@ parse_mapping(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc, int attr

 		}
 		switch (attr) {
 			case PKG_DEPS:
 				if (val->type != YAML_MAPPING_NODE)
 					pkg_emit_error("Skipping malformed depencency %s",
 								   key->data.scalar.value);
 				else
 					pkg_set_deps_from_node(pkg, val, doc, key->data.scalar.value);
 				break;
 			case PKG_DIRS:
 				if (val->type != YAML_MAPPING_NODE)
 					pkg_emit_error("Skipping malformed dirs %s",
 								   key->data.scalar.value);
 				else
 					pkg_set_dirs_from_node(pkg, val, doc, key->data.scalar.value);
 				break;
 			case PKG_USERS:
 				if (val->type == YAML_SCALAR_NODE && val->data.scalar.length > 0)
 					pkg_adduid(pkg, key->data.scalar.value, val->data.scalar.value);
 				else
 					pkg_emit_error("Skipping malformed users %s",
 							key->data.scalar.value);
 				break;
 			case PKG_GROUPS:
 				if (val->type == YAML_SCALAR_NODE && val->data.scalar.length > 0)
 					pkg_addgid(pkg, key->data.scalar.value, val->data.scalar.value);
 				else
 					pkg_emit_error("Skipping malformed groups %s",
 							key->data.scalar.value);
 				break;
 			case PKG_DIRECTORIES:
 				if (val->type == YAML_SCALAR_NODE && val->data.scalar.length > 0) {
 					urldecode(key->data.scalar.value, &tmp);
 					if (val->data.scalar.value[0] == 'y')
 						pkg_adddir(pkg, sbuf_get(tmp), 1);
 					else
 						pkg_adddir(pkg, sbuf_get(tmp), 0);
 				} else if (val->type == YAML_MAPPING_NODE) {
 					pkg_set_dirs_from_node(pkg, val, doc, key->data.scalar.value);
 				} else {
 					pkg_emit_error("Skipping malformed directories %s",
 								   key->data.scalar.value);
 				}
 				break;
 			case PKG_FILES:
 				if (val->type == YAML_SCALAR_NODE && val->data.scalar.length > 0) {
 					urldecode(key->data.scalar.value, &tmp);
 					pkg_addfile(pkg, sbuf_get(tmp), val->data.scalar.length == 64 ? val->data.scalar.value : NULL, true);
 				} else if (val->type == YAML_MAPPING_NODE)
 					pkg_set_files_from_node(pkg, val, doc, key->data.scalar.value);
 				else
 					pkg_emit_error("Skipping malformed files %s",
 								   key->data.scalar.value);
 				break;
 			case PKG_OPTIONS:
 				if (val->type != YAML_SCALAR_NODE)
 					pkg_emit_error("Skipping malformed option %s",
 								   key->data.scalar.value);
 		case PKG_DEPS:
 			if (val->type != YAML_MAPPING_NODE)
 				pkg_emit_error("Skipping malformed dependency %s",
 				    key->data.scalar.value);
 			else
 				pkg_set_deps_from_node(pkg, val, doc,
 				    key->data.scalar.value);
 			break;
 		case PKG_DIRS:
 			if (val->type != YAML_MAPPING_NODE)
 				pkg_emit_error("Skipping malformed dirs %s",
 				    key->data.scalar.value);
 			else
 				pkg_set_dirs_from_node(pkg, val, doc,
 				    key->data.scalar.value);
 			break;
 		case PKG_USERS:
 			if (is_valid_yaml_scalar(val))
 				pkg_adduid(pkg, key->data.scalar.value,
 				    val->data.scalar.value);
 			else
 				pkg_emit_error("Skipping malformed users %s",
 						key->data.scalar.value);
 			break;
 		case PKG_GROUPS:
 			if (is_valid_yaml_scalar(val))
 				pkg_addgid(pkg, key->data.scalar.value,
 				    val->data.scalar.value);
 			else
 				pkg_emit_error("Skipping malformed groups %s",
 						key->data.scalar.value);
 			break;
 		case PKG_DIRECTORIES:
 			if (is_valid_yaml_scalar(val)) {
 				urldecode(key->data.scalar.value, &tmp);
 				if (val->data.scalar.value[0] == 'y')
 					pkg_adddir(pkg, sbuf_get(tmp), 1);
 				else
 					pkg_addoption(pkg, key->data.scalar.value, val->data.scalar.value);
 				break;
 			case PKG_SCRIPTS:
 				if (val->type != YAML_SCALAR_NODE)
 					pkg_emit_error("Skipping malformed scripts %s",
 								   key->data.scalar.value);
 				if (strcmp(key->data.scalar.value, "pre-install") == 0) {
 					script_type = PKG_SCRIPT_PRE_INSTALL;
 				} else if (strcmp(key->data.scalar.value, "install") == 0) {
 					script_type = PKG_SCRIPT_INSTALL;
 				} else if (strcmp(key->data.scalar.value, "post-install") == 0) {
 					script_type = PKG_SCRIPT_POST_INSTALL;
 				} else if (strcmp(key->data.scalar.value, "pre-upgrade") == 0) {
 					script_type = PKG_SCRIPT_PRE_UPGRADE;
 				} else if (strcmp(key->data.scalar.value, "upgrade") == 0) {
 					script_type = PKG_SCRIPT_UPGRADE;
 				} else if (strcmp(key->data.scalar.value, "post-upgrade") == 0) {
 					script_type = PKG_SCRIPT_POST_UPGRADE;
 				} else if (strcmp(key->data.scalar.value, "pre-deinstall") == 0) {
 					script_type = PKG_SCRIPT_PRE_DEINSTALL;
 				} else if (strcmp(key->data.scalar.value, "deinstall") == 0) {
 					script_type = PKG_SCRIPT_DEINSTALL;
 				} else if (strcmp(key->data.scalar.value, "post-deinstall") == 0) {
 					script_type = PKG_SCRIPT_POST_DEINSTALL;
 				} else {
 					pkg_emit_error("Skipping unknown script type: %s",
 								   key->data.scalar.value);
 					break;
 				}
 				urldecode(val->data.scalar.value, &tmp);
 				pkg_addscript(pkg, sbuf_get(tmp), script_type);
 					pkg_adddir(pkg, sbuf_get(tmp), 0);
 			} else if (val->type == YAML_MAPPING_NODE) {
 				pkg_set_dirs_from_node(pkg, val, doc,
 				    key->data.scalar.value);
 			} else {
 				pkg_emit_error("Skipping malformed directories %s",
 				    key->data.scalar.value);
 			}
 			break;
 		case PKG_FILES:
 			if (is_valid_yaml_scalar(val)) {
 				const char *pkg_sum = NULL;
 				if (val->data.scalar.length == 64)
 					pkg_sum = val->data.scalar.value;
 				urldecode(key->data.scalar.value, &tmp);
 				pkg_addfile(pkg, sbuf_get(tmp), pkg_sum, true);
 			} else if (val->type == YAML_MAPPING_NODE)
 				pkg_set_files_from_node(pkg, val, doc,
 				    key->data.scalar.value);
 			else
 				pkg_emit_error("Skipping malformed files %s",
 				    key->data.scalar.value);
 			break;
 		case PKG_OPTIONS:
 			if (val->type != YAML_SCALAR_NODE)
 				pkg_emit_error("Skipping malformed option %s",
 				    key->data.scalar.value);
 			else
 				pkg_addoption(pkg, key->data.scalar.value,
 				    val->data.scalar.value);
 			break;
 		case PKG_SCRIPTS:
 			if (val->type != YAML_SCALAR_NODE)
 				pkg_emit_error("Skipping malformed scripts %s",
 				    key->data.scalar.value);
 			script_type = script_type_str(key->data.scalar.value);
 			if (script_type == INT_MAX) {
 				pkg_emit_error("Skipping unknown script "
 				    "type: %s", key->data.scalar.value);
 				break;
 			}
 			urldecode(val->data.scalar.value, &tmp);
 			pkg_addscript(pkg, sbuf_get(tmp), script_type);
 			break;
 		}
 		++pair;

@@ -400,7 +432,9 @@ parse_mapping(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc, int attr

 }
 static int
 pkg_set_files_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc, const char *filename) {
 pkg_set_files_from_node(struct pkg *pkg, yaml_node_t *item,
     yaml_document_t *doc, const char *filename)
 {
 	yaml_node_pair_t *pair = NULL;
 	yaml_node_t *key = NULL;
 	yaml_node_t *val = NULL;

@@ -415,13 +449,16 @@ pkg_set_files_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc

 		key = yaml_document_get_node(doc, pair->key);
 		val = yaml_document_get_node(doc, pair->value);
 		if (key->data.scalar.length <= 0) {
 			pkg_emit_error("Skipping malformed file entry for %s", filename);
 			pkg_emit_error("Skipping malformed file entry for %s",
 			    filename);
 			++pair;
 			continue;
 		}
 		if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0) {
 			pkg_emit_error("Skipping malformed file entry for %s", filename);
 		if (val->type != YAML_SCALAR_NODE ||
 		    val->data.scalar.length <= 0) {
 			pkg_emit_error("Skipping malformed file entry for %s",
 			    filename);
 			++pair;
 			continue;
 		}

@@ -430,29 +467,34 @@ pkg_set_files_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc

 			uname = val->data.scalar.value;
 		else if (!strcasecmp(key->data.scalar.value, "gname"))
 			gname = val->data.scalar.value;
 		else if (!strcasecmp(key->data.scalar.value, "sum") && val->data.scalar.length == 64)
 		else if (!strcasecmp(key->data.scalar.value, "sum") &&
 		    val->data.scalar.length == 64)
 			sum = val->data.scalar.value;
 		else if (!strcasecmp(key->data.scalar.value, "perm")) {
 			if ((set = setmode(val->data.scalar.value)) == NULL)
 				pkg_emit_error("Not a valide mode: %s", val->data.scalar.value);
 				pkg_emit_error("Not a valid mode: %s",
 				    val->data.scalar.value);
 			else
 				perm = getmode(set, 0);
 		} else {
 			pkg_emit_error("Skipping unknown key for file(%s): %s", filename,
 						   key->data.scalar.value);
 			pkg_emit_error("Skipping unknown key for file(%s): %s",
 			    filename, key->data.scalar.value);
 		}
 		++pair;
 	}
 	if (key != NULL)
 	    pkg_addfile_attr(pkg, key->data.scalar.value, sum, uname, gname, perm, true);
 		pkg_addfile_attr(pkg, key->data.scalar.value, sum, uname, gname,
 		    perm, true);
 	return (EPKG_OK);
 }
 static int
 pkg_set_dirs_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc, const char *dirname) {
 pkg_set_dirs_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc,
     const char *dirname)
 {
 	yaml_node_pair_t *pair;
 	yaml_node_t *key;
 	yaml_node_t *val;

@@ -467,13 +509,16 @@ pkg_set_dirs_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc,

 		key = yaml_document_get_node(doc, pair->key);
 		val = yaml_document_get_node(doc, pair->value);
 		if (key->data.scalar.length <= 0) {
 			pkg_emit_error("Skipping malformed file entry for %s", dirname);
 			pkg_emit_error("Skipping malformed file entry for %s",
 			    dirname);
 			++pair;
 			continue;
 		}
 		if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0) {
 			pkg_emit_error("Skipping malformed file entry for %s", dirname);
 		if (val->type != YAML_SCALAR_NODE ||
 		    val->data.scalar.length <= 0) {
 			pkg_emit_error("Skipping malformed file entry for %s",
 			    dirname);
 			++pair;
 			continue;
 		}

@@ -484,7 +529,8 @@ pkg_set_dirs_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc,

 			gname = val->data.scalar.value;
 		else if (!strcasecmp(key->data.scalar.value, "perm")) {
 			if ((set = setmode(val->data.scalar.value)) == NULL)
 				pkg_emit_error("Not a valide mode: %s", val->data.scalar.value);
 				pkg_emit_error("Not a valid mode: %s",
 				    val->data.scalar.value);
 			else
 				perm = getmode(set, 0);
 		} else if (!strcasecmp(key->data.scalar.value, "try")) {

@@ -493,10 +539,12 @@ pkg_set_dirs_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc,

 			else if (val->data.scalar.value[0] == 'y')
 				try = true;
 			else
 				pkg_emit_error("Wrong value for try: %s, expected 'y' or 'n'", val->data.scalar.value);
 				pkg_emit_error("Wrong value for try: %s, "
 				    "expected 'y' or 'n'",
 				    val->data.scalar.value);
 		} else {
 			pkg_emit_error("Skipping unknown key for dir(%s): %s", dirname,
 						   key->data.scalar.value);
 			pkg_emit_error("Skipping unknown key for dir(%s): %s",
 			    dirname, key->data.scalar.value);
 		}
 		++pair;

@@ -508,7 +556,9 @@ pkg_set_dirs_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc,

 }
 static int
 pkg_set_deps_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc, const char *depname) {
 pkg_set_deps_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc,
     const char *depname)
 {
 	yaml_node_pair_t *pair;
 	yaml_node_t *key;
 	yaml_node_t *val;

@@ -519,16 +569,12 @@ pkg_set_deps_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc,

 	while (pair < item->data.mapping.pairs.top) {
 		key = yaml_document_get_node(doc, pair->key);
 		val = yaml_document_get_node(doc, pair->value);
 		if (key->data.scalar.length <= 0) {
 			pkg_emit_error("Skipping malformed dependency entry for %s",
 						   depname);
 			++pair;
 			continue;
 		}
 		if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0) {
 			pkg_emit_error("Skipping malformed dependency entry for %s",
 						   depname);
 		if (key->data.scalar.length <= 0 ||
 		    val->type != YAML_SCALAR_NODE ||
 		    val->data.scalar.length <= 0) {
 			pkg_emit_error("Skipping malformed dependency entry "
 			    "for %s", depname);
 			++pair;
 			continue;
 		}

@@ -571,23 +617,23 @@ parse_root_node(struct pkg *pkg, yaml_node_t *node, yaml_document_t *doc) {

 			continue;
 		}
 		if (val->type == YAML_NO_NODE || (val->type == YAML_SCALAR_NODE && val->data.scalar.length <= 0)) {
 		if (val->type == YAML_NO_NODE ||
 		    (val->type == YAML_SCALAR_NODE &&
 		     val->data.scalar.length <= 0)) {
 			/* silently skip on purpose */
 			++pair;
 			continue;
 		}
 		for (i = 0; manifest_key[i].key != NULL; i++) {
 			if (!strcasecmp(key->data.scalar.value, manifest_key[i].key)) {
 				if (val->type == manifest_key[i].valid_type) {
 					retcode = manifest_key[i].parse_data(pkg, val, doc, manifest_key[i].type);
 					break;
 				}
 			const char *m_key = manifest_key[i].key;
 			if (strcasecmp(key->data.scalar.value, m_key))
 				continue;
 			if (val->type == manifest_key[i].valid_type) {
 				retcode = manifest_key[i].parse_data(pkg, val,
 				    doc, manifest_key[i].type);
 				break;
 			}
 			if (manifest_key[i].key == NULL)
 				pkg_emit_error("Skipping unknown manifest key: %s",
 							   key->data.scalar.value);
 		}
 		++pair;
 	}

@@ -637,17 +683,29 @@ yaml_write_buf(void *data, unsigned char *buffer, size_t size)

 }
 static void
 manifest_append_seqval(yaml_document_t *doc, int parent, int *seq, const char *title, const char *value)
 manifest_append_seqval(yaml_document_t *doc, int parent, int *seq,
     const char *title, const char *value)
 {
 	int scalar;
 	if (*seq == -1) {
 		*seq = yaml_document_add_sequence(doc, NULL, YAML_FLOW_SEQUENCE_STYLE);
 		yaml_document_append_mapping_pair(doc, parent,
 				yaml_document_add_scalar(doc, NULL, __DECONST(yaml_char_t*, title), strlen(title), YAML_PLAIN_SCALAR_STYLE), *seq);
 		*seq = yaml_document_add_sequence(doc, NULL,
 		    YAML_FLOW_SEQUENCE_STYLE);
 		scalar = yaml_document_add_scalar(doc, NULL,
 		    __DECONST(yaml_char_t *, title), strlen(title),
 		    YAML_PLAIN_SCALAR_STYLE);
 		yaml_document_append_mapping_pair(doc, parent, scalar, *seq);
 	}
 	yaml_document_append_sequence_item(doc, *seq,
 			yaml_document_add_scalar(doc, NULL, __DECONST(yaml_char_t*, value), strlen(value), YAML_PLAIN_SCALAR_STYLE));
 	scalar = yaml_document_add_scalar(doc, NULL,
 	    __DECONST(yaml_char_t *, value), strlen(value),
 	    YAML_PLAIN_SCALAR_STYLE);
 	yaml_document_append_sequence_item(doc, *seq, scalar);
 }
 #define	YAML_ADD_SCALAR(doc, name, style)				       \
 	yaml_document_add_scalar(doc, NULL, __DECONST(yaml_char_t *, name),    \
 	    strlen(name), YAML_##style##_SCALAR_STYLE)
 int
 pkg_emit_manifest(struct pkg *pkg, char **dest)
 {

@@ -672,10 +730,10 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 	int i;
 /*	int users = -1;
 	int groups = -1;*/
 	const char *script_types = NULL;
 	struct sbuf *destbuf = sbuf_new_auto();
 	const char *name, *version, *pkgorigin, *comment, *pkgarch, *www, *pkgmaintainer, *prefix;
 	const char *desc, *message, *infos;
 	const char *comment, *desc, *infos, *message, *name, *pkgarch;
 	const char *pkgmaintainer, *pkgorigin, *prefix, *version, *www;
 	const char *script_types = NULL;
 	lic_t licenselogic;
 	int64_t flatsize;

@@ -683,25 +741,28 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 	yaml_emitter_set_unicode(&emitter, 1);
 	yaml_emitter_set_output(&emitter, yaml_write_buf, destbuf);
 #define manifest_append_kv(map, key, val, style) yaml_document_append_mapping_pair(&doc, map, \
 		yaml_document_add_scalar(&doc, NULL, __DECONST(yaml_char_t*, key), strlen(key), YAML_PLAIN_SCALAR_STYLE), \
 		yaml_document_add_scalar(&doc, NULL, __DECONST(yaml_char_t*, val), strlen(val), YAML_##style##_SCALAR_STYLE));
 #define manifest_append_kv(map, key, val, style) do {			\
 	int key_obj = YAML_ADD_SCALAR(&doc, key, PLAIN);		\
 	int val_obj = YAML_ADD_SCALAR(&doc, key, style);		\
 	yaml_document_append_mapping_pair(&doc, map, key_obj, val_obj);	\
 } while (0)
 #define manifest_append_map(id, map, key, block) do { \
 #define manifest_append_map(id, map, key, block) do {			\
 	int scalar_obj = YAML_ADD_SCALAR(&doc, key, PLAIN);		\
 	id = yaml_document_add_mapping(&doc, NULL, YAML_##block##_MAPPING_STYLE); \
 	yaml_document_append_mapping_pair(&doc, map, \
 		yaml_document_add_scalar(&doc, NULL, __DECONST(yaml_char_t*, key), strlen(key), YAML_PLAIN_SCALAR_STYLE), id); \
 	} while (0)
 	yaml_document_append_mapping_pair(&doc, map, scalar_obj, id);	\
 } while (0)
 	yaml_document_initialize(&doc, NULL, NULL, NULL, 0, 1);
 	mapping = yaml_document_add_mapping(&doc, NULL, YAML_BLOCK_MAPPING_STYLE);
 	mapping = yaml_document_add_mapping(&doc, NULL,
 	    YAML_BLOCK_MAPPING_STYLE);
 	pkg_get(pkg, PKG_NAME, &name, PKG_ORIGIN, &pkgorigin, PKG_COMMENT, &comment,
 	    PKG_ARCH, &pkgarch, PKG_WWW, &www,
 	pkg_get(pkg, PKG_NAME, &name, PKG_ORIGIN, &pkgorigin,
 	    PKG_COMMENT, &comment, PKG_ARCH, &pkgarch, PKG_WWW, &www,
 	    PKG_MAINTAINER, &pkgmaintainer, PKG_PREFIX, &prefix,
 	    PKG_LICENSE_LOGIC, &licenselogic, PKG_DESC, &desc,
 	    PKG_FLATSIZE, &flatsize, PKG_MESSAGE, &message, PKG_VERSION, &version,
 	    PKG_INFOS, &infos);
 	    PKG_FLATSIZE, &flatsize, PKG_MESSAGE, &message,
 	    PKG_VERSION, &version, PKG_INFOS, &infos);
 	manifest_append_kv(mapping, "name", name, PLAIN);
 	manifest_append_kv(mapping, "version", version, PLAIN);
 	manifest_append_kv(mapping, "origin", pkgorigin, PLAIN);

@@ -711,20 +772,21 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 	manifest_append_kv(mapping, "maintainer", pkgmaintainer, PLAIN);
 	manifest_append_kv(mapping, "prefix", prefix, PLAIN);
 	switch (licenselogic) {
 		case LICENSE_SINGLE:
 			manifest_append_kv(mapping, "licenselogic", "single", PLAIN);
 			break;
 		case LICENSE_AND:
 			manifest_append_kv(mapping, "licenselogic", "and", PLAIN);
 			break;
 		case LICENSE_OR:
 			manifest_append_kv(mapping, "licenselogic", "or", PLAIN);
 			break;
 	case LICENSE_SINGLE:
 		manifest_append_kv(mapping, "licenselogic", "single", PLAIN);
 		break;
 	case LICENSE_AND:
 		manifest_append_kv(mapping, "licenselogic", "and", PLAIN);
 		break;
 	case LICENSE_OR:
 		manifest_append_kv(mapping, "licenselogic", "or", PLAIN);
 		break;
 	}
 	seq = -1;
 	while (pkg_licenses(pkg, &license) == EPKG_OK)
 		manifest_append_seqval(&doc, mapping, &seq, "licenses", pkg_license_name(license));
 		manifest_append_seqval(&doc, mapping, &seq, "licenses",
 		    pkg_license_name(license));
 	snprintf(tmpbuf, BUFSIZ, "%" PRId64, flatsize);
 	manifest_append_kv(mapping, "flatsize", tmpbuf, PLAIN);

@@ -738,66 +800,60 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 		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);
 		manifest_append_kv(depkv, "version", pkg_dep_version(dep),
 		    PLAIN);
 	}
 	seq = -1;
 	while (pkg_categories(pkg, &category) == EPKG_OK)
 		manifest_append_seqval(&doc, mapping, &seq, "categories", pkg_category_name(category));
 		manifest_append_seqval(&doc, mapping, &seq, "categories",
 		    pkg_category_name(category));
 	seq = -1;
 	while (pkg_users(pkg, &user) == EPKG_OK)
 		manifest_append_seqval(&doc, mapping, &seq, "users", pkg_user_name(user));
 		manifest_append_seqval(&doc, mapping, &seq, "users",
 		    pkg_user_name(user));
 	seq = -1;
 	while (pkg_groups(pkg, &group) == EPKG_OK)
 		manifest_append_seqval(&doc, mapping, &seq, "groups", pkg_group_name(group));
 /*	while (pkg_users(pkg, &user) == EPKG_OK) {
 		if (users == -1) {
 			users = yaml_document_add_mapping(&doc, NULL, YAML_BLOCK_MAPPING_STYLE);
 			yaml_document_append_mapping_pair(&doc, mapping,
 					yaml_document_add_scalar(&doc, NULL, __DECONST(yaml_char_t*, "users"), 5, YAML_PLAIN_SCALAR_STYLE),
 					users);
 		}
 		manifest_append_kv(users, pkg_user_name(user), user->uidstr);
 	}
 	while (pkg_groups(pkg, &group) == EPKG_OK) {
 		if (groups == -1) {
 			groups = yaml_document_add_mapping(&doc, NULL, YAML_BLOCK_MAPPING_STYLE);
 			yaml_document_append_mapping_pair(&doc, mapping,
 					yaml_document_add_scalar(&doc, NULL, __DECONST(yaml_char_t*, "groups"), 6, YAML_PLAIN_SCALAR_STYLE),
 					groups);
 		}
 		manifest_append_kv(groups, pkg_group_name(group), group->gidstr);
 	}*/
 		manifest_append_seqval(&doc, mapping, &seq, "groups",
 		    pkg_group_name(group));
 	seq = -1;
 	while (pkg_shlibs(pkg, &shlib) == EPKG_OK)
 		manifest_append_seqval(&doc, mapping, &seq, "shlibs", pkg_shlib_name(shlib));
 		manifest_append_seqval(&doc, mapping, &seq, "shlibs",
 		    pkg_shlib_name(shlib));
 	map = -1;
 	while (pkg_options(pkg, &option) == EPKG_OK) {
 		if (map == -1)
 			manifest_append_map(map, mapping, "options", FLOW);
 		manifest_append_kv(map, pkg_option_opt(option), pkg_option_value(option), PLAIN);
 		manifest_append_kv(map, pkg_option_opt(option),
 		    pkg_option_value(option), PLAIN);
 	}
 	map = -1;
 	while (pkg_files(pkg, &file) == EPKG_OK) {
 		const char *pkg_sum = pkg_file_cksum(file);
 		if (pkg_sum == NULL || pkg_sum[0] == '\0')
 			pkg_sum = "-";
 		if (map == -1)
 			manifest_append_map(map, mapping, "files", BLOCK);
 		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);
 		manifest_append_kv(map, sbuf_get(tmpsbuf), pkg_sum, PLAIN);
 	}
 	seq = -1;
 	map = -1;
 	while (pkg_dirs(pkg, &dir) == EPKG_OK) {
 		const char *try_str;
 		if (map == -1)
 			manifest_append_map(map, mapping, "directories", BLOCK);
 		urlencode(pkg_dir_path(dir), &tmpsbuf);
 		manifest_append_kv(map, sbuf_get(tmpsbuf), pkg_dir_try(dir) ? "y" : "n", PLAIN);
 		try_str = pkg_dir_try(dir) ? "y" : "n";
 		manifest_append_kv(map, sbuf_get(tmpsbuf), try_str, PLAIN);
 	}
 	map = -1;

@@ -838,16 +894,19 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 				break;
 		}
 		urlencode(pkg_script_get(pkg, i), &tmpsbuf);
 		manifest_append_kv(map, script_types, sbuf_get(tmpsbuf), LITERAL);
 		manifest_append_kv(map, script_types, sbuf_get(tmpsbuf),
 		    LITERAL);
 	}
 	if (infos != NULL && *infos != '\0') {
 		urlencode(infos, &tmpsbuf);
 		manifest_append_kv(mapping, "message", sbuf_get(tmpsbuf), LITERAL);
 		manifest_append_kv(mapping, "message", sbuf_get(tmpsbuf),
 		    LITERAL);
 	}
 	if (message != NULL && *message != '\0') {
 		urlencode(message, &tmpsbuf);
 		manifest_append_kv(mapping, "message", sbuf_get(tmpsbuf), LITERAL);
 		manifest_append_kv(mapping, "message", sbuf_get(tmpsbuf),
 		    LITERAL);
 	}
 	if (!yaml_emitter_dump(&emitter, &doc))

modified libpkg/pkg_ports.c

@@ -111,9 +111,12 @@ sbuf_append(struct sbuf *buf, __unused const char *comment, const char *str, ...

 	va_end(ap);
 }
 #define post_unexec_append(buf, str, ...) sbuf_append(buf, "unexec", str, __VA_ARGS__)
 #define pre_unexec_append(buf, str, ...) sbuf_append(buf, "unexec", str, __VA_ARGS__)
 #define exec_append(buf, str, ...) sbuf_append(buf, "exec", str, __VA_ARGS__)
 #define post_unexec_append(buf, str, ...) \
 	sbuf_append(buf, "unexec", str, __VA_ARGS__)
 #define pre_unexec_append(buf, str, ...) \
 	sbuf_append(buf, "unexec", str, __VA_ARGS__)
 #define exec_append(buf, str, ...) \
 	sbuf_append(buf, "exec", str, __VA_ARGS__)
 static int
 setprefix(struct plist *p, char *line)

@@ -146,7 +149,8 @@ meta_dirrm(struct plist *p, char *line, bool try)

 	if (line[0] == '/')
 		snprintf(path, sizeof(path), "%s/", line);
 	else
 		snprintf(path, sizeof(path), "%s%s%s/", p->prefix, p->slash, line);
 		snprintf(path, sizeof(path), "%s%s%s/", p->prefix, p->slash,
 		    line);
 	testpath = path;

@@ -156,7 +160,8 @@ meta_dirrm(struct plist *p, char *line, bool try)

 	}
 	if (lstat(testpath, &st) == 0)
 		return (pkg_adddir_attr(p->pkg, path, p->uname, p->gname, p->perm, try));
 		return (pkg_adddir_attr(p->pkg, path, p->uname, p->gname,
 		    p->perm, try));
 	pkg_emit_errno("lstat", path);
 	if (p->stage != NULL)

@@ -200,7 +205,8 @@ file(struct plist *p, char *line)

 	if (line[0] == '/')
 		snprintf(path, sizeof(path), "%s", line);
 	else
 		snprintf(path, sizeof(path), "%s%s%s", p->prefix, p->slash, line);
 		snprintf(path, sizeof(path), "%s%s%s", p->prefix,
 		    p->slash, line);
 	testpath = path;
 	if (p->stage != NULL) {

@@ -224,7 +230,8 @@ file(struct plist *p, char *line)

 			sha256_file(testpath, sha256);
 			buf = sha256;
 		}
 		return (pkg_addfile_attr(p->pkg, path, buf, p->uname, p->gname, p->perm, true));
 		return (pkg_addfile_attr(p->pkg, path, buf, p->uname, p->gname,
 		    p->perm, true));
 	}
 	pkg_emit_errno("lstat", path);

@@ -296,8 +303,10 @@ meta_exec(struct plist *p, char *line, bool unexec)

 	char comment[2];
 	char path[MAXPATHLEN + 1];
 	regmatch_t pmatch[2];
 	int ret;
 	if (format_exec_cmd(&cmd, line, p->prefix, p->last_file, NULL) != EPKG_OK)
 	ret = format_exec_cmd(&cmd, line, p->prefix, p->last_file, NULL);
 	if (ret != EPKG_OK)
 		return (EPKG_OK);
 	if (unexec) {

@@ -333,10 +342,13 @@ meta_exec(struct plist *p, char *line, bool unexec)

 		if (strstr(cmd, "rmdir") || strstr(cmd, "kldxref") ||
 		    strstr(cmd, "mkfontscale") || strstr(cmd, "mkfontdir") ||
 		    strstr(cmd, "fc-cache") || strstr(cmd, "fonts.dir") ||
 		    strstr(cmd, "fonts.scale") || strstr(cmd, "gtk-update-icon-cache") ||
 		    strstr(cmd, "update-desktop-database") || strstr(cmd, "update-mime-database")) {
 		    strstr(cmd, "fonts.scale") ||
 		    strstr(cmd, "gtk-update-icon-cache") ||
 		    strstr(cmd, "update-desktop-database") ||
 		    strstr(cmd, "update-mime-database")) {
 			if (comment[0] != '#')
 				post_unexec_append(p->post_deinstall_buf, "%s%s\n", comment, cmd);
 				post_unexec_append(p->post_deinstall_buf,
 				    "%s%s\n", comment, cmd);
 		} else {
 			sbuf_printf(p->unexec_buf, "%s%s\n",comment, cmd);
 		}

@@ -352,18 +364,22 @@ meta_exec(struct plist *p, char *line, bool unexec)

 			split_chr(buf, '|');
 			if (strstr(buf, "\"/")) {
 				regcomp(&preg, "[[:space:]]\"(/[^\"]+)", REG_EXTENDED);
 				regcomp(&preg, "[[:space:]]\"(/[^\"]+)",
 				    REG_EXTENDED);
 				while (regexec(&preg, buf, 2, pmatch, 0) == 0) {
 					strlcpy(path, &buf[pmatch[1].rm_so], pmatch[1].rm_eo - pmatch[1].rm_so + 1);
 					strlcpy(path, &buf[pmatch[1].rm_so],
 					    pmatch[1].rm_eo - pmatch[1].rm_so + 1);
 					buf+=pmatch[1].rm_eo;
 					if (!strcmp(path, "/dev/null"))
 						continue;
 					dirrmtry(p, path);
 				}
 			} else {
 				regcomp(&preg, "[[:space:]](/[[:graph:]/]+)", REG_EXTENDED);
 				regcomp(&preg, "[[:space:]](/[[:graph:]/]+)",
 				    REG_EXTENDED);
 				while (regexec(&preg, buf, 2, pmatch, 0) == 0) {
 					strlcpy(path, &buf[pmatch[1].rm_so], pmatch[1].rm_eo - pmatch[1].rm_so + 1);
 					strlcpy(path, &buf[pmatch[1].rm_so],
 					    pmatch[1].rm_eo - pmatch[1].rm_so + 1);
 					buf+=pmatch[1].rm_eo;
 					if (!strcmp(path, "/dev/null"))
 						continue;

@@ -506,7 +522,8 @@ plist_free(struct plist *plist)

 }
 static int
 parse_actions(yaml_document_t *doc, yaml_node_t *node, struct plist *p, char *line)
 parse_actions(yaml_document_t *doc, yaml_node_t *node, struct plist *p,
     char *line)
 {
 	yaml_node_item_t *item;
 	yaml_node_t *val;

@@ -527,7 +544,8 @@ parse_actions(yaml_document_t *doc, yaml_node_t *node, struct plist *p, char *li

 		}
 		for (i = 0; list_actions[i].name != NULL; i++) {
 			if (!strcasecmp(val->data.scalar.value, list_actions[i].name)) {
 			if (!strcasecmp(val->data.scalar.value,
 			    list_actions[i].name)) {
 				list_actions[i].perform(p, line);
 				break;
 			}

@@ -539,7 +557,8 @@ parse_actions(yaml_document_t *doc, yaml_node_t *node, struct plist *p, char *li

 }
 static int
 parse_and_apply_keyword_file(yaml_document_t *doc, yaml_node_t *node, struct plist *p, char *line)
 parse_and_apply_keyword_file(yaml_document_t *doc, yaml_node_t *node,
     struct plist *p, char *line)
 {
 	yaml_node_pair_t *pair;
 	yaml_node_t *key, *val;

@@ -562,7 +581,8 @@ parse_and_apply_keyword_file(yaml_document_t *doc, yaml_node_t *node, struct pli

 		if (!strcasecmp(key->data.scalar.value, "pre-install")) {
 			if (val->data.scalar.length != 0) {
 				format_exec_cmd(&cmd, val->data.scalar.value, p->prefix, p->last_file, line);
 				format_exec_cmd(&cmd, val->data.scalar.value,
 				    p->prefix, p->last_file, line);
 				sbuf_cat(p->pre_install_buf, cmd);
 				free(cmd);
 			}

@@ -572,7 +592,8 @@ parse_and_apply_keyword_file(yaml_document_t *doc, yaml_node_t *node, struct pli

 		if (!strcasecmp(key->data.scalar.value, "post-install")) {
 			if (val->data.scalar.length != 0) {
 				format_exec_cmd(&cmd, val->data.scalar.value, p->prefix, p->last_file, line);
 				format_exec_cmd(&cmd, val->data.scalar.value,
 				    p->prefix, p->last_file, line);
 				sbuf_cat(p->post_install_buf, cmd);
 				free(cmd);
 			}

@@ -582,7 +603,8 @@ parse_and_apply_keyword_file(yaml_document_t *doc, yaml_node_t *node, struct pli

 		if (!strcasecmp(key->data.scalar.value, "pre-deinstall")) {
 			if (val->data.scalar.length != 0) {
 				format_exec_cmd(&cmd, val->data.scalar.value, p->prefix, p->last_file, line);
 				format_exec_cmd(&cmd, val->data.scalar.value,
 				    p->prefix, p->last_file, line);
 				sbuf_cat(p->pre_deinstall_buf, cmd);
 				free(cmd);
 			}

@@ -592,7 +614,8 @@ parse_and_apply_keyword_file(yaml_document_t *doc, yaml_node_t *node, struct pli

 		if (!strcasecmp(key->data.scalar.value, "post-deinstall")) {
 			if (val->data.scalar.length != 0) {
 				format_exec_cmd(&cmd, val->data.scalar.value, p->prefix, p->last_file, line);
 				format_exec_cmd(&cmd, val->data.scalar.value,
 				    p->prefix, p->last_file, line);
 				sbuf_cat(p->post_deinstall_buf, cmd);
 				free(cmd);
 			}

@@ -602,7 +625,8 @@ parse_and_apply_keyword_file(yaml_document_t *doc, yaml_node_t *node, struct pli

 		if (!strcasecmp(key->data.scalar.value, "pre-upgrade")) {
 			if (val->data.scalar.length != 0) {
 				format_exec_cmd(&cmd, val->data.scalar.value, p->prefix, p->last_file, line);
 				format_exec_cmd(&cmd, val->data.scalar.value,
 				    p->prefix, p->last_file, line);
 				sbuf_cat(p->pre_upgrade_buf, cmd);
 				free(cmd);
 			}

@@ -612,7 +636,8 @@ parse_and_apply_keyword_file(yaml_document_t *doc, yaml_node_t *node, struct pli

 		if (!strcasecmp(key->data.scalar.value, "post-upgrade")) {
 			if (val->data.scalar.length != 0) {
 				format_exec_cmd(&cmd, val->data.scalar.value, p->prefix, p->last_file, line);
 				format_exec_cmd(&cmd, val->data.scalar.value,
 				    p->prefix, p->last_file, line);
 				sbuf_cat(p->post_upgrade_buf, cmd);
 				free(cmd);
 			}

@@ -639,14 +664,17 @@ external_keyword(struct plist *plist, char *keyword, char *line)

 	pkg_config_string(PKG_CONFIG_PLIST_KEYWORDS_DIR, &keyword_dir);
 	if (keyword_dir == NULL) {
 		pkg_config_string(PKG_CONFIG_PORTSDIR, &keyword_dir);
 		snprintf(keyfile_path, sizeof(keyfile_path), "%s/Keywords/%s.yaml", keyword_dir, keyword);
 		snprintf(keyfile_path, sizeof(keyfile_path),
 		    "%s/Keywords/%s.yaml", keyword_dir, keyword);
 	} else {
 		snprintf(keyfile_path, sizeof(keyfile_path), "%s/%s.yaml", keyword_dir, keyword);
 		snprintf(keyfile_path, sizeof(keyfile_path),
 		    "%s/%s.yaml", keyword_dir, keyword);
 	}
 	if ((fp = fopen(keyfile_path, "r")) == NULL) {
 		if (errno != ENOENT)
 			pkg_emit_errno("Unable to open keyword definition", keyfile_path);
 			pkg_emit_errno("Unable to open keyword definition",
 			    keyfile_path);
 		return (EPKG_UNKNOWN);
 	}

@@ -658,9 +686,11 @@ external_keyword(struct plist *plist, char *keyword, char *line)

 	node = yaml_document_get_root_node(&doc);
 	if (node != NULL) {
 		if (node->type != YAML_MAPPING_NODE) {
 			pkg_emit_error("Invalid keyword file format: %s", keyfile_path);
 			pkg_emit_error("Invalid keyword file format: %s",
 			    keyfile_path);
 		} else {
 			ret = parse_and_apply_keyword_file(&doc, node, plist, line);
 			ret = parse_and_apply_keyword_file(&doc, node, plist,
 			    line);
 		}
 	} else {
 		pkg_emit_error("Invalid keyword file format: %s", keyfile_path);

@@ -784,7 +814,8 @@ ports_parse_plist(struct pkg *pkg, char *plist, const char *stage)

 				buf++;
 			switch (parse_keywords(&pplist, keyword, buf)) {
 			case EPKG_UNKNOWN:
 				pkg_emit_error("unknown keyword %s, ignoring %s", keyword, plist_p);
 				pkg_emit_error("unknown keyword %s, ignoring %s",
 				    keyword, plist_p);
 				break;
 			case EPKG_FATAL:
 				ret = EPKG_FATAL;

@@ -816,13 +847,20 @@ ports_parse_plist(struct pkg *pkg, char *plist, const char *stage)

 	pkg_set(pkg, PKG_FLATSIZE, pplist.flatsize);
 	flush_script_buffer(pplist.pre_install_buf, pkg, PKG_SCRIPT_PRE_INSTALL);
 	flush_script_buffer(pplist.post_install_buf, pkg, PKG_SCRIPT_POST_INSTALL);
 	flush_script_buffer(pplist.pre_deinstall_buf, pkg, PKG_SCRIPT_PRE_DEINSTALL);
 	flush_script_buffer(pplist.unexec_buf, pkg, PKG_SCRIPT_POST_DEINSTALL);
 	flush_script_buffer(pplist.post_deinstall_buf, pkg, PKG_SCRIPT_POST_DEINSTALL);
 	flush_script_buffer(pplist.pre_upgrade_buf, pkg, PKG_SCRIPT_PRE_UPGRADE);
 	flush_script_buffer(pplist.post_upgrade_buf, pkg, PKG_SCRIPT_POST_UPGRADE);
 	flush_script_buffer(pplist.pre_install_buf, pkg,
 	    PKG_SCRIPT_PRE_INSTALL);
 	flush_script_buffer(pplist.post_install_buf, pkg,
 	    PKG_SCRIPT_POST_INSTALL);
 	flush_script_buffer(pplist.pre_deinstall_buf, pkg,
 	    PKG_SCRIPT_PRE_DEINSTALL);
 	flush_script_buffer(pplist.unexec_buf, pkg,
 	    PKG_SCRIPT_POST_DEINSTALL);
 	flush_script_buffer(pplist.post_deinstall_buf, pkg,
 	    PKG_SCRIPT_POST_DEINSTALL);
 	flush_script_buffer(pplist.pre_upgrade_buf, pkg,
 	    PKG_SCRIPT_PRE_UPGRADE);
 	flush_script_buffer(pplist.post_upgrade_buf, pkg,
 	    PKG_SCRIPT_POST_UPGRADE);
 	free(hardlinks.inodes);

modified libpkg/pkg_repo.c

@@ -217,11 +217,12 @@ pkg_repo_fetch(struct pkg *pkg)

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

@@ -266,8 +267,7 @@ get_repo_user_version(sqlite3 *sqlite, const char *database, int *reposcver)

 	sqlite3_snprintf(sizeof(sql), sql, fmt, database);
 	if (sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL) != SQLITE_OK)
 	{
 	if (sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(sqlite);
 		return (EPKG_FATAL);
 	}

@@ -308,7 +308,8 @@ initialize_repo(const char *repodb, bool force, sqlite3 **sqlite)

 			"flatsize INTEGER NOT NULL,"
 			"licenselogic INTEGER NOT NULL,"
 			"cksum TEXT NOT NULL,"
 			"path TEXT NOT NULL," /* relative path to the package in the repository */
 			/* relative path to the package in the repository */
 			"path TEXT NOT NULL,"
 			"pkg_format_version INTEGER"
 		");"
 		"CREATE TABLE deps ("

@@ -379,19 +380,20 @@ initialize_repo(const char *repodb, bool force, sqlite3 **sqlite)

 		   update, then we cannot do an incremental update.
 		   Delete the existing repo, and promote this to a
 		   full update */
 		if (incremental) {
 			if (get_repo_user_version(*sqlite, "main", &reposcver) != EPKG_OK)
 				return (EPKG_FATAL);
 			if (force || reposcver != REPO_SCHEMA_VERSION) {
 				if (reposcver != REPO_SCHEMA_VERSION)
 					pkg_emit_error("updating repo schema version "
 					     "from %d to %d", reposcver,
 					     REPO_SCHEMA_VERSION);
 				sqlite3_close(*sqlite);
 				unlink(repodb);
 				incremental = false;
 				db_not_open = true;
 			}
 		if (!incremental)
 			continue;
 		retcode = get_repo_user_version(*sqlite, "main", &reposcver);
 		if (retcode != EPKG_OK)
 			return (EPKG_FATAL);
 		if (force || reposcver != REPO_SCHEMA_VERSION) {
 			if (reposcver != REPO_SCHEMA_VERSION)
 				pkg_emit_error("updating repo schema version "
 				     "from %d to %d", reposcver,
 				     REPO_SCHEMA_VERSION);
 			sqlite3_close(*sqlite);
 			unlink(repodb);
 			incremental = false;
 			db_not_open = true;
 		}
 	}

@@ -401,24 +403,36 @@ initialize_repo(const char *repodb, bool force, sqlite3 **sqlite)

 	if ((retcode = sql_exec(*sqlite, "PRAGMA synchronous=off")) != EPKG_OK)
 		return (retcode);
 	if ((retcode = sql_exec(*sqlite, "PRAGMA journal_mode=memory")) != EPKG_OK)
 	retcode = sql_exec(*sqlite, "PRAGMA journal_mode=memory");
 	if (retcode != EPKG_OK)
 		return (retcode);
 	if ((retcode = sql_exec(*sqlite, "PRAGMA foreign_keys=on")) != EPKG_OK)
 		return (retcode);
 	if (!incremental && (retcode = sql_exec(*sqlite, initsql, REPO_SCHEMA_VERSION)) != EPKG_OK)
 		return (retcode);
 	if (!incremental) {
 		retcode = sql_exec(*sqlite, initsql, REPO_SCHEMA_VERSION);
 		if (retcode != EPKG_OK)
 			return (retcode);
 	}
 	if ((retcode = sql_exec(*sqlite, "BEGIN TRANSACTION")) != EPKG_OK)
 		return (retcode);
 	/* remove anything that is no longer in the repository. */
 	if (incremental) {
 		sql_exec(*sqlite, "DELETE FROM packages WHERE NOT FILE_EXISTS(path)");
 		sql_exec(*sqlite, "DELETE FROM categories WHERE id NOT IN (SELECT category_id FROM pkg_categories);");
 		sql_exec(*sqlite, "DELETE FROM licenses WHERE id NOT IN (SELECT license_id FROM pkg_licenses);");
 		sql_exec(*sqlite, "DELETE FROM shlibs WHERE id NOT IN (SELECT shlib_id FROM pkg_shlibs);");
 		const char *obsolete[] = {
 			"packages WHERE NOT FILE_EXISTS(path)",
 			"categories WHERE id NOT IN "
 				"(SELECT category_id FROM pkg_categories)",
 			"licenses WHERE id NOT IN "
 				"(SELECT license_id FROM pkg_licenses)",
 			"shlibs WHERE id NOT IN "
 				"(SELECT shlib_id FROM pkg_shlibs)"
 		};
 		size_t num_objs = sizeof(obsolete) / sizeof(*obsolete);
 		for (size_t obj = 0; obj < num_objs; obj++)
 			sql_exec(*sqlite, "DELETE FROM %s;", obsolete[obj]);
 	}
 	return (EPKG_OK);

@@ -428,19 +442,17 @@ static int

 initialize_prepared_statements(sqlite3 *sqlite)
 {
 	sql_prstmt_index i;
 	int retcode = EPKG_OK;
 	int ret;
 	for (i = 0; i < PRSTMT_LAST; i++)
 	{
 		if (sqlite3_prepare_v2(sqlite, SQL(i), -1, &STMT(i), NULL)
 		    != SQLITE_OK)
 		{
 		ret = sqlite3_prepare_v2(sqlite, SQL(i), -1, &STMT(i), NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(sqlite);
 			retcode = EPKG_FATAL;
 			break;
 			return (EPKG_FATAL);
 		}
 	}
 	return (retcode);
 	return (EPKG_OK);
 }
 static int

@@ -464,7 +476,7 @@ run_prepared_statement(sql_prstmt_index s, ...)

 		switch (argtypes[i]) {
 		case 'T':
 			sqlite3_bind_text(stmt, i + 1, va_arg(ap, const char*),
 					  -1, SQLITE_STATIC);
 			    -1, SQLITE_STATIC);
 			break;
 		case 'I':
 			sqlite3_bind_int64(stmt, i + 1, va_arg(ap, int64_t));

@@ -528,7 +540,8 @@ maybe_delete_conflicting(const char *origin, const char *version,

 }
 int
 pkg_create_repo(char *path, bool force, void (progress)(struct pkg *pkg, void *data), void *data)
 pkg_create_repo(char *path, bool force,
     void (progress)(struct pkg *pkg, void *data), void *data)
 {
 	FTS *fts = NULL;
 	FTSENT *ent = NULL;

@@ -579,14 +592,17 @@ pkg_create_repo(char *path, bool force, void (progress)(struct pkg *pkg, void *d

 		a = archive_read_new();
 		archive_read_support_compression_all(a);
 		archive_read_support_format_tar(a);
 		if (archive_read_open_filename(a, repopack, 4096) != ARCHIVE_OK) {
 		ret = archive_read_open_filename(a, repopack, 4096);
 		if (ret != ARCHIVE_OK) {
 			/* if we can't unpack it it won't be useful for us */
 			unlink(repopack);
 		} else {
 			while (archive_read_next_header(a, &ae) == ARCHIVE_OK) {
 				if (!strcmp(archive_entry_pathname(ae), "repo.sqlite")) {
 				if (!strcmp(archive_entry_pathname(ae),
 				    "repo.sqlite")) {
 					archive_entry_set_pathname(ae, repodb);
 					archive_read_extract(a, ae, EXTRACT_ARCHIVE_FLAGS);
 					archive_read_extract(a, ae,
 					    EXTRACT_ARCHIVE_FLAGS);
 					break;
 				}
 			}

@@ -653,10 +669,12 @@ pkg_create_repo(char *path, bool force, void (progress)(struct pkg *pkg, void *d

 		if (progress != NULL)
 			progress(pkg, data);
 		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);
 		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);
 	try_again:
 		if ((ret = run_prepared_statement(PKG, origin, name, version,

@@ -717,12 +735,12 @@ pkg_create_repo(char *path, bool force, void (progress)(struct pkg *pkg, void *d

 		license = NULL;
 		while (pkg_licenses(pkg, &license) == EPKG_OK) {
 			if (run_prepared_statement(LIC1,
 			    pkg_license_name(license)) != SQLITE_DONE
 			    &&
 			    run_prepared_statement(LIC2, package_id,
 			    pkg_license_name(license)) != SQLITE_DONE)
 			{
 			const char *lic_name = pkg_license_name(license);
 			ret = run_prepared_statement(LIC1, lic_name);
 			if (ret == SQLITE_DONE)
 				ret = run_prepared_statement(LIC2, package_id,
 				    lic_name);
 			if (ret != SQLITE_DONE) {
 				ERROR_SQLITE(sqlite);
 				retcode = EPKG_FATAL;
 				goto cleanup;

@@ -808,7 +826,8 @@ pkg_finish_repo(char *path, pem_password_cb *password_cb, char *rsa_key_path)

 		free(sigret);
 	}
 	packing_append_file_attr(pack, repo_path, "repo.sqlite", "root", "wheel", 0644);
 	packing_append_file_attr(pack, repo_path, "repo.sqlite",
 	    "root", "wheel", 0644);
 	unlink(repo_path);
 	packing_finish(pack);

@@ -853,18 +872,18 @@ pkg_check_repo_version(struct pkgdb *db, const char *database)

 		reposcver = 2001;
 	if (reposcver > REPO_SCHEMA_VERSION) {
 		pkg_emit_error("Repo %s (schema version %d) is too new - we can "
 			       "accept at most version %d", database, reposcver,
 			       REPO_SCHEMA_VERSION);
 		pkg_emit_error("Repo %s (schema version %d) is too new - we can"
 		    " accept at most version %d", database, reposcver,
 		    REPO_SCHEMA_VERSION);
 		return (EPKG_REPOSCHEMA);
 	}
 	repomajor = reposcver / 1000;
 	if (repomajor < REPO_SCHEMA_MAJOR) {
 		pkg_emit_error("Repo %s (schema version %d) is too old - need at "
 			       "least schema %d", database, reposcver,
 			       REPO_SCHEMA_MAJOR * 1000);
 		pkg_emit_error("Repo %s (schema version %d) is too old - "
 		    "need at least schema %d", database, reposcver,
 		    REPO_SCHEMA_MAJOR * 1000);
 		return (EPKG_REPOSCHEMA);
 	}

modified libpkg/pkg_version.c

@@ -43,7 +43,8 @@

  * Based on work of Jeremy D. Lea.
  */
 static const char *
 split_version(const char *pkgname, const char **endname, unsigned long *epoch, unsigned long *revision)
 split_version(const char *pkgname, const char **endname,
     unsigned long *epoch, unsigned long *revision)
 {
 	char *ch;
 	const char *versionstr;

@@ -59,7 +60,10 @@ split_version(const char *pkgname, const char **endname, unsigned long *epoch, u

 	/* Cheat if we are just passed a version, not a valid package name */
 	versionstr = ch ? ch + 1 : pkgname;
 	/* Look for the last '_' in the version string, advancing the end pointer */
 	/*
 	 * Look for the last '_' in the version string, advancing the
 	 * end pointer.
 	 */
 	ch = strrchr(versionstr, '_');
 	if (revision != NULL)

@@ -76,9 +80,13 @@ split_version(const char *pkgname, const char **endname, unsigned long *epoch, u

 	if (ch && !endversionstr)
 		endversionstr = ch;
 	/* set the pointer behind the last character of the version without revision or epoch */
 	/*
 	 * set the pointer behind the last character of the version without
 	 * revision or epoch
 	 */
 	if (endname)
 		*endname = endversionstr ? endversionstr : strrchr(versionstr, '\0');
 		*endname = endversionstr ? endversionstr :
 					   strrchr(versionstr, '\0');
 	return versionstr;
 }

@@ -186,8 +194,9 @@ get_component(const char *position, version_component *component)

 		if (isalpha(pos[1])) {
 			unsigned int i;
 			for (i = 0; stage[i].name; i++) {
 				if (strncasecmp(pos, stage[i].name, stage[i].namelen) == 0
 						&& !isalpha(pos[stage[i].namelen])) {
 				size_t len = stage[i].namelen;
 				if (strncasecmp(pos, stage[i].name, len) == 0 &&
 				    !isalpha(pos[stage[i].namelen])) {
 					if (hasstage) {
 						/* stage to value */
 						component->a = stage[i].value;

@@ -234,9 +243,9 @@ get_component(const char *position, version_component *component)

 	}
 	/* skip trailing separators */
 	while (*pos && !isdigit(*pos) && !isalpha(*pos) && *pos != '+' && *pos != '*') {
 	while (*pos && !isdigit(*pos) && !isalpha(*pos)
 	    && *pos != '+' && *pos != '*')
 		pos++;
 	}
 	return pos;
 }

@@ -281,10 +290,13 @@ pkg_version_cmp(const char * const pkg1, const char * const pkg2)

 	}
 	/* Shortcut check for equality before invoking the parsing routines. */
 	if (result == 0 && (ve1 - v1 != ve2 - v2 || strncasecmp(v1, v2, ve1 - v1) != 0)) {
 		/* Loop over different components (the parts separated by dots).
 		 * If any component differs, we have the basis for an inequality. */
 		while(result == 0 && (v1 < ve1 || v2 < ve2)) {
 	if (result == 0 &&
 	    (ve1 - v1 != ve2 - v2 || strncasecmp(v1, v2, ve1 - v1) != 0)) {
 		/*
 		 * Loop over different components (the parts separated by dots).
 		 * If any component differs, there is an inequality.
 		 */
 		while (result == 0 && (v1 < ve1 || v2 < ve2)) {
 			int block_v1 = 0;
 			int block_v2 = 0;
 			version_component vc1 = {0, 0, 0};

modified libpkg/pkgdb.c

@@ -73,7 +73,8 @@ static int create_temporary_pkgjobs(sqlite3 *);

 static void pkgdb_detach_remotes(sqlite3 *);
 static bool is_attached(sqlite3 *, const char *);
 static void report_already_installed(sqlite3 *);
 static int sqlcmd_init(sqlite3 *db, __unused const char **err, __unused const void *noused);
 static int sqlcmd_init(sqlite3 *db, __unused const char **err,
     __unused const void *noused);
 static int prstmt_initialize(struct pkgdb *db);
 /* static int run_prstmt(sql_prstmt_index s, ...); */
 static void prstmt_finalize(struct pkgdb *db);

@@ -112,7 +113,8 @@ static struct column_mapping {

 };
 static int
 load_val(sqlite3 *db, struct pkg *pkg, const char *sql, int flags, int (*pkg_adddata)(struct pkg *pkg, const char *data), int list)
 load_val(sqlite3 *db, struct pkg *pkg, const char *sql, int flags,
     int (*pkg_adddata)(struct pkg *pkg, const char *data), int list)
 {
 	sqlite3_stmt *stmt;
 	int ret;

@@ -160,7 +162,8 @@ pkgdb_get_reponame(struct pkgdb *db, const char *repo)

 	if (multirepos_enabled) {
 		if (repo != NULL) {
 			if (!is_attached(db->sqlite, repo)) {
 				pkg_emit_error("repository '%s' does not exist.", repo);
 				pkg_emit_error("repository '%s' does not exist",
 				    repo);
 				return (NULL);
 			}

@@ -170,8 +173,10 @@ pkgdb_get_reponame(struct pkgdb *db, const char *repo)

 			reponame = "default";
 		}
 	} else {
 		if (repo != NULL && strcmp(repo, "repo") && strcmp(repo, "remote")) {
 			pkg_emit_error("PKG_MULTIREPOS is not enabled. -r flag not supported.", repo);
 		if (repo != NULL && strcmp(repo, "repo") &&
 		    strcmp(repo, "remote")) {
 			pkg_emit_error("PKG_MULTIREPOS is not enabled. "
 			    "-r flag not supported.", repo);
 			return (NULL);
 		}
 		/* default repository in single-repo is 'remote' */

@@ -194,26 +199,33 @@ populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {

 			case SQLITE_TEXT:
 				for (i = 0; columns[i].name != NULL; i++) {
 					if (!strcmp(columns[i].name, colname)) {
 						pkg_set(pkg, columns[i].type, sqlite3_column_text(stmt, icol));
 						pkg_set(pkg, columns[i].type,
 						    sqlite3_column_text(stmt,
 						    icol));
 						break;
 					}
 				}
 				if (columns[i].name == NULL)
 					pkg_emit_error("Unknown column %s", colname);
 					pkg_emit_error("Unknown column %s",
 					    colname);
 				break;
 			case SQLITE_INTEGER:
 				for (i = 0; columns[i].name != NULL; i++) {
 					if (!strcmp(columns[i].name, colname)) {
 						pkg_set(pkg, columns[i].type, sqlite3_column_int64(stmt, icol));
 						pkg_set(pkg, columns[i].type,
 						    sqlite3_column_int64(stmt,
 						    icol));
 						break;
 					}
 				}
 				if (columns[i].name == NULL)
 					pkg_emit_error("Unknown column %s", colname);
 					pkg_emit_error("Unknown column %s",
 					    colname);
 				break;
 			case SQLITE_BLOB:
 			case SQLITE_FLOAT:
 				pkg_emit_error("Wrong type for column: %s", colname);
 				pkg_emit_error("Wrong type for column: %s",
 				    colname);
 				/* just ignore currently */
 				break;
 			case SQLITE_NULL:

@@ -232,7 +244,8 @@ pkgdb_regex(sqlite3_context *ctx, int argc, sqlite3_value **argv, int reg_type)

 	if (argc != 2 || (regex = sqlite3_value_text(argv[0])) == NULL ||
 		(str = sqlite3_value_text(argv[1])) == NULL) {
 		sqlite3_result_error(ctx, "SQL function regex() called with invalid arguments.\n", -1);
 		sqlite3_result_error(ctx, "SQL function regex() called "
 		    "with invalid arguments.\n", -1);
 		return;
 	}

@@ -277,7 +290,8 @@ static void

 pkgdb_now(sqlite3_context *ctx, int argc, __unused sqlite3_value **argv)
 {
 	if (argc != 0) {
 		sqlite3_result_error(ctx, "Invalid usage of now() no arguments expected\n", -1);
 		sqlite3_result_error(ctx, "Invalid usage of now() "
 		    "no arguments expected\n", -1);
 		return;
 	}

@@ -363,11 +377,12 @@ pkgdb_upgrade(struct pkgdb *db)

 {
 	int64_t db_version = -1;
 	const char *sql_upgrade;
 	int i;
 	int i, ret;
 	assert(db != NULL);
 	if (get_pragma(db->sqlite, "PRAGMA user_version;", &db_version) != EPKG_OK)
 	ret = get_pragma(db->sqlite, "PRAGMA user_version;", &db_version);
 	if (ret != EPKG_OK)
 		return (EPKG_FATAL);
 	if (db_version == DBVERSION)

@@ -378,8 +393,10 @@ pkgdb_upgrade(struct pkgdb *db)

 	}
 	while (db_version < DBVERSION) {
 		const char *sql_str;
 		if (sqlite3_db_readonly(db->sqlite, "main")) {
 			pkg_emit_error("The database is outdated and opened readonly");
 			pkg_emit_error("The database is outdated and "
 			    "opened readonly");
 			return (EPKG_FATAL);
 		}
 		db_version++;

@@ -396,12 +413,12 @@ pkgdb_upgrade(struct pkgdb *db)

 		/*
 		 * We can't find the statements to upgrade to the next version,
 		 * maybe because the current version is too old and upgrade support has
 		 * been removed.
 		 * maybe because the current version is too old and upgrade
 		 * support has been removed.
 		 */
 		if (sql_upgrade == NULL) {
 			pkg_emit_error("can not upgrade to db version %" PRId64,
 						   db_version);
 			    db_version);
 			return (EPKG_FATAL);
 		}

@@ -411,7 +428,9 @@ pkgdb_upgrade(struct pkgdb *db)

 		if (sql_exec(db->sqlite, sql_upgrade) != EPKG_OK)
 			return (EPKG_FATAL);
 		if (sql_exec(db->sqlite, "PRAGMA user_version = %" PRId64 ";", db_version) != EPKG_OK)
 		sql_str = "PRAGMA user_version = %" PRId64 ";";
 		ret = sql_exec(db->sqlite, sql_str, db_version);
 		if (ret != EPKG_OK)
 			return (EPKG_FATAL);
 		if (sql_exec(db->sqlite, "COMMIT;") != EPKG_OK)

@@ -610,6 +629,81 @@ pkgdb_remote_init(struct pkgdb *db, const char *repo)

 	return (ret);
 }
 static int
 pkgdb_open_multirepos(const char *dbdir, struct pkgdb *db)
 {
 	int ret;
 	char remotepath[MAXPATHLEN + 1];
 	struct pkg_config_kv *repokv = NULL;
 	const char *multirepo_warning =
 	    "\t/!\\		   WARNING WARNING WARNING		/!\\\n"
 	    "\t/!\\	     WORKING ON MULTIPLE REPOSITORIES		/!\\\n"
 	    "\t/!\\  THIS FEATURE IS STILL CONSIDERED EXPERIMENTAL	/!\\\n"
 	    "\t/!\\		     YOU HAVE BEEN WARNED		/!\\\n\n";
 	fprintf(stderr, multirepo_warning);
 	while (pkg_config_list(PKG_CONFIG_REPOS, &repokv) == EPKG_OK) {
 		const char *repo_name = pkg_config_kv_get(repokv,
 		    PKG_CONFIG_KV_KEY);
 		/* is it a reserved name? */
 		if ((strcmp(repo_name, "repo") == 0) ||
 		    (strcmp(repo_name, "main") == 0) ||
 		    (strcmp(repo_name, "temp") == 0) ||
 		    (strcmp(repo_name, "local") == 0))
 			continue;
 		/* is it already attached? */
 		if (is_attached(db->sqlite, repo_name)) {
 			pkg_emit_error("repository '%s' is already "
 			    "listed, ignoring", repo_name);
 			continue;
 		}
 		snprintf(remotepath, sizeof(remotepath), "%s/%s.sqlite",
 		    dbdir, repo_name);
 		if (access(remotepath, R_OK) != 0) {
 			pkg_emit_noremotedb(repo_name);
 			pkgdb_close(db);
 			return (EPKG_ENODB);
 		}
 		ret = sql_exec(db->sqlite, "ATTACH '%s' AS '%s';",
 		    remotepath, repo_name);
 		if (ret != EPKG_OK) {
 			pkgdb_close(db);
 			return (EPKG_FATAL);
 		}
 		switch(pkg_check_repo_version(db, repo_name)) {
 		case EPKG_FATAL:
 			pkgdb_close(db);
 			return (EPKG_FATAL);
 			break;
 		case EPKG_REPOSCHEMA:
 			ret = sql_exec(db->sqlite, "DETACH DATABASE '%s'",
 			    repo_name);
 			if (ret != EPKG_OK) {
 				pkgdb_close(db);
 				return (EPKG_FATAL);
 			}
 			break;
 		default:
 			break;
 		}
 		/* check if default repository exists */
 		if (!is_attached(db->sqlite, "default")) {
 			pkg_emit_error("no default repository defined");
 			pkgdb_close(db);
 			return (EPKG_FATAL);
 		}
 	}
 	return (EPKG_OK);
 }
 int
 pkgdb_open(struct pkgdb **db_p, pkgdb_t type)
 {

@@ -618,10 +712,8 @@ pkgdb_open(struct pkgdb **db_p, pkgdb_t type)

 	char localpath[MAXPATHLEN + 1];
 	char remotepath[MAXPATHLEN + 1];
 	const char *dbdir = NULL;
 	const char *repo_name = NULL;
 	bool multirepos_enabled = false;
 	bool create = false;
 	struct pkg_config_kv *repokv = NULL;
 	int ret;
 	if (*db_p != NULL) {

@@ -653,7 +745,10 @@ pkgdb_open(struct pkgdb **db_p, pkgdb_t type)

 				pkgdb_close(db);
 				return (EPKG_ENODB);
 			} else if (eaccess(dbdir, W_OK) != 0) {
 				/* If we need to create the db but can not write to it, fail early */
 				/*
 				 * If we need to create the db but cannot
 				 * write to it, fail early
 				 */
 				pkg_emit_nolocaldb();
 				pkgdb_close(db);
 				return (EPKG_ENODB);

@@ -688,82 +783,27 @@ pkgdb_open(struct pkgdb **db_p, pkgdb_t type)

 		}
 		/*
 		 * allow foreign key option which will allow to have clean support for
 		 * reinstalling
 		 * allow foreign key option which will allow to have
 		 * clean support for reinstalling
 		 */
 		if (sql_exec(db->sqlite, "PRAGMA foreign_keys = ON;") != EPKG_OK) {
 		ret = sql_exec(db->sqlite, "PRAGMA foreign_keys = ON;");
 		if (ret != EPKG_OK) {
 			pkgdb_close(db);
 			return (EPKG_FATAL);
 		}
 	}
 	pkg_config_bool(PKG_CONFIG_MULTIREPOS, &multirepos_enabled);
 	if (type == PKGDB_REMOTE) {
 		pkg_config_bool(PKG_CONFIG_MULTIREPOS, &multirepos_enabled);
 		if (multirepos_enabled) {
 			fprintf(stderr, "\t/!\\		   WARNING WARNING WARNING		/!\\\n");
 			fprintf(stderr, "\t/!\\	     WORKING ON MULTIPLE REPOSITORIES		/!\\\n");
 			fprintf(stderr, "\t/!\\  THIS FEATURE IS STILL CONSIDERED EXPERIMENTAL	/!\\\n");
 			fprintf(stderr, "\t/!\\		     YOU HAVE BEEN WARNED		/!\\\n\n");
 			while (pkg_config_list(PKG_CONFIG_REPOS, &repokv) == EPKG_OK) {
 				repo_name = pkg_config_kv_get(repokv, PKG_CONFIG_KV_KEY);
 				/* is it a reserved name? */
 				if ((strcmp(repo_name, "repo") == 0) ||
 				    (strcmp(repo_name, "main") == 0) ||
 				    (strcmp(repo_name, "temp") == 0) ||
 				    (strcmp(repo_name, "local") == 0))
 					continue;
 				/* is it already attached? */
 				if (is_attached(db->sqlite, repo_name)) {
 					pkg_emit_error("repository '%s' is already listed, ignoring", repo_name);
 					continue;
 				}
 				snprintf(remotepath, sizeof(remotepath), "%s/%s.sqlite",
 						dbdir, repo_name);
 				if (access(remotepath, R_OK) != 0) {
 					pkg_emit_noremotedb(repo_name);
 					pkgdb_close(db);
 					return (EPKG_ENODB);
 				}
 				if (sql_exec(db->sqlite, "ATTACH '%s' AS '%s';", remotepath, repo_name) != EPKG_OK) {
 					pkgdb_close(db);
 					return (EPKG_FATAL);
 				}
 				switch(pkg_check_repo_version(db, repo_name)) {
 				case EPKG_FATAL:
 					pkgdb_close(db);
 					return (EPKG_FATAL);
 					break;
 				case EPKG_REPOSCHEMA:
 					if (sql_exec(db->sqlite, "DETACH DATABASE '%s'", repo_name) != EPKG_OK) {
 						pkgdb_close(db);
 						return (EPKG_FATAL);
 					}
 					break;
 				default:
 					break;
 				}
 				/* check if default repository exists */
 				if (!is_attached(db->sqlite, "default")) {
 					pkg_emit_error("no default repository defined");
 					pkgdb_close(db);
 					return (EPKG_FATAL);
 				}
 			}
 		} else {
 		if (multirepos_enabled)
 			pkgdb_open_multirepos(dbdir, db);
 		else {
 			/*
 			 * Working on a single remote repository
 			 */
 			snprintf(remotepath, sizeof(remotepath), "%s/repo.sqlite", dbdir);
 			snprintf(remotepath, sizeof(remotepath),
 			    "%s/repo.sqlite", dbdir);
 			if (access(remotepath, R_OK) != 0) {
 				pkg_emit_noremotedb("repo");

@@ -771,12 +811,15 @@ pkgdb_open(struct pkgdb **db_p, pkgdb_t type)

 				return (EPKG_ENODB);
 			}
 			if (sql_exec(db->sqlite, "ATTACH '%q' AS 'remote';", remotepath) != EPKG_OK) {
 			ret = sql_exec(db->sqlite, "ATTACH '%q' AS 'remote';",
 			    remotepath);
 			if (ret != EPKG_OK) {
 				pkgdb_close(db);
 				return (EPKG_FATAL);
 			}
 			if ((ret = pkg_check_repo_version(db, "remote")) != EPKG_OK) {
 			ret = pkg_check_repo_version(db, "remote");
 			if (ret != EPKG_OK) {
 				pkgdb_close(db);
 				return (ret);
 			}

@@ -867,9 +910,11 @@ pkgdb_it_next(struct pkgdb_it *it, struct pkg **pkg_p, int flags)

 		populate_pkg(it->stmt, pkg);
 		for (i = 0; load_on_flag[i].load != NULL; i++) {
 			if (flags & load_on_flag[i].flag)
 				if ((ret = load_on_flag[i].load(it->db, pkg)) != EPKG_OK)
 			if (flags & load_on_flag[i].flag) {
 				ret = load_on_flag[i].load(it->db, pkg);
 				if (ret != EPKG_OK)
 					return (ret);
 			}
 		}
 		return (EPKG_OK);

@@ -968,7 +1013,7 @@ pkgdb_get_match_how(match_t match)

 			how = "EREGEXP(?1, %s)";
 			break;
 		case MATCH_CONDITION:
 			/* This case should not be called by pkgdb_get_match_how() */
 			/* Should not be called by pkgdb_get_match_how(). */
 			assert(0);
 			break;
 	}

@@ -1124,8 +1169,8 @@ pkgdb_load_deps(struct pkgdb *db, struct pkg *pkg)

 	sqlite3_bind_int64(stmt, 1, pkg->rowid);
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
 		pkg_adddep(pkg, sqlite3_column_text(stmt, 0), sqlite3_column_text(stmt, 1),
 				   sqlite3_column_text(stmt, 2));
 		pkg_adddep(pkg, sqlite3_column_text(stmt, 0),
 		    sqlite3_column_text(stmt, 1), sqlite3_column_text(stmt, 2));
 	}
 	sqlite3_finalize(stmt);

@@ -1174,8 +1219,8 @@ pkgdb_load_rdeps(struct pkgdb *db, struct pkg *pkg)

 	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),
 				   sqlite3_column_text(stmt, 2));
 		pkg_addrdep(pkg, sqlite3_column_text(stmt, 0),
 		    sqlite3_column_text(stmt, 1), sqlite3_column_text(stmt, 2));
 	}
 	sqlite3_finalize(stmt);

@@ -1214,7 +1259,8 @@ pkgdb_load_files(struct pkgdb *db, struct pkg *pkg)

 	sqlite3_bind_int64(stmt, 1, pkg->rowid);
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
 		pkg_addfile(pkg, sqlite3_column_text(stmt, 0), sqlite3_column_text(stmt, 1), false);
 		pkg_addfile(pkg, sqlite3_column_text(stmt, 0),
 		    sqlite3_column_text(stmt, 1), false);
 	}
 	sqlite3_finalize(stmt);

@@ -1254,7 +1300,8 @@ pkgdb_load_dirs(struct pkgdb *db, struct pkg *pkg)

 	sqlite3_bind_int64(stmt, 1, pkg->rowid);
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
 		pkg_adddir(pkg, sqlite3_column_text(stmt, 0), sqlite3_column_int(stmt, 1));
 		pkg_adddir(pkg, sqlite3_column_text(stmt, 0),
 		    sqlite3_column_int(stmt, 1));
 	}
 	sqlite3_finalize(stmt);

@@ -1290,7 +1337,8 @@ pkgdb_load_license(struct pkgdb *db, struct pkg *pkg)

 	} else
 		sqlite3_snprintf(sizeof(sql), sql, basesql, "main", "main");
 	return (load_val(db->sqlite, pkg, sql, PKG_LOAD_LICENSES, pkg_addlicense, PKG_LICENSES));
 	return (load_val(db->sqlite, pkg, sql, PKG_LOAD_LICENSES,
 	    pkg_addlicense, PKG_LICENSES));
 }
 int

@@ -1314,7 +1362,8 @@ pkgdb_load_category(struct pkgdb *db, struct pkg *pkg)

 	} else
 		sqlite3_snprintf(sizeof(sql), sql, basesql, "main", "main");
 	return (load_val(db->sqlite, pkg, sql, PKG_LOAD_CATEGORIES, pkg_addcategory, PKG_CATEGORIES));
 	return (load_val(db->sqlite, pkg, sql, PKG_LOAD_CATEGORIES,
 	    pkg_addcategory, PKG_CATEGORIES));
 }
 int

@@ -1334,7 +1383,8 @@ pkgdb_load_user(struct pkgdb *db, struct pkg *pkg)

 	assert(db != NULL && pkg != NULL);
 	assert(pkg->type == PKG_INSTALLED);
 	ret = load_val(db->sqlite, pkg, sql, PKG_LOAD_USERS, pkg_adduser, PKG_USERS);
 	ret = load_val(db->sqlite, pkg, sql, PKG_LOAD_USERS,
 	    pkg_adduser, PKG_USERS);
 	/* TODO get user uidstr from local database */
 /*	while (pkg_users(pkg, &u) == EPKG_OK) {

@@ -1364,7 +1414,8 @@ pkgdb_load_group(struct pkgdb *db, struct pkg *pkg)

 	assert(db != NULL && pkg != NULL);
 	assert(pkg->type == PKG_INSTALLED);
 	ret = load_val(db->sqlite, pkg, sql, PKG_LOAD_GROUPS, pkg_addgroup, PKG_GROUPS);
 	ret = load_val(db->sqlite, pkg, sql, PKG_LOAD_GROUPS,
 	    pkg_addgroup, PKG_GROUPS);
 	while (pkg_groups(pkg, &g) == EPKG_OK) {
 		grp = getgrnam(pkg_group_name(g));

@@ -1397,7 +1448,8 @@ pkgdb_load_shlib(struct pkgdb *db, struct pkg *pkg)

 	} else
 		sqlite3_snprintf(sizeof(sql), sql, basesql, "main", "main");
 	return (load_val(db->sqlite, pkg, sql, PKG_LOAD_SHLIBS, pkg_addshlib, PKG_SHLIBS));
 	return (load_val(db->sqlite, pkg, sql, PKG_LOAD_SHLIBS,
 	    pkg_addshlib, PKG_SHLIBS));
 }
 int

@@ -1424,7 +1476,8 @@ pkgdb_load_scripts(struct pkgdb *db, struct pkg *pkg)

 	sqlite3_bind_int64(stmt, 1, pkg->rowid);
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
 		pkg_addscript(pkg, sqlite3_column_text(stmt, 0), sqlite3_column_int(stmt, 1));
 		pkg_addscript(pkg, sqlite3_column_text(stmt, 0),
 		    sqlite3_column_int(stmt, 1));
 	}
 	sqlite3_finalize(stmt);

@@ -1471,7 +1524,7 @@ pkgdb_load_options(struct pkgdb *db, struct pkg *pkg)

 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
 		pkg_addoption(pkg, sqlite3_column_text(stmt, 0),
 					  sqlite3_column_text(stmt, 1));
 		    sqlite3_column_text(stmt, 1));
 	}
 	sqlite3_finalize(stmt);

@@ -1643,6 +1696,7 @@ prstmt_initialize(struct pkgdb *db)

 {
 	sql_prstmt_index i;
 	sqlite3 *sqlite;
 	int ret;
 	assert(db != NULL);

@@ -1650,9 +1704,8 @@ prstmt_initialize(struct pkgdb *db)

 	for (i = 0; i < PRSTMT_LAST; i++)
 	{
 		if (sqlite3_prepare_v2(sqlite, SQL(i), -1, &STMT(i), NULL)
 		    != SQLITE_OK)
 		{
 		ret = sqlite3_prepare_v2(sqlite, SQL(i), -1, &STMT(i), NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(sqlite);
 			return (EPKG_FATAL);
 		}

@@ -1757,9 +1810,9 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 	if (!complete && sql_exec(s, "BEGIN;") != EPKG_OK)
 		return (EPKG_FATAL);
 	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_MAINTAINER, &maintainer,
 	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_MAINTAINER, &maintainer,
 	    PKG_WWW, &www, PKG_PREFIX, &prefix, PKG_FLATSIZE, &flatsize,
 	    PKG_AUTOMATIC, &automatic, PKG_LICENSE_LOGIC, &licenselogic,
 	    PKG_NAME, &name, PKG_INFOS, &infos);

@@ -1776,9 +1829,10 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 	/*
 	 * Insert package record
 	 */
 	if (run_prstmt(PKG, origin, name, version, comment, desc, message, arch,
 	    maintainer, www, prefix, flatsize, automatic, licenselogic, mtree, infos)
 	    != SQLITE_DONE) {
 	ret = run_prstmt(PKG, origin, name, version, comment, desc, message,
 	    arch, maintainer, www, prefix, flatsize, automatic, licenselogic,
 	    mtree, infos);
 	if (ret != SQLITE_DONE) {
 		ERROR_SQLITE(s);
 		goto cleanup;
 	}

@@ -1790,8 +1844,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 	 * package
 	 */
 	if (run_prstmt(DEPS_UPDATE, name, version, origin)
 	    != SQLITE_DONE) {
 	if (run_prstmt(DEPS_UPDATE, name, version, origin) != SQLITE_DONE) {
 		ERROR_SQLITE(s);
 		goto cleanup;
 	}

@@ -1814,29 +1867,35 @@ 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_path(file),
 		    pkg_file_cksum(file), package_id)) != SQLITE_DONE) {
 			if (ret == SQLITE_CONSTRAINT) {
 				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) {
 					pkg_get(pkg2, PKG_NAME, &name2, PKG_VERSION, &version2);
 					pkg_emit_error("%s-%s conflicts with %s-%s"
 					    " (installs files into the same place). "
 					    " Problematic file: %s",
 					    name, version, name2, version2,
 					    pkg_file_path(file));
 					pkg_free(pkg2);
 				} else {
 					ERROR_SQLITE(s);
 				}
 				pkgdb_it_free(it);
 			} else {
 				ERROR_SQLITE(s);
 			}
 		const char *pkg_path = pkg_file_path(file);
 		const char *pkg_sum = pkg_file_cksum(file);
 		ret = run_prstmt(FILES, pkg_path, pkg_sum, package_id);
 		if (ret == SQLITE_DONE)
 			continue;
 		if (ret != SQLITE_CONSTRAINT) {
 			ERROR_SQLITE(s);
 			goto cleanup;
 		}
 		it = pkgdb_query_which(db, pkg_path);
 		if (it == NULL) {
 			ERROR_SQLITE(s);
 			goto cleanup;
 		}
 		ret = pkgdb_it_next(it, &pkg2, PKG_LOAD_BASIC);
 		if (ret != EPKG_OK) {
 			pkgdb_it_free(it);
 			ERROR_SQLITE(s);
 			goto cleanup;
 		}
 		pkg_get(pkg2, PKG_NAME, &name2, PKG_VERSION, &version2);
 		pkg_emit_error("%s-%s conflicts with %s-%s"
 		    " (installs files into the same place). "
 		    " Problematic file: %s",
 		    name, version, name2, version2, pkg_path);
 		pkg_free(pkg2);
 		pkgdb_it_free(it);
 		goto cleanup;
 	}
 	/*

@@ -1851,8 +1910,9 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 		if ((ret = run_prstmt(DIRS2, package_id, pkg_dir_path(dir),
 		    pkg_dir_try(dir))) != SQLITE_DONE) {
 			if (ret == SQLITE_CONSTRAINT) {
 				pkg_emit_error("Another package is already providing "
 					       "directory: %s", pkg_dir_path(dir));
 				pkg_emit_error("Another package is already "
 				    "providing directory: %s",
 				    pkg_dir_path(dir));
 			} else
 				ERROR_SQLITE(s);
 			goto cleanup;

@@ -1864,11 +1924,11 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 	 */
 	while (pkg_categories(pkg, &category) == EPKG_OK) {
 		if (run_prstmt(CATEGORY1, pkg_category_name(category))
 		    != SQLITE_DONE
 		    ||
 		    run_prstmt(CATEGORY2, package_id, pkg_category_name(category))
 		    != SQLITE_DONE) {
 		const char *pkg_cat = pkg_category_name(category);
 		ret = run_prstmt(CATEGORY1, pkg_cat);
 		if (ret == SQLITE_DONE)
 			ret = run_prstmt(CATEGORY2, package_id, pkg_cat);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			goto cleanup;
 		}

@@ -2063,6 +2123,25 @@ pkgdb_unregister_pkg(struct pkgdb *db, const char *origin)

 	sqlite3_stmt *stmt_del;
 	int ret;
 	const char sql[] = "DELETE FROM packages WHERE origin = ?1;";
 	const char *deletions[] = {
 		"directories WHERE id NOT IN "
 			"(SELECT DISTINCT directory_id FROM pkg_directories)",
 		"categories WHERE id NOT IN "
 			"(SELECT DISTINCT category_id FROM pkg_categories)",
 		"licenses WHERE id NOT IN "
 			"(SELECT DISTINCT license_id FROM pkg_licenses)",
 		"mtree WHERE id NOT IN "
 			"(SELECT DISTINCT mtree_id FROM packages)",
 		/* TODO print the users that are not used anymore */
 		"users WHERE id NOT IN "
 			"(SELECT DISTINCT user_id FROM pkg_users)",
 		/* TODO print the groups trhat are not used anymore */
 		"groups WHERE id NOT IN "
 			"(SELECT DISTINCT group_id FROM pkg_groups)",
 		"shlibs WHERE id NOT IN "
 			"(SELECT DISTINCT shlib_id FROM pkg_shlibs)"
 	};
 	size_t num_deletions = sizeof(deletions) / sizeof(*deletions);
 	assert(db != NULL);
 	assert(origin != NULL);

@@ -2082,30 +2161,11 @@ pkgdb_unregister_pkg(struct pkgdb *db, const char *origin)

 		return (EPKG_FATAL);
 	}
 	/* cleanup directories */
 	if (sql_exec(db->sqlite, "DELETE from directories WHERE id NOT IN (SELECT DISTINCT directory_id FROM pkg_directories);") != EPKG_OK)
 		return (EPKG_FATAL);
 	if (sql_exec(db->sqlite, "DELETE from categories WHERE id NOT IN (SELECT DISTINCT category_id FROM pkg_categories);") != EPKG_OK)
 		return (EPKG_FATAL);
 	if (sql_exec(db->sqlite, "DELETE from licenses WHERE id NOT IN (SELECT DISTINCT license_id FROM pkg_licenses);") != EPKG_OK)
 		return (EPKG_FATAL);
 	if (sql_exec(db->sqlite, "DELETE FROM mtree WHERE id NOT IN (SELECT DISTINCT mtree_id FROM packages);") != EPKG_OK)
 		return (EPKG_FATAL);
 	/* TODO print the users that are not used anymore */
 	if (sql_exec(db->sqlite, "DELETE FROM users WHERE id NOT IN (SELECT DISTINCT user_id FROM pkg_users);") != EPKG_OK)
 		return (EPKG_FATAL);
 	/* TODO print the groups trhat are not used anymore */
 	if (sql_exec(db->sqlite, "DELETE FROM groups WHERE id NOT IN (SELECT DISTINCT group_id FROM pkg_groups);") != EPKG_OK)
 		return (EPKG_FATAL);
 	if (sql_exec(db->sqlite, "DELETE FROM shlibs WHERE id NOT IN (SELECT DISTINCT shlib_id FROM pkg_shlibs);") != EPKG_OK)
 		return (EPKG_FATAL);
 	for (size_t obj = 0;obj < num_deletions; obj++) {
 		ret = sql_exec(db->sqlite, "DELETE FROM %s;", deletions[obj]);
 		if (ret != EPKG_OK)
 			return (EPKG_FATAL);
 	}
 	return (EPKG_OK);
 }

@@ -2150,10 +2210,12 @@ is_attached(sqlite3 *s, const char *name)

 {
 	sqlite3_stmt *stmt;
 	const char *dbname;
 	int ret;
 	assert(s != NULL);
 	if (sqlite3_prepare_v2(s, "PRAGMA database_list;", -1, &stmt, NULL) != SQLITE_OK) {
 	ret = sqlite3_prepare_v2(s, "PRAGMA database_list;", -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(s);
 		return false;
 	}

@@ -2179,7 +2241,11 @@ report_already_installed(sqlite3 *s)

 	const char *sql = "SELECT origin FROM pkgjobs WHERE "
 		"(SELECT p.origin FROM main.packages AS p WHERE "
 		"p.origin=pkgjobs.origin AND p.version=pkgjobs.version "
 		"AND (SELECT group_concat(option) FROM (select option FROM main.options WHERE package_id=p.id AND value='on' ORDER BY option)) IS pkgjobs.opts) "
 		"AND (SELECT group_concat(option) FROM "
 		"  (select option FROM main.options "
 		"                 WHERE package_id=p.id "
 		"                 AND value='on' ORDER BY option))"
 		"IS pkgjobs.opts) "
 		"IS NOT NULL;";
 	assert(s != NULL);

@@ -2191,29 +2257,35 @@ report_already_installed(sqlite3 *s)

 	while (sqlite3_step(stmt) != SQLITE_DONE) {
 		origin = sqlite3_column_text(stmt, 0);
 		pkg_emit_error("%s is already installed and at the latest version", origin);
 		pkg_emit_error("%s is already installed and at "
 		    "the latest version", origin);
 	}
 	sqlite3_finalize(stmt);
 }
 static int
 sql_on_all_attached_db(sqlite3 *s, struct sbuf *sql, const char *multireposql, const char *compound) {
 sql_on_all_attached_db(sqlite3 *s, struct sbuf *sql, const char *multireposql,
     const char *compound)
 {
 	sqlite3_stmt *stmt;
 	const char *dbname;
 	bool first = true;
 	int ret;
 	assert(s != NULL);
 	assert(compound != NULL);
 	if (sqlite3_prepare_v2(s, "PRAGMA database_list;", -1, &stmt, NULL) != SQLITE_OK) {
 	ret = sqlite3_prepare_v2(s, "PRAGMA database_list;", -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(s);
 		return (EPKG_FATAL);
 	}
 	while (sqlite3_step(stmt) != SQLITE_DONE) {
 		dbname = sqlite3_column_text(stmt, 1);
 		if ((strcmp(dbname, "main") == 0) || (strcmp(dbname, "temp") == 0))
 		if ((strcmp(dbname, "main") == 0) ||
 		    (strcmp(dbname, "temp") == 0))
 			continue;
 		if (!first) {

@@ -2237,10 +2309,12 @@ pkgdb_detach_remotes(sqlite3 *s)

 	sqlite3_stmt *stmt;
 	struct sbuf *sql = NULL;
 	const char *dbname;
 	int ret;
 	assert(s != NULL);
 	if (sqlite3_prepare_v2(s, "PRAGMA database_list;", -1, &stmt, NULL) != SQLITE_OK) {
 	ret = sqlite3_prepare_v2(s, "PRAGMA database_list;", -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(s);
 		return;
 	}

@@ -2297,14 +2371,16 @@ pkgdb_compact(struct pkgdb *db)

 {
 	int64_t page_count = 0;
 	int64_t freelist_count = 0;
 	int ret;
 	assert(db != NULL);
 	if (get_pragma(db->sqlite, "PRAGMA page_count;", &page_count) != EPKG_OK)
 	ret = get_pragma(db->sqlite, "PRAGMA page_count;", &page_count);
 	if (ret != EPKG_OK)
 		return (EPKG_FATAL);
 	if (get_pragma(db->sqlite, "PRAGMA freelist_count;", &freelist_count) !=
 		EPKG_OK)
 	ret = get_pragma(db->sqlite, "PRAGMA freelist_count;", &freelist_count);
 	if (ret != EPKG_OK)
 		return (EPKG_FATAL);
 	/*

@@ -2324,13 +2400,16 @@ create_temporary_pkgjobs(sqlite3 *s)

 	assert(s != NULL);
 	ret = sql_exec(s, "DROP TABLE IF EXISTS pkgjobs;"
 			"CREATE TEMPORARY TABLE IF NOT EXISTS pkgjobs (pkgid INTEGER, "
 			"origin TEXT UNIQUE NOT NULL, name TEXT, version TEXT, "
 			"comment TEXT, desc TEXT, message TEXT, "
 			"arch TEXT, maintainer TEXT, "
 			"www TEXT, prefix TEXT, flatsize INTEGER, newversion TEXT, "
 			"newflatsize INTEGER, pkgsize INTEGER, cksum TEXT, repopath TEXT, automatic INTEGER, weight INTEGER, "
 			"dbname TEXT, opts TEXT);");
 			"CREATE TEMPORARY TABLE IF NOT EXISTS pkgjobs ("
 			"    pkgid INTEGER, origin TEXT UNIQUE NOT NULL,"
 			"    name TEXT, version TEXT, comment TEXT, desc TEXT, "
 			"    message TEXT, arch TEXT, maintainer TEXT, "
 			"    www TEXT, prefix TEXT, flatsize INTEGER, "
 			"    newversion TEXT, newflatsize INTEGER, "
 			"    pkgsize INTEGER, cksum TEXT, repopath TEXT, "
 			"    automatic INTEGER, weight INTEGER, dbname TEXT, "
 			"    opts TEXT"
 			");");
 	return (ret);
 }

@@ -2342,6 +2421,7 @@ pkgdb_query_newpkgversion(struct pkgdb *db, const char *repo)

 	const char *reponame = NULL;
 	sqlite3_stmt *stmt = NULL;
 	struct pkgdb_it *it = NULL;
 	int ret;
 	const char finalsql[] = "SELECT pkgid AS id, origin, name, version, "
 		"comment, desc, message, arch, maintainer, "

@@ -2349,14 +2429,21 @@ pkgdb_query_newpkgversion(struct pkgdb *db, const char *repo)

 		"cksum, repopath, automatic, weight, "
 		"'%s' AS dbname FROM pkgjobs;";
 	const char main_sql[] = "INSERT OR IGNORE INTO pkgjobs (pkgid, origin, name, newversion, comment, desc, arch, "
 			"maintainer, www, prefix, newflatsize, pkgsize, "
 			"version, flatsize, cksum, repopath, automatic) "
 			"SELECT p.id, p.origin, p.name, p.version as newversion, p.comment, p.desc, "
 			"p.arch, p.maintainer, p.www, p.prefix, p.flatsize as newflatsize, p.pkgsize, "
 			/* If not installed from a port, insert the running version in */
 			"COALESCE(l.version, '" PKG_PORTVERSION "') as version, COALESCE(l.flatsize, p.flatsize) as flatsize, "
 			"p.cksum, p.path, 0 FROM '%s'.packages as p LEFT JOIN packages as l ON p.origin = l.origin WHERE p.origin='ports-mgmt/pkg';";
 	const char main_sql[] =
 	    "INSERT OR IGNORE INTO pkgjobs ("
 	    "  pkgid, origin, name, newversion, comment, desc, arch, "
 	    "  maintainer, www, prefix, newflatsize, pkgsize, "
 	    "  version, flatsize, cksum, repopath, automatic "
 	    ") "
 	    "SELECT p.id, p.origin, p.name, p.version as newversion, "
 	    "       p.comment, p.desc, p.arch, p.maintainer, p.www, "
 	    "       p.prefix, p.flatsize as newflatsize, p.pkgsize, "
 	    /* If not installed from a port, insert the running version in */
 	    "COALESCE(l.version, '" PKG_PORTVERSION "') as version, "
 	    "COALESCE(l.flatsize, p.flatsize) as flatsize, "
 	    "p.cksum, p.path, 0 FROM '%s'.packages as p "
 	    "  LEFT JOIN packages as l ON p.origin = l.origin "
 	    "  WHERE p.origin='ports-mgmt/pkg';";
 	assert(db != NULL);
 	assert(db->type == PKGDB_REMOTE);

@@ -2378,7 +2465,9 @@ pkgdb_query_newpkgversion(struct pkgdb *db, const char *repo)

 	}
 	/* Delete where the current version is higher than the remote version */
 	sql_exec(db->sqlite, "DELETE FROM pkgjobs WHERE PKGGT(version, newversion) OR version == newversion;");
 	sql_exec(db->sqlite,
 	    "DELETE FROM pkgjobs WHERE "
 	    "  PKGGT(version, newversion) OR version == newversion;");
 	/* Return NULL if pkg was deleted */
 	if (sqlite3_changes(db->sqlite) > 0) {

@@ -2389,7 +2478,8 @@ pkgdb_query_newpkgversion(struct pkgdb *db, const char *repo)

 	sbuf_printf(sql, finalsql, reponame);
 	sbuf_finish(sql);
 	if (sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL) != SQLITE_OK) {
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		goto cleanup;
 	}

@@ -2403,11 +2493,12 @@ cleanup:

 }
 struct pkgdb_it *
 pkgdb_query_installs(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs, const char *repo, bool force, bool recursive)
 pkgdb_query_installs(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs,
     const char *repo, bool force, bool recursive)
 {
 	sqlite3_stmt *stmt = NULL;
 	struct pkgdb_it *it;
 	int i = 0;
 	int i = 0, ret;
 	struct sbuf *sql = NULL;
 	const char *how = NULL;
 	const char *reponame = NULL;

@@ -2423,24 +2514,33 @@ pkgdb_query_installs(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs, c

 		"cksum, repopath, automatic, weight, "
 		"'%s' AS dbname FROM pkgjobs ORDER BY weight DESC;";
 	const char main_sql[] = "INSERT OR IGNORE INTO pkgjobs (pkgid, origin, name, version, comment, desc, arch, "
 			"maintainer, www, prefix, flatsize, pkgsize, "
 			"cksum, repopath, automatic, opts) "
 			"SELECT id, origin, name, version, comment, desc, "
 			"arch, maintainer, www, prefix, flatsize, pkgsize, "
 			"cksum, path, 0, "
 			"(select group_concat(option) from (select option from '%s'.options WHERE package_id=id AND value='on' ORDER BY option)) "
 			"FROM '%s'.packages WHERE ";
 	const char deps_sql[] = "INSERT OR IGNORE INTO pkgjobs (pkgid, origin, name, version, comment, desc, arch, "
 				"maintainer, www, prefix, flatsize, pkgsize, "
 				"cksum, repopath, automatic) "
 				"SELECT DISTINCT r.id, r.origin, r.name, r.version, r.comment, r.desc, "
 				"r.arch, r.maintainer, r.www, r.prefix, r.flatsize, r.pkgsize, "
 				"r.cksum, r.path, 1 "
 				"FROM '%s'.packages AS r where r.origin IN "
 				"(SELECT d.origin FROM '%s'.deps AS d, pkgjobs AS j WHERE d.package_id = j.pkgid) "
 				"AND (SELECT origin FROM main.packages WHERE origin=r.origin AND version=r.version) IS NULL;";
 	const char main_sql[] =
 	    "INSERT OR IGNORE INTO pkgjobs ("
 	    "  pkgid, origin, name, version, comment, desc, arch, "
 	    "  maintainer, www, prefix, flatsize, pkgsize, "
 	    "  cksum, repopath, automatic, opts"
 	    ") "
 	    "SELECT id, origin, name, version, comment, desc, "
 	    "  arch, maintainer, www, prefix, flatsize, pkgsize, "
 	    "  cksum, path, 0, "
 	    "  (SELECT group_concat(option) FROM "
 	    "    (SELECT option FROM '%s'.options "
 	    "                   WHERE package_id=id"
 	    "                   AND value='on' ORDER BY option"
 	    "    )"
 	    "  ) "
 	    "FROM '%s'.packages WHERE ";
 	const char deps_sql[] =
 	    "INSERT OR IGNORE INTO pkgjobs (pkgid, origin, name, version, comment, desc, arch, "
 	    "maintainer, www, prefix, flatsize, pkgsize, "
 	    "cksum, repopath, automatic) "
 	    "SELECT DISTINCT r.id, r.origin, r.name, r.version, r.comment, r.desc, "
 	    "r.arch, r.maintainer, r.www, r.prefix, r.flatsize, r.pkgsize, "
 	    "r.cksum, r.path, 1 "
 	    "FROM '%s'.packages AS r where r.origin IN "
 	    "(SELECT d.origin FROM '%s'.deps AS d, pkgjobs AS j WHERE d.package_id = j.pkgid) "
 	    "AND (SELECT origin FROM main.packages WHERE origin=r.origin AND version=r.version) IS NULL;";
 	const char upwards_deps_sql[] = "INSERT OR IGNORE INTO pkgjobs (pkgid, origin, name, version, comment, desc, arch, "
 				"maintainer, www, prefix, flatsize, pkgsize, "

@@ -2480,7 +2580,9 @@ pkgdb_query_installs(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs, c

 	sbuf_finish(sql);
 	for (i = 0; i < nbpkgs; i++) {
 		if (sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL) != SQLITE_OK) {
 		ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1,
 		    &stmt, NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(db->sqlite);
 			sbuf_delete(sql);
 			return (NULL);

@@ -2490,13 +2592,17 @@ pkgdb_query_installs(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs, c

 		/* report if package was not found in the database */
 		if (sqlite3_changes(db->sqlite) == 0)
 			pkg_emit_error("Package '%s' was not found in the repositories", pkgs[i]);
 			pkg_emit_error("Package '%s' was not found in "
 			    "the repositories", pkgs[i]);
 	}
 	sqlite3_finalize(stmt);
 	sbuf_clear(sql);
 	/* Report and remove packages already installed and at the latest version and without option change */
 	/*
 	 * Report and remove packages already installed and at the latest
 	 * version and without option change
 	 */
 	report_already_installed(db->sqlite);
 	if (!force) {
 		sql_exec(db->sqlite, "DELETE FROM pkgjobs WHERE "

@@ -2566,6 +2672,7 @@ pkgdb_query_upgrades(struct pkgdb *db, const char *repo, bool all)

 	struct sbuf *sql = NULL;
 	const char *reponame = NULL;
 	struct pkgdb_it *it;
 	int ret;
 	if ((it = pkgdb_query_newpkgversion(db, repo)) != NULL) {
 		pkg_emit_newpkgversion();

@@ -2674,7 +2781,8 @@ pkgdb_query_upgrades(struct pkgdb *db, const char *repo, bool all)

 	sbuf_printf(sql, finalsql, reponame);
 	sbuf_finish(sql);
 	if (sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL) != SQLITE_OK) {
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		sbuf_delete(sql);
 		return (NULL);

@@ -2691,6 +2799,7 @@ pkgdb_query_downgrades(struct pkgdb *db, const char *repo)

 	struct sbuf *sql = NULL;
 	const char *reponame = NULL;
 	sqlite3_stmt *stmt = NULL;
 	int ret;
 	assert(db != NULL);
 	assert(db->type == PKGDB_REMOTE);

@@ -2712,7 +2821,8 @@ pkgdb_query_downgrades(struct pkgdb *db, const char *repo)

 	sbuf_printf(sql, finalsql, reponame, reponame);
 	sbuf_finish(sql);
 	if (sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL) != SQLITE_OK) {
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		sbuf_delete(sql);
 		return (NULL);

@@ -2763,7 +2873,7 @@ pkgdb_query_delete(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs, int

 	struct sbuf *sql = sbuf_new_auto();
 	const char *how = NULL;
 	int i = 0;
 	int i = 0, ret;
 	assert(db != NULL);

@@ -2793,7 +2903,9 @@ pkgdb_query_delete(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs, int

 		sbuf_finish(sql);
 		for (i = 0; i < nbpkgs; i++) {
 			if (sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL) != SQLITE_OK) {
 			ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1,
 			    &stmt, NULL);
 			if (ret != SQLITE_OK) {
 				ERROR_SQLITE(db->sqlite);
 				sbuf_delete(sql);
 				return (NULL);

@@ -2803,7 +2915,9 @@ pkgdb_query_delete(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs, int

 		}
 	} else {
 		sbuf_finish(sql);
 		if (sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL) != SQLITE_OK) {
 		ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1,
 		    &stmt, NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(db->sqlite);
 			sbuf_delete(sql);
 			return (NULL);

@@ -2835,13 +2949,15 @@ pkgdb_query_delete(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs, int

 }
 struct pkgdb_it *
 pkgdb_rquery(struct pkgdb *db, const char *pattern, match_t match, const char *repo)
 pkgdb_rquery(struct pkgdb *db, const char *pattern, match_t match,
     const char *repo)
 {
 	sqlite3_stmt *stmt = NULL;
 	struct sbuf *sql = NULL;
 	bool multirepos_enabled = false;
 	const char *reponame = NULL;
 	const char *comp = NULL;
 	int ret;
 	char basesql[BUFSIZ] = ""
 				"SELECT id, origin, name, version, comment, "
 				"prefix, desc, arch, maintainer, www, "

@@ -2867,7 +2983,9 @@ pkgdb_rquery(struct pkgdb *db, const char *pattern, match_t match, const char *r

 	 */
 	if (multirepos_enabled && !strcmp(reponame, "default")) {
 		/* duplicate the query via UNION for all the attached databases */
 		if (sql_on_all_attached_db(db->sqlite, sql, basesql, " UNION ALL ") != EPKG_OK) {
 		ret = sql_on_all_attached_db(db->sqlite, sql,
 		    basesql, " UNION ALL ");
 		if (ret != EPKG_OK) {
 			sbuf_delete(sql);
 			return (NULL);
 		}

@@ -2877,7 +2995,8 @@ pkgdb_rquery(struct pkgdb *db, const char *pattern, match_t match, const char *r

 	sbuf_cat(sql, " ORDER BY name;");
 	sbuf_finish(sql);
 	if (sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL) != SQLITE_OK) {
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		sbuf_delete(sql);
 		return (NULL);

@@ -2893,7 +3012,8 @@ pkgdb_rquery(struct pkgdb *db, const char *pattern, match_t match, const char *r

 static int
 pkgdb_search_build_search_query(struct sbuf *sql, match_t match, unsigned int field)
 pkgdb_search_build_search_query(struct sbuf *sql, match_t match,
     unsigned int field)
 {
 	const char *how = NULL;
 	const char *what = NULL;

@@ -2928,11 +3048,13 @@ pkgdb_search_build_search_query(struct sbuf *sql, match_t match, unsigned int fi

 }
 struct pkgdb_it *
 pkgdb_search(struct pkgdb *db, const char *pattern, match_t match, unsigned int field, const char *reponame)
 pkgdb_search(struct pkgdb *db, const char *pattern, match_t match,
     unsigned int field, const char *reponame)
 {
 	sqlite3_stmt *stmt = NULL;
 	struct sbuf *sql = NULL;
 	bool multirepos_enabled = false;
 	int ret;
 	const char *basesql = ""
 				"SELECT id, origin, name, version, comment, "
 					"prefix, desc, arch, maintainer, www, "

@@ -2967,13 +3089,15 @@ pkgdb_search(struct pkgdb *db, const char *pattern, match_t match, unsigned int

 			if (is_attached(db->sqlite, reponame)) {
 				sbuf_printf(sql, multireposql, reponame, reponame);
 			} else {
 				pkg_emit_error("Repository %s can't be loaded", reponame);
 				pkg_emit_error("Repository %s can't be loaded",
 				    reponame);
 				sbuf_delete(sql);
 				return (NULL);
 			}
 		} else {
 			/* test on all the attached databases */
 			if (sql_on_all_attached_db(db->sqlite, sql, multireposql, " UNION ALL ") != EPKG_OK) {
 			if (sql_on_all_attached_db(db->sqlite, sql,
 			    multireposql, " UNION ALL ") != EPKG_OK) {
 				sbuf_delete(sql);
 				return (NULL);
 			}

@@ -2993,7 +3117,8 @@ pkgdb_search(struct pkgdb *db, const char *pattern, match_t match, unsigned int

 	sbuf_cat(sql, ";");
 	sbuf_finish(sql);
 	if (sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL) != SQLITE_OK) {
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		sbuf_delete(sql);
 		return (NULL);

@@ -3038,32 +3163,36 @@ pkgdb_integrity_append(struct pkgdb *db, struct pkg *p)

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

@@ -3081,7 +3210,7 @@ pkgdb_integrity_append(struct pkgdb *db, struct pkg *p)

 int
 pkgdb_integrity_check(struct pkgdb *db)
 {
 	int ret = EPKG_OK;
 	int ret, retcode = EPKG_OK;
 	sqlite3_stmt *stmt;
 	sqlite3_stmt *stmt_conflicts;
 	struct sbuf *conflictmsg = NULL;

@@ -3107,43 +3236,49 @@ pkgdb_integrity_check(struct pkgdb *db)

 	while (sqlite3_step(stmt) != SQLITE_DONE) {
 		sbuf_clear(conflictmsg);
 		if (sqlite3_prepare_v2(db->sqlite, sql_local_conflict, -1, &stmt_conflicts, NULL) != SQLITE_OK) {
 		ret = sqlite3_prepare_v2(db->sqlite, sql_local_conflict, -1,
 		    &stmt_conflicts, NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(db->sqlite);
 			sqlite3_finalize(stmt);
 			sbuf_delete(conflictmsg);
 			return (EPKG_FATAL);
 		}
 		sqlite3_bind_text(stmt_conflicts, 1, sqlite3_column_text(stmt, 0), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_conflicts, 1,
 		    sqlite3_column_text(stmt, 0), -1, SQLITE_STATIC);
 		sqlite3_step(stmt_conflicts);
 		sbuf_printf(conflictmsg, "WARNING: locally installed %s-%s conflicts on %s with:\n",
 				sqlite3_column_text(stmt_conflicts, 0),
 				sqlite3_column_text(stmt_conflicts, 1),
 				sqlite3_column_text(stmt, 0)
 				);
 		sbuf_printf(conflictmsg,
 		    "WARNING: locally installed %s-%s conflicts on %s with:\n",
 		    sqlite3_column_text(stmt_conflicts, 0),
 		    sqlite3_column_text(stmt_conflicts, 1),
 		    sqlite3_column_text(stmt, 0));
 		sqlite3_finalize(stmt_conflicts);
 		if (sqlite3_prepare_v2(db->sqlite, sql_conflicts, -1, &stmt_conflicts, NULL) != SQLITE_OK) {
 		ret = sqlite3_prepare_v2(db->sqlite, sql_conflicts, -1,
 		    &stmt_conflicts, NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(db->sqlite);
 			sqlite3_finalize(stmt);
 			sbuf_delete(conflictmsg);
 			return (EPKG_FATAL);
 		}
 		sqlite3_bind_text(stmt_conflicts, 1, sqlite3_column_text(stmt, 0), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_conflicts, 1,
 		    sqlite3_column_text(stmt, 0), -1, SQLITE_STATIC);
 		while (sqlite3_step(stmt_conflicts) != SQLITE_DONE) {
 			sbuf_printf(conflictmsg, "\t- %s-%s\n",
 					sqlite3_column_text(stmt_conflicts, 0),
 					sqlite3_column_text(stmt_conflicts, 1));
 			    sqlite3_column_text(stmt_conflicts, 0),
 			    sqlite3_column_text(stmt_conflicts, 1));
 		}
 		sqlite3_finalize(stmt_conflicts);
 		sbuf_finish(conflictmsg);
 		pkg_emit_error("%s", sbuf_get(conflictmsg));
 		ret = EPKG_FATAL;
 		retcode = EPKG_FATAL;
 	}
 	sqlite3_finalize(stmt);

@@ -3151,13 +3286,14 @@ pkgdb_integrity_check(struct pkgdb *db)

 /*	sql_exec(db->sqlite, "DROP TABLE IF EXISTS integritycheck");*/
 	return (ret);
 	return (retcode);
 }
 struct pkgdb_it *
 pkgdb_integrity_conflict_local(struct pkgdb *db, const char *origin)
 {
 	sqlite3_stmt *stmt;
 	int ret;
 	assert(db != NULL && origin != NULL);

@@ -3165,7 +3301,8 @@ pkgdb_integrity_conflict_local(struct pkgdb *db, const char *origin)

 		"FROM packages AS p, files AS f, integritycheck AS i "
 		"WHERE p.id = f.package_id AND f.path = i.path AND i.origin = ?1";
 	if (sqlite3_prepare_v2(db->sqlite, sql_conflicts, -1, &stmt, NULL) != SQLITE_OK) {
 	ret = sqlite3_prepare_v2(db->sqlite, sql_conflicts, -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		return (NULL);
 	}

@@ -3186,13 +3323,17 @@ pkgdb_vset(struct pkgdb *db, int64_t id, va_list ap)

 	/* Ensure there is an entry for each of the pkg_set_attr enum values */
 	const char *sql[PKG_SET_ORIGIN + 1] = {
 		[PKG_SET_FLATSIZE]  = "UPDATE packages SET flatsize=?1 WHERE id=?2",
 		[PKG_SET_AUTOMATIC] = "UPDATE packages SET automatic=?1 WHERE id=?2",
 		[PKG_SET_DEPORIGIN] = "UPDATE deps SET origin=?1, "
 					"name=(SELECT name FROM packages WHERE origin=?1), "
 					"version=(SELECT version FROM packages WHERE origin=?1), "
 					"WHERE package_id=?2 AND origin=?3",
 		[PKG_SET_ORIGIN]    = "UPDATE packages SET origin=?1 WHERE id=?2",
 		[PKG_SET_FLATSIZE]  =
 		    "UPDATE packages SET flatsize=?1 WHERE id=?2",
 		[PKG_SET_AUTOMATIC] =
 		    "UPDATE packages SET automatic=?1 WHERE id=?2",
 		[PKG_SET_DEPORIGIN] =
 		    "UPDATE deps SET origin=?1, "
 		    "name=(SELECT name FROM packages WHERE origin=?1), "
 		    "version=(SELECT version FROM packages WHERE origin=?1), "
 		    "WHERE package_id=?2 AND origin=?3",
 		[PKG_SET_ORIGIN]    =
 		    "UPDATE packages SET origin=?1 WHERE id=?2",
 	};
 	while ((attr = va_arg(ap, int)) > 0) {

@@ -3265,8 +3406,10 @@ pkgdb_file_set_cksum(struct pkgdb *db, struct pkg_file *file, const char *sha256

 	sqlite3_stmt *stmt = NULL;
 	const char sql_file_update[] = ""
 		"UPDATE files SET sha256=?1 WHERE path=?2";
 	int ret;
 	if (sqlite3_prepare_v2(db->sqlite, sql_file_update, -1, &stmt, NULL) != SQLITE_OK) {
 	ret = sqlite3_prepare_v2(db->sqlite, sql_file_update, -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		return (EPKG_FATAL);
 	}

@@ -3285,10 +3428,11 @@ pkgdb_file_set_cksum(struct pkgdb *db, struct pkg_file *file, const char *sha256

 }
 struct pkgdb_it *
 pkgdb_query_fetch(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs, const char *repo, int flags)
 pkgdb_query_fetch(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs,
     const char *repo, int flags)
 {
 	sqlite3_stmt *stmt = NULL;
 	int i = 0;
 	int i = 0, ret;
 	struct sbuf *sql = NULL;
 	const char *how = NULL;
 	const char *reponame = NULL;

@@ -3335,7 +3479,9 @@ pkgdb_query_fetch(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs, cons

 		sbuf_finish(sql);
 		for (i = 0; i < nbpkgs; i++) {
 			if (sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL) != SQLITE_OK) {
 			ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql),
 			    -1, &stmt, NULL);
 			if (ret != SQLITE_OK) {
 				ERROR_SQLITE(db->sqlite);
 				sbuf_delete(sql);
 				return (NULL);

@@ -3345,11 +3491,14 @@ pkgdb_query_fetch(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs, cons

 			/* report if package was not found in the database */
 			if (sqlite3_changes(db->sqlite) == 0)
 				pkg_emit_error("Package '%s' was not found in the repositories", pkgs[i]);
 				pkg_emit_error("Package '%s' was not found "
 				    "in the repositories", pkgs[i]);
 		}
 	} else {
 		sbuf_finish(sql);
 		if (sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL) != SQLITE_OK) {
 		ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1,
 		    &stmt, NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(db->sqlite);
 			sbuf_delete(sql);
 			return (NULL);

@@ -3384,7 +3533,8 @@ pkgdb_query_fetch(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs, cons

 	sbuf_printf(sql, finalsql, reponame);
 	sbuf_finish(sql);
 	if (sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL) != SQLITE_OK) {
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		sbuf_delete(sql);
 		return (NULL);

@@ -3396,7 +3546,10 @@ pkgdb_query_fetch(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs, cons

 	return (pkgdb_it_new(db, stmt, PKG_REMOTE));
 }
 /* create our custom functions in the sqlite3 connection. Used both in the shell and pkgdb_open */
 /*
  * create our custom functions in the sqlite3 connection.
  * Used both in the shell and pkgdb_open
  */
 static int
 sqlcmd_init(sqlite3 *db, __unused const char **err, __unused const void *noused)
 {

@@ -3450,7 +3603,8 @@ pkgdb_lock(struct pkgdb *db)

         assert(db != NULL);
 	assert(db->lock_count >= 0);
 	if (!(db->lock_count++))
 		return sql_exec(db->sqlite, "PRAGMA main.locking_mode=EXCLUSIVE;BEGIN IMMEDIATE;COMMIT;");
 		return sql_exec(db->sqlite,
 		    "PRAGMA main.locking_mode=EXCLUSIVE;BEGIN IMMEDIATE;COMMIT;");
 	else
 		return (EPKG_OK);
 }

@@ -3461,7 +3615,8 @@ pkgdb_unlock(struct pkgdb *db)

         assert(db != NULL);
 	assert(db->lock_count >= 1);
 	if (!(--db->lock_count))
 		return sql_exec(db->sqlite, "PRAGMA main.locking_mode=NORMAL;BEGIN IMMEDIATE;COMMIT;");
 		return sql_exec(db->sqlite,
 		    "PRAGMA main.locking_mode=NORMAL;BEGIN IMMEDIATE;COMMIT;");
 	else
 		return (EPKG_OK);
 }

@@ -3472,6 +3627,7 @@ pkgdb_stats(struct pkgdb *db, pkg_stats_t type)

 	sqlite3_stmt *stmt = NULL;
 	int64_t stats = 0;
 	struct sbuf *sql = NULL;
 	int ret;
 	assert(db != NULL);

@@ -3491,7 +3647,8 @@ pkgdb_stats(struct pkgdb *db, pkg_stats_t type)

 		sbuf_printf(sql, "(");
 		/* execute on all databases */
 		sql_on_all_attached_db(db->sqlite, sql, "SELECT origin AS c FROM '%1$s'.packages", " UNION ");
 		sql_on_all_attached_db(db->sqlite, sql,
 		    "SELECT origin AS c FROM '%1$s'.packages", " UNION ");
 		/* close parentheses for the compound statement */
 		sbuf_printf(sql, ");");

@@ -3503,7 +3660,8 @@ pkgdb_stats(struct pkgdb *db, pkg_stats_t type)

 		sbuf_printf(sql, "(");
 		/* execute on all databases */
 		sql_on_all_attached_db(db->sqlite, sql, "SELECT origin AS c FROM '%1$s'.packages", " UNION ALL ");
 		sql_on_all_attached_db(db->sqlite, sql,
 		    "SELECT origin AS c FROM '%1$s'.packages", " UNION ALL ");
 		/* close parentheses for the compound statement */
 		sbuf_printf(sql, ");");

@@ -3515,7 +3673,8 @@ pkgdb_stats(struct pkgdb *db, pkg_stats_t type)

 		sbuf_printf(sql, "(");
 		/* execute on all databases */
 		sql_on_all_attached_db(db->sqlite, sql, "SELECT flatsize AS s FROM '%1$s'.packages", " UNION ALL ");
 		sql_on_all_attached_db(db->sqlite, sql,
 		    "SELECT flatsize AS s FROM '%1$s'.packages", " UNION ALL ");
 		/* close parentheses for the compound statement */
 		sbuf_printf(sql, ");");

@@ -3527,14 +3686,16 @@ pkgdb_stats(struct pkgdb *db, pkg_stats_t type)

 		sbuf_printf(sql, "(");
 		/* execute on all databases */
 		sql_on_all_attached_db(db->sqlite, sql, "SELECT '%1$s' AS c", " UNION ALL ");
 		sql_on_all_attached_db(db->sqlite, sql,
 		    "SELECT '%1$s' AS c", " UNION ALL ");
 		/* close parentheses for the compound statement */
 		sbuf_printf(sql, ");");
 		break;
 	}
 	if (sqlite3_prepare_v2(db->sqlite, sbuf_data(sql), -1, &stmt, NULL) != SQLITE_OK) {
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_data(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		sbuf_free(sql);
 		ERROR_SQLITE(db->sqlite);
 		return (-1);

modified libpkg/rcscripts.c

@@ -94,7 +94,8 @@ rc_stop(const char *rc_file)

 			fd = open("/dev/null", O_WRONLY);
 			dup2(fd, STDERR_FILENO);
 			dup2(fd, STDOUT_FILENO);
 			execl("/usr/sbin/service", "service", rc_file, "onestatus", (char *)NULL);
 			execl("/usr/sbin/service", "service", rc_file,
 			    "onestatus", (char *)NULL);
 			_exit(1);
 			/* NOT REACHED */
 		default:

@@ -115,7 +116,8 @@ rc_stop(const char *rc_file)

 			return (-1);
 		case 0:
 			/* child */
 			execl("/usr/sbin/service", "service", rc_file, "stop", (char *)NULL);
 			execl("/usr/sbin/service", "service",
 			    rc_file, "stop", (char *)NULL);
 			_exit(1);
 			/* NOT REACHED */
 		default:

@@ -145,7 +147,8 @@ rc_start(const char *rc_file)

 			return (-1);
 		case 0:
 			/* child */
 			execl("/usr/sbin/service", "service", rc_file, "quietstart", (char *)NULL);
 			execl("/usr/sbin/service", "service", rc_file,
 			    "quietstart", (char *)NULL);
 			_exit(1);
 			/* NOT REACHED */
 		default:

modified libpkg/rsa.c

@@ -48,7 +48,8 @@ _load_rsa_private_key(char *rsa_key_path, pem_password_cb *password_cb)

 		return (NULL);
 	}
 	if ((rsa = PEM_read_RSAPrivateKey(fp, 0, password_cb, rsa_key_path)) == NULL) {
 	rsa = PEM_read_RSAPrivateKey(fp, 0, password_cb, rsa_key_path);
 	if (rsa == NULL) {
 		fclose(fp);
 		return (NULL);
 	}

@@ -71,7 +72,7 @@ _load_rsa_public_key(const char *rsa_key_path)

 	if (!PEM_read_RSA_PUBKEY(fp, &rsa, NULL, NULL)) {
 		pkg_emit_error("error reading public key(%s): %s", rsa_key_path,
 					   ERR_error_string(ERR_get_error(), errbuf));
 		    ERR_error_string(ERR_get_error(), errbuf));
 		fclose(fp);
 		return (NULL);
 	}

@@ -81,11 +82,13 @@ _load_rsa_public_key(const char *rsa_key_path)

 }
 int
 rsa_verify(const char *path, const char *key, unsigned char *sig, unsigned int sig_len)
 rsa_verify(const char *path, const char *key, unsigned char *sig,
     unsigned int sig_len)
 {
 	char sha256[SHA256_DIGEST_LENGTH *2 +1];
 	char errbuf[1024];
 	RSA *rsa = NULL;
 	int ret;
 	sha256_file(path, sha256);

@@ -97,9 +100,10 @@ rsa_verify(const char *path, const char *key, unsigned char *sig, unsigned int s

 	if (rsa == NULL)
 		return(EPKG_FATAL);
 	if (RSA_verify(NID_sha1, sha256, sizeof(sha256), sig, sig_len, rsa) == 0) {
 	ret = RSA_verify(NID_sha1, sha256, sizeof(sha256), sig, sig_len, rsa);
 	if (ret == 0) {
 		pkg_emit_error("%s: %s", key,
 					   ERR_error_string(ERR_get_error(), errbuf));
 		    ERR_error_string(ERR_get_error(), errbuf));
 		return (EPKG_FATAL);
 	}

@@ -114,7 +118,7 @@ rsa_sign(char *path, pem_password_cb *password_cb, char *rsa_key_path,

 		unsigned char **sigret, unsigned int *siglen)
 {
 	char errbuf[1024];
 	int max_len = 0;
 	int max_len = 0, ret;
 	RSA *rsa = NULL;
 	char sha256[SHA256_DIGEST_LENGTH * 2 +1];

@@ -139,7 +143,8 @@ rsa_sign(char *path, pem_password_cb *password_cb, char *rsa_key_path,

 	sha256_file(path, sha256);
 	if (RSA_sign(NID_sha1, sha256, sizeof(sha256), *sigret, siglen, rsa) == 0) {
 	ret = RSA_sign(NID_sha1, sha256, sizeof(sha256), *sigret, siglen, rsa);
 	if (ret == 0) {
 		/* XXX pass back RSA errors correctly */
 		pkg_emit_error("%s: %s", rsa_key_path,
 					   ERR_error_string(ERR_get_error(), errbuf));

modified libpkg/update.c

@@ -76,7 +76,7 @@ pkg_update(const char *name, const char *packagesite, bool force)

 	const char *repokey;
 	unsigned char *sig = NULL;
 	int siglen = 0;
 	int rc = EPKG_FATAL;
 	int rc = EPKG_FATAL, ret;
 	struct stat st;
 	time_t t = 0;

@@ -84,7 +84,8 @@ pkg_update(const char *name, const char *packagesite, bool force)

 	(void)strlcpy(tmp, "/tmp/repo.txz.XXXXXX", sizeof(tmp));
 	if (mktemp(tmp) == NULL) {
 		pkg_emit_error("Could not create temporary file %s, aborting update.\n", tmp);
 		pkg_emit_error("Could not create temporary file %s, "
 		    "aborting update.\n", tmp);
 		return (EPKG_FATAL);
 	}

@@ -123,7 +124,8 @@ pkg_update(const char *name, const char *packagesite, bool force)

 	while (archive_read_next_header(a, &ae) == ARCHIVE_OK) {
 		if (strcmp(archive_entry_pathname(ae), "repo.sqlite") == 0) {
 			snprintf(repofile_unchecked, sizeof(repofile_unchecked), "%s.unchecked", repofile);
 			snprintf(repofile_unchecked, sizeof(repofile_unchecked),
 			    "%s.unchecked", repofile);
 			archive_entry_set_pathname(ae, repofile_unchecked);
 			/*

@@ -147,16 +149,19 @@ pkg_update(const char *name, const char *packagesite, bool force)

 	if (repokey != NULL) {
 		if (sig != NULL) {
 			if (rsa_verify(repofile_unchecked, repokey, sig, siglen - 1) != EPKG_OK) {
 				pkg_emit_error("Invalid signature, removing repository.\n");
 			ret = rsa_verify(repofile_unchecked, repokey,
 			    sig, siglen - 1);
 			if (ret != EPKG_OK) {
 				pkg_emit_error("Invalid signature, "
 				    "removing repository.\n");
 				unlink(repofile_unchecked);
 				free(sig);
 				rc = EPKG_FATAL;
 				goto cleanup;
 			}
 		} else {
 			pkg_emit_error("No signature found in the repository."
 						   "Can not validate against %s key.", repokey);
 			pkg_emit_error("No signature found in the repository.  "
 			    "Can not validate against %s key.", repokey);
 			rc = EPKG_FATAL;
 			unlink(repofile_unchecked);
 			goto cleanup;

modified libpkg/usergroup.c

@@ -147,7 +147,8 @@ pkg_add_user_group(struct pkg *pkg)

 			pw_fini();
 		}
 		pw_fini();
 		if (strcmp(pw->pw_dir, "/nonexistent") && strcmp(pw->pw_dir, "/var/empty")) {
 		if (strcmp(pw->pw_dir, "/nonexistent") &&
 		    strcmp(pw->pw_dir, "/var/empty")) {
 			/* now create the homedir if it doesn't exists */
 			/* TODO: do it recursively */
 			mkdir(pw->pw_dir, 0644);

@@ -176,30 +177,37 @@ pkg_add_user_group(struct pkg *pkg)

 		for (i = 0; gr->gr_mem[i] != NULL; i++) {
 			while (pkg_users(pkg, &u) == EPKG_OK) {
 				if (!strcmp(pkg_user_name(u), gr->gr_mem[i])) {
 					/* check if the user is not already in the local group */
 					for (j = 0; grlocal->gr_mem[j] != NULL; j++) {
 						if (!strcmp(grlocal->gr_mem[j], gr->gr_mem[i]))
 							break;
 					}
 					if (grlocal->gr_mem[j] != NULL)
 						continue; /* already in the group */
 					/* adding the user to the group */
 					if (grnew == NULL) {
 						nx = j - 1;
 						grnew = gr_dup(grlocal);
 					}
 					if (nx == 0)
 						grnew->gr_mem = NULL;
 					nx++;
 					grnew->gr_mem = reallocf(grnew->gr_mem, sizeof(*grnew->gr_mem) * (nx + 1));
 					grnew->gr_mem[nx - 1] = __DECONST(char *, pkg_user_name(u));
 					grnew->gr_mem[nx] = NULL;
 				if (strcmp(pkg_user_name(u), gr->gr_mem[i]))
 					continue;
 				/*
 				 * check if the user is not already in the
 				 * local group
 				 */
 				for (j = 0; grlocal->gr_mem[j] != NULL; j++) {
 					if (!strcmp(grlocal->gr_mem[j],
 					    gr->gr_mem[i]))
 						break;
 				}
 				if (grlocal->gr_mem[j] != NULL)
 					continue; /* already in the group */
 				/* adding the user to the group */
 				if (grnew == NULL) {
 					nx = j - 1;
 					grnew = gr_dup(grlocal);
 				}
 				if (nx == 0)
 					grnew->gr_mem = NULL;
 				nx++;
 				grnew->gr_mem = reallocf(grnew->gr_mem,
 				    sizeof(*grnew->gr_mem) * (nx + 1));
 				grnew->gr_mem[nx - 1] =
 				    __DECONST(char *, pkg_user_name(u));
 				grnew->gr_mem[nx] = NULL;
 			}
 		}
 		if (grnew == NULL) {

modified libpkg/utils.c

@@ -175,80 +175,88 @@ file_to_buffer(const char *path, char **buffer, off_t *sz)

 }
 int
 format_exec_cmd(char **dest, const char *in, const char *prefix, const char *plist_file, char *line)
 format_exec_cmd(char **dest, const char *in, const char *prefix,
     const char *plist_file, char *line)
 {
 	struct sbuf *buf = sbuf_new_auto();
 	char path[MAXPATHLEN + 1];
 	char *cp;
 	while (in[0] != '\0') {
 		if (in[0] == '%') {
 		if (in[0] != '%') {
 			sbuf_putc(buf, in[0]);
 			in++;
 			switch(in[0]) {
 				case 'D':
 					sbuf_cat(buf, prefix);
 					break;
 				case 'F':
 					if (plist_file == NULL) {
 						pkg_emit_error("No files defined %%F couldn't be expanded, ignoring %s", in);
 						sbuf_finish(buf);
 						sbuf_free(buf);
 						return (EPKG_FATAL);
 					}
 					sbuf_cat(buf, plist_file);
 					break;
 				case 'f':
 					if (plist_file == NULL) {
 						pkg_emit_error("No files defined %%f couldn't be expanded, ignoring %s", in);
 						sbuf_finish(buf);
 						sbuf_free(buf);
 						return (EPKG_FATAL);
 					}
 					if (prefix[strlen(prefix) - 1] == '/')
 						snprintf(path, sizeof(path), "%s%s", prefix, plist_file);
 					else
 						snprintf(path, sizeof(path), "%s/%s", prefix, plist_file);
 					cp = strrchr(path, '/');
 					cp ++;
 					sbuf_cat(buf, cp);
 					break;
 				case 'B':
 					if (plist_file == NULL) {
 						pkg_emit_error("No files defined %%B couldn't be expanded, ignoring %s", in);
 						sbuf_finish(buf);
 						sbuf_free(buf);
 						return (EPKG_FATAL);
 					}
 					if (prefix[strlen(prefix) - 1] == '/')
 						snprintf(path, sizeof(path), "%s%s", prefix, plist_file);
 					else
 						snprintf(path, sizeof(path), "%s/%s", prefix, plist_file);
 					cp = strrchr(path, '/');
 					cp[0] = '\0';
 					sbuf_cat(buf, path);
 					break;
 				case '%':
 					sbuf_putc(buf, '%');
 					break;
 				case '@':
 					if (line != NULL) {
 						sbuf_cat(buf, line);
 						break;
 					}
 					/*
 					 * no break here because if line is not
 					 * given (default exec) %@ does not
 					 * exists
 					 */
 				default:
 					sbuf_putc(buf, '%');
 					sbuf_putc(buf, in[0]);
 					break;
 			continue;
 		}
 		in++;
 		switch(in[0]) {
 		case 'D':
 			sbuf_cat(buf, prefix);
 			break;
 		case 'F':
 			if (plist_file == NULL) {
 				pkg_emit_error("No files defined %%F couldn't "
 				    "be expanded, ignoring %s", in);
 				sbuf_finish(buf);
 				sbuf_free(buf);
 				return (EPKG_FATAL);
 			}
 			sbuf_cat(buf, plist_file);
 			break;
 		case 'f':
 			if (plist_file == NULL) {
 				pkg_emit_error("No files defined %%f couldn't "
 				    "be expanded, ignoring %s", in);
 				sbuf_finish(buf);
 				sbuf_free(buf);
 				return (EPKG_FATAL);
 			}
 			if (prefix[strlen(prefix) - 1] == '/')
 				snprintf(path, sizeof(path), "%s%s",
 				    prefix, plist_file);
 			else
 				snprintf(path, sizeof(path), "%s/%s",
 				    prefix, plist_file);
 			cp = strrchr(path, '/');
 			cp ++;
 			sbuf_cat(buf, cp);
 			break;
 		case 'B':
 			if (plist_file == NULL) {
 				pkg_emit_error("No files defined %%B couldn't "
 				    "be expanded, ignoring %s", in);
 				sbuf_finish(buf);
 				sbuf_free(buf);
 				return (EPKG_FATAL);
 			}
 			if (prefix[strlen(prefix) - 1] == '/')
 				snprintf(path, sizeof(path), "%s%s", prefix,
 				    plist_file);
 			else
 				snprintf(path, sizeof(path), "%s/%s", prefix,
 				    plist_file);
 			cp = strrchr(path, '/');
 			cp[0] = '\0';
 			sbuf_cat(buf, path);
 			break;
 		case '%':
 			sbuf_putc(buf, '%');
 			break;
 		case '@':
 			if (line != NULL) {
 				sbuf_cat(buf, line);
 				break;
 			}
 		} else {
 			/*
 			 * no break here because if line is not
 			 * given (default exec) %@ does not
 			 * exists
 			 */
 		default:
 			sbuf_putc(buf, '%');
 			sbuf_putc(buf, in[0]);
 			break;
 		}
 		in++;

@@ -287,7 +295,8 @@ is_dir(const char *path)

 }
 static void
 sha256_hash(unsigned char hash[SHA256_DIGEST_LENGTH], char out[SHA256_DIGEST_LENGTH * 2 + 1])
 sha256_hash(unsigned char hash[SHA256_DIGEST_LENGTH],
     char out[SHA256_DIGEST_LENGTH * 2 + 1])
 {
 	int i;
 	for (i = 0; i < SHA256_DIGEST_LENGTH; i++)