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

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