tar: prefer openat-style functions

[chaz/tar] / src / create.c

diff --git a/src/create.c b/src/create.c
index 01324d353bf62d082ab8599f6e5c36b0f6121f9a..26993c21e5792be036be572e930a4887556b9b2b 100644 (file)
--- a/src/create.c
+++ b/src/create.c
@@ -1,13 +1,13 @@
 /* Create a tar archive.
 
    Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
 /* Create a tar archive.
 
    Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,

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

 
    Written by John Gilmore, on 1985-08-25.
 
    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-08-25.
 
    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


@@ -17,32 +17,108 @@
 
    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"
-
-#if HAVE_UTIME_H
-# include <utime.h>
-#else
-struct utimbuf
-  {
-    long actime;
-    long modtime;
-  };
-#endif
+#include <system.h>

 
 #include <quotearg.h>
 
 #include "common.h"
 #include <hash.h>
 
 
 #include <quotearg.h>
 
 #include "common.h"
 #include <hash.h>
 

+/* Error number to use when an impostor is discovered.
+   Pretend the impostor isn't there.  */
+enum { IMPOSTOR_ERRNO = ENOENT };
+

 struct link
   {
     dev_t dev;
     ino_t ino;
 struct link
   {
     dev_t dev;
     ino_t ino;

-    size_t nlink;
+    nlink_t nlink;

     char name[1];
   };
     char name[1];
   };

+
+struct exclusion_tag
+{
+  const char *name;
+  size_t length;
+  enum exclusion_tag_type type;
+  bool (*predicate) (int fd);
+  struct exclusion_tag *next;
+};
+
+static struct exclusion_tag *exclusion_tags;
+
+void
+add_exclusion_tag (const char *name, enum exclusion_tag_type type,
+                  bool (*predicate) (int fd))
+{
+  struct exclusion_tag *tag = xmalloc (sizeof tag[0]);
+  tag->next = exclusion_tags;
+  tag->name = name;
+  tag->type = type;
+  tag->predicate = predicate;
+  tag->length = strlen (name);
+  exclusion_tags = tag;
+}
+
+void
+exclusion_tag_warning (const char *dirname, const char *tagname,
+                      const char *message)
+{
+  if (verbose_option)
+    WARNOPT (WARN_CACHEDIR,
+            (0, 0,
+             _("%s: contains a cache directory tag %s; %s"),
+             quotearg_colon (dirname),
+             quotearg_n (1, tagname),
+             message));
+}
+
+enum exclusion_tag_type
+check_exclusion_tags (struct tar_stat_info const *st, char const **tag_file_name)
+{
+  struct exclusion_tag *tag;
+
+  for (tag = exclusion_tags; tag; tag = tag->next)
+    {
+      int tagfd = subfile_open (st, tag->name, open_read_flags);
+      if (0 <= tagfd)
+       {
+         bool satisfied = !tag->predicate || tag->predicate (tagfd);
+         close (tagfd);
+         if (satisfied)
+           {
+             if (tag_file_name)
+               *tag_file_name = tag->name;
+             return tag->type;
+           }
+       }
+    }
+
+  return exclusion_tag_none;
+}
+
+/* Exclusion predicate to test if the named file (usually "CACHEDIR.TAG")
+   contains a valid header, as described at:
+       http://www.brynosaurus.com/cachedir
+   Applications can write this file into directories they create
+   for use as caches containing purely regenerable, non-precious data,
+   allowing us to avoid archiving them if --exclude-caches is specified. */
+
+#define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55"
+#define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1)
+
+bool
+cachedir_file_p (int fd)
+{
+  char tagbuf[CACHEDIR_SIGNATURE_SIZE];
+
+  return
+    (read (fd, tagbuf, CACHEDIR_SIGNATURE_SIZE) == CACHEDIR_SIGNATURE_SIZE
+     && memcmp (tagbuf, CACHEDIR_SIGNATURE, CACHEDIR_SIGNATURE_SIZE) == 0);
+}
+

 \f
 /* The maximum uintmax_t value that can be represented with DIGITS digits,
    assuming that each digit is BITS_PER_DIGIT wide.  */
 \f
 /* The maximum uintmax_t value that can be represented with DIGITS digits,
    assuming that each digit is BITS_PER_DIGIT wide.  */


@@ -51,6 +127,10 @@ struct link
     ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
     : (uintmax_t) -1)
 
     ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
     : (uintmax_t) -1)
 

+/* The maximum uintmax_t value that can be represented with octal
+   digits and a trailing NUL in BUFFER.  */
+#define MAX_OCTAL_VAL(buffer) MAX_VAL_WITH_DIGITS (sizeof (buffer) - 1, LG_8)
+

 /* Convert VALUE to an octal representation suitable for tar headers.
    Output to buffer WHERE with size SIZE.
    The result is undefined if SIZE is 0 or if VALUE is too large to fit.  */
 /* Convert VALUE to an octal representation suitable for tar headers.
    Output to buffer WHERE with size SIZE.
    The result is undefined if SIZE is 0 or if VALUE is too large to fit.  */


@@ -69,6 +149,29 @@ to_octal (uintmax_t value, char *where, size_t size)
   while (i);
 }
 
   while (i);
 }
 

+/* Copy at most LEN bytes from the string SRC to DST.  Terminate with
+   NUL unless SRC is LEN or more bytes long.  */
+
+static void
+tar_copy_str (char *dst, const char *src, size_t len)
+{
+  size_t i;
+  for (i = 0; i < len; i++)
+    if (! (dst[i] = src[i]))
+      break;
+}
+
+/* Same as tar_copy_str, but always terminate with NUL if using
+   is OLDGNU format */
+
+static void
+tar_name_copy_str (char *dst, const char *src, size_t len)
+{
+  tar_copy_str (dst, src, len);
+  if (archive_format == OLDGNU_FORMAT)
+    dst[len-1] = 0;
+}
+

 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
    tar headers.  NEGATIVE is 1 if VALUE was negative before being cast
    to uintmax_t, 0 otherwise.  Output to buffer WHERE with size SIZE.
 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
    tar headers.  NEGATIVE is 1 if VALUE was negative before being cast
    to uintmax_t, 0 otherwise.  Output to buffer WHERE with size SIZE.


@@ -91,6 +194,81 @@ to_base256 (int negative, uintmax_t value, char *where, size_t size)
   while (i);
 }
 
   while (i);
 }
 

+#define GID_TO_CHARS(val, where) gid_to_chars (val, where, sizeof (where))
+#define MAJOR_TO_CHARS(val, where) major_to_chars (val, where, sizeof (where))
+#define MINOR_TO_CHARS(val, where) minor_to_chars (val, where, sizeof (where))
+#define MODE_TO_CHARS(val, where) mode_to_chars (val, where, sizeof (where))
+#define UID_TO_CHARS(val, where) uid_to_chars (val, where, sizeof (where))
+
+#define UNAME_TO_CHARS(name,buf) string_to_chars (name, buf, sizeof(buf))
+#define GNAME_TO_CHARS(name,buf) string_to_chars (name, buf, sizeof(buf))
+
+static bool
+to_chars (int negative, uintmax_t value, size_t valsize,
+         uintmax_t (*substitute) (int *),
+         char *where, size_t size, const char *type);
+
+static bool
+to_chars_subst (int negative, int gnu_format, uintmax_t value, size_t valsize,
+               uintmax_t (*substitute) (int *),
+               char *where, size_t size, const char *type)
+{
+  uintmax_t maxval = (gnu_format
+                     ? MAX_VAL_WITH_DIGITS (size - 1, LG_256)
+                     : MAX_VAL_WITH_DIGITS (size - 1, LG_8));
+  char valbuf[UINTMAX_STRSIZE_BOUND + 1];
+  char maxbuf[UINTMAX_STRSIZE_BOUND];
+  char minbuf[UINTMAX_STRSIZE_BOUND + 1];
+  char const *minval_string;
+  char const *maxval_string = STRINGIFY_BIGINT (maxval, maxbuf);
+  char const *value_string;
+
+  if (gnu_format)
+    {
+      uintmax_t m = maxval + 1 ? maxval + 1 : maxval / 2 + 1;
+      char *p = STRINGIFY_BIGINT (m, minbuf + 1);
+      *--p = '-';
+      minval_string = p;
+    }
+  else
+    minval_string = "0";
+
+  if (negative)
+    {
+      char *p = STRINGIFY_BIGINT (- value, valbuf + 1);
+      *--p = '-';
+      value_string = p;
+    }
+  else
+    value_string = STRINGIFY_BIGINT (value, valbuf);
+
+  if (substitute)
+    {
+      int negsub;
+      uintmax_t sub = substitute (&negsub) & maxval;
+      /* NOTE: This is one of the few places where GNU_FORMAT differs from
+        OLDGNU_FORMAT.  The actual differences are:
+
+        1. In OLDGNU_FORMAT all strings in a tar header end in \0
+        2. Incremental archives use oldgnu_header.
+
+        Apart from this they are completely identical. */
+      uintmax_t s = (negsub &= archive_format == GNU_FORMAT) ? - sub : sub;
+      char subbuf[UINTMAX_STRSIZE_BOUND + 1];
+      char *sub_string = STRINGIFY_BIGINT (s, subbuf + 1);
+      if (negsub)
+       *--sub_string = '-';
+      WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
+            value_string, type, minval_string, maxval_string,
+            sub_string));
+      return to_chars (negsub, s, valsize, 0, where, size, type);
+    }
+  else
+    ERROR ((0, 0, _("value %s out of %s range %s..%s"),
+           value_string, type, minval_string, maxval_string));
+  return false;
+}
+

 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
    external form, using SUBSTITUTE (...) if VALUE won't fit.  Output
    to buffer WHERE with size SIZE.  NEGATIVE is 1 iff VALUE was
 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
    external form, using SUBSTITUTE (...) if VALUE won't fit.  Output
    to buffer WHERE with size SIZE.  NEGATIVE is 1 iff VALUE was


@@ -105,101 +283,61 @@ to_base256 (int negative, uintmax_t value, char *where, size_t size)
    SUBSTITUTE the address of an 0-or-1 flag recording whether the
    substitute value is negative.  */
 
    SUBSTITUTE the address of an 0-or-1 flag recording whether the
    substitute value is negative.  */
 

-static void
+static bool

 to_chars (int negative, uintmax_t value, size_t valsize,
          uintmax_t (*substitute) (int *),
          char *where, size_t size, const char *type)
 {
 to_chars (int negative, uintmax_t value, size_t valsize,
          uintmax_t (*substitute) (int *),
          char *where, size_t size, const char *type)
 {

-  int base256_allowed = (archive_format == GNU_FORMAT
-                        || archive_format == OLDGNU_FORMAT);
+  int gnu_format = (archive_format == GNU_FORMAT
+                   || archive_format == OLDGNU_FORMAT);

 
   /* Generate the POSIX octal representation if the number fits.  */
   if (! negative && value <= MAX_VAL_WITH_DIGITS (size - 1, LG_8))
     {
       where[size - 1] = '\0';
       to_octal (value, where, size - 1);
 
   /* Generate the POSIX octal representation if the number fits.  */
   if (! negative && value <= MAX_VAL_WITH_DIGITS (size - 1, LG_8))
     {
       where[size - 1] = '\0';
       to_octal (value, where, size - 1);

+      return true;

     }
     }

-
-  /* Otherwise, generate the base-256 representation if we are
-     generating an old or new GNU format and if the number fits.  */
-  else if (((negative ? -1 - value : value)
-           <= MAX_VAL_WITH_DIGITS (size - 1, LG_256))
-          && base256_allowed)
-    {
-      where[0] = negative ? -1 : 1 << (LG_256 - 1);
-      to_base256 (negative, value, where + 1, size - 1);
-    }
-
-  /* Otherwise, if the number is negative, and if it would not cause
-     ambiguity on this host by confusing positive with negative
-     values, then generate the POSIX octal representation of the value
-     modulo 2**(field bits).  The resulting tar file is
-     machine-dependent, since it depends on the host word size.  Yuck!
-     But this is the traditional behavior.  */
-  else if (negative && valsize * CHAR_BIT <= (size - 1) * LG_8)
+  else if (gnu_format)

     {
     {

-      static int warned_once;
-      if (! warned_once)
-       {
-         warned_once = 1;
-         WARN ((0, 0, _("Generating negative octal headers")));
-       }
-      where[size - 1] = '\0';
-      to_octal (value & MAX_VAL_WITH_DIGITS (valsize * CHAR_BIT, 1),
-               where, size - 1);
-    }
+      /* Try to cope with the number by using traditional GNU format
+        methods */

 
 

-  /* Otherwise, output a substitute value if possible (with a
-     warning), and an error message if not.  */
-  else
-    {
-      uintmax_t maxval = (base256_allowed
-                         ? MAX_VAL_WITH_DIGITS (size - 1, LG_256)
-                         : MAX_VAL_WITH_DIGITS (size - 1, LG_8));
-      char valbuf[UINTMAX_STRSIZE_BOUND + 1];
-      char maxbuf[UINTMAX_STRSIZE_BOUND];
-      char minbuf[UINTMAX_STRSIZE_BOUND + 1];
-      char const *minval_string;
-      char const *maxval_string = STRINGIFY_BIGINT (maxval, maxbuf);
-      char const *value_string;
-
-      if (base256_allowed)
+      /* Generate the base-256 representation if the number fits.  */
+      if (((negative ? -1 - value : value)
+          <= MAX_VAL_WITH_DIGITS (size - 1, LG_256)))

        {
        {

-         uintmax_t m = maxval + 1 ? maxval + 1 : maxval / 2 + 1;
-         char *p = STRINGIFY_BIGINT (m, minbuf + 1);
-         *--p = '-';
-         minval_string = p;
-       }
-      else
-       minval_string = "0";
-
-      if (negative)
-       {
-         char *p = STRINGIFY_BIGINT (- value, valbuf + 1);
-         *--p = '-';
-         value_string = p;
+         where[0] = negative ? -1 : 1 << (LG_256 - 1);
+         to_base256 (negative, value, where + 1, size - 1);
+         return true;

        }
        }

-      else
-       value_string = STRINGIFY_BIGINT (value, valbuf);

 
 

-      if (substitute)
+      /* Otherwise, if the number is negative, and if it would not cause
+        ambiguity on this host by confusing positive with negative
+        values, then generate the POSIX octal representation of the value
+        modulo 2**(field bits).  The resulting tar file is
+        machine-dependent, since it depends on the host word size.  Yuck!
+        But this is the traditional behavior.  */
+      else if (negative && valsize * CHAR_BIT <= (size - 1) * LG_8)

        {
        {

-         int negsub;
-         uintmax_t sub = substitute (&negsub) & maxval;
-         uintmax_t s = (negsub &= archive_format == GNU_FORMAT) ? - sub : sub;
-         char subbuf[UINTMAX_STRSIZE_BOUND + 1];
-         char *sub_string = STRINGIFY_BIGINT (s, subbuf + 1);
-         if (negsub)
-           *--sub_string = '-';
-         WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
-                value_string, type, minval_string, maxval_string,
-                sub_string));
-         to_chars (negsub, s, valsize, 0, where, size, type);
+         static int warned_once;
+         if (! warned_once)
+           {
+             warned_once = 1;
+             WARN ((0, 0, _("Generating negative octal headers")));
+           }
+         where[size - 1] = '\0';
+         to_octal (value & MAX_VAL_WITH_DIGITS (valsize * CHAR_BIT, 1),
+                   where, size - 1);
+         return true;

        }
        }

-      else
-       ERROR ((0, 0, _("value %s out of %s range %s..%s"),
-               value_string, type, minval_string, maxval_string));
+      /* Otherwise fall back to substitution, if possible: */

     }
     }

+  else
+    substitute = NULL; /* No substitution for formats, other than GNU */
+
+  return to_chars_subst (negative, gnu_format, value, valsize, substitute,
+                        where, size, type);

 }
 
 static uintmax_t
 }
 
 static uintmax_t


@@ -218,25 +356,25 @@ gid_substitute (int *negative)
   return r;
 }
 
   return r;
 }
 

-void
+static bool

 gid_to_chars (gid_t v, char *p, size_t s)
 {
 gid_to_chars (gid_t v, char *p, size_t s)
 {

-  to_chars (v < 0, (uintmax_t) v, sizeof v, gid_substitute, p, s, "gid_t");
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, gid_substitute, p, s, "gid_t");

 }
 
 }
 

-void
+static bool

 major_to_chars (major_t v, char *p, size_t s)
 {
 major_to_chars (major_t v, char *p, size_t s)
 {

-  to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "major_t");
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "major_t");

 }
 
 }
 

-void
+static bool

 minor_to_chars (minor_t v, char *p, size_t s)
 {
 minor_to_chars (minor_t v, char *p, size_t s)
 {

-  to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "minor_t");
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "minor_t");

 }
 
 }
 

-void
+static bool

 mode_to_chars (mode_t v, char *p, size_t s)
 {
   /* In the common case where the internal and external mode bits are the same,
 mode_to_chars (mode_t v, char *p, size_t s)
 {
   /* In the common case where the internal and external mode bits are the same,


@@ -273,25 +411,19 @@ mode_to_chars (mode_t v, char *p, size_t s)
           | (v & S_IWOTH ? TOWRITE : 0)
           | (v & S_IXOTH ? TOEXEC : 0));
     }
           | (v & S_IWOTH ? TOWRITE : 0)
           | (v & S_IXOTH ? TOEXEC : 0));
     }

-  to_chars (negative, u, sizeof v, 0, p, s, "mode_t");
+  return to_chars (negative, u, sizeof v, 0, p, s, "mode_t");

 }
 
 }
 

-void
+bool

 off_to_chars (off_t v, char *p, size_t s)
 {
 off_to_chars (off_t v, char *p, size_t s)
 {

-  to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "off_t");
-}
-
-void
-size_to_chars (size_t v, char *p, size_t s)
-{
-  to_chars (0, (uintmax_t) v, sizeof v, 0, p, s, "size_t");
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "off_t");

 }
 
 }
 

-void
+bool

 time_to_chars (time_t v, char *p, size_t s)
 {
 time_to_chars (time_t v, char *p, size_t s)
 {

-  to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "time_t");
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "time_t");

 }
 
 static uintmax_t
 }
 
 static uintmax_t


@@ -310,36 +442,45 @@ uid_substitute (int *negative)
   return r;
 }
 
   return r;
 }
 

-void
+static bool

 uid_to_chars (uid_t v, char *p, size_t s)
 {
 uid_to_chars (uid_t v, char *p, size_t s)
 {

-  to_chars (v < 0, (uintmax_t) v, sizeof v, uid_substitute, p, s, "uid_t");
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, uid_substitute, p, s, "uid_t");

 }
 
 }
 

-void
+static bool

 uintmax_to_chars (uintmax_t v, char *p, size_t s)
 {
 uintmax_to_chars (uintmax_t v, char *p, size_t s)
 {

-  to_chars (0, v, sizeof v, 0, p, s, "uintmax_t");
+  return to_chars (0, v, sizeof v, 0, p, s, "uintmax_t");

 }
 
 }
 

-void
-string_to_chars (char *str, char *p, size_t s)
+static void
+string_to_chars (char const *str, char *p, size_t s)

 {
 {

-  strncpy (p, str, s);
-  p[s-1] = 0;
+  tar_copy_str (p, str, s);
+  p[s - 1] = '\0';

 }
 
 \f
 }
 
 \f

-/* A file is not dumpable if
+/* A directory is always considered dumpable.
+   Otherwise, only regular and contiguous files are considered dumpable.
+   Such a file is dumpable if it is sparse and both --sparse and --totals
+   are specified.
+   Otherwise, it is dumpable unless any of the following conditions occur:
+

    a) it is empty *and* world-readable, or
    b) current archive is /dev/null */
 
    a) it is empty *and* world-readable, or
    b) current archive is /dev/null */
 

-bool
-file_dumpable_p (struct tar_stat_info *stat)
+static bool
+file_dumpable_p (struct stat const *st)

 {
 {

-  return !(dev_null_output
-          || (stat->archive_file_size == 0
-              && (stat->stat.st_mode & MODE_R) == MODE_R));
+  if (S_ISDIR (st->st_mode))
+    return true;
+  if (! (S_ISREG (st->st_mode) || S_ISCTG (st->st_mode)))
+    return false;
+  if (dev_null_output)
+    return totals_option && sparse_option && ST_IS_SPARSE (*st);
+  return ! (st->st_size == 0 && (st->st_mode & MODE_R) == MODE_R);

 }
 
 \f
 }
 
 \f


@@ -359,34 +500,23 @@ write_eot (void)
   set_next_block_after (pointer);
 }
 
   set_next_block_after (pointer);
 }
 

-/* Copy at most LEN bytes from SRC to DST. Terminate with NUL unless
-   SRC is LEN characters long */
-static void
-tar_copy_str (char *dst, const char *src, size_t len)
-{
-  dst[len-1] = 0;
-  strncpy (dst, src, len);
-}
-

 /* Write a "private" header */
 /* Write a "private" header */

-static union block *
-start_private_header (const char *name, size_t size)
+union block *
+start_private_header (const char *name, size_t size, time_t t)

 {
 {

-  time_t t;

   union block *header = find_next_block ();
   union block *header = find_next_block ();

-  
+

   memset (header->buffer, 0, sizeof (union block));
 
   memset (header->buffer, 0, sizeof (union block));
 

-  tar_copy_str (header->header.name, name, NAME_FIELD_SIZE);
+  tar_name_copy_str (header->header.name, name, NAME_FIELD_SIZE);

   OFF_TO_CHARS (size, header->header.size);
 
   OFF_TO_CHARS (size, header->header.size);
 

-  time (&t);

   TIME_TO_CHARS (t, header->header.mtime);
   MODE_TO_CHARS (S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH, header->header.mode);
   UID_TO_CHARS (getuid (), header->header.uid);
   GID_TO_CHARS (getgid (), header->header.gid);
   MAJOR_TO_CHARS (0, header->header.devmajor);
   TIME_TO_CHARS (t, header->header.mtime);
   MODE_TO_CHARS (S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH, header->header.mode);
   UID_TO_CHARS (getuid (), header->header.uid);
   GID_TO_CHARS (getgid (), header->header.gid);
   MAJOR_TO_CHARS (0, header->header.devmajor);

-  MAJOR_TO_CHARS (0, header->header.devminor);
+  MINOR_TO_CHARS (0, header->header.devminor);

   strncpy (header->header.magic, TMAGIC, TMAGLEN);
   strncpy (header->header.version, TVERSION, TVERSLEN);
   return header;
   strncpy (header->header.magic, TMAGIC, TMAGLEN);
   strncpy (header->header.version, TVERSION, TVERSLEN);
   return header;


@@ -395,15 +525,20 @@ start_private_header (const char *name, size_t size)
 /* Create a new header and store there at most NAME_FIELD_SIZE bytes of
    the file name */
 
 /* Create a new header and store there at most NAME_FIELD_SIZE bytes of
    the file name */
 

-static union block * 
+static union block *

 write_short_name (struct tar_stat_info *st)
 {
   union block *header = find_next_block ();
   memset (header->buffer, 0, sizeof (union block));
 write_short_name (struct tar_stat_info *st)
 {
   union block *header = find_next_block ();
   memset (header->buffer, 0, sizeof (union block));

-  tar_copy_str (header->header.name, st->file_name, NAME_FIELD_SIZE);
+  tar_name_copy_str (header->header.name, st->file_name, NAME_FIELD_SIZE);

   return header;
 }
 
   return header;
 }
 

+#define FILL(field,byte) do {            \
+  memset(field, byte, sizeof(field)-1);  \
+  (field)[sizeof(field)-1] = 0;          \
+} while (0)
+

 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block.  */
 static void
 write_gnu_long_link (struct tar_stat_info *st, const char *p, char type)
 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block.  */
 static void
 write_gnu_long_link (struct tar_stat_info *st, const char *p, char type)


@@ -411,8 +546,22 @@ write_gnu_long_link (struct tar_stat_info *st, const char *p, char type)
   size_t size = strlen (p) + 1;
   size_t bufsize;
   union block *header;
   size_t size = strlen (p) + 1;
   size_t bufsize;
   union block *header;

+  char *tmpname;
+
+  header = start_private_header ("././@LongLink", size, time (NULL));
+  FILL (header->header.mtime, '0');
+  FILL (header->header.mode, '0');
+  FILL (header->header.uid, '0');
+  FILL (header->header.gid, '0');
+  FILL (header->header.devmajor, 0);
+  FILL (header->header.devminor, 0);
+  uid_to_uname (0, &tmpname);
+  UNAME_TO_CHARS (tmpname, header->header.uname);
+  free (tmpname);
+  gid_to_gname (0, &tmpname);
+  GNAME_TO_CHARS (tmpname, header->header.gname);
+  free (tmpname);

 
 

-  header = start_private_header ("././@LongLink", size);

   strcpy (header->header.magic, OLDGNU_MAGIC);
   header->header.typeflag = type;
   finish_header (st, header, -1);
   strcpy (header->header.magic, OLDGNU_MAGIC);
   header->header.typeflag = type;
   finish_header (st, header, -1);


@@ -440,8 +589,10 @@ split_long_name (const char *name, size_t length)
 {
   size_t i;
 
 {
   size_t i;
 

-  if (length > PREFIX_FIELD_SIZE)
-    length = PREFIX_FIELD_SIZE+2;
+  if (length > PREFIX_FIELD_SIZE + 1)
+    length = PREFIX_FIELD_SIZE + 1;
+  else if (ISSLASH (name[length - 1]))
+    length--;

   for (i = length - 1; i > 0; i--)
     if (ISSLASH (name[i]))
       break;
   for (i = length - 1; i > 0; i--)
     if (ISSLASH (name[i]))
       break;


@@ -452,23 +603,23 @@ static union block *
 write_ustar_long_name (const char *name)
 {
   size_t length = strlen (name);
 write_ustar_long_name (const char *name)
 {
   size_t length = strlen (name);

-  size_t i;
+  size_t i, nlen;

   union block *header;
 
   if (length > PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1)
     {
   union block *header;
 
   if (length > PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1)
     {

-      WARN ((0, 0, _("%s: file name is too long (max %d); not dumped"),
-            quotearg_colon (name),
-            PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1));
+      ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
+             quotearg_colon (name),
+             PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1));

       return NULL;
     }
       return NULL;
     }

-  
+

   i = split_long_name (name, length);
   i = split_long_name (name, length);

-  if (i == 0 || length - i - 1 > NAME_FIELD_SIZE)
+  if (i == 0 || (nlen = length - i - 1) > NAME_FIELD_SIZE || nlen == 0)

     {
     {

-      WARN ((0, 0,
-            _("%s: file name is too long (cannot be split); not dumped"),
-            quotearg_colon (name)));
+      ERROR ((0, 0,
+             _("%s: file name is too long (cannot be split); not dumped"),
+             quotearg_colon (name)));

       return NULL;
     }
 
       return NULL;
     }
 


@@ -476,7 +627,7 @@ write_ustar_long_name (const char *name)
   memset (header->buffer, 0, sizeof (header->buffer));
   memcpy (header->header.prefix, name, i);
   memcpy (header->header.name, name + i + 1, length - i - 1);
   memset (header->buffer, 0, sizeof (header->buffer));
   memcpy (header->header.prefix, name, i);
   memcpy (header->header.name, name + i + 1, length - i - 1);

-  
+

   return header;
 }
 
   return header;
 }
 


@@ -493,11 +644,11 @@ write_long_link (struct tar_stat_info *st)
     case V7_FORMAT:                    /* old V7 tar format */
     case USTAR_FORMAT:
     case STAR_FORMAT:
     case V7_FORMAT:                    /* old V7 tar format */
     case USTAR_FORMAT:
     case STAR_FORMAT:

-      WARN ((0, 0,
-            _("%s: link name is too long; not dumped"),
-            quotearg_colon (st->link_name)));
-           break;
-      
+      ERROR ((0, 0,
+             _("%s: link name is too long; not dumped"),
+             quotearg_colon (st->link_name)));
+      break;
+

     case OLDGNU_FORMAT:
     case GNU_FORMAT:
       write_gnu_long_link (st, st->link_name, GNUTYPE_LONGLINK);
     case OLDGNU_FORMAT:
     case GNU_FORMAT:
       write_gnu_long_link (st, st->link_name, GNUTYPE_LONGLINK);


@@ -517,11 +668,20 @@ write_long_name (struct tar_stat_info *st)
       xheader_store ("path", st, NULL);
       break;
 
       xheader_store ("path", st, NULL);
       break;
 

-    case V7_FORMAT:                  
+    case V7_FORMAT:
+      if (strlen (st->file_name) > NAME_FIELD_SIZE-1)
+       {
+         ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
+                 quotearg_colon (st->file_name),
+                 NAME_FIELD_SIZE - 1));
+         return NULL;
+       }
+      break;
+

     case USTAR_FORMAT:
     case STAR_FORMAT:
       return write_ustar_long_name (st->file_name);
     case USTAR_FORMAT:
     case STAR_FORMAT:
       return write_ustar_long_name (st->file_name);

-      
+

     case OLDGNU_FORMAT:
     case GNU_FORMAT:
       write_gnu_long_link (st, st->file_name, GNUTYPE_LONGNAME);
     case OLDGNU_FORMAT:
     case GNU_FORMAT:
       write_gnu_long_link (st, st->file_name, GNUTYPE_LONGNAME);


@@ -533,56 +693,48 @@ write_long_name (struct tar_stat_info *st)
   return write_short_name (st);
 }
 
   return write_short_name (st);
 }
 

-static union block *
-write_extended (struct tar_stat_info *st, union block *old_header, char type)
+union block *
+write_extended (bool global, struct tar_stat_info *st, union block *old_header)

 {
   union block *header, hp;
 {
   union block *header, hp;

-  size_t size;

   char *p;
   char *p;

+  int type;
+  time_t t;

 
 

-  if (extended_header.buffer || extended_header.stk == NULL)
-    return old_header; 
-  
-  xheader_finish (&extended_header);
-  size = extended_header.size;
+  if (st->xhdr.buffer || st->xhdr.stk == NULL)
+    return old_header;

 
 

+  xheader_finish (&st->xhdr);

   memcpy (hp.buffer, old_header, sizeof (hp));
   memcpy (hp.buffer, old_header, sizeof (hp));

-
-  header = start_private_header (p = xheader_xhdr_name (st), size);
-  free (p);
-  header->header.typeflag = type;
-
-  finish_header (st, header, -1);
-
-  p = extended_header.buffer;
-
-  do
+  if (global)

     {
     {

-      size_t len;
-      
-      header = find_next_block ();
-      len = BLOCKSIZE;
-      if (len > size)
-       len = size;
-      memcpy (header->buffer, p, len);
-      if (len < BLOCKSIZE)
-       memset (header->buffer + len, 0, BLOCKSIZE - len);
-      p += len;
-      size -= len;
-      set_next_block_after (header);
+      type = XGLTYPE;
+      p = xheader_ghdr_name ();
+      time (&t);

     }
     }

-  while (size > 0);
-  
-  xheader_destroy (&extended_header);
+  else
+    {
+      type = XHDTYPE;
+      p = xheader_xhdr_name (st);
+      t = st->stat.st_mtime;
+    }
+  xheader_write (type, p, t, &st->xhdr);
+  free (p);

   header = find_next_block ();
   memcpy (header, &hp.buffer, sizeof (hp.buffer));
   return header;
 }
 
   header = find_next_block ();
   memcpy (header, &hp.buffer, sizeof (hp.buffer));
   return header;
 }
 

-static union block * 
+static union block *

 write_header_name (struct tar_stat_info *st)
 {
 write_header_name (struct tar_stat_info *st)
 {

-  if (NAME_FIELD_SIZE < strlen (st->file_name))
+  if (archive_format == POSIX_FORMAT && !string_ascii_p (st->file_name))
+    {
+      xheader_store ("path", st, NULL);
+      return write_short_name (st);
+    }
+  else if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT)
+          < strlen (st->file_name))

     return write_long_name (st);
   else
     return write_short_name (st);
     return write_long_name (st);
   else
     return write_short_name (st);


@@ -610,8 +762,10 @@ start_header (struct tar_stat_info *st)
   if (group_option != (gid_t) -1)
     st->stat.st_gid = group_option;
   if (mode_option)
   if (group_option != (gid_t) -1)
     st->stat.st_gid = group_option;
   if (mode_option)

-    st->stat.st_mode = ((st->stat.st_mode & ~MODE_ALL)
-                  | mode_adjust (st->stat.st_mode, mode_option));
+    st->stat.st_mode =
+      ((st->stat.st_mode & ~MODE_ALL)
+       | mode_adjust (st->stat.st_mode, S_ISDIR (st->stat.st_mode) != 0,
+                     initial_umask, mode_option, NULL));

 
   /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
      for a few tars and came up with the following interoperability
 
   /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
      for a few tars and came up with the following interoperability


@@ -641,56 +795,98 @@ start_header (struct tar_stat_info *st)
   else
     MODE_TO_CHARS (st->stat.st_mode, header->header.mode);
 
   else
     MODE_TO_CHARS (st->stat.st_mode, header->header.mode);
 

-  if (st->stat.st_uid > MAXOCTAL7 && archive_format == POSIX_FORMAT)
-    xheader_store ("uid", st, NULL);
-  else
-    UID_TO_CHARS (st->stat.st_uid, header->header.uid);
-  
-  if (st->stat.st_gid > MAXOCTAL7 && archive_format == POSIX_FORMAT)
-    xheader_store ("gid", st, NULL);
-  else
-    GID_TO_CHARS (st->stat.st_gid, header->header.gid);
+  {
+    uid_t uid = st->stat.st_uid;
+    if (archive_format == POSIX_FORMAT
+       && MAX_OCTAL_VAL (header->header.uid) < uid)
+      {
+       xheader_store ("uid", st, NULL);
+       uid = 0;
+      }
+    if (!UID_TO_CHARS (uid, header->header.uid))
+      return NULL;
+  }

 
 

-  if (st->stat.st_size > MAXOCTAL11 && archive_format == POSIX_FORMAT)
-    xheader_store ("size", st, NULL);
-  else
-    OFF_TO_CHARS (st->stat.st_size, header->header.size);
+  {
+    gid_t gid = st->stat.st_gid;
+    if (archive_format == POSIX_FORMAT
+       && MAX_OCTAL_VAL (header->header.gid) < gid)
+      {
+       xheader_store ("gid", st, NULL);
+       gid = 0;
+      }
+    if (!GID_TO_CHARS (gid, header->header.gid))
+      return NULL;
+  }
+
+  {
+    off_t size = st->stat.st_size;
+    if (archive_format == POSIX_FORMAT
+       && MAX_OCTAL_VAL (header->header.size) < size)
+      {
+       xheader_store ("size", st, NULL);
+       size = 0;
+      }
+    if (!OFF_TO_CHARS (size, header->header.size))
+      return NULL;
+  }

 
 

-  TIME_TO_CHARS (st->stat.st_mtime, header->header.mtime);
+  {
+    struct timespec mtime = set_mtime_option ? mtime_option : st->mtime;
+    if (archive_format == POSIX_FORMAT)
+      {
+       if (MAX_OCTAL_VAL (header->header.mtime) < mtime.tv_sec
+           || mtime.tv_nsec != 0)
+         xheader_store ("mtime", st, &mtime);
+       if (MAX_OCTAL_VAL (header->header.mtime) < mtime.tv_sec)
+         mtime.tv_sec = 0;
+      }
+    if (!TIME_TO_CHARS (mtime.tv_sec, header->header.mtime))
+      return NULL;
+  }

 
   /* FIXME */
   if (S_ISCHR (st->stat.st_mode)
       || S_ISBLK (st->stat.st_mode))
     {
 
   /* FIXME */
   if (S_ISCHR (st->stat.st_mode)
       || S_ISBLK (st->stat.st_mode))
     {

-      st->devmajor = major (st->stat.st_rdev);
-      st->devminor = minor (st->stat.st_rdev);
+      major_t devmajor = major (st->stat.st_rdev);
+      minor_t devminor = minor (st->stat.st_rdev);

 
 

-      if (st->devmajor > MAXOCTAL7 && archive_format == POSIX_FORMAT)
-       xheader_store ("devmajor", st, NULL);
-      else
-       MAJOR_TO_CHARS (st->devmajor, header->header.devmajor);
+      if (archive_format == POSIX_FORMAT
+         && MAX_OCTAL_VAL (header->header.devmajor) < devmajor)
+       {
+         xheader_store ("devmajor", st, NULL);
+         devmajor = 0;
+       }
+      if (!MAJOR_TO_CHARS (devmajor, header->header.devmajor))
+       return NULL;

 
 

-      if (st->devminor > MAXOCTAL7 && archive_format == POSIX_FORMAT)
-       xheader_store ("devminor", st, NULL);
-      else
-       MAJOR_TO_CHARS (st->devminor, header->header.devminor);
+      if (archive_format == POSIX_FORMAT
+         && MAX_OCTAL_VAL (header->header.devminor) < devminor)
+       {
+         xheader_store ("devminor", st, NULL);
+         devminor = 0;
+       }
+      if (!MINOR_TO_CHARS (devminor, header->header.devminor))
+       return NULL;

     }
     }

-  else
+  else if (archive_format != GNU_FORMAT && archive_format != OLDGNU_FORMAT)

     {
     {

-      MAJOR_TO_CHARS (0, header->header.devmajor);
-      MINOR_TO_CHARS (0, header->header.devminor);
+      if (!(MAJOR_TO_CHARS (0, header->header.devmajor)
+           && MINOR_TO_CHARS (0, header->header.devminor)))
+       return NULL;

     }
     }

-  
+

   if (archive_format == POSIX_FORMAT)
     {
       xheader_store ("atime", st, NULL);
       xheader_store ("ctime", st, NULL);
     }
   else if (incremental_option)
   if (archive_format == POSIX_FORMAT)
     {
       xheader_store ("atime", st, NULL);
       xheader_store ("ctime", st, NULL);
     }
   else if (incremental_option)

-    if (archive_format == OLDGNU_FORMAT)
+    if (archive_format == OLDGNU_FORMAT || archive_format == GNU_FORMAT)

       {
       {

-       TIME_TO_CHARS (st->stat.st_atime, header->oldgnu_header.atime);
-       TIME_TO_CHARS (st->stat.st_ctime, header->oldgnu_header.ctime);
+       TIME_TO_CHARS (st->atime.tv_sec, header->oldgnu_header.atime);
+       TIME_TO_CHARS (st->ctime.tv_sec, header->oldgnu_header.ctime);

       }
 
   header->header.typeflag = archive_format == V7_FORMAT ? AREGTYPE : REGTYPE;
       }
 
   header->header.typeflag = archive_format == V7_FORMAT ? AREGTYPE : REGTYPE;


@@ -724,52 +920,30 @@ start_header (struct tar_stat_info *st)
     {
       uid_to_uname (st->stat.st_uid, &st->uname);
       gid_to_gname (st->stat.st_gid, &st->gname);
     {
       uid_to_uname (st->stat.st_uid, &st->uname);
       gid_to_gname (st->stat.st_gid, &st->gname);

-      
+

       if (archive_format == POSIX_FORMAT
       if (archive_format == POSIX_FORMAT

-         && strlen (st->uname) > UNAME_FIELD_SIZE)
+         && (strlen (st->uname) > UNAME_FIELD_SIZE
+             || !string_ascii_p (st->uname)))

        xheader_store ("uname", st, NULL);
        xheader_store ("uname", st, NULL);

-      else
-       UNAME_TO_CHARS (st->uname, header->header.uname);
+      UNAME_TO_CHARS (st->uname, header->header.uname);

 
       if (archive_format == POSIX_FORMAT
 
       if (archive_format == POSIX_FORMAT

-         && strlen (st->gname) > GNAME_FIELD_SIZE)
+         && (strlen (st->gname) > GNAME_FIELD_SIZE
+             || !string_ascii_p (st->gname)))

        xheader_store ("gname", st, NULL);
        xheader_store ("gname", st, NULL);

-      else
-       GNAME_TO_CHARS (st->gname, header->header.gname);
+      GNAME_TO_CHARS (st->gname, header->header.gname);

     }
 
   return header;
 }
 
     }
 
   return header;
 }
 

-/* Finish off a filled-in header block and write it out.  We also
-   print the file name and/or full info if verbose is on.  If BLOCK_ORDINAL
-   is not negative, is the block ordinal of the first record for this
-   file, which may be a preceding long name or long link record.  */

 void
 void

-finish_header (struct tar_stat_info *st,
-              union block *header, off_t block_ordinal)
+simple_finish_header (union block *header)

 {
   size_t i;
   int sum;
   char *p;
 
 {
   size_t i;
   int sum;
   char *p;
 

-  /* Note: It is important to do this before the call to write_extended(),
-     so that the actual ustar header is printed */
-  if (verbose_option
-      && header->header.typeflag != GNUTYPE_LONGLINK
-      && header->header.typeflag != GNUTYPE_LONGNAME
-      && header->header.typeflag != XHDTYPE
-      && header->header.typeflag != XGLTYPE)
-    {
-      /* These globals are parameters to print_header, sigh.  */
-
-      current_header = header;
-      current_format = archive_format;
-      print_header (st, block_ordinal);
-    }
-
-  header = write_extended (st, header, XHDTYPE);
-  

   memcpy (header->header.chksum, CHKBLANKS, sizeof header->header.chksum);
 
   sum = 0;
   memcpy (header->header.chksum, CHKBLANKS, sizeof header->header.chksum);
 
   sum = 0;


@@ -792,6 +966,31 @@ finish_header (struct tar_stat_info *st,
 
   set_next_block_after (header);
 }
 
   set_next_block_after (header);
 }

+
+/* Finish off a filled-in header block and write it out.  We also
+   print the file name and/or full info if verbose is on.  If BLOCK_ORDINAL
+   is not negative, is the block ordinal of the first record for this
+   file, which may be a preceding long name or long link record.  */
+void
+finish_header (struct tar_stat_info *st,
+              union block *header, off_t block_ordinal)
+{
+  /* Note: It is important to do this before the call to write_extended(),
+     so that the actual ustar header is printed */
+  if (verbose_option
+      && header->header.typeflag != GNUTYPE_LONGLINK
+      && header->header.typeflag != GNUTYPE_LONGNAME
+      && header->header.typeflag != XHDTYPE
+      && header->header.typeflag != XGLTYPE)
+    {
+      /* FIXME: This global is used in print_header, sigh.  */
+      current_format = archive_format;
+      print_header (st, header, block_ordinal);
+    }
+
+  header = write_extended (false, st, header);
+  simple_finish_header (header);
+}

 \f
 
 void
 \f
 
 void


@@ -800,46 +999,40 @@ pad_archive (off_t size_left)
   union block *blk;
   while (size_left > 0)
     {
   union block *blk;
   while (size_left > 0)
     {

-      save_sizeleft = size_left;

       blk = find_next_block ();
       memset (blk->buffer, 0, BLOCKSIZE);
       set_next_block_after (blk);
       size_left -= BLOCKSIZE;
     }
       blk = find_next_block ();
       memset (blk->buffer, 0, BLOCKSIZE);
       set_next_block_after (blk);
       size_left -= BLOCKSIZE;
     }

-}  
+}

 
 static enum dump_status
 
 static enum dump_status

-dump_regular_file (int fd, struct tar_stat_info *stat)
+dump_regular_file (int fd, struct tar_stat_info *st)

 {
 {

-  off_t size_left = stat->stat.st_size;
+  off_t size_left = st->stat.st_size;

   off_t block_ordinal;
   union block *blk;
   off_t block_ordinal;
   union block *blk;

-  
+

   block_ordinal = current_block_ordinal ();
   block_ordinal = current_block_ordinal ();

-  blk = start_header (stat);
+  blk = start_header (st);

   if (!blk)
     return dump_status_fail;
 
   /* Mark contiguous files, if we support them.  */
   if (!blk)
     return dump_status_fail;
 
   /* Mark contiguous files, if we support them.  */

-  if (archive_format != V7_FORMAT && S_ISCTG (stat->stat.st_mode))
+  if (archive_format != V7_FORMAT && S_ISCTG (st->stat.st_mode))

     blk->header.typeflag = CONTTYPE;
 
     blk->header.typeflag = CONTTYPE;
 

-  finish_header (stat, blk, block_ordinal);
+  finish_header (st, blk, block_ordinal);

 
 

+  mv_begin_write (st->file_name, st->stat.st_size, st->stat.st_size);

   while (size_left > 0)
     {
       size_t bufsize, count;
   while (size_left > 0)
     {
       size_t bufsize, count;

-      
-      if (multi_volume_option)
-       {
-         assign_string (&save_name, stat->file_name);
-         save_sizeleft = size_left;
-         save_totsize = stat->stat.st_size;
-       }
+

       blk = find_next_block ();
       blk = find_next_block ();

-      
+

       bufsize = available_space_after (blk);
       bufsize = available_space_after (blk);

-      
+

       if (size_left < bufsize)
        {
          /* Last read -- zero out area beyond.  */
       if (size_left < bufsize)
        {
          /* Last read -- zero out area beyond.  */


@@ -848,121 +1041,92 @@ dump_regular_file (int fd, struct tar_stat_info *stat)
          if (count)
            memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
        }
          if (count)
            memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
        }

-      
-      count = (fd < 0) ? bufsize : safe_read (fd, blk->buffer, bufsize);
-      if (count < 0)
+
+      count = (fd <= 0) ? bufsize : safe_read (fd, blk->buffer, bufsize);
+      if (count == SAFE_READ_ERROR)

        {
        {

-         read_diag_details (stat->orig_file_name, 
-                            stat->stat.st_size - size_left, bufsize);
+         read_diag_details (st->orig_file_name,
+                            st->stat.st_size - size_left, bufsize);

          pad_archive (size_left);
          return dump_status_short;
        }
       size_left -= count;
          pad_archive (size_left);
          return dump_status_short;
        }
       size_left -= count;

-

       set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
 
       if (count != bufsize)
        {
          char buf[UINTMAX_STRSIZE_BOUND];
          memset (blk->buffer + count, 0, bufsize - count);
       set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
 
       if (count != bufsize)
        {
          char buf[UINTMAX_STRSIZE_BOUND];
          memset (blk->buffer + count, 0, bufsize - count);

-         WARN ((0, 0,
-                ngettext ("%s: File shrank by %s byte; padding with zeros",
-                          "%s: File shrank by %s bytes; padding with zeros",
-                          size_left),
-                quotearg_colon (stat->orig_file_name),
-                STRINGIFY_BIGINT (size_left, buf)));
+         WARNOPT (WARN_FILE_SHRANK,
+                  (0, 0,
+                   ngettext ("%s: File shrank by %s byte; padding with zeros",
+                             "%s: File shrank by %s bytes; padding with zeros",
+                             size_left),
+                   quotearg_colon (st->orig_file_name),
+                   STRINGIFY_BIGINT (size_left, buf)));

          if (! ignore_failed_read_option)
          if (! ignore_failed_read_option)

-           exit_status = TAREXIT_FAILURE;
-         pad_archive (size_left);
+           set_exit_status (TAREXIT_DIFFERS);
+         pad_archive (size_left - (bufsize - count));

          return dump_status_short;
        }
     }
   return dump_status_ok;
 }
 
          return dump_status_short;
        }
     }
   return dump_status_ok;
 }
 

-void
-dump_regular_finish (int fd, struct tar_stat_info *st, time_t original_ctime)
-{
-  if (fd >= 0)
-    {
-      struct stat final_stat;
-      if (fstat (fd, &final_stat) != 0)
-       {
-         stat_diag (st->orig_file_name);
-       }
-      else if (final_stat.st_ctime != original_ctime)
-       {
-         WARN ((0, 0, _("%s: file changed as we read it"),
-                quotearg_colon (st->orig_file_name)));
-       }
-      if (close (fd) != 0)
-       {
-         close_diag (st->orig_file_name);
-       }
-    }
-  if (remove_files_option)
-    {
-      if (unlink (st->orig_file_name) == -1)
-       unlink_error (st->orig_file_name);
-    }
-}
+\f
+/* Copy info from the directory identified by ST into the archive.
+   DIRECTORY contains the directory's entries.  */

 
 

-void
-dump_dir0 (char *directory,
-          struct tar_stat_info *stat, int top_level, dev_t parent_device)
+static void
+dump_dir0 (struct tar_stat_info *st, char const *directory)

 {
 {

-  dev_t our_device = stat->stat.st_dev;
-  
-  if (!is_avoided_name (stat->orig_file_name))
-    {
-      union block *blk = NULL;
-      off_t block_ordinal = current_block_ordinal ();
-      stat->stat.st_size = 0;  /* force 0 size on dir */
+  bool top_level = ! st->parent;
+  const char *tag_file_name;
+  union block *blk = NULL;
+  off_t block_ordinal = current_block_ordinal ();

 
 

-      blk = start_header (stat);
-      if (!blk)
-       return;
-         
-      if (incremental_option)
-       blk->header.typeflag = GNUTYPE_DUMPDIR;
-      else /* if (standard_option) */
-       blk->header.typeflag = DIRTYPE;
+  st->stat.st_size = 0;        /* force 0 size on dir */

 
 

-      /* If we're gnudumping, we aren't done yet so don't close it.  */
+  blk = start_header (st);
+  if (!blk)
+    return;
+
+  if (incremental_option && archive_format != POSIX_FORMAT)
+    blk->header.typeflag = GNUTYPE_DUMPDIR;
+  else /* if (standard_option) */
+    blk->header.typeflag = DIRTYPE;
+
+  /* If we're gnudumping, we aren't done yet so don't close it.  */

 
 

-      if (!incremental_option)
-       finish_header (stat, blk, block_ordinal);
-      else if (gnu_list_name->dir_contents)
+  if (!incremental_option)
+    finish_header (st, blk, block_ordinal);
+  else if (gnu_list_name->directory)
+    {
+      if (archive_format == POSIX_FORMAT)
+       {
+         xheader_store ("GNU.dumpdir", st,
+                        safe_directory_contents (gnu_list_name->directory));
+         finish_header (st, blk, block_ordinal);
+       }
+      else

        {
          off_t size_left;
          off_t totsize;
          size_t bufsize;
          ssize_t count;
          const char *buffer, *p_buffer;
        {
          off_t size_left;
          off_t totsize;
          size_t bufsize;
          ssize_t count;
          const char *buffer, *p_buffer;

-         off_t block_ordinal = current_block_ordinal ();
-         
-         buffer = gnu_list_name->dir_contents; /* FOO */
-         totsize = 0;
-         if (buffer)
-           for (p_buffer = buffer; *p_buffer; )
-             {
-               size_t size = strlen (p_buffer) + 1;
-               totsize += size;
-               p_buffer += size;
-             }
-         totsize++;
+
+         block_ordinal = current_block_ordinal ();
+         buffer = safe_directory_contents (gnu_list_name->directory);
+         totsize = dumpdir_size (buffer);

          OFF_TO_CHARS (totsize, blk->header.size);
          OFF_TO_CHARS (totsize, blk->header.size);

-         finish_header (stat, blk, block_ordinal); 
+         finish_header (st, blk, block_ordinal);

          p_buffer = buffer;
          size_left = totsize;
          p_buffer = buffer;
          size_left = totsize;

+
+         mv_begin_write (st->file_name, totsize, totsize);

          while (size_left > 0)
            {
          while (size_left > 0)
            {

-             if (multi_volume_option)
-               {
-                 assign_string (&save_name, stat->orig_file_name);
-                 save_sizeleft = size_left;
-                 save_totsize = totsize;
-               }

              blk = find_next_block ();
              bufsize = available_space_after (blk);
              if (size_left < bufsize)
              blk = find_next_block ();
              bufsize = available_space_after (blk);
              if (size_left < bufsize)


@@ -977,51 +1141,78 @@ dump_dir0 (char *directory,
              p_buffer += bufsize;
              set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
            }
              p_buffer += bufsize;
              set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
            }

-         if (multi_volume_option)
-           assign_string (&save_name, 0);
-         return;

        }
        }

+      return;

     }
 
   if (!recursion_option)
     return;
 
   if (one_file_system_option
     }
 
   if (!recursion_option)
     return;
 
   if (one_file_system_option

-          && !top_level
-          && parent_device != stat->stat.st_dev)
+      && !top_level
+      && st->parent->stat.st_dev != st->stat.st_dev)

     {
       if (verbose_option)
     {
       if (verbose_option)

-       WARN ((0, 0,
-              _("%s: file is on a different filesystem; not dumped"),
-              quotearg_colon (stat->orig_file_name)));
-      return;
+       WARNOPT (WARN_XDEV,
+                (0, 0,
+                 _("%s: file is on a different filesystem; not dumped"),
+                 quotearg_colon (st->orig_file_name)));

     }
     }

+  else
+    {
+      char *name_buf;
+      size_t name_size;

 
 

-  {
-    char const *entry;
-    size_t entry_len;
-    char *name_buf = strdup (stat->orig_file_name);
-    size_t name_size = strlen (name_buf);
-    size_t name_len = name_size;
-    
-    /* Now output all the files in the directory.  */
-    /* FIXME: Should speed this up by cd-ing into the dir.  */
-    
-    for (entry = directory; (entry_len = strlen (entry)) != 0;
-        entry += entry_len + 1)
-      {
-       if (name_size < name_len + entry_len)
+      switch (check_exclusion_tags (st, &tag_file_name))
+       {
+       case exclusion_tag_all:
+         /* Handled in dump_file0 */
+         break;
+
+       case exclusion_tag_none:

          {
          {

-           name_size = name_len + entry_len;
-           name_buf = xrealloc (name_buf, name_size + 1);
+           char const *entry;
+           size_t entry_len;
+           size_t name_len;
+
+           name_buf = xstrdup (st->orig_file_name);
+           name_size = name_len = strlen (name_buf);
+
+           /* Now output all the files in the directory.  */
+           for (entry = directory; (entry_len = strlen (entry)) != 0;
+                entry += entry_len + 1)
+             {
+               if (name_size < name_len + entry_len)
+                 {
+                   name_size = name_len + entry_len;
+                   name_buf = xrealloc (name_buf, name_size + 1);
+                 }
+               strcpy (name_buf + name_len, entry);
+               if (!excluded_name (name_buf))
+                 dump_file (st, entry, name_buf);
+             }
+
+           free (name_buf);

          }
          }

-       strcpy (name_buf + name_len, entry);
-       if (!excluded_name (name_buf))
-         dump_file (name_buf, 0, our_device);
-      }
-    
-    free (name_buf);
-  }
+         break;
+
+       case exclusion_tag_contents:
+         exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                _("contents not dumped"));
+         name_size = strlen (st->orig_file_name) + strlen (tag_file_name) + 1;
+         name_buf = xmalloc (name_size);
+         strcpy (name_buf, st->orig_file_name);
+         strcat (name_buf, tag_file_name);
+         dump_file (st, tag_file_name, name_buf);
+         free (name_buf);
+         break;
+
+       case exclusion_tag_under:
+         exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                _("contents not dumped"));
+         break;
+       }
+    }

 }
 
 /* Ensure exactly one trailing slash.  */
 }
 
 /* Ensure exactly one trailing slash.  */


@@ -1037,36 +1228,85 @@ ensure_slash (char **pstr)
   (*pstr)[len] = '\0';
 }
 
   (*pstr)[len] = '\0';
 }
 

-bool
-dump_dir (struct tar_stat_info *stat, int top_level, dev_t parent_device)
+/* If we just ran out of file descriptors, release a file descriptor
+   in the directory chain somewhere leading from DIR->parent->parent
+   up through the root.  Return true if successful, false (preserving
+   errno == EMFILE) otherwise.
+
+   Do not release DIR's file descriptor, or DIR's parent, as other
+   code assumes that they work.  On some operating systems, another
+   process can claim file descriptor resources as we release them, and
+   some calls or their emulations require multiple file descriptors,
+   so callers should not give up if a single release doesn't work.  */
+
+static bool
+open_failure_recover (struct tar_stat_info const *dir)
+{
+  if (errno == EMFILE && dir && dir->parent)
+    {
+      struct tar_stat_info *p;
+      for (p = dir->parent->parent; p; p = p->parent)
+       if (0 < p->fd && (! p->parent || p->parent->fd <= 0))
+         {
+           tar_stat_close (p);
+           return true;
+         }
+      errno = EMFILE;
+    }
+
+  return false;
+}
+
+/* Return the directory entries of ST, in a dynamically allocated buffer,
+   each entry followed by '\0' and the last followed by an extra '\0'.
+   Return null on failure, setting errno.  */
+char *
+get_directory_entries (struct tar_stat_info *st)

 {
 {

-  char *directory;
+  while (! (st->dirstream = fdopendir (st->fd)))
+    if (! open_failure_recover (st))
+      return 0;
+  return streamsavedir (st->dirstream);
+}

 
 

-  directory = savedir (stat->orig_file_name);
-  if (!directory)
+/* Dump the directory ST.  Return true if successful, false (emitting
+   diagnostics) otherwise.  Get ST's entries, recurse through its
+   subdirectories, and clean up file descriptors afterwards.  */
+static bool
+dump_dir (struct tar_stat_info *st)
+{
+  char *directory = get_directory_entries (st);
+  if (! directory)

     {
     {

-      savedir_diag (stat->orig_file_name);
+      savedir_diag (st->orig_file_name);

       return false;
     }
 
       return false;
     }
 

-  ensure_slash (&stat->orig_file_name);
-  ensure_slash (&stat->file_name);
-
-  dump_dir0 (directory, stat, top_level, parent_device);
+  dump_dir0 (st, directory);

 
 

+  restore_parent_fd (st);

   free (directory);
   return true;
 }
 
   free (directory);
   return true;
 }
 

+\f
+/* Number of links a file can have without having to be entered into
+   the link table.  Typically this is 1, but in trickier circumstances
+   it is 0.  */
+static nlink_t trivial_link_count;
+

 \f
 /* Main functions of this module.  */
 
 void
 create_archive (void)
 {
 \f
 /* Main functions of this module.  */
 
 void
 create_archive (void)
 {

-  char *p;
+  struct name const *p;
+
+  trivial_link_count = name_count <= 1 && ! dereference_option;

 
   open_archive (ACCESS_WRITE);
 
   open_archive (ACCESS_WRITE);

+  buffer_write_global_xheader ();

 
   if (incremental_option)
     {
 
   if (incremental_option)
     {


@@ -1077,30 +1317,49 @@ create_archive (void)
       collect_and_sort_names ();
 
       while ((p = name_from_list ()) != NULL)
       collect_and_sort_names ();
 
       while ((p = name_from_list ()) != NULL)

-       if (!excluded_name (p))
-         dump_file (p, -1, (dev_t) 0);
+       if (!excluded_name (p->name))
+         dump_file (0, p->name, p->name);

 
       blank_name_list ();
       while ((p = name_from_list ()) != NULL)
 
       blank_name_list ();
       while ((p = name_from_list ()) != NULL)

-       if (!excluded_name (p))
+       if (!excluded_name (p->name))

          {
          {

-           size_t plen = strlen (p);
+           struct tar_stat_info st;
+           size_t plen = strlen (p->name);

            if (buffer_size <= plen)
              {
                while ((buffer_size *= 2) <= plen)
                  continue;
                buffer = xrealloc (buffer, buffer_size);
              }
            if (buffer_size <= plen)
              {
                while ((buffer_size *= 2) <= plen)
                  continue;
                buffer = xrealloc (buffer, buffer_size);
              }

-           memcpy (buffer, p, plen);
+           memcpy (buffer, p->name, plen);

            if (! ISSLASH (buffer[plen - 1]))
            if (! ISSLASH (buffer[plen - 1]))

-             buffer[plen++] = '/';
-           q = gnu_list_name->dir_contents;
+             buffer[plen++] = DIRECTORY_SEPARATOR;
+           tar_stat_init (&st);
+           q = directory_contents (gnu_list_name->directory);

            if (q)
              while (*q)
                {
                  size_t qlen = strlen (q);
                  if (*q == 'Y')
                    {
            if (q)
              while (*q)
                {
                  size_t qlen = strlen (q);
                  if (*q == 'Y')
                    {

+                     if (! st.orig_file_name)
+                       {
+                         int fd = openat (chdir_fd, p->name,
+                                          open_searchdir_flags);
+                         if (fd < 0)
+                           {
+                             open_diag (p->name);
+                             break;
+                           }
+                         st.fd = fd;
+                         if (fstat (fd, &st.stat) != 0)
+                           {
+                             stat_diag (p->name);
+                             break;
+                           }
+                         st.orig_file_name = xstrdup (p->name);
+                       }

                      if (buffer_size < plen + qlen)
                        {
                          while ((buffer_size *=2 ) < plen + qlen)
                      if (buffer_size < plen + qlen)
                        {
                          while ((buffer_size *=2 ) < plen + qlen)


@@ -1108,34 +1367,37 @@ create_archive (void)
                          buffer = xrealloc (buffer, buffer_size);
                        }
                      strcpy (buffer + plen, q + 1);
                          buffer = xrealloc (buffer, buffer_size);
                        }
                      strcpy (buffer + plen, q + 1);

-                     dump_file (buffer, -1, (dev_t) 0);
+                     dump_file (&st, q + 1, buffer);

                    }
                  q += qlen + 1;
                }
                    }
                  q += qlen + 1;
                }

+           tar_stat_destroy (&st);

          }
       free (buffer);
     }
   else
     {
          }
       free (buffer);
     }
   else
     {

-      while ((p = name_next (1)) != NULL)
-       if (!excluded_name (p))
-         dump_file (p, 1, (dev_t) 0);
+      const char *name;
+      while ((name = name_next (1)) != NULL)
+       if (!excluded_name (name))
+         dump_file (0, name, name);

     }
 
   write_eot ();
   close_archive ();
     }
 
   write_eot ();
   close_archive ();

-
+  finish_deferred_unlinks ();

   if (listed_incremental_option)
     write_directory_file ();
 }
 
 
 /* Calculate the hash of a link.  */
   if (listed_incremental_option)
     write_directory_file ();
 }
 
 
 /* Calculate the hash of a link.  */

-static unsigned
-hash_link (void const *entry, unsigned n_buckets)
+static size_t
+hash_link (void const *entry, size_t n_buckets)

 {
 {

-  struct link const *link = entry;
-  return (uintmax_t) (link->dev ^ link->ino) % n_buckets;
+  struct link const *l = entry;
+  uintmax_t num = l->dev ^ l->ino;
+  return num % n_buckets;

 }
 
 /* Compare two links for equality.  */
 }
 
 /* Compare two links for equality.  */


@@ -1148,12 +1410,13 @@ compare_links (void const *entry1, void const *entry2)
 }
 
 static void
 }
 
 static void

-unknown_file_error (char *p)
+unknown_file_error (char const *p)

 {
 {

-  WARN ((0, 0, _("%s: Unknown file type; file ignored"),
-        quotearg_colon (p)));
+  WARNOPT (WARN_FILE_IGNORED,
+          (0, 0, _("%s: Unknown file type; file ignored"),
+           quotearg_colon (p)));

   if (!ignore_failed_read_option)
   if (!ignore_failed_read_option)

-    exit_status = TAREXIT_FAILURE;
+    set_exit_status (TAREXIT_FAILURE);

 }
 
 \f
 }
 
 \f


@@ -1164,44 +1427,47 @@ unknown_file_error (char *p)
    again if we've done it once already.  */
 static Hash_table *link_table;
 
    again if we've done it once already.  */
 static Hash_table *link_table;
 

-/* Try to dump stat as a hard link to another file in the archive. If
-   succeeded returns true */
+/* Try to dump stat as a hard link to another file in the archive.
+   Return true if successful.  */

 static bool
 static bool

-dump_hard_link (struct tar_stat_info *stat)
+dump_hard_link (struct tar_stat_info *st)

 {
 {

-  if (link_table && stat->stat.st_nlink > 1)
+  if (link_table
+      && (trivial_link_count < st->stat.st_nlink || remove_files_option))

     {
       struct link lp;
     {
       struct link lp;

-      struct link *dup;
+      struct link *duplicate;

       off_t block_ordinal;
       union block *blk;
       off_t block_ordinal;
       union block *blk;

-      
-      lp.ino = stat->stat.st_ino;
-      lp.dev = stat->stat.st_dev;

 
 

-      if ((dup = hash_lookup (link_table, &lp)))
+      lp.ino = st->stat.st_ino;
+      lp.dev = st->stat.st_dev;
+
+      if ((duplicate = hash_lookup (link_table, &lp)))

        {
          /* We found a link.  */
        {
          /* We found a link.  */

-         char const *link_name = safer_name_suffix (dup->name, true);
+         char const *link_name = safer_name_suffix (duplicate->name, true,
+                                                    absolute_names_option);
+
+         duplicate->nlink--;

 
 

-         dup->nlink--;
-             

          block_ordinal = current_block_ordinal ();
          block_ordinal = current_block_ordinal ();

-         assign_string (&stat->link_name, link_name);
-         if (NAME_FIELD_SIZE < strlen (link_name))
-           write_long_link (stat);
-         
-         stat->stat.st_size = 0;
-         blk = start_header (stat);
+         assign_string (&st->link_name, link_name);
+         if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT)
+             < strlen (link_name))
+           write_long_link (st);
+
+         st->stat.st_size = 0;
+         blk = start_header (st);

          if (!blk)
          if (!blk)

-           return true;
+           return false;

          tar_copy_str (blk->header.linkname, link_name, NAME_FIELD_SIZE);
 
          blk->header.typeflag = LNKTYPE;
          tar_copy_str (blk->header.linkname, link_name, NAME_FIELD_SIZE);
 
          blk->header.typeflag = LNKTYPE;

-         finish_header (stat, blk, block_ordinal);
+         finish_header (st, blk, block_ordinal);

 
 

-         if (remove_files_option && unlink (stat->orig_file_name) != 0)
-           unlink_error (stat->orig_file_name);
+         if (remove_files_option)
+           queue_deferred_unlink (st->orig_file_name, false);

 
          return true;
        }
 
          return true;
        }


@@ -1210,25 +1476,34 @@ dump_hard_link (struct tar_stat_info *stat)
 }
 
 static void
 }
 
 static void

-file_count_links (struct tar_stat_info *stat)
+file_count_links (struct tar_stat_info *st)

 {
 {

-  if (stat->stat.st_nlink > 1)
+  if (hard_dereference_option)
+    return;
+  if (trivial_link_count < st->stat.st_nlink)

     {
     {

-      struct link *dup;
-      struct link *lp = xmalloc (offsetof (struct link, name)
-                                + strlen (stat->orig_file_name) + 1);
-      lp->ino = stat->stat.st_ino;
-      lp->dev = stat->stat.st_dev;
-      lp->nlink = stat->stat.st_nlink;
-      strcpy (lp->name, stat->orig_file_name);
+      struct link *duplicate;
+      char *linkname = NULL;
+      struct link *lp;
+
+      assign_string (&linkname, st->orig_file_name);
+      transform_name (&linkname, XFORM_LINK);
+
+      lp = xmalloc (offsetof (struct link, name)
+                                + strlen (linkname) + 1);
+      lp->ino = st->stat.st_ino;
+      lp->dev = st->stat.st_dev;
+      lp->nlink = st->stat.st_nlink;
+      strcpy (lp->name, linkname);
+      free (linkname);

 
       if (! ((link_table
              || (link_table = hash_initialize (0, 0, hash_link,
                                                compare_links, 0)))
 
       if (! ((link_table
              || (link_table = hash_initialize (0, 0, hash_link,
                                                compare_links, 0)))

-            && (dup = hash_insert (link_table, lp))))
+            && (duplicate = hash_insert (link_table, lp))))

        xalloc_die ();
 
        xalloc_die ();
 

-      if (dup != lp)
+      if (duplicate != lp)

        abort ();
       lp->nlink--;
     }
        abort ();
       lp->nlink--;
     }


@@ -1237,7 +1512,7 @@ file_count_links (struct tar_stat_info *stat)
 /* For each dumped file, check if all its links were dumped. Emit
    warnings if it is not so. */
 void
 /* For each dumped file, check if all its links were dumped. Emit
    warnings if it is not so. */
 void

-check_links ()
+check_links (void)

 {
   struct link *lp;
 
 {
   struct link *lp;
 


@@ -1249,50 +1524,143 @@ check_links ()
     {
       if (lp->nlink)
        {
     {
       if (lp->nlink)
        {

-         WARN ((0, 0, _("Missing links to '%s'.\n"), lp->name));
+         WARN ((0, 0, _("Missing links to %s."), quote (lp->name)));

        }
     }
 }
 
        }
     }
 }
 

+/* Assuming DIR is the working directory, open FILE, using FLAGS to
+   control the open.  A null DIR means to use ".".  If we are low on
+   file descriptors, try to release one or more from DIR's parents to
+   reuse it.  */
+int
+subfile_open (struct tar_stat_info const *dir, char const *file, int flags)
+{
+  int fd;
+
+  static bool initialized;
+  if (! initialized)
+    {
+      /* Initialize any tables that might be needed when file
+        descriptors are exhausted, and whose initialization might
+        require a file descriptor.  This includes the system message
+        catalog and tar's message catalog.  */
+      initialized = true;
+      strerror (ENOENT);
+      gettext ("");
+    }
+
+  while ((fd = openat (dir ? dir->fd : chdir_fd, file, flags)) < 0
+        && open_failure_recover (dir))
+    continue;
+  return fd;
+}
+
+/* Restore the file descriptor for ST->parent, if it was temporarily
+   closed to conserve file descriptors.  On failure, set the file
+   descriptor to the negative of the corresponding errno value.  Call
+   this every time a subdirectory is ascended from.  */
+void
+restore_parent_fd (struct tar_stat_info const *st)
+{
+  struct tar_stat_info *parent = st->parent;
+  if (parent && ! parent->fd)
+    {
+      int parentfd = openat (st->fd, "..", open_searchdir_flags);
+      struct stat parentstat;
+
+      if (parentfd < 0)
+       parentfd = - errno;
+      else if (! (fstat (parentfd, &parentstat) == 0
+                 && parent->stat.st_ino == parentstat.st_ino
+                 && parent->stat.st_dev == parentstat.st_dev))
+       {
+         close (parentfd);
+         parentfd = IMPOSTOR_ERRNO;
+       }
+
+      if (parentfd < 0)
+       {
+         int origfd = openat (chdir_fd, parent->orig_file_name,
+                              open_searchdir_flags);
+         if (0 <= origfd)
+           {
+             if (fstat (parentfd, &parentstat) == 0
+                 && parent->stat.st_ino == parentstat.st_ino
+                 && parent->stat.st_dev == parentstat.st_dev)
+               parentfd = origfd;
+             else
+               close (origfd);
+           }
+       }
+
+      parent->fd = parentfd;
+    }
+}

 
 

-/* Dump a single file, recursing on directories.  P is the file name
-   to dump.  TOP_LEVEL tells whether this is a top-level call; zero
-   means no, positive means yes, and negative means the top level
-   of an incremental dump.  PARENT_DEVICE is the device of P's
-   parent directory; it is examined only if TOP_LEVEL is zero. */
+/* Dump a single file, recursing on directories.  ST is the file's
+   status info, NAME its name relative to the parent directory, and P
+   its full name (which may be relative to the working directory).  */

 
 /* FIXME: One should make sure that for *every* path leading to setting
    exit_status to failure, a clear diagnostic has been issued.  */
 
 
 /* FIXME: One should make sure that for *every* path leading to setting
    exit_status to failure, a clear diagnostic has been issued.  */
 

-void
-dump_file0 (struct tar_stat_info *stat, char *p,
-           int top_level, dev_t parent_device)
+static void
+dump_file0 (struct tar_stat_info *st, char const *name, char const *p)

 {
   union block *header;
   char type;
 {
   union block *header;
   char type;

-  time_t original_ctime;
-  struct utimbuf restore_times;
+  off_t original_size;
+  struct timespec original_ctime;

   off_t block_ordinal = -1;
   off_t block_ordinal = -1;

-  
+  int fd = 0;
+  bool is_dir;
+  struct tar_stat_info const *parent = st->parent;
+  bool top_level = ! parent;
+  int parentfd = top_level ? chdir_fd : parent->fd;
+  void (*diag) (char const *) = 0;
+

   if (interactive_option && !confirm ("add", p))
     return;
 
   if (interactive_option && !confirm ("add", p))
     return;
 

-  assign_string (&stat->orig_file_name, p);
-  assign_string (&stat->file_name, safer_name_suffix (p, false));
+  assign_string (&st->orig_file_name, p);
+  assign_string (&st->file_name,
+                 safer_name_suffix (p, false, absolute_names_option));
+
+  transform_name (&st->file_name, XFORM_REGFILE);

 
 

-  if (deref_stat (dereference_option, p, &stat->stat) != 0)
+  if (parentfd < 0 && ! top_level)

     {
     {

-      stat_diag (p);
+      errno = - parentfd;
+      diag = open_diag;
+    }
+  else if (fstatat (parentfd, name, &st->stat, fstatat_flags) != 0)
+    diag = stat_diag;
+  else if (file_dumpable_p (&st->stat))
+    {
+      fd = subfile_open (parent, name, open_read_flags);
+      if (fd < 0)
+       diag = open_diag;
+      else
+       {
+         st->fd = fd;
+         if (fstat (fd, &st->stat) != 0)
+           diag = stat_diag;
+       }
+    }
+  if (diag)
+    {
+      file_removed_diag (p, top_level, diag);

       return;
     }
       return;
     }

-  stat->archive_file_size = stat->stat.st_size;
-  sys_stat_nanoseconds(stat);
-  original_ctime = stat->stat.st_ctime;
-  restore_times.actime = stat->stat.st_atime;
-  restore_times.modtime = stat->stat.st_mtime;
+
+  st->archive_file_size = original_size = st->stat.st_size;
+  st->atime = get_stat_atime (&st->stat);
+  st->mtime = get_stat_mtime (&st->stat);
+  st->ctime = original_ctime = get_stat_ctime (&st->stat);

 
 #ifdef S_ISHIDDEN
 
 #ifdef S_ISHIDDEN

-  if (S_ISHIDDEN (stat->stat.st_mode))
+  if (S_ISHIDDEN (st->stat.st_mode))

     {
       char *new = (char *) alloca (strlen (p) + 2);
       if (new)
     {
       char *new = (char *) alloca (strlen (p) + 2);
       if (new)


@@ -1305,164 +1673,200 @@ dump_file0 (struct tar_stat_info *stat, char *p,
 #endif
 
   /* See if we want only new files, and check if this one is too old to
 #endif
 
   /* See if we want only new files, and check if this one is too old to

-     put in the archive.  */
+     put in the archive.
+
+     This check is omitted if incremental_option is set *and* the
+     requested file is not explicitely listed in the command line. */

 
 

-  if ((0 < top_level || !incremental_option)
-      && !S_ISDIR (stat->stat.st_mode)
-      && stat->stat.st_mtime < newer_mtime_option
-      && (!after_date_option || stat->stat.st_ctime < newer_ctime_option))
+  if (!(incremental_option && !is_individual_file (p))
+      && !S_ISDIR (st->stat.st_mode)
+      && OLDER_TAR_STAT_TIME (*st, m)
+      && (!after_date_option || OLDER_TAR_STAT_TIME (*st, c)))

     {
     {

-      if (0 < top_level)
-       WARN ((0, 0, _("%s: file is unchanged; not dumped"),
-              quotearg_colon (p)));
-      /* FIXME: recheck this return.  */
+      if (!incremental_option && verbose_option)
+       WARNOPT (WARN_FILE_UNCHANGED,
+                (0, 0, _("%s: file is unchanged; not dumped"),
+                 quotearg_colon (p)));

       return;
     }
 
   /* See if we are trying to dump the archive.  */
       return;
     }
 
   /* See if we are trying to dump the archive.  */

-  if (sys_file_is_archive (stat))
+  if (sys_file_is_archive (st))

     {
     {

-      WARN ((0, 0, _("%s: file is the archive; not dumped"),
-            quotearg_colon (p)));
+      WARNOPT (WARN_IGNORE_ARCHIVE,
+              (0, 0, _("%s: file is the archive; not dumped"),
+               quotearg_colon (p)));

       return;
     }
 
       return;
     }
 

-  if (S_ISDIR (stat->stat.st_mode))
-    {
-      dump_dir (stat, top_level, parent_device);
-      if (atime_preserve_option)
-       utime (p, &restore_times);
-      return;
-    }
-  else if (is_avoided_name (p))
+  is_dir = S_ISDIR (st->stat.st_mode) != 0;
+
+  if (!is_dir && dump_hard_link (st))

     return;
     return;

-  else
+
+  if (is_dir || S_ISREG (st->stat.st_mode) || S_ISCTG (st->stat.st_mode))

     {
     {

-      /* Check for multiple links.  */
-      if (dump_hard_link (stat))
-       return;
-      
-      /* This is not a link to a previously dumped file, so dump it.  */
+      bool ok;
+      struct stat final_stat;

 
 

-      if (S_ISREG (stat->stat.st_mode)
-         || S_ISCTG (stat->stat.st_mode))
+      if (is_dir)

        {
        {

-         int fd;
-         enum dump_status status;
+         const char *tag_file_name;
+         ensure_slash (&st->orig_file_name);
+         ensure_slash (&st->file_name);

 
 

-         if (file_dumpable_p (stat))
+         if (check_exclusion_tags (st, &tag_file_name) == exclusion_tag_all)

            {
            {

-             fd = open (stat->orig_file_name,
-                        O_RDONLY | O_BINARY);
-             if (fd < 0)
-               {
-                 if (!top_level && errno == ENOENT)
-                   WARN ((0, 0, _("%s: File removed before we read it"),
-                          quotearg_colon (stat->orig_file_name)));
-                 else
-                   open_diag (stat->orig_file_name);
-                 return;
-               }
+             exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                    _("directory not dumped"));
+             return;

            }
            }

-         else
-           fd = -1;
-         
-         if (sparse_option && sparse_file_p (stat))
+
+         ok = dump_dir (st);
+
+         fd = st->fd;
+         parentfd = top_level ? chdir_fd : parent->fd;
+       }
+      else
+       {
+         enum dump_status status;
+
+         if (fd && sparse_option && ST_IS_SPARSE (st->stat))

            {
            {

-             status = sparse_dump_file (fd, stat); 
+             status = sparse_dump_file (fd, st);

              if (status == dump_status_not_implemented)
              if (status == dump_status_not_implemented)

-               status = dump_regular_file (fd, stat);
+               status = dump_regular_file (fd, st);

            }
          else
            }
          else

-           status = dump_regular_file (fd, stat);
+           status = dump_regular_file (fd, st);

 
          switch (status)
            {
            case dump_status_ok:
 
          switch (status)
            {
            case dump_status_ok:

-             if (multi_volume_option)
-               assign_string (&save_name, 0);
-             dump_regular_finish (fd, stat, original_ctime);
-             break;
-

            case dump_status_short:
            case dump_status_short:

-             if (multi_volume_option)
-               assign_string (&save_name, 0);
-             close (fd);
+             file_count_links (st);

              break;
              break;

-      
+

            case dump_status_fail:
            case dump_status_fail:

-             close (fd);
-             return;
+             break;

 
            case dump_status_not_implemented:
              abort ();
            }
 
 
            case dump_status_not_implemented:
              abort ();
            }
 

-         if (atime_preserve_option)
-           utime (stat->orig_file_name, &restore_times);
-         file_count_links (stat);
-         return;
+         ok = status == dump_status_ok;

        }
        }

-#ifdef HAVE_READLINK
-      else if (S_ISLNK (stat->stat.st_mode))
+
+      if (ok)

        {
        {

-         char *buffer;
-         int size;
-         size_t linklen = stat->stat.st_size;
-         if (linklen != stat->stat.st_size || linklen + 1 == 0)
-           xalloc_die ();
-         buffer = (char *) alloca (linklen + 1);
-         size = readlink (p, buffer, linklen + 1);
-         if (size < 0)
+         if (fd < 0)

            {
            {

-             readlink_diag (p);
-             return;
+             errno = - fd;
+             ok = false;

            }
            }

-         buffer[size] = '\0';
-         assign_string (&stat->link_name, buffer);
-         if (size > NAME_FIELD_SIZE)
-           write_long_link (stat);
-
-         block_ordinal = current_block_ordinal ();
-         stat->stat.st_size = 0;       /* force 0 size on symlink */
-         header = start_header (stat);
-         if (!header)
-           return;
-         tar_copy_str (header->header.linkname, buffer, NAME_FIELD_SIZE);
-         header->header.typeflag = SYMTYPE;
-         finish_header (stat, header, block_ordinal);
-         /* nothing more to do to it */
-
-         if (remove_files_option)
+         else if (fd == 0)

            {
            {

-             if (unlink (p) == -1)
-               unlink_error (p);
+             if (parentfd < 0 && ! top_level)
+               {
+                 errno = - parentfd;
+                 ok = false;
+               }
+             else
+               ok = fstatat (parentfd, name, &final_stat, fstatat_flags) == 0;

            }
            }

-         file_count_links (stat);
-         return;
-       }
-#endif
-      else if (S_ISCHR (stat->stat.st_mode))
-       type = CHRTYPE;
-      else if (S_ISBLK (stat->stat.st_mode))
-       type = BLKTYPE;
-      else if (S_ISFIFO (stat->stat.st_mode))
-       type = FIFOTYPE;
-      else if (S_ISSOCK (stat->stat.st_mode))
-       {
-         WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p)));
-         return;
+         else
+           ok = fstat (fd, &final_stat) == 0;
+
+         if (! ok)
+           file_removed_diag (p, top_level, stat_diag);

        }
        }

-      else if (S_ISDOOR (stat->stat.st_mode))
+
+      if (ok)

        {
        {

-         WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p)));
-         return;
+         if ((timespec_cmp (get_stat_ctime (&final_stat), original_ctime) != 0
+              /* Original ctime will change if the file is a directory and
+                 --remove-files is given */
+              && !(remove_files_option && is_dir))
+             || original_size < final_stat.st_size)
+           {
+             WARNOPT (WARN_FILE_CHANGED,
+                      (0, 0, _("%s: file changed as we read it"),
+                       quotearg_colon (p)));
+             set_exit_status (TAREXIT_DIFFERS);
+           }
+         else if (atime_preserve_option == replace_atime_preserve
+                  && (set_file_atime (fd, parentfd, name,
+                                      st->atime, fstatat_flags)
+                      != 0))
+           utime_error (p);

        }
        }

-      else
+
+      ok &= tar_stat_close (st);
+      if (ok && remove_files_option)
+       queue_deferred_unlink (p, is_dir);
+
+      return;
+    }
+#ifdef HAVE_READLINK
+  else if (S_ISLNK (st->stat.st_mode))
+    {
+      char *buffer;
+      int size;
+      size_t linklen = st->stat.st_size;
+      if (linklen != st->stat.st_size || linklen + 1 == 0)
+       xalloc_die ();
+      buffer = (char *) alloca (linklen + 1);
+      size = readlinkat (parentfd, name, buffer, linklen + 1);
+      if (size < 0)

        {
        {

-         unknown_file_error (p);
+         file_removed_diag (p, top_level, readlink_diag);

          return;
        }
          return;
        }

+      buffer[size] = '\0';
+      assign_string (&st->link_name, buffer);
+      transform_name (&st->link_name, XFORM_SYMLINK);
+      if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT) < size)
+       write_long_link (st);
+
+      block_ordinal = current_block_ordinal ();
+      st->stat.st_size = 0;    /* force 0 size on symlink */
+      header = start_header (st);
+      if (!header)
+       return;
+      tar_copy_str (header->header.linkname, st->link_name, NAME_FIELD_SIZE);
+      header->header.typeflag = SYMTYPE;
+      finish_header (st, header, block_ordinal);
+      /* nothing more to do to it */
+
+      if (remove_files_option)
+       queue_deferred_unlink (p, false);
+
+      file_count_links (st);
+      return;
+    }
+#endif
+  else if (S_ISCHR (st->stat.st_mode))
+    type = CHRTYPE;
+  else if (S_ISBLK (st->stat.st_mode))
+    type = BLKTYPE;
+  else if (S_ISFIFO (st->stat.st_mode))
+    type = FIFOTYPE;
+  else if (S_ISSOCK (st->stat.st_mode))
+    {
+      WARNOPT (WARN_FILE_IGNORED,
+              (0, 0, _("%s: socket ignored"), quotearg_colon (p)));
+      return;
+    }
+  else if (S_ISDOOR (st->stat.st_mode))
+    {
+      WARNOPT (WARN_FILE_IGNORED,
+              (0, 0, _("%s: door ignored"), quotearg_colon (p)));
+      return;
+    }
+  else
+    {
+      unknown_file_error (p);
+      return;

     }
 
   if (archive_format == V7_FORMAT)
     }
 
   if (archive_format == V7_FORMAT)


@@ -1472,33 +1876,39 @@ dump_file0 (struct tar_stat_info *stat, char *p,
     }
 
   block_ordinal = current_block_ordinal ();
     }
 
   block_ordinal = current_block_ordinal ();

-  stat->stat.st_size = 0;      /* force 0 size */
-  header = start_header (stat);
+  st->stat.st_size = 0;        /* force 0 size */
+  header = start_header (st);

   if (!header)
     return;
   header->header.typeflag = type;
 
   if (type != FIFOTYPE)
     {
   if (!header)
     return;
   header->header.typeflag = type;
 
   if (type != FIFOTYPE)
     {

-      MAJOR_TO_CHARS (major (stat->stat.st_rdev),
+      MAJOR_TO_CHARS (major (st->stat.st_rdev),

                      header->header.devmajor);
                      header->header.devmajor);

-      MINOR_TO_CHARS (minor (stat->stat.st_rdev),
+      MINOR_TO_CHARS (minor (st->stat.st_rdev),

                      header->header.devminor);
     }
 
                      header->header.devminor);
     }
 

-  finish_header (stat, header, block_ordinal);
+  finish_header (st, header, block_ordinal);

   if (remove_files_option)
   if (remove_files_option)

-    {
-      if (unlink (p) == -1)
-       unlink_error (p);
-    }
+    queue_deferred_unlink (p, false);

 }
 
 }
 

+/* Dump a file, recursively.  PARENT describes the file's parent
+   directory, NAME is the file's name relative to PARENT, and FULLNAME
+   its full name, possibly relative to the working directory.  NAME
+   may contain slashes at the top level of invocation.  */
+

 void
 void

-dump_file (char *p, int top_level, dev_t parent_device)
+dump_file (struct tar_stat_info *parent, char const *name,
+          char const *fullname)

 {
 {

-  struct tar_stat_info stat;
-  tar_stat_init (&stat);
-  dump_file0 (&stat, p, top_level, parent_device);
-  tar_stat_destroy (&stat);
+  struct tar_stat_info st;
+  tar_stat_init (&st);
+  st.parent = parent;
+  dump_file0 (&st, name, fullname);
+  if (parent && listed_incremental_option)
+    update_parent_directory (parent);
+  tar_stat_destroy (&st);

 }
 }