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