tar: switch to gnulib fdutimensat module

[chaz/tar] / src / misc.c

diff --git a/src/misc.c b/src/misc.c
index 148d766c1dd00de8124142f11e2fbf8103a475ca..ca2921b0e0e6ad597f8967c41a40df3efcf92140 100644 (file)
--- a/src/misc.c
+++ b/src/misc.c
@@ -1,11 +1,11 @@
 /* Miscellaneous functions, not really specific to GNU tar.
 
    Copyright (C) 1988, 1992, 1994, 1995, 1996, 1997, 1999, 2000, 2001,
 /* Miscellaneous functions, not really specific to GNU tar.
 
    Copyright (C) 1988, 1992, 1994, 1995, 1996, 1997, 1999, 2000, 2001,

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

 
    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
 
    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


@@ -15,16 +15,20 @@
 
    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
 
    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,

-   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */

 
 #include <system.h>
 #include <rmt.h>
 #include "common.h"
 #include <quotearg.h>
 #include <save-cwd.h>
 
 #include <system.h>
 #include <rmt.h>
 #include "common.h"
 #include <quotearg.h>
 #include <save-cwd.h>

+#include <xgetcwd.h>
+#include <unlinkdir.h>
+
+#ifndef DOUBLE_SLASH_IS_DISTINCT_ROOT
+# define DOUBLE_SLASH_IS_DISTINCT_ROOT 0
+#endif

 
 

-static void call_arg_fatal (char const *, char const *)
-     __attribute__ ((noreturn));

 \f
 /* Handling strings.  */
 
 \f
 /* Handling strings.  */
 


@@ -38,6 +42,9 @@ assign_string (char **string, const char *value)
   *string = value ? xstrdup (value) : 0;
 }
 
   *string = value ? xstrdup (value) : 0;
 }
 

+#if 0
+/* This function is currently unused; perhaps it should be removed?  */
+

 /* Allocate a copy of the string quoted as in C, and returns that.  If
    the string does not have to be quoted, it returns a null pointer.
    The allocated copy should normally be freed with free() after the
 /* Allocate a copy of the string quoted as in C, and returns that.  If
    the string does not have to be quoted, it returns a null pointer.
    The allocated copy should normally be freed with free() after the


@@ -50,7 +57,7 @@ assign_string (char **string, const char *value)
    when reading directory files.  This means that we can't use
    quotearg, as quotearg is locale-dependent and is meant for human
    consumption.  */
    when reading directory files.  This means that we can't use
    quotearg, as quotearg is locale-dependent and is meant for human
    consumption.  */

-char *
+static char *

 quote_copy_string (const char *string)
 {
   const char *source = string;
 quote_copy_string (const char *string)
 {
   const char *source = string;


@@ -91,6 +98,7 @@ quote_copy_string (const char *string)
     }
   return 0;
 }
     }
   return 0;
 }

+#endif

 
 /* Takes a quoted C string (like those produced by quote_copy_string)
    and turns it back into the un-quoted original.  This is done in
 
 /* Takes a quoted C string (like those produced by quote_copy_string)
    and turns it back into the un-quoted original.  This is done in


@@ -127,7 +135,7 @@ unquote_string (char *string)
          *destination++ = '\a';
          source++;
          break;
          *destination++ = '\a';
          source++;
          break;

-         
+

        case 'b':
          *destination++ = '\b';
          source++;
        case 'b':
          *destination++ = '\b';
          source++;


@@ -157,7 +165,7 @@ unquote_string (char *string)
          *destination++ = '\v';
          source++;
          break;
          *destination++ = '\v';
          source++;
          break;

-         
+

        case '?':
          *destination++ = 0177;
          source++;
        case '?':
          *destination++ = 0177;
          source++;


@@ -206,6 +214,174 @@ unquote_string (char *string)
     *destination = '\0';
   return result;
 }
     *destination = '\0';
   return result;
 }

+
+/* Zap trailing slashes.  */
+char *
+zap_slashes (char *name)
+{
+  char *q;
+
+  if (!name || *name == 0)
+    return name;
+  q = name + strlen (name) - 1;
+  while (q > name && ISSLASH (*q))
+    *q-- = '\0';
+  return name;
+}
+
+/* Normalize FILE_NAME by removing redundant slashes and "."
+   components, including redundant trailing slashes.  Leave ".."
+   alone, as it may be significant in the presence of symlinks and on
+   platforms where "/.." != "/".  Destructive version: modifies its
+   argument. */
+static void
+normalize_filename_x (char *file_name)
+{
+  char *name = file_name + FILE_SYSTEM_PREFIX_LEN (file_name);
+  char *p;
+  char const *q;
+  char c;
+
+  /* Don't squeeze leading "//" to "/", on hosts where they're distinct.  */
+  name += (DOUBLE_SLASH_IS_DISTINCT_ROOT
+          && ISSLASH (*name) && ISSLASH (name[1]) && ! ISSLASH (name[2]));
+
+  /* Omit redundant leading "." components.  */
+  for (q = p = name; (*p = *q) == '.' && ISSLASH (q[1]); p += !*q)
+    for (q += 2; ISSLASH (*q); q++)
+      continue;
+
+  /* Copy components from Q to P, omitting redundant slashes and
+     internal "."  components.  */
+  while ((*p++ = c = *q++) != '\0')
+    if (ISSLASH (c))
+      while (ISSLASH (q[*q == '.']))
+       q += (*q == '.') + 1;
+
+  /* Omit redundant trailing "." component and slash.  */
+  if (2 < p - name)
+    {
+      p -= p[-2] == '.' && ISSLASH (p[-3]);
+      p -= 2 < p - name && ISSLASH (p[-2]);
+      p[-1] = '\0';
+    }
+}
+
+/* Normalize NAME by removing redundant slashes and "." components,
+   including redundant trailing slashes.  Return a normalized
+   newly-allocated copy.  */
+
+char *
+normalize_filename (const char *name)
+{
+  char *copy = NULL;
+
+  if (IS_RELATIVE_FILE_NAME (name))
+    {
+      /* Set COPY to the absolute file name if possible.
+
+         FIXME: There should be no need to get the absolute file name.
+         getcwd is slow, it might fail, and it does not necessarily
+         return a canonical name even when it succeeds.  Perhaps we
+         can use dev+ino pairs instead of names?  */
+      copy = xgetcwd ();
+      if (copy)
+        {
+          size_t copylen = strlen (copy);
+          bool need_separator = ! (DOUBLE_SLASH_IS_DISTINCT_ROOT
+                                   && copylen == 2 && ISSLASH (copy[1]));
+          copy = xrealloc (copy, copylen + need_separator + strlen (name) + 1);
+          copy[copylen] = DIRECTORY_SEPARATOR;
+          strcpy (copy + copylen + need_separator, name);
+        }
+      else
+        WARN ((0, errno, _("Cannot get working directory")));
+    }
+
+  if (! copy)
+    copy = xstrdup (name);
+  normalize_filename_x (copy);
+  return copy;
+}
+
+\f
+void
+replace_prefix (char **pname, const char *samp, size_t slen,
+               const char *repl, size_t rlen)
+{
+  char *name = *pname;
+  size_t nlen = strlen (name);
+  if (nlen > slen && memcmp (name, samp, slen) == 0 && ISSLASH (name[slen]))
+    {
+      if (rlen > slen)
+       {
+         name = xrealloc (name, nlen - slen + rlen + 1);
+         *pname = name;
+       }
+      memmove (name + rlen, name + slen, nlen - slen + 1);
+      memcpy (name, repl, rlen);
+    }
+}
+
+\f
+/* Handling numbers.  */
+
+/* Output fraction and trailing digits appropriate for a nanoseconds
+   count equal to NS, but don't output unnecessary '.' or trailing
+   zeros.  */
+
+void
+code_ns_fraction (int ns, char *p)
+{
+  if (ns == 0)
+    *p = '\0';
+  else
+    {
+      int i = 9;
+      *p++ = '.';
+
+      while (ns % 10 == 0)
+       {
+         ns /= 10;
+         i--;
+       }
+
+      p[i] = '\0';
+
+      for (;;)
+       {
+         p[--i] = '0' + ns % 10;
+         if (i == 0)
+           break;
+         ns /= 10;
+       }
+    }
+}
+
+char const *
+code_timespec (struct timespec t, char sbuf[TIMESPEC_STRSIZE_BOUND])
+{
+  time_t s = t.tv_sec;
+  int ns = t.tv_nsec;
+  char *np;
+  bool negative = s < 0;
+
+  /* ignore invalid values of ns */
+  if (BILLION <= ns || ns < 0)
+    ns = 0;
+
+  if (negative && ns != 0)
+    {
+      s++;
+      ns = BILLION - ns;
+    }
+
+  np = umaxtostr (negative ? - (uintmax_t) s : (uintmax_t) s, sbuf + 1);
+  if (negative)
+    *--np = '-';
+  code_ns_fraction (ns, sbuf + UINTMAX_STRSIZE_BOUND);
+  return np;
+}

 \f
 /* File handling.  */
 
 \f
 /* File handling.  */
 


@@ -214,7 +390,7 @@ static char *before_backup_name;
 static char *after_backup_name;
 
 /* Return 1 if FILE_NAME is obviously "." or "/".  */
 static char *after_backup_name;
 
 /* Return 1 if FILE_NAME is obviously "." or "/".  */

-static bool
+bool

 must_be_dot_or_slash (char const *file_name)
 {
   file_name += FILE_SYSTEM_PREFIX_LEN (file_name);
 must_be_dot_or_slash (char const *file_name)
 {
   file_name += FILE_SYSTEM_PREFIX_LEN (file_name);


@@ -224,7 +400,7 @@ must_be_dot_or_slash (char const *file_name)
       for (;;)
        if (ISSLASH (file_name[1]))
          file_name++;
       for (;;)
        if (ISSLASH (file_name[1]))
          file_name++;

-       else if (file_name[1] == '.' 
+       else if (file_name[1] == '.'

                  && ISSLASH (file_name[2 + (file_name[2] == '.')]))
          file_name += 2 + (file_name[2] == '.');
        else
                  && ISSLASH (file_name[2 + (file_name[2] == '.')]))
          file_name += 2 + (file_name[2] == '.');
        else


@@ -258,7 +434,7 @@ safer_rmdir (const char *file_name)
   return rmdir (file_name);
 }
 
   return rmdir (file_name);
 }
 

-/* Remove FILE_NAME, returning 1 on success.  If FILE_NAME is a directory, 
+/* Remove FILE_NAME, returning 1 on success.  If FILE_NAME is a directory,

    then if OPTION is RECURSIVE_REMOVE_OPTION is set remove FILE_NAME
    recursively; otherwise, remove it only if it is empty.  If FILE_NAME is
    a directory that cannot be removed (e.g., because it is nonempty)
    then if OPTION is RECURSIVE_REMOVE_OPTION is set remove FILE_NAME
    recursively; otherwise, remove it only if it is empty.  If FILE_NAME is
    a directory that cannot be removed (e.g., because it is nonempty)


@@ -268,9 +444,12 @@ safer_rmdir (const char *file_name)
 int
 remove_any_file (const char *file_name, enum remove_option option)
 {
 int
 remove_any_file (const char *file_name, enum remove_option option)
 {

-  /* Try unlink first if we are not root, as this saves us a system
-     call in the common case where we're removing a non-directory.  */
-  if (! we_are_root)
+  /* Try unlink first if we cannot unlink directories, as this saves
+     us a system call in the common case where we're removing a
+     non-directory.  */
+  bool try_unlink_first = cannot_unlink_dir ();
+
+  if (try_unlink_first)

     {
       if (unlink (file_name) == 0)
        return 1;
     {
       if (unlink (file_name) == 0)
        return 1;


@@ -288,7 +467,7 @@ remove_any_file (const char *file_name, enum remove_option option)
   switch (errno)
     {
     case ENOTDIR:
   switch (errno)
     {
     case ENOTDIR:

-      return we_are_root && unlink (file_name) == 0;
+      return !try_unlink_first && unlink (file_name) == 0;

 
     case 0:
     case EEXIST:
 
     case 0:
     case EEXIST:


@@ -317,7 +496,7 @@ remove_any_file (const char *file_name, enum remove_option option)
                 entry += entrylen + 1)
              {
                char *file_name_buffer = new_name (file_name, entry);
                 entry += entrylen + 1)
              {
                char *file_name_buffer = new_name (file_name, entry);

-               int r = remove_any_file (file_name_buffer, 
+               int r = remove_any_file (file_name_buffer,

                                          RECURSIVE_REMOVE_OPTION);
                int e = errno;
                free (file_name_buffer);
                                          RECURSIVE_REMOVE_OPTION);
                int e = errno;
                free (file_name_buffer);


@@ -347,10 +526,19 @@ remove_any_file (const char *file_name, enum remove_option option)
    so, we do not have to backup block or character devices, nor remote
    entities.  */
 bool
    so, we do not have to backup block or character devices, nor remote
    entities.  */
 bool

-maybe_backup_file (const char *file_name, int this_is_the_archive)
+maybe_backup_file (const char *file_name, bool this_is_the_archive)

 {
   struct stat file_stat;
 
 {
   struct stat file_stat;
 

+  assign_string (&before_backup_name, file_name);
+
+  /* A run situation may exist between Emacs or other GNU programs trying to
+     make a backup for the same file simultaneously.  If theoretically
+     possible, real problems are unlikely.  Doing any better would require a
+     convention, GNU-wide, for all programs doing backups.  */
+
+  assign_string (&after_backup_name, 0);
+

   /* Check if we really need to backup the file.  */
 
   if (this_is_the_archive && _remdev (file_name))
   /* Check if we really need to backup the file.  */
 
   if (this_is_the_archive && _remdev (file_name))


@@ -372,14 +560,6 @@ maybe_backup_file (const char *file_name, int this_is_the_archive)
       && (S_ISBLK (file_stat.st_mode) || S_ISCHR (file_stat.st_mode)))
     return true;
 
       && (S_ISBLK (file_stat.st_mode) || S_ISCHR (file_stat.st_mode)))
     return true;
 

-  assign_string (&before_backup_name, file_name);
-
-  /* A run situation may exist between Emacs or other GNU programs trying to
-     make a backup for the same file simultaneously.  If theoretically
-     possible, real problems are unlikely.  Doing any better would require a
-     convention, GNU-wide, for all programs doing backups.  */
-
-  assign_string (&after_backup_name, 0);

   after_backup_name = find_backup_file_name (file_name, backup_type);
   if (! after_backup_name)
     xalloc_die ();
   after_backup_name = find_backup_file_name (file_name, backup_type);
   if (! after_backup_name)
     xalloc_die ();


@@ -433,11 +613,31 @@ deref_stat (bool deref, char const *name, struct stat *buf)
   return deref ? stat (name, buf) : lstat (name, buf);
 }
 
   return deref ? stat (name, buf) : lstat (name, buf);
 }
 

+/* Set FD's (i.e., assuming the working directory is PARENTFD, FILE's)
+   access time to ATIME.  ATFLAG controls symbolic-link following, in
+   the style of openat.  */
+int
+set_file_atime (int fd, int parentfd, char const *file, struct timespec atime,
+               int atflag)
+{
+  struct timespec ts[2];
+  ts[0] = atime;
+  ts[1].tv_nsec = UTIME_OMIT;
+  return fdutimensat (fd, parentfd, file, ts, atflag);
+}
+

 /* A description of a working directory.  */
 struct wd
 {
 /* A description of a working directory.  */
 struct wd
 {

+  /* The directory's name.  */

   char const *name;
   char const *name;

-  int saved;
+
+  /* A negative value if no attempt has been made to save the
+     directory, 0 if it was saved successfully, and a positive errno
+     value if it was not saved successfully.  */
+  int err;
+
+  /* The saved version of the directory, if ERR == 0.  */

   struct saved_cwd saved_cwd;
 };
 
   struct saved_cwd saved_cwd;
 };
 


@@ -445,25 +645,39 @@ struct wd
 static struct wd *wd;
 
 /* The number of working directories in the vector.  */
 static struct wd *wd;
 
 /* The number of working directories in the vector.  */

-static size_t wds;
+static size_t wd_count;

 
 /* The allocated size of the vector.  */
 static size_t wd_alloc;
 
 
 /* The allocated size of the vector.  */
 static size_t wd_alloc;
 

+int
+chdir_count ()
+{
+  if (wd_count == 0)
+    return wd_count;
+  return wd_count - 1;
+}
+

 /* DIR is the operand of a -C option; add it to vector of chdir targets,
    and return the index of its location.  */
 int
 chdir_arg (char const *dir)
 {
 /* DIR is the operand of a -C option; add it to vector of chdir targets,
    and return the index of its location.  */
 int
 chdir_arg (char const *dir)
 {

-  if (wds == wd_alloc)
+  if (wd_count == wd_alloc)

     {
     {

-      wd_alloc = 2 * (wd_alloc + 1);
-      wd = xrealloc (wd, sizeof *wd * wd_alloc);
-      if (! wds)
+      if (wd_alloc == 0)

        {
        {

-         wd[wds].name = ".";
-         wd[wds].saved = 0;
-         wds++;
+         wd_alloc = 2;
+         wd = xmalloc (sizeof *wd * wd_alloc);
+       }
+      else
+       wd = x2nrealloc (wd, &wd_alloc, sizeof *wd);
+
+      if (! wd_count)
+       {
+         wd[wd_count].name = ".";
+         wd[wd_count].err = -1;
+         wd_count++;

        }
     }
 
        }
     }
 


@@ -475,37 +689,60 @@ chdir_arg (char const *dir)
        for (dir += 2;  ISSLASH (*dir);  dir++)
          continue;
       if (! dir[dir[0] == '.'])
        for (dir += 2;  ISSLASH (*dir);  dir++)
          continue;
       if (! dir[dir[0] == '.'])

-       return wds - 1;
+       return wd_count - 1;

     }
 
     }
 

-  wd[wds].name = dir;
-  wd[wds].saved = 0;
-  return wds++;
+  wd[wd_count].name = dir;
+  wd[wd_count].err = -1;
+  return wd_count++;

 }
 
 }
 

+/* Index of current directory.  */
+int chdir_current;
+

 /* Change to directory I.  If I is 0, change to the initial working
    directory; otherwise, I must be a value returned by chdir_arg.  */
 void
 chdir_do (int i)
 {
 /* Change to directory I.  If I is 0, change to the initial working
    directory; otherwise, I must be a value returned by chdir_arg.  */
 void
 chdir_do (int i)
 {

-  static int previous;
-
-  if (previous != i)
+  if (chdir_current != i)

     {
     {

-      struct wd *prev = &wd[previous];
+      struct wd *prev = &wd[chdir_current];

       struct wd *curr = &wd[i];
 
       struct wd *curr = &wd[i];
 

-      if (! prev->saved)
+      if (prev->err < 0)

        {
        {

-         prev->saved = 1;
+         prev->err = 0;

          if (save_cwd (&prev->saved_cwd) != 0)
          if (save_cwd (&prev->saved_cwd) != 0)

-           FATAL_ERROR ((0, 0, _("Cannot save working directory")));
+           prev->err = errno;
+         else if (0 <= prev->saved_cwd.desc)
+           {
+             /* Make sure we still have at least one descriptor available.  */
+             int fd1 = prev->saved_cwd.desc;
+             int fd2 = dup (fd1);
+             if (0 <= fd2)
+               close (fd2);
+             else if (errno == EMFILE)
+               {
+                 /* Force restore_cwd to use chdir_long.  */
+                 close (fd1);
+                 prev->saved_cwd.desc = -1;
+                 prev->saved_cwd.name = xgetcwd ();
+                 if (! prev->saved_cwd.name)
+                   prev->err = errno;
+               }
+             else
+               prev->err = errno;
+           }

        }
 
        }
 

-      if (curr->saved)
+      if (0 <= curr->err)

        {
        {

-         if (restore_cwd (&curr->saved_cwd))
-           FATAL_ERROR ((0, 0, _("Cannot change working directory")));
+         int err = curr->err;
+         if (err == 0 && restore_cwd (&curr->saved_cwd) != 0)
+           err = errno;
+         if (err)
+           FATAL_ERROR ((0, err, _("Cannot restore working directory")));

        }
       else
        {
        }
       else
        {


@@ -515,109 +752,10 @@ chdir_do (int i)
            chdir_fatal (curr->name);
        }
 
            chdir_fatal (curr->name);
        }
 

-      previous = i;
+      chdir_current = i;

     }
 }
 \f
     }
 }
 \f

-/* Decode MODE from its binary form in a stat structure, and encode it
-   into a 9-byte string STRING, terminated with a NUL.  */
-
-void
-decode_mode (mode_t mode, char *string)
-{
-  *string++ = mode & S_IRUSR ? 'r' : '-';
-  *string++ = mode & S_IWUSR ? 'w' : '-';
-  *string++ = (mode & S_ISUID
-              ? (mode & S_IXUSR ? 's' : 'S')
-              : (mode & S_IXUSR ? 'x' : '-'));
-  *string++ = mode & S_IRGRP ? 'r' : '-';
-  *string++ = mode & S_IWGRP ? 'w' : '-';
-  *string++ = (mode & S_ISGID
-              ? (mode & S_IXGRP ? 's' : 'S')
-              : (mode & S_IXGRP ? 'x' : '-'));
-  *string++ = mode & S_IROTH ? 'r' : '-';
-  *string++ = mode & S_IWOTH ? 'w' : '-';
-  *string++ = (mode & S_ISVTX
-              ? (mode & S_IXOTH ? 't' : 'T')
-              : (mode & S_IXOTH ? 'x' : '-'));
-  *string = '\0';
-}
-
-/* Report an error associated with the system call CALL and the
-   optional name NAME.  */
-static void
-call_arg_error (char const *call, char const *name)
-{
-  int e = errno;
-  /* TRANSLATORS: %s after `Cannot' is a function name, e.g. `Cannot open'.
-     Directly translating this to another language will not work, first because
-     %s itself is not translated.
-     Translate it as `%s: Function %s failed'. */
-  ERROR ((0, e, _("%s: Cannot %s"), quotearg_colon (name), call));
-}
-
-/* Report a fatal error associated with the system call CALL and
-   the optional file name NAME.  */
-static void
-call_arg_fatal (char const *call, char const *name)
-{
-  int e = errno;
-  /* TRANSLATORS: %s after `Cannot' is a function name, e.g. `Cannot open'.
-     Directly translating this to another language will not work, first because
-     %s itself is not translated.
-     Translate it as `%s: Function %s failed'. */
-  FATAL_ERROR ((0, e, _("%s: Cannot %s"), quotearg_colon (name),  call));
-}
-
-/* Report a warning associated with the system call CALL and
-   the optional file name NAME.  */
-static void
-call_arg_warn (char const *call, char const *name)
-{
-  int e = errno;
-  /* TRANSLATORS: %s after `Cannot' is a function name, e.g. `Cannot open'.
-     Directly translating this to another language will not work, first because
-     %s itself is not translated.
-     Translate it as `%s: Function %s failed'. */
-  WARN ((0, e, _("%s: Warning: Cannot %s"), quotearg_colon (name), call));
-}
-
-void
-chdir_fatal (char const *name)
-{
-  call_arg_fatal ("chdir", name);
-}
-
-void
-chmod_error_details (char const *name, mode_t mode)
-{
-  int e = errno;
-  char buf[10];
-  decode_mode (mode, buf);
-  ERROR ((0, e, _("%s: Cannot change mode to %s"),
-         quotearg_colon (name), buf));
-}
-
-void
-chown_error_details (char const *name, uid_t uid, gid_t gid)
-{
-  int e = errno;
-  ERROR ((0, e, _("%s: Cannot change ownership to uid %lu, gid %lu"),
-         quotearg_colon (name), (unsigned long) uid, (unsigned long) gid));
-}
-
-void
-close_error (char const *name)
-{
-  call_arg_error ("close", name);
-}
-
-void
-close_warn (char const *name)
-{
-  call_arg_warn ("close", name);
-}
-

 void
 close_diag (char const *name)
 {
 void
 close_diag (char const *name)
 {


@@ -627,80 +765,6 @@ close_diag (char const *name)
     close_error (name);
 }
 
     close_error (name);
 }
 

-void
-exec_fatal (char const *name)
-{
-  call_arg_fatal ("exec", name);
-}
-
-void
-link_error (char const *target, char const *source)
-{
-  int e = errno;
-  ERROR ((0, e, _("%s: Cannot hard link to %s"),
-         quotearg_colon (source), quote_n (1, target)));
-}
-
-void
-mkdir_error (char const *name)
-{
-  call_arg_error ("mkdir", name);
-}
-
-void
-mkfifo_error (char const *name)
-{
-  call_arg_error ("mkfifo", name);
-}
-
-void
-mknod_error (char const *name)
-{
-  call_arg_error ("mknod", name);
-}
-
-void
-exec_error (char const *name)
-{
-  call_arg_error ("exec", name);
-}
-
-void
-fork_error (char const *name)
-{
-  call_arg_error ("fork", name);
-}
-
-void
-dup2_error (char const *name)
-{
-  call_arg_error ("dup2", name);
-}
-
-void
-pipe_error (char const *name)
-{
-  call_arg_error ("pipe", name);
-}
-
-void
-open_error (char const *name)
-{
-  call_arg_error ("open", name);
-}
-
-void
-open_fatal (char const *name)
-{
-  call_arg_fatal ("open", name);
-}
-
-void
-open_warn (char const *name)
-{
-  call_arg_warn ("open", name);
-}
-

 void
 open_diag (char const *name)
 {
 void
 open_diag (char const *name)
 {


@@ -710,38 +774,6 @@ open_diag (char const *name)
     open_error (name);
 }
 
     open_error (name);
 }
 

-void
-read_error (char const *name)
-{
-  call_arg_error ("read", name);
-}
-
-void
-read_error_details (char const *name, off_t offset, size_t size)
-{
-  char buf[UINTMAX_STRSIZE_BOUND];
-  int e = errno;
-  ERROR ((0, e,
-         ngettext ("%s: Read error at byte %s, while reading %lu byte",
-                   "%s: Read error at byte %s, while reading %lu bytes",
-                   size),
-         quotearg_colon (name), STRINGIFY_BIGINT (offset, buf),
-         (unsigned long) size));
-}
-
-void
-read_warn_details (char const *name, off_t offset, size_t size)
-{
-  char buf[UINTMAX_STRSIZE_BOUND];
-  int e = errno;
-  WARN ((0, e,
-        ngettext ("%s: Warning: Read error at byte %s, while reading %lu byte",
-                  "%s: Warning: Read error at byte %s, while reading %lu bytes",
-                  size),
-        quotearg_colon (name), STRINGIFY_BIGINT (offset, buf),
-        (unsigned long) size));
-}
-

 void
 read_diag_details (char const *name, off_t offset, size_t size)
 {
 void
 read_diag_details (char const *name, off_t offset, size_t size)
 {


@@ -751,37 +783,6 @@ read_diag_details (char const *name, off_t offset, size_t size)
     read_error_details (name, offset, size);
 }
 
     read_error_details (name, offset, size);
 }
 

-void
-read_fatal (char const *name)
-{
-  call_arg_fatal ("read", name);
-}
-
-void
-read_fatal_details (char const *name, off_t offset, size_t size)
-{
-  char buf[UINTMAX_STRSIZE_BOUND];
-  int e = errno;
-  FATAL_ERROR ((0, e,
-               ngettext ("%s: Read error at byte %s, reading %lu byte",
-                         "%s: Read error at byte %s, reading %lu bytes",
-                         size),
-               quotearg_colon (name), STRINGIFY_BIGINT (offset, buf),
-               (unsigned long) size));
-}
-
-void
-readlink_error (char const *name)
-{
-  call_arg_error ("readlink", name);
-}
-
-void
-readlink_warn (char const *name)
-{
-  call_arg_warn ("readlink", name);
-}
-

 void
 readlink_diag (char const *name)
 {
 void
 readlink_diag (char const *name)
 {


@@ -791,18 +792,6 @@ readlink_diag (char const *name)
     readlink_error (name);
 }
 
     readlink_error (name);
 }
 

-void
-savedir_error (char const *name)
-{
-  call_arg_error ("savedir", name);
-}
-
-void
-savedir_warn (char const *name)
-{
-  call_arg_warn ("savedir", name);
-}
-

 void
 savedir_diag (char const *name)
 {
 void
 savedir_diag (char const *name)
 {


@@ -812,38 +801,6 @@ savedir_diag (char const *name)
     savedir_error (name);
 }
 
     savedir_error (name);
 }
 

-void
-seek_error (char const *name)
-{
-  call_arg_error ("seek", name);
-}
-
-void
-seek_error_details (char const *name, off_t offset)
-{
-  char buf[UINTMAX_STRSIZE_BOUND];
-  int e = errno;
-  ERROR ((0, e, _("%s: Cannot seek to %s"),
-         quotearg_colon (name),
-         STRINGIFY_BIGINT (offset, buf)));
-}
-
-void
-seek_warn (char const *name)
-{
-  call_arg_warn ("seek", name);
-}
-
-void
-seek_warn_details (char const *name, off_t offset)
-{
-  char buf[UINTMAX_STRSIZE_BOUND];
-  int e = errno;
-  WARN ((0, e, _("%s: Warning: Cannot seek to %s"),
-        quotearg_colon (name),
-        STRINGIFY_BIGINT (offset, buf)));
-}
-

 void
 seek_diag_details (char const *name, off_t offset)
 {
 void
 seek_diag_details (char const *name, off_t offset)
 {


@@ -853,32 +810,6 @@ seek_diag_details (char const *name, off_t offset)
     seek_error_details (name, offset);
 }
 
     seek_error_details (name, offset);
 }
 

-void
-symlink_error (char const *contents, char const *name)
-{
-  int e = errno;
-  ERROR ((0, e, _("%s: Cannot create symlink to %s"),
-         quotearg_colon (name), quote_n (1, contents)));
-}
-
-void
-stat_fatal (char const *name)
-{
-  call_arg_fatal ("stat", name);
-}
-
-void
-stat_error (char const *name)
-{
-  call_arg_error ("stat", name);
-}
-
-void
-stat_warn (char const *name)
-{
-  call_arg_warn ("stat", name);
-}
-

 void
 stat_diag (char const *name)
 {
 void
 stat_diag (char const *name)
 {


@@ -889,58 +820,33 @@ stat_diag (char const *name)
 }
 
 void
 }
 
 void

-truncate_error (char const *name)
-{
-  call_arg_error ("truncate", name);
-}
-
-void
-truncate_warn (char const *name)
-{
-  call_arg_warn ("truncate", name);
-}
-
-void
-unlink_error (char const *name)
-{
-  call_arg_error ("unlink", name);
-}
-
-void
-utime_error (char const *name)
-{
-  call_arg_error ("utime", name);
-}
-
-void
-waitpid_error (char const *name)
+file_removed_diag (const char *name, bool top_level,
+                  void (*diagfn) (char const *name))

 {
 {

-  call_arg_error ("waitpid", name);
-}
-
-void
-write_error (char const *name)
-{
-  call_arg_error ("write", name);
-}
-
-void
-write_error_details (char const *name, size_t status, size_t size)
-{
-  if (status == 0)
-    write_error (name);
+  if (!top_level && errno == ENOENT)
+    {
+      WARNOPT (WARN_FILE_REMOVED,
+              (0, 0, _("%s: File removed before we read it"),
+               quotearg_colon (name)));
+      set_exit_status (TAREXIT_DIFFERS);
+    }

   else
   else

-    ERROR ((0, 0,
-           ngettext ("%s: Wrote only %lu of %lu byte",
-                     "%s: Wrote only %lu of %lu bytes",
-                     size),
-           name, (unsigned long int) status, (unsigned long int) size));
+    diagfn (name);

 }
 
 void
 }
 
 void

-write_fatal (char const *name)
+dir_removed_diag (const char *name, bool top_level,
+                  void (*diagfn) (char const *name))

 {
 {

-  call_arg_fatal ("write", name);
+  if (!top_level && errno == ENOENT)
+    {
+      WARNOPT (WARN_FILE_REMOVED,
+              (0, 0, _("%s: Directory removed before we read it"),
+               quotearg_colon (name)));
+      set_exit_status (TAREXIT_DIFFERS);
+    }
+  else
+    diagfn (name);

 }
 
 void
 }
 
 void


@@ -950,7 +856,6 @@ write_fatal_details (char const *name, ssize_t status, size_t size)
   fatal_exit ();
 }
 
   fatal_exit ();
 }
 

-

 /* Fork, aborting if unsuccessful.  */
 pid_t
 xfork (void)
 /* Fork, aborting if unsuccessful.  */
 pid_t
 xfork (void)


@@ -995,3 +900,42 @@ page_aligned_alloc (void **ptr, size_t size)
   *ptr = xmalloc (size1);
   return ptr_align (*ptr, alignment);
 }
   *ptr = xmalloc (size1);
   return ptr_align (*ptr, alignment);
 }

+
+\f
+
+struct namebuf
+{
+  char *buffer;                /* directory, `/', and directory member */
+  size_t buffer_size;  /* allocated size of name_buffer */
+  size_t dir_length;   /* length of directory part in buffer */
+};
+
+namebuf_t
+namebuf_create (const char *dir)
+{
+  namebuf_t buf = xmalloc (sizeof (*buf));
+  buf->buffer_size = strlen (dir) + 2;
+  buf->buffer = xmalloc (buf->buffer_size);
+  strcpy (buf->buffer, dir);
+  buf->dir_length = strlen (buf->buffer);
+  if (!ISSLASH (buf->buffer[buf->dir_length - 1]))
+    buf->buffer[buf->dir_length++] = DIRECTORY_SEPARATOR;
+  return buf;
+}
+
+void
+namebuf_free (namebuf_t buf)
+{
+  free (buf->buffer);
+  free (buf);
+}
+
+char *
+namebuf_name (namebuf_t buf, const char *name)
+{
+  size_t len = strlen (name);
+  while (buf->dir_length + len + 1 >= buf->buffer_size)
+    buf->buffer = x2realloc (buf->buffer, &buf->buffer_size);
+  strcpy (buf->buffer + buf->dir_length, name);
+  return buf->buffer;
+}