walk

walk.c (6089B)

---

 /*
  * Copyright 2022 Jacob R. Edwards <jacob@jacobedwards.org>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
 /*
  * This program tries to conform to the behavior defined in 9front's
  * ls(1) (http://man.9front.org/1/ls) as far as possible. It could
  * be good to adapt it to UNIX systems instead (i.e. removing
  * impossible formats and file modes).
  */
 
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <errno.h>
 #include <libgen.h>
 #include <limits.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include <fts.h>
 
 void
 die(char *s)
 {
 	perror(s);
 	exit(1);
 }
 
 int
 getnum(char *s, char **ep)
 {
 	long n;
 
 	n = strtol(s, ep, 10);
 	if (n < 0 || n > INT_MAX) {
 		errno = ERANGE;
 		return -1;
 	}
 	return n;
 }
 
 int
 parse_n(char *arg, int *min, int *max)
 {
 	int n;
 
 	if (*arg == ',') {
 		*min = 0;
 	} else {
 		*min = getnum(arg, &arg);
 		if (*min < 0)
 			return 1;
 	}
 
 	if (*arg == ',') {
 		if (!arg[1]) {
 			*max = -1;
 			return 0;
 		}
 		*max = getnum(arg + 1, &arg);
 		if (*arg) {
 			errno = EINVAL;
 			return 1;
 		}
 		return *max < 0;
 	} else if (!*arg) {
 		*max = *min;
 		*min = 0;
 		return 0;
 	}
 
 	errno = EINVAL;
 	return 1;
 }
 
 void
 xprintf(char *fmt, ...)
 {
 	va_list ap;
 
 	va_start(ap, fmt);
 	if (vprintf(fmt, ap) < 0)
 		die("printf");
 	va_end(ap);
 }
 
 void
 permstr(mode_t mode, char buf[10])
 {
 	int i = 0;
 
 	buf[i++] = (mode & S_IRUSR) ? 'r' : '-';
 	buf[i++] = (mode & S_IWUSR) ? 'w' : '-';
 	buf[i++] = (mode & S_IXUSR) ? 'x' : '-';
 
 	buf[i++] = (mode & S_IRGRP) ? 'r' : '-';
 	buf[i++] = (mode & S_IWGRP) ? 'w' : '-';
 	buf[i++] = (mode & S_IXGRP) ? 'x' : '-';
 
 	buf[i++] = (mode & S_IROTH) ? 'r' : '-';
 	buf[i++] = (mode & S_IWOTH) ? 'w' : '-';
 	buf[i++] = (mode & S_IXOTH) ? 'x' : '-';
 
 	buf[i] = '\0';
 }
 
 int
 printent(char *fmt, char *path, struct stat *sb)
 {
 	int first;
 	char perms[10];
 
 	first = 1;
 	for (; *fmt; ++fmt) {
 		if (first)
 			first = 0;
 		else if (putchar(' ') == EOF)
 			return 1;
 
                 /*
 		 * NOTE: These are all guesses, I haven't looked
                  * at the 9front source code or ran the original
                  * program with the intent to study the formats.
 		 */
 		switch (*fmt) {
 		case 'U':
 			xprintf("%d", sb->st_uid);
 			break;
 		case 'G':
 			xprintf("%d", sb->st_gid);
 			break;
 		case 'a':
 			xprintf("%ld", sb->st_atim.tv_sec);
 			break;
 		case 'm':
 			xprintf("%ld", sb->st_mtim.tv_sec);
 			break;
 		case 'n':
 			xprintf("%s", basename(path));
 			break;
 		case 'p':
 			xprintf("%s", path);
 			break;
 		case 's':
 			xprintf("%zu", sb->st_size);
 			break;
 		case 'x':
 			permstr(sb->st_mode, perms);
 			xprintf("%c-%s", S_ISDIR(sb->st_mode) ? 'd' : '-',
 			    perms);
 			break;
 		case 'M':
 		case 'q':
 		case 'D':
 		case 'T':
 			xprintf("n/a");
 			break;
 		default:
 			return 1;
 		}
 	}
 
 	return putchar('\n') != '\n';
 }
 
 int
 main(int argc, char *argv[])
 {
 	int c;
 	FTS *fts;
 	FTSENT *ent;
 	int exec;
 	int vbuf;
 	int min, max;
 	char *fmt;
 	int show;
 	char *path;
 	int offset;
 	int depth;
 	enum {
 		DIR = 1, NOTDIR
 	} type;
 #ifdef __OpenBSD__
 	int i;
 
 	if (pledge("stdio rpath unveil", NULL))
 		die("pledge");
 #endif
 
 	type = 0;
 	exec = 0;
 	vbuf = 0;
 	min = max = -1;
 	fmt = "p";
 	while ((c = getopt(argc, argv, "dftxuE:n:e:")) != EOF) {
 		switch (c) {
 		case 'd':
 			type = DIR;
 			break;
 		case 'f':
 			type = NOTDIR;
 			break;
 		case 't':
 			die("No temporary flag on this system");
 			break;
 		case 'x':
 			exec = 1;
 			break;
 		case 'u':
 			if (setvbuf(stdout, NULL, 0, _IONBF))
 				die("setvbuf _IONBF");
 			vbuf = _IONBF;
 			break;
 		case 'n':
 			if (parse_n(optarg, &min, &max))
 				die(optarg);
 			break;
 		case 'e':
 			if (optarg[strcspn(optarg, "MqDT")]) {
 				errno = EOPNOTSUPP;
 				die(optarg);
 			}
 			/* fall-through */
 		case 'E':
 			if (optarg[strspn(optarg, "UGMamnpqsxDT")]) {
 				errno = EINVAL;
 				die(optarg);
 			}
 			fmt = optarg;
 			break;
 		default:
                         /*
 			 * -E is undocumented because it took up
                          * too much space and wasn't in the original.
                          */
 			fputs("usage: walk [-dftxu] [-n mind,maxd] [-e statfmt] [name ...]\n", stderr);
 			exit(1);
 		}
 	}
 	argv += optind;
 	argc -= optind;
 
 	if (argc) {
 		offset = 0;
 	} else {
 		offset = 2;
 		argv = (char *[]){ ".", NULL };
 		++argc;
 	}
 
 #ifdef __OpenBSD__
 	/* NOTE: the error for ENOENT is more helpful when running OpenBSD */
 	for (i = 0; i < argc; ++i)
 		if (unveil(argv[i], "r"))
 			die(argv[i]);
 	if (unveil(NULL, NULL))
 		die("unveil");
 #endif
 
 	if (!vbuf && setvbuf(stdout, NULL, 0, _IOFBF))
 		perror("setvbuf _IOFBF");
 
 	fts = fts_open(argv, FTS_PHYSICAL, NULL);
 	if (!fts)
 		die("fts open");
 
 	while ((ent = fts_read(fts))) {
 		if (offset && strcmp(ent->fts_path, ".") == 0)
 			continue;
 		path = ent->fts_path + offset;
 
 		switch (ent->fts_info) {
 		case FTS_DNR:
 		case FTS_ERR:
 		case FTS_NS:
 			perror(path);
 		case FTS_DP:
 			continue;
 		}
 
 		depth = ent->fts_level - 1;
 		if (max >= 0 && depth > max) {
 			if (fts_set(fts, ent, FTS_SKIP))
 				die("set skip");
 			continue;
 		}
 		if (depth < min)
 			continue;
 
 		if (type == DIR)
 			show = S_ISDIR(ent->fts_statp->st_mode);
 		else if (type == NOTDIR)
 			show = !S_ISDIR(ent->fts_statp->st_mode);
 		else
 			show = 1;
 
 		if (exec)
 			show = show && access(ent->fts_accpath, X_OK) == 0;
 
 		if (show && printent(fmt, path, ent->fts_statp))
 			die(path);
 	}
 	fts_close(fts);
 
 	return 0;
 }