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