/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved. */ /* * Copyright 2009 Jason King. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ /* Copyright (c) 1987, 1988 Microsoft Corporation */ /* All Rights Reserved */ /* * List files or directories */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef STANDALONE #define TERMINFO #endif /* * -DNOTERMINFO can be defined on the cc command line to prevent * the use of terminfo. This should be done on systems not having * the terminfo feature(pre 6.0 systems ?). * As a result, columnar listings assume 80 columns for output, * unless told otherwise via the COLUMNS environment variable. */ #ifdef NOTERMINFO #undef TERMINFO #endif #include #define BFSIZE 16 /* this bit equals 1 in lflags of structure lbuf if *namep is to be used */ #define ISARG 0100000 /* * this flag has been added to manipulate the display of S instead of 'l' when * the file is not a regular file and when group execution bit is off */ #define LS_NOTREG 010000 /* * Date and time formats * * b --- abbreviated month name * e --- day number * Y --- year in the form ccyy * H --- hour(24-hour version) * M --- minute * F --- yyyy-mm-dd * T --- hh:mm:ss * z --- time zone as hours displacement from UTC * note that %F and %z are from the ISO C99 standard and are * not present in older C libraries */ #define FORMAT_OLD " %b %e %Y " #define FORMAT_NEW " %b %e %H:%M " #define FORMAT_LONG " %b %e %T %Y " #define FORMAT_ISO_FULL " %%F %%T.%.09ld %%z " #define FORMAT_ISO_LONG " %F %R " #define FORMAT_ISO_NEW " %m-%d %H:%M " #define FORMAT_ISO_OLD " %F " #undef BUFSIZ #define BUFSIZ 4096 #define NUMBER_WIDTH 40 #define FMTSIZE 50 struct ditem { dev_t dev; /* directory items device number */ ino_t ino; /* directory items inode number */ struct ditem *parent; /* dir items ptr to its parent's info */ }; /* Holds boolean extended system attributes */ struct attrb { char *name; }; /* Holds timestamp extended system attributes */ struct attrtm { char *name; uint64_t stm; uint64_t nstm; }; #define LSA_NONE (0) #define LSA_BOLD (1L << 0) #define LSA_UNDERSCORE (1L << 1) #define LSA_BLINK (1L << 2) #define LSA_REVERSE (1L << 3) #define LSA_CONCEALED (1L << 4) /* these should be ordered most general to most specific */ typedef enum LS_CFTYPE { LS_NORMAL, LS_FILE, LS_EXEC, LS_DIR, LS_LINK, LS_FIFO, LS_SOCK, LS_DOOR, LS_BLK, LS_CHR, LS_PORT, LS_STICKY, LS_ORPHAN, LS_SETGID, LS_SETUID, LS_OTHER_WRITABLE, LS_STICKY_OTHER_WRITABLE, LS_PAT } ls_cftype_t; typedef struct { char *sfx; ls_cftype_t ftype; int attr; int fg; int bg; } ls_color_t; struct lbuf { union { char lname[MAXNAMLEN]; /* used for filename in a directory */ char *namep; /* for name in ls-command; */ } ln; char ltype; /* filetype */ ino_t lnum; /* inode number of file */ mode_t lflags; /* 0777 bits used as r,w,x permissions */ nlink_t lnl; /* number of links to file */ uid_t luid; gid_t lgid; off_t lsize; /* filesize or major/minor dev numbers */ blkcnt_t lblocks; /* number of file blocks */ timestruc_t lmtime; timestruc_t lat; timestruc_t lct; timestruc_t lmt; char *flinkto; /* symbolic link contents */ char acl; /* indicate there are additional acl entries */ int cycle; /* cycle detected flag */ struct ditem *ancinfo; /* maintains ancestor info */ acl_t *aclp; /* ACL if present */ struct attrb *exttr; /* boolean extended system attributes */ struct attrtm *extm; /* timestamp extended system attributes */ ls_color_t *color; /* color for entry */ ls_color_t *link_color; /* color for symlink */ }; struct dchain { char *dc_name; /* path name */ int cycle_detected; /* cycle detected visiting this directory */ struct ditem *myancinfo; /* this directory's ancestry info */ struct dchain *dc_next; /* next directory in the chain */ }; /* * A numbuf_t is used when converting a number to a string representation */ typedef char numbuf_t[NUMBER_WIDTH]; static struct dchain *dfirst; /* start of the dir chain */ static struct dchain *cdfirst; /* start of the current dir chain */ static struct dchain *dtemp; /* temporary - used for linking */ static char *curdir; /* the current directory */ static int first = 1; /* true if first line is not yet printed */ static int nfiles = 0; /* number of flist entries in current use */ static int nargs = 0; /* number of flist entries used for arguments */ static int maxfils = 0; /* number of flist/lbuf entries allocated */ static int maxn = 0; /* number of flist entries with lbufs asigned */ static int quantn = 64; /* allocation growth quantum */ static struct lbuf *nxtlbf; /* ptr to next lbuf to be assigned */ static struct lbuf **flist; /* ptr to list of lbuf pointers */ static struct lbuf *gstat(char *, int, struct ditem *); static char *getname(uid_t); static char *getgroup(gid_t); static char *makename(char *, char *); static void pentry(struct lbuf *); static void column(void); static void pmode(mode_t aflag); static void selection(int *); static void new_line(void); static void rddir(char *, struct ditem *); static int strcol(unsigned char *); static void pem(struct lbuf **, struct lbuf **, int); static void pdirectory(char *, int, int, int, struct ditem *); static struct cachenode *findincache(struct cachenode **, long); static void csi_pprintf(unsigned char *); static void pprintf(char *, char *); static int compar(struct lbuf **pp1, struct lbuf **pp2); static char *number_to_scaled_string(numbuf_t buf, unsigned long long number, long scale); static void record_ancestry(char *, struct stat *, struct lbuf *, int, struct ditem *); static void ls_color_init(void); static ls_color_t *ls_color_find(const char *, mode_t); static void ls_start_color(ls_color_t *); static void ls_end_color(void); static int aflg; static int atflg; static int bflg; static int cflg; static int dflg; static int eflg; static int fflg; static int gflg; static int hflg; static int iflg; static int lflg; static int mflg; static int nflg; static int oflg; static int pflg; static int qflg; static int rflg = 1; /* init to 1 for special use in compar */ static int sflg; static int tflg; static int uflg; static int Uflg; static int wflg; static int xflg; static int Aflg; static int Bflg; static int Cflg; static int Eflg; static int Fflg; static int Hflg; static int Lflg; static int Rflg; static int Sflg; static int vflg; static int Vflg; static int saflg; /* boolean extended system attr. */ static int sacnt; /* number of extended system attr. */ static int copt; static int vopt; static int tmflg; /* create time ext. system attr. */ static int ctm; static int atm; static int mtm; static int crtm; static int alltm; static long hscale; static mode_t flags; static int err = 0; /* Contains return code */ static int colorflg; static int file_typeflg; static uid_t lastuid = (uid_t)-1; static gid_t lastgid = (gid_t)-1; static char *lastuname = NULL; static char *lastgname = NULL; /* statreq > 0 if any of sflg, (n)lflg, tflg, Sflg, colorflg are on */ static int statreq; static uint64_t block_size = 1; static char *dotp = "."; static u_longlong_t tblocks; /* number of blocks of files in a directory */ static time_t year, now; static int num_cols = 80; static int colwidth; static int filewidth; static int fixedwidth; static int nomocore; static int curcol; static struct winsize win; /* if time_fmt_new is left NULL, time_fmt_old is used for all times */ static const char *time_fmt_old = FORMAT_OLD; /* non-recent files */ static const char *time_fmt_new = FORMAT_NEW; /* recent files */ static int time_custom; /* != 0 if a custom format */ static char time_buf[FMTSIZE]; /* array to hold day and time */ static int lsc_debug; static ls_color_t *lsc_match; static ls_color_t *lsc_colors; static size_t lsc_ncolors; static char *lsc_bold; static char *lsc_underline; static char *lsc_blink; static char *lsc_reverse; static char *lsc_concealed; static char *lsc_none; static char *lsc_setfg; static char *lsc_setbg; static ls_color_t *lsc_orphan; #define NOTWORKINGDIR(d, l) (((l) < 2) || \ (strcmp((d) + (l) - 2, "/.") != 0)) #define NOTPARENTDIR(d, l) (((l) < 3) || \ (strcmp((d) + (l) - 3, "/..") != 0)) /* Extended system attributes support */ static int get_sysxattr(char *, struct lbuf *); static void set_sysattrb_display(char *, boolean_t, struct lbuf *); static void set_sysattrtm_display(char *, struct lbuf *); static void format_time(time_t, time_t); static void print_time(struct lbuf *); static void format_attrtime(struct lbuf *); static void *xmalloc(size_t, struct lbuf *); static void free_sysattr(struct lbuf *); static nvpair_t *pair; static nvlist_t *response; static int acl_err; const struct option long_options[] = { { "all", no_argument, NULL, 'a' }, { "almost-all", no_argument, NULL, 'A' }, { "escape", no_argument, NULL, 'b' }, { "classify", no_argument, NULL, 'F' }, { "human-readable", no_argument, NULL, 'h' }, { "dereference", no_argument, NULL, 'L' }, { "dereference-command-line", no_argument, NULL, 'H' }, { "ignore-backups", no_argument, NULL, 'B' }, { "inode", no_argument, NULL, 'i' }, { "numeric-uid-gid", no_argument, NULL, 'n' }, { "no-group", no_argument, NULL, 'o' }, { "hide-control-chars", no_argument, NULL, 'q' }, { "reverse", no_argument, NULL, 'r' }, { "recursive", no_argument, NULL, 'R' }, { "size", no_argument, NULL, 's' }, { "width", required_argument, NULL, 'w' }, /* no short options for these */ { "block-size", required_argument, NULL, 0 }, { "full-time", no_argument, NULL, 0 }, { "si", no_argument, NULL, 0 }, { "color", optional_argument, NULL, 0 }, { "colour", optional_argument, NULL, 0}, { "file-type", no_argument, NULL, 0 }, { "time-style", required_argument, NULL, 0 }, {0, 0, 0, 0} }; int main(int argc, char *argv[]) { int c; int i; int width; int amino = 0; int opterr = 0; int option_index = 0; struct lbuf *ep; struct lbuf lb; struct ditem *myinfo; (void) setlocale(LC_ALL, ""); #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ #endif (void) textdomain(TEXT_DOMAIN); #ifdef STANDALONE if (argv[0][0] == '\0') argc = getargv("ls", &argv, 0); #endif lb.lmtime.tv_sec = time(NULL); lb.lmtime.tv_nsec = 0; year = lb.lmtime.tv_sec - 6L*30L*24L*60L*60L; /* 6 months ago */ now = lb.lmtime.tv_sec + 60; if (isatty(1)) { Cflg = 1; mflg = 0; } while ((c = getopt_long(argc, argv, "+aAbBcCdeEfFghHiklLmnopqrRsStuUw:x1@vV/:%:", long_options, &option_index)) != -1) switch (c) { case 0: /* non-short options */ if (strcmp(long_options[option_index].name, "color") == 0 || strcmp(long_options[option_index].name, "colour") == 0) { if (optarg == NULL || strcmp(optarg, "always") == 0 || strcmp(optarg, "yes") == 0 || strcmp(optarg, "force") == 0) { colorflg++; statreq++; continue; } if (strcmp(optarg, "auto") == 0 || strcmp(optarg, "tty") == 0 || strcmp(optarg, "if-tty") == 0) { if (isatty(1) == 1) { colorflg++; statreq++; } continue; } if (strcmp(optarg, "never") == 0 || strcmp(optarg, "no") == 0 || strcmp(optarg, "none") == 0) { colorflg = 0; continue; } (void) fprintf(stderr, gettext("Invalid argument '%s' for " "--color\n"), optarg); ++opterr; continue; } if (strcmp(long_options[option_index].name, "si") == 0) { hflg++; hscale = 1000; continue; } if (strcmp(long_options[option_index].name, "block-size") == 0) { size_t scale_len = strlen(optarg); uint64_t scale = 1; uint64_t kilo = 1024; char scale_c; if (scale_len == 0) { (void) fprintf(stderr, gettext( "Invalid block size \'%s\'\n"), optarg); exit(1); } scale_c = optarg[scale_len - 1]; if (scale_c == 'B') { /* need at least digit, scale, B */ if (scale_len < 3) { (void) fprintf(stderr, gettext( "Invalid block size " "\'%s\'\n"), optarg); exit(1); } kilo = 1000; scale_c = optarg[scale_len - 2]; if (isdigit(scale_c)) { (void) fprintf(stderr, gettext("Invalid block size" " \'%s\'\n"), optarg); exit(1); } /* * make optarg[scale_len - 1] point to * the scale factor */ --scale_len; } switch (scale_c) { case 'y': case 'Y': scale *= kilo; /*FALLTHROUGH*/ case 'Z': case 'z': scale *= kilo; /*FALLTHROUGH*/ case 'E': case 'e': scale *= kilo; /*FALLTHROUGH*/ case 'P': case 'p': scale *= kilo; /*FALLTHROUGH*/ case 'T': case 't': scale *= kilo; /*FALLTHROUGH*/ case 'G': case 'g': scale *= kilo; /*FALLTHROUGH*/ case 'M': case 'm': scale *= kilo; /*FALLTHROUGH*/ case 'K': case 'k': scale *= kilo; break; default: if (!isdigit(scale_c)) { (void) fprintf(stderr, gettext("Invalid character " "following block size in " "\'%s\'\n"), optarg); exit(1); } } /* NULL out scale constant if present */ if (scale > 1 && !isdigit(scale_c)) optarg[scale_len - 1] = '\0'; /* Based on testing, this is what GNU ls does */ block_size = strtoll(optarg, NULL, 0) * scale; if (block_size < 1) { (void) fprintf(stderr, gettext("Invalid block size " "\'%s\'\n"), optarg); exit(1); } continue; } if (strcmp(long_options[option_index].name, "file-type") == 0) { file_typeflg++; Fflg++; statreq++; continue; } if (strcmp(long_options[option_index].name, "full-time") == 0) { Eflg++; statreq++; eflg = 0; time_fmt_old = FORMAT_ISO_FULL; time_fmt_new = FORMAT_ISO_FULL; continue; } if (strcmp(long_options[option_index].name, "time-style") == 0) { /* like -E, but doesn't imply -l */ if (strcmp(optarg, "full-iso") == 0) { Eflg++; statreq++; eflg = 0; time_fmt_old = FORMAT_ISO_FULL; time_fmt_new = FORMAT_ISO_FULL; continue; } if (strcmp(optarg, "long-iso") == 0) { statreq++; Eflg = 0; eflg = 0; time_fmt_old = FORMAT_ISO_LONG; time_fmt_new = FORMAT_ISO_LONG; continue; } if (strcmp(optarg, "iso") == 0) { statreq++; Eflg = 0; eflg = 0; time_fmt_old = FORMAT_ISO_OLD; time_fmt_new = FORMAT_ISO_NEW; continue; } /* should be the default */ if (strcmp(optarg, "locale") == 0) { time_fmt_old = FORMAT_OLD; time_fmt_new = FORMAT_NEW; continue; } if (optarg[0] == '+') { char *told, *tnew; char *p; size_t timelen = strlen(optarg); p = strchr(optarg, '\n'); if (p != NULL) *p++ = '\0'; /* * Time format requires a leading and * trailing space * Add room for 3 spaces + 2 nulls * The + in optarg is replaced with * a space. */ timelen += 2 + 3; told = malloc(timelen); if (told == NULL) { perror("ls"); exit(2); } (void) memset(told, 0, timelen); told[0] = ' '; (void) strlcat(told, &optarg[1], timelen); (void) strlcat(told, " ", timelen); if (p != NULL) { size_t tnew_len; tnew = told + strlen(told) + 1; tnew_len = timelen - strlen(told) - 1; tnew[0] = ' '; (void) strlcat(tnew, p, tnew_len); (void) strlcat(tnew, " ", tnew_len); time_fmt_new = (const char *)tnew; } else { time_fmt_new = (const char *)told; } time_fmt_old = (const char *)told; time_custom = 1; continue; } continue; } continue; case 'a': aflg++; continue; case 'A': Aflg++; continue; case 'b': bflg = 1; qflg = 0; continue; case 'B': Bflg = 1; continue; case 'c': uflg = 0; atm = 0; ctm = 0; mtm = 0; crtm = 0; cflg++; continue; case 'C': Cflg = 1; mflg = 0; #ifdef XPG4 lflg = 0; #endif continue; case 'd': dflg++; continue; case 'e': eflg++; lflg++; statreq++; Eflg = 0; time_fmt_old = FORMAT_LONG; time_fmt_new = FORMAT_LONG; continue; case 'E': Eflg++; lflg++; statreq++; eflg = 0; time_fmt_old = FORMAT_ISO_FULL; time_fmt_new = FORMAT_ISO_FULL; continue; case 'f': fflg++; continue; case 'F': Fflg++; statreq++; continue; case 'g': gflg++; lflg++; statreq++; continue; case 'h': hflg++; hscale = 1024; continue; case 'H': Hflg++; /* -H and -L are mutually exclusive */ Lflg = 0; continue; case 'i': iflg++; continue; case 'k': block_size = 1024; continue; case 'l': lflg++; statreq++; Cflg = 0; xflg = 0; mflg = 0; atflg = 0; continue; case 'L': Lflg++; /* -H and -L are mutually exclusive */ Hflg = 0; continue; case 'm': Cflg = 0; mflg = 1; #ifdef XPG4 lflg = 0; #endif continue; case 'n': nflg++; lflg++; statreq++; Cflg = 0; xflg = 0; mflg = 0; atflg = 0; continue; case 'o': oflg++; lflg++; statreq++; continue; case 'p': pflg++; statreq++; continue; case 'q': qflg = 1; bflg = 0; continue; case 'r': rflg = -1; continue; case 'R': Rflg++; statreq++; continue; case 's': sflg++; statreq++; continue; case 'S': tflg = 0; Uflg = 0; Sflg++; statreq++; continue; case 't': Sflg = 0; Uflg = 0; tflg++; statreq++; continue; case 'U': Sflg = 0; tflg = 0; Uflg++; continue; case 'u': cflg = 0; atm = 0; ctm = 0; mtm = 0; crtm = 0; uflg++; continue; case 'V': Vflg++; /*FALLTHROUGH*/ case 'v': vflg++; #if !defined(XPG4) if (lflg) continue; #endif lflg++; statreq++; Cflg = 0; xflg = 0; mflg = 0; continue; case 'w': wflg++; num_cols = atoi(optarg); continue; case 'x': xflg = 1; Cflg = 1; mflg = 0; #ifdef XPG4 lflg = 0; #endif continue; case '1': Cflg = 0; continue; case '@': #if !defined(XPG4) /* * -l has precedence over -@ */ if (lflg) continue; #endif atflg++; lflg++; statreq++; Cflg = 0; xflg = 0; mflg = 0; continue; case '/': saflg++; if (optarg != NULL) { if (strcmp(optarg, "c") == 0) { copt++; vopt = 0; } else if (strcmp(optarg, "v") == 0) { vopt++; copt = 0; } else opterr++; } else opterr++; lflg++; statreq++; Cflg = 0; xflg = 0; mflg = 0; continue; case '%': tmflg++; if (optarg != NULL) { if (strcmp(optarg, "ctime") == 0) { ctm++; atm = 0; mtm = 0; crtm = 0; } else if (strcmp(optarg, "atime") == 0) { atm++; ctm = 0; mtm = 0; crtm = 0; uflg = 0; cflg = 0; } else if (strcmp(optarg, "mtime") == 0) { mtm++; atm = 0; ctm = 0; crtm = 0; uflg = 0; cflg = 0; } else if (strcmp(optarg, "crtime") == 0) { crtm++; atm = 0; ctm = 0; mtm = 0; uflg = 0; cflg = 0; } else if (strcmp(optarg, "all") == 0) { alltm++; atm = 0; ctm = 0; mtm = 0; crtm = 0; } else opterr++; } else opterr++; Sflg = 0; statreq++; mflg = 0; continue; case '?': opterr++; continue; } if (opterr) { (void) fprintf(stderr, gettext( "usage: ls -aAbBcCdeEfFghHiklLmnopqrRsStuUwxvV1@/%[c | v]" "%%[atime | crtime | ctime | mtime | all]" " [files]\n")); exit(2); } if (fflg) { aflg++; lflg = 0; sflg = 0; tflg = 0; Sflg = 0; statreq = 0; } fixedwidth = 2; if (pflg || Fflg) fixedwidth++; if (iflg) fixedwidth += 11; if (sflg) fixedwidth += 5; if (lflg) { if (!gflg && !oflg) gflg = oflg = 1; else if (gflg && oflg) gflg = oflg = 0; Cflg = mflg = 0; } if (!wflg && (Cflg || mflg)) { char *clptr; if ((clptr = getenv("COLUMNS")) != NULL) num_cols = atoi(clptr); #ifdef TERMINFO else { if (ioctl(1, TIOCGWINSZ, &win) != -1) num_cols = (win.ws_col == 0 ? 80 : win.ws_col); } #endif } if (num_cols < 20 || num_cols > 1000) /* assume it is an error */ num_cols = 80; /* allocate space for flist and the associated */ /* data structures (lbufs) */ maxfils = quantn; if (((flist = malloc(maxfils * sizeof (struct lbuf *))) == NULL) || ((nxtlbf = malloc(quantn * sizeof (struct lbuf))) == NULL)) { perror("ls"); exit(2); } if ((amino = (argc-optind)) == 0) { /* * case when no names are given * in ls-command and current * directory is to be used */ argv[optind] = dotp; } for (i = 0; i < (amino ? amino : 1); i++) { /* * If we are recursing, we need to make sure we don't * get into an endless loop. To keep track of the inodes * (actually, just the directories) visited, we * maintain a directory ancestry list for a file * hierarchy. As we go deeper into the hierarchy, * a parent directory passes its directory list * info (device id, inode number, and a pointer to * its parent) to each of its children. As we * process a child that is a directory, we save * its own personal directory list info. We then * check to see if the child has already been * processed by comparing its device id and inode * number from its own personal directory list info * to that of each of its ancestors. If there is a * match, then we know we've detected a cycle. */ if (Rflg) { /* * This is the first parent in this lineage * (first in a directory hierarchy), so * this parent's parent doesn't exist. We * only initialize myinfo when we are * recursing, otherwise it's not used. */ if ((myinfo = (struct ditem *)malloc( sizeof (struct ditem))) == NULL) { perror("ls"); exit(2); } else { myinfo->dev = 0; myinfo->ino = 0; myinfo->parent = NULL; } } if (Cflg || mflg) { width = strcol((unsigned char *)argv[optind]); if (width > filewidth) filewidth = width; } if ((ep = gstat((*argv[optind] ? argv[optind] : dotp), 1, myinfo)) == NULL) { if (nomocore) exit(2); err = 2; optind++; continue; } ep->ln.namep = (*argv[optind] ? argv[optind] : dotp); ep->lflags |= ISARG; optind++; nargs++; /* count good arguments stored in flist */ if (acl_err) err = 2; } colwidth = fixedwidth + filewidth; if (!Uflg) qsort(flist, (unsigned)nargs, sizeof (struct lbuf *), (int (*)(const void *, const void *))compar); for (i = 0; i < nargs; i++) { if (flist[i]->ltype == 'd' && dflg == 0 || fflg) break; } if (colorflg) ls_color_init(); pem(&flist[0], &flist[i], 0); for (; i < nargs; i++) { pdirectory(flist[i]->ln.namep, Rflg || (amino > 1), nargs, 0, flist[i]->ancinfo); if (nomocore) exit(2); /* -R: print subdirectories found */ while (dfirst || cdfirst) { /* Place direct subdirs on front in right order */ while (cdfirst) { /* reverse cdfirst onto front of dfirst */ dtemp = cdfirst; cdfirst = cdfirst -> dc_next; dtemp -> dc_next = dfirst; dfirst = dtemp; } /* take off first dir on dfirst & print it */ dtemp = dfirst; dfirst = dfirst->dc_next; pdirectory(dtemp->dc_name, 1, nargs, dtemp->cycle_detected, dtemp->myancinfo); if (nomocore) exit(2); free(dtemp->dc_name); free(dtemp); } } return (err); } /* * pdirectory: print the directory name, labelling it if title is * nonzero, using lp as the place to start reading in the dir. */ static void pdirectory(char *name, int title, int lp, int cdetect, struct ditem *myinfo) { struct dchain *dp; struct lbuf *ap; char *pname; int j; filewidth = 0; curdir = name; if (title) { if (!first) (void) putc('\n', stdout); pprintf(name, ":"); new_line(); } /* * If there was a cycle detected, then notify and don't report * further. */ if (cdetect) { if (lflg || sflg) { curcol += printf(gettext("total %d"), 0); new_line(); } (void) fprintf(stderr, gettext( "ls: cycle detected for %s\n"), name); return; } nfiles = lp; rddir(name, myinfo); if (nomocore) return; if (fflg == 0 && Uflg == 0) qsort(&flist[lp], (unsigned)(nfiles - lp), sizeof (struct lbuf *), (int (*)(const void *, const void *))compar); if (Rflg) { for (j = nfiles - 1; j >= lp; j--) { ap = flist[j]; if (ap->ltype == 'd' && strcmp(ap->ln.lname, ".") && strcmp(ap->ln.lname, "..")) { dp = malloc(sizeof (struct dchain)); if (dp == NULL) { perror("ls"); exit(2); } pname = makename(curdir, ap->ln.lname); if ((dp->dc_name = strdup(pname)) == NULL) { perror("ls"); exit(2); } dp->cycle_detected = ap->cycle; dp->myancinfo = ap->ancinfo; dp->dc_next = dfirst; dfirst = dp; } } } if (lflg || sflg) { curcol += printf(gettext("total %llu"), tblocks); new_line(); } pem(&flist[lp], &flist[nfiles], lflg||sflg); } /* * pem: print 'em. Print a list of files (e.g. a directory) bounded * by slp and lp. */ static void pem(struct lbuf **slp, struct lbuf **lp, int tot_flag) { long row, nrows, i; int col, ncols; struct lbuf **ep; if (Cflg || mflg) { if (colwidth > num_cols) { ncols = 1; } else { ncols = num_cols / colwidth; } } if (ncols == 1 || mflg || xflg || !Cflg) { for (ep = slp; ep < lp; ep++) pentry(*ep); new_line(); return; } /* otherwise print -C columns */ if (tot_flag) { slp--; row = 1; } else row = 0; nrows = (lp - slp - 1) / ncols + 1; for (i = 0; i < nrows; i++, row++) { for (col = 0; col < ncols; col++) { ep = slp + (nrows * col) + row; if (ep < lp) pentry(*ep); } new_line(); } } /* * print one output entry; * if uid/gid is not found in the appropriate * file(passwd/group), then print uid/gid instead of * user/group name; */ static void pentry(struct lbuf *ap) { struct lbuf *p; numbuf_t hbuf; char *dmark = ""; /* Used if -p or -F option active */ char *cp; char *str; p = ap; column(); if (iflg) if (mflg && !lflg) curcol += printf("%llu ", (long long)p->lnum); else curcol += printf("%10llu ", (long long)p->lnum); if (sflg) curcol += printf((mflg && !lflg) ? "%lld " : (p->lblocks < 10000) ? "%4lld " : "%lld ", (p->ltype != 'b' && p->ltype != 'c') ? p->lblocks : 0LL); if (lflg) { (void) putchar(p->ltype); curcol++; pmode(p->lflags); /* ACL: additional access mode flag */ (void) putchar(p->acl); curcol++; curcol += printf("%3lu ", (ulong_t)p->lnl); if (oflg) if (!nflg) { cp = getname(p->luid); curcol += printf("%-8s ", cp); } else curcol += printf("%-8lu ", (ulong_t)p->luid); if (gflg) if (!nflg) { cp = getgroup(p->lgid); curcol += printf("%-8s ", cp); } else curcol += printf("%-8lu ", (ulong_t)p->lgid); if (p->ltype == 'b' || p->ltype == 'c') { curcol += printf("%3u, %2u", (uint_t)major((dev_t)p->lsize), (uint_t)minor((dev_t)p->lsize)); } else if (hflg && (p->lsize >= hscale)) { curcol += printf("%7s", number_to_scaled_string(hbuf, p->lsize, hscale)); } else { uint64_t bsize = p->lsize / block_size; /* * Round up only when using blocks > 1 byte, otherwise * 'normal' sizes display 1 byte too large. */ if (p->lsize % block_size != 0) bsize++; curcol += printf("%7" PRIu64, bsize); } format_time(p->lmtime.tv_sec, p->lmtime.tv_nsec); /* format extended system attribute time */ if (tmflg && crtm) format_attrtime(p); curcol += printf("%s", time_buf); } /* * prevent both "->" and trailing marks * from appearing */ if (pflg && p->ltype == 'd') dmark = "/"; if (Fflg && !(lflg && p->flinkto)) { if (p->ltype == 'd') dmark = "/"; else if (p->ltype == 'D') dmark = ">"; else if (p->ltype == 'p') dmark = "|"; else if (p->ltype == 'l') dmark = "@"; else if (p->ltype == 's') dmark = "="; else if (!file_typeflg && (p->lflags & (S_IXUSR|S_IXGRP|S_IXOTH))) dmark = "*"; else dmark = ""; } if (colorflg) ls_start_color(p->color); if (p->lflags & ISARG) str = p->ln.namep; else str = p->ln.lname; if (qflg || bflg) { csi_pprintf((unsigned char *)str); if (lflg && p->flinkto) { if (colorflg) ls_end_color(); csi_pprintf((unsigned char *)" -> "); if (colorflg) ls_start_color(p->link_color); csi_pprintf((unsigned char *)p->flinkto); } else { csi_pprintf((unsigned char *)dmark); } } else { (void) printf("%s", str); curcol += strcol((unsigned char *)str); if (lflg && p->flinkto) { if (colorflg) ls_end_color(); str = " -> "; (void) printf("%s", str); curcol += strcol((unsigned char *)str); if (colorflg) ls_start_color(p->link_color); (void) printf("%s", p->flinkto); curcol += strcol((unsigned char *)p->flinkto); } else { (void) printf("%s", dmark); curcol += strcol((unsigned char *)dmark); } } if (colorflg) ls_end_color(); /* Display extended system attributes */ if (saflg) { int i; new_line(); (void) printf(" \t{"); if (p->exttr != NULL) { int k = 0; for (i = 0; i < sacnt; i++) { if (p->exttr[i].name != NULL) k++; } for (i = 0; i < sacnt; i++) { if (p->exttr[i].name != NULL) { (void) printf("%s", p->exttr[i].name); k--; if (vopt && (k != 0)) (void) printf(","); } } } (void) printf("}\n"); } /* Display file timestamps and extended system attribute timestamps */ if (tmflg && alltm) { new_line(); print_time(p); new_line(); } if (vflg) { new_line(); if (p->aclp) { acl_printacl(p->aclp, num_cols, Vflg); } } /* Free extended system attribute lists */ if (saflg || tmflg) free_sysattr(p); } /* print various r,w,x permissions */ static void pmode(mode_t aflag) { /* these arrays are declared static to allow initializations */ static int m0[] = { 1, S_IRUSR, 'r', '-' }; static int m1[] = { 1, S_IWUSR, 'w', '-' }; static int m2[] = { 3, S_ISUID|S_IXUSR, 's', S_IXUSR, 'x', S_ISUID, 'S', '-' }; static int m3[] = { 1, S_IRGRP, 'r', '-' }; static int m4[] = { 1, S_IWGRP, 'w', '-' }; static int m5[] = { 4, S_ISGID|S_IXGRP, 's', S_IXGRP, 'x', S_ISGID|LS_NOTREG, 'S', #ifdef XPG4 S_ISGID, 'L', '-'}; #else S_ISGID, 'l', '-'}; #endif static int m6[] = { 1, S_IROTH, 'r', '-' }; static int m7[] = { 1, S_IWOTH, 'w', '-' }; static int m8[] = { 3, S_ISVTX|S_IXOTH, 't', S_IXOTH, 'x', S_ISVTX, 'T', '-'}; static int *m[] = { m0, m1, m2, m3, m4, m5, m6, m7, m8}; int **mp; flags = aflag; for (mp = &m[0]; mp < &m[sizeof (m) / sizeof (m[0])]; mp++) selection(*mp); } static void selection(int *pairp) { int n; n = *pairp++; while (n-->0) { if ((flags & *pairp) == *pairp) { pairp++; break; } else { pairp += 2; } } (void) putchar(*pairp); curcol++; } /* * column: get to the beginning of the next column. */ static void column(void) { if (curcol == 0) return; if (mflg) { (void) putc(',', stdout); curcol++; if (curcol + colwidth + 2 > num_cols) { (void) putc('\n', stdout); curcol = 0; return; } (void) putc(' ', stdout); curcol++; return; } if (Cflg == 0) { (void) putc('\n', stdout); curcol = 0; return; } if ((curcol / colwidth + 2) * colwidth > num_cols) { (void) putc('\n', stdout); curcol = 0; return; } do { (void) putc(' ', stdout); curcol++; } while (curcol % colwidth); } static void new_line(void) { if (curcol) { first = 0; (void) putc('\n', stdout); curcol = 0; } } /* * read each filename in directory dir and store its * status in flist[nfiles] * use makename() to form pathname dir/filename; */ static void rddir(char *dir, struct ditem *myinfo) { struct dirent *dentry; DIR *dirf; int j; struct lbuf *ep; int width; if ((dirf = opendir(dir)) == NULL) { (void) fflush(stdout); perror(dir); err = 2; return; } else { tblocks = 0; for (;;) { errno = 0; if ((dentry = readdir(dirf)) == NULL) break; if (aflg == 0 && dentry->d_name[0] == '.' && (Aflg == 0 || dentry->d_name[1] == '\0' || dentry->d_name[1] == '.' && dentry->d_name[2] == '\0')) /* * check for directory items '.', '..', * and items without valid inode-number; */ continue; /* skip entries ending in ~ if -B was given */ if (Bflg && dentry->d_name[strlen(dentry->d_name) - 1] == '~') continue; if (Cflg || mflg) { width = strcol((unsigned char *)dentry->d_name); if (width > filewidth) filewidth = width; } ep = gstat(makename(dir, dentry->d_name), 0, myinfo); if (ep == NULL) { if (nomocore) exit(2); continue; } else { ep->lnum = dentry->d_ino; for (j = 0; dentry->d_name[j] != '\0'; j++) ep->ln.lname[j] = dentry->d_name[j]; ep->ln.lname[j] = '\0'; } } if (errno) { int sav_errno = errno; (void) fprintf(stderr, gettext("ls: error reading directory %s: %s\n"), dir, strerror(sav_errno)); } (void) closedir(dirf); colwidth = fixedwidth + filewidth; } } /* * Attaching a link to an inode's ancestors. Search * through the ancestors to check for cycles (an inode which * we have already tracked in this inodes ancestry). If a cycle * is detected, set the exit code and record the fact so that * it is reported at the right time when printing the directory. * In addition, set the exit code. Note: If the -a flag was * specified, we don't want to check for cycles for directories * ending in '/.' or '/..' unless they were specified on the * command line. */ static void record_ancestry(char *file, struct stat *pstatb, struct lbuf *rep, int argfl, struct ditem *myparent) { size_t file_len; struct ditem *myinfo; struct ditem *tptr; file_len = strlen(file); if (!aflg || argfl || (NOTWORKINGDIR(file, file_len) && NOTPARENTDIR(file, file_len))) { /* * Add this inode's ancestry * info and insert it into the * ancestry list by pointing * back to its parent. We save * it (in rep) with the other info * we're gathering for this inode. */ if ((myinfo = malloc( sizeof (struct ditem))) == NULL) { perror("ls"); exit(2); } myinfo->dev = pstatb->st_dev; myinfo->ino = pstatb->st_ino; myinfo->parent = myparent; rep->ancinfo = myinfo; /* * If this node has the same device id and * inode number of one of its ancestors, * then we've detected a cycle. */ if (myparent != NULL) { for (tptr = myparent; tptr->parent != NULL; tptr = tptr->parent) { if ((tptr->dev == pstatb->st_dev) && (tptr->ino == pstatb->st_ino)) { /* * Cycle detected for this * directory. Record the fact * it is a cycle so we don't * try to process this * directory as we are * walking through the * list of directories. */ rep->cycle = 1; err = 2; break; } } } } } /* * Do re-calculate the mode for group for ACE_T type of acls. * This is because, if the server's FS happens to be UFS, supporting * POSIX ACL's, then it does a special calculation of group mode * to be the bitwise OR of CLASS_OBJ and GROUP_OBJ (see PSARC/2001/717.) * * This algorithm is from the NFSv4 ACL Draft. Here a part of that * algorithm is used for the group mode calculation only. * What is modified here from the algorithm is that only the * entries with flags ACE_GROUP are considered. For each entry * with ACE_GROUP flag, the first occurance of a specific access * is checked if it is allowed. * We are not interested in perms for user and other, as they * were taken from st_mode value. * We are not interested in a_who field of ACE, as we need just * unix mode bits for the group. */ #define OWNED_GROUP (ACE_GROUP | ACE_IDENTIFIER_GROUP) #define IS_TYPE_ALLOWED(type) ((type) == ACE_ACCESS_ALLOWED_ACE_TYPE) int grp_mask_to_mode(struct lbuf *p) { int mode = 0, seen = 0; int acecnt; int flags; ace_t *ap; acl_t *acep = p->aclp; acecnt = acl_cnt(acep); for (ap = (ace_t *)acl_data(acep); acecnt--; ap++) { if (ap->a_type != ACE_ACCESS_ALLOWED_ACE_TYPE && ap->a_type != ACE_ACCESS_DENIED_ACE_TYPE) continue; if (ap->a_flags & ACE_INHERIT_ONLY_ACE) continue; /* * if it is first group@ or first everyone@ * for each of read, write and execute, then * that will be the group mode bit. */ flags = ap->a_flags & ACE_TYPE_FLAGS; if (flags == OWNED_GROUP || (flags == ACE_IDENTIFIER_GROUP && ap->a_who == p->lgid) || flags == ACE_EVERYONE) { if (ap->a_access_mask & ACE_READ_DATA) { if (!(seen & S_IRGRP)) { seen |= S_IRGRP; if (IS_TYPE_ALLOWED(ap->a_type)) mode |= S_IRGRP; } } if (ap->a_access_mask & ACE_WRITE_DATA) { if (!(seen & S_IWGRP)) { seen |= S_IWGRP; if (IS_TYPE_ALLOWED(ap->a_type)) mode |= S_IWGRP; } } if (ap->a_access_mask & ACE_EXECUTE) { if (!(seen & S_IXGRP)) { seen |= S_IXGRP; if (IS_TYPE_ALLOWED(ap->a_type)) mode |= S_IXGRP; } } } } return (mode); } /* * get status of file and recomputes tblocks; * argfl = 1 if file is a name in ls-command and = 0 * for filename in a directory whose name is an * argument in the command; * stores a pointer in flist[nfiles] and * returns that pointer; * returns NULL if failed; */ static struct lbuf * gstat(char *file, int argfl, struct ditem *myparent) { struct stat statb, statb1; struct lbuf *rep; char buf[BUFSIZ]; ssize_t cc; int (*statf)() = ((Lflg) || (Hflg && argfl)) ? stat : lstat; int aclcnt; int error; aclent_t *tp; o_mode_t groupperm, mask; int grouppermfound, maskfound; if (nomocore) return (NULL); if (nfiles >= maxfils) { /* * all flist/lbuf pair assigned files, time to get some * more space */ maxfils += quantn; if (((flist = realloc(flist, maxfils * sizeof (struct lbuf *))) == NULL) || ((nxtlbf = malloc(quantn * sizeof (struct lbuf))) == NULL)) { perror("ls"); nomocore = 1; return (NULL); } } /* * nfiles is reset to nargs for each directory * that is given as an argument maxn is checked * to prevent the assignment of an lbuf to a flist entry * that already has one assigned. */ if (nfiles >= maxn) { rep = nxtlbf++; flist[nfiles++] = rep; maxn = nfiles; } else { rep = flist[nfiles++]; } /* Initialize */ rep->lflags = (mode_t)0; rep->flinkto = NULL; rep->cycle = 0; rep->lat.tv_sec = time(NULL); rep->lat.tv_nsec = 0; rep->lct.tv_sec = time(NULL); rep->lct.tv_nsec = 0; rep->lmt.tv_sec = time(NULL); rep->lmt.tv_nsec = 0; rep->exttr = NULL; rep->extm = NULL; rep->color = NULL; rep->link_color = NULL; if (argfl || statreq) { int doacl; if (lflg) doacl = 1; else doacl = 0; if ((*statf)(file, &statb) < 0) { if (argfl || errno != ENOENT || (Lflg && lstat(file, &statb) == 0)) { /* * Avoid race between readdir and lstat. * Print error message in case of dangling link. */ perror(file); err = 2; } nfiles--; return (NULL); } /* * If -H was specified, and the file linked to was * not a directory, then we need to get the info * for the symlink itself. */ if ((Hflg) && (argfl) && ((statb.st_mode & S_IFMT) != S_IFDIR)) { if (lstat(file, &statb) < 0) { perror(file); err = 2; } } rep->lnum = statb.st_ino; rep->lsize = statb.st_size; rep->lblocks = statb.st_blocks; if (colorflg) rep->color = ls_color_find(file, statb.st_mode); switch (statb.st_mode & S_IFMT) { case S_IFDIR: rep->ltype = 'd'; if (Rflg) { record_ancestry(file, &statb, rep, argfl, myparent); } break; case S_IFBLK: rep->ltype = 'b'; rep->lsize = (off_t)statb.st_rdev; break; case S_IFCHR: rep->ltype = 'c'; rep->lsize = (off_t)statb.st_rdev; break; case S_IFIFO: rep->ltype = 'p'; break; case S_IFSOCK: rep->ltype = 's'; rep->lsize = 0; break; case S_IFLNK: /* symbolic links may not have ACLs, so elide acl() */ if ((Lflg == 0) || (Hflg == 0) || ((Hflg) && (!argfl))) { doacl = 0; } rep->ltype = 'l'; if (lflg || colorflg) { cc = readlink(file, buf, BUFSIZ); if (cc < 0) break; /* * follow the symbolic link * to generate the appropriate * Fflg marker for the object * eg, /bin -> /sym/bin/ */ error = 0; if (Fflg || pflg || colorflg) error = stat(file, &statb1); if (colorflg) { if (error >= 0) rep->link_color = ls_color_find(file, statb1.st_mode); else rep->link_color = lsc_orphan; } if ((Fflg || pflg) && error >= 0) { switch (statb1.st_mode & S_IFMT) { case S_IFDIR: buf[cc++] = '/'; break; case S_IFSOCK: buf[cc++] = '='; break; case S_IFDOOR: buf[cc++] = '>'; break; case S_IFIFO: buf[cc++] = '|'; break; default: if ((statb1.st_mode & ~S_IFMT) & (S_IXUSR|S_IXGRP| S_IXOTH)) buf[cc++] = '*'; break; } } buf[cc] = '\0'; rep->flinkto = strdup(buf); if (rep->flinkto == NULL) { perror("ls"); nomocore = 1; return (NULL); } break; } /* * ls /sym behaves differently from ls /sym/ * when /sym is a symbolic link. This is fixed * when explicit arguments are specified. */ #ifdef XPG6 /* Do not follow a symlink when -F is specified */ if ((!argfl) || (argfl && Fflg) || (stat(file, &statb1) < 0)) #else /* Follow a symlink when -F is specified */ if (!argfl || stat(file, &statb1) < 0) #endif /* XPG6 */ break; if ((statb1.st_mode & S_IFMT) == S_IFDIR) { statb = statb1; rep->ltype = 'd'; rep->lsize = statb1.st_size; if (Rflg) { record_ancestry(file, &statb, rep, argfl, myparent); } } break; case S_IFDOOR: rep->ltype = 'D'; break; case S_IFREG: rep->ltype = '-'; break; case S_IFPORT: rep->ltype = 'P'; break; default: rep->ltype = '?'; break; } rep->lflags = statb.st_mode & ~S_IFMT; if (!S_ISREG(statb.st_mode)) rep->lflags |= LS_NOTREG; rep->luid = statb.st_uid; rep->lgid = statb.st_gid; rep->lnl = statb.st_nlink; if (uflg || (tmflg && atm)) rep->lmtime = statb.st_atim; else if (cflg || (tmflg && ctm)) rep->lmtime = statb.st_ctim; else rep->lmtime = statb.st_mtim; rep->lat = statb.st_atim; rep->lct = statb.st_ctim; rep->lmt = statb.st_mtim; /* ACL: check acl entries count */ if (doacl) { error = acl_get(file, 0, &rep->aclp); if (error) { (void) fprintf(stderr, gettext("ls: can't read ACL on %s: %s\n"), file, acl_strerror(error)); rep->acl = ' '; acl_err++; return (rep); } rep->acl = ' '; if (rep->aclp && ((acl_flags(rep->aclp) & ACL_IS_TRIVIAL) == 0)) { rep->acl = '+'; /* * Special handling for ufs aka aclent_t ACL's */ if (acl_type(rep->aclp) == ACLENT_T) { /* * For files with non-trivial acls, the * effective group permissions are the * intersection of the GROUP_OBJ value * and the CLASS_OBJ (acl mask) value. * Determine both the GROUP_OBJ and * CLASS_OBJ for this file and insert * the logical AND of those two values * in the group permissions field * of the lflags value for this file. */ /* * Until found in acl list, assume * maximum permissions for both group * a nd mask. (Just in case the acl * lacks either value for some reason.) */ groupperm = 07; mask = 07; grouppermfound = 0; maskfound = 0; aclcnt = acl_cnt(rep->aclp); for (tp = (aclent_t *)acl_data(rep->aclp); aclcnt--; tp++) { if (tp->a_type == GROUP_OBJ) { groupperm = tp->a_perm; grouppermfound = 1; continue; } if (tp->a_type == CLASS_OBJ) { mask = tp->a_perm; maskfound = 1; } if (grouppermfound && maskfound) break; } /* reset all the group bits */ rep->lflags &= ~S_IRWXG; /* * Now set them to the logical AND of * the GROUP_OBJ permissions and the * acl mask. */ rep->lflags |= (groupperm & mask) << 3; } else if (acl_type(rep->aclp) == ACE_T) { int mode; mode = grp_mask_to_mode(rep); rep->lflags &= ~S_IRWXG; rep->lflags |= mode; } } if (!vflg && !Vflg && rep->aclp) { acl_free(rep->aclp); rep->aclp = NULL; } if (atflg && pathconf(file, _PC_XATTR_EXISTS) == 1) rep->acl = '@'; } else rep->acl = ' '; /* mask ISARG and other file-type bits */ if (rep->ltype != 'b' && rep->ltype != 'c') tblocks += rep->lblocks; /* Get extended system attributes */ if ((saflg || (tmflg && crtm) || (tmflg && alltm)) && (sysattr_support(file, _PC_SATTR_EXISTS) == 1)) { int i; sacnt = attr_count(); /* * Allocate 'sacnt' size array to hold extended * system attribute name (verbose) or respective * symbol represenation (compact). */ rep->exttr = xmalloc(sacnt * sizeof (struct attrb), rep); /* initialize boolean attribute list */ for (i = 0; i < sacnt; i++) rep->exttr[i].name = NULL; if (get_sysxattr(file, rep) != 0) { (void) fprintf(stderr, gettext("ls:Failed to retrieve " "extended system attribute from " "%s\n"), file); rep->exttr[0].name = xmalloc(2, rep); (void) strlcpy(rep->exttr[0].name, "?", 2); } } } return (rep); } /* * returns pathname of the form dir/file; * dir and file are null-terminated strings. */ static char * makename(char *dir, char *file) { /* * PATH_MAX is the maximum length of a path name. * MAXNAMLEN is the maximum length of any path name component. * Allocate space for both, plus the '/' in the middle * and the null character at the end. * dfile is static as this is returned by makename(). */ static char dfile[PATH_MAX + 1 + MAXNAMLEN + 1]; char *dp, *fp; dp = dfile; fp = dir; while (*fp) *dp++ = *fp++; if (dp > dfile && *(dp - 1) != '/') *dp++ = '/'; fp = file; while (*fp) *dp++ = *fp++; *dp = '\0'; return (dfile); } #include #include #include struct utmpx utmp; #define NMAX (sizeof (utmp.ut_name)) #define SCPYN(a, b) (void) strncpy(a, b, NMAX) struct cachenode { /* this struct must be zeroed before using */ struct cachenode *lesschild; /* subtree whose entries < val */ struct cachenode *grtrchild; /* subtree whose entries > val */ long val; /* the uid or gid of this entry */ int initted; /* name has been filled in */ char name[NMAX+1]; /* the string that val maps to */ }; static struct cachenode *names, *groups; static struct cachenode * findincache(struct cachenode **head, long val) { struct cachenode **parent = head; struct cachenode *c = *parent; while (c != NULL) { if (val == c->val) { /* found it */ return (c); } else if (val < c->val) { parent = &c->lesschild; c = c->lesschild; } else { parent = &c->grtrchild; c = c->grtrchild; } } /* not in the cache, make a new entry for it */ c = calloc(1, sizeof (struct cachenode)); if (c == NULL) { perror("ls"); exit(2); } *parent = c; c->val = val; return (c); } /* * get name from cache, or passwd file for a given uid; * lastuid is set to uid. */ static char * getname(uid_t uid) { struct passwd *pwent; struct cachenode *c; if ((uid == lastuid) && lastuname) return (lastuname); c = findincache(&names, uid); if (c->initted == 0) { if ((pwent = getpwuid(uid)) != NULL) { SCPYN(&c->name[0], pwent->pw_name); } else { (void) sprintf(&c->name[0], "%-8u", (int)uid); } c->initted = 1; } lastuid = uid; lastuname = &c->name[0]; return (lastuname); } /* * get name from cache, or group file for a given gid; * lastgid is set to gid. */ static char * getgroup(gid_t gid) { struct group *grent; struct cachenode *c; if ((gid == lastgid) && lastgname) return (lastgname); c = findincache(&groups, gid); if (c->initted == 0) { if ((grent = getgrgid(gid)) != NULL) { SCPYN(&c->name[0], grent->gr_name); } else { (void) sprintf(&c->name[0], "%-8u", (int)gid); } c->initted = 1; } lastgid = gid; lastgname = &c->name[0]; return (lastgname); } /* return >0 if item pointed by pp2 should appear first */ static int compar(struct lbuf **pp1, struct lbuf **pp2) { struct lbuf *p1, *p2; p1 = *pp1; p2 = *pp2; if (dflg == 0) { /* * compare two names in ls-command one of which is file * and the other is a directory; * this portion is not used for comparing files within * a directory name of ls-command; */ if (p1->lflags&ISARG && p1->ltype == 'd') { if (!(p2->lflags&ISARG && p2->ltype == 'd')) return (1); } else { if (p2->lflags&ISARG && p2->ltype == 'd') return (-1); } } if (tflg) { if (p2->lmtime.tv_sec > p1->lmtime.tv_sec) return (rflg); else if (p2->lmtime.tv_sec < p1->lmtime.tv_sec) return (-rflg); /* times are equal to the sec, check nsec */ if (p2->lmtime.tv_nsec > p1->lmtime.tv_nsec) return (rflg); else if (p2->lmtime.tv_nsec < p1->lmtime.tv_nsec) return (-rflg); /* if times are equal, fall through and sort by name */ } else if (Sflg) { /* * The size stored in lsize can be either the * size or the major minor number (in the case of * block and character special devices). If it's * a major minor number, then the size is considered * to be zero and we want to fall through and sort * by name. In addition, if the size of p2 is equal * to the size of p1 we want to fall through and * sort by name. */ off_t p1size = (p1->ltype == 'b') || (p1->ltype == 'c') ? 0 : p1->lsize; off_t p2size = (p2->ltype == 'b') || (p2->ltype == 'c') ? 0 : p2->lsize; if (p2size > p1size) { return (rflg); } else if (p2size < p1size) { return (-rflg); } /* Sizes are equal, fall through and sort by name. */ } return (rflg * strcoll( p1->lflags & ISARG ? p1->ln.namep : p1->ln.lname, p2->lflags&ISARG ? p2->ln.namep : p2->ln.lname)); } static void pprintf(char *s1, char *s2) { csi_pprintf((unsigned char *)s1); csi_pprintf((unsigned char *)s2); } static void csi_pprintf(unsigned char *s) { unsigned char *cp; char c; int i; int c_len; int p_col; wchar_t pcode; if (!qflg && !bflg) { for (cp = s; *cp != '\0'; cp++) { (void) putchar(*cp); curcol++; } return; } for (cp = s; *cp; ) { if (isascii(c = *cp)) { if (!isprint(c)) { if (qflg) { c = '?'; } else { curcol += 3; (void) putc('\\', stdout); c = '0' + ((*cp >> 6) & 07); (void) putc(c, stdout); c = '0' + ((*cp >> 3) & 07); (void) putc(c, stdout); c = '0' + (*cp & 07); } } curcol++; cp++; (void) putc(c, stdout); continue; } if ((c_len = mbtowc(&pcode, (char *)cp, MB_LEN_MAX)) <= 0) { c_len = 1; goto not_print; } if ((p_col = wcwidth(pcode)) > 0) { (void) putwchar(pcode); cp += c_len; curcol += p_col; continue; } not_print: for (i = 0; i < c_len; i++) { if (qflg) { c = '?'; } else { curcol += 3; (void) putc('\\', stdout); c = '0' + ((*cp >> 6) & 07); (void) putc(c, stdout); c = '0' + ((*cp >> 3) & 07); (void) putc(c, stdout); c = '0' + (*cp & 07); } curcol++; (void) putc(c, stdout); cp++; } } } static int strcol(unsigned char *s1) { int w; int w_col; int len; wchar_t wc; w = 0; while (*s1) { if (isascii(*s1)) { w++; s1++; continue; } if ((len = mbtowc(&wc, (char *)s1, MB_LEN_MAX)) <= 0) { w++; s1++; continue; } if ((w_col = wcwidth(wc)) < 0) w_col = len; s1 += len; w += w_col; } return (w); } /* * Convert an unsigned long long to a string representation and place the * result in the caller-supplied buffer. * * The number provided is a size in bytes. The number is first * converted to an integral multiple of 'scale' bytes. This new * number is then scaled down until it is small enough to be in a good * human readable format, i.e. in the range 0 thru scale-1. If the * number used to derive the final number is not a multiple of scale, and * the final number has only a single significant digit, we compute * tenths of units to provide a second significant digit. * * The value "(unsigned long long)-1" is a special case and is always * converted to "-1". * * A pointer to the caller-supplied buffer is returned. */ static char * number_to_scaled_string( numbuf_t buf, /* put the result here */ unsigned long long number, /* convert this number */ long scale) { unsigned long long save; /* Measurement: kilo, mega, giga, tera, peta, exa */ char *uom = "KMGTPE"; if ((long long)number == (long long)-1) { (void) strlcpy(buf, "-1", sizeof (numbuf_t)); return (buf); } save = number; number = number / scale; /* * Now we have number as a count of scale units. * If no further scaling is necessary, we round up as appropriate. * * The largest value number could have had entering the routine is * 16 Exabytes, so running off the end of the uom array should * never happen. We check for that, though, as a guard against * a breakdown elsewhere in the algorithm. */ if (number < (unsigned long long)scale) { if ((save % scale) >= (unsigned long long)(scale / 2)) { if (++number == (unsigned long long)scale) { uom++; number = 1; } } } else { while ((number >= (unsigned long long)scale) && (*uom != 'E')) { uom++; /* next unit of measurement */ save = number; /* * If we're over half way to the next unit of * 'scale' bytes (which means we should round * up), then adding half of 'scale' prior to * the division will push us into that next * unit of scale when we perform the division */ number = (number + (scale / 2)) / scale; } } /* check if we should output a decimal place after the point */ if ((save / scale) < 10) { /* snprintf() will round for us */ float fnum = (float)save / scale; (void) snprintf(buf, sizeof (numbuf_t), "%2.1f%c", fnum, *uom); } else { (void) snprintf(buf, sizeof (numbuf_t), "%4llu%c", number, *uom); } return (buf); } /* Get extended system attributes and set the display */ int get_sysxattr(char *fname, struct lbuf *rep) { boolean_t value; data_type_t type; int error; char *name; int i; if ((error = getattrat(AT_FDCWD, XATTR_VIEW_READWRITE, fname, &response)) != 0) { perror("ls:getattrat"); return (error); } /* * Allocate 'sacnt' size array to hold extended timestamp * system attributes and initialize the array. */ rep->extm = xmalloc(sacnt * sizeof (struct attrtm), rep); for (i = 0; i < sacnt; i++) { rep->extm[i].stm = 0; rep->extm[i].nstm = 0; rep->extm[i].name = NULL; } while ((pair = nvlist_next_nvpair(response, pair)) != NULL) { name = nvpair_name(pair); type = nvpair_type(pair); if (type == DATA_TYPE_BOOLEAN_VALUE) { error = nvpair_value_boolean_value(pair, &value); if (error) { (void) fprintf(stderr, gettext("nvpair_value_boolean_value " "failed: error = %d\n"), error); continue; } if (name != NULL) set_sysattrb_display(name, value, rep); continue; } else if (type == DATA_TYPE_UINT64_ARRAY) { if (name != NULL) set_sysattrtm_display(name, rep); continue; } } nvlist_free(response); return (0); } /* Set extended system attribute boolean display */ void set_sysattrb_display(char *name, boolean_t val, struct lbuf *rep) { f_attr_t fattr; const char *opt; size_t len; fattr = name_to_attr(name); if (fattr != F_ATTR_INVAL && fattr < sacnt) { if (vopt) { len = strlen(name); if (val) { rep->exttr[fattr].name = xmalloc(len + 1, rep); (void) strlcpy(rep->exttr[fattr].name, name, len + 1); } else { rep->exttr[fattr].name = xmalloc(len + 3, rep); (void) snprintf(rep->exttr[fattr].name, len + 3, "no%s", name); } } else { opt = attr_to_option(fattr); if (opt != NULL) { len = strlen(opt); rep->exttr[fattr].name = xmalloc(len + 1, rep); if (val) (void) strlcpy(rep->exttr[fattr].name, opt, len + 1); else (void) strlcpy(rep->exttr[fattr].name, "-", len + 1); } } } } /* Set extended system attribute timestamp display */ void set_sysattrtm_display(char *name, struct lbuf *rep) { uint_t nelem; uint64_t *value; int i; size_t len; if (nvpair_value_uint64_array(pair, &value, &nelem) == 0) { if (*value != NULL) { len = strlen(name); i = 0; while (rep->extm[i].stm != 0 && i < sacnt) i++; rep->extm[i].stm = value[0]; rep->extm[i].nstm = value[1]; rep->extm[i].name = xmalloc(len + 1, rep); (void) strlcpy(rep->extm[i].name, name, len + 1); } } } void format_time(time_t sec, time_t nsec) { const char *fstr = time_fmt_new; char fmt_buf[FMTSIZE]; if (Eflg) { (void) snprintf(fmt_buf, FMTSIZE, fstr, nsec); (void) strftime(time_buf, sizeof (time_buf), fmt_buf, localtime(&sec)); return; } if (sec < year || sec > now) fstr = time_fmt_old; /* if a custom time was specified, shouldn't be localized */ (void) strftime(time_buf, sizeof (time_buf), (time_custom == 0) ? dcgettext(NULL, fstr, LC_TIME) : fstr, localtime(&sec)); } void format_attrtime(struct lbuf *p) { int tmattr = 0; int i; if (p->extm != NULL) { for (i = 0; i < sacnt; i++) { if (p->extm[i].name != NULL) { tmattr = 1; break; } } } if (tmattr) { const char *old_save = time_fmt_old; const char *new_save = time_fmt_new; /* Eflg always sets format to FORMAT_ISO_FULL */ if (!Eflg && !time_custom) { time_fmt_old = FORMAT_OLD; time_fmt_new = FORMAT_NEW; } format_time((time_t)p->extm[i].stm, (time_t)p->extm[i].nstm); time_fmt_old = old_save; time_fmt_new = new_save; } } void print_time(struct lbuf *p) { const char *old_save = time_fmt_old; const char *new_save = time_fmt_new; int i = 0; if (!Eflg) { time_fmt_old = FORMAT_LONG; time_fmt_new = FORMAT_LONG; } new_line(); format_time(p->lat.tv_sec, p->lat.tv_nsec); (void) printf(" timestamp: atime %s\n", time_buf); format_time(p->lct.tv_sec, p->lct.tv_nsec); (void) printf(" timestamp: ctime %s\n", time_buf); format_time(p->lmt.tv_sec, p->lmt.tv_nsec); (void) printf(" timestamp: mtime %s\n", time_buf); if (p->extm != NULL) { while (p->extm[i].nstm != 0 && i < sacnt) { format_time(p->extm[i].stm, p->extm[i].nstm); if (p->extm[i].name != NULL) { (void) printf(" timestamp:" " %s %s\n", p->extm[i].name, time_buf); } i++; } } time_fmt_old = old_save; time_fmt_new = new_save; } /* * Check if color definition applies to entry, returns 1 if yes, 0 if no */ static int color_match(const char *fname, mode_t mode, ls_color_t *color) { switch (color->ftype) { case LS_PAT: { size_t fname_len, sfx_len; fname_len = strlen(fname); sfx_len = strlen(color->sfx); if (sfx_len > fname_len) return (0); if (strcmp(color->sfx, fname + fname_len - sfx_len) == 0) return (1); else return (0); } case LS_NORMAL: return (1); case LS_FILE: return (S_ISREG(mode)); case LS_DIR: return (S_ISDIR(mode)); case LS_LINK: return (S_ISLNK(mode)); case LS_FIFO: return (S_ISFIFO(mode)); case LS_SOCK: return (S_ISSOCK(mode)); case LS_DOOR: return (S_ISDOOR(mode)); case LS_BLK: return (S_ISBLK(mode)); case LS_CHR: return (S_ISCHR(mode)); case LS_PORT: return (S_ISPORT(mode)); case LS_ORPHAN: /* this is tested for by gstat */ return (0); case LS_SETUID: return (!S_ISLNK(mode) && (mode & S_ISUID)); case LS_SETGID: return (!S_ISLNK(mode) && (mode & S_ISGID)); case LS_STICKY_OTHER_WRITABLE: return (!S_ISLNK(mode) && (mode & (S_IWOTH|S_ISVTX))); case LS_OTHER_WRITABLE: return (!S_ISLNK(mode) && (mode & S_IWOTH)); case LS_STICKY: return (!S_ISLNK(mode) && (mode & S_ISVTX)); case LS_EXEC: return (!S_ISLNK(mode) && (mode & (S_IXUSR|S_IXGRP|S_IXOTH))); } return (0); } static void dump_color(ls_color_t *c) { if (c == NULL) return; (void) printf("\n\ttype: "); switch (c->ftype) { case LS_NORMAL: (void) printf("LS_NORMAL"); break; case LS_FILE: (void) printf("LS_FILE"); break; case LS_EXEC: (void) printf("LS_EXEC"); break; case LS_DIR: (void) printf("LS_DIR"); break; case LS_LINK: (void) printf("LS_LINK"); break; case LS_FIFO: (void) printf("LS_FIFO"); break; case LS_SOCK: (void) printf("LS_SOCK"); break; case LS_DOOR: (void) printf("LS_DOOR"); break; case LS_BLK: (void) printf("LS_BLK"); break; case LS_CHR: (void) printf("LS_CHR"); break; case LS_PORT: (void) printf("LS_PORT"); break; case LS_STICKY: (void) printf("LS_STICKY"); break; case LS_ORPHAN: (void) printf("LS_ORPHAN"); break; case LS_SETGID: (void) printf("LS_SETGID"); break; case LS_SETUID: (void) printf("LS_SETUID"); break; case LS_OTHER_WRITABLE: (void) printf("LS_OTHER_WRITABLE"); break; case LS_STICKY_OTHER_WRITABLE: (void) printf("LS_STICKY_OTHER_WRITABLE"); break; case LS_PAT: (void) printf("LS_PAT\n"); (void) printf("\tpattern: %s", c->sfx); break; } (void) printf("\n"); (void) printf("\tattr: %d\n", c->attr); (void) printf("\tfg: %d\n", c->fg); (void) printf("\tbg: %d\n", c->bg); (void) printf("\t"); } static ls_color_t * ls_color_find(const char *fname, mode_t mode) { int i; /* * Colors are sorted from most general lsc_colors[0] to most specific * lsc_colors[lsc_ncolors - 1] by ls_color_init(). Start search with * most specific color rule and work towards most general. */ for (i = lsc_ncolors - 1; i >= 0; --i) if (color_match(fname, mode, &lsc_colors[i])) return (&lsc_colors[i]); return (NULL); } static void ls_tprint(char *str, long int p1, long int p2, long int p3, long int p4, long int p5, long int p6, long int p7, long int p8, long int p9) { char *s; if (str == NULL) return; s = tparm(str, p1, p2, p3, p4, p5, p6, p7, p8, p9); if (s != NULL) (void) putp(s); } static void ls_start_color(ls_color_t *c) { if (c == NULL) return; if (lsc_debug) lsc_match = c; if (c->attr & LSA_BOLD) ls_tprint(lsc_bold, 0, 0, 0, 0, 0, 0, 0, 0, 0); if (c->attr & LSA_UNDERSCORE) ls_tprint(lsc_underline, 0, 0, 0, 0, 0, 0, 0, 0, 0); if (c->attr & LSA_BLINK) ls_tprint(lsc_blink, 0, 0, 0, 0, 0, 0, 0, 0, 0); if (c->attr & LSA_REVERSE) ls_tprint(lsc_reverse, 0, 0, 0, 0, 0, 0, 0, 0, 0); if (c->attr & LSA_CONCEALED) ls_tprint(lsc_concealed, 0, 0, 0, 0, 0, 0, 0, 0, 0); if (c->attr == LSA_NONE) ls_tprint(lsc_none, 0, 0, 0, 0, 0, 0, 0, 0, 0); if (c->fg != -1) ls_tprint(lsc_setfg, c->fg, 0, 0, 0, 0, 0, 0, 0, 0); if (c->bg != -1) ls_tprint(lsc_setbg, c->bg, 0, 0, 0, 0, 0, 0, 0, 0); } static void ls_end_color() { ls_tprint(lsc_none, 0, 0, 0, 0, 0, 0, 0, 0, 0); if (lsc_debug) dump_color(lsc_match); } static void new_color_entry(char *colorstr) { static const struct { const char *s; ls_cftype_t stype; } type_map[] = { { "no", LS_NORMAL }, { "fi", LS_FILE }, { "di", LS_DIR }, { "ln", LS_LINK }, { "pi", LS_FIFO }, { "so", LS_SOCK }, { "do", LS_DOOR }, { "bd", LS_BLK }, { "cd", LS_CHR }, { "or", LS_ORPHAN }, { "su", LS_SETUID }, { "sg", LS_SETGID }, { "tw", LS_STICKY_OTHER_WRITABLE }, { "ow", LS_OTHER_WRITABLE }, { "st", LS_STICKY }, { "ex", LS_EXEC }, { "po", LS_PORT }, { NULL, LS_NORMAL } }; char *p, *lasts; int i; int color, attr; p = strtok_r(colorstr, "=", &lasts); if (p == NULL) { colorflg = 0; return; } if (p[0] == '*') { lsc_colors[lsc_ncolors].ftype = LS_PAT; /* don't include the * in the suffix */ if ((lsc_colors[lsc_ncolors].sfx = strdup(p + 1)) == NULL) { colorflg = 0; return; } } else { lsc_colors[lsc_ncolors].sfx = NULL; for (i = 0; type_map[i].s != NULL; ++i) { if (strncmp(type_map[i].s, p, 2) == 0) break; } /* ignore unknown file types */ if (type_map[i].s == NULL) return; lsc_colors[lsc_ncolors].ftype = type_map[i].stype; } attr = LSA_NONE; lsc_colors[lsc_ncolors].fg = -1; lsc_colors[lsc_ncolors].bg = -1; for (p = strtok_r(NULL, ";", &lasts); p != NULL; p = strtok_r(NULL, ";", &lasts)) { color = strtol(p, NULL, 10); if (color < 10) { switch (color) { case 0: attr = LSA_NONE; continue; case 1: attr |= LSA_BOLD; continue; case 4: attr |= LSA_UNDERSCORE; continue; case 5: attr |= LSA_BLINK; continue; case 7: attr |= LSA_REVERSE; continue; case 8: attr |= LSA_CONCEALED; continue; default: continue; } } if (color < 40) lsc_colors[lsc_ncolors].fg = color - 30; else lsc_colors[lsc_ncolors].bg = color - 40; } lsc_colors[lsc_ncolors].attr = attr; ++lsc_ncolors; } static int ls_color_compare(const void *p1, const void *p2) { const ls_color_t *c1 = (const ls_color_t *)p1; const ls_color_t *c2 = (const ls_color_t *)p2; int ret = c1->ftype - c2->ftype; if (ret != 0) return (ret); if (c1->ftype != LS_PAT) return (ret); return (strcmp(c1->sfx, c2->sfx)); } static void ls_color_init() { static char *default_colorstr = "no=00:fi=00:di=01;34:ln=01;36:po=01;35" ":pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01" ":su=37;41:sg=30;43:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31" ":*.tgz=01;31:*.arj=01;31:*.taz=01;31:*.lzh=01;31:*.zip=01;31" ":*.z=01;31:*.Z=01;31:*.gz=01;31:*.bz2=01;31:*.deb=01;31" ":*.rpm=01;31:*.jar=01;31:*.jpg=01;35:*.jpeg=01;35:*.gif=01;35" ":*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35" ":*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35" ":*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.avi=01;35:*.fli=01;35" ":*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.flac=01;35" ":*.mp3=01;35:*.mpc=01;35:*.ogg=01;35:*.wav=01;35"; char *colorstr; char *p, *lasts; size_t color_sz; int termret; int i; (void) setupterm(NULL, 1, &termret); if (termret != 1) return; if ((p = getenv("LS_COLORS")) == NULL) p = default_colorstr; colorstr = strdup(p); if (colorstr == NULL) return; /* * Determine the size of lsc_colors. color_sz can be > lsc_ncolors * if there are invalid entries passed in the string (they are ignored) */ color_sz = 1; for (p = strchr(colorstr, ':'); p != NULL && *p != '\0'; p = strchr(++p, ':')) ++color_sz; lsc_colors = calloc(color_sz, sizeof (ls_color_t)); if (lsc_colors == NULL) { free(colorstr); return; } for (p = strtok_r(colorstr, ":", &lasts); p != NULL && lsc_ncolors < color_sz; p = strtok_r(NULL, ":", &lasts)) new_color_entry(p); qsort((void *)lsc_colors, lsc_ncolors, sizeof (ls_color_t), ls_color_compare); for (i = 0; i < lsc_ncolors; ++i) if (lsc_colors[i].ftype == LS_ORPHAN) { lsc_orphan = &lsc_colors[i]; break; } if ((lsc_bold = tigetstr("bold")) == (char *)-1) lsc_bold = NULL; if ((lsc_underline = tigetstr("smul")) == (char *)-1) lsc_underline = NULL; if ((lsc_blink = tigetstr("blink")) == (char *)-1) lsc_blink = NULL; if ((lsc_reverse = tigetstr("rev")) == (char *)-1) lsc_reverse = NULL; if ((lsc_concealed = tigetstr("prot")) == (char *)-1) lsc_concealed = NULL; if ((lsc_none = tigetstr("sgr0")) == (char *)-1) lsc_none = NULL; if ((lsc_setfg = tigetstr("setaf")) == (char *)-1) lsc_setfg = NULL; if ((lsc_setbg = tigetstr("setab")) == (char *)-1) lsc_setbg = NULL; if (getenv("_LS_COLOR_DEBUG") != NULL) { int i; lsc_debug = 1; for (i = 0; i < lsc_ncolors; ++i) dump_color(&lsc_colors[i]); } free(colorstr); } /* Free extended system attribute lists */ void free_sysattr(struct lbuf *p) { int i; if (p->exttr != NULL) { for (i = 0; i < sacnt; i++) { if (p->exttr[i].name != NULL) free(p->exttr[i].name); } free(p->exttr); } if (p->extm != NULL) { for (i = 0; i < sacnt; i++) { if (p->extm[i].name != NULL) free(p->extm[i].name); } free(p->extm); } } /* Allocate extended system attribute list */ void * xmalloc(size_t size, struct lbuf *p) { if ((p = malloc(size)) == NULL) { perror("ls"); free_sysattr(p); nvlist_free(response); exit(2); } return (p); }