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

   1 /* A tar (tape archiver) program.
   2
   3    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000,
   4    2001, 2003, 2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
   5
   6    Written by John Gilmore, starting 1985-08-25.
   7
   8    This program is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by the
  10    Free Software Foundation; either version 3, or (at your option) any later
  11    version.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
  16    Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License along
  19    with this program; if not, write to the Free Software Foundation, Inc.,
  20    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  21
  22 #include <system.h>
  23
  24 #include <fnmatch.h>
  25 #include <argp.h>
  26 #include <argp-namefrob.h>
  27 #include <argp-fmtstream.h>
  28 #include <argp-version-etc.h>
  29
  30 #include <signal.h>
  31 #if ! defined SIGCHLD && defined SIGCLD
  32 # define SIGCHLD SIGCLD
  33 #endif
  34
  35 /* The following causes "common.h" to produce definitions of all the global
  36    variables, rather than just "extern" declarations of them.  GNU tar does
  37    depend on the system loader to preset all GLOBAL variables to neutral (or
  38    zero) values; explicit initialization is usually not done.  */
  39 #define GLOBAL
  40 #include "common.h"
  41
  42 #include <argmatch.h>
  43 #include <closeout.h>
  44 #include <configmake.h>
  45 #include <exitfail.h>
  46 #include <getdate.h>
  47 #include <rmt.h>
  48 #include <rmt-command.h>
  49 #include <prepargs.h>
  50 #include <quotearg.h>
  51 #include <version-etc.h>
  52 #include <xstrtol.h>
  53 #include <stdopen.h>
  54 #include <priv-set.h>
  55
  56 /* Local declarations.  */
  57
  58 #ifndef DEFAULT_ARCHIVE_FORMAT
  59 # define DEFAULT_ARCHIVE_FORMAT GNU_FORMAT
  60 #endif
  61
  62 #ifndef DEFAULT_ARCHIVE
  63 # define DEFAULT_ARCHIVE "tar.out"
  64 #endif
  65
  66 #ifndef DEFAULT_BLOCKING
  67 # define DEFAULT_BLOCKING 20
  68 #endif
  69
  70 \f
  71 /* Miscellaneous.  */
  72
  73 /* Name of option using stdin.  */
  74 static const char *stdin_used_by;
  75
  76 /* Doesn't return if stdin already requested.  */
  77 void
  78 request_stdin (const char *option)
  79 {
  80   if (stdin_used_by)
  81     USAGE_ERROR ((0, 0, _("Options `-%s' and `-%s' both want standard input"),
  82                   stdin_used_by, option));
  83
  84   stdin_used_by = option;
  85 }
  86
  87 extern int rpmatch (char const *response);
  88
  89 /* Returns true if and only if the user typed an affirmative response.  */
  90 int
  91 confirm (const char *message_action, const char *message_name)
  92 {
  93   static FILE *confirm_file;
  94   static int confirm_file_EOF;
  95   bool status = false;
  96
  97   if (!confirm_file)
  98     {
  99       if (archive == 0 || stdin_used_by)
 100         {
 101           confirm_file = fopen (TTY_NAME, "r");
 102           if (! confirm_file)
 103             open_fatal (TTY_NAME);
 104         }
 105       else
 106         {
 107           request_stdin ("-w");
 108           confirm_file = stdin;
 109         }
 110     }
 111
 112   fprintf (stdlis, "%s %s?", message_action, quote (message_name));
 113   fflush (stdlis);
 114
 115   if (!confirm_file_EOF)
 116     {
 117       char *response = NULL;
 118       size_t response_size = 0;
 119       if (getline (&response, &response_size, confirm_file) < 0)
 120         confirm_file_EOF = 1;
 121       else
 122         status = rpmatch (response) > 0;
 123       free (response);
 124     }
 125
 126   if (confirm_file_EOF)
 127     {
 128       fputc ('\n', stdlis);
 129       fflush (stdlis);
 130     }
 131
 132   return status;
 133 }
 134
 135 static struct fmttab {
 136   char const *name;
 137   enum archive_format fmt;
 138 } const fmttab[] = {
 139   { "v7",      V7_FORMAT },
 140   { "oldgnu",  OLDGNU_FORMAT },
 141   { "ustar",   USTAR_FORMAT },
 142   { "posix",   POSIX_FORMAT },
 143 #if 0 /* not fully supported yet */
 144   { "star",    STAR_FORMAT },
 145 #endif
 146   { "gnu",     GNU_FORMAT },
 147   { "pax",     POSIX_FORMAT }, /* An alias for posix */
 148   { NULL,      0 }
 149 };
 150
 151 static void
 152 set_archive_format (char const *name)
 153 {
 154   struct fmttab const *p;
 155
 156   for (p = fmttab; strcmp (p->name, name) != 0; )
 157     if (! (++p)->name)
 158       USAGE_ERROR ((0, 0, _("%s: Invalid archive format"),
 159                     quotearg_colon (name)));
 160
 161   archive_format = p->fmt;
 162 }
 163
 164 const char *
 165 archive_format_string (enum archive_format fmt)
 166 {
 167   struct fmttab const *p;
 168
 169   for (p = fmttab; p->name; p++)
 170     if (p->fmt == fmt)
 171       return p->name;
 172   return "unknown?";
 173 }
 174
 175 #define FORMAT_MASK(n) (1<<(n))
 176
 177 static void
 178 assert_format(unsigned fmt_mask)
 179 {
 180   if ((FORMAT_MASK (archive_format) & fmt_mask) == 0)
 181     USAGE_ERROR ((0, 0,
 182                   _("GNU features wanted on incompatible archive format")));
 183 }
 184
 185 const char *
 186 subcommand_string (enum subcommand c)
 187 {
 188   switch (c)
 189     {
 190     case UNKNOWN_SUBCOMMAND:
 191       return "unknown?";
 192
 193     case APPEND_SUBCOMMAND:
 194       return "-r";
 195
 196     case CAT_SUBCOMMAND:
 197       return "-A";
 198
 199     case CREATE_SUBCOMMAND:
 200       return "-c";
 201
 202     case DELETE_SUBCOMMAND:
 203       return "-D";
 204
 205     case DIFF_SUBCOMMAND:
 206       return "-d";
 207
 208     case EXTRACT_SUBCOMMAND:
 209       return "-x";
 210
 211     case LIST_SUBCOMMAND:
 212       return "-t";
 213
 214     case UPDATE_SUBCOMMAND:
 215       return "-u";
 216
 217     default:
 218       abort ();
 219     }
 220 }
 221
 222 void
 223 tar_list_quoting_styles (struct obstack *stk, char *prefix)
 224 {
 225   int i;
 226   size_t prefixlen = strlen (prefix);
 227
 228   for (i = 0; quoting_style_args[i]; i++)
 229     {
 230       obstack_grow (stk, prefix, prefixlen);
 231       obstack_grow (stk, quoting_style_args[i],
 232                     strlen (quoting_style_args[i]));
 233       obstack_1grow (stk, '\n');
 234     }
 235 }
 236
 237 void
 238 tar_set_quoting_style (char *arg)
 239 {
 240   int i;
 241
 242   for (i = 0; quoting_style_args[i]; i++)
 243     if (strcmp (arg, quoting_style_args[i]) == 0)
 244       {
 245         set_quoting_style (NULL, i);
 246         return;
 247       }
 248   FATAL_ERROR ((0, 0,
 249                 _("Unknown quoting style `%s'. Try `%s --quoting-style=help' to get a list."), arg, program_invocation_short_name));
 250 }
 251
 252 \f
 253 /* Options.  */
 254
 255 enum
 256 {
 257   ANCHORED_OPTION = CHAR_MAX + 1,
 258   ATIME_PRESERVE_OPTION,
 259   BACKUP_OPTION,
 260   CHECK_DEVICE_OPTION,
 261   CHECKPOINT_OPTION,
 262   CHECKPOINT_ACTION_OPTION,
 263   DELAY_DIRECTORY_RESTORE_OPTION,
 264   HARD_DEREFERENCE_OPTION,
 265   DELETE_OPTION,
 266   EXCLUDE_BACKUPS_OPTION,
 267   EXCLUDE_CACHES_OPTION,
 268   EXCLUDE_CACHES_UNDER_OPTION,
 269   EXCLUDE_CACHES_ALL_OPTION,
 270   EXCLUDE_OPTION,
 271   EXCLUDE_TAG_OPTION,
 272   EXCLUDE_TAG_UNDER_OPTION,
 273   EXCLUDE_TAG_ALL_OPTION,
 274   EXCLUDE_VCS_OPTION,
 275   FORCE_LOCAL_OPTION,
 276   GROUP_OPTION,
 277   IGNORE_CASE_OPTION,
 278   IGNORE_COMMAND_ERROR_OPTION,
 279   IGNORE_FAILED_READ_OPTION,
 280   INDEX_FILE_OPTION,
 281   KEEP_NEWER_FILES_OPTION,
 282   LEVEL_OPTION,
 283   LZMA_OPTION,
 284   LZOP_OPTION,
 285   MODE_OPTION,
 286   MTIME_OPTION,
 287   NEWER_MTIME_OPTION,
 288   NO_ANCHORED_OPTION,
 289   NO_AUTO_COMPRESS_OPTION,
 290   NO_CHECK_DEVICE_OPTION,
 291   NO_DELAY_DIRECTORY_RESTORE_OPTION,
 292   NO_IGNORE_CASE_OPTION,
 293   NO_IGNORE_COMMAND_ERROR_OPTION,
 294   NO_NULL_OPTION,
 295   NO_OVERWRITE_DIR_OPTION,
 296   NO_QUOTE_CHARS_OPTION,
 297   NO_RECURSION_OPTION,
 298   NO_SAME_OWNER_OPTION,
 299   NO_SAME_PERMISSIONS_OPTION,
 300   NO_SEEK_OPTION,
 301   NO_UNQUOTE_OPTION,
 302   NO_WILDCARDS_MATCH_SLASH_OPTION,
 303   NO_WILDCARDS_OPTION,
 304   NULL_OPTION,
 305   NUMERIC_OWNER_OPTION,
 306   OCCURRENCE_OPTION,
 307   OLD_ARCHIVE_OPTION,
 308   ONE_FILE_SYSTEM_OPTION,
 309   OVERWRITE_DIR_OPTION,
 310   OVERWRITE_OPTION,
 311   OWNER_OPTION,
 312   PAX_OPTION,
 313   POSIX_OPTION,
 314   PRESERVE_OPTION,
 315   QUOTE_CHARS_OPTION,
 316   QUOTING_STYLE_OPTION,
 317   RECORD_SIZE_OPTION,
 318   RECURSION_OPTION,
 319   RECURSIVE_UNLINK_OPTION,
 320   REMOVE_FILES_OPTION,
 321   RESTRICT_OPTION,
 322   RMT_COMMAND_OPTION,
 323   RSH_COMMAND_OPTION,
 324   SAME_OWNER_OPTION,
 325   SHOW_DEFAULTS_OPTION,
 326   SHOW_OMITTED_DIRS_OPTION,
 327   SHOW_TRANSFORMED_NAMES_OPTION,
 328   SPARSE_VERSION_OPTION,
 329   STRIP_COMPONENTS_OPTION,
 330   SUFFIX_OPTION,
 331   TEST_LABEL_OPTION,
 332   TOTALS_OPTION,
 333   TO_COMMAND_OPTION,
 334   TRANSFORM_OPTION,
 335   UNQUOTE_OPTION,
 336   UTC_OPTION,
 337   VOLNO_FILE_OPTION,
 338   WARNING_OPTION,
 339   WILDCARDS_MATCH_SLASH_OPTION,
 340   WILDCARDS_OPTION
 341 };
 342
 343 const char *argp_program_version = "tar (" PACKAGE_NAME ") " VERSION;
 344 const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">";
 345 static char const doc[] = N_("\
 346 GNU `tar' saves many files together into a single tape or disk archive, \
 347 and can restore individual files from the archive.\n\
 348 \n\
 349 Examples:\n\
 350   tar -cf archive.tar foo bar  # Create archive.tar from files foo and bar.\n\
 351   tar -tvf archive.tar         # List all files in archive.tar verbosely.\n\
 352   tar -xf archive.tar          # Extract all files from archive.tar.\n")
 353 "\v"
 354 N_("The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
 355 The version control may be set with --backup or VERSION_CONTROL, values are:\n\n\
 356   none, off       never make backups\n\
 357   t, numbered     make numbered backups\n\
 358   nil, existing   numbered if numbered backups exist, simple otherwise\n\
 359   never, simple   always make simple backups\n");
 360
 361
 362 /* NOTE:
 363
 364    Available option letters are DEQY and eqy. Consider the following
 365    assignments:
 366
 367    [For Solaris tar compatibility =/= Is it important at all?]
 368    e  exit immediately with a nonzero exit status if unexpected errors occur
 369    E  use extended headers (--format=posix)
 370
 371    [q  alias for --occurrence=1 =/= this would better be used for quiet?]
 372
 373    y  per-file gzip compression
 374    Y  per-block gzip compression.
 375
 376    Additionally, the 'n' letter is assigned for option --seek, which
 377    is probably not needed and should be marked as deprecated, so that
 378    -n may become available in the future.
 379 */
 380
 381 static struct argp_option options[] = {
 382 #define GRID 10
 383   {NULL, 0, NULL, 0,
 384    N_("Main operation mode:"), GRID },
 385
 386   {"list", 't', 0, 0,
 387    N_("list the contents of an archive"), GRID+1 },
 388   {"extract", 'x', 0, 0,
 389    N_("extract files from an archive"), GRID+1 },
 390   {"get", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 391   {"create", 'c', 0, 0,
 392    N_("create a new archive"), GRID+1 },
 393   {"diff", 'd', 0, 0,
 394    N_("find differences between archive and file system"), GRID+1 },
 395   {"compare", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 396   {"append", 'r', 0, 0,
 397    N_("append files to the end of an archive"), GRID+1 },
 398   {"update", 'u', 0, 0,
 399    N_("only append files newer than copy in archive"), GRID+1 },
 400   {"catenate", 'A', 0, 0,
 401    N_("append tar files to an archive"), GRID+1 },
 402   {"concatenate", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 403   {"delete", DELETE_OPTION, 0, 0,
 404    N_("delete from the archive (not on mag tapes!)"), GRID+1 },
 405   {"test-label", TEST_LABEL_OPTION, NULL, 0,
 406    N_("test the archive volume label and exit"), GRID+1 },
 407 #undef GRID
 408
 409 #define GRID 20
 410   {NULL, 0, NULL, 0,
 411    N_("Operation modifiers:"), GRID },
 412
 413   {"sparse", 'S', 0, 0,
 414    N_("handle sparse files efficiently"), GRID+1 },
 415   {"sparse-version", SPARSE_VERSION_OPTION, N_("MAJOR[.MINOR]"), 0,
 416    N_("set version of the sparse format to use (implies --sparse)"), GRID+1},
 417   {"incremental", 'G', 0, 0,
 418    N_("handle old GNU-format incremental backup"), GRID+1 },
 419   {"listed-incremental", 'g', N_("FILE"), 0,
 420    N_("handle new GNU-format incremental backup"), GRID+1 },
 421   {"level", LEVEL_OPTION, N_("NUMBER"), 0,
 422    N_("dump level for created listed-incremental archive"), GRID+1 },
 423   {"ignore-failed-read", IGNORE_FAILED_READ_OPTION, 0, 0,
 424    N_("do not exit with nonzero on unreadable files"), GRID+1 },
 425   {"occurrence", OCCURRENCE_OPTION, N_("NUMBER"), OPTION_ARG_OPTIONAL,
 426    N_("process only the NUMBERth occurrence of each file in the archive;"
 427       " this option is valid only in conjunction with one of the subcommands"
 428       " --delete, --diff, --extract or --list and when a list of files"
 429       " is given either on the command line or via the -T option;"
 430       " NUMBER defaults to 1"), GRID+1 },
 431   {"seek", 'n', NULL, 0,
 432    N_("archive is seekable"), GRID+1 },
 433   {"no-seek", NO_SEEK_OPTION, NULL, 0,
 434    N_("archive is not seekable"), GRID+1 },
 435   {"no-check-device", NO_CHECK_DEVICE_OPTION, NULL, 0,
 436    N_("do not check device numbers when creating incremental archives"),
 437    GRID+1 },
 438   {"check-device", CHECK_DEVICE_OPTION, NULL, 0,
 439    N_("check device numbers when creating incremental archives (default)"),
 440    GRID+1 },
 441 #undef GRID
 442
 443 #define GRID 30
 444   {NULL, 0, NULL, 0,
 445    N_("Overwrite control:"), GRID },
 446
 447   {"verify", 'W', 0, 0,
 448    N_("attempt to verify the archive after writing it"), GRID+1 },
 449   {"remove-files", REMOVE_FILES_OPTION, 0, 0,
 450    N_("remove files after adding them to the archive"), GRID+1 },
 451   {"keep-old-files", 'k', 0, 0,
 452    N_("don't replace existing files when extracting"), GRID+1 },
 453   {"keep-newer-files", KEEP_NEWER_FILES_OPTION, 0, 0,
 454    N_("don't replace existing files that are newer than their archive copies"), GRID+1 },
 455   {"overwrite", OVERWRITE_OPTION, 0, 0,
 456    N_("overwrite existing files when extracting"), GRID+1 },
 457   {"unlink-first", 'U', 0, 0,
 458    N_("remove each file prior to extracting over it"), GRID+1 },
 459   {"recursive-unlink", RECURSIVE_UNLINK_OPTION, 0, 0,
 460    N_("empty hierarchies prior to extracting directory"), GRID+1 },
 461   {"no-overwrite-dir", NO_OVERWRITE_DIR_OPTION, 0, 0,
 462    N_("preserve metadata of existing directories"), GRID+1 },
 463   {"overwrite-dir", OVERWRITE_DIR_OPTION, 0, 0,
 464    N_("overwrite metadata of existing directories when extracting (default)"),
 465    GRID+1 },
 466 #undef GRID
 467
 468 #define GRID 40
 469   {NULL, 0, NULL, 0,
 470    N_("Select output stream:"), GRID },
 471
 472   {"to-stdout", 'O', 0, 0,
 473    N_("extract files to standard output"), GRID+1 },
 474   {"to-command", TO_COMMAND_OPTION, N_("COMMAND"), 0,
 475    N_("pipe extracted files to another program"), GRID+1 },
 476   {"ignore-command-error", IGNORE_COMMAND_ERROR_OPTION, 0, 0,
 477    N_("ignore exit codes of children"), GRID+1 },
 478   {"no-ignore-command-error", NO_IGNORE_COMMAND_ERROR_OPTION, 0, 0,
 479    N_("treat non-zero exit codes of children as error"), GRID+1 },
 480 #undef GRID
 481
 482 #define GRID 50
 483   {NULL, 0, NULL, 0,
 484    N_("Handling of file attributes:"), GRID },
 485
 486   {"owner", OWNER_OPTION, N_("NAME"), 0,
 487    N_("force NAME as owner for added files"), GRID+1 },
 488   {"group", GROUP_OPTION, N_("NAME"), 0,
 489    N_("force NAME as group for added files"), GRID+1 },
 490   {"mtime", MTIME_OPTION, N_("DATE-OR-FILE"), 0,
 491    N_("set mtime for added files from DATE-OR-FILE"), GRID+1 },
 492   {"mode", MODE_OPTION, N_("CHANGES"), 0,
 493    N_("force (symbolic) mode CHANGES for added files"), GRID+1 },
 494   {"atime-preserve", ATIME_PRESERVE_OPTION,
 495    N_("METHOD"), OPTION_ARG_OPTIONAL,
 496    N_("preserve access times on dumped files, either by restoring the times"
 497       " after reading (METHOD='replace'; default) or by not setting the times"
 498       " in the first place (METHOD='system')"), GRID+1 },
 499   {"touch", 'm', 0, 0,
 500    N_("don't extract file modified time"), GRID+1 },
 501   {"same-owner", SAME_OWNER_OPTION, 0, 0,
 502    N_("try extracting files with the same ownership as exists in the archive (default for superuser)"), GRID+1 },
 503   {"no-same-owner", NO_SAME_OWNER_OPTION, 0, 0,
 504    N_("extract files as yourself (default for ordinary users)"), GRID+1 },
 505   {"numeric-owner", NUMERIC_OWNER_OPTION, 0, 0,
 506    N_("always use numbers for user/group names"), GRID+1 },
 507   {"preserve-permissions", 'p', 0, 0,
 508    N_("extract information about file permissions (default for superuser)"),
 509    GRID+1 },
 510   {"same-permissions", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 511   {"no-same-permissions", NO_SAME_PERMISSIONS_OPTION, 0, 0,
 512    N_("apply the user's umask when extracting permissions from the archive (default for ordinary users)"), GRID+1 },
 513   {"preserve-order", 's', 0, 0,
 514    N_("sort names to extract to match archive"), GRID+1 },
 515   {"same-order", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 516   {"preserve", PRESERVE_OPTION, 0, 0,
 517    N_("same as both -p and -s"), GRID+1 },
 518   {"delay-directory-restore", DELAY_DIRECTORY_RESTORE_OPTION, 0, 0,
 519    N_("delay setting modification times and permissions of extracted"
 520       " directories until the end of extraction"), GRID+1 },
 521   {"no-delay-directory-restore", NO_DELAY_DIRECTORY_RESTORE_OPTION, 0, 0,
 522    N_("cancel the effect of --delay-directory-restore option"), GRID+1 },
 523 #undef GRID
 524
 525 #define GRID 60
 526   {NULL, 0, NULL, 0,
 527    N_("Device selection and switching:"), GRID },
 528
 529   {"file", 'f', N_("ARCHIVE"), 0,
 530    N_("use archive file or device ARCHIVE"), GRID+1 },
 531   {"force-local", FORCE_LOCAL_OPTION, 0, 0,
 532    N_("archive file is local even if it has a colon"), GRID+1 },
 533   {"rmt-command", RMT_COMMAND_OPTION, N_("COMMAND"), 0,
 534    N_("use given rmt COMMAND instead of rmt"), GRID+1 },
 535   {"rsh-command", RSH_COMMAND_OPTION, N_("COMMAND"), 0,
 536    N_("use remote COMMAND instead of rsh"), GRID+1 },
 537 #ifdef DEVICE_PREFIX
 538   {"-[0-7][lmh]", 0, NULL, OPTION_DOC, /* It is OK, since `name' will never be
 539                                           translated */
 540    N_("specify drive and density"), GRID+1 },
 541 #endif
 542   {NULL, '0', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 543   {NULL, '1', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 544   {NULL, '2', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 545   {NULL, '3', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 546   {NULL, '4', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 547   {NULL, '5', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 548   {NULL, '6', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 549   {NULL, '7', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 550   {NULL, '8', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 551   {NULL, '9', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 552
 553   {"multi-volume", 'M', 0, 0,
 554    N_("create/list/extract multi-volume archive"), GRID+1 },
 555   {"tape-length", 'L', N_("NUMBER"), 0,
 556    N_("change tape after writing NUMBER x 1024 bytes"), GRID+1 },
 557   {"info-script", 'F', N_("NAME"), 0,
 558    N_("run script at end of each tape (implies -M)"), GRID+1 },
 559   {"new-volume-script", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 560   {"volno-file", VOLNO_FILE_OPTION, N_("FILE"), 0,
 561    N_("use/update the volume number in FILE"), GRID+1 },
 562 #undef GRID
 563
 564 #define GRID 70
 565   {NULL, 0, NULL, 0,
 566    N_("Device blocking:"), GRID },
 567
 568   {"blocking-factor", 'b', N_("BLOCKS"), 0,
 569    N_("BLOCKS x 512 bytes per record"), GRID+1 },
 570   {"record-size", RECORD_SIZE_OPTION, N_("NUMBER"), 0,
 571    N_("NUMBER of bytes per record, multiple of 512"), GRID+1 },
 572   {"ignore-zeros", 'i', 0, 0,
 573    N_("ignore zeroed blocks in archive (means EOF)"), GRID+1 },
 574   {"read-full-records", 'B', 0, 0,
 575    N_("reblock as we read (for 4.2BSD pipes)"), GRID+1 },
 576 #undef GRID
 577
 578 #define GRID 80
 579   {NULL, 0, NULL, 0,
 580    N_("Archive format selection:"), GRID },
 581
 582   {"format", 'H', N_("FORMAT"), 0,
 583    N_("create archive of the given format"), GRID+1 },
 584
 585   {NULL, 0, NULL, 0, N_("FORMAT is one of the following:"), GRID+2 },
 586   {"  v7", 0, NULL, OPTION_DOC|OPTION_NO_TRANS, N_("old V7 tar format"),
 587    GRID+3 },
 588   {"  oldgnu", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 589    N_("GNU format as per tar <= 1.12"), GRID+3 },
 590   {"  gnu", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 591    N_("GNU tar 1.13.x format"), GRID+3 },
 592   {"  ustar", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 593    N_("POSIX 1003.1-1988 (ustar) format"), GRID+3 },
 594   {"  pax", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 595    N_("POSIX 1003.1-2001 (pax) format"), GRID+3 },
 596   {"  posix", 0, NULL, OPTION_DOC|OPTION_NO_TRANS, N_("same as pax"), GRID+3 },
 597
 598   {"old-archive", OLD_ARCHIVE_OPTION, 0, 0, /* FIXME */
 599    N_("same as --format=v7"), GRID+8 },
 600   {"portability", 0, 0, OPTION_ALIAS, NULL, GRID+8 },
 601   {"posix", POSIX_OPTION, 0, 0,
 602    N_("same as --format=posix"), GRID+8 },
 603   {"pax-option", PAX_OPTION, N_("keyword[[:]=value][,keyword[[:]=value]]..."), 0,
 604    N_("control pax keywords"), GRID+8 },
 605   {"label", 'V', N_("TEXT"), 0,
 606    N_("create archive with volume name TEXT; at list/extract time, use TEXT as a globbing pattern for volume name"), GRID+8 },
 607 #undef GRID
 608
 609 #define GRID 90
 610   {NULL, 0, NULL, 0,
 611    N_("Compression options:"), GRID },
 612   {"auto-compress", 'a', 0, 0,
 613    N_("use archive suffix to determine the compression program"), GRID+1 },
 614   {"no-auto-compress", NO_AUTO_COMPRESS_OPTION, 0, 0,
 615    N_("do not use archive suffix to determine the compression program"),
 616    GRID+1 },
 617   {"use-compress-program", 'I', N_("PROG"), 0,
 618    N_("filter through PROG (must accept -d)"), GRID+1 },
 619   /* Note: docstrings for the options below are generated by tar_help_filter */
 620   {"bzip2", 'j', 0, 0, NULL, GRID+1 },
 621   {"gzip", 'z', 0, 0, NULL, GRID+1 },
 622   {"gunzip", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 623   {"ungzip", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 624   {"compress", 'Z', 0, 0, NULL, GRID+1 },
 625   {"uncompress", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 626   {"lzma", LZMA_OPTION, 0, 0, NULL, GRID+1 },
 627   {"lzop", LZOP_OPTION, 0, 0, NULL, GRID+1 },
 628   {"xz", 'J', 0, 0, NULL, GRID+1 },
 629 #undef GRID
 630
 631 #define GRID 100
 632   {NULL, 0, NULL, 0,
 633    N_("Local file selection:"), GRID },
 634
 635   {"add-file", ARGP_KEY_ARG, N_("FILE"), 0,
 636    N_("add given FILE to the archive (useful if its name starts with a dash)"), GRID+1 },
 637   {"directory", 'C', N_("DIR"), 0,
 638    N_("change to directory DIR"), GRID+1 },
 639   {"files-from", 'T', N_("FILE"), 0,
 640    N_("get names to extract or create from FILE"), GRID+1 },
 641   {"null", NULL_OPTION, 0, 0,
 642    N_("-T reads null-terminated names, disable -C"), GRID+1 },
 643   {"no-null", NO_NULL_OPTION, 0, 0,
 644    N_("disable the effect of the previous --null option"), GRID+1 },
 645   {"unquote", UNQUOTE_OPTION, 0, 0,
 646    N_("unquote filenames read with -T (default)"), GRID+1 },
 647   {"no-unquote", NO_UNQUOTE_OPTION, 0, 0,
 648    N_("do not unquote filenames read with -T"), GRID+1 },
 649   {"exclude", EXCLUDE_OPTION, N_("PATTERN"), 0,
 650    N_("exclude files, given as a PATTERN"), GRID+1 },
 651   {"exclude-from", 'X', N_("FILE"), 0,
 652    N_("exclude patterns listed in FILE"), GRID+1 },
 653   {"exclude-caches", EXCLUDE_CACHES_OPTION, 0, 0,
 654    N_("exclude contents of directories containing CACHEDIR.TAG, "
 655       "except for the tag file itself"), GRID+1 },
 656   {"exclude-caches-under", EXCLUDE_CACHES_UNDER_OPTION, 0, 0,
 657    N_("exclude everything under directories containing CACHEDIR.TAG"),
 658    GRID+1 },
 659   {"exclude-caches-all", EXCLUDE_CACHES_ALL_OPTION, 0, 0,
 660    N_("exclude directories containing CACHEDIR.TAG"), GRID+1 },
 661   {"exclude-tag", EXCLUDE_TAG_OPTION, N_("FILE"), 0,
 662    N_("exclude contents of directories containing FILE, except"
 663       " for FILE itself"), GRID+1 },
 664   {"exclude-tag-under", EXCLUDE_TAG_UNDER_OPTION, N_("FILE"), 0,
 665    N_("exclude everything under directories containing FILE"), GRID+1 },
 666   {"exclude-tag-all", EXCLUDE_TAG_ALL_OPTION, N_("FILE"), 0,
 667    N_("exclude directories containing FILE"), GRID+1 },
 668   {"exclude-vcs", EXCLUDE_VCS_OPTION, NULL, 0,
 669    N_("exclude version control system directories"), GRID+1 },
 670   {"exclude-backups", EXCLUDE_BACKUPS_OPTION, NULL, 0,
 671    N_("exclude backup and lock files"), GRID+1 },
 672   {"no-recursion", NO_RECURSION_OPTION, 0, 0,
 673    N_("avoid descending automatically in directories"), GRID+1 },
 674   {"one-file-system", ONE_FILE_SYSTEM_OPTION, 0, 0,
 675    N_("stay in local file system when creating archive"), GRID+1 },
 676   {"recursion", RECURSION_OPTION, 0, 0,
 677    N_("recurse into directories (default)"), GRID+1 },
 678   {"absolute-names", 'P', 0, 0,
 679    N_("don't strip leading `/'s from file names"), GRID+1 },
 680   {"dereference", 'h', 0, 0,
 681    N_("follow symlinks; archive and dump the files they point to"), GRID+1 },
 682   {"hard-dereference", HARD_DEREFERENCE_OPTION, 0, 0,
 683    N_("follow hard links; archive and dump the files they refer to"), GRID+1 },
 684   {"starting-file", 'K', N_("MEMBER-NAME"), 0,
 685    N_("begin at member MEMBER-NAME in the archive"), GRID+1 },
 686   {"newer", 'N', N_("DATE-OR-FILE"), 0,
 687    N_("only store files newer than DATE-OR-FILE"), GRID+1 },
 688   {"after-date", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 689   {"newer-mtime", NEWER_MTIME_OPTION, N_("DATE"), 0,
 690    N_("compare date and time when data changed only"), GRID+1 },
 691   {"backup", BACKUP_OPTION, N_("CONTROL"), OPTION_ARG_OPTIONAL,
 692    N_("backup before removal, choose version CONTROL"), GRID+1 },
 693   {"suffix", SUFFIX_OPTION, N_("STRING"), 0,
 694    N_("backup before removal, override usual suffix ('~' unless overridden by environment variable SIMPLE_BACKUP_SUFFIX)"), GRID+1 },
 695 #undef GRID
 696
 697 #define GRID 110
 698   {NULL, 0, NULL, 0,
 699    N_("File name transformations:"), GRID },
 700   {"strip-components", STRIP_COMPONENTS_OPTION, N_("NUMBER"), 0,
 701    N_("strip NUMBER leading components from file names on extraction"),
 702    GRID+1 },
 703   {"transform", TRANSFORM_OPTION, N_("EXPRESSION"), 0,
 704    N_("use sed replace EXPRESSION to transform file names"), GRID+1 },
 705   {"xform", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 706 #undef GRID
 707
 708 #define GRID 120
 709   {NULL, 0, NULL, 0,
 710    N_("File name matching options (affect both exclude and include patterns):"),
 711    GRID },
 712   {"ignore-case", IGNORE_CASE_OPTION, 0, 0,
 713    N_("ignore case"), GRID+1 },
 714   {"anchored", ANCHORED_OPTION, 0, 0,
 715    N_("patterns match file name start"), GRID+1 },
 716   {"no-anchored", NO_ANCHORED_OPTION, 0, 0,
 717    N_("patterns match after any `/' (default for exclusion)"), GRID+1 },
 718   {"no-ignore-case", NO_IGNORE_CASE_OPTION, 0, 0,
 719    N_("case sensitive matching (default)"), GRID+1 },
 720   {"wildcards", WILDCARDS_OPTION, 0, 0,
 721    N_("use wildcards (default for exclusion)"), GRID+1 },
 722   {"no-wildcards", NO_WILDCARDS_OPTION, 0, 0,
 723    N_("verbatim string matching"), GRID+1 },
 724   {"no-wildcards-match-slash", NO_WILDCARDS_MATCH_SLASH_OPTION, 0, 0,
 725    N_("wildcards do not match `/'"), GRID+1 },
 726   {"wildcards-match-slash", WILDCARDS_MATCH_SLASH_OPTION, 0, 0,
 727    N_("wildcards match `/' (default for exclusion)"), GRID+1 },
 728 #undef GRID
 729
 730 #define GRID 130
 731   {NULL, 0, NULL, 0,
 732    N_("Informative output:"), GRID },
 733
 734   {"verbose", 'v', 0, 0,
 735    N_("verbosely list files processed"), GRID+1 },
 736   {"warning", WARNING_OPTION, N_("KEYWORD"), 0,
 737    N_("warning control"), GRID+1 },
 738   {"checkpoint", CHECKPOINT_OPTION, N_("NUMBER"), OPTION_ARG_OPTIONAL,
 739    N_("display progress messages every NUMBERth record (default 10)"),
 740    GRID+1 },
 741   {"checkpoint-action", CHECKPOINT_ACTION_OPTION, N_("ACTION"), 0,
 742    N_("execute ACTION on each checkpoint"),
 743    GRID+1 },
 744   {"check-links", 'l', 0, 0,
 745    N_("print a message if not all links are dumped"), GRID+1 },
 746   {"totals", TOTALS_OPTION, N_("SIGNAL"), OPTION_ARG_OPTIONAL,
 747    N_("print total bytes after processing the archive; "
 748       "with an argument - print total bytes when this SIGNAL is delivered; "
 749       "Allowed signals are: SIGHUP, SIGQUIT, SIGINT, SIGUSR1 and SIGUSR2; "
 750       "the names without SIG prefix are also accepted"), GRID+1 },
 751   {"utc", UTC_OPTION, 0, 0,
 752    N_("print file modification dates in UTC"), GRID+1 },
 753   {"index-file", INDEX_FILE_OPTION, N_("FILE"), 0,
 754    N_("send verbose output to FILE"), GRID+1 },
 755   {"block-number", 'R', 0, 0,
 756    N_("show block number within archive with each message"), GRID+1 },
 757   {"interactive", 'w', 0, 0,
 758    N_("ask for confirmation for every action"), GRID+1 },
 759   {"confirmation", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 760   {"show-defaults", SHOW_DEFAULTS_OPTION, 0, 0,
 761    N_("show tar defaults"), GRID+1 },
 762   {"show-omitted-dirs", SHOW_OMITTED_DIRS_OPTION, 0, 0,
 763    N_("when listing or extracting, list each directory that does not match search criteria"), GRID+1 },
 764   {"show-transformed-names", SHOW_TRANSFORMED_NAMES_OPTION, 0, 0,
 765    N_("show file or archive names after transformation"),
 766    GRID+1 },
 767   {"show-stored-names", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 768   {"quoting-style", QUOTING_STYLE_OPTION, N_("STYLE"), 0,
 769    N_("set name quoting style; see below for valid STYLE values"), GRID+1 },
 770   {"quote-chars", QUOTE_CHARS_OPTION, N_("STRING"), 0,
 771    N_("additionally quote characters from STRING"), GRID+1 },
 772   {"no-quote-chars", NO_QUOTE_CHARS_OPTION, N_("STRING"), 0,
 773    N_("disable quoting for characters from STRING"), GRID+1 },
 774 #undef GRID
 775
 776 #define GRID 140
 777   {NULL, 0, NULL, 0,
 778    N_("Compatibility options:"), GRID },
 779
 780   {NULL, 'o', 0, 0,
 781    N_("when creating, same as --old-archive; when extracting, same as --no-same-owner"), GRID+1 },
 782 #undef GRID
 783
 784 #define GRID 150
 785   {NULL, 0, NULL, 0,
 786    N_("Other options:"), GRID },
 787
 788   {"restrict", RESTRICT_OPTION, 0, 0,
 789    N_("disable use of some potentially harmful options"), -1 },
 790 #undef GRID
 791
 792   {0, 0, 0, 0, 0, 0}
 793 };
 794
 795 static char const *const atime_preserve_args[] =
 796 {
 797   "replace", "system", NULL
 798 };
 799
 800 static enum atime_preserve const atime_preserve_types[] =
 801 {
 802   replace_atime_preserve, system_atime_preserve
 803 };
 804
 805 /* Make sure atime_preserve_types has as much entries as atime_preserve_args
 806    (minus 1 for NULL guard) */
 807 ARGMATCH_VERIFY (atime_preserve_args, atime_preserve_types);
 808
 809 /* Wildcard matching settings */
 810 enum wildcards
 811   {
 812     default_wildcards, /* For exclusion == enable_wildcards,
 813                           for inclusion == disable_wildcards */
 814     disable_wildcards,
 815     enable_wildcards
 816   };
 817
 818 struct tar_args        /* Variables used during option parsing */
 819 {
 820   struct textual_date *textual_date; /* Keeps the arguments to --newer-mtime
 821                                         and/or --date option if they are
 822                                         textual dates */
 823   enum wildcards wildcards;        /* Wildcard settings (--wildcards/
 824                                       --no-wildcards) */
 825   int matching_flags;              /* exclude_fnmatch options */
 826   int include_anchored;            /* Pattern anchoring options used for
 827                                       file inclusion */
 828   bool o_option;                   /* True if -o option was given */
 829   bool pax_option;                 /* True if --pax-option was given */
 830   char const *backup_suffix_string;   /* --suffix option argument */
 831   char const *version_control_string; /* --backup option argument */
 832   bool input_files;                /* True if some input files where given */
 833   int compress_autodetect;         /* True if compression autodetection should
 834                                       be attempted when creating archives */
 835 };
 836
 837 \f
 838 #define MAKE_EXCL_OPTIONS(args) \
 839  ((((args)->wildcards != disable_wildcards) ? EXCLUDE_WILDCARDS : 0) \
 840   | (args)->matching_flags \
 841   | recursion_option)
 842
 843 #define MAKE_INCL_OPTIONS(args) \
 844  ((((args)->wildcards == enable_wildcards) ? EXCLUDE_WILDCARDS : 0) \
 845   | (args)->include_anchored \
 846   | (args)->matching_flags \
 847   | recursion_option)
 848
 849 static char const * const vcs_file_table[] = {
 850   /* CVS: */
 851   "CVS",
 852   ".cvsignore",
 853   /* RCS: */
 854   "RCS",
 855   /* SCCS: */
 856   "SCCS",
 857   /* SVN: */
 858   ".svn",
 859   /* git: */
 860   ".git",
 861   ".gitignore",
 862   /* Arch: */
 863   ".arch-ids",
 864   "{arch}",
 865   "=RELEASE-ID",
 866   "=meta-update",
 867   "=update",
 868   /* Bazaar */
 869   ".bzr",
 870   ".bzrignore",
 871   ".bzrtags",
 872   /* Mercurial */
 873   ".hg",
 874   ".hgignore",
 875   ".hgtags",
 876   /* darcs */
 877   "_darcs",
 878   NULL
 879 };
 880
 881 static char const * const backup_file_table[] = {
 882   ".#*",
 883   "*~",
 884   "#*#",
 885   NULL
 886 };
 887
 888 void
 889 add_exclude_array (char const * const * fv)
 890 {
 891   int i;
 892
 893   for (i = 0; fv[i]; i++)
 894     add_exclude (excluded, fv[i], 0);
 895 }
 896
 897 \f
 898 static char *
 899 format_default_settings (void)
 900 {
 901   return xasprintf (
 902             "--format=%s -f%s -b%d --quoting-style=%s --rmt-command=%s"
 903 #ifdef REMOTE_SHELL
 904             " --rsh-command=%s"
 905 #endif
 906             ,
 907             archive_format_string (DEFAULT_ARCHIVE_FORMAT),
 908             DEFAULT_ARCHIVE, DEFAULT_BLOCKING,
 909             quoting_style_args[DEFAULT_QUOTING_STYLE],
 910             DEFAULT_RMT_COMMAND,
 911 #ifdef REMOTE_SHELL
 912             REMOTE_SHELL
 913 #endif
 914             );
 915 }
 916
 917 \f
 918 static void
 919 set_subcommand_option (enum subcommand subcommand)
 920 {
 921   if (subcommand_option != UNKNOWN_SUBCOMMAND
 922       && subcommand_option != subcommand)
 923     USAGE_ERROR ((0, 0,
 924                   _("You may not specify more than one `-Acdtrux' option")));
 925
 926   subcommand_option = subcommand;
 927 }
 928
 929 static void
 930 set_use_compress_program_option (const char *string)
 931 {
 932   if (use_compress_program_option
 933       && strcmp (use_compress_program_option, string) != 0)
 934     USAGE_ERROR ((0, 0, _("Conflicting compression options")));
 935
 936   use_compress_program_option = string;
 937 }
 938 \f
 939 static RETSIGTYPE
 940 sigstat (int signo)
 941 {
 942   compute_duration ();
 943   print_total_stats ();
 944 #ifndef HAVE_SIGACTION
 945   signal (signo, sigstat);
 946 #endif
 947 }
 948
 949 static void
 950 stat_on_signal (int signo)
 951 {
 952 #ifdef HAVE_SIGACTION
 953   struct sigaction act;
 954   act.sa_handler = sigstat;
 955   sigemptyset (&act.sa_mask);
 956   act.sa_flags = 0;
 957   sigaction (signo, &act, NULL);
 958 #else
 959   signal (signo, sigstat);
 960 #endif
 961 }
 962
 963 void
 964 set_stat_signal (const char *name)
 965 {
 966   static struct sigtab
 967   {
 968     char *name;
 969     int signo;
 970   } sigtab[] = {
 971     { "SIGUSR1", SIGUSR1 },
 972     { "USR1", SIGUSR1 },
 973     { "SIGUSR2", SIGUSR2 },
 974     { "USR2", SIGUSR2 },
 975     { "SIGHUP", SIGHUP },
 976     { "HUP", SIGHUP },
 977     { "SIGINT", SIGINT },
 978     { "INT", SIGINT },
 979     { "SIGQUIT", SIGQUIT },
 980     { "QUIT", SIGQUIT }
 981   };
 982   struct sigtab *p;
 983
 984   for (p = sigtab; p < sigtab + sizeof (sigtab) / sizeof (sigtab[0]); p++)
 985     if (strcmp (p->name, name) == 0)
 986       {
 987         stat_on_signal (p->signo);
 988         return;
 989       }
 990   FATAL_ERROR ((0, 0, _("Unknown signal name: %s"), name));
 991 }
 992
 993 \f
 994 struct textual_date
 995 {
 996   struct textual_date *next;
 997   struct timespec ts;
 998   const char *option;
 999   char *date;
1000 };
1001
1002 static int
1003 get_date_or_file (struct tar_args *args, const char *option,
1004                   const char *str, struct timespec *ts)
1005 {
1006   if (FILE_SYSTEM_PREFIX_LEN (str) != 0
1007       || ISSLASH (*str)
1008       || *str == '.')
1009     {
1010       struct stat st;
1011       if (deref_stat (dereference_option, str, &st) != 0)
1012         {
1013           stat_error (str);
1014           USAGE_ERROR ((0, 0, _("Date sample file not found")));
1015         }
1016       *ts = get_stat_mtime (&st);
1017     }
1018   else
1019     {
1020       if (! get_date (ts, str, NULL))
1021         {
1022           WARN ((0, 0, _("Substituting %s for unknown date format %s"),
1023                  tartime (*ts, false), quote (str)));
1024           ts->tv_nsec = 0;
1025           return 1;
1026         }
1027       else
1028         {
1029           struct textual_date *p = xmalloc (sizeof (*p));
1030           p->ts = *ts;
1031           p->option = option;
1032           p->date = xstrdup (str);
1033           p->next = args->textual_date;
1034           args->textual_date = p;
1035         }
1036     }
1037   return 0;
1038 }
1039
1040 static void
1041 report_textual_dates (struct tar_args *args)
1042 {
1043   struct textual_date *p;
1044   for (p = args->textual_date; p; )
1045     {
1046       struct textual_date *next = p->next;
1047       if (verbose_option)
1048         {
1049           char const *treated_as = tartime (p->ts, true);
1050           if (strcmp (p->date, treated_as) != 0)
1051             WARN ((0, 0, _("Option %s: Treating date `%s' as %s"),
1052                    p->option, p->date, treated_as));
1053         }
1054       free (p->date);
1055       free (p);
1056       p = next;
1057     }
1058 }
1059
1060 \f
1061
1062 /* Either NL or NUL, as decided by the --null option.  */
1063 static char filename_terminator;
1064
1065 enum read_file_list_state  /* Result of reading file name from the list file */
1066   {
1067     file_list_success,     /* OK, name read successfully */
1068     file_list_end,         /* End of list file */
1069     file_list_zero,        /* Zero separator encountered where it should not */
1070     file_list_skip         /* Empty (zero-length) entry encountered, skip it */
1071   };
1072
1073 /* Read from FP a sequence of characters up to TERM and put them
1074    into STK.
1075  */
1076 static enum read_file_list_state
1077 read_name_from_file (FILE *fp, struct obstack *stk, int term)
1078 {
1079   int c;
1080   size_t counter = 0;
1081
1082   for (c = getc (fp); c != EOF && c != term; c = getc (fp))
1083     {
1084       if (c == 0)
1085         {
1086           /* We have read a zero separator. The file possibly is
1087              zero-separated */
1088           return file_list_zero;
1089         }
1090       obstack_1grow (stk, c);
1091       counter++;
1092     }
1093
1094   if (counter == 0 && c != EOF)
1095     return file_list_skip;
1096
1097   obstack_1grow (stk, 0);
1098
1099   return (counter == 0 && c == EOF) ? file_list_end : file_list_success;
1100 }
1101
1102 \f
1103 static bool files_from_option;  /* When set, tar will not refuse to create
1104                                    empty archives */
1105 static struct obstack argv_stk; /* Storage for additional command line options
1106                                    read using -T option */
1107
1108 /* Prevent recursive inclusion of the same file */
1109 struct file_id_list
1110 {
1111   struct file_id_list *next;
1112   ino_t ino;
1113   dev_t dev;
1114 };
1115
1116 static struct file_id_list *file_id_list;
1117
1118 static void
1119 add_file_id (const char *filename)
1120 {
1121   struct file_id_list *p;
1122   struct stat st;
1123
1124   if (stat (filename, &st))
1125     stat_fatal (filename);
1126   for (p = file_id_list; p; p = p->next)
1127     if (p->ino == st.st_ino && p->dev == st.st_dev)
1128       {
1129         FATAL_ERROR ((0, 0, _("%s: file list already read"),
1130                       quotearg_colon (filename)));
1131       }
1132   p = xmalloc (sizeof *p);
1133   p->next = file_id_list;
1134   p->ino = st.st_ino;
1135   p->dev = st.st_dev;
1136   file_id_list = p;
1137 }
1138
1139 /* Default density numbers for [0-9][lmh] device specifications */
1140
1141 #ifndef LOW_DENSITY_NUM
1142 # define LOW_DENSITY_NUM 0
1143 #endif
1144
1145 #ifndef MID_DENSITY_NUM
1146 # define MID_DENSITY_NUM 8
1147 #endif
1148
1149 #ifndef HIGH_DENSITY_NUM
1150 # define HIGH_DENSITY_NUM 16
1151 #endif
1152
1153 static void
1154 update_argv (const char *filename, struct argp_state *state)
1155 {
1156   FILE *fp;
1157   size_t count = 0, i;
1158   char *start, *p;
1159   char **new_argv;
1160   size_t new_argc;
1161   bool is_stdin = false;
1162   enum read_file_list_state read_state;
1163   int term = filename_terminator;
1164
1165   if (!strcmp (filename, "-"))
1166     {
1167       is_stdin = true;
1168       request_stdin ("-T");
1169       fp = stdin;
1170     }
1171   else
1172     {
1173       add_file_id (filename);
1174       if ((fp = fopen (filename, "r")) == NULL)
1175         open_fatal (filename);
1176     }
1177
1178   while ((read_state = read_name_from_file (fp, &argv_stk, term))
1179          != file_list_end)
1180     {
1181       switch (read_state)
1182         {
1183         case file_list_success:
1184           count++;
1185           break;
1186
1187         case file_list_end: /* won't happen, just to pacify gcc */
1188           break;
1189
1190         case file_list_zero:
1191           {
1192             size_t size;
1193
1194             WARNOPT (WARN_FILENAME_WITH_NULS,
1195                      (0, 0, N_("%s: file name read contains nul character"),
1196                       quotearg_colon (filename)));
1197
1198             /* Prepare new stack contents */
1199             size = obstack_object_size (&argv_stk);
1200             p = obstack_finish (&argv_stk);
1201             for (; size > 0; size--, p++)
1202               if (*p)
1203                 obstack_1grow (&argv_stk, *p);
1204               else
1205                 obstack_1grow (&argv_stk, '\n');
1206             obstack_1grow (&argv_stk, 0);
1207             count = 1;
1208             /* Read rest of files using new filename terminator */
1209             term = 0;
1210             break;
1211           }
1212
1213         case file_list_skip:
1214           break;
1215         }
1216     }
1217
1218   if (!is_stdin)
1219     fclose (fp);
1220
1221   if (count == 0)
1222     return;
1223
1224   start = obstack_finish (&argv_stk);
1225
1226   if (term == 0)
1227     for (p = start; *p; p += strlen (p) + 1)
1228       if (p[0] == '-')
1229         count++;
1230
1231   new_argc = state->argc + count;
1232   new_argv = xmalloc (sizeof (state->argv[0]) * (new_argc + 1));
1233   memcpy (new_argv, state->argv, sizeof (state->argv[0]) * (state->argc + 1));
1234   state->argv = new_argv;
1235   memmove (&state->argv[state->next + count], &state->argv[state->next],
1236            (state->argc - state->next + 1) * sizeof (state->argv[0]));
1237
1238   state->argc = new_argc;
1239
1240   for (i = state->next, p = start; *p; p += strlen (p) + 1, i++)
1241     {
1242       if (term == 0 && p[0] == '-')
1243         state->argv[i++] = "--add-file";
1244       state->argv[i] = p;
1245     }
1246 }
1247
1248 \f
1249 static char *
1250 tar_help_filter (int key, const char *text, void *input)
1251 {
1252   struct obstack stk;
1253   char *s;
1254
1255   switch (key)
1256     {
1257     default:
1258       s = (char*) text;
1259       break;
1260
1261     case 'j':
1262       s = xasprintf (_("filter the archive through %s"), BZIP2_PROGRAM);
1263       break;
1264
1265     case 'z':
1266       s = xasprintf (_("filter the archive through %s"), GZIP_PROGRAM);
1267       break;
1268
1269     case 'Z':
1270       s = xasprintf (_("filter the archive through %s"), COMPRESS_PROGRAM);
1271       break;
1272
1273     case LZMA_OPTION:
1274       s = xasprintf (_("filter the archive through %s"), LZMA_PROGRAM);
1275       break;
1276
1277     case 'J':
1278       s = xasprintf (_("filter the archive through %s"), XZ_PROGRAM);
1279       break;
1280
1281     case ARGP_KEY_HELP_EXTRA:
1282       obstack_init (&stk);
1283       s = _("Valid arguments for the --quoting-style option are:");
1284       obstack_grow (&stk, s, strlen (s));
1285       obstack_grow (&stk, "\n\n", 2);
1286       tar_list_quoting_styles (&stk, "  ");
1287       s = _("\n*This* tar defaults to:\n");
1288       obstack_grow (&stk, s, strlen (s));
1289       s = format_default_settings ();
1290       obstack_grow (&stk, s, strlen (s));
1291       obstack_1grow (&stk, '\n');
1292       obstack_1grow (&stk, 0);
1293       s = xstrdup (obstack_finish (&stk));
1294       obstack_free (&stk, NULL);
1295     }
1296   return s;
1297 }
1298 \f
1299 static char *
1300 expand_pax_option (struct tar_args *targs, const char *arg)
1301 {
1302   struct obstack stk;
1303   char *res;
1304
1305   obstack_init (&stk);
1306   while (*arg)
1307     {
1308       size_t seglen = strcspn (arg, ",");
1309       char *p = memchr (arg, '=', seglen);
1310       if (p)
1311         {
1312           size_t len = p - arg + 1;
1313           obstack_grow (&stk, arg, len);
1314           len = seglen - len;
1315           for (++p; *p && isspace ((unsigned char) *p); p++)
1316             len--;
1317           if (*p == '{' && p[len-1] == '}')
1318             {
1319               struct timespec ts;
1320               char *tmp = xmalloc (len);
1321               memcpy (tmp, p + 1, len-2);
1322               tmp[len-2] = 0;
1323               if (get_date_or_file (targs, "--pax-option", tmp, &ts) == 0)
1324                 {
1325                   char buf[UINTMAX_STRSIZE_BOUND], *s;
1326                   s = umaxtostr (ts.tv_sec, buf);
1327                   obstack_grow (&stk, s, strlen (s));
1328                 }
1329               else
1330                 obstack_grow (&stk, p, len);
1331               free (tmp);
1332             }
1333           else
1334             obstack_grow (&stk, p, len);
1335         }
1336       else
1337         obstack_grow (&stk, arg, seglen);
1338
1339       arg += seglen;
1340       if (*arg)
1341         {
1342           obstack_1grow (&stk, *arg);
1343           arg++;
1344         }
1345     }
1346   obstack_1grow (&stk, 0);
1347   res = xstrdup (obstack_finish (&stk));
1348   obstack_free (&stk, NULL);
1349   return res;
1350 }
1351
1352 \f
1353 static error_t
1354 parse_opt (int key, char *arg, struct argp_state *state)
1355 {
1356   struct tar_args *args = state->input;
1357
1358   switch (key)
1359     {
1360     case ARGP_KEY_ARG:
1361       /* File name or non-parsed option, because of ARGP_IN_ORDER */
1362       name_add_name (arg, MAKE_INCL_OPTIONS (args));
1363       args->input_files = true;
1364       break;
1365
1366     case 'A':
1367       set_subcommand_option (CAT_SUBCOMMAND);
1368       break;
1369
1370     case 'a':
1371       args->compress_autodetect = true;
1372       break;
1373
1374     case NO_AUTO_COMPRESS_OPTION:
1375       args->compress_autodetect = false;
1376       break;
1377
1378     case 'b':
1379       {
1380         uintmax_t u;
1381         if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1382                && u == (blocking_factor = u)
1383                && 0 < blocking_factor
1384                && u == (record_size = u * BLOCKSIZE) / BLOCKSIZE))
1385           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1386                         _("Invalid blocking factor")));
1387       }
1388       break;
1389
1390     case 'B':
1391       /* Try to reblock input records.  For reading 4.2BSD pipes.  */
1392
1393       /* It would surely make sense to exchange -B and -R, but it seems
1394          that -B has been used for a long while in Sun tar and most
1395          BSD-derived systems.  This is a consequence of the block/record
1396          terminology confusion.  */
1397
1398       read_full_records_option = true;
1399       break;
1400
1401     case 'c':
1402       set_subcommand_option (CREATE_SUBCOMMAND);
1403       break;
1404
1405     case 'C':
1406       name_add_dir (arg);
1407       break;
1408
1409     case 'd':
1410       set_subcommand_option (DIFF_SUBCOMMAND);
1411       break;
1412
1413     case 'f':
1414       if (archive_names == allocated_archive_names)
1415         archive_name_array = x2nrealloc (archive_name_array,
1416                                          &allocated_archive_names,
1417                                          sizeof (archive_name_array[0]));
1418
1419       archive_name_array[archive_names++] = arg;
1420       break;
1421
1422     case 'F':
1423       /* Since -F is only useful with -M, make it implied.  Run this
1424          script at the end of each tape.  */
1425
1426       info_script_option = arg;
1427       multi_volume_option = true;
1428       break;
1429
1430     case 'g':
1431       listed_incremental_option = arg;
1432       after_date_option = true;
1433       /* Fall through.  */
1434
1435     case 'G':
1436       /* We are making an incremental dump (FIXME: are we?); save
1437          directories at the beginning of the archive, and include in each
1438          directory its contents.  */
1439
1440       incremental_option = true;
1441       break;
1442
1443     case 'h':
1444       /* Follow symbolic links.  */
1445       dereference_option = true;
1446       break;
1447
1448     case HARD_DEREFERENCE_OPTION:
1449       hard_dereference_option = true;
1450       break;
1451
1452     case 'i':
1453       /* Ignore zero blocks (eofs).  This can't be the default,
1454          because Unix tar writes two blocks of zeros, then pads out
1455          the record with garbage.  */
1456
1457       ignore_zeros_option = true;
1458       break;
1459
1460     case 'j':
1461       set_use_compress_program_option (BZIP2_PROGRAM);
1462       break;
1463
1464     case 'J':
1465       set_use_compress_program_option (XZ_PROGRAM);
1466       break;
1467
1468     case 'k':
1469       /* Don't replace existing files.  */
1470       old_files_option = KEEP_OLD_FILES;
1471       break;
1472
1473     case 'K':
1474       starting_file_option = true;
1475       addname (arg, 0, true, NULL);
1476       break;
1477
1478     case ONE_FILE_SYSTEM_OPTION:
1479       /* When dumping directories, don't dump files/subdirectories
1480          that are on other filesystems. */
1481       one_file_system_option = true;
1482       break;
1483
1484     case 'l':
1485       check_links_option = 1;
1486       break;
1487
1488     case 'L':
1489       {
1490         uintmax_t u;
1491         if (xstrtoumax (arg, 0, 10, &u, "") != LONGINT_OK)
1492           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1493                         _("Invalid tape length")));
1494         tape_length_option = 1024 * (tarlong) u;
1495         multi_volume_option = true;
1496       }
1497       break;
1498
1499     case LEVEL_OPTION:
1500       {
1501         char *p;
1502         incremental_level = strtoul (arg, &p, 10);
1503         if (*p)
1504           USAGE_ERROR ((0, 0, _("Invalid incremental level value")));
1505       }
1506       break;
1507
1508     case LZMA_OPTION:
1509       set_use_compress_program_option (LZMA_PROGRAM);
1510       break;
1511
1512     case LZOP_OPTION:
1513       set_use_compress_program_option (LZOP_PROGRAM);
1514       break;
1515
1516     case 'm':
1517       touch_option = true;
1518       break;
1519
1520     case 'M':
1521       /* Make multivolume archive: when we can't write any more into
1522          the archive, re-open it, and continue writing.  */
1523
1524       multi_volume_option = true;
1525       break;
1526
1527     case MTIME_OPTION:
1528       get_date_or_file (args, "--mtime", arg, &mtime_option);
1529       set_mtime_option = true;
1530       break;
1531
1532     case 'n':
1533       seek_option = 1;
1534       break;
1535
1536     case NO_SEEK_OPTION:
1537       seek_option = 0;
1538       break;
1539
1540     case 'N':
1541       after_date_option = true;
1542       /* Fall through.  */
1543
1544     case NEWER_MTIME_OPTION:
1545       if (NEWER_OPTION_INITIALIZED (newer_mtime_option))
1546         USAGE_ERROR ((0, 0, _("More than one threshold date")));
1547       get_date_or_file (args,
1548                         key == NEWER_MTIME_OPTION ? "--newer-mtime"
1549                         : "--after-date", arg, &newer_mtime_option);
1550       break;
1551
1552     case 'o':
1553       args->o_option = true;
1554       break;
1555
1556     case 'O':
1557       to_stdout_option = true;
1558       break;
1559
1560     case 'p':
1561       same_permissions_option = true;
1562       break;
1563
1564     case 'P':
1565       absolute_names_option = true;
1566       break;
1567
1568     case 'r':
1569       set_subcommand_option (APPEND_SUBCOMMAND);
1570       break;
1571
1572     case 'R':
1573       /* Print block numbers for debugging bad tar archives.  */
1574
1575       /* It would surely make sense to exchange -B and -R, but it seems
1576          that -B has been used for a long while in Sun tar and most
1577          BSD-derived systems.  This is a consequence of the block/record
1578          terminology confusion.  */
1579
1580       block_number_option = true;
1581       break;
1582
1583     case 's':
1584       /* Names to extract are sorted.  */
1585
1586       same_order_option = true;
1587       break;
1588
1589     case 'S':
1590       sparse_option = true;
1591       break;
1592
1593     case SPARSE_VERSION_OPTION:
1594       sparse_option = true;
1595       {
1596         char *p;
1597         tar_sparse_major = strtoul (arg, &p, 10);
1598         if (*p)
1599           {
1600             if (*p != '.')
1601               USAGE_ERROR ((0, 0, _("Invalid sparse version value")));
1602             tar_sparse_minor = strtoul (p + 1, &p, 10);
1603             if (*p)
1604               USAGE_ERROR ((0, 0, _("Invalid sparse version value")));
1605           }
1606       }
1607       break;
1608
1609     case 't':
1610       set_subcommand_option (LIST_SUBCOMMAND);
1611       verbose_option++;
1612       break;
1613
1614     case TEST_LABEL_OPTION:
1615       set_subcommand_option (LIST_SUBCOMMAND);
1616       test_label_option = true;
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 (test_label_option)
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       for (archive_name_cursor = archive_name_array;
2476            archive_name_cursor < archive_name_array + archive_names;
2477            archive_name_cursor++)
2478         if (!strcmp (*archive_name_cursor, "-"))
2479           request_stdin ("-f");
2480       break;
2481
2482     case CAT_SUBCOMMAND:
2483     case UPDATE_SUBCOMMAND:
2484     case APPEND_SUBCOMMAND:
2485       for (archive_name_cursor = archive_name_array;
2486            archive_name_cursor < archive_name_array + archive_names;
2487            archive_name_cursor++)
2488         if (!strcmp (*archive_name_cursor, "-"))
2489           USAGE_ERROR ((0, 0,
2490                         _("Options `-Aru' are incompatible with `-f -'")));
2491
2492     default:
2493       break;
2494     }
2495
2496   /* Initialize stdlis */
2497   if (index_file_name)
2498     {
2499       stdlis = fopen (index_file_name, "w");
2500       if (! stdlis)
2501         open_error (index_file_name);
2502     }
2503   else
2504     stdlis = to_stdout_option ? stderr : stdout;
2505
2506   archive_name_cursor = archive_name_array;
2507
2508   /* Prepare for generating backup names.  */
2509
2510   if (args.backup_suffix_string)
2511     simple_backup_suffix = xstrdup (args.backup_suffix_string);
2512
2513   if (backup_option)
2514     {
2515       backup_type = xget_version ("--backup", args.version_control_string);
2516       /* No backup is needed either if explicitely disabled or if
2517          the extracted files are not being written to disk. */
2518       if (backup_type == no_backups || EXTRACT_OVER_PIPE)
2519         backup_option = false;
2520     }
2521
2522   checkpoint_finish_compile ();
2523
2524   report_textual_dates (&args);
2525 }
2526
2527 \f
2528 /* Tar proper.  */
2529
2530 /* Main routine for tar.  */
2531 int
2532 main (int argc, char **argv)
2533 {
2534   set_start_time ();
2535   set_program_name (argv[0]);
2536
2537   setlocale (LC_ALL, "");
2538   bindtextdomain (PACKAGE, LOCALEDIR);
2539   textdomain (PACKAGE);
2540
2541   exit_failure = TAREXIT_FAILURE;
2542   exit_status = TAREXIT_SUCCESS;
2543   filename_terminator = '\n';
2544   set_quoting_style (0, DEFAULT_QUOTING_STYLE);
2545
2546   /* Make sure we have first three descriptors available */
2547   stdopen ();
2548
2549   /* Pre-allocate a few structures.  */
2550
2551   allocated_archive_names = 10;
2552   archive_name_array =
2553     xmalloc (sizeof (const char *) * allocated_archive_names);
2554   archive_names = 0;
2555
2556   obstack_init (&argv_stk);
2557
2558   /* Ensure default behavior for some signals */
2559   signal (SIGPIPE, SIG_IGN);
2560   /* System V fork+wait does not work if SIGCHLD is ignored.  */
2561   signal (SIGCHLD, SIG_DFL);
2562
2563   /* Try to disable the ability to unlink a directory.  */
2564   priv_set_remove_linkdir ();
2565
2566   /* Decode options.  */
2567
2568   decode_options (argc, argv);
2569
2570   name_init ();
2571
2572   /* Main command execution.  */
2573
2574   if (volno_file_option)
2575     init_volume_number ();
2576
2577   switch (subcommand_option)
2578     {
2579     case UNKNOWN_SUBCOMMAND:
2580       USAGE_ERROR ((0, 0,
2581                     _("You must specify one of the `-Acdtrux' options")));
2582
2583     case CAT_SUBCOMMAND:
2584     case UPDATE_SUBCOMMAND:
2585     case APPEND_SUBCOMMAND:
2586       update_archive ();
2587       break;
2588
2589     case DELETE_SUBCOMMAND:
2590       delete_archive_members ();
2591       break;
2592
2593     case CREATE_SUBCOMMAND:
2594       create_archive ();
2595       break;
2596
2597     case EXTRACT_SUBCOMMAND:
2598       extr_init ();
2599       read_and (extract_archive);
2600
2601       /* FIXME: should extract_finish () even if an ordinary signal is
2602          received.  */
2603       extract_finish ();
2604
2605       break;
2606
2607     case LIST_SUBCOMMAND:
2608       read_and (list_archive);
2609       break;
2610
2611     case DIFF_SUBCOMMAND:
2612       diff_init ();
2613       read_and (diff_archive);
2614       break;
2615     }
2616
2617   if (totals_option)
2618     print_total_stats ();
2619
2620   if (check_links_option)
2621     check_links ();
2622
2623   if (volno_file_option)
2624     closeout_volume_number ();
2625
2626   /* Dispose of allocated memory, and return.  */
2627
2628   free (archive_name_array);
2629   name_term ();
2630
2631   if (exit_status == TAREXIT_FAILURE)
2632     error (0, 0, _("Exiting with failure status due to previous errors"));
2633
2634   if (stdlis == stdout)
2635     close_stdout ();
2636   else if (ferror (stderr) || fclose (stderr) != 0)
2637     set_exit_status (TAREXIT_FAILURE);
2638
2639   return exit_status;
2640 }
2641
2642 void
2643 tar_stat_init (struct tar_stat_info *st)
2644 {
2645   memset (st, 0, sizeof (*st));
2646 }
2647
2648 void
2649 tar_stat_destroy (struct tar_stat_info *st)
2650 {
2651   free (st->orig_file_name);
2652   free (st->file_name);
2653   free (st->link_name);
2654   free (st->uname);
2655   free (st->gname);
2656   free (st->sparse_map);
2657   free (st->dumpdir);
2658   xheader_destroy (&st->xhdr);
2659   memset (st, 0, sizeof (*st));
2660 }
2661
2662 /* Format mask for all available formats that support nanosecond
2663    timestamp resolution. */
2664 #define NS_PRECISION_FORMAT_MASK FORMAT_MASK (POSIX_FORMAT)
2665
2666 /* Same as timespec_cmp, but ignore nanoseconds if current archive
2667    format does not provide sufficient resolution.  */
2668 int
2669 tar_timespec_cmp (struct timespec a, struct timespec b)
2670 {
2671   if (!(FORMAT_MASK (current_format) & NS_PRECISION_FORMAT_MASK))
2672     a.tv_nsec = b.tv_nsec = 0;
2673   return timespec_cmp (a, b);
2674 }
2675
2676 /* Set tar exit status to VAL, unless it is already indicating
2677    a more serious condition. This relies on the fact that the
2678    values of TAREXIT_ constants are ranged by severity. */
2679 void
2680 set_exit_status (int val)
2681 {
2682   if (val > exit_status)
2683     exit_status = val;
2684 }