 @@ -1,1441 +1,1445 @@
-/*	$NetBSD: perform.c,v 1.81 2009/02/28 16:03:56 joerg Exp $	*/
+/*	$NetBSD: perform.c,v 1.82 2009/03/02 14:59:14 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.81 2009/02/28 16:03:56 joerg Exp $");
+__RCSID("$NetBSD: perform.c,v 1.82 2009/03/02 14:59:14 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, 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>
 #if HAVE_FCNTL_H
 #include <fcntl.h>
 #endif
 #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, 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);
+	}
 	close(fd);
 	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 != NULL && *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);
 				close(fd);
 				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)
+		if (fd == -1) {
 			warn("can't open dependency file '%s',"
 			    "registration is incomplete!", required_by);
-		else if (write(fd, text, text_len) != text_len)
+			close(fd);
 		} else if (write(fd, text, text_len) != text_len) {
 			warn("can't write to dependency file `%s'", required_by);
-		else if (close(fd) == -1)
+			close(fd);
 		} 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;
+}
 struct find_conflict_data {
 	const char *pkg;
 	const char *old_pkg;
 	const char *pattern;
 };
 static int
 check_explicit_conflict_iter(const char *cur_pkg, void *cookie)
+{
 	struct find_conflict_data *data = cookie;
 	if (data->old_pkg && strcmp(data->old_pkg, cur_pkg) == 0)
 		return 0;
 	warnx("Package `%s' conflicts with `%s', and `%s' is installed.",
 	    data->pkg, data->pattern, cur_pkg);
 	return 1;
+}
 static int
 check_explicit_conflict(struct pkg_task *pkg)
+{
 	struct find_conflict_data data;
 	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;
+		}
 		if (p->type != PLIST_PKGCFL)
 			continue;
 		data.pkg = pkg->pkgname;
 		data.old_pkg = pkg->other_version;
 		data.pattern = p->name;
 		status |= match_installed_pkgs(p->name,
 		    check_explicit_conflict_iter, &data);
+	}
 	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, 0)) {
 				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 (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;
 	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;
+	}
 	if (!audit_package(pv, pkg->pkgname, NULL, 0, 2))
 		return 0;
 	if (require_check)
 		return 1;
 	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;
+}
 /*
  * Install a single package.
  */
 static int
 pkg_do(const char *pkgpath, int mark_automatic, int top_level)
+{
 	int status, invalid_sig;
 	void *archive_cookie;
 	void *signature_cookie;
 	struct pkg_task *pkg;
 	pkg = xcalloc(1, sizeof(*pkg));
 	status = -1;
 	pkg->archive = find_archive(pkgpath, &archive_cookie, top_level);
 	if (pkg->archive == NULL) {
 		warnx("no pkg found for '%s', sorry.", pkgpath);
 		goto clean_find_archive;
+	}
 	invalid_sig = pkg_verify_signature(&pkg->archive, &pkg->entry,
 	    &pkg->pkgname, &signature_cookie);
 	if (pkg->archive == NULL)
 		goto clean_memory;
 	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);
 	pkg_free_signature(signature_cookie);
 clean_find_archive:
 	free(pkg);
 	return status;
+}
 int
 pkg_perform(lpkg_head_t *pkgs)
+{
 	int     errors = 0;
 	lpkg_t *lpp;
 	while ((lpp = TAILQ_FIRST(pkgs)) != NULL) {
 		if (pkg_do(lpp->lp_name, Automatic, 1))
 			++errors;
 		TAILQ_REMOVE(pkgs, lpp, lp_link);
 		free_lpkg(lpp);
+	}
 	return errors;
+}

 @@ -1,335 +1,336 @@
-/*	$NetBSD: pkcs7.c,v 1.3 2009/02/16 20:59:11 joerg Exp $	*/
+/*	$NetBSD: pkcs7.c,v 1.4 2009/03/02 14:59:14 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: pkcs7.c,v 1.3 2009/02/16 20:59:11 joerg Exp $");
+__RCSID("$NetBSD: pkcs7.c,v 1.4 2009/03/02 14:59:14 joerg Exp $");
 /*-
  * Copyright (c) 2004, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Love H�rnquist �strand <lha@it.su.se>
+ *
  * 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.
  */
 #if HAVE_ERR_H
 #include <err.h>
 #endif
 #include <openssl/pkcs7.h>
 #include <openssl/evp.h>
 #include <openssl/x509.h>
 #include <openssl/x509v3.h>
 #include <openssl/pem.h>
 #include <openssl/err.h>
 #include "lib.h"
 #ifndef __UNCONST
 #define __UNCONST(a)	((void *)(unsigned long)(const void *)(a))
 #endif
 #ifndef NS_ANY_CA
 #define NS_ANY_CA		(NS_SSL_CA|NS_SMIME_CA|NS_OBJSIGN_CA)
 #endif
 static const int pkg_key_usage = XKU_CODE_SIGN | XKU_SMIME;
 static int
 check_ca(X509 *cert)
+{
 	if ((cert->ex_flags & EXFLAG_KUSAGE) != 0 &&
 	    (cert->ex_kusage & KU_KEY_CERT_SIGN) != KU_KEY_CERT_SIGN)
 		return 0;
 	if ((cert->ex_flags & EXFLAG_BCONS) != 0)
 		return (cert->ex_flags & EXFLAG_CA) == EXFLAG_CA;
 	if ((cert->ex_flags & (EXFLAG_V1|EXFLAG_SS)) == (EXFLAG_V1|EXFLAG_SS))
 		return 1;
 	if ((cert->ex_flags & EXFLAG_KUSAGE) != 0)
 		return 1;
 	if ((cert->ex_flags & EXFLAG_NSCERT) != 0 &&
 	    (cert->ex_nscert & NS_ANY_CA) != 0)
 		return 1;
 	return 0;
+}
 static STACK_OF(X509) *
 file_to_certs(const char *file)
+{
 	unsigned long ret;
 	STACK_OF(X509) *certs;
 	FILE *f;
 	if ((f = fopen(file, "r")) == NULL) {
 		warn("open failed %s", file);
 		return NULL;
+	}
 	certs = sk_X509_new_null();
 	for (;;) {
 		X509 *cert;
 		cert = PEM_read_X509(f, NULL, NULL, NULL);
 		if (cert == NULL) {
 			ret = ERR_GET_REASON(ERR_peek_error());
 			if (ret == PEM_R_NO_START_LINE) {
 				/* End of file reached. no error */
 				ERR_clear_error();
 				break;
+			}
 			sk_X509_free(certs);
 			warnx("Can't read certificate in file: %s", file);
 			fclose(f);
 			return NULL;
+		}
 		sk_X509_insert(certs, cert, sk_X509_num(certs));
+	}
 	fclose(f);
 	if (sk_X509_num(certs) == 0) {
 		sk_X509_free(certs);
 		certs = NULL;
 		warnx("No certificate found in file %s", file);
+	}
 	return certs;
+}
 int
 easy_pkcs7_verify(const char *content, size_t len,
     const char *signature, size_t signature_len,
     const char *anchor, int is_pkg)
+{
 	STACK_OF(X509) *cert_chain, *signers;
 	X509_STORE *store;
 	BIO *sig, *in;
 	PKCS7 *p7;
 	int i, status;
 	X509_NAME *name;
 	char *subject;
 	OpenSSL_add_all_algorithms();
 	ERR_load_crypto_strings();
 	status = -1;
 	if (cert_chain_file)
 		cert_chain = file_to_certs(cert_chain_file);
 	else
 		cert_chain = NULL;
 	store = X509_STORE_new();
 	if (store == NULL) {
 		sk_X509_free(cert_chain);
 		warnx("Failed to create certificate store");
 		return -1;
+	}
 	X509_STORE_load_locations(store, anchor, NULL);
 	in = BIO_new_mem_buf(__UNCONST(content), len);
 	sig = BIO_new_mem_buf(__UNCONST(signature), signature_len);
 	signers = NULL;
 	p7 = PEM_read_bio_PKCS7(sig, NULL, NULL, NULL);
 	if (p7 == NULL) {
 		warnx("Failed to parse the signature");
 		goto cleanup;
+	}
 	if (PKCS7_verify(p7, cert_chain, store, in, NULL, 0) != 1) {
 		warnx("Failed to verify signature");
 		goto cleanup;
+	}
 	signers = PKCS7_get0_signers(p7, NULL, 0);
 	if (signers == NULL) {
 		warnx("Failed to get signers");
 		goto cleanup;
+	}
 	if (sk_X509_num(signers) == 0) {
 		warnx("No signers found");
 		goto cleanup;
+	}
 	for (i = 0; i < sk_X509_num(signers); i++) {
 		/* Compute ex_xkusage */
 		X509_check_purpose(sk_X509_value(signers, i), -1, -1);
 		if (check_ca(sk_X509_value(signers, i))) {
 			warnx("CA keys are not valid for signatures");
 			goto cleanup;
+		}
 		if (is_pkg) {
 			if (sk_X509_value(signers, i)->ex_xkusage != pkg_key_usage) {
 				warnx("Certificate must have CODE SIGNING "
 				    "and EMAIL PROTECTION property");
 				goto cleanup;
+			}
 		} else {
 			if (sk_X509_value(signers, i)->ex_xkusage != 0) {
 				warnx("Certificate must not have any property");
 				goto cleanup;
+			}
+		}
+	}
 	printf("Sigature ok, signed by:\n");
 	for (i = 0; i < sk_X509_num(signers); i++) {
 		name = X509_get_subject_name(sk_X509_value(signers, i));
 		subject = X509_NAME_oneline(name, NULL, 0);
 		printf("\t%s\n", subject);
 		OPENSSL_free(subject);
+	}
 	status = 0;
 cleanup:
 	sk_X509_free(cert_chain);
 	sk_X509_free(signers);
 	X509_STORE_free(store);
 	PKCS7_free(p7);
 	BIO_free(in);
 	BIO_free(sig);
 	return status;
+}
 static int
 ssl_pass_cb(char *buf, int size, int rwflag, void *u)
+{
 	if (EVP_read_pw_string(buf, size, "Passphrase :", 0)) {
 #if OPENSSL_VERSION >= 0x0090608fL
 		OPENSSL_cleanse(buf, size);
 #else
 		memset(buf, 0, size);
 #endif
 		return 0;
+	}
 	return strlen(buf);
+}
 int
 easy_pkcs7_sign(const char *content, size_t len,
     char **signature, size_t *signature_len,
     const char *key_file, const char *cert_file)
+{
 	FILE *f;
 	X509 *certificate;
 	STACK_OF(X509) *c, *cert_chain;
 	EVP_PKEY *private_key;
 	char *tmp_sig;
 	BIO *out, *in;
 	PKCS7 *p7;
 	int status;
 	OpenSSL_add_all_algorithms();
 	ERR_load_crypto_strings();
 	status = -1;
 	private_key = NULL;
 	cert_chain = NULL;
 	in = NULL;
 	c = file_to_certs(cert_file);
 	if (sk_X509_num(c) != 1) {
 		warnx("More then one certificate in the certificate file");
 		goto cleanup;
+	}
 	certificate = sk_X509_value(c, 0);
 	/* Compute ex_kusage */
 	X509_check_purpose(certificate, -1, 0);
 	if (check_ca(certificate)) {
 		warnx("CA keys are not valid for signatures");
 		goto cleanup;
+	}
 	if (certificate->ex_xkusage != pkg_key_usage) {
 		warnx("Certificate must have CODE SIGNING "
 		    "and EMAIL PROTECTION property");
 		goto cleanup;
+	}
 	if (cert_chain_file)
 		cert_chain = file_to_certs(cert_chain_file);
 	if ((f = fopen(key_file, "r")) == NULL) {
 		warn("Failed to open private key file %s", key_file);
 		goto cleanup;
+	}
 	private_key = PEM_read_PrivateKey(f, NULL, ssl_pass_cb, NULL);
 	fclose(f);
 	if (private_key == NULL) {
 		warnx("Can't read private key: %s", key_file);
 		goto cleanup;
+	}
 	if (X509_check_private_key(certificate, private_key) != 1) {
 		warnx("The private key %s doesn't match the certificate %s",
 		    key_file, cert_file);
 		goto cleanup;
+	}
 	in = BIO_new_mem_buf(__UNCONST(content), len);
 	p7 = PKCS7_sign(certificate, private_key, cert_chain, in,
 	    PKCS7_DETACHED|PKCS7_NOATTR|PKCS7_BINARY);
 	if (p7 == NULL) {
 		warnx("Failed to create signature structure");
 		goto cleanup;
+	}
 	out = BIO_new(BIO_s_mem());
 	PEM_write_bio_PKCS7(out, p7);
 	*signature_len = BIO_get_mem_data(out, &tmp_sig);
 	*signature = xmalloc(*signature_len);
 	memcpy(*signature, tmp_sig, *signature_len);
 	BIO_free_all(out);
 	PKCS7_free(p7);
 	status = 0;
 cleanup:
 	sk_X509_free(c);
 	sk_X509_free(cert_chain);
 	EVP_PKEY_free(private_key);
 	BIO_free(in);
 	return status;
+}

 @@ -1,710 +1,714 @@
-/*	$NetBSD: pkg_signature.c,v 1.5 2009/02/13 13:17:41 joerg Exp $	*/
+/*	$NetBSD: pkg_signature.c,v 1.6 2009/03/02 14:59:14 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: pkg_signature.c,v 1.5 2009/02/13 13:17:41 joerg Exp $");
+__RCSID("$NetBSD: pkg_signature.c,v 1.6 2009/03/02 14:59:14 joerg Exp $");
 /*-
  * 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_SYS_WAIT_H
 #include <sys/wait.h>
 #endif
 #include <ctype.h>
 #if HAVE_ERR_H
 #include <err.h>
 #endif
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #ifndef NETBSD
 #include <nbcompat/sha2.h>
 #else
 #include <sha2.h>
 #endif
 #include <signal.h>
 #ifdef NETBSD
 #include <unistd.h>
 #else
 #include <nbcompat/unistd.h>
 #endif
 #include <archive.h>
 #include <archive_entry.h>
 #include "lib.h"
 #define HASH_FNAME "+PKG_HASH"
 #define SIGNATURE_FNAME "+PKG_SIGNATURE"
 #define GPG_SIGNATURE_FNAME "+PKG_GPG_SIGNATURE"
 struct signature_archive {
 	struct archive *archive;
 	off_t pkg_size;
 	size_t sign_block_len, sign_block_number, sign_cur_block;
 	char **sign_blocks;
 	unsigned char *sign_buf;
 };
 static void
 hash_block(unsigned char *buf, size_t buf_len,
     char hash[SHA512_DIGEST_STRING_LENGTH])
+{
 	unsigned char digest[SHA512_DIGEST_LENGTH];
 	SHA512_CTX hash_ctx;
 	int i;
 	SHA512_Init(&hash_ctx);
 	SHA512_Update(&hash_ctx, buf, buf_len);
 	SHA512_Final(digest, &hash_ctx);
 	for (i = 0; i < SHA512_DIGEST_LENGTH; ++i) {
 		unsigned char c;
 		c = digest[i] / 16;
 		if (c < 10)
 			hash[2 * i] = '0' + c;
 		else
 			hash[2 * i] = 'a' - 10 + c;
 		c = digest[i] % 16;
 		if (c < 10)
 			hash[2 * i + 1] = '0' + c;
 		else
 			hash[2 * i + 1] = 'a' - 10 + c;
+	}
 	hash[2 * i] = '\0';
+}
 static ssize_t
 verify_signature_read_cb(struct archive *archive, void *cookie, const void **buf)
+{
 	struct signature_archive *state = cookie;
 	char hash[SHA512_DIGEST_STRING_LENGTH];
 	ssize_t len, expected;
 	if (state->sign_cur_block >= state->sign_block_number)
 		return 0;
 	/* The following works for sign_block_len > 1 */
 	if (state->sign_cur_block + 1 == state->sign_block_number)
 		expected = state->pkg_size % state->sign_block_len;
 	else
 		expected = state->sign_block_len;
 	len = archive_read_data(state->archive, state->sign_buf, expected);
 	if (len != expected) {
 		warnx("Short read from package");
 		return -1;
+	}
 	hash_block(state->sign_buf, len, hash);
 	if (strcmp(hash, state->sign_blocks[state->sign_cur_block]) != 0) {
 		warnx("Invalid signature of block %llu",
 		    (unsigned long long)state->sign_cur_block);
 		return -1;
+	}
 	++state->sign_cur_block;
 	*buf = state->sign_buf;
 	return len;
+}
 static void
 free_signature_int(struct signature_archive *state)
+{
 	size_t i;
 	if (state->sign_blocks != NULL) {
 		for (i = 0; i < state->sign_block_number; ++i)
 			free(state->sign_blocks[i]);
+	}
 	free(state->sign_blocks);
 	free(state->sign_buf);
 	free(state);
+}
 void
 pkg_free_signature(void *cookie)
+{
 	struct signature_archive *state = cookie;
 	if (state == NULL)
 		return;
 	archive_read_finish(state->archive);
 	free_signature_int(state);
+}
 static int
 read_file_from_archive(struct archive *archive, struct archive_entry **entry,
     const char *fname, char **content, size_t *len)
+{
 	int r;
 	*content = NULL;
 	*len = 0;
 retry:
 	if (*entry == NULL &&
 	    (r = archive_read_next_header(archive, entry)) != ARCHIVE_OK) {
 		if (r == ARCHIVE_FATAL) {
 			warnx("Cannot read from archive: %s",
 			    archive_error_string(archive));
 			return -1;
+		}
 		return 1;
+	}
 	if (strcmp(archive_entry_pathname(*entry), "//") == 0) {
 		archive_read_data_skip(archive);
 		*entry = NULL;
 		goto retry;
+	}
 	if (strcmp(fname, archive_entry_pathname(*entry)) != 0)
 		return 1;
 	if (archive_entry_size(*entry) > SSIZE_MAX - 1) {
 		warnx("signature too large to process");
 		return 1;
+	}
 	*len = archive_entry_size(*entry);
 	*content = xmalloc(*len + 1);
 	if (archive_read_data(archive, *content, *len) != *len) {
 		warnx("cannot read complete %s from archive", fname);
 		free(*content);
 		*len = 0;
 		*content = NULL;
 		return 1;
+	}
 	(*content)[*len] = '\0';
 	*entry = NULL;
 	return 0;
+}
 static int
 parse_hash_file(const char *hash_file, char **pkgname,
     struct signature_archive *state)
+{
 	static const char block1[] = "pkgsrc signature\n\nversion: 1\npkgname: ";
 	static const char block2[] = "algorithm: SHA512\nblock size: ";
 	static const char block3[] = "file size: ";
 	static const char block4[] = "end pkgsrc signature\n";
 	char *next;
 	size_t i, len;
 	*pkgname = NULL;
 	if (strncmp(hash_file, block1, strlen(block1)) != 0)
 		goto cleanup;
 	hash_file += strlen(block1);
 	len = strcspn(hash_file, "\n");
 	*pkgname = xmalloc(len + 1);
 	memcpy(*pkgname, hash_file, len);
 	(*pkgname)[len] = '\0';
 	for (i = 0; i < len; ++i) {
 		if (!isgraph((unsigned char)(*pkgname)[i]))
 			goto cleanup;
+	}
 	hash_file += len + 1;
 	if (strncmp(hash_file, block2, strlen(block2)) != 0)
 		goto cleanup;
 	hash_file += strlen(block2);
 	errno = 0;
 	if (!isdigit((unsigned char)*hash_file))
 		goto cleanup;
 	state->sign_block_len = strtoul(hash_file, &next, 10);
 	hash_file = next;
 	/* Assert sane minimum block size of 1KB */
 	if (*hash_file++ != '\n' || errno == ERANGE || state->sign_block_len < 1024)
 		goto cleanup;
 	if (strncmp(hash_file, block3, strlen(block3)) != 0)
 		goto cleanup;
 	hash_file += strlen(block3);
 	errno = 0;
 	if (!isdigit((unsigned char)*hash_file))
 		goto cleanup;
 	if (sizeof(off_t) >= sizeof(long long))
 		state->pkg_size = strtoll(hash_file, &next, 10);
 	else
 		state->pkg_size = strtol(hash_file, &next, 10);
 	hash_file = next;
 	if (*hash_file++ != '\n' || errno == ERANGE || state->pkg_size < 1)
 		goto cleanup;
 	if (*hash_file++ != '\n')
 		goto cleanup;
 	if (state->pkg_size / state->sign_block_len > SSIZE_MAX)
 		goto cleanup;
 	state->sign_block_number = (state->pkg_size +
 	    state->sign_block_len - 1) / state->sign_block_len;
 	state->sign_buf = xmalloc(state->sign_block_len);
 	state->sign_blocks = xcalloc(state->sign_block_number, sizeof(char *));
 	for (i = 0; i < state->sign_block_number; ++i) {
 		len = strspn(hash_file, "01234567889abcdef");
 		if (len != SHA512_DIGEST_LENGTH * 2 || hash_file[len] != '\n')
 			goto cleanup_hashes;
 		state->sign_blocks[i] = xmalloc(len + 1);
 		memcpy(state->sign_blocks[i], hash_file, len);
 		state->sign_blocks[i][len] = '\0';
 		hash_file += len + 1;
+	}
 	if (strcmp(hash_file, block4) != 0)
 		goto cleanup_hashes;
 	return 0;
 cleanup_hashes:
 	for (i = 0; i < state->sign_block_number; ++i)
 		free(state->sign_blocks[i]);
 	free(state->sign_blocks);
 	state->sign_blocks = NULL;
 cleanup:
 	warnx("Unknown format of hash file");
 	free(*pkgname);
 	*pkgname = NULL;
 	return -1;
+}
 int
 pkg_verify_signature(struct archive **archive, struct archive_entry **entry,
     char **pkgname, void **cookie)
+{
 	struct signature_archive *state;
 	struct archive_entry *my_entry;
 	struct archive *a;
 	char *hash_file, *signature_file;
 	size_t hash_len, signature_len;
 	int r, has_sig;
 	*pkgname = NULL;
 	*cookie = NULL;
 	state = xmalloc(sizeof(*state));
 	state->sign_blocks = NULL;
 	state->sign_buf = NULL;
 	state->archive = NULL;
 	r = read_file_from_archive(*archive, entry, HASH_FNAME,
 	    &hash_file, &hash_len);
 	if (r == -1) {
 		archive_read_finish(*archive);
 		*archive = NULL;
 		free(state);
 		goto no_valid_signature;
 	} else if (r == 1) {
 		free(state);
 		goto no_valid_signature;
+	}
 	if (parse_hash_file(hash_file, pkgname, state))
 		goto no_valid_signature;
 	r = read_file_from_archive(*archive, entry, SIGNATURE_FNAME,
 	    &signature_file, &signature_len);
 	if (r == -1) {
 		archive_read_finish(*archive);
 		*archive = NULL;
 		free(state);
 		free(hash_file);
 		goto no_valid_signature;
 	} else if (r != 0) {
 		if (*entry != NULL)
 			r = read_file_from_archive(*archive, entry,
 			    GPG_SIGNATURE_FNAME,
 			    &signature_file, &signature_len);
 		if (r == -1) {
 			archive_read_finish(*archive);
 			*archive = NULL;
 			free(state);
 			free(hash_file);
 			goto no_valid_signature;
 		} else if (r != 0) {
 			free(hash_file);
 			free(state);
 			goto no_valid_signature;
+		}
 		has_sig = !detached_gpg_verify(hash_file, hash_len,
 		    signature_file, signature_len, gpg_keyring_verify);
 		free(signature_file);
 	} else {
 #ifdef HAVE_SSL
 		has_sig = !easy_pkcs7_verify(hash_file, hash_len, signature_file,
 		    signature_len, certs_packages, 1);
 		free(signature_file);
 #else
 		warnx("No OpenSSL support compiled in, skipping signature");
 		has_sig = 0;
 		free(signature_file);
 #endif
+	}
 	r = archive_read_next_header(*archive, &my_entry);
 	if (r != ARCHIVE_OK) {
 		warnx("Cannot read inner package: %s",
 		    archive_error_string(*archive));
 		free_signature_int(state);
 		goto no_valid_signature;
+	}
 	if (archive_entry_size(my_entry) != state->pkg_size) {
 		warnx("Package size doesn't match signature");
 		free_signature_int(state);
 		goto no_valid_signature;
+	}
 	state->archive = *archive;
 	a = archive_read_new();
 	archive_read_support_compression_all(a);
 	archive_read_support_format_all(a);
 	if (archive_read_open(a, state, NULL, verify_signature_read_cb, NULL)) {
 		warnx("Can't open signed package file");
 		archive_read_finish(a);
 		free_signature_int(state);
 		goto no_valid_signature;
+	}
 	*archive = a;
 	*entry = NULL;
 	*cookie = state;
 	return has_sig ? 0 : -1;
 no_valid_signature:
 	return -1;
+}
 int
 pkg_full_signature_check(struct archive **archive)
+{
 	struct archive_entry *entry = NULL;
 	char *pkgname;
 	void *cookie;
 	int r;
 	if (pkg_verify_signature(archive, &entry, &pkgname, &cookie))
 		return -1;
 	if (pkgname == NULL)
 		return 0;
 	/* XXX read PLIST and compare pkgname */
 	while ((r = archive_read_next_header(*archive, &entry)) == ARCHIVE_OK)
 		archive_read_data_skip(*archive);
 	pkg_free_signature(cookie);
 	free(pkgname);
 	return r == ARCHIVE_EOF ? 0 : -1;
+}
 static char *
 extract_pkgname(int fd)
+{
 	package_t plist;
 	plist_t *p;
 	struct archive *a;
 	struct archive_entry *entry;
 	char *buf;
 	ssize_t len;
 	int r;
 	a = archive_read_new();
 	archive_read_support_compression_all(a);
 	archive_read_support_format_all(a);
 	if (archive_read_open_fd(a, fd, 1024)) {
 		warnx("Cannot open binary package: %s",
 		    archive_error_string(a));
 		archive_read_finish(a);
 		return NULL;
+	}
 	r = archive_read_next_header(a, &entry);
 	if (r != ARCHIVE_OK) {
 		warnx("Cannot extract package name: %s",
 		    r == ARCHIVE_EOF ? "EOF" : archive_error_string(a));
 		archive_read_finish(a);
 		return NULL;
+	}
 	if (strcmp(archive_entry_pathname(entry), "+CONTENTS") != 0) {
 		warnx("Invalid binary package, doesn't start with +CONTENTS");
 		archive_read_finish(a);
 		return NULL;
+	}
 	if (archive_entry_size(entry) > SSIZE_MAX - 1) {
 		warnx("+CONTENTS too large to process");
 		archive_read_finish(a);
 		return NULL;
+	}
 	len = archive_entry_size(entry);
 	buf = xmalloc(len + 1);
 	if (archive_read_data(a, buf, len) != len) {
 		warnx("Short read when extracing +CONTENTS");
 		free(buf);
 		archive_read_finish(a);
 		return NULL;
+	}
 	buf[len] = '\0';
 	archive_read_finish(a);
 	parse_plist(&plist, buf);
 	free(buf);
 	p = find_plist(&plist, PLIST_NAME);
 	if (p != NULL) {
 		buf = xstrdup(p->name);
 	} else {
 		warnx("Invalid PLIST: missing @name");
 		buf = NULL;
+	}
 	free_plist(&plist);
 	if (lseek(fd, 0, SEEK_SET) != 0) {
 		warn("Cannot seek in archive");
 		free(buf);
 		return NULL;
+	}
 	return buf;
+}
 static const char hash_template[] =
 "pkgsrc signature\n"
 "\n"
 "version: 1\n"
 "pkgname: %s\n"
 "algorithm: SHA512\n"
 "block size: 65536\n"
 "file size: %lld\n"
 "\n";
 static const char hash_trailer[] = "end pkgsrc signature\n";
 #ifdef HAVE_SSL
 void
 pkg_sign_x509(const char *name, const char *output, const char *key_file, const char *cert_file)
+{
 	struct archive *pkg;
 	struct archive_entry *entry, *hash_entry, *sign_entry;
 	int fd;
 	struct stat sb;
 	char *hash_file, *signature_file, *tmp, *pkgname, hash[SHA512_DIGEST_STRING_LENGTH];
 	unsigned char block[65536];
 	off_t i, size;
 	size_t block_len, signature_len;
 	if ((fd = open(name, O_RDONLY)) == -1)
 		err(EXIT_FAILURE, "Cannot open binary package %s", name);
 	if (fstat(fd, &sb) == -1)
 		err(EXIT_FAILURE, "Cannot stat %s", name);
 	entry = archive_entry_new();
 	archive_entry_copy_stat(entry, &sb);
 	pkgname = extract_pkgname(fd);
 	hash_file = xasprintf(hash_template, pkgname,
 	    (long long)archive_entry_size(entry));
 	free(pkgname);
 	for (i = 0; i < archive_entry_size(entry); i += block_len) {
 		if (i + sizeof(block) < archive_entry_size(entry))
 			block_len = sizeof(block);
 		else
 			block_len = archive_entry_size(entry) % sizeof(block);
 		if (read(fd, block, block_len) != block_len)
 			err(2, "short read");
 		hash_block(block, block_len, hash);
 		tmp = xasprintf("%s%s\n", hash_file, hash);
 		free(hash_file);
 		hash_file = tmp;
+	}
 	tmp = xasprintf("%s%s", hash_file, hash_trailer);
 	free(hash_file);
 	hash_file = tmp;
 	if (easy_pkcs7_sign(hash_file, strlen(hash_file), &signature_file,
 	    &signature_len, key_file, cert_file))
 		err(EXIT_FAILURE, "Cannot sign hash file");
 	lseek(fd, 0, SEEK_SET);
 	sign_entry = archive_entry_clone(entry);
 	hash_entry = archive_entry_clone(entry);
 	pkgname = strrchr(name, '/');
 	archive_entry_set_pathname(entry, pkgname != NULL ? pkgname + 1 : name);
 	archive_entry_set_pathname(hash_entry, HASH_FNAME);
 	archive_entry_set_pathname(sign_entry, SIGNATURE_FNAME);
 	archive_entry_set_size(hash_entry, strlen(hash_file));
 	archive_entry_set_size(sign_entry, signature_len);
 	pkg = archive_write_new();
 	archive_write_set_compression_none(pkg);
 	archive_write_set_format_ar_bsd(pkg);
 	archive_write_open_filename(pkg, output);
 	archive_write_header(pkg, hash_entry);
 	archive_write_data(pkg, hash_file, strlen(hash_file));
 	archive_write_finish_entry(pkg);
 	archive_entry_free(hash_entry);
 	archive_write_header(pkg, sign_entry);
 	archive_write_data(pkg, signature_file, signature_len);
 	archive_write_finish_entry(pkg);
 	archive_entry_free(sign_entry);
 	size = archive_entry_size(entry);
 	archive_write_header(pkg, entry);
 	for (i = 0; i < size; i += block_len) {
 		if (i + sizeof(block) < size)
 			block_len = sizeof(block);
 		else
 			block_len = size % sizeof(block);
 		if (read(fd, block, block_len) != block_len)
 			err(2, "short read");
 		archive_write_data(pkg, block, block_len);
+	}
 	archive_write_finish_entry(pkg);
 	archive_entry_free(entry);
 	archive_write_finish(pkg);
 	close(fd);
 	exit(0);
+}
 #endif
 void
 pkg_sign_gpg(const char *name, const char *output)
+{
 	struct archive *pkg;
 	struct archive_entry *entry, *hash_entry, *sign_entry;
 	int fd;
 	struct stat sb;
 	char *hash_file, *signature_file, *tmp, *pkgname, hash[SHA512_DIGEST_STRING_LENGTH];
 	unsigned char block[65536];
 	off_t i, size;
 	size_t block_len, signature_len;
 	if ((fd = open(name, O_RDONLY)) == -1)
 		err(EXIT_FAILURE, "Cannot open binary package %s", name);
 	if (fstat(fd, &sb) == -1)
 		err(EXIT_FAILURE, "Cannot stat %s", name);
 	entry = archive_entry_new();
 	archive_entry_copy_stat(entry, &sb);
 	pkgname = extract_pkgname(fd);
 	hash_file = xasprintf(hash_template, pkgname,
 	    (long long)archive_entry_size(entry));
 	free(pkgname);
 	for (i = 0; i < archive_entry_size(entry); i += block_len) {
 		if (i + sizeof(block) < archive_entry_size(entry))
 			block_len = sizeof(block);
 		else
 			block_len = archive_entry_size(entry) % sizeof(block);
 		if (read(fd, block, block_len) != block_len)
 			err(2, "short read");
 		hash_block(block, block_len, hash);
 		tmp = xasprintf("%s%s\n", hash_file, hash);
 		free(hash_file);
 		hash_file = tmp;
+	}
 	tmp = xasprintf("%s%s", hash_file, hash_trailer);
 	free(hash_file);
 	hash_file = tmp;
 	if (detached_gpg_sign(hash_file, strlen(hash_file), &signature_file,
 	    &signature_len, gpg_keyring_sign, gpg_sign_as))
 		err(EXIT_FAILURE, "Cannot sign hash file");
 	lseek(fd, 0, SEEK_SET);
 	sign_entry = archive_entry_clone(entry);
 	hash_entry = archive_entry_clone(entry);
 	pkgname = strrchr(name, '/');
 	archive_entry_set_pathname(entry, pkgname != NULL ? pkgname + 1 : name);
 	archive_entry_set_pathname(hash_entry, HASH_FNAME);
 	archive_entry_set_pathname(sign_entry, GPG_SIGNATURE_FNAME);
 	archive_entry_set_size(hash_entry, strlen(hash_file));
 	archive_entry_set_size(sign_entry, signature_len);
 	pkg = archive_write_new();
 	archive_write_set_compression_none(pkg);
 	archive_write_set_format_ar_bsd(pkg);
 	archive_write_open_filename(pkg, output);
 	archive_write_header(pkg, hash_entry);
 	archive_write_data(pkg, hash_file, strlen(hash_file));
 	archive_write_finish_entry(pkg);
 	archive_entry_free(hash_entry);
 	archive_write_header(pkg, sign_entry);
 	archive_write_data(pkg, signature_file, signature_len);
 	archive_write_finish_entry(pkg);
 	archive_entry_free(sign_entry);
 	size = archive_entry_size(entry);
 	archive_write_header(pkg, entry);
 	for (i = 0; i < size; i += block_len) {
 		if (i + sizeof(block) < size)
 			block_len = sizeof(block);
 		else
 			block_len = size % sizeof(block);
 		if (read(fd, block, block_len) != block_len)
 			err(2, "short read");
 		archive_write_data(pkg, block, block_len);
+	}
 	archive_write_finish_entry(pkg);
 	archive_entry_free(entry);
 	archive_write_finish(pkg);
 	close(fd);
 	exit(0);
+}

 @@ -1,588 +1,590 @@
-/*	$NetBSD: vulnerabilities-file.c,v 1.4 2009/02/02 12:35:01 joerg Exp $	*/
+/*	$NetBSD: vulnerabilities-file.c,v 1.5 2009/03/02 14:59:14 joerg Exp $	*/
 /*-
  * 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_CONFIG_H
 #include "config.h"
 #endif
 #include <nbcompat.h>
 #if HAVE_SYS_CDEFS_H
 #include <sys/cdefs.h>
 #endif
-__RCSID("$NetBSD: vulnerabilities-file.c,v 1.4 2009/02/02 12:35:01 joerg Exp $");
+__RCSID("$NetBSD: vulnerabilities-file.c,v 1.5 2009/03/02 14:59:14 joerg Exp $");
 #if HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
 #if HAVE_SYS_WAIT_H
 #include <sys/wait.h>
 #endif
 #include <ctype.h>
 #if HAVE_ERR_H
 #include <err.h>
 #endif
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #ifndef NETBSD
 #include <nbcompat/sha1.h>
 #include <nbcompat/sha2.h>
 #else
 #include <sha1.h>
 #include <sha2.h>
 #endif
 #include <unistd.h>
 #include "lib.h"
 static const char pgp_msg_start[] = "-----BEGIN PGP SIGNED MESSAGE-----\n";
 static const char pgp_msg_end[] = "-----BEGIN PGP SIGNATURE-----\n";
 static const char pkcs7_begin[] = "-----BEGIN PKCS7-----\n";
 static const char pkcs7_end[] = "-----END PKCS7-----\n";
 static void
 verify_signature_pkcs7(const char *input)
+{
 #ifdef HAVE_SSL
 	const char *begin_pkgvul, *end_pkgvul, *begin_sig, *end_sig;
 	if (strncmp(input, pgp_msg_start, strlen(pgp_msg_start)) == 0) {
 		begin_pkgvul = input + strlen(pgp_msg_start);
 		if ((end_pkgvul = strstr(begin_pkgvul, pgp_msg_end)) == NULL)
 			errx(EXIT_FAILURE, "Invalid PGP signature");
 		if ((begin_sig = strstr(end_pkgvul, pkcs7_begin)) == NULL)
 			errx(EXIT_FAILURE, "No PKCS7 signature");
 	} else {
 		begin_pkgvul = input;
 		if ((begin_sig = strstr(begin_pkgvul, pkcs7_begin)) == NULL)
 			errx(EXIT_FAILURE, "No PKCS7 signature");
 		end_pkgvul = begin_sig;
+	}
 	if ((end_sig = strstr(begin_sig, pkcs7_end)) == NULL)
 		errx(EXIT_FAILURE, "Invalid PKCS7 signature");
 	end_sig += strlen(pkcs7_end);
 	if (easy_pkcs7_verify(begin_pkgvul, end_pkgvul - begin_pkgvul,
 	    begin_sig, end_sig - begin_sig, certs_pkg_vulnerabilities, 0))
 		errx(EXIT_FAILURE, "Unable to verify PKCS7 signature");
 #else
 	errx(EXIT_FAILURE, "OpenSSL support is not compiled in");
 #endif
+}
 static void
 verify_signature(const char *input, size_t input_len)
+{
 	if (gpg_cmd == NULL && certs_pkg_vulnerabilities == NULL)
 		errx(EXIT_FAILURE,
 		    "At least GPG or CERTIFICATE_ANCHOR_PKGVULN "
 		    "must be configured");
 	if (gpg_cmd != NULL)
 		inline_gpg_verify(input, input_len, gpg_keyring_pkgvuln);
 	if (certs_pkg_vulnerabilities != NULL)
 		verify_signature_pkcs7(input);
+}
 static void *
 sha512_hash_init(void)
+{
 	static SHA512_CTX hash_ctx;
 	SHA512_Init(&hash_ctx);
 	return &hash_ctx;
+}
 static void
 sha512_hash_update(void *ctx, const void *data, size_t len)
+{
 	SHA512_CTX *hash_ctx = ctx;
 	SHA512_Update(hash_ctx, data, len);
+}
 static const char *
 sha512_hash_finish(void *ctx)
+{
 	static char hash[SHA512_DIGEST_STRING_LENGTH];
 	unsigned char digest[SHA512_DIGEST_LENGTH];
 	SHA512_CTX *hash_ctx = ctx;
 	int i;
 	SHA512_Final(digest, hash_ctx);
 	for (i = 0; i < SHA512_DIGEST_LENGTH; ++i) {
 		unsigned char c;
 		c = digest[i] / 16;
 		if (c < 10)
 			hash[2 * i] = '0' + c;
 		else
 			hash[2 * i] = 'a' - 10 + c;
 		c = digest[i] % 16;
 		if (c < 10)
 			hash[2 * i + 1] = '0' + c;
 		else
 			hash[2 * i + 1] = 'a' - 10 + c;
+	}
 	hash[2 * i] = '\0';
 	return hash;
+}
 static void *
 sha1_hash_init(void)
+{
 	static SHA1_CTX hash_ctx;
 	SHA1Init(&hash_ctx);
 	return &hash_ctx;
+}
 static void
 sha1_hash_update(void *ctx, const void *data, size_t len)
+{
 	SHA1_CTX *hash_ctx = ctx;
 	SHA1Update(hash_ctx, data, len);
+}
 static const char *
 sha1_hash_finish(void *ctx)
+{
 	static char hash[SHA1_DIGEST_STRING_LENGTH];
 	SHA1_CTX *hash_ctx = ctx;
 	SHA1End(hash_ctx, hash);
 	return hash;
+}
 static const struct hash_algorithm {
 	const char *name;
 	size_t name_len;
 	void * (*init)(void);
 	void (*update)(void *, const void *, size_t);
 	const char * (* finish)(void *);
 } hash_algorithms[] = {
 	{ "SHA512", 6, sha512_hash_init, sha512_hash_update,
 	  sha512_hash_finish },
 	{ "SHA1", 4, sha1_hash_init, sha1_hash_update,
 	  sha1_hash_finish },
 	{ NULL, 0, NULL, NULL, NULL }
 };
 static void
 verify_hash(const char *input, const char *hash_line)
+{
 	const struct hash_algorithm *hash;
 	void *ctx;
 	const char *last_start, *next, *hash_value;
 	int in_pgp_msg;
 	for (hash = hash_algorithms; hash->name != NULL; ++hash) {
 		if (strncmp(hash_line, hash->name, hash->name_len))
 			continue;
 		if (isspace((unsigned char)hash_line[hash->name_len]))
 			break;
+	}
 	if (hash->name == NULL) {
 		const char *end_name;
 		for (end_name = hash_line; *end_name != '\0'; ++end_name) {
 			if (!isalnum((unsigned char)*end_name))
 				break;
+		}
 		warnx("Unsupported hash algorithm: %.*s",
 		    (int)(end_name - hash_line), hash_line);
 		return;
+	}
 	hash_line += hash->name_len;
 	if (!isspace((unsigned char)*hash_line))
 		errx(EXIT_FAILURE, "Invalid #CHECKSUM");
 	while (isspace((unsigned char)*hash_line) && *hash_line != '\n')
 		++hash_line;
 	if (*hash_line == '\n')
 		errx(EXIT_FAILURE, "Invalid #CHECKSUM");
 	ctx = (*hash->init)();
 	if (strncmp(input, pgp_msg_start, strlen(pgp_msg_start)) == 0) {
 		input += strlen(pgp_msg_start);
 		in_pgp_msg = 1;
 	} else {
 		in_pgp_msg = 0;
+	}
 	for (last_start = input; *input != '\0'; input = next) {
 		if ((next = strchr(input, '\n')) == NULL)
 			errx(EXIT_FAILURE, "Missing newline in pkg-vulnerabilities");
 		++next;
 		if (in_pgp_msg && strncmp(input, pgp_msg_end, strlen(pgp_msg_end)) == 0)
 			break;
 		if (!in_pgp_msg && strncmp(input, pkcs7_begin, strlen(pkcs7_begin)) == 0)
 			break;
 		if (*input == '\n' ||
 		    strncmp(input, "Hash:", 5) == 0 ||
 		    strncmp(input, "# $NetBSD", 9) == 0 ||
 		    strncmp(input, "#CHECKSUM", 9) == 0) {
 			(*hash->update)(ctx, last_start, input - last_start);
 			last_start = next;
+		}
+	}
 	(*hash->update)(ctx, last_start, input - last_start);
 	hash_value = (*hash->finish)(ctx);
 	if (strncmp(hash_line, hash_value, strlen(hash_value)))
 		errx(EXIT_FAILURE, "%s hash doesn't match", hash->name);
 	hash_line += strlen(hash_value);
 	while (isspace((unsigned char)*hash_line) && *hash_line != '\n')
 		++hash_line;
 	if (!isspace((unsigned char)*hash_line))
 		errx(EXIT_FAILURE, "Invalid #CHECKSUM");
+}
 static void
 add_vulnerability(struct pkg_vulnerabilities *pv, size_t *allocated, const char *line)
+{
 	size_t len_pattern, len_class, len_url;
 	const char *start_pattern, *start_class, *start_url;
 	start_pattern = line;
 	start_class = line;
 	while (*start_class != '\0' && !isspace((unsigned char)*start_class))
 		++start_class;
 	len_pattern = start_class - line;
 	while (*start_class != '\n' && isspace((unsigned char)*start_class))
 		++start_class;
 	if (*start_class == '0' || *start_class == '\n')
 		errx(EXIT_FAILURE, "Input error: missing classification");
 	start_url = start_class;
 	while (*start_url != '\0' && !isspace((unsigned char)*start_url))
 		++start_url;
 	len_class = start_url - start_class;
 	while (*start_url != '\n' && isspace((unsigned char)*start_url))
 		++start_url;
 	if (*start_url == '0' || *start_url == '\n')
 		errx(EXIT_FAILURE, "Input error: missing URL");
 	line = start_url;
 	while (*line != '\0' && !isspace((unsigned char)*line))
 		++line;
 	len_url = line - start_url;
 	if (pv->entries == *allocated) {
 		if (*allocated == 0)
 			*allocated = 16;
 		else if (*allocated <= SSIZE_MAX / 2)
 			*allocated *= 2;
 		else
 			errx(EXIT_FAILURE, "Too many vulnerabilities");
 		pv->vulnerability = xrealloc(pv->vulnerability,
 		    sizeof(char *) * *allocated);
 		pv->classification = xrealloc(pv->classification,
 		    sizeof(char *) * *allocated);
 		pv->advisory = xrealloc(pv->advisory,
 		    sizeof(char *) * *allocated);
+	}
 	pv->vulnerability[pv->entries] = xmalloc(len_pattern + 1);
 	memcpy(pv->vulnerability[pv->entries], start_pattern, len_pattern);
 	pv->vulnerability[pv->entries][len_pattern] = '\0';
 	pv->classification[pv->entries] = xmalloc(len_class + 1);
 	memcpy(pv->classification[pv->entries], start_class, len_class);
 	pv->classification[pv->entries][len_class] = '\0';
 	pv->advisory[pv->entries] = xmalloc(len_url + 1);
 	memcpy(pv->advisory[pv->entries], start_url, len_url);
 	pv->advisory[pv->entries][len_url] = '\0';
 	++pv->entries;
+}
 struct pkg_vulnerabilities *
 read_pkg_vulnerabilities(const char *path, int ignore_missing, int check_sum)
+{
 	struct pkg_vulnerabilities *pv;
 	struct stat st;
 	int fd;
 	char *input, *decompressed_input;
 	size_t input_len, decompressed_len;
 	ssize_t bytes_read;
 	if ((fd = open(path, O_RDONLY)) == -1) {
 		if (errno == ENOENT && ignore_missing)
 			return NULL;
 		err(EXIT_FAILURE, "Cannot open %s", path);
+	}
 	if (fstat(fd, &st) == -1)
 		err(EXIT_FAILURE, "Cannot stat %s", path);
 	if ((st.st_mode & S_IFMT) != S_IFREG)
 		errx(EXIT_FAILURE, "Input is not regular file");
 	if (st.st_size > SSIZE_MAX - 1)
 		errx(EXIT_FAILURE, "Input too large");
 	input_len = (size_t)st.st_size;
 	if (input_len < 4)
 		err(EXIT_FAILURE, "Input too short for a pkg_vulnerability file");
 	input = xmalloc(input_len + 1);
 	if ((bytes_read = read(fd, input, input_len)) == -1)
 		err(1, "Failed to read input");
 	if (bytes_read != st.st_size)
 		errx(1, "Unexpected short read");
 	close(fd);
 	if (decompress_buffer(input, input_len, &decompressed_input,
 	    &decompressed_len)) {
 		free(input);
 		input = decompressed_input;
 		input_len = decompressed_len;
+	}
 	pv = parse_pkg_vulnerabilities(input, input_len, check_sum);
 	free(input);
 	return pv;
+}
 struct pkg_vulnerabilities *
 parse_pkg_vulnerabilities(const char *input, size_t input_len, int check_sum)
+{
 	struct pkg_vulnerabilities *pv;
 	long version;
 	char *end;
 	const char *iter, *next;
 	size_t allocated_vulns;
 	int in_pgp_msg;
 	pv = xmalloc(sizeof(*pv));
 	allocated_vulns = pv->entries = 0;
 	pv->vulnerability = NULL;
 	pv->classification = NULL;
 	pv->advisory = NULL;
 	if (strlen(input) != input_len)
 		errx(1, "Invalid input (NUL character found)");
 	if (check_sum)
 		verify_signature(input, input_len);
 	if (strncmp(input, pgp_msg_start, strlen(pgp_msg_start)) == 0) {
 		iter = input + strlen(pgp_msg_start);
 		in_pgp_msg = 1;
 	} else {
 		iter = input;
 		in_pgp_msg = 0;
+	}
 	for (; *iter; iter = next) {
 		if ((next = strchr(iter, '\n')) == NULL)
 			errx(EXIT_FAILURE, "Missing newline in pkg-vulnerabilities");
 		++next;
 		if (*iter == '\0' || *iter == '\n')
 			continue;
 		if (strncmp(iter, "Hash:", 5) == 0)
 			continue;
 		if (strncmp(iter, "# $NetBSD", 9) == 0)
 			continue;
 		if (*iter == '#' && isspace((unsigned char)iter[1])) {
 			for (++iter; iter != next; ++iter) {
 				if (!isspace((unsigned char)*iter))
 					errx(EXIT_FAILURE, "Invalid header");
+			}
 			continue;
+		}
 		if (strncmp(iter, "#FORMAT", 7) != 0)
 			errx(EXIT_FAILURE, "Input header is malformed");
 		iter += 7;
 		if (!isspace((unsigned char)*iter))
 			errx(EXIT_FAILURE, "Invalid #FORMAT");
 		++iter;
 		version = strtol(iter, &end, 10);
 		if (iter == end || version != 1 || *end != '.')
 			errx(EXIT_FAILURE, "Input #FORMAT");
 		iter = end + 1;
 		version = strtol(iter, &end, 10);
 		if (iter == end || version != 1 || *end != '.')
 			errx(EXIT_FAILURE, "Input #FORMAT");
 		iter = end + 1;
 		version = strtol(iter, &end, 10);
 		if (iter == end || version != 0)
 			errx(EXIT_FAILURE, "Input #FORMAT");
 		for (iter = end; iter != next; ++iter) {
 			if (!isspace((unsigned char)*iter))
 				errx(EXIT_FAILURE, "Input #FORMAT");
+		}
 		break;
+	}
 	if (*iter == '\0')
 		errx(EXIT_FAILURE, "Missing #CHECKSUM or content");
 	for (iter = next; *iter; iter = next) {
 		if ((next = strchr(iter, '\n')) == NULL)
 			errx(EXIT_FAILURE, "Missing newline in pkg-vulnerabilities");
 		++next;
 		if (*iter == '\0' || *iter == '\n')
 			continue;
 		if (in_pgp_msg && strncmp(iter, pgp_msg_end, strlen(pgp_msg_end)) == 0)
 			break;
 		if (!in_pgp_msg && strncmp(iter, pkcs7_begin, strlen(pkcs7_begin)) == 0)
 			break;
 		if (*iter == '#' &&
 		    (iter[1] == '\0' || iter[1] == '\n' || isspace((unsigned char)iter[1])))
 			continue;
 		if (strncmp(iter, "#CHECKSUM", 9) == 0) {
 			iter += 9;
 			if (!isspace((unsigned char)*iter))
 				errx(EXIT_FAILURE, "Invalid #CHECKSUM");
 			while (isspace((unsigned char)*iter))
 				++iter;
 			verify_hash(input, iter);
 			continue;
+		}
 		if (*iter == '#') {
 			/*
 			 * This should really be an error,
 			 * but it is still used.
 			 */
 			/* errx(EXIT_FAILURE, "Invalid data line starting with #"); */
 			continue;
+		}
 		add_vulnerability(pv, &allocated_vulns, iter);
+	}
 	if (pv->entries != allocated_vulns) {
 		pv->vulnerability = xrealloc(pv->vulnerability,
 		    sizeof(char *) * pv->entries);
 		pv->classification = xrealloc(pv->classification,
 		    sizeof(char *) * pv->entries);
 		pv->advisory = xrealloc(pv->advisory,
 		    sizeof(char *) * pv->entries);
+	}
 	return pv;
+}
 void
 free_pkg_vulnerabilities(struct pkg_vulnerabilities *pv)
+{
 	size_t i;
 	for (i = 0; i < pv->entries; ++i) {
 		free(pv->vulnerability[i]);
 		free(pv->classification[i]);
 		free(pv->advisory[i]);
+	}
 	free(pv->vulnerability);
 	free(pv->classification);
 	free(pv->advisory);
 	free(pv);
+}
 static int
 check_ignored_entry(struct pkg_vulnerabilities *pv, size_t i)
+{
 	const char *iter, *next;
 	size_t entry_len, url_len;
 	if (ignore_advisories == NULL)
 		return 0;
 	url_len = strlen(pv->advisory[i]);
 	for (iter = ignore_advisories; *iter; iter = next) {
 		if ((next = strchr(iter, '\n')) == NULL) {
 			entry_len = strlen(iter);
 			next = iter + entry_len;
 		} else {
 			entry_len = next - iter;
 			++next;
+		}
 		if (url_len != entry_len)
 			continue;
 		if (strncmp(pv->advisory[i], iter, entry_len) == 0)
 			return 1;
+	}
 	return 0;
+}
 int
 audit_package(struct pkg_vulnerabilities *pv, const char *pkgname,
     const char *limit_vul_types, int check_eol, int output_type)
+{
 	FILE *output = output_type == 1 ? stdout : stderr;
 	size_t i;
 	int retval;
 	retval = 0;
 	for (i = 0; i < pv->entries; ++i) {
 		if (check_ignored_entry(pv, i))
 			continue;
 		if (limit_vul_types != NULL &&
 		    strcmp(limit_vul_types, pv->classification[i]))
 			continue;
 		if (!pkg_match(pv->vulnerability[i], pkgname))
 			continue;
 		if (strcmp("eol", pv->classification[i]) == 0) {
 			if (!check_eol)
 				continue;
 			if (output_type == 0) {
 				puts(pkgname);
 				continue;
+			}
 			fprintf(output,
 			    "Package %s has reached end-of-life (eol), "
 			    "see %s/eol-packages\n", pkgname,
 			    tnf_vulnerability_base);
 			continue;
+		}
 		retval = 1;
 		if (output_type == 0) {
 			puts(pkgname);
 		} else {
 			fprintf(output,
 			    "Package %s has a %s vulnerability, see %s\n",
 			    pkgname, pv->classification[i], pv->advisory[i]);
+		}
+	}
 	return retval;
+}

 @@ -1,32 +1,32 @@
-/*	$NetBSD: version.h,v 1.115 2009/02/28 16:03:56 joerg Exp $	*/
+/*	$NetBSD: version.h,v 1.116 2009/03/02 14:59:14 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 "20090228"
+#define PKGTOOLS_VERSION "20090301"
 #endif /* _INST_LIB_VERSION_H_ */