src/ls.c

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