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

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