1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2012, Joyent, Inc. All rights reserved.
25 * Copyright 2015 Gary Mills
26 * Copyright 2016 Nexenta Systems, Inc. All rights reserved.
27 * Copyright 2020 Peter Tribble
28 */
29
30 /*
31 * Copyright 2017 Jason King. All rights reserved.
32 * Use is subject to license terms.
33 */
34
35 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
36 /* All Rights Reserved */
37
38 /* Copyright (c) 1987, 1988 Microsoft Corporation */
39 /* All Rights Reserved */
40
41 /*
42 * List files or directories
43 */
44
45 #include <sys/param.h>
46 #include <sys/types.h>
47 #include <sys/mkdev.h>
48 #include <sys/stat.h>
49 #include <sys/acl.h>
50
51 #include <wchar.h>
52 #include <stdio.h>
53 #include <ctype.h>
54 #include <dirent.h>
55 #include <string.h>
56 #include <locale.h>
57 #include <curses.h>
58 #include <term.h>
59 #include <termios.h>
60 #include <stdlib.h>
61 #include <widec.h>
62 #include <locale.h>
63 #include <wctype.h>
64 #include <pwd.h>
65 #include <grp.h>
66 #include <limits.h>
67 #include <fcntl.h>
68 #include <unistd.h>
69 #include <libgen.h>
70 #include <errno.h>
71 #include <aclutils.h>
72 #include <libnvpair.h>
73 #include <libcmdutils.h>
74 #include <attr.h>
75 #include <getopt.h>
76 #include <inttypes.h>
77
78 #ifndef STANDALONE
79 #define TERMINFO
80 #endif
81
82 /*
83 * -DNOTERMINFO can be defined on the cc command line to prevent
84 * the use of terminfo. This should be done on systems not having
85 * the terminfo feature(pre 6.0 systems ?).
86 * As a result, columnar listings assume 80 columns for output,
87 * unless told otherwise via the COLUMNS environment variable.
88 */
89 #ifdef NOTERMINFO
90 #undef TERMINFO
91 #endif
92
93 #include <term.h>
94
95 #define BFSIZE 16
96 /* this bit equals 1 in lflags of structure lbuf if *namep is to be used */
97 #define ISARG 0100000
98
99 /*
100 * this flag has been added to manipulate the display of S instead of 'l' when
101 * the file is not a regular file and when group execution bit is off
102 */
103 #define LS_NOTREG 010000
104
105
106 /*
107 * Date and time formats
108 *
109 * b --- abbreviated month name
110 * e --- day number
111 * Y --- year in the form ccyy
112 * H --- hour(24-hour version)
113 * M --- minute
114 * F --- yyyy-mm-dd
115 * T --- hh:mm:ss
116 * z --- time zone as hours displacement from UTC
117 * note that %F and %z are from the ISO C99 standard and are
118 * not present in older C libraries
119 */
120 #define FORMAT_OLD " %b %e %Y "
121 #define FORMAT_NEW " %b %e %H:%M "
122 #define FORMAT_LONG " %b %e %T %Y "
123 #define FORMAT_ISO_FULL " %%F %%T.%.09ld %%z "
124 #define FORMAT_ISO_LONG " %F %R "
125 #define FORMAT_ISO_NEW " %m-%d %H:%M "
126 #define FORMAT_ISO_OLD " %F "
127
128 #undef BUFSIZ
129 #define BUFSIZ 4096
130 #define FMTSIZE 50
131
132 struct ditem {
133 dev_t dev; /* directory items device number */
134 ino_t ino; /* directory items inode number */
135 struct ditem *parent; /* dir items ptr to its parent's info */
136 };
137 /* Holds boolean extended system attributes */
138 struct attrb {
139 char *name;
140 };
141 /* Holds timestamp extended system attributes */
142 struct attrtm {
143 char *name;
144 uint64_t stm;
145 uint64_t nstm;
146 };
147
148 #define LSA_NONE (0)
149 #define LSA_BOLD (1L << 0)
150 #define LSA_UNDERSCORE (1L << 1)
151 #define LSA_BLINK (1L << 2)
152 #define LSA_REVERSE (1L << 3)
153 #define LSA_CONCEALED (1L << 4)
154
155 /* these should be ordered most general to most specific */
156 typedef enum LS_CFTYPE {
157 LS_NORMAL,
158 LS_FILE,
159 LS_EXEC,
160 LS_DIR,
161 LS_LINK,
162 LS_FIFO,
163 LS_SOCK,
164 LS_DOOR,
165 LS_BLK,
166 LS_CHR,
167 LS_PORT,
168 LS_STICKY,
169 LS_ORPHAN,
170 LS_SETGID,
171 LS_SETUID,
172 LS_OTHER_WRITABLE,
173 LS_STICKY_OTHER_WRITABLE,
174 LS_PAT
175 } ls_cftype_t;
176
177 typedef struct {
178 char *sfx;
179 ls_cftype_t ftype;
180 int attr;
181 int fg;
182 int bg;
183 } ls_color_t;
184
185 struct lbuf {
186 union {
187 char lname[MAXNAMLEN]; /* used for filename in a directory */
188 char *namep; /* for name in ls-command; */
189 } ln;
190 char ltype; /* filetype */
191 ino_t lnum; /* inode number of file */
192 mode_t lflags; /* 0777 bits used as r,w,x permissions */
193 nlink_t lnl; /* number of links to file */
194 uid_t luid;
195 gid_t lgid;
196 off_t lsize; /* filesize or major/minor dev numbers */
197 blkcnt_t lblocks; /* number of file blocks */
198 timestruc_t lmtime;
199 timestruc_t lat;
200 timestruc_t lct;
201 timestruc_t lmt;
202 char *flinkto; /* symbolic link contents */
203 char acl; /* indicate there are additional acl entries */
204 int cycle; /* cycle detected flag */
205 struct ditem *ancinfo; /* maintains ancestor info */
206 acl_t *aclp; /* ACL if present */
207 struct attrb *exttr; /* boolean extended system attributes */
208 struct attrtm *extm; /* timestamp extended system attributes */
209 ls_color_t *color; /* color for entry */
210 ls_color_t *link_color; /* color for symlink */
211 };
212
213 struct dchain {
214 char *dc_name; /* path name */
215 int cycle_detected; /* cycle detected visiting this directory */
216 struct ditem *myancinfo; /* this directory's ancestry info */
217 struct dchain *dc_next; /* next directory in the chain */
218 };
219
220 static struct dchain *dfirst; /* start of the dir chain */
221 static struct dchain *cdfirst; /* start of the current dir chain */
222 static struct dchain *dtemp; /* temporary - used for linking */
223 static char *curdir; /* the current directory */
224
225 static int first = 1; /* true if first line is not yet printed */
226 static int nfiles = 0; /* number of flist entries in current use */
227 static int nargs = 0; /* number of flist entries used for arguments */
228 static int maxfils = 0; /* number of flist/lbuf entries allocated */
229 static int maxn = 0; /* number of flist entries with lbufs asigned */
230 static int quantn = 64; /* allocation growth quantum */
231
232 static struct lbuf *nxtlbf; /* ptr to next lbuf to be assigned */
233 static struct lbuf **flist; /* ptr to list of lbuf pointers */
234 static struct lbuf *gstat(char *, int, struct ditem *);
235 static char *getname(uid_t);
236 static char *getgroup(gid_t);
237 static char *getusid(uid_t);
238 static char *getgsid(gid_t);
239 static char *makename(char *, char *);
240 static void pentry(struct lbuf *);
241 static void column(void);
242 static void pmode(mode_t aflag);
243 static void selection(int *);
244 static void new_line(void);
245 static void rddir(char *, struct ditem *);
246 static int strcol(unsigned char *);
247 static void pem(struct lbuf **, struct lbuf **, int);
248 static void pdirectory(char *, int, int, int, struct ditem *);
249 static struct cachenode *findincache(struct cachenode **, long);
250 static void csi_pprintf(unsigned char *);
251 static void pprintf(char *, char *);
252 static int compar(struct lbuf **pp1, struct lbuf **pp2);
253 static void record_ancestry(char *, struct stat *, struct lbuf *,
254 int, struct ditem *);
255 static void ls_color_init(void);
256 static ls_color_t *ls_color_find(const char *, mode_t);
257 static void ls_start_color(ls_color_t *);
258 static void ls_end_color(void);
259
260 static int aflg;
261 static int atflg;
262 static int bflg;
263 static int cflg;
264 static int dflg;
265 static int eflg;
266 static int fflg;
267 static int gflg;
268 static int hflg;
269 static int iflg;
270 static int lflg;
271 static int mflg;
272 static int nflg;
273 static int oflg;
274 static int pflg;
275 static int qflg;
276 static int rflg = 1; /* init to 1 for special use in compar */
277 static int sflg;
278 static int tflg;
279 static int uflg;
280 static int Uflg;
281 static int wflg;
282 static int xflg;
283 static int Aflg;
284 static int Bflg;
285 static int Cflg;
286 static int Eflg;
287 static int Fflg;
288 static int Hflg;
289 static int Lflg;
290 static int Rflg;
291 static int Sflg;
292 static int vflg;
293 static int Vflg;
294 static int saflg; /* boolean extended system attr. */
295 static int sacnt; /* number of extended system attr. */
296 static int copt;
297 static int vopt;
298 static int tmflg; /* create time ext. system attr. */
299 static int ctm;
300 static int atm;
301 static int mtm;
302 static int crtm;
303 static int alltm;
304 static uint_t nicenum_flags;
305 static mode_t flags;
306 static int err = 0; /* Contains return code */
307 static int colorflg;
308 static int file_typeflg;
309 static int noflist = 0;
310
311 static uid_t lastuid = (uid_t)-1;
312 static gid_t lastgid = (gid_t)-1;
313 static char *lastuname = NULL;
314 static char *lastgname = NULL;
315
316 /* statreq > 0 if any of sflg, (n)lflg, tflg, Sflg, colorflg are on */
317 static int statreq;
318
319 static uint64_t block_size = 1;
320 static char *dotp = ".";
321
322 static u_longlong_t tblocks; /* number of blocks of files in a directory */
323 static time_t year, now, starttime;
324
325 static int num_cols = 80;
326 static int colwidth;
327 static int filewidth;
328 static int fixedwidth;
329 static int nomocore;
330 static int curcol;
331
332 static struct winsize win;
333
334 /* if time_fmt_new is left NULL, time_fmt_old is used for all times */
335 static const char *time_fmt_old = FORMAT_OLD; /* non-recent files */
336 static const char *time_fmt_new = FORMAT_NEW; /* recent files */
337 static int time_custom; /* != 0 if a custom format */
338 static char time_buf[FMTSIZE]; /* array to hold day and time */
339
340 static int lsc_debug;
341 static ls_color_t *lsc_match;
342 static ls_color_t *lsc_colors;
343 static size_t lsc_ncolors;
344 static char *lsc_bold;
345 static char *lsc_underline;
346 static char *lsc_blink;
347 static char *lsc_reverse;
348 static char *lsc_concealed;
349 static char *lsc_none;
350 static char *lsc_setfg;
351 static char *lsc_setbg;
352 static ls_color_t *lsc_orphan;
353
354 #define NOTWORKINGDIR(d, l) (((l) < 2) || \
355 (strcmp((d) + (l) - 2, "/.") != 0))
356
357 #define NOTPARENTDIR(d, l) (((l) < 3) || \
358 (strcmp((d) + (l) - 3, "/..") != 0))
359 /* Extended system attributes support */
360 static int get_sysxattr(char *, struct lbuf *);
361 static void set_sysattrb_display(char *, boolean_t, struct lbuf *);
362 static void set_sysattrtm_display(char *, struct lbuf *);
363 static void format_time(time_t, time_t);
364 static void print_time(struct lbuf *);
365 static void format_attrtime(struct lbuf *);
366 static void *xmalloc(size_t, struct lbuf *);
367 static void free_sysattr(struct lbuf *);
368 static nvpair_t *pair;
369 static nvlist_t *response;
370 static int acl_err;
371
372 const struct option long_options[] = {
373 { "all", no_argument, NULL, 'a' },
374 { "almost-all", no_argument, NULL, 'A' },
375 { "escape", no_argument, NULL, 'b' },
376 { "classify", no_argument, NULL, 'F' },
377 { "human-readable", no_argument, NULL, 'h' },
378 { "dereference", no_argument, NULL, 'L' },
379 { "dereference-command-line", no_argument, NULL, 'H' },
380 { "ignore-backups", no_argument, NULL, 'B' },
381 { "inode", no_argument, NULL, 'i' },
382 { "numeric-uid-gid", no_argument, NULL, 'n' },
383 { "no-group", no_argument, NULL, 'o' },
384 { "hide-control-chars", no_argument, NULL, 'q' },
385 { "reverse", no_argument, NULL, 'r' },
386 { "recursive", no_argument, NULL, 'R' },
387 { "size", no_argument, NULL, 's' },
388 { "width", required_argument, NULL, 'w' },
389
390 /* no short options for these */
391 { "block-size", required_argument, NULL, 0 },
392 { "full-time", no_argument, NULL, 0 },
393 { "si", no_argument, NULL, 0 },
394 { "color", optional_argument, NULL, 0 },
395 { "colour", optional_argument, NULL, 0},
396 { "file-type", no_argument, NULL, 0 },
397 { "time-style", required_argument, NULL, 0 },
398
399 {0, 0, 0, 0}
400 };
401
402 int
main(int argc,char * argv[])403 main(int argc, char *argv[])
404 {
405 int c;
406 int i;
407 int width;
408 int amino = 0;
409 int opterr = 0;
410 int option_index = 0;
411 struct lbuf *ep;
412 struct lbuf lb;
413 struct ditem *myinfo = NULL;
414
415 (void) setlocale(LC_ALL, "");
416 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
417 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
418 #endif
419 (void) textdomain(TEXT_DOMAIN);
420 #ifdef STANDALONE
421 if (argv[0][0] == '\0')
422 argc = getargv("ls", &argv, 0);
423 #endif
424
425 lb.lmtime.tv_sec = starttime = time(NULL);
426 lb.lmtime.tv_nsec = 0;
427 year = lb.lmtime.tv_sec - 6L*30L*24L*60L*60L; /* 6 months ago */
428 now = lb.lmtime.tv_sec + 60;
429 if (isatty(1)) {
430 Cflg = 1;
431 mflg = 0;
432 }
433
434 while ((c = getopt_long(argc, argv,
435 "+aAbBcCdeEfFghHiklLmnopqrRsStuUw:x1@vV/:%:", long_options,
436 &option_index)) != -1)
437 switch (c) {
438 case 0:
439 /* non-short options */
440 if (strcmp(long_options[option_index].name,
441 "color") == 0 ||
442 strcmp(long_options[option_index].name,
443 "colour") == 0) {
444 if (optarg == NULL ||
445 strcmp(optarg, "always") == 0 ||
446 strcmp(optarg, "yes") == 0 ||
447 strcmp(optarg, "force") == 0) {
448 colorflg++;
449 statreq++;
450 continue;
451 }
452
453 if (strcmp(optarg, "auto") == 0 ||
454 strcmp(optarg, "tty") == 0 ||
455 strcmp(optarg, "if-tty") == 0) {
456 if (isatty(1) == 1) {
457 colorflg++;
458 statreq++;
459 }
460 continue;
461 }
462
463 if (strcmp(optarg, "never") == 0 ||
464 strcmp(optarg, "no") == 0 ||
465 strcmp(optarg, "none") == 0) {
466 colorflg = 0;
467 continue;
468 }
469 (void) fprintf(stderr,
470 gettext("Invalid argument '%s' for "
471 "--color\n"), optarg);
472 ++opterr;
473 continue;
474 }
475
476 if (strcmp(long_options[option_index].name,
477 "si") == 0) {
478 hflg++;
479 nicenum_flags |= NN_DIVISOR_1000;
480 continue;
481 }
482
483 if (strcmp(long_options[option_index].name,
484 "block-size") == 0) {
485 size_t scale_len = strlen(optarg);
486 uint64_t scale = 1;
487 uint64_t kilo = 1024;
488 char scale_c;
489
490 if (scale_len == 0) {
491 (void) fprintf(stderr, gettext(
492 "Invalid block size \'%s\'\n"),
493 optarg);
494 exit(1);
495 }
496
497 scale_c = optarg[scale_len - 1];
498 if (scale_c == 'B') {
499 /* need at least digit, scale, B */
500 if (scale_len < 3) {
501 (void) fprintf(stderr, gettext(
502 "Invalid block size "
503 "\'%s\'\n"), optarg);
504 exit(1);
505 }
506 kilo = 1000;
507 scale_c = optarg[scale_len - 2];
508 if (isdigit(scale_c)) {
509 (void) fprintf(stderr,
510 gettext("Invalid block size"
511 " \'%s\'\n"), optarg);
512 exit(1);
513 }
514 /*
515 * make optarg[scale_len - 1] point to
516 * the scale factor
517 */
518 --scale_len;
519 }
520
521 switch (scale_c) {
522 case 'y':
523 case 'Y':
524 scale *= kilo;
525 /*FALLTHROUGH*/
526 case 'Z':
527 case 'z':
528 scale *= kilo;
529 /*FALLTHROUGH*/
530 case 'E':
531 case 'e':
532 scale *= kilo;
533 /*FALLTHROUGH*/
534 case 'P':
535 case 'p':
536 scale *= kilo;
537 /*FALLTHROUGH*/
538 case 'T':
539 case 't':
540 scale *= kilo;
541 /*FALLTHROUGH*/
542 case 'G':
543 case 'g':
544 scale *= kilo;
545 /*FALLTHROUGH*/
546 case 'M':
547 case 'm':
548 scale *= kilo;
549 /*FALLTHROUGH*/
550 case 'K':
551 case 'k':
552 scale *= kilo;
553 break;
554 default:
555 if (!isdigit(scale_c)) {
556 (void) fprintf(stderr,
557 gettext("Invalid character "
558 "following block size in "
559 "\'%s\'\n"), optarg);
560 exit(1);
561 }
562 }
563
564 /* NULL out scale constant if present */
565 if (scale > 1 && !isdigit(scale_c))
566 optarg[scale_len - 1] = '\0';
567
568 /* Based on testing, this is what GNU ls does */
569 block_size = strtoll(optarg, NULL, 0) * scale;
570 if (block_size < 1) {
571 (void) fprintf(stderr,
572 gettext("Invalid block size "
573 "\'%s\'\n"), optarg);
574 exit(1);
575 }
576 continue;
577 }
578
579 if (strcmp(long_options[option_index].name,
580 "file-type") == 0) {
581 file_typeflg++;
582 Fflg++;
583 statreq++;
584 continue;
585 }
586
587
588 if (strcmp(long_options[option_index].name,
589 "full-time") == 0) {
590 Eflg++;
591 statreq++;
592 eflg = 0;
593 time_fmt_old = FORMAT_ISO_FULL;
594 time_fmt_new = FORMAT_ISO_FULL;
595 continue;
596 }
597
598 if (strcmp(long_options[option_index].name,
599 "time-style") == 0) {
600 /* like -E, but doesn't imply -l */
601 if (strcmp(optarg, "full-iso") == 0) {
602 Eflg++;
603 statreq++;
604 eflg = 0;
605 time_fmt_old = FORMAT_ISO_FULL;
606 time_fmt_new = FORMAT_ISO_FULL;
607 continue;
608 }
609 if (strcmp(optarg, "long-iso") == 0) {
610 statreq++;
611 Eflg = 0;
612 eflg = 0;
613 time_fmt_old = FORMAT_ISO_LONG;
614 time_fmt_new = FORMAT_ISO_LONG;
615 continue;
616 }
617 if (strcmp(optarg, "iso") == 0) {
618 statreq++;
619 Eflg = 0;
620 eflg = 0;
621 time_fmt_old = FORMAT_ISO_OLD;
622 time_fmt_new = FORMAT_ISO_NEW;
623 continue;
624 }
625 /* should be the default */
626 if (strcmp(optarg, "locale") == 0) {
627 time_fmt_old = FORMAT_OLD;
628 time_fmt_new = FORMAT_NEW;
629 continue;
630 }
631 if (optarg[0] == '+') {
632 char *told, *tnew;
633 char *p;
634 size_t timelen = strlen(optarg);
635
636 p = strchr(optarg, '\n');
637 if (p != NULL)
638 *p++ = '\0';
639
640 /*
641 * Time format requires a leading and
642 * trailing space
643 * Add room for 3 spaces + 2 nulls
644 * The + in optarg is replaced with
645 * a space.
646 */
647 timelen += 2 + 3;
648 told = malloc(timelen);
649 if (told == NULL) {
650 perror("ls");
651 exit(2);
652 }
653
654 (void) memset(told, 0, timelen);
655 told[0] = ' ';
656 (void) strlcat(told, &optarg[1],
657 timelen);
658 (void) strlcat(told, " ", timelen);
659
660 if (p != NULL) {
661 size_t tnew_len;
662
663 tnew = told + strlen(told) + 1;
664 tnew_len = timelen -
665 strlen(told) - 1;
666
667 tnew[0] = ' ';
668 (void) strlcat(tnew, p,
669 tnew_len);
670 (void) strlcat(tnew, " ",
671 tnew_len);
672 time_fmt_new =
673 (const char *)tnew;
674 } else {
675 time_fmt_new =
676 (const char *)told;
677 }
678
679 time_fmt_old = (const char *)told;
680 time_custom = 1;
681 continue;
682 }
683 continue;
684 }
685
686 continue;
687
688 case 'a':
689 aflg++;
690 continue;
691 case 'A':
692 Aflg++;
693 continue;
694 case 'b':
695 bflg = 1;
696 qflg = 0;
697 continue;
698 case 'B':
699 Bflg = 1;
700 continue;
701 case 'c':
702 uflg = 0;
703 atm = 0;
704 ctm = 0;
705 mtm = 0;
706 crtm = 0;
707 cflg++;
708 continue;
709 case 'C':
710 Cflg = 1;
711 mflg = 0;
712 #ifdef XPG4
713 lflg = 0;
714 #endif
715 continue;
716 case 'd':
717 dflg++;
718 continue;
719 case 'e':
720 eflg++;
721 lflg++;
722 statreq++;
723 Eflg = 0;
724 time_fmt_old = FORMAT_LONG;
725 time_fmt_new = FORMAT_LONG;
726 continue;
727 case 'E':
728 Eflg++;
729 lflg++;
730 statreq++;
731 eflg = 0;
732 time_fmt_old = FORMAT_ISO_FULL;
733 time_fmt_new = FORMAT_ISO_FULL;
734 continue;
735 case 'f':
736 fflg++;
737 continue;
738 case 'F':
739 Fflg++;
740 statreq++;
741 continue;
742 case 'g':
743 gflg++;
744 lflg++;
745 statreq++;
746 continue;
747 case 'h':
748 hflg++;
749 continue;
750 case 'H':
751 Hflg++;
752 /* -H and -L are mutually exclusive */
753 Lflg = 0;
754 continue;
755 case 'i':
756 iflg++;
757 continue;
758 case 'k':
759 block_size = 1024;
760 continue;
761 case 'l':
762 lflg++;
763 statreq++;
764 Cflg = 0;
765 xflg = 0;
766 mflg = 0;
767 atflg = 0;
768 continue;
769 case 'L':
770 Lflg++;
771 /* -H and -L are mutually exclusive */
772 Hflg = 0;
773 continue;
774 case 'm':
775 Cflg = 0;
776 mflg = 1;
777 #ifdef XPG4
778 lflg = 0;
779 #endif
780 continue;
781 case 'n':
782 nflg++;
783 lflg++;
784 statreq++;
785 Cflg = 0;
786 xflg = 0;
787 mflg = 0;
788 atflg = 0;
789 continue;
790 case 'o':
791 oflg++;
792 lflg++;
793 statreq++;
794 continue;
795 case 'p':
796 pflg++;
797 statreq++;
798 continue;
799 case 'q':
800 qflg = 1;
801 bflg = 0;
802 continue;
803 case 'r':
804 rflg = -1;
805 continue;
806 case 'R':
807 Rflg++;
808 statreq++;
809 continue;
810 case 's':
811 sflg++;
812 statreq++;
813 continue;
814 case 'S':
815 tflg = 0;
816 Uflg = 0;
817 Sflg++;
818 statreq++;
819 continue;
820 case 't':
821 Sflg = 0;
822 Uflg = 0;
823 tflg++;
824 statreq++;
825 continue;
826 case 'U':
827 Sflg = 0;
828 tflg = 0;
829 Uflg++;
830 continue;
831 case 'u':
832 cflg = 0;
833 atm = 0;
834 ctm = 0;
835 mtm = 0;
836 crtm = 0;
837 uflg++;
838 continue;
839 case 'V':
840 Vflg++;
841 /*FALLTHROUGH*/
842 case 'v':
843 vflg++;
844 #if !defined(XPG4)
845 if (lflg)
846 continue;
847 #endif
848 lflg++;
849 statreq++;
850 Cflg = 0;
851 xflg = 0;
852 mflg = 0;
853 continue;
854 case 'w':
855 wflg++;
856 num_cols = atoi(optarg);
857 continue;
858 case 'x':
859 xflg = 1;
860 Cflg = 1;
861 mflg = 0;
862 #ifdef XPG4
863 lflg = 0;
864 #endif
865 continue;
866 case '1':
867 Cflg = 0;
868 continue;
869 case '@':
870 #if !defined(XPG4)
871 /*
872 * -l has precedence over -@
873 */
874 if (lflg)
875 continue;
876 #endif
877 atflg++;
878 lflg++;
879 statreq++;
880 Cflg = 0;
881 xflg = 0;
882 mflg = 0;
883 continue;
884 case '/':
885 saflg++;
886 if (optarg != NULL) {
887 if (strcmp(optarg, "c") == 0) {
888 copt++;
889 vopt = 0;
890 } else if (strcmp(optarg, "v") == 0) {
891 vopt++;
892 copt = 0;
893 } else
894 opterr++;
895 } else
896 opterr++;
897 lflg++;
898 statreq++;
899 Cflg = 0;
900 xflg = 0;
901 mflg = 0;
902 continue;
903 case '%':
904 tmflg++;
905 if (optarg != NULL) {
906 if (strcmp(optarg, "ctime") == 0) {
907 ctm++;
908 atm = 0;
909 mtm = 0;
910 crtm = 0;
911 } else if (strcmp(optarg, "atime") == 0) {
912 atm++;
913 ctm = 0;
914 mtm = 0;
915 crtm = 0;
916 uflg = 0;
917 cflg = 0;
918 } else if (strcmp(optarg, "mtime") == 0) {
919 mtm++;
920 atm = 0;
921 ctm = 0;
922 crtm = 0;
923 uflg = 0;
924 cflg = 0;
925 } else if (strcmp(optarg, "crtime") == 0) {
926 crtm++;
927 atm = 0;
928 ctm = 0;
929 mtm = 0;
930 uflg = 0;
931 cflg = 0;
932 } else if (strcmp(optarg, "all") == 0) {
933 alltm++;
934 atm = 0;
935 ctm = 0;
936 mtm = 0;
937 crtm = 0;
938 } else
939 opterr++;
940 } else
941 opterr++;
942
943 Sflg = 0;
944 statreq++;
945 mflg = 0;
946 continue;
947 case '?':
948 opterr++;
949 continue;
950 }
951
952 if (opterr) {
953 (void) fprintf(stderr, gettext(
954 "usage: ls -aAbBcCdeEfFghHiklLmnopqrRsStuUwxvV1@/%[c | v]"
955 "%%[atime | crtime | ctime | mtime | all]"
956 " [files]\n"));
957 exit(2);
958 }
959
960 if (fflg) {
961 aflg++;
962 lflg = 0;
963 sflg = 0;
964 tflg = 0;
965 Sflg = 0;
966 statreq = 0;
967 }
968
969 fixedwidth = 2;
970 if (pflg || Fflg)
971 fixedwidth++;
972 if (iflg)
973 fixedwidth += 11;
974 if (sflg)
975 fixedwidth += 5;
976
977 if (lflg) {
978 if (!gflg && !oflg)
979 gflg = oflg = 1;
980 else
981 if (gflg && oflg)
982 gflg = oflg = 0;
983 Cflg = mflg = 0;
984 }
985
986 if (!wflg && (Cflg || mflg)) {
987 char *clptr;
988 if ((clptr = getenv("COLUMNS")) != NULL)
989 num_cols = atoi(clptr);
990 #ifdef TERMINFO
991 else {
992 if (ioctl(1, TIOCGWINSZ, &win) != -1)
993 num_cols = (win.ws_col == 0 ? 80 : win.ws_col);
994 }
995 #endif
996 }
997
998 /*
999 * When certain options (-f, or -U and -1, and not -l, etc.) are
1000 * specified, don't cache each dirent as it's read. This 'noflist'
1001 * option is set when there's no need to cache those dirents; instead,
1002 * print them out as they're read.
1003 */
1004 if ((Uflg || fflg) && !Cflg && !lflg && !iflg && statreq == 0)
1005 noflist = 1;
1006
1007 if (num_cols < 20 || num_cols > 1000)
1008 /* assume it is an error */
1009 num_cols = 80;
1010
1011 /* allocate space for flist and the associated */
1012 /* data structures (lbufs) */
1013 maxfils = quantn;
1014 if (((flist = malloc(maxfils * sizeof (struct lbuf *))) == NULL) ||
1015 ((nxtlbf = malloc(quantn * sizeof (struct lbuf))) == NULL)) {
1016 perror("ls");
1017 exit(2);
1018 }
1019 if ((amino = (argc-optind)) == 0) {
1020 /*
1021 * case when no names are given
1022 * in ls-command and current
1023 * directory is to be used
1024 */
1025 argv[optind] = dotp;
1026 }
1027
1028 if (colorflg)
1029 ls_color_init();
1030
1031 for (i = 0; i < (amino ? amino : 1); i++) {
1032
1033 /*
1034 * If we are recursing, we need to make sure we don't
1035 * get into an endless loop. To keep track of the inodes
1036 * (actually, just the directories) visited, we
1037 * maintain a directory ancestry list for a file
1038 * hierarchy. As we go deeper into the hierarchy,
1039 * a parent directory passes its directory list
1040 * info (device id, inode number, and a pointer to
1041 * its parent) to each of its children. As we
1042 * process a child that is a directory, we save
1043 * its own personal directory list info. We then
1044 * check to see if the child has already been
1045 * processed by comparing its device id and inode
1046 * number from its own personal directory list info
1047 * to that of each of its ancestors. If there is a
1048 * match, then we know we've detected a cycle.
1049 */
1050 if (Rflg) {
1051 /*
1052 * This is the first parent in this lineage
1053 * (first in a directory hierarchy), so
1054 * this parent's parent doesn't exist. We
1055 * only initialize myinfo when we are
1056 * recursing, otherwise it's not used.
1057 */
1058 if ((myinfo = (struct ditem *)malloc(
1059 sizeof (struct ditem))) == NULL) {
1060 perror("ls");
1061 exit(2);
1062 } else {
1063 myinfo->dev = 0;
1064 myinfo->ino = 0;
1065 myinfo->parent = NULL;
1066 }
1067 }
1068
1069 if (Cflg || mflg) {
1070 width = strcol((unsigned char *)argv[optind]);
1071 if (width > filewidth)
1072 filewidth = width;
1073 }
1074 if ((ep = gstat((*argv[optind] ? argv[optind] : dotp),
1075 1, myinfo)) == NULL) {
1076 if (nomocore)
1077 exit(2);
1078 err = 2;
1079 optind++;
1080 continue;
1081 }
1082 ep->ln.namep = (*argv[optind] ? argv[optind] : dotp);
1083 ep->lflags |= ISARG;
1084 optind++;
1085 nargs++; /* count good arguments stored in flist */
1086 if (acl_err)
1087 err = 2;
1088 }
1089 colwidth = fixedwidth + filewidth;
1090 if (!Uflg)
1091 qsort(flist, (unsigned)nargs, sizeof (struct lbuf *),
1092 (int (*)(const void *, const void *))compar);
1093 for (i = 0; i < nargs; i++) {
1094 if ((flist[i]->ltype == 'd' && dflg == 0) || fflg)
1095 break;
1096 }
1097
1098 pem(&flist[0], &flist[i], 0);
1099 for (; i < nargs; i++) {
1100 pdirectory(flist[i]->ln.namep, Rflg ||
1101 (amino > 1), nargs, 0, flist[i]->ancinfo);
1102 if (nomocore)
1103 exit(2);
1104 /* -R: print subdirectories found */
1105 while (dfirst || cdfirst) {
1106 /* Place direct subdirs on front in right order */
1107 while (cdfirst) {
1108 /* reverse cdfirst onto front of dfirst */
1109 dtemp = cdfirst;
1110 cdfirst = cdfirst -> dc_next;
1111 dtemp -> dc_next = dfirst;
1112 dfirst = dtemp;
1113 }
1114 /* take off first dir on dfirst & print it */
1115 dtemp = dfirst;
1116 dfirst = dfirst->dc_next;
1117 pdirectory(dtemp->dc_name, 1, nargs,
1118 dtemp->cycle_detected, dtemp->myancinfo);
1119 if (nomocore)
1120 exit(2);
1121 free(dtemp->dc_name);
1122 free(dtemp);
1123 }
1124 }
1125
1126 return (err);
1127 }
1128
1129 /*
1130 * pdirectory: print the directory name, labelling it if title is
1131 * nonzero, using lp as the place to start reading in the dir.
1132 */
1133 static void
pdirectory(char * name,int title,int lp,int cdetect,struct ditem * myinfo)1134 pdirectory(char *name, int title, int lp, int cdetect, struct ditem *myinfo)
1135 {
1136 struct dchain *dp;
1137 struct lbuf *ap;
1138 char *pname;
1139 int j;
1140
1141 filewidth = 0;
1142 curdir = name;
1143 if (title) {
1144 if (!first)
1145 (void) putc('\n', stdout);
1146 pprintf(name, ":");
1147 new_line();
1148 }
1149 /*
1150 * If there was a cycle detected, then notify and don't report
1151 * further.
1152 */
1153 if (cdetect) {
1154 if (lflg || sflg) {
1155 curcol += printf(gettext("total %d"), 0);
1156 new_line();
1157 }
1158 (void) fprintf(stderr, gettext(
1159 "ls: cycle detected for %s\n"), name);
1160 return;
1161 }
1162
1163 nfiles = lp;
1164 rddir(name, myinfo);
1165 if (nomocore || noflist)
1166 return;
1167 if (fflg == 0 && Uflg == 0)
1168 qsort(&flist[lp], (unsigned)(nfiles - lp),
1169 sizeof (struct lbuf *),
1170 (int (*)(const void *, const void *))compar);
1171 if (Rflg) {
1172 for (j = nfiles - 1; j >= lp; j--) {
1173 ap = flist[j];
1174 if (ap->ltype == 'd' && strcmp(ap->ln.lname, ".") &&
1175 strcmp(ap->ln.lname, "..")) {
1176 dp = malloc(sizeof (struct dchain));
1177 if (dp == NULL) {
1178 perror("ls");
1179 exit(2);
1180 }
1181 pname = makename(curdir, ap->ln.lname);
1182 if ((dp->dc_name = strdup(pname)) == NULL) {
1183 perror("ls");
1184 exit(2);
1185 }
1186 dp->cycle_detected = ap->cycle;
1187 dp->myancinfo = ap->ancinfo;
1188 dp->dc_next = dfirst;
1189 dfirst = dp;
1190 }
1191 }
1192 }
1193 if (lflg || sflg) {
1194 curcol += printf(gettext("total %llu"), tblocks);
1195 new_line();
1196 }
1197 pem(&flist[lp], &flist[nfiles], lflg||sflg);
1198 }
1199
1200 /*
1201 * pem: print 'em. Print a list of files (e.g. a directory) bounded
1202 * by slp and lp.
1203 */
1204 static void
pem(struct lbuf ** slp,struct lbuf ** lp,int tot_flag)1205 pem(struct lbuf **slp, struct lbuf **lp, int tot_flag)
1206 {
1207 long row, nrows, i;
1208 int col, ncols = 1;
1209 struct lbuf **ep;
1210
1211 if (Cflg || mflg) {
1212 if (colwidth <= num_cols) {
1213 ncols = num_cols / colwidth;
1214 }
1215 }
1216
1217 if (ncols == 1 || mflg || xflg || !Cflg) {
1218 for (ep = slp; ep < lp; ep++)
1219 pentry(*ep);
1220 new_line();
1221 return;
1222 }
1223 /* otherwise print -C columns */
1224 if (tot_flag) {
1225 slp--;
1226 row = 1;
1227 }
1228 else
1229 row = 0;
1230
1231 nrows = (lp - slp - 1) / ncols + 1;
1232 for (i = 0; i < nrows; i++, row++) {
1233 for (col = 0; col < ncols; col++) {
1234 ep = slp + (nrows * col) + row;
1235 if (ep < lp)
1236 pentry(*ep);
1237 }
1238 new_line();
1239 }
1240 }
1241
1242 /*
1243 * print one output entry;
1244 * if uid/gid is not found in the appropriate
1245 * file(passwd/group), then print uid/gid instead of
1246 * user/group name;
1247 */
1248 static void
pentry(struct lbuf * ap)1249 pentry(struct lbuf *ap)
1250 {
1251 struct lbuf *p;
1252 char *dmark = ""; /* Used if -p or -F option active */
1253 char *cp;
1254 char *str;
1255
1256 if (noflist) {
1257 (void) printf("%s\n", (ap->lflags & ISARG) ? ap->ln.namep :
1258 ap->ln.lname);
1259 return;
1260 }
1261
1262 p = ap;
1263 column();
1264 if (iflg) {
1265 if (mflg && !lflg)
1266 curcol += printf("%llu ", (long long)p->lnum);
1267 else
1268 curcol += printf("%10llu ", (long long)p->lnum);
1269 }
1270 if (sflg) {
1271 curcol += printf((mflg && !lflg) ? "%lld " :
1272 (p->lblocks < 10000) ? "%4lld " : "%lld ",
1273 (p->ltype != 'b' && p->ltype != 'c') ?
1274 p->lblocks : 0LL);
1275 }
1276 if (lflg) {
1277 (void) putchar(p->ltype);
1278 curcol++;
1279 pmode(p->lflags);
1280
1281 /* ACL: additional access mode flag */
1282 (void) putchar(p->acl);
1283 curcol++;
1284
1285 /*
1286 * When handling owner/group options (-o -g) note -n:
1287 * With no -n options, getname/getroup converts any
1288 * ephemeral IDs to a winname (if possible) or a SID.
1289 * With just one -n option, convert ephemeral IDs to SIDs
1290 * With two or more -n options, show the ephemeral ID
1291 * (which is a lot less helpful than the SID).
1292 */
1293 curcol += printf("%3lu ", (ulong_t)p->lnl);
1294 if (oflg) {
1295 if (nflg == 0) {
1296 cp = getname(p->luid);
1297 curcol += printf("%-8s ", cp);
1298 } else if (nflg == 1 && p->luid > MAXUID) {
1299 cp = getusid(p->luid);
1300 curcol += printf("%-8s ", cp);
1301 } else {
1302 curcol += printf("%-8lu ", (ulong_t)p->luid);
1303 }
1304 }
1305 if (gflg) {
1306 if (nflg == 0) {
1307 cp = getgroup(p->lgid);
1308 curcol += printf("%-8s ", cp);
1309 } else if (nflg == 1 && p->lgid > MAXUID) {
1310 cp = getgsid(p->lgid);
1311 curcol += printf("%-8s ", cp);
1312 } else {
1313 curcol += printf("%-8lu ", (ulong_t)p->lgid);
1314 }
1315 }
1316 if (p->ltype == 'b' || p->ltype == 'c') {
1317 curcol += printf("%3u, %2u",
1318 (uint_t)major((dev_t)p->lsize),
1319 (uint_t)minor((dev_t)p->lsize));
1320 } else if (hflg) {
1321 char numbuf[NN_NUMBUF_SZ];
1322
1323 nicenum_scale(p->lsize, 1, numbuf, sizeof (numbuf),
1324 nicenum_flags);
1325
1326 curcol += printf("%7s", numbuf);
1327 } else {
1328 uint64_t bsize = p->lsize / block_size;
1329
1330 /*
1331 * Round up only when using blocks > 1 byte, otherwise
1332 * 'normal' sizes display 1 byte too large.
1333 */
1334 if (p->lsize % block_size != 0)
1335 bsize++;
1336
1337 curcol += printf("%7" PRIu64, bsize);
1338 }
1339 format_time(p->lmtime.tv_sec, p->lmtime.tv_nsec);
1340 /* format extended system attribute time */
1341 if (tmflg && crtm)
1342 format_attrtime(p);
1343
1344 curcol += printf("%s", time_buf);
1345
1346 }
1347 /*
1348 * prevent both "->" and trailing marks
1349 * from appearing
1350 */
1351
1352 if (pflg && p->ltype == 'd')
1353 dmark = "/";
1354
1355 if (Fflg && !(lflg && p->flinkto)) {
1356 if (p->ltype == 'd')
1357 dmark = "/";
1358 else if (p->ltype == 'D')
1359 dmark = ">";
1360 else if (p->ltype == 'p')
1361 dmark = "|";
1362 else if (p->ltype == 'l')
1363 dmark = "@";
1364 else if (p->ltype == 's')
1365 dmark = "=";
1366 else if (!file_typeflg &&
1367 (p->lflags & (S_IXUSR|S_IXGRP|S_IXOTH)))
1368 dmark = "*";
1369 else
1370 dmark = "";
1371 }
1372
1373 if (colorflg)
1374 ls_start_color(p->color);
1375
1376 if (p->lflags & ISARG)
1377 str = p->ln.namep;
1378 else
1379 str = p->ln.lname;
1380
1381 if (qflg || bflg) {
1382 csi_pprintf((unsigned char *)str);
1383
1384 if (lflg && p->flinkto) {
1385 if (colorflg)
1386 ls_end_color();
1387 csi_pprintf((unsigned char *)" -> ");
1388 if (colorflg)
1389 ls_start_color(p->link_color);
1390 csi_pprintf((unsigned char *)p->flinkto);
1391 } else {
1392 csi_pprintf((unsigned char *)dmark);
1393 }
1394 } else {
1395 (void) printf("%s", str);
1396 curcol += strcol((unsigned char *)str);
1397
1398 if (lflg && p->flinkto) {
1399 if (colorflg)
1400 ls_end_color();
1401 str = " -> ";
1402 (void) printf("%s", str);
1403 curcol += strcol((unsigned char *)str);
1404 if (colorflg)
1405 ls_start_color(p->link_color);
1406 (void) printf("%s", p->flinkto);
1407 curcol += strcol((unsigned char *)p->flinkto);
1408 } else {
1409 (void) printf("%s", dmark);
1410 curcol += strcol((unsigned char *)dmark);
1411 }
1412 }
1413
1414 if (colorflg)
1415 ls_end_color();
1416
1417 /* Display extended system attributes */
1418 if (saflg) {
1419 int i;
1420
1421 new_line();
1422 (void) printf(" \t{");
1423 if (p->exttr != NULL) {
1424 int k = 0;
1425 for (i = 0; i < sacnt; i++) {
1426 if (p->exttr[i].name != NULL)
1427 k++;
1428 }
1429 for (i = 0; i < sacnt; i++) {
1430 if (p->exttr[i].name != NULL) {
1431 (void) printf("%s", p->exttr[i].name);
1432 k--;
1433 if (vopt && (k != 0))
1434 (void) printf(",");
1435 }
1436 }
1437 }
1438 (void) printf("}\n");
1439 }
1440 /* Display file timestamps and extended system attribute timestamps */
1441 if (tmflg && alltm) {
1442 new_line();
1443 print_time(p);
1444 new_line();
1445 }
1446 if (vflg) {
1447 new_line();
1448 if (p->aclp) {
1449 int pa_flags = 0;
1450
1451 if (Vflg)
1452 pa_flags |= ACL_COMPACT_FMT;
1453 if (nflg)
1454 pa_flags |= ACL_NORESOLVE;
1455 if (nflg < 2)
1456 pa_flags |= ACL_SID_FMT;
1457
1458 acl_printacl2(p->aclp, num_cols, pa_flags);
1459 }
1460 }
1461 /* Free extended system attribute lists */
1462 if (saflg || tmflg)
1463 free_sysattr(p);
1464 }
1465
1466 /* print various r,w,x permissions */
1467 static void
pmode(mode_t aflag)1468 pmode(mode_t aflag)
1469 {
1470 /* these arrays are declared static to allow initializations */
1471 static int m0[] = { 1, S_IRUSR, 'r', '-' };
1472 static int m1[] = { 1, S_IWUSR, 'w', '-' };
1473 static int m2[] = { 3, S_ISUID|S_IXUSR, 's', S_IXUSR,
1474 'x', S_ISUID, 'S', '-' };
1475 static int m3[] = { 1, S_IRGRP, 'r', '-' };
1476 static int m4[] = { 1, S_IWGRP, 'w', '-' };
1477 static int m5[] = { 4, S_ISGID|S_IXGRP, 's', S_IXGRP,
1478 'x', S_ISGID|LS_NOTREG, 'S',
1479 #ifdef XPG4
1480 S_ISGID, 'L', '-'};
1481 #else
1482 S_ISGID, 'l', '-'};
1483 #endif
1484 static int m6[] = { 1, S_IROTH, 'r', '-' };
1485 static int m7[] = { 1, S_IWOTH, 'w', '-' };
1486 static int m8[] = { 3, S_ISVTX|S_IXOTH, 't', S_IXOTH,
1487 'x', S_ISVTX, 'T', '-'};
1488
1489 static int *m[] = { m0, m1, m2, m3, m4, m5, m6, m7, m8};
1490
1491 int **mp;
1492
1493 flags = aflag;
1494 for (mp = &m[0]; mp < &m[sizeof (m) / sizeof (m[0])]; mp++)
1495 selection(*mp);
1496 }
1497
1498 static void
selection(int * pairp)1499 selection(int *pairp)
1500 {
1501 int n;
1502
1503 n = *pairp++;
1504 while (n-->0) {
1505 if ((flags & *pairp) == *pairp) {
1506 pairp++;
1507 break;
1508 } else {
1509 pairp += 2;
1510 }
1511 }
1512 (void) putchar(*pairp);
1513 curcol++;
1514 }
1515
1516 /*
1517 * column: get to the beginning of the next column.
1518 */
1519 static void
column(void)1520 column(void)
1521 {
1522 if (curcol == 0)
1523 return;
1524 if (mflg) {
1525 (void) putc(',', stdout);
1526 curcol++;
1527 if (curcol + colwidth + 2 > num_cols) {
1528 (void) putc('\n', stdout);
1529 curcol = 0;
1530 return;
1531 }
1532 (void) putc(' ', stdout);
1533 curcol++;
1534 return;
1535 }
1536 if (Cflg == 0) {
1537 (void) putc('\n', stdout);
1538 curcol = 0;
1539 return;
1540 }
1541 if ((curcol / colwidth + 2) * colwidth > num_cols) {
1542 (void) putc('\n', stdout);
1543 curcol = 0;
1544 return;
1545 }
1546 do {
1547 (void) putc(' ', stdout);
1548 curcol++;
1549 } while (curcol % colwidth);
1550 }
1551
1552 static void
new_line(void)1553 new_line(void)
1554 {
1555 if (curcol) {
1556 first = 0;
1557 (void) putc('\n', stdout);
1558 curcol = 0;
1559 }
1560 }
1561
1562 /*
1563 * read each filename in directory dir and store its
1564 * status in flist[nfiles]
1565 * use makename() to form pathname dir/filename;
1566 */
1567 static void
rddir(char * dir,struct ditem * myinfo)1568 rddir(char *dir, struct ditem *myinfo)
1569 {
1570 struct dirent *dentry;
1571 DIR *dirf;
1572 int j;
1573 struct lbuf *ep;
1574 int width;
1575
1576 if ((dirf = opendir(dir)) == NULL) {
1577 (void) fflush(stdout);
1578 perror(dir);
1579 err = 2;
1580 return;
1581 } else {
1582 tblocks = 0;
1583 for (;;) {
1584 errno = 0;
1585 if ((dentry = readdir(dirf)) == NULL)
1586 break;
1587 if (aflg == 0 && dentry->d_name[0] == '.' &&
1588 (Aflg == 0 ||
1589 dentry->d_name[1] == '\0' ||
1590 (dentry->d_name[1] == '.' &&
1591 dentry->d_name[2] == '\0')))
1592 /*
1593 * check for directory items '.', '..',
1594 * and items without valid inode-number;
1595 */
1596 continue;
1597
1598 /* skip entries ending in ~ if -B was given */
1599 if (Bflg &&
1600 dentry->d_name[strlen(dentry->d_name) - 1] == '~')
1601 continue;
1602 if (Cflg || mflg) {
1603 width = strcol((unsigned char *)dentry->d_name);
1604 if (width > filewidth)
1605 filewidth = width;
1606 }
1607 ep = gstat(makename(dir, dentry->d_name), 0, myinfo);
1608 if (ep == NULL) {
1609 if (nomocore)
1610 exit(2);
1611 continue;
1612 } else {
1613 ep->lnum = dentry->d_ino;
1614 for (j = 0; dentry->d_name[j] != '\0'; j++)
1615 ep->ln.lname[j] = dentry->d_name[j];
1616 ep->ln.lname[j] = '\0';
1617
1618 /*
1619 * Since this entry doesn't need to be sorted
1620 * or further processed, print it right away.
1621 */
1622 if (noflist) {
1623 pem(&ep, &ep + 1, 0);
1624 nfiles--;
1625 }
1626 }
1627 }
1628 if (errno) {
1629 int sav_errno = errno;
1630
1631 (void) fprintf(stderr,
1632 gettext("ls: error reading directory %s: %s\n"),
1633 dir, strerror(sav_errno));
1634 }
1635 (void) closedir(dirf);
1636 colwidth = fixedwidth + filewidth;
1637 }
1638 }
1639
1640 /*
1641 * Attaching a link to an inode's ancestors. Search
1642 * through the ancestors to check for cycles (an inode which
1643 * we have already tracked in this inodes ancestry). If a cycle
1644 * is detected, set the exit code and record the fact so that
1645 * it is reported at the right time when printing the directory.
1646 * In addition, set the exit code. Note: If the -a flag was
1647 * specified, we don't want to check for cycles for directories
1648 * ending in '/.' or '/..' unless they were specified on the
1649 * command line.
1650 */
1651 static void
record_ancestry(char * file,struct stat * pstatb,struct lbuf * rep,int argfl,struct ditem * myparent)1652 record_ancestry(char *file, struct stat *pstatb, struct lbuf *rep,
1653 int argfl, struct ditem *myparent)
1654 {
1655 size_t file_len;
1656 struct ditem *myinfo;
1657 struct ditem *tptr;
1658
1659 file_len = strlen(file);
1660 if (!aflg || argfl || (NOTWORKINGDIR(file, file_len) &&
1661 NOTPARENTDIR(file, file_len))) {
1662 /*
1663 * Add this inode's ancestry
1664 * info and insert it into the
1665 * ancestry list by pointing
1666 * back to its parent. We save
1667 * it (in rep) with the other info
1668 * we're gathering for this inode.
1669 */
1670 if ((myinfo = malloc(
1671 sizeof (struct ditem))) == NULL) {
1672 perror("ls");
1673 exit(2);
1674 }
1675 myinfo->dev = pstatb->st_dev;
1676 myinfo->ino = pstatb->st_ino;
1677 myinfo->parent = myparent;
1678 rep->ancinfo = myinfo;
1679
1680 /*
1681 * If this node has the same device id and
1682 * inode number of one of its ancestors,
1683 * then we've detected a cycle.
1684 */
1685 if (myparent != NULL) {
1686 for (tptr = myparent; tptr->parent != NULL;
1687 tptr = tptr->parent) {
1688 if ((tptr->dev == pstatb->st_dev) &&
1689 (tptr->ino == pstatb->st_ino)) {
1690 /*
1691 * Cycle detected for this
1692 * directory. Record the fact
1693 * it is a cycle so we don't
1694 * try to process this
1695 * directory as we are
1696 * walking through the
1697 * list of directories.
1698 */
1699 rep->cycle = 1;
1700 err = 2;
1701 break;
1702 }
1703 }
1704 }
1705 }
1706 }
1707
1708 /*
1709 * Do re-calculate the mode for group for ACE_T type of acls.
1710 * This is because, if the server's FS happens to be UFS, supporting
1711 * POSIX ACL's, then it does a special calculation of group mode
1712 * to be the bitwise OR of CLASS_OBJ and GROUP_OBJ (see PSARC/2001/717.)
1713 *
1714 * This algorithm is from the NFSv4 ACL Draft. Here a part of that
1715 * algorithm is used for the group mode calculation only.
1716 * What is modified here from the algorithm is that only the
1717 * entries with flags ACE_GROUP are considered. For each entry
1718 * with ACE_GROUP flag, the first occurrence of a specific access
1719 * is checked if it is allowed.
1720 * We are not interested in perms for user and other, as they
1721 * were taken from st_mode value.
1722 * We are not interested in a_who field of ACE, as we need just
1723 * unix mode bits for the group.
1724 */
1725
1726 #define OWNED_GROUP (ACE_GROUP | ACE_IDENTIFIER_GROUP)
1727 #define IS_TYPE_ALLOWED(type) ((type) == ACE_ACCESS_ALLOWED_ACE_TYPE)
1728
1729 int
grp_mask_to_mode(struct lbuf * p)1730 grp_mask_to_mode(struct lbuf *p)
1731 {
1732 int mode = 0, seen = 0;
1733 int acecnt;
1734 int flags;
1735 ace_t *ap;
1736 acl_t *acep = p->aclp;
1737
1738 acecnt = acl_cnt(acep);
1739 for (ap = (ace_t *)acl_data(acep); acecnt--; ap++) {
1740
1741 if (ap->a_type != ACE_ACCESS_ALLOWED_ACE_TYPE &&
1742 ap->a_type != ACE_ACCESS_DENIED_ACE_TYPE)
1743 continue;
1744
1745 if (ap->a_flags & ACE_INHERIT_ONLY_ACE)
1746 continue;
1747
1748 /*
1749 * if it is first group@ or first everyone@
1750 * for each of read, write and execute, then
1751 * that will be the group mode bit.
1752 */
1753 flags = ap->a_flags & ACE_TYPE_FLAGS;
1754 if (flags == OWNED_GROUP || (flags == ACE_IDENTIFIER_GROUP &&
1755 ap->a_who == p->lgid) || flags == ACE_EVERYONE) {
1756 if (ap->a_access_mask & ACE_READ_DATA) {
1757 if (!(seen & S_IRGRP)) {
1758 seen |= S_IRGRP;
1759 if (IS_TYPE_ALLOWED(ap->a_type))
1760 mode |= S_IRGRP;
1761 }
1762 }
1763 if (ap->a_access_mask & ACE_WRITE_DATA) {
1764 if (!(seen & S_IWGRP)) {
1765 seen |= S_IWGRP;
1766 if (IS_TYPE_ALLOWED(ap->a_type))
1767 mode |= S_IWGRP;
1768 }
1769 }
1770 if (ap->a_access_mask & ACE_EXECUTE) {
1771 if (!(seen & S_IXGRP)) {
1772 seen |= S_IXGRP;
1773 if (IS_TYPE_ALLOWED(ap->a_type))
1774 mode |= S_IXGRP;
1775 }
1776 }
1777 }
1778 }
1779 return (mode);
1780 }
1781
1782 /*
1783 * get status of file and recomputes tblocks;
1784 * argfl = 1 if file is a name in ls-command and = 0
1785 * for filename in a directory whose name is an
1786 * argument in the command;
1787 * stores a pointer in flist[nfiles] and
1788 * returns that pointer;
1789 * returns NULL if failed;
1790 */
1791 static struct lbuf *
gstat(char * file,int argfl,struct ditem * myparent)1792 gstat(char *file, int argfl, struct ditem *myparent)
1793 {
1794 struct stat statb, statb1;
1795 struct lbuf *rep;
1796 char buf[BUFSIZ];
1797 ssize_t cc;
1798 int (*statf)() = ((Lflg) || (Hflg && argfl)) ? stat : lstat;
1799 int aclcnt;
1800 int error;
1801 aclent_t *tp;
1802 o_mode_t groupperm, mask;
1803 int grouppermfound, maskfound;
1804
1805 if (nomocore)
1806 return (NULL);
1807
1808 if (nfiles >= maxfils) {
1809 /*
1810 * all flist/lbuf pair assigned files, time to get some
1811 * more space
1812 */
1813 maxfils += quantn;
1814 if (((flist = realloc(flist,
1815 maxfils * sizeof (struct lbuf *))) == NULL) ||
1816 ((nxtlbf = malloc(quantn *
1817 sizeof (struct lbuf))) == NULL)) {
1818 perror("ls");
1819 nomocore = 1;
1820 return (NULL);
1821 }
1822 }
1823
1824 /*
1825 * nfiles is reset to nargs for each directory
1826 * that is given as an argument maxn is checked
1827 * to prevent the assignment of an lbuf to a flist entry
1828 * that already has one assigned.
1829 */
1830 if (nfiles >= maxn) {
1831 rep = nxtlbf++;
1832 flist[nfiles++] = rep;
1833 maxn = nfiles;
1834 } else {
1835 rep = flist[nfiles++];
1836 }
1837
1838 /* Clear the lbuf */
1839 (void) memset((void *) rep, 0, sizeof (struct lbuf));
1840
1841 /*
1842 * When noflist is set, none of the extra information about the dirent
1843 * will be printed, so omit remaining initialization of this lbuf
1844 * as well as the stat(2) call.
1845 */
1846 if (!argfl && noflist)
1847 return (rep);
1848
1849 /* Initialize non-zero members */
1850 rep->lat.tv_sec = rep->lct.tv_sec = rep->lmt.tv_sec = starttime;
1851
1852 if (argfl || statreq) {
1853 int doacl;
1854
1855 if (lflg)
1856 doacl = 1;
1857 else
1858 doacl = 0;
1859
1860 if ((*statf)(file, &statb) < 0) {
1861 if (argfl || errno != ENOENT ||
1862 (Lflg && lstat(file, &statb) == 0)) {
1863 /*
1864 * Avoid race between readdir and lstat.
1865 * Print error message in case of dangling link.
1866 */
1867 perror(file);
1868 err = 2;
1869 }
1870 nfiles--;
1871 return (NULL);
1872 }
1873
1874 /*
1875 * If -H was specified, and the file linked to was
1876 * not a directory, then we need to get the info
1877 * for the symlink itself.
1878 */
1879 if ((Hflg) && (argfl) &&
1880 ((statb.st_mode & S_IFMT) != S_IFDIR)) {
1881 if (lstat(file, &statb) < 0) {
1882 perror(file);
1883 err = 2;
1884 }
1885 }
1886
1887 rep->lnum = statb.st_ino;
1888 rep->lsize = statb.st_size;
1889 rep->lblocks = statb.st_blocks;
1890 if (colorflg)
1891 rep->color = ls_color_find(file, statb.st_mode);
1892
1893 switch (statb.st_mode & S_IFMT) {
1894 case S_IFDIR:
1895 rep->ltype = 'd';
1896 if (Rflg) {
1897 record_ancestry(file, &statb, rep,
1898 argfl, myparent);
1899 }
1900 break;
1901 case S_IFBLK:
1902 rep->ltype = 'b';
1903 rep->lsize = (off_t)statb.st_rdev;
1904 break;
1905 case S_IFCHR:
1906 rep->ltype = 'c';
1907 rep->lsize = (off_t)statb.st_rdev;
1908 break;
1909 case S_IFIFO:
1910 rep->ltype = 'p';
1911 break;
1912 case S_IFSOCK:
1913 rep->ltype = 's';
1914 rep->lsize = 0;
1915 break;
1916 case S_IFLNK:
1917 /* symbolic links may not have ACLs, so elide acl() */
1918 if ((Lflg == 0) || (Hflg == 0) ||
1919 ((Hflg) && (!argfl))) {
1920 doacl = 0;
1921 }
1922 rep->ltype = 'l';
1923 if (lflg || colorflg) {
1924 cc = readlink(file, buf, BUFSIZ);
1925 if (cc < 0)
1926 break;
1927
1928 /*
1929 * follow the symbolic link
1930 * to generate the appropriate
1931 * Fflg marker for the object
1932 * eg, /bin -> /sym/bin/
1933 */
1934 error = 0;
1935 if (Fflg || pflg || colorflg)
1936 error = stat(file, &statb1);
1937
1938 if (colorflg) {
1939 if (error >= 0)
1940 rep->link_color =
1941 ls_color_find(file,
1942 statb1.st_mode);
1943 else
1944 rep->link_color =
1945 lsc_orphan;
1946 }
1947
1948 if ((Fflg || pflg) && error >= 0) {
1949 switch (statb1.st_mode & S_IFMT) {
1950 case S_IFDIR:
1951 buf[cc++] = '/';
1952 break;
1953 case S_IFSOCK:
1954 buf[cc++] = '=';
1955 break;
1956 case S_IFDOOR:
1957 buf[cc++] = '>';
1958 break;
1959 case S_IFIFO:
1960 buf[cc++] = '|';
1961 break;
1962 default:
1963 if ((statb1.st_mode & ~S_IFMT) &
1964 (S_IXUSR|S_IXGRP| S_IXOTH))
1965 buf[cc++] = '*';
1966 break;
1967 }
1968 }
1969 buf[cc] = '\0';
1970 rep->flinkto = strdup(buf);
1971 if (rep->flinkto == NULL) {
1972 perror("ls");
1973 nomocore = 1;
1974 return (NULL);
1975 }
1976 break;
1977 }
1978
1979 /*
1980 * ls /sym behaves differently from ls /sym/
1981 * when /sym is a symbolic link. This is fixed
1982 * when explicit arguments are specified.
1983 */
1984
1985 #ifdef XPG6
1986 /* Do not follow a symlink when -F is specified */
1987 if ((!argfl) || (argfl && Fflg) ||
1988 (stat(file, &statb1) < 0))
1989 #else
1990 /* Follow a symlink when -F is specified */
1991 if (!argfl || stat(file, &statb1) < 0)
1992 #endif /* XPG6 */
1993 break;
1994 if ((statb1.st_mode & S_IFMT) == S_IFDIR) {
1995 statb = statb1;
1996 rep->ltype = 'd';
1997 rep->lsize = statb1.st_size;
1998 if (Rflg) {
1999 record_ancestry(file, &statb, rep,
2000 argfl, myparent);
2001 }
2002 }
2003 break;
2004 case S_IFDOOR:
2005 rep->ltype = 'D';
2006 break;
2007 case S_IFREG:
2008 rep->ltype = '-';
2009 break;
2010 case S_IFPORT:
2011 rep->ltype = 'P';
2012 break;
2013 default:
2014 rep->ltype = '?';
2015 break;
2016 }
2017 rep->lflags = statb.st_mode & ~S_IFMT;
2018
2019 if (!S_ISREG(statb.st_mode))
2020 rep->lflags |= LS_NOTREG;
2021
2022 rep->luid = statb.st_uid;
2023 rep->lgid = statb.st_gid;
2024 rep->lnl = statb.st_nlink;
2025 if (uflg || (tmflg && atm))
2026 rep->lmtime = statb.st_atim;
2027 else if (cflg || (tmflg && ctm))
2028 rep->lmtime = statb.st_ctim;
2029 else
2030 rep->lmtime = statb.st_mtim;
2031 rep->lat = statb.st_atim;
2032 rep->lct = statb.st_ctim;
2033 rep->lmt = statb.st_mtim;
2034
2035 /* ACL: check acl entries count */
2036 if (doacl) {
2037
2038 error = acl_get(file, 0, &rep->aclp);
2039 if (error) {
2040 (void) fprintf(stderr,
2041 gettext("ls: can't read ACL on %s: %s\n"),
2042 file, acl_strerror(error));
2043 rep->acl = ' ';
2044 acl_err++;
2045 return (rep);
2046 }
2047
2048 rep->acl = ' ';
2049
2050 if (rep->aclp &&
2051 ((acl_flags(rep->aclp) & ACL_IS_TRIVIAL) == 0)) {
2052 rep->acl = '+';
2053 /*
2054 * Special handling for ufs aka aclent_t ACL's
2055 */
2056 if (acl_type(rep->aclp) == ACLENT_T) {
2057 /*
2058 * For files with non-trivial acls, the
2059 * effective group permissions are the
2060 * intersection of the GROUP_OBJ value
2061 * and the CLASS_OBJ (acl mask) value.
2062 * Determine both the GROUP_OBJ and
2063 * CLASS_OBJ for this file and insert
2064 * the logical AND of those two values
2065 * in the group permissions field
2066 * of the lflags value for this file.
2067 */
2068
2069 /*
2070 * Until found in acl list, assume
2071 * maximum permissions for both group
2072 * a nd mask. (Just in case the acl
2073 * lacks either value for some reason.)
2074 */
2075 groupperm = 07;
2076 mask = 07;
2077 grouppermfound = 0;
2078 maskfound = 0;
2079 aclcnt = acl_cnt(rep->aclp);
2080 for (tp =
2081 (aclent_t *)acl_data(rep->aclp);
2082 aclcnt--; tp++) {
2083 if (tp->a_type == GROUP_OBJ) {
2084 groupperm = tp->a_perm;
2085 grouppermfound = 1;
2086 continue;
2087 }
2088 if (tp->a_type == CLASS_OBJ) {
2089 mask = tp->a_perm;
2090 maskfound = 1;
2091 }
2092 if (grouppermfound && maskfound)
2093 break;
2094 }
2095
2096
2097 /* reset all the group bits */
2098 rep->lflags &= ~S_IRWXG;
2099
2100 /*
2101 * Now set them to the logical AND of
2102 * the GROUP_OBJ permissions and the
2103 * acl mask.
2104 */
2105
2106 rep->lflags |= (groupperm & mask) << 3;
2107
2108 } else if (acl_type(rep->aclp) == ACE_T) {
2109 int mode;
2110 mode = grp_mask_to_mode(rep);
2111 rep->lflags &= ~S_IRWXG;
2112 rep->lflags |= mode;
2113 }
2114 }
2115
2116 if (!vflg && !Vflg && rep->aclp) {
2117 acl_free(rep->aclp);
2118 rep->aclp = NULL;
2119 }
2120
2121 if (atflg && pathconf(file, _PC_XATTR_EXISTS) == 1)
2122 rep->acl = '@';
2123
2124 } else
2125 rep->acl = ' ';
2126
2127 /* mask ISARG and other file-type bits */
2128
2129 if (rep->ltype != 'b' && rep->ltype != 'c')
2130 tblocks += rep->lblocks;
2131
2132 /* Get extended system attributes */
2133
2134 if ((saflg || (tmflg && crtm) || (tmflg && alltm)) &&
2135 (sysattr_support(file, _PC_SATTR_EXISTS) == 1)) {
2136 int i;
2137
2138 sacnt = attr_count();
2139 /*
2140 * Allocate 'sacnt' size array to hold extended
2141 * system attribute name (verbose) or respective
2142 * symbol representation (compact).
2143 */
2144 rep->exttr = xmalloc(sacnt * sizeof (struct attrb),
2145 rep);
2146
2147 /* initialize boolean attribute list */
2148 for (i = 0; i < sacnt; i++)
2149 rep->exttr[i].name = NULL;
2150 if (get_sysxattr(file, rep) != 0) {
2151 (void) fprintf(stderr,
2152 gettext("ls:Failed to retrieve "
2153 "extended system attribute from "
2154 "%s\n"), file);
2155 rep->exttr[0].name = xmalloc(2, rep);
2156 (void) strlcpy(rep->exttr[0].name, "?", 2);
2157 }
2158 }
2159 }
2160 return (rep);
2161 }
2162
2163 /*
2164 * returns pathname of the form dir/file;
2165 * dir and file are null-terminated strings.
2166 */
2167 static char *
makename(char * dir,char * file)2168 makename(char *dir, char *file)
2169 {
2170 /*
2171 * PATH_MAX is the maximum length of a path name.
2172 * MAXNAMLEN is the maximum length of any path name component.
2173 * Allocate space for both, plus the '/' in the middle
2174 * and the null character at the end.
2175 * dfile is static as this is returned by makename().
2176 */
2177 static char dfile[PATH_MAX + 1 + MAXNAMLEN + 1];
2178 char *dp, *fp;
2179
2180 dp = dfile;
2181 fp = dir;
2182 while (*fp)
2183 *dp++ = *fp++;
2184 if (dp > dfile && *(dp - 1) != '/')
2185 *dp++ = '/';
2186 fp = file;
2187 while (*fp)
2188 *dp++ = *fp++;
2189 *dp = '\0';
2190 return (dfile);
2191 }
2192
2193 #define NMAX 256 /* The maximum size of a SID in string format */
2194 #define SCPYN(a, b) (void) strlcpy(a, b, NMAX)
2195
2196 struct cachenode { /* this struct must be zeroed before using */
2197 struct cachenode *lesschild; /* subtree whose entries < val */
2198 struct cachenode *grtrchild; /* subtree whose entries > val */
2199 long val; /* the uid or gid of this entry */
2200 int initted; /* name has been filled in */
2201 char name[NMAX]; /* the string that val maps to */
2202 };
2203 static struct cachenode *names, *groups;
2204 static struct cachenode *user_sids, *group_sids;
2205
2206 static struct cachenode *
findincache(struct cachenode ** head,long val)2207 findincache(struct cachenode **head, long val)
2208 {
2209 struct cachenode **parent = head;
2210 struct cachenode *c = *parent;
2211
2212 while (c != NULL) {
2213 if (val == c->val) {
2214 /* found it */
2215 return (c);
2216 } else if (val < c->val) {
2217 parent = &c->lesschild;
2218 c = c->lesschild;
2219 } else {
2220 parent = &c->grtrchild;
2221 c = c->grtrchild;
2222 }
2223 }
2224
2225 /* not in the cache, make a new entry for it */
2226 c = calloc(1, sizeof (struct cachenode));
2227 if (c == NULL) {
2228 perror("ls");
2229 exit(2);
2230 }
2231 *parent = c;
2232 c->val = val;
2233 return (c);
2234 }
2235
2236 /*
2237 * get name from cache, or passwd file for a given uid;
2238 * lastuid is set to uid.
2239 *
2240 * If an ephemeral UID (> MAXUID) try to convert to either a
2241 * name or a sid.
2242 */
2243 static char *
getname(uid_t uid)2244 getname(uid_t uid)
2245 {
2246 struct passwd *pwent;
2247 struct cachenode *c;
2248 char *sid;
2249
2250 if ((uid == lastuid) && lastuname)
2251 return (lastuname);
2252
2253 c = findincache(&names, uid);
2254 if (c->initted == 0) {
2255 sid = NULL;
2256 if (uid > MAXUID &&
2257 sid_string_by_id(uid, B_TRUE, &sid, 0) == 0) {
2258 SCPYN(&c->name[0], sid);
2259 free(sid);
2260 } else if ((pwent = getpwuid(uid)) != NULL) {
2261 SCPYN(&c->name[0], pwent->pw_name);
2262 } else {
2263 (void) sprintf(&c->name[0], "%-8u", (int)uid);
2264 }
2265 c->initted = 1;
2266 }
2267 lastuid = uid;
2268 lastuname = &c->name[0];
2269 return (lastuname);
2270 }
2271
2272 /*
2273 * get name from cache, or group file for a given gid;
2274 * lastgid is set to gid.
2275 *
2276 * If an ephemeral GID (> MAXUID) try to convert to either a
2277 * name or a sid.
2278 */
2279 static char *
getgroup(gid_t gid)2280 getgroup(gid_t gid)
2281 {
2282 struct group *grent;
2283 struct cachenode *c;
2284 char *sid;
2285
2286 if ((gid == lastgid) && lastgname)
2287 return (lastgname);
2288
2289 c = findincache(&groups, gid);
2290 if (c->initted == 0) {
2291 sid = NULL;
2292 if (gid > MAXUID &&
2293 sid_string_by_id(gid, B_FALSE, &sid, 0) == 0) {
2294 SCPYN(&c->name[0], sid);
2295 free(sid);
2296 } else if ((grent = getgrgid(gid)) != NULL) {
2297 SCPYN(&c->name[0], grent->gr_name);
2298 } else {
2299 (void) sprintf(&c->name[0], "%-8u", (int)gid);
2300 }
2301 c->initted = 1;
2302 }
2303 lastgid = gid;
2304 lastgname = &c->name[0];
2305 return (lastgname);
2306 }
2307
2308 /*
2309 * get SID from cache, or from idmap for a given (ephemeral) uid;
2310 *
2311 * Always an ephemeral UID (> MAXUID) here.
2312 * Just convert to a SID (no winname lookup)
2313 */
2314 static char *
getusid(uid_t uid)2315 getusid(uid_t uid)
2316 {
2317 struct cachenode *c;
2318 char *sid;
2319
2320 c = findincache(&user_sids, uid);
2321 if (c->initted == 0) {
2322 sid = NULL;
2323 if (sid_string_by_id(uid, B_TRUE, &sid, ACL_NORESOLVE) == 0) {
2324 SCPYN(&c->name[0], sid);
2325 free(sid);
2326 } else {
2327 (void) sprintf(&c->name[0], "%-8u", (int)uid);
2328 }
2329 c->initted = 1;
2330 }
2331
2332 return (&c->name[0]);
2333 }
2334
2335 /*
2336 * get SID from cache, or from idmap for a given (ephemeral) gid;
2337 *
2338 * If an ephemeral UID (> MAXUID) try to convert to a SID
2339 * (no winname lookup here)
2340 */
2341 static char *
getgsid(gid_t gid)2342 getgsid(gid_t gid)
2343 {
2344 struct cachenode *c;
2345 char *sid;
2346
2347 c = findincache(&group_sids, gid);
2348 if (c->initted == 0) {
2349 sid = NULL;
2350 if (sid_string_by_id(gid, B_FALSE, &sid, ACL_NORESOLVE) == 0) {
2351 SCPYN(&c->name[0], sid);
2352 free(sid);
2353 } else {
2354 (void) sprintf(&c->name[0], "%-8u", (int)gid);
2355 }
2356 c->initted = 1;
2357 }
2358
2359 return (&c->name[0]);
2360 }
2361
2362 /* return >0 if item pointed by pp2 should appear first */
2363 static int
compar(struct lbuf ** pp1,struct lbuf ** pp2)2364 compar(struct lbuf **pp1, struct lbuf **pp2)
2365 {
2366 struct lbuf *p1, *p2;
2367
2368 p1 = *pp1;
2369 p2 = *pp2;
2370 if (dflg == 0) {
2371 /*
2372 * compare two names in ls-command one of which is file
2373 * and the other is a directory;
2374 * this portion is not used for comparing files within
2375 * a directory name of ls-command;
2376 */
2377 if (p1->lflags&ISARG && p1->ltype == 'd') {
2378 if (!(p2->lflags&ISARG && p2->ltype == 'd'))
2379 return (1);
2380 } else {
2381 if (p2->lflags&ISARG && p2->ltype == 'd')
2382 return (-1);
2383 }
2384 }
2385 if (tflg) {
2386 if (p2->lmtime.tv_sec > p1->lmtime.tv_sec)
2387 return (rflg);
2388 else if (p2->lmtime.tv_sec < p1->lmtime.tv_sec)
2389 return (-rflg);
2390 /* times are equal to the sec, check nsec */
2391 if (p2->lmtime.tv_nsec > p1->lmtime.tv_nsec)
2392 return (rflg);
2393 else if (p2->lmtime.tv_nsec < p1->lmtime.tv_nsec)
2394 return (-rflg);
2395 /* if times are equal, fall through and sort by name */
2396 } else if (Sflg) {
2397 /*
2398 * The size stored in lsize can be either the
2399 * size or the major minor number (in the case of
2400 * block and character special devices). If it's
2401 * a major minor number, then the size is considered
2402 * to be zero and we want to fall through and sort
2403 * by name. In addition, if the size of p2 is equal
2404 * to the size of p1 we want to fall through and
2405 * sort by name.
2406 */
2407 off_t p1size = (p1->ltype == 'b') ||
2408 (p1->ltype == 'c') ? 0 : p1->lsize;
2409 off_t p2size = (p2->ltype == 'b') ||
2410 (p2->ltype == 'c') ? 0 : p2->lsize;
2411 if (p2size > p1size) {
2412 return (rflg);
2413 } else if (p2size < p1size) {
2414 return (-rflg);
2415 }
2416 /* Sizes are equal, fall through and sort by name. */
2417 }
2418 return (rflg * strcoll(
2419 p1->lflags & ISARG ? p1->ln.namep : p1->ln.lname,
2420 p2->lflags&ISARG ? p2->ln.namep : p2->ln.lname));
2421 }
2422
2423 static void
pprintf(char * s1,char * s2)2424 pprintf(char *s1, char *s2)
2425 {
2426 csi_pprintf((unsigned char *)s1);
2427 csi_pprintf((unsigned char *)s2);
2428 }
2429
2430 static void
csi_pprintf(unsigned char * s)2431 csi_pprintf(unsigned char *s)
2432 {
2433 unsigned char *cp;
2434 char c;
2435 int i;
2436 int c_len;
2437 int p_col;
2438 wchar_t pcode;
2439
2440 if (!qflg && !bflg) {
2441 for (cp = s; *cp != '\0'; cp++) {
2442 (void) putchar(*cp);
2443 curcol++;
2444 }
2445 return;
2446 }
2447
2448 for (cp = s; *cp; ) {
2449 if (isascii(c = *cp)) {
2450 if (!isprint(c)) {
2451 if (qflg) {
2452 c = '?';
2453 } else {
2454 curcol += 3;
2455 (void) putc('\\', stdout);
2456 c = '0' + ((*cp >> 6) & 07);
2457 (void) putc(c, stdout);
2458 c = '0' + ((*cp >> 3) & 07);
2459 (void) putc(c, stdout);
2460 c = '0' + (*cp & 07);
2461 }
2462 }
2463 curcol++;
2464 cp++;
2465 (void) putc(c, stdout);
2466 continue;
2467 }
2468
2469 if ((c_len = mbtowc(&pcode, (char *)cp, MB_LEN_MAX)) <= 0) {
2470 c_len = 1;
2471 goto not_print;
2472 }
2473
2474 if ((p_col = wcwidth(pcode)) > 0) {
2475 (void) putwchar(pcode);
2476 cp += c_len;
2477 curcol += p_col;
2478 continue;
2479 }
2480
2481 not_print:
2482 for (i = 0; i < c_len; i++) {
2483 if (qflg) {
2484 c = '?';
2485 } else {
2486 curcol += 3;
2487 (void) putc('\\', stdout);
2488 c = '0' + ((*cp >> 6) & 07);
2489 (void) putc(c, stdout);
2490 c = '0' + ((*cp >> 3) & 07);
2491 (void) putc(c, stdout);
2492 c = '0' + (*cp & 07);
2493 }
2494 curcol++;
2495 (void) putc(c, stdout);
2496 cp++;
2497 }
2498 }
2499 }
2500
2501 static int
strcol(unsigned char * s1)2502 strcol(unsigned char *s1)
2503 {
2504 int w;
2505 int w_col;
2506 int len;
2507 wchar_t wc;
2508
2509 w = 0;
2510 while (*s1) {
2511 if (isascii(*s1)) {
2512 w++;
2513 s1++;
2514 continue;
2515 }
2516
2517 if ((len = mbtowc(&wc, (char *)s1, MB_LEN_MAX)) <= 0) {
2518 w++;
2519 s1++;
2520 continue;
2521 }
2522
2523 if ((w_col = wcwidth(wc)) < 0)
2524 w_col = len;
2525 s1 += len;
2526 w += w_col;
2527 }
2528 return (w);
2529 }
2530
2531 /* Get extended system attributes and set the display */
2532
2533 int
get_sysxattr(char * fname,struct lbuf * rep)2534 get_sysxattr(char *fname, struct lbuf *rep)
2535 {
2536 boolean_t value;
2537 data_type_t type;
2538 int error;
2539 char *name;
2540 int i;
2541
2542 if ((error = getattrat(AT_FDCWD, XATTR_VIEW_READWRITE, fname,
2543 &response)) != 0) {
2544 perror("ls:getattrat");
2545 return (error);
2546 }
2547
2548 /*
2549 * Allocate 'sacnt' size array to hold extended timestamp
2550 * system attributes and initialize the array.
2551 */
2552 rep->extm = xmalloc(sacnt * sizeof (struct attrtm), rep);
2553 for (i = 0; i < sacnt; i++) {
2554 rep->extm[i].stm = 0;
2555 rep->extm[i].nstm = 0;
2556 rep->extm[i].name = NULL;
2557 }
2558 while ((pair = nvlist_next_nvpair(response, pair)) != NULL) {
2559 name = nvpair_name(pair);
2560 type = nvpair_type(pair);
2561 if (type == DATA_TYPE_BOOLEAN_VALUE) {
2562 error = nvpair_value_boolean_value(pair, &value);
2563 if (error) {
2564 (void) fprintf(stderr,
2565 gettext("nvpair_value_boolean_value "
2566 "failed: error = %d\n"), error);
2567 continue;
2568 }
2569 if (name != NULL)
2570 set_sysattrb_display(name, value, rep);
2571 continue;
2572 } else if (type == DATA_TYPE_UINT64_ARRAY) {
2573 if (name != NULL)
2574 set_sysattrtm_display(name, rep);
2575 continue;
2576 }
2577 }
2578 nvlist_free(response);
2579 return (0);
2580 }
2581
2582 /* Set extended system attribute boolean display */
2583
2584 void
set_sysattrb_display(char * name,boolean_t val,struct lbuf * rep)2585 set_sysattrb_display(char *name, boolean_t val, struct lbuf *rep)
2586 {
2587 f_attr_t fattr;
2588 const char *opt;
2589 size_t len;
2590
2591 fattr = name_to_attr(name);
2592 if (fattr != F_ATTR_INVAL && fattr < sacnt) {
2593 if (vopt) {
2594 len = strlen(name);
2595 if (val) {
2596 rep->exttr[fattr].name = xmalloc(len + 1, rep);
2597 (void) strlcpy(rep->exttr[fattr].name, name,
2598 len + 1);
2599 } else {
2600 rep->exttr[fattr].name = xmalloc(len + 3, rep);
2601 (void) snprintf(rep->exttr[fattr].name, len + 3,
2602 "no%s", name);
2603 }
2604 } else {
2605 opt = attr_to_option(fattr);
2606 if (opt != NULL) {
2607 len = strlen(opt);
2608 rep->exttr[fattr].name = xmalloc(len + 1, rep);
2609 if (val)
2610 (void) strlcpy(rep->exttr[fattr].name,
2611 opt, len + 1);
2612 else
2613 (void) strlcpy(rep->exttr[fattr].name,
2614 "-", len + 1);
2615 }
2616 }
2617 }
2618 }
2619
2620 /* Set extended system attribute timestamp display */
2621
2622 void
set_sysattrtm_display(char * name,struct lbuf * rep)2623 set_sysattrtm_display(char *name, struct lbuf *rep)
2624 {
2625 uint_t nelem;
2626 uint64_t *value;
2627 int i;
2628 size_t len;
2629
2630 if (nvpair_value_uint64_array(pair, &value, &nelem) == 0) {
2631 if (value != NULL) {
2632 len = strlen(name);
2633 i = 0;
2634 while (rep->extm[i].stm != 0 && i < sacnt)
2635 i++;
2636 rep->extm[i].stm = value[0];
2637 rep->extm[i].nstm = value[1];
2638 rep->extm[i].name = xmalloc(len + 1, rep);
2639 (void) strlcpy(rep->extm[i].name, name, len + 1);
2640 }
2641 }
2642 }
2643
2644 void
format_time(time_t sec,time_t nsec)2645 format_time(time_t sec, time_t nsec)
2646 {
2647 const char *fstr = time_fmt_new;
2648 char fmt_buf[FMTSIZE];
2649
2650 if (Eflg) {
2651 (void) snprintf(fmt_buf, FMTSIZE, fstr, nsec);
2652 (void) strftime(time_buf, sizeof (time_buf), fmt_buf,
2653 localtime(&sec));
2654 return;
2655 }
2656
2657 if (sec < year || sec > now)
2658 fstr = time_fmt_old;
2659
2660 /* if a custom time was specified, shouldn't be localized */
2661 (void) strftime(time_buf, sizeof (time_buf),
2662 (time_custom == 0) ? dcgettext(NULL, fstr, LC_TIME) : fstr,
2663 localtime(&sec));
2664 }
2665
2666 void
format_attrtime(struct lbuf * p)2667 format_attrtime(struct lbuf *p)
2668 {
2669 int tmattr = 0;
2670 int i;
2671
2672 if (p->extm != NULL) {
2673 for (i = 0; i < sacnt; i++) {
2674 if (p->extm[i].name != NULL) {
2675 tmattr = 1;
2676 break;
2677 }
2678 }
2679 }
2680
2681 if (tmattr) {
2682 const char *old_save = time_fmt_old;
2683 const char *new_save = time_fmt_new;
2684
2685 /* Eflg always sets format to FORMAT_ISO_FULL */
2686 if (!Eflg && !time_custom) {
2687 time_fmt_old = FORMAT_OLD;
2688 time_fmt_new = FORMAT_NEW;
2689 }
2690
2691 format_time((time_t)p->extm[i].stm, (time_t)p->extm[i].nstm);
2692
2693 time_fmt_old = old_save;
2694 time_fmt_new = new_save;
2695 }
2696 }
2697
2698 void
print_time(struct lbuf * p)2699 print_time(struct lbuf *p)
2700 {
2701 const char *old_save = time_fmt_old;
2702 const char *new_save = time_fmt_new;
2703
2704 int i = 0;
2705
2706 if (!Eflg) {
2707 time_fmt_old = FORMAT_LONG;
2708 time_fmt_new = FORMAT_LONG;
2709 }
2710
2711 new_line();
2712 format_time(p->lat.tv_sec, p->lat.tv_nsec);
2713 (void) printf(" timestamp: atime %s\n", time_buf);
2714 format_time(p->lct.tv_sec, p->lct.tv_nsec);
2715 (void) printf(" timestamp: ctime %s\n", time_buf);
2716 format_time(p->lmt.tv_sec, p->lmt.tv_nsec);
2717 (void) printf(" timestamp: mtime %s\n", time_buf);
2718 if (p->extm != NULL) {
2719 while (p->extm[i].nstm != 0 && i < sacnt) {
2720 format_time(p->extm[i].stm, p->extm[i].nstm);
2721 if (p->extm[i].name != NULL) {
2722 (void) printf(" timestamp:"
2723 " %s %s\n",
2724 p->extm[i].name, time_buf);
2725 }
2726 i++;
2727 }
2728 }
2729
2730 time_fmt_old = old_save;
2731 time_fmt_new = new_save;
2732 }
2733
2734 /*
2735 * Check if color definition applies to entry, returns 1 if yes, 0 if no
2736 */
2737 static int
color_match(const char * fname,mode_t mode,ls_color_t * color)2738 color_match(const char *fname, mode_t mode, ls_color_t *color)
2739 {
2740 switch (color->ftype) {
2741 case LS_PAT:
2742 {
2743 size_t fname_len, sfx_len;
2744
2745 fname_len = strlen(fname);
2746 sfx_len = strlen(color->sfx);
2747 if (sfx_len > fname_len)
2748 return (0);
2749
2750 if (strcmp(color->sfx, fname + fname_len - sfx_len) == 0)
2751 return (1);
2752 else
2753 return (0);
2754 }
2755
2756 case LS_NORMAL:
2757 return (1);
2758
2759 case LS_FILE:
2760 return (S_ISREG(mode));
2761
2762 case LS_DIR:
2763 return (S_ISDIR(mode));
2764
2765 case LS_LINK:
2766 return (S_ISLNK(mode));
2767
2768 case LS_FIFO:
2769 return (S_ISFIFO(mode));
2770
2771 case LS_SOCK:
2772 return (S_ISSOCK(mode));
2773
2774 case LS_DOOR:
2775 return (S_ISDOOR(mode));
2776
2777 case LS_BLK:
2778 return (S_ISBLK(mode));
2779
2780 case LS_CHR:
2781 return (S_ISCHR(mode));
2782
2783 case LS_PORT:
2784 return (S_ISPORT(mode));
2785
2786 case LS_ORPHAN:
2787 /* this is tested for by gstat */
2788 return (0);
2789
2790 case LS_SETUID:
2791 return (!S_ISLNK(mode) && (mode & S_ISUID));
2792
2793 case LS_SETGID:
2794 return (!S_ISLNK(mode) && (mode & S_ISGID));
2795
2796 case LS_STICKY_OTHER_WRITABLE:
2797 return (!S_ISLNK(mode) && (mode & (S_IWOTH|S_ISVTX)));
2798
2799 case LS_OTHER_WRITABLE:
2800 return (!S_ISLNK(mode) && (mode & S_IWOTH));
2801
2802 case LS_STICKY:
2803 return (!S_ISLNK(mode) && (mode & S_ISVTX));
2804
2805 case LS_EXEC:
2806 return (!S_ISLNK(mode) && (mode & (S_IXUSR|S_IXGRP|S_IXOTH)));
2807 }
2808
2809 return (0);
2810 }
2811
2812 static void
dump_color(ls_color_t * c)2813 dump_color(ls_color_t *c)
2814 {
2815 if (c == NULL)
2816 return;
2817
2818 (void) printf("\n\ttype: ");
2819 switch (c->ftype) {
2820 case LS_NORMAL:
2821 (void) printf("LS_NORMAL");
2822 break;
2823 case LS_FILE:
2824 (void) printf("LS_FILE");
2825 break;
2826 case LS_EXEC:
2827 (void) printf("LS_EXEC");
2828 break;
2829 case LS_DIR:
2830 (void) printf("LS_DIR");
2831 break;
2832 case LS_LINK:
2833 (void) printf("LS_LINK");
2834 break;
2835
2836 case LS_FIFO:
2837 (void) printf("LS_FIFO");
2838 break;
2839
2840 case LS_SOCK:
2841 (void) printf("LS_SOCK");
2842 break;
2843
2844 case LS_DOOR:
2845 (void) printf("LS_DOOR");
2846 break;
2847
2848 case LS_BLK:
2849 (void) printf("LS_BLK");
2850 break;
2851
2852 case LS_CHR:
2853 (void) printf("LS_CHR");
2854 break;
2855
2856 case LS_PORT:
2857 (void) printf("LS_PORT");
2858 break;
2859
2860 case LS_STICKY:
2861 (void) printf("LS_STICKY");
2862 break;
2863
2864 case LS_ORPHAN:
2865 (void) printf("LS_ORPHAN");
2866 break;
2867
2868 case LS_SETGID:
2869 (void) printf("LS_SETGID");
2870 break;
2871
2872 case LS_SETUID:
2873 (void) printf("LS_SETUID");
2874 break;
2875
2876 case LS_OTHER_WRITABLE:
2877 (void) printf("LS_OTHER_WRITABLE");
2878 break;
2879
2880 case LS_STICKY_OTHER_WRITABLE:
2881 (void) printf("LS_STICKY_OTHER_WRITABLE");
2882 break;
2883
2884 case LS_PAT:
2885 (void) printf("LS_PAT\n");
2886 (void) printf("\tpattern: %s", c->sfx);
2887 break;
2888 }
2889 (void) printf("\n");
2890 (void) printf("\tattr: %d\n", c->attr);
2891 (void) printf("\tfg: %d\n", c->fg);
2892 (void) printf("\tbg: %d\n", c->bg);
2893 (void) printf("\t");
2894 }
2895
2896 static ls_color_t *
ls_color_find(const char * fname,mode_t mode)2897 ls_color_find(const char *fname, mode_t mode)
2898 {
2899 int i;
2900
2901 /*
2902 * Colors are sorted from most general lsc_colors[0] to most specific
2903 * lsc_colors[lsc_ncolors - 1] by ls_color_init(). Start search with
2904 * most specific color rule and work towards most general.
2905 */
2906 for (i = lsc_ncolors - 1; i >= 0; --i)
2907 if (color_match(fname, mode, &lsc_colors[i]))
2908 return (&lsc_colors[i]);
2909
2910 return (NULL);
2911 }
2912
2913 static void
ls_tprint(char * str,long int p1,long int p2,long int p3,long int p4,long int p5,long int p6,long int p7,long int p8,long int p9)2914 ls_tprint(char *str, long int p1, long int p2, long int p3, long int p4,
2915 long int p5, long int p6, long int p7, long int p8, long int p9)
2916 {
2917 char *s;
2918
2919 if (str == NULL)
2920 return;
2921
2922 s = tparm(str, p1, p2, p3, p4, p5, p6, p7, p8, p9);
2923
2924 if (s != NULL)
2925 (void) putp(s);
2926 }
2927
2928 static void
ls_start_color(ls_color_t * c)2929 ls_start_color(ls_color_t *c)
2930 {
2931 if (c == NULL)
2932 return;
2933
2934 if (lsc_debug)
2935 lsc_match = c;
2936
2937 if (c->attr & LSA_BOLD)
2938 ls_tprint(lsc_bold, 0, 0, 0, 0, 0, 0, 0, 0, 0);
2939 if (c->attr & LSA_UNDERSCORE)
2940 ls_tprint(lsc_underline, 0, 0, 0, 0, 0, 0, 0, 0, 0);
2941 if (c->attr & LSA_BLINK)
2942 ls_tprint(lsc_blink, 0, 0, 0, 0, 0, 0, 0, 0, 0);
2943 if (c->attr & LSA_REVERSE)
2944 ls_tprint(lsc_reverse, 0, 0, 0, 0, 0, 0, 0, 0, 0);
2945 if (c->attr & LSA_CONCEALED)
2946 ls_tprint(lsc_concealed, 0, 0, 0, 0, 0, 0, 0, 0, 0);
2947 if (c->attr == LSA_NONE)
2948 ls_tprint(lsc_none, 0, 0, 0, 0, 0, 0, 0, 0, 0);
2949
2950 if (c->fg != -1)
2951 ls_tprint(lsc_setfg, c->fg, 0, 0, 0, 0, 0, 0, 0, 0);
2952 if (c->bg != -1)
2953 ls_tprint(lsc_setbg, c->bg, 0, 0, 0, 0, 0, 0, 0, 0);
2954 }
2955
2956 static void
ls_end_color()2957 ls_end_color()
2958 {
2959 ls_tprint(lsc_none, 0, 0, 0, 0, 0, 0, 0, 0, 0);
2960 if (lsc_debug)
2961 dump_color(lsc_match);
2962 }
2963
2964 static void
new_color_entry(char * colorstr)2965 new_color_entry(char *colorstr)
2966 {
2967 static const struct {
2968 const char *s;
2969 ls_cftype_t stype;
2970 } type_map[] = {
2971 { "no", LS_NORMAL },
2972 { "fi", LS_FILE },
2973 { "di", LS_DIR },
2974 { "ln", LS_LINK },
2975 { "pi", LS_FIFO },
2976 { "so", LS_SOCK },
2977 { "do", LS_DOOR },
2978 { "bd", LS_BLK },
2979 { "cd", LS_CHR },
2980 { "or", LS_ORPHAN },
2981 { "su", LS_SETUID },
2982 { "sg", LS_SETGID },
2983 { "tw", LS_STICKY_OTHER_WRITABLE },
2984 { "ow", LS_OTHER_WRITABLE },
2985 { "st", LS_STICKY },
2986 { "ex", LS_EXEC },
2987 { "po", LS_PORT },
2988 { NULL, LS_NORMAL }
2989 };
2990
2991 char *p, *lasts;
2992 int i;
2993 int color, attr;
2994
2995 p = strtok_r(colorstr, "=", &lasts);
2996 if (p == NULL) {
2997 colorflg = 0;
2998 return;
2999 }
3000
3001 if (p[0] == '*') {
3002 lsc_colors[lsc_ncolors].ftype = LS_PAT;
3003 /* don't include the * in the suffix */
3004 if ((lsc_colors[lsc_ncolors].sfx = strdup(p + 1)) == NULL) {
3005 colorflg = 0;
3006 return;
3007 }
3008 } else {
3009 lsc_colors[lsc_ncolors].sfx = NULL;
3010
3011 for (i = 0; type_map[i].s != NULL; ++i) {
3012 if (strncmp(type_map[i].s, p, 2) == 0)
3013 break;
3014 }
3015
3016 /* ignore unknown file types */
3017 if (type_map[i].s == NULL)
3018 return;
3019
3020 lsc_colors[lsc_ncolors].ftype = type_map[i].stype;
3021 }
3022
3023 attr = LSA_NONE;
3024 lsc_colors[lsc_ncolors].fg = -1;
3025 lsc_colors[lsc_ncolors].bg = -1;
3026 for (p = strtok_r(NULL, ";", &lasts); p != NULL;
3027 p = strtok_r(NULL, ";", &lasts)) {
3028 color = strtol(p, NULL, 10);
3029
3030 if (color < 10) {
3031 switch (color) {
3032 case 0:
3033 attr = LSA_NONE;
3034 continue;
3035 case 1:
3036 attr |= LSA_BOLD;
3037 continue;
3038 case 4:
3039 attr |= LSA_UNDERSCORE;
3040 continue;
3041 case 5:
3042 attr |= LSA_BLINK;
3043 continue;
3044 case 7:
3045 attr |= LSA_REVERSE;
3046 continue;
3047 case 8:
3048 attr |= LSA_CONCEALED;
3049 continue;
3050 default:
3051 continue;
3052 }
3053 }
3054
3055 if (color < 40)
3056 lsc_colors[lsc_ncolors].fg = color - 30;
3057 else
3058 lsc_colors[lsc_ncolors].bg = color - 40;
3059 }
3060
3061 lsc_colors[lsc_ncolors].attr = attr;
3062 ++lsc_ncolors;
3063 }
3064
3065 static int
ls_color_compare(const void * p1,const void * p2)3066 ls_color_compare(const void *p1, const void *p2)
3067 {
3068 const ls_color_t *c1 = (const ls_color_t *)p1;
3069 const ls_color_t *c2 = (const ls_color_t *)p2;
3070
3071 int ret = c1->ftype - c2->ftype;
3072
3073 if (ret != 0)
3074 return (ret);
3075
3076 if (c1->ftype != LS_PAT)
3077 return (ret);
3078
3079 return (strcmp(c1->sfx, c2->sfx));
3080 }
3081
3082 static void
ls_color_init()3083 ls_color_init()
3084 {
3085 static char *default_colorstr = "no=00:fi=00:di=01;34:ln=01;36:po=01;35"
3086 ":pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01"
3087 ":su=37;41:sg=30;43:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31"
3088 ":*.tgz=01;31:*.arj=01;31:*.taz=01;31:*.lzh=01;31:*.zip=01;31"
3089 ":*.z=01;31:*.Z=01;31:*.gz=01;31:*.bz2=01;31:*.deb=01;31"
3090 ":*.rpm=01;31:*.jar=01;31:*.jpg=01;35:*.jpeg=01;35:*.gif=01;35"
3091 ":*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35"
3092 ":*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35"
3093 ":*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.avi=01;35:*.fli=01;35"
3094 ":*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.flac=01;35"
3095 ":*.mp3=01;35:*.mpc=01;35:*.ogg=01;35:*.wav=01;35";
3096
3097 char *colorstr;
3098 char *p, *lasts;
3099 size_t color_sz;
3100 int termret;
3101 int i;
3102
3103 (void) setupterm(NULL, 1, &termret);
3104 if (termret != 1)
3105 return;
3106
3107 if ((p = getenv("LS_COLORS")) == NULL)
3108 p = default_colorstr;
3109 colorstr = strdup(p);
3110 if (colorstr == NULL)
3111 return;
3112
3113 /*
3114 * Determine the size of lsc_colors. color_sz can be > lsc_ncolors
3115 * if there are invalid entries passed in the string (they are ignored)
3116 */
3117 color_sz = 1;
3118 for (p = strchr(colorstr, ':'); p != NULL && *p != '\0';
3119 p = strchr(++p, ':'))
3120 ++color_sz;
3121
3122 lsc_colors = calloc(color_sz, sizeof (ls_color_t));
3123 if (lsc_colors == NULL) {
3124 free(colorstr);
3125 return;
3126 }
3127
3128 for (p = strtok_r(colorstr, ":", &lasts);
3129 p != NULL && lsc_ncolors < color_sz;
3130 p = strtok_r(NULL, ":", &lasts))
3131 new_color_entry(p);
3132
3133 qsort((void *)lsc_colors, lsc_ncolors, sizeof (ls_color_t),
3134 ls_color_compare);
3135
3136 for (i = 0; i < lsc_ncolors; ++i)
3137 if (lsc_colors[i].ftype == LS_ORPHAN) {
3138 lsc_orphan = &lsc_colors[i];
3139 break;
3140 }
3141
3142 if ((lsc_bold = tigetstr("bold")) == (char *)-1)
3143 lsc_bold = NULL;
3144
3145 if ((lsc_underline = tigetstr("smul")) == (char *)-1)
3146 lsc_underline = NULL;
3147
3148 if ((lsc_blink = tigetstr("blink")) == (char *)-1)
3149 lsc_blink = NULL;
3150
3151 if ((lsc_reverse = tigetstr("rev")) == (char *)-1)
3152 lsc_reverse = NULL;
3153
3154 if ((lsc_concealed = tigetstr("prot")) == (char *)-1)
3155 lsc_concealed = NULL;
3156
3157 if ((lsc_none = tigetstr("sgr0")) == (char *)-1)
3158 lsc_none = NULL;
3159
3160 if ((lsc_setfg = tigetstr("setaf")) == (char *)-1)
3161 lsc_setfg = NULL;
3162
3163 if ((lsc_setbg = tigetstr("setab")) == (char *)-1)
3164 lsc_setbg = NULL;
3165
3166 if (getenv("_LS_COLOR_DEBUG") != NULL) {
3167 int i;
3168
3169 lsc_debug = 1;
3170 for (i = 0; i < lsc_ncolors; ++i)
3171 dump_color(&lsc_colors[i]);
3172 }
3173
3174 free(colorstr);
3175 }
3176
3177 /* Free extended system attribute lists */
3178
3179 void
free_sysattr(struct lbuf * p)3180 free_sysattr(struct lbuf *p)
3181 {
3182 int i;
3183
3184 if (p->exttr != NULL) {
3185 for (i = 0; i < sacnt; i++) {
3186 if (p->exttr[i].name != NULL)
3187 free(p->exttr[i].name);
3188 }
3189 free(p->exttr);
3190 }
3191 if (p->extm != NULL) {
3192 for (i = 0; i < sacnt; i++) {
3193 if (p->extm[i].name != NULL)
3194 free(p->extm[i].name);
3195 }
3196 free(p->extm);
3197 }
3198 }
3199
3200 /* Allocate extended system attribute list */
3201
3202 void *
xmalloc(size_t size,struct lbuf * p)3203 xmalloc(size_t size, struct lbuf *p)
3204 {
3205 if ((p = malloc(size)) == NULL) {
3206 perror("ls");
3207 free_sysattr(p);
3208 nvlist_free(response);
3209 exit(2);
3210 }
3211 return (p);
3212 }
3213