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