src/ls.c

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