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