Dogcows Code - chaz/tar/blob - src/tar.c

   1 /* A tar (tape archiver) program.
   2
   3    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000,
   4    2001, 2003, 2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
   5
   6    Written by John Gilmore, starting 1985-08-25.
   7
   8    This program is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by the
  10    Free Software Foundation; either version 3, or (at your option) any later
  11    version.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
  16    Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License along
  19    with this program; if not, write to the Free Software Foundation, Inc.,
  20    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  21
  22 #include <system.h>
  23
  24 #include <fnmatch.h>
  25 #include <argp.h>
  26 #include <argp-namefrob.h>
  27 #include <argp-fmtstream.h>
  28 #include <argp-version-etc.h>
  29
  30 #include <signal.h>
  31 #if ! defined SIGCHLD && defined SIGCLD
  32 # define SIGCHLD SIGCLD
  33 #endif
  34
  35 /* The following causes "common.h" to produce definitions of all the global
  36    variables, rather than just "extern" declarations of them.  GNU tar does
  37    depend on the system loader to preset all GLOBAL variables to neutral (or
  38    zero) values; explicit initialization is usually not done.  */
  39 #define GLOBAL
  40 #include "common.h"
  41
  42 #include <argmatch.h>
  43 #include <closeout.h>
  44 #include <configmake.h>
  45 #include <exitfail.h>
  46 #include <getdate.h>
  47 #include <rmt.h>
  48 #include <rmt-command.h>
  49 #include <prepargs.h>
  50 #include <quotearg.h>
  51 #include <version-etc.h>
  52 #include <xstrtol.h>
  53 #include <stdopen.h>
  54 #include <priv-set.h>
  55
  56 /* Local declarations.  */
  57
  58 #ifndef DEFAULT_ARCHIVE_FORMAT
  59 # define DEFAULT_ARCHIVE_FORMAT GNU_FORMAT
  60 #endif
  61
  62 #ifndef DEFAULT_ARCHIVE
  63 # define DEFAULT_ARCHIVE "tar.out"
  64 #endif
  65
  66 #ifndef DEFAULT_BLOCKING
  67 # define DEFAULT_BLOCKING 20
  68 #endif
  69
  70 \f
  71 /* Miscellaneous.  */
  72
  73 /* Name of option using stdin.  */
  74 static const char *stdin_used_by;
  75
  76 /* Doesn't return if stdin already requested.  */
  77 void
  78 request_stdin (const char *option)
  79 {
  80   if (stdin_used_by)
  81     USAGE_ERROR ((0, 0, _("Options `-%s' and `-%s' both want standard input"),
  82                   stdin_used_by, option));
  83
  84   stdin_used_by = option;
  85 }
  86
  87 extern int rpmatch (char const *response);
  88
  89 /* Returns true if and only if the user typed an affirmative response.  */
  90 int
  91 confirm (const char *message_action, const char *message_name)
  92 {
  93   static FILE *confirm_file;
  94   static int confirm_file_EOF;
  95   bool status = false;
  96
  97   if (!confirm_file)
  98     {
  99       if (archive == 0 || stdin_used_by)
 100         {
 101           confirm_file = fopen (TTY_NAME, "r");
 102           if (! confirm_file)
 103             open_fatal (TTY_NAME);
 104         }
 105       else
 106         {
 107           request_stdin ("-w");
 108           confirm_file = stdin;
 109         }
 110     }
 111
 112   fprintf (stdlis, "%s %s?", message_action, quote (message_name));
 113   fflush (stdlis);
 114
 115   if (!confirm_file_EOF)
 116     {
 117       char *response = NULL;
 118       size_t response_size = 0;
 119       if (getline (&response, &response_size, confirm_file) < 0)
 120         confirm_file_EOF = 1;
 121       else
 122         status = rpmatch (response) > 0;
 123       free (response);
 124     }
 125
 126   if (confirm_file_EOF)
 127     {
 128       fputc ('\n', stdlis);
 129       fflush (stdlis);
 130     }
 131
 132   return status;
 133 }
 134
 135 static struct fmttab {
 136   char const *name;
 137   enum archive_format fmt;
 138 } const fmttab[] = {
 139   { "v7",      V7_FORMAT },
 140   { "oldgnu",  OLDGNU_FORMAT },
 141   { "ustar",   USTAR_FORMAT },
 142   { "posix",   POSIX_FORMAT },
 143 #if 0 /* not fully supported yet */
 144   { "star",    STAR_FORMAT },
 145 #endif
 146   { "gnu",     GNU_FORMAT },
 147   { "pax",     POSIX_FORMAT }, /* An alias for posix */
 148   { NULL,      0 }
 149 };
 150
 151 static void
 152 set_archive_format (char const *name)
 153 {
 154   struct fmttab const *p;
 155
 156   for (p = fmttab; strcmp (p->name, name) != 0; )
 157     if (! (++p)->name)
 158       USAGE_ERROR ((0, 0, _("%s: Invalid archive format"),
 159                     quotearg_colon (name)));
 160
 161   archive_format = p->fmt;
 162 }
 163
 164 const char *
 165 archive_format_string (enum archive_format fmt)
 166 {
 167   struct fmttab const *p;
 168
 169   for (p = fmttab; p->name; p++)
 170     if (p->fmt == fmt)
 171       return p->name;
 172   return "unknown?";
 173 }
 174
 175 #define FORMAT_MASK(n) (1<<(n))
 176
 177 static void
 178 assert_format(unsigned fmt_mask)
 179 {
 180   if ((FORMAT_MASK (archive_format) & fmt_mask) == 0)
 181     USAGE_ERROR ((0, 0,
 182                   _("GNU features wanted on incompatible archive format")));
 183 }
 184
 185 const char *
 186 subcommand_string (enum subcommand c)
 187 {
 188   switch (c)
 189     {
 190     case UNKNOWN_SUBCOMMAND:
 191       return "unknown?";
 192
 193     case APPEND_SUBCOMMAND:
 194       return "-r";
 195
 196     case CAT_SUBCOMMAND:
 197       return "-A";
 198
 199     case CREATE_SUBCOMMAND:
 200       return "-c";
 201
 202     case DELETE_SUBCOMMAND:
 203       return "-D";
 204
 205     case DIFF_SUBCOMMAND:
 206       return "-d";
 207
 208     case EXTRACT_SUBCOMMAND:
 209       return "-x";
 210
 211     case LIST_SUBCOMMAND:
 212       return "-t";
 213
 214     case UPDATE_SUBCOMMAND:
 215       return "-u";
 216
 217     default:
 218       abort ();
 219     }
 220 }
 221
 222 void
 223 tar_list_quoting_styles (struct obstack *stk, char *prefix)
 224 {
 225   int i;
 226   size_t prefixlen = strlen (prefix);
 227
 228   for (i = 0; quoting_style_args[i]; i++)
 229     {
 230       obstack_grow (stk, prefix, prefixlen);
 231       obstack_grow (stk, quoting_style_args[i],
 232                     strlen (quoting_style_args[i]));
 233       obstack_1grow (stk, '\n');
 234     }
 235 }
 236
 237 void
 238 tar_set_quoting_style (char *arg)
 239 {
 240   int i;
 241
 242   for (i = 0; quoting_style_args[i]; i++)
 243     if (strcmp (arg, quoting_style_args[i]) == 0)
 244       {
 245         set_quoting_style (NULL, i);
 246         return;
 247       }
 248   FATAL_ERROR ((0, 0,
 249                 _("Unknown quoting style `%s'. Try `%s --quoting-style=help' to get a list."), arg, program_invocation_short_name));
 250 }
 251
 252 \f
 253 /* Options.  */
 254
 255 enum
 256 {
 257   ANCHORED_OPTION = CHAR_MAX + 1,
 258   ATIME_PRESERVE_OPTION,
 259   BACKUP_OPTION,
 260   CHECK_DEVICE_OPTION,
 261   CHECKPOINT_OPTION,
 262   CHECKPOINT_ACTION_OPTION,
 263   DELAY_DIRECTORY_RESTORE_OPTION,
 264   HARD_DEREFERENCE_OPTION,
 265   DELETE_OPTION,
 266   EXCLUDE_BACKUPS_OPTION,
 267   EXCLUDE_CACHES_OPTION,
 268   EXCLUDE_CACHES_UNDER_OPTION,
 269   EXCLUDE_CACHES_ALL_OPTION,
 270   EXCLUDE_OPTION,
 271   EXCLUDE_TAG_OPTION,
 272   EXCLUDE_TAG_UNDER_OPTION,
 273   EXCLUDE_TAG_ALL_OPTION,
 274   EXCLUDE_VCS_OPTION,
 275   FORCE_LOCAL_OPTION,
 276   GROUP_OPTION,
 277   IGNORE_CASE_OPTION,
 278   IGNORE_COMMAND_ERROR_OPTION,
 279   IGNORE_FAILED_READ_OPTION,
 280   INDEX_FILE_OPTION,
 281   KEEP_NEWER_FILES_OPTION,
 282   LEVEL_OPTION,
 283   LZMA_OPTION,
 284   LZOP_OPTION,
 285   MODE_OPTION,
 286   MTIME_OPTION,
 287   NEWER_MTIME_OPTION,
 288   NO_ANCHORED_OPTION,
 289   NO_AUTO_COMPRESS_OPTION,
 290   NO_CHECK_DEVICE_OPTION,
 291   NO_DELAY_DIRECTORY_RESTORE_OPTION,
 292   NO_IGNORE_CASE_OPTION,
 293   NO_IGNORE_COMMAND_ERROR_OPTION,
 294   NO_NULL_OPTION,
 295   NO_OVERWRITE_DIR_OPTION,
 296   NO_QUOTE_CHARS_OPTION,
 297   NO_RECURSION_OPTION,
 298   NO_SAME_OWNER_OPTION,
 299   NO_SAME_PERMISSIONS_OPTION,
 300   NO_SEEK_OPTION,
 301   NO_UNQUOTE_OPTION,
 302   NO_WILDCARDS_MATCH_SLASH_OPTION,
 303   NO_WILDCARDS_OPTION,
 304   NULL_OPTION,
 305   NUMERIC_OWNER_OPTION,
 306   OCCURRENCE_OPTION,
 307   OLD_ARCHIVE_OPTION,
 308   ONE_FILE_SYSTEM_OPTION,
 309   OVERWRITE_DIR_OPTION,
 310   OVERWRITE_OPTION,
 311   OWNER_OPTION,
 312   PAX_OPTION,
 313   POSIX_OPTION,
 314   PRESERVE_OPTION,
 315   QUOTE_CHARS_OPTION,
 316   QUOTING_STYLE_OPTION,
 317   RECORD_SIZE_OPTION,
 318   RECURSION_OPTION,
 319   RECURSIVE_UNLINK_OPTION,
 320   REMOVE_FILES_OPTION,
 321   RESTRICT_OPTION,
 322   RMT_COMMAND_OPTION,
 323   RSH_COMMAND_OPTION,
 324   SAME_OWNER_OPTION,
 325   SHOW_DEFAULTS_OPTION,
 326   SHOW_OMITTED_DIRS_OPTION,
 327   SHOW_TRANSFORMED_NAMES_OPTION,
 328   SPARSE_VERSION_OPTION,
 329   STRIP_COMPONENTS_OPTION,
 330   SUFFIX_OPTION,
 331   TEST_LABEL_OPTION,
 332   TOTALS_OPTION,
 333   TO_COMMAND_OPTION,
 334   TRANSFORM_OPTION,
 335   UNQUOTE_OPTION,
 336   UTC_OPTION,
 337   VOLNO_FILE_OPTION,
 338   WARNING_OPTION,
 339   WILDCARDS_MATCH_SLASH_OPTION,
 340   WILDCARDS_OPTION
 341 };
 342
 343 const char *argp_program_version = "tar (" PACKAGE_NAME ") " VERSION;
 344 const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">";
 345 static char const doc[] = N_("\
 346 GNU `tar' saves many files together into a single tape or disk archive, \
 347 and can restore individual files from the archive.\n\
 348 \n\
 349 Examples:\n\
 350   tar -cf archive.tar foo bar  # Create archive.tar from files foo and bar.\n\
 351   tar -tvf archive.tar         # List all files in archive.tar verbosely.\n\
 352   tar -xf archive.tar          # Extract all files from archive.tar.\n")
 353 "\v"
 354 N_("The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
 355 The version control may be set with --backup or VERSION_CONTROL, values are:\n\n\
 356   none, off       never make backups\n\
 357   t, numbered     make numbered backups\n\
 358   nil, existing   numbered if numbered backups exist, simple otherwise\n\
 359   never, simple   always make simple backups\n");
 360
 361
 362 /* NOTE:
 363
 364    Available option letters are DEQY and eqy. Consider the following
 365    assignments:
 366
 367    [For Solaris tar compatibility =/= Is it important at all?]
 368    e  exit immediately with a nonzero exit status if unexpected errors occur
 369    E  use extended headers (--format=posix)
 370
 371    [q  alias for --occurrence=1 =/= this would better be used for quiet?]
 372
 373    y  per-file gzip compression
 374    Y  per-block gzip compression.
 375
 376    Additionally, the 'n' letter is assigned for option --seek, which
 377    is probably not needed and should be marked as deprecated, so that
 378    -n may become available in the future.
 379 */
 380
 381 static struct argp_option options[] = {
 382 #define GRID 10
 383   {NULL, 0, NULL, 0,
 384    N_("Main operation mode:"), GRID },
 385
 386   {"list", 't', 0, 0,
 387    N_("list the contents of an archive"), GRID+1 },
 388   {"extract", 'x', 0, 0,
 389    N_("extract files from an archive"), GRID+1 },
 390   {"get", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 391   {"create", 'c', 0, 0,
 392    N_("create a new archive"), GRID+1 },
 393   {"diff", 'd', 0, 0,
 394    N_("find differences between archive and file system"), GRID+1 },
 395   {"compare", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 396   {"append", 'r', 0, 0,
 397    N_("append files to the end of an archive"), GRID+1 },
 398   {"update", 'u', 0, 0,
 399    N_("only append files newer than copy in archive"), GRID+1 },
 400   {"catenate", 'A', 0, 0,
 401    N_("append tar files to an archive"), GRID+1 },
 402   {"concatenate", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 403   {"delete", DELETE_OPTION, 0, 0,
 404    N_("delete from the archive (not on mag tapes!)"), GRID+1 },
 405   {"test-label", TEST_LABEL_OPTION, NULL, 0,
 406    N_("test the archive volume label and exit"), GRID+1 },
 407 #undef GRID
 408
 409 #define GRID 20
 410   {NULL, 0, NULL, 0,
 411    N_("Operation modifiers:"), GRID },
 412
 413   {"sparse", 'S', 0, 0,
 414    N_("handle sparse files efficiently"), GRID+1 },
 415   {"sparse-version", SPARSE_VERSION_OPTION, N_("MAJOR[.MINOR]"), 0,
 416    N_("set version of the sparse format to use (implies --sparse)"), GRID+1},
 417   {"incremental", 'G', 0, 0,
 418    N_("handle old GNU-format incremental backup"), GRID+1 },
 419   {"listed-incremental", 'g', N_("FILE"), 0,
 420    N_("handle new GNU-format incremental backup"), GRID+1 },
 421   {"level", LEVEL_OPTION, N_("NUMBER"), 0,
 422    N_("dump level for created listed-incremental archive"), GRID+1 },
 423   {"ignore-failed-read", IGNORE_FAILED_READ_OPTION, 0, 0,
 424    N_("do not exit with nonzero on unreadable files"), GRID+1 },
 425   {"occurrence", OCCURRENCE_OPTION, N_("NUMBER"), OPTION_ARG_OPTIONAL,
 426    N_("process only the NUMBERth occurrence of each file in the archive;"
 427       " this option is valid only in conjunction with one of the subcommands"
 428       " --delete, --diff, --extract or --list and when a list of files"
 429       " is given either on the command line or via the -T option;"
 430       " NUMBER defaults to 1"), GRID+1 },
 431   {"seek", 'n', NULL, 0,
 432    N_("archive is seekable"), GRID+1 },
 433   {"no-seek", NO_SEEK_OPTION, NULL, 0,
 434    N_("archive is not seekable"), GRID+1 },
 435   {"no-check-device", NO_CHECK_DEVICE_OPTION, NULL, 0,
 436    N_("do not check device numbers when creating incremental archives"),
 437    GRID+1 },
 438   {"check-device", CHECK_DEVICE_OPTION, NULL, 0,
 439    N_("check device numbers when creating incremental archives (default)"),
 440    GRID+1 },
 441 #undef GRID
 442
 443 #define GRID 30
 444   {NULL, 0, NULL, 0,
 445    N_("Overwrite control:"), GRID },
 446
 447   {"verify", 'W', 0, 0,
 448    N_("attempt to verify the archive after writing it"), GRID+1 },
 449   {"remove-files", REMOVE_FILES_OPTION, 0, 0,
 450    N_("remove files after adding them to the archive"), GRID+1 },
 451   {"keep-old-files", 'k', 0, 0,
 452    N_("don't replace existing files when extracting"), GRID+1 },
 453   {"keep-newer-files", KEEP_NEWER_FILES_OPTION, 0, 0,
 454    N_("don't replace existing files that are newer than their archive copies"), GRID+1 },
 455   {"overwrite", OVERWRITE_OPTION, 0, 0,
 456    N_("overwrite existing files when extracting"), GRID+1 },
 457   {"unlink-first", 'U', 0, 0,
 458    N_("remove each file prior to extracting over it"), GRID+1 },
 459   {"recursive-unlink", RECURSIVE_UNLINK_OPTION, 0, 0,
 460    N_("empty hierarchies prior to extracting directory"), GRID+1 },
 461   {"no-overwrite-dir", NO_OVERWRITE_DIR_OPTION, 0, 0,
 462    N_("preserve metadata of existing directories"), GRID+1 },
 463   {"overwrite-dir", OVERWRITE_DIR_OPTION, 0, 0,
 464    N_("overwrite metadata of existing directories when extracting (default)"),
 465    GRID+1 },
 466 #undef GRID
 467
 468 #define GRID 40
 469   {NULL, 0, NULL, 0,
 470    N_("Select output stream:"), GRID },
 471
 472   {"to-stdout", 'O', 0, 0,
 473    N_("extract files to standard output"), GRID+1 },
 474   {"to-command", TO_COMMAND_OPTION, N_("COMMAND"), 0,
 475    N_("pipe extracted files to another program"), GRID+1 },
 476   {"ignore-command-error", IGNORE_COMMAND_ERROR_OPTION, 0, 0,
 477    N_("ignore exit codes of children"), GRID+1 },
 478   {"no-ignore-command-error", NO_IGNORE_COMMAND_ERROR_OPTION, 0, 0,
 479    N_("treat non-zero exit codes of children as error"), GRID+1 },
 480 #undef GRID
 481
 482 #define GRID 50
 483   {NULL, 0, NULL, 0,
 484    N_("Handling of file attributes:"), GRID },
 485
 486   {"owner", OWNER_OPTION, N_("NAME"), 0,
 487    N_("force NAME as owner for added files"), GRID+1 },
 488   {"group", GROUP_OPTION, N_("NAME"), 0,
 489    N_("force NAME as group for added files"), GRID+1 },
 490   {"mtime", MTIME_OPTION, N_("DATE-OR-FILE"), 0,
 491    N_("set mtime for added files from DATE-OR-FILE"), GRID+1 },
 492   {"mode", MODE_OPTION, N_("CHANGES"), 0,
 493    N_("force (symbolic) mode CHANGES for added files"), GRID+1 },
 494   {"atime-preserve", ATIME_PRESERVE_OPTION,
 495    N_("METHOD"), OPTION_ARG_OPTIONAL,
 496    N_("preserve access times on dumped files, either by restoring the times"
 497       " after reading (METHOD='replace'; default) or by not setting the times"
 498       " in the first place (METHOD='system')"), GRID+1 },
 499   {"touch", 'm', 0, 0,
 500    N_("don't extract file modified time"), GRID+1 },
 501   {"same-owner", SAME_OWNER_OPTION, 0, 0,
 502    N_("try extracting files with the same ownership as exists in the archive (default for superuser)"), GRID+1 },
 503   {"no-same-owner", NO_SAME_OWNER_OPTION, 0, 0,
 504    N_("extract files as yourself (default for ordinary users)"), GRID+1 },
 505   {"numeric-owner", NUMERIC_OWNER_OPTION, 0, 0,
 506    N_("always use numbers for user/group names"), GRID+1 },
 507   {"preserve-permissions", 'p', 0, 0,
 508    N_("extract information about file permissions (default for superuser)"),
 509    GRID+1 },
 510   {"same-permissions", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 511   {"no-same-permissions", NO_SAME_PERMISSIONS_OPTION, 0, 0,
 512    N_("apply the user's umask when extracting permissions from the archive (default for ordinary users)"), GRID+1 },
 513   {"preserve-order", 's', 0, 0,
 514    N_("sort names to extract to match archive"), GRID+1 },
 515   {"same-order", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 516   {"preserve", PRESERVE_OPTION, 0, 0,
 517    N_("same as both -p and -s"), GRID+1 },
 518   {"delay-directory-restore", DELAY_DIRECTORY_RESTORE_OPTION, 0, 0,
 519    N_("delay setting modification times and permissions of extracted"
 520       " directories until the end of extraction"), GRID+1 },
 521   {"no-delay-directory-restore", NO_DELAY_DIRECTORY_RESTORE_OPTION, 0, 0,
 522    N_("cancel the effect of --delay-directory-restore option"), GRID+1 },
 523 #undef GRID
 524
 525 #define GRID 60
 526   {NULL, 0, NULL, 0,
 527    N_("Device selection and switching:"), GRID },
 528
 529   {"file", 'f', N_("ARCHIVE"), 0,
 530    N_("use archive file or device ARCHIVE"), GRID+1 },
 531   {"force-local", FORCE_LOCAL_OPTION, 0, 0,
 532    N_("archive file is local even if it has a colon"), GRID+1 },
 533   {"rmt-command", RMT_COMMAND_OPTION, N_("COMMAND"), 0,
 534    N_("use given rmt COMMAND instead of rmt"), GRID+1 },
 535   {"rsh-command", RSH_COMMAND_OPTION, N_("COMMAND"), 0,
 536    N_("use remote COMMAND instead of rsh"), GRID+1 },
 537 #ifdef DEVICE_PREFIX
 538   {"-[0-7][lmh]", 0, NULL, OPTION_DOC, /* It is OK, since `name' will never be
 539                                           translated */
 540    N_("specify drive and density"), GRID+1 },
 541 #endif
 542   {NULL, '0', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 543   {NULL, '1', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 544   {NULL, '2', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 545   {NULL, '3', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 546   {NULL, '4', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 547   {NULL, '5', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 548   {NULL, '6', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 549   {NULL, '7', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 550   {NULL, '8', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 551   {NULL, '9', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 552
 553   {"multi-volume", 'M', 0, 0,
 554    N_("create/list/extract multi-volume archive"), GRID+1 },
 555   {"tape-length", 'L', N_("NUMBER"), 0,
 556    N_("change tape after writing NUMBER x 1024 bytes"), GRID+1 },
 557   {"info-script", 'F', N_("NAME"), 0,
 558    N_("run script at end of each tape (implies -M)"), GRID+1 },
 559   {"new-volume-script", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 560   {"volno-file", VOLNO_FILE_OPTION, N_("FILE"), 0,
 561    N_("use/update the volume number in FILE"), GRID+1 },
 562 #undef GRID
 563
 564 #define GRID 70
 565   {NULL, 0, NULL, 0,
 566    N_("Device blocking:"), GRID },
 567
 568   {"blocking-factor", 'b', N_("BLOCKS"), 0,
 569    N_("BLOCKS x 512 bytes per record"), GRID+1 },
 570   {"record-size", RECORD_SIZE_OPTION, N_("NUMBER"), 0,
 571    N_("NUMBER of bytes per record, multiple of 512"), GRID+1 },
 572   {"ignore-zeros", 'i', 0, 0,
 573    N_("ignore zeroed blocks in archive (means EOF)"), GRID+1 },
 574   {"read-full-records", 'B', 0, 0,
 575    N_("reblock as we read (for 4.2BSD pipes)"), GRID+1 },
 576 #undef GRID
 577
 578 #define GRID 80
 579   {NULL, 0, NULL, 0,
 580    N_("Archive format selection:"), GRID },
 581
 582   {"format", 'H', N_("FORMAT"), 0,
 583    N_("create archive of the given format"), GRID+1 },
 584
 585   {NULL, 0, NULL, 0, N_("FORMAT is one of the following:"), GRID+2 },
 586   {"  v7", 0, NULL, OPTION_DOC|OPTION_NO_TRANS, N_("old V7 tar format"),
 587    GRID+3 },
 588   {"  oldgnu", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 589    N_("GNU format as per tar <= 1.12"), GRID+3 },
 590   {"  gnu", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 591    N_("GNU tar 1.13.x format"), GRID+3 },
 592   {"  ustar", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 593    N_("POSIX 1003.1-1988 (ustar) format"), GRID+3 },
 594   {"  pax", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 595    N_("POSIX 1003.1-2001 (pax) format"), GRID+3 },
 596   {"  posix", 0, NULL, OPTION_DOC|OPTION_NO_TRANS, N_("same as pax"), GRID+3 },
 597
 598   {"old-archive", OLD_ARCHIVE_OPTION, 0, 0, /* FIXME */
 599    N_("same as --format=v7"), GRID+8 },
 600   {"portability", 0, 0, OPTION_ALIAS, NULL, GRID+8 },
 601   {"posix", POSIX_OPTION, 0, 0,
 602    N_("same as --format=posix"), GRID+8 },
 603   {"pax-option", PAX_OPTION, N_("keyword[[:]=value][,keyword[[:]=value]]..."), 0,
 604    N_("control pax keywords"), GRID+8 },
 605   {"label", 'V', N_("TEXT"), 0,
 606    N_("create archive with volume name TEXT; at list/extract time, use TEXT as a globbing pattern for volume name"), GRID+8 },
 607 #undef GRID
 608
 609 #define GRID 90
 610   {NULL, 0, NULL, 0,
 611    N_("Compression options:"), GRID },
 612   {"auto-compress", 'a', 0, 0,
 613    N_("use archive suffix to determine the compression program"), GRID+1 },
 614   {"no-auto-compress", NO_AUTO_COMPRESS_OPTION, 0, 0,
 615    N_("do not use archive suffix to determine the compression program"),
 616    GRID+1 },
 617   {"bzip2", 'j', 0, 0,
 618    N_("filter the archive through bzip2"), GRID+1 },
 619   {"gzip", 'z', 0, 0,
 620    N_("filter the archive through gzip"), GRID+1 },
 621   {"gunzip", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 622   {"ungzip", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 623   {"compress", 'Z', 0, 0,
 624    N_("filter the archive through compress"), GRID+1 },
 625   {"uncompress", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 626   {"lzma", LZMA_OPTION, 0, 0,
 627    N_("filter the archive through lzma"), GRID+1 },
 628   {"lzop", LZOP_OPTION, 0, 0,
 629    N_("filter the archive through lzop"), GRID+8 },
 630   {"xz", 'J', 0, 0,
 631    N_("filter the archive through xz"), GRID+8 },
 632   {"use-compress-program", 'I', N_("PROG"), 0,
 633    N_("filter through PROG (must accept -d)"), GRID+1 },
 634 #undef GRID
 635
 636 #define GRID 100
 637   {NULL, 0, NULL, 0,
 638    N_("Local file selection:"), GRID },
 639
 640   {"add-file", ARGP_KEY_ARG, N_("FILE"), 0,
 641    N_("add given FILE to the archive (useful if its name starts with a dash)"), GRID+1 },
 642   {"directory", 'C', N_("DIR"), 0,
 643    N_("change to directory DIR"), GRID+1 },
 644   {"files-from", 'T', N_("FILE"), 0,
 645    N_("get names to extract or create from FILE"), GRID+1 },
 646   {"null", NULL_OPTION, 0, 0,
 647    N_("-T reads null-terminated names, disable -C"), GRID+1 },
 648   {"no-null", NO_NULL_OPTION, 0, 0,
 649    N_("disable the effect of the previous --null option"), GRID+1 },
 650   {"unquote", UNQUOTE_OPTION, 0, 0,
 651    N_("unquote filenames read with -T (default)"), GRID+1 },
 652   {"no-unquote", NO_UNQUOTE_OPTION, 0, 0,
 653    N_("do not unquote filenames read with -T"), GRID+1 },
 654   {"exclude", EXCLUDE_OPTION, N_("PATTERN"), 0,
 655    N_("exclude files, given as a PATTERN"), GRID+1 },
 656   {"exclude-from", 'X', N_("FILE"), 0,
 657    N_("exclude patterns listed in FILE"), GRID+1 },
 658   {"exclude-caches", EXCLUDE_CACHES_OPTION, 0, 0,
 659    N_("exclude contents of directories containing CACHEDIR.TAG, "
 660       "except for the tag file itself"), GRID+1 },
 661   {"exclude-caches-under", EXCLUDE_CACHES_UNDER_OPTION, 0, 0,
 662    N_("exclude everything under directories containing CACHEDIR.TAG"),
 663    GRID+1 },
 664   {"exclude-caches-all", EXCLUDE_CACHES_ALL_OPTION, 0, 0,
 665    N_("exclude directories containing CACHEDIR.TAG"), GRID+1 },
 666   {"exclude-tag", EXCLUDE_TAG_OPTION, N_("FILE"), 0,
 667    N_("exclude contents of directories containing FILE, except"
 668       " for FILE itself"), GRID+1 },
 669   {"exclude-tag-under", EXCLUDE_TAG_UNDER_OPTION, N_("FILE"), 0,
 670    N_("exclude everything under directories containing FILE"), GRID+1 },
 671   {"exclude-tag-all", EXCLUDE_TAG_ALL_OPTION, N_("FILE"), 0,
 672    N_("exclude directories containing FILE"), GRID+1 },
 673   {"exclude-vcs", EXCLUDE_VCS_OPTION, NULL, 0,
 674    N_("exclude version control system directories"), GRID+1 },
 675   {"exclude-backups", EXCLUDE_BACKUPS_OPTION, NULL, 0,
 676    N_("exclude backup and lock files"), GRID+1 },
 677   {"no-recursion", NO_RECURSION_OPTION, 0, 0,
 678    N_("avoid descending automatically in directories"), GRID+1 },
 679   {"one-file-system", ONE_FILE_SYSTEM_OPTION, 0, 0,
 680    N_("stay in local file system when creating archive"), GRID+1 },
 681   {"recursion", RECURSION_OPTION, 0, 0,
 682    N_("recurse into directories (default)"), GRID+1 },
 683   {"absolute-names", 'P', 0, 0,
 684    N_("don't strip leading `/'s from file names"), GRID+1 },
 685   {"dereference", 'h', 0, 0,
 686    N_("follow symlinks; archive and dump the files they point to"), GRID+1 },
 687   {"hard-dereference", HARD_DEREFERENCE_OPTION, 0, 0,
 688    N_("follow hard links; archive and dump the files they refer to"), GRID+1 },
 689   {"starting-file", 'K', N_("MEMBER-NAME"), 0,
 690    N_("begin at member MEMBER-NAME in the archive"), GRID+1 },
 691   {"newer", 'N', N_("DATE-OR-FILE"), 0,
 692    N_("only store files newer than DATE-OR-FILE"), GRID+1 },
 693   {"after-date", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 694   {"newer-mtime", NEWER_MTIME_OPTION, N_("DATE"), 0,
 695    N_("compare date and time when data changed only"), GRID+1 },
 696   {"backup", BACKUP_OPTION, N_("CONTROL"), OPTION_ARG_OPTIONAL,
 697    N_("backup before removal, choose version CONTROL"), GRID+1 },
 698   {"suffix", SUFFIX_OPTION, N_("STRING"), 0,
 699    N_("backup before removal, override usual suffix ('~' unless overridden by environment variable SIMPLE_BACKUP_SUFFIX)"), GRID+1 },
 700 #undef GRID
 701
 702 #define GRID 110
 703   {NULL, 0, NULL, 0,
 704    N_("File name transformations:"), GRID },
 705   {"strip-components", STRIP_COMPONENTS_OPTION, N_("NUMBER"), 0,
 706    N_("strip NUMBER leading components from file names on extraction"),
 707    GRID+1 },
 708   {"transform", TRANSFORM_OPTION, N_("EXPRESSION"), 0,
 709    N_("use sed replace EXPRESSION to transform file names"), GRID+1 },
 710   {"xform", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 711 #undef GRID
 712
 713 #define GRID 120
 714   {NULL, 0, NULL, 0,
 715    N_("File name matching options (affect both exclude and include patterns):"),
 716    GRID },
 717   {"ignore-case", IGNORE_CASE_OPTION, 0, 0,
 718    N_("ignore case"), GRID+1 },
 719   {"anchored", ANCHORED_OPTION, 0, 0,
 720    N_("patterns match file name start"), GRID+1 },
 721   {"no-anchored", NO_ANCHORED_OPTION, 0, 0,
 722    N_("patterns match after any `/' (default for exclusion)"), GRID+1 },
 723   {"no-ignore-case", NO_IGNORE_CASE_OPTION, 0, 0,
 724    N_("case sensitive matching (default)"), GRID+1 },
 725   {"wildcards", WILDCARDS_OPTION, 0, 0,
 726    N_("use wildcards (default for exclusion)"), GRID+1 },
 727   {"no-wildcards", NO_WILDCARDS_OPTION, 0, 0,
 728    N_("verbatim string matching"), GRID+1 },
 729   {"no-wildcards-match-slash", NO_WILDCARDS_MATCH_SLASH_OPTION, 0, 0,
 730    N_("wildcards do not match `/'"), GRID+1 },
 731   {"wildcards-match-slash", WILDCARDS_MATCH_SLASH_OPTION, 0, 0,
 732    N_("wildcards match `/' (default for exclusion)"), GRID+1 },
 733 #undef GRID
 734
 735 #define GRID 130
 736   {NULL, 0, NULL, 0,
 737    N_("Informative output:"), GRID },
 738
 739   {"verbose", 'v', 0, 0,
 740    N_("verbosely list files processed"), GRID+1 },
 741   {"warning", WARNING_OPTION, N_("KEYWORD"), 0,
 742    N_("warning control"), GRID+1 },
 743   {"checkpoint", CHECKPOINT_OPTION, N_("NUMBER"), OPTION_ARG_OPTIONAL,
 744    N_("display progress messages every NUMBERth record (default 10)"),
 745    GRID+1 },
 746   {"checkpoint-action", CHECKPOINT_ACTION_OPTION, N_("ACTION"), 0,
 747    N_("execute ACTION on each checkpoint"),
 748    GRID+1 },
 749   {"check-links", 'l', 0, 0,
 750    N_("print a message if not all links are dumped"), GRID+1 },
 751   {"totals", TOTALS_OPTION, N_("SIGNAL"), OPTION_ARG_OPTIONAL,
 752    N_("print total bytes after processing the archive; "
 753       "with an argument - print total bytes when this SIGNAL is delivered; "
 754       "Allowed signals are: SIGHUP, SIGQUIT, SIGINT, SIGUSR1 and SIGUSR2; "
 755       "the names without SIG prefix are also accepted"), GRID+1 },
 756   {"utc", UTC_OPTION, 0, 0,
 757    N_("print file modification dates in UTC"), GRID+1 },
 758   {"index-file", INDEX_FILE_OPTION, N_("FILE"), 0,
 759    N_("send verbose output to FILE"), GRID+1 },
 760   {"block-number", 'R', 0, 0,
 761    N_("show block number within archive with each message"), GRID+1 },
 762   {"interactive", 'w', 0, 0,
 763    N_("ask for confirmation for every action"), GRID+1 },
 764   {"confirmation", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 765   {"show-defaults", SHOW_DEFAULTS_OPTION, 0, 0,
 766    N_("show tar defaults"), GRID+1 },
 767   {"show-omitted-dirs", SHOW_OMITTED_DIRS_OPTION, 0, 0,
 768    N_("when listing or extracting, list each directory that does not match search criteria"), GRID+1 },
 769   {"show-transformed-names", SHOW_TRANSFORMED_NAMES_OPTION, 0, 0,
 770    N_("show file or archive names after transformation"),
 771    GRID+1 },
 772   {"show-stored-names", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 773   {"quoting-style", QUOTING_STYLE_OPTION, N_("STYLE"), 0,
 774    N_("set name quoting style; see below for valid STYLE values"), GRID+1 },
 775   {"quote-chars", QUOTE_CHARS_OPTION, N_("STRING"), 0,
 776    N_("additionally quote characters from STRING"), GRID+1 },
 777   {"no-quote-chars", NO_QUOTE_CHARS_OPTION, N_("STRING"), 0,
 778    N_("disable quoting for characters from STRING"), GRID+1 },
 779 #undef GRID
 780
 781 #define GRID 140
 782   {NULL, 0, NULL, 0,
 783    N_("Compatibility options:"), GRID },
 784
 785   {NULL, 'o', 0, 0,
 786    N_("when creating, same as --old-archive; when extracting, same as --no-same-owner"), GRID+1 },
 787 #undef GRID
 788
 789 #define GRID 150
 790   {NULL, 0, NULL, 0,
 791    N_("Other options:"), GRID },
 792
 793   {"restrict", RESTRICT_OPTION, 0, 0,
 794    N_("disable use of some potentially harmful options"), -1 },
 795 #undef GRID
 796
 797   {0, 0, 0, 0, 0, 0}
 798 };
 799
 800 static char const *const atime_preserve_args[] =
 801 {
 802   "replace", "system", NULL
 803 };
 804
 805 static enum atime_preserve const atime_preserve_types[] =
 806 {
 807   replace_atime_preserve, system_atime_preserve
 808 };
 809
 810 /* Make sure atime_preserve_types has as much entries as atime_preserve_args
 811    (minus 1 for NULL guard) */
 812 ARGMATCH_VERIFY (atime_preserve_args, atime_preserve_types);
 813
 814 /* Wildcard matching settings */
 815 enum wildcards
 816   {
 817     default_wildcards, /* For exclusion == enable_wildcards,
 818                           for inclusion == disable_wildcards */
 819     disable_wildcards,
 820     enable_wildcards
 821   };
 822
 823 struct tar_args        /* Variables used during option parsing */
 824 {
 825   struct textual_date *textual_date; /* Keeps the arguments to --newer-mtime
 826                                         and/or --date option if they are
 827                                         textual dates */
 828   enum wildcards wildcards;        /* Wildcard settings (--wildcards/
 829                                       --no-wildcards) */
 830   int matching_flags;              /* exclude_fnmatch options */
 831   int include_anchored;            /* Pattern anchoring options used for
 832                                       file inclusion */
 833   bool o_option;                   /* True if -o option was given */
 834   bool pax_option;                 /* True if --pax-option was given */
 835   char const *backup_suffix_string;   /* --suffix option argument */
 836   char const *version_control_string; /* --backup option argument */
 837   bool input_files;                /* True if some input files where given */
 838   int compress_autodetect;         /* True if compression autodetection should
 839                                       be attempted when creating archives */
 840 };
 841
 842 \f
 843 #define MAKE_EXCL_OPTIONS(args) \
 844  ((((args)->wildcards != disable_wildcards) ? EXCLUDE_WILDCARDS : 0) \
 845   | (args)->matching_flags \
 846   | recursion_option)
 847
 848 #define MAKE_INCL_OPTIONS(args) \
 849  ((((args)->wildcards == enable_wildcards) ? EXCLUDE_WILDCARDS : 0) \
 850   | (args)->include_anchored \
 851   | (args)->matching_flags \
 852   | recursion_option)
 853
 854 static char const * const vcs_file_table[] = {
 855   /* CVS: */
 856   "CVS",
 857   ".cvsignore",
 858   /* RCS: */
 859   "RCS",
 860   /* SCCS: */
 861   "SCCS",
 862   /* SVN: */
 863   ".svn",
 864   /* git: */
 865   ".git",
 866   ".gitignore",
 867   /* Arch: */
 868   ".arch-ids",
 869   "{arch}",
 870   "=RELEASE-ID",
 871   "=meta-update",
 872   "=update",
 873   /* Bazaar */
 874   ".bzr",
 875   ".bzrignore",
 876   ".bzrtags",
 877   /* Mercurial */
 878   ".hg",
 879   ".hgignore",
 880   ".hgtags",
 881   /* darcs */
 882   "_darcs",
 883   NULL
 884 };
 885
 886 static char const * const backup_file_table[] = {
 887   ".#*",
 888   "*~",
 889   "#*#",
 890   NULL
 891 };
 892
 893 void
 894 add_exclude_array (char const * const * fv)
 895 {
 896   int i;
 897
 898   for (i = 0; fv[i]; i++)
 899     add_exclude (excluded, fv[i], 0);
 900 }
 901
 902 \f
 903 static char *
 904 format_default_settings (void)
 905 {
 906   char *s;
 907
 908   asprintf (&s,
 909             "--format=%s -f%s -b%d --quoting-style=%s --rmt-command=%s"
 910 #ifdef REMOTE_SHELL
 911             " --rsh-command=%s"
 912 #endif
 913             ,
 914             archive_format_string (DEFAULT_ARCHIVE_FORMAT),
 915             DEFAULT_ARCHIVE, DEFAULT_BLOCKING,
 916             quoting_style_args[DEFAULT_QUOTING_STYLE],
 917             DEFAULT_RMT_COMMAND,
 918 #ifdef REMOTE_SHELL
 919             REMOTE_SHELL
 920 #endif
 921             );
 922   return s;
 923 }
 924
 925 \f
 926 static void
 927 set_subcommand_option (enum subcommand subcommand)
 928 {
 929   if (subcommand_option != UNKNOWN_SUBCOMMAND
 930       && subcommand_option != subcommand)
 931     USAGE_ERROR ((0, 0,
 932                   _("You may not specify more than one `-Acdtrux' option")));
 933
 934   subcommand_option = subcommand;
 935 }
 936
 937 static void
 938 set_use_compress_program_option (const char *string)
 939 {
 940   if (use_compress_program_option
 941       && strcmp (use_compress_program_option, string) != 0)
 942     USAGE_ERROR ((0, 0, _("Conflicting compression options")));
 943
 944   use_compress_program_option = string;
 945 }
 946 \f
 947 static RETSIGTYPE
 948 sigstat (int signo)
 949 {
 950   compute_duration ();
 951   print_total_stats ();
 952 #ifndef HAVE_SIGACTION
 953   signal (signo, sigstat);
 954 #endif
 955 }
 956
 957 static void
 958 stat_on_signal (int signo)
 959 {
 960 #ifdef HAVE_SIGACTION
 961   struct sigaction act;
 962   act.sa_handler = sigstat;
 963   sigemptyset (&act.sa_mask);
 964   act.sa_flags = 0;
 965   sigaction (signo, &act, NULL);
 966 #else
 967   signal (signo, sigstat);
 968 #endif
 969 }
 970
 971 void
 972 set_stat_signal (const char *name)
 973 {
 974   static struct sigtab
 975   {
 976     char *name;
 977     int signo;
 978   } sigtab[] = {
 979     { "SIGUSR1", SIGUSR1 },
 980     { "USR1", SIGUSR1 },
 981     { "SIGUSR2", SIGUSR2 },
 982     { "USR2", SIGUSR2 },
 983     { "SIGHUP", SIGHUP },
 984     { "HUP", SIGHUP },
 985     { "SIGINT", SIGINT },
 986     { "INT", SIGINT },
 987     { "SIGQUIT", SIGQUIT },
 988     { "QUIT", SIGQUIT }
 989   };
 990   struct sigtab *p;
 991
 992   for (p = sigtab; p < sigtab + sizeof (sigtab) / sizeof (sigtab[0]); p++)
 993     if (strcmp (p->name, name) == 0)
 994       {
 995         stat_on_signal (p->signo);
 996         return;
 997       }
 998   FATAL_ERROR ((0, 0, _("Unknown signal name: %s"), name));
 999 }
1000
1001 \f
1002 struct textual_date
1003 {
1004   struct textual_date *next;
1005   struct timespec ts;
1006   const char *option;
1007   char *date;
1008 };
1009
1010 static int
1011 get_date_or_file (struct tar_args *args, const char *option,
1012                   const char *str, struct timespec *ts)
1013 {
1014   if (FILE_SYSTEM_PREFIX_LEN (str) != 0
1015       || ISSLASH (*str)
1016       || *str == '.')
1017     {
1018       struct stat st;
1019       if (deref_stat (dereference_option, str, &st) != 0)
1020         {
1021           stat_error (str);
1022           USAGE_ERROR ((0, 0, _("Date sample file not found")));
1023         }
1024       *ts = get_stat_mtime (&st);
1025     }
1026   else
1027     {
1028       if (! get_date (ts, str, NULL))
1029         {
1030           WARN ((0, 0, _("Substituting %s for unknown date format %s"),
1031                  tartime (*ts, false), quote (str)));
1032           ts->tv_nsec = 0;
1033           return 1;
1034         }
1035       else
1036         {
1037           struct textual_date *p = xmalloc (sizeof (*p));
1038           p->ts = *ts;
1039           p->option = option;
1040           p->date = xstrdup (str);
1041           p->next = args->textual_date;
1042           args->textual_date = p;
1043         }
1044     }
1045   return 0;
1046 }
1047
1048 static void
1049 report_textual_dates (struct tar_args *args)
1050 {
1051   struct textual_date *p;
1052   for (p = args->textual_date; p; )
1053     {
1054       struct textual_date *next = p->next;
1055       if (verbose_option)
1056         {
1057           char const *treated_as = tartime (p->ts, true);
1058           if (strcmp (p->date, treated_as) != 0)
1059             WARN ((0, 0, _("Option %s: Treating date `%s' as %s"),
1060                    p->option, p->date, treated_as));
1061         }
1062       free (p->date);
1063       free (p);
1064       p = next;
1065     }
1066 }
1067
1068 \f
1069
1070 /* Either NL or NUL, as decided by the --null option.  */
1071 static char filename_terminator;
1072
1073 enum read_file_list_state  /* Result of reading file name from the list file */
1074   {
1075     file_list_success,     /* OK, name read successfully */
1076     file_list_end,         /* End of list file */
1077     file_list_zero,        /* Zero separator encountered where it should not */
1078     file_list_skip         /* Empty (zero-length) entry encountered, skip it */
1079   };
1080
1081 /* Read from FP a sequence of characters up to TERM and put them
1082    into STK.
1083  */
1084 static enum read_file_list_state
1085 read_name_from_file (FILE *fp, struct obstack *stk, int term)
1086 {
1087   int c;
1088   size_t counter = 0;
1089
1090   for (c = getc (fp); c != EOF && c != term; c = getc (fp))
1091     {
1092       if (c == 0)
1093         {
1094           /* We have read a zero separator. The file possibly is
1095              zero-separated */
1096           return file_list_zero;
1097         }
1098       obstack_1grow (stk, c);
1099       counter++;
1100     }
1101
1102   if (counter == 0 && c != EOF)
1103     return file_list_skip;
1104
1105   obstack_1grow (stk, 0);
1106
1107   return (counter == 0 && c == EOF) ? file_list_end : file_list_success;
1108 }
1109
1110 \f
1111 static bool files_from_option;  /* When set, tar will not refuse to create
1112                                    empty archives */
1113 static struct obstack argv_stk; /* Storage for additional command line options
1114                                    read using -T option */
1115
1116 /* Prevent recursive inclusion of the same file */
1117 struct file_id_list
1118 {
1119   struct file_id_list *next;
1120   ino_t ino;
1121   dev_t dev;
1122 };
1123
1124 static struct file_id_list *file_id_list;
1125
1126 static void
1127 add_file_id (const char *filename)
1128 {
1129   struct file_id_list *p;
1130   struct stat st;
1131
1132   if (stat (filename, &st))
1133     stat_fatal (filename);
1134   for (p = file_id_list; p; p = p->next)
1135     if (p->ino == st.st_ino && p->dev == st.st_dev)
1136       {
1137         FATAL_ERROR ((0, 0, _("%s: file list already read"),
1138                       quotearg_colon (filename)));
1139       }
1140   p = xmalloc (sizeof *p);
1141   p->next = file_id_list;
1142   p->ino = st.st_ino;
1143   p->dev = st.st_dev;
1144   file_id_list = p;
1145 }
1146
1147 /* Default density numbers for [0-9][lmh] device specifications */
1148
1149 #ifndef LOW_DENSITY_NUM
1150 # define LOW_DENSITY_NUM 0
1151 #endif
1152
1153 #ifndef MID_DENSITY_NUM
1154 # define MID_DENSITY_NUM 8
1155 #endif
1156
1157 #ifndef HIGH_DENSITY_NUM
1158 # define HIGH_DENSITY_NUM 16
1159 #endif
1160
1161 static void
1162 update_argv (const char *filename, struct argp_state *state)
1163 {
1164   FILE *fp;
1165   size_t count = 0, i;
1166   char *start, *p;
1167   char **new_argv;
1168   size_t new_argc;
1169   bool is_stdin = false;
1170   enum read_file_list_state read_state;
1171   int term = filename_terminator;
1172
1173   if (!strcmp (filename, "-"))
1174     {
1175       is_stdin = true;
1176       request_stdin ("-T");
1177       fp = stdin;
1178     }
1179   else
1180     {
1181       add_file_id (filename);
1182       if ((fp = fopen (filename, "r")) == NULL)
1183         open_fatal (filename);
1184     }
1185
1186   while ((read_state = read_name_from_file (fp, &argv_stk, term))
1187          != file_list_end)
1188     {
1189       switch (read_state)
1190         {
1191         case file_list_success:
1192           count++;
1193           break;
1194
1195         case file_list_end: /* won't happen, just to pacify gcc */
1196           break;
1197
1198         case file_list_zero:
1199           {
1200             size_t size;
1201
1202             WARNOPT (WARN_FILENAME_WITH_NULS,
1203                      (0, 0, N_("%s: file name read contains nul character"),
1204                       quotearg_colon (filename)));
1205
1206             /* Prepare new stack contents */
1207             size = obstack_object_size (&argv_stk);
1208             p = obstack_finish (&argv_stk);
1209             for (; size > 0; size--, p++)
1210               if (*p)
1211                 obstack_1grow (&argv_stk, *p);
1212               else
1213                 obstack_1grow (&argv_stk, '\n');
1214             obstack_1grow (&argv_stk, 0);
1215             count = 1;
1216             /* Read rest of files using new filename terminator */
1217             term = 0;
1218             break;
1219           }
1220
1221         case file_list_skip:
1222           break;
1223         }
1224     }
1225
1226   if (!is_stdin)
1227     fclose (fp);
1228
1229   if (count == 0)
1230     return;
1231
1232   start = obstack_finish (&argv_stk);
1233
1234   if (term == 0)
1235     for (p = start; *p; p += strlen (p) + 1)
1236       if (p[0] == '-')
1237         count++;
1238
1239   new_argc = state->argc + count;
1240   new_argv = xmalloc (sizeof (state->argv[0]) * (new_argc + 1));
1241   memcpy (new_argv, state->argv, sizeof (state->argv[0]) * (state->argc + 1));
1242   state->argv = new_argv;
1243   memmove (&state->argv[state->next + count], &state->argv[state->next],
1244            (state->argc - state->next + 1) * sizeof (state->argv[0]));
1245
1246   state->argc = new_argc;
1247
1248   for (i = state->next, p = start; *p; p += strlen (p) + 1, i++)
1249     {
1250       if (term == 0 && p[0] == '-')
1251         state->argv[i++] = "--add-file";
1252       state->argv[i] = p;
1253     }
1254 }
1255
1256 \f
1257 static char *
1258 tar_help_filter (int key, const char *text, void *input)
1259 {
1260   struct obstack stk;
1261   char *s;
1262
1263   if (key != ARGP_KEY_HELP_EXTRA)
1264     return (char*) text;
1265
1266   obstack_init (&stk);
1267   s = _("Valid arguments for the --quoting-style option are:");
1268   obstack_grow (&stk, s, strlen (s));
1269   obstack_grow (&stk, "\n\n", 2);
1270   tar_list_quoting_styles (&stk, "  ");
1271   s = _("\n*This* tar defaults to:\n");
1272   obstack_grow (&stk, s, strlen (s));
1273   s = format_default_settings ();
1274   obstack_grow (&stk, s, strlen (s));
1275   obstack_1grow (&stk, '\n');
1276   obstack_1grow (&stk, 0);
1277   s = xstrdup (obstack_finish (&stk));
1278   obstack_free (&stk, NULL);
1279   return s;
1280 }
1281 \f
1282 static char *
1283 expand_pax_option (struct tar_args *targs, const char *arg)
1284 {
1285   struct obstack stk;
1286   char *res;
1287
1288   obstack_init (&stk);
1289   while (*arg)
1290     {
1291       size_t seglen = strcspn (arg, ",");
1292       char *p = memchr (arg, '=', seglen);
1293       if (p)
1294         {
1295           size_t len = p - arg + 1;
1296           obstack_grow (&stk, arg, len);
1297           len = seglen - len;
1298           for (++p; *p && isspace ((unsigned char) *p); p++)
1299             len--;
1300           if (*p == '{' && p[len-1] == '}')
1301             {
1302               struct timespec ts;
1303               char *tmp = xmalloc (len);
1304               memcpy (tmp, p + 1, len-2);
1305               tmp[len-2] = 0;
1306               if (get_date_or_file (targs, "--pax-option", tmp, &ts) == 0)
1307                 {
1308                   char buf[UINTMAX_STRSIZE_BOUND], *s;
1309                   s = umaxtostr (ts.tv_sec, buf);
1310                   obstack_grow (&stk, s, strlen (s));
1311                 }
1312               else
1313                 obstack_grow (&stk, p, len);
1314               free (tmp);
1315             }
1316           else
1317             obstack_grow (&stk, p, len);
1318         }
1319       else
1320         obstack_grow (&stk, arg, seglen);
1321
1322       arg += seglen;
1323       if (*arg)
1324         {
1325           obstack_1grow (&stk, *arg);
1326           arg++;
1327         }
1328     }
1329   obstack_1grow (&stk, 0);
1330   res = xstrdup (obstack_finish (&stk));
1331   obstack_free (&stk, NULL);
1332   return res;
1333 }
1334
1335 \f
1336 static error_t
1337 parse_opt (int key, char *arg, struct argp_state *state)
1338 {
1339   struct tar_args *args = state->input;
1340
1341   switch (key)
1342     {
1343     case ARGP_KEY_ARG:
1344       /* File name or non-parsed option, because of ARGP_IN_ORDER */
1345       name_add_name (arg, MAKE_INCL_OPTIONS (args));
1346       args->input_files = true;
1347       break;
1348
1349     case 'A':
1350       set_subcommand_option (CAT_SUBCOMMAND);
1351       break;
1352
1353     case 'a':
1354       args->compress_autodetect = true;
1355       break;
1356
1357     case NO_AUTO_COMPRESS_OPTION:
1358       args->compress_autodetect = false;
1359       break;
1360
1361     case 'b':
1362       {
1363         uintmax_t u;
1364         if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1365                && u == (blocking_factor = u)
1366                && 0 < blocking_factor
1367                && u == (record_size = u * BLOCKSIZE) / BLOCKSIZE))
1368           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1369                         _("Invalid blocking factor")));
1370       }
1371       break;
1372
1373     case 'B':
1374       /* Try to reblock input records.  For reading 4.2BSD pipes.  */
1375
1376       /* It would surely make sense to exchange -B and -R, but it seems
1377          that -B has been used for a long while in Sun tar and most
1378          BSD-derived systems.  This is a consequence of the block/record
1379          terminology confusion.  */
1380
1381       read_full_records_option = true;
1382       break;
1383
1384     case 'c':
1385       set_subcommand_option (CREATE_SUBCOMMAND);
1386       break;
1387
1388     case 'C':
1389       name_add_dir (arg);
1390       break;
1391
1392     case 'd':
1393       set_subcommand_option (DIFF_SUBCOMMAND);
1394       break;
1395
1396     case 'f':
1397       if (archive_names == allocated_archive_names)
1398         archive_name_array = x2nrealloc (archive_name_array,
1399                                          &allocated_archive_names,
1400                                          sizeof (archive_name_array[0]));
1401
1402       archive_name_array[archive_names++] = arg;
1403       break;
1404
1405     case 'F':
1406       /* Since -F is only useful with -M, make it implied.  Run this
1407          script at the end of each tape.  */
1408
1409       info_script_option = arg;
1410       multi_volume_option = true;
1411       break;
1412
1413     case 'g':
1414       listed_incremental_option = arg;
1415       after_date_option = true;
1416       /* Fall through.  */
1417
1418     case 'G':
1419       /* We are making an incremental dump (FIXME: are we?); save
1420          directories at the beginning of the archive, and include in each
1421          directory its contents.  */
1422
1423       incremental_option = true;
1424       break;
1425
1426     case 'h':
1427       /* Follow symbolic links.  */
1428       dereference_option = true;
1429       break;
1430
1431     case HARD_DEREFERENCE_OPTION:
1432       hard_dereference_option = true;
1433       break;
1434
1435     case 'i':
1436       /* Ignore zero blocks (eofs).  This can't be the default,
1437          because Unix tar writes two blocks of zeros, then pads out
1438          the record with garbage.  */
1439
1440       ignore_zeros_option = true;
1441       break;
1442
1443     case 'j':
1444       set_use_compress_program_option ("bzip2");
1445       break;
1446
1447     case 'J':
1448       set_use_compress_program_option ("xz");
1449       break;
1450
1451     case 'k':
1452       /* Don't replace existing files.  */
1453       old_files_option = KEEP_OLD_FILES;
1454       break;
1455
1456     case 'K':
1457       starting_file_option = true;
1458       addname (arg, 0, true, NULL);
1459       break;
1460
1461     case ONE_FILE_SYSTEM_OPTION:
1462       /* When dumping directories, don't dump files/subdirectories
1463          that are on other filesystems. */
1464       one_file_system_option = true;
1465       break;
1466
1467     case 'l':
1468       check_links_option = 1;
1469       break;
1470
1471     case 'L':
1472       {
1473         uintmax_t u;
1474         if (xstrtoumax (arg, 0, 10, &u, "") != LONGINT_OK)
1475           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1476                         _("Invalid tape length")));
1477         tape_length_option = 1024 * (tarlong) u;
1478         multi_volume_option = true;
1479       }
1480       break;
1481
1482     case LEVEL_OPTION:
1483       {
1484         char *p;
1485         incremental_level = strtoul (arg, &p, 10);
1486         if (*p)
1487           USAGE_ERROR ((0, 0, _("Invalid incremental level value")));
1488       }
1489       break;
1490
1491     case LZMA_OPTION:
1492       set_use_compress_program_option ("lzma");
1493       break;
1494
1495     case LZOP_OPTION:
1496       set_use_compress_program_option ("lzop");
1497       break;
1498
1499     case 'm':
1500       touch_option = true;
1501       break;
1502
1503     case 'M':
1504       /* Make multivolume archive: when we can't write any more into
1505          the archive, re-open it, and continue writing.  */
1506
1507       multi_volume_option = true;
1508       break;
1509
1510     case MTIME_OPTION:
1511       get_date_or_file (args, "--mtime", arg, &mtime_option);
1512       set_mtime_option = true;
1513       break;
1514
1515     case 'n':
1516       seek_option = 1;
1517       break;
1518
1519     case NO_SEEK_OPTION:
1520       seek_option = 0;
1521       break;
1522
1523     case 'N':
1524       after_date_option = true;
1525       /* Fall through.  */
1526
1527     case NEWER_MTIME_OPTION:
1528       if (NEWER_OPTION_INITIALIZED (newer_mtime_option))
1529         USAGE_ERROR ((0, 0, _("More than one threshold date")));
1530       get_date_or_file (args,
1531                         key == NEWER_MTIME_OPTION ? "--newer-mtime"
1532                         : "--after-date", arg, &newer_mtime_option);
1533       break;
1534
1535     case 'o':
1536       args->o_option = true;
1537       break;
1538
1539     case 'O':
1540       to_stdout_option = true;
1541       break;
1542
1543     case 'p':
1544       same_permissions_option = true;
1545       break;
1546
1547     case 'P':
1548       absolute_names_option = true;
1549       break;
1550
1551     case 'r':
1552       set_subcommand_option (APPEND_SUBCOMMAND);
1553       break;
1554
1555     case 'R':
1556       /* Print block numbers for debugging bad tar archives.  */
1557
1558       /* It would surely make sense to exchange -B and -R, but it seems
1559          that -B has been used for a long while in Sun tar and most
1560          BSD-derived systems.  This is a consequence of the block/record
1561          terminology confusion.  */
1562
1563       block_number_option = true;
1564       break;
1565
1566     case 's':
1567       /* Names to extract are sorted.  */
1568
1569       same_order_option = true;
1570       break;
1571
1572     case 'S':
1573       sparse_option = true;
1574       break;
1575
1576     case SPARSE_VERSION_OPTION:
1577       sparse_option = true;
1578       {
1579         char *p;
1580         tar_sparse_major = strtoul (arg, &p, 10);
1581         if (*p)
1582           {
1583             if (*p != '.')
1584               USAGE_ERROR ((0, 0, _("Invalid sparse version value")));
1585             tar_sparse_minor = strtoul (p + 1, &p, 10);
1586             if (*p)
1587               USAGE_ERROR ((0, 0, _("Invalid sparse version value")));
1588           }
1589       }
1590       break;
1591
1592     case 't':
1593       set_subcommand_option (LIST_SUBCOMMAND);
1594       verbose_option++;
1595       break;
1596
1597     case TEST_LABEL_OPTION:
1598       set_subcommand_option (LIST_SUBCOMMAND);
1599       test_label_option = true;
1600       break;
1601
1602     case 'T':
1603       update_argv (arg, state);
1604       /* Indicate we've been given -T option. This is for backward
1605          compatibility only, so that `tar cfT archive /dev/null will
1606          succeed */
1607       files_from_option = true;
1608       break;
1609
1610     case 'u':
1611       set_subcommand_option (UPDATE_SUBCOMMAND);
1612       break;
1613
1614     case 'U':
1615       old_files_option = UNLINK_FIRST_OLD_FILES;
1616       break;
1617
1618     case UTC_OPTION:
1619       utc_option = true;
1620       break;
1621
1622     case 'v':
1623       verbose_option++;
1624       warning_option |= WARN_VERBOSE_WARNINGS;
1625       break;
1626
1627     case 'V':
1628       volume_label_option = arg;
1629       break;
1630
1631     case 'w':
1632       interactive_option = true;
1633       break;
1634
1635     case 'W':
1636       verify_option = true;
1637       break;
1638
1639     case 'x':
1640       set_subcommand_option (EXTRACT_SUBCOMMAND);
1641       break;
1642
1643     case 'X':
1644       if (add_exclude_file (add_exclude, excluded, arg,
1645                             MAKE_EXCL_OPTIONS (args), '\n')
1646           != 0)
1647         {
1648           int e = errno;
1649           FATAL_ERROR ((0, e, "%s", quotearg_colon (arg)));
1650         }
1651       break;
1652
1653     case 'z':
1654       set_use_compress_program_option ("gzip");
1655       break;
1656
1657     case 'Z':
1658       set_use_compress_program_option ("compress");
1659       break;
1660
1661     case ANCHORED_OPTION:
1662       args->matching_flags |= EXCLUDE_ANCHORED;
1663       break;
1664
1665     case ATIME_PRESERVE_OPTION:
1666       atime_preserve_option =
1667         (arg
1668          ? XARGMATCH ("--atime-preserve", arg,
1669                       atime_preserve_args, atime_preserve_types)
1670          : replace_atime_preserve);
1671       if (! O_NOATIME && atime_preserve_option == system_atime_preserve)
1672         FATAL_ERROR ((0, 0,
1673                       _("--atime-preserve='system' is not supported"
1674                         " on this platform")));
1675       break;
1676
1677     case CHECK_DEVICE_OPTION:
1678       check_device_option = true;
1679       break;
1680
1681     case NO_CHECK_DEVICE_OPTION:
1682       check_device_option = false;
1683       break;
1684
1685     case CHECKPOINT_OPTION:
1686       if (arg)
1687         {
1688           char *p;
1689
1690           if (*arg == '.')
1691             {
1692               checkpoint_compile_action (".");
1693               arg++;
1694             }
1695           checkpoint_option = strtoul (arg, &p, 0);
1696           if (*p)
1697             FATAL_ERROR ((0, 0,
1698                           _("--checkpoint value is not an integer")));
1699         }
1700       else
1701         checkpoint_option = DEFAULT_CHECKPOINT;
1702       break;
1703
1704     case CHECKPOINT_ACTION_OPTION:
1705       checkpoint_compile_action (arg);
1706       break;
1707
1708     case BACKUP_OPTION:
1709       backup_option = true;
1710       if (arg)
1711         args->version_control_string = arg;
1712       break;
1713
1714     case DELAY_DIRECTORY_RESTORE_OPTION:
1715       delay_directory_restore_option = true;
1716       break;
1717
1718     case NO_DELAY_DIRECTORY_RESTORE_OPTION:
1719       delay_directory_restore_option = false;
1720       break;
1721
1722     case DELETE_OPTION:
1723       set_subcommand_option (DELETE_SUBCOMMAND);
1724       break;
1725
1726     case EXCLUDE_BACKUPS_OPTION:
1727       add_exclude_array (backup_file_table);
1728       break;
1729
1730     case EXCLUDE_OPTION:
1731       add_exclude (excluded, arg, MAKE_EXCL_OPTIONS (args));
1732       break;
1733
1734     case EXCLUDE_CACHES_OPTION:
1735       add_exclusion_tag ("CACHEDIR.TAG", exclusion_tag_contents,
1736                          cachedir_file_p);
1737       break;
1738
1739     case EXCLUDE_CACHES_UNDER_OPTION:
1740       add_exclusion_tag ("CACHEDIR.TAG", exclusion_tag_under,
1741                          cachedir_file_p);
1742       break;
1743
1744     case EXCLUDE_CACHES_ALL_OPTION:
1745       add_exclusion_tag ("CACHEDIR.TAG", exclusion_tag_all,
1746                          cachedir_file_p);
1747       break;
1748
1749     case EXCLUDE_TAG_OPTION:
1750       add_exclusion_tag (arg, exclusion_tag_contents, NULL);
1751       break;
1752
1753     case EXCLUDE_TAG_UNDER_OPTION:
1754       add_exclusion_tag (arg, exclusion_tag_under, NULL);
1755       break;
1756
1757     case EXCLUDE_TAG_ALL_OPTION:
1758       add_exclusion_tag (arg, exclusion_tag_all, NULL);
1759       break;
1760
1761     case EXCLUDE_VCS_OPTION:
1762       add_exclude_array (vcs_file_table);
1763       break;
1764
1765     case FORCE_LOCAL_OPTION:
1766       force_local_option = true;
1767       break;
1768
1769     case 'H':
1770       set_archive_format (arg);
1771       break;
1772
1773     case INDEX_FILE_OPTION:
1774       index_file_name = arg;
1775       break;
1776
1777     case IGNORE_CASE_OPTION:
1778       args->matching_flags |= FNM_CASEFOLD;
1779       break;
1780
1781     case IGNORE_COMMAND_ERROR_OPTION:
1782       ignore_command_error_option = true;
1783       break;
1784
1785     case IGNORE_FAILED_READ_OPTION:
1786       ignore_failed_read_option = true;
1787       break;
1788
1789     case KEEP_NEWER_FILES_OPTION:
1790       old_files_option = KEEP_NEWER_FILES;
1791       break;
1792
1793     case GROUP_OPTION:
1794       if (! (strlen (arg) < GNAME_FIELD_SIZE
1795              && gname_to_gid (arg, &group_option)))
1796         {
1797           uintmax_t g;
1798           if (xstrtoumax (arg, 0, 10, &g, "") == LONGINT_OK
1799               && g == (gid_t) g)
1800             group_option = g;
1801           else
1802             FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1803                           _("Invalid group")));
1804         }
1805       break;
1806
1807     case MODE_OPTION:
1808       mode_option = mode_compile (arg);
1809       if (!mode_option)
1810         FATAL_ERROR ((0, 0, _("Invalid mode given on option")));
1811       initial_umask = umask (0);
1812       umask (initial_umask);
1813       break;
1814
1815     case NO_ANCHORED_OPTION:
1816       args->include_anchored = 0; /* Clear the default for comman line args */
1817       args->matching_flags &= ~ EXCLUDE_ANCHORED;
1818       break;
1819
1820     case NO_IGNORE_CASE_OPTION:
1821       args->matching_flags &= ~ FNM_CASEFOLD;
1822       break;
1823
1824     case NO_IGNORE_COMMAND_ERROR_OPTION:
1825       ignore_command_error_option = false;
1826       break;
1827
1828     case NO_OVERWRITE_DIR_OPTION:
1829       old_files_option = NO_OVERWRITE_DIR_OLD_FILES;
1830       break;
1831
1832     case NO_QUOTE_CHARS_OPTION:
1833       for (;*arg; arg++)
1834         set_char_quoting (NULL, *arg, 0);
1835       break;
1836
1837     case NO_WILDCARDS_OPTION:
1838       args->wildcards = disable_wildcards;
1839       break;
1840
1841     case NO_WILDCARDS_MATCH_SLASH_OPTION:
1842       args->matching_flags |= FNM_FILE_NAME;
1843       break;
1844
1845     case NULL_OPTION:
1846       filename_terminator = '\0';
1847       break;
1848
1849     case NO_NULL_OPTION:
1850       filename_terminator = '\n';
1851       break;
1852
1853     case NUMERIC_OWNER_OPTION:
1854       numeric_owner_option = true;
1855       break;
1856
1857     case OCCURRENCE_OPTION:
1858       if (!arg)
1859         occurrence_option = 1;
1860       else
1861         {
1862           uintmax_t u;
1863           if (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK)
1864             occurrence_option = u;
1865           else
1866             FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1867                           _("Invalid number")));
1868         }
1869       break;
1870
1871     case OVERWRITE_DIR_OPTION:
1872       old_files_option = DEFAULT_OLD_FILES;
1873       break;
1874
1875     case OVERWRITE_OPTION:
1876       old_files_option = OVERWRITE_OLD_FILES;
1877       break;
1878
1879     case OWNER_OPTION:
1880       if (! (strlen (arg) < UNAME_FIELD_SIZE
1881              && uname_to_uid (arg, &owner_option)))
1882         {
1883           uintmax_t u;
1884           if (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1885               && u == (uid_t) u)
1886             owner_option = u;
1887           else
1888             FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1889                           _("Invalid owner")));
1890         }
1891       break;
1892
1893     case QUOTE_CHARS_OPTION:
1894       for (;*arg; arg++)
1895         set_char_quoting (NULL, *arg, 1);
1896       break;
1897
1898     case QUOTING_STYLE_OPTION:
1899       tar_set_quoting_style (arg);
1900       break;
1901
1902     case PAX_OPTION:
1903       {
1904         char *tmp = expand_pax_option (args, arg);
1905         args->pax_option = true;
1906         xheader_set_option (tmp);
1907         free (tmp);
1908       }
1909       break;
1910
1911     case POSIX_OPTION:
1912       set_archive_format ("posix");
1913       break;
1914
1915     case PRESERVE_OPTION:
1916       /* FIXME: What it is good for? */
1917       same_permissions_option = true;
1918       same_order_option = true;
1919       WARN ((0, 0, _("The --preserve option is deprecated, "
1920                      "use --preserve-permissions --preserve-order instead")));
1921       break;
1922
1923     case RECORD_SIZE_OPTION:
1924       {
1925         uintmax_t u;
1926         if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1927                && u == (size_t) u))
1928           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1929                         _("Invalid record size")));
1930         record_size = u;
1931         if (record_size % BLOCKSIZE != 0)
1932           USAGE_ERROR ((0, 0, _("Record size must be a multiple of %d."),
1933                         BLOCKSIZE));
1934         blocking_factor = record_size / BLOCKSIZE;
1935       }
1936       break;
1937
1938     case RECURSIVE_UNLINK_OPTION:
1939       recursive_unlink_option = true;
1940       break;
1941
1942     case REMOVE_FILES_OPTION:
1943       remove_files_option = true;
1944       break;
1945
1946     case RESTRICT_OPTION:
1947       restrict_option = true;
1948       break;
1949
1950     case RMT_COMMAND_OPTION:
1951       rmt_command = arg;
1952       break;
1953
1954     case RSH_COMMAND_OPTION:
1955       rsh_command_option = arg;
1956       break;
1957
1958     case SHOW_DEFAULTS_OPTION:
1959       {
1960         char *s = format_default_settings ();
1961         printf ("%s\n", s);
1962         close_stdout ();
1963         free (s);
1964         exit (0);
1965       }
1966
1967     case STRIP_COMPONENTS_OPTION:
1968       {
1969         uintmax_t u;
1970         if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1971                && u == (size_t) u))
1972           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1973                         _("Invalid number of elements")));
1974         strip_name_components = u;
1975       }
1976       break;
1977
1978     case SHOW_OMITTED_DIRS_OPTION:
1979       show_omitted_dirs_option = true;
1980       break;
1981
1982     case SHOW_TRANSFORMED_NAMES_OPTION:
1983       show_transformed_names_option = true;
1984       break;
1985
1986     case SUFFIX_OPTION:
1987       backup_option = true;
1988       args->backup_suffix_string = arg;
1989       break;
1990
1991     case TO_COMMAND_OPTION:
1992       if (to_command_option)
1993         USAGE_ERROR ((0, 0, _("Only one --to-command option allowed")));
1994       to_command_option = arg;
1995       break;
1996
1997     case TOTALS_OPTION:
1998       if (arg)
1999         set_stat_signal (arg);
2000       else
2001         totals_option = true;
2002       break;
2003
2004     case TRANSFORM_OPTION:
2005       set_transform_expr (arg);
2006       break;
2007
2008     case 'I':
2009       set_use_compress_program_option (arg);
2010       break;
2011
2012     case VOLNO_FILE_OPTION:
2013       volno_file_option = arg;
2014       break;
2015
2016     case WILDCARDS_OPTION:
2017       args->wildcards = enable_wildcards;
2018       break;
2019
2020     case WILDCARDS_MATCH_SLASH_OPTION:
2021       args->matching_flags &= ~ FNM_FILE_NAME;
2022       break;
2023
2024     case NO_RECURSION_OPTION:
2025       recursion_option = 0;
2026       break;
2027
2028     case NO_SAME_OWNER_OPTION:
2029       same_owner_option = -1;
2030       break;
2031
2032     case NO_SAME_PERMISSIONS_OPTION:
2033       same_permissions_option = -1;
2034       break;
2035
2036     case RECURSION_OPTION:
2037       recursion_option = FNM_LEADING_DIR;
2038       break;
2039
2040     case SAME_OWNER_OPTION:
2041       same_owner_option = 1;
2042       break;
2043
2044     case UNQUOTE_OPTION:
2045       unquote_option = true;
2046       break;
2047
2048     case NO_UNQUOTE_OPTION:
2049       unquote_option = false;
2050       break;
2051
2052     case WARNING_OPTION:
2053       set_warning_option (arg);
2054       break;
2055
2056     case '0':
2057     case '1':
2058     case '2':
2059     case '3':
2060     case '4':
2061     case '5':
2062     case '6':
2063     case '7':
2064
2065 #ifdef DEVICE_PREFIX
2066       {
2067         int device = key - '0';
2068         int density;
2069         static char buf[sizeof DEVICE_PREFIX + 10];
2070         char *cursor;
2071
2072         if (arg[1])
2073           argp_error (state, _("Malformed density argument: %s"), quote (arg));
2074
2075         strcpy (buf, DEVICE_PREFIX);
2076         cursor = buf + strlen (buf);
2077
2078 #ifdef DENSITY_LETTER
2079
2080         sprintf (cursor, "%d%c", device, arg[0]);
2081
2082 #else /* not DENSITY_LETTER */
2083
2084         switch (arg[0])
2085           {
2086           case 'l':
2087             device += LOW_DENSITY_NUM;
2088             break;
2089
2090           case 'm':
2091             device += MID_DENSITY_NUM;
2092             break;
2093
2094           case 'h':
2095             device += HIGH_DENSITY_NUM;
2096             break;
2097
2098           default:
2099             argp_error (state, _("Unknown density: `%c'"), arg[0]);
2100           }
2101         sprintf (cursor, "%d", device);
2102
2103 #endif /* not DENSITY_LETTER */
2104
2105         if (archive_names == allocated_archive_names)
2106           archive_name_array = x2nrealloc (archive_name_array,
2107                                            &allocated_archive_names,
2108                                            sizeof (archive_name_array[0]));
2109         archive_name_array[archive_names++] = xstrdup (buf);
2110       }
2111       break;
2112
2113 #else /* not DEVICE_PREFIX */
2114
2115       argp_error (state,
2116                   _("Options `-[0-7][lmh]' not supported by *this* tar"));
2117
2118 #endif /* not DEVICE_PREFIX */
2119
2120     default:
2121       return ARGP_ERR_UNKNOWN;
2122     }
2123   return 0;
2124 }
2125
2126 static struct argp argp = {
2127   options,
2128   parse_opt,
2129   N_("[FILE]..."),
2130   doc,
2131   NULL,
2132   tar_help_filter,
2133   NULL
2134 };
2135
2136 void
2137 usage (int status)
2138 {
2139   argp_help (&argp, stderr, ARGP_HELP_SEE, (char*) program_name);
2140   close_stdout ();
2141   exit (status);
2142 }
2143
2144 /* Parse the options for tar.  */
2145
2146 static struct argp_option *
2147 find_argp_option (struct argp_option *o, int letter)
2148 {
2149   for (;
2150        !(o->name == NULL
2151          && o->key == 0
2152          && o->arg == 0
2153          && o->flags == 0
2154          && o->doc == NULL); o++)
2155     if (o->key == letter)
2156       return o;
2157   return NULL;
2158 }
2159
2160 static const char *tar_authors[] = {
2161   "John Gilmore",
2162   "Jay Fenlason",
2163   NULL
2164 };
2165
2166 static void
2167 decode_options (int argc, char **argv)
2168 {
2169   int idx;
2170   struct tar_args args;
2171
2172   argp_version_setup ("tar", tar_authors);
2173
2174   /* Set some default option values.  */
2175   args.textual_date = NULL;
2176   args.wildcards = default_wildcards;
2177   args.matching_flags = 0;
2178   args.include_anchored = EXCLUDE_ANCHORED;
2179   args.o_option = false;
2180   args.pax_option = false;
2181   args.backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
2182   args.version_control_string = 0;
2183   args.input_files = false;
2184   args.compress_autodetect = false;
2185
2186   subcommand_option = UNKNOWN_SUBCOMMAND;
2187   archive_format = DEFAULT_FORMAT;
2188   blocking_factor = DEFAULT_BLOCKING;
2189   record_size = DEFAULT_BLOCKING * BLOCKSIZE;
2190   excluded = new_exclude ();
2191   newer_mtime_option.tv_sec = TYPE_MINIMUM (time_t);
2192   newer_mtime_option.tv_nsec = -1;
2193   recursion_option = FNM_LEADING_DIR;
2194   unquote_option = true;
2195   tar_sparse_major = 1;
2196   tar_sparse_minor = 0;
2197
2198   owner_option = -1;
2199   group_option = -1;
2200
2201   check_device_option = true;
2202
2203   incremental_level = -1;
2204
2205   seek_option = -1;
2206
2207   /* Convert old-style tar call by exploding option element and rearranging
2208      options accordingly.  */
2209
2210   if (argc > 1 && argv[1][0] != '-')
2211     {
2212       int new_argc;             /* argc value for rearranged arguments */
2213       char **new_argv;          /* argv value for rearranged arguments */
2214       char *const *in;          /* cursor into original argv */
2215       char **out;               /* cursor into rearranged argv */
2216       const char *letter;       /* cursor into old option letters */
2217       char buffer[3];           /* constructed option buffer */
2218
2219       /* Initialize a constructed option.  */
2220
2221       buffer[0] = '-';
2222       buffer[2] = '\0';
2223
2224       /* Allocate a new argument array, and copy program name in it.  */
2225
2226       new_argc = argc - 1 + strlen (argv[1]);
2227       new_argv = xmalloc ((new_argc + 1) * sizeof (char *));
2228       in = argv;
2229       out = new_argv;
2230       *out++ = *in++;
2231
2232       /* Copy each old letter option as a separate option, and have the
2233          corresponding argument moved next to it.  */
2234
2235       for (letter = *in++; *letter; letter++)
2236         {
2237           struct argp_option *opt;
2238
2239           buffer[1] = *letter;
2240           *out++ = xstrdup (buffer);
2241           opt = find_argp_option (options, *letter);
2242           if (opt && opt->arg)
2243             {
2244               if (in < argv + argc)
2245                 *out++ = *in++;
2246               else
2247                 USAGE_ERROR ((0, 0, _("Old option `%c' requires an argument."),
2248                               *letter));
2249             }
2250         }
2251
2252       /* Copy all remaining options.  */
2253
2254       while (in < argv + argc)
2255         *out++ = *in++;
2256       *out = 0;
2257
2258       /* Replace the old option list by the new one.  */
2259
2260       argc = new_argc;
2261       argv = new_argv;
2262     }
2263
2264   /* Parse all options and non-options as they appear.  */
2265
2266   prepend_default_options (getenv ("TAR_OPTIONS"), &argc, &argv);
2267
2268   if (argp_parse (&argp, argc, argv, ARGP_IN_ORDER, &idx, &args))
2269     exit (TAREXIT_FAILURE);
2270
2271
2272   /* Special handling for 'o' option:
2273
2274      GNU tar used to say "output old format".
2275      UNIX98 tar says don't chown files after extracting (we use
2276      "--no-same-owner" for this).
2277
2278      The old GNU tar semantics is retained when used with --create
2279      option, otherwise UNIX98 semantics is assumed */
2280
2281   if (args.o_option)
2282     {
2283       if (subcommand_option == CREATE_SUBCOMMAND)
2284         {
2285           /* GNU Tar <= 1.13 compatibility */
2286           set_archive_format ("v7");
2287         }
2288       else
2289         {
2290           /* UNIX98 compatibility */
2291           same_owner_option = -1;
2292         }
2293     }
2294
2295   /* Handle operands after any "--" argument.  */
2296   for (; idx < argc; idx++)
2297     {
2298       name_add_name (argv[idx], MAKE_INCL_OPTIONS (&args));
2299       args.input_files = true;
2300     }
2301
2302   /* Warn about implicit use of the wildcards in command line arguments.
2303      See TODO */
2304   warn_regex_usage = args.wildcards == default_wildcards;
2305
2306   /* Derive option values and check option consistency.  */
2307
2308   if (archive_format == DEFAULT_FORMAT)
2309     {
2310       if (args.pax_option)
2311         archive_format = POSIX_FORMAT;
2312       else
2313         archive_format = DEFAULT_ARCHIVE_FORMAT;
2314     }
2315
2316   if ((volume_label_option && subcommand_option == CREATE_SUBCOMMAND)
2317       || incremental_option
2318       || multi_volume_option
2319       || sparse_option)
2320     assert_format (FORMAT_MASK (OLDGNU_FORMAT)
2321                    | FORMAT_MASK (GNU_FORMAT)
2322                    | FORMAT_MASK (POSIX_FORMAT));
2323
2324   if (occurrence_option)
2325     {
2326       if (!args.input_files)
2327         USAGE_ERROR ((0, 0,
2328                       _("--occurrence is meaningless without a file list")));
2329       if (subcommand_option != DELETE_SUBCOMMAND
2330           && subcommand_option != DIFF_SUBCOMMAND
2331           && subcommand_option != EXTRACT_SUBCOMMAND
2332           && subcommand_option != LIST_SUBCOMMAND)
2333             USAGE_ERROR ((0, 0,
2334                           _("--occurrence cannot be used in the requested operation mode")));
2335     }
2336
2337   if (archive_names == 0)
2338     {
2339       /* If no archive file name given, try TAPE from the environment, or
2340          else, DEFAULT_ARCHIVE from the configuration process.  */
2341
2342       archive_names = 1;
2343       archive_name_array[0] = getenv ("TAPE");
2344       if (! archive_name_array[0])
2345         archive_name_array[0] = DEFAULT_ARCHIVE;
2346     }
2347
2348   /* Allow multiple archives only with `-M'.  */
2349
2350   if (archive_names > 1 && !multi_volume_option)
2351     USAGE_ERROR ((0, 0,
2352                   _("Multiple archive files require `-M' option")));
2353
2354   if (listed_incremental_option
2355       && NEWER_OPTION_INITIALIZED (newer_mtime_option))
2356     USAGE_ERROR ((0, 0,
2357                   _("Cannot combine --listed-incremental with --newer")));
2358   if (incremental_level != -1 && !listed_incremental_option)
2359     WARN ((0, 0,
2360            _("--level is meaningless without --listed-incremental")));
2361
2362   if (volume_label_option)
2363     {
2364       if (archive_format == GNU_FORMAT || archive_format == OLDGNU_FORMAT)
2365         {
2366           size_t volume_label_max_len =
2367             (sizeof current_header->header.name
2368              - 1 /* for trailing '\0' */
2369              - (multi_volume_option
2370                 ? (sizeof " Volume "
2371                    - 1 /* for null at end of " Volume " */
2372                    + INT_STRLEN_BOUND (int) /* for volume number */
2373                    - 1 /* for sign, as 0 <= volno */)
2374                 : 0));
2375           if (volume_label_max_len < strlen (volume_label_option))
2376             USAGE_ERROR ((0, 0,
2377                           ngettext ("%s: Volume label is too long (limit is %lu byte)",
2378                                     "%s: Volume label is too long (limit is %lu bytes)",
2379                                     volume_label_max_len),
2380                           quotearg_colon (volume_label_option),
2381                           (unsigned long) volume_label_max_len));
2382         }
2383       /* else FIXME
2384          Label length in PAX format is limited by the volume size. */
2385     }
2386
2387   if (verify_option)
2388     {
2389       if (multi_volume_option)
2390         USAGE_ERROR ((0, 0, _("Cannot verify multi-volume archives")));
2391       if (use_compress_program_option)
2392         USAGE_ERROR ((0, 0, _("Cannot verify compressed archives")));
2393     }
2394
2395   if (use_compress_program_option)
2396     {
2397       if (multi_volume_option)
2398         USAGE_ERROR ((0, 0, _("Cannot use multi-volume compressed archives")));
2399       if (subcommand_option == UPDATE_SUBCOMMAND
2400           || subcommand_option == APPEND_SUBCOMMAND
2401           || subcommand_option == DELETE_SUBCOMMAND)
2402         USAGE_ERROR ((0, 0, _("Cannot update compressed archives")));
2403       if (subcommand_option == CAT_SUBCOMMAND)
2404         USAGE_ERROR ((0, 0, _("Cannot concatenate compressed archives")));
2405     }
2406
2407   /* It is no harm to use --pax-option on non-pax archives in archive
2408      reading mode. It may even be useful, since it allows to override
2409      file attributes from tar headers. Therefore I allow such usage.
2410      --gray */
2411   if (args.pax_option
2412       && archive_format != POSIX_FORMAT
2413       && (subcommand_option != EXTRACT_SUBCOMMAND
2414           || subcommand_option != DIFF_SUBCOMMAND
2415           || subcommand_option != LIST_SUBCOMMAND))
2416     USAGE_ERROR ((0, 0, _("--pax-option can be used only on POSIX archives")));
2417
2418   /* If ready to unlink hierarchies, so we are for simpler files.  */
2419   if (recursive_unlink_option)
2420     old_files_option = UNLINK_FIRST_OLD_FILES;
2421
2422
2423   if (test_label_option)
2424     {
2425       /* --test-label is silent if the user has specified the label name to
2426          compare against. */
2427       if (!args.input_files)
2428         verbose_option++;
2429     }
2430   else if (utc_option)
2431     verbose_option = 2;
2432
2433   if (tape_length_option && tape_length_option < record_size)
2434     USAGE_ERROR ((0, 0, _("Volume length cannot be less than record size")));
2435
2436   if (same_order_option && listed_incremental_option)
2437     USAGE_ERROR ((0, 0, _("--preserve-order is not compatible with "
2438                           "--listed-incremental")));
2439
2440   /* Forbid using -c with no input files whatsoever.  Check that `-f -',
2441      explicit or implied, is used correctly.  */
2442
2443   switch (subcommand_option)
2444     {
2445     case CREATE_SUBCOMMAND:
2446       if (!args.input_files && !files_from_option)
2447         USAGE_ERROR ((0, 0,
2448                       _("Cowardly refusing to create an empty archive")));
2449       if (args.compress_autodetect && archive_names
2450           && strcmp (archive_name_array[0], "-"))
2451         set_comression_program_by_suffix (archive_name_array[0],
2452                                           use_compress_program_option);
2453       break;
2454
2455     case EXTRACT_SUBCOMMAND:
2456     case LIST_SUBCOMMAND:
2457     case DIFF_SUBCOMMAND:
2458       for (archive_name_cursor = archive_name_array;
2459            archive_name_cursor < archive_name_array + archive_names;
2460            archive_name_cursor++)
2461         if (!strcmp (*archive_name_cursor, "-"))
2462           request_stdin ("-f");
2463       break;
2464
2465     case CAT_SUBCOMMAND:
2466     case UPDATE_SUBCOMMAND:
2467     case APPEND_SUBCOMMAND:
2468       for (archive_name_cursor = archive_name_array;
2469            archive_name_cursor < archive_name_array + archive_names;
2470            archive_name_cursor++)
2471         if (!strcmp (*archive_name_cursor, "-"))
2472           USAGE_ERROR ((0, 0,
2473                         _("Options `-Aru' are incompatible with `-f -'")));
2474
2475     default:
2476       break;
2477     }
2478
2479   /* Initialize stdlis */
2480   if (index_file_name)
2481     {
2482       stdlis = fopen (index_file_name, "w");
2483       if (! stdlis)
2484         open_error (index_file_name);
2485     }
2486   else
2487     stdlis = to_stdout_option ? stderr : stdout;
2488
2489   archive_name_cursor = archive_name_array;
2490
2491   /* Prepare for generating backup names.  */
2492
2493   if (args.backup_suffix_string)
2494     simple_backup_suffix = xstrdup (args.backup_suffix_string);
2495
2496   if (backup_option)
2497     {
2498       backup_type = xget_version ("--backup", args.version_control_string);
2499       /* No backup is needed either if explicitely disabled or if
2500          the extracted files are not being written to disk. */
2501       if (backup_type == no_backups || EXTRACT_OVER_PIPE)
2502         backup_option = false;
2503     }
2504
2505   checkpoint_finish_compile ();
2506
2507   report_textual_dates (&args);
2508 }
2509
2510 \f
2511 /* Tar proper.  */
2512
2513 /* Main routine for tar.  */
2514 int
2515 main (int argc, char **argv)
2516 {
2517   set_start_time ();
2518   set_program_name (argv[0]);
2519
2520   setlocale (LC_ALL, "");
2521   bindtextdomain (PACKAGE, LOCALEDIR);
2522   textdomain (PACKAGE);
2523
2524   exit_failure = TAREXIT_FAILURE;
2525   exit_status = TAREXIT_SUCCESS;
2526   filename_terminator = '\n';
2527   set_quoting_style (0, DEFAULT_QUOTING_STYLE);
2528
2529   /* Make sure we have first three descriptors available */
2530   stdopen ();
2531
2532   /* Pre-allocate a few structures.  */
2533
2534   allocated_archive_names = 10;
2535   archive_name_array =
2536     xmalloc (sizeof (const char *) * allocated_archive_names);
2537   archive_names = 0;
2538
2539   obstack_init (&argv_stk);
2540
2541   /* Ensure default behavior for some signals */
2542   signal (SIGPIPE, SIG_DFL);
2543   /* System V fork+wait does not work if SIGCHLD is ignored.  */
2544   signal (SIGCHLD, SIG_DFL);
2545
2546   /* Try to disable the ability to unlink a directory.  */
2547   priv_set_remove_linkdir ();
2548
2549   /* Decode options.  */
2550
2551   decode_options (argc, argv);
2552
2553   name_init ();
2554
2555   /* Main command execution.  */
2556
2557   if (volno_file_option)
2558     init_volume_number ();
2559
2560   switch (subcommand_option)
2561     {
2562     case UNKNOWN_SUBCOMMAND:
2563       USAGE_ERROR ((0, 0,
2564                     _("You must specify one of the `-Acdtrux' options")));
2565
2566     case CAT_SUBCOMMAND:
2567     case UPDATE_SUBCOMMAND:
2568     case APPEND_SUBCOMMAND:
2569       update_archive ();
2570       break;
2571
2572     case DELETE_SUBCOMMAND:
2573       delete_archive_members ();
2574       break;
2575
2576     case CREATE_SUBCOMMAND:
2577       create_archive ();
2578       break;
2579
2580     case EXTRACT_SUBCOMMAND:
2581       extr_init ();
2582       read_and (extract_archive);
2583
2584       /* FIXME: should extract_finish () even if an ordinary signal is
2585          received.  */
2586       extract_finish ();
2587
2588       break;
2589
2590     case LIST_SUBCOMMAND:
2591       read_and (list_archive);
2592       break;
2593
2594     case DIFF_SUBCOMMAND:
2595       diff_init ();
2596       read_and (diff_archive);
2597       break;
2598     }
2599
2600   if (totals_option)
2601     print_total_stats ();
2602
2603   if (check_links_option)
2604     check_links ();
2605
2606   if (volno_file_option)
2607     closeout_volume_number ();
2608
2609   /* Dispose of allocated memory, and return.  */
2610
2611   free (archive_name_array);
2612   name_term ();
2613
2614   if (exit_status == TAREXIT_FAILURE)
2615     error (0, 0, _("Exiting with failure status due to previous errors"));
2616
2617   if (stdlis == stdout)
2618     close_stdout ();
2619   else if (ferror (stderr) || fclose (stderr) != 0)
2620     set_exit_status (TAREXIT_FAILURE);
2621
2622   return exit_status;
2623 }
2624
2625 void
2626 tar_stat_init (struct tar_stat_info *st)
2627 {
2628   memset (st, 0, sizeof (*st));
2629 }
2630
2631 void
2632 tar_stat_destroy (struct tar_stat_info *st)
2633 {
2634   free (st->orig_file_name);
2635   free (st->file_name);
2636   free (st->link_name);
2637   free (st->uname);
2638   free (st->gname);
2639   free (st->sparse_map);
2640   free (st->dumpdir);
2641   xheader_destroy (&st->xhdr);
2642   memset (st, 0, sizeof (*st));
2643 }
2644
2645 /* Format mask for all available formats that support nanosecond
2646    timestamp resolution. */
2647 #define NS_PRECISION_FORMAT_MASK FORMAT_MASK (POSIX_FORMAT)
2648
2649 /* Same as timespec_cmp, but ignore nanoseconds if current archive
2650    format does not provide sufficient resolution.  */
2651 int
2652 tar_timespec_cmp (struct timespec a, struct timespec b)
2653 {
2654   if (!(FORMAT_MASK (current_format) & NS_PRECISION_FORMAT_MASK))
2655     a.tv_nsec = b.tv_nsec = 0;
2656   return timespec_cmp (a, b);
2657 }
2658
2659 /* Set tar exit status to VAL, unless it is already indicating
2660    a more serious condition. This relies on the fact that the
2661    values of TAREXIT_ constants are ranged by severity. */
2662 void
2663 set_exit_status (int val)
2664 {
2665   if (val > exit_status)
2666     exit_status = val;
2667 }