 @@ -1,255 +1,257 @@
-/*	$NetBSD: perform.c,v 1.19.2.3 2008/08/10 22:08:16 joerg Exp $	*/
+/*	$NetBSD: perform.c,v 1.19.2.4 2008/08/11 15:58:15 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
 #if 0
 static const char *rcsid = "from FreeBSD Id: perform.c,v 1.38 1997/10/13 15:03:51 jkh Exp";
 #else
-__RCSID("$NetBSD: perform.c,v 1.19.2.3 2008/08/10 22:08:16 joerg Exp $");
+__RCSID("$NetBSD: perform.c,v 1.19.2.4 2008/08/11 15:58:15 joerg Exp $");
 #endif
 #endif
 /*
  * 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
+ *
  * This is the main body of the create module.
+ *
  */
 #include "lib.h"
 #include "create.h"
 #if HAVE_ERR_H
 #include <err.h>
 #endif
 #if HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 static void
 sanity_check(void)
+{
 	if (!Comment)
 		errx(2, "required package comment string is missing (-c comment)");
 	if (!Desc)
 		errx(2, "required package description string is missing (-d desc)");
 	if (!Contents)
 		errx(2, "required package contents list is missing (-f [-]file)");
+}
 static void
 register_depends(package_t *plist, char *deps, int build_only)
+{
 	char *cp;
 	if (Verbose && !PlistOnly) {
 		if (build_only)
 			printf("Registering build depends:");
 		else
 			printf("Registering depends:");
+	}
 	while (deps) {
 		cp = strsep(&deps, " \t\n");
 		if (*cp) {
 			char *best_installed;
 			best_installed = find_best_matching_installed_pkg(cp);
 			if (best_installed != NULL) {
 				add_plist(plist, PLIST_BLDDEP, best_installed);
 				if (Verbose && !PlistOnly && build_only)
 					printf(" %s", cp);
 			} else
 				warnx("No matching package installed for %s", cp);
 			free(best_installed);
 			if (!build_only) {
 				add_plist(plist, PLIST_PKGDEP, cp);
 				if (Verbose && !PlistOnly)
 					printf(" %s", cp);
+			}
+		}
+	}
 	if (Verbose && !PlistOnly)
 		printf(".\n");
+}
 /*
  *  Expect "fname" to point at a file, and read it into
  *  the buffer returned.
  */
 static char   *
 fileGetContents(char *fname)
+{
 	char   *contents;
 	struct stat sb;
 	int     fd;
 	if (stat(fname, &sb) == FAIL) {
 		cleanup(0);
 		errx(2, "can't stat '%s'", fname);
+	}
 	contents = xmalloc((size_t) (sb.st_size) + 1);
 	fd = open(fname, O_RDONLY, 0);
 	if (fd == FAIL) {
 		cleanup(0);
 		errx(2, "unable to open '%s' for reading", fname);
+	}
 	if (read(fd, contents, (size_t) sb.st_size) != (size_t) sb.st_size) {
 		cleanup(0);
 		errx(2, "short read on '%s' - did not get %lld bytes",
 		    fname, (long long) sb.st_size);
+	}
 	close(fd);
 	contents[(size_t) sb.st_size] = '\0';
 	return contents;
+}
 /*
  * Get a string parameter as a file spec or as a "contents follow -" spec
  */
 static void
 get_dash_string(char **s)
+{
 	if (**s == '-')
 		*s = xstrdup(*s + 1);
 	else
 		*s = fileGetContents(*s);
+}
 int
 pkg_perform(const char *pkg)
+{
 	char   *cp;
 	FILE   *pkg_in;
 	package_t plist;
 	const char *full_pkg, *suffix;
 	char *allocated_pkg;
 	int retval;
 	/* Break the package name into base and desired suffix (if any) */
 	if ((cp = strrchr(pkg, '.')) != NULL) {
 		allocated_pkg = xmalloc(cp - pkg + 1);
 		memcpy(allocated_pkg, pkg, cp - pkg);
 		allocated_pkg[cp - pkg] = '\0';
 		suffix = cp + 1;
 		full_pkg = pkg;
 		pkg = allocated_pkg;
 	} else {
 		allocated_pkg = NULL;
 		full_pkg = pkg;
 		suffix = "tgz";
+	}
 	/* Preliminary setup */
 	sanity_check();
 	if (Verbose && !PlistOnly)
 		printf("Creating package %s\n", pkg);
 	get_dash_string(&Comment);
 	get_dash_string(&Desc);
 	if (IS_STDIN(Contents))
 		pkg_in = stdin;
 	else {
 		pkg_in = fopen(Contents, "r");
 		if (!pkg_in)
 			errx(2, "unable to open contents file '%s' for input", Contents);
+	}
 	plist.head = plist.tail = NULL;
 	/* If a SrcDir override is set, add it now */
 	if (SrcDir) {
 		if (Verbose && !PlistOnly)
 			printf("Using SrcDir value of %s\n", (realprefix) ? realprefix : SrcDir);
 		add_plist(&plist, PLIST_SRC, SrcDir);
+	}
 	/* Stick the dependencies, if any, at the top */
 	if (Pkgdeps)
 		register_depends(&plist, Pkgdeps, 0);
 	/*
 	 * Put the build dependencies after the dependencies.
 	 * This works due to the evaluation order in pkg_add.
 	 */
 	if (BuildPkgdeps)
 		register_depends(&plist, BuildPkgdeps, 1);
 	/* Put the conflicts directly after the dependencies, if any */
 	if (Pkgcfl) {
 		if (Verbose && !PlistOnly)
 			printf("Registering conflicts:");
 		while (Pkgcfl) {
 			cp = strsep(&Pkgcfl, " \t\n");
 			if (*cp) {
 				add_plist(&plist, PLIST_PKGCFL, cp);
 				if (Verbose && !PlistOnly)
 					printf(" %s", cp);
+			}
+		}
 		if (Verbose && !PlistOnly)
 			printf(".\n");
+	}
 	/* Slurp in the packing list */
-	read_plist(&plist, pkg_in);
+	append_plist(&plist, pkg_in);
 	if (pkg_in != stdin)
 		fclose(pkg_in);
 	/* Prefix should override the packing list */
 	if (Prefix) {
 		delete_plist(&plist, FALSE, PLIST_CWD, NULL);
 		add_plist_top(&plist, PLIST_CWD, Prefix);
+	}
 	/*
          * Run down the list and see if we've named it, if not stick in a name
          * at the top.
          */
 	if (find_plist(&plist, PLIST_NAME) == NULL) {
 		add_plist_top(&plist, PLIST_NAME, basename_of(pkg));
+	}
 	/* Make first "real contents" pass over it */
 	check_list(&plist, basename_of(pkg));
 	/*
          * We're just here for to dump out a revised plist for the FreeBSD ports
          * hack.  It's not a real create in progress.
          */
 	if (PlistOnly) {
 		write_plist(&plist, stdout, realprefix);
 		retval = TRUE;
 	} else {
 #ifdef BOOTSTRAP
 		warnx("Package building is not supported in bootstrap mode");
 		retval = FALSE;
 #else
 		retval = pkg_build(pkg, full_pkg, suffix, &plist);
 #endif
+	}
 	/* Cleanup */
 	free(Comment);
 	free(Desc);
 	free_plist(&plist);
 	free(allocated_pkg);
 	return retval;
+}

 @@ -1,416 +1,417 @@
-/* $NetBSD: lib.h,v 1.42.2.13 2008/08/05 22:56:24 joerg Exp $ */
+/* $NetBSD: lib.h,v 1.42.2.14 2008/08/11 15:58:15 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(const char *, const char *, const char *, const char *);
 #endif
 #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
 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 *config_file;
 extern const char *verified_installation;
 extern const char *gpg_cmd;
 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,729 +1,735 @@
-/*	$NetBSD: plist.c,v 1.17.4.9 2008/08/10 22:09:38 joerg Exp $	*/
+/*	$NetBSD: plist.c,v 1.17.4.10 2008/08/11 15:58:15 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
 #if 0
 static const char *rcsid = "from FreeBSD Id: plist.c,v 1.24 1997/10/08 07:48:15 charnier Exp";
 #else
-__RCSID("$NetBSD: plist.c,v 1.17.4.9 2008/08/10 22:09:38 joerg Exp $");
+__RCSID("$NetBSD: plist.c,v 1.17.4.10 2008/08/11 15:58:15 joerg Exp $");
 #endif
 #endif
 /*
  * 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
+ *
  * General packing list routines.
+ *
  */
 /*-
  * 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.
  */
 #include "lib.h"
 #if HAVE_ERRNO_H
 #include <errno.h>
 #endif
 #if HAVE_ERR_H
 #include <err.h>
 #endif
 #ifndef NETBSD
 #include <nbcompat/md5.h>
 #else
 #include <md5.h>
 #endif
 /* This struct defines a plist command type */
 typedef struct cmd_t {
 	const char   *c_s;		/* string to recognise */
 	pl_ent_t c_type;	/* type of command */
 	int     c_argc;		/* # of arguments */
 	int     c_subst;	/* can substitute real prefix */
 }       cmd_t;
 /* Commands to recognise */
 static const cmd_t cmdv[] = {
 	{"cwd", PLIST_CWD, 1, 1},
 	{"src", PLIST_SRC, 1, 1},
 	{"cd", PLIST_CWD, 1, 1},
 	{"exec", PLIST_CMD, 1, 0},
 	{"unexec", PLIST_UNEXEC, 1, 0},
 	{"mode", PLIST_CHMOD, 1, 0},
 	{"owner", PLIST_CHOWN, 1, 0},
 	{"group", PLIST_CHGRP, 1, 0},
 	{"comment", PLIST_COMMENT, 1, 0},
 	{"ignore", PLIST_IGNORE, 0, 0},
 	{"ignore_inst", PLIST_IGNORE_INST, 0, 0},
 	{"name", PLIST_NAME, 1, 0},
 	{"display", PLIST_DISPLAY, 1, 0},
 	{"pkgdep", PLIST_PKGDEP, 1, 0},
 	{"pkgcfl", PLIST_PKGCFL, 1, 0},
 	{"mtree", PLIST_MTREE, 1, 0},
 	{"dirrm", PLIST_DIR_RM, 1, 0},
 	{"option", PLIST_OPTION, 1, 0},
 	{"blddep", PLIST_BLDDEP, 1, 0},
 	{NULL, FAIL, 0, 0}
 };
 /*
  * Add an item to the end of a packing list
  */
 void
 add_plist(package_t *p, pl_ent_t type, const char *arg)
+{
 	plist_t *tmp;
 	tmp = new_plist_entry();
 	tmp->name = (arg == NULL) ? NULL : xstrdup(arg);
 	tmp->type = type;
 	if (!p->head) {
 		p->head = p->tail = tmp;
 	} else {
 		tmp->prev = p->tail;
 		p->tail->next = tmp;
 		p->tail = tmp;
+	}
+}
 /*
  * Add an item to the start of a packing list
  */
 void
 add_plist_top(package_t *p, pl_ent_t type, const char *arg)
+{
 	plist_t *tmp;
 	tmp = new_plist_entry();
 	tmp->name = (arg == NULL) ? NULL : xstrdup(arg);
 	tmp->type = type;
 	if (!p->head) {
 		p->head = p->tail = tmp;
 	} else {
 		tmp->next = p->head;
 		p->head->prev = tmp;
 		p->head = tmp;
+	}
+}
 /*
  * Return the last (most recent) entry in a packing list
  */
 plist_t *
 last_plist(package_t *p)
+{
 	return p->tail;
+}
 /*
  * Mark all items in a packing list to prevent iteration over them
  */
 void
 mark_plist(package_t *pkg)
+{
 	plist_t *pp;
 	for (pp = pkg->head; pp; pp = pp->next) {
 		pp->marked = TRUE;
+	}
+}
 /*
  * Find a given item in a packing list and, if so, return it (else NULL)
  */
 plist_t *
 find_plist(package_t *pkg, pl_ent_t type)
+{
 	plist_t *pp;
 	for (pp = pkg->head; pp && pp->type != type; pp = pp->next) {
+	}
 	return pp;
+}
 /*
  * Look for a specific boolean option argument in the list
  */
 char   *
 find_plist_option(package_t *pkg, char *name)
+{
 	plist_t *p;
 	for (p = pkg->head; p; p = p->next) {
 		if (p->type == PLIST_OPTION
 		    && strcmp(p->name, name) == 0) {
 			return p->name;
+		}
+	}
 	return (char *) NULL;
+}
 /*
  * Delete plist item 'type' in the list (if 'name' is non-null, match it
  * too.)  If 'all' is set, delete all items, not just the first occurance.
  */
 void
 delete_plist(package_t *pkg, Boolean all, pl_ent_t type, char *name)
+{
 	plist_t *p = pkg->head;
 	while (p) {
 		plist_t *pnext = p->next;
 		if (p->type == type && (!name || !strcmp(name, p->name))) {
 			free(p->name);
 			if (p->prev)
 				p->prev->next = pnext;
 			else
 				pkg->head = pnext;
 			if (pnext)
 				pnext->prev = p->prev;
 			else
 				pkg->tail = p->prev;
 			free(p);
 			if (!all)
 				return;
 			p = pnext;
 		} else
 			p = p->next;
+	}
+}
 /*
  * Allocate a new packing list entry, and return a pointer to it.
  */
 plist_t *
 new_plist_entry(void)
+{
 	return xcalloc(1, sizeof(plist_t));
+}
 /*
  * Free an entire packing list
  */
 void
 free_plist(package_t *pkg)
+{
 	plist_t *p = pkg->head;
 	while (p) {
 		plist_t *p1 = p->next;
 		free(p->name);
 		free(p);
 		p = p1;
+	}
 	pkg->head = pkg->tail = NULL;
+}
 /*
  * For an ASCII string denoting a plist command, return its code and
  * optionally its argument(s)
  */
 static int
 plist_cmd(const char *s, char **arg)
+{
 	const cmd_t *cmdp;
 	const char *cp, *sp;
 	char *sp2;
 	for (cmdp = cmdv; cmdp->c_s; ++cmdp) {
 		for (sp = s, cp = cmdp->c_s; *sp && *cp; ++cp, ++sp)
 			if (tolower((unsigned char)*sp) != *cp)
 				break;
 		if (*cp == '\0')
 			break;
+	}
 	if (cmdp->c_s == NULL || arg == NULL)
 		return cmdp->c_type;
 	while (isspace((unsigned char)*sp))
 		++sp;
 	*arg = xstrdup(sp);
 	if (*sp) {
 		sp2 = *arg + strlen(*arg) - 1;
 		/*
 		 * The earlier loop ensured that at least one non-whitespace
 		 * is in the string.
 		 */
 		while (isspace((unsigned char)*sp2))
 			--sp2;
 		sp2[1] = '\0';
+	}
 	return cmdp->c_type;
+}
 /*
  * Parse a packaging list from a memory buffer.
  */
 void
 parse_plist(package_t *pkg, const char *buf)
+{
 	int cmd;
 	char *line, *cp;
 	const char *eol, *next;
 	size_t len;
 	pkg->head = NULL;
 	pkg->tail = NULL;
 	for (; *buf; buf = next) {
 		/* Until add_plist can deal with trailing whitespace. */
 		if ((eol = strchr(buf, '\n')) != NULL) {
 			next = eol + 1;
 			len = eol - buf;
 		} else {
 			len = strlen(buf);
 			next = buf + len;
+		}
 		while (len && isspace((unsigned char)buf[len - 1]))
 			--len;
 		if (len == 0)
 			continue;
 		line = xmalloc(len + 1);
 		memcpy(line, buf, len);
 		line[len] = '\0';
 		if (*(cp = line) == CMD_CHAR) {
 			if ((cmd = plist_cmd(line + 1, &cp)) == FAIL) {
 				warnx("Unrecognised PLIST command `%s'", line);
 				continue;
+			}
 			if (*cp == '\0') {
 				free(cp);
 				cp = NULL;
+			}
 		} else {
 			cmd = PLIST_FILE;
+		}
 		add_plist(pkg, cmd, cp);
 		free(cp);
+	}
+}
 /*
  * Read a packing list from a file
  */
 void
-read_plist(package_t *pkg, FILE * fp)
+append_plist(package_t *pkg, FILE * fp)
+{
 	char    pline[MaxPathSize];
 	char   *cp;
 	int     cmd;
 	int     len;
 	int	free_cp;
 	pkg->head = NULL;
 	pkg->tail = NULL;
 	while (fgets(pline, MaxPathSize, fp) != (char *) NULL) {
 		for (len = strlen(pline); len &&
 		    isspace((unsigned char) pline[len - 1]);) {
 			pline[--len] = '\0';
+		}
 		if (len == 0) {
 			continue;
+		}
 		free_cp = 0;
 		if (*(cp = pline) == CMD_CHAR) {
 			if ((cmd = plist_cmd(pline + 1, &cp)) == FAIL) {
 				warnx("Unrecognised PLIST command `%s'", pline);
 				continue;
+			}
 			if (*cp == '\0') {
 				free(cp);
 				cp = NULL;
+			}
 			free_cp = 1;
 		} else {
 			cmd = PLIST_FILE;
+		}
 		add_plist(pkg, cmd, cp);
 		if (free_cp)
 			free(cp);
+	}
+}
 void
 read_plist(package_t *pkg, FILE * fp)
+{
 	pkg->head = NULL;
 	pkg->tail = NULL;
 	append_plist(pkg, fp);
+}
 /*
  * Write a packing list to a file, converting commands to ASCII equivs
  */
 void
 write_plist(package_t *pkg, FILE * fp, char *realprefix)
+{
 	plist_t *p;
 	const cmd_t *cmdp;
 	for (p = pkg->head; p; p = p->next) {
 		if (p->type == PLIST_FILE) {
 			/* Fast-track files - these are the most common */
 			(void) fprintf(fp, "%s\n", p->name);
 			continue;
+		}
 		for (cmdp = cmdv; cmdp->c_type != FAIL && cmdp->c_type != p->type; cmdp++) {
+		}
 		if (cmdp->c_type == FAIL) {
 			warnx("Unknown PLIST command type %d (%s)", p->type, p->name);
 		} else if (cmdp->c_argc == 0) {
 			(void) fprintf(fp, "%c%s\n", CMD_CHAR, cmdp->c_s);
 		} else if (cmdp->c_subst && realprefix) {
 			(void) fprintf(fp, "%c%s %s\n", CMD_CHAR, cmdp->c_s, realprefix);
 		} else {
 			(void) fprintf(fp, "%c%s %s\n", CMD_CHAR, cmdp->c_s,
 			    (p->name) ? p->name : "");
+		}
+	}
+}
 /*
  * Like write_plist, but compute memory string.
  */
 void
 stringify_plist(package_t *pkg, char **real_buf, size_t *real_len,
     const char *realprefix)
+{
 	plist_t *p;
 	const cmd_t *cmdp;
 	char *buf;
 	size_t len;
 	int item_len;
 	/* Pass One: compute output size only. */
 	len = 0;
 	for (p = pkg->head; p; p = p->next) {
 		if (p->type == PLIST_FILE) {
 			len += strlen(p->name) + 1;
 			continue;
+		}
 		for (cmdp = cmdv; cmdp->c_type != FAIL && cmdp->c_type != p->type; cmdp++) {
+		}
 		if (cmdp->c_type == FAIL)
 			continue;
 		if (cmdp->c_argc == 0)
 			len += 1 + strlen(cmdp->c_s) + 1;
 		else if (cmdp->c_subst && realprefix)
 			len += 1 + strlen(cmdp->c_s) + 1 + strlen(realprefix) + 1;
 		else
 			len += 1 + strlen(cmdp->c_s) + 1 + strlen(p->name ? p->name : "") + 1;
+	}
 	/* Pass Two: build actual string. */
 	buf = xmalloc(len + 1);
 	*real_buf = buf;
 	*real_len = len;
 	++len;
 #define	UPDATE_LEN							\
 do {									\
 	if (item_len < 0 || item_len > len)				\
 		errx(2, "Size computation failed, aborted.");		\
 	buf += item_len;						\
 	len -= item_len;						\
 } while (0)
 	for (p = pkg->head; p; p = p->next) {
 		if (p->type == PLIST_FILE) {
 			/* Fast-track files - these are the most common */
 			item_len = snprintf(buf, len, "%s\n", p->name);
 			UPDATE_LEN;
 			continue;
+		}
 		for (cmdp = cmdv; cmdp->c_type != FAIL && cmdp->c_type != p->type; cmdp++) {
+		}
 		if (cmdp->c_type == FAIL) {
 			warnx("Unknown PLIST command type %d (%s)", p->type, p->name);
 		} else if (cmdp->c_argc == 0) {
 			item_len = snprintf(buf, len, "%c%s\n", CMD_CHAR, cmdp->c_s);
 			UPDATE_LEN;
 		} else if (cmdp->c_subst && realprefix) {
 			item_len = snprintf(buf, len, "%c%s %s\n", CMD_CHAR, cmdp->c_s, realprefix);
 			UPDATE_LEN;
 		} else {
 			item_len = snprintf(buf, len, "%c%s %s\n", CMD_CHAR, cmdp->c_s,
 			    (p->name) ? p->name : "");
 			UPDATE_LEN;
+		}
+	}
 	if (len != 1)
 		errx(2, "Size computation failed, aborted.");
+}
 /*
  * Delete the results of a package installation.
+ *
  * This is here rather than in the pkg_delete code because pkg_add needs to
  * run it too in cases of failure.
  */
 int
 delete_package(Boolean ign_err, Boolean nukedirs, package_t *pkg,
     Boolean NoDeleteFiles, const char *destdir)
+{
 	plist_t *p;
 	char   *Where = ".", *last_file = "";
 	int     fail = SUCCESS;
 	Boolean preserve;
 	char    tmp[MaxPathSize], *name = NULL;
 	if (!pkgdb_open(ReadWrite)) {
 		err(EXIT_FAILURE, "cannot open pkgdb");
+	}
 	preserve = find_plist_option(pkg, "preserve") ? TRUE : FALSE;
 	for (p = pkg->head; p; p = p->next) {
 		switch (p->type) {
 		case PLIST_NAME:
 			name = p->name;
 			break;
 		case PLIST_IGNORE:
 			p = p->next;
 			break;
 		case PLIST_CWD:
 			Where = p->name;
 			if (Verbose)
 				printf("Change working directory to %s\n", Where);
 			break;
 		case PLIST_UNEXEC:
 			if (NoDeleteFiles)
 				break;
 			format_cmd(tmp, sizeof(tmp), p->name, Where, last_file);
 			/* XXX cleanup(0); */
 			printf("Executing `%s'\n", tmp);
 			if (!Fake && system(tmp)) {
 				warnx("unexec command for `%s' failed", tmp);
 				fail = FAIL;
+			}
 			break;
 		case PLIST_FILE:
 			last_file = p->name;
 			(void) snprintf(tmp, sizeof(tmp), "%s%s%s/%s",
 			    destdir ? destdir : "", destdir ? "/" : "",
 			    Where, p->name);
 			if (isdir(tmp)) {
 				warnx("attempting to delete directory `%s' as a file\n"
 				    "this packing list is incorrect - ignoring delete request", tmp);
 			} else {
 				int     restored = 0;	/* restored from preserve? */
 				if (p->next && p->next->type == PLIST_COMMENT) {
 					if (strncmp(p->next->name, CHECKSUM_HEADER, ChecksumHeaderLen) == 0) {
 						char   *cp, buf[LegibleChecksumLen];
 						if ((cp = MD5File(tmp, buf)) != NULL) {
 							/* Mismatch? */
 							if (strcmp(cp, p->next->name + ChecksumHeaderLen) != 0) {
 								printf("original MD5 checksum failed, %s: %s\n",
 								    Force ? "deleting anyway" : "not deleting", tmp);
 								if (!Force) {
 									fail = FAIL;
 									continue;
+								}
+							}
+						}
 					} else if (strncmp(p->next->name, SYMLINK_HEADER, SymlinkHeaderLen) == 0) {
 						char	buf[MaxPathSize + SymlinkHeaderLen];
 						int	cc;
 						(void) strlcpy(buf, SYMLINK_HEADER,
 						    sizeof(buf));
 						if ((cc = readlink(tmp, &buf[SymlinkHeaderLen],
 							  sizeof(buf) - SymlinkHeaderLen - 1)) < 0) {
 							warn("can't readlink `%s'", tmp);
 							continue;
+						}
 						buf[SymlinkHeaderLen + cc] = 0x0;
 						if (strcmp(buf, p->next->name) != 0) {
 							if ((cc = readlink(&buf[SymlinkHeaderLen], &buf[SymlinkHeaderLen],
 								  sizeof(buf) - SymlinkHeaderLen)) < 0) {
 								printf("symlink %s is not same as recorded value, %s: %s\n",
 								    buf, Force ? "deleting anyway" : "not deleting", tmp);
 								if (!Force) {
 									fail = FAIL;
 									continue;
+								}
+							}
 							buf[SymlinkHeaderLen + cc] = 0x0;
 							if (strcmp(buf, p->next->name) != 0) {
 								printf("symlink %s is not same as recorded value, %s: %s\n",
 								    buf, Force ? "deleting anyway" : "not deleting", tmp);
 								if (!Force) {
 									fail = FAIL;
 									continue;
+								}
+							}
+						}
+					}
+				}
 				if (Verbose && !NoDeleteFiles)
 					printf("Delete file %s\n", tmp);
 				if (!Fake && !NoDeleteFiles) {
 					if (delete_hierarchy(tmp, ign_err, nukedirs))
 						fail = FAIL;
 					if (preserve && name) {
 						char    tmp2[MaxPathSize];
 						if (make_preserve_name(tmp2, MaxPathSize, name, tmp)) {
 							if (fexists(tmp2)) {
 								if (rename(tmp2, tmp))
 									warn("preserve: unable to restore %s as %s",
 									    tmp2, tmp);
 								else
 									restored = 1;
+							}
+						}
+					}
+				}
 				if (!Fake) {
 					if (!restored) {
 #ifdef PKGDB_DEBUG
 						printf("pkgdb_remove(\"%s\")\n", tmp);	/* HF */
 #endif
 						errno = 0;
 						if (pkgdb_remove(tmp)) {
 							if (errno) {
 								perror("pkgdb_remove");
+							}
 						} else {
 #ifdef PKGDB_DEBUG
 							printf("pkgdb_remove: ok\n");
 #endif
+						}
+					}
+				}
+			}
 			break;
 		case PLIST_DIR_RM:
 			if (NoDeleteFiles)
 				break;
 			(void) snprintf(tmp, sizeof(tmp), "%s%s%s/%s",
 			    destdir ? destdir : "", destdir ? "/" : "",
 			    Where, p->name);
 			if (fexists(tmp)) {
 			    if (!isdir(tmp)) {
 				warnx("cannot remove `%s' as a directory\n"
 				    "this packing list is incorrect - ignoring delete request", tmp);
 			    } else {
 				if (Verbose)
 					printf("Delete directory %s\n", tmp);
 				if (!Fake && delete_hierarchy(tmp, ign_err, FALSE)) {
 					warnx("unable to completely remove directory '%s'", tmp);
 					fail = FAIL;
+				}
+			    }
 			} else {
 			    warnx("cannot remove non-existent directory `%s'\n"
 			            "this packing list is incorrect - ignoring delete request", tmp);
+			}
 			last_file = p->name;
 			break;
 		default:
 			break;
+		}
+	}
 	pkgdb_close();
 	return fail;
+}
 /*
  * Selectively delete a hierarchy
  * Returns 1 on error, 0 else.
  */
 int
 delete_hierarchy(char *dir, Boolean ign_err, Boolean nukedirs)
+{
 	char   *cp1, *cp2;
 	cp1 = cp2 = dir;
 	if (!fexists(dir)) {
 		if (!ign_err)
 			warnx("%s `%s' doesn't really exist",
 			    isdir(dir) ? "directory" : "file", dir);
 		return !ign_err;
 	} else if (nukedirs) {
 		if (recursive_remove(dir, ign_err)) {
 			warn("Couldn't remove %s", dir);
 			return 1;
+		}
 	} else if (isdir(dir)) {
 		if (rmdir(dir) && !ign_err)
 			return 1;
 	} else {
 		if (remove(dir) && !ign_err)
 			return 1;
+	}
 	if (!nukedirs)
 		return 0;
 	while (cp2) {
 		if ((cp2 = strrchr(cp1, '/')) != NULL)
 			*cp2 = '\0';
 		if (!isemptydir(dir))
 			return 0;
 		if (rmdir(dir) && !ign_err) {
 			if (!fexists(dir))
 				warnx("directory `%s' doesn't really exist", dir);
 			else
 				return 1;
+		}
 		/* back up the pathname one component */
 		if (cp2) {
 			cp1 = dir;
+		}
+	}
 	return 0;
+}