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