xref: /freebsd/bin/ls/ls.c (revision 994297b01b98816bea1abf45ae4bac1bc69ee7a0)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 1989, 1993, 1994
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * Michael Fischbein.
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  * 3. Neither the name of the University nor the names of its contributors
19  *    may be used to endorse or promote products derived from this software
20  *    without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34 
35 #ifndef lint
36 static const char copyright[] =
37 "@(#) Copyright (c) 1989, 1993, 1994\n\
38 	The Regents of the University of California.  All rights reserved.\n";
39 #endif /* not lint */
40 
41 #if 0
42 #ifndef lint
43 static char sccsid[] = "@(#)ls.c	8.5 (Berkeley) 4/2/94";
44 #endif /* not lint */
45 #endif
46 #include <sys/cdefs.h>
47 __FBSDID("$FreeBSD$");
48 
49 #include <sys/param.h>
50 #include <sys/stat.h>
51 #include <sys/ioctl.h>
52 #include <sys/mac.h>
53 
54 #include <ctype.h>
55 #include <dirent.h>
56 #include <err.h>
57 #include <errno.h>
58 #include <fts.h>
59 #include <getopt.h>
60 #include <grp.h>
61 #include <inttypes.h>
62 #include <limits.h>
63 #include <locale.h>
64 #include <pwd.h>
65 #include <stdbool.h>
66 #include <stdio.h>
67 #include <stdlib.h>
68 #include <string.h>
69 #include <unistd.h>
70 #ifdef COLORLS
71 #include <termcap.h>
72 #include <signal.h>
73 #endif
74 
75 #include "ls.h"
76 #include "extern.h"
77 
78 /*
79  * Upward approximation of the maximum number of characters needed to
80  * represent a value of integral type t as a string, excluding the
81  * NUL terminator, with provision for a sign.
82  */
83 #define	STRBUF_SIZEOF(t)	(1 + CHAR_BIT * sizeof(t) / 3 + 1)
84 
85 /*
86  * MAKENINES(n) turns n into (10**n)-1.  This is useful for converting a width
87  * into a number that wide in decimal.
88  * XXX: Overflows are not considered.
89  */
90 #define MAKENINES(n)							\
91 	do {								\
92 		intmax_t __i;						\
93 									\
94 		/* Use a loop as all values of n are small. */		\
95 		for (__i = 1; n > 0; __i *= 10)				\
96 			n--;						\
97 		n = __i - 1;						\
98 	} while(0)
99 
100 static void	 display(const FTSENT *, FTSENT *, int);
101 static int	 mastercmp(const FTSENT * const *, const FTSENT * const *);
102 static void	 traverse(int, char **, int);
103 
104 #define	COLOR_OPT	(CHAR_MAX + 1)
105 
106 static const struct option long_opts[] =
107 {
108         {"color",       optional_argument,      NULL, COLOR_OPT},
109         {NULL,          no_argument,            NULL, 0}
110 };
111 
112 static void (*printfcn)(const DISPLAY *);
113 static int (*sortfcn)(const FTSENT *, const FTSENT *);
114 
115 long blocksize;			/* block size units */
116 int termwidth = 80;		/* default terminal width */
117 
118 /* flags */
119        int f_accesstime;	/* use time of last access */
120        int f_birthtime;		/* use time of birth */
121        int f_flags;		/* show flags associated with a file */
122        int f_humanval;		/* show human-readable file sizes */
123        int f_inode;		/* print inode */
124 static int f_kblocks;		/* print size in kilobytes */
125        int f_label;		/* show MAC label */
126 static int f_listdir;		/* list actual directory, not contents */
127 static int f_listdot;		/* list files beginning with . */
128        int f_longform;		/* long listing format */
129 static int f_noautodot;		/* do not automatically enable -A for root */
130 static int f_nofollow;		/* don't follow symbolic link arguments */
131        int f_nonprint;		/* show unprintables as ? */
132 static int f_nosort;		/* don't sort output */
133        int f_notabs;		/* don't use tab-separated multi-col output */
134 static int f_numericonly;	/* don't convert uid/gid to name */
135        int f_octal;		/* show unprintables as \xxx */
136        int f_octal_escape;	/* like f_octal but use C escapes if possible */
137 static int f_recursive;		/* ls subdirectories also */
138 static int f_reversesort;	/* reverse whatever sort is used */
139        int f_samesort;		/* sort time and name in same direction */
140        int f_sectime;		/* print full time information */
141 static int f_singlecol;		/* use single column output */
142        int f_size;		/* list size in short listing */
143 static int f_sizesort;
144        int f_slash;		/* similar to f_type, but only for dirs */
145        int f_sortacross;	/* sort across rows, not down columns */
146        int f_statustime;	/* use time of last mode change */
147 static int f_stream;		/* stream the output, separate with commas */
148        int f_thousands;		/* show file sizes with thousands separators */
149        char *f_timeformat;	/* user-specified time format */
150 static int f_timesort;		/* sort by time vice name */
151        int f_type;		/* add type character for non-regular files */
152 static int f_whiteout;		/* show whiteout entries */
153 #ifdef COLORLS
154        int colorflag = COLORFLAG_NEVER;		/* passed in colorflag */
155        int f_color;		/* add type in color for non-regular files */
156        bool explicitansi;	/* Explicit ANSI sequences, no termcap(5) */
157 char *ansi_bgcol;		/* ANSI sequence to set background colour */
158 char *ansi_fgcol;		/* ANSI sequence to set foreground colour */
159 char *ansi_coloff;		/* ANSI sequence to reset colours */
160 char *attrs_off;		/* ANSI sequence to turn off attributes */
161 char *enter_bold;		/* ANSI sequence to set color to bold mode */
162 char *enter_underline;		/* ANSI sequence to enter underline mode */
163 #endif
164 
165 static int rval;
166 
167 static bool
168 do_color_from_env(void)
169 {
170 	const char *p;
171 	bool doit;
172 
173 	doit = false;
174 	p = getenv("CLICOLOR");
175 	if (p == NULL) {
176 		/*
177 		 * COLORTERM is the more standard name for this variable.  We'll
178 		 * honor it as long as it's both set and not empty.
179 		 */
180 		p = getenv("COLORTERM");
181 		if (p != NULL && *p != '\0')
182 			doit = true;
183 	} else
184 		doit = true;
185 
186 	return (doit &&
187 	    (isatty(STDOUT_FILENO) || getenv("CLICOLOR_FORCE")));
188 }
189 
190 static bool
191 do_color(void)
192 {
193 
194 #ifdef COLORLS
195 	if (colorflag == COLORFLAG_NEVER)
196 		return (false);
197 	else if (colorflag == COLORFLAG_ALWAYS)
198 		return (true);
199 #endif
200 	return (do_color_from_env());
201 }
202 
203 #ifdef COLORLS
204 static bool
205 do_color_always(const char *term)
206 {
207 
208 	return (strcmp(term, "always") == 0 || strcmp(term, "yes") == 0 ||
209 	    strcmp(term, "force") == 0);
210 }
211 
212 static bool
213 do_color_never(const char *term)
214 {
215 
216 	return (strcmp(term, "never") == 0 || strcmp(term, "no") == 0 ||
217 	    strcmp(term, "none") == 0);
218 }
219 
220 static bool
221 do_color_auto(const char *term)
222 {
223 
224 	return (strcmp(term, "auto") == 0 || strcmp(term, "tty") == 0 ||
225 	    strcmp(term, "if-tty") == 0);
226 }
227 #endif	/* COLORLS */
228 
229 int
230 main(int argc, char *argv[])
231 {
232 	static char dot[] = ".", *dotav[] = {dot, NULL};
233 	struct winsize win;
234 	int ch, fts_options, notused;
235 	char *p;
236 	const char *errstr = NULL;
237 #ifdef COLORLS
238 	char termcapbuf[1024];	/* termcap definition buffer */
239 	char tcapbuf[512];	/* capability buffer */
240 	char *bp = tcapbuf, *term;
241 #endif
242 
243 	(void)setlocale(LC_ALL, "");
244 
245 	/* Terminal defaults to -Cq, non-terminal defaults to -1. */
246 	if (isatty(STDOUT_FILENO)) {
247 		termwidth = 80;
248 		if ((p = getenv("COLUMNS")) != NULL && *p != '\0')
249 			termwidth = strtonum(p, 0, INT_MAX, &errstr);
250 		else if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) != -1 &&
251 		    win.ws_col > 0)
252 			termwidth = win.ws_col;
253 		f_nonprint = 1;
254 	} else {
255 		f_singlecol = 1;
256 		/* retrieve environment variable, in case of explicit -C */
257 		p = getenv("COLUMNS");
258 		if (p)
259 			termwidth = strtonum(p, 0, INT_MAX, &errstr);
260 	}
261 
262 	if (errstr)
263 		termwidth = 80;
264 
265 	fts_options = FTS_PHYSICAL;
266 	if (getenv("LS_SAMESORT"))
267 		f_samesort = 1;
268 
269 	/*
270 	 * For historical compatibility, we'll use our autodetection if CLICOLOR
271 	 * is set.
272 	 */
273 #ifdef COLORLS
274 	if (getenv("CLICOLOR"))
275 		colorflag = COLORFLAG_AUTO;
276 #endif
277 	while ((ch = getopt_long(argc, argv,
278 	    "+1ABCD:FGHILPRSTUWXZabcdfghiklmnopqrstuwxy,", long_opts,
279 	    NULL)) != -1) {
280 		switch (ch) {
281 		/*
282 		 * The -1, -C, -x and -l options all override each other so
283 		 * shell aliasing works right.
284 		 */
285 		case '1':
286 			f_singlecol = 1;
287 			f_longform = 0;
288 			f_stream = 0;
289 			break;
290 		case 'C':
291 			f_sortacross = f_longform = f_singlecol = 0;
292 			break;
293 		case 'l':
294 			f_longform = 1;
295 			f_singlecol = 0;
296 			f_stream = 0;
297 			break;
298 		case 'x':
299 			f_sortacross = 1;
300 			f_longform = 0;
301 			f_singlecol = 0;
302 			break;
303 		/* The -c, -u, and -U options override each other. */
304 		case 'c':
305 			f_statustime = 1;
306 			f_accesstime = 0;
307 			f_birthtime = 0;
308 			break;
309 		case 'u':
310 			f_accesstime = 1;
311 			f_statustime = 0;
312 			f_birthtime = 0;
313 			break;
314 		case 'U':
315 			f_birthtime = 1;
316 			f_accesstime = 0;
317 			f_statustime = 0;
318 			break;
319 		case 'f':
320 			f_nosort = 1;
321 		       /* FALLTHROUGH */
322 		case 'a':
323 			fts_options |= FTS_SEEDOT;
324 			/* FALLTHROUGH */
325 		case 'A':
326 			f_listdot = 1;
327 			break;
328 		/* The -t and -S options override each other. */
329 		case 'S':
330 			f_sizesort = 1;
331 			f_timesort = 0;
332 			break;
333 		case 't':
334 			f_timesort = 1;
335 			f_sizesort = 0;
336 			break;
337 		/* Other flags.  Please keep alphabetic. */
338 		case ',':
339 			f_thousands = 1;
340 			break;
341 		case 'B':
342 			f_nonprint = 0;
343 			f_octal = 1;
344 			f_octal_escape = 0;
345 			break;
346 		case 'D':
347 			f_timeformat = optarg;
348 			break;
349 		case 'F':
350 			f_type = 1;
351 			f_slash = 0;
352 			break;
353 		case 'G':
354 			/*
355 			 * We both set CLICOLOR here and set colorflag to
356 			 * COLORFLAG_AUTO, because -G should not force color if
357 			 * stdout isn't a tty.
358 			 */
359 			setenv("CLICOLOR", "", 1);
360 #ifdef COLORLS
361 			colorflag = COLORFLAG_AUTO;
362 #endif
363 			break;
364 		case 'H':
365 			fts_options |= FTS_COMFOLLOW;
366 			f_nofollow = 0;
367 			break;
368 		case 'I':
369 			f_noautodot = 1;
370 			break;
371 		case 'L':
372 			fts_options &= ~FTS_PHYSICAL;
373 			fts_options |= FTS_LOGICAL;
374 			f_nofollow = 0;
375 			break;
376 		case 'P':
377 			fts_options &= ~FTS_COMFOLLOW;
378 			fts_options &= ~FTS_LOGICAL;
379 			fts_options |= FTS_PHYSICAL;
380 			f_nofollow = 1;
381 			break;
382 		case 'R':
383 			f_recursive = 1;
384 			break;
385 		case 'T':
386 			f_sectime = 1;
387 			break;
388 		case 'W':
389 			f_whiteout = 1;
390 			break;
391 		case 'Z':
392 			f_label = 1;
393 			break;
394 		case 'b':
395 			f_nonprint = 0;
396 			f_octal = 0;
397 			f_octal_escape = 1;
398 			break;
399 		/* The -d option turns off the -R option. */
400 		case 'd':
401 			f_listdir = 1;
402 			f_recursive = 0;
403 			break;
404 		case 'g':	/* Compatibility with 4.3BSD. */
405 			break;
406 		case 'h':
407 			f_humanval = 1;
408 			break;
409 		case 'i':
410 			f_inode = 1;
411 			break;
412 		case 'k':
413 			f_humanval = 0;
414 			f_kblocks = 1;
415 			break;
416 		case 'm':
417 			f_stream = 1;
418 			f_singlecol = 0;
419 			f_longform = 0;
420 			break;
421 		case 'n':
422 			f_numericonly = 1;
423 			break;
424 		case 'o':
425 			f_flags = 1;
426 			break;
427 		case 'p':
428 			f_slash = 1;
429 			f_type = 1;
430 			break;
431 		case 'q':
432 			f_nonprint = 1;
433 			f_octal = 0;
434 			f_octal_escape = 0;
435 			break;
436 		case 'r':
437 			f_reversesort = 1;
438 			break;
439 		case 's':
440 			f_size = 1;
441 			break;
442 		case 'w':
443 			f_nonprint = 0;
444 			f_octal = 0;
445 			f_octal_escape = 0;
446 			break;
447 		case 'y':
448 			f_samesort = 1;
449 			break;
450 		case COLOR_OPT:
451 #ifdef COLORLS
452 			if (optarg == NULL || do_color_always(optarg))
453 				colorflag = COLORFLAG_ALWAYS;
454 			else if (do_color_auto(optarg))
455 				colorflag = COLORFLAG_AUTO;
456 			else if (do_color_never(optarg))
457 				colorflag = COLORFLAG_NEVER;
458 			else
459 				errx(2, "unsupported --color value '%s' (must be always, auto, or never)",
460 				    optarg);
461 			break;
462 #else
463 			warnx("color support not compiled in");
464 #endif
465 		default:
466 		case '?':
467 			usage();
468 		}
469 	}
470 	argc -= optind;
471 	argv += optind;
472 
473 	/* Root is -A automatically unless -I. */
474 	if (!f_listdot && getuid() == (uid_t)0 && !f_noautodot)
475 		f_listdot = 1;
476 
477 	/*
478 	 * Enabling of colours is conditional on the environment in conjunction
479 	 * with the --color and -G arguments, if supplied.
480 	 */
481 	if (do_color()) {
482 #ifdef COLORLS
483 		if ((term = getenv("TERM")) != NULL &&
484 		    tgetent(termcapbuf, term) == 1) {
485 			ansi_fgcol = tgetstr("AF", &bp);
486 			ansi_bgcol = tgetstr("AB", &bp);
487 			attrs_off = tgetstr("me", &bp);
488 			enter_bold = tgetstr("md", &bp);
489 			enter_underline = tgetstr("us", &bp);
490 
491 			/* To switch colours off use 'op' if
492 			 * available, otherwise use 'oc', or
493 			 * don't do colours at all. */
494 			ansi_coloff = tgetstr("op", &bp);
495 			if (!ansi_coloff)
496 				ansi_coloff = tgetstr("oc", &bp);
497 			if (ansi_fgcol && ansi_bgcol && ansi_coloff)
498 				f_color = 1;
499 		} else if (colorflag == COLORFLAG_ALWAYS) {
500 			/*
501 			 * If we're *always* doing color but we don't have
502 			 * a functional TERM supplied, we'll fallback to
503 			 * outputting raw ANSI sequences.
504 			 */
505 			f_color = 1;
506 			explicitansi = true;
507 		}
508 #endif /*COLORLS*/
509 	}
510 
511 #ifdef COLORLS
512 	if (f_color) {
513 		/*
514 		 * We can't put tabs and color sequences together:
515 		 * column number will be incremented incorrectly
516 		 * for "stty oxtabs" mode.
517 		 */
518 		f_notabs = 1;
519 		(void)signal(SIGINT, colorquit);
520 		(void)signal(SIGQUIT, colorquit);
521 		parsecolors(getenv("LSCOLORS"));
522 	}
523 #endif
524 
525 	/*
526 	 * If not -F, -i, -l, -s, -S or -t options, don't require stat
527 	 * information, unless in color mode in which case we do
528 	 * need this to determine which colors to display.
529 	 */
530 	if (!f_inode && !f_longform && !f_size && !f_timesort &&
531 	    !f_sizesort && !f_type
532 #ifdef COLORLS
533 	    && !f_color
534 #endif
535 	    )
536 		fts_options |= FTS_NOSTAT;
537 
538 	/*
539 	 * If not -F, -P, -d or -l options, follow any symbolic links listed on
540 	 * the command line, unless in color mode in which case we need to
541 	 * distinguish file type for a symbolic link itself and its target.
542 	 */
543 	if (!f_nofollow && !f_longform && !f_listdir && (!f_type || f_slash)
544 #ifdef COLORLS
545 	    && !f_color
546 #endif
547 	    )
548 		fts_options |= FTS_COMFOLLOW;
549 
550 	/*
551 	 * If -W, show whiteout entries
552 	 */
553 #ifdef FTS_WHITEOUT
554 	if (f_whiteout)
555 		fts_options |= FTS_WHITEOUT;
556 #endif
557 
558 	/* If -i, -l or -s, figure out block size. */
559 	if (f_inode || f_longform || f_size) {
560 		if (f_kblocks)
561 			blocksize = 2;
562 		else {
563 			(void)getbsize(&notused, &blocksize);
564 			blocksize /= 512;
565 		}
566 	}
567 	/* Select a sort function. */
568 	if (f_reversesort) {
569 		if (!f_timesort && !f_sizesort)
570 			sortfcn = revnamecmp;
571 		else if (f_sizesort)
572 			sortfcn = revsizecmp;
573 		else if (f_accesstime)
574 			sortfcn = revacccmp;
575 		else if (f_birthtime)
576 			sortfcn = revbirthcmp;
577 		else if (f_statustime)
578 			sortfcn = revstatcmp;
579 		else		/* Use modification time. */
580 			sortfcn = revmodcmp;
581 	} else {
582 		if (!f_timesort && !f_sizesort)
583 			sortfcn = namecmp;
584 		else if (f_sizesort)
585 			sortfcn = sizecmp;
586 		else if (f_accesstime)
587 			sortfcn = acccmp;
588 		else if (f_birthtime)
589 			sortfcn = birthcmp;
590 		else if (f_statustime)
591 			sortfcn = statcmp;
592 		else		/* Use modification time. */
593 			sortfcn = modcmp;
594 	}
595 
596 	/* Select a print function. */
597 	if (f_singlecol)
598 		printfcn = printscol;
599 	else if (f_longform)
600 		printfcn = printlong;
601 	else if (f_stream)
602 		printfcn = printstream;
603 	else
604 		printfcn = printcol;
605 
606 	if (argc)
607 		traverse(argc, argv, fts_options);
608 	else
609 		traverse(1, dotav, fts_options);
610 	exit(rval);
611 }
612 
613 static int output;		/* If anything output. */
614 
615 /*
616  * Traverse() walks the logical directory structure specified by the argv list
617  * in the order specified by the mastercmp() comparison function.  During the
618  * traversal it passes linked lists of structures to display() which represent
619  * a superset (may be exact set) of the files to be displayed.
620  */
621 static void
622 traverse(int argc, char *argv[], int options)
623 {
624 	FTS *ftsp;
625 	FTSENT *p, *chp;
626 	int ch_options;
627 
628 	if ((ftsp =
629 	    fts_open(argv, options, f_nosort ? NULL : mastercmp)) == NULL)
630 		err(1, "fts_open");
631 
632 	/*
633 	 * We ignore errors from fts_children here since they will be
634 	 * replicated and signalled on the next call to fts_read() below.
635 	 */
636 	chp = fts_children(ftsp, 0);
637 	if (chp != NULL)
638 		display(NULL, chp, options);
639 	if (f_listdir)
640 		return;
641 
642 	/*
643 	 * If not recursing down this tree and don't need stat info, just get
644 	 * the names.
645 	 */
646 	ch_options = !f_recursive && !f_label &&
647 	    options & FTS_NOSTAT ? FTS_NAMEONLY : 0;
648 
649 	while (errno = 0, (p = fts_read(ftsp)) != NULL)
650 		switch (p->fts_info) {
651 		case FTS_DC:
652 			warnx("%s: directory causes a cycle", p->fts_name);
653 			break;
654 		case FTS_DNR:
655 		case FTS_ERR:
656 			warnx("%s: %s", p->fts_path, strerror(p->fts_errno));
657 			rval = 1;
658 			break;
659 		case FTS_D:
660 			if (p->fts_level != FTS_ROOTLEVEL &&
661 			    p->fts_name[0] == '.' && !f_listdot)
662 				break;
663 
664 			/*
665 			 * If already output something, put out a newline as
666 			 * a separator.  If multiple arguments, precede each
667 			 * directory with its name.
668 			 */
669 			if (output) {
670 				putchar('\n');
671 				(void)printname(p->fts_path);
672 				puts(":");
673 			} else if (argc > 1) {
674 				(void)printname(p->fts_path);
675 				puts(":");
676 				output = 1;
677 			}
678 			chp = fts_children(ftsp, ch_options);
679 			display(p, chp, options);
680 
681 			if (!f_recursive && chp != NULL)
682 				(void)fts_set(ftsp, p, FTS_SKIP);
683 			break;
684 		default:
685 			break;
686 		}
687 	if (errno)
688 		err(1, "fts_read");
689 }
690 
691 /*
692  * Display() takes a linked list of FTSENT structures and passes the list
693  * along with any other necessary information to the print function.  P
694  * points to the parent directory of the display list.
695  */
696 static void
697 display(const FTSENT *p, FTSENT *list, int options)
698 {
699 	struct stat *sp;
700 	DISPLAY d;
701 	FTSENT *cur;
702 	NAMES *np;
703 	off_t maxsize;
704 	long maxblock;
705 	uintmax_t maxinode;
706 	u_long btotal, labelstrlen, maxlen, maxnlink;
707 	u_long maxlabelstr;
708 	u_int sizelen;
709 	int maxflags;
710 	gid_t maxgroup;
711 	uid_t maxuser;
712 	size_t flen, ulen, glen;
713 	char *initmax;
714 	int entries, needstats;
715 	const char *user, *group;
716 	char *flags, *labelstr = NULL;
717 	char ngroup[STRBUF_SIZEOF(uid_t) + 1];
718 	char nuser[STRBUF_SIZEOF(gid_t) + 1];
719 	u_long width[9];
720 	int i;
721 
722 	needstats = f_inode || f_longform || f_size;
723 	flen = 0;
724 	btotal = 0;
725 
726 #define LS_COLWIDTHS_FIELDS	9
727 	initmax = getenv("LS_COLWIDTHS");
728 
729 	for (i = 0 ; i < LS_COLWIDTHS_FIELDS; i++)
730 		width[i] = 0;
731 
732 	if (initmax != NULL) {
733 		char *endp;
734 
735 		for (i = 0; i < LS_COLWIDTHS_FIELDS && *initmax != '\0'; i++) {
736 			if (*initmax == ':') {
737 				width[i] = 0;
738 			} else {
739 				width[i] = strtoul(initmax, &endp, 10);
740 				initmax = endp;
741 				while (isspace(*initmax))
742 					initmax++;
743 				if (*initmax != ':')
744 					break;
745 				initmax++;
746 			}
747 		}
748 		if (i < LS_COLWIDTHS_FIELDS)
749 #ifdef COLORLS
750 			if (!f_color)
751 #endif
752 				f_notabs = 0;
753 	}
754 
755 	/* Fields match -lios order.  New ones should be added at the end. */
756 	maxinode = width[0];
757 	maxblock = width[1];
758 	maxnlink = width[2];
759 	maxuser = width[3];
760 	maxgroup = width[4];
761 	maxflags = width[5];
762 	maxsize = width[6];
763 	maxlen = width[7];
764 	maxlabelstr = width[8];
765 
766 	MAKENINES(maxinode);
767 	MAKENINES(maxblock);
768 	MAKENINES(maxnlink);
769 	MAKENINES(maxsize);
770 
771 	d.s_size = 0;
772 	sizelen = 0;
773 	flags = NULL;
774 	for (cur = list, entries = 0; cur; cur = cur->fts_link) {
775 		if (cur->fts_info == FTS_ERR || cur->fts_info == FTS_NS) {
776 			warnx("%s: %s",
777 			    cur->fts_name, strerror(cur->fts_errno));
778 			cur->fts_number = NO_PRINT;
779 			rval = 1;
780 			continue;
781 		}
782 		/*
783 		 * P is NULL if list is the argv list, to which different rules
784 		 * apply.
785 		 */
786 		if (p == NULL) {
787 			/* Directories will be displayed later. */
788 			if (cur->fts_info == FTS_D && !f_listdir) {
789 				cur->fts_number = NO_PRINT;
790 				continue;
791 			}
792 		} else {
793 			/* Only display dot file if -a/-A set. */
794 			if (cur->fts_name[0] == '.' && !f_listdot) {
795 				cur->fts_number = NO_PRINT;
796 				continue;
797 			}
798 		}
799 		if (cur->fts_namelen > maxlen)
800 			maxlen = cur->fts_namelen;
801 		if (f_octal || f_octal_escape) {
802 			u_long t = len_octal(cur->fts_name, cur->fts_namelen);
803 
804 			if (t > maxlen)
805 				maxlen = t;
806 		}
807 		if (needstats) {
808 			sp = cur->fts_statp;
809 			if (sp->st_blocks > maxblock)
810 				maxblock = sp->st_blocks;
811 			if (sp->st_ino > maxinode)
812 				maxinode = sp->st_ino;
813 			if (sp->st_nlink > maxnlink)
814 				maxnlink = sp->st_nlink;
815 			if (sp->st_size > maxsize)
816 				maxsize = sp->st_size;
817 
818 			btotal += sp->st_blocks;
819 			if (f_longform) {
820 				if (f_numericonly) {
821 					(void)snprintf(nuser, sizeof(nuser),
822 					    "%u", sp->st_uid);
823 					(void)snprintf(ngroup, sizeof(ngroup),
824 					    "%u", sp->st_gid);
825 					user = nuser;
826 					group = ngroup;
827 				} else {
828 					user = user_from_uid(sp->st_uid, 0);
829 					/*
830 					 * user_from_uid(..., 0) only returns
831 					 * NULL in OOM conditions.  We could
832 					 * format the uid here, but (1) in
833 					 * general ls(1) exits on OOM, and (2)
834 					 * there is another allocation/exit
835 					 * path directly below, which will
836 					 * likely exit anyway.
837 					 */
838 					if (user == NULL)
839 						err(1, "user_from_uid");
840 					group = group_from_gid(sp->st_gid, 0);
841 					/* Ditto. */
842 					if (group == NULL)
843 						err(1, "group_from_gid");
844 				}
845 				if ((ulen = strlen(user)) > maxuser)
846 					maxuser = ulen;
847 				if ((glen = strlen(group)) > maxgroup)
848 					maxgroup = glen;
849 				if (f_flags) {
850 					flags = fflagstostr(sp->st_flags);
851 					if (flags != NULL && *flags == '\0') {
852 						free(flags);
853 						flags = strdup("-");
854 					}
855 					if (flags == NULL)
856 						err(1, "fflagstostr");
857 					flen = strlen(flags);
858 					if (flen > (size_t)maxflags)
859 						maxflags = flen;
860 				} else
861 					flen = 0;
862 				labelstr = NULL;
863 				if (f_label) {
864 					char name[PATH_MAX + 1];
865 					mac_t label;
866 					int error;
867 
868 					error = mac_prepare_file_label(&label);
869 					if (error == -1) {
870 						warn("MAC label for %s/%s",
871 						    cur->fts_parent->fts_path,
872 						    cur->fts_name);
873 						goto label_out;
874 					}
875 
876 					if (cur->fts_level == FTS_ROOTLEVEL)
877 						snprintf(name, sizeof(name),
878 						    "%s", cur->fts_name);
879 					else
880 						snprintf(name, sizeof(name),
881 						    "%s/%s", cur->fts_parent->
882 						    fts_accpath, cur->fts_name);
883 
884 					if (options & FTS_LOGICAL)
885 						error = mac_get_file(name,
886 						    label);
887 					else
888 						error = mac_get_link(name,
889 						    label);
890 					if (error == -1) {
891 						warn("MAC label for %s/%s",
892 						    cur->fts_parent->fts_path,
893 						    cur->fts_name);
894 						mac_free(label);
895 						goto label_out;
896 					}
897 
898 					error = mac_to_text(label,
899 					    &labelstr);
900 					if (error == -1) {
901 						warn("MAC label for %s/%s",
902 						    cur->fts_parent->fts_path,
903 						    cur->fts_name);
904 						mac_free(label);
905 						goto label_out;
906 					}
907 					mac_free(label);
908 label_out:
909 					if (labelstr == NULL)
910 						labelstr = strdup("-");
911 					labelstrlen = strlen(labelstr);
912 					if (labelstrlen > maxlabelstr)
913 						maxlabelstr = labelstrlen;
914 				} else
915 					labelstrlen = 0;
916 
917 				if ((np = malloc(sizeof(NAMES) + labelstrlen +
918 				    ulen + glen + flen + 4)) == NULL)
919 					err(1, "malloc");
920 
921 				np->user = &np->data[0];
922 				(void)strcpy(np->user, user);
923 				np->group = &np->data[ulen + 1];
924 				(void)strcpy(np->group, group);
925 
926 				if (S_ISCHR(sp->st_mode) ||
927 				    S_ISBLK(sp->st_mode)) {
928 					sizelen = snprintf(NULL, 0,
929 					    "%#jx", (uintmax_t)sp->st_rdev);
930 					if (d.s_size < sizelen)
931 						d.s_size = sizelen;
932 				}
933 
934 				if (f_flags) {
935 					np->flags = &np->data[ulen + glen + 2];
936 					(void)strcpy(np->flags, flags);
937 					free(flags);
938 				}
939 				if (f_label) {
940 					np->label = &np->data[ulen + glen + 2
941 					    + (f_flags ? flen + 1 : 0)];
942 					(void)strcpy(np->label, labelstr);
943 					free(labelstr);
944 				}
945 				cur->fts_pointer = np;
946 			}
947 		}
948 		++entries;
949 	}
950 
951 	/*
952 	 * If there are no entries to display, we normally stop right
953 	 * here.  However, we must continue if we have to display the
954 	 * total block count.  In this case, we display the total only
955 	 * on the second (p != NULL) pass.
956 	 */
957 	if (!entries && (!(f_longform || f_size) || p == NULL))
958 		return;
959 
960 	d.list = list;
961 	d.entries = entries;
962 	d.maxlen = maxlen;
963 	if (needstats) {
964 		d.btotal = btotal;
965 		d.s_block = snprintf(NULL, 0, "%lu", howmany(maxblock, blocksize));
966 		d.s_flags = maxflags;
967 		d.s_label = maxlabelstr;
968 		d.s_group = maxgroup;
969 		d.s_inode = snprintf(NULL, 0, "%ju", maxinode);
970 		d.s_nlink = snprintf(NULL, 0, "%lu", maxnlink);
971 		sizelen = f_humanval ? HUMANVALSTR_LEN :
972 		    snprintf(NULL, 0, "%ju", maxsize);
973 		if (d.s_size < sizelen)
974 			d.s_size = sizelen;
975 		d.s_user = maxuser;
976 	}
977 	if (f_thousands)			/* make space for commas */
978 		d.s_size += (d.s_size - 1) / 3;
979 	printfcn(&d);
980 	output = 1;
981 
982 	if (f_longform)
983 		for (cur = list; cur; cur = cur->fts_link)
984 			free(cur->fts_pointer);
985 }
986 
987 /*
988  * Ordering for mastercmp:
989  * If ordering the argv (fts_level = FTS_ROOTLEVEL) return non-directories
990  * as larger than directories.  Within either group, use the sort function.
991  * All other levels use the sort function.  Error entries remain unsorted.
992  */
993 static int
994 mastercmp(const FTSENT * const *a, const FTSENT * const *b)
995 {
996 	int a_info, b_info;
997 
998 	a_info = (*a)->fts_info;
999 	if (a_info == FTS_ERR)
1000 		return (0);
1001 	b_info = (*b)->fts_info;
1002 	if (b_info == FTS_ERR)
1003 		return (0);
1004 
1005 	if (a_info == FTS_NS || b_info == FTS_NS)
1006 		return (namecmp(*a, *b));
1007 
1008 	if (a_info != b_info &&
1009 	    (*a)->fts_level == FTS_ROOTLEVEL && !f_listdir) {
1010 		if (a_info == FTS_D)
1011 			return (1);
1012 		if (b_info == FTS_D)
1013 			return (-1);
1014 	}
1015 	return (sortfcn(*a, *b));
1016 }
1017