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