src/ls.c

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