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