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