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