git.cworth.org Git - tar/blob - src/extract.c

   1 /* Extract files from a tar archive.
   2
   3    Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,
   4    2001, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
   5
   6    Written by John Gilmore, on 1985-11-19.
   7
   8    This program is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by the
  10    Free Software Foundation; either version 3, or (at your option) any later
  11    version.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
  16    Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License along
  19    with this program; if not, write to the Free Software Foundation, Inc.,
  20    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  21
  22 #include <system.h>
  23 #include <quotearg.h>
  24 #include <utimens.h>
  25 #include <errno.h>
  26 #include <xgetcwd.h>
  27
  28 #include "common.h"
  29
  30 static bool we_are_root;        /* true if our effective uid == 0 */
  31 static mode_t newdir_umask;     /* umask when creating new directories */
  32 static mode_t current_umask;    /* current umask (which is set to 0 if -p) */
  33
  34 /* Status of the permissions of a file that we are extracting.  */
  35 enum permstatus
  36 {
  37   /* This file may have existed already; its permissions are unknown.  */
  38   UNKNOWN_PERMSTATUS,
  39
  40   /* This file was created using the permissions from the archive,
  41      except with S_IRWXG | S_IRWXO masked out if 0 < same_owner_option.  */
  42   ARCHIVED_PERMSTATUS,
  43
  44   /* This is an intermediate directory; the archive did not specify
  45      its permissions.  */
  46   INTERDIR_PERMSTATUS
  47 };
  48
  49 /* List of directories whose statuses we need to extract after we've
  50    finished extracting their subsidiary files.  If you consider each
  51    contiguous subsequence of elements of the form [D]?[^D]*, where [D]
  52    represents an element where AFTER_LINKS is nonzero and [^D]
  53    represents an element where AFTER_LINKS is zero, then the head
  54    of the subsequence has the longest name, and each non-head element
  55    in the prefix is an ancestor (in the directory hierarchy) of the
  56    preceding element.  */
  57
  58 struct delayed_set_stat
  59   {
  60     struct delayed_set_stat *next;
  61     dev_t dev;
  62     ino_t ino;
  63     mode_t mode;
  64     uid_t uid;
  65     gid_t gid;
  66     struct timespec atime;
  67     struct timespec mtime;
  68     size_t file_name_len;
  69     mode_t invert_permissions;
  70     enum permstatus permstatus;
  71     bool after_links;
  72     char file_name[1];
  73   };
  74
  75 static struct delayed_set_stat *delayed_set_stat_head;
  76
  77 /* List of links whose creation we have delayed.  */
  78 struct delayed_link
  79   {
  80     /* The next delayed link in the list.  */
  81     struct delayed_link *next;
  82
  83     /* The device, inode number and last-modified time of the placeholder.  */
  84     dev_t dev;
  85     ino_t ino;
  86     struct timespec mtime;
  87
  88     /* True if the link is symbolic.  */
  89     bool is_symlink;
  90
  91     /* The desired owner and group of the link, if it is a symlink.  */
  92     uid_t uid;
  93     gid_t gid;
  94
  95     /* A list of sources for this link.  The sources are all to be
  96        hard-linked together.  */
  97     struct string_list *sources;
  98
  99     /* The desired target of the desired link.  */
 100     char target[1];
 101   };
 102
 103 static struct delayed_link *delayed_link_head;
 104
 105 struct string_list
 106   {
 107     struct string_list *next;
 108     char string[1];
 109   };
 110
 111 /*  Set up to extract files.  */
 112 void
 113 extr_init (void)
 114 {
 115   we_are_root = geteuid () == 0;
 116   same_permissions_option += we_are_root;
 117   same_owner_option += we_are_root;
 118
 119   /* Option -p clears the kernel umask, so it does not affect proper
 120      restoration of file permissions.  New intermediate directories will
 121      comply with umask at start of program.  */
 122
 123   newdir_umask = umask (0);
 124   if (0 < same_permissions_option)
 125     current_umask = 0;
 126   else
 127     {
 128       umask (newdir_umask);     /* restore the kernel umask */
 129       current_umask = newdir_umask;
 130     }
 131 }
 132
 133 /* If restoring permissions, restore the mode for FILE_NAME from
 134    information given in *STAT_INFO (where *CUR_INFO gives
 135    the current status if CUR_INFO is nonzero); otherwise invert the
 136    INVERT_PERMISSIONS bits from the file's current permissions.
 137    PERMSTATUS specifies the status of the file's permissions.
 138    TYPEFLAG specifies the type of the file.  */
 139 static void
 140 set_mode (char const *file_name,
 141           struct stat const *stat_info,
 142           struct stat const *cur_info,
 143           mode_t invert_permissions, enum permstatus permstatus,
 144           char typeflag)
 145 {
 146   mode_t mode;
 147
 148   if (0 < same_permissions_option
 149       && permstatus != INTERDIR_PERMSTATUS)
 150     {
 151       mode = stat_info->st_mode;
 152
 153       /* If we created the file and it has a mode that we set already
 154          with O_CREAT, then its mode is often set correctly already.
 155          But if we are changing ownership, the mode's group and and
 156          other permission bits were omitted originally, so it's less
 157          likely that the mode is OK now.  Also, on many hosts, some
 158          directories inherit the setgid bits from their parents, so we
 159          we must set directories' modes explicitly.  */
 160       if ((permstatus == ARCHIVED_PERMSTATUS
 161            && ! (mode & ~ (0 < same_owner_option ? S_IRWXU : MODE_RWX)))
 162           && typeflag != DIRTYPE
 163           && typeflag != GNUTYPE_DUMPDIR)
 164         return;
 165     }
 166   else if (! invert_permissions)
 167     return;
 168   else
 169     {
 170       /* We must inspect a directory's current permissions, since the
 171          directory may have inherited its setgid bit from its parent.
 172
 173          INVERT_PERMISSIONS happens to be nonzero only for directories
 174          that we created, so there's no point optimizing this code for
 175          other cases.  */
 176       struct stat st;
 177       if (! cur_info)
 178         {
 179           if (stat (file_name, &st) != 0)
 180             {
 181               stat_error (file_name);
 182               return;
 183             }
 184           cur_info = &st;
 185         }
 186       mode = cur_info->st_mode ^ invert_permissions;
 187     }
 188
 189   if (chmod (file_name, mode) != 0)
 190     chmod_error_details (file_name, mode);
 191 }
 192
 193 /* Check time after successfully setting FILE_NAME's time stamp to T.  */
 194 static void
 195 check_time (char const *file_name, struct timespec t)
 196 {
 197   if (t.tv_sec <= 0)
 198     WARN ((0, 0, _("%s: implausibly old time stamp %s"),
 199            file_name, tartime (t, true)));
 200   else if (timespec_cmp (volume_start_time, t) < 0)
 201     {
 202       struct timespec now;
 203       gettime (&now);
 204       if (timespec_cmp (now, t) < 0)
 205         {
 206           char buf[TIMESPEC_STRSIZE_BOUND];
 207           struct timespec diff;
 208           diff.tv_sec = t.tv_sec - now.tv_sec;
 209           diff.tv_nsec = t.tv_nsec - now.tv_nsec;
 210           if (diff.tv_nsec < 0)
 211             {
 212               diff.tv_nsec += BILLION;
 213               diff.tv_sec--;
 214             }
 215           WARN ((0, 0, _("%s: time stamp %s is %s s in the future"),
 216                  file_name, tartime (t, true), code_timespec (diff, buf)));
 217         }
 218     }
 219 }
 220
 221 /* Restore stat attributes (owner, group, mode and times) for
 222    FILE_NAME, using information given in *ST.
 223    If CUR_INFO is nonzero, *CUR_INFO is the
 224    file's current status.
 225    If not restoring permissions, invert the
 226    INVERT_PERMISSIONS bits from the file's current permissions.
 227    PERMSTATUS specifies the status of the file's permissions.
 228    TYPEFLAG specifies the type of the file.  */
 229
 230 /* FIXME: About proper restoration of symbolic link attributes, we still do
 231    not have it right.  Pretesters' reports tell us we need further study and
 232    probably more configuration.  For now, just use lchown if it exists, and
 233    punt for the rest.  Sigh!  */
 234
 235 static void
 236 set_stat (char const *file_name,
 237           struct tar_stat_info const *st,
 238           struct stat const *cur_info,
 239           mode_t invert_permissions, enum permstatus permstatus,
 240           char typeflag)
 241 {
 242   if (typeflag != SYMTYPE)
 243     {
 244       /* We do the utime before the chmod because some versions of utime are
 245          broken and trash the modes of the file.  */
 246
 247       if (! touch_option && permstatus != INTERDIR_PERMSTATUS)
 248         {
 249           /* We set the accessed time to `now', which is really the time we
 250              started extracting files, unless incremental_option is used, in
 251              which case .st_atime is used.  */
 252
 253           /* FIXME: incremental_option should set ctime too, but how?  */
 254
 255           struct timespec ts[2];
 256           if (incremental_option)
 257             ts[0] = st->atime;
 258           else
 259             ts[0] = start_time;
 260           ts[1] = st->mtime;
 261
 262           if (utimens (file_name, ts) != 0)
 263             utime_error (file_name);
 264           else
 265             {
 266               check_time (file_name, ts[0]);
 267               check_time (file_name, ts[1]);
 268             }
 269         }
 270
 271       /* Some systems allow non-root users to give files away.  Once this
 272          done, it is not possible anymore to change file permissions.
 273          However, setting file permissions now would be incorrect, since
 274          they would apply to the wrong user, and there would be a race
 275          condition.  So, don't use systems that allow non-root users to
 276          give files away.  */
 277     }
 278
 279   if (0 < same_owner_option && permstatus != INTERDIR_PERMSTATUS)
 280     {
 281       /* When lchown exists, it should be used to change the attributes of
 282          the symbolic link itself.  In this case, a mere chown would change
 283          the attributes of the file the symbolic link is pointing to, and
 284          should be avoided.  */
 285       int chown_result = 1;
 286
 287       if (typeflag == SYMTYPE)
 288         {
 289 #if HAVE_LCHOWN
 290           chown_result = lchown (file_name, st->stat.st_uid, st->stat.st_gid);
 291 #endif
 292         }
 293       else
 294         {
 295           chown_result = chown (file_name, st->stat.st_uid, st->stat.st_gid);
 296         }
 297
 298       if (chown_result == 0)
 299         {
 300           /* Changing the owner can flip st_mode bits in some cases, so
 301              ignore cur_info if it might be obsolete now.  */
 302           if (cur_info
 303               && cur_info->st_mode & S_IXUGO
 304               && cur_info->st_mode & (S_ISUID | S_ISGID))
 305             cur_info = NULL;
 306         }
 307       else if (chown_result < 0)
 308         chown_error_details (file_name,
 309                              st->stat.st_uid, st->stat.st_gid);
 310     }
 311
 312   if (typeflag != SYMTYPE)
 313     set_mode (file_name, &st->stat, cur_info,
 314               invert_permissions, permstatus, typeflag);
 315 }
 316
 317 /* Remember to restore stat attributes (owner, group, mode and times)
 318    for the directory FILE_NAME, using information given in *ST,
 319    once we stop extracting files into that directory.
 320    If not restoring permissions, remember to invert the
 321    INVERT_PERMISSIONS bits from the file's current permissions.
 322    PERMSTATUS specifies the status of the file's permissions.
 323
 324    NOTICE: this works only if the archive has usual member order, i.e.
 325    directory, then the files in that directory. Incremental archive have
 326    somewhat reversed order: first go subdirectories, then all other
 327    members. To help cope with this case the variable
 328    delay_directory_restore_option is set by prepare_to_extract.
 329
 330    If an archive was explicitely created so that its member order is
 331    reversed, some directory timestamps can be restored incorrectly,
 332    e.g.:
 333        tar --no-recursion -cf archive dir dir/file1 foo dir/file2
 334 */
 335 static void
 336 delay_set_stat (char const *file_name, struct tar_stat_info const *st,
 337                 mode_t invert_permissions, enum permstatus permstatus)
 338 {
 339   size_t file_name_len = strlen (file_name);
 340   struct delayed_set_stat *data =
 341     xmalloc (offsetof (struct delayed_set_stat, file_name)
 342              + file_name_len + 1);
 343   data->next = delayed_set_stat_head;
 344   data->dev = st->stat.st_dev;
 345   data->ino = st->stat.st_ino;
 346   data->mode = st->stat.st_mode;
 347   data->uid = st->stat.st_uid;
 348   data->gid = st->stat.st_gid;
 349   data->atime = st->atime;
 350   data->mtime = st->mtime;
 351   data->file_name_len = file_name_len;
 352   data->invert_permissions = invert_permissions;
 353   data->permstatus = permstatus;
 354   data->after_links = 0;
 355   strcpy (data->file_name, file_name);
 356   delayed_set_stat_head = data;
 357 }
 358
 359 /* Update the delayed_set_stat info for an intermediate directory
 360    created within the file name of DIR.  The intermediate directory turned
 361    out to be the same as this directory, e.g. due to ".." or symbolic
 362    links.  *DIR_STAT_INFO is the status of the directory.  */
 363 static void
 364 repair_delayed_set_stat (char const *dir,
 365                          struct stat const *dir_stat_info)
 366 {
 367   struct delayed_set_stat *data;
 368   for (data = delayed_set_stat_head;  data;  data = data->next)
 369     {
 370       struct stat st;
 371       if (stat (data->file_name, &st) != 0)
 372         {
 373           stat_error (data->file_name);
 374           return;
 375         }
 376
 377       if (st.st_dev == dir_stat_info->st_dev
 378           && st.st_ino == dir_stat_info->st_ino)
 379         {
 380           data->dev = current_stat_info.stat.st_dev;
 381           data->ino = current_stat_info.stat.st_ino;
 382           data->mode = current_stat_info.stat.st_mode;
 383           data->uid = current_stat_info.stat.st_uid;
 384           data->gid = current_stat_info.stat.st_gid;
 385           data->atime = current_stat_info.atime;
 386           data->mtime = current_stat_info.mtime;
 387           data->invert_permissions =
 388             ((current_stat_info.stat.st_mode ^ st.st_mode)
 389              & MODE_RWX & ~ current_umask);
 390           data->permstatus = ARCHIVED_PERMSTATUS;
 391           return;
 392         }
 393     }
 394
 395   ERROR ((0, 0, _("%s: Unexpected inconsistency when making directory"),
 396           quotearg_colon (dir)));
 397 }
 398
 399 /* After a file/link/directory creation has failed, see if
 400    it's because some required directory was not present, and if so,
 401    create all required directories.  Return non-zero if a directory
 402    was created.  */
 403 static int
 404 make_directories (char *file_name)
 405 {
 406   char *cursor0 = file_name + FILE_SYSTEM_PREFIX_LEN (file_name);
 407   char *cursor;                 /* points into the file name */
 408   int did_something = 0;        /* did we do anything yet? */
 409   int mode;
 410   int invert_permissions;
 411   int status;
 412
 413   for (cursor = cursor0; *cursor; cursor++)
 414     {
 415       if (! ISSLASH (*cursor))
 416         continue;
 417
 418       /* Avoid mkdir of empty string, if leading or double '/'.  */
 419
 420       if (cursor == cursor0 || ISSLASH (cursor[-1]))
 421         continue;
 422
 423       /* Avoid mkdir where last part of file name is "." or "..".  */
 424
 425       if (cursor[-1] == '.'
 426           && (cursor == cursor0 + 1 || ISSLASH (cursor[-2])
 427               || (cursor[-2] == '.'
 428                   && (cursor == cursor0 + 2 || ISSLASH (cursor[-3])))))
 429         continue;
 430
 431       *cursor = '\0';           /* truncate the name there */
 432       mode = MODE_RWX & ~ newdir_umask;
 433       invert_permissions = we_are_root ? 0 : MODE_WXUSR & ~ mode;
 434       status = mkdir (file_name, mode ^ invert_permissions);
 435
 436       if (status == 0)
 437         {
 438           /* Create a struct delayed_set_stat even if
 439              invert_permissions is zero, because
 440              repair_delayed_set_stat may need to update the struct.  */
 441           delay_set_stat (file_name,
 442                           &current_stat_info,
 443                           invert_permissions, INTERDIR_PERMSTATUS);
 444
 445           print_for_mkdir (file_name, cursor - file_name, mode);
 446           did_something = 1;
 447
 448           *cursor = '/';
 449           continue;
 450         }
 451
 452       *cursor = '/';
 453
 454       if (errno == EEXIST)
 455         continue;               /* Directory already exists.  */
 456       else if ((errno == ENOSYS /* Automounted dirs on Solaris return
 457                                    this. Reported by Warren Hyde
 458                                    <Warren.Hyde@motorola.com> */
 459                || ERRNO_IS_EACCES)  /* Turbo C mkdir gives a funny errno.  */
 460                && access (file_name, W_OK) == 0)
 461         continue;
 462
 463       /* Some other error in the mkdir.  We return to the caller.  */
 464       break;
 465     }
 466
 467   return did_something;         /* tell them to retry if we made one */
 468 }
 469
 470 static bool
 471 file_newer_p (const char *file_name, struct tar_stat_info *tar_stat)
 472 {
 473   struct stat st;
 474
 475   if (stat (file_name, &st))
 476     {
 477       stat_warn (file_name);
 478       /* Be on the safe side: if the file does exist assume it is newer */
 479       return errno != ENOENT;
 480     }
 481   if (!S_ISDIR (st.st_mode)
 482       && tar_timespec_cmp (tar_stat->mtime, get_stat_mtime (&st)) <= 0)
 483     {
 484       return true;
 485     }
 486   return false;
 487 }
 488
 489 /* Attempt repairing what went wrong with the extraction.  Delete an
 490    already existing file or create missing intermediate directories.
 491    Return nonzero if we somewhat increased our chances at a successful
 492    extraction.  errno is properly restored on zero return.  */
 493 static int
 494 maybe_recoverable (char *file_name, int *interdir_made)
 495 {
 496   int e = errno;
 497
 498   if (*interdir_made)
 499     return 0;
 500
 501   switch (errno)
 502     {
 503     case EEXIST:
 504       /* Remove an old file, if the options allow this.  */
 505
 506       switch (old_files_option)
 507         {
 508         case KEEP_OLD_FILES:
 509           return 0;
 510
 511         case KEEP_NEWER_FILES:
 512           if (file_newer_p (file_name, &current_stat_info))
 513             {
 514               errno = e;
 515               return 0;
 516             }
 517           /* FALL THROUGH */
 518
 519         case DEFAULT_OLD_FILES:
 520         case NO_OVERWRITE_DIR_OLD_FILES:
 521         case OVERWRITE_OLD_FILES:
 522           {
 523             int r = remove_any_file (file_name, ORDINARY_REMOVE_OPTION);
 524             errno = EEXIST;
 525             return r;
 526           }
 527
 528         case UNLINK_FIRST_OLD_FILES:
 529           break;
 530         }
 531
 532     case ENOENT:
 533       /* Attempt creating missing intermediate directories.  */
 534       if (! make_directories (file_name))
 535         {
 536           errno = ENOENT;
 537           return 0;
 538         }
 539       *interdir_made = 1;
 540       return 1;
 541
 542     default:
 543       /* Just say we can't do anything about it...  */
 544
 545       return 0;
 546     }
 547 }
 548
 549 /* Fix the statuses of all directories whose statuses need fixing, and
 550    which are not ancestors of FILE_NAME.  If AFTER_LINKS is
 551    nonzero, do this for all such directories; otherwise, stop at the
 552    first directory that is marked to be fixed up only after delayed
 553    links are applied.  */
 554 static void
 555 apply_nonancestor_delayed_set_stat (char const *file_name, bool after_links)
 556 {
 557   size_t file_name_len = strlen (file_name);
 558   bool check_for_renamed_directories = 0;
 559
 560   while (delayed_set_stat_head)
 561     {
 562       struct delayed_set_stat *data = delayed_set_stat_head;
 563       bool skip_this_one = 0;
 564       struct stat st;
 565       struct stat const *cur_info = 0;
 566
 567       check_for_renamed_directories |= data->after_links;
 568
 569       if (after_links < data->after_links
 570           || (data->file_name_len < file_name_len
 571               && file_name[data->file_name_len]
 572               && (ISSLASH (file_name[data->file_name_len])
 573                   || ISSLASH (file_name[data->file_name_len - 1]))
 574               && memcmp (file_name, data->file_name, data->file_name_len) == 0))
 575         break;
 576
 577       if (check_for_renamed_directories)
 578         {
 579           cur_info = &st;
 580           if (stat (data->file_name, &st) != 0)
 581             {
 582               stat_error (data->file_name);
 583               skip_this_one = 1;
 584             }
 585           else if (! (st.st_dev == data->dev && st.st_ino == data->ino))
 586             {
 587               ERROR ((0, 0,
 588                       _("%s: Directory renamed before its status could be extracted"),
 589                       quotearg_colon (data->file_name)));
 590               skip_this_one = 1;
 591             }
 592         }
 593
 594       if (! skip_this_one)
 595         {
 596           struct tar_stat_info sb;
 597           sb.stat.st_mode = data->mode;
 598           sb.stat.st_uid = data->uid;
 599           sb.stat.st_gid = data->gid;
 600           sb.atime = data->atime;
 601           sb.mtime = data->mtime;
 602           set_stat (data->file_name, &sb, cur_info,
 603                     data->invert_permissions, data->permstatus, DIRTYPE);
 604         }
 605
 606       delayed_set_stat_head = data->next;
 607       free (data);
 608     }
 609 }
 610
 611 \f
 612
 613 /* Extractor functions for various member types */
 614
 615 static int
 616 extract_dir (char *file_name, int typeflag)
 617 {
 618   int status;
 619   mode_t mode;
 620   int interdir_made = 0;
 621
 622   /* Save 'root device' to avoid purging mount points. */
 623   if (one_file_system_option && root_device == 0)
 624     {
 625       struct stat st;
 626       char *dir = xgetcwd ();
 627
 628       if (deref_stat (true, dir, &st))
 629         stat_diag (dir);
 630       else
 631         root_device = st.st_dev;
 632       free (dir);
 633     }
 634
 635   if (incremental_option)
 636     /* Read the entry and delete files that aren't listed in the archive.  */
 637     purge_directory (file_name);
 638   else if (typeflag == GNUTYPE_DUMPDIR)
 639     skip_member ();
 640
 641   mode = current_stat_info.stat.st_mode | (we_are_root ? 0 : MODE_WXUSR);
 642   if (0 < same_owner_option || current_stat_info.stat.st_mode & ~ MODE_RWX)
 643     mode &= S_IRWXU;
 644
 645   while ((status = mkdir (file_name, mode)))
 646     {
 647       if (errno == EEXIST
 648           && (interdir_made
 649               || old_files_option == DEFAULT_OLD_FILES
 650               || old_files_option == OVERWRITE_OLD_FILES))
 651         {
 652           struct stat st;
 653           if (stat (file_name, &st) == 0)
 654             {
 655               if (interdir_made)
 656                 {
 657                   repair_delayed_set_stat (file_name, &st);
 658                   return 0;
 659                 }
 660               if (S_ISDIR (st.st_mode))
 661                 {
 662                   mode = st.st_mode;
 663                   break;
 664                 }
 665             }
 666           errno = EEXIST;
 667         }
 668
 669       if (maybe_recoverable (file_name, &interdir_made))
 670         continue;
 671
 672       if (errno != EEXIST)
 673         {
 674           mkdir_error (file_name);
 675           return 1;
 676         }
 677       break;
 678     }
 679
 680   if (status == 0
 681       || old_files_option == DEFAULT_OLD_FILES
 682       || old_files_option == OVERWRITE_OLD_FILES)
 683     {
 684       if (status == 0)
 685         delay_set_stat (file_name, &current_stat_info,
 686                         ((mode ^ current_stat_info.stat.st_mode)
 687                          & MODE_RWX & ~ current_umask),
 688                         ARCHIVED_PERMSTATUS);
 689       else /* For an already existing directory, invert_perms must be 0 */
 690         delay_set_stat (file_name, &current_stat_info,
 691                         0,
 692                         UNKNOWN_PERMSTATUS);
 693     }
 694   return status;
 695 }
 696
 697
 698 static int
 699 open_output_file (char *file_name, int typeflag, mode_t mode)
 700 {
 701   int fd;
 702   int openflag = (O_WRONLY | O_BINARY | O_CREAT
 703                   | (old_files_option == OVERWRITE_OLD_FILES
 704                      ? O_TRUNC
 705                      : O_EXCL));
 706
 707 #if O_CTG
 708   /* Contiguous files (on the Masscomp) have to specify the size in
 709      the open call that creates them.  */
 710
 711   if (typeflag == CONTTYPE)
 712     fd = open (file_name, openflag | O_CTG, mode, current_stat_info.stat.st_size);
 713   else
 714     fd = open (file_name, openflag, mode);
 715
 716 #else /* not O_CTG */
 717   if (typeflag == CONTTYPE)
 718     {
 719       static int conttype_diagnosed;
 720
 721       if (!conttype_diagnosed)
 722         {
 723           conttype_diagnosed = 1;
 724           WARN ((0, 0, _("Extracting contiguous files as regular files")));
 725         }
 726     }
 727   fd = open (file_name, openflag, mode);
 728
 729 #endif /* not O_CTG */
 730
 731   return fd;
 732 }
 733
 734 static int
 735 extract_file (char *file_name, int typeflag)
 736 {
 737   int fd;
 738   off_t size;
 739   union block *data_block;
 740   int status;
 741   size_t count;
 742   size_t written;
 743   int interdir_made = 0;
 744   mode_t mode = current_stat_info.stat.st_mode & MODE_RWX & ~ current_umask;
 745   mode_t invert_permissions =
 746     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
 747
 748   /* FIXME: deal with protection issues.  */
 749
 750   if (to_stdout_option)
 751     fd = STDOUT_FILENO;
 752   else if (to_command_option)
 753     {
 754       fd = sys_exec_command (file_name, 'f', &current_stat_info);
 755       if (fd < 0)
 756         {
 757           skip_member ();
 758           return 0;
 759         }
 760     }
 761   else
 762     {
 763       do
 764         fd = open_output_file (file_name, typeflag, mode ^ invert_permissions);
 765       while (fd < 0 && maybe_recoverable (file_name, &interdir_made));
 766
 767       if (fd < 0)
 768         {
 769           skip_member ();
 770           open_error (file_name);
 771           return 1;
 772         }
 773     }
 774
 775   mv_begin (&current_stat_info);
 776   if (current_stat_info.is_sparse)
 777     sparse_extract_file (fd, &current_stat_info, &size);
 778   else
 779     for (size = current_stat_info.stat.st_size; size > 0; )
 780       {
 781         mv_size_left (size);
 782
 783         /* Locate data, determine max length writeable, write it,
 784            block that we have used the data, then check if the write
 785            worked.  */
 786
 787         data_block = find_next_block ();
 788         if (! data_block)
 789           {
 790             ERROR ((0, 0, _("Unexpected EOF in archive")));
 791             break;              /* FIXME: What happens, then?  */
 792           }
 793
 794         written = available_space_after (data_block);
 795
 796         if (written > size)
 797           written = size;
 798         errno = 0;
 799         count = full_write (fd, data_block->buffer, written);
 800         size -= written;
 801
 802         set_next_block_after ((union block *)
 803                               (data_block->buffer + written - 1));
 804         if (count != written)
 805           {
 806             if (!to_command_option)
 807               write_error_details (file_name, count, written);
 808             /* FIXME: shouldn't we restore from backup? */
 809             break;
 810           }
 811       }
 812
 813   skip_file (size);
 814
 815   mv_end ();
 816
 817   /* If writing to stdout, don't try to do anything to the filename;
 818      it doesn't exist, or we don't want to touch it anyway.  */
 819
 820   if (to_stdout_option)
 821     return 0;
 822
 823   status = close (fd);
 824   if (status < 0)
 825     close_error (file_name);
 826
 827   if (to_command_option)
 828     sys_wait_command ();
 829   else
 830     set_stat (file_name, &current_stat_info, NULL, invert_permissions,
 831               (old_files_option == OVERWRITE_OLD_FILES ?
 832                UNKNOWN_PERMSTATUS : ARCHIVED_PERMSTATUS),
 833               typeflag);
 834
 835   return status;
 836 }
 837
 838 /* Create a placeholder file with name FILE_NAME, which will be
 839    replaced after other extraction is done by a symbolic link if
 840    IS_SYMLINK is true, and by a hard link otherwise.  Set
 841    *INTERDIR_MADE if an intermediate directory is made in the
 842    process.  */
 843
 844 static int
 845 create_placeholder_file (char *file_name, bool is_symlink, int *interdir_made)
 846 {
 847   int fd;
 848   struct stat st;
 849
 850   while ((fd = open (file_name, O_WRONLY | O_CREAT | O_EXCL, 0)) < 0)
 851     if (! maybe_recoverable (file_name, interdir_made))
 852       break;
 853
 854   if (fd < 0)
 855     open_error (file_name);
 856   else if (fstat (fd, &st) != 0)
 857     {
 858       stat_error (file_name);
 859       close (fd);
 860     }
 861   else if (close (fd) != 0)
 862     close_error (file_name);
 863   else
 864     {
 865       struct delayed_set_stat *h;
 866       struct delayed_link *p =
 867         xmalloc (offsetof (struct delayed_link, target)
 868                  + strlen (current_stat_info.link_name)
 869                  + 1);
 870       p->next = delayed_link_head;
 871       delayed_link_head = p;
 872       p->dev = st.st_dev;
 873       p->ino = st.st_ino;
 874       p->mtime = get_stat_mtime (&st);
 875       p->is_symlink = is_symlink;
 876       if (is_symlink)
 877         {
 878           p->uid = current_stat_info.stat.st_uid;
 879           p->gid = current_stat_info.stat.st_gid;
 880         }
 881       p->sources = xmalloc (offsetof (struct string_list, string)
 882                             + strlen (file_name) + 1);
 883       p->sources->next = 0;
 884       strcpy (p->sources->string, file_name);
 885       strcpy (p->target, current_stat_info.link_name);
 886
 887       h = delayed_set_stat_head;
 888       if (h && ! h->after_links
 889           && strncmp (file_name, h->file_name, h->file_name_len) == 0
 890           && ISSLASH (file_name[h->file_name_len])
 891           && (last_component (file_name) == file_name + h->file_name_len + 1))
 892         {
 893           do
 894             {
 895               h->after_links = 1;
 896
 897               if (stat (h->file_name, &st) != 0)
 898                 stat_error (h->file_name);
 899               else
 900                 {
 901                   h->dev = st.st_dev;
 902                   h->ino = st.st_ino;
 903                 }
 904             }
 905           while ((h = h->next) && ! h->after_links);
 906         }
 907
 908       return 0;
 909     }
 910
 911   return -1;
 912 }
 913
 914 static int
 915 extract_link (char *file_name, int typeflag)
 916 {
 917   int interdir_made = 0;
 918   char const *link_name;
 919
 920   transform_member_name (&current_stat_info.link_name, xform_link);
 921   link_name = current_stat_info.link_name;
 922
 923   if (! absolute_names_option && contains_dot_dot (link_name))
 924     return create_placeholder_file (file_name, false, &interdir_made);
 925
 926   do
 927     {
 928       struct stat st1, st2;
 929       int e;
 930       int status = link (link_name, file_name);
 931       e = errno;
 932
 933       if (status == 0)
 934         {
 935           struct delayed_link *ds = delayed_link_head;
 936           if (ds && lstat (link_name, &st1) == 0)
 937             for (; ds; ds = ds->next)
 938               if (ds->dev == st1.st_dev
 939                   && ds->ino == st1.st_ino
 940                   && timespec_cmp (ds->mtime, get_stat_mtime (&st1)) == 0)
 941                 {
 942                   struct string_list *p =  xmalloc (offsetof (struct string_list, string)
 943                                                     + strlen (file_name) + 1);
 944                   strcpy (p->string, file_name);
 945                   p->next = ds->sources;
 946                   ds->sources = p;
 947                   break;
 948                 }
 949           return 0;
 950         }
 951       else if ((e == EEXIST && strcmp (link_name, file_name) == 0)
 952                || (lstat (link_name, &st1) == 0
 953                    && lstat (file_name, &st2) == 0
 954                    && st1.st_dev == st2.st_dev
 955                    && st1.st_ino == st2.st_ino))
 956         return 0;
 957
 958       errno = e;
 959     }
 960   while (maybe_recoverable (file_name, &interdir_made));
 961
 962   if (!(incremental_option && errno == EEXIST))
 963     {
 964       link_error (link_name, file_name);
 965       return 1;
 966     }
 967   return 0;
 968 }
 969
 970 static int
 971 extract_symlink (char *file_name, int typeflag)
 972 {
 973 #ifdef HAVE_SYMLINK
 974   int status;
 975   int interdir_made = 0;
 976
 977   transform_member_name (&current_stat_info.link_name, xform_symlink);
 978
 979   if (! absolute_names_option
 980       && (IS_ABSOLUTE_FILE_NAME (current_stat_info.link_name)
 981           || contains_dot_dot (current_stat_info.link_name)))
 982     return create_placeholder_file (file_name, true, &interdir_made);
 983
 984   while ((status = symlink (current_stat_info.link_name, file_name)))
 985     if (!maybe_recoverable (file_name, &interdir_made))
 986       break;
 987
 988   if (status == 0)
 989     set_stat (file_name, &current_stat_info, NULL, 0, 0, SYMTYPE);
 990   else
 991     symlink_error (current_stat_info.link_name, file_name);
 992   return status;
 993
 994 #else
 995   static int warned_once;
 996
 997   if (!warned_once)
 998     {
 999       warned_once = 1;
1000       WARN ((0, 0, _("Attempting extraction of symbolic links as hard links")));
1001     }
1002   return extract_link (file_name, typeflag);
1003 #endif
1004 }
1005
1006 #if S_IFCHR || S_IFBLK
1007 static int
1008 extract_node (char *file_name, int typeflag)
1009 {
1010   int status;
1011   int interdir_made = 0;
1012   mode_t mode = current_stat_info.stat.st_mode & ~ current_umask;
1013   mode_t invert_permissions =
1014     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
1015
1016   do
1017     status = mknod (file_name, mode ^ invert_permissions,
1018                     current_stat_info.stat.st_rdev);
1019   while (status && maybe_recoverable (file_name, &interdir_made));
1020
1021   if (status != 0)
1022     mknod_error (file_name);
1023   else
1024     set_stat (file_name, &current_stat_info, NULL, invert_permissions,
1025               ARCHIVED_PERMSTATUS, typeflag);
1026   return status;
1027 }
1028 #endif
1029
1030 #if HAVE_MKFIFO || defined mkfifo
1031 static int
1032 extract_fifo (char *file_name, int typeflag)
1033 {
1034   int status;
1035   int interdir_made = 0;
1036   mode_t mode = current_stat_info.stat.st_mode & ~ current_umask;
1037   mode_t invert_permissions =
1038     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
1039
1040   while ((status = mkfifo (file_name, mode)) != 0)
1041     if (!maybe_recoverable (file_name, &interdir_made))
1042       break;
1043
1044   if (status == 0)
1045     set_stat (file_name, &current_stat_info, NULL, invert_permissions,
1046               ARCHIVED_PERMSTATUS, typeflag);
1047   else
1048     mkfifo_error (file_name);
1049   return status;
1050 }
1051 #endif
1052
1053 static int
1054 extract_volhdr (char *file_name, int typeflag)
1055 {
1056   if (verbose_option)
1057     fprintf (stdlis, _("Reading %s\n"), quote (current_stat_info.file_name));
1058   skip_member ();
1059   return 0;
1060 }
1061
1062 static int
1063 extract_failure (char *file_name, int typeflag)
1064 {
1065   return 1;
1066 }
1067
1068 typedef int (*tar_extractor_t) (char *file_name, int typeflag);
1069
1070 \f
1071
1072 /* Prepare to extract a file. Find extractor function.
1073    Return zero if extraction should not proceed.  */
1074
1075 static int
1076 prepare_to_extract (char const *file_name, int typeflag, tar_extractor_t *fun)
1077 {
1078   int rc = 1;
1079
1080   if (EXTRACT_OVER_PIPE)
1081     rc = 0;
1082
1083   /* Select the extractor */
1084   switch (typeflag)
1085     {
1086     case GNUTYPE_SPARSE:
1087       *fun = extract_file;
1088       rc = 1;
1089       break;
1090
1091     case AREGTYPE:
1092     case REGTYPE:
1093     case CONTTYPE:
1094       /* Appears to be a file.  But BSD tar uses the convention that a slash
1095          suffix means a directory.  */
1096       if (current_stat_info.had_trailing_slash)
1097         *fun = extract_dir;
1098       else
1099         {
1100           *fun = extract_file;
1101           rc = 1;
1102         }
1103       break;
1104
1105     case SYMTYPE:
1106       *fun = extract_symlink;
1107       break;
1108
1109     case LNKTYPE:
1110       *fun = extract_link;
1111       break;
1112
1113 #if S_IFCHR
1114     case CHRTYPE:
1115       current_stat_info.stat.st_mode |= S_IFCHR;
1116       *fun = extract_node;
1117       break;
1118 #endif
1119
1120 #if S_IFBLK
1121     case BLKTYPE:
1122       current_stat_info.stat.st_mode |= S_IFBLK;
1123       *fun = extract_node;
1124       break;
1125 #endif
1126
1127 #if HAVE_MKFIFO || defined mkfifo
1128     case FIFOTYPE:
1129       *fun = extract_fifo;
1130       break;
1131 #endif
1132
1133     case DIRTYPE:
1134     case GNUTYPE_DUMPDIR:
1135       *fun = extract_dir;
1136       if (current_stat_info.is_dumpdir)
1137         delay_directory_restore_option = true;
1138       break;
1139
1140     case GNUTYPE_VOLHDR:
1141       *fun = extract_volhdr;
1142       break;
1143
1144     case GNUTYPE_MULTIVOL:
1145       ERROR ((0, 0,
1146               _("%s: Cannot extract -- file is continued from another volume"),
1147               quotearg_colon (current_stat_info.file_name)));
1148       *fun = extract_failure;
1149       break;
1150
1151     case GNUTYPE_LONGNAME:
1152     case GNUTYPE_LONGLINK:
1153       ERROR ((0, 0, _("Unexpected long name header")));
1154       *fun = extract_failure;
1155       break;
1156
1157     default:
1158       WARN ((0, 0,
1159              _("%s: Unknown file type `%c', extracted as normal file"),
1160              quotearg_colon (file_name), typeflag));
1161       *fun = extract_file;
1162     }
1163
1164   /* Determine whether the extraction should proceed */
1165   if (rc == 0)
1166     return 0;
1167
1168   switch (old_files_option)
1169     {
1170     case UNLINK_FIRST_OLD_FILES:
1171       if (!remove_any_file (file_name,
1172                             recursive_unlink_option ? RECURSIVE_REMOVE_OPTION
1173                                                       : ORDINARY_REMOVE_OPTION)
1174           && errno && errno != ENOENT)
1175         {
1176           unlink_error (file_name);
1177           return 0;
1178         }
1179       break;
1180
1181     case KEEP_NEWER_FILES:
1182       if (file_newer_p (file_name, &current_stat_info))
1183         {
1184           WARN ((0, 0, _("Current %s is newer or same age"),
1185                  quote (file_name)));
1186           return 0;
1187         }
1188       break;
1189
1190     default:
1191       break;
1192     }
1193
1194   return 1;
1195 }
1196
1197 /* Extract a file from the archive.  */
1198 void
1199 extract_archive (void)
1200 {
1201   char typeflag;
1202   tar_extractor_t fun;
1203
1204   set_next_block_after (current_header);
1205   decode_header (current_header, &current_stat_info, &current_format, 1);
1206   if (!current_stat_info.file_name[0]
1207       || (interactive_option
1208           && !confirm ("extract", current_stat_info.file_name)))
1209     {
1210       skip_member ();
1211       return;
1212     }
1213
1214   /* Print the block from current_header and current_stat.  */
1215   if (verbose_option)
1216     print_header (&current_stat_info, -1);
1217
1218   /* Restore stats for all non-ancestor directories, unless
1219      it is an incremental archive.
1220      (see NOTICE in the comment to delay_set_stat above) */
1221   if (!delay_directory_restore_option)
1222     apply_nonancestor_delayed_set_stat (current_stat_info.file_name, 0);
1223
1224   /* Take a safety backup of a previously existing file.  */
1225
1226   if (backup_option)
1227     if (!maybe_backup_file (current_stat_info.file_name, 0))
1228       {
1229         int e = errno;
1230         ERROR ((0, e, _("%s: Was unable to backup this file"),
1231                 quotearg_colon (current_stat_info.file_name)));
1232         skip_member ();
1233         return;
1234       }
1235
1236   /* Extract the archive entry according to its type.  */
1237   /* KLUDGE */
1238   typeflag = sparse_member_p (&current_stat_info) ?
1239                   GNUTYPE_SPARSE : current_header->header.typeflag;
1240
1241   if (prepare_to_extract (current_stat_info.file_name, typeflag, &fun))
1242     {
1243       if (fun && (*fun) (current_stat_info.file_name, typeflag)
1244           && backup_option)
1245         undo_last_backup ();
1246     }
1247   else
1248     skip_member ();
1249
1250 }
1251
1252 /* Extract the symbolic links whose final extraction were delayed.  */
1253 static void
1254 apply_delayed_links (void)
1255 {
1256   struct delayed_link *ds;
1257
1258   for (ds = delayed_link_head; ds; )
1259     {
1260       struct string_list *sources = ds->sources;
1261       char const *valid_source = 0;
1262
1263       for (sources = ds->sources; sources; sources = sources->next)
1264         {
1265           char const *source = sources->string;
1266           struct stat st;
1267
1268           /* Make sure the placeholder file is still there.  If not,
1269              don't create a link, as the placeholder was probably
1270              removed by a later extraction.  */
1271           if (lstat (source, &st) == 0
1272               && st.st_dev == ds->dev
1273               && st.st_ino == ds->ino
1274               && timespec_cmp (get_stat_mtime (&st), ds->mtime) == 0)
1275             {
1276               /* Unlink the placeholder, then create a hard link if possible,
1277                  a symbolic link otherwise.  */
1278               if (unlink (source) != 0)
1279                 unlink_error (source);
1280               else if (valid_source && link (valid_source, source) == 0)
1281                 ;
1282               else if (!ds->is_symlink)
1283                 {
1284                   if (link (ds->target, source) != 0)
1285                     link_error (ds->target, source);
1286                 }
1287               else if (symlink (ds->target, source) != 0)
1288                 symlink_error (ds->target, source);
1289               else
1290                 {
1291                   struct tar_stat_info st1;
1292                   st1.stat.st_uid = ds->uid;
1293                   st1.stat.st_gid = ds->gid;
1294                   set_stat (source, &st1, NULL, 0, 0, SYMTYPE);
1295                   valid_source = source;
1296                 }
1297             }
1298         }
1299
1300       for (sources = ds->sources; sources; )
1301         {
1302           struct string_list *next = sources->next;
1303           free (sources);
1304           sources = next;
1305         }
1306
1307       {
1308         struct delayed_link *next = ds->next;
1309         free (ds);
1310         ds = next;
1311       }
1312     }
1313
1314   delayed_link_head = 0;
1315 }
1316
1317 /* Finish the extraction of an archive.  */
1318 void
1319 extract_finish (void)
1320 {
1321   /* First, fix the status of ordinary directories that need fixing.  */
1322   apply_nonancestor_delayed_set_stat ("", 0);
1323
1324   /* Then, apply delayed links, so that they don't affect delayed
1325      directory status-setting for ordinary directories.  */
1326   apply_delayed_links ();
1327
1328   /* Finally, fix the status of directories that are ancestors
1329      of delayed links.  */
1330   apply_nonancestor_delayed_set_stat ("", 1);
1331 }
1332
1333 bool
1334 rename_directory (char *src, char *dst)
1335 {
1336   if (rename (src, dst))
1337     {
1338       int e = errno;
1339
1340       switch (e)
1341         {
1342         case ENOENT:
1343           if (make_directories (dst))
1344             {
1345               if (rename (src, dst) == 0)
1346                 return true;
1347               e = errno;
1348             }
1349           break;
1350
1351         case EXDEV:
1352           /* FIXME: Fall back to recursive copying */
1353
1354         default:
1355           break;
1356         }
1357
1358       ERROR ((0, e, _("Cannot rename %s to %s"),
1359               quote_n (0, src),
1360               quote_n (1, dst)));
1361       return false;
1362     }
1363   return true;
1364 }
1365
1366 void
1367 fatal_exit (void)
1368 {
1369   extract_finish ();
1370   error (TAREXIT_FAILURE, 0, _("Error is not recoverable: exiting now"));
1371   abort ();
1372 }
1373
1374 void
1375 xalloc_die (void)
1376 {
1377   error (0, 0, "%s", _("memory exhausted"));
1378   fatal_exit ();
1379 }