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   link_name = current_stat_info.link_name;
 921
 922   if (! absolute_names_option && contains_dot_dot (link_name))
 923     return create_placeholder_file (file_name, false, &interdir_made);
 924
 925   do
 926     {
 927       struct stat st1, st2;
 928       int e;
 929       int status = link (link_name, file_name);
 930       e = errno;
 931
 932       if (status == 0)
 933         {
 934           struct delayed_link *ds = delayed_link_head;
 935           if (ds && lstat (link_name, &st1) == 0)
 936             for (; ds; ds = ds->next)
 937               if (ds->dev == st1.st_dev
 938                   && ds->ino == st1.st_ino
 939                   && timespec_cmp (ds->mtime, get_stat_mtime (&st1)) == 0)
 940                 {
 941                   struct string_list *p =  xmalloc (offsetof (struct string_list, string)
 942                                                     + strlen (file_name) + 1);
 943                   strcpy (p->string, file_name);
 944                   p->next = ds->sources;
 945                   ds->sources = p;
 946                   break;
 947                 }
 948           return 0;
 949         }
 950       else if ((e == EEXIST && strcmp (link_name, file_name) == 0)
 951                || (lstat (link_name, &st1) == 0
 952                    && lstat (file_name, &st2) == 0
 953                    && st1.st_dev == st2.st_dev
 954                    && st1.st_ino == st2.st_ino))
 955         return 0;
 956
 957       errno = e;
 958     }
 959   while (maybe_recoverable (file_name, &interdir_made));
 960
 961   if (!(incremental_option && errno == EEXIST))
 962     {
 963       link_error (link_name, file_name);
 964       return 1;
 965     }
 966   return 0;
 967 }
 968
 969 static int
 970 extract_symlink (char *file_name, int typeflag)
 971 {
 972 #ifdef HAVE_SYMLINK
 973   int status;
 974   int interdir_made = 0;
 975
 976   if (! absolute_names_option
 977       && (IS_ABSOLUTE_FILE_NAME (current_stat_info.link_name)
 978           || contains_dot_dot (current_stat_info.link_name)))
 979     return create_placeholder_file (file_name, true, &interdir_made);
 980
 981   while ((status = symlink (current_stat_info.link_name, file_name)))
 982     if (!maybe_recoverable (file_name, &interdir_made))
 983       break;
 984
 985   if (status == 0)
 986     set_stat (file_name, &current_stat_info, NULL, 0, 0, SYMTYPE);
 987   else
 988     symlink_error (current_stat_info.link_name, file_name);
 989   return status;
 990
 991 #else
 992   static int warned_once;
 993
 994   if (!warned_once)
 995     {
 996       warned_once = 1;
 997       WARN ((0, 0, _("Attempting extraction of symbolic links as hard links")));
 998     }
 999   return extract_link (file_name, typeflag);
1000 #endif
1001 }
1002
1003 #if S_IFCHR || S_IFBLK
1004 static int
1005 extract_node (char *file_name, int typeflag)
1006 {
1007   int status;
1008   int interdir_made = 0;
1009   mode_t mode = current_stat_info.stat.st_mode & ~ current_umask;
1010   mode_t invert_permissions =
1011     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
1012
1013   do
1014     status = mknod (file_name, mode ^ invert_permissions,
1015                     current_stat_info.stat.st_rdev);
1016   while (status && maybe_recoverable (file_name, &interdir_made));
1017
1018   if (status != 0)
1019     mknod_error (file_name);
1020   else
1021     set_stat (file_name, &current_stat_info, NULL, invert_permissions,
1022               ARCHIVED_PERMSTATUS, typeflag);
1023   return status;
1024 }
1025 #endif
1026
1027 #if HAVE_MKFIFO || defined mkfifo
1028 static int
1029 extract_fifo (char *file_name, int typeflag)
1030 {
1031   int status;
1032   int interdir_made = 0;
1033   mode_t mode = current_stat_info.stat.st_mode & ~ current_umask;
1034   mode_t invert_permissions =
1035     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
1036
1037   while ((status = mkfifo (file_name, mode)) != 0)
1038     if (!maybe_recoverable (file_name, &interdir_made))
1039       break;
1040
1041   if (status == 0)
1042     set_stat (file_name, &current_stat_info, NULL, invert_permissions,
1043               ARCHIVED_PERMSTATUS, typeflag);
1044   else
1045     mkfifo_error (file_name);
1046   return status;
1047 }
1048 #endif
1049
1050 static int
1051 extract_volhdr (char *file_name, int typeflag)
1052 {
1053   if (verbose_option)
1054     fprintf (stdlis, _("Reading %s\n"), quote (current_stat_info.file_name));
1055   skip_member ();
1056   return 0;
1057 }
1058
1059 static int
1060 extract_failure (char *file_name, int typeflag)
1061 {
1062   return 1;
1063 }
1064
1065 typedef int (*tar_extractor_t) (char *file_name, int typeflag);
1066
1067 \f
1068
1069 /* Prepare to extract a file. Find extractor function.
1070    Return zero if extraction should not proceed.  */
1071
1072 static int
1073 prepare_to_extract (char const *file_name, int typeflag, tar_extractor_t *fun)
1074 {
1075   int rc = 1;
1076
1077   if (EXTRACT_OVER_PIPE)
1078     rc = 0;
1079
1080   /* Select the extractor */
1081   switch (typeflag)
1082     {
1083     case GNUTYPE_SPARSE:
1084       *fun = extract_file;
1085       rc = 1;
1086       break;
1087
1088     case AREGTYPE:
1089     case REGTYPE:
1090     case CONTTYPE:
1091       /* Appears to be a file.  But BSD tar uses the convention that a slash
1092          suffix means a directory.  */
1093       if (current_stat_info.had_trailing_slash)
1094         *fun = extract_dir;
1095       else
1096         {
1097           *fun = extract_file;
1098           rc = 1;
1099         }
1100       break;
1101
1102     case SYMTYPE:
1103       *fun = extract_symlink;
1104       break;
1105
1106     case LNKTYPE:
1107       *fun = extract_link;
1108       break;
1109
1110 #if S_IFCHR
1111     case CHRTYPE:
1112       current_stat_info.stat.st_mode |= S_IFCHR;
1113       *fun = extract_node;
1114       break;
1115 #endif
1116
1117 #if S_IFBLK
1118     case BLKTYPE:
1119       current_stat_info.stat.st_mode |= S_IFBLK;
1120       *fun = extract_node;
1121       break;
1122 #endif
1123
1124 #if HAVE_MKFIFO || defined mkfifo
1125     case FIFOTYPE:
1126       *fun = extract_fifo;
1127       break;
1128 #endif
1129
1130     case DIRTYPE:
1131     case GNUTYPE_DUMPDIR:
1132       *fun = extract_dir;
1133       if (current_stat_info.is_dumpdir)
1134         delay_directory_restore_option = true;
1135       break;
1136
1137     case GNUTYPE_VOLHDR:
1138       *fun = extract_volhdr;
1139       break;
1140
1141     case GNUTYPE_MULTIVOL:
1142       ERROR ((0, 0,
1143               _("%s: Cannot extract -- file is continued from another volume"),
1144               quotearg_colon (current_stat_info.file_name)));
1145       *fun = extract_failure;
1146       break;
1147
1148     case GNUTYPE_LONGNAME:
1149     case GNUTYPE_LONGLINK:
1150       ERROR ((0, 0, _("Unexpected long name header")));
1151       *fun = extract_failure;
1152       break;
1153
1154     default:
1155       WARN ((0, 0,
1156              _("%s: Unknown file type `%c', extracted as normal file"),
1157              quotearg_colon (file_name), typeflag));
1158       *fun = extract_file;
1159     }
1160
1161   /* Determine whether the extraction should proceed */
1162   if (rc == 0)
1163     return 0;
1164
1165   switch (old_files_option)
1166     {
1167     case UNLINK_FIRST_OLD_FILES:
1168       if (!remove_any_file (file_name,
1169                             recursive_unlink_option ? RECURSIVE_REMOVE_OPTION
1170                                                       : ORDINARY_REMOVE_OPTION)
1171           && errno && errno != ENOENT)
1172         {
1173           unlink_error (file_name);
1174           return 0;
1175         }
1176       break;
1177
1178     case KEEP_NEWER_FILES:
1179       if (file_newer_p (file_name, &current_stat_info))
1180         {
1181           WARN ((0, 0, _("Current %s is newer or same age"),
1182                  quote (file_name)));
1183           return 0;
1184         }
1185       break;
1186
1187     default:
1188       break;
1189     }
1190
1191   return 1;
1192 }
1193
1194 /* Extract a file from the archive.  */
1195 void
1196 extract_archive (void)
1197 {
1198   char typeflag;
1199   tar_extractor_t fun;
1200
1201   set_next_block_after (current_header);
1202   decode_header (current_header, &current_stat_info, &current_format, 1);
1203   if (!current_stat_info.file_name[0]
1204       || (interactive_option
1205           && !confirm ("extract", current_stat_info.file_name)))
1206     {
1207       skip_member ();
1208       return;
1209     }
1210
1211   /* Print the block from current_header and current_stat.  */
1212   if (verbose_option)
1213     print_header (&current_stat_info, -1);
1214
1215   /* Restore stats for all non-ancestor directories, unless
1216      it is an incremental archive.
1217      (see NOTICE in the comment to delay_set_stat above) */
1218   if (!delay_directory_restore_option)
1219     apply_nonancestor_delayed_set_stat (current_stat_info.file_name, 0);
1220
1221   /* Take a safety backup of a previously existing file.  */
1222
1223   if (backup_option)
1224     if (!maybe_backup_file (current_stat_info.file_name, 0))
1225       {
1226         int e = errno;
1227         ERROR ((0, e, _("%s: Was unable to backup this file"),
1228                 quotearg_colon (current_stat_info.file_name)));
1229         skip_member ();
1230         return;
1231       }
1232
1233   /* Extract the archive entry according to its type.  */
1234   /* KLUDGE */
1235   typeflag = sparse_member_p (&current_stat_info) ?
1236                   GNUTYPE_SPARSE : current_header->header.typeflag;
1237
1238   if (prepare_to_extract (current_stat_info.file_name, typeflag, &fun))
1239     {
1240       if (fun && (*fun) (current_stat_info.file_name, typeflag)
1241           && backup_option)
1242         undo_last_backup ();
1243     }
1244   else
1245     skip_member ();
1246
1247 }
1248
1249 /* Extract the symbolic links whose final extraction were delayed.  */
1250 static void
1251 apply_delayed_links (void)
1252 {
1253   struct delayed_link *ds;
1254
1255   for (ds = delayed_link_head; ds; )
1256     {
1257       struct string_list *sources = ds->sources;
1258       char const *valid_source = 0;
1259
1260       for (sources = ds->sources; sources; sources = sources->next)
1261         {
1262           char const *source = sources->string;
1263           struct stat st;
1264
1265           /* Make sure the placeholder file is still there.  If not,
1266              don't create a link, as the placeholder was probably
1267              removed by a later extraction.  */
1268           if (lstat (source, &st) == 0
1269               && st.st_dev == ds->dev
1270               && st.st_ino == ds->ino
1271               && timespec_cmp (get_stat_mtime (&st), ds->mtime) == 0)
1272             {
1273               /* Unlink the placeholder, then create a hard link if possible,
1274                  a symbolic link otherwise.  */
1275               if (unlink (source) != 0)
1276                 unlink_error (source);
1277               else if (valid_source && link (valid_source, source) == 0)
1278                 ;
1279               else if (!ds->is_symlink)
1280                 {
1281                   if (link (ds->target, source) != 0)
1282                     link_error (ds->target, source);
1283                 }
1284               else if (symlink (ds->target, source) != 0)
1285                 symlink_error (ds->target, source);
1286               else
1287                 {
1288                   struct tar_stat_info st1;
1289                   st1.stat.st_uid = ds->uid;
1290                   st1.stat.st_gid = ds->gid;
1291                   set_stat (source, &st1, NULL, 0, 0, SYMTYPE);
1292                   valid_source = source;
1293                 }
1294             }
1295         }
1296
1297       for (sources = ds->sources; sources; )
1298         {
1299           struct string_list *next = sources->next;
1300           free (sources);
1301           sources = next;
1302         }
1303
1304       {
1305         struct delayed_link *next = ds->next;
1306         free (ds);
1307         ds = next;
1308       }
1309     }
1310
1311   delayed_link_head = 0;
1312 }
1313
1314 /* Finish the extraction of an archive.  */
1315 void
1316 extract_finish (void)
1317 {
1318   /* First, fix the status of ordinary directories that need fixing.  */
1319   apply_nonancestor_delayed_set_stat ("", 0);
1320
1321   /* Then, apply delayed links, so that they don't affect delayed
1322      directory status-setting for ordinary directories.  */
1323   apply_delayed_links ();
1324
1325   /* Finally, fix the status of directories that are ancestors
1326      of delayed links.  */
1327   apply_nonancestor_delayed_set_stat ("", 1);
1328 }
1329
1330 bool
1331 rename_directory (char *src, char *dst)
1332 {
1333   if (rename (src, dst))
1334     {
1335       int e = errno;
1336
1337       switch (e)
1338         {
1339         case ENOENT:
1340           if (make_directories (dst))
1341             {
1342               if (rename (src, dst) == 0)
1343                 return true;
1344               e = errno;
1345             }
1346           break;
1347
1348         case EXDEV:
1349           /* FIXME: Fall back to recursive copying */
1350
1351         default:
1352           break;
1353         }
1354
1355       ERROR ((0, e, _("Cannot rename %s to %s"),
1356               quote_n (0, src),
1357               quote_n (1, dst)));
1358       return false;
1359     }
1360   return true;
1361 }
1362
1363 void
1364 fatal_exit (void)
1365 {
1366   extract_finish ();
1367   error (TAREXIT_FAILURE, 0, _("Error is not recoverable: exiting now"));
1368   abort ();
1369 }
1370
1371 void
1372 xalloc_die (void)
1373 {
1374   error (0, 0, "%s", _("memory exhausted"));
1375   fatal_exit ();
1376 }