Dogcows Code - chaz/tar/blob - src/tar.c

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