/* $NetBSD: extract.c,v 1.18 2008/04/26 17:40:01 joerg Exp $ */ #if HAVE_CONFIG_H #include "config.h" #endif #include <nbcompat.h> #if HAVE_SYS_CDEFS_H #include <sys/cdefs.h> #endif #if HAVE_SYS_QUEUE_H #include <sys/queue.h> #endif #ifndef lint #if 0 static const char *rcsid = "FreeBSD - Id: extract.c,v 1.17 1997/10/08 07:45:35 charnier Exp"; #else __RCSID("$NetBSD: extract.c,v 1.18 2008/04/26 17:40:01 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 package extraction code for the add module. * */ #if HAVE_ERR_H #include <err.h> #endif #include "lib.h" #include "add.h" lfile_head_t files; lfile_head_t perms; /* * Copy files from staging area to todir. * This is only used when the files cannot be directory rename()ed. */ static void pushout(char *todir) { pipe_to_system_t *pipe_to; char *file_args[4]; char **perm_argv; int perm_argc = 1; lfile_t *lfp; int count; /* set up arguments to run "pax -r -w -p e" */ file_args[0] = (char *)strrchr(PAX_CMD, '/'); if (file_args[0] == NULL) file_args[0] = PAX_CMD; else file_args[0]++; file_args[1] = "-rwpe"; file_args[2] = todir; file_args[3] = NULL; /* count entries for files */ count = 0; TAILQ_FOREACH(lfp, &files, lf_link) count++; if (count > 0) { /* open pipe, feed it files, close pipe */ pipe_to = pipe_to_system_begin(PAX_CMD, file_args, NULL); while ((lfp = TAILQ_FIRST(&files)) != NULL) { fprintf(pipe_to->fp, "%s\n", lfp->lf_name); TAILQ_REMOVE(&files, lfp, lf_link); free(lfp); } pipe_to_system_end(pipe_to); } /* count entries for permissions */ count = 0; TAILQ_FOREACH(lfp, &perms, lf_link) count++; if (count > 0) { perm_argv = malloc((count + 1) * sizeof(char *)); perm_argc = 0; TAILQ_FOREACH(lfp, &perms, lf_link) perm_argv[perm_argc++] = lfp->lf_name; perm_argv[perm_argc] = NULL; apply_perms(todir, perm_argv, perm_argc); /* empty the perm list */ while ((lfp = TAILQ_FIRST(&perms)) != NULL) { TAILQ_REMOVE(&perms, lfp, lf_link); free(lfp); } free(perm_argv); } } static void rollback(char *name, char *home, plist_t *start, plist_t *stop) { plist_t *q; char try[MaxPathSize], bup[MaxPathSize], *dir; dir = home; for (q = start; q != stop; q = q->next) { if (q->type == PLIST_FILE) { (void) snprintf(try, sizeof(try), "%s/%s", dir, q->name); if (make_preserve_name(bup, sizeof(bup), name, try) && fexists(bup)) { #if HAVE_CHFLAGS (void) chflags(try, 0); #endif (void) unlink(try); if (rename(bup, try)) warnx("rollback: unable to rename %s back to %s", bup, try); } } else if (q->type == PLIST_CWD) { if (strcmp(q->name, ".")) dir = q->name; else dir = home; } } } /* * Return 0 on error, 1 for success. */ int extract_plist(char *home, package_t *pkg) { plist_t *p = pkg->head; char *last_file; char *last_chdir; Boolean preserve; lfile_t *lfp; TAILQ_INIT(&files); TAILQ_INIT(&perms); last_chdir = 0; preserve = find_plist_option(pkg, "preserve") ? TRUE : FALSE; /* Reset the world */ Owner = NULL; Group = NULL; Mode = NULL; last_file = NULL; Directory = home; if (!NoRecord) { /* Open Package Database for writing */ if (!pkgdb_open(ReadWrite)) { cleanup(0); err(EXIT_FAILURE, "can't open pkgdb"); } } /* Do it */ while (p) { char cmd[MaxPathSize]; switch (p->type) { case PLIST_NAME: PkgName = p->name; if (Verbose) printf("extract: Package name is %s\n", p->name); break; case PLIST_FILE: last_file = p->name; if (Verbose) printf("extract: %s/%s\n", Directory, p->name); if (!Fake) { char try[MaxPathSize]; if (strrchr(p->name, '\'')) { cleanup(0); errx(2, "Bogus filename \"%s\"", p->name); } /* first try to rename it into place */ (void) snprintf(try, sizeof(try), "%s/%s", Directory, p->name); if (fexists(try)) { #if HAVE_CHFLAGS (void) chflags(try, 0); /* XXX hack - if truly immutable, rename fails */ #endif if (preserve && PkgName) { char pf[MaxPathSize]; if (make_preserve_name(pf, sizeof(pf), PkgName, try)) { if (rename(try, pf)) { warnx( "unable to back up %s to %s, aborting pkg_add", try, pf); rollback(PkgName, home, pkg->head, p); return 0; } } } } if (rename(p->name, try) == 0) { if (!NoRecord) { /* note in pkgdb */ char *s, t[MaxPathSize]; int rc; (void) snprintf(t, sizeof(t), "%s/%s", Directory, p->name); s = pkgdb_retrieve(t); #ifdef PKGDB_DEBUG printf("pkgdb_retrieve(\"%s\")=\"%s\"\n", t, s); /* pkgdb-debug - HF */ #endif if (s) warnx("Overwriting %s - pkg %s bogus/conflicting?", t, s); else { rc = pkgdb_store(t, PkgName); #ifdef PKGDB_DEBUG printf("pkgdb_store(\"%s\", \"%s\") = %d\n", t, PkgName, rc); /* pkgdb-debug - HF */ #endif } } /* try to add to list of perms to be changed and run in bulk. */ if (p->name[0] == '/') pushout(Directory); LFILE_ADD(&perms, lfp, p->name); } else { /* rename failed, try copying with a big tar command */ if (last_chdir != Directory) { if (last_chdir != NULL) pushout(last_chdir); last_chdir = Directory; } else if (p->name[0] == '/') { pushout(Directory); } if (!NoRecord) { /* note in pkgdb */ /* XXX would be better to store in PUSHOUT, but * that would probably affect too much code I prefer * not to touch - HF */ char *s, t[MaxPathSize]; int rc; LFILE_ADD(&files, lfp, p->name); LFILE_ADD(&perms, lfp, p->name); if (p->name[0] == '/') errx(EXIT_FAILURE, "File names must not be absolute (%s).", p->name); else { (void) snprintf(t, sizeof(t), "%s/%s", Directory, p->name); } s = pkgdb_retrieve(t); #ifdef PKGDB_DEBUG printf("pkgdb_retrieve(\"%s\")=\"%s\"\n", t, s); /* pkgdb-debug - HF */ #endif if (s) warnx("Overwriting %s - pkg %s bogus/conflicting?", t, s); else { rc = pkgdb_store(t, PkgName); #ifdef PKGDB_DEBUG printf("pkgdb_store(\"%s\", \"%s\") = %d\n", t, PkgName, rc); /* pkgdb-debug - HF */ #endif } } } } break; case PLIST_CWD: if (Verbose) printf("extract: CWD to %s\n", p->name); pushout(Directory); if (strcmp(p->name, ".")) { if (!Fake && make_hierarchy(p->name) == FAIL) { cleanup(0); errx(2, "unable to make directory '%s'", p->name); } Directory = p->name; } else Directory = home; break; case PLIST_CMD: format_cmd(cmd, sizeof(cmd), p->name, Directory, last_file); pushout(Directory); printf("Executing '%s'\n", cmd); if (!Fake && system(cmd)) warnx("command '%s' failed", cmd); break; case PLIST_CHMOD: pushout(Directory); Mode = p->name; break; case PLIST_CHOWN: pushout(Directory); Owner = p->name; break; case PLIST_CHGRP: pushout(Directory); Group = p->name; break; case PLIST_COMMENT: break; case PLIST_IGNORE: p = p->next; break; default: break; } p = p->next; } pushout(Directory); if (!NoRecord) pkgdb_close(); return 1; }

/* $NetBSD: futil.c,v 1.11 2008/04/26 17:40:01 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: futil.c,v 1.7 1997/10/08 07:45:39 charnier Exp"; #else __RCSID("$NetBSD: futil.c,v 1.11 2008/04/26 17:40:01 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 * * Miscellaneous file access utilities. * */ #if HAVE_ERR_H #include <err.h> #endif #include "lib.h" #include "add.h" /* * Assuming dir is a desired directory name, make it and all intervening * directories necessary. */ int make_hierarchy(char *dir) { char *cp1, *cp2; char *argv[2]; argv[0] = dir; argv[1] = NULL; if (dir[0] == '/') cp1 = cp2 = dir + 1; else cp1 = cp2 = dir; while (cp2) { if ((cp2 = strchr(cp1, '/')) != NULL) *cp2 = '\0'; if (fexists(dir)) { if (!(isdir(dir) || islinktodir(dir))) return FAIL; } else { if (fexec("mkdir", dir, NULL)) return FAIL; apply_perms(NULL, argv, 1); } /* Put it back */ if (cp2) { *cp2 = '/'; cp1 = cp2 + 1; } } return SUCCESS; } /* * Using permission defaults, apply them as necessary */ void apply_perms(char *dir, char **args, int nargs) { char *cd_to; char owner_group[128]; const char **argv; int i; argv = malloc((nargs + 4) * sizeof(char *)); /* * elements 0..2 are set later depending on Mode. * args is a NULL terminated list of file names. * by appending them to argv, argv becomes NULL terminated also. */ for (i = 0; i <= nargs; i++) argv[i + 3] = args[i]; if (!dir || args[0][0] == '/') /* absolute path? */ cd_to = "/"; else cd_to = dir; if (Mode) { argv[0] = CHMOD_CMD; argv[1] = "-R"; argv[2] = Mode; if (pfcexec(cd_to, argv[0], argv)) warnx("couldn't change modes of '%s' ... to '%s'", args[0], Mode); } if (Owner != NULL && Group != NULL) { if (snprintf(owner_group, sizeof(owner_group), "%s:%s", Owner, Group) > sizeof(owner_group)) { warnx("'%s:%s' is too long (%lu max)", Owner, Group, (unsigned long) sizeof(owner_group)); free(argv); return; } argv[0] = CHOWN_CMD; argv[1] = "-R"; argv[2] = owner_group; if (pfcexec(cd_to, argv[0], argv)) warnx("couldn't change owner/group of '%s' ... to '%s:%s'", args[0], Owner, Group); free(argv); return; } if (Owner != NULL) { argv[0] = CHOWN_CMD; argv[1] = "-R"; argv[2] = Owner; if (pfcexec(cd_to, argv[0], argv)) warnx("couldn't change owner of '%s' ... to '%s'", args[0], Owner); free(argv); return; } if (Group != NULL) { argv[0] = CHGRP_CMD; argv[1] = "-R"; argv[2] = Group; if (pfcexec(cd_to, argv[0], argv)) warnx("couldn't change group of '%s' ... to '%s'", args[0], Group); } free(argv); }

 @@ -1,1228 +1,1053 @@
-/*	$NetBSD: perform.c,v 1.71 2008/04/26 14:56:34 joerg Exp $	*/
+/*	$NetBSD: perform.c,v 1.72 2008/04/26 17:40:01 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.71 2008/04/26 14:56:34 joerg Exp $");
+#if HAVE_SYS_QUEUE_H
 #include <sys/queue.h>
 #endif
 #ifndef lint
 #if 0
 static const char *rcsid = "from FreeBSD Id: perform.c,v 1.44 1997/10/13 15:03:46 jkh Exp";
 #else
 __RCSID("$NetBSD: perform.c,v 1.72 2008/04/26 17:40:01 joerg Exp $");
 #endif
 #endif
-/*-
+/*
- * Copyright (c) 2003 Grant Beattie <grant@NetBSD.org>
+ * FreeBSD install - a package for the installation and maintainance
- * Copyright (c) 2005 Dieter Baron <dillo@NetBSD.org>
+ * of non-core utilities.
  * Copyright (c) 2007 Roland Illig <rillig@NetBSD.org>
  * 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
+ *    notice, this list of conditions and the following disclaimer in the
- *    the documentation and/or other materials provided with the
+ *    documentation and/or other materials provided with the distribution.
  *    distribution.
  * Jordan K. Hubbard
  * 18 July 1993
+ *
  * This is the main body of the add module.
+ *
  * 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_ASSERT_H
-#include <archive.h>
+#include <assert.h>
-#include <archive_entry.h>
+#endif
 #if HAVE_ERR_H
 #include <err.h>
 #endif
 #if HAVE_ERRNO_H
 #include <errno.h>
-#include <stdlib.h>
+#endif
-#include <string.h>
+#include "defs.h"
 #include <unistd.h>
 #include "lib.h"
 #include "add.h"
 #include "verify.h"
-struct pkg_meta {
+#if HAVE_INTTYPES_H
-	char *meta_contents;
+#include <inttypes.h>
-	char *meta_comment;
+#endif
-	char *meta_desc;
+#if HAVE_SIGNAL_H
-	char *meta_mtree;
+#include <signal.h>
-	char *meta_build_version;
+#endif
-	char *meta_build_info;
+#if HAVE_STRING_H
-	char *meta_size_pkg;
+#include <string.h>
-	char *meta_size_all;
+#endif
-	char *meta_required_by;
+#if HAVE_STDLIB_H
-	char *meta_display;
+#include <stdlib.h>
-	char *meta_install;
+#endif
-	char *meta_deinstall;
+#if HAVE_SYS_UTSNAME_H
-	char *meta_preserve;
+#include <sys/utsname.h>
-	char *meta_views;
+#endif
 	char *meta_installed_info;
 };
 struct pkg_task {
 	const char *pkgname;
 	const char *prefix;
 	const char *install_prefix;
 	char *logdir;
 	char *other_version;
 	package_t plist;
 	struct pkg_meta meta_data;
-	struct archive *archive;
+static char LogDir[MaxPathSize];
-	struct archive_entry *entry;
+static int zapLogDir;		/* Should we delete LogDir? */
-	char *buildinfo[BI_ENUM_COUNT];
+static package_t Plist;
 static char *Home;
-	size_t dep_length, dep_allocated;
+static lfile_head_t files;
 	char **dependencies;
 };
-static const struct pkg_meta_desc {
+/* used in build information */
-	size_t entry_offset;
+enum {
-	const char *entry_filename;
+	Good,
-	int required_file;
+	Missing,
-	mode_t perm;
+	Warning,
-} pkg_meta_descriptors[] = {
+	Fatal
 	{ offsetof(struct pkg_meta, meta_contents), CONTENTS_FNAME, 1, 0644 },
 	{ offsetof(struct pkg_meta, meta_comment), COMMENT_FNAME, 1, 0444},
 	{ offsetof(struct pkg_meta, meta_desc), DESC_FNAME, 1, 0444},
 	{ offsetof(struct pkg_meta, meta_install), INSTALL_FNAME, 0, 0555 },
 	{ offsetof(struct pkg_meta, meta_deinstall), DEINSTALL_FNAME, 0, 0555 },
 	{ offsetof(struct pkg_meta, meta_display), DISPLAY_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_mtree), MTREE_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_build_version), BUILD_VERSION_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_build_info), BUILD_INFO_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_size_pkg), SIZE_PKG_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_size_all), SIZE_ALL_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_preserve), PRESERVE_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_views), VIEWS_FNAME, 0, 0444 },
 	{ offsetof(struct pkg_meta, meta_required_by), REQUIRED_BY_FNAME, 0, 0644 },
 	{ offsetof(struct pkg_meta, meta_installed_info), INSTALLED_INFO_FNAME, 0, 0644 },
 	{ 0, NULL, 0 },
 };
-static int pkg_do(const char *, int);
+static void
 normalise_platform(struct utsname *host_name)
 static int
 mkdir_p(const char *path)
+{
-	return fexec(MKDIR_CMD, "-p", path, (void *)NULL);
+#ifdef NUMERIC_VERSION_ONLY
 	size_t span;
 	span = strspn(host_name->release, "0123456789.");
 	host_name->release[span] = '\0';
 #endif
+}
-/*
+/* Read package build information */
  * 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)
+read_buildinfo(char **buildinfo)
+{
-	const struct pkg_meta_desc *descr, *last_descr;
+	char   *key;
-	const char *fname;
+	char   *line;
-	char **target;
+	size_t	len;
-	int64_t size;
+	FILE   *fp;
 	int r, found_required;
 	found_required = 0;
-	last_descr = 0;
+	if ((fp = fopen(BUILD_INFO_FNAME, "r")) == NULL) {
-	while ((r = archive_read_next_header(pkg->archive, &pkg->entry)) ==
+		warnx("unable to open %s file.", BUILD_INFO_FNAME);
-	    ARCHIVE_OK) {
+		return 0;
 		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;
 		if ((*target = malloc(size + 1)) == NULL)
 			err(2, "cannot allocate meta data");
 		if (archive_read_data(pkg->archive, *target, size) != size) {
 			warn("cannot read package meta data");
 			return -1;
 		(*target)[size] = '\0';
+	}
-	if (r != ARCHIVE_OK)
+	while ((line = fgetln(fp, &len)) != NULL) {
-		pkg->entry = NULL;
+		if (line[len - 1] == '\n')
 			line[len - 1] = '\0';
-	for (descr = pkg_meta_descriptors; descr->entry_filename; ++descr) {
+		if ((key = strsep(&line, "=")) == NULL)
-		if (descr->required_file)
+			continue;
 			--found_required;
 	return !found_required ? 0 : -1;
-/*
+		/*
- * Free meta data.
+		 * pkgsrc used to create the BUILDINFO file using
- */
+		 * "key= value", so skip the space if it's there.
-static void
+		 */
-free_meta_data(struct pkg_task *pkg)
+		if (line == NULL)
 			continue;
-	const struct pkg_meta_desc *descr;
+		if (line[0] == ' ')
-	char **target;
+			line += sizeof(char);
-	for (descr = pkg_meta_descriptors; descr->entry_filename; ++descr) {
+		/*
-		target = (char **)((char *)&pkg->meta_data +
+		 * we only care about opsys, arch, version, and
-		    descr->entry_offset);
+		 * dependency recommendations
-		free(*target);
+		 */
-		*target = NULL;
+		if (line[0] != '\0') {
 			if (strcmp(key, "OPSYS") == 0)
 			    buildinfo[BI_OPSYS] = strdup(line);
 			else if (strcmp(key, "OS_VERSION") == 0)
 			    buildinfo[BI_OS_VERSION] = strdup(line);
 			else if (strcmp(key, "MACHINE_ARCH") == 0)
 			    buildinfo[BI_MACHINE_ARCH] = strdup(line);
 			else if (strcmp(key, "IGNORE_RECOMMENDED") == 0)
 			    buildinfo[BI_IGNORE_RECOMMENDED] = strdup(line);
 			else if (strcmp(key, "USE_ABI_DEPENDS") == 0)
 			    buildinfo[BI_USE_ABI_DEPENDS] = strdup(line);
+		}
+	}
 	(void) fclose(fp);
 	if (buildinfo[BI_OPSYS] == NULL ||
 	    buildinfo[BI_OS_VERSION] == NULL ||
 	    buildinfo[BI_MACHINE_ARCH] == NULL) {
 		warnx("couldn't extract build information from package.");
 		return 0;
+	}
 	return 1;
+}
 /*
  * Parse PLIST and populate pkg.
  */
 static int
-pkg_parse_plist(struct pkg_task *pkg)
+sanity_check(const char *pkg)
+{
-	plist_t *p;
+	int     errc = 0;
-	parse_plist(&pkg->plist, pkg->meta_data.meta_contents);
+	if (!fexists(CONTENTS_FNAME)) {
-	if ((p = find_plist(&pkg->plist, PLIST_NAME)) == NULL) {
+		warnx("package %s has no CONTENTS file!", pkg);
-		warnx("Invalid PLIST: missing @name");
+		errc = 1;
-		return -1;
+	} else if (!fexists(COMMENT_FNAME)) {
 		warnx("package %s has no COMMENT file!", pkg);
 		errc = 1;
 	} else if (!fexists(DESC_FNAME)) {
 		warnx("package %s has no DESC file!", pkg);
 		errc = 1;
+	}
-	pkg->pkgname = p->name;
+	return errc;
 	if ((p = find_plist(&pkg->plist, PLIST_CWD)) == NULL) {
 		warnx("Invalid PLIST: missing @cwd");
 		return -1;
 	/* XXX change first @cwd in PLIST? */
 	pkg->prefix = p->name;
 	pkg->install_prefix = Prefix != NULL ? Prefix : 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 = malloc(eol - key);
 	if (val == NULL)
 		err(2, "malloc failed");
 	memcpy(val, key + 1, eol - key - 1);
 	val[eol - key - 1] = '\0';
 	return val;
+}
 /* install a pre-requisite package. Returns 1 if it installed it */
 static int
-check_already_installed(struct pkg_task *pkg)
+installprereq(const char *name, int *errc, int doupdate)
+{
-	char *filename;
+	int ret;
-	int fd;
+	ret = 0;
 	if (Force)
 		return -1;
-	filename = pkgdb_pkg_file(pkg->pkgname, CONTENTS_FNAME);
+	if (Verbose)
-	fd = open(filename, O_RDONLY);
+		printf("Loading it from %s.\n", name);
-	free(filename);
+	path_setenv("PKG_PATH");
 	if (fd == -1)
 		return -1;
-	/* We can only arrive here for explicitly requested packages. */
+	if (fexec_skipempty(BINDIR "/pkg_add", "-K", _pkgdb_getPKGDB_DIR(),
-	if (!Automatic && is_automatic_installed(pkg->pkgname)) {
+			    "-s", get_verification(),
-		if (Fake ||
+	            doupdate > 1 ? "-uu" : (doupdate ? "-u" : ""),
-		    mark_as_automatic_installed(pkg->pkgname, 0) == 0)
+	            Fake ? "-n" : "",
-			warnx("package `%s' was already installed as "
+			    NoView ? "-L" : "",
-			      "dependency, now marked as installed "
+			    View ? "-w" : "", View ? View : "",
-			      "manually", pkg->pkgname);
+			    Viewbase ? "-W" : "", Viewbase ? Viewbase : "",
 			    Force ? "-f" : "",
 			    Prefix ? "-p" : "", Prefix ? Prefix : "",
 			    Verbose ? "-v" : "",
 			    OverrideMachine ? "-m" : "",
 			    OverrideMachine ? OverrideMachine : "",
 			    NoInstall ? "-I" : "",
 			    "-A", name, NULL)) {
 		warnx("autoload of dependency `%s' failed%s",
 			name, Force ? " (proceeding anyway)" : "!");
 		if (!Force)
 			++(*errc);
 	} else {
-		warnx("package `%s' already recorded as installed",
+		ret = 1;
 		      pkg->pkgname);
+	}
 	return 0;
 	return ret;
+}
 static int
-check_other_installed(struct pkg_task *pkg)
+pkg_do_installed(int *replacing, char replace_via[MaxPathSize], char replace_to[MaxPathSize],
     Boolean is_depoted_pkg, const char *dbdir)
+{
-	FILE *f, *f_pkg;
+	char    replace_from[MaxPathSize];
-	size_t len;
+	char   *s;
-	char *pkgbase, *iter, *filename;
+	char    buf[MaxPathSize];
-	package_t plist;
+	char *best_installed;
 	plist_t *p;
 	int status;
 	if ((pkgbase = strdup(pkg->pkgname)) == NULL) {
 		warnx("strdup failed");
 		return -1;
 	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) {
+	const size_t replace_via_size = MaxPathSize;
-		/* XXX This is redundant to the implicit conflict check. */
+	const size_t replace_to_size = MaxPathSize;
 		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);
+	if ((s = strrchr(PkgName, '-')) == NULL) {
-	errno = 0;
+		warnx("Package name %s does not contain a version, bailing out", PkgName);
 	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;
+	}
 	/*
 	 * See if the pkg is already installed. If so, we might want to
 	 * upgrade/replace it. Otherwise, just return and let pkg_do work.
 	 */
 	(void) snprintf(buf, sizeof(buf), "%.*s[0-9]*",
 		(int)(s - PkgName) + 1, PkgName);
 	best_installed = find_best_matching_installed_pkg(buf);
 	if (best_installed == NULL)
 		return 0;
-	status = 0;
+	if (!Replace || Fake) {
 		if (is_depoted_pkg) {
-	while ((iter = fgetln(f, &len)) != NULL) {
+			free(best_installed);
-		if (iter[len - 1] == '\n')
+			return 0;
-			iter[len - 1] = '\0';
+		} else {
-		filename = pkgdb_pkg_file(iter, CONTENTS_FNAME);
+			warnx("other version '%s' already installed", best_installed);
-		if ((f_pkg = fopen(filename, "r")) == NULL) {
+			free(best_installed);
-			warnx("Can't open +CONTENTS of depending package %s",
+			return 1;	/* close enough for government work */
 			    iter);
 			fclose(f);
 			return -1;
 		plist.head = plist.tail = NULL;
 		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);
+	/* XXX Should list the steps in Fake mode */
 	snprintf(replace_from, sizeof(replace_from), "%s/%s/" REQUIRED_BY_FNAME,
 		 dbdir, best_installed);
 	snprintf(replace_via, replace_via_size, "%s/.%s." REQUIRED_BY_FNAME,
 		 dbdir, best_installed);
 	snprintf(replace_to, replace_to_size, "%s/%s/" REQUIRED_BY_FNAME,
 		 dbdir, PkgName);
-	return status;
+	if (Verbose)
 		printf("Upgrading %s to %s.\n", best_installed, PkgName);
-/*
+	if (fexists(replace_from)) {  /* Are there any dependencies? */
- * Read package build information from meta data.
+	  	/*
- */
+		 * Upgrade step 1/4: Check if the new version is ok with all pkgs
-static int
+		 * (from +REQUIRED_BY) that require this pkg
-read_buildinfo(struct pkg_task *pkg)
+		 */
 		FILE *rb;                     /* +REQUIRED_BY file */
-	const char *data, *eol, *next_line;
+		char pkg2chk[MaxPathSize];
-	data = pkg->meta_data.meta_build_info;
+		rb = fopen(replace_from, "r");
 		if (! rb) {
 			warnx("Cannot open '%s' for reading%s", replace_from,
 			      Force ? " (proceeding anyways)" : "");
 			if (Force)
 				goto ignore_replace_depends_check;
 			else
 				return -1;
+		}
 		while (fgets(pkg2chk, sizeof(pkg2chk), rb)) {
 			package_t depPlist;
 			FILE *depf;
 			plist_t *depp;
 			char depC[MaxPathSize];
 			depPlist.head = depPlist.tail = NULL;
 			s = strrchr(pkg2chk, '\n');
 			if (s)
 				*s = '\0'; /* strip trailing '\n' */
 			/*
 			 * step into pkg2chk, read it's +CONTENTS file and see if
 			 * all @pkgdep lines agree with PkgName (using pkg_match())
 			 */
 			snprintf(depC, sizeof(depC), "%s/%s/%s", dbdir, pkg2chk, CONTENTS_FNAME);
 			depf = fopen(depC , "r");
 			if (depf == NULL) {
 				warnx("Cannot check depends in '%s'%s", depC,
 				      Force ? " (proceeding anyways)" : "!" );
 				if (Force)
 					goto ignore_replace_depends_check;
 				else
 					return -1;
+			}
 			read_plist(&depPlist, depf);
 			fclose(depf);
 			for (depp = depPlist.head; depp; depp = depp->next) {
 				char base_new[MaxPathSize];
 				char base_exist[MaxPathSize];
 				char *s2;
 				if (depp->type != PLIST_PKGDEP)
 					continue;
 				/*
 				 *  Prepare basename (no versions) of both pkgs,
 				 *  to see if we want to compare against that
 				 *  one at all.
 				 */
 				strlcpy(base_new, PkgName, sizeof(base_new));
 				s2 = strpbrk(base_new, "<>[]?*{"); /* } */
 				if (s2)
 					*s2 = '\0';
 				else {
 					s2 = strrchr(base_new, '-');
 					if (s2)
 						*s2 = '\0';
+				}
 				strlcpy(base_exist, depp->name, sizeof(base_exist));
 				s2 = strpbrk(base_exist, "<>[]?*{"); /* } */
 				if (s2)
 					*s2 = '\0';
 				else {
 					s2 = strrchr(base_exist, '-');
 					if (s2)
 						*s2 = '\0';
+				}
 				if (strcmp(base_new, base_exist) == 0) {
 					/* Same pkg, so do the interesting compare */
 					if (pkg_match(depp->name, PkgName)) {
 						if (Verbose)
 							printf("@pkgdep check: %s is ok for %s (in %s pkg)\n",
 							       PkgName, depp->name, pkg2chk);
 					} else {
 						printf("Package %s requires %s, \n\tCannot replace with %s%s\n",
 						       pkg2chk, depp->name, PkgName,
 						       Force? " (proceeding anyways)" : "!");
 						if (! Force)
 							return -1;
+					}
+				}
+			}
+		}
 		fclose(rb);
-	for (; *data != '\0'; data = next_line) {
+ignore_replace_depends_check:
-		if ((eol = strchr(data, '\n')) == NULL) {
+		/*
-			eol = data + strlen(data);
+		 * Upgrade step 2/4: Do the actual update by moving aside
-			next_line = eol;
+		 * the +REQUIRED_BY file, deinstalling the old pkg, adding
-		} else
+		 * the new one and moving the +REQUIRED_BY file back
-			next_line = eol + 1;
+		 * into place (finished in step 3/4)
 		 */
 		if (Verbose)
 			printf("mv %s %s\n", replace_from, replace_via);
 		if (rename(replace_from, replace_via) != 0)
 			err(EXIT_FAILURE, "renaming \"%s\" to \"%s\" failed", replace_from, replace_via);
-		if (strncmp(data, "OPSYS=", 6) == 0)
+		*replacing = 1;
 			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 &&
+	if (Verbose) {
-	    strcasecmp(pkg->buildinfo[BI_USE_ABI_DEPENDS], "YES") != 0) ||
+		printf("%s/pkg_delete -K %s '%s'\n",
-	    (pkg->buildinfo[BI_IGNORE_RECOMMENDED] != NULL &&
+			BINDIR, dbdir, best_installed);
 	    strcasecmp(pkg->buildinfo[BI_IGNORE_RECOMMENDED], "NO") != 0)) {
 		warnx("%s was built to ignore ABI dependencies", pkg->pkgname);
+	}
 	fexec(BINDIR "/pkg_delete", "-K", dbdir, best_installed, NULL);
-	return 0;
+	free(best_installed);
-/*
+	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.
+ * Install a single package
  * Returns 0 if everything is ok, >0 else
  */
 static int
-write_meta_data(struct pkg_task *pkg)
+pkg_do(const char *pkg, lpkg_head_t *pkgs)
+{
-	const struct pkg_meta_desc *descr;
+	char    playpen[MaxPathSize];
-	char *filename, **target;
+	char    replace_via[MaxPathSize];
-	size_t len;
+	char    replace_to[MaxPathSize];
-	ssize_t ret;
+	char   *buildinfo[BI_ENUM_COUNT];
-	int fd;
+	int	replacing = 0;
 	char   dbdir[MaxPathSize];
-	if (Fake)
+	const char *tmppkg;
-		return 0;
+	FILE   *cfile;
 	int     errc, err_prescan;
-	if (mkdir_p(pkg->logdir)) {
+	plist_t *p;
-		warn("Can't create pkgdb entry: %s", pkg->logdir);
+	struct stat sb;
-		return -1;
+	struct utsname host_uname;
 	uint64_t needed;
 	Boolean	is_depoted_pkg = FALSE;
-	for (descr = pkg_meta_descriptors; descr->entry_filename; ++descr) {
+	lfile_t	*lfp;
-		target = (char **)((char *)&pkg->meta_data +
+	int	result;
 		    descr->entry_offset);
-		if (*target == NULL)
+	errc = 0;
-			continue;
+	zapLogDir = 0;
-		if (asprintf(&filename, "%s/%s", pkg->logdir,
+	LogDir[0] = '\0';
-		    descr->entry_filename) == -1) {
+	strlcpy(playpen, FirstPen, sizeof(playpen));
-			    warn("asprintf failed");
+	memset(buildinfo, '\0', sizeof(buildinfo));
 			    return -1;
 	umask(DEF_UMASK);
 		(void)unlink(filename);
-		fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT, descr->perm);
+	tmppkg = fileFindByPath(pkg);
-		if (fd == -1) {
+	if (tmppkg == NULL) {
-			warn("Can't open meta data file: %s", filename);
+		warnx("no pkg found for '%s', sorry.", pkg);
-			return -1;
+		return 1;
+	}
 		len = strlen(*target);
-		do {
+	pkg = tmppkg;
 			ret = write(fd, *target, len);
-			if (ret == -1) {
+	if (IS_URL(pkg)) {
-				warn("Can't write meta data file: %s",
+		Home = fileGetURL(pkg);
-				    filename);
+		if (Home == NULL) {
-				free(filename);
+			warnx("unable to fetch `%s' by URL", pkg);
 				return -1;
 		/* make sure the pkg is verified */
 		if (!verify(pkg)) {
 			warnx("Package %s will not be extracted", pkg);
 			goto bomb;
+		}
 	} else { /* local */
 		if (!IS_STDIN(pkg)) {
 		        /* not stdin */
 			if (!ispkgpattern(pkg)) {
 				if (stat(pkg, &sb) == FAIL) {
 					warnx("can't stat package file '%s'", pkg);
 					goto bomb;
+				}
 				/* make sure the pkg is verified */
 				if (!verify(pkg)) {
 					warnx("Package %s will not be extracted", pkg);
 					goto bomb;
+				}
+			}
-			len -= ret;
+			LFILE_ADD(&files, lfp, CONTENTS_FNAME);
-		} while (ret > 0);
+		} else {
-		if (close(fd) == -1) {
+		        /* some values for stdin */
-			warn("Can't close meta data file: %s", filename);
+			sb.st_size = 100000;	/* Make up a plausible average size */
 			free(filename);
 			return -1;
+		}
-		free(filename);
+		Home = make_playpen(playpen, sizeof(playpen), sb.st_size * 4);
 		if (!Home)
 			warnx("unable to make playpen for %ld bytes",
-	return 0;
+			      (long) (sb.st_size * 4));
 		result = unpack(pkg, &files);
 		while ((lfp = TAILQ_FIRST(&files)) != NULL) {
-/*
+			TAILQ_REMOVE(&files, lfp, lf_link);
- * Helper function for extract_files.
+			free(lfp);
  */
-static int
+		if (result) {
-copy_data_to_disk(struct archive *reader, struct archive *writer,
+			warnx("unable to extract table of contents file from `%s' - not a package?",
-    const char *filename)
+			      pkg);
 			goto bomb;
 	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)
+	cfile = fopen(CONTENTS_FNAME, "r");
-		return 0;
+	if (!cfile) {
 		warnx("unable to open table of contents file `%s' - not a package?",
-	if (mkdir_p(pkg->install_prefix)) {
+		      CONTENTS_FNAME);
-		warn("Can't create prefix: %s", pkg->install_prefix);
+		goto bomb;
 		return -1;
 	if (chdir(pkg->install_prefix) == -1) {
 		warn("Can't change into prefix: %s", pkg->install_prefix);
 		return -1;
+	}
 	read_plist(&Plist, cfile);
 	fclose(cfile);
-	if (!NoRecord && !pkgdb_open(ReadWrite)) {
+	if (!IS_URL(pkg)) {
-		warn("Can't open pkgdb for writing");
+		/*
-		return -1;
+		 * Apply a crude heuristic to see how much space the package will
 		 * take up once it's unpacked.  I've noticed that most packages
 		 * compress an average of 75%, so multiply by 4 for good measure.
-	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;
 			if (asprintf(&fullpath, "%s/%s", pkg->install_prefix, p->name) == -1) {
 				warnx("asprintf failed");
 				goto out;
 			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->install_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:
+		needed = 4 * (uint64_t) sb.st_size;
-			continue;
+		if (min_free(playpen) < needed) {
 			warnx("projected size of %" MY_PRIu64 " bytes exceeds available free space\n"
 			    "in %s. Please set your PKG_TMPDIR variable to point\n"
 			    "to a location with more free space and try again.",
 				needed, playpen);
 			goto bomb;
+		}
-		r = archive_write_header(writer, pkg->entry);
+		/* Finally unpack the whole mess */
-		if (r != ARCHIVE_OK) {
+		if (unpack(pkg, NULL)) {
-			warnx("Failed to write %s: %s",
+			warnx("unable to extract `%s'!", pkg);
-			    archive_entry_pathname(pkg->entry),
+			goto bomb;
 			    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) {
+	/* Check for sanity */
-		warnx("Package contains entries not in PLIST: %s",
+	if (sanity_check(pkg))
-		    archive_entry_pathname(pkg->entry));
+		goto bomb;
 		goto out;
 	r = 0;
 out:
 	if (!NoRecord)
 		pkgdb_close();
 	archive_write_close(writer);
 	archive_write_finish(writer);
-	return r;
+	/* Read the OS, version and architecture from BUILD_INFO file */
 	if (!read_buildinfo(buildinfo)) {
 		warn("can't read build information from %s", BUILD_INFO_FNAME);
-/*
+		if (!Force) {
- * Register dependencies after sucessfully installing the package.
+			warnx("aborting.");
- */
+			goto bomb;
 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. */
 	if (asprintf(&text, "%s\n", pkg->pkgname) == -1)
 		err(2, "asprintf failed");
 	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, 644);
 		if (fd == -1)
 			warn("can't open dependency file '%s',"
 			    "registration is incomplete!", required_by);
 		else if (write(fd, text, text_len) != text_len)
 			warn("can't write to dependency file `%s'", required_by);
 		else if (close(fd) == -1)
 			warn("cannot close file %s", required_by);
 		free(required_by);
+	}
-	free(text);
+	if (uname(&host_uname) < 0) {
 		warnx("uname() failed.");
 		if (!Force) {
-/*
+			warnx("aborting.");
- * Reduce the result from uname(3) to a canonical form.
+			goto bomb;
  */
-static void
+	} else {
-normalise_platform(struct utsname *host_name)
+		int	status = Good;
 #ifdef NUMERIC_VERSION_ONLY
 	size_t span;
-	span = strspn(host_name->release, "0123456789.");
+		normalise_platform(&host_uname);
 	host_name->release[span] = '\0';
 #endif
-/*
+		/* check that we have read some values from buildinfo */
- * Check build platform of the package against local host.
+		if (buildinfo[BI_OPSYS] == NULL) {
- */
+			warnx("Missing operating system value from build information");
-static int
+			status = Missing;
 check_platform(struct pkg_task *pkg)
 		if (buildinfo[BI_MACHINE_ARCH] == NULL) {
-	struct utsname host_uname;
+			warnx("Missing machine architecture value from build information");
-	const char *effective_arch;
+			status = Missing;
 	int fatal;
 		if (buildinfo[BI_OS_VERSION] == NULL) {
 			warnx("Missing operating system version value from build information");
 			status = Missing;
+		}
 		if (status == Good) {
 			const char *effective_arch;
 			if (OverrideMachine != NULL)
 				effective_arch = OverrideMachine;
 			else
 				effective_arch = MACHINE_ARCH;
 			/* If either the OS or arch are different, bomb */
 			if (strcmp(OPSYS_NAME, buildinfo[BI_OPSYS]) != 0)
 				status = Fatal;
 			if (strcmp(effective_arch, buildinfo[BI_MACHINE_ARCH]) != 0)
 				status = Fatal;
 			/* If OS and arch are the same, warn if version differs */
 			if (status == Good &&
 			    strcmp(host_uname.release, buildinfo[BI_OS_VERSION]) != 0)
 				status = Warning;
 			if (status != Good) {
 				warnx("Warning: package `%s' was built for a different version of the OS:", pkg);
 				warnx("%s/%s %s (pkg) vs. %s/%s %s (this host)",
 				    buildinfo[BI_OPSYS],
 				    buildinfo[BI_MACHINE_ARCH],
 				    buildinfo[BI_OS_VERSION],
 				    OPSYS_NAME,
 				    effective_arch,
 				    host_uname.release);
+			}
+		}
-	if (uname(&host_uname) < 0) {
+		if (!Force && status == Fatal) {
-		if (Force) {
+			warnx("aborting.");
-			warnx("uname() failed, continuing.");
+			goto bomb;
 			return 0;
 		} else {
 			warnx("uname() failed, aborting.");
 			return -1;
+		}
+	}
-	normalise_platform(&host_uname);
+	/* Check if USE_ABI_DEPENDS or IGNORE_RECOMMENDED was set
 	 * when this package was built. IGNORE_RECOMMENDED is historical. */
 	if (OverrideMachine != NULL)
-		effective_arch = OverrideMachine;
+	if ((buildinfo[BI_USE_ABI_DEPENDS] != NULL &&
-	else
+	    strcasecmp(buildinfo[BI_USE_ABI_DEPENDS], "YES") != 0) ||
-		effective_arch = MACHINE_ARCH;
+	    (buildinfo[BI_IGNORE_RECOMMENDED] != NULL &&
 	    strcasecmp(buildinfo[BI_IGNORE_RECOMMENDED], "NO") != 0)) {
-	/* If either the OS or arch are different, bomb */
+		warnx("%s was built", pkg);
-	if (strcmp(OPSYS_NAME, pkg->buildinfo[BI_OPSYS]) ||
+		warnx("\tto ignore recommended ABI dependencies, this may cause problems!\n");
 	    strcmp(effective_arch, pkg->buildinfo[BI_MACHINE_ARCH]) != 0)
 		fatal = 1;
-	else
+	/*
-		fatal = 0;
+         * If we have a prefix, delete the first one we see and add this
          * one in place of it.
-	if (fatal ||
+         */
-	    strcmp(host_uname.release, pkg->buildinfo[BI_OS_VERSION]) != 0) {
+	if (Prefix) {
-		warnx("Warning: package `%s' was built for a platform:",
+		delete_plist(&Plist, FALSE, PLIST_CWD, NULL);
-		    pkg->pkgname);
+		add_plist_top(&Plist, PLIST_CWD, Prefix);
 		warnx("%s/%s %s (pkg) vs. %s/%s %s (this host)",
 		    pkg->buildinfo[BI_OPSYS],
-		    pkg->buildinfo[BI_MACHINE_ARCH],
+	/* Protect against old packages with bogus @name fields */
-		    pkg->buildinfo[BI_OS_VERSION],
+	p = find_plist(&Plist, PLIST_NAME);
-		    OPSYS_NAME,
+	if (p->name == NULL) {
-		    effective_arch,
+		warnx("PLIST contains no @name field");
-		    host_uname.release);
+		goto bomb;
 		if (!Force && fatal)
-			return -1;
+	PkgName = p->name;
 	if (fexists(VIEWS_FNAME))
 		is_depoted_pkg = TRUE;
 	/*
 	 * Depoted packages' dbdir is the same as DEPOTBASE.  Non-depoted
 	 * packages' dbdir comes from the command-line or the environment.
 	 */
 	if (is_depoted_pkg) {
 		p = find_plist(&Plist, PLIST_CWD);
 		if (p == NULL) {
 			warn("no @cwd in +CONTENTS file?! aborting.");
 			goto bomb;
+		}
 		(void) strlcpy(dbdir, dirname_of(p->name), sizeof(dbdir));
 		(void) strlcpy(LogDir, p->name, sizeof(LogDir));
 	} else {
 		(void) strlcpy(dbdir, _pkgdb_getPKGDB_DIR(), sizeof(dbdir));
 		(void) snprintf(LogDir, sizeof(LogDir), "%s/%s", dbdir, PkgName);
+	}
 	return 0;
-/*
+	/* Set environment variables expected by the +INSTALL script. */
- * Run the install script.
+	setenv(PKG_PREFIX_VNAME, (p = find_plist(&Plist, PLIST_CWD)) ? p->name : ".", 1);
- */
+	setenv(PKG_METADATA_DIR_VNAME, LogDir, 1);
 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;
 	setenv(PKG_PREFIX_VNAME, pkg->install_prefix, 1); /* XXX or prefix? */
 	setenv(PKG_METADATA_DIR_VNAME, pkg->logdir, 1);
 	setenv(PKG_REFCOUNT_DBDIR_VNAME, pkgdb_refcount_dir(), 1);
-	filename = pkgdb_pkg_file(pkg->pkgname, INSTALL_FNAME);
+	/* make sure dbdir actually exists! */
-	if (Verbose)
+	if (!(isdir(dbdir) || islinktodir(dbdir))) {
-		printf("Running install with PRE-INSTALL for %s.\n", pkg->pkgname);
+		if (fexec("mkdir", "-p", dbdir, NULL)) {
-	if (Fake) {
+			errx(EXIT_FAILURE,
-		free(filename);
+			    "Database-dir %s cannot be generated, aborting.",
-		return 0;
+			    dbdir);
+		}
+	}
-	ret = 0;
+	/* See if this package (exact version) is already registered */
 	if (isdir(LogDir) && !Force) {
-	if (chdir(pkg->logdir) == -1) {
+		if (!Automatic && is_automatic_installed(PkgName)) {
-		warn("Can't change to %s", pkg->logdir);
+			if (mark_as_automatic_installed(PkgName, 0) == 0)
-		ret = -1;
+				warnx("package `%s' was already installed as "
 				      "dependency, now marked as installed "
 				      "manually", PkgName);
 		} else {
 			warnx("package `%s' already recorded as installed",
 			      PkgName);
+		}
 		goto success;	/* close enough for government work */
+	}
-	errno = 0;
+	/* See if some other version of us is already installed */
-	if (ret == 0 && fexec(filename, pkg->pkgname, argument, (void *)NULL)) {
+	switch (pkg_do_installed(&replacing, replace_via, replace_to, is_depoted_pkg, dbdir)) {
-		if (errno != 0)
+	case 0:
-			warn("exec of install script failed");
+		break;
-		else
+	case 1:
-			warnx("install script returned error status");
+		errc = 1;
-		ret = -1;
+		goto success;
 	case -1:
 		goto bomb;
+	}
-	free(filename);
+	/* See if there are conflicting packages installed */
-	return ret;
+	for (p = Plist.head; p; p = p->next) {
 		char *best_installed;
-static int
+		if (p->type != PLIST_PKGCFL)
 check_explicit_conflict(struct pkg_task *pkg)
 	char *installed, *installed_pattern;
 	plist_t *p;
 	int status;
 	status = 0;
 	for (p = pkg->plist.head; p != NULL; p = p->next) {
 		if (p->type == PLIST_IGNORE) {
 			p = p->next;
 			continue;
 		} else if (p->type != PLIST_PKGCFL)
 			continue;
-		installed = find_best_matching_installed_pkg(p->name);
+		if (Verbose)
-		if (installed) {
+			printf("Package `%s' conflicts with `%s'.\n", PkgName, p->name);
 		best_installed = find_best_matching_installed_pkg(p->name);
 		if (best_installed) {
 			warnx("Package `%s' conflicts with `%s', and `%s' is installed.",
-			    pkg->pkgname, p->name, installed);
+			      PkgName, p->name, best_installed);
-			free(installed);
+			free(best_installed);
-			status = -1;
+			++errc;
+		}
+	}
-	if (some_installed_package_conflicts_with(pkg->pkgname,
+	/* See if any of the installed packages conflicts with this one. */
 	    pkg->other_version, &installed, &installed_pattern)) {
-		warnx("Installed package `%s' conflicts with `%s' when trying to install `%s'.",
+		char *inst_pkgname, *inst_pattern;
 			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 (some_installed_package_conflicts_with(PkgName, &inst_pkgname, &inst_pattern)) {
-#if notyet /* XXX empty pkgdb without database? */
+			warnx("Installed package `%s' conflicts with `%s' when trying to install `%s'.",
-		warn("Can't open pkgdb for reading");
+				inst_pkgname, inst_pattern, PkgName);
-		return -1;
+			free(inst_pkgname);
-#else
+			free(inst_pattern);
-		return 0;
+			errc++;
 #endif
+	}
-	status = 0;
+	/* Quick pre-check if any conflicting dependencies are installed
 	 * (e.g. version X is installed, but version Y is required)
-	for (p = pkg->plist.head; p != NULL; p = p->next) {
+	 */
-		if (p->type == PLIST_IGNORE) {
+	err_prescan=0;
-			p = p->next;
+	for (p = Plist.head; p; p = p->next) {
-			continue;
+		char *best_installed;
 		} else if (p->type != PLIST_FILE)
-			continue;
+		if (p->type != PLIST_PKGDEP)
 		if (asprintf(&fullpath, "%s/%s", pkg->install_prefix, p->name) == -1) {
 			warnx("asprintf failed");
 			status = -1;
 			break;
 		existing = pkgdb_retrieve(fullpath);
 		free(fullpath);
 		if (existing == NULL)
 			continue;
 		if (pkg->other_version != NULL &&
 		    strcmp(pkg->other_version, existing) == 0)
 			continue;
 		if (Verbose)
 			printf("Depends pre-scan: `%s' required.\n", p->name);
 		best_installed = find_best_matching_installed_pkg(p->name);
 		if (best_installed == NULL) {
 			/*
 			 * required pkg not found. look if it's available with a more liberal
 			 * pattern. If so, this will lead to problems later (check on "some
 			 * other version of us is already installed" will fail, see above),
 			 * and we better stop right now.
 			 */
 			char *s;
 			int skip = -1;
-		warnx("Conflicting PLIST with %s: %s", existing, p->name);
+			/* doing this right required to parse the full version(s),
-		if (!Force) {
+			 * do a 99% solution here for now */
-			status = -1;
+			if (strchr(p->name, '{'))
-			if (!Verbose)
+				continue;	/* would remove trailing '}' else */
 				break;
 			if ((s = strpbrk(p->name, "<>")) != NULL) {
 				skip = 0;
 			} else if (((s = strstr(p->name, "-[0-9]*")) != NULL) &&
 				    (*(s + sizeof("-[0-9]*") - 1) == '\0')) {
 				/* -[0-9]* already present so no need to */
 				/* add it a second time */
 				skip = -1;
 			} else if ((s = strrchr(p->name, '-')) != NULL) {
 				skip = 1;
+			}
 			if (skip >= 0) {
 				char    buf[MaxPathSize];
 				(void) snprintf(buf, sizeof(buf),
 				    skip ? "%.*s[0-9]*" : "%.*s-[0-9]*",
 				    (int)(s - p->name) + skip, p->name);
 				best_installed = find_best_matching_installed_pkg(buf);
 				if (best_installed) {
 					int done = 0;
 					if (Replace > 1)
+					{
 						int errc0 = 0;
 						char tmp[MaxPathSize];
 						warnx("Attempting to update `%s' using binary package\n", p->name);
 						/* Yes, append .tgz after the version so the */
 						/* pattern can match a filename. */
 						snprintf(tmp, sizeof(tmp), "%s.tgz", p->name);
 						done = installprereq(tmp, &errc0, 2);
+					}
 					else if (Replace)
+					{
 						warnx("To perform necessary upgrades on required packages specify -u twice.\n");
+					}
 					if (!done)
+					{
 						warnx("pkg `%s' required, but `%s' found installed.",
 							  p->name, best_installed);
 						if (Force) {
 							warnx("Proceeding anyway.");
 						} else {
 							err_prescan++;
+						}
+					}
 					free(best_installed);
+				}
+			}
 		} else {
 			free(best_installed);
+		}
+	}
 	if (err_prescan > 0) {
 		warnx("Please resolve this conflict!");
 		errc += err_prescan;
 		goto success; /* close enough */
+	}
 	/* Now check the packing list for dependencies */
 	for (p = Plist.head; p; p = p->next) {
 		char *best_installed;
-	pkgdb_close();
+		if (p->type != PLIST_PKGDEP)
 	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;
 		if (Verbose)
 			printf("Package `%s' depends on `%s'.\n", PkgName, p->name);
 		best_installed = find_best_matching_installed_pkg(p->name);
 		if (best_installed == NULL) {
-			/* XXX check cyclic dependencies? */
+			/* required pkg not found - need to pull in */
 			if (Fake || NoRecord) {
-				if (!Force) {
+			if (Fake) {
-					warnx("Missing dependency %s\n",
+			        /* fake install (???) */
-					     p->name);
+				if (Verbose)
-					status = -1;
+					printf("Package dependency %s for %s not installed%s\n", p->name, pkg,
-					break;
+					    Force ? " (proceeding anyway)" : "!");
 			} else {
 				int done = 0;
 				int errc0 = 0;
 				done = installprereq(p->name, &errc0, (Replace > 1) ? 2 : 0);
 				if (!done && !Force) {
 					errc += errc0;
+				}
 				warnx("Missing dependency %s, continuing",
 				    p->name);
 				continue;
 			if (pkg_do(p->name, 1)) {
 				warnx("Can't install dependency %s", p->name);
 				status = -1;
 				break;
+			}
-			best_installed = find_best_matching_installed_pkg(p->name);
+		} else {
-			if (best_installed == NULL && Force) {
+			if (Verbose)
-				warnx("Missing dependency %s ignored", p->name);
+				printf(" - %s already installed.\n", best_installed);
 				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;
 			tmp = realloc(pkg->dependencies,
 			    pkg->dep_allocated * sizeof(*tmp));
 			if (tmp == NULL) {
 				warnx("realloc failed");
 				free(pkg->dependencies);
 				pkg->dependencies = NULL;
 				pkg->dep_length = pkg->dep_allocated = 0;
 				free(best_installed);
 				return -1;
 			pkg->dependencies = tmp;
 		pkg->dependencies[pkg->dep_length++] = best_installed;
+	}
-	return status;
+	if (errc != 0)
 		goto bomb;
-/*
+	/* If we're really installing, and have an installation file, run it */
- * If this package uses pkg_views, register it in the default view.
+	if (!NoInstall && fexists(INSTALL_FNAME)) {
- */
+		(void) fexec(CHMOD_CMD, "+x", INSTALL_FNAME, NULL);	/* make sure */
-static void
+		if (Verbose)
-pkg_register_views(struct pkg_task *pkg)
+			printf("Running install with PRE-INSTALL for %s.\n", PkgName);
 		errno = 0;
-	if (Fake || NoView || pkg->meta_data.meta_views == NULL)
+		if (!Fake && fexec("./" INSTALL_FNAME, PkgName, "PRE-INSTALL", NULL)) {
-		return;
+			if (errno != 0)
 				warn("exec of install script failed");
-	if (Verbose) {
+			else
-		printf("%s/pkg_view -d %s %s%s %s%s %sadd %s\n",
+				warnx("install script returned error status");
-			BINDIR, _pkgdb_getPKGDB_DIR(),
+			errc = 1;
-			View ? "-w " : "", View ? View : "",
+			goto success;	/* nothing to uninstall yet */
 			Viewbase ? "-W " : "", Viewbase ? Viewbase : "",
 			Verbose ? "-v " : "", pkg->pkgname);
+	}
-	fexec_skipempty(BINDIR "/pkg_view", "-d", _pkgdb_getPKGDB_DIR(),
+	/*
-			View ? "-w " : "", View ? View : "",
+	 * Now finally extract the entire show if we're not going direct.
-			Viewbase ? "-W " : "", Viewbase ? Viewbase : "",
+	 * We need to reset the package dbdir so that extract_plist()
-			Verbose ? "-v " : "", "add", pkg->pkgname,
+	 * updates the correct pkgdb.byfile.db database.
-			(void *)NULL);
+	 */
 static int
 start_replacing(struct pkg_task *pkg)
 	char *old_required_by, *new_required_by;
 	old_required_by = pkgdb_pkg_file(pkg->other_version,
 	    REQUIRED_BY_FNAME);
 	new_required_by = pkgdb_pkg_file(pkg->pkgname,
 	    REQUIRED_BY_FNAME);
 	if (!Fake) {
-		if (rename(old_required_by, new_required_by) == -1 &&
+		_pkgdb_setPKGDB_DIR(dbdir);
-		    errno != ENOENT) {
+		if (!extract_plist(".", &Plist)) {
-			warn("Can't move +REQUIRED_BY from %s to %s",
+			errc = 1;
-			    old_required_by, new_required_by);
+			goto fail;
 			return -1;
+		}
+	}
-	if (Verbose || Fake) {
+	if (!Fake && fexists(MTREE_FNAME)) {
-		printf("%s/pkg_delete -K %s -p %s '%s'\n",
+		warnx("Mtree file ignored for package %s", PkgName);
 			BINDIR, _pkgdb_getPKGDB_DIR(), pkg->install_prefix,
 			pkg->other_version);
+	}
 	if (!Fake)
 		fexec(BINDIR "/pkg_delete", "-K", _pkgdb_getPKGDB_DIR(),
 		    "-p", pkg->install_prefix,
 		    pkg->other_version, NULL);
 	/* XXX Check return value and do what? */
 	return 0;
-/*
+	/* Run the installation script one last time? */
- * Install a single package.
+	if (!NoInstall && fexists(INSTALL_FNAME)) {
- */
+		if (Verbose)
-static int
+			printf("Running install with POST-INSTALL for %s.\n", PkgName);
-pkg_do(const char *pkgpath, int mark_automatic)
+		if (!Fake && fexec("./" INSTALL_FNAME, PkgName, "POST-INSTALL", NULL)) {
 			warnx("install script returned error status");
-	int status;
+			errc = 1;
-	void *archive_cookie;
+			goto fail;
 	struct pkg_task *pkg;
 	if ((pkg = calloc(1, sizeof(*pkg))) == NULL)
 		err(2, "malloc failed");
 	status = -1;
 	if ((pkg->archive = find_archive(pkgpath, &archive_cookie)) == NULL) {
 		warnx("no pkg found for '%s', sorry.", pkgpath);
 		goto clean_memory;
+	}
 	if (read_meta_data(pkg))
 		goto clean_memory;
-	/* Parse PLIST early, so that messages can use real package name. */
+	/* Time to record the deed? */
-	if (pkg_parse_plist(pkg))
+	if (!NoRecord && !Fake) {
-		goto clean_memory;
+		char    contents[MaxPathSize];
-	if (pkg->meta_data.meta_mtree != NULL)
+		if (!PkgName) {
-		warnx("mtree specification in pkg `%s' ignored", pkg->pkgname);
+			warnx("no package name! can't record package, sorry");
 			errc = 1;
 			goto success;	/* well, partial anyway */
+		}
 		(void) snprintf(LogDir, sizeof(LogDir), "%s/%s", dbdir, PkgName);
 		zapLogDir = 1; /* LogDir contains something valid now */
 		if (Verbose)
 			printf("Attempting to record package into %s.\n", LogDir);
 		if (make_hierarchy(LogDir)) {
 			warnx("can't record package into '%s', you're on your own!",
 			    LogDir);
 			memset(LogDir, 0, sizeof(LogDir));
 			errc = 1;
 			goto success;	/* close enough for government work */
+		}
 		/* Make sure pkg_info can read the entry */
 		(void) fexec(CHMOD_CMD, "a+rx", LogDir, NULL);
 		/* Move all of the +-files into place */
 		move_files(".", "+*", LogDir);
 		/* Generate the +CONTENTS file in-place from the Plist */
 		(void) snprintf(contents, sizeof(contents), "%s/%s", LogDir, CONTENTS_FNAME);
 		cfile = fopen(contents, "w");
 		if (!cfile) {
 			warnx("can't open new contents file '%s'! can't register pkg",
 			    contents);
 			goto success;	/* can't log, but still keep pkg */
+		}
 		write_plist(&Plist, cfile, NULL);
 		fclose(cfile);
 		/* register dependencies */
 		/* we could save some cycles here if we remembered what we
 		 * installed above (in case we got a wildcard dependency)  */
 		/* XXX remembering in p->name would NOT be good! */
 		for (p = Plist.head; p; p = p->next) {
 			if (p->type != PLIST_PKGDEP)
 				continue;
 			if (Verbose)
 				printf("Attempting to record dependency on package `%s'\n", p->name);
 			(void) snprintf(contents, sizeof(contents), "%s/%s", dbdir,
 			    basename_of(p->name));
 			if (ispkgpattern(p->name)) {
 				char   *s;
-	if (pkg->meta_data.meta_views != NULL) {
+				s = find_best_matching_installed_pkg(p->name);
 		if ((pkg->logdir = strdup(pkg->install_prefix)) == NULL)
 			err(EXIT_FAILURE, "strdup failed");
 		_pkgdb_setPKGDB_DIR(dirname_of(pkg->logdir));
 	} else {
 		if (asprintf(&pkg->logdir, "%s/%s", _pkgdb_getPKGDB_DIR(),
 			     pkg->pkgname) == -1)
 			err(EXIT_FAILURE, "asprintf failed");
-	if (NoRecord && !Fake) {
+				if (s == NULL)
-		const char *tmpdir;
+					errx(EXIT_FAILURE, "Where did our dependency go?!");
-		tmpdir = getenv("TMPDIR");
+				(void) snprintf(contents, sizeof(contents), "%s/%s", dbdir, s);
-		if (tmpdir == NULL)
+				free(s);
 			tmpdir = "/tmp";
 			strlcat(contents, "/", sizeof(contents));
 			strlcat(contents, REQUIRED_BY_FNAME, sizeof(contents));
-		free(pkg->logdir);
+			cfile = fopen(contents, "a");
-		if (asprintf(&pkg->logdir, "%s/pkg_install.XXXXXX", tmpdir) == -1)
+			if (!cfile)
-			err(EXIT_FAILURE, "asprintf failed");
+				warnx("can't open dependency file '%s'!\n"
-		/* XXX pkg_add -u... */
+				    "dependency registration is incomplete", contents);
-		if (mkdtemp(pkg->logdir) == NULL) {
+			else {
-			warn("mkdtemp failed");
+				fprintf(cfile, "%s\n", PkgName);
-			goto clean_memory;
+				if (fclose(cfile) == EOF)
 					warnx("cannot properly close file %s", contents);
+			}
+		}
 		if (Automatic)
 			mark_as_automatic_installed(PkgName, 1);
 		if (Verbose)
 			printf("Package %s registered in %s\n", PkgName, LogDir);
+	}
-	if (check_already_installed(pkg) == 0) {
+	if ((p = find_plist(&Plist, PLIST_DISPLAY)) != NULL) {
-		status = 0;
+		FILE   *fp;
-		goto clean_memory;
+		char    buf[BUFSIZ];
 		(void) snprintf(buf, sizeof(buf), "%s/%s", LogDir, p->name);
 		fp = fopen(buf, "r");
 		if (fp) {
 			putc('\n', stdout);
 			while (fgets(buf, sizeof(buf), fp))
 				fputs(buf, stdout);
 			putc('\n', stdout);
 			(void) fclose(fp);
 		} else
 			warnx("cannot open %s as display file", buf);
+	}
-	if (read_buildinfo(pkg))
+	/* Add the package to a default view. */
-		goto clean_memory;
+	if (!Fake && !NoView && is_depoted_pkg) {
 		if (Verbose) {
 			printf("%s/pkg_view -d %s %s%s %s%s %sadd %s\n",
 				BINDIR, dbdir,
 				View ? "-w " : "", View ? View : "",
 				Viewbase ? "-W " : "", Viewbase ? Viewbase : "",
 				Verbose ? "-v " : "", PkgName);
+		}
-	if (check_platform(pkg))
+		fexec_skipempty(BINDIR "/pkg_view", "-d", dbdir,
-		goto clean_memory;
+				View ? "-w " : "", View ? View : "",
 				Viewbase ? "-W " : "", Viewbase ? Viewbase : "",
 				Verbose ? "-v " : "", "add", PkgName, NULL);
+	}
 	goto success;
-	if (check_other_installed(pkg))
+bomb:
-		goto clean_memory;
+	errc = 1;
 	goto success;
-	if (check_explicit_conflict(pkg))
+fail:
-		goto clean_memory;
+	/* Nuke the whole (installed) show, XXX but don't clean directories */
 	if (!Fake)
 		delete_package(FALSE, FALSE, &Plist, FALSE);
-	if (check_implicit_conflict(pkg))
+success:
-		goto clean_memory;
+	/* delete the packing list contents */
 	free_plist(&Plist);
 	leave_playpen(Home);
-	if (pkg->other_version != NULL) {
+	if (replacing) {
 		/*
-		 * Replacing an existing package.
+		 * Upgrade step 3/4: move back +REQUIRED_BY file
-		 * Write meta-data, get rid of the old version,
+		 * (see also step 2/4)
 		 * install/update dependencies and finally extract.
 		 */
-		if (write_meta_data(pkg))
+		if (rename(replace_via, replace_to) != 0)
-			goto nuke_pkgdb;
+			err(EXIT_FAILURE, "renaming \"%s\" to \"%s\" failed", replace_via, replace_to);
 		if (start_replacing(pkg))
 			goto nuke_pkgdb;
 		if (check_dependencies(pkg))
 			goto nuke_pkgdb;
 	} else {
 		/*
-		 * Normal installation.
+		 * Upgrade step 4/4: Fix pkgs that depend on us to
-		 * Install/update dependencies first and
+		 * depend on the new version instead of the old
-		 * write the current package to disk afterwards.
+		 * one by fixing @pkgdep lines in +CONTENTS files.
 		 */
-		if (check_dependencies(pkg))
+		/* TODO */
 			goto clean_memory;
 		if (write_meta_data(pkg))
 			goto nuke_pkgdb;
+	}
-	if (run_install_script(pkg, "PRE-INSTALL"))
+	return errc;
 		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->logdir);
 	if (pkg->meta_data.meta_display != NULL)
 		fputs(pkg->meta_data.meta_display, stdout);
-	pkg_register_views(pkg);
+void
 cleanup(int signo)
+{
 	static int alreadyCleaning;
 	void   (*oldint) (int);
 	void   (*oldhup) (int);
 	int    saved_errno;
-	status = 0;
+	saved_errno = errno;
-	goto clean_memory;
+	oldint = signal(SIGINT, SIG_IGN);
 	oldhup = signal(SIGHUP, SIG_IGN);
-nuke_pkg:
+	if (!alreadyCleaning) {
-	if (!Fake) {
+		alreadyCleaning = 1;
-		if (pkg->other_version) {
+		if (signo)
-			warnx("Updating of %s to %s failed.",
+			printf("Signal %d received, cleaning up.\n", signo);
-			    pkg->other_version, pkg->pkgname);
+		if (!Fake && zapLogDir && LogDir[0])
-			warnx("Remember to run pkg_admin rebuild-tree after fixing this.");
+			(void) fexec(REMOVE_CMD, "-fr", LogDir, NULL);
 		leave_playpen(Home);
-		delete_package(FALSE, FALSE, &pkg->plist, FALSE);
+		if (signo)
 			exit(1);
+	}
 	signal(SIGINT, oldint);
-nuke_pkgdb:
+	signal(SIGHUP, oldhup);
-	if (!Fake) {
+	errno = saved_errno;
 		(void) fexec(REMOVE_CMD, "-fr", pkg->logdir, (void *)NULL);
 		free(pkg->logdir);
 		pkg->logdir = NULL;
 clean_memory:
 	if (pkg->logdir != NULL && NoRecord && !Fake)
 		(void) fexec(REMOVE_CMD, "-fr", pkg->logdir, (void *)NULL);
 	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);
 	return status;
+}
 int
 pkg_perform(lpkg_head_t *pkgs)
+{
-	int     errors = 0;
+	int     err_cnt = 0;
 	lpkg_t *lpp;
 	signal(SIGINT, cleanup);
 	signal(SIGHUP, cleanup);
 	TAILQ_INIT(&files);
 	while ((lpp = TAILQ_FIRST(pkgs)) != NULL) {
 		path_prepend_from_pkgname(lpp->lp_name);
-		if (pkg_do(lpp->lp_name, Automatic))
+		err_cnt += pkg_do(lpp->lp_name, pkgs);
 			++errors;
 		path_prepend_clear();
 		TAILQ_REMOVE(pkgs, lpp, lp_link);
 		free_lpkg(lpp);
+	}
-	return errors;
+	ftp_stop();
 	return err_cnt;
+}

 @@ -1,33 +1,33 @@
-/*	$NetBSD: file.c,v 1.24 2008/04/26 14:56:34 joerg Exp $	*/
+/*	$NetBSD: file.c,v 1.25 2008/04/26 17:40:01 joerg Exp $	*/
 #if HAVE_CONFIG_H
 #include "config.h"
 #endif
 #include <nbcompat.h>
 #if HAVE_SYS_CDEFS_H
 #include <sys/cdefs.h>
 #endif
 #if HAVE_SYS_PARAM_H
 #include <sys/param.h>
 #endif
 #if HAVE_SYS_QUEUE_H
 #include <sys/queue.h>
 #endif
 #ifndef lint
 #if 0
 static const char *rcsid = "from FreeBSD Id: file.c,v 1.29 1997/10/08 07:47:54 charnier Exp";
 #else
-__RCSID("$NetBSD: file.c,v 1.24 2008/04/26 14:56:34 joerg Exp $");
+__RCSID("$NetBSD: file.c,v 1.25 2008/04/26 17:40:01 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
 @@ -208,26 +208,283 @@ URLlength(const char *fname)
 		for (i = 0; isspace((unsigned char) *fname); i++) {
 			fname++;
+		}
 		for (up = urls; up->u_s; up++) {
 			if (strncmp(fname, up->u_s, up->u_len) == 0) {
 				return i + up->u_len;    /* ... + sizeof(up->u_s);  - HF */
+			}
+		}
+	}
 	return -1;
+}
 /*
  * Returns the host part of a URL
  */
 const char *
 fileURLHost(const char *fname, char *where, int max)
+{
 	const char   *ret;
 	int     i;
 	assert(where != NULL);
 	assert(max > 0);
 	if ((i = URLlength(fname)) < 0) {	/* invalid URL? */
 		errx(EXIT_FAILURE, "fileURLhost called with a bad URL: `%s'", fname);
+	}
 	fname += i;
 	/* Do we have a place to stick our work? */
 	ret = where;
 	while (*fname && *fname != '/' && --max)
 		*where++ = *fname++;
 	*where = '\0';
 	return ret;
+}
 /*
  * Returns the filename part of a URL
  */
 const char *
 fileURLFilename(const char *fname, char *where, int max)
+{
 	const char *ret;
 	int     i;
 	assert(where != NULL);
 	assert(max > 0);
 	if ((i = URLlength(fname)) < 0) {	/* invalid URL? */
 		errx(EXIT_FAILURE, "fileURLFilename called with a bad URL: `%s'", fname);
+	}
 	fname += i;
 	/* Do we have a place to stick our work? */
 	ret = where;
 	while (*fname && *fname != '/')
 		++fname;
 	if (*fname == '/') {
 		while (*fname && --max)
 			*where++ = *fname++;
+	}
 	*where = '\0';
 	return ret;
+}
 /*
  * Try and fetch a file by URL, returning the directory name for where
  * it's unpacked, if successful. To be handed to leave_playpen() later.
  */
 char   *
 fileGetURL(const char *spec)
+{
 	char    host[MAXHOSTNAMELEN], file[MaxPathSize];
 	const char *cp;
 	char   *rp;
 	char    pen[MaxPathSize];
 	int     rc;
 	rp = NULL;
 	if (!IS_URL(spec)) {
 		errx(EXIT_FAILURE, "fileGetURL was called with non-URL arg '%s'", spec);
+	}
  	/* Some sanity checks on the URL */
 	cp = fileURLHost(spec, host, MAXHOSTNAMELEN);
 	if (!*cp) {
 		warnx("URL `%s' has bad host part!", spec);
 		return NULL;
+	}
 	cp = fileURLFilename(spec, file, MaxPathSize);
 	if (!*cp) {
 		warnx("URL `%s' has bad filename part!", spec);
 		return NULL;
+	}
 	if (Verbose)
 		printf("Trying to fetch %s.\n", spec);
 	pen[0] = '\0';
 	rp = make_playpen(pen, sizeof(pen), 0);
 	if (rp == NULL) {
 		printf("Error: Unable to construct a new playpen for FTP!\n");
 		return NULL;
+	}
 	rp = strdup(pen);
 	rc = unpackURL(spec, pen);
 	if (rc < 0) {
 		leave_playpen(rp); /* Don't leave dir hang around! */
 		printf("Error on unpackURL('%s', '%s')\n", spec, pen);
 		return NULL;
+	}
 	return rp;
+}
 static char *
 resolvepattern1(const char *name)
+{
 	static char tmp[MaxPathSize];
 	char *cp;
 	if (IS_URL(name)) {
 		/* some package depends on a wildcard pkg */
 		int rc;
 		rc = expandURL(tmp, name);
 		if (rc < 0) {
 			return NULL;
+		}
 		if (Verbose)
 			printf("'%s' expanded to '%s'\n", name, tmp);
 		return tmp;    /* return expanded URL w/ corrent pkg */
+	}
 	else if (ispkgpattern(name)) {
 		cp = find_best_matching_file(dirname_of(name), basename_of(name), 1, 0);
 		if (cp) {
 			snprintf(tmp, sizeof(tmp), "%s/%s", dirname_of(name), cp);
 			free(cp);
 			return tmp;
+		}
 	} else {
 		if (isfile(name)) {
 			strlcpy(tmp, name, sizeof(tmp));
 			return tmp;
+		}
+	}
 	return NULL;
+}
 static char *
 resolvepattern(const char *name)
+{
 	char tmp[MaxPathSize];
 	char *cp;
 	const char *suf;
 	cp = resolvepattern1(name);
 	if (cp != NULL)
 		return cp;
 	if (ispkgpattern(name))
 		return NULL;
 	suf = suffix_of(name);
 	if (!strcmp(suf, "tbz") || !strcmp(suf, "tgz"))
 		return NULL;
 	/* add suffix and try */
 	snprintf(tmp, sizeof(tmp), "%s.tbz", name);
 	cp = resolvepattern1(tmp);
 	if (cp != NULL)
 		return cp;
 	snprintf(tmp, sizeof(tmp), "%s.tgz", name);
 	cp = resolvepattern1(tmp);
 	if (cp != NULL)
 		return cp;
 	/* add version number wildcard and try */
 	snprintf(tmp, sizeof(tmp), "%s-[0-9]*", name);
 	return resolvepattern1(tmp);
+}
 /*
  *  Look for filename/pattern "fname" in
  * Returns a full path/URL where the pkg can be found
  */
 char   *
 fileFindByPath(const char *fname)
+{
 	char    tmp[MaxPathSize];
 	struct path *path;
 	/*
 	 * 1. if fname is an absolute pathname or a URL,
 	 *    just use it.
 	 */
 	if (IS_FULLPATH(fname) || IS_URL(fname))
 		return resolvepattern(fname);
 	/*
 	 * 2. otherwise, use PKG_PATH.
 	 */
 	TAILQ_FOREACH(path, &PkgPath, pl_entry) {
 		char *cp;
 		const char *cp2 = path->pl_path;
 		if (Verbose)
 			printf("trying PKG_PATH %s\n", cp2);
 		if (IS_FULLPATH(cp2) || IS_URL(cp2)) {
 			snprintf(tmp, sizeof(tmp), "%s/%s", cp2, fname);
+		}
 		else {
 			char cwdtmp[MaxPathSize];
 			if (getcwd(cwdtmp, sizeof(cwdtmp)) == NULL)
 				errx(EXIT_FAILURE, "getcwd");
 			snprintf(tmp, sizeof(tmp), "%s/%s/%s", cwdtmp, cp2, fname);
+		}
 		cp = resolvepattern(tmp);
 		if (cp)
 			return cp;
+	}
 #if 0
 	/*
 	 * 3. finally, search current directory.
 	 */
 	snprintf(tmp, sizeof(tmp), "./%s", fname);
 	return resolvepattern(tmp);
 #else
 	return NULL;
 #endif
+}
 /*
  *  Expect "fname" to point at a file, and read it into
  *  the buffer returned.
  */
 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 = (char *) malloc((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;
+}
 /*
  * Takes a filename and package name, returning (in "try") the canonical
  * "preserve" name for it.
  */
 Boolean
 make_preserve_name(char *try, size_t max, char *name, char *file)
+{
 	int     len, i;
 	if ((len = strlen(file)) == 0)
 		return FALSE;
 	else
 		i = len - 1;
 	strncpy(try, file, max);
 @@ -242,26 +499,117 @@ make_preserve_name(char *try, size_t max
+	}
 	if (!i) {
 		try[0] = '.';
 		strncpy(try + 1, file, max - 1);
+	}
 	/* I should probably be called rude names for these inline assignments */
 	strncat(try, ".", max -= strlen(try));
 	strncat(try, name, max -= strlen(name));
 	strncat(try, ".", max--);
 	strncat(try, "backup", max -= 6);
 	return TRUE;
+}
 /*
  * Write the contents of "str" to a file
  */
 void
 write_file(char *name, char *str)
+{
 	size_t  len;
 	FILE   *fp;
 	if ((fp = fopen(name, "w")) == (FILE *) NULL) {
 		cleanup(0);
 		errx(2, "cannot fopen '%s' for writing", name);
+	}
 	len = strlen(str);
 	if (fwrite(str, 1, len, fp) != len) {
 		cleanup(0);
 		errx(2, "short fwrite on '%s', tried to write %ld bytes",
 		    name, (long) len);
+	}
 	if (fclose(fp)) {
 		cleanup(0);
 		errx(2, "failure to fclose '%s'", name);
+	}
+}
 void
 copy_file(char *dir, char *fname, char *to)
+{
 	char    fpath[MaxPathSize];
 	(void) snprintf(fpath, sizeof(fpath), "%s%s%s",
 			(fname[0] != '/') ? dir : "",
 			(fname[0] != '/') ? "/" : "",
 			fname);
 	if (fexec("cp", "-r", fpath, to, NULL)) {
 		cleanup(0);
 		errx(2, "could not perform 'cp -r %s %s'", fpath, to);
+	}
+}
 void
 move_file(char *dir, char *fname, char *to)
+{
 	char    fpath[MaxPathSize];
 	(void) snprintf(fpath, sizeof(fpath), "%s%s%s",
 			(fname[0] != '/') ? dir : "",
 			(fname[0] != '/') ? "/" : "",
 			fname);
 	if (fexec("mv", fpath, to, NULL)) {
 		cleanup(0);
 		errx(2, "could not perform 'mv %s %s'", fpath, to);
+	}
+}
 void
 move_files(const char *dir, const char *pattern, const char *to)
+{
 	char	fpath[MaxPathSize];
 	glob_t	globbed;
 	size_t	i;
 	(void) snprintf(fpath, sizeof(fpath), "%s/%s", dir, pattern);
 	if ((i=glob(fpath, GLOB_NOSORT, NULL, &globbed)) != 0) {
 		switch(i) {
 		case GLOB_NOMATCH:
 			warn("no files matching ``%s'' found", fpath);
 			break;
 		case GLOB_ABORTED:
 			warn("globbing aborted");
 			break;
 		case GLOB_NOSPACE:
 			warn("out-of-memory during globbing");
 			break;
 		default:
 			warn("unknown error during globbing");
 			break;
+		}
 		return;
+	}
 	/* Moving globbed files -- we just use mv(1) to do the job */
 	for (i=0; i<globbed.gl_pathc; i++)
 		if (fexec("mv", globbed.gl_pathv[i], to, NULL)) {
 			cleanup(0);
 			errx(2, "could not perform 'mv %s %s'", globbed.gl_pathv[i], to);
+		}
 	return;
+}
 void
 remove_files(const char *path, const char *pattern)
+{
 	char	fpath[MaxPathSize];
 	glob_t	globbed;
 	int	i;
 	(void) snprintf(fpath, sizeof(fpath), "%s/%s", path, pattern);
 	if ((i=glob(fpath, GLOB_NOSORT, NULL, &globbed)) != 0) {
 		switch(i) {
 		case GLOB_NOMATCH:
 			warn("no files matching ``%s'' found", fpath);
 			break;
 @@ -277,47 +625,115 @@ remove_files(const char *path, const cha
+		}
 		return;
+	}
 	/* deleting globbed files */
 	for (i=0; i<globbed.gl_pathc; i++)
 		if (unlink(globbed.gl_pathv[i]) < 0)
 			warn("can't delete ``%s''", globbed.gl_pathv[i]);
 	return;
+}
 /*
  * Unpack a tar file
  */
 int
 unpack(const char *pkg, const lfile_head_t *filesp)
+{
 	const char *decompress_cmd = NULL;
 	const char *suf;
 	int count = 0;
 	lfile_t	*lfp;
 	char **up_argv;
 	int up_argc = 7;
 	int i = 0;
 	int result;
 	if (filesp != NULL)
 		TAILQ_FOREACH(lfp, filesp, lf_link)
 			count++;
 	up_argc += count;
 	up_argv = malloc((count + up_argc + 1) * sizeof(char *));
 	if (!IS_STDIN(pkg)) {
 		suf = suffix_of(pkg);
 		if (!strcmp(suf, "tbz") || !strcmp(suf, "bz2"))
 			decompress_cmd = BZIP2_CMD;
 		else if (!strcmp(suf, "tgz") || !strcmp(suf, "gz"))
 			decompress_cmd = GZIP_CMD;
 		else if (!strcmp(suf, "tar"))
 			; /* do nothing */
 		else
 			errx(EXIT_FAILURE, "don't know how to decompress %s, sorry", pkg);
 	} else
 		decompress_cmd = GZIP_CMD;
 	up_argv[i] = (char *)strrchr(TAR_CMD, '/');
 	if (up_argv[i] == NULL)
 		up_argv[i] = TAR_CMD;
 	else
 		up_argv[i]++;  /* skip / character */
 	if (count > 0)
 		up_argv[++i] = "--fast-read";
 	if (decompress_cmd != NULL) {
 		up_argv[++i] = "--use-compress-program";
 		up_argv[++i] = (char *)decompress_cmd;
+	}
 	up_argv[++i] = "-xpf";
 	up_argv[++i] = (char *)pkg;
 	if (count > 0)
 		TAILQ_FOREACH(lfp, filesp, lf_link)
 			up_argv[++i] = lfp->lf_name;
 	up_argv[++i] = NULL;
 	if (Verbose) {
 		printf("running: %s", TAR_CMD);
 		for (i = 1; up_argv[i] != NULL; i++)
 			printf(" %s", up_argv[i]);
 		printf("\n");
+	}
 	result = pfcexec(NULL, TAR_CMD, (const char **)up_argv);
 	free(up_argv);
 	if (result != 0) {
 		warnx("extract of %s failed", pkg);
 		return 1;
+	}
 	return 0;
+}
 /*
  * Using fmt, replace all instances of:
+ *
  * %F	With the parameter "name"
  * %D	With the parameter "dir"
  * %B	Return the directory part ("base") of %D/%F
  * %f	Return the filename part of %D/%F
+ *
  * Check that no overflows can occur.
  */
-int
+void
-format_cmd(char *buf, size_t size, const char *fmt, const char *dir, const char *name)
+format_cmd(char *buf, size_t size, char *fmt, char *dir, char *name)
+{
 	char    scratch[MaxPathSize * 2];
 	char   *bufp;
 	char   *cp;
 	for (bufp = buf; (int) (bufp - buf) < size && *fmt;) {
 		if (*fmt == '%') {
 			if (*++fmt != 'D' && name == NULL) {
-				warnx("no last file available for '%s' command", buf);
+				cleanup(0);
-				return -1;
+				errx(2, "no last file available for '%s' command", buf);
+			}
 			switch (*fmt) {
 			case 'F':
 				strlcpy(bufp, name, size - (int) (bufp - buf));
 				bufp += strlen(bufp);
 				break;
 			case 'D':
 				strlcpy(bufp, dir, size - (int) (bufp - buf));
 				bufp += strlen(bufp);
 				break;
 			case 'B':
 @@ -342,15 +758,14 @@ format_cmd(char *buf, size_t size, const
 				break;
 			default:
 				*bufp++ = '%';
 				*bufp++ = *fmt;
 				break;
+			}
 			++fmt;
 		} else {
 			*bufp++ = *fmt++;
+		}
+	}
 	*bufp = '\0';
 	return 0;
+}

/* $NetBSD: ftpio.c,v 1.28 2008/04/26 17:40:01 joerg Exp $ */ #if HAVE_CONFIG_H #include "config.h" #endif #include <nbcompat.h> #if HAVE_SYS_CDEFS_H #include <sys/cdefs.h> #endif #ifndef lint __RCSID("$NetBSD: ftpio.c,v 1.28 2008/04/26 17:40:01 joerg Exp $"); #endif /*- * Copyright (c) 1999-2008 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Hubert Feyrer <hubert@feyrer.de> and Thomas Klausner. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the NetBSD * Foundation, Inc. and its contributors. * 4. Neither the name of The NetBSD Foundation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * 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_SYS_TYPES_H #include <sys/types.h> #endif #if HAVE_SYS_TIME_H #include <sys/time.h> #endif #if HAVE_SYS_POLL_H #include <sys/poll.h> #endif #if HAVE_SYS_WAIT_H #include <sys/wait.h> #endif #if HAVE_SIGNAL_H #include <signal.h> #endif #if HAVE_ASSERT_H #include <assert.h> #endif #if HAVE_CTYPE_H #include <ctype.h> #endif #if HAVE_ERR_H #include <err.h> #endif #if HAVE_ERRNO_H #include <errno.h> #endif #if HAVE_FCNTL_H #include <fcntl.h> #endif #if HAVE_NETDB_H #include <netdb.h> #endif #if HAVE_REGEX_H #include <regex.h> #endif #if HAVE_STRING_H #include <string.h> #endif #if HAVE_STDIO_H #include <stdio.h> #endif #if HAVE_STDLIB_H #include <stdlib.h> #endif #if HAVE_TERMCAP_H #include <termcap.h> #endif #if HAVE_UNISTD_H #include <unistd.h> #endif #include "../lib/lib.h" /* * Names of environment variables used to pass things to * subprocesses, for connection caching. */ #define PKG_FTPIO_COMMAND "PKG_FTPIO_COMMAND" #define PKG_FTPIO_ANSWER "PKG_FTPIO_ANSWER" #define PKG_FTPIO_CNT "PKG_FTPIO_CNT" #define PKG_FTPIO_CURRENTHOST "PKG_FTPIO_CURRENTHOST" #define PKG_FTPIO_CURRENTDIR "PKG_FTPIO_CURRENTDIR" #undef STANDALONE /* define for standalone debugging */ /* File descriptors */ typedef struct { int command; int answer; } fds; static int needclose=0; static int ftp_started=0; static fds ftpio; static int ftp_pid; static char term[1024]; static char bold_on[1024]; static char bold_off[1024]; static char *ftp_expand_URL(const char *, char *); static int hexvalue(char); static char *http_expand_URL(const char *, char *); static int http_extract_fn(char *, char *, size_t); static void URL_decode(char *); /* * expect "str" (a regular expression) on file descriptor "fd", storing * the FTP return code of the command in the integer "ftprc". The "str" * string is expected to match some FTP return codes after a '\n', e.g. * "\n(550|226).*\n" */ static int expect(int fd, const char *str, int *ftprc) { int rc; char buf[256]; regex_t rstr; int done; struct pollfd set[1]; int retval; regmatch_t match; int verbose_expect=0; if (regcomp(&rstr, str, REG_EXTENDED) != 0) err(EXIT_FAILURE, "expect: regcomp() failed"); memset(buf, '\n', sizeof(buf)); done=0; retval=0; set[0].fd = fd; set[0].events = POLLIN; while(!done) { rc = poll(set, 1, 60*60*1000); /* seconds until next message from tar */ switch (rc) { case -1: if (errno == EINTR) break; warn("expect: poll() failed (probably ftp died because of bad args)"); done = 1; retval = -1; break; case 0: warnx("expect: poll() timeout"); /* need to send ftp coprocess SIGINT to make it stop * downloading into dir that we'll blow away in a second */ kill(ftp_pid, SIGINT); /* Wait until ftp coprocess is responsive again * XXX Entering recursion here! */ rc = ftp_cmd("cd .\n", "\n(550|250).*\n"); if (rc != 250) { /* now we have a really good reason to bail out ;) */ } /* ftp is at command prompt again, and will wait for our * next command. If we were downloading, we can now safely * continue and remove the dir that the tar command was * expanding to */ done = 1; /* hope that's ok */ retval = -1; break; default: if (set[0].revents & POLLHUP) { done = 1; retval = -1; break; } rc = read(fd, &buf[sizeof(buf) - 1], 1); if (rc <= 0) { done = 1; retval = -1; break; } if (verbose_expect) putchar(buf[sizeof(buf)-1]); if (regexec(&rstr, buf, 1, &match, 0) == 0) { if (ftprc && isdigit((unsigned char)buf[match.rm_so+1])) *ftprc = atoi(buf+match.rm_so+1); done=1; retval=0; } memmove(buf, buf+1, sizeof(buf)-1); /* yes, this is non-performant */ break; } } return retval; } /* * send a certain ftp-command "cmd" to our FTP coprocess, and wait for * "expectstr" to be returned. Return numeric FTP return code or -1 * in case of an error (usually expect() timeout) */ int ftp_cmd(const char *cmd, const char *expectstr) { int rc=0, verbose_ftp=0; int len; if (Verbose) verbose_ftp=1; if (verbose_ftp) fprintf(stderr, "\n%sftp> %s%s", bold_on, cmd, bold_off); fflush(stdout); len = write(ftpio.command, cmd, strlen(cmd)); if (len == strlen(cmd)) { if (expectstr) { /* set "rc" to the FTP error code: */ if (expect(ftpio.answer, expectstr, &rc) == -1) rc = -1; /* some error occurred */ } } else { if (Verbose) warn("short write"); } return rc; } /* * Really fire up FTP coprocess */ static int setupCoproc(const char *base) { int command_pipe[2]; int answer_pipe[2]; int rc1, rc2; char buf[20]; char *argv0 = (char *)strrchr(FTP_CMD, '/'); if (argv0 == NULL) argv0 = FTP_CMD; else argv0++; rc1 = pipe(command_pipe); rc2 = pipe(answer_pipe); if(rc1==-1 || rc2==-1) { warn("setupCoproc: pipe() failed"); return -1; } if (command_pipe[0] == -1 || command_pipe[1] == -1 || answer_pipe[0] == -1 || answer_pipe[1] == -1 ) { warn("setupCoproc: pipe() returned bogus descriptor"); return -1; } rc1 = fork(); switch (rc1) { case -1: /* Error */ warn("setupCoproc: fork() failed"); return -1; break; case 0: /* Child */ (void) close(command_pipe[1]); rc1 = dup2(command_pipe[0], 0); if (rc1 == -1) { err(EXIT_FAILURE, "setupCoproc: dup2 failed (command_pipe[0])"); } (void) close(command_pipe[0]); (void) close(answer_pipe[0]); rc1 = dup2(answer_pipe[1], 1); if (rc1 == -1) { err(EXIT_FAILURE, "setupCoproc: dup2 failed (answer_pipe[1])"); } (void) close(answer_pipe[1]); setbuf(stdout, NULL); if (Verbose) fprintf(stderr, "%sftp -detv %s%s\n", bold_on, base, bold_off); rc1 = execlp(FTP_CMD, argv0, "-detv", base, NULL); warn("setupCoproc: execlp() failed"); exit(1); break; default: /* Parent */ (void) close(command_pipe[0]); (void) close(answer_pipe[1]); (void) snprintf(buf, sizeof(buf), "%d", command_pipe[1]); setenv(PKG_FTPIO_COMMAND, buf, 1); (void) snprintf(buf, sizeof(buf), "%d", answer_pipe[0]); setenv(PKG_FTPIO_ANSWER, buf, 1); ftpio.command = command_pipe[1]; ftpio.answer = answer_pipe[0]; ftp_pid = rc1; /* to ^C transfers */ fcntl(ftpio.command, F_SETFL, O_NONBLOCK); fcntl(ftpio.answer , F_SETFL, O_NONBLOCK); break; } return 0; } /* * Dummy signal handler to detect if the ftp(1) coprocess or * and of the processes of the tar/gzip pipeline dies. */ static void sigchld_handler (int n) { /* Make poll(2) return EINTR */ } /* * SIGPIPE only happens when there's something wrong with the FTP * coprocess. In that case, set mark to not try to close shut down * the coprocess. */ static void sigpipe_handler(int n) { /* aparently our ftp companion died */ if (Verbose) fprintf(stderr, "SIGPIPE!\n"); needclose = 0; } /* * Close the FTP coprocess' current connection, but * keep the process itself alive. */ void ftp_stop(void) { #if defined(__svr4__) && defined(__sun__) char env[BUFSIZ]; #endif const char *tmp1, *tmp2; if (!ftp_started) return; tmp1=getenv(PKG_FTPIO_COMMAND); tmp2=getenv(PKG_FTPIO_ANSWER); /* (Only) the last one closes the link */ if (tmp1 != NULL && tmp2 != NULL) { if (needclose) ftp_cmd("close\n", "\n(221 .*|Not connected.)\n"); (void) close(ftpio.command); (void) close(ftpio.answer); } #if defined(__svr4__) && defined(__sun__) (void) snprintf(env, sizeof(env), "%s=", PKG_FTPIO_COMMAND); putenv(env); (void) snprintf(env, sizeof(env), "%s=", PKG_FTPIO_ANSWER); putenv(env); #else unsetenv(PKG_FTPIO_COMMAND); unsetenv(PKG_FTPIO_ANSWER); #endif } /* * (Start and re-)Connect the FTP coprocess to some host/dir. * If the requested host/dir is different than the one that the * coprocess is currently at, close first. */ int ftp_start(const char *base) { const char *tmp1, *tmp2; char *p; int rc; char newHost[MAXHOSTNAMELEN]; const char *newDir; const char *currentHost=getenv(PKG_FTPIO_CURRENTHOST); const char *currentDir=getenv(PKG_FTPIO_CURRENTDIR); int urllen; /* talk to termcap for bold on/off escape sequences */ if (getenv("TERM") != NULL && tgetent(term, getenv("TERM")) > 0) { p = bold_on; tgetstr("md", &p); p = bold_off; tgetstr("me", &p); } else { bold_on[0] = '\0'; bold_off[0] = '\0'; } fileURLHost(base, newHost, sizeof(newHost)); urllen = URLlength(base); if (urllen < 0 || !(newDir = strchr(base + URLlength(base), '/'))) errx(EXIT_FAILURE, "ftp_start: bad URL '%s'", base); newDir++; if (currentHost && currentDir && ( strcmp(newHost, currentHost) != 0 || strcmp(newDir, currentDir) != 0)) { /* could handle new dir case better here, w/o reconnect */ if (Verbose) { printf("ftp_start: new host or dir, stopping previous connect...\n"); printf("currentHost='%s', newHost='%s'\n", currentHost, newHost); printf("currentDir='%s', newDir='%s'\n", currentDir, newDir); } ftp_stop(); if (Verbose) printf("ftp stopped\n"); } setenv(PKG_FTPIO_CURRENTHOST, newHost, 1); /* need to update this in the environment */ setenv(PKG_FTPIO_CURRENTDIR, newDir, 1); /* for subprocesses to have this available */ tmp1=getenv(PKG_FTPIO_COMMAND); tmp2=getenv(PKG_FTPIO_ANSWER); if(tmp1==NULL || tmp2==NULL || *tmp1=='\0' || *tmp2=='\0') { /* no FTP coprocess running yet */ if (Verbose) printf("Spawning FTP coprocess\n"); rc = setupCoproc(base); if (rc == -1) { warnx("setupCoproc() failed"); return -1; } needclose=1; signal(SIGPIPE, sigpipe_handler); signal(SIGCHLD, sigchld_handler); if ((expect(ftpio.answer, "\n(221|250|221|550).*\n", &rc) != 0) || rc != 250) { warnx("expect1 failed, rc=%d", rc); return -1; } /* nbftp now issues a CWD for each part of the path * and will return a code for each of them. No idea how to * deal with that other than to issue a 'prompt off' to * get something that we can wait for and that does NOT * look like a CWD command's output */ rc = ftp_cmd("prompt off\n", "\n(Interactive mode off|221).*\n"); if ((rc == 221) || (rc == -1)) { /* something is wrong */ ftp_started=1; /* not really, but for ftp_stop() */ ftp_stop(); warnx("prompt failed - wrong dir?"); return -1; } ftp_started=1; } else { /* get FDs of our coprocess */ ftpio.command = dup(atoi(tmp1)); if (ftpio.command == -1 ) { warnx("command dup() failed, increase 'descriptors' limit"); return -1; } ftpio.answer = dup(atoi(tmp2)); if (ftpio.answer == -1 ) { warnx("answer dup() failed, increase 'descriptors' limit"); return -1; } if (Verbose) printf("Reusing FDs %s/%s for communication to FTP coprocess\n", tmp1, tmp2); fcntl(ftpio.command, F_SETFL, O_NONBLOCK); fcntl(ftpio.answer , F_SETFL, O_NONBLOCK); } return 0; } /* * Expand the given wildcard URL "wildcardurl" if possible, and store the * expanded value into "expandedurl". return 0 if successful, -1 else. */ int expandURL(char *expandedurl, const char *wildcardurl) { char *pattern; char *bestmatch; char base[MaxPathSize]; pattern=strrchr(wildcardurl, '/'); if (pattern == NULL){ warnx("expandURL: no '/' in URL %s?!", wildcardurl); return -1; } if (pattern-strchr(wildcardurl, '/') < 2) { /* only one or two slashes in total */ warnx("expandURL: not enough '/' in URL %s", wildcardurl); return -1; } (void) snprintf(base, sizeof(base), "%.*s/", (int)(pattern-wildcardurl), wildcardurl); pattern++; if (strncmp(wildcardurl, "ftp://", 6) == 0) bestmatch=ftp_expand_URL(base, pattern); else if (strncmp(wildcardurl, "http://", 7) == 0) bestmatch=http_expand_URL(base, pattern); else { warnx("expandURL: unknown protocol in URL `%s'", wildcardurl); return -1; } /* no match found */ if (bestmatch == NULL) return -1; snprintf(expandedurl, MaxPathSize, "%s%s", base, bestmatch); if (Verbose) printf("best match: '%s'\n", expandedurl); return 0; } /* for a given wildcard ftp:// URL, find the best matching pkg */ static char * ftp_expand_URL(const char *base, char *pattern) { char *s, buf[MaxPathSize]; char tmpname[MaxPathSize]; char best[MaxPathSize]; char s_best[MaxPathSize]; int rc, got_list, tfd, retry_tbz; retry_tbz = 0; best[0]='\0'; s_best[0]='\0'; rc = ftp_start(base); if (rc == -1) { warnx("ftp_start() failed"); return NULL; } strlcpy(tmpname, "/var/tmp/pkg.XXXXXX", sizeof(tmpname)); tfd=mkstemp(tmpname); if (tfd == -1) { warnx("Cannot generate temp file for ftp(1)'s nlist output"); return NULL; } close(tfd); /* We don't need the file descriptor, but will use the file in a second */ s=strpbrk(pattern, "<>[]?*{"); /* Could leave out "[]?*" here; * ftp(1) is not that stupid */ if (!s) { /* This should only happen when getting here with (only) a package * name specified to pkg_add, and PKG_PATH containing some URL. */ (void) snprintf(buf, sizeof(buf), "nlist %s %s\n", pattern, tmpname); } else { /* replace possible version(wildcard) given with "-*". * we can't use the pkg wildcards here as dewey compare * and alternates won't be handled by ftp(1); sort * out later, using pkg_match() */ if (retry_tbz) { retry_with_tbz: (void) snprintf(buf, sizeof(buf), "nlist %.*s*.tbz %s\n", (int)(s-pattern), pattern, tmpname); retry_tbz = 0; } else { (void) snprintf(buf, sizeof(buf), "nlist %.*s*.tgz %s\n", (int)(s-pattern), pattern, tmpname); retry_tbz = 1; } } rc = ftp_cmd(buf, "\n(550|450|226).*\n"); /* catch errors */ if (rc != 226) got_list = 0; else got_list = 1; /* Sync - don't remove */ rc = ftp_cmd("cd .\n", "\n(550|250|257).*\n"); if (rc != 250) { warnx("chdir failed!"); unlink(tmpname); /* remove clutter */ return NULL; } if (got_list == 1 && access(tmpname, R_OK)==0) { FILE *f; char filename[MaxPathSize]; f=fopen(tmpname, "r"); if (f == NULL) { warn("fopen"); unlink(tmpname); /* remove clutter */ return NULL; } /* The following loop is basically the same as the readdir() loop * in findmatchingname() */ while (fgets(filename, sizeof(filename), f)) { /* * We need to strip off any .t[bg]z etc. * suffix here */ char s_filename[MaxPathSize]; char s_pattern[MaxPathSize]; filename[strlen(filename)-1] = '\0'; strip_txz(s_filename, NULL, filename); strip_txz(s_pattern, NULL, pattern); if (pkg_order(s_pattern, s_filename, s_best[0] != '\0' ? s_best : NULL) == 1) { strlcpy(s_best, s_filename, sizeof(s_best)); strlcpy(best, filename, sizeof(best)); } } (void) fclose(f); } if (retry_tbz) goto retry_with_tbz; if (best[0] == '\0' && Verbose) warnx("nothing appropriate found"); unlink(tmpname); if (best[0] == '\0') return NULL; return strdup(best); } /* for a given wildcard http:// URL, find the best matching pkg */ static char * http_expand_URL(const char *base, char *pattern) { char best[MaxPathSize]; char s_best[MaxPathSize]; char line[BUFSIZ]; char filename[MaxPathSize]; FILE *fp; int pipefds[2]; int state; pid_t pid; *best = '\0'; *s_best = '\0'; /* Set up a pipe for getting the file list */ if (pipe(pipefds) == -1) { warnx("cannot create pipe"); return NULL; } if ((pid = fork()) == -1) { warnx("cannot fork ftp process"); return NULL; } if (pid == 0) { /* The child */ if (dup2(pipefds[1], STDOUT_FILENO) == -1) { warnx("dup2 failed before starting ftp"); _exit(2); } close(pipefds[0]); close(pipefds[1]); /* get URL contents to stdout and thus to parent, * silently */ execlp("ftp", "ftp", "-V", "-o", "-", base, NULL); warnx("failed to execute ftp"); _exit(2); } /* parent */ close(pipefds[1]); if ((fp=fdopen(pipefds[0], "r")) == NULL) warn("can't fdopen pipe end"); else { char s_pattern[MaxPathSize]; int len, offset; /* strip of .t[bg]z for comparison */ strip_txz(s_pattern, NULL, pattern); /* initialize http_extract_fn internal state */ http_extract_fn(NULL, NULL, 0); /* read line from HTTP output and extract filenames */ while (fgets(line, sizeof(line), fp) != NULL) { len = offset = 0; while ((len=http_extract_fn(line+offset, filename, sizeof(filename))) > 0) { char s_filename[MaxPathSize]; offset += len; strip_txz(s_filename, NULL, filename); if (pkg_order(s_pattern, s_filename, *s_best != '\0' ? s_best : NULL) == 1) { strlcpy(best, filename, sizeof(best)); strlcpy(s_best, s_filename, sizeof(best)); } } } } fclose(fp); /* wait for child to exit */ if (waitpid(pid, &state, 0) < 0) { /* error has been reported by child */ return NULL; } if (best[0] == '\0') { if (Verbose) warnx("nothing appropriate found"); return NULL; } return strdup(best); } enum http_states { ST_NONE, ST_LT, ST_LTA, ST_TAGA, ST_H, ST_R, ST_E, ST_F, ST_HREF, ST_TAG, ST_TAGAX }; /* return any hrefs found */ static int http_extract_fn(char *input, char *outbuf, size_t outbuflen) { /* partial copied hrefs from previous calls are saved here */ static char tempbuf[MaxPathSize]; /* fill state of tempbuf */ static int tempbuffill = 0; /* parsing state information */ static enum http_states state; /* currently in double quotes (in parsing) */ static int dqflag; char p; int offset, found; if (outbuf == NULL) { /* init */ dqflag = tempbuffill = 0; state = ST_NONE; return 0; } offset = 0; found = 0; while ((p=input[offset++]) != '\0') { /* handle anything that's inside double quotes */ if (dqflag) { /* incomplete href */ if (state == ST_HREF) { /* check if space left in output * buffer */ if (tempbuffill >= sizeof(tempbuf)) { warnx("href starting with `%.*s'" " too long", 60, tempbuf); /* ignore remainder */ tempbuffill = 0; /* need space before "href" * can start again (invalidly, * of course, but we don't * care) */ state = ST_TAGAX; } /* href complete */ if (p == '\"') { /* complete */ dqflag = 0; tempbuf[tempbuffill++] = '\0'; /* need space before "href" * can start again (invalidly, * of course, but we don't * care) */ state = ST_TAGAX; found = 1; break; } else { /* copy one more char */ tempbuf[tempbuffill++] = p; } } else { /* leaving double quotes */ if (p == '\"') dqflag = 0; } continue; } /* * entering double quotes? (only relevant inside a tag) */ if (state != ST_NONE && p == '\"') { dqflag = 1; continue; } /* other cases */ switch (state) { case ST_NONE: /* plain text, not in markup */ if (p == '<') state = ST_LT; break; case ST_LT: /* in tag -- "<" already found */ if (p == '>') state = ST_NONE; else if (p == 'a' || p == 'A') state = ST_LTA; else if (!isspace((unsigned char)p)) state = ST_TAG; break; case ST_LTA: /* in tag -- "<a" already found */ if (p == '>') state = ST_NONE; else if (isspace((unsigned char)p)) state = ST_TAGA; else state = ST_TAG; break; case ST_TAG: /* in tag, but not "<a" -- disregard */ if (p == '>') state = ST_NONE; break; case ST_TAGA: /* in a-tag -- "<a " already found */ if (p == '>') state = ST_NONE; else if (p == 'h' || p == 'H') state = ST_H; else if (!isspace((unsigned char)p)) state = ST_TAGAX; break; case ST_TAGAX: /* in unknown keyword in a-tag */ if (p == '>') state = ST_NONE; else if (isspace((unsigned char)p)) state = ST_TAGA; break; case ST_H: /* in a-tag -- "<a h" already found */ if (p == '>') state = ST_NONE; else if (p == 'r' || p == 'R') state = ST_R; else if (isspace((unsigned char)p)) state = ST_TAGA; else state = ST_TAGAX; break; case ST_R: /* in a-tag -- "<a hr" already found */ if (p == '>') state = ST_NONE; else if (p == 'e' || p == 'E') state = ST_E; else if (isspace((unsigned char)p)) state = ST_TAGA; else state = ST_TAGAX; break; case ST_E: /* in a-tag -- "<a hre" already found */ if (p == '>') state = ST_NONE; else if (p == 'f' || p == 'F') state = ST_F; else if (isspace((unsigned char)p)) state = ST_TAGA; else state = ST_TAGAX; break; case ST_F: /* in a-tag -- "<a href" already found */ if (p == '>') state = ST_NONE; else if (p == '=') state = ST_HREF; else if (!isspace((unsigned char)p)) state = ST_TAGAX; break; case ST_HREF: /* in a-tag -- "<a href=" already found */ /* XXX: handle missing double quotes? */ if (p == '>') state = ST_NONE; /* skip spaces before URL */ else if (!isspace((unsigned char)p)) state = ST_TAGA; break; /* no default case by purpose */ } } if (p == '\0') return -1; if (found) { char *q; URL_decode(tempbuf); /* strip path (XXX) */ if ((q=strrchr(tempbuf, '/')) == NULL) q = tempbuf; (void)strlcpy(outbuf, q, outbuflen); tempbuffill = 0; } return offset; } static int hexvalue(char p) { if (p >= '0' && p <= '9') return (p-'0'); else if (p >= 'a' && p <= 'f') return (p-'a'+10); else if (p >= 'A' && p <= 'F') return (p-'A'+10); else return -1; } /* fetch and extract URL url into directory path */ static int http_fetch(const char *url, const char *path) { int pipefds[2]; int stateftp, state; pid_t pidftp, pid; /* Set up a pipe for passing the fetched contents. */ if (pipe(pipefds) == -1) { warn("cannot create pipe"); return -1; } /* fork ftp child */ if ((pidftp = fork()) == -1) { warn("cannot fork process for ftp"); return -1; } if (pidftp == 0) { /* child */ if (dup2(pipefds[1], STDOUT_FILENO) == -1) { warn("dup2 failed before executing ftp"); _exit(2); } close(pipefds[0]); close(pipefds[1]); execlp(FTP_CMD, FTP_CMD, "-o", "-", url, NULL); warnx("failed to execute ftp"); _exit(2); } /* fork unpack child */ if ((pid = fork()) == -1) { warn("cannot fork unpack process"); return -1; } if (pid == 0) { /* child */ if (dup2(pipefds[0], STDIN_FILENO) == -1) { warn("dup2 failed before unpack"); _exit(2); } close(pipefds[0]); close(pipefds[1]); if ((path != NULL) && (chdir(path) < 0)) _exit(127); if (unpack("-", NULL) != 0) { warnx("unpack failed"); _exit(2); } _exit(0); } close(pipefds[0]); close(pipefds[1]); /* wait for unpack to exit */ while (waitpid(pid, &state, 0) < 0) { if (errno != EINTR) { (void)waitpid(pidftp, &stateftp, 0); return -1; } } while (waitpid(pidftp, &stateftp, 0) < 0) { if (errno != EINTR) { return -1; } } if (!WIFEXITED(state) || !WIFEXITED(stateftp)) return -1; if (WEXITSTATUS(state) != 0 || WEXITSTATUS(stateftp) != 0) return -1; return 0; } static void URL_decode(char *URL) { char *in, *out; in = out = URL; while (*in != '\0') { if (in[0] == '%' && in[1] != '\0' && in[2] != '\0') { /* URL-decode character */ if (hexvalue(in[1]) != -1 && hexvalue(in[2]) != -1) { *out++ = hexvalue(in[1])*16+hexvalue(in[2]); } /* skip invalid encoded signs too */ in += 3; } else *out++ = *in++; } *out = '\0'; return; } /* * extract the given (expanded) URL "url" to the given directory "dir" * return -1 on error, 0 else; */ int unpackURL(const char *url, const char *dir) { char *pkg; int rc; char base[MaxPathSize]; char pkg_path[MaxPathSize]; { /* Verify if the URL is really ok */ char expnd[MaxPathSize]; rc=expandURL(expnd, url); if (rc == -1) { warnx("unpackURL: verification expandURL failed"); return -1; } if (strcmp(expnd, url) != 0) { warnx("unpackURL: verification expandURL failed, '%s'!='%s'", expnd, url); return -1; } } pkg=strrchr(url, '/'); if (pkg == NULL){ warnx("unpackURL: no '/' in URL %s?!", url); return -1; } (void) snprintf(base, sizeof(base), "%.*s/", (int)(pkg-url), url); (void) snprintf(pkg_path, sizeof(pkg_path), "%.*s", (int)(pkg-url), url); /* no trailing '/' */ pkg++; /* Leave a hint for any depending pkgs that may need it */ if (getenv("PKG_PATH") == NULL) { setenv("PKG_PATH", pkg_path, 1); #if 0 path_create(pkg_path); /* XXX */ #endif if (Verbose) printf("setenv PKG_PATH='%s'\n", pkg_path); } if (strncmp(url, "http://", 7) == 0) return http_fetch(url, dir); rc = ftp_start(base); if (rc == -1) { warnx("ftp_start() failed"); return -1; /* error */ } { char cmd[1024]; const char *decompress_cmd = NULL; const char *suf; if (Verbose) printf("unpackURL '%s' to '%s'\n", url, dir); suf = suffix_of(pkg); if (!strcmp(suf, "tbz") || !strcmp(suf, "bz2")) decompress_cmd = BZIP2_CMD; else if (!strcmp(suf, "tgz") || !strcmp(suf, "gz")) decompress_cmd = GZIP_CMD; else if (!strcmp(suf, "tar")) ; /* do nothing */ else errx(EXIT_FAILURE, "don't know how to decompress %s, sorry", pkg); /* yes, this is gross, but needed for borken ftp(1) */ (void) snprintf(cmd, sizeof(cmd), "get %s \"| ( cd %s; " TAR_CMD " %s %s -vvxp -f - | tee %s )\"\n", pkg, dir, decompress_cmd != NULL ? "--use-compress-program" : "", decompress_cmd != NULL ? decompress_cmd : "", Verbose ? "/dev/stderr" : "/dev/null"); rc = ftp_cmd(cmd, "\n(226|550).*\n"); if (rc != 226) { warnx("Cannot fetch file (%d!=226)!", rc); return -1; } } return 0; } #ifdef STANDALONE static void usage(void) { errx(EXIT_FAILURE, "Usage: foo [-v] ftp://-pattern"); } int main(int argc, char *argv[]) { int rc, ch; char *argv0 = argv[0]; while ((ch = getopt(argc, argv, "v")) != -1) { switch (ch) { case 'v': Verbose=1; break; default: usage(); } } argc -= optind; argv += optind; if (argc<1) usage(); while(argv[0] != NULL) { char newurl[MaxPathSize]; printf("Expand %s:\n", argv[0]); rc = expandURL(newurl, argv[0]); if (rc==-1) warnx("Cannot expand %s", argv[0]); else printf("Expanded URL: %s\n", newurl); /* test out connection caching */ if (1) { char *s, buf[MaxPathSize]; if ((s=getenv(PKG_FTPIO_CNT)) && atoi(s)>0){ (void) snprintf(buf, sizeof(buf),"%d", atoi(s)-1); setenv(PKG_FTPIO_CNT, buf, 1); printf("%s>>> %s -v %s\n", s, argv0, argv[0]); fexec(argv0, "-v", argv[0], NULL); } } printf("\n\n\n"); argv++; } ftp_stop(); return 0; } void cleanup(int i) { } #endif /* STANDALONE */

 @@ -1,14 +1,14 @@
-/* $NetBSD: lib.h,v 1.43 2008/04/26 14:56:34 joerg Exp $ */
+/* $NetBSD: lib.h,v 1.44 2008/04/26 17:40:01 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
 @@ -76,38 +76,68 @@
 #ifndef FALSE
 #define FALSE	(0)
 #endif
 #ifndef OPSYS_NAME
 #define OPSYS_NAME "NetBSD"
 #endif
 #ifndef DEF_UMASK
 #define DEF_UMASK 022
 #endif
 #define	MKDIR_CMD	"mkdir"
 /* Usually "rm", but often "echo" during debugging! */
 #define REMOVE_CMD	"rm"
 /* Usually "rm", but often "echo" during debugging! */
 #define RMDIR_CMD	"rmdir"
 /* Define tar as a string, in case it's called gtar or something */
 #ifndef TAR_CMD
 #define TAR_CMD	"tar"
 #endif
 /* Define pax as a string, used to copy files from staging area */
 #ifndef PAX_CMD
 #define PAX_CMD "pax"
 #endif
 /* Define gzip and bzip2, used to unpack binary packages */
 #ifndef GZIP_CMD
 #define GZIP_CMD "gzip"
 #endif
 #ifndef BZIP2_CMD
 #define BZIP2_CMD "bzip2"
 #endif
 /* Define ftp as a string, in case the ftp client is called something else */
 #ifndef FTP_CMD
 #define FTP_CMD "ftp"
 #endif
 #ifndef CHOWN_CMD
 #define CHOWN_CMD "chown"
 #endif
 #ifndef CHMOD_CMD
 #define CHMOD_CMD "chmod"
 #endif
 #ifndef CHGRP_CMD
 #define CHGRP_CMD "chgrp"
 #endif
 /* some operating systems don't have this */
 #ifndef MAXPATHLEN
 #define MAXPATHLEN	1024
 #endif
 enum {
 	MaxPathSize = MAXPATHLEN
 };
 /* The names of our "special" files */
 #define CONTENTS_FNAME		"+CONTENTS"
 #define COMMENT_FNAME		"+COMMENT"
 #define DESC_FNAME		"+DESC"
 @@ -118,28 +148,33 @@ enum {
 #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 DEPOT_FNAME		"+DEPOT"
 /* The names of special variables */
 #define AUTOMATIC_VARNAME	"automatic"
-/* Prefix for extended PLIST cmd */
+/*
-#define CMD_CHAR		'@'
+ * files which we expect to be in every package, passed to
  * tar --fast-read.
  */
 #define ALL_FNAMES              CONTENTS_FNAME" "COMMENT_FNAME" "DESC_FNAME" "MTREE_FNAME" "BUILD_VERSION_FNAME" "BUILD_INFO_FNAME" "SIZE_PKG_FNAME" "SIZE_ALL_FNAME
 #define CMD_CHAR		'@'	/* prefix for extended PLIST cmd */
 /* The name of the "prefix" environment variable given to scripts */
 #define PKG_PREFIX_VNAME	"PKG_PREFIX"
 /*
  * 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.
 @@ -228,108 +263,143 @@ typedef struct _lfile_head_t lfile_head_
 	lfp = malloc(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;
 /* This structure describes a pipe to a child process */
 typedef struct {
 	int fds[2];	/* pipe, 0=child stdin, 1=parent output */
 	FILE *fp;	/* output from parent process */
 	pid_t pid;	/* process id of child process */
 	void (*cleanup)(void);	/* called on non-zero child exit status */
 } pipe_to_system_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 **);
+int	some_installed_package_conflicts_with(const char *, char **, char **);
 /* Prototypes */
 /* Misc */
 void    cleanup(int);
 char   *make_playpen(char *, size_t, size_t);
 char   *where_playpen(void);
 void    leave_playpen(char *);
 uint64_t min_free(const char *);
 void    save_dirs(char **, char **);
 void    restore_dirs(char *, char *);
 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 **);
 pipe_to_system_t	*pipe_to_system_begin(const char *, char *const *, void (*)(void));
 int	pipe_to_system_end(pipe_to_system_t *);
 /* 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 *);
 void	strip_txz(char *, 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 *);
 char   *fileGetURL(const char *);
 const char *fileURLFilename(const char *, char *, int);
 const char *fileURLHost(const char *, char *, int);
 char   *fileFindByPath(const char *);
 char   *fileGetContents(char *);
 Boolean make_preserve_name(char *, size_t, char *, char *);
 void    write_file(char *, char *);
 void    copy_file(char *, char *, char *);
 void    move_file(char *, char *, char *);
 void    move_files(const char *, const char *, const 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     unpack(const char *, const lfile_head_t *);
 void    format_cmd(char *, size_t, char *, char *, char *);
 /* ftpio.c: FTP handling */
 int	expandURL(char *, const char *);
 int	unpackURL(const char *, const char *);
 int	ftp_cmd(const char *, const char *);
 int	ftp_start(const char *);
 void	ftp_stop(void);
 /* pkg_io.c: Local and remote archive handling */
 struct archive;
-struct archive *open_archive(const char *, void **);
+struct archive *open_remote_archive(const char *, void **);
-void	close_archive(void *);
+void	close_remote_archive(void *);
-struct archive *find_archive(const char *, void **);
+struct archive *open_local_archive(const char *, void **);
 void	close_local_archive(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 *);

/* $NetBSD: pen.c,v 1.24 2008/04/26 17:40:01 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: pen.c,v 1.25 1997/10/08 07:48:12 charnier Exp"; #else __RCSID("$NetBSD: pen.c,v 1.24 2008/04/26 17:40:01 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 * * Routines for managing the "play pen". * */ #if HAVE_ERR_H #include <err.h> #endif #include "lib.h" #if HAVE_SYS_SIGNAL_H #include <sys/signal.h> #endif /* For keeping track of where we are */ static char Current[MaxPathSize]; static char Previous[MaxPathSize]; static int CurrentSet; /* rm -fr Current only if it's really set! */ /* CurrentSet is set to 0 before strcpy()s * to prevent rm'ing of a partial string * when interrupted by ^C */ char * where_playpen(void) { return Current; } /* * Find a good place to play. */ static char * find_play_pen(char *pen, size_t pensize, size_t sz) { const char **cp; struct stat sb; char *r; const char *tmpdir[] = { "PKG_TMPDIR", "TMPDIR", "/var/tmp", "/tmp", "/usr/tmp", NULL }; if (pen == NULL) { cleanup(0); errx(2, "find_play_pen(): 'pen' variable is NULL\n" "(this should not happen, please report!)"); return NULL; } if (pen[0] && (r = strrchr(pen, '/')) != NULL) { *r = '\0'; if (stat(pen, &sb) != FAIL && (min_free(pen) >= sz)) { *r = '/'; return pen; } } for (cp = tmpdir; *cp; cp++) { const char *d = (**cp == '/') ? *cp : getenv(*cp); if (d == NULL || stat(d, &sb) == FAIL || min_free(d) < sz) continue; (void)snprintf(pen, pensize, "%s/instmp.XXXXXX", d); return pen; } cleanup(0); errx(2, "Can't find enough temporary space to extract the files.\n" "Please set your PKG_TMPDIR environment variable to a location " "with at least %zu bytes free", sz); return NULL; } /* * Make a temporary directory to play in and chdir() to it, returning * pathname of previous working directory. */ char * make_playpen(char *pen, size_t pensize, size_t sz) { if (!find_play_pen(pen, pensize, sz)) return NULL; if (!mkdtemp(pen)) { cleanup(0); errx(2, "can't mkdtemp '%s'", pen); } /* * On at least NetBSD, the temporary directory may have a group * that isn't in the group list of the current user. In that * case, it is impossible to extract setgid binaries from the * package, since chmod(2) doesn't allow to set the S_ISGID bit * for a group that isn't yours. */ (void)chown(pen, -1, getegid()); if (Verbose) { if (sz) fprintf(stderr, "Requested space: %lu bytes, free space: %lld bytes in %s\n", (u_long) sz, (long long) min_free(pen), pen); } if (min_free(pen) < sz) { rmdir(pen); cleanup(0); errx(2, "not enough free space to create '%s'.\n" "Please set your PKG_TMPDIR environment variable to a location\n" "with more space and\ntry the command again", pen); } if (Current[0]) strlcpy(Previous, Current, sizeof(Previous)); else if (!getcwd(Previous, MaxPathSize)) { cleanup(0); err(EXIT_FAILURE, "fatal error during execution: getcwd"); } if (chdir(pen) == FAIL) { cleanup(0); errx(2, "can't chdir to '%s'", pen); } CurrentSet = 0; strlcpy(Current, pen, sizeof(Current)); CurrentSet = 1; return Previous; } /* * Convenience routine for getting out of playpen */ void leave_playpen(char *save) { void (*oldsig) (int); /* Make us interruptable while we're cleaning up - just in case... */ oldsig = signal(SIGINT, SIG_DFL); if (Previous[0] && chdir(Previous) == FAIL) { cleanup(0); errx(2, "can't chdir back to '%s'", Previous); } else if (CurrentSet && Current[0] && strcmp(Current, Previous)) { if (strcmp(Current, "/") == 0) { fprintf(stderr, "PANIC: About to rm -fr / (not doing so, aborting)\n"); abort(); } if (fexec("rm", "-fr", Current, NULL)) warnx("couldn't remove temporary dir '%s'", Current); strlcpy(Current, Previous, sizeof(Current)); } if (save) strlcpy(Previous, save, sizeof(Previous)); else Previous[0] = '\0'; signal(SIGINT, oldsig); } /* * Return free disk space (in bytes) on given file system. * Returns size in a uint64_t since off_t isn't 64 bits on all * operating systems. */ uint64_t min_free(const char *tmpdir) { struct statvfs buf; if (statvfs(tmpdir, &buf) != 0) { warn("statvfs"); return 0; } return (uint64_t)buf.f_bavail * buf.f_bsize; }

#if HAVE_CONFIG_H #include "config.h" #endif #include <nbcompat.h> #if HAVE_SYS_WAIT_H #include <sys/wait.h> #endif #if HAVE_ERR_H #include <err.h> #endif #if HAVE_ERRNO_H #include <errno.h> #endif #if HAVE_STDLIB_H #include <stdlib.h> #endif #if HAVE_UNISTD_H #include <unistd.h> #endif #if HAVE_STDIO_H #include <stdio.h> #endif #include "lib.h" /* * If the supplied callback is not NULL, then call it. */ static void call_callback(void (*callback)(void)) { if (callback != NULL) { callback(); } } /* * create pipe, fork and exec file with arguments in argv * child takes stdin from pipe, set up fp for parent to * output to pipe, and return this information. */ pipe_to_system_t *pipe_to_system_begin(const char *file, char *const argv[], void (*cleanup_callback)(void)) { pipe_to_system_t *retval; retval = malloc(sizeof(pipe_to_system_t)); if (retval == NULL) { call_callback(cleanup_callback); errx(2, "can't get pipe space"); } retval->cleanup = cleanup_callback; if (pipe(retval->fds) == -1) { call_callback(retval->cleanup); errx(2, "cannot create pipe"); } retval->pid = fork(); if (retval->pid == -1) { call_callback(retval->cleanup); errx(2, "cannot fork process for %s", file); } if (retval->pid == 0) { /* The child */ if (retval->fds[0] != 0) { dup2(retval->fds[0], 0); close(retval->fds[0]); } close(retval->fds[1]); execvp(file, argv); warn("failed to execute %s command", file); _exit(2); } /* Meanwhile, back in the parent process ... */ close(retval->fds[0]); retval->fp = fdopen(retval->fds[1], "w"); if (retval->fp == NULL) { call_callback(retval->cleanup); errx(2, "fdopen failed"); } return retval; } /* * close pipe and wait for child to exit. on non-zero exit status, * call cleanup callback. return exit status. */ int pipe_to_system_end(pipe_to_system_t *to_pipe) { int status; int wait_ret; fclose(to_pipe->fp); do { wait_ret = waitpid(to_pipe->pid, &status, 0); } while (wait_ret == -1 && errno == EINTR); if (wait_ret < 0) { call_callback(to_pipe->cleanup); errx(2, "waitpid returned failure"); } if (!WIFEXITED(status)) { call_callback(to_pipe->cleanup); errx(2, "waitpid: process terminated abnormally"); } free(to_pipe); return WEXITSTATUS(status); }

 @@ -1,39 +1,39 @@
-# $NetBSD: Makefile.in,v 1.17 2008/04/26 14:56:33 joerg Exp $
+# $NetBSD: Makefile.in,v 1.18 2008/04/26 17:40:01 joerg Exp $
 srcdir=		@srcdir@
 prefix=		@prefix@
 exec_prefix=	@exec_prefix@
 sbindir=	@sbindir@
 mandir=		@mandir@
 datarootdir=	@datarootdir@
 man1dir=	$(mandir)/man1
 cat1dir=	$(mandir)/cat1
 CC=		@CC@
 CCLD=		$(CC)
-LIBS=		-linstall -lfetch -larchive -lbz2 -lz @LIBS@
+LIBS=		-linstall @LIBS@
 CPPFLAGS=	@CPPFLAGS@ -I. -I$(srcdir) -I../lib
-DEFS=		@DEFS@ -DOPSYS_NAME=\"$(OPSYS)\" -DMACHINE_ARCH=\"$(MACHINE_ARCH)\" -DBINDIR=\"$(sbindir)\"
+DEFS=		@DEFS@ -DOPSYS_NAME=\"$(OPSYS)\" -DMACHINE_ARCH=\"$(MACHINE_ARCH)\" -DBINDIR=\"$(sbindir)\" -DTAR_CMD=\"@tar@\" -DPAX_CMD=\"@pax@\"
 CFLAGS=		@CFLAGS@
 LDFLAGS=	@LDFLAGS@ -L../lib
 INSTALL=	@INSTALL@
 PROG=		pkg_add
-OBJS=	main.o perform.o verify.o
+OBJS=	main.o perform.o futil.o extract.o verify.o
 all: $(PROG)
 .c.o:
 	$(CC) $(DEFS) $(CPPFLAGS) $(CFLAGS) -c $<
 $(PROG): $(OBJS)
 	$(CCLD) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
 clean:
 	rm -f $(OBJS) $(PROG)
 install:

 @@ -1,27 +1,27 @@
-/*	$NetBSD: main.c,v 1.15 2008/04/26 14:56:34 joerg Exp $	*/
+/*	$NetBSD: main.c,v 1.16 2008/04/26 17:40:01 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 char *rcsid = "from FreeBSD Id: main.c,v 1.16 1997/10/08 07:45:43 charnier Exp";
 #else
-__RCSID("$NetBSD: main.c,v 1.15 2008/04/26 14:56:34 joerg Exp $");
+__RCSID("$NetBSD: main.c,v 1.16 2008/04/26 17:40:01 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.
 @@ -50,34 +50,40 @@ __RCSID("$NetBSD: main.c,v 1.15 2008/04/
 #include "verify.h"
 static char Options[] = "AIK:LRVW:fhm:np:s:t:uvw:";
 char   *OverrideMachine = NULL;
 char   *Prefix = NULL;
 char   *View = NULL;
 char   *Viewbase = NULL;
 Boolean NoView = FALSE;
 Boolean NoInstall = FALSE;
 Boolean NoRecord = FALSE;
 Boolean Automatic = FALSE;
 char   *Mode = NULL;
 char   *Owner = NULL;
 char   *Group = NULL;
 char   *PkgName = NULL;
 char   *Directory = NULL;
 char    FirstPen[MaxPathSize];
 int     Replace = 0;
 static void
 usage(void)
+{
 	(void) fprintf(stderr, "%s\n%s\n%s\n",
 	    "usage: pkg_add [-AfhILnRuVv] [-K pkg_dbdir] [-m machine] [-p prefix]",
-	    "               [-s verification-type] [-W viewbase] [-w view]",
+	    "               [-s verification-type] [-t template] [-W viewbase] [-w view]",
 	    "               [[ftp|http]://[user[:password]@]host[:port]][/path/]pkg-name ...");
 	exit(1);
+}
 int
 main(int argc, char **argv)
+{
 	int     ch, error=0;
 	lpkg_head_t pkgs;
 	struct rlimit rlim;
 	int rc;
 	setprogname(argv[0]);
 @@ -110,31 +116,33 @@ main(int argc, char **argv)
 		case 'm':
 			OverrideMachine = optarg;
 			break;
 		case 'n':
 			Fake = TRUE;
 			Verbose = TRUE;
 			break;
 		case 'p':
 			Prefix = optarg;
 			break;
 #if 0
 		case 's':
 			set_verification(optarg);
 			break;
 #endif
 		case 't':
 			strlcpy(FirstPen, optarg, sizeof(FirstPen));
 			break;
 		case 'u':
 			Replace++;
 			break;
 		case 'V':
 			show_version();
 			/* NOTREACHED */
 		case 'v':
 			Verbose = TRUE;
 			break;

 @@ -1,14 +1,14 @@
-.\" $NetBSD: pkg_add.1,v 1.29 2008/04/26 14:56:34 joerg Exp $
+.\" $NetBSD: pkg_add.1,v 1.30 2008/04/26 17:40:01 joerg Exp $
 .\"
 .\" FreeBSD install - a package for the installation and maintenance
 .\" 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.
 .\"
 @@ -20,26 +20,27 @@
 .Dd August 23, 2007
 .Dt PKG_ADD 1
 .Os
 .Sh NAME
 .Nm pkg_add
 .Nd a utility for installing and upgrading software package distributions
 .Sh SYNOPSIS
 .Nm
 .Op Fl AfILnRuVv
 .Op Fl K Ar pkg_dbdir
 .Op Fl m Ar machine
 .Op Fl p Ar prefix
 .Op Fl s Ar verification-type
 .Op Fl t Ar template
 .Op Fl W Ar viewbase
 .Op Fl w Ar view
 .Ar \fR[[ftp|http]://[\fIuser\fR[:\fIpassword]\fR@]\fIhost\fR[:\fIport\fR]][/\fIpath/\fR]pkg-name ...
 .Sh DESCRIPTION
 The
 .Nm
 command is used to extract and upgrade packages that have been
 previously created with the
 .Xr pkg_create 1
 command.
 Packages are prepared collections of pre-built binaries, documentation,
 configurations, installation instructions and/or other files.
 .Nm
 @@ -149,51 +150,73 @@ as the directory in which to extract fil
 If a package has set its default directory, it will be overridden
 by this flag.
 Note that only the first
 .Cm @cwd
 directive will be replaced, since
 .Nm
 has no way of knowing which directory settings are relative and
 which are absolute.
 Only one directory transition is supported and the second one is expected to go
 into
 .Ar pkgdb .
 .It Fl R
 Do not record the installation of a package.
 This implies
 .Fl I .
 This means that you cannot deinstall it later, so only use this option if
 you know what you are doing!
 .It Fl s Ar verification-type
 Use a callout to an external program to verify the binary package
 being installed against an existing detached signature file.
 The signature file must reside in the same directory
 as the binary package.
 At the present time, the following verification types
 are defined: none, gpg and pgp5.
 The signature will be verified at install time, and the results
 will be displayed.
 If the signature type is anything other than none, the user will be asked if
 .Nm
 should proceed to install the binary package.
 The user must then take the decision whether to proceed or not, depending
 upon the amount of trust that is placed in the signatory of the binary
 package.
 Please note that, at the current time, it is not possible to use
 the verification feature when using
 .Nm
 to add a binary package via a URL - the package, and the related
 detached signature file, must be local
 for the verification to work.
 .It Fl t Ar template
 Use
 .Ar template
 as the input to
 .Xr mktemp 3
 when creating a
 .Dq staging area .
 By default, this is the string
 .Pa /var/tmp/instmp.XXXXXX ,
 but it may be necessary to override it in the situation where
 space in your
 .Pa /var/tmp
 directory is limited.
 Be sure to leave some number of
 .Sq X
 characters for
 .Xr mktemp 3
 to fill in with a unique ID.
 .Pp
 You can get a performance boost by setting the staging area
 .Ar template
 to reside on the same disk partition as target directories for package
 file installation; often this is
 .Pa /usr .
 .It Fl u
 If the package that's being installed is already installed, either
 in the same or a different version, an update is performed.
 If this is specified twice, then any dependant packages that are
 too old will also be updated to fulfill the dependency.
 See below for a more detailed description of the process.
 .It Fl V
 Print version number and exit.
 .It Fl v
 Turn on verbose output.
 .It Fl W Ar viewbase
 Set
 .Ar viewbase
 @@ -242,30 +265,31 @@ FTP_PASSIVE_MODE
 .Ef
 to some value in your environment.
 Otherwise, the more standard ACTIVE mode may be used.
 If
 .Nm
 consistently fails to fetch a package from a site known to work,
 it may be because you have a firewall that demands the usage of
 .Bf -emphasis
 passive mode
 .Ef
 ftp.
 .Sh TECHNICAL DETAILS
 .Nm
-extracts each package's meta data (including the
+extracts each package's
-.Dq packing list )
+.Dq packing list
-to memory and then runs through the following sequence to fully extract
+into a special staging directory in /var/tmp (or $PKG_TMPDIR if set)
-the contents of the package:
+and then runs through the following sequence to fully extract the contents
 of the package:
 .Bl -enum -offset indent
 .It
 A check is made to determine if the package or another version of it
 is already recorded as installed.
 If it is,
 installation is terminated if the
 .Fl u
 option is not given.
 .Pp
 If the
 .Fl u
 option is given, it's assumed the package should be replaced by the
 new version instead.

 @@ -1,32 +1,32 @@
-# $NetBSD: Makefile.in,v 1.15 2008/04/26 14:56:34 joerg Exp $
+# $NetBSD: Makefile.in,v 1.16 2008/04/26 17:40:01 joerg Exp $
 srcdir=		@srcdir@
 prefix=		@prefix@
 exec_prefix=	@exec_prefix@
 sbindir=	@sbindir@
 mandir=		@mandir@
 datarootdir=	@datarootdir@
 man1dir=	$(mandir)/man1
 cat1dir=	$(mandir)/cat1
 BOOTSTRAP=	@bootstrap@
 CC=		@CC@
 CCLD=		$(CC)
 .if empty(BOOTSTRAP)
-LIBS=		-linstall -larchive -lfetch -lbz2 -lz @LIBS@
+LIBS=		-linstall -larchive -lbz2 -lfetch -lz @LIBS@
 CPPFLAGS=	@CPPFLAGS@ -I. -I$(srcdir) -I../lib
 .else
 LIBS=		-linstall @LIBS@
 CPPFLAGS=	@CPPFLAGS@ -I. -I$(srcdir) -I../lib -DBOOTSTRAP
 .endif
 DEFS=		@DEFS@
 CFLAGS=		@CFLAGS@
 LDFLAGS=	@LDFLAGS@ -L../lib
 INSTALL=	@INSTALL@
 PROG=		pkg_info

 @@ -1,45 +1,45 @@
-# $NetBSD: Makefile.in,v 1.22 2008/04/26 14:56:34 joerg Exp $
+# $NetBSD: Makefile.in,v 1.23 2008/04/26 17:40:01 joerg Exp $
 srcdir=		@srcdir@
 pkgdbdir=	@pkgdbdir@
 mandir=		@mandir@
 datarootdir=	@datarootdir@
 cat5dir=	$(mandir)/cat5
 cat7dir=	$(mandir)/cat7
 man5dir=	$(mandir)/man5
 man7dir=	$(mandir)/man7
 tar=		@tar@
 ftp=		@ftp@
 BOOTSTRAP=	@bootstrap@
 RANLIB=		@RANLIB@
 AR=		@AR@
 CC=		@CC@
 CPPFLAGS=	@CPPFLAGS@ -I. -I$(srcdir)
-DEFS=		@DEFS@ -DDEF_LOG_DIR=\"$(pkgdbdir)\"
+DEFS=		@DEFS@ -DDEF_LOG_DIR=\"$(pkgdbdir)\" -DTAR_CMD=\"$(tar)\" -DFTP_CMD=\"$(ftp)\"
 CFLAGS=		@CFLAGS@
 INSTALL=	@INSTALL@
 LIB=	libinstall.a
 OBJS=	automatic.o conflicts.o decompress.o dewey.o fexec.o file.o \
-	global.o iterate.o lpkg.o opattern.o \
+	ftpio.o global.o iterate.o lpkg.o opattern.o \
-	path.o pkgdb.o plist.o \
+	path.o pen.o pexec.o pkgdb.o plist.o \
 	str.o var.o version.o vulnerabilities-file.o
 .if !empty(BOOTSTRAP)
 CPPFLAGS+=	-DBOOTSTRAP
 .else
 OBJS+=	pkg_io.o
 .endif
 all: $(LIB)
 .c.o:
 	$(CC) $(DEFS) $(CPPFLAGS) $(CFLAGS) -c $<

 @@ -1,14 +1,14 @@
-/* $NetBSD: add.h,v 1.11 2008/04/26 14:56:33 joerg Exp $ */
+/* $NetBSD: add.h,v 1.12 2008/04/26 17:40:01 joerg Exp $ */
 /* from FreeBSD Id: add.h,v 1.8 1997/02/22 16:09:15 peter 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
 @@ -25,20 +25,27 @@
 #ifndef _INST_ADD_H_INCLUDE
 #define _INST_ADD_H_INCLUDE
 extern char *OverrideMachine;
 extern char *Prefix;
 extern char *View;
 extern char *Viewbase;
 extern Boolean NoView;
 extern Boolean NoInstall;
 extern Boolean NoRecord;
 extern Boolean Force;
 extern Boolean Automatic;
 extern int Replace;
 extern char *Mode;
 extern char *Owner;
 extern char *Group;
 extern char *Directory;
 extern char *PkgName;
 extern char FirstPen[];
 int     make_hierarchy(char *);
 int     extract_plist(char *, package_t *);
 void    apply_perms(char *, char **, int);
 int     pkg_perform(lpkg_head_t *);
 #endif				/* _INST_ADD_H_INCLUDE */

 @@ -20,27 +20,26 @@
 #include "dewey.h"
 #include "lib.h"
 /**
  * Data structure to keep the intermediate result of the conflict
  * search. ''pkgname'' is the package in question. The first
  * installed package that conflicts is filled into
  * ''conflicting_pkgname''. The pattern that leads to the conflict is
  * also filled in to help the user in deciding what to do with the
  * conflict.
  */
 struct package_conflict {
 	const char *pkgname;
 	const char *skip_pkgname;
 	char **conflicting_pkgname;
 	char **conflicting_pattern;
 };
 static void *
 nonnull(void *p)
+{
 	if (p == NULL) {
 		err(EXIT_FAILURE, "NullPointerException");
 		/* NOTREACHED */
+	}
 	return p;
 @@ -61,30 +60,26 @@ fopen_contents(const char *pkgname, cons
 	return f;
+}
 static int
 check_package_conflict(const char *pkgname, void *v)
+{
 	struct package_conflict *conflict = v;
 	package_t pkg;
 	plist_t *p;
 	FILE *f;
 	int rv;
 	if (conflict->skip_pkgname != NULL &&
 	    strcmp(conflict->skip_pkgname, pkgname) == 0)
 		return 0;
 	rv = 0;
 	pkg.head = NULL;
 	pkg.tail = NULL;
 	f = fopen_contents(pkgname, "r");
 	read_plist(&pkg, f);
 	(void)fclose(f);
 	for (p = pkg.head; p; p = p->next) {
 		if (p->type != PLIST_PKGCFL)
 			continue;
 		if (pkg_match(p->name, conflict->pkgname) == 1) {
 @@ -97,34 +92,32 @@ check_package_conflict(const char *pkgna
 	free_plist(&pkg);
 	return rv;
+}
 /**
  * Checks if some installed package has a pkgcfl entry that matches
  * PkgName.  If such an entry is found, the package name is returned in
  * inst_pkgname, the matching pattern in inst_pattern, and the function
  * returns a non-zero value. Otherwise, zero is returned and the result
  * variables are set to NULL.
  */
 int
-some_installed_package_conflicts_with(const char *pkgname,
+some_installed_package_conflicts_with(const char *pkgname, char **inst_pkgname, char **inst_pattern)
     const char *skip_pkgname, char **inst_pkgname, char **inst_pattern)
+{
 	struct package_conflict cfl;
 	int rv;
 	cfl.pkgname = pkgname;
 	cfl.skip_pkgname = skip_pkgname;
 	*inst_pkgname = NULL;
 	*inst_pattern = NULL;
 	cfl.conflicting_pkgname = inst_pkgname;
 	cfl.conflicting_pattern = inst_pattern;
 	rv = iterate_pkg_db(check_package_conflict, &cfl);
 	if (rv == -1) {
 		errx(EXIT_FAILURE, "Couldn't read list of installed packages.");
 		/* NOTREACHED */
+	}
 	return *inst_pkgname != NULL;
+}
 #if 0

 @@ -1,27 +1,27 @@
-/*	$NetBSD: plist.c,v 1.18 2008/04/26 14:56:34 joerg Exp $	*/
+/*	$NetBSD: plist.c,v 1.19 2008/04/26 17:40:01 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.18 2008/04/26 14:56:34 joerg Exp $");
+__RCSID("$NetBSD: plist.c,v 1.19 2008/04/26 17:40:01 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
 @@ -529,27 +529,26 @@ delete_package(Boolean ign_err, Boolean
 			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", 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);

 @@ -1,27 +1,27 @@
-/*	$NetBSD: str.c,v 1.23 2008/04/26 14:56:34 joerg Exp $	*/
+/*	$NetBSD: str.c,v 1.24 2008/04/26 17:40:01 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 = "Id: str.c,v 1.5 1997/10/08 07:48:21 charnier Exp";
 #else
-__RCSID("$NetBSD: str.c,v 1.23 2008/04/26 14:56:34 joerg Exp $");
+__RCSID("$NetBSD: str.c,v 1.24 2008/04/26 17:40:01 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
 @@ -96,13 +96,54 @@ dirname_of(const char *path)
 	buf[cc] = 0;
 	return buf;
+}
 /*
  * Does the pkgname contain any of the special chars ("{[]?*<>")?
  * If so, return 1, else 0
  */
 int
 ispkgpattern(const char *pkg)
+{
 	return strpbrk(pkg, "<>[]?*{") != NULL;
+}
 /*
  * Strip off any .tgz, .tbz or .t[bg]z suffix from fname,
  * and copy into buffer "buf", the suffix is stored in "sfx"
  * if "sfx" is not NULL. If no suffix is found, "sfx" is set
  * to an empty string.
  */
 void
 strip_txz(char *buf, char *sfx, const char *fname)
+{
 	static const char *const suffixes[] = {
 		".tgz", ".tbz", ".t[bg]z", 0};
 	const char *const *suffixp;
 	size_t len;
 	len = strlen(fname);
 	assert(len < PKG_PATTERN_MAX);
 	if (sfx)
 		sfx[0] = '\0';
 	for (suffixp = suffixes; *suffixp; suffixp++) {
 		size_t suffixlen = strlen(*suffixp);
 		if (memcmp(&fname[len - suffixlen], *suffixp, suffixlen))
 			continue;
 		/* matched! */
 		memcpy(buf, fname, len - suffixlen);
 		buf[len - suffixlen] = 0;
 		if (sfx) {
 			if (suffixlen >= PKG_SUFFIX_MAX)
 				errx(EXIT_FAILURE, "too long suffix '%s'", fname);
 			memcpy(sfx, *suffixp, suffixlen+1);
 			return;
+		}
+	}
 	/* not found */
 	memcpy(buf, fname, len+1);
+}