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