src/ls.c

   1 /* `dir', `vdir' and `ls' directory listing programs for GNU.
   2    Copyright (C) 85, 88, 90, 91, 1995-2005 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  17
  18 /* If ls_mode is LS_MULTI_COL,
  19    the multi-column format is the default regardless
  20    of the type of output device.
  21    This is for the `dir' program.
  22
  23    If ls_mode is LS_LONG_FORMAT,
  24    the long format is the default regardless of the
  25    type of output device.
  26    This is for the `vdir' program.
  27
  28    If ls_mode is LS_LS,
  29    the output format depends on whether the output
  30    device is a terminal.
  31    This is for the `ls' program.  */
  32
  33 /* Written by Richard Stallman and David MacKenzie.  */
  34
  35 /* Color support by Peter Anvin <Peter.Anvin@linux.org> and Dennis
  36    Flaherty <dennisf@denix.elk.miles.com> based on original patches by
  37    Greg Lee <lee@uhunix.uhcc.hawaii.edu>.  */
  38
  39 #include <config.h>
  40 #include <sys/types.h>
  41
  42 #if HAVE_TERMIOS_H
  43 # include <termios.h>
  44 #endif
  45 #if HAVE_STROPTS_H
  46 # include <stropts.h>
  47 #endif
  48 #if HAVE_SYS_IOCTL_H
  49 # include <sys/ioctl.h>
  50 #endif
  51
  52 #ifdef WINSIZE_IN_PTEM
  53 # include <sys/stream.h>
  54 # include <sys/ptem.h>
  55 #endif
  56
  57 #include <stdio.h>
  58 #include <assert.h>
  59 #include <setjmp.h>
  60 #include <grp.h>
  61 #include <pwd.h>
  62 #include <getopt.h>
  63 #include <signal.h>
  64
  65 /* Use SA_NOCLDSTOP as a proxy for whether the sigaction machinery is
  66    present.  */
  67 #ifndef SA_NOCLDSTOP
  68 # define SA_NOCLDSTOP 0
  69 # define sigprocmask(How, Set, Oset) /* empty */
  70 # define sigset_t int
  71 # if ! HAVE_SIGINTERRUPT
  72 #  define siginterrupt(sig, flag) /* empty */
  73 # endif
  74 #endif
  75
  76 /* Get mbstate_t, mbrtowc(), mbsinit(), wcwidth().  */
  77 #if HAVE_WCHAR_H
  78 # include <wchar.h>
  79 #endif
  80
  81 /* Get iswprint().  */
  82 #if HAVE_WCTYPE_H
  83 # include <wctype.h>
  84 #endif
  85 #if !defined iswprint && !HAVE_ISWPRINT
  86 # define iswprint(wc) 1
  87 #endif
  88
  89 #ifndef HAVE_DECL_WCWIDTH
  90 "this configure-time declaration test was not run"
  91 #endif
  92 #if !HAVE_DECL_WCWIDTH
  93 int wcwidth ();
  94 #endif
  95
  96 /* If wcwidth() doesn't exist, assume all printable characters have
  97    width 1.  */
  98 #ifndef wcwidth
  99 # if !HAVE_WCWIDTH
 100 #  define wcwidth(wc) ((wc) == 0 ? 0 : iswprint (wc) ? 1 : -1)
 101 # endif
 102 #endif
 103
 104 #include "system.h"
 105 #include <fnmatch.h>
 106
 107 #include "acl.h"
 108 #include "argmatch.h"
 109 #include "dev-ino.h"
 110 #include "dirname.h"
 111 #include "dirfd.h"
 112 #include "error.h"
 113 #include "filenamecat.h"
 114 #include "hard-locale.h"
 115 #include "hash.h"
 116 #include "human.h"
 117 #include "filemode.h"
 118 #include "inttostr.h"
 119 #include "ls.h"
 120 #include "lstat.h"
 121 #include "mbswidth.h"
 122 #include "obstack.h"
 123 #include "quote.h"
 124 #include "quotearg.h"
 125 #include "same.h"
 126 #include "stat-time.h"
 127 #include "strftime.h"
 128 #include "strverscmp.h"
 129 #include "xstrtol.h"
 130 #include "xreadlink.h"
 131
 132 #define PROGRAM_NAME (ls_mode == LS_LS ? "ls" \
 133                       : (ls_mode == LS_MULTI_COL \
 134                          ? "dir" : "vdir"))
 135
 136 #define AUTHORS "Richard Stallman", "David MacKenzie"
 137
 138 #define obstack_chunk_alloc malloc
 139 #define obstack_chunk_free free
 140
 141 /* Return an int indicating the result of comparing two integers.
 142    Subtracting doesn't always work, due to overflow.  */
 143 #define longdiff(a, b) ((a) < (b) ? -1 : (a) > (b))
 144
 145 #if HAVE_STRUCT_DIRENT_D_TYPE && defined DTTOIF
 146 # define DT_INIT(Val) = Val
 147 #else
 148 # define DT_INIT(Val) /* empty */
 149 #endif
 150
 151 #if ! HAVE_STRUCT_STAT_ST_AUTHOR
 152 # define st_author st_uid
 153 #endif
 154
 155 /* Cray/Unicos DMF: use the file's migrated, not real, status */
 156 #if HAVE_ST_DM_MODE
 157 # define ST_DM_MODE(Stat_buf) ((Stat_buf).st_dm_mode)
 158 #else
 159 # define ST_DM_MODE(Stat_buf) ((Stat_buf).st_mode)
 160 #endif
 161
 162 enum filetype
 163   {
 164     unknown DT_INIT (DT_UNKNOWN),
 165     fifo DT_INIT (DT_FIFO),
 166     chardev DT_INIT (DT_CHR),
 167     directory DT_INIT (DT_DIR),
 168     blockdev DT_INIT (DT_BLK),
 169     normal DT_INIT (DT_REG),
 170     symbolic_link DT_INIT (DT_LNK),
 171     sock DT_INIT (DT_SOCK),
 172     arg_directory DT_INIT (2 * (DT_UNKNOWN | DT_FIFO | DT_CHR | DT_DIR | DT_BLK
 173                                 | DT_REG | DT_LNK | DT_SOCK))
 174   };
 175
 176 struct fileinfo
 177   {
 178     /* The file name.  */
 179     char *name;
 180
 181     struct stat stat;
 182
 183     /* For symbolic link, name of the file linked to, otherwise zero.  */
 184     char *linkname;
 185
 186     /* For symbolic link and long listing, st_mode of file linked to, otherwise
 187        zero.  */
 188     mode_t linkmode;
 189
 190     /* For symbolic link and color printing, true if linked-to file
 191        exists, otherwise false.  */
 192     bool linkok;
 193
 194     enum filetype filetype;
 195
 196 #if HAVE_ACL
 197     /* For long listings, true if the file has an access control list.  */
 198     bool have_acl;
 199 #endif
 200   };
 201
 202 #if HAVE_ACL
 203 # define FILE_HAS_ACL(F) ((F)->have_acl)
 204 #else
 205 # define FILE_HAS_ACL(F) 0
 206 #endif
 207
 208 #define LEN_STR_PAIR(s) sizeof (s) - 1, s
 209
 210 /* Null is a valid character in a color indicator (think about Epson
 211    printers, for example) so we have to use a length/buffer string
 212    type.  */
 213
 214 struct bin_str
 215   {
 216     size_t len;                 /* Number of bytes */
 217     const char *string;         /* Pointer to the same */
 218   };
 219
 220 char *getgroup ();
 221 char *getuser ();
 222
 223 #if ! HAVE_TCGETPGRP
 224 # define tcgetpgrp(Fd) 0
 225 #endif
 226
 227 static size_t quote_name (FILE *out, const char *name,
 228                           struct quoting_options const *options,
 229                           size_t *width);
 230 static char *make_link_name (char const *name, char const *linkname);
 231 static int decode_switches (int argc, char **argv);
 232 static bool file_ignored (char const *name);
 233 static uintmax_t gobble_file (char const *name, enum filetype type,
 234                               bool command_line_arg, char const *dirname);
 235 static void print_color_indicator (const char *name, mode_t mode, int linkok);
 236 static void put_indicator (const struct bin_str *ind);
 237 static void add_ignore_pattern (const char *pattern);
 238 static void attach (char *dest, const char *dirname, const char *name);
 239 static void clear_files (void);
 240 static void extract_dirs_from_files (char const *dirname,
 241                                      bool command_line_arg);
 242 static void get_link_name (char const *filename, struct fileinfo *f,
 243                            bool command_line_arg);
 244 static void indent (size_t from, size_t to);
 245 static size_t calculate_columns (bool by_columns);
 246 static void print_current_files (void);
 247 static void print_dir (char const *name, char const *realname,
 248                        bool command_line_arg);
 249 static void print_file_name_and_frills (const struct fileinfo *f);
 250 static void print_horizontal (void);
 251 static int format_user_width (uid_t u);
 252 static int format_group_width (gid_t g);
 253 static void print_long_format (const struct fileinfo *f);
 254 static void print_many_per_line (void);
 255 static void print_name_with_quoting (const char *p, mode_t mode,
 256                                      int linkok,
 257                                      struct obstack *stack);
 258 static void prep_non_filename_text (void);
 259 static void print_type_indicator (mode_t mode);
 260 static void print_with_commas (void);
 261 static void queue_directory (char const *name, char const *realname,
 262                              bool command_line_arg);
 263 static void sort_files (void);
 264 static void parse_ls_color (void);
 265 void usage (int status);
 266
 267 /* The name this program was run with.  */
 268 char *program_name;
 269
 270 /* Initial size of hash table.
 271    Most hierarchies are likely to be shallower than this.  */
 272 #define INITIAL_TABLE_SIZE 30
 273
 274 /* The set of `active' directories, from the current command-line argument
 275    to the level in the hierarchy at which files are being listed.
 276    A directory is represented by its device and inode numbers (struct dev_ino).
 277    A directory is added to this set when ls begins listing it or its
 278    entries, and it is removed from the set just after ls has finished
 279    processing it.  This set is used solely to detect loops, e.g., with
 280    mkdir loop; cd loop; ln -s ../loop sub; ls -RL  */
 281 static Hash_table *active_dir_set;
 282
 283 #define LOOP_DETECT (!!active_dir_set)
 284
 285 /* The table of files in the current directory:
 286
 287    `files' points to a vector of `struct fileinfo', one per file.
 288    `nfiles' is the number of elements space has been allocated for.
 289    `files_index' is the number actually in use.  */
 290
 291 /* Address of block containing the files that are described.  */
 292 static struct fileinfo *files;  /* FIXME: rename this to e.g. cwd_file */
 293
 294 /* Length of block that `files' points to, measured in files.  */
 295 static size_t nfiles;  /* FIXME: rename this to e.g. cwd_n_alloc */
 296
 297 /* Index of first unused in `files'.  */
 298 static size_t files_index;  /* FIXME: rename this to e.g. cwd_n_used */
 299
 300 /* When true, in a color listing, color each symlink name according to the
 301    type of file it points to.  Otherwise, color them according to the `ln'
 302    directive in LS_COLORS.  Dangling (orphan) symlinks are treated specially,
 303    regardless.  This is set when `ln=target' appears in LS_COLORS.  */
 304
 305 static bool color_symlink_as_referent;
 306
 307 /* mode of appropriate file for colorization */
 308 #define FILE_OR_LINK_MODE(File) \
 309     ((color_symlink_as_referent & (File)->linkok) \
 310      ? (File)->linkmode : (File)->stat.st_mode)
 311
 312
 313 /* Record of one pending directory waiting to be listed.  */
 314
 315 struct pending
 316   {
 317     char *name;
 318     /* If the directory is actually the file pointed to by a symbolic link we
 319        were told to list, `realname' will contain the name of the symbolic
 320        link, otherwise zero.  */
 321     char *realname;
 322     bool command_line_arg;
 323     struct pending *next;
 324   };
 325
 326 static struct pending *pending_dirs;
 327
 328 /* Current time in seconds and nanoseconds since 1970, updated as
 329    needed when deciding whether a file is recent.  */
 330
 331 static time_t current_time = TYPE_MINIMUM (time_t);
 332 static int current_time_ns = -1;
 333
 334 /* Whether any of the files has an ACL.  This affects the width of the
 335    mode column.  */
 336
 337 #if HAVE_ACL
 338 static bool any_has_acl;
 339 #else
 340 enum { any_has_acl = false };
 341 #endif
 342
 343 /* The number of columns to use for columns containing inode numbers,
 344    block sizes, link counts, owners, groups, authors, major device
 345    numbers, minor device numbers, and file sizes, respectively.  */
 346
 347 static int inode_number_width;
 348 static int block_size_width;
 349 static int nlink_width;
 350 static int owner_width;
 351 static int group_width;
 352 static int author_width;
 353 static int major_device_number_width;
 354 static int minor_device_number_width;
 355 static int file_size_width;
 356
 357 /* Option flags */
 358
 359 /* long_format for lots of info, one per line.
 360    one_per_line for just names, one per line.
 361    many_per_line for just names, many per line, sorted vertically.
 362    horizontal for just names, many per line, sorted horizontally.
 363    with_commas for just names, many per line, separated by commas.
 364
 365    -l (and other options that imply -l), -1, -C, -x and -m control
 366    this parameter.  */
 367
 368 enum format
 369   {
 370     long_format,                /* -l and other options that imply -l */
 371     one_per_line,               /* -1 */
 372     many_per_line,              /* -C */
 373     horizontal,                 /* -x */
 374     with_commas                 /* -m */
 375   };
 376
 377 static enum format format;
 378
 379 /* `full-iso' uses full ISO-style dates and times.  `long-iso' uses longer
 380    ISO-style time stamps, though shorter than `full-iso'.  `iso' uses shorter
 381    ISO-style time stamps.  `locale' uses locale-dependent time stamps.  */
 382 enum time_style
 383   {
 384     full_iso_time_style,        /* --time-style=full-iso */
 385     long_iso_time_style,        /* --time-style=long-iso */
 386     iso_time_style,             /* --time-style=iso */
 387     locale_time_style           /* --time-style=locale */
 388   };
 389
 390 static char const *const time_style_args[] =
 391 {
 392   "full-iso", "long-iso", "iso", "locale", NULL
 393 };
 394 static enum time_style const time_style_types[] =
 395 {
 396   full_iso_time_style, long_iso_time_style, iso_time_style,
 397   locale_time_style
 398 };
 399 ARGMATCH_VERIFY (time_style_args, time_style_types);
 400
 401 /* Type of time to print or sort by.  Controlled by -c and -u.  */
 402
 403 enum time_type
 404   {
 405     time_mtime,                 /* default */
 406     time_ctime,                 /* -c */
 407     time_atime                  /* -u */
 408   };
 409
 410 static enum time_type time_type;
 411
 412 /* The file characteristic to sort by.  Controlled by -t, -S, -U, -X, -v.  */
 413
 414 enum sort_type
 415   {
 416     sort_none,                  /* -U */
 417     sort_name,                  /* default */
 418     sort_extension,             /* -X */
 419     sort_time,                  /* -t */
 420     sort_size,                  /* -S */
 421     sort_version                /* -v */
 422   };
 423
 424 static enum sort_type sort_type;
 425
 426 /* Direction of sort.
 427    false means highest first if numeric,
 428    lowest first if alphabetic;
 429    these are the defaults.
 430    true means the opposite order in each case.  -r  */
 431
 432 static bool sort_reverse;
 433
 434 /* True means to display owner information.  -g turns this off.  */
 435
 436 static bool print_owner = true;
 437
 438 /* True means to display author information.  */
 439
 440 static bool print_author;
 441
 442 /* True means to display group information.  -G and -o turn this off.  */
 443
 444 static bool print_group = true;
 445
 446 /* True means print the user and group id's as numbers rather
 447    than as names.  -n  */
 448
 449 static bool numeric_ids;
 450
 451 /* True means mention the size in blocks of each file.  -s  */
 452
 453 static bool print_block_size;
 454
 455 /* Human-readable options for output.  */
 456 static int human_output_opts;
 457
 458 /* The units to use when printing sizes other than file sizes.  */
 459 static uintmax_t output_block_size;
 460
 461 /* Likewise, but for file sizes.  */
 462 static uintmax_t file_output_block_size = 1;
 463
 464 /* Follow the output with a special string.  Using this format,
 465    Emacs' dired mode starts up twice as fast, and can handle all
 466    strange characters in file names.  */
 467 static bool dired;
 468
 469 /* `none' means don't mention the type of files.
 470    `slash' means mention directories only, with a '/'.
 471    `file_type' means mention file types.
 472    `classify' means mention file types and mark executables.
 473
 474    Controlled by -F, -p, and --indicator-style.  */
 475
 476 enum indicator_style
 477   {
 478     none,       /*     --indicator-style=none */
 479     slash,      /* -p, --indicator-style=slash */
 480     file_type,  /*     --indicator-style=file-type */
 481     classify    /* -F, --indicator-style=classify */
 482   };
 483
 484 static enum indicator_style indicator_style;
 485
 486 /* Names of indicator styles.  */
 487 static char const *const indicator_style_args[] =
 488 {
 489   "none", "slash", "file-type", "classify", NULL
 490 };
 491 static enum indicator_style const indicator_style_types[] =
 492 {
 493   none, slash, file_type, classify
 494 };
 495 ARGMATCH_VERIFY (indicator_style_args, indicator_style_types);
 496
 497 /* True means use colors to mark types.  Also define the different
 498    colors as well as the stuff for the LS_COLORS environment variable.
 499    The LS_COLORS variable is now in a termcap-like format.  */
 500
 501 static bool print_with_color;
 502
 503 enum color_type
 504   {
 505     color_never,                /* 0: default or --color=never */
 506     color_always,               /* 1: --color=always */
 507     color_if_tty                /* 2: --color=tty */
 508   };
 509
 510 enum Dereference_symlink
 511   {
 512     DEREF_UNDEFINED = 1,
 513     DEREF_NEVER,
 514     DEREF_COMMAND_LINE_ARGUMENTS,       /* -H */
 515     DEREF_COMMAND_LINE_SYMLINK_TO_DIR,  /* the default, in certain cases */
 516     DEREF_ALWAYS                        /* -L */
 517   };
 518
 519 enum indicator_no
 520   {
 521     C_LEFT, C_RIGHT, C_END, C_NORM, C_FILE, C_DIR, C_LINK, C_FIFO, C_SOCK,
 522     C_BLK, C_CHR, C_MISSING, C_ORPHAN, C_EXEC, C_DOOR, C_SETUID, C_SETGID,
 523     C_STICKY, C_OTHER_WRITABLE, C_STICKY_OTHER_WRITABLE
 524   };
 525
 526 static const char *const indicator_name[]=
 527   {
 528     "lc", "rc", "ec", "no", "fi", "di", "ln", "pi", "so",
 529     "bd", "cd", "mi", "or", "ex", "do", "su", "sg", "st",
 530     "ow", "tw", NULL
 531   };
 532
 533 struct color_ext_type
 534   {
 535     struct bin_str ext;         /* The extension we're looking for */
 536     struct bin_str seq;         /* The sequence to output when we do */
 537     struct color_ext_type *next;        /* Next in list */
 538   };
 539
 540 static struct bin_str color_indicator[] =
 541   {
 542     { LEN_STR_PAIR ("\033[") },         /* lc: Left of color sequence */
 543     { LEN_STR_PAIR ("m") },             /* rc: Right of color sequence */
 544     { 0, NULL },                        /* ec: End color (replaces lc+no+rc) */
 545     { LEN_STR_PAIR ("0") },             /* no: Normal */
 546     { LEN_STR_PAIR ("0") },             /* fi: File: default */
 547     { LEN_STR_PAIR ("01;34") },         /* di: Directory: bright blue */
 548     { LEN_STR_PAIR ("01;36") },         /* ln: Symlink: bright cyan */
 549     { LEN_STR_PAIR ("33") },            /* pi: Pipe: yellow/brown */
 550     { LEN_STR_PAIR ("01;35") },         /* so: Socket: bright magenta */
 551     { LEN_STR_PAIR ("01;33") },         /* bd: Block device: bright yellow */
 552     { LEN_STR_PAIR ("01;33") },         /* cd: Char device: bright yellow */
 553     { 0, NULL },                        /* mi: Missing file: undefined */
 554     { 0, NULL },                        /* or: Orphaned symlink: undefined */
 555     { LEN_STR_PAIR ("01;32") },         /* ex: Executable: bright green */
 556     { LEN_STR_PAIR ("01;35") },         /* do: Door: bright magenta */
 557     { LEN_STR_PAIR ("37;41") },         /* su: setuid: white on red */
 558     { LEN_STR_PAIR ("30;43") },         /* sg: setgid: black on yellow */
 559     { LEN_STR_PAIR ("37;44") },         /* st: sticky: black on blue */
 560     { LEN_STR_PAIR ("34;42") },         /* ow: other-writable: blue on green */
 561     { LEN_STR_PAIR ("30;42") },         /* tw: ow w/ sticky: black on green */
 562   };
 563
 564 /* FIXME: comment  */
 565 static struct color_ext_type *color_ext_list = NULL;
 566
 567 /* Buffer for color sequences */
 568 static char *color_buf;
 569
 570 /* True means to check for orphaned symbolic link, for displaying
 571    colors.  */
 572
 573 static bool check_symlink_color;
 574
 575 /* True means mention the inode number of each file.  -i  */
 576
 577 static bool print_inode;
 578
 579 /* What to do with symbolic links.  Affected by -d, -F, -H, -l (and
 580    other options that imply -l), and -L.  */
 581
 582 static enum Dereference_symlink dereference;
 583
 584 /* True means when a directory is found, display info on its
 585    contents.  -R  */
 586
 587 static bool recursive;
 588
 589 /* True means when an argument is a directory name, display info
 590    on it itself.  -d  */
 591
 592 static bool immediate_dirs;
 593
 594 /* Which files to ignore.  */
 595
 596 static enum
 597 {
 598   /* Ignore files whose names start with `.', and files specified by
 599      --hide and --ignore.  */
 600   IGNORE_DEFAULT,
 601
 602   /* Ignore `.', `..', and files specified by --ignore.  */
 603   IGNORE_DOT_AND_DOTDOT,
 604
 605   /* Ignore only files specified by --ignore.  */
 606   IGNORE_MINIMAL
 607 } ignore_mode;
 608
 609 /* A linked list of shell-style globbing patterns.  If a non-argument
 610    file name matches any of these patterns, it is ignored.
 611    Controlled by -I.  Multiple -I options accumulate.
 612    The -B option adds `*~' and `.*~' to this list.  */
 613
 614 struct ignore_pattern
 615   {
 616     const char *pattern;
 617     struct ignore_pattern *next;
 618   };
 619
 620 static struct ignore_pattern *ignore_patterns;
 621
 622 /* Similar to IGNORE_PATTERNS, except that -a or -A causes this
 623    variable itself to be ignored.  */
 624 static struct ignore_pattern *hide_patterns;
 625
 626 /* True means output nongraphic chars in file names as `?'.
 627    (-q, --hide-control-chars)
 628    qmark_funny_chars and the quoting style (-Q, --quoting-style=WORD) are
 629    independent.  The algorithm is: first, obey the quoting style to get a
 630    string representing the file name;  then, if qmark_funny_chars is set,
 631    replace all nonprintable chars in that string with `?'.  It's necessary
 632    to replace nonprintable chars even in quoted strings, because we don't
 633    want to mess up the terminal if control chars get sent to it, and some
 634    quoting methods pass through control chars as-is.  */
 635 static bool qmark_funny_chars;
 636
 637 /* Quoting options for file and dir name output.  */
 638
 639 static struct quoting_options *filename_quoting_options;
 640 static struct quoting_options *dirname_quoting_options;
 641
 642 /* The number of chars per hardware tab stop.  Setting this to zero
 643    inhibits the use of TAB characters for separating columns.  -T */
 644 static size_t tabsize;
 645
 646 /* True means print each directory name before listing it.  */
 647
 648 static bool print_dir_name;
 649
 650 /* The line length to use for breaking lines in many-per-line format.
 651    Can be set with -w.  */
 652
 653 static size_t line_length;
 654
 655 /* If true, the file listing format requires that stat be called on
 656    each file.  */
 657
 658 static bool format_needs_stat;
 659
 660 /* Similar to `format_needs_stat', but set if only the file type is
 661    needed.  */
 662
 663 static bool format_needs_type;
 664
 665 /* An arbitrary limit on the number of bytes in a printed time stamp.
 666    This is set to a relatively small value to avoid the need to worry
 667    about denial-of-service attacks on servers that run "ls" on behalf
 668    of remote clients.  1000 bytes should be enough for any practical
 669    time stamp format.  */
 670
 671 enum { TIME_STAMP_LEN_MAXIMUM = MAX (1000, INT_STRLEN_BOUND (time_t)) };
 672
 673 /* strftime formats for non-recent and recent files, respectively, in
 674    -l output.  */
 675
 676 static char const *long_time_format[2] =
 677   {
 678     /* strftime format for non-recent files (older than 6 months), in
 679        -l output when --time-style=locale is specified.  This should
 680        contain the year, month and day (at least), in an order that is
 681        understood by people in your locale's territory.
 682        Please try to keep the number of used screen columns small,
 683        because many people work in windows with only 80 columns.  But
 684        make this as wide as the other string below, for recent files.  */
 685     N_("%b %e  %Y"),
 686     /* strftime format for recent files (younger than 6 months), in
 687        -l output when --time-style=locale is specified.  This should
 688        contain the month, day and time (at least), in an order that is
 689        understood by people in your locale's territory.
 690        Please try to keep the number of used screen columns small,
 691        because many people work in windows with only 80 columns.  But
 692        make this as wide as the other string above, for non-recent files.  */
 693     N_("%b %e %H:%M")
 694   };
 695
 696 /* The set of signals that are caught.  */
 697
 698 static sigset_t caught_signals;
 699
 700 /* If nonzero, the value of the pending fatal signal.  */
 701
 702 static sig_atomic_t volatile interrupt_signal;
 703
 704 /* A count of the number of pending stop signals that have been received.  */
 705
 706 static sig_atomic_t volatile stop_signal_count;
 707
 708 /* Desired exit status.  */
 709
 710 static int exit_status;
 711
 712 /* Exit statuses.  */
 713 enum
 714   {
 715     /* "ls" had a minor problem (e.g., it could not stat a directory
 716        entry).  */
 717     LS_MINOR_PROBLEM = 1,
 718
 719     /* "ls" had more serious trouble.  */
 720     LS_FAILURE = 2
 721   };
 722
 723 /* For long options that have no equivalent short option, use a
 724    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
 725 enum
 726 {
 727   AUTHOR_OPTION = CHAR_MAX + 1,
 728   BLOCK_SIZE_OPTION,
 729   COLOR_OPTION,
 730   DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR_OPTION,
 731   FORMAT_OPTION,
 732   FULL_TIME_OPTION,
 733   HIDE_OPTION,
 734   INDICATOR_STYLE_OPTION,
 735   QUOTING_STYLE_OPTION,
 736   SHOW_CONTROL_CHARS_OPTION,
 737   SI_OPTION,
 738   SORT_OPTION,
 739   TIME_OPTION,
 740   TIME_STYLE_OPTION
 741 };
 742
 743 static struct option const long_options[] =
 744 {
 745   {"all", no_argument, NULL, 'a'},
 746   {"escape", no_argument, NULL, 'b'},
 747   {"directory", no_argument, NULL, 'd'},
 748   {"dired", no_argument, NULL, 'D'},
 749   {"full-time", no_argument, NULL, FULL_TIME_OPTION},
 750   {"human-readable", no_argument, NULL, 'h'},
 751   {"inode", no_argument, NULL, 'i'},
 752   {"kilobytes", no_argument, NULL, 'k'}, /* long form is obsolescent */
 753   {"numeric-uid-gid", no_argument, NULL, 'n'},
 754   {"no-group", no_argument, NULL, 'G'},
 755   {"hide-control-chars", no_argument, NULL, 'q'},
 756   {"reverse", no_argument, NULL, 'r'},
 757   {"size", no_argument, NULL, 's'},
 758   {"width", required_argument, NULL, 'w'},
 759   {"almost-all", no_argument, NULL, 'A'},
 760   {"ignore-backups", no_argument, NULL, 'B'},
 761   {"classify", no_argument, NULL, 'F'},
 762   {"file-type", no_argument, NULL, 'p'},
 763   {"si", no_argument, NULL, SI_OPTION},
 764   {"dereference-command-line", no_argument, NULL, 'H'},
 765   {"dereference-command-line-symlink-to-dir", no_argument, NULL,
 766    DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR_OPTION},
 767   {"hide", required_argument, NULL, HIDE_OPTION},
 768   {"ignore", required_argument, NULL, 'I'},
 769   {"indicator-style", required_argument, NULL, INDICATOR_STYLE_OPTION},
 770   {"dereference", no_argument, NULL, 'L'},
 771   {"literal", no_argument, NULL, 'N'},
 772   {"quote-name", no_argument, NULL, 'Q'},
 773   {"quoting-style", required_argument, NULL, QUOTING_STYLE_OPTION},
 774   {"recursive", no_argument, NULL, 'R'},
 775   {"format", required_argument, NULL, FORMAT_OPTION},
 776   {"show-control-chars", no_argument, NULL, SHOW_CONTROL_CHARS_OPTION},
 777   {"sort", required_argument, NULL, SORT_OPTION},
 778   {"tabsize", required_argument, NULL, 'T'},
 779   {"time", required_argument, NULL, TIME_OPTION},
 780   {"time-style", required_argument, NULL, TIME_STYLE_OPTION},
 781   {"color", optional_argument, NULL, COLOR_OPTION},
 782   {"block-size", required_argument, NULL, BLOCK_SIZE_OPTION},
 783   {"author", no_argument, NULL, AUTHOR_OPTION},
 784   {GETOPT_HELP_OPTION_DECL},
 785   {GETOPT_VERSION_OPTION_DECL},
 786   {NULL, 0, NULL, 0}
 787 };
 788
 789 static char const *const format_args[] =
 790 {
 791   "verbose", "long", "commas", "horizontal", "across",
 792   "vertical", "single-column", NULL
 793 };
 794 static enum format const format_types[] =
 795 {
 796   long_format, long_format, with_commas, horizontal, horizontal,
 797   many_per_line, one_per_line
 798 };
 799 ARGMATCH_VERIFY (format_args, format_types);
 800
 801 static char const *const sort_args[] =
 802 {
 803   "none", "time", "size", "extension", "version", NULL
 804 };
 805 static enum sort_type const sort_types[] =
 806 {
 807   sort_none, sort_time, sort_size, sort_extension, sort_version
 808 };
 809 ARGMATCH_VERIFY (sort_args, sort_types);
 810
 811 static char const *const time_args[] =
 812 {
 813   "atime", "access", "use", "ctime", "status", NULL
 814 };
 815 static enum time_type const time_types[] =
 816 {
 817   time_atime, time_atime, time_atime, time_ctime, time_ctime
 818 };
 819 ARGMATCH_VERIFY (time_args, time_types);
 820
 821 static char const *const color_args[] =
 822 {
 823   /* force and none are for compatibility with another color-ls version */
 824   "always", "yes", "force",
 825   "never", "no", "none",
 826   "auto", "tty", "if-tty", NULL
 827 };
 828 static enum color_type const color_types[] =
 829 {
 830   color_always, color_always, color_always,
 831   color_never, color_never, color_never,
 832   color_if_tty, color_if_tty, color_if_tty
 833 };
 834 ARGMATCH_VERIFY (color_args, color_types);
 835
 836 /* Information about filling a column.  */
 837 struct column_info
 838 {
 839   bool valid_len;
 840   size_t line_len;
 841   size_t *col_arr;
 842 };
 843
 844 /* Array with information about column filledness.  */
 845 static struct column_info *column_info;
 846
 847 /* Maximum number of columns ever possible for this display.  */
 848 static size_t max_idx;
 849
 850 /* The minimum width of a column is 3: 1 character for the name and 2
 851    for the separating white space.  */
 852 #define MIN_COLUMN_WIDTH        3
 853
 854
 855 /* This zero-based index is used solely with the --dired option.
 856    When that option is in effect, this counter is incremented for each
 857    byte of output generated by this program so that the beginning
 858    and ending indices (in that output) of every file name can be recorded
 859    and later output themselves.  */
 860 static size_t dired_pos;
 861
 862 #define DIRED_PUTCHAR(c) do {putchar ((c)); ++dired_pos;} while (0)
 863
 864 /* Write S to STREAM and increment DIRED_POS by S_LEN.  */
 865 #define DIRED_FPUTS(s, stream, s_len) \
 866     do {fputs ((s), (stream)); dired_pos += s_len;} while (0)
 867
 868 /* Like DIRED_FPUTS, but for use when S is a literal string.  */
 869 #define DIRED_FPUTS_LITERAL(s, stream) \
 870     do {fputs ((s), (stream)); dired_pos += sizeof((s)) - 1;} while (0)
 871
 872 #define DIRED_INDENT()                                                  \
 873     do                                                                  \
 874       {                                                                 \
 875         if (dired)                                                      \
 876           DIRED_FPUTS_LITERAL ("  ", stdout);                           \
 877       }                                                                 \
 878     while (0)
 879
 880 /* With --dired, store pairs of beginning and ending indices of filenames.  */
 881 static struct obstack dired_obstack;
 882
 883 /* With --dired, store pairs of beginning and ending indices of any
 884    directory names that appear as headers (just before `total' line)
 885    for lists of directory entries.  Such directory names are seen when
 886    listing hierarchies using -R and when a directory is listed with at
 887    least one other command line argument.  */
 888 static struct obstack subdired_obstack;
 889
 890 /* Save the current index on the specified obstack, OBS.  */
 891 #define PUSH_CURRENT_DIRED_POS(obs)                                     \
 892   do                                                                    \
 893     {                                                                   \
 894       if (dired)                                                        \
 895         obstack_grow ((obs), &dired_pos, sizeof (dired_pos));           \
 896     }                                                                   \
 897   while (0)
 898
 899 /* With -R, this stack is used to help detect directory cycles.
 900    The device/inode pairs on this stack mirror the pairs in the
 901    active_dir_set hash table.  */
 902 static struct obstack dev_ino_obstack;
 903
 904 /* Push a pair onto the device/inode stack.  */
 905 #define DEV_INO_PUSH(Dev, Ino)                                          \
 906   do                                                                    \
 907     {                                                                   \
 908       struct dev_ino *di;                                               \
 909       obstack_blank (&dev_ino_obstack, sizeof (struct dev_ino));        \
 910       di = -1 + (struct dev_ino *) obstack_next_free (&dev_ino_obstack); \
 911       di->st_dev = (Dev);                                               \
 912       di->st_ino = (Ino);                                               \
 913     }                                                                   \
 914   while (0)
 915
 916 /* Pop a dev/ino struct off the global dev_ino_obstack
 917    and return that struct.  */
 918 static struct dev_ino
 919 dev_ino_pop (void)
 920 {
 921   assert (sizeof (struct dev_ino) <= obstack_object_size (&dev_ino_obstack));
 922   obstack_blank (&dev_ino_obstack, -(int) (sizeof (struct dev_ino)));
 923   return *(struct dev_ino*) obstack_next_free (&dev_ino_obstack);
 924 }
 925
 926 #define ASSERT_MATCHING_DEV_INO(Name, Di)       \
 927   do                                            \
 928     {                                           \
 929       struct stat sb;                           \
 930       assert (Name);                            \
 931       assert (0 <= stat (Name, &sb));           \
 932       assert (sb.st_dev == Di.st_dev);          \
 933       assert (sb.st_ino == Di.st_ino);          \
 934     }                                           \
 935   while (0)
 936
 937
 938 /* Write to standard output PREFIX, followed by the quoting style and
 939    a space-separated list of the integers stored in OS all on one line.  */
 940
 941 static void
 942 dired_dump_obstack (const char *prefix, struct obstack *os)
 943 {
 944   size_t n_pos;
 945
 946   n_pos = obstack_object_size (os) / sizeof (dired_pos);
 947   if (n_pos > 0)
 948     {
 949       size_t i;
 950       size_t *pos;
 951
 952       pos = (size_t *) obstack_finish (os);
 953       fputs (prefix, stdout);
 954       for (i = 0; i < n_pos; i++)
 955         printf (" %lu", (unsigned long int) pos[i]);
 956       putchar ('\n');
 957     }
 958 }
 959
 960 static size_t
 961 dev_ino_hash (void const *x, size_t table_size)
 962 {
 963   struct dev_ino const *p = x;
 964   return (uintmax_t) p->st_ino % table_size;
 965 }
 966
 967 static bool
 968 dev_ino_compare (void const *x, void const *y)
 969 {
 970   struct dev_ino const *a = x;
 971   struct dev_ino const *b = y;
 972   return SAME_INODE (*a, *b) ? true : false;
 973 }
 974
 975 static void
 976 dev_ino_free (void *x)
 977 {
 978   free (x);
 979 }
 980
 981 /* Add the device/inode pair (P->st_dev/P->st_ino) to the set of
 982    active directories.  Return true if there is already a matching
 983    entry in the table.  */
 984
 985 static bool
 986 visit_dir (dev_t dev, ino_t ino)
 987 {
 988   struct dev_ino *ent;
 989   struct dev_ino *ent_from_table;
 990   bool found_match;
 991
 992   ent = xmalloc (sizeof *ent);
 993   ent->st_ino = ino;
 994   ent->st_dev = dev;
 995
 996   /* Attempt to insert this entry into the table.  */
 997   ent_from_table = hash_insert (active_dir_set, ent);
 998
 999   if (ent_from_table == NULL)
1000     {
1001       /* Insertion failed due to lack of memory.  */
1002       xalloc_die ();
1003     }
1004
1005   found_match = (ent_from_table != ent);
1006
1007   if (found_match)
1008     {
1009       /* ent was not inserted, so free it.  */
1010       free (ent);
1011     }
1012
1013   return found_match;
1014 }
1015
1016 static void
1017 free_pending_ent (struct pending *p)
1018 {
1019   free (p->name);
1020   free (p->realname);
1021   free (p);
1022 }
1023
1024 static bool
1025 is_colored (enum indicator_no type)
1026 {
1027   size_t len = color_indicator[type].len;
1028   char const *s = color_indicator[type].string;
1029   return ! (len == 0
1030             || (len == 1 && strncmp (s, "0", 1) == 0)
1031             || (len == 2 && strncmp (s, "00", 2) == 0));
1032 }
1033
1034 static void
1035 restore_default_color (void)
1036 {
1037   put_indicator (&color_indicator[C_LEFT]);
1038   put_indicator (&color_indicator[C_RIGHT]);
1039 }
1040
1041 /* An ordinary signal was received; arrange for the program to exit.  */
1042
1043 static void
1044 sighandler (int sig)
1045 {
1046   if (! SA_NOCLDSTOP)
1047     signal (sig, SIG_IGN);
1048   if (! interrupt_signal)
1049     interrupt_signal = sig;
1050 }
1051
1052 /* A SIGTSTP was received; arrange for the program to suspend itself.  */
1053
1054 static void
1055 stophandler (int sig)
1056 {
1057   if (! SA_NOCLDSTOP)
1058     signal (sig, stophandler);
1059   if (! interrupt_signal)
1060     stop_signal_count++;
1061 }
1062
1063 /* Process any pending signals.  If signals are caught, this function
1064    should be called periodically.  Ideally there should never be an
1065    unbounded amount of time when signals are not being processed.
1066    Signal handling can restore the default colors, so callers must
1067    immediately change colors after invoking this function.  */
1068
1069 static void
1070 process_signals (void)
1071 {
1072   while (interrupt_signal | stop_signal_count)
1073     {
1074       int sig;
1075       int stops;
1076       sigset_t oldset;
1077
1078       restore_default_color ();
1079       fflush (stdout);
1080
1081       sigprocmask (SIG_BLOCK, &caught_signals, &oldset);
1082
1083       /* Reload interrupt_signal and stop_signal_count, in case a new
1084          signal was handled before sigprocmask took effect.  */
1085       sig = interrupt_signal;
1086       stops = stop_signal_count;
1087
1088       /* SIGTSTP is special, since the application can receive that signal
1089          more than once.  In this case, don't set the signal handler to the
1090          default.  Instead, just raise the uncatchable SIGSTOP.  */
1091       if (stops)
1092         {
1093           stop_signal_count = stops - 1;
1094           sig = SIGSTOP;
1095         }
1096       else
1097         signal (sig, SIG_DFL);
1098
1099       /* Exit or suspend the program.  */
1100       raise (sig);
1101       sigprocmask (SIG_SETMASK, &oldset, NULL);
1102
1103       /* If execution reaches here, then the program has been
1104          continued (after being suspended).  */
1105     }
1106 }
1107
1108 int
1109 main (int argc, char **argv)
1110 {
1111   int i;
1112   struct pending *thispend;
1113   int n_files;
1114
1115   /* The signals that are trapped, and the number of such signals.  */
1116   static int const sig[] = { SIGHUP, SIGINT, SIGPIPE,
1117                              SIGQUIT, SIGTERM, SIGTSTP };
1118   enum { nsigs = sizeof sig / sizeof sig[0] };
1119
1120 #if ! SA_NOCLDSTOP
1121   bool caught_sig[nsigs];
1122 #endif
1123
1124   initialize_main (&argc, &argv);
1125   program_name = argv[0];
1126   setlocale (LC_ALL, "");
1127   bindtextdomain (PACKAGE, LOCALEDIR);
1128   textdomain (PACKAGE);
1129
1130   initialize_exit_failure (LS_FAILURE);
1131   atexit (close_stdout);
1132
1133 #define N_ENTRIES(Array) (sizeof Array / sizeof *(Array))
1134   assert (N_ENTRIES (color_indicator) + 1 == N_ENTRIES (indicator_name));
1135
1136   exit_status = EXIT_SUCCESS;
1137   print_dir_name = true;
1138   pending_dirs = NULL;
1139
1140   i = decode_switches (argc, argv);
1141
1142   if (print_with_color)
1143     parse_ls_color ();
1144
1145   /* Test print_with_color again, because the call to parse_ls_color
1146      may have just reset it -- e.g., if LS_COLORS is invalid.  */
1147   if (print_with_color)
1148     {
1149       /* Avoid following symbolic links when possible.  */
1150       if (is_colored (C_ORPHAN)
1151           || is_colored (C_EXEC)
1152           || (is_colored (C_MISSING) && format == long_format))
1153         check_symlink_color = true;
1154
1155       /* If the standard output is a controlling terminal, watch out
1156          for signals, so that the colors can be restored to the
1157          default state if "ls" is suspended or interrupted.  */
1158
1159       if (0 <= tcgetpgrp (STDOUT_FILENO))
1160         {
1161           int j;
1162 #if SA_NOCLDSTOP
1163           struct sigaction act;
1164
1165           sigemptyset (&caught_signals);
1166           for (j = 0; j < nsigs; j++)
1167             {
1168               sigaction (sig[j], NULL, &act);
1169               if (act.sa_handler != SIG_IGN)
1170                 sigaddset (&caught_signals, sig[j]);
1171             }
1172
1173           act.sa_mask = caught_signals;
1174           act.sa_flags = SA_RESTART;
1175
1176           for (j = 0; j < nsigs; j++)
1177             if (sigismember (&caught_signals, sig[j]))
1178               {
1179                 act.sa_handler = sig[j] == SIGTSTP ? stophandler : sighandler;
1180                 sigaction (sig[j], &act, NULL);
1181               }
1182 #else
1183           for (j = 0; j < nsigs; j++)
1184             {
1185               caught_sig[j] = (signal (sig[j], SIG_IGN) != SIG_IGN);
1186               if (caught_sig[j])
1187                 {
1188                   signal (sig[j], sig[j] == SIGTSTP ? stophandler : sighandler);
1189                   siginterrupt (sig[j], 0);
1190                 }
1191             }
1192 #endif
1193         }
1194
1195       prep_non_filename_text ();
1196     }
1197
1198   if (dereference == DEREF_UNDEFINED)
1199     dereference = ((immediate_dirs
1200                     || indicator_style == classify
1201                     || format == long_format)
1202                    ? DEREF_NEVER
1203                    : DEREF_COMMAND_LINE_SYMLINK_TO_DIR);
1204
1205   /* When using -R, initialize a data structure we'll use to
1206      detect any directory cycles.  */
1207   if (recursive)
1208     {
1209       active_dir_set = hash_initialize (INITIAL_TABLE_SIZE, NULL,
1210                                         dev_ino_hash,
1211                                         dev_ino_compare,
1212                                         dev_ino_free);
1213       if (active_dir_set == NULL)
1214         xalloc_die ();
1215
1216       obstack_init (&dev_ino_obstack);
1217     }
1218
1219   format_needs_stat = sort_type == sort_time || sort_type == sort_size
1220     || format == long_format
1221     || dereference == DEREF_ALWAYS
1222     || print_block_size || print_inode;
1223   format_needs_type = (!format_needs_stat
1224                        && (recursive || print_with_color
1225                            || indicator_style != none));
1226
1227   if (dired)
1228     {
1229       obstack_init (&dired_obstack);
1230       obstack_init (&subdired_obstack);
1231     }
1232
1233   nfiles = 100;
1234   files = xnmalloc (nfiles, sizeof *files);
1235   files_index = 0;
1236
1237   clear_files ();
1238
1239   n_files = argc - i;
1240
1241   if (n_files <= 0)
1242     {
1243       if (immediate_dirs)
1244         gobble_file (".", directory, true, "");
1245       else
1246         queue_directory (".", NULL, true);
1247     }
1248   else
1249     do
1250       gobble_file (argv[i++], unknown, true, "");
1251     while (i < argc);
1252
1253   if (files_index)
1254     {
1255       sort_files ();
1256       if (!immediate_dirs)
1257         extract_dirs_from_files (NULL, true);
1258       /* `files_index' might be zero now.  */
1259     }
1260
1261   /* In the following if/else blocks, it is sufficient to test `pending_dirs'
1262      (and not pending_dirs->name) because there may be no markers in the queue
1263      at this point.  A marker may be enqueued when extract_dirs_from_files is
1264      called with a non-empty string or via print_dir.  */
1265   if (files_index)
1266     {
1267       print_current_files ();
1268       if (pending_dirs)
1269         DIRED_PUTCHAR ('\n');
1270     }
1271   else if (n_files <= 1 && pending_dirs && pending_dirs->next == 0)
1272     print_dir_name = false;
1273
1274   while (pending_dirs)
1275     {
1276       thispend = pending_dirs;
1277       pending_dirs = pending_dirs->next;
1278
1279       if (LOOP_DETECT)
1280         {
1281           if (thispend->name == NULL)
1282             {
1283               /* thispend->name == NULL means this is a marker entry
1284                  indicating we've finished processing the directory.
1285                  Use its dev/ino numbers to remove the corresponding
1286                  entry from the active_dir_set hash table.  */
1287               struct dev_ino di = dev_ino_pop ();
1288               struct dev_ino *found = hash_delete (active_dir_set, &di);
1289               /* ASSERT_MATCHING_DEV_INO (thispend->realname, di); */
1290               assert (found);
1291               dev_ino_free (found);
1292               free_pending_ent (thispend);
1293               continue;
1294             }
1295         }
1296
1297       print_dir (thispend->name, thispend->realname,
1298                  thispend->command_line_arg);
1299
1300       free_pending_ent (thispend);
1301       print_dir_name = true;
1302     }
1303
1304   if (print_with_color)
1305     {
1306       int j;
1307
1308       restore_default_color ();
1309       fflush (stdout);
1310
1311       /* Restore the default signal handling.  */
1312 #if SA_NOCLDSTOP
1313       for (j = 0; j < nsigs; j++)
1314         if (sigismember (&caught_signals, sig[j]))
1315           signal (sig[j], SIG_DFL);
1316 #else
1317       for (j = 0; j < nsigs; j++)
1318         if (caught_sig[j])
1319           signal (sig[j], SIG_DFL);
1320 #endif
1321
1322       /* Act on any signals that arrived before the default was restored.
1323          This can process signals out of order, but there doesn't seem to
1324          be an easy way to do them in order, and the order isn't that
1325          important anyway.  */
1326       for (j = stop_signal_count; j; j--)
1327         raise (SIGSTOP);
1328       j = interrupt_signal;
1329       if (j)
1330         raise (j);
1331     }
1332
1333   if (dired)
1334     {
1335       /* No need to free these since we're about to exit.  */
1336       dired_dump_obstack ("//DIRED//", &dired_obstack);
1337       dired_dump_obstack ("//SUBDIRED//", &subdired_obstack);
1338       printf ("//DIRED-OPTIONS// --quoting-style=%s\n",
1339               quoting_style_args[get_quoting_style (filename_quoting_options)]);
1340     }
1341
1342   if (LOOP_DETECT)
1343     {
1344       assert (hash_get_n_entries (active_dir_set) == 0);
1345       hash_free (active_dir_set);
1346     }
1347
1348   exit (exit_status);
1349 }
1350
1351 /* Set all the option flags according to the switches specified.
1352    Return the index of the first non-option argument.  */
1353
1354 static int
1355 decode_switches (int argc, char **argv)
1356 {
1357   int c;
1358   char *time_style_option = NULL;
1359
1360   /* Record whether there is an option specifying sort type.  */
1361   bool sort_type_specified = false;
1362
1363   qmark_funny_chars = false;
1364
1365   /* initialize all switches to default settings */
1366
1367   switch (ls_mode)
1368     {
1369     case LS_MULTI_COL:
1370       /* This is for the `dir' program.  */
1371       format = many_per_line;
1372       set_quoting_style (NULL, escape_quoting_style);
1373       break;
1374
1375     case LS_LONG_FORMAT:
1376       /* This is for the `vdir' program.  */
1377       format = long_format;
1378       set_quoting_style (NULL, escape_quoting_style);
1379       break;
1380
1381     case LS_LS:
1382       /* This is for the `ls' program.  */
1383       if (isatty (STDOUT_FILENO))
1384         {
1385           format = many_per_line;
1386           /* See description of qmark_funny_chars, above.  */
1387           qmark_funny_chars = true;
1388         }
1389       else
1390         {
1391           format = one_per_line;
1392           qmark_funny_chars = false;
1393         }
1394       break;
1395
1396     default:
1397       abort ();
1398     }
1399
1400   time_type = time_mtime;
1401   sort_type = sort_name;
1402   sort_reverse = false;
1403   numeric_ids = false;
1404   print_block_size = false;
1405   indicator_style = none;
1406   print_inode = false;
1407   dereference = DEREF_UNDEFINED;
1408   recursive = false;
1409   immediate_dirs = false;
1410   ignore_mode = IGNORE_DEFAULT;
1411   ignore_patterns = NULL;
1412   hide_patterns = NULL;
1413
1414   /* FIXME: put this in a function.  */
1415   {
1416     char const *q_style = getenv ("QUOTING_STYLE");
1417     if (q_style)
1418       {
1419         int i = ARGMATCH (q_style, quoting_style_args, quoting_style_vals);
1420         if (0 <= i)
1421           set_quoting_style (NULL, quoting_style_vals[i]);
1422         else
1423           error (0, 0,
1424          _("ignoring invalid value of environment variable QUOTING_STYLE: %s"),
1425                  quotearg (q_style));
1426       }
1427   }
1428
1429   {
1430     char const *ls_block_size = getenv ("LS_BLOCK_SIZE");
1431     human_output_opts = human_options (ls_block_size, false,
1432                                        &output_block_size);
1433     if (ls_block_size || getenv ("BLOCK_SIZE"))
1434       file_output_block_size = output_block_size;
1435   }
1436
1437   line_length = 80;
1438   {
1439     char const *p = getenv ("COLUMNS");
1440     if (p && *p)
1441       {
1442         unsigned long int tmp_ulong;
1443         if (xstrtoul (p, NULL, 0, &tmp_ulong, NULL) == LONGINT_OK
1444             && 0 < tmp_ulong && tmp_ulong <= SIZE_MAX)
1445           {
1446             line_length = tmp_ulong;
1447           }
1448         else
1449           {
1450             error (0, 0,
1451                _("ignoring invalid width in environment variable COLUMNS: %s"),
1452                    quotearg (p));
1453           }
1454       }
1455   }
1456
1457 #ifdef TIOCGWINSZ
1458   {
1459     struct winsize ws;
1460
1461     if (ioctl (STDOUT_FILENO, TIOCGWINSZ, &ws) != -1
1462         && 0 < ws.ws_col && ws.ws_col == (size_t) ws.ws_col)
1463       line_length = ws.ws_col;
1464   }
1465 #endif
1466
1467   {
1468     char const *p = getenv ("TABSIZE");
1469     tabsize = 8;
1470     if (p)
1471       {
1472         unsigned long int tmp_ulong;
1473         if (xstrtoul (p, NULL, 0, &tmp_ulong, NULL) == LONGINT_OK
1474             && tmp_ulong <= SIZE_MAX)
1475           {
1476             tabsize = tmp_ulong;
1477           }
1478         else
1479           {
1480             error (0, 0,
1481              _("ignoring invalid tab size in environment variable TABSIZE: %s"),
1482                    quotearg (p));
1483           }
1484       }
1485   }
1486
1487   while ((c = getopt_long (argc, argv,
1488                            "abcdfghiklmnopqrstuvw:xABCDFGHI:LNQRST:UX1",
1489                            long_options, NULL)) != -1)
1490     {
1491       switch (c)
1492         {
1493         case 'a':
1494           ignore_mode = IGNORE_MINIMAL;
1495           break;
1496
1497         case 'b':
1498           set_quoting_style (NULL, escape_quoting_style);
1499           break;
1500
1501         case 'c':
1502           time_type = time_ctime;
1503           break;
1504
1505         case 'd':
1506           immediate_dirs = true;
1507           break;
1508
1509         case 'f':
1510           /* Same as enabling -a -U and disabling -l -s.  */
1511           ignore_mode = IGNORE_MINIMAL;
1512           sort_type = sort_none;
1513           sort_type_specified = true;
1514           /* disable -l */
1515           if (format == long_format)
1516             format = (isatty (STDOUT_FILENO) ? many_per_line : one_per_line);
1517           print_block_size = false;     /* disable -s */
1518           print_with_color = false;     /* disable --color */
1519           break;
1520
1521         case 'g':
1522           format = long_format;
1523           print_owner = false;
1524           break;
1525
1526         case 'h':
1527           human_output_opts = human_autoscale | human_SI | human_base_1024;
1528           file_output_block_size = output_block_size = 1;
1529           break;
1530
1531         case 'i':
1532           print_inode = true;
1533           break;
1534
1535         case 'k':
1536           human_output_opts = 0;
1537           file_output_block_size = output_block_size = 1024;
1538           break;
1539
1540         case 'l':
1541           format = long_format;
1542           break;
1543
1544         case 'm':
1545           format = with_commas;
1546           break;
1547
1548         case 'n':
1549           numeric_ids = true;
1550           format = long_format;
1551           break;
1552
1553         case 'o':  /* Just like -l, but don't display group info.  */
1554           format = long_format;
1555           print_group = false;
1556           break;
1557
1558         case 'p':
1559           indicator_style = slash;
1560           break;
1561
1562         case 'q':
1563           qmark_funny_chars = true;
1564           break;
1565
1566         case 'r':
1567           sort_reverse = true;
1568           break;
1569
1570         case 's':
1571           print_block_size = true;
1572           break;
1573
1574         case 't':
1575           sort_type = sort_time;
1576           sort_type_specified = true;
1577           break;
1578
1579         case 'u':
1580           time_type = time_atime;
1581           break;
1582
1583         case 'v':
1584           sort_type = sort_version;
1585           sort_type_specified = true;
1586           break;
1587
1588         case 'w':
1589           {
1590             unsigned long int tmp_ulong;
1591             if (xstrtoul (optarg, NULL, 0, &tmp_ulong, NULL) != LONGINT_OK
1592                 || ! (0 < tmp_ulong && tmp_ulong <= SIZE_MAX))
1593               error (LS_FAILURE, 0, _("invalid line width: %s"),
1594                      quotearg (optarg));
1595             line_length = tmp_ulong;
1596             break;
1597           }
1598
1599         case 'x':
1600           format = horizontal;
1601           break;
1602
1603         case 'A':
1604           if (ignore_mode == IGNORE_DEFAULT)
1605             ignore_mode = IGNORE_DOT_AND_DOTDOT;
1606           break;
1607
1608         case 'B':
1609           add_ignore_pattern ("*~");
1610           add_ignore_pattern (".*~");
1611           break;
1612
1613         case 'C':
1614           format = many_per_line;
1615           break;
1616
1617         case 'D':
1618           dired = true;
1619           break;
1620
1621         case 'F':
1622           indicator_style = classify;
1623           break;
1624
1625         case 'G':               /* inhibit display of group info */
1626           print_group = false;
1627           break;
1628
1629         case 'H':
1630           dereference = DEREF_COMMAND_LINE_ARGUMENTS;
1631           break;
1632
1633         case DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR_OPTION:
1634           dereference = DEREF_COMMAND_LINE_SYMLINK_TO_DIR;
1635           break;
1636
1637         case 'I':
1638           add_ignore_pattern (optarg);
1639           break;
1640
1641         case 'L':
1642           dereference = DEREF_ALWAYS;
1643           break;
1644
1645         case 'N':
1646           set_quoting_style (NULL, literal_quoting_style);
1647           break;
1648
1649         case 'Q':
1650           set_quoting_style (NULL, c_quoting_style);
1651           break;
1652
1653         case 'R':
1654           recursive = true;
1655           break;
1656
1657         case 'S':
1658           sort_type = sort_size;
1659           sort_type_specified = true;
1660           break;
1661
1662         case 'T':
1663           {
1664             unsigned long int tmp_ulong;
1665             if (xstrtoul (optarg, NULL, 0, &tmp_ulong, NULL) != LONGINT_OK
1666                 || SIZE_MAX < tmp_ulong)
1667               error (LS_FAILURE, 0, _("invalid tab size: %s"),
1668                      quotearg (optarg));
1669             tabsize = tmp_ulong;
1670             break;
1671           }
1672
1673         case 'U':
1674           sort_type = sort_none;
1675           sort_type_specified = true;
1676           break;
1677
1678         case 'X':
1679           sort_type = sort_extension;
1680           sort_type_specified = true;
1681           break;
1682
1683         case '1':
1684           /* -1 has no effect after -l.  */
1685           if (format != long_format)
1686             format = one_per_line;
1687           break;
1688
1689         case AUTHOR_OPTION:
1690           print_author = true;
1691           break;
1692
1693         case HIDE_OPTION:
1694           {
1695             struct ignore_pattern *hide = xmalloc (sizeof *hide);
1696             hide->pattern = optarg;
1697             hide->next = hide_patterns;
1698             hide_patterns = hide;
1699           }
1700           break;
1701
1702         case SORT_OPTION:
1703           sort_type = XARGMATCH ("--sort", optarg, sort_args, sort_types);
1704           sort_type_specified = true;
1705           break;
1706
1707         case TIME_OPTION:
1708           time_type = XARGMATCH ("--time", optarg, time_args, time_types);
1709           break;
1710
1711         case FORMAT_OPTION:
1712           format = XARGMATCH ("--format", optarg, format_args, format_types);
1713           break;
1714
1715         case FULL_TIME_OPTION:
1716           format = long_format;
1717           time_style_option = "full-iso";
1718           break;
1719
1720         case COLOR_OPTION:
1721           {
1722             int i;
1723             if (optarg)
1724               i = XARGMATCH ("--color", optarg, color_args, color_types);
1725             else
1726               /* Using --color with no argument is equivalent to using
1727                  --color=always.  */
1728               i = color_always;
1729
1730             print_with_color = (i == color_always
1731                                 || (i == color_if_tty
1732                                     && isatty (STDOUT_FILENO)));
1733
1734             if (print_with_color)
1735               {
1736                 /* Don't use TAB characters in output.  Some terminal
1737                    emulators can't handle the combination of tabs and
1738                    color codes on the same line.  */
1739                 tabsize = 0;
1740               }
1741             break;
1742           }
1743
1744         case INDICATOR_STYLE_OPTION:
1745           indicator_style = XARGMATCH ("--indicator-style", optarg,
1746                                        indicator_style_args,
1747                                        indicator_style_types);
1748           break;
1749
1750         case QUOTING_STYLE_OPTION:
1751           set_quoting_style (NULL,
1752                              XARGMATCH ("--quoting-style", optarg,
1753                                         quoting_style_args,
1754                                         quoting_style_vals));
1755           break;
1756
1757         case TIME_STYLE_OPTION:
1758           time_style_option = optarg;
1759           break;
1760
1761         case SHOW_CONTROL_CHARS_OPTION:
1762           qmark_funny_chars = false;
1763           break;
1764
1765         case BLOCK_SIZE_OPTION:
1766           human_output_opts = human_options (optarg, true, &output_block_size);
1767           file_output_block_size = output_block_size;
1768           break;
1769
1770         case SI_OPTION:
1771           human_output_opts = human_autoscale | human_SI;
1772           file_output_block_size = output_block_size = 1;
1773           break;
1774
1775         case_GETOPT_HELP_CHAR;
1776
1777         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1778
1779         default:
1780           usage (LS_FAILURE);
1781         }
1782     }
1783
1784   max_idx = MAX (1, line_length / MIN_COLUMN_WIDTH);
1785
1786   filename_quoting_options = clone_quoting_options (NULL);
1787   if (get_quoting_style (filename_quoting_options) == escape_quoting_style)
1788     set_char_quoting (filename_quoting_options, ' ', 1);
1789   if (file_type <= indicator_style)
1790     {
1791       char const *p;
1792       for (p = "*=>@|" + indicator_style - file_type; *p; p++)
1793         set_char_quoting (filename_quoting_options, *p, 1);
1794     }
1795
1796   dirname_quoting_options = clone_quoting_options (NULL);
1797   set_char_quoting (dirname_quoting_options, ':', 1);
1798
1799   /* --dired is meaningful only with --format=long (-l).
1800      Otherwise, ignore it.  FIXME: warn about this?
1801      Alternatively, make --dired imply --format=long?  */
1802   if (dired && format != long_format)
1803     dired = false;
1804
1805   /* If -c or -u is specified and not -l (or any other option that implies -l),
1806      and no sort-type was specified, then sort by the ctime (-c) or atime (-u).
1807      The behavior of ls when using either -c or -u but with neither -l nor -t
1808      appears to be unspecified by POSIX.  So, with GNU ls, `-u' alone means
1809      sort by atime (this is the one that's not specified by the POSIX spec),
1810      -lu means show atime and sort by name, -lut means show atime and sort
1811      by atime.  */
1812
1813   if ((time_type == time_ctime || time_type == time_atime)
1814       && !sort_type_specified && format != long_format)
1815     {
1816       sort_type = sort_time;
1817     }
1818
1819   if (format == long_format)
1820     {
1821       char *style = time_style_option;
1822       static char const posix_prefix[] = "posix-";
1823
1824       if (! style)
1825         if (! (style = getenv ("TIME_STYLE")))
1826           style = "posix-long-iso";
1827
1828       while (strncmp (style, posix_prefix, sizeof posix_prefix - 1) == 0)
1829         {
1830           if (! hard_locale (LC_TIME))
1831             return optind;
1832           style += sizeof posix_prefix - 1;
1833         }
1834
1835       if (*style == '+')
1836         {
1837           char *p0 = style + 1;
1838           char *p1 = strchr (p0, '\n');
1839           if (! p1)
1840             p1 = p0;
1841           else
1842             {
1843               if (strchr (p1 + 1, '\n'))
1844                 error (LS_FAILURE, 0, _("invalid time style format %s"),
1845                        quote (p0));
1846               *p1++ = '\0';
1847             }
1848           long_time_format[0] = p0;
1849           long_time_format[1] = p1;
1850         }
1851       else
1852         switch (XARGMATCH ("time style", style,
1853                            time_style_args,
1854                            time_style_types))
1855           {
1856           case full_iso_time_style:
1857             long_time_format[0] = long_time_format[1] =
1858               "%Y-%m-%d %H:%M:%S.%N %z";
1859             break;
1860
1861           case long_iso_time_style:
1862             long_time_format[0] = long_time_format[1] = "%Y-%m-%d %H:%M";
1863             break;
1864
1865           case iso_time_style:
1866             long_time_format[0] = "%Y-%m-%d ";
1867             long_time_format[1] = "%m-%d %H:%M";
1868             break;
1869
1870           case locale_time_style:
1871             if (hard_locale (LC_TIME))
1872               {
1873                 int i;
1874                 for (i = 0; i < 2; i++)
1875                   long_time_format[i] =
1876                     dcgettext (NULL, long_time_format[i], LC_TIME);
1877               }
1878           }
1879     }
1880
1881   return optind;
1882 }
1883
1884 /* Parse a string as part of the LS_COLORS variable; this may involve
1885    decoding all kinds of escape characters.  If equals_end is set an
1886    unescaped equal sign ends the string, otherwise only a : or \0
1887    does.  Set *OUTPUT_COUNT to the number of bytes output.  Return
1888    true if successful.
1889
1890    The resulting string is *not* null-terminated, but may contain
1891    embedded nulls.
1892
1893    Note that both dest and src are char **; on return they point to
1894    the first free byte after the array and the character that ended
1895    the input string, respectively.  */
1896
1897 static bool
1898 get_funky_string (char **dest, const char **src, bool equals_end,
1899                   size_t *output_count)
1900 {
1901   char num;                     /* For numerical codes */
1902   size_t count;                 /* Something to count with */
1903   enum {
1904     ST_GND, ST_BACKSLASH, ST_OCTAL, ST_HEX, ST_CARET, ST_END, ST_ERROR
1905   } state;
1906   const char *p;
1907   char *q;
1908
1909   p = *src;                     /* We don't want to double-indirect */
1910   q = *dest;                    /* the whole darn time.  */
1911
1912   count = 0;                    /* No characters counted in yet.  */
1913   num = 0;
1914
1915   state = ST_GND;               /* Start in ground state.  */
1916   while (state < ST_END)
1917     {
1918       switch (state)
1919         {
1920         case ST_GND:            /* Ground state (no escapes) */
1921           switch (*p)
1922             {
1923             case ':':
1924             case '\0':
1925               state = ST_END;   /* End of string */
1926               break;
1927             case '\\':
1928               state = ST_BACKSLASH; /* Backslash scape sequence */
1929               ++p;
1930               break;
1931             case '^':
1932               state = ST_CARET; /* Caret escape */
1933               ++p;
1934               break;
1935             case '=':
1936               if (equals_end)
1937                 {
1938                   state = ST_END; /* End */
1939                   break;
1940                 }
1941               /* else fall through */
1942             default:
1943               *(q++) = *(p++);
1944               ++count;
1945               break;
1946             }
1947           break;
1948
1949         case ST_BACKSLASH:      /* Backslash escaped character */
1950           switch (*p)
1951             {
1952             case '0':
1953             case '1':
1954             case '2':
1955             case '3':
1956             case '4':
1957             case '5':
1958             case '6':
1959             case '7':
1960               state = ST_OCTAL; /* Octal sequence */
1961               num = *p - '0';
1962               break;
1963             case 'x':
1964             case 'X':
1965               state = ST_HEX;   /* Hex sequence */
1966               num = 0;
1967               break;
1968             case 'a':           /* Bell */
1969               num = '\a';
1970               break;
1971             case 'b':           /* Backspace */
1972               num = '\b';
1973               break;
1974             case 'e':           /* Escape */
1975               num = 27;
1976               break;
1977             case 'f':           /* Form feed */
1978               num = '\f';
1979               break;
1980             case 'n':           /* Newline */
1981               num = '\n';
1982               break;
1983             case 'r':           /* Carriage return */
1984               num = '\r';
1985               break;
1986             case 't':           /* Tab */
1987               num = '\t';
1988               break;
1989             case 'v':           /* Vtab */
1990               num = '\v';
1991               break;
1992             case '?':           /* Delete */
1993               num = 127;
1994               break;
1995             case '_':           /* Space */
1996               num = ' ';
1997               break;
1998             case '\0':          /* End of string */
1999               state = ST_ERROR; /* Error! */
2000               break;
2001             default:            /* Escaped character like \ ^ : = */
2002               num = *p;
2003               break;
2004             }
2005           if (state == ST_BACKSLASH)
2006             {
2007               *(q++) = num;
2008               ++count;
2009               state = ST_GND;
2010             }
2011           ++p;
2012           break;
2013
2014         case ST_OCTAL:          /* Octal sequence */
2015           if (*p < '0' || *p > '7')
2016             {
2017               *(q++) = num;
2018               ++count;
2019               state = ST_GND;
2020             }
2021           else
2022             num = (num << 3) + (*(p++) - '0');
2023           break;
2024
2025         case ST_HEX:            /* Hex sequence */
2026           switch (*p)
2027             {
2028             case '0':
2029             case '1':
2030             case '2':
2031             case '3':
2032             case '4':
2033             case '5':
2034             case '6':
2035             case '7':
2036             case '8':
2037             case '9':
2038               num = (num << 4) + (*(p++) - '0');
2039               break;
2040             case 'a':
2041             case 'b':
2042             case 'c':
2043             case 'd':
2044             case 'e':
2045             case 'f':
2046               num = (num << 4) + (*(p++) - 'a') + 10;
2047               break;
2048             case 'A':
2049             case 'B':
2050             case 'C':
2051             case 'D':
2052             case 'E':
2053             case 'F':
2054               num = (num << 4) + (*(p++) - 'A') + 10;
2055               break;
2056             default:
2057               *(q++) = num;
2058               ++count;
2059               state = ST_GND;
2060               break;
2061             }
2062           break;
2063
2064         case ST_CARET:          /* Caret escape */
2065           state = ST_GND;       /* Should be the next state... */
2066           if (*p >= '@' && *p <= '~')
2067             {
2068               *(q++) = *(p++) & 037;
2069               ++count;
2070             }
2071           else if (*p == '?')
2072             {
2073               *(q++) = 127;
2074               ++count;
2075             }
2076           else
2077             state = ST_ERROR;
2078           break;
2079
2080         default:
2081           abort ();
2082         }
2083     }
2084
2085   *dest = q;
2086   *src = p;
2087   *output_count = count;
2088
2089   return state != ST_ERROR;
2090 }
2091
2092 static void
2093 parse_ls_color (void)
2094 {
2095   const char *p;                /* Pointer to character being parsed */
2096   char *buf;                    /* color_buf buffer pointer */
2097   int state;                    /* State of parser */
2098   int ind_no;                   /* Indicator number */
2099   char label[3];                /* Indicator label */
2100   struct color_ext_type *ext;   /* Extension we are working on */
2101
2102   if ((p = getenv ("LS_COLORS")) == NULL || *p == '\0')
2103     return;
2104
2105   ext = NULL;
2106   strcpy (label, "??");
2107
2108   /* This is an overly conservative estimate, but any possible
2109      LS_COLORS string will *not* generate a color_buf longer than
2110      itself, so it is a safe way of allocating a buffer in
2111      advance.  */
2112   buf = color_buf = xstrdup (p);
2113
2114   state = 1;
2115   while (state > 0)
2116     {
2117       switch (state)
2118         {
2119         case 1:         /* First label character */
2120           switch (*p)
2121             {
2122             case ':':
2123               ++p;
2124               break;
2125
2126             case '*':
2127               /* Allocate new extension block and add to head of
2128                  linked list (this way a later definition will
2129                  override an earlier one, which can be useful for
2130                  having terminal-specific defs override global).  */
2131
2132               ext = xmalloc (sizeof *ext);
2133               ext->next = color_ext_list;
2134               color_ext_list = ext;
2135
2136               ++p;
2137               ext->ext.string = buf;
2138
2139               state = (get_funky_string (&buf, &p, true, &ext->ext.len)
2140                        ? 4 : -1);
2141               break;
2142
2143             case '\0':
2144               state = 0;        /* Done! */
2145               break;
2146
2147             default:    /* Assume it is file type label */
2148               label[0] = *(p++);
2149               state = 2;
2150               break;
2151             }
2152           break;
2153
2154         case 2:         /* Second label character */
2155           if (*p)
2156             {
2157               label[1] = *(p++);
2158               state = 3;
2159             }
2160           else
2161             state = -1; /* Error */
2162           break;
2163
2164         case 3:         /* Equal sign after indicator label */
2165           state = -1;   /* Assume failure...  */
2166           if (*(p++) == '=')/* It *should* be...  */
2167             {
2168               for (ind_no = 0; indicator_name[ind_no] != NULL; ++ind_no)
2169                 {
2170                   if (STREQ (label, indicator_name[ind_no]))
2171                     {
2172                       color_indicator[ind_no].string = buf;
2173                       state = (get_funky_string (&buf, &p, false,
2174                                                  &color_indicator[ind_no].len)
2175                                ? 1 : -1);
2176                       break;
2177                     }
2178                 }
2179               if (state == -1)
2180                 error (0, 0, _("unrecognized prefix: %s"), quotearg (label));
2181             }
2182          break;
2183
2184         case 4:         /* Equal sign after *.ext */
2185           if (*(p++) == '=')
2186             {
2187               ext->seq.string = buf;
2188               state = (get_funky_string (&buf, &p, false, &ext->seq.len)
2189                        ? 1 : -1);
2190             }
2191           else
2192             state = -1;
2193           break;
2194         }
2195     }
2196
2197   if (state < 0)
2198     {
2199       struct color_ext_type *e;
2200       struct color_ext_type *e2;
2201
2202       error (0, 0,
2203              _("unparsable value for LS_COLORS environment variable"));
2204       free (color_buf);
2205       for (e = color_ext_list; e != NULL; /* empty */)
2206         {
2207           e2 = e;
2208           e = e->next;
2209           free (e2);
2210         }
2211       print_with_color = false;
2212     }
2213
2214   if (color_indicator[C_LINK].len == 6
2215       && !strncmp (color_indicator[C_LINK].string, "target", 6))
2216     color_symlink_as_referent = true;
2217 }
2218
2219 /* Set the exit status to report a failure.  If SERIOUS, it is a
2220    serious failure; otherwise, it is merely a minor problem.  */
2221
2222 static void
2223 set_exit_status (bool serious)
2224 {
2225   if (serious)
2226     exit_status = LS_FAILURE;
2227   else if (exit_status == EXIT_SUCCESS)
2228     exit_status = LS_MINOR_PROBLEM;
2229 }
2230
2231 /* Assuming a failure is serious if SERIOUS, use the printf-style
2232    MESSAGE to report the failure to access a file named FILE.  Assume
2233    errno is set appropriately for the failure.  */
2234
2235 static void
2236 file_failure (bool serious, char const *message, char const *file)
2237 {
2238   error (0, errno, message, quotearg_colon (file));
2239   set_exit_status (serious);
2240 }
2241
2242 /* Request that the directory named NAME have its contents listed later.
2243    If REALNAME is nonzero, it will be used instead of NAME when the
2244    directory name is printed.  This allows symbolic links to directories
2245    to be treated as regular directories but still be listed under their
2246    real names.  NAME == NULL is used to insert a marker entry for the
2247    directory named in REALNAME.
2248    If NAME is non-NULL, we use its dev/ino information to save
2249    a call to stat -- when doing a recursive (-R) traversal.
2250    COMMAND_LINE_ARG means this directory was mentioned on the command line.  */
2251
2252 static void
2253 queue_directory (char const *name, char const *realname, bool command_line_arg)
2254 {
2255   struct pending *new = xmalloc (sizeof *new);
2256   new->realname = realname ? xstrdup (realname) : NULL;
2257   new->name = name ? xstrdup (name) : NULL;
2258   new->command_line_arg = command_line_arg;
2259   new->next = pending_dirs;
2260   pending_dirs = new;
2261 }
2262
2263 /* Read directory NAME, and list the files in it.
2264    If REALNAME is nonzero, print its name instead of NAME;
2265    this is used for symbolic links to directories.
2266    COMMAND_LINE_ARG means this directory was mentioned on the command line.  */
2267
2268 static void
2269 print_dir (char const *name, char const *realname, bool command_line_arg)
2270 {
2271   DIR *dirp;
2272   struct dirent *next;
2273   uintmax_t total_blocks = 0;
2274   static bool first = true;
2275
2276   errno = 0;
2277   dirp = opendir (name);
2278   if (!dirp)
2279     {
2280       file_failure (command_line_arg, "%s", name);
2281       return;
2282     }
2283
2284   if (LOOP_DETECT)
2285     {
2286       struct stat dir_stat;
2287       int fd = dirfd (dirp);
2288
2289       /* If dirfd failed, endure the overhead of using stat.  */
2290       if ((0 <= fd
2291            ? fstat (fd, &dir_stat)
2292            : stat (name, &dir_stat)) < 0)
2293         {
2294           file_failure (command_line_arg,
2295                         _("cannot determine device and inode of %s"), name);
2296           return;
2297         }
2298
2299       /* If we've already visited this dev/inode pair, warn that
2300          we've found a loop, and do not process this directory.  */
2301       if (visit_dir (dir_stat.st_dev, dir_stat.st_ino))
2302         {
2303           error (0, 0, _("%s: not listing already-listed directory"),
2304                  quotearg_colon (name));
2305           return;
2306         }
2307
2308       DEV_INO_PUSH (dir_stat.st_dev, dir_stat.st_ino);
2309     }
2310
2311   /* Read the directory entries, and insert the subfiles into the `files'
2312      table.  */
2313
2314   clear_files ();
2315
2316   while (1)
2317     {
2318       /* Set errno to zero so we can distinguish between a readdir failure
2319          and when readdir simply finds that there are no more entries.  */
2320       errno = 0;
2321       next = readdir (dirp);
2322       if (next)
2323         {
2324           if (! file_ignored (next->d_name))
2325             {
2326               enum filetype type = unknown;
2327
2328 #if HAVE_STRUCT_DIRENT_D_TYPE
2329               if (next->d_type == DT_BLK
2330                   || next->d_type == DT_CHR
2331                   || next->d_type == DT_DIR
2332                   || next->d_type == DT_FIFO
2333                   || next->d_type == DT_LNK
2334                   || next->d_type == DT_REG
2335                   || next->d_type == DT_SOCK)
2336                 type = next->d_type;
2337 #endif
2338               total_blocks += gobble_file (next->d_name, type, false, name);
2339             }
2340         }
2341       else if (errno != 0)
2342         {
2343           file_failure (command_line_arg, _("reading directory %s"), name);
2344           if (errno != EOVERFLOW)
2345             break;
2346         }
2347       else
2348         break;
2349     }
2350
2351   if (CLOSEDIR (dirp) != 0)
2352     {
2353       file_failure (command_line_arg, _("closing directory %s"), name);
2354       /* Don't return; print whatever we got.  */
2355     }
2356
2357   /* Sort the directory contents.  */
2358   sort_files ();
2359
2360   /* If any member files are subdirectories, perhaps they should have their
2361      contents listed rather than being mentioned here as files.  */
2362
2363   if (recursive)
2364     extract_dirs_from_files (name, command_line_arg);
2365
2366   if (recursive | print_dir_name)
2367     {
2368       if (!first)
2369         DIRED_PUTCHAR ('\n');
2370       first = false;
2371       DIRED_INDENT ();
2372       PUSH_CURRENT_DIRED_POS (&subdired_obstack);
2373       dired_pos += quote_name (stdout, realname ? realname : name,
2374                                dirname_quoting_options, NULL);
2375       PUSH_CURRENT_DIRED_POS (&subdired_obstack);
2376       DIRED_FPUTS_LITERAL (":\n", stdout);
2377     }
2378
2379   if (format == long_format || print_block_size)
2380     {
2381       const char *p;
2382       char buf[LONGEST_HUMAN_READABLE + 1];
2383
2384       DIRED_INDENT ();
2385       p = _("total");
2386       DIRED_FPUTS (p, stdout, strlen (p));
2387       DIRED_PUTCHAR (' ');
2388       p = human_readable (total_blocks, buf, human_output_opts,
2389                           ST_NBLOCKSIZE, output_block_size);
2390       DIRED_FPUTS (p, stdout, strlen (p));
2391       DIRED_PUTCHAR ('\n');
2392     }
2393
2394   if (files_index)
2395     print_current_files ();
2396 }
2397
2398 /* Add `pattern' to the list of patterns for which files that match are
2399    not listed.  */
2400
2401 static void
2402 add_ignore_pattern (const char *pattern)
2403 {
2404   struct ignore_pattern *ignore;
2405
2406   ignore = xmalloc (sizeof *ignore);
2407   ignore->pattern = pattern;
2408   /* Add it to the head of the linked list.  */
2409   ignore->next = ignore_patterns;
2410   ignore_patterns = ignore;
2411 }
2412
2413 /* Return true if one of the PATTERNS matches FILE.  */
2414
2415 static bool
2416 patterns_match (struct ignore_pattern const *patterns, char const *file)
2417 {
2418   struct ignore_pattern const *p;
2419   for (p = patterns; p; p = p->next)
2420     if (fnmatch (p->pattern, file, FNM_PERIOD) == 0)
2421       return true;
2422   return false;
2423 }
2424
2425 /* Return true if FILE should be ignored.  */
2426
2427 static bool
2428 file_ignored (char const *name)
2429 {
2430   return ((ignore_mode != IGNORE_MINIMAL
2431            && name[0] == '.'
2432            && (ignore_mode == IGNORE_DEFAULT || ! name[1 + (name[1] == '.')]))
2433           || (ignore_mode == IGNORE_DEFAULT
2434               && patterns_match (hide_patterns, name))
2435           || patterns_match (ignore_patterns, name));
2436 }
2437
2438 /* POSIX requires that a file size be printed without a sign, even
2439    when negative.  Assume the typical case where negative sizes are
2440    actually positive values that have wrapped around.  */
2441
2442 static uintmax_t
2443 unsigned_file_size (off_t size)
2444 {
2445   return size + (size < 0) * ((uintmax_t) OFF_T_MAX - OFF_T_MIN + 1);
2446 }
2447
2448 /* Enter and remove entries in the table `files'.  */
2449
2450 /* Empty the table of files.  */
2451
2452 static void
2453 clear_files (void)
2454 {
2455   size_t i;
2456
2457   for (i = 0; i < files_index; i++)
2458     {
2459       free (files[i].name);
2460       free (files[i].linkname);
2461     }
2462
2463   files_index = 0;
2464 #if HAVE_ACL
2465   any_has_acl = false;
2466 #endif
2467   inode_number_width = 0;
2468   block_size_width = 0;
2469   nlink_width = 0;
2470   owner_width = 0;
2471   group_width = 0;
2472   author_width = 0;
2473   major_device_number_width = 0;
2474   minor_device_number_width = 0;
2475   file_size_width = 0;
2476 }
2477
2478 /* Add a file to the current table of files.
2479    Verify that the file exists, and print an error message if it does not.
2480    Return the number of blocks that the file occupies.  */
2481
2482 static uintmax_t
2483 gobble_file (char const *name, enum filetype type, bool command_line_arg,
2484              char const *dirname)
2485 {
2486   uintmax_t blocks;
2487   struct fileinfo *f;
2488
2489   if (files_index == nfiles)
2490     {
2491       files = xnrealloc (files, nfiles, 2 * sizeof *files);
2492       nfiles *= 2;
2493     }
2494
2495   f = &files[files_index];
2496   f->linkname = NULL;
2497   f->linkmode = 0;
2498   f->linkok = false;
2499
2500   if (command_line_arg
2501       || format_needs_stat
2502       || (format_needs_type
2503           && (type == unknown
2504
2505               /* FIXME: remove this disjunct.
2506                  I don't think we care about symlinks here, but for now
2507                  this won't make a big performance difference.  */
2508               || type == symbolic_link
2509
2510               /* --indicator-style=classify (aka -F)
2511                  requires that we stat each regular file
2512                  to see if it's executable.  */
2513               || (type == normal && (indicator_style == classify
2514                                      /* This is so that --color ends up
2515                                         highlighting files with the executable
2516                                         bit set even when options like -F are
2517                                         not specified.  */
2518                                      || (print_with_color
2519                                          && is_colored (C_EXEC))
2520                                      )))))
2521
2522     {
2523       /* Absolute name of this file.  */
2524       char *absolute_name;
2525
2526       int err;
2527
2528       if (name[0] == '/' || dirname[0] == 0)
2529         absolute_name = (char *) name;
2530       else
2531         {
2532           absolute_name = alloca (strlen (name) + strlen (dirname) + 2);
2533           attach (absolute_name, dirname, name);
2534         }
2535
2536       switch (dereference)
2537         {
2538         case DEREF_ALWAYS:
2539           err = stat (absolute_name, &f->stat);
2540           break;
2541
2542         case DEREF_COMMAND_LINE_ARGUMENTS:
2543         case DEREF_COMMAND_LINE_SYMLINK_TO_DIR:
2544           if (command_line_arg)
2545             {
2546               bool need_lstat;
2547               err = stat (absolute_name, &f->stat);
2548
2549               if (dereference == DEREF_COMMAND_LINE_ARGUMENTS)
2550                 break;
2551
2552               need_lstat = (err < 0
2553                             ? errno == ENOENT
2554                             : ! S_ISDIR (f->stat.st_mode));
2555               if (!need_lstat)
2556                 break;
2557
2558               /* stat failed because of ENOENT, maybe indicating a dangling
2559                  symlink.  Or stat succeeded, ABSOLUTE_NAME does not refer to a
2560                  directory, and --dereference-command-line-symlink-to-dir is
2561                  in effect.  Fall through so that we call lstat instead.  */
2562             }
2563
2564         default: /* DEREF_NEVER */
2565           err = lstat (absolute_name, &f->stat);
2566           break;
2567         }
2568
2569       if (err < 0)
2570         {
2571           file_failure (command_line_arg, "%s", absolute_name);
2572           return 0;
2573         }
2574
2575 #if HAVE_ACL
2576       if (format == long_format)
2577         {
2578           int n = file_has_acl (absolute_name, &f->stat);
2579           f->have_acl = (0 < n);
2580           any_has_acl |= f->have_acl;
2581           if (n < 0)
2582             error (0, errno, "%s", quotearg_colon (absolute_name));
2583         }
2584 #endif
2585
2586       if (S_ISLNK (f->stat.st_mode)
2587           && (format == long_format || check_symlink_color))
2588         {
2589           char *linkname;
2590           struct stat linkstats;
2591
2592           get_link_name (absolute_name, f, command_line_arg);
2593           linkname = make_link_name (absolute_name, f->linkname);
2594
2595           /* Avoid following symbolic links when possible, ie, when
2596              they won't be traced and when no indicator is needed.  */
2597           if (linkname
2598               && (file_type <= indicator_style || check_symlink_color)
2599               && stat (linkname, &linkstats) == 0)
2600             {
2601               f->linkok = true;
2602
2603               /* Symbolic links to directories that are mentioned on the
2604                  command line are automatically traced if not being
2605                  listed as files.  */
2606               if (!command_line_arg || format == long_format
2607                   || !S_ISDIR (linkstats.st_mode))
2608                 {
2609                   /* Get the linked-to file's mode for the filetype indicator
2610                      in long listings.  */
2611                   f->linkmode = linkstats.st_mode;
2612                   f->linkok = true;
2613                 }
2614             }
2615           free (linkname);
2616         }
2617
2618       if (S_ISLNK (f->stat.st_mode))
2619         f->filetype = symbolic_link;
2620       else if (S_ISDIR (f->stat.st_mode))
2621         {
2622           if (command_line_arg & !immediate_dirs)
2623             f->filetype = arg_directory;
2624           else
2625             f->filetype = directory;
2626         }
2627       else
2628         f->filetype = normal;
2629
2630       {
2631         char buf[INT_BUFSIZE_BOUND (uintmax_t)];
2632         int len = strlen (umaxtostr (f->stat.st_ino, buf));
2633         if (inode_number_width < len)
2634           inode_number_width = len;
2635       }
2636
2637       blocks = ST_NBLOCKS (f->stat);
2638       {
2639         char buf[LONGEST_HUMAN_READABLE + 1];
2640         int len = mbswidth (human_readable (blocks, buf, human_output_opts,
2641                                             ST_NBLOCKSIZE, output_block_size),
2642                             0);
2643         if (block_size_width < len)
2644           block_size_width = len;
2645       }
2646
2647       if (print_owner)
2648         {
2649           int len = format_user_width (f->stat.st_uid);
2650           if (owner_width < len)
2651             owner_width = len;
2652         }
2653
2654       if (print_group)
2655         {
2656           int len = format_group_width (f->stat.st_gid);
2657           if (group_width < len)
2658             group_width = len;
2659         }
2660
2661       if (print_author)
2662         {
2663           int len = format_user_width (f->stat.st_author);
2664           if (author_width < len)
2665             author_width = len;
2666         }
2667
2668       {
2669         char buf[INT_BUFSIZE_BOUND (uintmax_t)];
2670         int len = strlen (umaxtostr (f->stat.st_nlink, buf));
2671         if (nlink_width < len)
2672           nlink_width = len;
2673       }
2674
2675       if (S_ISCHR (f->stat.st_mode) || S_ISBLK (f->stat.st_mode))
2676         {
2677           char buf[INT_BUFSIZE_BOUND (uintmax_t)];
2678           int len = strlen (umaxtostr (major (f->stat.st_rdev), buf));
2679           if (major_device_number_width < len)
2680             major_device_number_width = len;
2681           len = strlen (umaxtostr (minor (f->stat.st_rdev), buf));
2682           if (minor_device_number_width < len)
2683             minor_device_number_width = len;
2684           len = major_device_number_width + 2 + minor_device_number_width;
2685           if (file_size_width < len)
2686             file_size_width = len;
2687         }
2688       else
2689         {
2690           char buf[LONGEST_HUMAN_READABLE + 1];
2691           uintmax_t size = unsigned_file_size (f->stat.st_size);
2692           int len = mbswidth (human_readable (size, buf, human_output_opts,
2693                                               1, file_output_block_size),
2694                               0);
2695           if (file_size_width < len)
2696             file_size_width = len;
2697         }
2698     }
2699   else
2700     {
2701       f->filetype = type;
2702 #if HAVE_STRUCT_DIRENT_D_TYPE
2703       f->stat.st_mode = DTTOIF (type);
2704 #endif
2705       blocks = 0;
2706     }
2707
2708   f->name = xstrdup (name);
2709   files_index++;
2710
2711   return blocks;
2712 }
2713
2714 #ifdef S_ISLNK
2715
2716 /* Put the name of the file that FILENAME is a symbolic link to
2717    into the LINKNAME field of `f'.  COMMAND_LINE_ARG indicates whether
2718    FILENAME is a command-line argument.  */
2719
2720 static void
2721 get_link_name (char const *filename, struct fileinfo *f, bool command_line_arg)
2722 {
2723   f->linkname = xreadlink (filename, f->stat.st_size);
2724   if (f->linkname == NULL)
2725     file_failure (command_line_arg, _("cannot read symbolic link %s"),
2726                   filename);
2727 }
2728
2729 /* If `linkname' is a relative name and `name' contains one or more
2730    leading directories, return `linkname' with those directories
2731    prepended; otherwise, return a copy of `linkname'.
2732    If `linkname' is zero, return zero.  */
2733
2734 static char *
2735 make_link_name (char const *name, char const *linkname)
2736 {
2737   char *linkbuf;
2738   size_t bufsiz;
2739
2740   if (!linkname)
2741     return NULL;
2742
2743   if (*linkname == '/')
2744     return xstrdup (linkname);
2745
2746   /* The link is to a relative name.  Prepend any leading directory
2747      in `name' to the link name.  */
2748   linkbuf = strrchr (name, '/');
2749   if (linkbuf == 0)
2750     return xstrdup (linkname);
2751
2752   bufsiz = linkbuf - name + 1;
2753   linkbuf = xmalloc (bufsiz + strlen (linkname) + 1);
2754   strncpy (linkbuf, name, bufsiz);
2755   strcpy (linkbuf + bufsiz, linkname);
2756   return linkbuf;
2757 }
2758 #endif
2759
2760 /* Return true if base_name (NAME) ends in `.' or `..'
2761    This is so we don't try to recurse on `././././. ...' */
2762
2763 static bool
2764 basename_is_dot_or_dotdot (const char *name)
2765 {
2766   char const *base = base_name (name);
2767   return DOT_OR_DOTDOT (base);
2768 }
2769
2770 /* Remove any entries from FILES that are for directories,
2771    and queue them to be listed as directories instead.
2772    DIRNAME is the prefix to prepend to each dirname
2773    to make it correct relative to ls's working dir;
2774    if it is null, no prefix is needed and "." and ".." should not be ignored.
2775    If COMMAND_LINE_ARG is true, this directory was mentioned at the top level,
2776    This is desirable when processing directories recursively.  */
2777
2778 static void
2779 extract_dirs_from_files (char const *dirname, bool command_line_arg)
2780 {
2781   size_t i;
2782   size_t j;
2783   bool ignore_dot_and_dot_dot = (dirname != NULL);
2784
2785   if (dirname && LOOP_DETECT)
2786     {
2787       /* Insert a marker entry first.  When we dequeue this marker entry,
2788          we'll know that DIRNAME has been processed and may be removed
2789          from the set of active directories.  */
2790       queue_directory (NULL, dirname, false);
2791     }
2792
2793   /* Queue the directories last one first, because queueing reverses the
2794      order.  */
2795   for (i = files_index; i-- != 0; )
2796     if ((files[i].filetype == directory || files[i].filetype == arg_directory)
2797         && (!ignore_dot_and_dot_dot
2798             || !basename_is_dot_or_dotdot (files[i].name)))
2799       {
2800         if (!dirname || files[i].name[0] == '/')
2801           {
2802             queue_directory (files[i].name, files[i].linkname,
2803                              command_line_arg);
2804           }
2805         else
2806           {
2807             char *name = file_name_concat (dirname, files[i].name, NULL);
2808             queue_directory (name, files[i].linkname, command_line_arg);
2809             free (name);
2810           }
2811         if (files[i].filetype == arg_directory)
2812           free (files[i].name);
2813       }
2814
2815   /* Now delete the directories from the table, compacting all the remaining
2816      entries.  */
2817
2818   for (i = 0, j = 0; i < files_index; i++)
2819     {
2820       if (files[i].filetype != arg_directory)
2821         {
2822           if (j < i)
2823             files[j] = files[i];
2824           ++j;
2825         }
2826     }
2827   files_index = j;
2828 }
2829
2830 /* Use strcoll to compare strings in this locale.  If an error occurs,
2831    report an error and longjmp to failed_strcoll.  */
2832
2833 static jmp_buf failed_strcoll;
2834
2835 static int
2836 xstrcoll (char const *a, char const *b)
2837 {
2838   int diff;
2839   errno = 0;
2840   diff = strcoll (a, b);
2841   if (errno)
2842     {
2843       error (0, errno, _("cannot compare file names %s and %s"),
2844              quote_n (0, a), quote_n (1, b));
2845       set_exit_status (false);
2846       longjmp (failed_strcoll, 1);
2847     }
2848   return diff;
2849 }
2850
2851 /* Comparison routines for sorting the files.  */
2852
2853 typedef void const *V;
2854
2855 static inline int
2856 cmp_ctime (struct fileinfo const *a, struct fileinfo const *b,
2857            int (*cmp) (char const *, char const *))
2858 {
2859   int diff = timespec_cmp (get_stat_ctime (&b->stat),
2860                            get_stat_ctime (&a->stat));
2861   return diff ? diff : cmp (a->name, b->name);
2862 }
2863 static int compare_ctime (V a, V b) { return cmp_ctime (a, b, xstrcoll); }
2864 static int compstr_ctime (V a, V b) { return cmp_ctime (a, b, strcmp); }
2865 static int rev_cmp_ctime (V a, V b) { return compare_ctime (b, a); }
2866 static int rev_str_ctime (V a, V b) { return compstr_ctime (b, a); }
2867
2868 static inline int
2869 cmp_mtime (struct fileinfo const *a, struct fileinfo const *b,
2870            int (*cmp) (char const *, char const *))
2871 {
2872   int diff = timespec_cmp (get_stat_mtime (&b->stat),
2873                            get_stat_mtime (&a->stat));
2874   return diff ? diff : cmp (a->name, b->name);
2875 }
2876 static int compare_mtime (V a, V b) { return cmp_mtime (a, b, xstrcoll); }
2877 static int compstr_mtime (V a, V b) { return cmp_mtime (a, b, strcmp); }
2878 static int rev_cmp_mtime (V a, V b) { return compare_mtime (b, a); }
2879 static int rev_str_mtime (V a, V b) { return compstr_mtime (b, a); }
2880
2881 static inline int
2882 cmp_atime (struct fileinfo const *a, struct fileinfo const *b,
2883            int (*cmp) (char const *, char const *))
2884 {
2885   int diff = timespec_cmp (get_stat_atime (&b->stat),
2886                            get_stat_atime (&a->stat));
2887   return diff ? diff : cmp (a->name, b->name);
2888 }
2889 static int compare_atime (V a, V b) { return cmp_atime (a, b, xstrcoll); }
2890 static int compstr_atime (V a, V b) { return cmp_atime (a, b, strcmp); }
2891 static int rev_cmp_atime (V a, V b) { return compare_atime (b, a); }
2892 static int rev_str_atime (V a, V b) { return compstr_atime (b, a); }
2893
2894 static inline int
2895 cmp_size (struct fileinfo const *a, struct fileinfo const *b,
2896           int (*cmp) (char const *, char const *))
2897 {
2898   int diff = longdiff (b->stat.st_size, a->stat.st_size);
2899   return diff ? diff : cmp (a->name, b->name);
2900 }
2901 static int compare_size (V a, V b) { return cmp_size (a, b, xstrcoll); }
2902 static int compstr_size (V a, V b) { return cmp_size (a, b, strcmp); }
2903 static int rev_cmp_size (V a, V b) { return compare_size (b, a); }
2904 static int rev_str_size (V a, V b) { return compstr_size (b, a); }
2905
2906 static inline int
2907 cmp_version (struct fileinfo const *a, struct fileinfo const *b)
2908 {
2909   return strverscmp (a->name, b->name);
2910 }
2911 static int compare_version (V a, V b) { return cmp_version (a, b); }
2912 static int rev_cmp_version (V a, V b) { return compare_version (b, a); }
2913
2914 static inline int
2915 cmp_name (struct fileinfo const *a, struct fileinfo const *b,
2916           int (*cmp) (char const *, char const *))
2917 {
2918   return cmp (a->name, b->name);
2919 }
2920 static int compare_name (V a, V b) { return cmp_name (a, b, xstrcoll); }
2921 static int compstr_name (V a, V b) { return cmp_name (a, b, strcmp); }
2922 static int rev_cmp_name (V a, V b) { return compare_name (b, a); }
2923 static int rev_str_name (V a, V b) { return compstr_name (b, a); }
2924
2925 /* Compare file extensions.  Files with no extension are `smallest'.
2926    If extensions are the same, compare by filenames instead.  */
2927
2928 static inline int
2929 cmp_extension (struct fileinfo const *a, struct fileinfo const *b,
2930                int (*cmp) (char const *, char const *))
2931 {
2932   char const *base1 = strrchr (a->name, '.');
2933   char const *base2 = strrchr (b->name, '.');
2934   int diff = cmp (base1 ? base1 : "", base2 ? base2 : "");
2935   return diff ? diff : cmp (a->name, b->name);
2936 }
2937 static int compare_extension (V a, V b) { return cmp_extension (a, b, xstrcoll); }
2938 static int compstr_extension (V a, V b) { return cmp_extension (a, b, strcmp); }
2939 static int rev_cmp_extension (V a, V b) { return compare_extension (b, a); }
2940 static int rev_str_extension (V a, V b) { return compstr_extension (b, a); }
2941
2942 /* Sort the files now in the table.  */
2943
2944 static void
2945 sort_files (void)
2946 {
2947   int (*func) (V, V);
2948
2949   /* Try strcoll.  If it fails, fall back on strcmp.  We can't safely
2950      ignore strcoll failures, as a failing strcoll might be a
2951      comparison function that is not a total order, and if we ignored
2952      the failure this might cause qsort to dump core.  */
2953
2954   if (! setjmp (failed_strcoll))
2955     {
2956       switch (sort_type)
2957         {
2958         case sort_none:
2959           return;
2960         case sort_time:
2961           switch (time_type)
2962             {
2963             case time_ctime:
2964               func = sort_reverse ? rev_cmp_ctime : compare_ctime;
2965               break;
2966             case time_mtime:
2967               func = sort_reverse ? rev_cmp_mtime : compare_mtime;
2968               break;
2969             case time_atime:
2970               func = sort_reverse ? rev_cmp_atime : compare_atime;
2971               break;
2972             default:
2973               abort ();
2974             }
2975           break;
2976         case sort_name:
2977           func = sort_reverse ? rev_cmp_name : compare_name;
2978           break;
2979         case sort_extension:
2980           func = sort_reverse ? rev_cmp_extension : compare_extension;
2981           break;
2982         case sort_size:
2983           func = sort_reverse ? rev_cmp_size : compare_size;
2984           break;
2985         case sort_version:
2986           func = sort_reverse ? rev_cmp_version : compare_version;
2987           break;
2988         default:
2989           abort ();
2990         }
2991     }
2992   else
2993     {
2994       switch (sort_type)
2995         {
2996         case sort_time:
2997           switch (time_type)
2998             {
2999             case time_ctime:
3000               func = sort_reverse ? rev_str_ctime : compstr_ctime;
3001               break;
3002             case time_mtime:
3003               func = sort_reverse ? rev_str_mtime : compstr_mtime;
3004               break;
3005             case time_atime:
3006               func = sort_reverse ? rev_str_atime : compstr_atime;
3007               break;
3008             default:
3009               abort ();
3010             }
3011           break;
3012         case sort_name:
3013           func = sort_reverse ? rev_str_name : compstr_name;
3014           break;
3015         case sort_extension:
3016           func = sort_reverse ? rev_str_extension : compstr_extension;
3017           break;
3018         case sort_size:
3019           func = sort_reverse ? rev_str_size : compstr_size;
3020           break;
3021         default:
3022           abort ();
3023         }
3024     }
3025
3026   qsort (files, files_index, sizeof *files, func);
3027 }
3028
3029 /* List all the files now in the table.  */
3030
3031 static void
3032 print_current_files (void)
3033 {
3034   size_t i;
3035
3036   switch (format)
3037     {
3038     case one_per_line:
3039       for (i = 0; i < files_index; i++)
3040         {
3041           print_file_name_and_frills (files + i);
3042           putchar ('\n');
3043         }
3044       break;
3045
3046     case many_per_line:
3047       print_many_per_line ();
3048       break;
3049
3050     case horizontal:
3051       print_horizontal ();
3052       break;
3053
3054     case with_commas:
3055       print_with_commas ();
3056       break;
3057
3058     case long_format:
3059       for (i = 0; i < files_index; i++)
3060         {
3061           print_long_format (files + i);
3062           DIRED_PUTCHAR ('\n');
3063         }
3064       break;
3065     }
3066 }
3067
3068 /* Return the expected number of columns in a long-format time stamp,
3069    or zero if it cannot be calculated.  */
3070
3071 static int
3072 long_time_expected_width (void)
3073 {
3074   static int width = -1;
3075
3076   if (width < 0)
3077     {
3078       time_t epoch = 0;
3079       struct tm const *tm = localtime (&epoch);
3080       char buf[TIME_STAMP_LEN_MAXIMUM + 1];
3081
3082       /* In case you're wondering if localtime can fail with an input time_t
3083          value of 0, let's just say it's very unlikely, but not inconceivable.
3084          The TZ environment variable would have to specify a time zone that
3085          is 2**31-1900 years or more ahead of UTC.  This could happen only on
3086          a 64-bit system that blindly accepts e.g., TZ=UTC+20000000000000.
3087          However, this is not possible with Solaris 10 or glibc-2.3.5, since
3088          their implementations limit the offset to 167:59 and 24:00, resp.  */
3089       if (tm)
3090         {
3091           size_t len =
3092             nstrftime (buf, sizeof buf, long_time_format[0], tm, 0, 0);
3093           if (len != 0)
3094             width = mbsnwidth (buf, len, 0);
3095         }
3096
3097       if (width < 0)
3098         width = 0;
3099     }
3100
3101   return width;
3102 }
3103
3104 /* Get the current time.  */
3105
3106 static void
3107 get_current_time (void)
3108 {
3109 #if HAVE_CLOCK_GETTIME && defined CLOCK_REALTIME
3110   {
3111     struct timespec timespec;
3112     if (clock_gettime (CLOCK_REALTIME, &timespec) == 0)
3113       {
3114         current_time = timespec.tv_sec;
3115         current_time_ns = timespec.tv_nsec;
3116         return;
3117       }
3118   }
3119 #endif
3120
3121   /* The clock does not have nanosecond resolution, so get the maximum
3122      possible value for the current time that is consistent with the
3123      reported clock.  That way, files are not considered to be in the
3124      future merely because their time stamps have higher resolution
3125      than the clock resolution.  */
3126
3127 #if HAVE_GETTIMEOFDAY
3128   {
3129     struct timeval timeval;
3130     gettimeofday (&timeval, NULL);
3131     current_time = timeval.tv_sec;
3132     current_time_ns = timeval.tv_usec * 1000 + 999;
3133   }
3134 #else
3135   current_time = time (NULL);
3136   current_time_ns = 999999999;
3137 #endif
3138 }
3139
3140 /* Print the user or group name NAME, with numeric id ID, using a
3141    print width of WIDTH columns.  */
3142
3143 static void
3144 format_user_or_group (char const *name, unsigned long int id, int width)
3145 {
3146   size_t len;
3147
3148   if (name)
3149     {
3150       int width_gap = width - mbswidth (name, 0);
3151       int pad = MAX (0, width_gap);
3152       fputs (name, stdout);
3153       len = strlen (name) + pad;
3154
3155       do
3156         putchar (' ');
3157       while (pad--);
3158     }
3159   else
3160     {
3161       printf ("%*lu ", width, id);
3162       len = width;
3163     }
3164
3165   dired_pos += len + 1;
3166 }
3167
3168 /* Print the name or id of the user with id U, using a print width of
3169    WIDTH.  */
3170
3171 static void
3172 format_user (uid_t u, int width)
3173 {
3174   format_user_or_group (numeric_ids ? NULL : getuser (u), u, width);
3175 }
3176
3177 /* Likewise, for groups.  */
3178
3179 static void
3180 format_group (gid_t g, int width)
3181 {
3182   format_user_or_group (numeric_ids ? NULL : getgroup (g), g, width);
3183 }
3184
3185 /* Return the number of columns that format_user_or_group will print.  */
3186
3187 static int
3188 format_user_or_group_width (char const *name, unsigned long int id)
3189 {
3190   if (name)
3191     {
3192       int len = mbswidth (name, 0);
3193       return MAX (0, len);
3194     }
3195   else
3196     {
3197       char buf[INT_BUFSIZE_BOUND (unsigned long int)];
3198       sprintf (buf, "%lu", id);
3199       return strlen (buf);
3200     }
3201 }
3202
3203 /* Return the number of columns that format_user will print.  */
3204
3205 static int
3206 format_user_width (uid_t u)
3207 {
3208   return format_user_or_group_width (numeric_ids ? NULL : getuser (u), u);
3209 }
3210
3211 /* Likewise, for groups.  */
3212
3213 static int
3214 format_group_width (gid_t g)
3215 {
3216   return format_user_or_group_width (numeric_ids ? NULL : getgroup (g), g);
3217 }
3218
3219
3220 /* Print information about F in long format.  */
3221
3222 static void
3223 print_long_format (const struct fileinfo *f)
3224 {
3225   char modebuf[12];
3226   char buf
3227     [LONGEST_HUMAN_READABLE + 1         /* inode */
3228      + LONGEST_HUMAN_READABLE + 1       /* size in blocks */
3229      + sizeof (modebuf) - 1 + 1         /* mode string */
3230      + INT_BUFSIZE_BOUND (uintmax_t)    /* st_nlink */
3231      + LONGEST_HUMAN_READABLE + 2       /* major device number */
3232      + LONGEST_HUMAN_READABLE + 1       /* minor device number */
3233      + TIME_STAMP_LEN_MAXIMUM + 1       /* max length of time/date */
3234      ];
3235   size_t s;
3236   char *p;
3237   time_t when;
3238   int when_ns;
3239   struct timespec when_timespec;
3240   struct tm *when_local;
3241
3242   /* Compute mode string.  On most systems, it's based on st_mode.
3243      On systems with migration (via the stat.st_dm_mode field), use
3244      the file's migrated status.  */
3245   mode_string (ST_DM_MODE (f->stat), modebuf);
3246
3247   modebuf[10] = (FILE_HAS_ACL (f) ? '+' : ' ');
3248   modebuf[10 + any_has_acl] = '\0';
3249
3250   switch (time_type)
3251     {
3252     case time_ctime:
3253       when_timespec = get_stat_ctime (&f->stat);
3254       break;
3255     case time_mtime:
3256       when_timespec = get_stat_mtime (&f->stat);
3257       break;
3258     case time_atime:
3259       when_timespec = get_stat_atime (&f->stat);
3260       break;
3261     }
3262
3263   when = when_timespec.tv_sec;
3264   when_ns = when_timespec.tv_nsec;
3265
3266   p = buf;
3267
3268   if (print_inode)
3269     {
3270       char hbuf[INT_BUFSIZE_BOUND (uintmax_t)];
3271       sprintf (p, "%*s ", inode_number_width,
3272                umaxtostr (f->stat.st_ino, hbuf));
3273       p += inode_number_width + 1;
3274     }
3275
3276   if (print_block_size)
3277     {
3278       char hbuf[LONGEST_HUMAN_READABLE + 1];
3279       char const *blocks =
3280         human_readable (ST_NBLOCKS (f->stat), hbuf, human_output_opts,
3281                         ST_NBLOCKSIZE, output_block_size);
3282       int pad;
3283       for (pad = block_size_width - mbswidth (blocks, 0); 0 < pad; pad--)
3284         *p++ = ' ';
3285       while ((*p++ = *blocks++))
3286         continue;
3287       p[-1] = ' ';
3288     }
3289
3290   /* The last byte of the mode string is the POSIX
3291      "optional alternate access method flag".  */
3292   {
3293     char hbuf[INT_BUFSIZE_BOUND (uintmax_t)];
3294     sprintf (p, "%s %*s ", modebuf, nlink_width,
3295              umaxtostr (f->stat.st_nlink, hbuf));
3296   }
3297   p += sizeof modebuf - 2 + any_has_acl + 1 + nlink_width + 1;
3298
3299   DIRED_INDENT ();
3300
3301   if (print_owner | print_group | print_author)
3302     {
3303       DIRED_FPUTS (buf, stdout, p - buf);
3304
3305       if (print_owner)
3306         format_user (f->stat.st_uid, owner_width);
3307
3308       if (print_group)
3309         format_group (f->stat.st_gid, group_width);
3310
3311       if (print_author)
3312         format_user (f->stat.st_author, author_width);
3313
3314       p = buf;
3315     }
3316
3317   if (S_ISCHR (f->stat.st_mode) || S_ISBLK (f->stat.st_mode))
3318     {
3319       char majorbuf[INT_BUFSIZE_BOUND (uintmax_t)];
3320       char minorbuf[INT_BUFSIZE_BOUND (uintmax_t)];
3321       int blanks_width = (file_size_width
3322                           - (major_device_number_width + 2
3323                              + minor_device_number_width));
3324       sprintf (p, "%*s, %*s ",
3325                major_device_number_width + MAX (0, blanks_width),
3326                umaxtostr (major (f->stat.st_rdev), majorbuf),
3327                minor_device_number_width,
3328                umaxtostr (minor (f->stat.st_rdev), minorbuf));
3329       p += file_size_width + 1;
3330     }
3331   else
3332     {
3333       char hbuf[LONGEST_HUMAN_READABLE + 1];
3334       char const *size =
3335         human_readable (unsigned_file_size (f->stat.st_size),
3336                         hbuf, human_output_opts, 1, file_output_block_size);
3337       int pad;
3338       for (pad = file_size_width - mbswidth (size, 0); 0 < pad; pad--)
3339         *p++ = ' ';
3340       while ((*p++ = *size++))
3341         continue;
3342       p[-1] = ' ';
3343     }
3344
3345   when_local = localtime (&when_timespec.tv_sec);
3346   s = 0;
3347   *p = '\1';
3348
3349   if (when_local)
3350     {
3351       time_t six_months_ago;
3352       bool recent;
3353       char const *fmt;
3354
3355       /* If the file appears to be in the future, update the current
3356          time, in case the file happens to have been modified since
3357          the last time we checked the clock.  */
3358       if (current_time < when
3359           || (current_time == when && current_time_ns < when_ns))
3360         {
3361           /* Note that get_current_time calls gettimeofday which, on some non-
3362              compliant systems, clobbers the buffer used for localtime's result.
3363              But it's ok here, because we use a gettimeofday wrapper that
3364              saves and restores the buffer around the gettimeofday call.  */
3365           get_current_time ();
3366         }
3367
3368       /* Consider a time to be recent if it is within the past six
3369          months.  A Gregorian year has 365.2425 * 24 * 60 * 60 ==
3370          31556952 seconds on the average.  Write this value as an
3371          integer constant to avoid floating point hassles.  */
3372       six_months_ago = current_time - 31556952 / 2;
3373       recent = (six_months_ago <= when
3374                 && (when < current_time
3375                     || (when == current_time && when_ns <= current_time_ns)));
3376       fmt = long_time_format[recent];
3377
3378       s = nstrftime (p, TIME_STAMP_LEN_MAXIMUM + 1, fmt,
3379                      when_local, 0, when_ns);
3380     }
3381
3382   if (s || !*p)
3383     {
3384       p += s;
3385       *p++ = ' ';
3386
3387       /* NUL-terminate the string -- fputs (via DIRED_FPUTS) requires it.  */
3388       *p = '\0';
3389     }
3390   else
3391     {
3392       /* The time cannot be converted using the desired format, so
3393          print it as a huge integer number of seconds.  */
3394       char hbuf[INT_BUFSIZE_BOUND (intmax_t)];
3395       sprintf (p, "%*s ", long_time_expected_width (),
3396                (TYPE_SIGNED (time_t)
3397                 ? imaxtostr (when, hbuf)
3398                 : umaxtostr (when, hbuf)));
3399       p += strlen (p);
3400     }
3401
3402   DIRED_FPUTS (buf, stdout, p - buf);
3403   print_name_with_quoting (f->name, FILE_OR_LINK_MODE (f), f->linkok,
3404                            &dired_obstack);
3405
3406   if (f->filetype == symbolic_link)
3407     {
3408       if (f->linkname)
3409         {
3410           DIRED_FPUTS_LITERAL (" -> ", stdout);
3411           print_name_with_quoting (f->linkname, f->linkmode, f->linkok - 1,
3412                                    NULL);
3413           if (indicator_style != none)
3414             print_type_indicator (f->linkmode);
3415         }
3416     }
3417   else if (indicator_style != none)
3418     print_type_indicator (f->stat.st_mode);
3419 }
3420
3421 /* Output to OUT a quoted representation of the file name NAME,
3422    using OPTIONS to control quoting.  Produce no output if OUT is NULL.
3423    Store the number of screen columns occupied by NAME's quoted
3424    representation into WIDTH, if non-NULL.  Return the number of bytes
3425    produced.  */
3426
3427 static size_t
3428 quote_name (FILE *out, const char *name, struct quoting_options const *options,
3429             size_t *width)
3430 {
3431   char smallbuf[BUFSIZ];
3432   size_t len = quotearg_buffer (smallbuf, sizeof smallbuf, name, -1, options);
3433   char *buf;
3434   size_t displayed_width IF_LINT (= 0);
3435
3436   if (len < sizeof smallbuf)
3437     buf = smallbuf;
3438   else
3439     {
3440       buf = alloca (len + 1);
3441       quotearg_buffer (buf, len + 1, name, -1, options);
3442     }
3443
3444   if (qmark_funny_chars)
3445     {
3446 #if HAVE_MBRTOWC
3447       if (MB_CUR_MAX > 1)
3448         {
3449           char const *p = buf;
3450           char const *plimit = buf + len;
3451           char *q = buf;
3452           displayed_width = 0;
3453
3454           while (p < plimit)
3455             switch (*p)
3456               {
3457                 case ' ': case '!': case '"': case '#': case '%':
3458                 case '&': case '\'': case '(': case ')': case '*':
3459                 case '+': case ',': case '-': case '.': case '/':
3460                 case '0': case '1': case '2': case '3': case '4':
3461                 case '5': case '6': case '7': case '8': case '9':
3462                 case ':': case ';': case '<': case '=': case '>':
3463                 case '?':
3464                 case 'A': case 'B': case 'C': case 'D': case 'E':
3465                 case 'F': case 'G': case 'H': case 'I': case 'J':
3466                 case 'K': case 'L': case 'M': case 'N': case 'O':
3467                 case 'P': case 'Q': case 'R': case 'S': case 'T':
3468                 case 'U': case 'V': case 'W': case 'X': case 'Y':
3469                 case 'Z':
3470                 case '[': case '\\': case ']': case '^': case '_':
3471                 case 'a': case 'b': case 'c': case 'd': case 'e':
3472                 case 'f': case 'g': case 'h': case 'i': case 'j':
3473                 case 'k': case 'l': case 'm': case 'n': case 'o':
3474                 case 'p': case 'q': case 'r': case 's': case 't':
3475                 case 'u': case 'v': case 'w': case 'x': case 'y':
3476                 case 'z': case '{': case '|': case '}': case '~':
3477                   /* These characters are printable ASCII characters.  */
3478                   *q++ = *p++;
3479                   displayed_width += 1;
3480                   break;
3481                 default:
3482                   /* If we have a multibyte sequence, copy it until we
3483                      reach its end, replacing each non-printable multibyte
3484                      character with a single question mark.  */
3485                   {
3486                     mbstate_t mbstate;
3487                     memset (&mbstate, 0, sizeof mbstate);
3488                     do
3489                       {
3490                         wchar_t wc;
3491                         size_t bytes;
3492                         int w;
3493
3494                         bytes = mbrtowc (&wc, p, plimit - p, &mbstate);
3495
3496                         if (bytes == (size_t) -1)
3497                           {
3498                             /* An invalid multibyte sequence was
3499                                encountered.  Skip one input byte, and
3500                                put a question mark.  */
3501                             p++;
3502                             *q++ = '?';
3503                             displayed_width += 1;
3504                             break;
3505                           }
3506
3507                         if (bytes == (size_t) -2)
3508                           {
3509                             /* An incomplete multibyte character
3510                                at the end.  Replace it entirely with
3511                                a question mark.  */
3512                             p = plimit;
3513                             *q++ = '?';
3514                             displayed_width += 1;
3515                             break;
3516                           }
3517
3518                         if (bytes == 0)
3519                           /* A null wide character was encountered.  */
3520                           bytes = 1;
3521
3522                         w = wcwidth (wc);
3523                         if (w >= 0)
3524                           {
3525                             /* A printable multibyte character.
3526                                Keep it.  */
3527                             for (; bytes > 0; --bytes)
3528                               *q++ = *p++;
3529                             displayed_width += w;
3530                           }
3531                         else
3532                           {
3533                             /* An unprintable multibyte character.
3534                                Replace it entirely with a question
3535                                mark.  */
3536                             p += bytes;
3537                             *q++ = '?';
3538                             displayed_width += 1;
3539                           }
3540                       }
3541                     while (! mbsinit (&mbstate));
3542                   }
3543                   break;
3544               }
3545
3546           /* The buffer may have shrunk.  */
3547           len = q - buf;
3548         }
3549       else
3550 #endif
3551         {
3552           char *p = buf;
3553           char const *plimit = buf + len;
3554
3555           while (p < plimit)
3556             {
3557               if (! ISPRINT (to_uchar (*p)))
3558                 *p = '?';
3559               p++;
3560             }
3561           displayed_width = len;
3562         }
3563     }
3564   else if (width != NULL)
3565     {
3566 #if HAVE_MBRTOWC
3567       if (MB_CUR_MAX > 1)
3568         displayed_width = mbsnwidth (buf, len, 0);
3569       else
3570 #endif
3571         {
3572           char const *p = buf;
3573           char const *plimit = buf + len;
3574
3575           displayed_width = 0;
3576           while (p < plimit)
3577             {
3578               if (ISPRINT (to_uchar (*p)))
3579                 displayed_width++;
3580               p++;
3581             }
3582         }
3583     }
3584
3585   if (out != NULL)
3586     fwrite (buf, 1, len, out);
3587   if (width != NULL)
3588     *width = displayed_width;
3589   return len;
3590 }
3591
3592 static void
3593 print_name_with_quoting (const char *p, mode_t mode, int linkok,
3594                          struct obstack *stack)
3595 {
3596   if (print_with_color)
3597     print_color_indicator (p, mode, linkok);
3598
3599   if (stack)
3600     PUSH_CURRENT_DIRED_POS (stack);
3601
3602   dired_pos += quote_name (stdout, p, filename_quoting_options, NULL);
3603
3604   if (stack)
3605     PUSH_CURRENT_DIRED_POS (stack);
3606
3607   if (print_with_color)
3608     {
3609       process_signals ();
3610       prep_non_filename_text ();
3611     }
3612 }
3613
3614 static void
3615 prep_non_filename_text (void)
3616 {
3617   if (color_indicator[C_END].string != NULL)
3618     put_indicator (&color_indicator[C_END]);
3619   else
3620     {
3621       put_indicator (&color_indicator[C_LEFT]);
3622       put_indicator (&color_indicator[C_NORM]);
3623       put_indicator (&color_indicator[C_RIGHT]);
3624     }
3625 }
3626
3627 /* Print the file name of `f' with appropriate quoting.
3628    Also print file size, inode number, and filetype indicator character,
3629    as requested by switches.  */
3630
3631 static void
3632 print_file_name_and_frills (const struct fileinfo *f)
3633 {
3634   char buf[MAX (LONGEST_HUMAN_READABLE + 1, INT_BUFSIZE_BOUND (uintmax_t))];
3635
3636   if (print_inode)
3637     printf ("%*s ", format == with_commas ? 0 : inode_number_width,
3638             umaxtostr (f->stat.st_ino, buf));
3639
3640   if (print_block_size)
3641     printf ("%*s ", format == with_commas ? 0 : block_size_width,
3642             human_readable (ST_NBLOCKS (f->stat), buf, human_output_opts,
3643                             ST_NBLOCKSIZE, output_block_size));
3644
3645   print_name_with_quoting (f->name, FILE_OR_LINK_MODE (f), f->linkok, NULL);
3646
3647   if (indicator_style != none)
3648     print_type_indicator (f->stat.st_mode);
3649 }
3650
3651 static void
3652 print_type_indicator (mode_t mode)
3653 {
3654   char c;
3655
3656   if (S_ISREG (mode))
3657     {
3658       if (indicator_style == classify && (mode & S_IXUGO))
3659         c = '*';
3660       else
3661         c = 0;
3662     }
3663   else
3664     {
3665       if (S_ISDIR (mode))
3666         c = '/';
3667       else if (indicator_style == slash)
3668         c = 0;
3669       else if (S_ISLNK (mode))
3670         c = '@';
3671       else if (S_ISFIFO (mode))
3672         c = '|';
3673       else if (S_ISSOCK (mode))
3674         c = '=';
3675       else if (S_ISDOOR (mode))
3676         c = '>';
3677       else
3678         c = 0;
3679     }
3680
3681   if (c)
3682     DIRED_PUTCHAR (c);
3683 }
3684
3685 static void
3686 print_color_indicator (const char *name, mode_t mode, int linkok)
3687 {
3688   int type = C_FILE;
3689   struct color_ext_type *ext;   /* Color extension */
3690   size_t len;                   /* Length of name */
3691
3692   /* Is this a nonexistent file?  If so, linkok == -1.  */
3693
3694   if (linkok == -1 && color_indicator[C_MISSING].string != NULL)
3695     {
3696       ext = NULL;
3697       type = C_MISSING;
3698     }
3699   else
3700     {
3701       if (S_ISDIR (mode))
3702         {
3703           if ((mode & S_ISVTX) && (mode & S_IWOTH))
3704             type = C_STICKY_OTHER_WRITABLE;
3705           else if ((mode & S_IWOTH) != 0)
3706             type = C_OTHER_WRITABLE;
3707           else if ((mode & S_ISVTX) != 0)
3708             type = C_STICKY;
3709           else
3710             type = C_DIR;
3711         }
3712       else if (S_ISLNK (mode))
3713         type = ((!linkok && color_indicator[C_ORPHAN].string)
3714                 ? C_ORPHAN : C_LINK);
3715       else if (S_ISFIFO (mode))
3716         type = C_FIFO;
3717       else if (S_ISSOCK (mode))
3718         type = C_SOCK;
3719       else if (S_ISBLK (mode))
3720         type = C_BLK;
3721       else if (S_ISCHR (mode))
3722         type = C_CHR;
3723       else if (S_ISDOOR (mode))
3724         type = C_DOOR;
3725
3726       if (type == C_FILE)
3727         {
3728           if ((mode & S_ISUID) != 0)
3729             type = C_SETUID;
3730           else if ((mode & S_ISGID) != 0)
3731             type = C_SETGID;
3732           else if ((mode & S_IXUGO) != 0)
3733             type = C_EXEC;
3734         }
3735
3736       /* Check the file's suffix only if still classified as C_FILE.  */
3737       ext = NULL;
3738       if (type == C_FILE)
3739         {
3740           /* Test if NAME has a recognized suffix.  */
3741
3742           len = strlen (name);
3743           name += len;          /* Pointer to final \0.  */
3744           for (ext = color_ext_list; ext != NULL; ext = ext->next)
3745             {
3746               if (ext->ext.len <= len
3747                   && strncmp (name - ext->ext.len, ext->ext.string,
3748                               ext->ext.len) == 0)
3749                 break;
3750             }
3751         }
3752     }
3753
3754   put_indicator (&color_indicator[C_LEFT]);
3755   put_indicator (ext ? &(ext->seq) : &color_indicator[type]);
3756   put_indicator (&color_indicator[C_RIGHT]);
3757 }
3758
3759 /* Output a color indicator (which may contain nulls).  */
3760 static void
3761 put_indicator (const struct bin_str *ind)
3762 {
3763   size_t i;
3764   const char *p;
3765
3766   p = ind->string;
3767
3768   for (i = ind->len; i != 0; --i)
3769     putchar (*(p++));
3770 }
3771
3772 static size_t
3773 length_of_file_name_and_frills (const struct fileinfo *f)
3774 {
3775   size_t len = 0;
3776   size_t name_width;
3777   char buf[MAX (LONGEST_HUMAN_READABLE + 1, INT_BUFSIZE_BOUND (uintmax_t))];
3778
3779   if (print_inode)
3780     len += 1 + (format == with_commas
3781                 ? strlen (umaxtostr (f->stat.st_ino, buf))
3782                 : inode_number_width);
3783
3784   if (print_block_size)
3785     len += 1 + (format == with_commas
3786                 ? strlen (human_readable (ST_NBLOCKS (f->stat), buf,
3787                                           human_output_opts, ST_NBLOCKSIZE,
3788                                           output_block_size))
3789                 : block_size_width);
3790
3791   quote_name (NULL, f->name, filename_quoting_options, &name_width);
3792   len += name_width;
3793
3794   if (indicator_style != none)
3795     {
3796       mode_t mode = f->stat.st_mode;
3797
3798       len += (S_ISREG (mode)
3799               ? (indicator_style == classify && (mode & S_IXUGO))
3800               : (S_ISDIR (mode)
3801                  || (indicator_style != slash
3802                      && (S_ISLNK (mode)
3803                          || S_ISFIFO (mode)
3804                          || S_ISSOCK (mode)
3805                          || S_ISDOOR (mode)))));
3806     }
3807
3808   return len;
3809 }
3810
3811 static void
3812 print_many_per_line (void)
3813 {
3814   size_t row;                   /* Current row.  */
3815   size_t cols = calculate_columns (true);
3816   struct column_info const *line_fmt = &column_info[cols - 1];
3817
3818   /* Calculate the number of rows that will be in each column except possibly
3819      for a short column on the right.  */
3820   size_t rows = files_index / cols + (files_index % cols != 0);
3821
3822   for (row = 0; row < rows; row++)
3823     {
3824       size_t col = 0;
3825       size_t filesno = row;
3826       size_t pos = 0;
3827
3828       /* Print the next row.  */
3829       while (1)
3830         {
3831           size_t name_length = length_of_file_name_and_frills (files + filesno);
3832           size_t max_name_length = line_fmt->col_arr[col++];
3833           print_file_name_and_frills (files + filesno);
3834
3835           filesno += rows;
3836           if (filesno >= files_index)
3837             break;
3838
3839           indent (pos + name_length, pos + max_name_length);
3840           pos += max_name_length;
3841         }
3842       putchar ('\n');
3843     }
3844 }
3845
3846 static void
3847 print_horizontal (void)
3848 {
3849   size_t filesno;
3850   size_t pos = 0;
3851   size_t cols = calculate_columns (false);
3852   struct column_info const *line_fmt = &column_info[cols - 1];
3853   size_t name_length = length_of_file_name_and_frills (files);
3854   size_t max_name_length = line_fmt->col_arr[0];
3855
3856   /* Print first entry.  */
3857   print_file_name_and_frills (files);
3858
3859   /* Now the rest.  */
3860   for (filesno = 1; filesno < files_index; ++filesno)
3861     {
3862       size_t col = filesno % cols;
3863
3864       if (col == 0)
3865         {
3866           putchar ('\n');
3867           pos = 0;
3868         }
3869       else
3870         {
3871           indent (pos + name_length, pos + max_name_length);
3872           pos += max_name_length;
3873         }
3874
3875       print_file_name_and_frills (files + filesno);
3876
3877       name_length = length_of_file_name_and_frills (files + filesno);
3878       max_name_length = line_fmt->col_arr[col];
3879     }
3880   putchar ('\n');
3881 }
3882
3883 static void
3884 print_with_commas (void)
3885 {
3886   size_t filesno;
3887   size_t pos = 0;
3888
3889   for (filesno = 0; filesno < files_index; filesno++)
3890     {
3891       size_t len = length_of_file_name_and_frills (files + filesno);
3892
3893       if (filesno != 0)
3894         {
3895           char separator;
3896
3897           if (pos + len + 2 < line_length)
3898             {
3899               pos += 2;
3900               separator = ' ';
3901             }
3902           else
3903             {
3904               pos = 0;
3905               separator = '\n';
3906             }
3907
3908           putchar (',');
3909           putchar (separator);
3910         }
3911
3912       print_file_name_and_frills (files + filesno);
3913       pos += len;
3914     }
3915   putchar ('\n');
3916 }
3917
3918 /* Assuming cursor is at position FROM, indent up to position TO.
3919    Use a TAB character instead of two or more spaces whenever possible.  */
3920
3921 static void
3922 indent (size_t from, size_t to)
3923 {
3924   while (from < to)
3925     {
3926       if (tabsize != 0 && to / tabsize > (from + 1) / tabsize)
3927         {
3928           putchar ('\t');
3929           from += tabsize - from % tabsize;
3930         }
3931       else
3932         {
3933           putchar (' ');
3934           from++;
3935         }
3936     }
3937 }
3938
3939 /* Put DIRNAME/NAME into DEST, handling `.' and `/' properly.  */
3940 /* FIXME: maybe remove this function someday.  See about using a
3941    non-malloc'ing version of file_name_concat.  */
3942
3943 static void
3944 attach (char *dest, const char *dirname, const char *name)
3945 {
3946   const char *dirnamep = dirname;
3947
3948   /* Copy dirname if it is not ".".  */
3949   if (dirname[0] != '.' || dirname[1] != 0)
3950     {
3951       while (*dirnamep)
3952         *dest++ = *dirnamep++;
3953       /* Add '/' if `dirname' doesn't already end with it.  */
3954       if (dirnamep > dirname && dirnamep[-1] != '/')
3955         *dest++ = '/';
3956     }
3957   while (*name)
3958     *dest++ = *name++;
3959   *dest = 0;
3960 }
3961
3962 /* Allocate enough column info suitable for the current number of
3963    files and display columns, and initialize the info to represent the
3964    narrowest possible columns.  */
3965
3966 static void
3967 init_column_info (void)
3968 {
3969   size_t i;
3970   size_t max_cols = MIN (max_idx, files_index);
3971
3972   /* Currently allocated columns in column_info.  */
3973   static size_t column_info_alloc;
3974
3975   if (column_info_alloc < max_cols)
3976     {
3977       size_t new_column_info_alloc;
3978       size_t *p;
3979
3980       if (max_cols < max_idx / 2)
3981         {
3982           /* The number of columns is far less than the display width
3983              allows.  Grow the allocation, but only so that it's
3984              double the current requirements.  If the display is
3985              extremely wide, this avoids allocating a lot of memory
3986              that is never needed.  */
3987           column_info = xnrealloc (column_info, max_cols,
3988                                    2 * sizeof *column_info);
3989           new_column_info_alloc = 2 * max_cols;
3990         }
3991       else
3992         {
3993           column_info = xnrealloc (column_info, max_idx, sizeof *column_info);
3994           new_column_info_alloc = max_idx;
3995         }
3996
3997       /* Allocate the new size_t objects by computing the triangle
3998          formula n * (n + 1) / 2, except that we don't need to
3999          allocate the part of the triangle that we've already
4000          allocated.  Check for address arithmetic overflow.  */
4001       {
4002         size_t column_info_growth = new_column_info_alloc - column_info_alloc;
4003         size_t s = column_info_alloc + 1 + new_column_info_alloc;
4004         size_t t = s * column_info_growth;
4005         if (s < new_column_info_alloc || t / column_info_growth != s)
4006           xalloc_die ();
4007         p = xnmalloc (t / 2, sizeof *p);
4008       }
4009
4010       /* Grow the triangle by parceling out the cells just allocated.  */
4011       for (i = column_info_alloc; i < new_column_info_alloc; i++)
4012         {
4013           column_info[i].col_arr = p;
4014           p += i + 1;
4015         }
4016
4017       column_info_alloc = new_column_info_alloc;
4018     }
4019
4020   for (i = 0; i < max_cols; ++i)
4021     {
4022       size_t j;
4023
4024       column_info[i].valid_len = true;
4025       column_info[i].line_len = (i + 1) * MIN_COLUMN_WIDTH;
4026       for (j = 0; j <= i; ++j)
4027         column_info[i].col_arr[j] = MIN_COLUMN_WIDTH;
4028     }
4029 }
4030
4031 /* Calculate the number of columns needed to represent the current set
4032    of files in the current display width.  */
4033
4034 static size_t
4035 calculate_columns (bool by_columns)
4036 {
4037   size_t filesno;               /* Index into files.  */
4038   size_t cols;                  /* Number of files across.  */
4039
4040   /* Normally the maximum number of columns is determined by the
4041      screen width.  But if few files are available this might limit it
4042      as well.  */
4043   size_t max_cols = MIN (max_idx, files_index);
4044
4045   init_column_info ();
4046
4047   /* Compute the maximum number of possible columns.  */
4048   for (filesno = 0; filesno < files_index; ++filesno)
4049     {
4050       size_t name_length = length_of_file_name_and_frills (files + filesno);
4051       size_t i;
4052
4053       for (i = 0; i < max_cols; ++i)
4054         {
4055           if (column_info[i].valid_len)
4056             {
4057               size_t idx = (by_columns
4058                             ? filesno / ((files_index + i) / (i + 1))
4059                             : filesno % (i + 1));
4060               size_t real_length = name_length + (idx == i ? 0 : 2);
4061
4062               if (column_info[i].col_arr[idx] < real_length)
4063                 {
4064                   column_info[i].line_len += (real_length
4065                                               - column_info[i].col_arr[idx]);
4066                   column_info[i].col_arr[idx] = real_length;
4067                   column_info[i].valid_len = (column_info[i].line_len
4068                                               < line_length);
4069                 }
4070             }
4071         }
4072     }
4073
4074   /* Find maximum allowed columns.  */
4075   for (cols = max_cols; 1 < cols; --cols)
4076     {
4077       if (column_info[cols - 1].valid_len)
4078         break;
4079     }
4080
4081   return cols;
4082 }
4083
4084 void
4085 usage (int status)
4086 {
4087   if (status != EXIT_SUCCESS)
4088     fprintf (stderr, _("Try `%s --help' for more information.\n"),
4089              program_name);
4090   else
4091     {
4092       printf (_("Usage: %s [OPTION]... [FILE]...\n"), program_name);
4093       fputs (_("\
4094 List information about the FILEs (the current directory by default).\n\
4095 Sort entries alphabetically if none of -cftuSUX nor --sort.\n\
4096 \n\
4097 "), stdout);
4098       fputs (_("\
4099 Mandatory arguments to long options are mandatory for short options too.\n\
4100 "), stdout);
4101       fputs (_("\
4102   -a, --all                  do not ignore entries starting with .\n\
4103   -A, --almost-all           do not list implied . and ..\n\
4104       --author               with -l, print the author of each file\n\
4105   -b, --escape               print octal escapes for nongraphic characters\n\
4106 "), stdout);
4107       fputs (_("\
4108       --block-size=SIZE      use SIZE-byte blocks\n\
4109   -B, --ignore-backups       do not list implied entries ending with ~\n\
4110   -c                         with -lt: sort by, and show, ctime (time of last\n\
4111                                modification of file status information)\n\
4112                                with -l: show ctime and sort by name\n\
4113                                otherwise: sort by ctime\n\
4114 "), stdout);
4115       fputs (_("\
4116   -C                         list entries by columns\n\
4117       --color[=WHEN]         control whether color is used to distinguish file\n\
4118                                types.  WHEN may be `never', `always', or `auto'\n\
4119   -d, --directory            list directory entries instead of contents,\n\
4120                                and do not dereference symbolic links\n\
4121   -D, --dired                generate output designed for Emacs' dired mode\n\
4122 "), stdout);
4123       fputs (_("\
4124   -f                         do not sort, enable -aU, disable -lst\n\
4125   -F, --classify             append indicator (one of */=>@|) to entries\n\
4126       --file-type            likewise, except do not append `*'\n\
4127       --format=WORD          across -x, commas -m, horizontal -x, long -l,\n\
4128                                single-column -1, verbose -l, vertical -C\n\
4129       --full-time            like -l --time-style=full-iso\n\
4130 "), stdout);
4131       fputs (_("\
4132   -g                         like -l, but do not list owner\n\
4133   -G, --no-group             like -l, but do not list group\n\
4134   -h, --human-readable       with -l, print sizes in human readable format\n\
4135                                (e.g., 1K 234M 2G)\n\
4136       --si                   likewise, but use powers of 1000 not 1024\n\
4137   -H, --dereference-command-line\n\
4138                              follow symbolic links listed on the command line\n\
4139       --dereference-command-line-symlink-to-dir\n\
4140                              follow each command line symbolic link\n\
4141                              that points to a directory\n\
4142       --hide=PATTERN         do not list implied entries matching shell PATTERN\n\
4143                                (overridden by -a or -A)\n\
4144 "), stdout);
4145       fputs (_("\
4146       --indicator-style=WORD append indicator with style WORD to entry names:\n\
4147                                none (default), slash (-p),\n\
4148                                file-type (--file-type), classify (-F)\n\
4149   -i, --inode                with -l, print the index number of each file\n\
4150   -I, --ignore=PATTERN       do not list implied entries matching shell PATTERN\n\
4151   -k                         like --block-size=1K\n\
4152 "), stdout);
4153       fputs (_("\
4154   -l                         use a long listing format\n\
4155   -L, --dereference          when showing file information for a symbolic\n\
4156                                link, show information for the file the link\n\
4157                                references rather than for the link itself\n\
4158   -m                         fill width with a comma separated list of entries\n\
4159 "), stdout);
4160       fputs (_("\
4161   -n, --numeric-uid-gid      like -l, but list numeric user and group IDs\n\
4162   -N, --literal              print raw entry names (don't treat e.g. control\n\
4163                                characters specially)\n\
4164   -o                         like -l, but do not list group information\n\
4165   -p, --indicator-style=slash\n\
4166                              append / indicator to directories\n\
4167 "), stdout);
4168       fputs (_("\
4169   -q, --hide-control-chars   print ? instead of non graphic characters\n\
4170       --show-control-chars   show non graphic characters as-is (default\n\
4171                              unless program is `ls' and output is a terminal)\n\
4172   -Q, --quote-name           enclose entry names in double quotes\n\
4173       --quoting-style=WORD   use quoting style WORD for entry names:\n\
4174                                literal, locale, shell, shell-always, c, escape\n\
4175 "), stdout);
4176       fputs (_("\
4177   -r, --reverse              reverse order while sorting\n\
4178   -R, --recursive            list subdirectories recursively\n\
4179   -s, --size                 with -l, print size of each file, in blocks\n\
4180 "), stdout);
4181       fputs (_("\
4182   -S                         sort by file size\n\
4183       --sort=WORD            extension -X, none -U, size -S, time -t,\n\
4184                              version -v, status -c, time -t, atime -u,\n\
4185                              access -u, use -u\n\
4186       --time=WORD            with -l, show time as WORD instead of modification\n\
4187                              time: atime, access, use, ctime or status; use\n\
4188                              specified time as sort key if --sort=time\n\
4189 "), stdout);
4190       fputs (_("\
4191       --time-style=STYLE     with -l, show times using style STYLE:\n\
4192                              full-iso, long-iso, iso, locale, +FORMAT.\n\
4193                              FORMAT is interpreted like `date'; if FORMAT is\n\
4194                              FORMAT1<newline>FORMAT2, FORMAT1 applies to\n\
4195                              non-recent files and FORMAT2 to recent files;\n\
4196                              if STYLE is prefixed with `posix-', STYLE\n\
4197                              takes effect only outside the POSIX locale\n\
4198   -t                         sort by modification time\n\
4199   -T, --tabsize=COLS         assume tab stops at each COLS instead of 8\n\
4200 "), stdout);
4201       fputs (_("\
4202   -u                         with -lt: sort by, and show, access time\n\
4203                                with -l: show access time and sort by name\n\
4204                                otherwise: sort by access time\n\
4205   -U                         do not sort; list entries in directory order\n\
4206   -v                         sort by version\n\
4207 "), stdout);
4208       fputs (_("\
4209   -w, --width=COLS           assume screen width instead of current value\n\
4210   -x                         list entries by lines instead of by columns\n\
4211   -X                         sort alphabetically by entry extension\n\
4212   -1                         list one file per line\n\
4213 "), stdout);
4214       fputs (HELP_OPTION_DESCRIPTION, stdout);
4215       fputs (VERSION_OPTION_DESCRIPTION, stdout);
4216       fputs (_("\n\
4217 SIZE may be (or may be an integer optionally followed by) one of following:\n\
4218 kB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.\n\
4219 "), stdout);
4220       fputs (_("\
4221 \n\
4222 By default, color is not used to distinguish types of files.  That is\n\
4223 equivalent to using --color=none.  Using the --color option without the\n\
4224 optional WHEN argument is equivalent to using --color=always.  With\n\
4225 --color=auto, color codes are output only if standard output is connected\n\
4226 to a terminal (tty).  The environment variable LS_COLORS can influence the\n\
4227 colors, and can be set easily by the dircolors command.\n\
4228 "), stdout);
4229       fputs (_("\
4230 \n\
4231 Exit status is 0 if OK, 1 if minor problems, 2 if serious trouble.\n\
4232 "), stdout);
4233       printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
4234     }
4235   exit (status);
4236 }