ls.c

   1 /*
   2  * tiny-ls.c version 0.1.0: A minimalist 'ls'
   3  * Copyright (C) 1996 Brian Candler <B.Candler@pobox.com>
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19
  20 /*
  21  * To achieve a small memory footprint, this version of 'ls' doesn't do any
  22  * file sorting, and only has the most essential command line switches
  23  * (i.e. the ones I couldn't live without :-) All features which involve
  24  * linking in substantial chunks of libc can be disabled.
  25  *
  26  * Although I don't really want to add new features to this program to
  27  * keep it small, I *am* interested to receive bug fixes and ways to make
  28  * it more portable.
  29  *
  30  * KNOWN BUGS:
  31  * 1. messy output if you mix files and directories on the command line
  32  * 2. ls -l of a directory doesn't give "total <blocks>" header
  33  * 3. ls of a symlink to a directory doesn't list directory contents
  34  * 4. hidden files can make column width too large
  35  * NON-OPTIMAL BEHAVIOUR:
  36  * 1. autowidth reads directories twice
  37  * 2. if you do a short directory listing without filetype characters
  38  *    appended, there's no need to stat each one
  39  * PORTABILITY:
  40  * 1. requires lstat (BSD) - how do you do it without?
  41  */
  42
  43 #define TERMINAL_WIDTH  80      /* use 79 if your terminal has linefold bug */
  44 #define COLUMN_WIDTH    14      /* default if AUTOWIDTH not defined */
  45 #define COLUMN_GAP      2       /* includes the file type char, if present */
  46 #define HAS_REWINDDIR
  47
  48 /************************************************************************/
  49
  50 #include "internal.h"
  51 #if !defined(__GLIBC__) && (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1)
  52 # include <linux/types.h>
  53 #else
  54 # include <sys/types.h>
  55 #endif
  56 #include <sys/stat.h>
  57 #include <stdio.h>
  58 #include <unistd.h>
  59 #include <dirent.h>
  60 #include <errno.h>
  61 #include <stdio.h>
  62 #ifdef BB_FEATURE_LS_TIMESTAMPS
  63 #include <time.h>
  64 #endif
  65
  66 #define TYPEINDEX(mode) (((mode) >> 12) & 0x0f)
  67 #define TYPECHAR(mode)  ("0pcCd?bB-?l?s???" [TYPEINDEX(mode)])
  68 #ifdef BB_FEATURE_LS_FILETYPES
  69 #define APPCHAR(mode)   ("\0|\0\0/\0\0\0\0\0@\0=\0\0\0" [TYPEINDEX(mode)])
  70 #endif
  71
  72 #ifndef MAJOR
  73 #define MAJOR(dev) (((dev)>>8)&0xff)
  74 #define MINOR(dev) ((dev)&0xff)
  75 #endif
  76
  77 #define FMT_AUTO        0
  78 #define FMT_LONG        1       /* one record per line, extended info */
  79 #define FMT_SINGLE      2       /* one record per line */
  80 #define FMT_ROWS        3       /* print across rows */
  81 #define FMT_COLUMNS     3       /* fill columns (same, since we don't sort) */
  82
  83 #define TIME_MOD        0
  84 #define TIME_CHANGE     1
  85 #define TIME_ACCESS     2
  86
  87 #define DISP_FTYPE      1       /* show character for file type */
  88 #define DISP_EXEC       2       /* show '*' if regular executable file */
  89 #define DISP_HIDDEN     4       /* show files starting . (except . and ..) */
  90 #define DISP_DOT        8       /* show . and .. */
  91 #define DISP_NUMERIC    16      /* numeric uid and gid */
  92 #define DISP_FULLTIME   32      /* show extended time display */
  93 #define DIR_NOLIST      64      /* show directory as itself, not contents */
  94 #define DISP_DIRNAME    128     /* show directory name (for internal use) */
  95 #define DIR_RECURSE     256     /* -R (not yet implemented) */
  96
  97 static unsigned char    display_fmt = FMT_AUTO;
  98 static unsigned short   opts = 0;
  99 static unsigned short   column = 0;
 100
 101 #ifdef BB_FEATURE_AUTOWIDTH
 102 static unsigned short terminal_width = 0, column_width = 0;
 103 #else
 104 #define terminal_width  TERMINAL_WIDTH
 105 #define column_width    COLUMN_WIDTH
 106 #endif
 107
 108 #ifdef BB_FEATURE_LS_TIMESTAMPS
 109 static unsigned char time_fmt = TIME_MOD;
 110 #endif
 111
 112 #define wr(data,len) fwrite(data, 1, len, stdout)
 113
 114 static void writenum(long val, short minwidth)
 115 {
 116         char    scratch[128];
 117
 118         char *p = scratch + sizeof(scratch);
 119         short len = 0;
 120         short neg = (val < 0);
 121
 122         if (neg) val = -val;
 123         do
 124                 *--p = (val % 10) + '0', len++, val /= 10;
 125         while (val);
 126         if (neg)
 127                 *--p = '-', len++;
 128         while (len < minwidth)
 129                 *--p = ' ', len++;
 130         wr(p, len);
 131         column += len;
 132 }
 133
 134 static void newline(void)
 135 {
 136         if (column > 0) {
 137                 wr("\n", 1);
 138                 column = 0;
 139         }
 140 }
 141
 142 static void tab(short col)
 143 {
 144         static const char spaces[] = "                ";
 145         #define nspaces ((sizeof spaces)-1)     /* null terminator! */
 146
 147         short n = col - column;
 148
 149         if (n > 0) {
 150                 column = col;
 151                 while (n > nspaces) {
 152                         wr(spaces, nspaces);
 153                         n -= nspaces;
 154                 }
 155                 /* must be 1...(sizeof spaces) left */
 156                 wr(spaces, n);
 157         }
 158         #undef nspaces
 159 }
 160
 161 #ifdef BB_FEATURE_LS_FILETYPES
 162 static char append_char(mode_t mode)
 163 {
 164         if (!(opts & DISP_FTYPE))
 165                 return '\0';
 166         if ((opts & DISP_EXEC) && S_ISREG(mode) && (mode & (S_IXUSR|S_IXGRP|S_IXOTH)))
 167                 return '*';
 168         return APPCHAR(mode);
 169 }
 170 #endif
 171
 172 /**
 173  **
 174  ** Display a file or directory as a single item
 175  ** (in either long or short format)
 176  **
 177  **/
 178
 179 static void list_single(const char *name, struct stat *info, const char *fullname)
 180 {
 181         char scratch[PATH_MAX];
 182         short len = strlen(name);
 183 #ifdef BB_FEATURE_LS_FILETYPES
 184         char append = append_char(info->st_mode);
 185 #endif
 186
 187         if (display_fmt == FMT_LONG) {
 188                 mode_t mode = info->st_mode;
 189                 newline();
 190                 wr(modeString(mode), 10);
 191                 column=10;
 192                 writenum((long)info->st_nlink,(short)5);
 193                 fputs(" ", stdout);
 194 #ifdef BB_FEATURE_LS_USERNAME
 195                 if (!(opts & DISP_NUMERIC)) {
 196                         scratch[0]='\0';
 197                         my_getpwuid( scratch, info->st_uid);
 198                         scratch[8]='\0';
 199                         if (*scratch)
 200                                 wr(scratch,8);
 201                         else {
 202                                 writenum((long) info->st_uid,(short)8);
 203                                 fputs(" ", stdout);
 204                         }
 205                 } else
 206 #endif
 207                 {
 208                     writenum((long) info->st_uid,(short)8);
 209                     fputs(" ", stdout);
 210                 }
 211                 tab(16);
 212 #ifdef BB_FEATURE_LS_USERNAME
 213                 if (!(opts & DISP_NUMERIC)) {
 214                         scratch[0]='\0';
 215                         my_getgrgid( scratch, info->st_gid);
 216                         scratch[8]='\0';
 217                         if (*scratch)
 218                                 wr(scratch,8);
 219                         else
 220                                 writenum((long) info->st_gid,(short)8);
 221                 } else
 222 #endif
 223                 writenum((long) info->st_gid,(short)8);
 224                 tab(17);
 225                 if (S_ISBLK(mode) || S_ISCHR(mode)) {
 226                         writenum((long)MAJOR(info->st_rdev),(short)3);
 227                         fputs(", ", stdout);
 228                         writenum((long)MINOR(info->st_rdev),(short)3);
 229                 }
 230                 else
 231                         writenum((long)info->st_size,(short)8);
 232                 fputs(" ", stdout);
 233 #ifdef BB_FEATURE_LS_TIMESTAMPS
 234                 {
 235                         time_t cal;
 236                         char *string;
 237
 238                         switch(time_fmt) {
 239                         case TIME_CHANGE:
 240                                 cal=info->st_ctime; break;
 241                         case TIME_ACCESS:
 242                                 cal=info->st_atime; break;
 243                         default:
 244                                 cal=info->st_mtime; break;
 245                         }
 246                         string=ctime(&cal);
 247                         if (opts & DISP_FULLTIME)
 248                                 wr(string,24);
 249                         else {
 250                                 time_t age = time(NULL) - cal;
 251                                 wr(string+4,7); /* mmm_dd_ */
 252                                 if(age < 3600L*24*365/2 && age > -15*60)
 253                                         /* hh:mm if less than 6 months old */
 254                                         wr(string+11,5);
 255                                 else
 256                                         /* _yyyy otherwise */
 257                                         wr(string+19,5);
 258                         }
 259                         wr(" ", 1);
 260                 }
 261 #else
 262                 fputs("--- -- ----- ", stdout);
 263 #endif
 264                 wr(name, len);
 265                 if (S_ISLNK(mode)) {
 266                         wr(" -> ", 4);
 267                         len = readlink(fullname, scratch, sizeof scratch);
 268                         if (len > 0) fwrite(scratch, 1, len, stdout);
 269 #ifdef BB_FEATURE_LS_FILETYPES
 270                         /* show type of destination */
 271                         if (opts & DISP_FTYPE) {
 272                                 if (!stat(fullname, info)) {
 273                                         append = append_char(info->st_mode);
 274                                         if (append)
 275                                                 fputc(append, stdout);
 276                                 }
 277                         }
 278 #endif
 279                 }
 280 #ifdef BB_FEATURE_LS_FILETYPES
 281                 else if (append)
 282                         wr(&append, 1);
 283 #endif
 284         } else {
 285                 static short nexttab = 0;
 286
 287                 /* sort out column alignment */
 288                 if (column == 0)
 289                         ; /* nothing to do */
 290                 else if (display_fmt == FMT_SINGLE)
 291                         newline();
 292                 else {
 293                         if (nexttab + column_width > terminal_width
 294 #ifndef BB_FEATURE_AUTOWIDTH
 295                         || nexttab + len >= terminal_width
 296 #endif
 297                         )
 298                                 newline();
 299                         else
 300                                 tab(nexttab);
 301                 }
 302                 /* work out where next column starts */
 303 #ifdef BB_FEATURE_AUTOWIDTH
 304                 /* we know the calculated width is big enough */
 305                 nexttab = column + column_width + COLUMN_GAP;
 306 #else
 307                 /* might cover more than one fixed-width column */
 308                 nexttab = column;
 309                 do
 310                         nexttab += column_width + COLUMN_GAP;
 311                 while (nexttab < (column + len + COLUMN_GAP));
 312 #endif
 313                 /* now write the data */
 314                 wr(name, len);
 315                 column = column + len;
 316 #ifdef BB_FEATURE_LS_FILETYPES
 317                 if (append)
 318                         wr(&append, 1), column++;
 319 #endif
 320         }
 321 }
 322
 323 /**
 324  **
 325  ** List the given file or directory, expanding a directory
 326  ** to show its contents if required
 327  **
 328  **/
 329
 330 static int list_item(const char *name)
 331 {
 332         struct stat info;
 333         DIR *dir;
 334         struct dirent *entry;
 335         char fullname[MAXNAMLEN+1], *fnend;
 336
 337         if (lstat(name, &info))
 338                 goto listerr;
 339
 340         if (!S_ISDIR(info.st_mode) ||
 341             (opts & DIR_NOLIST)) {
 342                 list_single(name, &info, name);
 343                 return 0;
 344         }
 345
 346         /* Otherwise, it's a directory we want to list the contents of */
 347
 348         if (opts & DISP_DIRNAME) {   /* identify the directory */
 349                 if (column)
 350                         wr("\n\n", 2), column = 0;
 351                 wr(name, strlen(name));
 352                 wr(":\n", 2);
 353         }
 354
 355         dir = opendir(name);
 356         if (!dir) goto listerr;
 357 #ifdef BB_FEATURE_AUTOWIDTH
 358         column_width = 0;
 359         while ((entry = readdir(dir)) != NULL) {
 360                 short w = strlen(entry->d_name);
 361                 if (column_width < w)
 362                         column_width = w;
 363         }
 364 #ifdef HAS_REWINDDIR
 365         rewinddir(dir);
 366 #else
 367         closedir(dir);
 368         dir = opendir(name);
 369         if (!dir) goto listerr;
 370 #endif
 371 #endif
 372
 373         /* List the contents */
 374
 375         strcpy(fullname,name);  /* *** ignore '.' by itself */
 376         fnend=fullname+strlen(fullname);
 377         if (fnend[-1] != '/')
 378                 *fnend++ = '/';
 379
 380         while ((entry = readdir(dir)) != NULL) {
 381                 const char *en=entry->d_name;
 382                 if (en[0] == '.') {
 383                         if (!en[1] || (en[1] == '.' && !en[2])) { /* . or .. */
 384                                 if (!(opts & DISP_DOT))
 385                                         continue;
 386                         }
 387                         else if (!(opts & DISP_HIDDEN))
 388                                 continue;
 389                 }
 390                 /* FIXME: avoid stat if not required */
 391                 strcpy(fnend, entry->d_name);
 392                 if (lstat(fullname, &info))
 393                         goto direrr; /* (shouldn't fail) */
 394                 list_single(entry->d_name, &info, fullname);
 395         }
 396         closedir(dir);
 397         return 0;
 398
 399 direrr:
 400         closedir(dir);
 401 listerr:
 402         newline();
 403         perror(name);
 404         return 1;
 405 }
 406
 407 static const char ls_usage[] = "ls [-1a"
 408 #ifdef BB_FEATURE_LS_TIMESTAMPS
 409         "c"
 410 #endif
 411         "d"
 412 #ifdef BB_FEATURE_LS_TIMESTAMPS
 413         "e"
 414 #endif
 415         "ln"
 416 #ifdef BB_FEATURE_LS_FILETYPES
 417         "p"
 418 #endif
 419 #ifdef BB_FEATURE_LS_TIMESTAMPS
 420         "u"
 421 #endif
 422         "xAC"
 423 #ifdef BB_FEATURE_LS_FILETYPES
 424         "F"
 425 #endif
 426 #ifdef FEATURE_RECURSIVE
 427         "R"
 428 #endif
 429         "] [filenames...]\n";
 430
 431 extern int
 432 ls_main(int argc, char * * argv)
 433 {
 434         int argi=1, i;
 435
 436         /* process options */
 437         while (argi < argc && argv[argi][0] == '-') {
 438                 const char *p = &argv[argi][1];
 439
 440                 if (!*p) goto print_usage_message;      /* "-" by itself not allowed */
 441                 if (*p == '-') {
 442                         if (!p[1]) {    /* "--" forces end of options */
 443                                 argi++;
 444                                 break;
 445                         }
 446                         /* it's a long option name - we don't support them */
 447                         goto print_usage_message;
 448                 }
 449
 450                 while (*p)
 451                         switch (*p++) {
 452                         case 'l':       display_fmt = FMT_LONG; break;
 453                         case '1':       display_fmt = FMT_SINGLE; break;
 454                         case 'x':       display_fmt = FMT_ROWS; break;
 455                         case 'C':       display_fmt = FMT_COLUMNS; break;
 456 #ifdef BB_FEATURE_LS_FILETYPES
 457                         case 'p':       opts |= DISP_FTYPE; break;
 458                         case 'F':       opts |= DISP_FTYPE|DISP_EXEC; break;
 459 #endif
 460                         case 'A':       opts |= DISP_HIDDEN; break;
 461                         case 'a':       opts |= DISP_HIDDEN|DISP_DOT; break;
 462                         case 'n':       opts |= DISP_NUMERIC; break;
 463                         case 'd':       opts |= DIR_NOLIST; break;
 464 #ifdef FEATURE_RECURSIVE
 465                         case 'R':       opts |= DIR_RECURSE; break;
 466 #endif
 467 #ifdef BB_FEATURE_LS_TIMESTAMPS
 468                         case 'u':       time_fmt = TIME_ACCESS; break;
 469                         case 'c':       time_fmt = TIME_CHANGE; break;
 470                         case 'e':       opts |= DISP_FULLTIME; break;
 471 #endif
 472                         default:        goto print_usage_message;
 473                         }
 474
 475                 argi++;
 476         }
 477
 478         /* choose a display format */
 479         if (display_fmt == FMT_AUTO)
 480                 display_fmt = isatty(fileno(stdout)) ? FMT_COLUMNS : FMT_SINGLE;
 481         if (argi < argc - 1)
 482                 opts |= DISP_DIRNAME; /* 2 or more items? label directories */
 483 #ifdef BB_FEATURE_AUTOWIDTH
 484         /* could add a -w option and/or TIOCGWINSZ call */
 485         if (terminal_width < 1) terminal_width = TERMINAL_WIDTH;
 486
 487         for (i = argi; i < argc; i++) {
 488                 int len = strlen(argv[i]);
 489                 if (column_width < len)
 490                         column_width = len;
 491         }
 492 #endif
 493
 494         /* process files specified, or current directory if none */
 495         i=0;
 496         if (argi == argc)
 497                 i = list_item(".");
 498         while (argi < argc)
 499                 i |= list_item(argv[argi++]);
 500         newline();
 501         exit( i);
 502
 503 print_usage_message:
 504         usage (ls_usage);
 505         exit( FALSE);
 506 }
 507