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