git.gag.com Git - debian/tar/blob - src/tar.c

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