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   FORCE_LOCAL_OPTION,
 259   GROUP_OPTION,
 260   HANG_OPTION,
 261   IGNORE_CASE_OPTION,
 262   IGNORE_COMMAND_ERROR_OPTION,
 263   IGNORE_FAILED_READ_OPTION,
 264   INDEX_FILE_OPTION,
 265   KEEP_NEWER_FILES_OPTION,
 266   MODE_OPTION,
 267   MTIME_OPTION,
 268   NEWER_MTIME_OPTION,
 269   NO_ANCHORED_OPTION,
 270   NO_DELAY_DIRECTORY_RESTORE_OPTION,
 271   NO_IGNORE_CASE_OPTION,
 272   NO_IGNORE_COMMAND_ERROR_OPTION,
 273   NO_OVERWRITE_DIR_OPTION,
 274   NO_QUOTE_CHARS_OPTION,
 275   NO_RECURSION_OPTION,
 276   NO_SAME_OWNER_OPTION,
 277   NO_SAME_PERMISSIONS_OPTION,
 278   NO_UNQUOTE_OPTION,
 279   NO_WILDCARDS_MATCH_SLASH_OPTION,
 280   NO_WILDCARDS_OPTION,
 281   NULL_OPTION,
 282   NUMERIC_OWNER_OPTION,
 283   OCCURRENCE_OPTION,
 284   OLD_ARCHIVE_OPTION,
 285   ONE_FILE_SYSTEM_OPTION,
 286   OVERWRITE_DIR_OPTION,
 287   OVERWRITE_OPTION,
 288   OWNER_OPTION,
 289   PAX_OPTION,
 290   POSIX_OPTION,
 291   PRESERVE_OPTION,
 292   QUOTE_CHARS_OPTION,
 293   QUOTING_STYLE_OPTION,
 294   RECORD_SIZE_OPTION,
 295   RECURSION_OPTION,
 296   RECURSIVE_UNLINK_OPTION,
 297   REMOVE_FILES_OPTION,
 298   RESTRICT_OPTION,
 299   RMT_COMMAND_OPTION,
 300   RSH_COMMAND_OPTION,
 301   SAME_OWNER_OPTION,
 302   SHOW_DEFAULTS_OPTION,
 303   SHOW_OMITTED_DIRS_OPTION,
 304   SHOW_TRANSFORMED_NAMES_OPTION,
 305   SPARSE_VERSION_OPTION,
 306   STRIP_COMPONENTS_OPTION,
 307   SUFFIX_OPTION,
 308   TEST_LABEL_OPTION,
 309   TOTALS_OPTION,
 310   TO_COMMAND_OPTION,
 311   TRANSFORM_OPTION,
 312   UNQUOTE_OPTION,
 313   USAGE_OPTION,
 314   USE_COMPRESS_PROGRAM_OPTION,
 315   UTC_OPTION,
 316   VERSION_OPTION,
 317   VOLNO_FILE_OPTION,
 318   WILDCARDS_MATCH_SLASH_OPTION,
 319   WILDCARDS_OPTION
 320 };
 321
 322 const char *argp_program_version = "tar (" PACKAGE_NAME ") " VERSION;
 323 const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">";
 324 static char const doc[] = N_("\
 325 GNU `tar' saves many files together into a single tape or disk archive, \
 326 and can restore individual files from the archive.\n\
 327 \n\
 328 Examples:\n\
 329   tar -cf archive.tar foo bar  # Create archive.tar from files foo and bar.\n\
 330   tar -tvf archive.tar         # List all files in archive.tar verbosely.\n\
 331   tar -xf archive.tar          # Extract all files from archive.tar.\n")
 332 "\v"
 333 N_("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 },
 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:"), GRID },
 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 },
 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     file_list_skip         /* Empty (zero-length) entry encountered, skip it */
 959   };
 960
 961 /* Read from FP a sequence of characters up to FILENAME_TERMINATOR and put them
 962    into STK.
 963  */
 964 static enum read_file_list_state
 965 read_name_from_file (FILE *fp, struct obstack *stk)
 966 {
 967   int c;
 968   size_t counter = 0;
 969
 970   for (c = getc (fp); c != EOF && c != filename_terminator; c = getc (fp))
 971     {
 972       if (c == 0)
 973         {
 974           /* We have read a zero separator. The file possibly is
 975              zero-separated */
 976           return file_list_zero;
 977         }
 978       obstack_1grow (stk, c);
 979       counter++;
 980     }
 981
 982   if (counter == 0 && c != EOF)
 983     return file_list_skip;
 984
 985   obstack_1grow (stk, 0);
 986
 987   return (counter == 0 && c == EOF) ? file_list_end : file_list_success;
 988 }
 989
 990 \f
 991 static bool files_from_option;  /* When set, tar will not refuse to create
 992                                    empty archives */
 993 static struct obstack argv_stk; /* Storage for additional command line options
 994                                    read using -T option */
 995
 996 /* Prevent recursive inclusion of the same file */
 997 struct file_id_list
 998 {
 999   struct file_id_list *next;
1000   ino_t ino;
1001   dev_t dev;
1002 };
1003
1004 static struct file_id_list *file_id_list;
1005
1006 static void
1007 add_file_id (const char *filename)
1008 {
1009   struct file_id_list *p;
1010   struct stat st;
1011
1012   if (stat (filename, &st))
1013     stat_fatal (filename);
1014   for (p = file_id_list; p; p = p->next)
1015     if (p->ino == st.st_ino && p->dev == st.st_dev)
1016       {
1017         FATAL_ERROR ((0, 0, _("%s: file list already read"),
1018                       quotearg_colon (filename)));
1019       }
1020   p = xmalloc (sizeof *p);
1021   p->next = file_id_list;
1022   p->ino = st.st_ino;
1023   p->dev = st.st_dev;
1024   file_id_list = p;
1025 }
1026
1027 /* Default density numbers for [0-9][lmh] device specifications */
1028
1029 #ifndef LOW_DENSITY_NUM
1030 # define LOW_DENSITY_NUM 0
1031 #endif
1032
1033 #ifndef MID_DENSITY_NUM
1034 # define MID_DENSITY_NUM 8
1035 #endif
1036
1037 #ifndef HIGH_DENSITY_NUM
1038 # define HIGH_DENSITY_NUM 16
1039 #endif
1040
1041 static void
1042 update_argv (const char *filename, struct argp_state *state)
1043 {
1044   FILE *fp;
1045   size_t count = 0, i;
1046   char *start, *p;
1047   char **new_argv;
1048   size_t new_argc;
1049   bool is_stdin = false;
1050   enum read_file_list_state read_state;
1051
1052   if (!strcmp (filename, "-"))
1053     {
1054       is_stdin = true;
1055       request_stdin ("-T");
1056       fp = stdin;
1057     }
1058   else
1059     {
1060       add_file_id (filename);
1061       if ((fp = fopen (filename, "r")) == NULL)
1062         open_fatal (filename);
1063     }
1064
1065   while ((read_state = read_name_from_file (fp, &argv_stk)) != file_list_end)
1066     {
1067       switch (read_state)
1068         {
1069         case file_list_success:
1070           count++;
1071           break;
1072
1073         case file_list_end: /* won't happen, just to pacify gcc */
1074           break;
1075
1076         case file_list_zero:
1077           {
1078             size_t size;
1079
1080             WARN ((0, 0, N_("%s: file name read contains nul character"),
1081                    quotearg_colon (filename)));
1082
1083             /* Prepare new stack contents */
1084             size = obstack_object_size (&argv_stk);
1085             p = obstack_finish (&argv_stk);
1086             for (; size > 0; size--, p++)
1087               if (*p)
1088                 obstack_1grow (&argv_stk, *p);
1089               else
1090                 obstack_1grow (&argv_stk, '\n');
1091             obstack_1grow (&argv_stk, 0);
1092             count = 1;
1093             /* Read rest of files using new filename terminator */
1094             filename_terminator = 0;
1095             break;
1096           }
1097
1098         case file_list_skip:
1099           break;
1100         }
1101     }
1102
1103   if (!is_stdin)
1104     fclose (fp);
1105
1106   if (count == 0)
1107     return;
1108
1109   start = obstack_finish (&argv_stk);
1110
1111   if (filename_terminator == 0)
1112     for (p = start; *p; p += strlen (p) + 1)
1113       if (p[0] == '-')
1114         count++;
1115
1116   new_argc = state->argc + count;
1117   new_argv = xmalloc (sizeof (state->argv[0]) * (new_argc + 1));
1118   memcpy (new_argv, state->argv, sizeof (state->argv[0]) * (state->argc + 1));
1119   state->argv = new_argv;
1120   memmove (&state->argv[state->next + count], &state->argv[state->next],
1121            (state->argc - state->next + 1) * sizeof (state->argv[0]));
1122
1123   state->argc = new_argc;
1124
1125   for (i = state->next, p = start; *p; p += strlen (p) + 1, i++)
1126     {
1127       if (filename_terminator == 0 && p[0] == '-')
1128         state->argv[i++] = "--add-file";
1129       state->argv[i] = p;
1130     }
1131 }
1132
1133 \f
1134 static void
1135 tar_help (struct argp_state *state)
1136 {
1137   argp_fmtstream_t fs;
1138   state->flags |= ARGP_NO_EXIT;
1139   argp_state_help (state, state->out_stream,
1140                    ARGP_HELP_STD_HELP & ~ARGP_HELP_BUG_ADDR);
1141   /* FIXME: use struct uparams.rmargin (from argp-help.c) instead of 79 */
1142   fs = argp_make_fmtstream (state->out_stream, 0, 79, 0);
1143
1144   argp_fmtstream_printf (fs, "\n%s\n\n",
1145                        _("Valid arguments for --quoting-style options are:"));
1146   tar_list_quoting_styles (fs, "  ");
1147
1148   argp_fmtstream_puts (fs, _("\n*This* tar defaults to:\n"));
1149   show_default_settings_fs (fs);
1150   argp_fmtstream_putc (fs, '\n');
1151   argp_fmtstream_printf (fs, _("Report bugs to %s.\n"),
1152                          argp_program_bug_address);
1153   argp_fmtstream_free (fs);
1154 }
1155 \f
1156 static error_t
1157 parse_opt (int key, char *arg, struct argp_state *state)
1158 {
1159   struct tar_args *args = state->input;
1160
1161   switch (key)
1162     {
1163       case ARGP_KEY_ARG:
1164         /* File name or non-parsed option, because of ARGP_IN_ORDER */
1165         name_add_name (arg, MAKE_INCL_OPTIONS (args));
1166         args->input_files = true;
1167         break;
1168
1169     case 'A':
1170       set_subcommand_option (CAT_SUBCOMMAND);
1171       break;
1172
1173     case 'b':
1174       {
1175         uintmax_t u;
1176         if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1177                && u == (blocking_factor = u)
1178                && 0 < blocking_factor
1179                && u == (record_size = u * BLOCKSIZE) / BLOCKSIZE))
1180           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1181                         _("Invalid blocking factor")));
1182       }
1183       break;
1184
1185     case 'B':
1186       /* Try to reblock input records.  For reading 4.2BSD pipes.  */
1187
1188       /* It would surely make sense to exchange -B and -R, but it seems
1189          that -B has been used for a long while in Sun tar and most
1190          BSD-derived systems.  This is a consequence of the block/record
1191          terminology confusion.  */
1192
1193       read_full_records_option = true;
1194       break;
1195
1196     case 'c':
1197       set_subcommand_option (CREATE_SUBCOMMAND);
1198       break;
1199
1200     case 'C':
1201       name_add_dir (arg);
1202       break;
1203
1204     case 'd':
1205       set_subcommand_option (DIFF_SUBCOMMAND);
1206       break;
1207
1208     case 'f':
1209       if (archive_names == allocated_archive_names)
1210         archive_name_array = x2nrealloc (archive_name_array,
1211                                          &allocated_archive_names,
1212                                          sizeof (archive_name_array[0]));
1213
1214       archive_name_array[archive_names++] = arg;
1215       break;
1216
1217     case 'F':
1218       /* Since -F is only useful with -M, make it implied.  Run this
1219          script at the end of each tape.  */
1220
1221       info_script_option = arg;
1222       multi_volume_option = true;
1223       break;
1224
1225     case 'g':
1226       listed_incremental_option = arg;
1227       after_date_option = true;
1228       /* Fall through.  */
1229
1230     case 'G':
1231       /* We are making an incremental dump (FIXME: are we?); save
1232          directories at the beginning of the archive, and include in each
1233          directory its contents.  */
1234
1235       incremental_option = true;
1236       break;
1237
1238     case 'h':
1239       /* Follow symbolic links.  */
1240       dereference_option = true;
1241       break;
1242
1243     case 'i':
1244       /* Ignore zero blocks (eofs).  This can't be the default,
1245          because Unix tar writes two blocks of zeros, then pads out
1246          the record with garbage.  */
1247
1248       ignore_zeros_option = true;
1249       break;
1250
1251     case 'I':
1252       USAGE_ERROR ((0, 0,
1253                     _("Warning: the -I option is not supported;"
1254                       " perhaps you meant -j or -T?")));
1255       break;
1256
1257     case 'j':
1258       set_use_compress_program_option ("bzip2");
1259       break;
1260
1261     case 'k':
1262       /* Don't replace existing files.  */
1263       old_files_option = KEEP_OLD_FILES;
1264       break;
1265
1266     case 'K':
1267       starting_file_option = true;
1268       addname (arg, 0);
1269       break;
1270
1271     case ONE_FILE_SYSTEM_OPTION:
1272       /* When dumping directories, don't dump files/subdirectories
1273          that are on other filesystems. */
1274       one_file_system_option = true;
1275       break;
1276
1277     case 'l':
1278       check_links_option = 1;
1279       break;
1280
1281     case 'L':
1282       {
1283         uintmax_t u;
1284         if (xstrtoumax (arg, 0, 10, &u, "") != LONGINT_OK)
1285           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1286                         _("Invalid tape length")));
1287         tape_length_option = 1024 * (tarlong) u;
1288         multi_volume_option = true;
1289       }
1290       break;
1291
1292     case 'm':
1293       touch_option = true;
1294       break;
1295
1296     case 'M':
1297       /* Make multivolume archive: when we can't write any more into
1298          the archive, re-open it, and continue writing.  */
1299
1300       multi_volume_option = true;
1301       break;
1302
1303     case MTIME_OPTION:
1304       get_date_or_file (args, "--mtime", arg, &mtime_option);
1305       set_mtime_option = true;
1306       break;
1307
1308     case 'n':
1309       seekable_archive = true;
1310       break;
1311
1312     case 'N':
1313       after_date_option = true;
1314       /* Fall through.  */
1315
1316     case NEWER_MTIME_OPTION:
1317       if (NEWER_OPTION_INITIALIZED (newer_mtime_option))
1318         USAGE_ERROR ((0, 0, _("More than one threshold date")));
1319       get_date_or_file (args,
1320                         key == NEWER_MTIME_OPTION ? "--newer-mtime"
1321                           : "--after-date", arg, &newer_mtime_option);
1322       break;
1323
1324     case 'o':
1325       args->o_option = true;
1326       break;
1327
1328     case 'O':
1329       to_stdout_option = true;
1330       break;
1331
1332     case 'p':
1333       same_permissions_option = true;
1334       break;
1335
1336     case 'P':
1337       absolute_names_option = true;
1338       break;
1339
1340     case 'r':
1341       set_subcommand_option (APPEND_SUBCOMMAND);
1342       break;
1343
1344     case 'R':
1345       /* Print block numbers for debugging bad tar archives.  */
1346
1347       /* It would surely make sense to exchange -B and -R, but it seems
1348          that -B has been used for a long while in Sun tar and most
1349          BSD-derived systems.  This is a consequence of the block/record
1350          terminology confusion.  */
1351
1352       block_number_option = true;
1353       break;
1354
1355     case 's':
1356       /* Names to extract are sorted.  */
1357
1358       same_order_option = true;
1359       break;
1360
1361     case 'S':
1362       sparse_option = true;
1363       break;
1364
1365     case SPARSE_VERSION_OPTION:
1366       sparse_option = true;
1367       {
1368         char *p;
1369         tar_sparse_major = strtoul (arg, &p, 10);
1370         if (*p)
1371           {
1372             if (*p != '.')
1373               USAGE_ERROR ((0, 0, _("Invalid sparse version value")));
1374             tar_sparse_minor = strtoul (p + 1, &p, 10);
1375             if (*p)
1376               USAGE_ERROR ((0, 0, _("Invalid sparse version value")));
1377           }
1378       }
1379       break;
1380
1381     case 't':
1382       set_subcommand_option (LIST_SUBCOMMAND);
1383       verbose_option++;
1384       break;
1385
1386     case TEST_LABEL_OPTION:
1387       set_subcommand_option (LIST_SUBCOMMAND);
1388       test_label_option = true;
1389       break;
1390
1391     case 'T':
1392       update_argv (arg, state);
1393       /* Indicate we've been given -T option. This is for backward
1394          compatibility only, so that `tar cfT archive /dev/null will
1395          succeed */
1396       files_from_option = true;
1397       break;
1398
1399     case 'u':
1400       set_subcommand_option (UPDATE_SUBCOMMAND);
1401       break;
1402
1403     case 'U':
1404       old_files_option = UNLINK_FIRST_OLD_FILES;
1405       break;
1406
1407     case UTC_OPTION:
1408       utc_option = true;
1409       break;
1410
1411     case 'v':
1412       verbose_option++;
1413       break;
1414
1415     case 'V':
1416       volume_label_option = arg;
1417       break;
1418
1419     case 'w':
1420       interactive_option = true;
1421       break;
1422
1423     case 'W':
1424       verify_option = true;
1425       break;
1426
1427     case 'x':
1428       set_subcommand_option (EXTRACT_SUBCOMMAND);
1429       break;
1430
1431     case 'X':
1432       if (add_exclude_file (add_exclude, excluded, arg,
1433                             MAKE_EXCL_OPTIONS (args), '\n')
1434           != 0)
1435         {
1436           int e = errno;
1437           FATAL_ERROR ((0, e, "%s", quotearg_colon (arg)));
1438         }
1439       break;
1440
1441     case 'z':
1442       set_use_compress_program_option ("gzip");
1443       break;
1444
1445     case 'Z':
1446       set_use_compress_program_option ("compress");
1447       break;
1448
1449     case ANCHORED_OPTION:
1450       args->matching_flags |= EXCLUDE_ANCHORED;
1451       break;
1452
1453     case ATIME_PRESERVE_OPTION:
1454       atime_preserve_option =
1455         (arg
1456          ? XARGMATCH ("--atime-preserve", arg,
1457                       atime_preserve_args, atime_preserve_types)
1458          : replace_atime_preserve);
1459       if (! O_NOATIME && atime_preserve_option == system_atime_preserve)
1460         FATAL_ERROR ((0, 0,
1461                       _("--atime-preserve='system' is not supported"
1462                         " on this platform")));
1463       break;
1464
1465     case CHECKPOINT_OPTION:
1466       if (arg)
1467         {
1468           char *p;
1469
1470           if (*arg == '.')
1471             {
1472               checkpoint_style = checkpoint_dot;
1473               arg++;
1474             }
1475           checkpoint_option = strtoul (arg, &p, 0);
1476           if (*p)
1477             FATAL_ERROR ((0, 0,
1478                           _("--checkpoint value is not an integer")));
1479         }
1480       else
1481         checkpoint_option = 10;
1482       break;
1483
1484     case BACKUP_OPTION:
1485       backup_option = true;
1486       if (arg)
1487         args->version_control_string = arg;
1488       break;
1489
1490     case DELAY_DIRECTORY_RESTORE_OPTION:
1491       delay_directory_restore_option = true;
1492       break;
1493
1494     case NO_DELAY_DIRECTORY_RESTORE_OPTION:
1495       delay_directory_restore_option = false;
1496       break;
1497
1498     case DELETE_OPTION:
1499       set_subcommand_option (DELETE_SUBCOMMAND);
1500       break;
1501
1502     case EXCLUDE_OPTION:
1503       add_exclude (excluded, arg, MAKE_EXCL_OPTIONS (args));
1504       break;
1505
1506     case EXCLUDE_CACHES_OPTION:
1507       exclude_caches_option = true;
1508       break;
1509
1510     case FORCE_LOCAL_OPTION:
1511       force_local_option = true;
1512       break;
1513
1514     case 'H':
1515       set_archive_format (arg);
1516       break;
1517
1518     case INDEX_FILE_OPTION:
1519       index_file_name = arg;
1520       break;
1521
1522     case IGNORE_CASE_OPTION:
1523       args->matching_flags |= FNM_CASEFOLD;
1524       break;
1525
1526     case IGNORE_COMMAND_ERROR_OPTION:
1527       ignore_command_error_option = true;
1528       break;
1529
1530     case IGNORE_FAILED_READ_OPTION:
1531       ignore_failed_read_option = true;
1532       break;
1533
1534     case KEEP_NEWER_FILES_OPTION:
1535       old_files_option = KEEP_NEWER_FILES;
1536       break;
1537
1538     case GROUP_OPTION:
1539       if (! (strlen (arg) < GNAME_FIELD_SIZE
1540              && gname_to_gid (arg, &group_option)))
1541         {
1542           uintmax_t g;
1543           if (xstrtoumax (arg, 0, 10, &g, "") == LONGINT_OK
1544               && g == (gid_t) g)
1545             group_option = g;
1546           else
1547             FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1548                           _("%s: Invalid group")));
1549         }
1550       break;
1551
1552     case MODE_OPTION:
1553       mode_option = mode_compile (arg);
1554       if (!mode_option)
1555         FATAL_ERROR ((0, 0, _("Invalid mode given on option")));
1556       initial_umask = umask (0);
1557       umask (initial_umask);
1558       break;
1559
1560     case NO_ANCHORED_OPTION:
1561       args->include_anchored = 0; /* Clear the default for comman line args */
1562       args->matching_flags &= ~ EXCLUDE_ANCHORED;
1563       break;
1564
1565     case NO_IGNORE_CASE_OPTION:
1566       args->matching_flags &= ~ FNM_CASEFOLD;
1567       break;
1568
1569     case NO_IGNORE_COMMAND_ERROR_OPTION:
1570       ignore_command_error_option = false;
1571       break;
1572
1573     case NO_OVERWRITE_DIR_OPTION:
1574       old_files_option = NO_OVERWRITE_DIR_OLD_FILES;
1575       break;
1576
1577     case NO_QUOTE_CHARS_OPTION:
1578       for (;*arg; arg++)
1579         set_char_quoting (NULL, *arg, 0);
1580       break;
1581
1582     case NO_WILDCARDS_OPTION:
1583       args->wildcards = disable_wildcards;
1584       break;
1585
1586     case NO_WILDCARDS_MATCH_SLASH_OPTION:
1587       args->matching_flags |= FNM_FILE_NAME;
1588       break;
1589
1590     case NULL_OPTION:
1591       filename_terminator = '\0';
1592       break;
1593
1594     case NUMERIC_OWNER_OPTION:
1595       numeric_owner_option = true;
1596       break;
1597
1598     case OCCURRENCE_OPTION:
1599       if (!arg)
1600         occurrence_option = 1;
1601       else
1602         {
1603           uintmax_t u;
1604           if (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK)
1605             occurrence_option = u;
1606           else
1607             FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1608                           _("Invalid number")));
1609         }
1610       break;
1611
1612     case OVERWRITE_DIR_OPTION:
1613       old_files_option = DEFAULT_OLD_FILES;
1614       break;
1615
1616     case OVERWRITE_OPTION:
1617       old_files_option = OVERWRITE_OLD_FILES;
1618       break;
1619
1620     case OWNER_OPTION:
1621       if (! (strlen (arg) < UNAME_FIELD_SIZE
1622              && uname_to_uid (arg, &owner_option)))
1623         {
1624           uintmax_t u;
1625           if (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1626               && u == (uid_t) u)
1627             owner_option = u;
1628           else
1629             FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1630                           _("Invalid owner")));
1631         }
1632       break;
1633
1634     case QUOTE_CHARS_OPTION:
1635       for (;*arg; arg++)
1636         set_char_quoting (NULL, *arg, 1);
1637       break;
1638
1639     case QUOTING_STYLE_OPTION:
1640       tar_set_quoting_style (arg);
1641       break;
1642
1643     case PAX_OPTION:
1644       args->pax_option = true;
1645       xheader_set_option (arg);
1646       break;
1647
1648     case POSIX_OPTION:
1649       set_archive_format ("posix");
1650       break;
1651
1652     case PRESERVE_OPTION:
1653       /* FIXME: What it is good for? */
1654       same_permissions_option = true;
1655       same_order_option = true;
1656       break;
1657
1658     case RECORD_SIZE_OPTION:
1659       {
1660         uintmax_t u;
1661         if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1662                && u == (size_t) u))
1663           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1664                         _("Invalid record size")));
1665         record_size = u;
1666         if (record_size % BLOCKSIZE != 0)
1667           USAGE_ERROR ((0, 0, _("Record size must be a multiple of %d."),
1668                         BLOCKSIZE));
1669         blocking_factor = record_size / BLOCKSIZE;
1670       }
1671       break;
1672
1673     case RECURSIVE_UNLINK_OPTION:
1674       recursive_unlink_option = true;
1675       break;
1676
1677     case REMOVE_FILES_OPTION:
1678       remove_files_option = true;
1679       break;
1680
1681     case RESTRICT_OPTION:
1682       restrict_option = true;
1683       break;
1684
1685     case RMT_COMMAND_OPTION:
1686       rmt_command = arg;
1687       break;
1688
1689     case RSH_COMMAND_OPTION:
1690       rsh_command_option = arg;
1691       break;
1692
1693     case SHOW_DEFAULTS_OPTION:
1694       show_default_settings (stdout);
1695       close_stdout ();
1696       exit (0);
1697
1698     case STRIP_COMPONENTS_OPTION:
1699       {
1700         uintmax_t u;
1701         if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1702                && u == (size_t) u))
1703           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1704                         _("Invalid number of elements")));
1705         strip_name_components = u;
1706       }
1707       break;
1708
1709     case SHOW_OMITTED_DIRS_OPTION:
1710       show_omitted_dirs_option = true;
1711       break;
1712
1713     case SHOW_TRANSFORMED_NAMES_OPTION:
1714       show_transformed_names_option = true;
1715       break;
1716
1717     case SUFFIX_OPTION:
1718       backup_option = true;
1719       args->backup_suffix_string = arg;
1720       break;
1721
1722     case TO_COMMAND_OPTION:
1723       if (to_command_option)
1724         USAGE_ERROR ((0, 0, _("Only one --to-command option allowed")));
1725       to_command_option = arg;
1726       break;
1727
1728     case TOTALS_OPTION:
1729       if (arg)
1730         set_stat_signal (arg);
1731       else
1732         totals_option = true;
1733       break;
1734
1735     case TRANSFORM_OPTION:
1736       set_transform_expr (arg);
1737       break;
1738
1739     case USE_COMPRESS_PROGRAM_OPTION:
1740       set_use_compress_program_option (arg);
1741       break;
1742
1743     case VOLNO_FILE_OPTION:
1744       volno_file_option = arg;
1745       break;
1746
1747     case WILDCARDS_OPTION:
1748       args->wildcards = enable_wildcards;
1749       break;
1750
1751     case WILDCARDS_MATCH_SLASH_OPTION:
1752       args->matching_flags &= ~ FNM_FILE_NAME;
1753       break;
1754
1755     case NO_RECURSION_OPTION:
1756       recursion_option = 0;
1757       break;
1758
1759     case NO_SAME_OWNER_OPTION:
1760       same_owner_option = -1;
1761       break;
1762
1763     case NO_SAME_PERMISSIONS_OPTION:
1764       same_permissions_option = -1;
1765       break;
1766
1767     case RECURSION_OPTION:
1768       recursion_option = FNM_LEADING_DIR;
1769       break;
1770
1771     case SAME_OWNER_OPTION:
1772       same_owner_option = 1;
1773       break;
1774
1775     case UNQUOTE_OPTION:
1776       unquote_option = true;
1777       break;
1778
1779     case NO_UNQUOTE_OPTION:
1780       unquote_option = false;
1781       break;
1782
1783     case '0':
1784     case '1':
1785     case '2':
1786     case '3':
1787     case '4':
1788     case '5':
1789     case '6':
1790     case '7':
1791
1792 #ifdef DEVICE_PREFIX
1793       {
1794         int device = key - '0';
1795         int density;
1796         static char buf[sizeof DEVICE_PREFIX + 10];
1797         char *cursor;
1798
1799         if (arg[1])
1800           argp_error (state, _("Malformed density argument: %s"), quote (arg));
1801
1802         strcpy (buf, DEVICE_PREFIX);
1803         cursor = buf + strlen (buf);
1804
1805 #ifdef DENSITY_LETTER
1806
1807         sprintf (cursor, "%d%c", device, arg[0]);
1808
1809 #else /* not DENSITY_LETTER */
1810
1811         switch (arg[0])
1812           {
1813           case 'l':
1814             device += LOW_DENSITY_NUM;
1815             break;
1816
1817           case 'm':
1818             device += MID_DENSITY_NUM;
1819             break;
1820
1821           case 'h':
1822             device += HIGH_DENSITY_NUM;
1823             break;
1824
1825           default:
1826             argp_error (state, _("Unknown density: `%c'"), arg[0]);
1827           }
1828         sprintf (cursor, "%d", device);
1829
1830 #endif /* not DENSITY_LETTER */
1831
1832         if (archive_names == allocated_archive_names)
1833           archive_name_array = x2nrealloc (archive_name_array,
1834                                            &allocated_archive_names,
1835                                            sizeof (archive_name_array[0]));
1836         archive_name_array[archive_names++] = xstrdup (buf);
1837       }
1838       break;
1839
1840 #else /* not DEVICE_PREFIX */
1841
1842       argp_error (state,
1843                   _("Options `-[0-7][lmh]' not supported by *this* tar"));
1844
1845 #endif /* not DEVICE_PREFIX */
1846
1847     case '?':
1848       tar_help (state);
1849       close_stdout ();
1850       exit (0);
1851
1852     case USAGE_OPTION:
1853       argp_state_help (state, state->out_stream, ARGP_HELP_USAGE);
1854       close_stdout ();
1855       exit (0);
1856
1857     case VERSION_OPTION:
1858       version_etc (state->out_stream, "tar", PACKAGE_NAME, VERSION,
1859                    "John Gilmore", "Jay Fenlason", (char *) NULL);
1860       close_stdout ();
1861       exit (0);
1862
1863     case HANG_OPTION:
1864       _argp_hang = atoi (arg ? arg : "3600");
1865       while (_argp_hang-- > 0)
1866         sleep (1);
1867       break;
1868
1869     default:
1870       return ARGP_ERR_UNKNOWN;
1871     }
1872   return 0;
1873 }
1874
1875 static struct argp argp = {
1876   options,
1877   parse_opt,
1878   N_("[FILE]..."),
1879   doc,
1880   NULL,
1881   NULL,
1882   NULL
1883 };
1884
1885 void
1886 usage (int status)
1887 {
1888   argp_help (&argp, stderr, ARGP_HELP_SEE, (char*) program_name);
1889   close_stdout ();
1890   exit (status);
1891 }
1892
1893 /* Parse the options for tar.  */
1894
1895 static struct argp_option *
1896 find_argp_option (struct argp_option *options, int letter)
1897 {
1898   for (;
1899        !(options->name == NULL
1900          && options->key == 0
1901          && options->arg == 0
1902          && options->flags == 0
1903          && options->doc == NULL); options++)
1904     if (options->key == letter)
1905       return options;
1906   return NULL;
1907 }
1908
1909 static void
1910 decode_options (int argc, char **argv)
1911 {
1912   int index;
1913   struct tar_args args;
1914
1915   /* Set some default option values.  */
1916   args.textual_date = NULL;
1917   args.wildcards = default_wildcards;
1918   args.matching_flags = 0;
1919   args.include_anchored = EXCLUDE_ANCHORED;
1920   args.o_option = false;
1921   args.pax_option = false;
1922   args.backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
1923   args.version_control_string = 0;
1924   args.input_files = false;
1925
1926   subcommand_option = UNKNOWN_SUBCOMMAND;
1927   archive_format = DEFAULT_FORMAT;
1928   blocking_factor = DEFAULT_BLOCKING;
1929   record_size = DEFAULT_BLOCKING * BLOCKSIZE;
1930   excluded = new_exclude ();
1931   newer_mtime_option.tv_sec = TYPE_MINIMUM (time_t);
1932   newer_mtime_option.tv_nsec = -1;
1933   recursion_option = FNM_LEADING_DIR;
1934   unquote_option = true;
1935   tar_sparse_major = 1;
1936   tar_sparse_minor = 0;
1937
1938   owner_option = -1;
1939   group_option = -1;
1940
1941   /* Convert old-style tar call by exploding option element and rearranging
1942      options accordingly.  */
1943
1944   if (argc > 1 && argv[1][0] != '-')
1945     {
1946       int new_argc;             /* argc value for rearranged arguments */
1947       char **new_argv;          /* argv value for rearranged arguments */
1948       char *const *in;          /* cursor into original argv */
1949       char **out;               /* cursor into rearranged argv */
1950       const char *letter;       /* cursor into old option letters */
1951       char buffer[3];           /* constructed option buffer */
1952
1953       /* Initialize a constructed option.  */
1954
1955       buffer[0] = '-';
1956       buffer[2] = '\0';
1957
1958       /* Allocate a new argument array, and copy program name in it.  */
1959
1960       new_argc = argc - 1 + strlen (argv[1]);
1961       new_argv = xmalloc ((new_argc + 1) * sizeof (char *));
1962       in = argv;
1963       out = new_argv;
1964       *out++ = *in++;
1965
1966       /* Copy each old letter option as a separate option, and have the
1967          corresponding argument moved next to it.  */
1968
1969       for (letter = *in++; *letter; letter++)
1970         {
1971           struct argp_option *opt;
1972
1973           buffer[1] = *letter;
1974           *out++ = xstrdup (buffer);
1975           opt = find_argp_option (options, *letter);
1976           if (opt && opt->arg)
1977             {
1978               if (in < argv + argc)
1979                 *out++ = *in++;
1980               else
1981                 USAGE_ERROR ((0, 0, _("Old option `%c' requires an argument."),
1982                               *letter));
1983             }
1984         }
1985
1986       /* Copy all remaining options.  */
1987
1988       while (in < argv + argc)
1989         *out++ = *in++;
1990       *out = 0;
1991
1992       /* Replace the old option list by the new one.  */
1993
1994       argc = new_argc;
1995       argv = new_argv;
1996     }
1997
1998   /* Parse all options and non-options as they appear.  */
1999
2000   prepend_default_options (getenv ("TAR_OPTIONS"), &argc, &argv);
2001
2002   if (argp_parse (&argp, argc, argv, ARGP_IN_ORDER|ARGP_NO_HELP,
2003                   &index, &args))
2004     exit (TAREXIT_FAILURE);
2005
2006
2007   /* Special handling for 'o' option:
2008
2009      GNU tar used to say "output old format".
2010      UNIX98 tar says don't chown files after extracting (we use
2011      "--no-same-owner" for this).
2012
2013      The old GNU tar semantics is retained when used with --create
2014      option, otherwise UNIX98 semantics is assumed */
2015
2016   if (args.o_option)
2017     {
2018       if (subcommand_option == CREATE_SUBCOMMAND)
2019         {
2020           /* GNU Tar <= 1.13 compatibility */
2021           set_archive_format ("v7");
2022         }
2023       else
2024         {
2025           /* UNIX98 compatibility */
2026           same_owner_option = -1;
2027         }
2028     }
2029
2030   /* Handle operands after any "--" argument.  */
2031   for (; index < argc; index++)
2032     {
2033       name_add_name (argv[index], MAKE_INCL_OPTIONS (&args));
2034       args.input_files = true;
2035     }
2036
2037   /* Warn about implicit use of the wildcards in command line arguments.
2038      See TODO */
2039   warn_regex_usage = args.wildcards == default_wildcards;
2040
2041   /* Derive option values and check option consistency.  */
2042
2043   if (archive_format == DEFAULT_FORMAT)
2044     {
2045       if (args.pax_option)
2046         archive_format = POSIX_FORMAT;
2047       else
2048         archive_format = DEFAULT_ARCHIVE_FORMAT;
2049     }
2050
2051   if ((volume_label_option && subcommand_option == CREATE_SUBCOMMAND)
2052       || incremental_option
2053       || multi_volume_option
2054       || sparse_option)
2055     assert_format (FORMAT_MASK (OLDGNU_FORMAT)
2056                    | FORMAT_MASK (GNU_FORMAT)
2057                    | FORMAT_MASK (POSIX_FORMAT));
2058
2059   if (occurrence_option)
2060     {
2061       if (!args.input_files)
2062         USAGE_ERROR ((0, 0,
2063                       _("--occurrence is meaningless without a file list")));
2064       if (subcommand_option != DELETE_SUBCOMMAND
2065           && subcommand_option != DIFF_SUBCOMMAND
2066           && subcommand_option != EXTRACT_SUBCOMMAND
2067           && subcommand_option != LIST_SUBCOMMAND)
2068             USAGE_ERROR ((0, 0,
2069                           _("--occurrence cannot be used in the requested operation mode")));
2070     }
2071
2072   if (seekable_archive && subcommand_option == DELETE_SUBCOMMAND)
2073     {
2074       /* The current code in delete.c is based on the assumption that
2075          skip_member() reads all data from the archive. So, we should
2076          make sure it won't use seeks. On the other hand, the same code
2077          depends on the ability to backspace a record in the archive,
2078          so setting seekable_archive to false is technically incorrect.
2079          However, it is tested only in skip_member(), so it's not a
2080          problem. */
2081       seekable_archive = false;
2082     }
2083
2084   if (archive_names == 0)
2085     {
2086       /* If no archive file name given, try TAPE from the environment, or
2087          else, DEFAULT_ARCHIVE from the configuration process.  */
2088
2089       archive_names = 1;
2090       archive_name_array[0] = getenv ("TAPE");
2091       if (! archive_name_array[0])
2092         archive_name_array[0] = DEFAULT_ARCHIVE;
2093     }
2094
2095   /* Allow multiple archives only with `-M'.  */
2096
2097   if (archive_names > 1 && !multi_volume_option)
2098     USAGE_ERROR ((0, 0,
2099                   _("Multiple archive files require `-M' option")));
2100
2101   if (listed_incremental_option
2102       && NEWER_OPTION_INITIALIZED (newer_mtime_option))
2103     USAGE_ERROR ((0, 0,
2104                   _("Cannot combine --listed-incremental with --newer")));
2105
2106   if (volume_label_option)
2107     {
2108       if (archive_format == GNU_FORMAT || archive_format == OLDGNU_FORMAT)
2109         {
2110           size_t volume_label_max_len =
2111             (sizeof current_header->header.name
2112              - 1 /* for trailing '\0' */
2113              - (multi_volume_option
2114                 ? (sizeof " Volume "
2115                    - 1 /* for null at end of " Volume " */
2116                    + INT_STRLEN_BOUND (int) /* for volume number */
2117                    - 1 /* for sign, as 0 <= volno */)
2118                 : 0));
2119           if (volume_label_max_len < strlen (volume_label_option))
2120             USAGE_ERROR ((0, 0,
2121                           ngettext ("%s: Volume label is too long (limit is %lu byte)",
2122                                     "%s: Volume label is too long (limit is %lu bytes)",
2123                                     volume_label_max_len),
2124                           quotearg_colon (volume_label_option),
2125                           (unsigned long) volume_label_max_len));
2126         }
2127       /* else FIXME
2128          Label length in PAX format is limited by the volume size. */
2129     }
2130
2131   if (verify_option)
2132     {
2133       if (multi_volume_option)
2134         USAGE_ERROR ((0, 0, _("Cannot verify multi-volume archives")));
2135       if (use_compress_program_option)
2136         USAGE_ERROR ((0, 0, _("Cannot verify compressed archives")));
2137     }
2138
2139   if (use_compress_program_option)
2140     {
2141       if (multi_volume_option)
2142         USAGE_ERROR ((0, 0, _("Cannot use multi-volume compressed archives")));
2143       if (subcommand_option == UPDATE_SUBCOMMAND
2144           || subcommand_option == APPEND_SUBCOMMAND
2145           || subcommand_option == DELETE_SUBCOMMAND)
2146         USAGE_ERROR ((0, 0, _("Cannot update compressed archives")));
2147       if (subcommand_option == CAT_SUBCOMMAND)
2148         USAGE_ERROR ((0, 0, _("Cannot concatenate compressed archives")));
2149     }
2150
2151   /* It is no harm to use --pax-option on non-pax archives in archive
2152      reading mode. It may even be useful, since it allows to override
2153      file attributes from tar headers. Therefore I allow such usage.
2154      --gray */
2155   if (args.pax_option
2156       && archive_format != POSIX_FORMAT
2157       && (subcommand_option != EXTRACT_SUBCOMMAND
2158           || subcommand_option != DIFF_SUBCOMMAND
2159           || subcommand_option != LIST_SUBCOMMAND))
2160     USAGE_ERROR ((0, 0, _("--pax-option can be used only on POSIX archives")));
2161
2162   /* If ready to unlink hierarchies, so we are for simpler files.  */
2163   if (recursive_unlink_option)
2164     old_files_option = UNLINK_FIRST_OLD_FILES;
2165
2166
2167   if (test_label_option)
2168     {
2169       /* --test-label is silent if the user has specified the label name to
2170          compare against. */
2171       if (!args.input_files)
2172         verbose_option++;
2173     }
2174   else if (utc_option)
2175     verbose_option = 2;
2176
2177   /* Forbid using -c with no input files whatsoever.  Check that `-f -',
2178      explicit or implied, is used correctly.  */
2179
2180   switch (subcommand_option)
2181     {
2182     case CREATE_SUBCOMMAND:
2183       if (!args.input_files && !files_from_option)
2184         USAGE_ERROR ((0, 0,
2185                       _("Cowardly refusing to create an empty archive")));
2186       break;
2187
2188     case EXTRACT_SUBCOMMAND:
2189     case LIST_SUBCOMMAND:
2190     case DIFF_SUBCOMMAND:
2191       for (archive_name_cursor = archive_name_array;
2192            archive_name_cursor < archive_name_array + archive_names;
2193            archive_name_cursor++)
2194         if (!strcmp (*archive_name_cursor, "-"))
2195           request_stdin ("-f");
2196       break;
2197
2198     case CAT_SUBCOMMAND:
2199     case UPDATE_SUBCOMMAND:
2200     case APPEND_SUBCOMMAND:
2201       for (archive_name_cursor = archive_name_array;
2202            archive_name_cursor < archive_name_array + archive_names;
2203            archive_name_cursor++)
2204         if (!strcmp (*archive_name_cursor, "-"))
2205           USAGE_ERROR ((0, 0,
2206                         _("Options `-Aru' are incompatible with `-f -'")));
2207
2208     default:
2209       break;
2210     }
2211
2212   /* Initialize stdlis */
2213   if (index_file_name)
2214     {
2215       stdlis = fopen (index_file_name, "w");
2216       if (! stdlis)
2217         open_error (index_file_name);
2218     }
2219   else
2220     stdlis = to_stdout_option ? stderr : stdout;
2221
2222   archive_name_cursor = archive_name_array;
2223
2224   /* Prepare for generating backup names.  */
2225
2226   if (args.backup_suffix_string)
2227     simple_backup_suffix = xstrdup (args.backup_suffix_string);
2228
2229   if (backup_option)
2230     {
2231       backup_type = xget_version ("--backup", args.version_control_string);
2232       /* No backup is needed either if explicitely disabled or if
2233          the extracted files are not being written to disk. */
2234       if (backup_type == no_backups || EXTRACT_OVER_PIPE)
2235         backup_option = false;
2236     }
2237
2238   if (verbose_option)
2239     report_textual_dates (&args);
2240 }
2241
2242 \f
2243 /* Tar proper.  */
2244
2245 /* Main routine for tar.  */
2246 int
2247 main (int argc, char **argv)
2248 {
2249   set_start_time ();
2250   program_name = argv[0];
2251
2252   setlocale (LC_ALL, "");
2253   bindtextdomain (PACKAGE, LOCALEDIR);
2254   textdomain (PACKAGE);
2255
2256   exit_failure = TAREXIT_FAILURE;
2257   exit_status = TAREXIT_SUCCESS;
2258   filename_terminator = '\n';
2259   set_quoting_style (0, DEFAULT_QUOTING_STYLE);
2260
2261   /* Make sure we have first three descriptors available */
2262   stdopen ();
2263
2264   /* Close all inherited open descriptors, except for the first three */
2265   closeopen ();
2266
2267   /* Pre-allocate a few structures.  */
2268
2269   allocated_archive_names = 10;
2270   archive_name_array =
2271     xmalloc (sizeof (const char *) * allocated_archive_names);
2272   archive_names = 0;
2273
2274   obstack_init (&argv_stk);
2275
2276 #ifdef SIGCHLD
2277   /* System V fork+wait does not work if SIGCHLD is ignored.  */
2278   signal (SIGCHLD, SIG_DFL);
2279 #endif
2280
2281   /* Decode options.  */
2282
2283   decode_options (argc, argv);
2284   name_init ();
2285
2286   /* Main command execution.  */
2287
2288   if (volno_file_option)
2289     init_volume_number ();
2290
2291   switch (subcommand_option)
2292     {
2293     case UNKNOWN_SUBCOMMAND:
2294       USAGE_ERROR ((0, 0,
2295                     _("You must specify one of the `-Acdtrux' options")));
2296
2297     case CAT_SUBCOMMAND:
2298     case UPDATE_SUBCOMMAND:
2299     case APPEND_SUBCOMMAND:
2300       update_archive ();
2301       break;
2302
2303     case DELETE_SUBCOMMAND:
2304       delete_archive_members ();
2305       break;
2306
2307     case CREATE_SUBCOMMAND:
2308       create_archive ();
2309       break;
2310
2311     case EXTRACT_SUBCOMMAND:
2312       extr_init ();
2313       read_and (extract_archive);
2314
2315       /* FIXME: should extract_finish () even if an ordinary signal is
2316          received.  */
2317       extract_finish ();
2318
2319       break;
2320
2321     case LIST_SUBCOMMAND:
2322       read_and (list_archive);
2323       break;
2324
2325     case DIFF_SUBCOMMAND:
2326       diff_init ();
2327       read_and (diff_archive);
2328       break;
2329     }
2330
2331   if (totals_option)
2332     print_total_stats ();
2333
2334   if (check_links_option)
2335     check_links ();
2336
2337   if (volno_file_option)
2338     closeout_volume_number ();
2339
2340   /* Dispose of allocated memory, and return.  */
2341
2342   free (archive_name_array);
2343   name_term ();
2344
2345   if (exit_status == TAREXIT_FAILURE)
2346     error (0, 0, _("Error exit delayed from previous errors"));
2347
2348   if (stdlis == stdout)
2349     close_stdout ();
2350   else if (ferror (stderr) || fclose (stderr) != 0)
2351     exit_status = TAREXIT_FAILURE;
2352
2353   return exit_status;
2354 }
2355
2356 void
2357 tar_stat_init (struct tar_stat_info *st)
2358 {
2359   memset (st, 0, sizeof (*st));
2360 }
2361
2362 void
2363 tar_stat_destroy (struct tar_stat_info *st)
2364 {
2365   free (st->orig_file_name);
2366   free (st->file_name);
2367   free (st->link_name);
2368   free (st->uname);
2369   free (st->gname);
2370   free (st->sparse_map);
2371   free (st->dumpdir);
2372   memset (st, 0, sizeof (*st));
2373 }
2374
2375 /* Format mask for all available formats that support nanosecond
2376    timestamp resolution. */
2377 #define NS_PRECISION_FORMAT_MASK FORMAT_MASK (POSIX_FORMAT)
2378
2379 /* Same as timespec_cmp, but ignore nanoseconds if current archive
2380    format does not provide sufficient resolution.  */
2381 int
2382 tar_timespec_cmp (struct timespec a, struct timespec b)
2383 {
2384   if (!(FORMAT_MASK (current_format) & NS_PRECISION_FORMAT_MASK))
2385     a.tv_nsec = b.tv_nsec = 0;
2386   return timespec_cmp (a, b);
2387 }