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