 @@ -1,1386 +1,1436 @@
-/*	$NetBSD: perform.c,v 1.70.4.19 2008/08/25 19:15:11 joerg Exp $	*/
+/*	$NetBSD: perform.c,v 1.70.4.20 2009/01/08 00:01:30 joerg Exp $	*/
 #if HAVE_CONFIG_H
 #include "config.h"
 #endif
 #include <nbcompat.h>
 #if HAVE_SYS_CDEFS_H
 #include <sys/cdefs.h>
 #endif
-__RCSID("$NetBSD: perform.c,v 1.70.4.19 2008/08/25 19:15:11 joerg Exp $");
+__RCSID("$NetBSD: perform.c,v 1.70.4.20 2009/01/08 00:01:30 joerg Exp $");
 /*-
  * Copyright (c) 2003 Grant Beattie <grant@NetBSD.org>
  * Copyright (c) 2005 Dieter Baron <dillo@NetBSD.org>
  * Copyright (c) 2007 Roland Illig <rillig@NetBSD.org>
- * Copyright (c) 2008 Joerg Sonnenberger <joerg@NetBSD.org>
+ * Copyright (c) 2008, 2009 Joerg Sonnenberger <joerg@NetBSD.org>
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
+ *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/utsname.h>
 #if HAVE_ERR_H
 #include <err.h>
 #endif
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <archive.h>
 #include <archive_entry.h>
 #include "lib.h"
 #include "add.h"
 struct pkg_meta {
 	char *meta_contents;
 	char *meta_comment;
 	char *meta_desc;
 	char *meta_mtree;
 	char *meta_build_version;
 	char *meta_build_info;
 	char *meta_size_pkg;
 	char *meta_size_all;
 	char *meta_required_by;
 	char *meta_display;
 	char *meta_install;
 	char *meta_deinstall;
 	char *meta_preserve;
 	char *meta_views;
 	char *meta_installed_info;
 };
 struct pkg_task {
 	char *pkgname;
 	const char *prefix;
 	char *install_prefix;
 	char *logdir;
 	char *install_logdir;
 	char *other_version;
 	package_t plist;
 	struct pkg_meta meta_data;
 	struct archive *archive;
 	struct archive_entry *entry;
 	char *buildinfo[BI_ENUM_COUNT];
 	size_t dep_length, dep_allocated;
 	char **dependencies;
 };
 static const struct pkg_meta_desc {
 	size_t entry_offset;
 	const char *entry_filename;
 	int required_file;
 	mode_t perm;
 } pkg_meta_descriptors[] = {
 	{ offsetof(struct pkg_meta, meta_contents), CONTENTS_FNAME, 1, 0644 },
 	{ offsetof(struct pkg_meta, meta_comment), COMMENT_FNAME, 1, 0444},
 	{ offsetof(struct pkg_meta, meta_desc), DESC_FNAME, 1, 0444},
 	{ offsetof(struct pkg_meta, meta_install), INSTALL_FNAME, 0, 0555 },
 	{ offsetof(struct pkg_meta, meta_deinstall), DEINSTALL_FNAME, 0, 0555 },
 	{ offsetof(struct pkg_meta, meta_display), DISPLAY_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_mtree), MTREE_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_build_version), BUILD_VERSION_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_build_info), BUILD_INFO_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_size_pkg), SIZE_PKG_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_size_all), SIZE_ALL_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_preserve), PRESERVE_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_views), VIEWS_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_required_by), REQUIRED_BY_FNAME, 0, 0644 },
 	{ offsetof(struct pkg_meta, meta_installed_info), INSTALLED_INFO_FNAME, 0, 0644 },
 	{ 0, NULL, 0 },
 };
 static int pkg_do(const char *, int);
 static int
 mkdir_p(const char *path)
+{
 	char *p, *cur_end;
 	int done;
 	/*
 	 * Handle the easy case of direct success or
 	 * pre-existing directory first.
 	 */
 	if (mkdir(path, 0777) == 0 || errno == EEXIST)
 		return 0;
 	if (errno != ENOENT)
 		return -1;
 	cur_end = p = xstrdup(path);
 	for (;;) {
 		/*
 		 * First skip leading slashes either from / or
 		 * from the last iteration.
 		 */
 		cur_end += strspn(cur_end, "/");
 		/* Find end of actual directory name. */
 		cur_end += strcspn(cur_end, "/");
 		/*
 		 * Remember if this is the last component and
 		 * overwrite / if needed.
 		 */
 		done = (*cur_end == '\0');
 		*cur_end = '\0';
 		/*
 		 * ENOENT can only happen if something else races us,
 		 * in which case we should better give up.
 		 */
 		if (mkdir(p, 0777) == -1 && errno != EEXIST) {
 			free(p);
 			return -1;
+		}
 		if (done)
 			break;
 		*cur_end = '/';
+	}
 	free(p);
 	return 0;
+}
 /*
  * Read meta data from archive.
  * Bail out if a required entry is missing or entries are in the wrong order.
  */
 static int
 read_meta_data(struct pkg_task *pkg)
+{
 	const struct pkg_meta_desc *descr, *last_descr;
 	const char *fname;
 	char **target;
 	int64_t size;
 	int r, found_required;
 	found_required = 0;
 	r = ARCHIVE_OK;
 	last_descr = 0;
 	if (pkg->entry != NULL)
 		goto skip_header;
 	for (;;) {
 		r = archive_read_next_header(pkg->archive, &pkg->entry);
 		if (r != ARCHIVE_OK)
 				break;
 skip_header:
 		fname = archive_entry_pathname(pkg->entry);
 		for (descr = pkg_meta_descriptors; descr->entry_filename;
 		     ++descr) {
 			if (strcmp(descr->entry_filename, fname) == 0)
 				break;
+		}
 		if (descr->entry_filename == NULL)
 			break;
 		if (descr->required_file)
 			++found_required;
 		target = (char **)((char *)&pkg->meta_data +
 		    descr->entry_offset);
 		if (*target) {
 			warnx("duplicate entry, package corrupt");
 			return -1;
+		}
 		if (descr < last_descr) {
 			warnx("misordered package");
 			return -1;
+		}
 		last_descr = descr;
 		size = archive_entry_size(pkg->entry);
 		if (size > SSIZE_MAX - 1) {
 			warnx("package meta data too large to process");
 			return -1;
+		}
 		*target = xmalloc(size + 1);
 		if (archive_read_data(pkg->archive, *target, size) != size) {
 			warnx("cannot read package meta data");
 			return -1;
+		}
 		(*target)[size] = '\0';
+	}
 	if (r != ARCHIVE_OK)
 		pkg->entry = NULL;
 	if (r == ARCHIVE_EOF)
 		r = ARCHIVE_OK;
 	for (descr = pkg_meta_descriptors; descr->entry_filename; ++descr) {
 		if (descr->required_file)
 			--found_required;
+	}
 	return !found_required && r == ARCHIVE_OK ? 0 : -1;
+}
 /*
  * Free meta data.
  */
 static void
 free_meta_data(struct pkg_task *pkg)
+{
 	const struct pkg_meta_desc *descr;
 	char **target;
 	for (descr = pkg_meta_descriptors; descr->entry_filename; ++descr) {
 		target = (char **)((char *)&pkg->meta_data +
 		    descr->entry_offset);
 		free(*target);
 		*target = NULL;
+	}
+}
 /*
  * Parse PLIST and populate pkg.
  */
 static int
 pkg_parse_plist(struct pkg_task *pkg)
+{
 	plist_t *p;
 	parse_plist(&pkg->plist, pkg->meta_data.meta_contents);
 	if ((p = find_plist(&pkg->plist, PLIST_NAME)) == NULL) {
 		warnx("Invalid PLIST: missing @name");
 		return -1;
+	}
 	if (pkg->pkgname == NULL)
 		pkg->pkgname = xstrdup(p->name);
 	else if (strcmp(pkg->pkgname, p->name) != 0) {
 		warnx("Signature and PLIST differ on package name");
 		return -1;
+	}
 	if ((p = find_plist(&pkg->plist, PLIST_CWD)) == NULL) {
 		warnx("Invalid PLIST: missing @cwd");
 		return -1;
+	}
 	if (Prefix != NULL &&
 	    strcmp(p->name, Prefix) != 0) {
 		size_t len;
 		delete_plist(&pkg->plist, FALSE, PLIST_CWD, NULL);
 		add_plist_top(&pkg->plist, PLIST_CWD, Prefix);
 		free(pkg->meta_data.meta_contents);
 		stringify_plist(&pkg->plist, &pkg->meta_data.meta_contents, &len,
 		    Prefix);
 		pkg->prefix = Prefix;
 	} else
 		pkg->prefix = p->name;
 	if (Destdir != NULL)
 		pkg->install_prefix = xasprintf("%s/%s", Destdir, pkg->prefix);
 	else
 		pkg->install_prefix = xstrdup(pkg->prefix);
 	return 0;
+}
 /*
  * Helper function to extract value from a string of the
  * form key=value ending at eol.
  */
 static char *
 dup_value(const char *line, const char *eol)
+{
 	const char *key;
 	char *val;
 	key = strchr(line, '=');
 	val = xmalloc(eol - key);
 	memcpy(val, key + 1, eol - key - 1);
 	val[eol - key - 1] = '\0';
 	return val;
+}
 static int
 check_already_installed(struct pkg_task *pkg)
+{
 	char *filename;
 	int fd;
 	if (Force)
 		return -1;
 	filename = pkgdb_pkg_file(pkg->pkgname, CONTENTS_FNAME);
 	fd = open(filename, O_RDONLY);
 	free(filename);
 	if (fd == -1)
 		return -1;
 	/* We can only arrive here for explicitly requested packages. */
 	if (!Automatic && is_automatic_installed(pkg->pkgname)) {
 		if (Fake ||
 		    mark_as_automatic_installed(pkg->pkgname, 0) == 0)
 			warnx("package `%s' was already installed as "
 			      "dependency, now marked as installed "
 			      "manually", pkg->pkgname);
 	} else {
 		warnx("package `%s' already recorded as installed",
 		      pkg->pkgname);
+	}
 	return 0;
+}
 static int
 check_other_installed(struct pkg_task *pkg)
+{
 	FILE *f, *f_pkg;
 	size_t len;
 	char *pkgbase, *iter, *filename;
 	package_t plist;
 	plist_t *p;
 	int status;
 	pkgbase = xstrdup(pkg->pkgname);
 	if ((iter = strrchr(pkgbase, '-')) == NULL) {
 		free(pkgbase);
 		warnx("Invalid package name %s", pkg->pkgname);
 		return -1;
+	}
 	*iter = '\0';
 	pkg->other_version = find_best_matching_installed_pkg(pkgbase);
 	free(pkgbase);
 	if (pkg->other_version == NULL)
 		return 0;
 	if (!Replace) {
 		/* XXX This is redundant to the implicit conflict check. */
 		warnx("A different version of %s is already installed: %s",
 		    pkg->pkgname, pkg->other_version);
 		return -1;
+	}
 	filename = pkgdb_pkg_file(pkg->other_version, REQUIRED_BY_FNAME);
 	errno = 0;
 	f = fopen(filename, "r");
 	free(filename);
 	if (f == NULL) {
 		if (errno == ENOENT) {
 			/* No packages depend on this, so everything is well. */
 			return 0;
+		}
 		warnx("Can't open +REQUIRED_BY of %s", pkg->other_version);
 		return -1;
+	}
 	status = 0;
 	while ((iter = fgetln(f, &len)) != NULL) {
 		if (iter[len - 1] == '\n')
 			iter[len - 1] = '\0';
 		filename = pkgdb_pkg_file(iter, CONTENTS_FNAME);
 		if ((f_pkg = fopen(filename, "r")) == NULL) {
 			warnx("Can't open +CONTENTS of depending package %s",
 			    iter);
 			fclose(f);
 			return -1;
+		}
 		read_plist(&plist, f_pkg);
 		fclose(f_pkg);
 		for (p = plist.head; p != NULL; p = p->next) {
 			if (p->type == PLIST_IGNORE) {
 				p = p->next;
 				continue;
 			} else if (p->type != PLIST_PKGDEP)
 				continue;
 			/*
 			 * XXX This is stricter than necessary.
 			 * XXX One pattern might be fulfilled by
 			 * XXX a different package and still need this
 			 * XXX one for a different pattern.
 			 */
 			if (pkg_match(p->name, pkg->other_version) == 0)
 				continue;
 			if (pkg_match(p->name, pkg->pkgname) == 1)
 				continue; /* Both match, ok. */
 			warnx("Dependency of %s fulfilled by %s, but not by %s",
 			    iter, pkg->other_version, pkg->pkgname);
 			if (!Force)
 				status = -1;
 			break;
+		}
 		free_plist(&plist);
+	}
 	fclose(f);
 	return status;
+}
 /*
  * Read package build information from meta data.
  */
 static int
 read_buildinfo(struct pkg_task *pkg)
+{
 	const char *data, *eol, *next_line;
 	data = pkg->meta_data.meta_build_info;
 	for (; *data != '\0'; data = next_line) {
 		if ((eol = strchr(data, '\n')) == NULL) {
 			eol = data + strlen(data);
 			next_line = eol;
 		} else
 			next_line = eol + 1;
 		if (strncmp(data, "OPSYS=", 6) == 0)
 			pkg->buildinfo[BI_OPSYS] = dup_value(data, eol);
 		else if (strncmp(data, "OS_VERSION=", 11) == 0)
 			pkg->buildinfo[BI_OS_VERSION] = dup_value(data, eol);
 		else if (strncmp(data, "MACHINE_ARCH=", 13) == 0)
 			pkg->buildinfo[BI_MACHINE_ARCH] = dup_value(data, eol);
 		else if (strncmp(data, "IGNORE_RECOMMENDED=", 19) == 0)
 			pkg->buildinfo[BI_IGNORE_RECOMMENDED] = dup_value(data,
 			    eol);
 		else if (strncmp(data, "USE_ABI_DEPENDS=", 16) == 0)
 			pkg->buildinfo[BI_USE_ABI_DEPENDS] = dup_value(data,
 			    eol);
+	}
 	if (pkg->buildinfo[BI_OPSYS] == NULL ||
 	    pkg->buildinfo[BI_OS_VERSION] == NULL ||
 	    pkg->buildinfo[BI_MACHINE_ARCH] == NULL) {
 		warnx("Not all required build information are present.");
 		return -1;
+	}
 	if ((pkg->buildinfo[BI_USE_ABI_DEPENDS] != NULL &&
 	    strcasecmp(pkg->buildinfo[BI_USE_ABI_DEPENDS], "YES") != 0) ||
 	    (pkg->buildinfo[BI_IGNORE_RECOMMENDED] != NULL &&
 	    strcasecmp(pkg->buildinfo[BI_IGNORE_RECOMMENDED], "NO") != 0)) {
 		warnx("%s was built to ignore ABI dependencies", pkg->pkgname);
+	}
 	return 0;
+}
 /*
  * Free buildinfo.
  */
 static void
 free_buildinfo(struct pkg_task *pkg)
+{
 	size_t i;
 	for (i = 0; i < BI_ENUM_COUNT; ++i) {
 		free(pkg->buildinfo[i]);
 		pkg->buildinfo[i] = NULL;
+	}
+}
 /*
  * Write meta data files to pkgdb after creating the directory.
  */
 static int
 write_meta_data(struct pkg_task *pkg)
+{
 	const struct pkg_meta_desc *descr;
 	char *filename, **target;
 	size_t len;
 	ssize_t ret;
 	int fd;
 	if (Fake)
 		return 0;
 	if (mkdir_p(pkg->install_logdir)) {
 		warn("Can't create pkgdb entry: %s", pkg->install_logdir);
 		return -1;
+	}
 	for (descr = pkg_meta_descriptors; descr->entry_filename; ++descr) {
 		target = (char **)((char *)&pkg->meta_data +
 		    descr->entry_offset);
 		if (*target == NULL)
 			continue;
 		filename = xasprintf("%s/%s", pkg->install_logdir,
 		    descr->entry_filename);
 		(void)unlink(filename);
 		fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT, descr->perm);
 		if (fd == -1) {
 			warn("Can't open meta data file: %s", filename);
 			return -1;
+		}
 		len = strlen(*target);
 		do {
 			ret = write(fd, *target, len);
 			if (ret == -1) {
 				warn("Can't write meta data file: %s",
 				    filename);
 				free(filename);
 				return -1;
+			}
 			len -= ret;
 		} while (ret > 0);
 		if (close(fd) == -1) {
 			warn("Can't close meta data file: %s", filename);
 			free(filename);
 			return -1;
+		}
 		free(filename);
+	}
 	return 0;
+}
 /*
  * Helper function for extract_files.
  */
 static int
 copy_data_to_disk(struct archive *reader, struct archive *writer,
     const char *filename)
+{
 	int r;
 	const void *buff;
 	size_t size;
 	off_t offset;
 	for (;;) {
 		r = archive_read_data_block(reader, &buff, &size, &offset);
 		if (r == ARCHIVE_EOF)
 			return 0;
 		if (r != ARCHIVE_OK) {
 			warnx("Read error for %s: %s", filename,
 			    archive_error_string(reader));
 			return -1;
+		}
 		r = archive_write_data_block(writer, buff, size, offset);
 		if (r != ARCHIVE_OK) {
 			warnx("Write error for %s: %s", filename,
 			    archive_error_string(writer));
 			return -1;
+		}
+	}
+}
 /*
  * Extract package.
  * Any misordered, missing or unlisted file in the package is an error.
  */
 static const int extract_flags = /* ARCHIVE_EXTRACT_OWNER | */
     ARCHIVE_EXTRACT_PERM | ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_UNLINK |
     ARCHIVE_EXTRACT_ACL | ARCHIVE_EXTRACT_FFLAGS | ARCHIVE_EXTRACT_XATTR;
 static int
 extract_files(struct pkg_task *pkg)
+{
 	char    cmd[MaxPathSize];
 	const char *owner, *group, *permissions;
 	struct archive *writer;
 	int r;
 	plist_t *p;
 	const char *last_file;
 	char *fullpath;
 	if (Fake)
 		return 0;
 	if (mkdir_p(pkg->install_prefix)) {
 		warn("Can't create prefix: %s", pkg->install_prefix);
 		return -1;
+	}
 	if (!NoRecord && !pkgdb_open(ReadWrite)) {
 		warn("Can't open pkgdb for writing");
 		return -1;
+	}
 	if (chdir(pkg->install_prefix) == -1) {
 		warn("Can't change into prefix: %s", pkg->install_prefix);
 		return -1;
+	}
 	writer = archive_write_disk_new();
 	archive_write_disk_set_options(writer, extract_flags);
 	archive_write_disk_set_standard_lookup(writer);
 	owner = NULL;
 	group = NULL;
 	permissions = NULL;
 	last_file = NULL;
 	r = -1;
 	for (p = pkg->plist.head; p != NULL; p = p->next) {
 		switch (p->type) {
 		case PLIST_FILE:
 			last_file = p->name;
 			if (pkg->entry == NULL) {
 				warnx("PLIST entry not in package (%s)",
 				    archive_entry_pathname(pkg->entry));
 				goto out;
+			}
 			if (strcmp(p->name, archive_entry_pathname(pkg->entry))) {
 				warnx("PLIST entry and package don't match (%s vs %s)",
 				    p->name, archive_entry_pathname(pkg->entry));
 				goto out;
+			}
 			fullpath = xasprintf("%s/%s", pkg->prefix, p->name);
 			pkgdb_store(fullpath, pkg->pkgname);
 			free(fullpath);
 			if (Verbose)
 				printf("%s", p->name);
 			break;
 		case PLIST_CMD:
 			if (format_cmd(cmd, sizeof(cmd), p->name, pkg->prefix, last_file))
 				return -1;
 			printf("Executing '%s'\n", cmd);
 			if (!Fake && system(cmd))
 				warnx("command '%s' failed", cmd); /* XXX bail out? */
 			continue;
 		case PLIST_CHMOD:
 			permissions = p->name;
 			continue;
 		case PLIST_CHOWN:
 			owner = p->name;
 			continue;
 		case PLIST_CHGRP:
 			group = p->name;
 			continue;
 		case PLIST_IGNORE:
 			p = p->next;
 			continue;
 		default:
 			continue;
+		}
 		r = archive_write_header(writer, pkg->entry);
 		if (r != ARCHIVE_OK) {
 			warnx("Failed to write %s: %s",
 			    archive_entry_pathname(pkg->entry),
 			    archive_error_string(writer));
 			goto out;
+		}
 		if (owner != NULL)
 			archive_entry_set_uname(pkg->entry, owner);
 		if (group != NULL)
 			archive_entry_set_uname(pkg->entry, group);
 		if (permissions != NULL) {
 			mode_t mode;
 			mode = archive_entry_mode(pkg->entry);
 			mode = getmode(setmode(permissions), mode);
 			archive_entry_set_mode(pkg->entry, mode);
+		}
 		r = copy_data_to_disk(pkg->archive, writer,
 		    archive_entry_pathname(pkg->entry));
 		if (r)
 			goto out;
 		if (Verbose)
 			printf("\n");
 		r = archive_read_next_header(pkg->archive, &pkg->entry);
 		if (r == ARCHIVE_EOF) {
 			pkg->entry = NULL;
 			continue;
+		}
 		if (r != ARCHIVE_OK) {
 			warnx("Failed to read from archive: %s",
 			    archive_error_string(pkg->archive));
 			goto out;
+		}
+	}
 	if (pkg->entry != NULL) {
 		warnx("Package contains entries not in PLIST: %s",
 		    archive_entry_pathname(pkg->entry));
 		goto out;
+	}
 	r = 0;
 out:
 	if (!NoRecord)
 		pkgdb_close();
 	archive_write_close(writer);
 	archive_write_finish(writer);
 	return r;
+}
 /*
  * Register dependencies after sucessfully installing the package.
  */
 static void
 pkg_register_depends(struct pkg_task *pkg)
+{
 	int fd;
 	size_t text_len, i;
 	char *required_by, *text;
 	if (Fake)
 		return;
 	if (pkg->other_version != NULL)
 		return; /* XXX It's using the old dependencies. */
 	text = xasprintf("%s\n", pkg->pkgname);
 	text_len = strlen(text);
 	for (i = 0; i < pkg->dep_length; ++i) {
 		required_by = pkgdb_pkg_file(pkg->dependencies[i], REQUIRED_BY_FNAME);
 		fd = open(required_by, O_WRONLY | O_APPEND | O_CREAT, 0644);
 		if (fd == -1)
 			warn("can't open dependency file '%s',"
 			    "registration is incomplete!", required_by);
 		else if (write(fd, text, text_len) != text_len)
 			warn("can't write to dependency file `%s'", required_by);
 		else if (close(fd) == -1)
 			warn("cannot close file %s", required_by);
 		free(required_by);
+	}
 	free(text);
+}
 /*
  * Reduce the result from uname(3) to a canonical form.
  */
 static void
 normalise_platform(struct utsname *host_name)
+{
 #ifdef NUMERIC_VERSION_ONLY
 	size_t span;
 	span = strspn(host_name->release, "0123456789.");
 	host_name->release[span] = '\0';
 #endif
+}
 /*
  * Check build platform of the package against local host.
  */
 static int
 check_platform(struct pkg_task *pkg)
+{
 	struct utsname host_uname;
 	const char *effective_arch;
 	int fatal;
 	if (uname(&host_uname) < 0) {
 		if (Force) {
 			warnx("uname() failed, continuing.");
 			return 0;
 		} else {
 			warnx("uname() failed, aborting.");
 			return -1;
+		}
+	}
 	normalise_platform(&host_uname);
 	if (OverrideMachine != NULL)
 		effective_arch = OverrideMachine;
 	else
 		effective_arch = MACHINE_ARCH;
 	/* If either the OS or arch are different, bomb */
 	if (strcmp(OPSYS_NAME, pkg->buildinfo[BI_OPSYS]) ||
 	    strcmp(effective_arch, pkg->buildinfo[BI_MACHINE_ARCH]) != 0)
 		fatal = 1;
 	else
 		fatal = 0;
 	if (fatal ||
 	    strcmp(host_uname.release, pkg->buildinfo[BI_OS_VERSION]) != 0) {
 		warnx("Warning: package `%s' was built for a platform:",
 		    pkg->pkgname);
 		warnx("%s/%s %s (pkg) vs. %s/%s %s (this host)",
 		    pkg->buildinfo[BI_OPSYS],
 		    pkg->buildinfo[BI_MACHINE_ARCH],
 		    pkg->buildinfo[BI_OS_VERSION],
 		    OPSYS_NAME,
 		    effective_arch,
 		    host_uname.release);
 		if (!Force && fatal)
 			return -1;
+	}
 	return 0;
+}
 /*
  * Run the install script.
  */
 static int
 run_install_script(struct pkg_task *pkg, const char *argument)
+{
 	int ret;
 	char *filename;
 	if (pkg->meta_data.meta_install == NULL || NoInstall)
 		return 0;
 	if (Destdir != NULL)
 		setenv(PKG_DESTDIR_VNAME, Destdir, 1);
 	setenv(PKG_PREFIX_VNAME, pkg->prefix, 1);
 	setenv(PKG_METADATA_DIR_VNAME, pkg->logdir, 1);
 	setenv(PKG_REFCOUNT_DBDIR_VNAME, pkgdb_refcount_dir(), 1);
 	if (Verbose)
 		printf("Running install with PRE-INSTALL for %s.\n", pkg->pkgname);
 	if (Fake)
 		return 0;
 	filename = pkgdb_pkg_file(pkg->pkgname, INSTALL_FNAME);
 	ret = 0;
 	errno = 0;
 	if (fcexec(pkg->install_logdir, filename, pkg->pkgname, argument,
 	    (void *)NULL)) {
 		if (errno != 0)
 			warn("exec of install script failed");
 		else
 			warnx("install script returned error status");
 		ret = -1;
+	}
 	free(filename);
 	return ret;
+}
 static int
 check_explicit_conflict(struct pkg_task *pkg)
+{
 	char *installed, *installed_pattern;
 	plist_t *p;
 	int status;
 	status = 0;
 	for (p = pkg->plist.head; p != NULL; p = p->next) {
 		if (p->type == PLIST_IGNORE) {
 			p = p->next;
 			continue;
 		} else if (p->type != PLIST_PKGCFL)
 			continue;
 		installed = find_best_matching_installed_pkg(p->name);
 		if (installed) {
 			warnx("Package `%s' conflicts with `%s', and `%s' is installed.",
 			    pkg->pkgname, p->name, installed);
 			free(installed);
 			status = -1;
+		}
+	}
 	if (some_installed_package_conflicts_with(pkg->pkgname,
 	    pkg->other_version, &installed, &installed_pattern)) {
 		warnx("Installed package `%s' conflicts with `%s' when trying to install `%s'.",
 			installed, installed_pattern, pkg->pkgname);
 		free(installed);
 		free(installed_pattern);
 		status = -1;
+	}
 	return status;
+}
 static int
 check_implicit_conflict(struct pkg_task *pkg)
+{
 	plist_t *p;
 	char *fullpath, *existing;
 	int status;
 	if (!pkgdb_open(ReadOnly)) {
 #if notyet /* XXX empty pkgdb without database? */
 		warn("Can't open pkgdb for reading");
 		return -1;
 #else
 		return 0;
 #endif
+	}
 	status = 0;
 	for (p = pkg->plist.head; p != NULL; p = p->next) {
 		if (p->type == PLIST_IGNORE) {
 			p = p->next;
 			continue;
 		} else if (p->type != PLIST_FILE)
 			continue;
 		fullpath = xasprintf("%s/%s", pkg->prefix, p->name);
 		existing = pkgdb_retrieve(fullpath);
 		free(fullpath);
 		if (existing == NULL)
 			continue;
 		if (pkg->other_version != NULL &&
 		    strcmp(pkg->other_version, existing) == 0)
 			continue;
 		warnx("Conflicting PLIST with %s: %s", existing, p->name);
 		if (!Force) {
 			status = -1;
 			if (!Verbose)
 				break;
+		}
+	}
 	pkgdb_close();
 	return status;
+}
 static int
 check_dependencies(struct pkg_task *pkg)
+{
 	plist_t *p;
 	char *best_installed;
 	int status;
 	size_t i;
 	status = 0;
 	for (p = pkg->plist.head; p != NULL; p = p->next) {
 		if (p->type == PLIST_IGNORE) {
 			p = p->next;
 			continue;
 		} else if (p->type != PLIST_PKGDEP)
 			continue;
 		best_installed = find_best_matching_installed_pkg(p->name);
 		if (best_installed == NULL) {
 			/* XXX check cyclic dependencies? */
 			if (Fake || NoRecord) {
 				if (!Force) {
 					warnx("Missing dependency %s\n",
 					     p->name);
 					status = -1;
 					break;
+				}
 				warnx("Missing dependency %s, continuing",
 				    p->name);
 				continue;
+			}
 			if (pkg_do(p->name, 1)) {
 				warnx("Can't install dependency %s", p->name);
 				status = -1;
 				break;
+			}
 			best_installed = find_best_matching_installed_pkg(p->name);
 			if (best_installed == NULL && Force) {
 				warnx("Missing dependency %s ignored", p->name);
 				continue;
 			} else if (best_installed == NULL) {
 				warnx("Just installed dependency %s disappeared", p->name);
 				status = -1;
 				break;
+			}
+		}
 		for (i = 0; i < pkg->dep_length; ++i) {
 			if (strcmp(best_installed, pkg->dependencies[i]) == 0)
 				break;
+		}
 		if (i < pkg->dep_length) {
 			/* Already used as dependency, so skip it. */
 			free(best_installed);
 			continue;
+		}
 		if (pkg->dep_length + 1 >= pkg->dep_allocated) {
 			char **tmp;
 			pkg->dep_allocated = 2 * pkg->dep_allocated + 1;
 			pkg->dependencies = xrealloc(pkg->dependencies,
 			    pkg->dep_allocated * sizeof(*tmp));
+		}
 		pkg->dependencies[pkg->dep_length++] = best_installed;
+	}
 	return status;
+}
 /*
  * If this package uses pkg_views, register it in the default view.
  */
 static void
 pkg_register_views(struct pkg_task *pkg)
+{
 	if (Fake || NoView || pkg->meta_data.meta_views == NULL)
 		return;
 	if (Verbose) {
 		printf("%s/pkg_view -d %s %s%s %s%s %sadd %s\n",
 			BINDIR, _pkgdb_getPKGDB_DIR(),
 			View ? "-w " : "", View ? View : "",
 			Viewbase ? "-W " : "", Viewbase ? Viewbase : "",
 			Verbose ? "-v " : "", pkg->pkgname);
+	}
 	fexec_skipempty(BINDIR "/pkg_view", "-d", _pkgdb_getPKGDB_DIR(),
 			View ? "-w " : "", View ? View : "",
 			Viewbase ? "-W " : "", Viewbase ? Viewbase : "",
 			Verbose ? "-v " : "", "add", pkg->pkgname,
 			(void *)NULL);
+}
 static int
 preserve_meta_data_file(struct pkg_task *pkg, const char *name)
+{
 	char *old_file, *new_file;
 	int rv;
 	if (Fake)
 		return 0;
 	old_file = pkgdb_pkg_file(pkg->other_version, name);
 	new_file = pkgdb_pkg_file(pkg->pkgname, name);
 	rv = 0;
 	if (rename(old_file, new_file) == -1 && errno != ENOENT) {
 		warn("Can't move %s from %s to %s", name, old_file, new_file);
 		rv = -1;
+	}
 	free(old_file);
 	free(new_file);
 	return rv;
+}
 static int
 start_replacing(struct pkg_task *pkg)
+{
 	if (preserve_meta_data_file(pkg, REQUIRED_BY_FNAME))
 		return -1;
 	if (pkg->meta_data.meta_preserve == NULL &&
 	    preserve_meta_data_file(pkg, PRESERVE_FNAME))
 		return -1;
 	if (pkg->meta_data.meta_installed_info == NULL &&
 	    preserve_meta_data_file(pkg, INSTALLED_INFO_FNAME))
 		return -1;
 	if (Verbose || Fake) {
 		printf("%s/pkg_delete -K %s -p %s%s%s '%s'\n",
 			BINDIR, _pkgdb_getPKGDB_DIR(), pkg->prefix,
 			Destdir ? " -P ": "", Destdir ? Destdir : "",
 			pkg->other_version);
+	}
 	if (!Fake)
 		fexec_skipempty(BINDIR "/pkg_delete", "-K", _pkgdb_getPKGDB_DIR(),
 		    "-p", pkg->prefix,
 		    Destdir ? "-P": "", Destdir ? Destdir : "",
 		    pkg->other_version, NULL);
 	/* XXX Check return value and do what? */
 	return 0;
+}
 static int check_input(const char *line, size_t len)
+{
 	if (line == NULL || len == 0)
 		return 1;
 	switch (*line) {
 	case 'Y':
 	case 'y':
 	case 'T':
 	case 't':
 	case '1':
 		return 0;
 	default:
 		return 1;
+	}
+}
 static int
 check_signature(struct pkg_task *pkg, void *signature_cookie, int invalid_sig)
+{
 	char *line;
 	size_t len;
 	if (strcasecmp(verified_installation, "never") == 0)
 		return 0;
 	if (strcasecmp(verified_installation, "always") == 0) {
 		if (invalid_sig)
 			warnx("No valid signature found, rejected");
 		return invalid_sig;
+	}
 	if (strcasecmp(verified_installation, "trusted") == 0) {
 		if (!invalid_sig)
 			return 0;
 		fprintf(stderr, "No valid signature found for %s.\n",
 		    pkg->pkgname);
 		fprintf(stderr,
 		    "Do you want to proceed with the installation [y/n]?\n");
 		line = fgetln(stdin, &len);
 		if (check_input(line, len)) {
 			fprintf(stderr, "Cancelling installation\n");
 			return 1;
+		}
 		return 0;
+	}
 	if (strcasecmp(verified_installation, "interactive") == 0) {
 		fprintf(stderr, "Do you want to proceed with "
 		    "the installation of %s [y/n]?\n", pkg->pkgname);
 		line = fgetln(stdin, &len);
 		if (check_input(line, len)) {
 			fprintf(stderr, "Cancelling installation\n");
 			return 1;
+		}
 		return 0;
+	}
 	warnx("Unknown value of configuration variable VERIFIED_INSTALLATION");
 	return 1;
+}
 static int
 check_vulnerable(struct pkg_task *pkg)
+{
 	static struct pkg_vulnerabilities *pv;
 	size_t i;
 	int require_check;
 	char *line;
 	size_t len;
 	if (strcasecmp(check_vulnerabilities, "never") == 0)
 		return 0;
 	else if (strcasecmp(check_vulnerabilities, "always"))
 		require_check = 1;
 	else if (strcasecmp(check_vulnerabilities, "interactive"))
 		require_check = 0;
 	else {
 		warnx("Unknown value of the configuration variable"
 		    "CHECK_VULNERABILITIES");
 		return 1;
+	}
 	if (pv == NULL) {
 		pv = read_pkg_vulnerabilities(pkg_vulnerabilities_file,
 		    require_check, 0);
 		if (pv == NULL)
 			return require_check;
+	}
 	for (i = 0; i < pv->entries; ++i) {
 		if (!pkg_match(pv->vulnerability[i], pkg->pkgname))
 			continue;
 		if (strcmp("eol", pv->classification[i]) == 0)
 			continue;
 		warnx("Package %s has a %s vulnerability, see %s",
 		    pkg->pkgname, pv->classification[i], pv->advisory[i]);
 		fprintf(stderr, "Do you want to proceed with "
 		    "the installation of %s [y/n]?\n", pkg->pkgname);
 		line = fgetln(stdin, &len);
 		if (check_input(line, len)) {
 			fprintf(stderr, "Cancelling installation\n");
 			return 1;
+		}
 		return 0;
+	}
 	return 0;
+}
 /*
  * Install a single package.
  */
 static int
 pkg_do(const char *pkgpath, int mark_automatic)
+{
 	int status, invalid_sig;
 	void *archive_cookie;
 	void *signature_cookie;
 	struct pkg_task *pkg;
 	pkg = xcalloc(1, sizeof(*pkg));
 	status = -1;
 	if ((pkg->archive = find_archive(pkgpath, &archive_cookie)) == NULL) {
 		warnx("no pkg found for '%s', sorry.", pkgpath);
 		goto clean_find_archive;
+	}
 #ifdef HAVE_SSL
 	invalid_sig = pkg_verify_signature(&pkg->archive, &pkg->entry,
 	    &pkg->pkgname, &signature_cookie);
 #else
 	invalid_sig = 1;
 	signature_cookie = NULL;
 #endif
 	if (read_meta_data(pkg))
 		goto clean_memory;
 	/* Parse PLIST early, so that messages can use real package name. */
 	if (pkg_parse_plist(pkg))
 		goto clean_memory;
 	if (check_signature(pkg, &signature_cookie, invalid_sig))
 		goto clean_memory;
 	if (check_vulnerable(pkg))
 		goto clean_memory;
 	if (pkg->meta_data.meta_mtree != NULL)
 		warnx("mtree specification in pkg `%s' ignored", pkg->pkgname);
 	if (pkg->meta_data.meta_views != NULL) {
 		pkg->logdir = xstrdup(pkg->prefix);
 		_pkgdb_setPKGDB_DIR(dirname_of(pkg->logdir));
 	} else {
 		pkg->logdir = xasprintf("%s/%s", _pkgdb_getPKGDB_DIR(),
 		    pkg->pkgname);
+	}
 	if (Destdir != NULL) {
 		pkg->install_logdir = xasprintf("%s/%s", Destdir, pkg->logdir);
 		_pkgdb_setPKGDB_DIR(dirname_of(pkg->install_logdir));
 	} else
 		pkg->install_logdir = xstrdup(pkg->logdir);
 	if (NoRecord && !Fake) {
 		const char *tmpdir;
 		tmpdir = getenv("TMPDIR");
 		if (tmpdir == NULL)
 			tmpdir = "/tmp";
 		free(pkg->install_logdir);
 		pkg->install_logdir = xasprintf("%s/pkg_install.XXXXXX", tmpdir);
 		/* XXX pkg_add -u... */
 		if (mkdtemp(pkg->install_logdir) == NULL) {
 			warn("mkdtemp failed");
 			goto clean_memory;
+		}
+	}
 	if (check_already_installed(pkg) == 0) {
 		status = 0;
 		goto clean_memory;
+	}
 	if (read_buildinfo(pkg))
 		goto clean_memory;
 	if (check_platform(pkg))
 		goto clean_memory;
 	if (check_other_installed(pkg))
 		goto clean_memory;
 	if (check_explicit_conflict(pkg))
 		goto clean_memory;
 	if (check_implicit_conflict(pkg))
 		goto clean_memory;
 	if (pkg->other_version != NULL) {
 		/*
 		 * Replacing an existing package.
 		 * Write meta-data, get rid of the old version,
 		 * install/update dependencies and finally extract.
 		 */
 		if (write_meta_data(pkg))
 			goto nuke_pkgdb;
 		if (start_replacing(pkg))
 			goto nuke_pkgdb;
 		if (check_dependencies(pkg))
 			goto nuke_pkgdb;
 	} else {
 		/*
 		 * Normal installation.
 		 * Install/update dependencies first and
 		 * write the current package to disk afterwards.
 		 */
 		if (check_dependencies(pkg))
 			goto clean_memory;
 		if (write_meta_data(pkg))
 			goto nuke_pkgdb;
+	}
 	if (run_install_script(pkg, "PRE-INSTALL"))
 		goto nuke_pkgdb;
 	if (extract_files(pkg))
 		goto nuke_pkg;
 	if (run_install_script(pkg, "POST-INSTALL"))
 		goto nuke_pkgdb;
 	/* XXX keep +INSTALL_INFO for updates? */
 	/* XXX keep +PRESERVE for updates? */
 	if (mark_automatic)
 		mark_as_automatic_installed(pkg->pkgname, 1);
 	pkg_register_depends(pkg);
 	if (Verbose)
 		printf("Package %s registered in %s\n", pkg->pkgname, pkg->install_logdir);
 	if (pkg->meta_data.meta_display != NULL)
 		fputs(pkg->meta_data.meta_display, stdout);
 	pkg_register_views(pkg);
 	status = 0;
 	goto clean_memory;
 nuke_pkg:
 	if (!Fake) {
 		if (pkg->other_version) {
 			warnx("Updating of %s to %s failed.",
 			    pkg->other_version, pkg->pkgname);
 			warnx("Remember to run pkg_admin rebuild-tree after fixing this.");
+		}
 		delete_package(FALSE, FALSE, &pkg->plist, FALSE, Destdir);
+	}
 nuke_pkgdb:
 	if (!Fake) {
 		if (recursive_remove(pkg->install_logdir, 1))
 			warn("Couldn't remove %s", pkg->install_logdir);
 		free(pkg->install_logdir);
 		free(pkg->logdir);
 		pkg->install_logdir = NULL;
 		pkg->logdir = NULL;
+	}
 clean_memory:
 	if (pkg->logdir != NULL && NoRecord && !Fake) {
 		if (recursive_remove(pkg->install_logdir, 1))
 			warn("Couldn't remove %s", pkg->install_logdir);
+	}
 	free(pkg->install_prefix);
 	free(pkg->install_logdir);
 	free(pkg->logdir);
 	free_buildinfo(pkg);
 	free_plist(&pkg->plist);
 	free_meta_data(pkg);
 	if (pkg->archive) {
 		archive_read_close(pkg->archive);
 		close_archive(archive_cookie);
+	}
 	free(pkg->other_version);
 	free(pkg->pkgname);
 #ifdef HAVE_SSL
 	pkg_free_signature(signature_cookie);
 #endif
 clean_find_archive:
 	free(pkg);
 	return status;
+}
 int
 pkg_perform(lpkg_head_t *pkgs)
+{
 	int     oldcwd, errors = 0;
 	lpkg_t *lpp;
 	if ((oldcwd = open(".", O_RDONLY, 0)) == -1)
 		err(EXIT_FAILURE, "unable to open cwd");
 	while ((lpp = TAILQ_FIRST(pkgs)) != NULL) {
 		path_prepend_from_pkgname(lpp->lp_name);
 		if (pkg_do(lpp->lp_name, Automatic))
 			++errors;
 		path_prepend_clear();
 		TAILQ_REMOVE(pkgs, lpp, lp_link);
 		free_lpkg(lpp);
 		if (fchdir(oldcwd) == -1)
 			err(EXIT_FAILURE, "unable to restore cwd");
+	}
 	close(oldcwd);
 	return errors;
+}

 @@ -1,426 +1,427 @@
-/* $NetBSD: lib.h,v 1.42.2.16 2008/12/30 15:55:57 joerg Exp $ */
+/* $NetBSD: lib.h,v 1.42.2.17 2009/01/08 00:01:31 joerg Exp $ */
 /* from FreeBSD Id: lib.h,v 1.25 1997/10/08 07:48:03 charnier Exp */
 /*
  * FreeBSD install - a package for the installation and maintainance
  * of non-core utilities.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * Jordan K. Hubbard
  * 18 July 1993
+ *
  * Include and define various things wanted by the library routines.
+ *
  */
 #ifndef _INST_LIB_LIB_H_
 #define _INST_LIB_LIB_H_
 #if HAVE_CONFIG_H
 #include "config.h"
 #endif
 #include <nbcompat.h>
 #if HAVE_SYS_PARAM_H
 #include <sys/param.h>
 #endif
 #if HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
 #if HAVE_SYS_FILE_H
 #include <sys/file.h>
 #endif
 #if HAVE_SYS_QUEUE_H
 #include <sys/queue.h>
 #endif
 #if HAVE_CTYPE_H
 #include <ctype.h>
 #endif
 #if HAVE_DIRENT_H
 #include <dirent.h>
 #endif
 #if HAVE_STDIO_H
 #include <stdio.h>
 #endif
 #if HAVE_STDLIB_H
 #include <stdlib.h>
 #endif
 #if HAVE_STDARG_H
 #include <stdarg.h>
 #endif
 #if HAVE_STRING_H
 #include <string.h>
 #endif
 #if HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #include "path.h"
 /* Macros */
 #define SUCCESS	(0)
 #define	FAIL	(-1)
 #ifndef TRUE
 #define TRUE	(1)
 #endif
 #ifndef FALSE
 #define FALSE	(0)
 #endif
 #ifndef OPSYS_NAME
 #define OPSYS_NAME "NetBSD"
 #endif
 #ifndef DEF_UMASK
 #define DEF_UMASK 022
 #endif
 #ifndef	PATH_MAX
 #  ifdef MAXPATHLEN
 #    define PATH_MAX	MAXPATHLEN
 #  else
 #    define PATH_MAX	1024
 #  endif
 #endif
 enum {
 	MaxPathSize = PATH_MAX
 };
 /* The names of our "special" files */
 #define CONTENTS_FNAME		"+CONTENTS"
 #define COMMENT_FNAME		"+COMMENT"
 #define DESC_FNAME		"+DESC"
 #define INSTALL_FNAME		"+INSTALL"
 #define DEINSTALL_FNAME		"+DEINSTALL"
 #define REQUIRED_BY_FNAME	"+REQUIRED_BY"
 #define REQUIRED_BY_FNAME_TMP	"+REQUIRED_BY.tmp"
 #define DISPLAY_FNAME		"+DISPLAY"
 #define MTREE_FNAME		"+MTREE_DIRS"
 #define BUILD_VERSION_FNAME	"+BUILD_VERSION"
 #define BUILD_INFO_FNAME	"+BUILD_INFO"
 #define INSTALLED_INFO_FNAME	"+INSTALLED_INFO"
 #define SIZE_PKG_FNAME		"+SIZE_PKG"
 #define SIZE_ALL_FNAME		"+SIZE_ALL"
 #define PRESERVE_FNAME		"+PRESERVE"
 #define VIEWS_FNAME		"+VIEWS"
 #define VIEWS_FNAME_TMP		"+VIEWS.tmp"
 #define DEPOT_FNAME		"+DEPOT"
 /* The names of special variables */
 #define AUTOMATIC_VARNAME	"automatic"
 /* Prefix for extended PLIST cmd */
 #define CMD_CHAR		'@'
 /* The name of the "prefix" environment variable given to scripts */
 #define PKG_PREFIX_VNAME	"PKG_PREFIX"
 /* The name of the "destdir" environment variable given to scripts */
 #define PKG_DESTDIR_VNAME	"PKG_DESTDIR"
 /*
  * The name of the "metadatadir" environment variable given to scripts.
  * This variable holds the location of the +-files for this package.
  */
 #define PKG_METADATA_DIR_VNAME	"PKG_METADATA_DIR"
 /*
  * The name of the environment variable holding the location to the
  * reference-counts database directory.
  */
 #define PKG_REFCOUNT_DBDIR_VNAME	"PKG_REFCOUNT_DBDIR"
 #define	PKG_PATTERN_MAX	MaxPathSize	/* max length of pattern, including nul */
 #define	PKG_SUFFIX_MAX	10	/* max length of suffix, including nul */
 enum {
 	ReadWrite,
 	ReadOnly
 };
 /* Enumerated constants for plist entry types */
 typedef enum pl_ent_t {
 	PLIST_SHOW_ALL = -1,
 	PLIST_FILE,		/*  0 */
 	PLIST_CWD,		/*  1 */
 	PLIST_CMD,		/*  2 */
 	PLIST_CHMOD,		/*  3 */
 	PLIST_CHOWN,		/*  4 */
 	PLIST_CHGRP,		/*  5 */
 	PLIST_COMMENT,		/*  6 */
 	PLIST_IGNORE,		/*  7 */
 	PLIST_NAME,		/*  8 */
 	PLIST_UNEXEC,		/*  9 */
 	PLIST_SRC,		/* 10 */
 	PLIST_DISPLAY,		/* 11 */
 	PLIST_PKGDEP,		/* 12 */
 	PLIST_MTREE,		/* 13 */
 	PLIST_DIR_RM,		/* 14 */
 	PLIST_IGNORE_INST,	/* 15 */
 	PLIST_OPTION,		/* 16 */
 	PLIST_PKGCFL,		/* 17 */
 	PLIST_BLDDEP		/* 18 */
 }       pl_ent_t;
 /* Enumerated constants for build info */
 typedef enum bi_ent_t {
 	BI_OPSYS,		/*  0 */
 	BI_OS_VERSION,		/*  1 */
 	BI_MACHINE_ARCH,	/*  2 */
 	BI_IGNORE_RECOMMENDED,	/*  3 */
 	BI_USE_ABI_DEPENDS,	/*  4 */
 	BI_ENUM_COUNT		/*  5 */
 }	bi_ent_t;
 /* Types */
 typedef unsigned int Boolean;
 /* This structure describes a packing list entry */
 typedef struct plist_t {
 	struct plist_t *prev;	/* previous entry */
 	struct plist_t *next;	/* next entry */
 	char   *name;		/* name of entry */
 	Boolean marked;		/* whether entry has been marked */
 	pl_ent_t type;		/* type of entry */
 }       plist_t;
 /* This structure describes a package's complete packing list */
 typedef struct package_t {
 	plist_t *head;		/* head of list */
 	plist_t *tail;		/* tail of list */
 }       package_t;
 #define SYMLINK_HEADER	"Symlink:"
 #define CHECKSUM_HEADER	"MD5:"
 enum {
 	ChecksumHeaderLen = 4,	/* strlen(CHECKSUM_HEADER) */
 	SymlinkHeaderLen = 8,	/* strlen(SYMLINK_HEADER) */
 	ChecksumLen = 16,
 	LegibleChecksumLen = 33
 };
 /* List of files */
 typedef struct _lfile_t {
         TAILQ_ENTRY(_lfile_t) lf_link;
         char *lf_name;
 } lfile_t;
 TAILQ_HEAD(_lfile_head_t, _lfile_t);
 typedef struct _lfile_head_t lfile_head_t;
 #define	LFILE_ADD(lfhead,lfp,str) do {		\
 	lfp = xmalloc(sizeof(lfile_t));		\
 	lfp->lf_name = str;			\
 	TAILQ_INSERT_TAIL(lfhead,lfp,lf_link);	\
 	} while(0)
 /* List of packages */
 typedef struct _lpkg_t {
 	TAILQ_ENTRY(_lpkg_t) lp_link;
 	char   *lp_name;
 }       lpkg_t;
 TAILQ_HEAD(_lpkg_head_t, _lpkg_t);
 typedef struct _lpkg_head_t lpkg_head_t;
 struct pkg_vulnerabilities {
 	size_t	entries;
 	char	**vulnerability;
 	char	**classification;
 	char	**advisory;
 };
 /* If URLlength()>0, then there is a ftp:// or http:// in the string,
  * and this must be an URL. Hide this behind a more obvious name. */
 #define IS_URL(str)	(URLlength(str) > 0)
 #define IS_STDIN(str)	((str) != NULL && !strcmp((str), "-"))
 #define IS_FULLPATH(str)	((str) != NULL && (str)[0] == '/')
 /* Conflict handling (conflicts.c) */
 int	some_installed_package_conflicts_with(const char *, const char *, char **, char **);
 /* Prototypes */
 /* Misc */
 void    cleanup(int);
 void    show_version(void);
 int	fexec(const char *, ...);
 int	fexec_skipempty(const char *, ...);
 int	fcexec(const char *, const char *, ...);
 int	pfcexec(const char *, const char *, const char **);
 /* variables file handling */
 char   *var_get(const char *, const char *);
 char   *var_get_memory(const char *, const char *);
 int	var_set(const char *, const char *, const char *);
 int     var_copy_list(const char *, const char **);
 /* automatically installed as dependency */
 Boolean	is_automatic_installed(const char *);
 int	mark_as_automatic_installed(const char *, int);
 /* String */
 const char *basename_of(const char *);
 const char *dirname_of(const char *);
 const char *suffix_of(const char *);
 int     pkg_match(const char *, const char *);
 int	pkg_order(const char *, const char *, const char *);
 int     ispkgpattern(const char *);
 int	quick_pkg_match(const char *, const char *);
 /* Iterator functions */
 int	iterate_pkg_generic_src(int (*)(const char *, void *), void *,
 				const char *(*)(void *),void *);
 int	iterate_local_pkg_dir(const char *, int, int, int (*)(const char *, void *),
 			      void *);
 int	iterate_pkg_db(int (*)(const char *, void *), void *);
 int	add_installed_pkgs_by_basename(const char *, lpkg_head_t *);
 int	add_installed_pkgs_by_pattern(const char *, lpkg_head_t *);
 char	*find_best_matching_installed_pkg(const char *);
 char	*find_best_matching_file(const char *, const char *, int, int);
 int	match_installed_pkgs(const char *, int (*)(const char *, void *), void *);
 int	match_local_files(const char *, int, int, const char *, int (*cb)(const char *, void *), void *);
 /* File */
 Boolean fexists(const char *);
 Boolean isdir(const char *);
 Boolean islinktodir(const char *);
 Boolean isemptydir(const char *);
 Boolean isemptyfile(const char *);
 Boolean isfile(const char *);
 Boolean isbrokenlink(const char *);
 Boolean isempty(const char *);
 int     URLlength(const char *);
 Boolean make_preserve_name(char *, size_t, char *, char *);
 void    remove_files(const char *, const char *);
 int     delete_hierarchy(char *, Boolean, Boolean);
 int     format_cmd(char *, size_t, const char *, const char *, const char *);
 int	recursive_remove(const char *, int);
 /* pkg_io.c: Local and remote archive handling */
 struct archive;
 struct archive_entry;
 struct archive *open_archive(const char *, void **);
 void	close_archive(void *);
 struct archive *find_archive(const char *, void **);
 /* Packing list */
 plist_t *new_plist_entry(void);
 plist_t *last_plist(package_t *);
 plist_t *find_plist(package_t *, pl_ent_t);
 char   *find_plist_option(package_t *, char *);
 void    plist_delete(package_t *, Boolean, pl_ent_t, char *);
 void    free_plist(package_t *);
 void    mark_plist(package_t *);
 void    csum_plist_entry(char *, plist_t *);
 void    add_plist(package_t *, pl_ent_t, const char *);
 void    add_plist_top(package_t *, pl_ent_t, const char *);
 void    delete_plist(package_t *, Boolean, pl_ent_t, char *);
 void    write_plist(package_t *, FILE *, char *);
 void	stringify_plist(package_t *, char **, size_t *, const char *);
 void	parse_plist(package_t *, const char *);
 void    read_plist(package_t *, FILE *);
 void    append_plist(package_t *, FILE *);
 int     delete_package(Boolean, Boolean, package_t *, Boolean, const char *);
 /* Package Database */
 int     pkgdb_open(int);
 void    pkgdb_close(void);
 int     pkgdb_store(const char *, const char *);
 char   *pkgdb_retrieve(const char *);
 int	pkgdb_dump(void);
 int     pkgdb_remove(const char *);
 int	pkgdb_remove_pkg(const char *);
 char   *pkgdb_refcount_dir(void);
 char   *_pkgdb_getPKGDB_FILE(char *, unsigned);
 const char *_pkgdb_getPKGDB_DIR(void);
 void	_pkgdb_setPKGDB_DIR(const char *);
 char   *pkgdb_pkg_file(const char *, const char *);
 /* List of packages functions */
 lpkg_t *alloc_lpkg(const char *);
 lpkg_t *find_on_queue(lpkg_head_t *, const char *);
 void    free_lpkg(lpkg_t *);
 /* Extract input if compressed to NUL terminated buffer (not counted) */
 int decompress_buffer(const char *, size_t, char **, size_t *);
 /* Parse NUL terminated inputed, argument is strlen of the input */
 struct pkg_vulnerabilities *parse_pkg_vulnerabilities(const char *, size_t, int);
 /* Read pkg_vulnerabilities from file */
 struct pkg_vulnerabilities *read_pkg_vulnerabilities(const char *, int, int);
 void free_pkg_vulnerabilities(struct pkg_vulnerabilities *);
 /* Parse configuration file */
 void pkg_install_config(void);
 /* Print configuration variable */
 void pkg_install_show_variable(const char *);
 #ifdef HAVE_SSL
 /* Package signature creation and validation */
 int pkg_verify_signature(struct archive **, struct archive_entry **, char **,
     void **);
 int pkg_full_signature_check(struct archive *);
 void pkg_free_signature(void *);
 void pkg_sign_x509(const char *, const char *, const char *, const char *);
 #endif
 void pkg_sign_gpg(const char *, const char *);
 #ifdef HAVE_SSL
 /* PKCS7 signing/verification */
 int easy_pkcs7_verify(const char *, size_t, const char *, size_t,
     const char *, int);
 int easy_pkcs7_sign(const char *, size_t, char **, size_t *, const char *,
     const char *);
 #endif
 int inline_gpg_verify(const char *, size_t);
 int detached_gpg_verify(const char *, size_t, const char *, size_t,
     const char *);
 int detached_gpg_sign(const char *, size_t, char **, size_t *, const char *,
     const char *);
 char *xstrdup(const char *);
 void *xrealloc(void *, size_t);
 void *xcalloc(size_t, size_t);
 void *xmalloc(size_t);
 char *xasprintf(const char *, ...);
 /* Externs */
 extern Boolean Verbose;
 extern Boolean Fake;
 extern Boolean Force;
 extern const char *cert_chain_file;
 extern const char *certs_packages;
 extern const char *certs_pkg_vulnerabilities;
 extern const char *check_vulnerabilities;
 extern const char *config_file;
 extern const char *verified_installation;
 extern const char *gpg_cmd;
 extern char fetch_flags[];
 extern const char *pkg_vulnerabilities_dir;
 extern const char *pkg_vulnerabilities_file;
 extern const char *pkg_vulnerabilities_url;
 extern const char *ignore_advisories;
 extern const char tnf_vulnerability_base[];
 #endif				/* _INST_LIB_LIB_H_ */

 @@ -1,128 +1,133 @@
-/*	$NetBSD: parse-config.c,v 1.1.2.5 2008/08/21 16:04:39 joerg Exp $	*/
+/*	$NetBSD: parse-config.c,v 1.1.2.6 2009/01/08 00:01:31 joerg Exp $	*/
 #if HAVE_CONFIG_H
 #include "config.h"
 #endif
 #include <nbcompat.h>
 #if HAVE_SYS_CDEFS_H
 #include <sys/cdefs.h>
 #endif
 #ifndef lint
-__RCSID("$NetBSD: parse-config.c,v 1.1.2.5 2008/08/21 16:04:39 joerg Exp $");
+__RCSID("$NetBSD: parse-config.c,v 1.1.2.6 2009/01/08 00:01:31 joerg Exp $");
 #endif
 /*-
  * Copyright (c) 2008 Joerg Sonnenberger <joerg@NetBSD.org>.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
+ *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #if HAVE_ERR_H
 #include <err.h>
 #endif
 #if HAVE_STRING_H
 #include <string.h>
 #endif
 #include "lib.h"
 const char     *config_file = SYSCONFDIR"/pkg_install.conf";
 char fetch_flags[10];
 static const char *active_ftp;
 static const char *verbose_netio;
 static const char *ignore_proxy;
 const char *cert_chain_file;
 const char *certs_packages;
 const char *certs_pkg_vulnerabilities;
 const char *check_vulnerabilities;
 const char *verified_installation;
 const char *gpg_cmd;
 const char *pkg_vulnerabilities_dir;
 const char *pkg_vulnerabilities_file;
 const char *pkg_vulnerabilities_url;
 const char *ignore_advisories = NULL;
 const char tnf_vulnerability_base[] = "ftp://ftp.NetBSD.org/pub/NetBSD/packages/vulns";
 static struct config_variable {
 	const char *name;
 	const char **var;
 } config_variables[] = {
 	{ "ACTIVE_FTP", &active_ftp },
 	{ "CERTIFICATE_ANCHOR_PKGS", &certs_packages },
 	{ "CERTIFICATE_ANCHOR_PKGVULN", &certs_pkg_vulnerabilities },
 	{ "CERTIFICATE_CHAIN", &cert_chain_file },
 	{ "CHECK_VULNERABILITIES", &check_vulnerabilities },
 	{ "GPG", &gpg_cmd },
 	{ "IGNORE_PROXY", &ignore_proxy },
 	{ "IGNORE_URL", &ignore_advisories },
 	{ "PKGVULNDIR", &pkg_vulnerabilities_dir },
 	{ "PKGVULNURL", &pkg_vulnerabilities_url },
 	{ "VERBOSE_NETIO", &verbose_netio },
 	{ "VERIFIED_INSTALLATION", &verified_installation },
 	{ NULL, NULL }
 };
 void
 pkg_install_config(void)
+{
 	char *value;
 	struct config_variable *var;
 	for (var = config_variables; var->name != NULL; ++var) {
 		value = var_get(config_file, var->name);
 		if (value != NULL)
 			*var->var = value;
+	}
 	if (pkg_vulnerabilities_dir == NULL)
 		pkg_vulnerabilities_dir = _pkgdb_getPKGDB_DIR();
 	pkg_vulnerabilities_file = xasprintf("%s/pkg-vulnerabilities",
 	    pkg_vulnerabilities_dir);
 	if (pkg_vulnerabilities_url == NULL) {
 		pkg_vulnerabilities_url = xasprintf("%s/pkg-vulnerabilities.gz",
 		    tnf_vulnerability_base);
+	}
 	if (verified_installation == NULL)
 		verified_installation = "never";
 	if (check_vulnerabilities == NULL)
 		check_vulnerabilities = "never";
 	snprintf(fetch_flags, sizeof(fetch_flags), "%s%s%s",
 	    (verbose_netio && *verbose_netio) ? "v" : "",
 	    (active_ftp && *active_ftp) ? "" : "p",
 	    (ignore_proxy && *ignore_proxy) ? "d" : "");
+}
 void
 pkg_install_show_variable(const char *var_name)
+{
 	struct config_variable *var;
 	for (var = config_variables; var->name != NULL; ++var) {
 		if (strcmp(var->name, var_name) != 0)
 			continue;
 		if (*var->var != NULL)
 			puts(*var->var);
+	}
+}

 @@ -1,137 +1,149 @@
-.\"	$NetBSD: pkg_install.conf.5,v 1.1.2.3 2008/08/21 16:10:01 joerg Exp $
+.\"	$NetBSD: pkg_install.conf.5,v 1.1.2.4 2009/01/08 00:01:31 joerg Exp $
 .\"
-.\" Copyright (c) 2008 The NetBSD Foundation, Inc.
+.\" Copyright (c) 2008, 2009 The NetBSD Foundation, Inc.
 .\" All rights reserved.
 .\"
 .\" This code is derived from software contributed to The NetBSD Foundation
 .\" by Thomas Klausner.
 .\"
 .\" Redistribution and use in source and binary forms, with or without
 .\" modification, are permitted provided that the following conditions
 .\" are met:
 .\" 1. Redistributions of source code must retain the above copyright
 .\"    notice, this list of conditions and the following disclaimer.
 .\" 2. Redistributions in binary form must reproduce the above copyright
 .\"    notice, this list of conditions and the following disclaimer in the
 .\"    documentation and/or other materials provided with the distribution.
 .\"
 .\" THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 .\" ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 .\" TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 .\" PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 .\" BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 .\" CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 .\" SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 .\" INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 .\" CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 .\" ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 .\" POSSIBILITY OF SUCH DAMAGE.
 .\"
-.Dd August 21, 2008
+.Dd January 8, 2009
 .Dt PKG_INSTALL.CONF 5
 .Os
 .Sh NAME
 .Nm pkg_install.conf
 .Nd configuration file for package installation tools
 .Sh DESCRIPTION
 The file
 .Nm
 contains system defaults for the package installation tools
 as a list of variable-value pairs.
 Each line has the format
 .Ev VARIABLE=VALUE .
 If the value consists of more than one line, each line is prefixed with
 .Ev VARIABLE= .
 .Pp
 The current value of a variable can be checked by running
 .Dl Ic pkg_admin config-var VARIABLE
 .Pp
 The following variables are supported:
 .Bl -tag -width indent
 .It Dv ACTIVE_FTP
 Force the use of active FTP.
 .It Dv CERTIFICATE_ANCHOR_PKGS
 Path to the file containing the certificates used for validating
 binary packages.
 A package is trusted when a certificate chain ends in one of the
 certificates contained in this file.
 The certificates must be PEM-encoded.
 .It Dv CERTIFICATE_ANCHOR_PKGVULN
 Analogous to
 .Dv CERTIFICATE_ANCHOR_PKGS .
 The
 .Pa pkg-vulnerabilities
 is trusted when a certificate chain ends in one of the certificates
 contained in this file.
 .It Dv CERTIFICATE_CHAIN
 Path to a file containing additional certificates that can be used
 for completing certicate chains when validating binary packages or
 pkg-vulnerabilities files.
 .Dv CHECK_VULNERABILITIES
 Check for vulnerabilities when installating packages.
 Supported values are:
 .Bl -tag -width interactiveXX
 .It Dv never
 No check is performed.
 .It Dv always
 Passing the vulnerability check is required.
 A missing pkg-vulnerabilities file is considered an error.
 .It Dv interactive
 The user is always asked to confirm installation of vulnerable packages.
 .El
 .It Dv GPG
 Deprecated.
 Path to
 .Xr gpg 1 ,
 which can be used to verify the signature in the
 .Pa pkg-vulnerabilities
 file when running
 .Dl Ic pkg_admin check-pkg-vulnerabilities -s
 or
 .Dl Ic pkg_admin fetch-pkg-vulnerabilities -s
 .It Dv IGNORE_PROXY
 Use direct connections and ignore
 .Ev FTP_PROXY
 and
 .Ev HTTP_PROXY .
 .It Dv IGNORE_URL
 One line per advisory which should be ignored when running
 .Dl Ic pkg_admin audit
 The URL from the
 .Pa pkg-vulnerabilities
 file should be used as value.
 .It Dv PKGVULNDIR
 Directory name in which the
 .Pa pkg-vulnerabilities
 file resides.
 Default is
 .Pa ${PKG_DBDIR} .
 .It Dv PKGVULNURL
 URL which is used for updating the local
 .Pa pkg-vulnerabilities
 file when running
 .Dl Ic pkg_admin fetch-pkg-vulnerabilities
 The default is
 .Pa ftp://ftp.NetBSD.org/pub/NetBSD/packages/vulns/pkg-vulnerabilities.gz
 .Em Note :
 Usually, only the compression type should be changed.
 Currently supported are uncompressed files and files compressed by
 .Xr bzip2 1
 .Pq Pa .bz2
 or
 .Xr gzip 1
 .Pq Pa .gz .
 .It Dv VERBOSE_NETIO
 Log details of network IO to stderr.
 .It Dv VERIFIED_INSTALLATION
 Set trust level used when installation.
 Supported values are:
 .Bl -tag -width interactiveXX
 .It Dv never
 No signature checks are performed.
 .It Dv always
 A valid signature is required.
 If the binary package can not be verified, the installation is terminated
 .It Dv trusted
 A valid signature is required.
 If the binary package can not be verified, the user is asked interactively.
 .It Dv interactive
 The user is always asked interactively when installing a package.
 .El
 .El
 .Sh FILES
 .Bl -tag
 .It Pa @SYSCONFDIR@/pkg_install.conf
 Default location for the file described in this manual page.
 .El
 .Sh SEE ALSO
 .Xr pkg_add 1 ,
 .Xr pkg_admin 1

 @@ -1,91 +1,102 @@
 PKG_INSTALL.CONF(5)       NetBSD File Formats Manual       PKG_INSTALL.CONF(5)
 NNAAMMEE
      ppkkgg__iinnssttaallll..ccoonnff -- configuration file for package installation tools
 DDEESSCCRRIIPPTTIIOONN
      The file ppkkgg__iinnssttaallll..ccoonnff contains system defaults for the package
      installation tools as a list of variable-value pairs.  Each line has the
      format VARIABLE=VALUE.  If the value consists of more than one line, each
      line is prefixed with VARIABLE=.
      The current value of a variable can be checked by running
            ppkkgg__aaddmmiinn ccoonnffiigg--vvaarr VVAARRIIAABBLLEE
      The following variables are supported:
      ACTIVE_FTP
              Force the use of active FTP.
      CERTIFICATE_ANCHOR_PKGS
              Path to the file containing the certificates used for validating
              binary packages.  A package is trusted when a certificate chain
              ends in one of the certificates contained in this file.  The cer-
              tificates must be PEM-encoded.
      CERTIFICATE_ANCHOR_PKGVULN
              Analogous to CERTIFICATE_ANCHOR_PKGS.  The _p_k_g_-_v_u_l_n_e_r_a_b_i_l_i_t_i_e_s is
              trusted when a certificate chain ends in one of the certificates
              contained in this file.
      CERTIFICATE_CHAIN
              Path to a file containing additional certificates that can be
              used for completing certicate chains when validating binary pack-
-             ages or pkg-vulnerabilities files.
+             ages or pkg-vulnerabilities files.  CHECK_VULNERABILITIES Check
              for vulnerabilities when installating packages.  Supported values
              are:
              never          No check is performed.
              always         Passing the vulnerability check is required.  A
                             missing pkg-vulnerabilities file is considered an
                             error.
              interactive    The user is always asked to confirm installation
                             of vulnerable packages.
      GPG     Deprecated.  Path to gpg(1), which can be used to verify the sig-
              nature in the _p_k_g_-_v_u_l_n_e_r_a_b_i_l_i_t_i_e_s file when running
                    ppkkgg__aaddmmiinn cchheecckk--ppkkgg--vvuullnneerraabbiilliittiieess --ss
              or
                    ppkkgg__aaddmmiinn ffeettcchh--ppkkgg--vvuullnneerraabbiilliittiieess --ss
      IGNORE_PROXY
              Use direct connections and ignore FTP_PROXY and HTTP_PROXY.
      IGNORE_URL
              One line per advisory which should be ignored when running
                    ppkkgg__aaddmmiinn aauuddiitt
              The URL from the _p_k_g_-_v_u_l_n_e_r_a_b_i_l_i_t_i_e_s file should be used as
              value.
      PKGVULNDIR
              Directory name in which the _p_k_g_-_v_u_l_n_e_r_a_b_i_l_i_t_i_e_s file resides.
              Default is _$_{_P_K_G___D_B_D_I_R_}.
      PKGVULNURL
              URL which is used for updating the local _p_k_g_-_v_u_l_n_e_r_a_b_i_l_i_t_i_e_s file
              when running
                    ppkkgg__aaddmmiinn ffeettcchh--ppkkgg--vvuullnneerraabbiilliittiieess
              The default is
              _f_t_p_:_/_/_f_t_p_._N_e_t_B_S_D_._o_r_g_/_p_u_b_/_N_e_t_B_S_D_/_p_a_c_k_a_g_e_s_/_v_u_l_n_s_/_p_k_g_-_v_u_l_n_e_r_a_b_i_l_i_t_i_e_s_._g_z
              _N_o_t_e: Usually, only the compression type should be changed.  Cur-
              rently supported are uncompressed files and files compressed by
              bzip2(1) (_._b_z_2) or gzip(1) (_._g_z).
      VERBOSE_NETIO
              Log details of network IO to stderr.
      VERIFIED_INSTALLATION
              Set trust level used when installation.  Supported values are:
              never          No signature checks are performed.
              always         A valid signature is required.  If the binary
                             package can not be verified, the installation is
                             terminated
              trusted        A valid signature is required.  If the binary
                             package can not be verified, the user is asked
                             interactively.
              interactive    The user is always asked interactively when
                             installing a package.
 FFIILLEESS
      @SYSCONFDIR@/pkg_install.conf     Default location for the file described
                                        in this manual page.
 SSEEEE AALLSSOO
      pkg_add(1), pkg_admin(1)
-NetBSD 4.0                      August 21, 2008                     NetBSD 4.0
+NetBSD 5.0                      January 8, 2009                     NetBSD 5.0

 @@ -1,32 +1,32 @@
-/*	$NetBSD: version.h,v 1.102.2.19 2008/12/30 15:55:57 joerg Exp $	*/
+/*	$NetBSD: version.h,v 1.102.2.20 2009/01/08 00:01:31 joerg Exp $	*/
 /*
  * Copyright (c) 2001 Thomas Klausner.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef _INST_LIB_VERSION_H_
 #define _INST_LIB_VERSION_H_
-#define PKGTOOLS_VERSION "20081230"
+#define PKGTOOLS_VERSION "20090108"
 #endif /* _INST_LIB_VERSION_H_ */