tar: fix bug with -C and delayed setting of metadata

[chaz/tar] / src / extract.c

diff --git a/src/extract.c b/src/extract.c
index 387ebb977722d64b4fa5776cac3fff7bfa7e9696..5b12ed1763b72875bf5b8df83fe936f12ad7e25f 100644 (file)
--- a/src/extract.c
+++ b/src/extract.c
@@ -1,13 +1,13 @@
 /* Extract files from a tar archive.
 
    Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,
 /* Extract files from a tar archive.
 
    Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,

-   2001, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+   2001, 2003, 2004, 2005, 2006, 2007, 2010 Free Software Foundation, Inc.

 
    Written by John Gilmore, on 1985-11-19.
 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
 
    Written by John Gilmore, on 1985-11-19.
 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the

-   Free Software Foundation; either version 2, or (at your option) any later
+   Free Software Foundation; either version 3, or (at your option) any later

    version.
 
    This program is distributed in the hope that it will be useful, but
    version.
 
    This program is distributed in the hope that it will be useful, but


@@ -23,7 +23,7 @@
 #include <quotearg.h>
 #include <utimens.h>
 #include <errno.h>
 #include <quotearg.h>
 #include <utimens.h>
 #include <errno.h>

-#include <xgetcwd.h>
+#include <priv-set.h>

 
 #include "common.h"
 
 
 #include "common.h"
 


@@ -69,6 +69,7 @@ struct delayed_set_stat
     mode_t invert_permissions;
     enum permstatus permstatus;
     bool after_links;
     mode_t invert_permissions;
     enum permstatus permstatus;
     bool after_links;

+    int change_dir;

     char file_name[1];
   };
 
     char file_name[1];
   };
 


@@ -80,10 +81,12 @@ struct delayed_link
     /* The next delayed link in the list.  */
     struct delayed_link *next;
 
     /* The next delayed link in the list.  */
     struct delayed_link *next;
 

-    /* The device, inode number and last-modified time of the placeholder.  */
+    /* The device, inode number and ctime of the placeholder.  Use
+       ctime, not mtime, to make false matches less likely if some
+       other process removes the placeholder.  */

     dev_t dev;
     ino_t ino;
     dev_t dev;
     ino_t ino;

-    struct timespec mtime;
+    struct timespec ctime;

 
     /* True if the link is symbolic.  */
     bool is_symlink;
 
     /* True if the link is symbolic.  */
     bool is_symlink;


@@ -92,6 +95,9 @@ struct delayed_link
     uid_t uid;
     gid_t gid;
 
     uid_t uid;
     gid_t gid;
 

+    /* The directory that the sources and target are relative to.  */
+    int change_dir;
+

     /* A list of sources for this link.  The sources are all to be
        hard-linked together.  */
     struct string_list *sources;
     /* A list of sources for this link.  The sources are all to be
        hard-linked together.  */
     struct string_list *sources;


@@ -144,6 +150,7 @@ set_mode (char const *file_name,
          char typeflag)
 {
   mode_t mode;
          char typeflag)
 {
   mode_t mode;

+  int chmod_errno;

 
   if (0 < same_permissions_option
       && permstatus != INTERDIR_PERMSTATUS)
 
   if (0 < same_permissions_option
       && permstatus != INTERDIR_PERMSTATUS)


@@ -186,8 +193,24 @@ set_mode (char const *file_name,
       mode = cur_info->st_mode ^ invert_permissions;
     }
 
       mode = cur_info->st_mode ^ invert_permissions;
     }
 

-  if (chmod (file_name, mode) != 0)
-    chmod_error_details (file_name, mode);
+  chmod_errno = chmod (file_name, mode) == 0 ? 0 : errno;
+  if (chmod_errno == EPERM && (mode & S_ISUID) != 0)
+    {
+      /* On Solaris, chmod may fail if we don't have PRIV_ALL, because
+        setuid-root files would otherwise be a backdoor.  See
+        http://opensolaris.org/jive/thread.jspa?threadID=95826
+        (2009-09-03).  */
+      if (priv_set_restore_linkdir () == 0)
+       {
+         chmod_errno = chmod (file_name, mode) == 0 ? 0 : errno;
+         priv_set_remove_linkdir ();
+       }
+    }
+  if (chmod_errno)
+    {
+      errno = chmod_errno;
+      chmod_error_details (file_name, mode);
+    }

 }
 
 /* Check time after successfully setting FILE_NAME's time stamp to T.  */
 }
 
 /* Check time after successfully setting FILE_NAME's time stamp to T.  */


@@ -195,8 +218,9 @@ static void
 check_time (char const *file_name, struct timespec t)
 {
   if (t.tv_sec <= 0)
 check_time (char const *file_name, struct timespec t)
 {
   if (t.tv_sec <= 0)

-    WARN ((0, 0, _("%s: implausibly old time stamp %s"),
-          file_name, tartime (t, true)));
+    WARNOPT (WARN_TIMESTAMP,
+            (0, 0, _("%s: implausibly old time stamp %s"),
+             file_name, tartime (t, true)));

   else if (timespec_cmp (volume_start_time, t) < 0)
     {
       struct timespec now;
   else if (timespec_cmp (volume_start_time, t) < 0)
     {
       struct timespec now;


@@ -212,8 +236,9 @@ check_time (char const *file_name, struct timespec t)
              diff.tv_nsec += BILLION;
              diff.tv_sec--;
            }
              diff.tv_nsec += BILLION;
              diff.tv_sec--;
            }

-         WARN ((0, 0, _("%s: time stamp %s is %s s in the future"),
-                file_name, tartime (t, true), code_timespec (diff, buf)));
+         WARNOPT (WARN_TIMESTAMP,
+                  (0, 0, _("%s: time stamp %s is %s s in the future"),
+                   file_name, tartime (t, true), code_timespec (diff, buf)));

        }
     }
 }
        }
     }
 }


@@ -352,6 +377,7 @@ delay_set_stat (char const *file_name, struct tar_stat_info const *st,
   data->invert_permissions = invert_permissions;
   data->permstatus = permstatus;
   data->after_links = 0;
   data->invert_permissions = invert_permissions;
   data->permstatus = permstatus;
   data->after_links = 0;

+  data->change_dir = chdir_current;

   strcpy (data->file_name, file_name);
   delayed_set_stat_head = data;
 }
   strcpy (data->file_name, file_name);
   delayed_set_stat_head = data;
 }


@@ -474,9 +500,13 @@ file_newer_p (const char *file_name, struct tar_stat_info *tar_stat)
 
   if (stat (file_name, &st))
     {
 
   if (stat (file_name, &st))
     {

-      stat_warn (file_name);
-      /* Be on the safe side: if the file does exist assume it is newer */
-      return errno != ENOENT;
+      if (errno != ENOENT)
+       {
+         stat_warn (file_name);
+         /* Be on the safe side: if the file does exist assume it is newer */
+         return true;
+       }
+      return false;

     }
   if (!S_ISDIR (st.st_mode)
       && tar_timespec_cmp (tar_stat->mtime, get_stat_mtime (&st)) <= 0)
     }
   if (!S_ISDIR (st.st_mode)
       && tar_timespec_cmp (tar_stat->mtime, get_stat_mtime (&st)) <= 0)


@@ -486,17 +516,24 @@ file_newer_p (const char *file_name, struct tar_stat_info *tar_stat)
   return false;
 }
 
   return false;
 }
 

+#define RECOVER_NO 0
+#define RECOVER_OK 1
+#define RECOVER_SKIP 2
+

 /* Attempt repairing what went wrong with the extraction.  Delete an
    already existing file or create missing intermediate directories.
 /* Attempt repairing what went wrong with the extraction.  Delete an
    already existing file or create missing intermediate directories.

-   Return nonzero if we somewhat increased our chances at a successful
-   extraction.  errno is properly restored on zero return.  */
+   Return RECOVER_OK if we somewhat increased our chances at a successful
+   extraction, RECOVER_NO if there are no chances, and RECOVER_SKIP if the
+   caller should skip extraction of that member.  The value of errno is
+   properly restored on returning RECOVER_NO.  */
+

 static int
 static int

-maybe_recoverable (char *file_name, int *interdir_made)
+maybe_recoverable (char *file_name, bool *interdir_made)

 {
   int e = errno;
 
   if (*interdir_made)
 {
   int e = errno;
 
   if (*interdir_made)

-    return 0;
+    return RECOVER_NO;

 
   switch (errno)
     {
 
   switch (errno)
     {


@@ -506,13 +543,13 @@ maybe_recoverable (char *file_name, int *interdir_made)
       switch (old_files_option)
        {
        case KEEP_OLD_FILES:
       switch (old_files_option)
        {
        case KEEP_OLD_FILES:

-         return 0;
+         return RECOVER_SKIP;

 
        case KEEP_NEWER_FILES:
          if (file_newer_p (file_name, &current_stat_info))
            {
              errno = e;
 
        case KEEP_NEWER_FILES:
          if (file_newer_p (file_name, &current_stat_info))
            {
              errno = e;

-             return 0;
+             return RECOVER_NO;

            }
          /* FALL THROUGH */
 
            }
          /* FALL THROUGH */
 


@@ -522,7 +559,7 @@ maybe_recoverable (char *file_name, int *interdir_made)
          {
            int r = remove_any_file (file_name, ORDINARY_REMOVE_OPTION);
            errno = EEXIST;
          {
            int r = remove_any_file (file_name, ORDINARY_REMOVE_OPTION);
            errno = EEXIST;

-           return r;
+           return r > 0 ? RECOVER_OK : RECOVER_NO;

          }
 
        case UNLINK_FIRST_OLD_FILES:
          }
 
        case UNLINK_FIRST_OLD_FILES:


@@ -534,15 +571,15 @@ maybe_recoverable (char *file_name, int *interdir_made)
       if (! make_directories (file_name))
        {
          errno = ENOENT;
       if (! make_directories (file_name))
        {
          errno = ENOENT;

-         return 0;
+         return RECOVER_NO;

        }
        }

-      *interdir_made = 1;
-      return 1;
+      *interdir_made = true;
+      return RECOVER_OK;

 
     default:
       /* Just say we can't do anything about it...  */
 
 
     default:
       /* Just say we can't do anything about it...  */
 

-      return 0;
+      return RECOVER_NO;

     }
 }
 
     }
 }
 


@@ -574,6 +611,8 @@ apply_nonancestor_delayed_set_stat (char const *file_name, bool after_links)
              && memcmp (file_name, data->file_name, data->file_name_len) == 0))
        break;
 
              && memcmp (file_name, data->file_name, data->file_name_len) == 0))
        break;
 

+      chdir_do (data->change_dir);
+

       if (check_for_renamed_directories)
        {
          cur_info = &st;
       if (check_for_renamed_directories)
        {
          cur_info = &st;


@@ -593,13 +632,13 @@ apply_nonancestor_delayed_set_stat (char const *file_name, bool after_links)
 
       if (! skip_this_one)
        {
 
       if (! skip_this_one)
        {

-         struct tar_stat_info st;
-         st.stat.st_mode = data->mode;
-         st.stat.st_uid = data->uid;
-         st.stat.st_gid = data->gid;
-         st.atime = data->atime;
-         st.mtime = data->mtime;
-         set_stat (data->file_name, &st, cur_info,
+         struct tar_stat_info sb;
+         sb.stat.st_mode = data->mode;
+         sb.stat.st_uid = data->uid;
+         sb.stat.st_gid = data->gid;
+         sb.atime = data->atime;
+         sb.mtime = data->mtime;
+         set_stat (data->file_name, &sb, cur_info,

                    data->invert_permissions, data->permstatus, DIRTYPE);
        }
 
                    data->invert_permissions, data->permstatus, DIRTYPE);
        }
 


@@ -617,19 +656,17 @@ extract_dir (char *file_name, int typeflag)
 {
   int status;
   mode_t mode;
 {
   int status;
   mode_t mode;

-  int interdir_made = 0;
+  bool interdir_made = false;

 
   /* Save 'root device' to avoid purging mount points. */
   if (one_file_system_option && root_device == 0)
     {
       struct stat st;
 
   /* Save 'root device' to avoid purging mount points. */
   if (one_file_system_option && root_device == 0)
     {
       struct stat st;

-      char *dir = xgetcwd ();

 
 

-      if (deref_stat (true, dir, &st))
-       stat_diag (dir);
+      if (stat (".", &st) != 0)
+       stat_diag (".");

       else
        root_device = st.st_dev;
       else
        root_device = st.st_dev;

-      free (dir);

     }
 
   if (incremental_option)
     }
 
   if (incremental_option)


@@ -659,6 +696,7 @@ extract_dir (char *file_name, int typeflag)
                }
              if (S_ISDIR (st.st_mode))
                {
                }
              if (S_ISDIR (st.st_mode))
                {

+                 status = 0;

                  mode = st.st_mode;
                  break;
                }
                  mode = st.st_mode;
                  break;
                }


@@ -666,13 +704,21 @@ extract_dir (char *file_name, int typeflag)
          errno = EEXIST;
        }
 
          errno = EEXIST;
        }
 

-      if (maybe_recoverable (file_name, &interdir_made))
-       continue;
-
-      if (errno != EEXIST)
+      switch (maybe_recoverable (file_name, &interdir_made))

        {
        {

-         mkdir_error (file_name);
-         return 1;
+       case RECOVER_OK:
+         continue;
+
+       case RECOVER_SKIP:
+         break;
+
+       case RECOVER_NO:
+         if (errno != EEXIST)
+           {
+             mkdir_error (file_name);
+             return 1;
+           }
+         break;

        }
       break;
     }
        }
       break;
     }


@@ -721,7 +767,8 @@ open_output_file (char *file_name, int typeflag, mode_t mode)
       if (!conttype_diagnosed)
        {
          conttype_diagnosed = 1;
       if (!conttype_diagnosed)
        {
          conttype_diagnosed = 1;

-         WARN ((0, 0, _("Extracting contiguous files as regular files")));
+         WARNOPT (WARN_CONTIGUOUS_CAST,
+                  (0, 0, _("Extracting contiguous files as regular files")));

        }
     }
   fd = open (file_name, openflag, mode);
        }
     }
   fd = open (file_name, openflag, mode);


@@ -740,7 +787,7 @@ extract_file (char *file_name, int typeflag)
   int status;
   size_t count;
   size_t written;
   int status;
   size_t count;
   size_t written;

-  int interdir_made = 0;
+  bool interdir_made = false;

   mode_t mode = current_stat_info.stat.st_mode & MODE_RWX & ~ current_umask;
   mode_t invert_permissions =
     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
   mode_t mode = current_stat_info.stat.st_mode & MODE_RWX & ~ current_umask;
   mode_t invert_permissions =
     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;


@@ -760,19 +807,24 @@ extract_file (char *file_name, int typeflag)
     }
   else
     {
     }
   else
     {

+      int recover = RECOVER_NO;

       do
        fd = open_output_file (file_name, typeflag, mode ^ invert_permissions);
       do
        fd = open_output_file (file_name, typeflag, mode ^ invert_permissions);

-      while (fd < 0 && maybe_recoverable (file_name, &interdir_made));
+      while (fd < 0
+            && (recover = maybe_recoverable (file_name, &interdir_made))
+                == RECOVER_OK);

 
       if (fd < 0)
        {
          skip_member ();
 
       if (fd < 0)
        {
          skip_member ();

+         if (recover == RECOVER_SKIP)
+           return 0;

          open_error (file_name);
          return 1;
        }
     }
 
          open_error (file_name);
          return 1;
        }
     }
 

-  mv_begin (&current_stat_info);
+  mv_begin_read (&current_stat_info);

   if (current_stat_info.is_sparse)
     sparse_extract_file (fd, &current_stat_info, &size);
   else
   if (current_stat_info.is_sparse)
     sparse_extract_file (fd, &current_stat_info, &size);
   else


@@ -842,18 +894,28 @@ extract_file (char *file_name, int typeflag)
    process.  */
 
 static int
    process.  */
 
 static int

-create_placeholder_file (char *file_name, bool is_symlink, int *interdir_made)
+create_placeholder_file (char *file_name, bool is_symlink, bool *interdir_made)

 {
   int fd;
   struct stat st;
 
   while ((fd = open (file_name, O_WRONLY | O_CREAT | O_EXCL, 0)) < 0)
 {
   int fd;
   struct stat st;
 
   while ((fd = open (file_name, O_WRONLY | O_CREAT | O_EXCL, 0)) < 0)

-    if (! maybe_recoverable (file_name, interdir_made))
-      break;
+    {
+      switch (maybe_recoverable (file_name, interdir_made))
+       {
+       case RECOVER_OK:
+         continue;
+
+       case RECOVER_SKIP:
+         return 0;
+
+       case RECOVER_NO:
+         open_error (file_name);
+         return -1;
+       }
+      }

 
 

-  if (fd < 0)
-    open_error (file_name);
-  else if (fstat (fd, &st) != 0)
+  if (fstat (fd, &st) != 0)

     {
       stat_error (file_name);
       close (fd);
     {
       stat_error (file_name);
       close (fd);


@@ -871,13 +933,14 @@ create_placeholder_file (char *file_name, bool is_symlink, int *interdir_made)
       delayed_link_head = p;
       p->dev = st.st_dev;
       p->ino = st.st_ino;
       delayed_link_head = p;
       p->dev = st.st_dev;
       p->ino = st.st_ino;

-      p->mtime = get_stat_mtime (&st);
+      p->ctime = get_stat_ctime (&st);

       p->is_symlink = is_symlink;
       if (is_symlink)
        {
          p->uid = current_stat_info.stat.st_uid;
          p->gid = current_stat_info.stat.st_gid;
        }
       p->is_symlink = is_symlink;
       if (is_symlink)
        {
          p->uid = current_stat_info.stat.st_uid;
          p->gid = current_stat_info.stat.st_gid;
        }

+      p->change_dir = chdir_current;

       p->sources = xmalloc (offsetof (struct string_list, string)
                            + strlen (file_name) + 1);
       p->sources->next = 0;
       p->sources = xmalloc (offsetof (struct string_list, string)
                            + strlen (file_name) + 1);
       p->sources->next = 0;


@@ -914,9 +977,11 @@ create_placeholder_file (char *file_name, bool is_symlink, int *interdir_made)
 static int
 extract_link (char *file_name, int typeflag)
 {
 static int
 extract_link (char *file_name, int typeflag)
 {

-  char const *link_name = safer_name_suffix (current_stat_info.link_name,
-                                             true, absolute_names_option);
-  int interdir_made = 0;
+  bool interdir_made = false;
+  char const *link_name;
+  int rc;
+
+  link_name = current_stat_info.link_name;

 
   if (! absolute_names_option && contains_dot_dot (link_name))
     return create_placeholder_file (file_name, false, &interdir_made);
 
   if (! absolute_names_option && contains_dot_dot (link_name))
     return create_placeholder_file (file_name, false, &interdir_made);


@@ -933,9 +998,10 @@ extract_link (char *file_name, int typeflag)
          struct delayed_link *ds = delayed_link_head;
          if (ds && lstat (link_name, &st1) == 0)
            for (; ds; ds = ds->next)
          struct delayed_link *ds = delayed_link_head;
          if (ds && lstat (link_name, &st1) == 0)
            for (; ds; ds = ds->next)

-             if (ds->dev == st1.st_dev
+             if (ds->change_dir == chdir_current
+                 && ds->dev == st1.st_dev

                  && ds->ino == st1.st_ino
                  && ds->ino == st1.st_ino

-                 && timespec_cmp (ds->mtime, get_stat_mtime (&st1)) == 0)
+                 && timespec_cmp (ds->ctime, get_stat_ctime (&st1)) == 0)

                {
                  struct string_list *p =  xmalloc (offsetof (struct string_list, string)
                                                    + strlen (file_name) + 1);
                {
                  struct string_list *p =  xmalloc (offsetof (struct string_list, string)
                                                    + strlen (file_name) + 1);


@@ -955,8 +1021,10 @@ extract_link (char *file_name, int typeflag)
 
       errno = e;
     }
 
       errno = e;
     }

-  while (maybe_recoverable (file_name, &interdir_made));
+  while ((rc = maybe_recoverable (file_name, &interdir_made)) == RECOVER_OK);

 
 

+  if (rc == RECOVER_SKIP)
+    return 0;

   if (!(incremental_option && errno == EEXIST))
     {
       link_error (link_name, file_name);
   if (!(incremental_option && errno == EEXIST))
     {
       link_error (link_name, file_name);


@@ -969,23 +1037,29 @@ static int
 extract_symlink (char *file_name, int typeflag)
 {
 #ifdef HAVE_SYMLINK
 extract_symlink (char *file_name, int typeflag)
 {
 #ifdef HAVE_SYMLINK

-  int status;
-  int interdir_made = 0;
+  bool interdir_made = false;

 
   if (! absolute_names_option
       && (IS_ABSOLUTE_FILE_NAME (current_stat_info.link_name)
          || contains_dot_dot (current_stat_info.link_name)))
     return create_placeholder_file (file_name, true, &interdir_made);
 
 
   if (! absolute_names_option
       && (IS_ABSOLUTE_FILE_NAME (current_stat_info.link_name)
          || contains_dot_dot (current_stat_info.link_name)))
     return create_placeholder_file (file_name, true, &interdir_made);
 

-  while ((status = symlink (current_stat_info.link_name, file_name)))
-    if (!maybe_recoverable (file_name, &interdir_made))
-      break;
+  while (symlink (current_stat_info.link_name, file_name))
+    switch (maybe_recoverable (file_name, &interdir_made))
+      {
+      case RECOVER_OK:
+       continue;

 
 

-  if (status == 0)
-    set_stat (file_name, &current_stat_info, NULL, 0, 0, SYMTYPE);
-  else
-    symlink_error (current_stat_info.link_name, file_name);
-  return status;
+      case RECOVER_SKIP:
+       return 0;
+
+      case RECOVER_NO:
+       symlink_error (current_stat_info.link_name, file_name);
+       return -1;
+      }
+
+  set_stat (file_name, &current_stat_info, NULL, 0, 0, SYMTYPE);
+  return 0;

 
 #else
   static int warned_once;
 
 #else
   static int warned_once;


@@ -993,7 +1067,9 @@ extract_symlink (char *file_name, int typeflag)
   if (!warned_once)
     {
       warned_once = 1;
   if (!warned_once)
     {
       warned_once = 1;

-      WARN ((0, 0, _("Attempting extraction of symbolic links as hard links")));
+      WARNOPT (WARN_SYMBOLIC_CAST,
+              (0, 0,
+               _("Attempting extraction of symbolic links as hard links")));

     }
   return extract_link (file_name, typeflag);
 #endif
     }
   return extract_link (file_name, typeflag);
 #endif


@@ -1003,23 +1079,29 @@ extract_symlink (char *file_name, int typeflag)
 static int
 extract_node (char *file_name, int typeflag)
 {
 static int
 extract_node (char *file_name, int typeflag)
 {

-  int status;
-  int interdir_made = 0;
+  bool interdir_made = false;

   mode_t mode = current_stat_info.stat.st_mode & ~ current_umask;
   mode_t invert_permissions =
     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
 
   mode_t mode = current_stat_info.stat.st_mode & ~ current_umask;
   mode_t invert_permissions =
     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
 

-  do
-    status = mknod (file_name, mode ^ invert_permissions,
-                   current_stat_info.stat.st_rdev);
-  while (status && maybe_recoverable (file_name, &interdir_made));
+  while (mknod (file_name, mode ^ invert_permissions,
+               current_stat_info.stat.st_rdev))
+    switch (maybe_recoverable (file_name, &interdir_made))
+      {
+      case RECOVER_OK:
+       continue;

 
 

-  if (status != 0)
-    mknod_error (file_name);
-  else
-    set_stat (file_name, &current_stat_info, NULL, invert_permissions,
-             ARCHIVED_PERMSTATUS, typeflag);
-  return status;
+      case RECOVER_SKIP:
+       return 0;
+
+      case RECOVER_NO:
+       mknod_error (file_name);
+       return -1;
+      }
+
+  set_stat (file_name, &current_stat_info, NULL, invert_permissions,
+           ARCHIVED_PERMSTATUS, typeflag);
+  return 0;

 }
 #endif
 
 }
 #endif
 


@@ -1028,29 +1110,34 @@ static int
 extract_fifo (char *file_name, int typeflag)
 {
   int status;
 extract_fifo (char *file_name, int typeflag)
 {
   int status;

-  int interdir_made = 0;
+  bool interdir_made = false;

   mode_t mode = current_stat_info.stat.st_mode & ~ current_umask;
   mode_t invert_permissions =
     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
 
   while ((status = mkfifo (file_name, mode)) != 0)
   mode_t mode = current_stat_info.stat.st_mode & ~ current_umask;
   mode_t invert_permissions =
     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
 
   while ((status = mkfifo (file_name, mode)) != 0)

-    if (!maybe_recoverable (file_name, &interdir_made))
-      break;
+    switch (maybe_recoverable (file_name, &interdir_made))
+      {
+      case RECOVER_OK:
+       continue;

 
 

-  if (status == 0)
-    set_stat (file_name, &current_stat_info, NULL, invert_permissions,
-             ARCHIVED_PERMSTATUS, typeflag);
-  else
-    mkfifo_error (file_name);
-  return status;
+      case RECOVER_SKIP:
+       return 0;
+
+      case RECOVER_NO:
+       mkfifo_error (file_name);
+       return -1;
+      }
+
+  set_stat (file_name, &current_stat_info, NULL, invert_permissions,
+           ARCHIVED_PERMSTATUS, typeflag);
+  return 0;

 }
 #endif
 
 static int
 extract_volhdr (char *file_name, int typeflag)
 {
 }
 #endif
 
 static int
 extract_volhdr (char *file_name, int typeflag)
 {

-  if (verbose_option)
-    fprintf (stdlis, _("Reading %s\n"), quote (current_stat_info.file_name));

   skip_member ();
   return 0;
 }
   skip_member ();
   return 0;
 }


@@ -1151,9 +1238,10 @@ prepare_to_extract (char const *file_name, int typeflag, tar_extractor_t *fun)
       break;
 
     default:
       break;
 
     default:

-      WARN ((0, 0,
-            _("%s: Unknown file type `%c', extracted as normal file"),
-            quotearg_colon (file_name), typeflag));
+      WARNOPT (WARN_UNKNOWN_CAST,
+              (0, 0,
+               _("%s: Unknown file type `%c', extracted as normal file"),
+               quotearg_colon (file_name), typeflag));

       *fun = extract_file;
     }
 
       *fun = extract_file;
     }
 


@@ -1177,8 +1265,9 @@ prepare_to_extract (char const *file_name, int typeflag, tar_extractor_t *fun)
     case KEEP_NEWER_FILES:
       if (file_newer_p (file_name, &current_stat_info))
        {
     case KEEP_NEWER_FILES:
       if (file_newer_p (file_name, &current_stat_info))
        {

-         WARN ((0, 0, _("Current %s is newer or same age"),
-                quote (file_name)));
+         WARNOPT (WARN_IGNORE_NEWER,
+                  (0, 0, _("Current %s is newer or same age"),
+                   quote (file_name)));

          return 0;
        }
       break;
          return 0;
        }
       break;


@@ -1197,8 +1286,10 @@ extract_archive (void)
   char typeflag;
   tar_extractor_t fun;
 
   char typeflag;
   tar_extractor_t fun;
 

+  fatal_exit_hook = extract_finish;
+

   set_next_block_after (current_header);
   set_next_block_after (current_header);

-  decode_header (current_header, &current_stat_info, &current_format, 1);
+

   if (!current_stat_info.file_name[0]
       || (interactive_option
          && !confirm ("extract", current_stat_info.file_name)))
   if (!current_stat_info.file_name[0]
       || (interactive_option
          && !confirm ("extract", current_stat_info.file_name)))


@@ -1209,13 +1300,17 @@ extract_archive (void)
 
   /* Print the block from current_header and current_stat.  */
   if (verbose_option)
 
   /* Print the block from current_header and current_stat.  */
   if (verbose_option)

-    print_header (&current_stat_info, -1);
+    print_header (&current_stat_info, current_header, -1);

 
   /* Restore stats for all non-ancestor directories, unless
      it is an incremental archive.
      (see NOTICE in the comment to delay_set_stat above) */
   if (!delay_directory_restore_option)
 
   /* Restore stats for all non-ancestor directories, unless
      it is an incremental archive.
      (see NOTICE in the comment to delay_set_stat above) */
   if (!delay_directory_restore_option)

-    apply_nonancestor_delayed_set_stat (current_stat_info.file_name, 0);
+    {
+      int dir = chdir_current;
+      apply_nonancestor_delayed_set_stat (current_stat_info.file_name, 0);
+      chdir_do (dir);
+    }

 
   /* Take a safety backup of a previously existing file.  */
 
 
   /* Take a safety backup of a previously existing file.  */
 


@@ -1245,7 +1340,7 @@ extract_archive (void)
 
 }
 
 
 }
 

-/* Extract the symbolic links whose final extraction were delayed.  */
+/* Extract the links whose final extraction were delayed.  */

 static void
 apply_delayed_links (void)
 {
 static void
 apply_delayed_links (void)
 {


@@ -1256,6 +1351,8 @@ apply_delayed_links (void)
       struct string_list *sources = ds->sources;
       char const *valid_source = 0;
 
       struct string_list *sources = ds->sources;
       char const *valid_source = 0;
 

+      chdir_do (ds->change_dir);
+

       for (sources = ds->sources; sources; sources = sources->next)
        {
          char const *source = sources->string;
       for (sources = ds->sources; sources; sources = sources->next)
        {
          char const *source = sources->string;


@@ -1267,7 +1364,7 @@ apply_delayed_links (void)
          if (lstat (source, &st) == 0
              && st.st_dev == ds->dev
              && st.st_ino == ds->ino
          if (lstat (source, &st) == 0
              && st.st_dev == ds->dev
              && st.st_ino == ds->ino

-             && timespec_cmp (get_stat_mtime (&st), ds->mtime) == 0)
+             && timespec_cmp (get_stat_ctime (&st), ds->ctime) == 0)

            {
              /* Unlink the placeholder, then create a hard link if possible,
                 a symbolic link otherwise.  */
            {
              /* Unlink the placeholder, then create a hard link if possible,
                 a symbolic link otherwise.  */


@@ -1358,18 +1455,3 @@ rename_directory (char *src, char *dst)
     }
   return true;
 }
     }
   return true;
 }

-
-void
-fatal_exit (void)
-{
-  extract_finish ();
-  error (TAREXIT_FAILURE, 0, _("Error is not recoverable: exiting now"));
-  abort ();
-}
-
-void
-xalloc_die (void)
-{
-  error (0, 0, "%s", _("memory exhausted"));
-  fatal_exit ();
-}