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