 @@ -1,1528 +1,1528 @@
-/*	$NetBSD: util.c,v 1.50 2020/10/25 08:50:32 martin Exp $	*/
+/*	$NetBSD: util.c,v 1.51 2020/10/26 20:18:33 martin Exp $	*/
 /*
  * Copyright 1997 Piermont Information Systems Inc.
  * All rights reserved.
+ *
  * Written by Philip A. Nelson for Piermont Information Systems Inc.
+ *
  * 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. The name of Piermont Information Systems Inc. may not be used to endorse
  *    or promote products derived from this software without specific prior
  *    written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``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 PIERMONT INFORMATION SYSTEMS INC. 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.
+ *
  */
 /* util.c -- routines that don't really fit anywhere else... */
 #include <assert.h>
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/mount.h>
 #include <sys/dkio.h>
 #include <sys/ioctl.h>
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/sysctl.h>
 #include <sys/stat.h>
 #include <sys/statvfs.h>
 #include <isofs/cd9660/iso.h>
 #include <curses.h>
 #include <err.h>
 #include <errno.h>
 #include <dirent.h>
 #include <util.h>
 #include "defs.h"
 #include "md.h"
 #include "defsizes.h"
 #include "msg_defs.h"
 #include "menu_defs.h"
 #ifdef MD_MAY_SWAP_TO
 #include <sys/drvctlio.h>
 #endif
 #define MAX_CD_DEVS	256	/* how many cd drives do we expect to attach */
 #define ISO_BLKSIZE	ISO_DEFAULT_BLOCK_SIZE
 static const char *msg_yes, *msg_no, *msg_all, *msg_some, *msg_none;
 static int select_menu_width;
 static uint8_t set_status[SET_GROUP_END];
 #define SET_VALID	0x01
 #define SET_SELECTED	0x02
 #define SET_SKIPPED	0x04
 #define SET_INSTALLED	0x08
 #define	SET_NO_EXTRACT	0x10
 struct  tarstats {
 	int nselected;
 	int nfound;
 	int nnotfound;
 	int nerror;
 	int nsuccess;
 	int nskipped;
 } tarstats;
 distinfo dist_list[] = {
 #ifdef SET_KERNEL_1_NAME
 	{SET_KERNEL_1_NAME,	SET_KERNEL_1,		false, MSG_set_kernel_1, NULL},
 #endif
 #ifdef SET_KERNEL_2_NAME
 	{SET_KERNEL_2_NAME,	SET_KERNEL_2,		false, MSG_set_kernel_2, NULL},
 #endif
 #ifdef SET_KERNEL_3_NAME
 	{SET_KERNEL_3_NAME,	SET_KERNEL_3,		false, MSG_set_kernel_3, NULL},
 #endif
 #ifdef SET_KERNEL_4_NAME
 	{SET_KERNEL_4_NAME,	SET_KERNEL_4,		false, MSG_set_kernel_4, NULL},
 #endif
 #ifdef SET_KERNEL_5_NAME
 	{SET_KERNEL_5_NAME,	SET_KERNEL_5,		false, MSG_set_kernel_5, NULL},
 #endif
 #ifdef SET_KERNEL_6_NAME
 	{SET_KERNEL_6_NAME,	SET_KERNEL_6,		false, MSG_set_kernel_6, NULL},
 #endif
 #ifdef SET_KERNEL_7_NAME
 	{SET_KERNEL_7_NAME,	SET_KERNEL_7,		false, MSG_set_kernel_7, NULL},
 #endif
 #ifdef SET_KERNEL_8_NAME
 	{SET_KERNEL_8_NAME,	SET_KERNEL_8,		false, MSG_set_kernel_8, NULL},
 #endif
 #ifdef SET_KERNEL_9_NAME
 	{SET_KERNEL_9_NAME,	SET_KERNEL_9,		false, MSG_set_kernel_9, NULL},
 #endif
 	{"modules",		SET_MODULES,		false, MSG_set_modules, NULL},
 	{"base",		SET_BASE,		false, MSG_set_base, NULL},
 #ifdef HAVE_DTB
 	{"dtb",			SET_DTB,		false, MSG_set_dtb, NULL},
 #endif
 	{"etc",			SET_ETC,		false, MSG_set_system, NULL},
 	{"comp",		SET_COMPILER,		false, MSG_set_compiler, NULL},
 	{"games",		SET_GAMES,		false, MSG_set_games, NULL},
 	{"man",			SET_MAN_PAGES,		false, MSG_set_man_pages, NULL},
 	{"misc",		SET_MISC,		false, MSG_set_misc, NULL},
 	{"rescue",		SET_RESCUE,		false, MSG_set_rescue, NULL},
 	{"tests",		SET_TESTS,		false, MSG_set_tests, NULL},
 	{"text",		SET_TEXT_TOOLS,		false, MSG_set_text_tools, NULL},
 	{NULL,			SET_GROUP,		false, MSG_set_X11, NULL},
 	{"xbase",		SET_X11_BASE,		false, MSG_set_X11_base, NULL},
 	{"xcomp",		SET_X11_PROG,		false, MSG_set_X11_prog, NULL},
 	{"xetc",		SET_X11_ETC,		false, MSG_set_X11_etc, NULL},
 	{"xfont",		SET_X11_FONTS,		false, MSG_set_X11_fonts, NULL},
 	{"xserver",		SET_X11_SERVERS,	false, MSG_set_X11_servers, NULL},
 	{NULL,			SET_GROUP_END,		false, NULL, NULL},
 #ifdef SET_MD_1_NAME
 	{SET_MD_1_NAME,		SET_MD_1,		false, MSG_set_md_1, NULL},
 #endif
 #ifdef SET_MD_2_NAME
 	{SET_MD_2_NAME,		SET_MD_2,		false, MSG_set_md_2, NULL},
 #endif
 #ifdef SET_MD_3_NAME
 	{SET_MD_3_NAME,		SET_MD_3,		false, MSG_set_md_3, NULL},
 #endif
 #ifdef SET_MD_4_NAME
 	{SET_MD_4_NAME,		SET_MD_4,		false, MSG_set_md_4, NULL},
 #endif
 	{NULL,			SET_GROUP,		true, MSG_set_source, NULL},
 	{"syssrc",		SET_SYSSRC,		true, MSG_set_syssrc, NULL},
 	{"src",			SET_SRC,		true, MSG_set_src, NULL},
 	{"sharesrc",		SET_SHARESRC,		true, MSG_set_sharesrc, NULL},
 	{"gnusrc",		SET_GNUSRC,		true, MSG_set_gnusrc, NULL},
 	{"xsrc",		SET_XSRC,		true, MSG_set_xsrc, NULL},
 	{"debug",		SET_DEBUG,		false, MSG_set_debug, NULL},
 	{"xdebug",		SET_X11_DEBUG,		false, MSG_set_xdebug, NULL},
 	{NULL,			SET_GROUP_END,		false, NULL, NULL},
 	{NULL,			SET_LAST,		false, NULL, NULL},
 };
 #define MAX_CD_INFOS	16	/* how many media can be found? */
 struct cd_info {
 	char device_name[16];
 	char menu[100];
 };
 static struct cd_info cds[MAX_CD_INFOS];
 /* flags whether to offer the respective options (depending on helper
    programs available on install media */
 int have_raid, have_vnd, have_cgd, have_lvm, have_gpt, have_dk;
 /*
  * local prototypes
  */
 static int check_for(unsigned int mode, const char *pathname);
 static int get_iso9660_volname(int dev, int sess, char *volname,
 		size_t volnamelen);
 static int get_available_cds(void);
 static int binary_available(const char *prog);
 void
 init_set_status(int flags)
+{
 	static const uint8_t sets_valid[] = {MD_SETS_VALID};
 	static const uint8_t sets_selected_full[] = {MD_SETS_SELECTED};
 	static const uint8_t sets_selected_minimal[] = {MD_SETS_SELECTED_MINIMAL};
 	static const uint8_t sets_selected_nox[] = {MD_SETS_SELECTED_NOX};
 	static const uint8_t *sets_selected;
 	unsigned int nelem_selected;
 	unsigned int i, len;
 	const char *longest;
 	if (flags & SFLAG_MINIMAL) {
 		sets_selected = sets_selected_minimal;
 		nelem_selected = __arraycount(sets_selected_minimal);
 	} else if (flags & SFLAG_NOX) {
 		sets_selected = sets_selected_nox;
 		nelem_selected = __arraycount(sets_selected_nox);
 	} else {
 		sets_selected = sets_selected_full;
 		nelem_selected = __arraycount(sets_selected_full);
+	}
 	for (i = 0; i < __arraycount(sets_valid); i++)
 		set_status[sets_valid[i]] = SET_VALID;
 	for (i = 0; i < nelem_selected; i++)
 		set_status[sets_selected[i]] |= SET_SELECTED;
 	set_status[SET_GROUP] = SET_VALID;
 	/* Lookup some strings we need lots of times */
 	msg_yes = msg_string(MSG_Yes);
 	msg_no = msg_string(MSG_No);
 	msg_all = msg_string(MSG_All);
 	msg_some = msg_string(MSG_Some);
 	msg_none = msg_string(MSG_None);
 	/* Find longest and use it to determine width of selection menu */
 	len = strlen(msg_no); longest = msg_no;
 	i = strlen(msg_yes); if (i > len) {len = i; longest = msg_yes; }
 	i = strlen(msg_all); if (i > len) {len = i; longest = msg_all; }
 	i = strlen(msg_some); if (i > len) {len = i; longest = msg_some; }
 	i = strlen(msg_none); if (i > len) {len = i; longest = msg_none; }
 	select_menu_width = snprintf(NULL, 0, "%-30s %s", "", longest);
 	/* Give the md code a chance to choose the right kernel, etc. */
 	md_init_set_status(flags);
+}
 int
 dir_exists_p(const char *path)
+{
 	return file_mode_match(path, S_IFDIR);
+}
 int
 file_exists_p(const char *path)
+{
 	return file_mode_match(path, S_IFREG);
+}
 int
 file_mode_match(const char *path, unsigned int mode)
+{
 	struct stat st;
 	return (stat(path, &st) == 0 && (st.st_mode & S_IFMT) == mode);
+}
 /* return ram size in MB */
 uint64_t
 get_ramsize(void)
+{
 	uint64_t ramsize;
 	size_t len = sizeof ramsize;
 	int mib[2] = {CTL_HW, HW_PHYSMEM64};
 	sysctl(mib, 2, &ramsize, &len, NULL, 0);
 	/* Find out how many Megs ... round up. */
 	return (ramsize + MEG - 1) / MEG;
+}
 void
 run_makedev(void)
+{
 	char *owd;
 	msg_display_add("\n\n");
 	msg_display_add(MSG_makedev);
 	owd = getcwd(NULL, 0);
 	/* make /dev, in case the user  didn't extract it. */
 	make_target_dir("/dev");
 	target_chdir_or_die("/dev");
 	run_program(0, "/bin/sh MAKEDEV all");
 	chdir(owd);
 	free(owd);
+}
 /*
  * Performs in-place replacement of a set of patterns in a file that lives
  * inside the installed system.  The patterns must be separated by a semicolon.
  * For example:
+ *
  * replace("/etc/some-file.conf", "s/prop1=NO/prop1=YES/;s/foo/bar/");
  */
 void
 replace(const char *path, const char *patterns, ...)
+{
 	char *spatterns;
 	va_list ap;
 	va_start(ap, patterns);
 	vasprintf(&spatterns, patterns, ap);
 	va_end(ap);
 	if (spatterns == NULL)
 		err(1, "vasprintf(&spatterns, \"%s\", ...)", patterns);
 	run_program(RUN_CHROOT, "sed -an -e '%s;H;$!d;g;w %s' %s", spatterns,
 	    path, path);
 	free(spatterns);
+}
 static int
 floppy_fetch(const char *set_name)
+{
 	char post[4];
 	msg errmsg;
 	int menu;
 	int status;
 	const char *write_mode = ">";
 	strcpy(post, "aa");
 	errmsg = "";
 	menu = MENU_fdok;
 	for (;;) {
 		umount_mnt2();
 		msg_display(errmsg);
 		msg_fmt_display_add(MSG_fdmount, "%s%s", set_name, post);
 		process_menu(menu, &status);
 		if (status != SET_CONTINUE)
 			return status;
 		menu = MENU_fdremount;
 		errmsg = MSG_fdremount;
 		if (run_program(0, "/sbin/mount -r -t %s %s /mnt2",
 							fd_type, fd_dev))
 			continue;
 		mnt2_mounted = 1;
 		errmsg = MSG_fdnotfound;
 		/* Display this because it might take a while.... */
 		if (run_program(RUN_DISPLAY,
 			    "sh -c '/bin/cat /mnt2/%s.%s %s %s/%s/%s%s'",
 			    set_name, post, write_mode,
 			    target_prefix(), xfer_dir, set_name,
 			    set_postfix(set_name)))
 			/* XXX: a read error will give a corrupt file! */
 			continue;
 		/* We got that file, advance to next fragment */
 		if (post[1] < 'z')
 			post[1]++;
 		else
 			post[1] = 'a', post[0]++;
 		write_mode = ">>";
 		errmsg = "";
 		menu = MENU_fdok;
+	}
+}
 /*
  * Load files from floppy.  Requires a /mnt2 directory for mounting them.
  */
 int
 get_via_floppy(void)
+{
 	int rv = -1;
 	process_menu(MENU_floppysource, &rv);
 	if (rv == SET_RETRY)
 		return SET_RETRY;
 	fetch_fn = floppy_fetch;
 	/* Set ext_dir for absolute path. */
 	snprintf(ext_dir_bin, sizeof ext_dir_bin, "%s/%s", target_prefix(), xfer_dir);
 	snprintf(ext_dir_src, sizeof ext_dir_src, "%s/%s", target_prefix(), xfer_dir);
 	return SET_OK;
+}
 /*
  * Get the volume name of a ISO9660 file system
  */
 static int
 get_iso9660_volname(int dev, int sess, char *volname, size_t volnamelen)
+{
 	int blkno, error, last;
 	char buf[ISO_BLKSIZE];
 	struct iso_volume_descriptor *vd = NULL;
 	struct iso_primary_descriptor *pd = NULL;
 	for (blkno = sess+16; blkno < sess+16+100; blkno++) {
 		error = pread(dev, buf, ISO_BLKSIZE, blkno*ISO_BLKSIZE);
 		if (error == -1)
 			return -1;
 		vd = (struct iso_volume_descriptor *)&buf;
 		if (memcmp(vd->id, ISO_STANDARD_ID, sizeof(vd->id)) != 0)
 			return -1;
 		if (isonum_711((const unsigned char *)&vd->type)
 		     == ISO_VD_PRIMARY) {
 			pd = (struct iso_primary_descriptor*)buf;
 			strncpy(volname, pd->volume_id, volnamelen - 1);
 			volname[volnamelen - 1] = '\0';
 			last = volnamelen - 1;
 			while (last >= 0
 			    && (volname[last] == ' ' || volname[last] == 0))
 				last--;
 			volname[last+1] = 0;
 			return 0;
+		}
+	}
 	return -1;
+}
 /*
  * Local state while iterating CDs and collecting volumes
  */
 struct get_available_cds_state {
 	size_t num_mounted;
 	struct statvfs *mounted;
 	struct cd_info *info;
 	size_t count;
 };
 /*
  * Callback function: if this is a CD, enumerate all volumes on it
  */
 static bool
 get_available_cds_helper(void *arg, const char *device)
+{
 	struct get_available_cds_state *state = arg;
 	char dname[16], tname[16], volname[80], *t;
 	struct disklabel label;
 	int part, dev, error, sess, ready, tlen;
 	if (!is_cdrom_device(device, false))
 		return true;
 	sprintf(dname, "/dev/r%s%c", device, 'a'+RAW_PART);
 	tlen = sprintf(tname, "/dev/%s", device);
 	/* check if this is mounted already */
 	for (size_t i = 0; i < state->num_mounted; i++) {
 		if (strncmp(state->mounted[i].f_mntfromname, tname, tlen)
 		    == 0) {
 			t = state->mounted[i].f_mntfromname + tlen;
 			if (t[0] >= 'a' && t[0] <= 'z' && t[1] == 0)
 				return true;
+		}
+	}
 	dev = open(dname, O_RDONLY, 0);
 	if (dev == -1)
 		return true;
 	ready = 0;
 	error = ioctl(dev, DIOCTUR, &ready);
 	if (error != 0 || ready == 0) {
 		close(dev);
 		return true;
+	}
 	error = ioctl(dev, DIOCGDINFO, &label);
 	close(dev);
 	if (error != 0)
 		return true;
 	for (part = 0; part < label.d_npartitions; part++) {
 		if (label.d_partitions[part].p_fstype == FS_UNUSED
 		    || label.d_partitions[part].p_size == 0)
 			continue;
 		if (label.d_partitions[part].p_fstype == FS_ISO9660) {
 			sess = label.d_partitions[part].p_cdsession;
 			sprintf(dname, "/dev/r%s%c", device, 'a'+part);
 			dev = open(dname, O_RDONLY, 0);
 			if (dev == -1)
 				continue;
 			error = get_iso9660_volname(dev, sess, volname,
 			    sizeof volname);
 			close(dev);
 			if (error)
 				continue;
 			sprintf(state->info->device_name,
 			    "%s%c", device, 'a'+part);
 			sprintf(state->info->menu, "%s (%s)",
 			    state->info->device_name, volname);
 		} else {
 			/*
 			 * All install CDs use partition
 			 * a for the sets.
 			 */
 			if (part > 0)
 				continue;
 			sprintf(state->info->device_name,
 			    "%s%c", device, 'a'+part);
 			strcpy(state->info->menu, state->info->device_name);
+		}
 		state->info++;
 		if (++state->count >= MAX_CD_INFOS)
 			return false;
+	}
 	return true;
+}
 /*
  * Get a list of all available CD media (not drives!), return
  * the number of entries collected.
  */
 static int
 get_available_cds(void)
+{
 	struct get_available_cds_state data;
-	int n, __diagused e;
+	int n, m;
 	memset(&data, 0, sizeof data);
 	data.info = cds;
 	n = getvfsstat(NULL, 0, ST_NOWAIT);
 	if (n > 0) {
 		data.mounted = calloc(n, sizeof(*data.mounted));
-		e = getvfsstat(data.mounted, n*sizeof(*data.mounted),
+		m = getvfsstat(data.mounted, n*sizeof(*data.mounted),
 		    ST_NOWAIT);
-		assert(e == n);
+		assert(m >= 0 && m <= n);
-		data.num_mounted = n;
+		data.num_mounted = m;
+	}
 	enumerate_disks(&data, get_available_cds_helper);
 	free(data.mounted);
 	return data.count;
+}
 static int
 cd_has_sets(void)
+{
 	/* Mount it */
 	if (run_program(RUN_SILENT, "/sbin/mount -rt cd9660 /dev/%s /mnt2",
 	    cdrom_dev) != 0)
 		return 0;
 	mnt2_mounted = 1;
 	snprintf(ext_dir_bin, sizeof ext_dir_bin, "%s/%s", "/mnt2", set_dir_bin);
 	snprintf(ext_dir_src, sizeof ext_dir_src, "%s/%s", "/mnt2", set_dir_src);
 	return dir_exists_p(ext_dir_bin);
+}
 /*
  * Check whether we can remove the boot media.
  * If it is not a local filesystem, return -1.
  * If we can not decide for sure (can not tell MD content from plain ffs
  * on hard disk, for example), return 0.
  * If it is a CD/DVD, return 1.
  */
 int
 boot_media_still_needed(void)
+{
 	struct statvfs sb;
 	if (statvfs("/", &sb) == 0) {
 		if (!(sb.f_flag & ST_LOCAL))
 			return -1;
 		if (strcmp(sb.f_fstypename, MOUNT_CD9660) == 0
 			   || strcmp(sb.f_fstypename, MOUNT_UDF) == 0)
 			return 1;
+	}
 	return 0;
+}
 bool
 root_is_read_only(void)
+{
 	struct statvfs sb;
 	if (statvfs("/", &sb) == 0)
 		return sb.f_flag & ST_RDONLY;
 	return false;
+}
 /*
  * Get from a CDROM distribution.
  * Also used on "installation using bootable install media"
  * as the default option in the "distmedium" menu.
  */
 int
 get_via_cdrom(void)
+{
 	menu_ent cd_menu[MAX_CD_INFOS];
 	struct stat sb;
 	int rv, num_cds, menu_cd, i, selected_cd = 0;
 	bool silent = false;
 	int mib[2];
 	char rootdev[SSTRSIZE] = "";
 	size_t varlen;
 	/* If root is not md(4) and we have set dir, skip this step. */
 	mib[0] = CTL_KERN;
 	mib[1] = KERN_ROOT_DEVICE;
 	varlen = sizeof(rootdev);
 	(void)sysctl(mib, 2, rootdev, &varlen, NULL, 0);
 	if (stat(set_dir_bin, &sb) == 0 && S_ISDIR(sb.st_mode) &&
 	    strncmp("md", rootdev, 2) != 0) {
 	    	strlcpy(ext_dir_bin, set_dir_bin, sizeof ext_dir_bin);
 	    	strlcpy(ext_dir_src, set_dir_src, sizeof ext_dir_src);
 		return SET_OK;
+	}
 	memset(cd_menu, 0, sizeof(cd_menu));
 	num_cds = get_available_cds();
 	if (num_cds <= 0) {
 		hit_enter_to_continue(MSG_No_cd_found, NULL);
 		return SET_RETRY;
 	} else if (num_cds == 1) {
 		/* single CD found, check for sets on it */
 		strcpy(cdrom_dev, cds[0].device_name);
 		if (cd_has_sets())
 			return SET_OK;
 	} else {
 		for (i = 0; i< num_cds; i++) {
 			cd_menu[i].opt_name = cds[i].menu;
 			cd_menu[i].opt_flags = OPT_EXIT;
 			cd_menu[i].opt_action = set_menu_select;
+		}
 		/* create a menu offering available choices */
 		menu_cd = new_menu(MSG_Available_cds,
 			cd_menu, num_cds, -1, 4, 0, 0,
 			MC_SCROLL | MC_NOEXITOPT,
 			NULL, NULL, NULL, NULL, NULL);
 		if (menu_cd == -1)
 			return SET_RETRY;
 		msg_display(MSG_ask_cd);
 		process_menu(menu_cd, &selected_cd);
 		free_menu(menu_cd);
 		strcpy(cdrom_dev, cds[selected_cd].device_name);
 		if (cd_has_sets())
 			return SET_OK;
+	}
 	if (silent)
 		msg_display("");
 	else {
 		umount_mnt2();
 		hit_enter_to_continue(MSG_cd_path_not_found, NULL);
+	}
 	/* ask for paths on the CD */
 	rv = -1;
 	process_menu(MENU_cdromsource, &rv);
 	if (rv == SET_RETRY)
 		return SET_RETRY;
 	if (cd_has_sets())
 		return SET_OK;
 	return SET_RETRY;
+}
 /*
  * Get from a pathname inside an unmounted local filesystem
  * (e.g., where sets were preloaded onto a local DOS partition)
  */
 int
 get_via_localfs(void)
+{
 	int rv = -1;
 	/* Get device, filesystem, and filepath */
 	process_menu (MENU_localfssource, &rv);
 	if (rv == SET_RETRY)
 		return SET_RETRY;
 	/* Mount it */
 	if (run_program(0, "/sbin/mount -rt %s /dev/%s /mnt2",
 	    localfs_fs, localfs_dev))
 		return SET_RETRY;
 	mnt2_mounted = 1;
 	snprintf(ext_dir_bin, sizeof ext_dir_bin, "%s/%s/%s",
 		"/mnt2", localfs_dir, set_dir_bin);
 	snprintf(ext_dir_src, sizeof ext_dir_src, "%s/%s/%s",
 		"/mnt2", localfs_dir, set_dir_src);
 	return SET_OK;
+}
 /*
  * Get from an already-mounted pathname.
  */
 int
 get_via_localdir(void)
+{
 	int rv = -1;
 	/* Get filepath */
 	process_menu(MENU_localdirsource, &rv);
 	if (rv == SET_RETRY)
 		return SET_RETRY;
 	/*
 	 * We have to have an absolute path ('cos pax runs in a
 	 * different directory), make it so.
 	 */
 	snprintf(ext_dir_bin, sizeof ext_dir_bin, "/%s/%s", localfs_dir, set_dir_bin);
 	snprintf(ext_dir_src, sizeof ext_dir_src, "/%s/%s", localfs_dir, set_dir_src);
 	return SET_OK;
+}
 /*
  * Support for custom distribution fetches / unpacks.
  */
 unsigned int
 set_X11_selected(void)
+{
 	int i;
 	for (i = SET_X11_FIRST; ++i < SET_X11_LAST;)
 		if (set_status[i] & SET_SELECTED)
 			return 1;
 	return 0;
+}
 unsigned int
 get_kernel_set(void)
+{
 	int i;
 	for (i = SET_KERNEL_FIRST; ++i < SET_KERNEL_LAST;)
 		if (set_status[i] & SET_SELECTED)
 			return i;
 	return SET_NONE;
+}
 void
 set_kernel_set(unsigned int kernel_set)
+{
 	int i;
 	/* only one kernel set is allowed */
 	for (i = SET_KERNEL_FIRST; ++i < SET_KERNEL_LAST;)
 		set_status[i] &= ~SET_SELECTED;
 	set_status[kernel_set] |= SET_SELECTED;
+}
 void
 set_noextract_set(unsigned int set)
+{
 	set_status[set] |= SET_NO_EXTRACT;
+}
 static int
 set_toggle(menudesc *menu, void *arg)
+{
 	distinfo **distp = arg;
 	int set = distp[menu->cursel]->set;
 	if (set > SET_KERNEL_FIRST && set < SET_KERNEL_LAST &&
 	    !(set_status[set] & SET_SELECTED))
 		set_kernel_set(set);
 	else
 		set_status[set] ^= SET_SELECTED;
 	return 0;
+}
 static int
 set_all_none(menudesc *menu, void *arg, int set, int clr)
+{
 	distinfo **distp = arg;
 	distinfo *dist = *distp;
 	int nested;
 	for (nested = 0; dist->set != SET_GROUP_END || nested--; dist++) {
 		if (dist->set == SET_GROUP) {
 			nested++;
 			continue;
+		}
 		set_status[dist->set] = (set_status[dist->set] & ~clr) | set;
+	}
 	return 0;
+}
 static int
 set_all(menudesc *menu, void *arg)
+{
 	return set_all_none(menu, arg, SET_SELECTED, 0);
+}
 static int
 set_none(menudesc *menu, void *arg)
+{
 	return set_all_none(menu, arg, 0, SET_SELECTED);
+}
 static void
 set_label(menudesc *menu, int opt, void *arg)
+{
 	distinfo **distp = arg;
 	distinfo *dist = distp[opt];
 	const char *selected;
 	const char *desc;
 	int nested;
 	desc = dist->desc;
 	if (dist->set != SET_GROUP)
 		selected = set_status[dist->set] & SET_SELECTED ? msg_yes : msg_no;
 	else {
 		/* sub menu - display None/Some/All */
 		nested = 0;
 		selected = "unknown";
 		while ((++dist)->set != SET_GROUP_END || nested--) {
 			if (dist->set == SET_GROUP) {
 				nested++;
 				continue;
+			}
 			if (!(set_status[dist->set] & SET_VALID))
 				continue;
 			if (set_status[dist->set] & SET_SELECTED) {
 				if (selected == msg_none) {
 					selected = msg_some;
 					break;
+				}
 				selected = msg_all;
 			} else {
 				if (selected == msg_all) {
 					selected = msg_some;
 					break;
+				}
 				selected = msg_none;
+			}
+		}
+	}
 	wprintw(menu->mw, "%-30s %s", msg_string(desc), selected);
+}
 static int set_sublist(menudesc *menu, void *arg);
 static int
 initialise_set_menu(distinfo *dist, menu_ent *me, distinfo **de, int all_none)
+{
 	int set;
 	int sets;
 	int nested;
 	for (sets = 0; ; dist++) {
 		set = dist->set;
 		if (set == SET_LAST || set == SET_GROUP_END)
 			break;
 		if (!(set_status[set] & SET_VALID))
 			continue;
 		*de = dist;
 		memset(me, 0, sizeof(*me));
 		if (set != SET_GROUP)
 			me->opt_action = set_toggle;
 		else {
 			/* Collapse sublist */
 			nested = 0;
 			while ((++dist)->set != SET_GROUP_END || nested--) {
 				if (dist->set == SET_GROUP)
 					nested++;
+			}
 			me->opt_action = set_sublist;
+		}
 		sets++;
 		de++;
 		me++;
+	}
 	if (all_none) {
 		me->opt_name = MSG_select_all;
 		me->opt_action = set_all;
 		me++;
 		me->opt_name = MSG_select_none;
 		me->opt_action = set_none;
 		sets += 2;
+	}
 	return sets;
+}
 static int
 set_sublist(menudesc *menu, void *arg)
+{
 	distinfo *de[SET_LAST];
 	menu_ent me[SET_LAST];
 	distinfo **dist = arg;
 	int menu_no;
 	int sets;
 	memset(me, 0, sizeof(me));
 	sets = initialise_set_menu(dist[menu->cursel] + 1, me, de, 1);
 	menu_no = new_menu(NULL, me, sets, 20, 10, 0, select_menu_width,
 		MC_SUBMENU | MC_SCROLL | MC_DFLTEXIT,
 		NULL, set_label, NULL, NULL,
 		MSG_install_selected_sets);
 	process_menu(menu_no, de);
 	free_menu(menu_no);
 	return 0;
+}
 void
 customise_sets(void)
+{
 	distinfo *de[SET_LAST];
 	menu_ent me[SET_LAST];
 	int sets;
 	int menu_no;
 	msg_display(MSG_cur_distsets);
 	msg_table_add(MSG_cur_distsets_header);
 	memset(me, 0, sizeof(me));
 	sets = initialise_set_menu(dist_list, me, de, 0);
 	menu_no = new_menu(NULL, me, sets, 0, 5, 0, select_menu_width,
 		MC_SCROLL | MC_NOBOX | MC_DFLTEXIT | MC_NOCLEAR,
 		NULL, set_label, NULL, NULL,
 		MSG_install_selected_sets);
 	process_menu(menu_no, de);
 	free_menu(menu_no);
+}
 /*
  * Extract_file **REQUIRES** an absolute path in ext_dir.  Any code
  * that sets up xfer_dir for use by extract_file needs to put in the
  * full path name to the directory.
  */
 int
 extract_file(distinfo *dist, int update)
+{
 	const char *dest_dir = NULL;
 	if (update && (dist->set == SET_ETC || dist->set == SET_X11_ETC)) {
 		dest_dir = "/.sysinst";
 		make_target_dir(dest_dir);
 	} else if (dist->set == SET_PKGSRC)
 		dest_dir = "/usr";
 	else
 		dest_dir = "/";
 	return extract_file_to(dist, update, dest_dir, NULL, true);
+}
 int
 extract_file_to(distinfo *dist, int update, const char *dest_dir,
     const char *extr_pattern, bool do_stats)
+{
 	char path[STRSIZE];
 	char *owd;
 	int   rval;
 	/* If we might need to tidy up, ensure directory exists */
 	if (fetch_fn != NULL)
 		make_target_dir(xfer_dir);
 	(void)snprintf(path, sizeof path, "%s/%s%s",
 	    ext_dir_for_set(dist->name), dist->name, set_postfix(dist->name));
 	owd = getcwd(NULL, 0);
 	/* Do we need to fetch the file now? */
 	if (fetch_fn != NULL) {
 		rval = fetch_fn(dist->name);
 		if (rval != SET_OK)
 			return rval;
+	}
 	/* check tarfile exists */
 	if (!file_exists_p(path)) {
 #ifdef SUPPORT_8_3_SOURCE_FILESYSTEM
 		/*
 		 * Update path to use dist->name truncated to the first eight
 		 * characters and check again
 		 */
 		(void)snprintf(path, sizeof path,
 		    "%s/%.8s%.4s", /* 4 as includes '.' */
 		    ext_dir_for_set(dist->name), dist->name,
 		    set_postfix(dist->name));
 		if (!file_exists_p(path)) {
 #endif /* SUPPORT_8_3_SOURCE_FILESYSTEM */
 			if (do_stats)
 				tarstats.nnotfound++;
 			char *err = str_arg_subst(msg_string(MSG_notarfile),
 , &dist->name);
 			hit_enter_to_continue(err, NULL);
 			free(err);
 			free(owd);
 			return SET_RETRY;
+		}
 #ifdef SUPPORT_8_3_SOURCE_FILESYSTEM
+	}
 #endif /* SUPPORT_8_3_SOURCE_FILESYSTEM */
 	if (do_stats)
 		tarstats.nfound++;
 	/* cd to the target root. */
 	target_chdir_or_die(dest_dir);
 	/*
 	 * /usr/X11R7/lib/X11/xkb/symbols/pc was a directory in 5.0
 	 * but is a file in 5.1 and beyond, so on upgrades we need to
 	 * delete it before extracting the xbase set.
 	 */
 	if (update && dist->set == SET_X11_BASE)
 		run_program(0, "rm -rf usr/X11R7/lib/X11/xkb/symbols/pc");
 	/* now extract set files into "./". */
 	if (extr_pattern != NULL) {
 		rval = run_program(RUN_DISPLAY | RUN_PROGRESS,
 				"progress -zf %s tar --chroot "
 				TAR_EXTRACT_FLAGS " - '%s'",
 				path, extr_pattern);
 	} else {
 		rval = run_program(RUN_DISPLAY | RUN_PROGRESS,
 				"progress -zf %s tar --chroot "
 				TAR_EXTRACT_FLAGS " -", path);
+	}
 	chdir(owd);
 	free(owd);
 	/* Check rval for errors and give warning. */
 	if (rval != 0) {
 		if (do_stats)
 			tarstats.nerror++;
 		msg_fmt_display(MSG_tarerror, "%s", path);
 		hit_enter_to_continue(NULL, NULL);
 		return SET_RETRY;
+	}
 	if (fetch_fn != NULL && clean_xfer_dir) {
 		run_program(0, "rm %s", path);
 		/* Plausibly we should unlink an empty xfer_dir as well */
+	}
 	set_status[dist->set] |= SET_INSTALLED;
 	if (do_stats)
 		tarstats.nsuccess++;
 	return SET_OK;
+}
 static void
 skip_set(distinfo *dist, int skip_type)
+{
 	int nested;
 	int set;
 	nested = 0;
 	while ((++dist)->set != SET_GROUP_END || nested--) {
 		set = dist->set;
 		if (set == SET_GROUP) {
 			nested++;
 			continue;
+		}
 		if (set == SET_LAST)
 			break;
 		if (set_status[set] == (SET_SELECTED | SET_VALID))
 			set_status[set] |= SET_SKIPPED;
 		tarstats.nskipped++;
+	}
+}
 distinfo*
 get_set_distinfo(int opt)
+{
 	distinfo *dist;
 	int set;
 	for (dist = dist_list; (set = dist->set) != SET_LAST; dist++) {
 		if (set != opt)
 			continue;
 		if (dist->name == NULL)
 			continue;
 		if ((set_status[set] & (SET_VALID | SET_SELECTED))
 		    != (SET_VALID | SET_SELECTED))
 			continue;
 		return dist;
+	}
 	return NULL;
+}
 /*
  * Get and unpack the distribution.
  * Show success_msg if installation completes.
  * Otherwise show failure_msg and wait for the user to ack it before continuing.
  * success_msg and failure_msg must both be 0-adic messages.
  */
 int
 get_and_unpack_sets(int update, msg setupdone_msg, msg success_msg, msg failure_msg)
+{
 	distinfo *dist;
 	int status;
 	int set, olderror, oldfound;
 	bool entropy_loaded = false;
 	/* Ensure mountpoint for distribution files exists in current root. */
 	(void)mkdir("/mnt2", S_IRWXU| S_IRGRP|S_IXGRP | S_IROTH|S_IXOTH);
 	if (script)
 		(void)fprintf(script, "mkdir -m 755 /mnt2\n");
 	/* reset failure/success counters */
 	memset(&tarstats, 0, sizeof(tarstats));
 	/* Find out which files to "get" if we get files. */
 	/* Accurately count selected sets */
 	for (dist = dist_list; (set = dist->set) != SET_LAST; dist++) {
 		if (dist->name == NULL)
 			continue;
 		if (set_status[set] & SET_NO_EXTRACT)
 			continue;
 		if ((set_status[set] & (SET_VALID | SET_SELECTED))
 		    == (SET_VALID | SET_SELECTED))
 			tarstats.nselected++;
+	}
 	status = SET_RETRY;
 	for (dist = dist_list; (set = dist->set) != SET_LAST; dist++) {
 		if (dist->name == NULL)
 			continue;
 		if (set_status[set] != (SET_VALID | SET_SELECTED))
 			continue;
 		/* save stats, in case we will retry */
 		oldfound = tarstats.nfound;
 		olderror = tarstats.nerror;
 		if (status != SET_OK) {
 			/* This might force a redraw.... */
 			clearok(curscr, 1);
 			touchwin(stdscr);
 			wrefresh(stdscr);
 			/* Sort out the location of the set files */
 			do {
 				umount_mnt2();
 				msg_fmt_display(MSG_distmedium, "%d%d%s",
 				    tarstats.nselected,
 				    tarstats.nsuccess + tarstats.nskipped,
 				    dist->name);
 				fetch_fn = NULL;
 				process_menu(MENU_distmedium, &status);
 			} while (status == SET_RETRY);
 			if (status == SET_SKIP) {
 				set_status[set] |= SET_SKIPPED;
 				tarstats.nskipped++;
 				continue;
+			}
 			if (status == SET_SKIP_GROUP) {
 				skip_set(dist, status);
 				continue;
+			}
 			if (status != SET_OK) {
 				hit_enter_to_continue(failure_msg, NULL);
 				return 1;
+			}
+		}
 		if (set_status[set] & SET_NO_EXTRACT)
 			continue;
 		/* Try to extract this set */
 		status = extract_file(dist, update);
 		if (status == SET_RETRY) {
 			/* do this set again */
 			dist--;
 			/* and reset statistics to what we had before this
 			 * set */
 			tarstats.nfound = oldfound;
 			tarstats.nerror = olderror;
+		}
+	}
 #ifdef MD_SET_EXTRACT_FINALIZE
 	MD_SET_EXTRACT_FINALIZE(update);
 #endif
 	if (tarstats.nerror == 0 && tarstats.nsuccess == tarstats.nselected) {
 		msg_display(MSG_endtarok);
 		/* Give user a chance to see the success message */
 		sleep(1);
 	} else {
 		/* We encountered errors. Let the user know. */
 		msg_fmt_display(MSG_endtar, "%d%d%d%d%d%d",
 		    tarstats.nselected, tarstats.nnotfound, tarstats.nskipped,
 		    tarstats.nfound, tarstats.nsuccess, tarstats.nerror);
 		hit_enter_to_continue(NULL, NULL);
+	}
 	/*
 	 * postinstall needs to be run after extracting all sets, because
 	 * otherwise /var/db/obsolete will only have current information
 	 * from the base, comp, and etc sets.
 	 */
 	if (update && (set_status[SET_ETC] & SET_INSTALLED)) {
 		int oldsendmail;
 		oldsendmail = run_program(RUN_DISPLAY | RUN_CHROOT |
 					  RUN_ERROR_OK | RUN_PROGRESS,
 					  "/usr/sbin/postinstall -s /.sysinst -d / check mailerconf");
 		if (oldsendmail == 1) {
 			msg_display(MSG_oldsendmail);
 			if (ask_yesno(NULL)) {
 				run_program(RUN_DISPLAY | RUN_CHROOT,
 					    "/usr/sbin/postinstall -s /.sysinst -d / fix mailerconf");
+			}
+		}
 		run_program(RUN_DISPLAY | RUN_CHROOT,
 			"/usr/sbin/postinstall -s /.sysinst -d / fix");
 		/* Don't discard the system's old entropy if any */
 		run_program(RUN_CHROOT | RUN_SILENT,
 		    "/etc/rc.d/random_seed start");
 		entropy_loaded = true;
+	}
 	/* Configure the system */
 	if (set_status[SET_BASE] & SET_INSTALLED)
 		run_makedev();
 	if (!update) {
 		struct stat sb1, sb2;
 		if (stat(target_expand("/"), &sb1) == 0
 		    && stat(target_expand("/var"), &sb2) == 0
 		    && sb1.st_dev != sb2.st_dev) {
 			add_rc_conf("random_file=/etc/entropy-file\n");
 			if (target_file_exists_p("/boot.cfg")) {
 				run_program(RUN_CHROOT|RUN_FATAL,
 					    "sh -c 'sed -e s./var/db/./etc/. "
 					    "< /boot.cfg "
 					    "> /tmp/boot.cfg.tmp'");
 				mv_within_target_or_die("/tmp/boot.cfg.tmp",
 							"/boot.cfg");
+			}
+		}
 #ifdef MD_BOOT_CFG_FINALIZE
 		if (target_file_exists_p("/boot.cfg")) {
 			MD_BOOT_CFG_FINALIZE("/boot.cfg");
+		}
 #endif
 		/* Save keyboard type */
 		save_kb_encoding();
 		/* Other configuration. */
 		mnt_net_config();
+	}
 	/* Mounted dist dir? */
 	umount_mnt2();
 	/* Save entropy -- on some systems it's ~all we'll ever get */
 	if (!update || entropy_loaded)
 		run_program(RUN_SILENT | RUN_CHROOT | RUN_ERROR_OK,
 		    "/etc/rc.d/random_seed stop");
 	/* Install/Upgrade complete ... reboot or exit to script */
 	hit_enter_to_continue(success_msg, NULL);
 	return 0;
+}
 void
 umount_mnt2(void)
+{
 	if (!mnt2_mounted)
 		return;
 	run_program(RUN_SILENT, "/sbin/umount /mnt2");
 	mnt2_mounted = 0;
+}
 /*
  * Do a quick sanity check that  the target can reboot.
  * return 1 if everything OK, 0 if there is a problem.
  * Uses a table of files we expect to find after a base install/upgrade.
  */
 /* test flag and pathname to check for after unpacking. */
 struct check_table { unsigned int mode; const char *path;} checks[] = {
   { S_IFREG, "/netbsd" },
   { S_IFDIR, "/etc" },
   { S_IFREG, "/etc/fstab" },
   { S_IFREG, "/sbin/init" },
   { S_IFREG, "/bin/sh" },
   { S_IFREG, "/etc/rc" },
   { S_IFREG, "/etc/rc.subr" },
   { S_IFREG, "/etc/rc.conf" },
   { S_IFDIR, "/dev" },
   { S_IFCHR, "/dev/console" },
 /* XXX check for rootdev in target /dev? */
   { S_IFREG, "/sbin/fsck" },
   { S_IFREG, "/sbin/fsck_ffs" },
   { S_IFREG, "/sbin/mount" },
   { S_IFREG, "/sbin/mount_ffs" },
   { S_IFREG, "/sbin/mount_nfs" },
 #if defined(DEBUG) || defined(DEBUG_CHECK)
   { S_IFREG, "/foo/bar" },		/* bad entry to exercise warning */
 #endif
   { 0, 0 }
 };
 /*
  * Check target for a single file.
  */
 static int
 check_for(unsigned int mode, const char *pathname)
+{
 	int found;
 	found = (target_test(mode, pathname) == 0);
 	if (found == 0)
 		msg_fmt_display(MSG_rootmissing, "%s", pathname);
 	return found;
+}
 /*
  * Check that all the files in check_table are present in the
  * target root. Warn if not found.
  */
 int
 sanity_check(void)
+{
 	int target_ok = 1;
 	struct check_table *p;
 	for (p = checks; p->path; p++) {
 		target_ok = target_ok && check_for(p->mode, p->path);
+	}
 	if (target_ok)
 		return 0;
 	/* Uh, oh. Something's missing. */
 	hit_enter_to_continue(MSG_badroot, NULL);
 	return 1;
+}
 /*
  * Some globals to pass things back from callbacks
  */
 static char zoneinfo_dir[STRSIZE];
 static int zonerootlen;
 static char *tz_selected;	/* timezonename (relative to share/zoneinfo */
 const char *tz_default;		/* UTC, or whatever /etc/localtime points to */
 static char tz_env[STRSIZE];
 static int save_cursel, save_topline;
 static int time_menu = -1;
 static void
 update_time_display(void)
+{
 	time_t t;
 	struct tm *tm;
 	char cur_time[STRSIZE], *p;
 	t = time(NULL);
 	tm = localtime(&t);
 	strlcpy(cur_time, safectime(&t), sizeof cur_time);
 	p = strchr(cur_time, '\n');
 	if (p != NULL)
 		*p = 0;
 	msg_clear();
 	msg_fmt_table_add(MSG_choose_timezone, "%s%s%s%s",
 	    tz_default, tz_selected, cur_time, tm ? tm->tm_zone : "?");
+}
 /*
  * Callback from timezone menu
  */
 static int
 set_tz_select(menudesc *m, void *arg)
+{
 	char *new;
 	if (m && strcmp(tz_selected, m->opts[m->cursel].opt_name) != 0) {
 		/* Change the displayed timezone */
 		new = strdup(m->opts[m->cursel].opt_name);
 		if (new == NULL)
 			return 0;
 		free(tz_selected);
 		tz_selected = new;
 		snprintf(tz_env, sizeof tz_env, "%.*s%s",
 			 zonerootlen, zoneinfo_dir, tz_selected);
 		setenv("TZ", tz_env, 1);
+	}
 	if (m)
 		/* Warp curser to 'Exit' line on menu */
 		m->cursel = -1;
 	update_time_display();
 	if (time_menu >= 1) {
 		WINDOW *w = get_menudesc(time_menu)->mw;
 		if (w != NULL) {
 			touchwin(w);
 			wrefresh(w);
+		}
+	}
 	return 0;
+}
 static int
 set_tz_back(menudesc *m, void *arg)
+{
 	zoneinfo_dir[zonerootlen] = 0;
 	m->cursel = save_cursel;
 	m->topline = save_topline;
 	return 0;
+}
 static int
 set_tz_dir(menudesc *m, void *arg)
+{
 	strlcpy(zoneinfo_dir + zonerootlen, m->opts[m->cursel].opt_name,
 		sizeof zoneinfo_dir - zonerootlen);
 	save_cursel = m->cursel;
 	save_topline = m->topline;
 	m->cursel = 0;
 	m->topline = 0;
 	return 0;
+}
 /*
  * Alarm-handler to update example-display
  */
 static void
 /*ARGSUSED*/
 timezone_sig(int sig)
+{
 	set_tz_select(NULL, NULL);
 	alarm(60);
+}
 static int
 tz_sort(const void *a, const void *b)
+{
 	return strcmp(((const menu_ent *)a)->opt_name, ((const menu_ent *)b)->opt_name);
+}
 static void
 tzm_set_names(menudesc *m, void *arg)
+{
 	DIR *dir;
 	struct dirent *dp;
 	static int nfiles;
 	static int maxfiles = 32;
 	static menu_ent *tz_menu;
 	static char **tz_names;
 	void *p;
 	int maxfname;
 	char *fp;
 	struct stat sb;
 	if (tz_menu == NULL)
 		tz_menu = calloc(maxfiles, sizeof *tz_menu);
 	if (tz_names == NULL)
 		tz_names = malloc(maxfiles * sizeof *tz_names);
 	if (tz_menu == NULL || tz_names == NULL)
 		return;	/* error - skip timezone setting */
 	while (nfiles > 0)
 		free(tz_names[--nfiles]);
 	dir = opendir(zoneinfo_dir);
 	fp = strchr(zoneinfo_dir, 0);
 	if (fp != zoneinfo_dir + zonerootlen) {
 		tz_names[0] = 0;
 		tz_menu[0].opt_name = msg_string(MSG_tz_back);
 		tz_menu[0].opt_action = set_tz_back;
 		nfiles = 1;
+	}
 	maxfname = zoneinfo_dir + sizeof zoneinfo_dir - fp - 1;
 	if (dir != NULL) {
 		while ((dp = readdir(dir)) != NULL) {
 			if (dp->d_namlen > maxfname || dp->d_name[0] == '.')
 				continue;
 			strlcpy(fp, dp->d_name, maxfname);
 			if (stat(zoneinfo_dir, &sb) == -1)
 				continue;
 			if (nfiles >= maxfiles) {
 				p = realloc(tz_menu,
 * maxfiles * sizeof *tz_menu);
 				if (p == NULL)
 					break;
 				tz_menu = p;
 				memset(tz_menu + maxfiles, 0,
 				    maxfiles * sizeof *tz_menu);
 				p = realloc(tz_names,
 * maxfiles * sizeof *tz_names);
 				if (p == NULL)
 					break;
 				tz_names = p;
 				memset(tz_names + maxfiles, 0,
 				    maxfiles * sizeof *tz_names);
 				maxfiles *= 2;
+			}
 			if (S_ISREG(sb.st_mode))
 				tz_menu[nfiles].opt_action = set_tz_select;
 			else if (S_ISDIR(sb.st_mode)) {
 				tz_menu[nfiles].opt_action = set_tz_dir;