coreutils/ls.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * tiny-ls.c version 0.1.0: A minimalist 'ls'
   4  * Copyright (C) 1996 Brian Candler <B.Candler@pobox.com>
   5  *
   6  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   7  */
   8
   9 /* [date unknown. Perhaps before year 2000]
  10  * To achieve a small memory footprint, this version of 'ls' doesn't do any
  11  * file sorting, and only has the most essential command line switches
  12  * (i.e., the ones I couldn't live without :-) All features which involve
  13  * linking in substantial chunks of libc can be disabled.
  14  *
  15  * Although I don't really want to add new features to this program to
  16  * keep it small, I *am* interested to receive bug fixes and ways to make
  17  * it more portable.
  18  *
  19  * KNOWN BUGS:
  20  * 1. hidden files can make column width too large
  21  *
  22  * NON-OPTIMAL BEHAVIOUR:
  23  * 1. autowidth reads directories twice
  24  * 2. if you do a short directory listing without filetype characters
  25  *    appended, there's no need to stat each one
  26  * PORTABILITY:
  27  * 1. requires lstat (BSD) - how do you do it without?
  28  *
  29  * [2009-03]
  30  * ls sorts listing now, and supports almost all options.
  31  */
  32
  33 //usage:#define ls_trivial_usage
  34 //usage:        "[-1AaCxd"
  35 //usage:        IF_FEATURE_LS_FOLLOWLINKS("LH")
  36 //usage:        IF_FEATURE_LS_RECURSIVE("R")
  37 //usage:        IF_FEATURE_LS_FILETYPES("Fp") "lins"
  38 //usage:        IF_FEATURE_LS_TIMESTAMPS("e")
  39 //usage:        IF_FEATURE_HUMAN_READABLE("h")
  40 //usage:        IF_FEATURE_LS_SORTFILES("rSXv")
  41 //usage:        IF_FEATURE_LS_TIMESTAMPS("ctu")
  42 //usage:        IF_SELINUX("kKZ") "]"
  43 //usage:        IF_FEATURE_AUTOWIDTH(" -w WIDTH") " [FILE]..."
  44 //usage:#define ls_full_usage "\n\n"
  45 //usage:       "List directory contents\n"
  46 //usage:     "\nOptions:"
  47 //usage:     "\n        -1      List in a single column"
  48 //usage:     "\n        -A      Don't list . and .."
  49 //usage:     "\n        -a      Don't hide entries starting with ."
  50 //usage:     "\n        -C      List by columns"
  51 //usage:     "\n        -x      List by lines"
  52 //usage:     "\n        -d      List directory entries instead of contents"
  53 //usage:        IF_FEATURE_LS_FOLLOWLINKS(
  54 //usage:     "\n        -L      Follow symlinks"
  55 //usage:     "\n        -H      Follow symlinks on command line only"
  56 //usage:        )
  57 //usage:        IF_FEATURE_LS_RECURSIVE(
  58 //usage:     "\n        -R      Recurse"
  59 //usage:        )
  60 //usage:        IF_FEATURE_LS_FILETYPES(
  61 //usage:     "\n        -F      Append indicator (one of */=@|) to entries"
  62 //usage:     "\n        -p      Append indicator (one of /=@|) to entries"
  63 //usage:        )
  64 //usage:     "\n        -l      Long listing format"
  65 //usage:     "\n        -i      List inode numbers"
  66 //usage:     "\n        -n      List numeric UIDs and GIDs instead of names"
  67 //usage:     "\n        -s      List the size of each file, in blocks"
  68 //usage:        IF_FEATURE_LS_TIMESTAMPS(
  69 //usage:     "\n        -e      List full date and time"
  70 //usage:        )
  71 //usage:        IF_FEATURE_HUMAN_READABLE(
  72 //usage:     "\n        -h      List sizes in human readable format (1K 243M 2G)"
  73 //usage:        )
  74 //usage:        IF_FEATURE_LS_SORTFILES(
  75 //usage:     "\n        -r      Sort in reverse order"
  76 //usage:     "\n        -S      Sort by file size"
  77 //usage:     "\n        -X      Sort by extension"
  78 //usage:     "\n        -v      Sort by version"
  79 //usage:        )
  80 //usage:        IF_FEATURE_LS_TIMESTAMPS(
  81 //usage:     "\n        -c      With -l: sort by ctime"
  82 //usage:     "\n        -t      With -l: sort by modification time"
  83 //usage:     "\n        -u      With -l: sort by access time"
  84 //usage:        )
  85 //usage:        IF_SELINUX(
  86 //usage:     "\n        -k      List security context"
  87 //usage:     "\n        -K      List security context in long format"
  88 //usage:     "\n        -Z      List security context and permission"
  89 //usage:        )
  90 //usage:        IF_FEATURE_AUTOWIDTH(
  91 //usage:     "\n        -w N    Assume the terminal is N columns wide"
  92 //usage:        )
  93 //usage:        IF_FEATURE_LS_COLOR(
  94 //usage:     "\n        --color[={always,never,auto}]   Control coloring"
  95 //usage:        )
  96
  97 #include "libbb.h"
  98 #include "unicode.h"
  99
 100
 101 /* This is a NOEXEC applet. Be very careful! */
 102
 103
 104 #if ENABLE_FTPD
 105 /* ftpd uses ls, and without timestamps Mozilla won't understand
 106  * ftpd's LIST output.
 107  */
 108 # undef CONFIG_FEATURE_LS_TIMESTAMPS
 109 # undef ENABLE_FEATURE_LS_TIMESTAMPS
 110 # undef IF_FEATURE_LS_TIMESTAMPS
 111 # undef IF_NOT_FEATURE_LS_TIMESTAMPS
 112 # define CONFIG_FEATURE_LS_TIMESTAMPS 1
 113 # define ENABLE_FEATURE_LS_TIMESTAMPS 1
 114 # define IF_FEATURE_LS_TIMESTAMPS(...) __VA_ARGS__
 115 # define IF_NOT_FEATURE_LS_TIMESTAMPS(...)
 116 #endif
 117
 118
 119 enum {
 120 TERMINAL_WIDTH  = 80,           /* use 79 if terminal has linefold bug */
 121
 122 SPLIT_DIR       = 1,
 123 SPLIT_FILE      = 0,
 124 SPLIT_SUBDIR    = 2,
 125
 126 /* Bits in all_fmt: */
 127
 128 /* 51306 lrwxrwxrwx  1 root     root         2 May 11 01:43 /bin/view -> vi* */
 129 /* what file information will be listed */
 130 LIST_INO        = 1 << 0,
 131 LIST_BLOCKS     = 1 << 1,
 132 LIST_MODEBITS   = 1 << 2,
 133 LIST_NLINKS     = 1 << 3,
 134 LIST_ID_NAME    = 1 << 4,
 135 LIST_ID_NUMERIC = 1 << 5,
 136 LIST_CONTEXT    = 1 << 6,
 137 LIST_SIZE       = 1 << 7,
 138 LIST_DATE_TIME  = 1 << 8,
 139 LIST_FULLTIME   = 1 << 9,
 140 LIST_SYMLINK    = 1 << 10,
 141 LIST_FILETYPE   = 1 << 11,
 142 LIST_EXEC       = 1 << 12,
 143 LIST_MASK       = (LIST_EXEC << 1) - 1,
 144
 145 /* what files will be displayed */
 146 DISP_DIRNAME    = 1 << 13,      /* 2 or more items? label directories */
 147 DISP_HIDDEN     = 1 << 14,      /* show filenames starting with . */
 148 DISP_DOT        = 1 << 15,      /* show . and .. */
 149 DISP_NOLIST     = 1 << 16,      /* show directory as itself, not contents */
 150 DISP_RECURSIVE  = 1 << 17,      /* show directory and everything below it */
 151 DISP_ROWS       = 1 << 18,      /* print across rows */
 152 DISP_MASK       = ((DISP_ROWS << 1) - 1) & ~(DISP_DIRNAME - 1),
 153
 154 /* what is the overall style of the listing */
 155 STYLE_COLUMNAR  = 1 << 19,      /* many records per line */
 156 STYLE_LONG      = 2 << 19,      /* one record per line, extended info */
 157 STYLE_SINGLE    = 3 << 19,      /* one record per line */
 158 STYLE_MASK      = STYLE_SINGLE,
 159
 160 /* which of the three times will be used */
 161 TIME_CHANGE     = (1 << 21) * ENABLE_FEATURE_LS_TIMESTAMPS,
 162 TIME_ACCESS     = (1 << 22) * ENABLE_FEATURE_LS_TIMESTAMPS,
 163 TIME_MASK       = (3 << 21) * ENABLE_FEATURE_LS_TIMESTAMPS,
 164
 165 /* how will the files be sorted (CONFIG_FEATURE_LS_SORTFILES) */
 166 SORT_REVERSE    = 1 << 23,
 167
 168 SORT_NAME       = 0,            /* sort by file name */
 169 SORT_SIZE       = 1 << 24,      /* sort by file size */
 170 SORT_ATIME      = 2 << 24,      /* sort by last access time */
 171 SORT_CTIME      = 3 << 24,      /* sort by last change time */
 172 SORT_MTIME      = 4 << 24,      /* sort by last modification time */
 173 SORT_VERSION    = 5 << 24,      /* sort by version */
 174 SORT_EXT        = 6 << 24,      /* sort by file name extension */
 175 SORT_DIR        = 7 << 24,      /* sort by file or directory */
 176 SORT_MASK       = (7 << 24) * ENABLE_FEATURE_LS_SORTFILES,
 177
 178 LIST_LONG       = LIST_MODEBITS | LIST_NLINKS | LIST_ID_NAME | LIST_SIZE | \
 179                   LIST_DATE_TIME | LIST_SYMLINK,
 180 };
 181
 182 /* -Cadil1  Std options, busybox always supports */
 183 /* -gnsxA   Std options, busybox always supports */
 184 /* -Q       GNU option, busybox always supports */
 185 /* -k       SELinux option, busybox always supports (ignores if !SELinux) */
 186 /*          Std has -k which means "show sizes in kbytes" */
 187 /* -FLHRctur Std options, busybox optionally supports */
 188 /* -p       Std option, busybox optionally supports */
 189 /*          Not fully compatible - we show not only '/' but other chars too */
 190 /* -SXvhTw  GNU options, busybox optionally supports */
 191 /*          -T TABWIDTH is ignored (we don't use tabs on output) */
 192 /* -K       SELinux mandated options, busybox optionally supports */
 193 /* -e       I think we made this one up (looks similar to GNU --full-time) */
 194 /* Std opts we do not support: */
 195 /* -H       Follow the links on command line only */
 196 static const char ls_options[] ALIGN1 =
 197         "Cadil1gnsxQAk"      /* 13 opts, total 13 */
 198         IF_FEATURE_LS_TIMESTAMPS("cetu") /* 4, 17 */
 199         IF_FEATURE_LS_SORTFILES("SXrv")  /* 4, 21 */
 200         IF_FEATURE_LS_FILETYPES("Fp")    /* 2, 23 */
 201         IF_FEATURE_LS_RECURSIVE("R")     /* 1, 24 */
 202         IF_SELINUX("KZ")                 /* 2, 26 */
 203         IF_FEATURE_LS_FOLLOWLINKS("LH")  /* 2, 28 */
 204         IF_FEATURE_HUMAN_READABLE("h")   /* 1, 29 */
 205         IF_FEATURE_AUTOWIDTH("T:w:")     /* 2, 31 */
 206         ;
 207 enum {
 208         //OPT_C = (1 << 0),
 209         //OPT_a = (1 << 1),
 210         //OPT_d = (1 << 2),
 211         //OPT_i = (1 << 3),
 212         //OPT_l = (1 << 4),
 213         //OPT_1 = (1 << 5),
 214         OPT_g = (1 << 6),
 215         //OPT_n = (1 << 7),
 216         //OPT_s = (1 << 8),
 217         //OPT_x = (1 << 9),
 218         OPT_Q = (1 << 10),
 219         //OPT_A = (1 << 11),
 220         //OPT_k = (1 << 12),
 221
 222         OPTBIT_c = 13,
 223         OPTBIT_e,
 224         OPTBIT_t,
 225         OPTBIT_u,
 226         OPTBIT_S = OPTBIT_c + 4 * ENABLE_FEATURE_LS_TIMESTAMPS,
 227         OPTBIT_X, /* 18 */
 228         OPTBIT_r,
 229         OPTBIT_v,
 230         OPTBIT_F = OPTBIT_S + 4 * ENABLE_FEATURE_LS_SORTFILES,
 231         OPTBIT_p, /* 22 */
 232         OPTBIT_R = OPTBIT_F + 2 * ENABLE_FEATURE_LS_FILETYPES,
 233         OPTBIT_K = OPTBIT_R + 1 * ENABLE_FEATURE_LS_RECURSIVE,
 234         OPTBIT_Z, /* 25 */
 235         OPTBIT_L = OPTBIT_K + 2 * ENABLE_SELINUX,
 236         OPTBIT_H, /* 27 */
 237         OPTBIT_h = OPTBIT_L + 1 * ENABLE_FEATURE_LS_FOLLOWLINKS,
 238         OPTBIT_T = OPTBIT_h + 2 * ENABLE_FEATURE_HUMAN_READABLE,
 239         OPTBIT_w, /* 30 */
 240         OPTBIT_color = OPTBIT_T + 2 * ENABLE_FEATURE_AUTOWIDTH,
 241
 242         OPT_c = (1 << OPTBIT_c) * ENABLE_FEATURE_LS_TIMESTAMPS,
 243         OPT_e = (1 << OPTBIT_e) * ENABLE_FEATURE_LS_TIMESTAMPS,
 244         OPT_t = (1 << OPTBIT_t) * ENABLE_FEATURE_LS_TIMESTAMPS,
 245         OPT_u = (1 << OPTBIT_u) * ENABLE_FEATURE_LS_TIMESTAMPS,
 246         OPT_S = (1 << OPTBIT_S) * ENABLE_FEATURE_LS_SORTFILES,
 247         OPT_X = (1 << OPTBIT_X) * ENABLE_FEATURE_LS_SORTFILES,
 248         OPT_r = (1 << OPTBIT_r) * ENABLE_FEATURE_LS_SORTFILES,
 249         OPT_v = (1 << OPTBIT_v) * ENABLE_FEATURE_LS_SORTFILES,
 250         OPT_F = (1 << OPTBIT_F) * ENABLE_FEATURE_LS_FILETYPES,
 251         OPT_p = (1 << OPTBIT_p) * ENABLE_FEATURE_LS_FILETYPES,
 252         OPT_R = (1 << OPTBIT_R) * ENABLE_FEATURE_LS_RECURSIVE,
 253         OPT_K = (1 << OPTBIT_K) * ENABLE_SELINUX,
 254         OPT_Z = (1 << OPTBIT_Z) * ENABLE_SELINUX,
 255         OPT_L = (1 << OPTBIT_L) * ENABLE_FEATURE_LS_FOLLOWLINKS,
 256         OPT_H = (1 << OPTBIT_H) * ENABLE_FEATURE_LS_FOLLOWLINKS,
 257         OPT_h = (1 << OPTBIT_h) * ENABLE_FEATURE_HUMAN_READABLE,
 258         OPT_T = (1 << OPTBIT_T) * ENABLE_FEATURE_AUTOWIDTH,
 259         OPT_w = (1 << OPTBIT_w) * ENABLE_FEATURE_AUTOWIDTH,
 260         OPT_color = (1 << OPTBIT_color) * ENABLE_FEATURE_LS_COLOR,
 261 };
 262
 263 /* TODO: simple toggles may be stored as OPT_xxx bits instead */
 264 static const uint32_t opt_flags[] = {
 265         STYLE_COLUMNAR,              /* C */
 266         DISP_HIDDEN | DISP_DOT,      /* a */
 267         DISP_NOLIST,                 /* d */
 268         LIST_INO,                    /* i */
 269         LIST_LONG | STYLE_LONG,      /* l */
 270         STYLE_SINGLE,                /* 1 */
 271         0,                           /* g (don't show owner) - handled via OPT_g */
 272         LIST_ID_NUMERIC,             /* n */
 273         LIST_BLOCKS,                 /* s */
 274         DISP_ROWS | STYLE_COLUMNAR,  /* x */
 275         0,                           /* Q (quote filename) - handled via OPT_Q */
 276         DISP_HIDDEN,                 /* A */
 277         ENABLE_SELINUX * LIST_CONTEXT, /* k (ignored if !SELINUX) */
 278 #if ENABLE_FEATURE_LS_TIMESTAMPS
 279         TIME_CHANGE | (ENABLE_FEATURE_LS_SORTFILES * SORT_CTIME), /* c */
 280         LIST_FULLTIME,               /* e */
 281         ENABLE_FEATURE_LS_SORTFILES * SORT_MTIME, /* t */
 282         TIME_ACCESS | (ENABLE_FEATURE_LS_SORTFILES * SORT_ATIME), /* u */
 283 #endif
 284 #if ENABLE_FEATURE_LS_SORTFILES
 285         SORT_SIZE,                   /* S */
 286         SORT_EXT,                    /* X */
 287         SORT_REVERSE,                /* r */
 288         SORT_VERSION,                /* v */
 289 #endif
 290 #if ENABLE_FEATURE_LS_FILETYPES
 291         LIST_FILETYPE | LIST_EXEC,   /* F */
 292         LIST_FILETYPE,               /* p */
 293 #endif
 294 #if ENABLE_FEATURE_LS_RECURSIVE
 295         DISP_RECURSIVE,              /* R */
 296 #endif
 297 #if ENABLE_SELINUX
 298         LIST_MODEBITS|LIST_NLINKS|LIST_CONTEXT|LIST_SIZE|LIST_DATE_TIME, /* K */
 299         LIST_MODEBITS|LIST_ID_NAME|LIST_CONTEXT, /* Z */
 300 #endif
 301         (1U << 31)
 302         /* options after Z are not processed through opt_flags */
 303 };
 304
 305
 306 /*
 307  * a directory entry and its stat info are stored here
 308  */
 309 struct dnode {
 310         const char *name;       /* the dir entry name */
 311         const char *fullname;   /* the dir entry name */
 312         struct dnode *next;     /* point at the next node */
 313         smallint fname_allocated;
 314         struct stat dstat;      /* the file stat info */
 315         IF_SELINUX(security_context_t sid;)
 316 };
 317
 318 struct globals {
 319 #if ENABLE_FEATURE_LS_COLOR
 320         smallint show_color;
 321 #endif
 322         smallint exit_code;
 323         unsigned all_fmt;
 324 #if ENABLE_FEATURE_AUTOWIDTH
 325         unsigned terminal_width; // = TERMINAL_WIDTH;
 326 #endif
 327 #if ENABLE_FEATURE_LS_TIMESTAMPS
 328         /* Do time() just once. Saves one syscall per file for "ls -l" */
 329         time_t current_time_t;
 330 #endif
 331 } FIX_ALIASING;
 332 #define G (*(struct globals*)&bb_common_bufsiz1)
 333 #if ENABLE_FEATURE_LS_COLOR
 334 # define show_color     (G.show_color    )
 335 #else
 336 enum { show_color = 0 };
 337 #endif
 338 #define exit_code       (G.exit_code     )
 339 #define all_fmt         (G.all_fmt       )
 340 #if ENABLE_FEATURE_AUTOWIDTH
 341 # define terminal_width (G.terminal_width)
 342 #else
 343 enum {
 344         terminal_width = TERMINAL_WIDTH,
 345 };
 346 #endif
 347 #define current_time_t (G.current_time_t)
 348 #define INIT_G() do { \
 349         /* we have to zero it out because of NOEXEC */ \
 350         memset(&G, 0, sizeof(G)); \
 351         IF_FEATURE_AUTOWIDTH(terminal_width = TERMINAL_WIDTH;) \
 352         IF_FEATURE_LS_TIMESTAMPS(time(&current_time_t);) \
 353 } while (0)
 354
 355
 356 static struct dnode *my_stat(const char *fullname, const char *name, int force_follow)
 357 {
 358         struct stat dstat;
 359         struct dnode *cur;
 360         IF_SELINUX(security_context_t sid = NULL;)
 361
 362         if ((option_mask32 & OPT_L) || force_follow) {
 363 #if ENABLE_SELINUX
 364                 if (is_selinux_enabled())  {
 365                          getfilecon(fullname, &sid);
 366                 }
 367 #endif
 368                 if (stat(fullname, &dstat)) {
 369                         bb_simple_perror_msg(fullname);
 370                         exit_code = EXIT_FAILURE;
 371                         return 0;
 372                 }
 373         } else {
 374 #if ENABLE_SELINUX
 375                 if (is_selinux_enabled()) {
 376                         lgetfilecon(fullname, &sid);
 377                 }
 378 #endif
 379                 if (lstat(fullname, &dstat)) {
 380                         bb_simple_perror_msg(fullname);
 381                         exit_code = EXIT_FAILURE;
 382                         return 0;
 383                 }
 384         }
 385
 386         cur = xmalloc(sizeof(*cur));
 387         cur->fullname = fullname;
 388         cur->name = name;
 389         cur->dstat = dstat;
 390         IF_SELINUX(cur->sid = sid;)
 391         return cur;
 392 }
 393
 394 /* FYI type values: 1:fifo 2:char 4:dir 6:blk 8:file 10:link 12:socket
 395  * (various wacky OSes: 13:Sun door 14:BSD whiteout 5:XENIX named file
 396  *  3/7:multiplexed char/block device)
 397  * and we use 0 for unknown and 15 for executables (see below) */
 398 #define TYPEINDEX(mode) (((mode) >> 12) & 0x0f)
 399 #define TYPECHAR(mode)  ("0pcCd?bB-?l?s???" [TYPEINDEX(mode)])
 400 #define APPCHAR(mode)   ("\0|\0\0/\0\0\0\0\0@\0=\0\0\0" [TYPEINDEX(mode)])
 401 /* 036 black foreground              050 black background
 402    037 red foreground                051 red background
 403    040 green foreground              052 green background
 404    041 brown foreground              053 brown background
 405    042 blue foreground               054 blue background
 406    043 magenta (purple) foreground   055 magenta background
 407    044 cyan (light blue) foreground  056 cyan background
 408    045 gray foreground               057 white background
 409 */
 410 #define COLOR(mode) ( \
 411         /*un  fi  chr     dir     blk     file    link    sock        exe */ \
 412         "\037\043\043\045\042\045\043\043\000\045\044\045\043\045\045\040" \
 413         [TYPEINDEX(mode)])
 414 /* Select normal (0) [actually "reset all"] or bold (1)
 415  * (other attributes are 2:dim 4:underline 5:blink 7:reverse,
 416  *  let's use 7 for "impossible" types, just for fun)
 417  * Note: coreutils 6.9 uses inverted red for setuid binaries.
 418  */
 419 #define ATTR(mode) ( \
 420         /*un fi chr   dir   blk   file  link  sock     exe */ \
 421         "\01\00\01\07\01\07\01\07\00\07\01\07\01\07\07\01" \
 422         [TYPEINDEX(mode)])
 423
 424 #if ENABLE_FEATURE_LS_COLOR
 425 /* mode of zero is interpreted as "unknown" (stat failed) */
 426 static char fgcolor(mode_t mode)
 427 {
 428         if (S_ISREG(mode) && (mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
 429                 return COLOR(0xF000);   /* File is executable ... */
 430         return COLOR(mode);
 431 }
 432 static char bold(mode_t mode)
 433 {
 434         if (S_ISREG(mode) && (mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
 435                 return ATTR(0xF000);    /* File is executable ... */
 436         return ATTR(mode);
 437 }
 438 #endif
 439
 440 #if ENABLE_FEATURE_LS_FILETYPES || ENABLE_FEATURE_LS_COLOR
 441 static char append_char(mode_t mode)
 442 {
 443         if (!(all_fmt & LIST_FILETYPE))
 444                 return '\0';
 445         if (S_ISDIR(mode))
 446                 return '/';
 447         if (!(all_fmt & LIST_EXEC))
 448                 return '\0';
 449         if (S_ISREG(mode) && (mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
 450                 return '*';
 451         return APPCHAR(mode);
 452 }
 453 #endif
 454
 455 static unsigned count_dirs(struct dnode **dn, int which)
 456 {
 457         unsigned dirs, all;
 458
 459         if (!dn)
 460                 return 0;
 461
 462         dirs = all = 0;
 463         for (; *dn; dn++) {
 464                 const char *name;
 465
 466                 all++;
 467                 if (!S_ISDIR((*dn)->dstat.st_mode))
 468                         continue;
 469                 name = (*dn)->name;
 470                 if (which != SPLIT_SUBDIR /* if not requested to skip . / .. */
 471                  /* or if it's not . or .. */
 472                  || name[0] != '.' || (name[1] && (name[1] != '.' || name[2]))
 473                 ) {
 474                         dirs++;
 475                 }
 476         }
 477         return which != SPLIT_FILE ? dirs : all - dirs;
 478 }
 479
 480 /* get memory to hold an array of pointers */
 481 static struct dnode **dnalloc(unsigned num)
 482 {
 483         if (num < 1)
 484                 return NULL;
 485
 486         num++; /* so that we have terminating NULL */
 487         return xzalloc(num * sizeof(struct dnode *));
 488 }
 489
 490 #if ENABLE_FEATURE_LS_RECURSIVE
 491 static void dfree(struct dnode **dnp)
 492 {
 493         unsigned i;
 494
 495         if (dnp == NULL)
 496                 return;
 497
 498         for (i = 0; dnp[i]; i++) {
 499                 struct dnode *cur = dnp[i];
 500                 if (cur->fname_allocated)
 501                         free((char*)cur->fullname);
 502                 free(cur);
 503         }
 504         free(dnp);
 505 }
 506 #else
 507 #define dfree(...) ((void)0)
 508 #endif
 509
 510 /* Returns NULL-terminated malloced vector of pointers (or NULL) */
 511 static struct dnode **splitdnarray(struct dnode **dn, int which)
 512 {
 513         unsigned dncnt, d;
 514         struct dnode **dnp;
 515
 516         if (dn == NULL)
 517                 return NULL;
 518
 519         /* count how many dirs or files there are */
 520         dncnt = count_dirs(dn, which);
 521
 522         /* allocate a file array and a dir array */
 523         dnp = dnalloc(dncnt);
 524
 525         /* copy the entrys into the file or dir array */
 526         for (d = 0; *dn; dn++) {
 527                 if (S_ISDIR((*dn)->dstat.st_mode)) {
 528                         const char *name;
 529
 530                         if (!(which & (SPLIT_DIR|SPLIT_SUBDIR)))
 531                                 continue;
 532                         name = (*dn)->name;
 533                         if ((which & SPLIT_DIR)
 534                          || name[0]!='.' || (name[1] && (name[1]!='.' || name[2]))
 535                         ) {
 536                                 dnp[d++] = *dn;
 537                         }
 538                 } else if (!(which & (SPLIT_DIR|SPLIT_SUBDIR))) {
 539                         dnp[d++] = *dn;
 540                 }
 541         }
 542         return dnp;
 543 }
 544
 545 #if ENABLE_FEATURE_LS_SORTFILES
 546 static int sortcmp(const void *a, const void *b)
 547 {
 548         struct dnode *d1 = *(struct dnode **)a;
 549         struct dnode *d2 = *(struct dnode **)b;
 550         unsigned sort_opts = all_fmt & SORT_MASK;
 551         off_t dif;
 552
 553         dif = 0; /* assume SORT_NAME */
 554         // TODO: use pre-initialized function pointer
 555         // instead of branch forest
 556         if (sort_opts == SORT_SIZE) {
 557                 dif = (d2->dstat.st_size - d1->dstat.st_size);
 558         } else if (sort_opts == SORT_ATIME) {
 559                 dif = (d2->dstat.st_atime - d1->dstat.st_atime);
 560         } else if (sort_opts == SORT_CTIME) {
 561                 dif = (d2->dstat.st_ctime - d1->dstat.st_ctime);
 562         } else if (sort_opts == SORT_MTIME) {
 563                 dif = (d2->dstat.st_mtime - d1->dstat.st_mtime);
 564         } else if (sort_opts == SORT_DIR) {
 565                 dif = S_ISDIR(d2->dstat.st_mode) - S_ISDIR(d1->dstat.st_mode);
 566                 /* } else if (sort_opts == SORT_VERSION) { */
 567                 /* } else if (sort_opts == SORT_EXT) { */
 568         }
 569         if (dif == 0) {
 570                 /* sort by name, or tie_breaker for other sorts */
 571                 if (ENABLE_LOCALE_SUPPORT)
 572                         dif = strcoll(d1->name, d2->name);
 573                 else
 574                         dif = strcmp(d1->name, d2->name);
 575         }
 576
 577         /* Make dif fit into an int */
 578         if (sizeof(dif) > sizeof(int)) {
 579                 enum { BITS_TO_SHIFT = 8 * (sizeof(dif) - sizeof(int)) };
 580                 /* shift leaving only "int" worth of bits */
 581                 if (dif != 0) {
 582                         dif = 1 | (int)((uoff_t)dif >> BITS_TO_SHIFT);
 583                 }
 584         }
 585
 586         return (all_fmt & SORT_REVERSE) ? -(int)dif : (int)dif;
 587 }
 588
 589 static void dnsort(struct dnode **dn, int size)
 590 {
 591         qsort(dn, size, sizeof(*dn), sortcmp);
 592 }
 593 #else
 594 #define dnsort(dn, size) ((void)0)
 595 #endif
 596
 597
 598 static unsigned calc_name_len(const char *name)
 599 {
 600         unsigned len;
 601         uni_stat_t uni_stat;
 602
 603         // TODO: quote tab as \t, etc, if -Q
 604         name = printable_string(&uni_stat, name);
 605
 606         if (!(option_mask32 & OPT_Q)) {
 607                 return uni_stat.unicode_width;
 608         }
 609
 610         len = 2 + uni_stat.unicode_width;
 611         while (*name) {
 612                 if (*name == '"' || *name == '\\') {
 613                         len++;
 614                 }
 615                 name++;
 616         }
 617         return len;
 618 }
 619
 620
 621 /* Return the number of used columns.
 622  * Note that only STYLE_COLUMNAR uses return value.
 623  * STYLE_SINGLE and STYLE_LONG don't care.
 624  * coreutils 7.2 also supports:
 625  * ls -b (--escape) = octal escapes (although it doesn't look like working)
 626  * ls -N (--literal) = not escape at all
 627  */
 628 static unsigned print_name(const char *name)
 629 {
 630         unsigned len;
 631         uni_stat_t uni_stat;
 632
 633         // TODO: quote tab as \t, etc, if -Q
 634         name = printable_string(&uni_stat, name);
 635
 636         if (!(option_mask32 & OPT_Q)) {
 637                 fputs(name, stdout);
 638                 return uni_stat.unicode_width;
 639         }
 640
 641         len = 2 + uni_stat.unicode_width;
 642         putchar('"');
 643         while (*name) {
 644                 if (*name == '"' || *name == '\\') {
 645                         putchar('\\');
 646                         len++;
 647                 }
 648                 putchar(*name);
 649                 name++;
 650         }
 651         putchar('"');
 652         return len;
 653 }
 654
 655 /* Return the number of used columns.
 656  * Note that only STYLE_COLUMNAR uses return value,
 657  * STYLE_SINGLE and STYLE_LONG don't care.
 658  */
 659 static NOINLINE unsigned list_single(const struct dnode *dn)
 660 {
 661         unsigned column = 0;
 662         char *lpath = lpath; /* for compiler */
 663 #if ENABLE_FEATURE_LS_FILETYPES || ENABLE_FEATURE_LS_COLOR
 664         struct stat info;
 665         char append;
 666 #endif
 667
 668         /* Never happens:
 669         if (dn->fullname == NULL)
 670                 return 0;
 671         */
 672
 673 #if ENABLE_FEATURE_LS_FILETYPES
 674         append = append_char(dn->dstat.st_mode);
 675 #endif
 676
 677         /* Do readlink early, so that if it fails, error message
 678          * does not appear *inside* the "ls -l" line */
 679         if (all_fmt & LIST_SYMLINK)
 680                 if (S_ISLNK(dn->dstat.st_mode))
 681                         lpath = xmalloc_readlink_or_warn(dn->fullname);
 682
 683         if (all_fmt & LIST_INO)
 684                 column += printf("%7llu ", (long long) dn->dstat.st_ino);
 685         if (all_fmt & LIST_BLOCKS)
 686                 column += printf("%4"OFF_FMT"u ", (off_t) (dn->dstat.st_blocks >> 1));
 687         if (all_fmt & LIST_MODEBITS)
 688                 column += printf("%-10s ", (char *) bb_mode_string(dn->dstat.st_mode));
 689         if (all_fmt & LIST_NLINKS)
 690                 column += printf("%4lu ", (long) dn->dstat.st_nlink);
 691 #if ENABLE_FEATURE_LS_USERNAME
 692         if (all_fmt & LIST_ID_NAME) {
 693                 if (option_mask32 & OPT_g) {
 694                         column += printf("%-8.8s ",
 695                                 get_cached_groupname(dn->dstat.st_gid));
 696                 } else {
 697                         column += printf("%-8.8s %-8.8s ",
 698                                 get_cached_username(dn->dstat.st_uid),
 699                                 get_cached_groupname(dn->dstat.st_gid));
 700                 }
 701         }
 702 #endif
 703         if (all_fmt & LIST_ID_NUMERIC) {
 704                 if (option_mask32 & OPT_g)
 705                         column += printf("%-8u ", (int) dn->dstat.st_gid);
 706                 else
 707                         column += printf("%-8u %-8u ",
 708                                         (int) dn->dstat.st_uid,
 709                                         (int) dn->dstat.st_gid);
 710         }
 711         if (all_fmt & LIST_SIZE) {
 712                 if (S_ISBLK(dn->dstat.st_mode) || S_ISCHR(dn->dstat.st_mode)) {
 713                         column += printf("%4u, %3u ",
 714                                         (int) major(dn->dstat.st_rdev),
 715                                         (int) minor(dn->dstat.st_rdev));
 716                 } else {
 717                         if (option_mask32 & OPT_h) {
 718                                 column += printf("%"HUMAN_READABLE_MAX_WIDTH_STR"s ",
 719                                         /* print st_size, show one fractional, use suffixes */
 720                                         make_human_readable_str(dn->dstat.st_size, 1, 0)
 721                                 );
 722                         } else {
 723                                 column += printf("%9"OFF_FMT"u ", (off_t) dn->dstat.st_size);
 724                         }
 725                 }
 726         }
 727 #if ENABLE_FEATURE_LS_TIMESTAMPS
 728         if (all_fmt & (LIST_FULLTIME|LIST_DATE_TIME)) {
 729                 char *filetime;
 730                 time_t ttime = dn->dstat.st_mtime;
 731                 if (all_fmt & TIME_ACCESS)
 732                         ttime = dn->dstat.st_atime;
 733                 if (all_fmt & TIME_CHANGE)
 734                         ttime = dn->dstat.st_ctime;
 735                 filetime = ctime(&ttime);
 736                 /* filetime's format: "Wed Jun 30 21:49:08 1993\n" */
 737                 if (all_fmt & LIST_FULLTIME)
 738                         column += printf("%.24s ", filetime);
 739                 else { /* LIST_DATE_TIME */
 740                         /* current_time_t ~== time(NULL) */
 741                         time_t age = current_time_t - ttime;
 742                         printf("%.6s ", filetime + 4); /* "Jun 30" */
 743                         if (age < 3600L * 24 * 365 / 2 && age > -15 * 60) {
 744                                 /* hh:mm if less than 6 months old */
 745                                 printf("%.5s ", filetime + 11);
 746                         } else { /* year. buggy if year > 9999 ;) */
 747                                 printf(" %.4s ", filetime + 20);
 748                         }
 749                         column += 13;
 750                 }
 751         }
 752 #endif
 753 #if ENABLE_SELINUX
 754         if (all_fmt & LIST_CONTEXT) {
 755                 column += printf("%-32s ", dn->sid ? dn->sid : "unknown");
 756                 freecon(dn->sid);
 757         }
 758 #endif
 759
 760 #if ENABLE_FEATURE_LS_COLOR
 761         if (show_color) {
 762                 info.st_mode = 0; /* for fgcolor() */
 763                 lstat(dn->fullname, &info);
 764                 printf("\033[%u;%um", bold(info.st_mode),
 765                         fgcolor(info.st_mode));
 766         }
 767 #endif
 768         column += print_name(dn->name);
 769         if (show_color) {
 770                 printf("\033[0m");
 771         }
 772
 773         if (all_fmt & LIST_SYMLINK) {
 774                 if (S_ISLNK(dn->dstat.st_mode) && lpath) {
 775                         printf(" -> ");
 776 #if ENABLE_FEATURE_LS_FILETYPES || ENABLE_FEATURE_LS_COLOR
 777 #if ENABLE_FEATURE_LS_COLOR
 778                         info.st_mode = 0; /* for fgcolor() */
 779 #endif
 780                         if (stat(dn->fullname, &info) == 0) {
 781                                 append = append_char(info.st_mode);
 782                         }
 783 #endif
 784 #if ENABLE_FEATURE_LS_COLOR
 785                         if (show_color) {
 786                                 printf("\033[%u;%um", bold(info.st_mode),
 787                                            fgcolor(info.st_mode));
 788                         }
 789 #endif
 790                         column += print_name(lpath) + 4;
 791                         if (show_color) {
 792                                 printf("\033[0m");
 793                         }
 794                         free(lpath);
 795                 }
 796         }
 797 #if ENABLE_FEATURE_LS_FILETYPES
 798         if (all_fmt & LIST_FILETYPE) {
 799                 if (append) {
 800                         putchar(append);
 801                         column++;
 802                 }
 803         }
 804 #endif
 805
 806         return column;
 807 }
 808
 809 static void showfiles(struct dnode **dn, unsigned nfiles)
 810 {
 811         unsigned i, ncols, nrows, row, nc;
 812         unsigned column;
 813         unsigned nexttab;
 814         unsigned column_width = 0; /* used only by STYLE_COLUMNAR */
 815
 816         if (all_fmt & STYLE_LONG) { /* STYLE_LONG or STYLE_SINGLE */
 817                 ncols = 1;
 818         } else {
 819                 /* find the longest file name, use that as the column width */
 820                 for (i = 0; dn[i]; i++) {
 821                         int len = calc_name_len(dn[i]->name);
 822                         if (column_width < len)
 823                                 column_width = len;
 824                 }
 825                 column_width += 1 +
 826                         IF_SELINUX( ((all_fmt & LIST_CONTEXT) ? 33 : 0) + )
 827                                 ((all_fmt & LIST_INO) ? 8 : 0) +
 828                                 ((all_fmt & LIST_BLOCKS) ? 5 : 0);
 829                 ncols = (int) (terminal_width / column_width);
 830         }
 831
 832         if (ncols > 1) {
 833                 nrows = nfiles / ncols;
 834                 if (nrows * ncols < nfiles)
 835                         nrows++;                /* round up fractionals */
 836         } else {
 837                 nrows = nfiles;
 838                 ncols = 1;
 839         }
 840
 841         column = 0;
 842         nexttab = 0;
 843         for (row = 0; row < nrows; row++) {
 844                 for (nc = 0; nc < ncols; nc++) {
 845                         /* reach into the array based on the column and row */
 846                         if (all_fmt & DISP_ROWS)
 847                                 i = (row * ncols) + nc; /* display across row */
 848                         else
 849                                 i = (nc * nrows) + row; /* display by column */
 850                         if (i < nfiles) {
 851                                 if (column > 0) {
 852                                         nexttab -= column;
 853                                         printf("%*s ", nexttab, "");
 854                                         column += nexttab + 1;
 855                                 }
 856                                 nexttab = column + column_width;
 857                                 column += list_single(dn[i]);
 858                         }
 859                 }
 860                 putchar('\n');
 861                 column = 0;
 862         }
 863 }
 864
 865
 866 #if ENABLE_DESKTOP
 867 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/ls.html
 868  * If any of the -l, -n, -s options is specified, each list
 869  * of files within the directory shall be preceded by a
 870  * status line indicating the number of file system blocks
 871  * occupied by files in the directory in 512-byte units if
 872  * the -k option is not specified, or 1024-byte units if the
 873  * -k option is specified, rounded up to the next integral
 874  * number of units.
 875  */
 876 /* by Jorgen Overgaard (jorgen AT antistaten.se) */
 877 static off_t calculate_blocks(struct dnode **dn)
 878 {
 879         uoff_t blocks = 1;
 880         if (dn) {
 881                 while (*dn) {
 882                         /* st_blocks is in 512 byte blocks */
 883                         blocks += (*dn)->dstat.st_blocks;
 884                         dn++;
 885                 }
 886         }
 887
 888         /* Even though standard says use 512 byte blocks, coreutils use 1k */
 889         /* Actually, we round up by calculating (blocks + 1) / 2,
 890          * "+ 1" was done when we initialized blocks to 1 */
 891         return blocks >> 1;
 892 }
 893 #endif
 894
 895
 896 static struct dnode **list_dir(const char *, unsigned *);
 897
 898 static void showdirs(struct dnode **dn, int first)
 899 {
 900         unsigned nfiles;
 901         unsigned dndirs;
 902         struct dnode **subdnp;
 903         struct dnode **dnd;
 904
 905         for (; *dn; dn++) {
 906                 if (all_fmt & (DISP_DIRNAME | DISP_RECURSIVE)) {
 907                         if (!first)
 908                                 bb_putchar('\n');
 909                         first = 0;
 910                         printf("%s:\n", (*dn)->fullname);
 911                 }
 912                 subdnp = list_dir((*dn)->fullname, &nfiles);
 913 #if ENABLE_DESKTOP
 914                 if ((all_fmt & STYLE_MASK) == STYLE_LONG)
 915                         printf("total %"OFF_FMT"u\n", calculate_blocks(subdnp));
 916 #endif
 917                 if (nfiles > 0) {
 918                         /* list all files at this level */
 919                         dnsort(subdnp, nfiles);
 920                         showfiles(subdnp, nfiles);
 921                         if (ENABLE_FEATURE_LS_RECURSIVE
 922                          && (all_fmt & DISP_RECURSIVE)
 923                         ) {
 924                                 /* recursive - list the sub-dirs */
 925                                 dnd = splitdnarray(subdnp, SPLIT_SUBDIR);
 926                                 dndirs = count_dirs(subdnp, SPLIT_SUBDIR);
 927                                 if (dndirs > 0) {
 928                                         dnsort(dnd, dndirs);
 929                                         showdirs(dnd, 0);
 930                                         /* free the array of dnode pointers to the dirs */
 931                                         free(dnd);
 932                                 }
 933                         }
 934                         /* free the dnodes and the fullname mem */
 935                         dfree(subdnp);
 936                 }
 937         }
 938 }
 939
 940
 941 /* Returns NULL-terminated malloced vector of pointers (or NULL) */
 942 static struct dnode **list_dir(const char *path, unsigned *nfiles_p)
 943 {
 944         struct dnode *dn, *cur, **dnp;
 945         struct dirent *entry;
 946         DIR *dir;
 947         unsigned i, nfiles;
 948
 949         /* Never happens:
 950         if (path == NULL)
 951                 return NULL;
 952         */
 953
 954         *nfiles_p = 0;
 955         dir = warn_opendir(path);
 956         if (dir == NULL) {
 957                 exit_code = EXIT_FAILURE;
 958                 return NULL;    /* could not open the dir */
 959         }
 960         dn = NULL;
 961         nfiles = 0;
 962         while ((entry = readdir(dir)) != NULL) {
 963                 char *fullname;
 964
 965                 /* are we going to list the file- it may be . or .. or a hidden file */
 966                 if (entry->d_name[0] == '.') {
 967                         if ((!entry->d_name[1] || (entry->d_name[1] == '.' && !entry->d_name[2]))
 968                          && !(all_fmt & DISP_DOT)
 969                         ) {
 970                                 continue;
 971                         }
 972                         if (!(all_fmt & DISP_HIDDEN))
 973                                 continue;
 974                 }
 975                 fullname = concat_path_file(path, entry->d_name);
 976                 cur = my_stat(fullname, bb_basename(fullname), 0);
 977                 if (!cur) {
 978                         free(fullname);
 979                         continue;
 980                 }
 981                 cur->fname_allocated = 1;
 982                 cur->next = dn;
 983                 dn = cur;
 984                 nfiles++;
 985         }
 986         closedir(dir);
 987
 988         if (dn == NULL)
 989                 return NULL;
 990
 991         /* now that we know how many files there are
 992          * allocate memory for an array to hold dnode pointers
 993          */
 994         *nfiles_p = nfiles;
 995         dnp = dnalloc(nfiles);
 996         for (i = 0; /* i < nfiles - detected via !dn below */; i++) {
 997                 dnp[i] = dn;    /* save pointer to node in array */
 998                 dn = dn->next;
 999                 if (!dn)
1000                         break;
1001         }
1002
1003         return dnp;
1004 }
1005
1006
1007 int ls_main(int argc UNUSED_PARAM, char **argv)
1008 {
1009         struct dnode **dnd;
1010         struct dnode **dnf;
1011         struct dnode **dnp;
1012         struct dnode *dn;
1013         struct dnode *cur;
1014         unsigned opt;
1015         unsigned nfiles;
1016         unsigned dnfiles;
1017         unsigned dndirs;
1018         unsigned i;
1019 #if ENABLE_FEATURE_LS_COLOR
1020         /* colored LS support by JaWi, janwillem.janssen@lxtreme.nl */
1021         /* coreutils 6.10:
1022          * # ls --color=BOGUS
1023          * ls: invalid argument 'BOGUS' for '--color'
1024          * Valid arguments are:
1025          * 'always', 'yes', 'force'
1026          * 'never', 'no', 'none'
1027          * 'auto', 'tty', 'if-tty'
1028          * (and substrings: "--color=alwa" work too)
1029          */
1030         static const char ls_longopts[] ALIGN1 =
1031                 "color\0" Optional_argument "\xff"; /* no short equivalent */
1032         static const char color_str[] ALIGN1 =
1033                 "always\0""yes\0""force\0"
1034                 "auto\0""tty\0""if-tty\0";
1035         /* need to initialize since --color has _an optional_ argument */
1036         const char *color_opt = color_str; /* "always" */
1037 #endif
1038
1039         INIT_G();
1040
1041         init_unicode();
1042
1043         all_fmt = ENABLE_FEATURE_LS_SORTFILES * SORT_NAME;
1044
1045 #if ENABLE_FEATURE_AUTOWIDTH
1046         /* obtain the terminal width */
1047         get_terminal_width_height(STDIN_FILENO, &terminal_width, NULL);
1048         /* go one less... */
1049         terminal_width--;
1050 #endif
1051
1052         /* process options */
1053         IF_FEATURE_LS_COLOR(applet_long_options = ls_longopts;)
1054         opt_complementary =
1055                 /* -e implies -l */
1056                 "el"
1057                 /* http://pubs.opengroup.org/onlinepubs/9699919799/utilities/ls.html:
1058                  * in some pairs of opts, only last one takes effect:
1059                  */
1060                 IF_FEATURE_LS_TIMESTAMPS(IF_FEATURE_LS_SORTFILES(":t-S:S-t")) /* time/size */
1061                 // ":m-l:l-m" - we don't have -m
1062                 IF_FEATURE_LS_FOLLOWLINKS(":H-L:L-H")
1063                 ":C-xl:x-Cl:l-xC" /* bycols/bylines/long */
1064                 ":C-1:1-C" /* bycols/oneline */
1065                 ":x-1:1-x" /* bylines/oneline (not in SuS, but in GNU coreutils 8.4) */
1066                 ":c-u:u-c" /* mtime/atime */
1067                 /* -w NUM: */
1068                 IF_FEATURE_AUTOWIDTH(":w+");
1069         opt = getopt32(argv, ls_options
1070                 IF_FEATURE_AUTOWIDTH(, NULL, &terminal_width)
1071                 IF_FEATURE_LS_COLOR(, &color_opt)
1072         );
1073         for (i = 0; opt_flags[i] != (1U << 31); i++) {
1074                 if (opt & (1 << i)) {
1075                         uint32_t flags = opt_flags[i];
1076
1077                         if (flags & STYLE_MASK)
1078                                 all_fmt &= ~STYLE_MASK;
1079                         if (flags & SORT_MASK)
1080                                 all_fmt &= ~SORT_MASK;
1081                         if (flags & TIME_MASK)
1082                                 all_fmt &= ~TIME_MASK;
1083
1084                         if (flags & LIST_CONTEXT)
1085                                 all_fmt |= STYLE_SINGLE;
1086                         all_fmt |= flags;
1087                 }
1088         }
1089
1090 #if ENABLE_FEATURE_LS_COLOR
1091         /* find color bit value - last position for short getopt */
1092         if (ENABLE_FEATURE_LS_COLOR_IS_DEFAULT && isatty(STDOUT_FILENO)) {
1093                 char *p = getenv("LS_COLORS");
1094                 /* LS_COLORS is unset, or (not empty && not "none") ? */
1095                 if (!p || (p[0] && strcmp(p, "none") != 0))
1096                         show_color = 1;
1097         }
1098         if (opt & OPT_color) {
1099                 if (color_opt[0] == 'n')
1100                         show_color = 0;
1101                 else switch (index_in_substrings(color_str, color_opt)) {
1102                 case 3:
1103                 case 4:
1104                 case 5:
1105                         if (isatty(STDOUT_FILENO)) {
1106                 case 0:
1107                 case 1:
1108                 case 2:
1109                                 show_color = 1;
1110                         }
1111                 }
1112         }
1113 #endif
1114
1115         /* sort out which command line options take precedence */
1116         if (ENABLE_FEATURE_LS_RECURSIVE && (all_fmt & DISP_NOLIST))
1117                 all_fmt &= ~DISP_RECURSIVE;     /* no recurse if listing only dir */
1118         if (ENABLE_FEATURE_LS_TIMESTAMPS && ENABLE_FEATURE_LS_SORTFILES) {
1119                 if (all_fmt & TIME_CHANGE)
1120                         all_fmt = (all_fmt & ~SORT_MASK) | SORT_CTIME;
1121                 if (all_fmt & TIME_ACCESS)
1122                         all_fmt = (all_fmt & ~SORT_MASK) | SORT_ATIME;
1123         }
1124         if ((all_fmt & STYLE_MASK) != STYLE_LONG) /* only for long list */
1125                 all_fmt &= ~(LIST_ID_NUMERIC|LIST_ID_NAME|LIST_FULLTIME);
1126         if (ENABLE_FEATURE_LS_USERNAME)
1127                 if ((all_fmt & STYLE_MASK) == STYLE_LONG && (all_fmt & LIST_ID_NUMERIC))
1128                         all_fmt &= ~LIST_ID_NAME; /* don't list names if numeric uid */
1129
1130         /* choose a display format if one was not already specified by an option */
1131         if (!(all_fmt & STYLE_MASK))
1132                 all_fmt |= (isatty(STDOUT_FILENO) ? STYLE_COLUMNAR : STYLE_SINGLE);
1133
1134         argv += optind;
1135         if (!argv[0])
1136                 *--argv = (char*)".";
1137
1138         if (argv[1])
1139                 all_fmt |= DISP_DIRNAME; /* 2 or more items? label directories */
1140
1141         /* stuff the command line file names into a dnode array */
1142         dn = NULL;
1143         nfiles = 0;
1144         do {
1145                 cur = my_stat(*argv, *argv,
1146                         /* follow links on command line unless -l, -s or -F: */
1147                         !((all_fmt & (STYLE_LONG|LIST_BLOCKS)) || (option_mask32 & OPT_F))
1148                         /* ... or if -H: */
1149                         || (option_mask32 & OPT_H)
1150                 );
1151                 argv++;
1152                 if (!cur)
1153                         continue;
1154                 cur->fname_allocated = 0;
1155                 cur->next = dn;
1156                 dn = cur;
1157                 nfiles++;
1158         } while (*argv);
1159
1160         /* nfiles _may_ be 0 here - try "ls doesnt_exist" */
1161         if (nfiles == 0)
1162                 return exit_code;
1163
1164         /* now that we know how many files there are
1165          * allocate memory for an array to hold dnode pointers
1166          */
1167         dnp = dnalloc(nfiles);
1168         for (i = 0; /* i < nfiles - detected via !dn below */; i++) {
1169                 dnp[i] = dn;    /* save pointer to node in array */
1170                 dn = dn->next;
1171                 if (!dn)
1172                         break;
1173         }
1174
1175         if (all_fmt & DISP_NOLIST) {
1176                 dnsort(dnp, nfiles);
1177                 showfiles(dnp, nfiles);
1178         } else {
1179                 dnd = splitdnarray(dnp, SPLIT_DIR);
1180                 dnf = splitdnarray(dnp, SPLIT_FILE);
1181                 dndirs = count_dirs(dnp, SPLIT_DIR);
1182                 dnfiles = nfiles - dndirs;
1183                 if (dnfiles > 0) {
1184                         dnsort(dnf, dnfiles);
1185                         showfiles(dnf, dnfiles);
1186                         if (ENABLE_FEATURE_CLEAN_UP)
1187                                 free(dnf);
1188                 }
1189                 if (dndirs > 0) {
1190                         dnsort(dnd, dndirs);
1191                         showdirs(dnd, dnfiles == 0);
1192                         if (ENABLE_FEATURE_CLEAN_UP)
1193                                 free(dnd);
1194                 }
1195         }
1196         if (ENABLE_FEATURE_CLEAN_UP)
1197                 dfree(dnp);
1198         return exit_code;
1199 }