xref: /freebsd/bin/ls/ls.c (revision ae83180158c4c937f170e31eff311b18c0286a93)
1 /*
2  * Copyright (c) 1989, 1993, 1994
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Michael Fischbein.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *	This product includes software developed by the University of
19  *	California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  */
36 
37 #ifndef lint
38 static const char copyright[] =
39 "@(#) Copyright (c) 1989, 1993, 1994\n\
40 	The Regents of the University of California.  All rights reserved.\n";
41 #endif /* not lint */
42 
43 #if 0
44 #ifndef lint
45 static char sccsid[] = "@(#)ls.c	8.5 (Berkeley) 4/2/94";
46 #endif /* not lint */
47 #endif
48 #include <sys/cdefs.h>
49 __FBSDID("$FreeBSD$");
50 
51 #include <sys/types.h>
52 #include <sys/stat.h>
53 #include <sys/ioctl.h>
54 
55 #include <dirent.h>
56 #include <err.h>
57 #include <errno.h>
58 #include <fts.h>
59 #include <grp.h>
60 #include <limits.h>
61 #include <locale.h>
62 #include <pwd.h>
63 #include <stdio.h>
64 #include <stdlib.h>
65 #include <string.h>
66 #include <unistd.h>
67 #ifdef COLORLS
68 #include <termcap.h>
69 #include <signal.h>
70 #endif
71 
72 #include "ls.h"
73 #include "extern.h"
74 #include "lomac.h"
75 
76 /*
77  * Upward approximation of the maximum number of characters needed to
78  * represent a value of integral type t as a string, excluding the
79  * NUL terminator, with provision for a sign.
80  */
81 #define	STRBUF_SIZEOF(t)	(1 + CHAR_BIT * sizeof(t) / 3 + 1)
82 
83 static void	 display(FTSENT *, FTSENT *);
84 static u_quad_t	 makenines(u_long);
85 static int	 mastercmp(const FTSENT **, const FTSENT **);
86 static void	 traverse(int, char **, int);
87 
88 static void (*printfcn)(DISPLAY *);
89 static int (*sortfcn)(const FTSENT *, const FTSENT *);
90 
91 long blocksize;			/* block size units */
92 int termwidth = 80;		/* default terminal width */
93 
94 /* flags */
95        int f_accesstime;	/* use time of last access */
96        int f_flags;		/* show flags associated with a file */
97        int f_humanval;		/* show human-readable file sizes */
98        int f_inode;		/* print inode */
99 static int f_kblocks;		/* print size in kilobytes */
100 static int f_listdir;		/* list actual directory, not contents */
101 static int f_listdot;		/* list files beginning with . */
102        int f_longform;		/* long listing format */
103        int f_nonprint;		/* show unprintables as ? */
104 static int f_nosort;		/* don't sort output */
105        int f_notabs;		/* don't use tab-separated multi-col output */
106 static int f_numericonly;	/* don't convert uid/gid to name */
107        int f_octal;		/* show unprintables as \xxx */
108        int f_octal_escape;	/* like f_octal but use C escapes if possible */
109 static int f_recursive;		/* ls subdirectories also */
110 static int f_reversesort;	/* reverse whatever sort is used */
111        int f_sectime;		/* print the real time for all files */
112 static int f_singlecol;		/* use single column output */
113        int f_size;		/* list size in short listing */
114        int f_slash;		/* similar to f_type, but only for dirs */
115        int f_sortacross;	/* sort across rows, not down columns */
116        int f_statustime;	/* use time of last mode change */
117        int f_stream;		/* stream the output, separate with commas */
118 static int f_timesort;		/* sort by time vice name */
119        int f_type;		/* add type character for non-regular files */
120 static int f_whiteout;		/* show whiteout entries */
121        int f_lomac;		/* show LOMAC attributes */
122 #ifdef COLORLS
123        int f_color;		/* add type in color for non-regular files */
124 
125 char *ansi_bgcol;		/* ANSI sequence to set background colour */
126 char *ansi_fgcol;		/* ANSI sequence to set foreground colour */
127 char *ansi_coloff;		/* ANSI sequence to reset colours */
128 char *attrs_off;		/* ANSI sequence to turn off attributes */
129 char *enter_bold;		/* ANSI sequence to set color to bold mode */
130 #endif
131 
132 static int rval;
133 
134 int
135 main(int argc, char *argv[])
136 {
137 	static char dot[] = ".", *dotav[] = {dot, NULL};
138 	struct winsize win;
139 	int ch, fts_options, notused;
140 	char *p;
141 #ifdef COLORLS
142 	char termcapbuf[1024];	/* termcap definition buffer */
143 	char tcapbuf[512];	/* capability buffer */
144 	char *bp = tcapbuf;
145 #endif
146 
147 	(void)setlocale(LC_ALL, "");
148 
149 	/* Terminal defaults to -Cq, non-terminal defaults to -1. */
150 	if (isatty(STDOUT_FILENO)) {
151 		termwidth = 80;
152 		if ((p = getenv("COLUMNS")) != NULL && *p != '\0')
153 			termwidth = atoi(p);
154 		else if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) != -1 &&
155 		    win.ws_col > 0)
156 			termwidth = win.ws_col;
157 		f_nonprint = 1;
158 	} else {
159 		f_singlecol = 1;
160 		/* retrieve environment variable, in case of explicit -C */
161 		p = getenv("COLUMNS");
162 		if (p)
163 			termwidth = atoi(p);
164 	}
165 
166 	/* Root is -A automatically. */
167 	if (!getuid())
168 		f_listdot = 1;
169 
170 	fts_options = FTS_PHYSICAL;
171  	while ((ch = getopt(argc, argv, "1ABCFGHLPRTWZabcdfghiklmnopqrstuwx"))
172 	    != -1) {
173 		switch (ch) {
174 		/*
175 		 * The -1, -C, -x and -l options all override each other so
176 		 * shell aliasing works right.
177 		 */
178 		case '1':
179 			f_singlecol = 1;
180 			f_longform = 0;
181 			f_stream = 0;
182 			break;
183 		case 'B':
184 			f_nonprint = 0;
185 			f_octal = 1;
186 			f_octal_escape = 0;
187 			break;
188 		case 'C':
189 			f_sortacross = f_longform = f_singlecol = 0;
190 			break;
191 		case 'l':
192 			f_longform = 1;
193 			f_singlecol = 0;
194 			f_stream = 0;
195 			break;
196 		case 'x':
197 			f_sortacross = 1;
198 			f_longform = 0;
199 			f_singlecol = 0;
200 			break;
201 		/* The -c and -u options override each other. */
202 		case 'c':
203 			f_statustime = 1;
204 			f_accesstime = 0;
205 			break;
206 		case 'u':
207 			f_accesstime = 1;
208 			f_statustime = 0;
209 			break;
210 		case 'F':
211 			f_type = 1;
212 			f_slash = 0;
213 			break;
214 		case 'H':
215 			fts_options |= FTS_COMFOLLOW;
216 			break;
217 		case 'G':
218 			setenv("CLICOLOR", "", 1);
219 			break;
220 		case 'L':
221 			fts_options &= ~FTS_PHYSICAL;
222 			fts_options |= FTS_LOGICAL;
223 			break;
224 		case 'P':
225 			fts_options &= ~FTS_COMFOLLOW;
226 			fts_options &= ~FTS_LOGICAL;
227 			fts_options |= FTS_PHYSICAL;
228 			break;
229 		case 'R':
230 			f_recursive = 1;
231 			break;
232 		case 'a':
233 			fts_options |= FTS_SEEDOT;
234 			/* FALLTHROUGH */
235 		case 'A':
236 			f_listdot = 1;
237 			break;
238 		/* The -d option turns off the -R option. */
239 		case 'd':
240 			f_listdir = 1;
241 			f_recursive = 0;
242 			break;
243 		case 'f':
244 			f_nosort = 1;
245 			break;
246 		case 'g':	/* Compatibility with 4.3BSD. */
247 			break;
248 		case 'h':
249 			f_humanval = 1;
250 			break;
251 		case 'i':
252 			f_inode = 1;
253 			break;
254 		case 'k':
255 			f_kblocks = 1;
256 			break;
257 		case 'm':
258 			f_stream = 1;
259 			f_singlecol = 0;
260 			f_longform = 0;
261 			break;
262 		case 'n':
263 			f_numericonly = 1;
264 			break;
265 		case 'o':
266 			f_flags = 1;
267 			break;
268 		case 'p':
269 			f_slash = 1;
270 			f_type = 1;
271 			break;
272 		case 'q':
273 			f_nonprint = 1;
274 			f_octal = 0;
275 			f_octal_escape = 0;
276 			break;
277 		case 'r':
278 			f_reversesort = 1;
279 			break;
280 		case 's':
281 			f_size = 1;
282 			break;
283 		case 'T':
284 			f_sectime = 1;
285 			break;
286 		case 't':
287 			f_timesort = 1;
288 			break;
289 		case 'W':
290 			f_whiteout = 1;
291 			break;
292 		case 'b':
293 			f_nonprint = 0;
294 			f_octal = 0;
295 			f_octal_escape = 1;
296 			break;
297 		case 'w':
298 			f_nonprint = 0;
299 			f_octal = 0;
300 			f_octal_escape = 0;
301 			break;
302 		case 'Z':
303 			f_lomac = 1;
304 			break;
305 		default:
306 		case '?':
307 			usage();
308 		}
309 	}
310 	argc -= optind;
311 	argv += optind;
312 
313 	/* Enabling of colours is conditional on the environment. */
314 	if (getenv("CLICOLOR") &&
315 	    (isatty(STDOUT_FILENO) || getenv("CLICOLOR_FORCE")))
316 #ifdef COLORLS
317 		if (tgetent(termcapbuf, getenv("TERM")) == 1) {
318 			ansi_fgcol = tgetstr("AF", &bp);
319 			ansi_bgcol = tgetstr("AB", &bp);
320 			attrs_off = tgetstr("me", &bp);
321 			enter_bold = tgetstr("md", &bp);
322 
323 			/* To switch colours off use 'op' if
324 			 * available, otherwise use 'oc', or
325 			 * don't do colours at all. */
326 			ansi_coloff = tgetstr("op", &bp);
327 			if (!ansi_coloff)
328 				ansi_coloff = tgetstr("oc", &bp);
329 			if (ansi_fgcol && ansi_bgcol && ansi_coloff)
330 				f_color = 1;
331 		}
332 #else
333 		(void)fprintf(stderr, "Color support not compiled in.\n");
334 #endif /*COLORLS*/
335 
336 #ifdef COLORLS
337 	if (f_color) {
338 		/*
339 		 * We can't put tabs and color sequences together:
340 		 * column number will be incremented incorrectly
341 		 * for "stty oxtabs" mode.
342 		 */
343 		f_notabs = 1;
344 		(void)signal(SIGINT, colorquit);
345 		(void)signal(SIGQUIT, colorquit);
346 		parsecolors(getenv("LSCOLORS"));
347 	}
348 #endif
349 
350 	/*
351 	 * If not -F, -i, -l, -s or -t options, don't require stat
352 	 * information, unless in color mode in which case we do
353 	 * need this to determine which colors to display.
354 	 */
355 	if (!f_inode && !f_longform && !f_size && !f_timesort && !f_type
356 #ifdef COLORLS
357 	    && !f_color
358 #endif
359 	    )
360 		fts_options |= FTS_NOSTAT;
361 
362 	/*
363 	 * If not -F, -d or -l options, follow any symbolic links listed on
364 	 * the command line.
365 	 */
366 	if (!f_longform && !f_listdir && !f_type)
367 		fts_options |= FTS_COMFOLLOW;
368 
369 	/*
370 	 * If -W, show whiteout entries
371 	 */
372 #ifdef FTS_WHITEOUT
373 	if (f_whiteout)
374 		fts_options |= FTS_WHITEOUT;
375 #endif
376 
377 	/* If -l or -s, figure out block size. */
378 	if (f_longform || f_size) {
379 		if (f_kblocks)
380 			blocksize = 2;
381 		else {
382 			(void)getbsize(&notused, &blocksize);
383 			blocksize /= 512;
384 		}
385 	}
386 	/* Select a sort function. */
387 	if (f_reversesort) {
388 		if (!f_timesort)
389 			sortfcn = revnamecmp;
390 		else if (f_accesstime)
391 			sortfcn = revacccmp;
392 		else if (f_statustime)
393 			sortfcn = revstatcmp;
394 		else		/* Use modification time. */
395 			sortfcn = revmodcmp;
396 	} else {
397 		if (!f_timesort)
398 			sortfcn = namecmp;
399 		else if (f_accesstime)
400 			sortfcn = acccmp;
401 		else if (f_statustime)
402 			sortfcn = statcmp;
403 		else		/* Use modification time. */
404 			sortfcn = modcmp;
405 	}
406 
407 	/* Select a print function. */
408 	if (f_singlecol)
409 		printfcn = printscol;
410 	else if (f_longform)
411 		printfcn = printlong;
412 	else if (f_stream)
413 		printfcn = printstream;
414 	else
415 		printfcn = printcol;
416 
417 	if (argc)
418 		traverse(argc, argv, fts_options);
419 	else
420 		traverse(1, dotav, fts_options);
421 	exit(rval);
422 }
423 
424 static int output;		/* If anything output. */
425 
426 /*
427  * Traverse() walks the logical directory structure specified by the argv list
428  * in the order specified by the mastercmp() comparison function.  During the
429  * traversal it passes linked lists of structures to display() which represent
430  * a superset (may be exact set) of the files to be displayed.
431  */
432 static void
433 traverse(int argc, char *argv[], int options)
434 {
435 	FTS *ftsp;
436 	FTSENT *p, *chp;
437 	int ch_options;
438 
439 	if ((ftsp =
440 	    fts_open(argv, options, f_nosort ? NULL : mastercmp)) == NULL)
441 		err(1, "fts_open");
442 
443 	display(NULL, fts_children(ftsp, 0));
444 	if (f_listdir)
445 		return;
446 
447 	/*
448 	 * If not recursing down this tree and don't need stat info, just get
449 	 * the names.
450 	 */
451 	ch_options = !f_recursive && options & FTS_NOSTAT ? FTS_NAMEONLY : 0;
452 
453 	while ((p = fts_read(ftsp)) != NULL)
454 		switch (p->fts_info) {
455 		case FTS_DC:
456 			warnx("%s: directory causes a cycle", p->fts_name);
457 			break;
458 		case FTS_DNR:
459 		case FTS_ERR:
460 			warnx("%s: %s", p->fts_name, strerror(p->fts_errno));
461 			rval = 1;
462 			break;
463 		case FTS_D:
464 			if (p->fts_level != FTS_ROOTLEVEL &&
465 			    p->fts_name[0] == '.' && !f_listdot)
466 				break;
467 
468 			/*
469 			 * If already output something, put out a newline as
470 			 * a separator.  If multiple arguments, precede each
471 			 * directory with its name.
472 			 */
473 			if (output)
474 				(void)printf("\n%s:\n", p->fts_path);
475 			else if (argc > 1) {
476 				(void)printf("%s:\n", p->fts_path);
477 				output = 1;
478 			}
479 			chp = fts_children(ftsp, ch_options);
480 			display(p, chp);
481 
482 			if (!f_recursive && chp != NULL)
483 				(void)fts_set(ftsp, p, FTS_SKIP);
484 			break;
485 		default:
486 			break;
487 		}
488 	if (errno)
489 		err(1, "fts_read");
490 }
491 
492 /*
493  * Display() takes a linked list of FTSENT structures and passes the list
494  * along with any other necessary information to the print function.  P
495  * points to the parent directory of the display list.
496  */
497 static void
498 display(FTSENT *p, FTSENT *list)
499 {
500 	struct stat *sp;
501 	DISPLAY d;
502 	FTSENT *cur;
503 	NAMES *np;
504 	off_t maxsize;
505 	u_long btotal, lattrlen, maxblock, maxinode, maxlen, maxnlink, maxlattr;
506 	int bcfile, maxflags;
507 	gid_t maxgroup;
508 	uid_t maxuser;
509 	size_t flen, ulen, glen;
510 	char *initmax;
511 	int entries, needstats;
512 	const char *user, *group;
513 	char *flags, *lattr = NULL;
514 	char buf[STRBUF_SIZEOF(u_quad_t) + 1];
515 	char ngroup[STRBUF_SIZEOF(uid_t) + 1];
516 	char nuser[STRBUF_SIZEOF(gid_t) + 1];
517 
518 	/*
519 	 * If list is NULL there are two possibilities: that the parent
520 	 * directory p has no children, or that fts_children() returned an
521 	 * error.  We ignore the error case since it will be replicated
522 	 * on the next call to fts_read() on the post-order visit to the
523 	 * directory p, and will be signaled in traverse().
524 	 */
525 	if (list == NULL)
526 		return;
527 
528 	needstats = f_inode || f_longform || f_size;
529 	flen = 0;
530 	btotal = 0;
531 	initmax = getenv("LS_COLWIDTHS");
532 	/* Fields match -lios order.  New ones should be added at the end. */
533 	maxlattr = maxblock = maxinode = maxlen = maxnlink =
534 	    maxuser = maxgroup = maxflags = maxsize = 0;
535 	if (initmax != NULL && *initmax != '\0') {
536 		char *initmax2, *jinitmax;
537 		int ninitmax;
538 
539 		/* Fill-in "::" as "0:0:0" for the sake of scanf. */
540 		jinitmax = initmax2 = malloc(strlen(initmax) * 2 + 2);
541 		if (jinitmax == NULL)
542 			err(1, "malloc");
543 		if (*initmax == ':')
544 			strcpy(initmax2, "0:"), initmax2 += 2;
545 		else
546 			*initmax2++ = *initmax, *initmax2 = '\0';
547 		for (initmax++; *initmax != '\0'; initmax++) {
548 			if (initmax[-1] == ':' && initmax[0] == ':') {
549 				*initmax2++ = '0';
550 				*initmax2++ = initmax[0];
551 				initmax2[1] = '\0';
552 			} else {
553 				*initmax2++ = initmax[0];
554 				initmax2[1] = '\0';
555 			}
556 		}
557 		if (initmax2[-1] == ':')
558 			strcpy(initmax2, "0");
559 
560 		ninitmax = sscanf(jinitmax,
561 		    " %lu : %lu : %lu : %i : %i : %i : %llu : %lu : %lu ",
562 		    &maxinode, &maxblock, &maxnlink, &maxuser,
563 		    &maxgroup, &maxflags, &maxsize, &maxlen, &maxlattr);
564 		f_notabs = 1;
565 		switch (ninitmax) {
566 		case 0:
567 			maxinode = 0;
568 			/* fall through */
569 		case 1:
570 			maxblock = 0;
571 			/* fall through */
572 		case 2:
573 			maxnlink = 0;
574 			/* fall through */
575 		case 3:
576 			maxuser = 0;
577 			/* fall through */
578 		case 4:
579 			maxgroup = 0;
580 			/* fall through */
581 		case 5:
582 			maxflags = 0;
583 			/* fall through */
584 		case 6:
585 			maxsize = 0;
586 			/* fall through */
587 		case 7:
588 			maxlen = 0;
589 			/* fall through */
590 		case 8:
591 			maxlattr = 0;
592 			/* fall through */
593 #ifdef COLORLS
594 			if (!f_color)
595 #endif
596 				f_notabs = 0;
597 			/* fall through */
598 		default:
599 			break;
600 		}
601 		maxinode = makenines(maxinode);
602 		maxblock = makenines(maxblock);
603 		maxnlink = makenines(maxnlink);
604 		maxsize = makenines(maxsize);
605 	}
606 	if (f_lomac)
607 		lomac_start();
608 	bcfile = 0;
609 	flags = NULL;
610 	for (cur = list, entries = 0; cur; cur = cur->fts_link) {
611 		if (cur->fts_info == FTS_ERR || cur->fts_info == FTS_NS) {
612 			warnx("%s: %s",
613 			    cur->fts_name, strerror(cur->fts_errno));
614 			cur->fts_number = NO_PRINT;
615 			rval = 1;
616 			continue;
617 		}
618 		/*
619 		 * P is NULL if list is the argv list, to which different rules
620 		 * apply.
621 		 */
622 		if (p == NULL) {
623 			/* Directories will be displayed later. */
624 			if (cur->fts_info == FTS_D && !f_listdir) {
625 				cur->fts_number = NO_PRINT;
626 				continue;
627 			}
628 		} else {
629 			/* Only display dot file if -a/-A set. */
630 			if (cur->fts_name[0] == '.' && !f_listdot) {
631 				cur->fts_number = NO_PRINT;
632 				continue;
633 			}
634 		}
635 		if (cur->fts_namelen > maxlen)
636 			maxlen = cur->fts_namelen;
637 		if (f_octal || f_octal_escape) {
638 			u_long t = len_octal(cur->fts_name, cur->fts_namelen);
639 
640 			if (t > maxlen)
641 				maxlen = t;
642 		}
643 		if (needstats) {
644 			sp = cur->fts_statp;
645 			if (sp->st_blocks > maxblock)
646 				maxblock = sp->st_blocks;
647 			if (sp->st_ino > maxinode)
648 				maxinode = sp->st_ino;
649 			if (sp->st_nlink > maxnlink)
650 				maxnlink = sp->st_nlink;
651 			if (sp->st_size > maxsize)
652 				maxsize = sp->st_size;
653 
654 			btotal += sp->st_blocks;
655 			if (f_longform) {
656 				if (f_numericonly) {
657 					(void)snprintf(nuser, sizeof(nuser),
658 					    "%u", sp->st_uid);
659 					(void)snprintf(ngroup, sizeof(ngroup),
660 					    "%u", sp->st_gid);
661 					user = nuser;
662 					group = ngroup;
663 				} else {
664 					user = user_from_uid(sp->st_uid, 0);
665 					group = group_from_gid(sp->st_gid, 0);
666 				}
667 				if ((ulen = strlen(user)) > maxuser)
668 					maxuser = ulen;
669 				if ((glen = strlen(group)) > maxgroup)
670 					maxgroup = glen;
671 				if (f_flags) {
672 					flags = fflagstostr(sp->st_flags);
673 					if (flags != NULL && *flags == '\0') {
674 						free(flags);
675 						flags = strdup("-");
676 					}
677 					if (flags == NULL)
678 						err(1, "fflagstostr");
679 					flen = strlen(flags);
680 					if (flen > (size_t)maxflags)
681 						maxflags = flen;
682 				} else
683 					flen = 0;
684 				lattr = NULL;
685 				if (f_lomac) {
686 					lattr = get_lattr(cur);
687 					lattrlen = strlen(lattr);
688 					if (lattrlen > maxlattr)
689 						maxlattr = lattrlen;
690 				} else
691 					lattrlen = 0;
692 
693 				if ((np = malloc(sizeof(NAMES) + lattrlen +
694 				    ulen + glen + flen + 4)) == NULL)
695 					err(1, "malloc");
696 
697 				np->user = &np->data[0];
698 				(void)strcpy(np->user, user);
699 				np->group = &np->data[ulen + 1];
700 				(void)strcpy(np->group, group);
701 
702 				if (S_ISCHR(sp->st_mode) ||
703 				    S_ISBLK(sp->st_mode))
704 					bcfile = 1;
705 
706 				if (f_flags) {
707 					np->flags = &np->data[ulen + glen + 2];
708 					(void)strcpy(np->flags, flags);
709 					free(flags);
710 				}
711 				if (f_lomac) {
712 					np->lattr = &np->data[ulen + glen + 2
713 					    + (f_flags ? flen + 1 : 0)];
714 					(void)strcpy(np->lattr, lattr);
715 					free(lattr);
716 				}
717 				cur->fts_pointer = np;
718 			}
719 		}
720 		++entries;
721 	}
722 
723 	if (!entries)
724 		return;
725 
726 	d.list = list;
727 	d.entries = entries;
728 	d.maxlen = maxlen;
729 	if (needstats) {
730 		d.bcfile = bcfile;
731 		d.btotal = btotal;
732 		(void)snprintf(buf, sizeof(buf), "%lu", maxblock);
733 		d.s_block = strlen(buf);
734 		d.s_flags = maxflags;
735 		d.s_lattr = maxlattr;
736 		d.s_group = maxgroup;
737 		(void)snprintf(buf, sizeof(buf), "%lu", maxinode);
738 		d.s_inode = strlen(buf);
739 		(void)snprintf(buf, sizeof(buf), "%lu", maxnlink);
740 		d.s_nlink = strlen(buf);
741 		(void)snprintf(buf, sizeof(buf), "%qu", maxsize);
742 		d.s_size = strlen(buf);
743 		d.s_user = maxuser;
744 	}
745 	printfcn(&d);
746 	output = 1;
747 
748 	if (f_longform)
749 		for (cur = list; cur; cur = cur->fts_link)
750 			free(cur->fts_pointer);
751 	if (f_lomac)
752 		lomac_stop();
753 }
754 
755 /*
756  * Ordering for mastercmp:
757  * If ordering the argv (fts_level = FTS_ROOTLEVEL) return non-directories
758  * as larger than directories.  Within either group, use the sort function.
759  * All other levels use the sort function.  Error entries remain unsorted.
760  */
761 static int
762 mastercmp(const FTSENT **a, const FTSENT **b)
763 {
764 	int a_info, b_info;
765 
766 	a_info = (*a)->fts_info;
767 	if (a_info == FTS_ERR)
768 		return (0);
769 	b_info = (*b)->fts_info;
770 	if (b_info == FTS_ERR)
771 		return (0);
772 
773 	if (a_info == FTS_NS || b_info == FTS_NS)
774 		return (namecmp(*a, *b));
775 
776 	if (a_info != b_info &&
777 	    (*a)->fts_level == FTS_ROOTLEVEL && !f_listdir) {
778 		if (a_info == FTS_D)
779 			return (1);
780 		if (b_info == FTS_D)
781 			return (-1);
782 	}
783 	return (sortfcn(*a, *b));
784 }
785 
786 /*
787  * Makenines() returns (10**n)-1.  This is useful for converting a width
788  * into a number that wide in decimal.
789  */
790 static u_quad_t
791 makenines(u_long n)
792 {
793 	u_long i;
794 	u_quad_t reg;
795 
796 	reg = 1;
797 	/* Use a loop instead of pow(), since all values of n are small. */
798 	for (i = 0; i < n; i++)
799 		reg *= 10;
800 	reg--;
801 
802 	return reg;
803 }
804