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  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 /*
  22  * To achieve a small memory footprint, this version of 'ls' doesn't do any
  23  * file sorting, and only has the most essential command line switches
  24  * (i.e., the ones I couldn't live without :-) All features which involve
  25  * linking in substantial chunks of libc can be disabled.
  26  *
  27  * Although I don't really want to add new features to this program to
  28  * keep it small, I *am* interested to receive bug fixes and ways to make
  29  * it more portable.
  30  *
  31  * KNOWN BUGS:
  32  * 1. ls -l of a directory doesn't give "total <blocks>" header
  33  * 2. ls of a symlink to a directory doesn't list directory contents
  34  * 3. hidden files can make column width too large
  35  *
  36  * NON-OPTIMAL BEHAVIOUR:
  37  * 1. autowidth reads directories twice
  38  * 2. if you do a short directory listing without filetype characters
  39  *    appended, there's no need to stat each one
  40  * PORTABILITY:
  41  * 1. requires lstat (BSD) - how do you do it without?
  42  */
  43
  44 enum {
  45         TERMINAL_WIDTH = 80,    /* use 79 if terminal has linefold bug */
  46         COLUMN_GAP = 2,         /* includes the file type char */
  47 };
  48
  49 /************************************************************************/
  50
  51 #include <sys/types.h>
  52 #include <sys/stat.h>
  53 #include <stdio.h>
  54 #include <unistd.h>
  55 #include <dirent.h>
  56 #include <errno.h>
  57 #include <stdio.h>
  58 #include <string.h>
  59 #include <stdlib.h>
  60 #include <fcntl.h>
  61 #include <signal.h>
  62 #include <termios.h>
  63 #include <sys/ioctl.h>
  64 #include "busybox.h"
  65
  66 #ifdef CONFIG_FEATURE_LS_TIMESTAMPS
  67 #include <time.h>
  68 #endif
  69
  70 #ifndef MAJOR
  71 #define MAJOR(dev) (((dev)>>8)&0xff)
  72 #define MINOR(dev) ((dev)&0xff)
  73 #endif
  74
  75 /* what is the overall style of the listing */
  76 enum {
  77         STYLE_AUTO = 0,
  78         STYLE_LONG = 1,         /* one record per line, extended info */
  79         STYLE_SINGLE = 2,       /* one record per line */
  80         STYLE_COLUMNS = 3       /* fill columns */
  81 };
  82
  83 /* 51306 lrwxrwxrwx  1 root     root         2 May 11 01:43 /bin/view -> vi* */
  84 /* what file information will be listed */
  85 #define LIST_INO                (1<<0)
  86 #define LIST_BLOCKS             (1<<1)
  87 #define LIST_MODEBITS   (1<<2)
  88 #define LIST_NLINKS             (1<<3)
  89 #define LIST_ID_NAME    (1<<4)
  90 #define LIST_ID_NUMERIC (1<<5)
  91 #define LIST_SIZE               (1<<6)
  92 #define LIST_DEV                (1<<7)
  93 #define LIST_DATE_TIME  (1<<8)
  94 #define LIST_FULLTIME   (1<<9)
  95 #define LIST_FILENAME   (1<<10)
  96 #define LIST_SYMLINK    (1<<11)
  97 #define LIST_FILETYPE   (1<<12)
  98 #define LIST_EXEC               (1<<13)
  99
 100 /* what files will be displayed */
 101 #define DISP_NORMAL             (0)     /* show normal filenames */
 102 #define DISP_DIRNAME    (1<<0)  /* 2 or more items? label directories */
 103 #define DISP_HIDDEN             (1<<1)  /* show filenames starting with .  */
 104 #define DISP_DOT                (1<<2)  /* show . and .. */
 105 #define DISP_NOLIST             (1<<3)  /* show directory as itself, not contents */
 106 #define DISP_RECURSIVE  (1<<4)  /* show directory and everything below it */
 107 #define DISP_ROWS               (1<<5)  /* print across rows */
 108
 109 #ifdef CONFIG_FEATURE_LS_SORTFILES
 110 /* how will the files be sorted */
 111 static const int SORT_FORWARD = 0;      /* sort in reverse order */
 112 static const int SORT_REVERSE = 1;      /* sort in reverse order */
 113 static const int SORT_NAME = 2; /* sort by file name */
 114 static const int SORT_SIZE = 3; /* sort by file size */
 115 static const int SORT_ATIME = 4;        /* sort by last access time */
 116 static const int SORT_CTIME = 5;        /* sort by last change time */
 117 static const int SORT_MTIME = 6;        /* sort by last modification time */
 118 static const int SORT_VERSION = 7;      /* sort by version */
 119 static const int SORT_EXT = 8;  /* sort by file name extension */
 120 static const int SORT_DIR = 9;  /* sort by file or directory */
 121 #endif
 122
 123 #ifdef CONFIG_FEATURE_LS_TIMESTAMPS
 124 /* which of the three times will be used */
 125 static const int TIME_MOD = 0;
 126 static const int TIME_CHANGE = 1;
 127 static const int TIME_ACCESS = 2;
 128 #endif
 129
 130 #define LIST_SHORT      (LIST_FILENAME)
 131 #define LIST_ISHORT     (LIST_INO | LIST_FILENAME)
 132 #define LIST_LONG       (LIST_MODEBITS | LIST_NLINKS | LIST_ID_NAME | LIST_SIZE | \
 133                                                 LIST_DATE_TIME | LIST_FILENAME | LIST_SYMLINK)
 134 #define LIST_ILONG      (LIST_INO | LIST_LONG)
 135
 136 static const int SPLIT_DIR = 0;
 137 static const int SPLIT_FILE = 1;
 138 static const int SPLIT_SUBDIR = 2;
 139
 140 #define TYPEINDEX(mode) (((mode) >> 12) & 0x0f)
 141 #define TYPECHAR(mode)  ("0pcCd?bB-?l?s???" [TYPEINDEX(mode)])
 142
 143 #if defined(CONFIG_FEATURE_LS_FILETYPES) || defined(CONFIG_FEATURE_LS_COLOR)
 144 # define APPCHAR(mode)   ("\0|\0\0/\0\0\0\0\0@\0=\0\0\0" [TYPEINDEX(mode)])
 145 #endif
 146
 147 /* colored LS support by JaWi, janwillem.janssen@lxtreme.nl */
 148 #ifdef CONFIG_FEATURE_LS_COLOR
 149 static int show_color = 0;
 150
 151 #define COLOR(mode)     ("\000\043\043\043\042\000\043\043"\
 152                                         "\000\000\044\000\043\000\000\040" [TYPEINDEX(mode)])
 153 #define ATTR(mode)      ("\00\00\01\00\01\00\01\00"\
 154                                         "\00\00\01\00\01\00\00\01" [TYPEINDEX(mode)])
 155 #endif
 156
 157 /*
 158  * a directory entry and its stat info are stored here
 159  */
 160 struct dnode {                  /* the basic node */
 161         char *name;                     /* the dir entry name */
 162         char *fullname;         /* the dir entry name */
 163         struct stat dstat;      /* the file stat info */
 164         struct dnode *next;     /* point at the next node */
 165 };
 166 typedef struct dnode dnode_t;
 167
 168 static struct dnode **list_dir(const char *);
 169 static struct dnode **dnalloc(int);
 170 static int list_single(struct dnode *);
 171
 172 static unsigned int disp_opts;
 173 static unsigned int style_fmt;
 174 static unsigned int list_fmt;
 175
 176 #ifdef CONFIG_FEATURE_LS_SORTFILES
 177 static unsigned int sort_opts;
 178 static unsigned int sort_order;
 179 #endif
 180 #ifdef CONFIG_FEATURE_LS_TIMESTAMPS
 181 static unsigned int time_fmt;
 182 #endif
 183 #ifdef CONFIG_FEATURE_LS_FOLLOWLINKS
 184 static unsigned int follow_links = FALSE;
 185 #endif
 186
 187 #ifdef CONFIG_FEATURE_AUTOWIDTH
 188 static unsigned short terminal_width = TERMINAL_WIDTH;
 189 static unsigned short tabstops = COLUMN_GAP;
 190 #else
 191 #define tabstops COLUMN_GAP
 192 #define terminal_width TERMINAL_WIDTH
 193 #endif
 194
 195 static int status = EXIT_SUCCESS;
 196
 197 #ifdef CONFIG_FEATURE_HUMAN_READABLE
 198 static unsigned long ls_disp_hr = 0;
 199 #endif
 200
 201 static struct dnode *my_stat(char *fullname, char *name)
 202 {
 203         struct stat dstat;
 204         struct dnode *cur;
 205
 206 #ifdef CONFIG_FEATURE_LS_FOLLOWLINKS
 207         if (follow_links) {
 208                 if (stat(fullname, &dstat)) {
 209                         perror_msg("%s", fullname);
 210                         status = EXIT_FAILURE;
 211                         return 0;
 212                 }
 213         } else
 214 #endif
 215         if (lstat(fullname, &dstat)) {
 216                 perror_msg("%s", fullname);
 217                 status = EXIT_FAILURE;
 218         return 0;
 219         }
 220
 221         cur = (struct dnode *) xmalloc(sizeof(struct dnode));
 222         cur->fullname = fullname;
 223         cur->name = name;
 224         cur->dstat = dstat;
 225         return cur;
 226 }
 227
 228 /*----------------------------------------------------------------------*/
 229 #ifdef CONFIG_FEATURE_LS_COLOR
 230 static char fgcolor(mode_t mode)
 231 {
 232         /* Check wheter the file is existing (if so, color it red!) */
 233         if (errno == ENOENT) {
 234                 return '\037';
 235         }
 236         if (LIST_EXEC && S_ISREG(mode)
 237                 && (mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
 238                 return COLOR(0xF000);   /* File is executable ... */
 239         return COLOR(mode);
 240 }
 241
 242 /*----------------------------------------------------------------------*/
 243 static char bgcolor(mode_t mode)
 244 {
 245         if (LIST_EXEC && S_ISREG(mode)
 246                 && (mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
 247                 return ATTR(0xF000);    /* File is executable ... */
 248         return ATTR(mode);
 249 }
 250 #endif
 251
 252 /*----------------------------------------------------------------------*/
 253 #if defined(CONFIG_FEATURE_LS_FILETYPES) || defined(CONFIG_FEATURE_LS_COLOR)
 254 static char append_char(mode_t mode)
 255 {
 256         if (!(list_fmt & LIST_FILETYPE))
 257                 return '\0';
 258         if ((list_fmt & LIST_EXEC) && S_ISREG(mode)
 259                 && (mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
 260                 return '*';
 261         return APPCHAR(mode);
 262 }
 263 #endif
 264
 265 /*----------------------------------------------------------------------*/
 266 static int is_subdir(struct dnode *dn)
 267 {
 268         return (S_ISDIR(dn->dstat.st_mode) && strcmp(dn->name, ".") != 0 &&
 269                         strcmp(dn->name, "..") != 0);
 270 }
 271
 272 static int countdirs(struct dnode **dn, int nfiles)
 273 {
 274         int i, dirs;
 275
 276         if (dn == NULL || nfiles < 1)
 277                 return (0);
 278         dirs = 0;
 279         for (i = 0; i < nfiles; i++) {
 280                 if (S_ISDIR(dn[i]->dstat.st_mode))
 281                         dirs++;
 282         }
 283         return (dirs);
 284 }
 285
 286 static int countsubdirs(struct dnode **dn, int nfiles)
 287 {
 288         int i, subdirs;
 289
 290         if (dn == NULL || nfiles < 1)
 291                 return 0;
 292         subdirs = 0;
 293         for (i = 0; i < nfiles; i++)
 294                 if (is_subdir(dn[i]))
 295                         subdirs++;
 296         return subdirs;
 297 }
 298
 299 static int countfiles(struct dnode **dnp)
 300 {
 301         int nfiles;
 302         struct dnode *cur;
 303
 304         if (dnp == NULL)
 305                 return (0);
 306         nfiles = 0;
 307         for (cur = dnp[0]; cur->next != NULL; cur = cur->next)
 308                 nfiles++;
 309         nfiles++;
 310         return (nfiles);
 311 }
 312
 313 /* get memory to hold an array of pointers */
 314 static struct dnode **dnalloc(int num)
 315 {
 316         struct dnode **p;
 317
 318         if (num < 1)
 319                 return (NULL);
 320
 321         p = (struct dnode **) xcalloc((size_t) num,
 322                                                                   (size_t) (sizeof(struct dnode *)));
 323         return (p);
 324 }
 325
 326 #ifdef CONFIG_FEATURE_LS_RECURSIVE
 327 static void dfree(struct dnode **dnp)
 328 {
 329         struct dnode *cur, *next;
 330
 331         if (dnp == NULL)
 332                 return;
 333
 334         cur = dnp[0];
 335         while (cur != NULL) {
 336                 free(cur->fullname);    /* free the filename */
 337                 next = cur->next;
 338                 free(cur);              /* free the dnode */
 339                 cur = next;
 340         }
 341         free(dnp);                      /* free the array holding the dnode pointers */
 342 }
 343 #endif
 344
 345 static struct dnode **splitdnarray(struct dnode **dn, int nfiles, int which)
 346 {
 347         int dncnt, i, d;
 348         struct dnode **dnp;
 349
 350         if (dn == NULL || nfiles < 1)
 351                 return (NULL);
 352
 353         /* count how many dirs and regular files there are */
 354         if (which == SPLIT_SUBDIR)
 355                 dncnt = countsubdirs(dn, nfiles);
 356         else {
 357                 dncnt = countdirs(dn, nfiles);  /* assume we are looking for dirs */
 358                 if (which == SPLIT_FILE)
 359                         dncnt = nfiles - dncnt; /* looking for files */
 360         }
 361
 362         /* allocate a file array and a dir array */
 363         dnp = dnalloc(dncnt);
 364
 365         /* copy the entrys into the file or dir array */
 366         for (d = i = 0; i < nfiles; i++) {
 367                 if (which == SPLIT_DIR) {
 368                         if (S_ISDIR(dn[i]->dstat.st_mode)) {
 369                                 dnp[d++] = dn[i];
 370                         }                       /* else skip the file */
 371                 } else if (which == SPLIT_SUBDIR) {
 372                         if (is_subdir(dn[i])) {
 373                                 dnp[d++] = dn[i];
 374                         }                       /* else skip the file or dir */
 375                 } else {
 376                         if (!(S_ISDIR(dn[i]->dstat.st_mode))) {
 377                                 dnp[d++] = dn[i];
 378                         }                       /* else skip the dir */
 379                 }
 380         }
 381         return (dnp);
 382 }
 383
 384 /*----------------------------------------------------------------------*/
 385 #ifdef CONFIG_FEATURE_LS_SORTFILES
 386 static int sortcmp(struct dnode *d1, struct dnode *d2)
 387 {
 388         int cmp, dif;
 389
 390         cmp = 0;
 391         if (sort_opts == SORT_SIZE) {
 392                 dif = (int) (d1->dstat.st_size - d2->dstat.st_size);
 393         } else if (sort_opts == SORT_ATIME) {
 394                 dif = (int) (d1->dstat.st_atime - d2->dstat.st_atime);
 395         } else if (sort_opts == SORT_CTIME) {
 396                 dif = (int) (d1->dstat.st_ctime - d2->dstat.st_ctime);
 397         } else if (sort_opts == SORT_MTIME) {
 398                 dif = (int) (d1->dstat.st_mtime - d2->dstat.st_mtime);
 399         } else if (sort_opts == SORT_DIR) {
 400                 dif = S_ISDIR(d1->dstat.st_mode) - S_ISDIR(d2->dstat.st_mode);
 401                 /* } else if (sort_opts == SORT_VERSION) { */
 402                 /* } else if (sort_opts == SORT_EXT) { */
 403         } else {                        /* assume SORT_NAME */
 404                 dif = 0;
 405         }
 406
 407         if (dif > 0)
 408                 cmp = -1;
 409         if (dif < 0)
 410                 cmp = 1;
 411         if (dif == 0) {
 412                 /* sort by name- may be a tie_breaker for time or size cmp */
 413 #ifdef CONFIG_LOCALE_SUPPORT
 414                 dif = strcoll(d1->name, d2->name);
 415 #else
 416                 dif = strcmp(d1->name, d2->name);
 417 #endif
 418                 if (dif > 0)
 419                         cmp = 1;
 420                 if (dif < 0)
 421                         cmp = -1;
 422         }
 423
 424         if (sort_order == SORT_REVERSE) {
 425                 cmp = -1 * cmp;
 426         }
 427         return (cmp);
 428 }
 429
 430 /*----------------------------------------------------------------------*/
 431 static void shellsort(struct dnode **dn, int size)
 432 {
 433         struct dnode *temp;
 434         int gap, i, j;
 435
 436         /* shell short the array */
 437         if (dn == NULL || size < 2)
 438                 return;
 439
 440         for (gap = size / 2; gap > 0; gap /= 2) {
 441                 for (i = gap; i < size; i++) {
 442                         for (j = i - gap; j >= 0; j -= gap) {
 443                                 if (sortcmp(dn[j], dn[j + gap]) <= 0)
 444                                         break;
 445                                 /* they are out of order, swap them */
 446                                 temp = dn[j];
 447                                 dn[j] = dn[j + gap];
 448                                 dn[j + gap] = temp;
 449                         }
 450                 }
 451         }
 452 }
 453 #endif
 454
 455 /*----------------------------------------------------------------------*/
 456 static void showfiles(struct dnode **dn, int nfiles)
 457 {
 458         int i, ncols, nrows, row, nc;
 459         int column = 0;
 460         int nexttab = 0;
 461         int column_width = 0; /* for STYLE_LONG and STYLE_SINGLE not used */
 462
 463         if (dn == NULL || nfiles < 1)
 464                 return;
 465
 466         switch (style_fmt) {
 467         case STYLE_LONG:        /* one record per line, extended info */
 468         case STYLE_SINGLE:      /* one record per line */
 469                 ncols = 1;
 470                 break;
 471         default:
 472         /* find the longest file name-  use that as the column width */
 473         for (i = 0; i < nfiles; i++) {
 474                         int len = strlen(dn[i]->name) +
 475                         ((list_fmt & LIST_INO) ? 8 : 0) +
 476                         ((list_fmt & LIST_BLOCKS) ? 5 : 0);
 477                 if (column_width < len)
 478                         column_width = len;
 479         }
 480                 column_width += tabstops;
 481                 ncols = (int) (terminal_width / column_width);
 482         }
 483
 484         if (ncols > 1) {
 485                 nrows = nfiles / ncols;
 486                 if ((nrows * ncols) < nfiles)
 487                         nrows++;                /* round up fractionals */
 488         } else {
 489                 nrows = nfiles;
 490                 ncols = 1;
 491         }
 492
 493         for (row = 0; row < nrows; row++) {
 494                 for (nc = 0; nc < ncols; nc++) {
 495                         /* reach into the array based on the column and row */
 496                         i = (nc * nrows) + row; /* assume display by column */
 497                         if (disp_opts & DISP_ROWS)
 498                                 i = (row * ncols) + nc; /* display across row */
 499                         if (i < nfiles) {
 500                                 if (column > 0) {
 501                                         nexttab -= column;
 502                                         while (nexttab--) {
 503                                                 putchar(' ');
 504                                                 column++;
 505                                         }
 506                         }
 507                                 nexttab = column + column_width;
 508                                 column += list_single(dn[i]);
 509                 }
 510                 }
 511                 putchar('\n');
 512                 column = 0;
 513         }
 514 }
 515
 516 /*----------------------------------------------------------------------*/
 517 static void showdirs(struct dnode **dn, int ndirs)
 518 {
 519         int i, nfiles;
 520         struct dnode **subdnp;
 521
 522 #ifdef CONFIG_FEATURE_LS_RECURSIVE
 523         int dndirs;
 524         struct dnode **dnd;
 525 #endif
 526
 527         if (dn == NULL || ndirs < 1)
 528                 return;
 529
 530         for (i = 0; i < ndirs; i++) {
 531                 if (disp_opts & (DISP_DIRNAME | DISP_RECURSIVE)) {
 532                         printf("\n%s:\n", dn[i]->fullname);
 533                 }
 534                 subdnp = list_dir(dn[i]->fullname);
 535                 nfiles = countfiles(subdnp);
 536                 if (nfiles > 0) {
 537                         /* list all files at this level */
 538 #ifdef CONFIG_FEATURE_LS_SORTFILES
 539                         shellsort(subdnp, nfiles);
 540 #endif
 541                         showfiles(subdnp, nfiles);
 542 #ifdef CONFIG_FEATURE_LS_RECURSIVE
 543                         if (disp_opts & DISP_RECURSIVE) {
 544                                 /* recursive- list the sub-dirs */
 545                                 dnd = splitdnarray(subdnp, nfiles, SPLIT_SUBDIR);
 546                                 dndirs = countsubdirs(subdnp, nfiles);
 547                                 if (dndirs > 0) {
 548 #ifdef CONFIG_FEATURE_LS_SORTFILES
 549                                         shellsort(dnd, dndirs);
 550 #endif
 551                                         showdirs(dnd, dndirs);
 552                                         free(dnd);      /* free the array of dnode pointers to the dirs */
 553                                 }
 554                         }
 555                         dfree(subdnp);  /* free the dnodes and the fullname mem */
 556 #endif
 557                 }
 558         }
 559 }
 560
 561 /*----------------------------------------------------------------------*/
 562 static struct dnode **list_dir(const char *path)
 563 {
 564         struct dnode *dn, *cur, **dnp;
 565         struct dirent *entry;
 566         DIR *dir;
 567         int i, nfiles;
 568
 569         if (path == NULL)
 570                 return (NULL);
 571
 572         dn = NULL;
 573         nfiles = 0;
 574         dir = opendir(path);
 575         if (dir == NULL) {
 576                 perror_msg("%s", path);
 577                 status = EXIT_FAILURE;
 578                 return (NULL);  /* could not open the dir */
 579         }
 580         while ((entry = readdir(dir)) != NULL) {
 581                 char *fullname;
 582
 583                 /* are we going to list the file- it may be . or .. or a hidden file */
 584                 if (entry->d_name[0] == '.') {
 585                         if ((entry->d_name[1] == 0 || (
 586                                 entry->d_name[1] == '.'
 587                                 && entry->d_name[2] == 0))
 588                                         && !(disp_opts & DISP_DOT))
 589                         continue;
 590                         if (!(disp_opts & DISP_HIDDEN))
 591                         continue;
 592                 }
 593                 fullname = concat_path_file(path, entry->d_name);
 594                 cur = my_stat(fullname, strrchr(fullname, '/') + 1);
 595                 if (!cur)
 596                         continue;
 597                 cur->next = dn;
 598                 dn = cur;
 599                 nfiles++;
 600         }
 601         closedir(dir);
 602
 603         /* now that we know how many files there are
 604            ** allocate memory for an array to hold dnode pointers
 605          */
 606         if (dn == NULL)
 607                 return (NULL);
 608         dnp = dnalloc(nfiles);
 609         for (i = 0, cur = dn; i < nfiles; i++) {
 610                 dnp[i] = cur;   /* save pointer to node in array */
 611                 cur = cur->next;
 612         }
 613
 614         return (dnp);
 615 }
 616
 617 /*----------------------------------------------------------------------*/
 618 static int list_single(struct dnode *dn)
 619 {
 620         int i, column = 0;
 621
 622 #ifdef CONFIG_FEATURE_LS_USERNAME
 623         char scratch[16];
 624 #endif
 625 #ifdef CONFIG_FEATURE_LS_TIMESTAMPS
 626         char *filetime;
 627         time_t ttime, age;
 628 #endif
 629 #if defined(CONFIG_FEATURE_LS_FILETYPES) || defined (CONFIG_FEATURE_LS_COLOR)
 630         struct stat info;
 631         char append;
 632 #endif
 633
 634         if (dn->fullname == NULL)
 635                 return (0);
 636
 637 #ifdef CONFIG_FEATURE_LS_TIMESTAMPS
 638         ttime = dn->dstat.st_mtime;     /* the default time */
 639         if (time_fmt & TIME_ACCESS)
 640                 ttime = dn->dstat.st_atime;
 641         if (time_fmt & TIME_CHANGE)
 642                 ttime = dn->dstat.st_ctime;
 643         filetime = ctime(&ttime);
 644 #endif
 645 #ifdef CONFIG_FEATURE_LS_FILETYPES
 646         append = append_char(dn->dstat.st_mode);
 647 #endif
 648
 649         for (i = 0; i <= 31; i++) {
 650                 switch (list_fmt & (1 << i)) {
 651                 case LIST_INO:
 652                         column += printf("%7ld ", (long int) dn->dstat.st_ino);
 653                         break;
 654                 case LIST_BLOCKS:
 655 #if _FILE_OFFSET_BITS == 64
 656                         column += printf("%4lld ", dn->dstat.st_blocks >> 1);
 657 #else
 658                         column += printf("%4ld ", dn->dstat.st_blocks >> 1);
 659 #endif
 660                         break;
 661                 case LIST_MODEBITS:
 662                         column += printf("%-10s ", (char *) mode_string(dn->dstat.st_mode));
 663                         break;
 664                 case LIST_NLINKS:
 665                         column += printf("%4ld ", (long) dn->dstat.st_nlink);
 666                         break;
 667                 case LIST_ID_NAME:
 668 #ifdef CONFIG_FEATURE_LS_USERNAME
 669                         my_getpwuid(scratch, dn->dstat.st_uid);
 670                         printf("%-8.8s ", scratch);
 671                         my_getgrgid(scratch, dn->dstat.st_gid);
 672                         printf("%-8.8s", scratch);
 673                         column += 17;
 674                         break;
 675 #endif
 676                 case LIST_ID_NUMERIC:
 677                         column += printf("%-8d %-8d", dn->dstat.st_uid, dn->dstat.st_gid);
 678                         break;
 679                 case LIST_SIZE:
 680                 case LIST_DEV:
 681                         if (S_ISBLK(dn->dstat.st_mode) || S_ISCHR(dn->dstat.st_mode)) {
 682                                 column += printf("%4d, %3d ", (int) MAJOR(dn->dstat.st_rdev),
 683                                            (int) MINOR(dn->dstat.st_rdev));
 684                         } else {
 685 #ifdef CONFIG_FEATURE_HUMAN_READABLE
 686                                 if (ls_disp_hr == TRUE) {
 687                                         column += printf("%9s ",
 688                                                         make_human_readable_str(dn->dstat.st_size, 1, 0));
 689                                 } else
 690 #endif
 691                                 {
 692 #if _FILE_OFFSET_BITS == 64
 693                                         column += printf("%9lld ", (long long) dn->dstat.st_size);
 694 #else
 695                                         column += printf("%9ld ", dn->dstat.st_size);
 696 #endif
 697                                 }
 698                         }
 699                         break;
 700 #ifdef CONFIG_FEATURE_LS_TIMESTAMPS
 701                 case LIST_FULLTIME:
 702                 case LIST_DATE_TIME:
 703                         if (list_fmt & LIST_FULLTIME) {
 704                                 printf("%24.24s ", filetime);
 705                                 column += 25;
 706                                 break;
 707                         }
 708                         age = time(NULL) - ttime;
 709                         printf("%6.6s ", filetime + 4);
 710                         if (age < 3600L * 24 * 365 / 2 && age > -15 * 60) {
 711                                 /* hh:mm if less than 6 months old */
 712                                 printf("%5.5s ", filetime + 11);
 713                         } else {
 714                                 printf(" %4.4s ", filetime + 20);
 715                         }
 716                         column += 13;
 717                         break;
 718 #endif
 719                 case LIST_FILENAME:
 720 #ifdef CONFIG_FEATURE_LS_COLOR
 721                         errno = 0;
 722                         if (show_color && !lstat(dn->fullname, &info)) {
 723                                 printf("\033[%d;%dm", bgcolor(info.st_mode),
 724                                            fgcolor(info.st_mode));
 725                         }
 726 #endif
 727                         column += printf("%s", dn->name);
 728 #ifdef CONFIG_FEATURE_LS_COLOR
 729                         if (show_color) {
 730                                 printf("\033[0m");
 731                         }
 732 #endif
 733                         break;
 734                 case LIST_SYMLINK:
 735                         if (S_ISLNK(dn->dstat.st_mode)) {
 736                                 char *lpath = xreadlink(dn->fullname);
 737
 738                                 if (lpath) {
 739                                         printf(" -> ");
 740 #if defined(CONFIG_FEATURE_LS_FILETYPES) || defined (CONFIG_FEATURE_LS_COLOR)
 741                                         if (!stat(dn->fullname, &info)) {
 742                                                 append = append_char(info.st_mode);
 743                                         }
 744 #endif
 745 #ifdef CONFIG_FEATURE_LS_COLOR
 746                                         if (show_color) {
 747                                                 errno = 0;
 748                                                 printf("\033[%d;%dm", bgcolor(info.st_mode),
 749                                                            fgcolor(info.st_mode));
 750                                         }
 751 #endif
 752                                         column += printf("%s", lpath) + 4;
 753 #ifdef CONFIG_FEATURE_LS_COLOR
 754                                         if (show_color) {
 755                                                 printf("\033[0m");
 756                                         }
 757 #endif
 758                                         free(lpath);
 759                                 }
 760                         }
 761                         break;
 762 #ifdef CONFIG_FEATURE_LS_FILETYPES
 763                 case LIST_FILETYPE:
 764                         if (append != '\0') {
 765                                 printf("%1c", append);
 766                                 column++;
 767                         }
 768                         break;
 769 #endif
 770                 }
 771         }
 772
 773         return column;
 774 }
 775
 776 /*----------------------------------------------------------------------*/
 777 extern int ls_main(int argc, char **argv)
 778 {
 779         struct dnode **dnf, **dnd;
 780         int dnfiles, dndirs;
 781         struct dnode *dn, *cur, **dnp;
 782         int i, nfiles;
 783         int opt;
 784         int oi, ac;
 785         char **av;
 786
 787 #ifdef CONFIG_FEATURE_AUTOWIDTH
 788         struct winsize win = { 0, 0, 0, 0 };
 789 #endif
 790
 791         disp_opts = DISP_NORMAL;
 792         style_fmt = STYLE_AUTO;
 793         list_fmt = LIST_SHORT;
 794 #ifdef CONFIG_FEATURE_LS_SORTFILES
 795         sort_opts = SORT_NAME;
 796         sort_order = SORT_FORWARD;
 797 #endif
 798 #ifdef CONFIG_FEATURE_LS_TIMESTAMPS
 799         time_fmt = TIME_MOD;
 800 #endif
 801 #ifdef CONFIG_FEATURE_AUTOWIDTH
 802         ioctl(fileno(stdout), TIOCGWINSZ, &win);
 803         if (win.ws_col > 0)
 804                 terminal_width = win.ws_col - 1;
 805 #endif
 806         nfiles = 0;
 807
 808 #ifdef CONFIG_FEATURE_LS_COLOR
 809         if (isatty(fileno(stdout)))
 810                 show_color = 1;
 811 #endif
 812
 813         /* process options */
 814         while ((opt = getopt(argc, argv, "1AaCdgilnsx"
 815 #ifdef CONFIG_FEATURE_AUTOWIDTH
 816                                                  "T:w:"
 817 #endif
 818 #ifdef CONFIG_FEATURE_LS_FILETYPES
 819                                                  "Fp"
 820 #endif
 821 #ifdef CONFIG_FEATURE_LS_RECURSIVE
 822                                                  "R"
 823 #endif
 824 #ifdef CONFIG_FEATURE_LS_SORTFILES
 825                                                  "rSvX"
 826 #endif
 827 #ifdef CONFIG_FEATURE_LS_TIMESTAMPS
 828                                                  "cetu"
 829 #endif
 830 #ifdef CONFIG_FEATURE_LS_FOLLOWLINKS
 831                                                  "L"
 832 #endif
 833 #ifdef CONFIG_FEATURE_HUMAN_READABLE
 834                                                  "h"
 835 #endif
 836                                                  "k")) > 0) {
 837                 switch (opt) {
 838                 case '1':
 839                         style_fmt = STYLE_SINGLE;
 840                         break;
 841                 case 'A':
 842                         disp_opts |= DISP_HIDDEN;
 843                         break;
 844                 case 'a':
 845                         disp_opts |= DISP_HIDDEN | DISP_DOT;
 846                         break;
 847                 case 'C':
 848                         style_fmt = STYLE_COLUMNS;
 849                         break;
 850                 case 'd':
 851                         disp_opts |= DISP_NOLIST;
 852                         break;
 853                 case 'g':               /* ignore -- for ftp servers */
 854                         break;
 855                 case 'i':
 856                         list_fmt |= LIST_INO;
 857                         break;
 858                 case 'l':
 859                         style_fmt = STYLE_LONG;
 860                         list_fmt |= LIST_LONG;
 861 #ifdef CONFIG_FEATURE_HUMAN_READABLE
 862                         ls_disp_hr = FALSE;
 863 #endif
 864                         break;
 865                 case 'n':
 866                         list_fmt |= LIST_ID_NUMERIC;
 867                         break;
 868                 case 's':
 869                         list_fmt |= LIST_BLOCKS;
 870                         break;
 871                 case 'x':
 872                         disp_opts = DISP_ROWS;
 873                         break;
 874 #ifdef CONFIG_FEATURE_LS_FILETYPES
 875                 case 'F':
 876                         list_fmt |= LIST_FILETYPE | LIST_EXEC;
 877                         break;
 878                 case 'p':
 879                         list_fmt |= LIST_FILETYPE;
 880                         break;
 881 #endif
 882 #ifdef CONFIG_FEATURE_LS_RECURSIVE
 883                 case 'R':
 884                         disp_opts |= DISP_RECURSIVE;
 885                         break;
 886 #endif
 887 #ifdef CONFIG_FEATURE_LS_SORTFILES
 888                 case 'r':
 889                         sort_order |= SORT_REVERSE;
 890                         break;
 891                 case 'S':
 892                         sort_opts = SORT_SIZE;
 893                         break;
 894                 case 'v':
 895                         sort_opts = SORT_VERSION;
 896                         break;
 897                 case 'X':
 898                         sort_opts = SORT_EXT;
 899                         break;
 900 #endif
 901 #ifdef CONFIG_FEATURE_LS_TIMESTAMPS
 902                 case 'e':
 903                         list_fmt |= LIST_FULLTIME;
 904                         break;
 905                 case 'c':
 906                         time_fmt = TIME_CHANGE;
 907 #ifdef CONFIG_FEATURE_LS_SORTFILES
 908                         sort_opts = SORT_CTIME;
 909 #endif
 910                         break;
 911                 case 'u':
 912                         time_fmt = TIME_ACCESS;
 913 #ifdef CONFIG_FEATURE_LS_SORTFILES
 914                         sort_opts = SORT_ATIME;
 915 #endif
 916                         break;
 917                 case 't':
 918 #ifdef CONFIG_FEATURE_LS_SORTFILES
 919                         sort_opts = SORT_MTIME;
 920 #endif
 921                         break;
 922 #endif
 923 #ifdef CONFIG_FEATURE_LS_FOLLOWLINKS
 924                 case 'L':
 925                         follow_links = TRUE;
 926                         break;
 927 #endif
 928 #ifdef CONFIG_FEATURE_AUTOWIDTH
 929                 case 'T':
 930                         tabstops = atoi(optarg);
 931                         break;
 932                 case 'w':
 933                         terminal_width = atoi(optarg);
 934                         break;
 935 #endif
 936 #ifdef CONFIG_FEATURE_HUMAN_READABLE
 937                 case 'h':
 938                         ls_disp_hr = TRUE;
 939                         break;
 940 #endif
 941                 case 'k':
 942                         break;
 943                 default:
 944                         goto print_usage_message;
 945                 }
 946         }
 947
 948         /* sort out which command line options take precedence */
 949 #ifdef CONFIG_FEATURE_LS_RECURSIVE
 950         if (disp_opts & DISP_NOLIST)
 951                 disp_opts &= ~DISP_RECURSIVE;   /* no recurse if listing only dir */
 952 #endif
 953 #if defined (CONFIG_FEATURE_LS_TIMESTAMPS) && defined (CONFIG_FEATURE_LS_SORTFILES)
 954         if (time_fmt & TIME_CHANGE)
 955                 sort_opts = SORT_CTIME;
 956         if (time_fmt & TIME_ACCESS)
 957                 sort_opts = SORT_ATIME;
 958 #endif
 959         if (style_fmt != STYLE_LONG)
 960                 list_fmt &= ~LIST_ID_NUMERIC;   /* numeric uid only for long list */
 961 #ifdef CONFIG_FEATURE_LS_USERNAME
 962         if (style_fmt == STYLE_LONG && (list_fmt & LIST_ID_NUMERIC))
 963                 list_fmt &= ~LIST_ID_NAME;      /* don't list names if numeric uid */
 964 #endif
 965
 966         /* choose a display format */
 967         if (style_fmt == STYLE_AUTO)
 968                 style_fmt = isatty(fileno(stdout)) ? STYLE_COLUMNS : STYLE_SINGLE;
 969
 970         /*
 971          * when there are no cmd line args we have to supply a default "." arg.
 972          * we will create a second argv array, "av" that will hold either
 973          * our created "." arg, or the real cmd line args.  The av array
 974          * just holds the pointers- we don't move the date the pointers
 975          * point to.
 976          */
 977         ac = argc - optind;     /* how many cmd line args are left */
 978         if (ac < 1) {
 979                 av = (char **) xcalloc((size_t) 1, (size_t) (sizeof(char *)));
 980                 av[0] = xstrdup(".");
 981                 ac = 1;
 982         } else {
 983                 av = (char **) xcalloc((size_t) ac, (size_t) (sizeof(char *)));
 984                 for (oi = 0; oi < ac; oi++) {
 985                         av[oi] = argv[optind++];        /* copy pointer to real cmd line arg */
 986                 }
 987         }
 988
 989         /* now, everything is in the av array */
 990         if (ac > 1)
 991                 disp_opts |= DISP_DIRNAME;      /* 2 or more items? label directories */
 992
 993         /* stuff the command line file names into an dnode array */
 994         dn = NULL;
 995         for (oi = 0; oi < ac; oi++) {
 996                 char *fullname = xstrdup(av[oi]);
 997
 998                 cur = my_stat(fullname, fullname);
 999                 if (!cur)
1000                         continue;
1001                 cur->next = dn;
1002                 dn = cur;
1003                 nfiles++;
1004         }
1005
1006         /* now that we know how many files there are
1007            ** allocate memory for an array to hold dnode pointers
1008          */
1009         dnp = dnalloc(nfiles);
1010         for (i = 0, cur = dn; i < nfiles; i++) {
1011                 dnp[i] = cur;   /* save pointer to node in array */
1012                 cur = cur->next;
1013         }
1014
1015
1016         if (disp_opts & DISP_NOLIST) {
1017 #ifdef CONFIG_FEATURE_LS_SORTFILES
1018                 shellsort(dnp, nfiles);
1019 #endif
1020                 if (nfiles > 0)
1021                         showfiles(dnp, nfiles);
1022         } else {
1023                 dnd = splitdnarray(dnp, nfiles, SPLIT_DIR);
1024                 dnf = splitdnarray(dnp, nfiles, SPLIT_FILE);
1025                 dndirs = countdirs(dnp, nfiles);
1026                 dnfiles = nfiles - dndirs;
1027                 if (dnfiles > 0) {
1028 #ifdef CONFIG_FEATURE_LS_SORTFILES
1029                         shellsort(dnf, dnfiles);
1030 #endif
1031                         showfiles(dnf, dnfiles);
1032                 }
1033                 if (dndirs > 0) {
1034 #ifdef CONFIG_FEATURE_LS_SORTFILES
1035                         shellsort(dnd, dndirs);
1036 #endif
1037                         showdirs(dnd, dndirs);
1038                 }
1039         }
1040         return (status);
1041
1042   print_usage_message:
1043         show_usage();
1044 }