xref: /freebsd/bin/ls/print.c (revision 66fd12cf4896eb08ad8e7a2627537f84ead84dd3)
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 #if 0
36 #ifndef lint
37 static char sccsid[] = "@(#)print.c	8.4 (Berkeley) 4/17/94";
38 #endif /* not lint */
39 #endif
40 #include <sys/cdefs.h>
41 __FBSDID("$FreeBSD$");
42 
43 #include <sys/param.h>
44 #include <sys/stat.h>
45 #include <sys/acl.h>
46 
47 #include <err.h>
48 #include <errno.h>
49 #include <fts.h>
50 #include <langinfo.h>
51 #include <libutil.h>
52 #include <limits.h>
53 #include <stdio.h>
54 #include <stdint.h>
55 #include <stdlib.h>
56 #include <string.h>
57 #include <time.h>
58 #include <unistd.h>
59 #include <wchar.h>
60 #ifdef COLORLS
61 #include <ctype.h>
62 #include <termcap.h>
63 #include <signal.h>
64 #endif
65 
66 #include "ls.h"
67 #include "extern.h"
68 
69 static int	printaname(const FTSENT *, u_long, u_long);
70 static void	printdev(size_t, dev_t);
71 static void	printlink(const FTSENT *);
72 static void	printtime(time_t);
73 static int	printtype(u_int);
74 static void	printsize(size_t, off_t);
75 #ifdef COLORLS
76 static void	endcolor_termcap(int);
77 static void	endcolor_ansi(void);
78 static void	endcolor(int);
79 static int	colortype(mode_t);
80 #endif
81 static void	aclmode(char *, const FTSENT *);
82 
83 #define	IS_NOPRINT(p)	((p)->fts_number == NO_PRINT)
84 
85 #ifdef COLORLS
86 /* Most of these are taken from <sys/stat.h> */
87 typedef enum Colors {
88 	C_DIR,			/* directory */
89 	C_LNK,			/* symbolic link */
90 	C_SOCK,			/* socket */
91 	C_FIFO,			/* pipe */
92 	C_EXEC,			/* executable */
93 	C_BLK,			/* block special */
94 	C_CHR,			/* character special */
95 	C_SUID,			/* setuid executable */
96 	C_SGID,			/* setgid executable */
97 	C_WSDIR,		/* directory writeble to others, with sticky
98 				 * bit */
99 	C_WDIR,			/* directory writeble to others, without
100 				 * sticky bit */
101 	C_NUMCOLORS		/* just a place-holder */
102 } Colors;
103 
104 static const char *defcolors = "exfxcxdxbxegedabagacad";
105 
106 /* colors for file types */
107 static struct {
108 	int	num[2];
109 	bool	bold;
110 	bool	underline;
111 } colors[C_NUMCOLORS];
112 #endif
113 
114 static size_t padding_for_month[12];
115 static size_t month_max_size = 0;
116 
117 void
118 printscol(const DISPLAY *dp)
119 {
120 	FTSENT *p;
121 
122 	for (p = dp->list; p; p = p->fts_link) {
123 		if (IS_NOPRINT(p))
124 			continue;
125 		(void)printaname(p, dp->s_inode, dp->s_block);
126 		(void)putchar('\n');
127 	}
128 }
129 
130 /*
131  * print name in current style
132  */
133 int
134 printname(const char *name)
135 {
136 	if (f_octal || f_octal_escape)
137 		return prn_octal(name);
138 	else if (f_nonprint)
139 		return prn_printable(name);
140 	else
141 		return prn_normal(name);
142 }
143 
144 static const char *
145 get_abmon(int mon)
146 {
147 
148 	switch (mon) {
149 	case 0: return (nl_langinfo(ABMON_1));
150 	case 1: return (nl_langinfo(ABMON_2));
151 	case 2: return (nl_langinfo(ABMON_3));
152 	case 3: return (nl_langinfo(ABMON_4));
153 	case 4: return (nl_langinfo(ABMON_5));
154 	case 5: return (nl_langinfo(ABMON_6));
155 	case 6: return (nl_langinfo(ABMON_7));
156 	case 7: return (nl_langinfo(ABMON_8));
157 	case 8: return (nl_langinfo(ABMON_9));
158 	case 9: return (nl_langinfo(ABMON_10));
159 	case 10: return (nl_langinfo(ABMON_11));
160 	case 11: return (nl_langinfo(ABMON_12));
161 	}
162 
163 	/* should never happen */
164 	abort();
165 }
166 
167 static size_t
168 mbswidth(const char *month)
169 {
170 	wchar_t wc;
171 	size_t width, donelen, clen, w;
172 
173 	width = donelen = 0;
174 	while ((clen = mbrtowc(&wc, month + donelen, MB_LEN_MAX, NULL)) != 0) {
175 		if (clen == (size_t)-1 || clen == (size_t)-2)
176 			return (-1);
177 		donelen += clen;
178 		if ((w = wcwidth(wc)) == (size_t)-1)
179 			return (-1);
180 		width += w;
181 	}
182 
183 	return (width);
184 }
185 
186 static void
187 compute_abbreviated_month_size(void)
188 {
189 	int i;
190 	size_t width;
191 	size_t months_width[12];
192 
193 	for (i = 0; i < 12; i++) {
194 		width = mbswidth(get_abmon(i));
195 		if (width == (size_t)-1) {
196 			month_max_size = -1;
197 			return;
198 		}
199 		months_width[i] = width;
200 		if (width > month_max_size)
201 			month_max_size = width;
202 	}
203 
204 	for (i = 0; i < 12; i++)
205 		padding_for_month[i] = month_max_size - months_width[i];
206 }
207 
208 void
209 printlong(const DISPLAY *dp)
210 {
211 	struct stat *sp;
212 	FTSENT *p;
213 	NAMES *np;
214 	char buf[20];
215 #ifdef COLORLS
216 	int color_printed = 0;
217 #endif
218 
219 	if ((dp->list == NULL || dp->list->fts_level != FTS_ROOTLEVEL) &&
220 	    (f_longform || f_size)) {
221 		(void)printf("total %lu\n", howmany(dp->btotal, blocksize));
222 	}
223 
224 	for (p = dp->list; p; p = p->fts_link) {
225 		if (IS_NOPRINT(p))
226 			continue;
227 		sp = p->fts_statp;
228 		if (f_inode)
229 			(void)printf("%*ju ",
230 			    dp->s_inode, (uintmax_t)sp->st_ino);
231 		if (f_size)
232 			(void)printf("%*jd ",
233 			    dp->s_block, howmany(sp->st_blocks, blocksize));
234 		strmode(sp->st_mode, buf);
235 		aclmode(buf, p);
236 		np = p->fts_pointer;
237 		(void)printf("%s %*ju ", buf, dp->s_nlink,
238 		    (uintmax_t)sp->st_nlink);
239 		if (!f_sowner)
240 			(void)printf("%-*s ", dp->s_user, np->user);
241 		(void)printf("%-*s ", dp->s_group, np->group);
242 		if (f_flags)
243 			(void)printf("%-*s ", dp->s_flags, np->flags);
244 		if (f_label)
245 			(void)printf("%-*s ", dp->s_label, np->label);
246 		if (S_ISCHR(sp->st_mode) || S_ISBLK(sp->st_mode))
247 			printdev(dp->s_size, sp->st_rdev);
248 		else
249 			printsize(dp->s_size, sp->st_size);
250 		if (f_accesstime)
251 			printtime(sp->st_atime);
252 		else if (f_birthtime)
253 			printtime(sp->st_birthtime);
254 		else if (f_statustime)
255 			printtime(sp->st_ctime);
256 		else
257 			printtime(sp->st_mtime);
258 #ifdef COLORLS
259 		if (f_color)
260 			color_printed = colortype(sp->st_mode);
261 #endif
262 		(void)printname(p->fts_name);
263 #ifdef COLORLS
264 		if (f_color && color_printed)
265 			endcolor(0);
266 #endif
267 		if (f_type)
268 			(void)printtype(sp->st_mode);
269 		if (S_ISLNK(sp->st_mode))
270 			printlink(p);
271 		(void)putchar('\n');
272 	}
273 }
274 
275 void
276 printstream(const DISPLAY *dp)
277 {
278 	FTSENT *p;
279 	int chcnt;
280 
281 	for (p = dp->list, chcnt = 0; p; p = p->fts_link) {
282 		if (p->fts_number == NO_PRINT)
283 			continue;
284 		/* XXX strlen does not take octal escapes into account. */
285 		if (strlen(p->fts_name) + chcnt +
286 		    (p->fts_link ? 2 : 0) >= (unsigned)termwidth) {
287 			putchar('\n');
288 			chcnt = 0;
289 		}
290 		chcnt += printaname(p, dp->s_inode, dp->s_block);
291 		if (p->fts_link) {
292 			printf(", ");
293 			chcnt += 2;
294 		}
295 	}
296 	if (chcnt)
297 		putchar('\n');
298 }
299 
300 void
301 printcol(const DISPLAY *dp)
302 {
303 	static FTSENT **array;
304 	static int lastentries = -1;
305 	FTSENT *p;
306 	FTSENT **narray;
307 	int base;
308 	int chcnt;
309 	int cnt;
310 	int col;
311 	int colwidth;
312 	int endcol;
313 	int num;
314 	int numcols;
315 	int numrows;
316 	int row;
317 	int tabwidth;
318 
319 	if (f_notabs)
320 		tabwidth = 1;
321 	else
322 		tabwidth = 8;
323 
324 	/*
325 	 * Have to do random access in the linked list -- build a table
326 	 * of pointers.
327 	 */
328 	if (dp->entries > lastentries) {
329 		if ((narray =
330 		    realloc(array, dp->entries * sizeof(FTSENT *))) == NULL) {
331 			warn(NULL);
332 			printscol(dp);
333 			return;
334 		}
335 		lastentries = dp->entries;
336 		array = narray;
337 	}
338 	for (p = dp->list, num = 0; p; p = p->fts_link)
339 		if (p->fts_number != NO_PRINT)
340 			array[num++] = p;
341 
342 	colwidth = dp->maxlen;
343 	if (f_inode)
344 		colwidth += dp->s_inode + 1;
345 	if (f_size)
346 		colwidth += dp->s_block + 1;
347 	if (f_type)
348 		colwidth += 1;
349 
350 	colwidth = (colwidth + tabwidth) & ~(tabwidth - 1);
351 	if (termwidth < 2 * colwidth) {
352 		printscol(dp);
353 		return;
354 	}
355 	numcols = termwidth / colwidth;
356 	numrows = num / numcols;
357 	if (num % numcols)
358 		++numrows;
359 
360 	if ((dp->list == NULL || dp->list->fts_level != FTS_ROOTLEVEL) &&
361 	    (f_longform || f_size)) {
362 		(void)printf("total %lu\n", howmany(dp->btotal, blocksize));
363 	}
364 
365 	base = 0;
366 	for (row = 0; row < numrows; ++row) {
367 		endcol = colwidth;
368 		if (!f_sortacross)
369 			base = row;
370 		for (col = 0, chcnt = 0; col < numcols; ++col) {
371 			chcnt += printaname(array[base], dp->s_inode,
372 			    dp->s_block);
373 			if (f_sortacross)
374 				base++;
375 			else
376 				base += numrows;
377 			if (base >= num)
378 				break;
379 			while ((cnt = ((chcnt + tabwidth) & ~(tabwidth - 1)))
380 			    <= endcol) {
381 				if (f_sortacross && col + 1 >= numcols)
382 					break;
383 				(void)putchar(f_notabs ? ' ' : '\t');
384 				chcnt = cnt;
385 			}
386 			endcol += colwidth;
387 		}
388 		(void)putchar('\n');
389 	}
390 }
391 
392 /*
393  * print [inode] [size] name
394  * return # of characters printed, no trailing characters.
395  */
396 static int
397 printaname(const FTSENT *p, u_long inodefield, u_long sizefield)
398 {
399 	struct stat *sp;
400 	int chcnt;
401 #ifdef COLORLS
402 	int color_printed = 0;
403 #endif
404 
405 	sp = p->fts_statp;
406 	chcnt = 0;
407 	if (f_inode)
408 		chcnt += printf("%*ju ",
409 		    (int)inodefield, (uintmax_t)sp->st_ino);
410 	if (f_size)
411 		chcnt += printf("%*jd ",
412 		    (int)sizefield, howmany(sp->st_blocks, blocksize));
413 #ifdef COLORLS
414 	if (f_color)
415 		color_printed = colortype(sp->st_mode);
416 #endif
417 	chcnt += printname(p->fts_name);
418 #ifdef COLORLS
419 	if (f_color && color_printed)
420 		endcolor(0);
421 #endif
422 	if (f_type)
423 		chcnt += printtype(sp->st_mode);
424 	return (chcnt);
425 }
426 
427 /*
428  * Print device special file major and minor numbers.
429  */
430 static void
431 printdev(size_t width, dev_t dev)
432 {
433 
434 	(void)printf("%#*jx ", (u_int)width, (uintmax_t)dev);
435 }
436 
437 static void
438 ls_strftime(char *str, size_t len, const char *fmt, const struct tm *tm)
439 {
440 	char *posb, nfmt[BUFSIZ];
441 	const char *format = fmt;
442 
443 	if ((posb = strstr(fmt, "%b")) != NULL) {
444 		if (month_max_size == 0) {
445 			compute_abbreviated_month_size();
446 		}
447 		if (month_max_size > 0 && tm != NULL) {
448 			snprintf(nfmt, sizeof(nfmt),  "%.*s%s%*s%s",
449 			    (int)(posb - fmt), fmt,
450 			    get_abmon(tm->tm_mon),
451 			    (int)padding_for_month[tm->tm_mon],
452 			    "",
453 			    posb + 2);
454 			format = nfmt;
455 		}
456 	}
457 	if (tm != NULL)
458 		strftime(str, len, format, tm);
459 	else
460 		strlcpy(str, "bad date val", len);
461 }
462 
463 static void
464 printtime(time_t ftime)
465 {
466 	char longstring[80];
467 	static time_t now = 0;
468 	const char *format;
469 	static int d_first = -1;
470 
471 	if (d_first < 0)
472 		d_first = (*nl_langinfo(D_MD_ORDER) == 'd');
473 	if (now == 0)
474 		now = time(NULL);
475 
476 #define	SIXMONTHS	((365 / 2) * 86400)
477 	if (f_timeformat)  /* user specified format */
478 		format = f_timeformat;
479 	else if (f_sectime)
480 		/* mmm dd hh:mm:ss yyyy || dd mmm hh:mm:ss yyyy */
481 		format = d_first ? "%e %b %T %Y" : "%b %e %T %Y";
482 	else if (ftime + SIXMONTHS > now && ftime < now + SIXMONTHS)
483 		/* mmm dd hh:mm || dd mmm hh:mm */
484 		format = d_first ? "%e %b %R" : "%b %e %R";
485 	else
486 		/* mmm dd  yyyy || dd mmm  yyyy */
487 		format = d_first ? "%e %b  %Y" : "%b %e  %Y";
488 	ls_strftime(longstring, sizeof(longstring), format, localtime(&ftime));
489 	fputs(longstring, stdout);
490 	fputc(' ', stdout);
491 }
492 
493 static int
494 printtype(u_int mode)
495 {
496 
497 	if (f_slash) {
498 		if ((mode & S_IFMT) == S_IFDIR) {
499 			(void)putchar('/');
500 			return (1);
501 		}
502 		return (0);
503 	}
504 
505 	switch (mode & S_IFMT) {
506 	case S_IFDIR:
507 		(void)putchar('/');
508 		return (1);
509 	case S_IFIFO:
510 		(void)putchar('|');
511 		return (1);
512 	case S_IFLNK:
513 		(void)putchar('@');
514 		return (1);
515 	case S_IFSOCK:
516 		(void)putchar('=');
517 		return (1);
518 	case S_IFWHT:
519 		(void)putchar('%');
520 		return (1);
521 	default:
522 		break;
523 	}
524 	if (mode & (S_IXUSR | S_IXGRP | S_IXOTH)) {
525 		(void)putchar('*');
526 		return (1);
527 	}
528 	return (0);
529 }
530 
531 #ifdef COLORLS
532 static int
533 putch(int c)
534 {
535 	(void)putchar(c);
536 	return 0;
537 }
538 
539 static int
540 writech(int c)
541 {
542 	char tmp = (char)c;
543 
544 	(void)write(STDOUT_FILENO, &tmp, 1);
545 	return 0;
546 }
547 
548 static void
549 printcolor_termcap(Colors c)
550 {
551 	char *ansiseq;
552 
553 	if (colors[c].bold)
554 		tputs(enter_bold, 1, putch);
555 	if (colors[c].underline)
556 		tputs(enter_underline, 1, putch);
557 
558 	if (colors[c].num[0] != -1) {
559 		ansiseq = tgoto(ansi_fgcol, 0, colors[c].num[0]);
560 		if (ansiseq)
561 			tputs(ansiseq, 1, putch);
562 	}
563 	if (colors[c].num[1] != -1) {
564 		ansiseq = tgoto(ansi_bgcol, 0, colors[c].num[1]);
565 		if (ansiseq)
566 			tputs(ansiseq, 1, putch);
567 	}
568 }
569 
570 static void
571 printcolor_ansi(Colors c)
572 {
573 
574 	printf("\033[");
575 
576 	if (colors[c].bold)
577 		printf("1");
578 	if (colors[c].underline)
579 		printf(";4");
580 	if (colors[c].num[0] != -1)
581 		printf(";3%d", colors[c].num[0]);
582 	if (colors[c].num[1] != -1)
583 		printf(";4%d", colors[c].num[1]);
584 	printf("m");
585 }
586 
587 static void
588 printcolor(Colors c)
589 {
590 
591 	if (explicitansi)
592 		printcolor_ansi(c);
593 	else
594 		printcolor_termcap(c);
595 }
596 
597 static void
598 endcolor_termcap(int sig)
599 {
600 
601 	tputs(ansi_coloff, 1, sig ? writech : putch);
602 	tputs(attrs_off, 1, sig ? writech : putch);
603 }
604 
605 static void
606 endcolor_ansi(void)
607 {
608 
609 	printf("\33[m");
610 }
611 
612 static void
613 endcolor(int sig)
614 {
615 
616 	if (explicitansi)
617 		endcolor_ansi();
618 	else
619 		endcolor_termcap(sig);
620 }
621 
622 static int
623 colortype(mode_t mode)
624 {
625 	switch (mode & S_IFMT) {
626 	case S_IFDIR:
627 		if (mode & S_IWOTH)
628 			if (mode & S_ISTXT)
629 				printcolor(C_WSDIR);
630 			else
631 				printcolor(C_WDIR);
632 		else
633 			printcolor(C_DIR);
634 		return (1);
635 	case S_IFLNK:
636 		printcolor(C_LNK);
637 		return (1);
638 	case S_IFSOCK:
639 		printcolor(C_SOCK);
640 		return (1);
641 	case S_IFIFO:
642 		printcolor(C_FIFO);
643 		return (1);
644 	case S_IFBLK:
645 		printcolor(C_BLK);
646 		return (1);
647 	case S_IFCHR:
648 		printcolor(C_CHR);
649 		return (1);
650 	default:;
651 	}
652 	if (mode & (S_IXUSR | S_IXGRP | S_IXOTH)) {
653 		if (mode & S_ISUID)
654 			printcolor(C_SUID);
655 		else if (mode & S_ISGID)
656 			printcolor(C_SGID);
657 		else
658 			printcolor(C_EXEC);
659 		return (1);
660 	}
661 	return (0);
662 }
663 
664 void
665 parsecolors(const char *cs)
666 {
667 	int i;
668 	int j;
669 	size_t len;
670 	char c[2];
671 	short legacy_warn = 0;
672 
673 	if (cs == NULL)
674 		cs = "";	/* LSCOLORS not set */
675 	len = strlen(cs);
676 	for (i = 0; i < (int)C_NUMCOLORS; i++) {
677 		colors[i].bold = false;
678 		colors[i].underline = false;
679 
680 		if (len <= 2 * (size_t)i) {
681 			c[0] = defcolors[2 * i];
682 			c[1] = defcolors[2 * i + 1];
683 		} else {
684 			c[0] = cs[2 * i];
685 			c[1] = cs[2 * i + 1];
686 		}
687 		for (j = 0; j < 2; j++) {
688 			/* Legacy colours used 0-7 */
689 			if (c[j] >= '0' && c[j] <= '7') {
690 				colors[i].num[j] = c[j] - '0';
691 				if (!legacy_warn) {
692 					warnx("LSCOLORS should use "
693 					    "characters a-h instead of 0-9 ("
694 					    "see the manual page)");
695 				}
696 				legacy_warn = 1;
697 			} else if (c[j] >= 'a' && c[j] <= 'h')
698 				colors[i].num[j] = c[j] - 'a';
699 			else if (c[j] >= 'A' && c[j] <= 'H') {
700 				colors[i].num[j] = c[j] - 'A';
701 				if (j == 1)
702 					colors[i].underline = true;
703 				else
704 					colors[i].bold = true;
705 			} else if (tolower((unsigned char)c[j]) == 'x') {
706 				if (j == 1 && c[j] == 'X')
707 					colors[i].underline = true;
708 				colors[i].num[j] = -1;
709 			} else {
710 				warnx("invalid character '%c' in LSCOLORS"
711 				    " env var", c[j]);
712 				colors[i].num[j] = -1;
713 			}
714 		}
715 	}
716 }
717 
718 void
719 colorquit(int sig)
720 {
721 	endcolor(sig);
722 
723 	(void)signal(sig, SIG_DFL);
724 	(void)kill(getpid(), sig);
725 }
726 
727 #endif /* COLORLS */
728 
729 static void
730 printlink(const FTSENT *p)
731 {
732 	int lnklen;
733 	char name[MAXPATHLEN + 1];
734 	char path[MAXPATHLEN + 1];
735 
736 	if (p->fts_level == FTS_ROOTLEVEL)
737 		(void)snprintf(name, sizeof(name), "%s", p->fts_name);
738 	else
739 		(void)snprintf(name, sizeof(name),
740 		    "%s/%s", p->fts_parent->fts_accpath, p->fts_name);
741 	if ((lnklen = readlink(name, path, sizeof(path) - 1)) == -1) {
742 		(void)fprintf(stderr, "\nls: %s: %s\n", name, strerror(errno));
743 		return;
744 	}
745 	path[lnklen] = '\0';
746 	(void)printf(" -> ");
747 	(void)printname(path);
748 }
749 
750 static void
751 printsize(size_t width, off_t bytes)
752 {
753 
754 	if (f_humanval) {
755 		/*
756 		 * Reserve one space before the size and allocate room for
757 		 * the trailing '\0'.
758 		 */
759 		char buf[HUMANVALSTR_LEN - 1 + 1];
760 
761 		humanize_number(buf, sizeof(buf), (int64_t)bytes, "",
762 		    HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
763 		(void)printf("%*s ", (u_int)width, buf);
764 	} else if (f_thousands) {		/* with commas */
765 		/* This format assignment needed to work round gcc bug. */
766 		const char *format = "%*j'd ";
767 		(void)printf(format, (u_int)width, bytes);
768 	} else
769 		(void)printf("%*jd ", (u_int)width, bytes);
770 }
771 
772 /*
773  * Add a + after the standard rwxrwxrwx mode if the file has an
774  * ACL. strmode() reserves space at the end of the string.
775  */
776 static void
777 aclmode(char *buf, const FTSENT *p)
778 {
779 	char name[MAXPATHLEN + 1];
780 	int ret, trivial;
781 	static dev_t previous_dev = NODEV;
782 	static int supports_acls = -1;
783 	static int type = ACL_TYPE_ACCESS;
784 	acl_t facl;
785 
786 	/*
787 	 * XXX: ACLs are not supported on whiteouts and device files
788 	 * residing on UFS.
789 	 */
790 	if (S_ISCHR(p->fts_statp->st_mode) || S_ISBLK(p->fts_statp->st_mode) ||
791 	    S_ISWHT(p->fts_statp->st_mode))
792 		return;
793 
794 	if (previous_dev == p->fts_statp->st_dev && supports_acls == 0)
795 		return;
796 
797 	if (p->fts_level == FTS_ROOTLEVEL)
798 		snprintf(name, sizeof(name), "%s", p->fts_name);
799 	else
800 		snprintf(name, sizeof(name), "%s/%s",
801 		    p->fts_parent->fts_accpath, p->fts_name);
802 
803 	if (previous_dev != p->fts_statp->st_dev) {
804 		previous_dev = p->fts_statp->st_dev;
805 		supports_acls = 0;
806 
807 		ret = lpathconf(name, _PC_ACL_NFS4);
808 		if (ret > 0) {
809 			type = ACL_TYPE_NFS4;
810 			supports_acls = 1;
811 		} else if (ret < 0 && errno != EINVAL) {
812 			warn("%s", name);
813 			return;
814 		}
815 		if (supports_acls == 0) {
816 			ret = lpathconf(name, _PC_ACL_EXTENDED);
817 			if (ret > 0) {
818 				type = ACL_TYPE_ACCESS;
819 				supports_acls = 1;
820 			} else if (ret < 0 && errno != EINVAL) {
821 				warn("%s", name);
822 				return;
823 			}
824 		}
825 	}
826 	if (supports_acls == 0)
827 		return;
828 	facl = acl_get_link_np(name, type);
829 	if (facl == NULL) {
830 		warn("%s", name);
831 		return;
832 	}
833 	if (acl_is_trivial_np(facl, &trivial)) {
834 		acl_free(facl);
835 		warn("%s", name);
836 		return;
837 	}
838 	if (!trivial)
839 		buf[10] = '+';
840 	acl_free(facl);
841 }
842