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