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