xref: /freebsd/usr.bin/stat/stat.c (revision 7ef62cebc2f965b0f640263e179276928885e33d)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (c) 2002 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Andrew Brown.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  */
31 
32 #include <sys/cdefs.h>
33 #if 0
34 #ifndef lint
35 __RCSID("$NetBSD: stat.c,v 1.33 2011/01/15 22:54:10 njoly Exp $"
36 "$OpenBSD: stat.c,v 1.14 2009/06/24 09:44:25 sobrado Exp $");
37 #endif
38 #endif
39 
40 __FBSDID("$FreeBSD$");
41 
42 #if HAVE_CONFIG_H
43 #include "config.h"
44 #else  /* HAVE_CONFIG_H */
45 #define HAVE_STRUCT_STAT_ST_FLAGS 1
46 #define HAVE_STRUCT_STAT_ST_GEN 1
47 #define HAVE_STRUCT_STAT_ST_BIRTHTIME 1
48 #define HAVE_STRUCT_STAT_ST_MTIMENSEC 1
49 #define HAVE_DEVNAME 1
50 #endif /* HAVE_CONFIG_H */
51 
52 #include <sys/param.h>
53 #include <sys/types.h>
54 #include <sys/stat.h>
55 #include <sys/mount.h>
56 
57 #include <ctype.h>
58 #include <err.h>
59 #include <errno.h>
60 #include <grp.h>
61 #include <limits.h>
62 #include <locale.h>
63 #include <paths.h>
64 #include <pwd.h>
65 #include <stdio.h>
66 #include <stdlib.h>
67 #include <string.h>
68 #include <time.h>
69 #include <unistd.h>
70 
71 #if HAVE_STRUCT_STAT_ST_FLAGS
72 #define DEF_F "%#Xf "
73 #define RAW_F "%f "
74 #define SHELL_F " st_flags=%f"
75 #else /* HAVE_STRUCT_STAT_ST_FLAGS */
76 #define DEF_F
77 #define RAW_F
78 #define SHELL_F
79 #endif /* HAVE_STRUCT_STAT_ST_FLAGS */
80 
81 #if HAVE_STRUCT_STAT_ST_BIRTHTIME
82 #define DEF_B "\"%SB\" "
83 #define RAW_B "%B "
84 #define SHELL_B "st_birthtime=%B "
85 #else /* HAVE_STRUCT_STAT_ST_BIRTHTIME */
86 #define DEF_B
87 #define RAW_B
88 #define SHELL_B
89 #endif /* HAVE_STRUCT_STAT_ST_BIRTHTIME */
90 
91 #if HAVE_STRUCT_STAT_ST_ATIM
92 #define st_atimespec st_atim
93 #define st_ctimespec st_ctim
94 #define st_mtimespec st_mtim
95 #endif /* HAVE_STRUCT_STAT_ST_ATIM */
96 
97 #define DEF_FORMAT \
98 	"%d %i %Sp %l %Su %Sg %r %z \"%Sa\" \"%Sm\" \"%Sc\" " DEF_B \
99 	"%k %b " DEF_F "%N"
100 #define RAW_FORMAT	"%d %i %#p %l %u %g %r %z %a %m %c " RAW_B \
101 	"%k %b " RAW_F "%N"
102 #define LS_FORMAT	"%Sp %l %Su %Sg %Z %Sm %N%SY"
103 #define LSF_FORMAT	"%Sp %l %Su %Sg %Z %Sm %N%T%SY"
104 #define SHELL_FORMAT \
105 	"st_dev=%d st_ino=%i st_mode=%#p st_nlink=%l " \
106 	"st_uid=%u st_gid=%g st_rdev=%r st_size=%z " \
107 	"st_atime=%a st_mtime=%m st_ctime=%c " SHELL_B \
108 	"st_blksize=%k st_blocks=%b" SHELL_F
109 #define LINUX_FORMAT \
110 	"  File: \"%N\"%n" \
111 	"  Size: %-11z  FileType: %HT%n" \
112 	"  Mode: (%OMp%03OLp/%.10Sp)         Uid: (%5u/%8Su)  Gid: (%5g/%8Sg)%n" \
113 	"Device: %Hd,%Ld   Inode: %i    Links: %l%n" \
114 	"Access: %Sa%n" \
115 	"Modify: %Sm%n" \
116 	"Change: %Sc%n"	\
117 	" Birth: %SB"
118 
119 #define TIME_FORMAT	"%b %e %T %Y"
120 
121 #define FLAG_POUND	0x01
122 #define FLAG_SPACE	0x02
123 #define FLAG_PLUS	0x04
124 #define FLAG_ZERO	0x08
125 #define FLAG_MINUS	0x10
126 
127 /*
128  * These format characters must all be unique, except the magic one.
129  */
130 #define FMT_MAGIC	'%'
131 #define FMT_DOT		'.'
132 
133 #define SIMPLE_NEWLINE	'n'
134 #define SIMPLE_TAB	't'
135 #define SIMPLE_PERCENT	'%'
136 #define SIMPLE_NUMBER	'@'
137 
138 #define FMT_POUND	'#'
139 #define FMT_SPACE	' '
140 #define FMT_PLUS	'+'
141 #define FMT_ZERO	'0'
142 #define FMT_MINUS	'-'
143 
144 #define FMT_DECIMAL 	'D'
145 #define FMT_OCTAL 	'O'
146 #define FMT_UNSIGNED 	'U'
147 #define FMT_HEX 	'X'
148 #define FMT_FLOAT 	'F'
149 #define FMT_STRING 	'S'
150 
151 #define FMTF_DECIMAL	0x01
152 #define FMTF_OCTAL	0x02
153 #define FMTF_UNSIGNED	0x04
154 #define FMTF_HEX	0x08
155 #define FMTF_FLOAT	0x10
156 #define FMTF_STRING	0x20
157 
158 #define HIGH_PIECE	'H'
159 #define MIDDLE_PIECE	'M'
160 #define LOW_PIECE	'L'
161 
162 #define	SHOW_realpath	'R'
163 #define SHOW_st_dev	'd'
164 #define SHOW_st_ino	'i'
165 #define SHOW_st_mode	'p'
166 #define SHOW_st_nlink	'l'
167 #define SHOW_st_uid	'u'
168 #define SHOW_st_gid	'g'
169 #define SHOW_st_rdev	'r'
170 #define SHOW_st_atime	'a'
171 #define SHOW_st_mtime	'm'
172 #define SHOW_st_ctime	'c'
173 #define SHOW_st_btime	'B'
174 #define SHOW_st_size	'z'
175 #define SHOW_st_blocks	'b'
176 #define SHOW_st_blksize	'k'
177 #define SHOW_st_flags	'f'
178 #define SHOW_st_gen	'v'
179 #define SHOW_symlink	'Y'
180 #define SHOW_filetype	'T'
181 #define SHOW_filename	'N'
182 #define SHOW_sizerdev	'Z'
183 
184 void	usage(const char *);
185 void	output(const struct stat *, const char *,
186 	    const char *, int, int);
187 int	format1(const struct stat *,	/* stat info */
188 	    const char *,		/* the file name */
189 	    const char *, int,		/* the format string itself */
190 	    char *, size_t,		/* a place to put the output */
191 	    int, int, int, int,		/* the parsed format */
192 	    int, int);
193 int	hex2byte(const char [2]);
194 #if HAVE_STRUCT_STAT_ST_FLAGS
195 char   *xfflagstostr(unsigned long);
196 #endif
197 
198 static const char *timefmt;
199 static int linkfail;
200 
201 #define addchar(s, c, nl) \
202 	do { \
203 		(void)fputc((c), (s)); \
204 		(*nl) = ((c) == '\n'); \
205 	} while (0/*CONSTCOND*/)
206 
207 int
208 main(int argc, char *argv[])
209 {
210 	struct stat st;
211 	int ch, rc, errs, am_readlink;
212 	int lsF, fmtchar, usestat, nfs_handle, fn, nonl, quiet;
213 	const char *statfmt, *options, *synopsis;
214 	char dname[sizeof _PATH_DEV + SPECNAMELEN] = _PATH_DEV;
215 	fhandle_t fhnd;
216 	const char *file;
217 
218 	am_readlink = 0;
219 	lsF = 0;
220 	fmtchar = '\0';
221 	usestat = 0;
222 	nfs_handle = 0;
223 	nonl = 0;
224 	quiet = 0;
225 	linkfail = 0;
226 	statfmt = NULL;
227 	timefmt = NULL;
228 
229 	if (strcmp(getprogname(), "readlink") == 0) {
230 		am_readlink = 1;
231 		options = "fn";
232 		synopsis = "[-fn] [file ...]";
233 		statfmt = "%Y";
234 		fmtchar = 'f';
235 		quiet = 1;
236 	} else {
237 		options = "f:FHlLnqrst:x";
238 		synopsis = "[-FLnq] [-f format | -l | -r | -s | -x] "
239 		    "[-t timefmt] [file|handle ...]";
240 	}
241 
242 	while ((ch = getopt(argc, argv, options)) != -1)
243 		switch (ch) {
244 		case 'F':
245 			lsF = 1;
246 			break;
247                 case 'H':
248 			nfs_handle = 1;
249 			break;
250 		case 'L':
251 			usestat = 1;
252 			break;
253 		case 'n':
254 			nonl = 1;
255 			break;
256 		case 'q':
257 			quiet = 1;
258 			break;
259 		case 'f':
260 			if (am_readlink) {
261 				statfmt = "%R";
262 				break;
263 			}
264 			statfmt = optarg;
265 			/* FALLTHROUGH */
266 		case 'l':
267 		case 'r':
268 		case 's':
269 		case 'x':
270 			if (fmtchar != 0)
271 				errx(1, "can't use format '%c' with '%c'",
272 				    fmtchar, ch);
273 			fmtchar = ch;
274 			break;
275 		case 't':
276 			timefmt = optarg;
277 			break;
278 		default:
279 			usage(synopsis);
280 		}
281 
282 	argc -= optind;
283 	argv += optind;
284 	fn = 1;
285 
286 	if (fmtchar == '\0') {
287 		if (lsF)
288 			fmtchar = 'l';
289 		else {
290 			fmtchar = 'f';
291 			statfmt = DEF_FORMAT;
292 		}
293 	}
294 
295 	if (lsF && fmtchar != 'l')
296 		errx(1, "can't use format '%c' with -F", fmtchar);
297 
298 	switch (fmtchar) {
299 	case 'f':
300 		/* statfmt already set */
301 		break;
302 	case 'l':
303 		statfmt = lsF ? LSF_FORMAT : LS_FORMAT;
304 		break;
305 	case 'r':
306 		statfmt = RAW_FORMAT;
307 		break;
308 	case 's':
309 		statfmt = SHELL_FORMAT;
310 		break;
311 	case 'x':
312 		statfmt = LINUX_FORMAT;
313 		if (timefmt == NULL)
314 			timefmt = "%c";
315 		break;
316 	default:
317 		usage(synopsis);
318 		/*NOTREACHED*/
319 	}
320 
321 	if (timefmt == NULL)
322 		timefmt = TIME_FORMAT;
323 
324 	errs = 0;
325 	do {
326 		if (argc == 0) {
327 			if (fdevname_r(STDIN_FILENO, dname +
328 			    sizeof _PATH_DEV - 1, SPECNAMELEN) != NULL)
329 				file = dname;
330 			else
331 				file = "(stdin)";
332 			rc = fstat(STDIN_FILENO, &st);
333 		} else {
334 			int j;
335 
336 			file = argv[0];
337 			if (nfs_handle) {
338 				rc = 0;
339 				bzero(&fhnd, sizeof(fhnd));
340 				j = MIN(2 * sizeof(fhnd), strlen(file));
341 				if ((j & 1) != 0) {
342 					rc = -1;
343 				} else {
344 					while (j) {
345 						rc = hex2byte(&file[j - 2]);
346 						if (rc == -1)
347 							break;
348 						((char*) &fhnd)[j / 2 - 1] = rc;
349 						j -= 2;
350 					}
351 				}
352 				if (rc == -1)
353 					errno = EINVAL;
354 				else
355 					rc = fhstat(&fhnd, &st);
356 
357 			} else if (usestat) {
358 				/*
359 				 * Try stat() and if it fails, fall back to
360 				 * lstat() just in case we're examining a
361 				 * broken symlink.
362 				 */
363 				if ((rc = stat(file, &st)) == -1 &&
364 				    errno == ENOENT &&
365 				    (rc = lstat(file, &st)) == -1)
366 					errno = ENOENT;
367 			}
368 			else
369 				rc = lstat(file, &st);
370 		}
371 
372 		if (rc == -1) {
373 			errs = 1;
374 			linkfail = 1;
375 			if (!quiet)
376 				warn("%s", file);
377 		}
378 		else
379 			output(&st, file, statfmt, fn, nonl);
380 
381 		argv++;
382 		argc--;
383 		fn++;
384 	} while (argc > 0);
385 
386 	return (am_readlink ? linkfail : errs);
387 }
388 
389 #if HAVE_STRUCT_STAT_ST_FLAGS
390 /*
391  * fflagstostr() wrapper that leaks only once
392  */
393 char *
394 xfflagstostr(unsigned long fflags)
395 {
396 	static char *str = NULL;
397 
398 	if (str != NULL)
399 		free(str);
400 
401 	str = fflagstostr(fflags);
402 	if (str == NULL)
403 		err(1, "fflagstostr");
404 	return (str);
405 }
406 #endif /* HAVE_STRUCT_STAT_ST_FLAGS */
407 
408 void
409 usage(const char *synopsis)
410 {
411 
412 	(void)fprintf(stderr, "usage: %s %s\n", getprogname(), synopsis);
413 	exit(1);
414 }
415 
416 /*
417  * Parses a format string.
418  */
419 void
420 output(const struct stat *st, const char *file,
421     const char *statfmt, int fn, int nonl)
422 {
423 	int flags, size, prec, ofmt, hilo, what;
424 	char buf[PATH_MAX + 4 + 1];
425 	const char *subfmt;
426 	int nl, t, i;
427 
428 	nl = 1;
429 	while (*statfmt != '\0') {
430 
431 		/*
432 		 * Non-format characters go straight out.
433 		 */
434 		if (*statfmt != FMT_MAGIC) {
435 			addchar(stdout, *statfmt, &nl);
436 			statfmt++;
437 			continue;
438 		}
439 
440 		/*
441 		 * The current format "substring" starts here,
442 		 * and then we skip the magic.
443 		 */
444 		subfmt = statfmt;
445 		statfmt++;
446 
447 		/*
448 		 * Some simple one-character "formats".
449 		 */
450 		switch (*statfmt) {
451 		case SIMPLE_NEWLINE:
452 			addchar(stdout, '\n', &nl);
453 			statfmt++;
454 			continue;
455 		case SIMPLE_TAB:
456 			addchar(stdout, '\t', &nl);
457 			statfmt++;
458 			continue;
459 		case SIMPLE_PERCENT:
460 			addchar(stdout, '%', &nl);
461 			statfmt++;
462 			continue;
463 		case SIMPLE_NUMBER: {
464 			char num[12], *p;
465 
466 			snprintf(num, sizeof(num), "%d", fn);
467 			for (p = &num[0]; *p; p++)
468 				addchar(stdout, *p, &nl);
469 			statfmt++;
470 			continue;
471 		}
472 		}
473 
474 		/*
475 		 * This must be an actual format string.  Format strings are
476 		 * similar to printf(3) formats up to a point, and are of
477 		 * the form:
478 		 *
479 		 *	%	required start of format
480 		 *	[-# +0]	opt. format characters
481 		 *	size	opt. field width
482 		 *	.	opt. decimal separator, followed by
483 		 *	prec	opt. precision
484 		 *	fmt	opt. output specifier (string, numeric, etc.)
485 		 *	sub	opt. sub field specifier (high, middle, low)
486 		 *	datum	required field specifier (size, mode, etc)
487 		 *
488 		 * Only the % and the datum selector are required.  All data
489 		 * have reasonable default output forms.  The "sub" specifier
490 		 * only applies to certain data (mode, dev, rdev, filetype).
491 		 * The symlink output defaults to STRING, yet will only emit
492 		 * the leading " -> " if STRING is explicitly specified.  The
493 		 * sizerdev datum will generate rdev output for character or
494 		 * block devices, and size output for all others.
495 		 */
496 		flags = 0;
497 		do {
498 			if      (*statfmt == FMT_POUND)
499 				flags |= FLAG_POUND;
500 			else if (*statfmt == FMT_SPACE)
501 				flags |= FLAG_SPACE;
502 			else if (*statfmt == FMT_PLUS)
503 				flags |= FLAG_PLUS;
504 			else if (*statfmt == FMT_ZERO)
505 				flags |= FLAG_ZERO;
506 			else if (*statfmt == FMT_MINUS)
507 				flags |= FLAG_MINUS;
508 			else
509 				break;
510 			statfmt++;
511 		} while (1/*CONSTCOND*/);
512 
513 		size = -1;
514 		if (isdigit((unsigned)*statfmt)) {
515 			size = 0;
516 			while (isdigit((unsigned)*statfmt)) {
517 				size = (size * 10) + (*statfmt - '0');
518 				statfmt++;
519 				if (size < 0)
520 					goto badfmt;
521 			}
522 		}
523 
524 		prec = -1;
525 		if (*statfmt == FMT_DOT) {
526 			statfmt++;
527 
528 			prec = 0;
529 			while (isdigit((unsigned)*statfmt)) {
530 				prec = (prec * 10) + (*statfmt - '0');
531 				statfmt++;
532 				if (prec < 0)
533 					goto badfmt;
534 			}
535 		}
536 
537 #define fmtcase(x, y)		case (y): (x) = (y); statfmt++; break
538 #define fmtcasef(x, y, z)	case (y): (x) = (z); statfmt++; break
539 		switch (*statfmt) {
540 			fmtcasef(ofmt, FMT_DECIMAL,	FMTF_DECIMAL);
541 			fmtcasef(ofmt, FMT_OCTAL,	FMTF_OCTAL);
542 			fmtcasef(ofmt, FMT_UNSIGNED,	FMTF_UNSIGNED);
543 			fmtcasef(ofmt, FMT_HEX,		FMTF_HEX);
544 			fmtcasef(ofmt, FMT_FLOAT,	FMTF_FLOAT);
545 			fmtcasef(ofmt, FMT_STRING,	FMTF_STRING);
546 		default:
547 			ofmt = 0;
548 			break;
549 		}
550 
551 		switch (*statfmt) {
552 			fmtcase(hilo, HIGH_PIECE);
553 			fmtcase(hilo, MIDDLE_PIECE);
554 			fmtcase(hilo, LOW_PIECE);
555 		default:
556 			hilo = 0;
557 			break;
558 		}
559 
560 		switch (*statfmt) {
561 			fmtcase(what, SHOW_realpath);
562 			fmtcase(what, SHOW_st_dev);
563 			fmtcase(what, SHOW_st_ino);
564 			fmtcase(what, SHOW_st_mode);
565 			fmtcase(what, SHOW_st_nlink);
566 			fmtcase(what, SHOW_st_uid);
567 			fmtcase(what, SHOW_st_gid);
568 			fmtcase(what, SHOW_st_rdev);
569 			fmtcase(what, SHOW_st_atime);
570 			fmtcase(what, SHOW_st_mtime);
571 			fmtcase(what, SHOW_st_ctime);
572 			fmtcase(what, SHOW_st_btime);
573 			fmtcase(what, SHOW_st_size);
574 			fmtcase(what, SHOW_st_blocks);
575 			fmtcase(what, SHOW_st_blksize);
576 			fmtcase(what, SHOW_st_flags);
577 			fmtcase(what, SHOW_st_gen);
578 			fmtcase(what, SHOW_symlink);
579 			fmtcase(what, SHOW_filetype);
580 			fmtcase(what, SHOW_filename);
581 			fmtcase(what, SHOW_sizerdev);
582 		default:
583 			goto badfmt;
584 		}
585 #undef fmtcasef
586 #undef fmtcase
587 
588 		t = format1(st,
589 		     file,
590 		     subfmt, statfmt - subfmt,
591 		     buf, sizeof(buf),
592 		     flags, size, prec, ofmt, hilo, what);
593 
594 		for (i = 0; i < t && i < (int)(sizeof(buf) - 1); i++)
595 			addchar(stdout, buf[i], &nl);
596 
597 		continue;
598 
599 	badfmt:
600 		errx(1, "%.*s: bad format",
601 		    (int)(statfmt - subfmt + 1), subfmt);
602 	}
603 
604 	if (!nl && !nonl)
605 		(void)fputc('\n', stdout);
606 	(void)fflush(stdout);
607 }
608 
609 /*
610  * Arranges output according to a single parsed format substring.
611  */
612 int
613 format1(const struct stat *st,
614     const char *file,
615     const char *fmt, int flen,
616     char *buf, size_t blen,
617     int flags, int size, int prec, int ofmt,
618     int hilo, int what)
619 {
620 	u_int64_t data;
621 	char *stmp, lfmt[24], tmp[20];
622 	const char *sdata;
623 	char smode[12], sid[12], path[PATH_MAX + 4];
624 	const struct timespec *tsp;
625 	struct timespec ts;
626 	struct tm *tm;
627 	int l, small, formats;
628 
629 	tsp = NULL;
630 	formats = 0;
631 	small = 0;
632 
633 	/*
634 	 * First, pick out the data and tweak it based on hilo or
635 	 * specified output format (symlink output only).
636 	 */
637 	switch (what) {
638 	case SHOW_st_dev:
639 	case SHOW_st_rdev:
640 		small = (sizeof(st->st_dev) == 4);
641 		data = (what == SHOW_st_dev) ? st->st_dev : st->st_rdev;
642 #if HAVE_DEVNAME
643 		sdata = devname(what == SHOW_st_dev ? st->st_dev :
644 		    st->st_rdev, S_ISCHR(st->st_mode) ? S_IFCHR :
645 		    (S_ISBLK(st->st_mode) ? S_IFBLK : 0));
646 #endif /* HAVE_DEVNAME */
647 		if (hilo == HIGH_PIECE) {
648 			data = major(data);
649 			hilo = 0;
650 		}
651 		else if (hilo == LOW_PIECE) {
652 			data = minor((unsigned)data);
653 			hilo = 0;
654 		}
655 		formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX |
656 #if HAVE_DEVNAME
657 		    FMTF_STRING;
658 #else /* HAVE_DEVNAME */
659 		    0;
660 #endif /* HAVE_DEVNAME */
661 		if (ofmt == 0)
662 			ofmt = FMTF_UNSIGNED;
663 		break;
664 	case SHOW_st_ino:
665 		small = (sizeof(st->st_ino) == 4);
666 		data = st->st_ino;
667 		sdata = NULL;
668 		formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX;
669 		if (ofmt == 0)
670 			ofmt = FMTF_UNSIGNED;
671 		break;
672 	case SHOW_st_mode:
673 		small = (sizeof(st->st_mode) == 4);
674 		data = st->st_mode;
675 		strmode(st->st_mode, smode);
676 		stmp = smode;
677 		l = strlen(stmp);
678 		if (stmp[l - 1] == ' ')
679 			stmp[--l] = '\0';
680 		if (hilo == HIGH_PIECE) {
681 			data >>= 12;
682 			stmp += 1;
683 			stmp[3] = '\0';
684 			hilo = 0;
685 		}
686 		else if (hilo == MIDDLE_PIECE) {
687 			data = (data >> 9) & 07;
688 			stmp += 4;
689 			stmp[3] = '\0';
690 			hilo = 0;
691 		}
692 		else if (hilo == LOW_PIECE) {
693 			data &= 0777;
694 			stmp += 7;
695 			stmp[3] = '\0';
696 			hilo = 0;
697 		}
698 		sdata = stmp;
699 		formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX |
700 		    FMTF_STRING;
701 		if (ofmt == 0)
702 			ofmt = FMTF_OCTAL;
703 		break;
704 	case SHOW_st_nlink:
705 		small = (sizeof(st->st_dev) == 4);
706 		data = st->st_nlink;
707 		sdata = NULL;
708 		formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX;
709 		if (ofmt == 0)
710 			ofmt = FMTF_UNSIGNED;
711 		break;
712 	case SHOW_st_uid:
713 		small = (sizeof(st->st_uid) == 4);
714 		data = st->st_uid;
715 		sdata = user_from_uid(st->st_uid, 1);
716 		if (sdata == NULL) {
717 			snprintf(sid, sizeof(sid), "(%ld)", (long)st->st_uid);
718 			sdata = sid;
719 		}
720 		formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX |
721 		    FMTF_STRING;
722 		if (ofmt == 0)
723 			ofmt = FMTF_UNSIGNED;
724 		break;
725 	case SHOW_st_gid:
726 		small = (sizeof(st->st_gid) == 4);
727 		data = st->st_gid;
728 		sdata = group_from_gid(st->st_gid, 1);
729 		if (sdata == NULL) {
730 			snprintf(sid, sizeof(sid), "(%ld)", (long)st->st_gid);
731 			sdata = sid;
732 		}
733 		formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX |
734 		    FMTF_STRING;
735 		if (ofmt == 0)
736 			ofmt = FMTF_UNSIGNED;
737 		break;
738 	case SHOW_st_atime:
739 		tsp = &st->st_atimespec;
740 		/* FALLTHROUGH */
741 	case SHOW_st_mtime:
742 		if (tsp == NULL)
743 			tsp = &st->st_mtimespec;
744 		/* FALLTHROUGH */
745 	case SHOW_st_ctime:
746 		if (tsp == NULL)
747 			tsp = &st->st_ctimespec;
748 		/* FALLTHROUGH */
749 #if HAVE_STRUCT_STAT_ST_BIRTHTIME
750 	case SHOW_st_btime:
751 		if (tsp == NULL)
752 			tsp = &st->st_birthtimespec;
753 #endif /* HAVE_STRUCT_STAT_ST_BIRTHTIME */
754 		ts = *tsp;		/* copy so we can muck with it */
755 		small = (sizeof(ts.tv_sec) == 4);
756 		data = ts.tv_sec;
757 		tm = localtime(&ts.tv_sec);
758 		if (tm == NULL) {
759 			ts.tv_sec = 0;
760 			tm = localtime(&ts.tv_sec);
761 		}
762 		(void)setlocale(LC_TIME, "");
763 		(void)strftime(path, sizeof(path), timefmt, tm);
764 		sdata = path;
765 		formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX |
766 		    FMTF_FLOAT | FMTF_STRING;
767 		if (ofmt == 0)
768 			ofmt = FMTF_DECIMAL;
769 		break;
770 	case SHOW_st_size:
771 		small = (sizeof(st->st_size) == 4);
772 		data = st->st_size;
773 		sdata = NULL;
774 		formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX;
775 		if (ofmt == 0)
776 			ofmt = FMTF_UNSIGNED;
777 		break;
778 	case SHOW_st_blocks:
779 		small = (sizeof(st->st_blocks) == 4);
780 		data = st->st_blocks;
781 		sdata = NULL;
782 		formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX;
783 		if (ofmt == 0)
784 			ofmt = FMTF_UNSIGNED;
785 		break;
786 	case SHOW_st_blksize:
787 		small = (sizeof(st->st_blksize) == 4);
788 		data = st->st_blksize;
789 		sdata = NULL;
790 		formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX;
791 		if (ofmt == 0)
792 			ofmt = FMTF_UNSIGNED;
793 		break;
794 #if HAVE_STRUCT_STAT_ST_FLAGS
795 	case SHOW_st_flags:
796 		small = (sizeof(st->st_flags) == 4);
797 		data = st->st_flags;
798 		sdata = xfflagstostr(st->st_flags);
799 		if (*sdata == '\0')
800 			sdata = "-";
801 		formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX |
802 		    FMTF_STRING;
803 		if (ofmt == 0)
804 			ofmt = FMTF_UNSIGNED;
805 		break;
806 #endif /* HAVE_STRUCT_STAT_ST_FLAGS */
807 #if HAVE_STRUCT_STAT_ST_GEN
808 	case SHOW_st_gen:
809 		small = (sizeof(st->st_gen) == 4);
810 		data = st->st_gen;
811 		sdata = NULL;
812 		formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX;
813 		if (ofmt == 0)
814 			ofmt = FMTF_UNSIGNED;
815 		break;
816 #endif /* HAVE_STRUCT_STAT_ST_GEN */
817 	case SHOW_realpath:
818 		small = 0;
819 		data = 0;
820 		if (file == NULL) {
821 			(void)strlcpy(path, "(stdin)", sizeof(path));
822 			sdata = path;
823 		} else {
824 			snprintf(path, sizeof(path), " -> ");
825 			if (realpath(file, path + 4) == NULL) {
826 				linkfail = 1;
827 				l = 0;
828 				path[0] = '\0';
829 			}
830 			sdata = path + (ofmt == FMTF_STRING ? 0 : 4);
831 		}
832 
833 		formats = FMTF_STRING;
834 		if (ofmt == 0)
835 			ofmt = FMTF_STRING;
836 		break;
837 	case SHOW_symlink:
838 		small = 0;
839 		data = 0;
840 		if (S_ISLNK(st->st_mode)) {
841 			snprintf(path, sizeof(path), " -> ");
842 			l = readlink(file, path + 4, sizeof(path) - 4 - 1);
843 			if (l == -1) {
844 				linkfail = 1;
845 				l = 0;
846 				path[0] = '\0';
847 			}
848 			path[l + 4] = '\0';
849 			sdata = path + (ofmt == FMTF_STRING ? 0 : 4);
850 		}
851 		else {
852 			linkfail = 1;
853 			sdata = "";
854 		}
855 		formats = FMTF_STRING;
856 		if (ofmt == 0)
857 			ofmt = FMTF_STRING;
858 		break;
859 	case SHOW_filetype:
860 		small = 0;
861 		data = 0;
862 		sdata = "";
863 		if (hilo == 0 || hilo == LOW_PIECE) {
864 			switch (st->st_mode & S_IFMT) {
865 			case S_IFIFO:	sdata = "|";	break;
866 			case S_IFDIR:	sdata = "/";	break;
867 			case S_IFREG:
868 				if (st->st_mode &
869 				    (S_IXUSR | S_IXGRP | S_IXOTH))
870 					sdata = "*";
871 				break;
872 			case S_IFLNK:	sdata = "@";	break;
873 			case S_IFSOCK:	sdata = "=";	break;
874 #ifdef S_IFWHT
875 			case S_IFWHT:	sdata = "%";	break;
876 #endif /* S_IFWHT */
877 #ifdef S_IFDOOR
878 			case S_IFDOOR:	sdata = ">";	break;
879 #endif /* S_IFDOOR */
880 			}
881 			hilo = 0;
882 		}
883 		else if (hilo == HIGH_PIECE) {
884 			switch (st->st_mode & S_IFMT) {
885 			case S_IFIFO:	sdata = "Fifo File";		break;
886 			case S_IFCHR:	sdata = "Character Device";	break;
887 			case S_IFDIR:	sdata = "Directory";		break;
888 			case S_IFBLK:	sdata = "Block Device";		break;
889 			case S_IFREG:	sdata = "Regular File";		break;
890 			case S_IFLNK:	sdata = "Symbolic Link";	break;
891 			case S_IFSOCK:	sdata = "Socket";		break;
892 #ifdef S_IFWHT
893 			case S_IFWHT:	sdata = "Whiteout File";	break;
894 #endif /* S_IFWHT */
895 #ifdef S_IFDOOR
896 			case S_IFDOOR:	sdata = "Door";			break;
897 #endif /* S_IFDOOR */
898 			default:	sdata = "???";			break;
899 			}
900 			hilo = 0;
901 		}
902 		formats = FMTF_STRING;
903 		if (ofmt == 0)
904 			ofmt = FMTF_STRING;
905 		break;
906 	case SHOW_filename:
907 		small = 0;
908 		data = 0;
909 		(void)strlcpy(path, file, sizeof(path));
910 		sdata = path;
911 		formats = FMTF_STRING;
912 		if (ofmt == 0)
913 			ofmt = FMTF_STRING;
914 		break;
915 	case SHOW_sizerdev:
916 		if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode)) {
917 			char majdev[20], mindev[20];
918 			int l1, l2;
919 
920 			l1 = format1(st,
921 			    file,
922 			    fmt, flen,
923 			    majdev, sizeof(majdev),
924 			    flags, size, prec,
925 			    ofmt, HIGH_PIECE, SHOW_st_rdev);
926 			l2 = format1(st,
927 			    file,
928 			    fmt, flen,
929 			    mindev, sizeof(mindev),
930 			    flags, size, prec,
931 			    ofmt, LOW_PIECE, SHOW_st_rdev);
932 			return (snprintf(buf, blen, "%.*s,%.*s",
933 			    l1, majdev, l2, mindev));
934 		}
935 		else {
936 			return (format1(st,
937 			    file,
938 			    fmt, flen,
939 			    buf, blen,
940 			    flags, size, prec,
941 			    ofmt, 0, SHOW_st_size));
942 		}
943 		/*NOTREACHED*/
944 	default:
945 		errx(1, "%.*s: bad format", (int)flen, fmt);
946 	}
947 
948 	/*
949 	 * If a subdatum was specified but not supported, or an output
950 	 * format was selected that is not supported, that's an error.
951 	 */
952 	if (hilo != 0 || (ofmt & formats) == 0)
953 		errx(1, "%.*s: bad format", (int)flen, fmt);
954 
955 	/*
956 	 * Assemble the format string for passing to printf(3).
957 	 */
958 	lfmt[0] = '\0';
959 	(void)strcat(lfmt, "%");
960 	if (flags & FLAG_POUND)
961 		(void)strcat(lfmt, "#");
962 	if (flags & FLAG_SPACE)
963 		(void)strcat(lfmt, " ");
964 	if (flags & FLAG_PLUS)
965 		(void)strcat(lfmt, "+");
966 	if (flags & FLAG_MINUS)
967 		(void)strcat(lfmt, "-");
968 	if (flags & FLAG_ZERO)
969 		(void)strcat(lfmt, "0");
970 
971 	/*
972 	 * Only the timespecs support the FLOAT output format, and that
973 	 * requires work that differs from the other formats.
974 	 */
975 	if (ofmt == FMTF_FLOAT) {
976 		/*
977 		 * Nothing after the decimal point, so just print seconds.
978 		 */
979 		if (prec == 0) {
980 			if (size != -1) {
981 				(void)snprintf(tmp, sizeof(tmp), "%d", size);
982 				(void)strcat(lfmt, tmp);
983 			}
984 			(void)strcat(lfmt, "lld");
985 			return (snprintf(buf, blen, lfmt,
986 			    (long long)ts.tv_sec));
987 		}
988 
989 		/*
990 		 * Unspecified precision gets all the precision we have:
991 		 * 9 digits.
992 		 */
993 		if (prec == -1)
994 			prec = 9;
995 
996 		/*
997 		 * Adjust the size for the decimal point and the digits
998 		 * that will follow.
999 		 */
1000 		size -= prec + 1;
1001 
1002 		/*
1003 		 * Any leftover size that's legitimate will be used.
1004 		 */
1005 		if (size > 0) {
1006 			(void)snprintf(tmp, sizeof(tmp), "%d", size);
1007 			(void)strcat(lfmt, tmp);
1008 		}
1009 		/* Seconds: time_t cast to long long. */
1010 		(void)strcat(lfmt, "lld");
1011 
1012 		/*
1013 		 * The stuff after the decimal point always needs zero
1014 		 * filling.
1015 		 */
1016 		(void)strcat(lfmt, ".%0");
1017 
1018 		/*
1019 		 * We can "print" at most nine digits of precision.  The
1020 		 * rest we will pad on at the end.
1021 		 *
1022 		 * Nanoseconds: long.
1023 		 */
1024 		(void)snprintf(tmp, sizeof(tmp), "%dld", MIN(prec, 9));
1025 		(void)strcat(lfmt, tmp);
1026 
1027 		/*
1028 		 * For precision of less that nine digits, trim off the
1029 		 * less significant figures.
1030 		 */
1031 		for (; prec < 9; prec++)
1032 			ts.tv_nsec /= 10;
1033 
1034 		/*
1035 		 * Use the format, and then tack on any zeroes that
1036 		 * might be required to make up the requested precision.
1037 		 */
1038 		l = snprintf(buf, blen, lfmt, (long long)ts.tv_sec, ts.tv_nsec);
1039 		for (; prec > 9 && l < (int)blen; prec--, l++)
1040 			(void)strcat(buf, "0");
1041 		return (l);
1042 	}
1043 
1044 	/*
1045 	 * Add on size and precision, if specified, to the format.
1046 	 */
1047 	if (size != -1) {
1048 		(void)snprintf(tmp, sizeof(tmp), "%d", size);
1049 		(void)strcat(lfmt, tmp);
1050 	}
1051 	if (prec != -1) {
1052 		(void)snprintf(tmp, sizeof(tmp), ".%d", prec);
1053 		(void)strcat(lfmt, tmp);
1054 	}
1055 
1056 	/*
1057 	 * String output uses the temporary sdata.
1058 	 */
1059 	if (ofmt == FMTF_STRING) {
1060 		if (sdata == NULL)
1061 			errx(1, "%.*s: bad format", (int)flen, fmt);
1062 		(void)strcat(lfmt, "s");
1063 		return (snprintf(buf, blen, lfmt, sdata));
1064 	}
1065 
1066 	/*
1067 	 * Ensure that sign extension does not cause bad looking output
1068 	 * for some forms.
1069 	 */
1070 	if (small && ofmt != FMTF_DECIMAL)
1071 		data = (u_int32_t)data;
1072 
1073 	/*
1074 	 * The four "numeric" output forms.
1075 	 */
1076 	(void)strcat(lfmt, "ll");
1077 	switch (ofmt) {
1078 	case FMTF_DECIMAL:	(void)strcat(lfmt, "d");	break;
1079 	case FMTF_OCTAL:		(void)strcat(lfmt, "o");	break;
1080 	case FMTF_UNSIGNED:	(void)strcat(lfmt, "u");	break;
1081 	case FMTF_HEX:		(void)strcat(lfmt, "x");	break;
1082 	}
1083 
1084 	return (snprintf(buf, blen, lfmt, data));
1085 }
1086 
1087 
1088 #define hex2nibble(c) (c <= '9' ? c - '0' : toupper(c) - 'A' + 10)
1089 int
1090 hex2byte(const char c[2]) {
1091 	if (!(ishexnumber(c[0]) && ishexnumber(c[1])))
1092 		return -1;
1093 	return (hex2nibble(c[0]) << 4) + hex2nibble(c[1]);
1094 }
1095