 @@ -1,14 +1,14 @@
-/*	$NetBSD: walk.c,v 1.37 2024/04/24 14:02:39 christos Exp $	*/
+/*	$NetBSD: walk.c,v 1.38 2024/04/24 14:23:37 christos Exp $	*/
 /*
  * Copyright (c) 2001 Wasabi Systems, Inc.
  * All rights reserved.
+ *
  * Written by Luke Mewburn for Wasabi 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
 @@ -31,27 +31,27 @@
  * 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_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID) && !defined(__lint)
-__RCSID("$NetBSD: walk.c,v 1.37 2024/04/24 14:02:39 christos Exp $");
+__RCSID("$NetBSD: walk.c,v 1.38 2024/04/24 14:23:37 christos Exp $");
 #endif	/* !__lint */
 #include <sys/param.h>
 #include <sys/stat.h>
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <dirent.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 @@ -85,44 +85,46 @@ fsnode_cmp(const void *vleft, const void
 		return 1;
 	return strcmp(lname, rname);
+}
 static fsnode *
 fsnode_sort(fsnode *first, const char *root, const char *dir)
+{
 	fsnode **list, **listptr;
 	size_t num = 0;
 	for (fsnode *tmp = first; tmp; tmp = tmp->next, num++) {
 		num++;
 		if (debug & DEBUG_DUMP_FSNODES_VERBOSE)
-			printf ("pre sort: %s %s %s\n", root, dir, tmp->name);
+			printf("%s: pre sort: %s %s %s\n",
 			    __func__, root, dir, tmp->name);
+	}
 	list = listptr = ecalloc(num, sizeof(*list));
 	for (fsnode *tmp = first; tmp; tmp = tmp->next)
 		*listptr++ = tmp;
 	qsort (list, num, sizeof(*list), fsnode_cmp);
 	for (size_t i = 0; i < num - 1; ++i)
 		list[i]->next = list[i + 1];
 	list[num - 1]->next = NULL;
 	first = list[0];
 	assert(strcmp(first->name, ".") == 0);
 	free(list);
 	if (debug & DEBUG_DUMP_FSNODES_VERBOSE)
 		for (fsnode *tmp = first; tmp; tmp = tmp->next)
-			printf("post sort: %s %s %s\n", root, dir, tmp->name);
+			printf("%s: post sort: %s %s %s\n",
 			    __func__, root, dir, tmp->name);
 	return first;
+}
 /*
  * walk_dir --
  *	build a tree of fsnodes from `root' and `dir', with a parent
  *	fsnode of `parent' (which may be NULL for the root of the tree).
  *	append the tree to a fsnode of `join' if it is not NULL.
  *	each "level" is a directory, with the "." entry guaranteed to be
  *	at the start of the list, and without ".." entries.
  */
 fsnode *
 @@ -134,27 +136,27 @@ walk_dir(const char *root, const char *d
 	struct dirent	*dent;
 	char		path[MAXPATHLEN + 1];
 	struct stat	stbuf;
 	char		*name, *rp;
 	int		dot, len;
 	assert(root != NULL);
 	assert(dir != NULL);
 	len = snprintf(path, sizeof(path), "%s/%s", root, dir);
 	if ((size_t)len >= sizeof(path))
 		errx(EXIT_FAILURE, "Pathname too long.");
 	if (debug & DEBUG_WALK_DIR)
-		printf("walk_dir: %s %p\n", path, parent);
+		printf("%s: %s %p\n", __func__, path, parent);
 	if ((dirp = opendir(path)) == NULL)
 		err(EXIT_FAILURE, "Can't opendir `%s'", path);
 	rp = path + strlen(root) + 1;
 	if (join != NULL) {
 		first = cur = join;
 		while (cur->next != NULL)
 			cur = cur->next;
 		prev = last = cur;
 	} else
 		last = first = prev = NULL;
 	while ((dent = readdir(dirp)) != NULL) {
 		name = dent->d_name;
 		dot = 0;
 @@ -163,86 +165,88 @@ walk_dir(const char *root, const char *d
 			case '\0':	/* "." */
 				if (join != NULL)
 					continue;
 				dot = 1;
 				break;
 			case '.':	/* ".." */
 				if (name[2] == '\0')
 					continue;
 				/* FALLTHROUGH */
 			default:
 				dot = 0;
+			}
 		if (debug & DEBUG_WALK_DIR_NODE)
-			printf("scanning %s/%s/%s\n", root, dir, name);
+			printf("%s: scanning %s/%s/%s\n",
 			    __func__, root, dir, name);
 		if (snprintf(path + len, sizeof(path) - len, "/%s", name) >=
 		    (int)sizeof(path) - len)
 			errx(EXIT_FAILURE, "Pathname too long.");
 		if (follow) {
 			if (stat(path, &stbuf) == -1)
 				err(EXIT_FAILURE, "Can't stat `%s'", path);
 		} else {
 			if (lstat(path, &stbuf) == -1)
 				err(EXIT_FAILURE, "Can't lstat `%s'", path);
 			/*
 			 * Symlink permission bits vary between filesystems/OSs
 			 * (ie. 0755 on FFS/NetBSD, 0777 for ext[234]/Linux),
 			 * force them to 0755.
 			 */
 			if (S_ISLNK(stbuf.st_mode)) {
 				stbuf.st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO);
 				stbuf.st_mode |= S_IRWXU
 				    | S_IRGRP | S_IXGRP
 				    | S_IROTH | S_IXOTH;
+			}
+		}
 #ifdef S_ISSOCK
 		if (S_ISSOCK(stbuf.st_mode & S_IFMT)) {
 			if (debug & DEBUG_WALK_DIR_NODE)
-				printf("  skipping socket %s\n", path);
+				printf("%s: skipping socket %s\n", __func__, path);
 			continue;
+		}
 #endif
 		if (join != NULL) {
 			cur = join->next;
 			for (;;) {
 				if (cur == NULL || strcmp(cur->name, name) == 0)
 					break;
 				if (cur == last) {
 					cur = NULL;
 					break;
+				}
 				cur = cur->next;
+			}
 			if (cur != NULL) {
 				if (S_ISDIR(cur->type) &&
 				    S_ISDIR(stbuf.st_mode)) {
 					if (debug & DEBUG_WALK_DIR_NODE)
-						printf("merging %s with %p\n",
+						printf("%s: merging %s with %p\n",
-						    path, cur->child);
+						    __func__, path, cur->child);
 					cur->child = walk_dir(root, rp, cur,
 					    cur->child, replace, follow);
 					continue;
+				}
 				if (!replace)
 					errx(EXIT_FAILURE,
 					    "Can't merge %s `%s' with "
 					    "existing %s",
 					    inode_type(stbuf.st_mode), path,
 					    inode_type(cur->type));
 				else {
 					if (debug & DEBUG_WALK_DIR_NODE)
-						printf("replacing %s %s\n",
+						printf("%s: replacing %s %s\n",
 						    __func__,
 						    inode_type(stbuf.st_mode),
 						    path);
 					if (cur == join->next)
 						join->next = cur->next;
 					else {
 						fsnode *p;
 						for (p = join->next;
 						    p->next != cur; p = p->next)
 							continue;
 						p->next = cur->next;
+					}
 					free(cur);
+				}
 @@ -270,27 +274,28 @@ walk_dir(const char *root, const char *d
 				    replace, follow);
 				continue;
+			}
+		}
 		if (stbuf.st_nlink > 1) {
 			fsinode	*curino;
 			curino = link_check(cur->inode);
 			if (curino != NULL) {
 				free(cur->inode);
 				cur->inode = curino;
 				cur->inode->nlink++;
 				if (debug & DEBUG_WALK_DIR_LINKCHECK)
-					printf("link_check: found [%ju, %ju]\n",
+					printf("%s: link check found [%ju, %ju]\n",
 					    __func__,
 					    (uintmax_t)curino->st.st_dev,
 					    (uintmax_t)curino->st.st_ino);
+			}
+		}
 		if (S_ISLNK(cur->type)) {
 			char	slink[PATH_MAX+1];
 			ssize_t	llen;
 			llen = readlink(path, slink, sizeof(slink) - 1);
 			if (llen == -1)
 				err(EXIT_FAILURE, "Readlink `%s'", path);
 			slink[llen] = '\0';
 			cur->symlink = estrdup(slink);
 @@ -393,27 +398,27 @@ free_fsnodes(fsnode *node)
  *	entries will be added.
  */
 void
 apply_specfile(const char *specfile, const char *dir, fsnode *parent, int speconly)
+{
 	struct timeval	 start;
 	FILE	*fp;
 	NODE	*root;
 	assert(specfile != NULL);
 	assert(parent != NULL);
 	if (debug & DEBUG_APPLY_SPECFILE)
-		printf("apply_specfile: %s, %s %p\n", specfile, dir, parent);
+		printf("%s: %s, %s %p\n", __func__, specfile, dir, parent);
 				/* read in the specfile */
 	if ((fp = fopen(specfile, "r")) == NULL)
 		err(EXIT_FAILURE, "Can't open `%s'", specfile);
 	TIMER_START(start);
 	root = spec(fp);
 	TIMER_RESULTS(start, "spec");
 	if (fclose(fp) == EOF)
 		err(EXIT_FAILURE, "Can't close `%s'", specfile);
 				/* perform some sanity checks */
 	if (root == NULL)
 		errx(EXIT_FAILURE,
 @@ -428,27 +433,27 @@ apply_specfile(const char *specfile, con
+}
 static void
 apply_specdir(const char *dir, NODE *specnode, fsnode *dirnode, int speconly)
+{
 	char	 path[MAXPATHLEN + 1];
 	NODE	*curnode;
 	fsnode	*curfsnode;
 	assert(specnode != NULL);
 	assert(dirnode != NULL);
 	if (debug & DEBUG_APPLY_SPECFILE)
-		printf("apply_specdir: %s %p %p\n", dir, specnode, dirnode);
+		printf("%s: %s %p %p\n", __func__, dir, specnode, dirnode);
 	if (specnode->type != F_DIR)
 		errx(EXIT_FAILURE, "Specfile node `%s/%s' is not a directory",
 		    dir, specnode->name);
 	if (dirnode->type != S_IFDIR)
 		errx(EXIT_FAILURE, "Directory node `%s/%s' is not a directory",
 		    dir, dirnode->name);
 	apply_specentry(dir, specnode, dirnode);
 	/* Remove any filesystem nodes not found in specfile */
 	/* XXX inefficient.  This is O^2 in each dir and it would
 	 * have been better never to have walked this part of the tree
 @@ -456,44 +461,45 @@ apply_specdir(const char *dir, NODE *spe
 	 */
 	if (speconly) {
 		fsnode *next;
 		assert(dirnode->name[0] == '.' && dirnode->name[1] == '\0');
 		for (curfsnode = dirnode->next; curfsnode != NULL; curfsnode = next) {
 			next = curfsnode->next;
 			for (curnode = specnode->child; curnode != NULL;
 			     curnode = curnode->next) {
 				if (strcmp(curnode->name, curfsnode->name) == 0)
 					break;
+			}
 			if (curnode == NULL) {
 				if (debug & DEBUG_APPLY_SPECONLY) {
-					printf("apply_specdir: trimming %s/%s %p\n", dir, curfsnode->name, curfsnode);
+					printf("%s: trimming %s/%s %p\n",
 					    __func__, dir, curfsnode->name,
 					    curfsnode);
+				}
 				free_fsnodes(curfsnode);
+			}
+		}
+	}
 			/* now walk specnode->child matching up with dirnode */
 	for (curnode = specnode->child; curnode != NULL;
 	    curnode = curnode->next) {
 		if (debug & DEBUG_APPLY_SPECENTRY)
-			printf("apply_specdir:  spec %s\n",
+			printf("%s:  spec %s\n", __func__, curnode->name);
 			    curnode->name);
 		for (curfsnode = dirnode->next; curfsnode != NULL;
 		    curfsnode = curfsnode->next) {
 #if 0	/* too verbose for now */
 			if (debug & DEBUG_APPLY_SPECENTRY)
-				printf("apply_specdir:  dirent %s\n",
+				printf("%s: dirent %s\n", __func__,
 				    curfsnode->name);
 #endif
 			if (strcmp(curnode->name, curfsnode->name) == 0)
 				break;
+		}
 		if ((size_t)snprintf(path, sizeof(path), "%s/%s",
 		    dir, curnode->name) >= sizeof(path))
 			errx(EXIT_FAILURE, "Pathname too long.");
 		if (curfsnode == NULL) {	/* need new entry */
 			struct stat	stbuf;
 					    /*
 					     * don't add optional spec entries
 @@ -511,28 +517,27 @@ apply_specdir(const char *dir, NODE *spe
 			NODETEST(curnode->flags & F_TYPE, "type");
 			NODETEST(curnode->flags & F_MODE, "mode");
 				/* XXX: require F_TIME ? */
 			NODETEST(curnode->flags & F_GID ||
 			    curnode->flags & F_GNAME, "group");
 			NODETEST(curnode->flags & F_UID ||
 			    curnode->flags & F_UNAME, "user");
 			if (curnode->type == F_BLOCK || curnode->type == F_CHAR)
 				NODETEST(curnode->flags & F_DEV,
 				    "device number");
 #undef NODETEST
 			if (debug & DEBUG_APPLY_SPECFILE)
-				printf("apply_specdir: adding %s\n",
+				printf("%s: adding %s\n", __func__, curnode->name);
 				    curnode->name);
 					/* build minimal fsnode */
 			memset(&stbuf, 0, sizeof(stbuf));
 			stbuf.st_mode = nodetoino(curnode->type);
 			stbuf.st_nlink = 1;
 			stbuf.st_mtime = stbuf.st_atime =
 			    stbuf.st_ctime = start_time.tv_sec;
 #if HAVE_STRUCT_STAT_ST_MTIMENSEC
 			stbuf.st_mtimensec = stbuf.st_atimensec =
 			    stbuf.st_ctimensec = start_time.tv_nsec;
 #endif
 			curfsnode = create_fsnode(".", ".", curnode->name,
 			    &stbuf);
 			curfsnode->parent = dirnode->parent;
 @@ -567,27 +572,27 @@ static void
 apply_specentry(const char *dir, NODE *specnode, fsnode *dirnode)
+{
 	assert(specnode != NULL);
 	assert(dirnode != NULL);
 	if (nodetoino(specnode->type) != dirnode->type)
 		errx(EXIT_FAILURE,
 		    "`%s/%s' type mismatch: specfile %s, tree %s",
 		    dir, specnode->name, inode_type(nodetoino(specnode->type)),
 		    inode_type(dirnode->type));
 	if (debug & DEBUG_APPLY_SPECENTRY)
-		printf("apply_specentry: %s/%s\n", dir, dirnode->name);
+		printf("%s: %s/%s\n", dir, __func__, dirnode->name);
 #define ASEPRINT(t, b, o, n) \
 		if (debug & DEBUG_APPLY_SPECENTRY) \
 			printf("\t\t\tchanging %s from " b " to " b "\n", \
 			    t, o, n)
 	if (specnode->flags & (F_GID | F_GNAME)) {
 		ASEPRINT("gid", "%d",
 		    dirnode->inode->st.st_gid, specnode->st_gid);
 		dirnode->inode->st.st_gid = specnode->st_gid;
+	}
 	if (specnode->flags & F_MODE) {
 		ASEPRINT("mode", "%#o",
 @@ -647,52 +652,52 @@ apply_specentry(const char *dir, NODE *s
+}
 /*
  * dump_fsnodes --
  *	dump the fsnodes from `cur'
  */
 void
 dump_fsnodes(fsnode *root)
+{
 	fsnode	*cur;
 	char	path[MAXPATHLEN + 1];
-	printf("dump_fsnodes: %s %p\n", root->path, root);
+	printf("%s: %s %p\n", __func__, root->path, root);
 	for (cur = root; cur != NULL; cur = cur->next) {
 		if (snprintf(path, sizeof(path), "%s/%s", cur->path,
 		    cur->name) >= (int)sizeof(path))
 			errx(EXIT_FAILURE, "Pathname too long.");
 		if (debug & DEBUG_DUMP_FSNODES_VERBOSE)
-			printf("cur=%8p parent=%8p first=%8p ",
+			printf("%s: cur=%8p parent=%8p first=%8p ", __func__,
 			    cur, cur->parent, cur->first);
 		printf("%7s: %s", inode_type(cur->type), path);
 		if (S_ISLNK(cur->type)) {
 			assert(cur->symlink != NULL);
 			printf(" -> %s", cur->symlink);
 		} else {
 			assert (cur->symlink == NULL);
+		}
 		if (cur->inode->nlink > 1)
 			printf(", nlinks=%d", cur->inode->nlink);
 		putchar('\n');
 		if (cur->child) {
 			assert (cur->type == S_IFDIR);
 			dump_fsnodes(cur->child);
+		}
+	}
-	printf("dump_fsnodes: finished %s/%s\n", root->path, root->name);
+	printf("%s: finished %s/%s\n", __func__, root->path, root->name);
+}
 /*
  * inode_type --
  *	for a given inode type `mode', return a descriptive string.
  *	for most cases, uses inotype() from mtree/misc.c
  */
 const char *
 inode_type(mode_t mode)
+{
 	if (S_ISLNK(mode))