Improve listed incremental dumps.

[chaz/tar] / src / create.c

diff --git a/src/create.c b/src/create.c
index 241310699ab0c37b091e8ca6907f28bdf0667d3d..072732a6195250bd1a9ff436971de709a590bf6f 100644 (file)
--- a/src/create.c
+++ b/src/create.c
@@ -1,10 +1,13 @@
 /* Create a tar archive.
 /* Create a tar archive.

-   Copyright 1985, 92, 93, 94, 96, 97, 1999 Free Software Foundation, Inc.
+
+   Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
+   2003, 2004, 2005, 2006, 2007, 2009 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


@@ -14,45 +17,128 @@
 
    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 !MSDOS
-# include <pwd.h>
-# include <grp.h>
-#endif
+#include <system.h>

 
 

-#if HAVE_UTIME_H
-# include <utime.h>
-#else
-struct utimbuf
-  {
-    long actime;
-    long modtime;
-  };
-#endif
+#include <quotearg.h>

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

-
-#ifndef MSDOS
-extern dev_t ar_dev;
-extern ino_t ar_ino;
-#endif
-
-extern struct name *gnu_list_name;
-
-/* This module is the only one that cares about `struct link's.  */
+#include <hash.h>

 
 struct link
   {
 
 struct link
   {

-    struct link *next;

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

+    size_t nlink;

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

-static struct link *linklist;  /* points to first link in list */
+struct exclusion_tag
+{
+  const char *name;
+  size_t length;
+  enum exclusion_tag_type type;
+  bool (*predicate) (const char *name);
+  struct exclusion_tag *next;
+};
+
+static struct exclusion_tag *exclusion_tags;
+
+void
+add_exclusion_tag (const char *name, enum exclusion_tag_type type,
+                  bool (*predicate) (const char *name))
+{
+  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 (const char *dirname, const char **tag_file_name)
+{
+  static char *tagname;
+  static size_t tagsize;
+  struct exclusion_tag *tag;
+  size_t dlen = strlen (dirname);
+  int addslash = !ISSLASH (dirname[dlen-1]);
+  char *nptr = NULL;
+  
+  for (tag = exclusion_tags; tag; tag = tag->next)
+    {
+      size_t size = dlen + addslash + tag->length + 1;
+      if (size > tagsize)
+       {
+         tagsize = size;
+         tagname = xrealloc (tagname, tagsize);
+       }
+
+      if (!nptr)
+       {
+         strcpy (tagname, dirname);
+         nptr = tagname + dlen;
+         if (addslash)
+           *nptr++ = '/';
+       }
+      strcpy (nptr, tag->name);
+      if (access (tagname, F_OK) == 0
+         && (!tag->predicate || tag->predicate (tagname)))
+       {
+         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 (const char *name)
+{
+  bool tag_present = false;
+  int fd = open (name, O_RDONLY);
+  if (fd >= 0)
+    {
+      static char tagbuf[CACHEDIR_SIGNATURE_SIZE];
+
+      if (read (fd, tagbuf, CACHEDIR_SIGNATURE_SIZE)
+         == CACHEDIR_SIGNATURE_SIZE
+         && memcmp (tagbuf, CACHEDIR_SIGNATURE, CACHEDIR_SIGNATURE_SIZE) == 0)
+       tag_present = true;
+
+      close (fd);
+    }
+  return tag_present;
+}
+

 \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.  */


@@ -61,6 +147,10 @@ static struct link *linklist;       /* points to first link in list */
     ? ((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.  */


@@ -79,6 +169,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.


@@ -101,6 +214,73 @@ to_base256 (int negative, uintmax_t value, char *where, size_t size)
   while (i);
 }
 
   while (i);
 }
 

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


@@ -115,101 +295,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,
 to_chars (int negative, uintmax_t value, size_t valsize,

-         uintmax_t (*substitute) PARAMS ((int *)),
+         uintmax_t (*substitute) (int *),

          char *where, size_t size, const char *type)
 {
          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)
-    {
-      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);
-    }
-
-  /* Otherwise, output a substitute value if possible (with a
-     warning), and an error message if not.  */
-  else
+  else if (gnu_format)

     {
     {

-      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)
-       {
-         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";
+      /* Try to cope with the number by using traditional GNU format
+        methods */

 
 

-      if (negative)
+      /* Generate the base-256 representation if the number fits.  */
+      if (((negative ? -1 - value : value)
+          <= MAX_VAL_WITH_DIGITS (size - 1, LG_256)))

        {
        {

-         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


@@ -228,25 +368,25 @@ gid_substitute (int *negative)
   return r;
 }
 
   return r;
 }
 

-void
+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
+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
+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
+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,


@@ -261,7 +401,9 @@ mode_to_chars (mode_t v, char *p, size_t s)
       && S_IRGRP == TGREAD && S_IWGRP == TGWRITE && S_IXGRP == TGEXEC
       && S_IROTH == TOREAD && S_IWOTH == TOWRITE && S_IXOTH == TOEXEC
       && archive_format != POSIX_FORMAT
       && S_IRGRP == TGREAD && S_IWGRP == TGWRITE && S_IXGRP == TGEXEC
       && S_IROTH == TOREAD && S_IWOTH == TOWRITE && S_IXOTH == TOEXEC
       && archive_format != POSIX_FORMAT

-      && archive_format != GNU_FORMAT)
+      && archive_format != USTAR_FORMAT
+      && archive_format != GNU_FORMAT
+      && archive_format != OLDGNU_FORMAT)

     {
       negative = v < 0;
       u = v;
     {
       negative = v < 0;
       u = v;


@@ -282,25 +424,25 @@ 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");
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "off_t");

 }
 
 }
 

-void
+bool

 size_to_chars (size_t v, char *p, size_t s)
 {
 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 (0, (uintmax_t) v, sizeof v, 0, p, s, "size_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


@@ -319,37 +461,48 @@ uid_substitute (int *negative)
   return r;
 }
 
   return r;
 }
 

-void
+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
+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 const *str, char *p, size_t s)
+{
+  tar_copy_str (p, str, s);
+  p[s - 1] = '\0';

 }
 }

+

 \f
 \f

-/* Writing routines.  */
+/* A file is considered dumpable if it is sparse and both --sparse and --totals
+   are specified.
+   Otherwise, it is dumpable unless any of the following conditions occur:

 
 

-/*-----------------------------------------------------------------------.
-| Just zeroes out the buffer so we don't confuse ourselves with leftover |
-| data.                                                                         |
-`-----------------------------------------------------------------------*/
+   a) it is empty *and* world-readable, or
+   b) current archive is /dev/null */

 
 

-static void
-clear_buffer (char *buffer)
+bool
+file_dumpable_p (struct tar_stat_info *st)

 {
 {

-  memset (buffer, 0, BLOCKSIZE);
+  if (dev_null_output)
+    return totals_option && sparse_option && ST_IS_SPARSE (st->stat);
+  return !(st->archive_file_size == 0
+          && (st->stat.st_mode & MODE_R) == MODE_R);

 }
 
 }
 

-/*-------------------------------------------------------------------------.
-| Write the EOT block(s).  We zero at least two blocks, through                   |
-| the end of the record.  Old tar, as previous versions of GNU tar, writes |
-| garbage after two zeroed blocks.                                        |
-`-------------------------------------------------------------------------*/
+\f
+/* Writing routines.  */

 
 

+/* Write the EOT block(s).  Zero at least two blocks, through the end
+   of the record.  Old tar, as previous versions of GNU tar, writes
+   garbage after two zeroed blocks.  */

 void
 write_eot (void)
 {
 void
 write_eot (void)
 {


@@ -361,28 +514,73 @@ write_eot (void)
   set_next_block_after (pointer);
 }
 
   set_next_block_after (pointer);
 }
 

-/*-----------------------------------------------------.
-| Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block.  |
-`-----------------------------------------------------*/
+/* Write a "private" header */
+union block *
+start_private_header (const char *name, size_t size)
+{
+  time_t t;
+  union block *header = find_next_block ();
+
+  memset (header->buffer, 0, sizeof (union block));
+
+  tar_name_copy_str (header->header.name, name, NAME_FIELD_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);
+  MINOR_TO_CHARS (0, header->header.devminor);
+  strncpy (header->header.magic, TMAGIC, TMAGLEN);
+  strncpy (header->header.version, TVERSION, TVERSLEN);
+  return header;
+}
+
+/* Create a new header and store there at most NAME_FIELD_SIZE bytes of
+   the file name */

 
 

-/* FIXME: Cross recursion between start_header and write_long!  */
+static union block *
+write_short_name (struct tar_stat_info *st)
+{
+  union block *header = find_next_block ();
+  memset (header->buffer, 0, sizeof (union block));
+  tar_name_copy_str (header->header.name, st->file_name, NAME_FIELD_SIZE);
+  return header;
+}

 
 

-static union block *start_header PARAMS ((const char *, struct stat *));
+#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
 static void

-write_long (const char *p, char type)
+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;

-  struct stat foo;
-
-  memset (&foo, 0, sizeof foo);
-  foo.st_size = size;
-
-  header = start_header ("././@LongLink", &foo);
+  char *tmpname;
+
+  header = start_private_header ("././@LongLink", size);
+  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);
+
+  strcpy (header->header.magic, OLDGNU_MAGIC);

   header->header.typeflag = type;
   header->header.typeflag = type;

-  finish_header (header);
+  finish_header (st, header, -1);

 
   header = find_next_block ();
 
 
   header = find_next_block ();
 


@@ -401,64 +599,184 @@ write_long (const char *p, char type)
   memset (header->buffer + size, 0, bufsize - size);
   set_next_block_after (header + (size - 1) / BLOCKSIZE);
 }
   memset (header->buffer + size, 0, bufsize - size);
   set_next_block_after (header + (size - 1) / BLOCKSIZE);
 }

-\f
-/* Header handling.  */

 
 

-/* Make a header block for the file whose stat info is st,
-   and return its address.  */
+static size_t
+split_long_name (const char *name, size_t length)
+{
+  size_t i;
+
+  if (length > PREFIX_FIELD_SIZE)
+    length = PREFIX_FIELD_SIZE + 1;
+  for (i = length - 1; i > 0; i--)
+    if (ISSLASH (name[i]))
+      break;
+  return i;
+}

 
 static union block *
 
 static union block *

-start_header (const char *name, struct stat *st)
+write_ustar_long_name (const char *name)

 {
 {

+  size_t length = strlen (name);
+  size_t i;

   union block *header;
 
   union block *header;
 

-  if (!absolute_names_option)
+  if (length > PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1)

     {
     {

-      size_t prefix_len = FILESYSTEM_PREFIX_LEN (name);
+      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;
+    }

 
 

-      if (prefix_len)
-       {
-         static int warned_once;
-         if (!warned_once)
-           {
-             warned_once = 1;
-             WARN ((0, 0, _("Removing `%.*s' prefix from archive names"),
-                    (int) prefix_len, name));
-           }
-         name += prefix_len;
-       }
+  i = split_long_name (name, length);
+  if (i == 0 || length - i - 1 > NAME_FIELD_SIZE)
+    {
+      ERROR ((0, 0,
+             _("%s: file name is too long (cannot be split); not dumped"),
+             quotearg_colon (name)));
+      return NULL;
+    }
+
+  header = find_next_block ();
+  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;
+}
+
+/* Write a long link name, depending on the current archive format */
+static void
+write_long_link (struct tar_stat_info *st)
+{
+  switch (archive_format)
+    {
+    case POSIX_FORMAT:
+      xheader_store ("linkpath", st, NULL);
+      break;
+
+    case V7_FORMAT:                    /* old V7 tar format */
+    case USTAR_FORMAT:
+    case STAR_FORMAT:
+      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);
+      break;
+
+    default:
+      abort(); /*FIXME*/
+    }
+}
+
+static union block *
+write_long_name (struct tar_stat_info *st)
+{
+  switch (archive_format)
+    {
+    case POSIX_FORMAT:
+      xheader_store ("path", st, NULL);
+      break;

 
 

-      while (*name == '/')
+    case V7_FORMAT:
+      if (strlen (st->file_name) > NAME_FIELD_SIZE-1)

        {
        {

-         static int warned_once;
-         if (!warned_once)
-           {
-             warned_once = 1;
-             WARN ((0, 0, _("Removing leading `/' from archive names")));
-           }
-         name++;
+         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 OLDGNU_FORMAT:
+    case GNU_FORMAT:
+      write_gnu_long_link (st, st->file_name, GNUTYPE_LONGNAME);
+      break;
+
+    default:
+      abort(); /*FIXME*/

     }
     }

+  return write_short_name (st);
+}
+
+union block *
+write_extended (bool global, struct tar_stat_info *st, union block *old_header)
+{
+  union block *header, hp;
+  char *p;
+  int type;

 
 

-  if (sizeof header->header.name <= strlen (name))
-    write_long (name, GNUTYPE_LONGNAME);
+  if (st->xhdr.buffer || st->xhdr.stk == NULL)
+    return old_header;
+
+  xheader_finish (&st->xhdr);
+  memcpy (hp.buffer, old_header, sizeof (hp));
+  if (global)
+    {
+      type = XGLTYPE;
+      p = xheader_ghdr_name ();
+    }
+  else
+    {
+      type = XHDTYPE;
+      p = xheader_xhdr_name (st);
+    }
+  xheader_write (type, p, &st->xhdr);
+  free (p);

   header = find_next_block ();
   header = find_next_block ();

-  memset (header->buffer, 0, sizeof (union block));
+  memcpy (header, &hp.buffer, sizeof (hp.buffer));
+  return header;
+}
+
+static union block *
+write_header_name (struct tar_stat_info *st)
+{
+  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);
+}
+
+\f
+/* Header handling.  */
+
+/* Make a header block for the file whose stat info is st,
+   and return its address.  */

 
 

-  assign_string (&current_file_name, name);
+union block *
+start_header (struct tar_stat_info *st)
+{
+  union block *header;

 
 

-  strncpy (header->header.name, name, NAME_FIELD_SIZE);
-  header->header.name[NAME_FIELD_SIZE - 1] = '\0';
+  header = write_header_name (st);
+  if (!header)
+    return NULL;

 
   /* Override some stat fields, if requested to do so.  */
 
   if (owner_option != (uid_t) -1)
 
   /* Override some stat fields, if requested to do so.  */
 
   if (owner_option != (uid_t) -1)

-    st->st_uid = owner_option;
+    st->stat.st_uid = owner_option;

   if (group_option != (gid_t) -1)
   if (group_option != (gid_t) -1)

-    st->st_gid = group_option;
+    st->stat.st_gid = group_option;

   if (mode_option)
   if (mode_option)

-    st->st_mode = ((st->st_mode & ~MODE_ALL)
-                  | mode_adjust (st->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


@@ -483,21 +801,103 @@ start_header (const char *name, struct stat *st)
      above, thus making GNU tar both a universal donor and a universal
      acceptor for Paul's test.  */
 
      above, thus making GNU tar both a universal donor and a universal
      acceptor for Paul's test.  */
 

-  if (archive_format == V7_FORMAT)
-    MODE_TO_CHARS (st->st_mode & MODE_ALL, header->header.mode);
+  if (archive_format == V7_FORMAT || archive_format == USTAR_FORMAT)
+    MODE_TO_CHARS (st->stat.st_mode & MODE_ALL, header->header.mode);

   else
   else

-    MODE_TO_CHARS (st->st_mode, header->header.mode);
+    MODE_TO_CHARS (st->stat.st_mode, header->header.mode);
+
+  {
+    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;
+  }

 
 

-  UID_TO_CHARS (st->st_uid, header->header.uid);
-  GID_TO_CHARS (st->st_gid, header->header.gid);
-  OFF_TO_CHARS (st->st_size, header->header.size);
-  TIME_TO_CHARS (st->st_mtime, header->header.mtime);
+  {
+    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;
+  }

 
 

-  if (incremental_option)
-    if (archive_format == OLDGNU_FORMAT)
+  {
+    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;
+  }
+
+  {
+    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))
+    {
+      major_t devmajor = major (st->stat.st_rdev);
+      minor_t devminor = minor (st->stat.st_rdev);
+
+      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 (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 if (archive_format != GNU_FORMAT && archive_format != OLDGNU_FORMAT)
+    {
+      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 == OLDGNU_FORMAT || archive_format == GNU_FORMAT)

       {
       {

-       TIME_TO_CHARS (st->st_atime, header->oldgnu_header.atime);
-       TIME_TO_CHARS (st->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;


@@ -508,12 +908,13 @@ start_header (const char *name, struct stat *st)
       break;
 
     case OLDGNU_FORMAT:
       break;
 
     case OLDGNU_FORMAT:

+    case GNU_FORMAT:   /*FIXME?*/

       /* Overwrite header->header.magic and header.version in one blow.  */
       strcpy (header->header.magic, OLDGNU_MAGIC);
       break;
 
     case POSIX_FORMAT:
       /* Overwrite header->header.magic and header.version in one blow.  */
       strcpy (header->header.magic, OLDGNU_MAGIC);
       break;
 
     case POSIX_FORMAT:

-    case GNU_FORMAT:
+    case USTAR_FORMAT:

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


@@ -528,20 +929,27 @@ start_header (const char *name, struct stat *st)
     }
   else
     {
     }
   else
     {

-      uid_to_uname (st->st_uid, header->header.uname);
-      gid_to_gname (st->st_gid, header->header.gname);
+      uid_to_uname (st->stat.st_uid, &st->uname);
+      gid_to_gname (st->stat.st_gid, &st->gname);
+
+      if (archive_format == POSIX_FORMAT
+         && (strlen (st->uname) > UNAME_FIELD_SIZE
+             || !string_ascii_p (st->uname)))
+       xheader_store ("uname", st, NULL);
+      UNAME_TO_CHARS (st->uname, header->header.uname);
+
+      if (archive_format == POSIX_FORMAT
+         && (strlen (st->gname) > GNAME_FIELD_SIZE
+             || !string_ascii_p (st->gname)))
+       xheader_store ("gname", st, NULL);
+      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.                            |
-`-------------------------------------------------------------------------*/
-

 void
 void

-finish_header (union block *header)
+simple_finish_header (union block *header)

 {
   size_t i;
   int sum;
 {
   size_t i;
   int sum;


@@ -568,348 +976,358 @@ finish_header (union block *header)
   uintmax_to_chars ((uintmax_t) sum, header->header.chksum, 7);
 
   set_next_block_after (header);
   uintmax_to_chars ((uintmax_t) sum, header->header.chksum, 7);
 
   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
   if (verbose_option
       && header->header.typeflag != GNUTYPE_LONGLINK

-      && header->header.typeflag != GNUTYPE_LONGNAME)
+      && header->header.typeflag != GNUTYPE_LONGNAME
+      && header->header.typeflag != XHDTYPE
+      && header->header.typeflag != XGLTYPE)

     {
       /* These globals are parameters to print_header, sigh.  */
 
       current_header = header;
     {
       /* These globals are parameters to print_header, sigh.  */
 
       current_header = header;

-      /* current_stat is already set up.  */

       current_format = archive_format;
       current_format = archive_format;

-      print_header ();
+      print_header (st, block_ordinal);

     }
     }

+
+  header = write_extended (false, st, header);
+  simple_finish_header (header);

 }
 \f
 }
 \f

-/* Sparse file processing.  */

 
 

-/*-------------------------------------------------------------------------.
-| Takes a blockful of data and basically cruises through it to see if it's |
-| made *entirely* of zeros, returning a 0 the instant it finds something   |
-| that is a nonzero, i.e., useful data.                                           |
-`-------------------------------------------------------------------------*/
-
-static int
-zero_block_p (char *buffer)
-{
-  int counter;
-
-  for (counter = 0; counter < BLOCKSIZE; counter++)
-    if (buffer[counter] != '\0')
-      return 0;
-  return 1;
-}
-
-/*---.
-| ?  |
-`---*/
-
-static void
-init_sparsearray (void)
+void
+pad_archive (off_t size_left)

 {
 {

-  int counter;
-
-  sp_array_size = 10;
-
-  /* Make room for our scratch space -- initially is 10 elts long.  */
-
-  sparsearray = xmalloc (sp_array_size * sizeof (struct sp_array));
-  for (counter = 0; counter < sp_array_size; counter++)
+  union block *blk;
+  while (size_left > 0)

     {
     {

-      sparsearray[counter].offset = 0;
-      sparsearray[counter].numbytes = 0;
+      mv_size_left (size_left);
+      blk = find_next_block ();
+      memset (blk->buffer, 0, BLOCKSIZE);
+      set_next_block_after (blk);
+      size_left -= BLOCKSIZE;

     }
 }
 
     }
 }
 

-/*---.
-| ?  |
-`---*/
-
-static void
-find_new_file_size (off_t *filesize, int highest_index)
+static enum dump_status
+dump_regular_file (int fd, struct tar_stat_info *st)

 {
 {

-  int counter;
-
-  *filesize = 0;
-  for (counter = 0;
-       sparsearray[counter].numbytes && counter <= highest_index;
-       counter++)
-    *filesize += sparsearray[counter].numbytes;
-}
-
-/*-----------------------------------------------------------------------.
-| Make one pass over the file NAME, studying where any non-zero data is, |
-| that is, how far into the file each instance of data is, and how many  |
-| bytes are there.  Save this information in the sparsearray, which will |
-| later be translated into header information.                           |
-`-----------------------------------------------------------------------*/
+  off_t size_left = st->stat.st_size;
+  off_t block_ordinal;
+  union block *blk;

 
 

-/* There is little point in trimming small amounts of null data at the head
-   and tail of blocks, only avoid dumping full null blocks.  */
+  block_ordinal = current_block_ordinal ();
+  blk = start_header (st);
+  if (!blk)
+    return dump_status_fail;

 
 

-/* FIXME: this routine might accept bits of algorithmic cleanup, it is
-   too kludgey for my taste...  */
+  /* Mark contiguous files, if we support them.  */
+  if (archive_format != V7_FORMAT && S_ISCTG (st->stat.st_mode))
+    blk->header.typeflag = CONTTYPE;

 
 

-static int
-deal_with_sparse (char *name, union block *header)
-{
-  size_t numbytes = 0;
-  off_t offset = 0;
-  int file;
-  int sparse_index = 0;
-  ssize_t count;
-  char buffer[BLOCKSIZE];
+  finish_header (st, blk, block_ordinal);

 
 

-  if (archive_format == OLDGNU_FORMAT)
-    header->oldgnu_header.isextended = 0;
+  mv_begin (st);
+  while (size_left > 0)
+    {
+      size_t bufsize, count;
+      
+      mv_size_left (size_left);

 
 

-  if (file = open (name, O_RDONLY), file < 0)
-    /* This problem will be caught later on, so just return.  */
-    return 0;
+      blk = find_next_block ();

 
 

-  init_sparsearray ();
-  clear_buffer (buffer);
+      bufsize = available_space_after (blk);

 
 

-  while (count = safe_read (file, buffer, sizeof buffer), count != 0)
-    {
-      /* Realloc the scratch area as necessary.  FIXME: should reallocate
-        only at beginning of a new instance of non-zero data.  */
-
-      if (sparse_index > sp_array_size - 1)
+      if (size_left < bufsize)

        {
        {

-         sparsearray =
-           xrealloc (sparsearray,
-                     2 * sp_array_size * sizeof (struct sp_array));
-         sp_array_size *= 2;
+         /* Last read -- zero out area beyond.  */
+         bufsize = size_left;
+         count = bufsize % BLOCKSIZE;
+         if (count)
+           memset (blk->buffer + size_left, 0, BLOCKSIZE - count);

        }
 
        }
 

-      /* Process one block.  */
-
-      if (count == sizeof buffer)
-
-       if (zero_block_p (buffer))
-         {
-           if (numbytes)
-             {
-               sparsearray[sparse_index++].numbytes = numbytes;
-               numbytes = 0;
-             }
-         }
-       else
-         {
-           if (!numbytes)
-             sparsearray[sparse_index].offset = offset;
-           numbytes += count;
-         }
-
-      else
-
-       /* Since count < sizeof buffer, we have the last bit of the file.  */
-
-       if (!zero_block_p (buffer))
-         {
-           if (!numbytes)
-             sparsearray[sparse_index].offset = offset;
-           numbytes += count;
-         }
-       else
-         /* The next two lines are suggested by Andreas Degert, who says
-            they are required for trailing full blocks to be written to the
-            archive, when all zeroed.  Yet, it seems to me that the case
-            does not apply.  Further, at restore time, the file is not as
-            sparse as it should.  So, some serious cleanup is *also* needed
-            in this area.  Just one more... :-(.  FIXME.  */
-         if (numbytes)
-           numbytes += count;
-
-      /* Prepare for next block.  */
-
-      offset += count;
-      /* FIXME: do not clear unless necessary.  */
-      clear_buffer (buffer);
-    }
+      count = (fd < 0) ? bufsize : safe_read (fd, blk->buffer, bufsize);
+      if (count == SAFE_READ_ERROR)
+       {
+         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;
+      set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);

 
 

-  if (numbytes)
-    sparsearray[sparse_index++].numbytes = numbytes;
-  else
-    {
-      sparsearray[sparse_index].offset = offset - 1;
-      sparsearray[sparse_index++].numbytes = 1;
+      if (count != bufsize)
+       {
+         char buf[UINTMAX_STRSIZE_BOUND];
+         memset (blk->buffer + count, 0, bufsize - count);
+         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) 
+           exit_status = TAREXIT_DIFFERS;
+         pad_archive (size_left - (bufsize - count));
+         return dump_status_short;
+       }

     }
     }

-
-  close (file);
-  return sparse_index - 1;
+  return dump_status_ok;

 }
 
 }
 

-/*---.
-| ?  |
-`---*/
-
-static int
-finish_sparse_file (int file, off_t *sizeleft, off_t fullsize, char *name)
+\f
+static void
+dump_dir0 (char *directory,
+          struct tar_stat_info *st, int top_level, dev_t parent_device)

 {
 {

-  union block *start;
-  size_t bufsize;
-  int sparse_index = 0;
-  ssize_t count;
-
-  while (*sizeleft > 0)
+  dev_t our_device = st->stat.st_dev;
+  const char *tag_file_name;
+  
+  if (!is_avoided_name (st->orig_file_name))

     {
     {

-      start = find_next_block ();
-      memset (start->buffer, 0, BLOCKSIZE);
-      bufsize = sparsearray[sparse_index].numbytes;
-      if (!bufsize)
-       {
-         /* We blew it, maybe.  */
-         char buf1[UINTMAX_STRSIZE_BOUND];
-         char buf2[UINTMAX_STRSIZE_BOUND];
-
-         ERROR ((0, 0, _("Wrote %s of %s bytes to file %s"),
-                 STRINGIFY_BIGINT (fullsize - *sizeleft, buf1),
-                 STRINGIFY_BIGINT (fullsize, buf2),
-                 name));
-         break;
-       }
+      union block *blk = NULL;
+      off_t block_ordinal = current_block_ordinal ();
+      st->stat.st_size = 0;    /* force 0 size on dir */

 
 

-      if (lseek (file, sparsearray[sparse_index++].offset, SEEK_SET) < 0)
-       {
-         char buf[UINTMAX_STRSIZE_BOUND];
-         ERROR ((0, errno, _("lseek error at byte %s in file %s"),
-                 STRINGIFY_BIGINT (sparsearray[sparse_index - 1].offset, buf),
-                 name));
-         break;
-       }
+      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 the number of bytes to be written here exceeds the size of
-        the temporary buffer, do it in steps.  */
+      /* If we're gnudumping, we aren't done yet so don't close it.  */

 
 

-      while (bufsize > BLOCKSIZE)
+      if (!incremental_option)
+       finish_header (st, blk, block_ordinal);
+      else if (gnu_list_name->dir_contents)

        {
        {

-#if 0
-         if (amount_read)
+         if (archive_format == POSIX_FORMAT)

            {
            {

-             count = safe_read (file, start->buffer + amount_read,
-                                BLOCKSIZE - amount_read);
-             bufsize -= BLOCKSIZE - amount_read;
-             amount_read = 0;
-             set_next_block_after (start);
-             start = find_next_block ();
-             memset (start->buffer, 0, BLOCKSIZE);
+             xheader_store ("GNU.dumpdir", st, gnu_list_name->dir_contents);
+             finish_header (st, blk, block_ordinal);

            }
            }

-#endif
-         /* Store the data.  */
-
-         count = safe_read (file, start->buffer, BLOCKSIZE);
-         if (count < 0)
+         else

            {
            {

-             char buf[UINTMAX_STRSIZE_BOUND];
-             ERROR ((0, errno,
-                     _("Read error at byte %s, reading %lu bytes, in file %s"),
-                     STRINGIFY_BIGINT (fullsize - *sizeleft, buf),
-                     (unsigned long) bufsize, name));
-             return 1;
+             off_t size_left;
+             off_t totsize;
+             size_t bufsize;
+             ssize_t count;
+             const char *buffer, *p_buffer;
+
+             block_ordinal = current_block_ordinal ();
+             buffer = gnu_list_name->dir_contents;
+             if (buffer)
+               totsize = dumpdir_size (buffer);
+             else
+               totsize = 0;
+             OFF_TO_CHARS (totsize, blk->header.size);
+             finish_header (st, blk, block_ordinal);
+             p_buffer = buffer;
+             size_left = totsize;
+
+             mv_begin (st);
+             mv_total_size (totsize);
+             while (size_left > 0)
+               {
+                 mv_size_left (size_left);
+                 blk = find_next_block ();
+                 bufsize = available_space_after (blk);
+                 if (size_left < bufsize)
+                   {
+                     bufsize = size_left;
+                     count = bufsize % BLOCKSIZE;
+                     if (count)
+                       memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
+                   }
+                 memcpy (blk->buffer, p_buffer, bufsize);
+                 size_left -= bufsize;
+                 p_buffer += bufsize;
+                 set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
+               }
+             mv_end ();

            }
            }

-         bufsize -= count;
-         *sizeleft -= count;
-         set_next_block_after (start);
-         start = find_next_block ();
-         memset (start->buffer, 0, BLOCKSIZE);
+         return;

        }
        }

+    }

 
 

-      {
-       char buffer[BLOCKSIZE];
-
-       clear_buffer (buffer);
-       count = safe_read (file, buffer, bufsize);
-       memcpy (start->buffer, buffer, BLOCKSIZE);
-      }
+  if (!recursion_option)
+    return;

 
 

-      if (count < 0)
+  if (one_file_system_option
+      && !top_level
+      && parent_device != st->stat.st_dev)
+    {
+      if (verbose_option)
+       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;
+      
+      switch (check_exclusion_tags (st->orig_file_name, &tag_file_name))

        {
        {

-         char buf[UINTMAX_STRSIZE_BOUND];
+       case exclusion_tag_all:
+         /* Handled in dump_file0 */
+         break;

          
          

-         ERROR ((0, errno,
-                 _("Read error at byte %s, reading %lu bytes, in file %s"),
-                 STRINGIFY_BIGINT (fullsize - *sizeleft, buf),
-                 (unsigned long) bufsize, name));
-         return 1;
-       }
-#if 0
-      if (amount_read >= BLOCKSIZE)
-       {
-         amount_read = 0;
-         set_next_block_after (start + (count - 1) / BLOCKSIZE);
-         if (count != bufsize)
-           {
-             ERROR ((0, 0,
-                     _("File %s shrunk, padding with zeros"),
-                     name));
-             return 1;
-           }
-         start = find_next_block ();
+       case exclusion_tag_none:
+         {
+           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.  */
+           /* 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)
+                 {
+                   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 (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 (name_buf, 0, our_device);
+         free (name_buf);
+         break;
+      
+       case exclusion_tag_under:
+         exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                _("contents not dumped"));
+         break;

        }
        }

-      else
-       amount_read += bufsize;
-#endif
-      *sizeleft -= count;
-      set_next_block_after (start);
+    }
+}
+
+/* Ensure exactly one trailing slash.  */
+static void
+ensure_slash (char **pstr)
+{
+  size_t len = strlen (*pstr);
+  while (len >= 1 && ISSLASH ((*pstr)[len - 1]))
+    len--;
+  if (!ISSLASH ((*pstr)[len]))
+    *pstr = xrealloc (*pstr, len + 2);
+  (*pstr)[len++] = '/';
+  (*pstr)[len] = '\0';
+}

 
 

+static bool
+dump_dir (int fd, struct tar_stat_info *st, int top_level, dev_t parent_device)
+{
+  char *directory = fdsavedir (fd);
+  if (!directory)
+    {
+      savedir_diag (st->orig_file_name);
+      return false;

     }
     }

-  free (sparsearray);
-#if 0
-  set_next_block_after (start + (count - 1) / BLOCKSIZE);
-#endif
-  return 0;
+
+  dump_dir0 (directory, st, top_level, parent_device);
+
+  free (directory);
+  return true;

 }
 }

+

 \f
 /* Main functions of this module.  */
 
 \f
 /* Main functions of this module.  */
 

-/*---.
-| ?  |
-`---*/
-

 void
 create_archive (void)
 {
 void
 create_archive (void)
 {

-  char *p;
+  const char *p;

 
   open_archive (ACCESS_WRITE);
 
   open_archive (ACCESS_WRITE);

+  buffer_write_global_xheader ();

 
   if (incremental_option)
     {
 
   if (incremental_option)
     {

-      char *buffer = xmalloc (PATH_MAX);
+      size_t buffer_size = 1000;
+      char *buffer = xmalloc (buffer_size);

       const char *q;
       const char *q;

-      char *bufp;

 
       collect_and_sort_names ();
 
 
       collect_and_sort_names ();
 

-      while (p = name_from_list (), p)
+      while ((p = name_from_list ()) != NULL)

        if (!excluded_name (p))
          dump_file (p, -1, (dev_t) 0);
 
       blank_name_list ();
        if (!excluded_name (p))
          dump_file (p, -1, (dev_t) 0);
 
       blank_name_list ();

-      while (p = name_from_list (), p)
+      while ((p = name_from_list ()) != NULL)

        if (!excluded_name (p))
          {
        if (!excluded_name (p))
          {

-           strcpy (buffer, p);
-           if (p[strlen (p) - 1] != '/')
-             strcat (buffer, "/");
-           bufp = buffer + strlen (buffer);
+           size_t plen = strlen (p);
+           if (buffer_size <= plen)
+             {
+               while ((buffer_size *= 2) <= plen)
+                 continue;
+               buffer = xrealloc (buffer, buffer_size);
+             }
+           memcpy (buffer, p, plen);
+           if (! ISSLASH (buffer[plen - 1]))
+             buffer[plen++] = DIRECTORY_SEPARATOR;

            q = gnu_list_name->dir_contents;
            if (q)
            q = gnu_list_name->dir_contents;
            if (q)

-             for (; *q; q += strlen (q) + 1)
-               if (*q == 'Y')
-                 {
-                   strcpy (bufp, q + 1);
-                   dump_file (buffer, -1, (dev_t) 0);
-                 }
+             while (*q)
+               {
+                 size_t qlen = strlen (q);
+                 if (*q == 'Y')
+                   {
+                     if (buffer_size < plen + qlen)
+                       {
+                         while ((buffer_size *=2 ) < plen + qlen)
+                           continue;
+                         buffer = xrealloc (buffer, buffer_size);
+                       }
+                     strcpy (buffer + plen, q + 1);
+                     dump_file (buffer, -1, (dev_t) 0);
+                   }
+                 q += qlen + 1;
+               }

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

-      while (p = name_next (1), p)
+      while ((p = name_next (1)) != NULL)

        if (!excluded_name (p))
          dump_file (p, 1, (dev_t) 0);
     }
        if (!excluded_name (p))
          dump_file (p, 1, (dev_t) 0);
     }


@@ -921,47 +1339,187 @@ create_archive (void)
     write_directory_file ();
 }
 
     write_directory_file ();
 }
 

+
+/* Calculate the hash of a link.  */
+static size_t
+hash_link (void const *entry, size_t n_buckets)
+{
+  struct link const *l = entry;
+  uintmax_t num = l->dev ^ l->ino;
+  return num % n_buckets;
+}
+
+/* Compare two links for equality.  */
+static bool
+compare_links (void const *entry1, void const *entry2)
+{
+  struct link const *link1 = entry1;
+  struct link const *link2 = entry2;
+  return ((link1->dev ^ link2->dev) | (link1->ino ^ link2->ino)) == 0;
+}
+
+static void
+unknown_file_error (char const *p)
+{
+  WARNOPT (WARN_FILE_IGNORED,
+          (0, 0, _("%s: Unknown file type; file ignored"),
+           quotearg_colon (p)));
+  if (!ignore_failed_read_option)
+    exit_status = TAREXIT_FAILURE;
+}
+
+\f
+/* Handling of hard links */
+
+/* Table of all non-directories that we've written so far.  Any time
+   we see another, we check the table and avoid dumping the data
+   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.
+   Return true if successful.  */
+static bool
+dump_hard_link (struct tar_stat_info *st)
+{
+  if (link_table && (st->stat.st_nlink > 1 || remove_files_option))
+    {
+      struct link lp;
+      struct link *duplicate;
+      off_t block_ordinal;
+      union block *blk;
+
+      lp.ino = st->stat.st_ino;
+      lp.dev = st->stat.st_dev;
+
+      if ((duplicate = hash_lookup (link_table, &lp)))
+       {
+         /* We found a link.  */
+         char const *link_name = safer_name_suffix (duplicate->name, true,
+                                                    absolute_names_option);
+
+         duplicate->nlink--;
+
+         block_ordinal = current_block_ordinal ();
+         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)
+           return false;
+         tar_copy_str (blk->header.linkname, link_name, NAME_FIELD_SIZE);
+
+         blk->header.typeflag = LNKTYPE;
+         finish_header (st, blk, block_ordinal);
+
+         if (remove_files_option && unlink (st->orig_file_name) != 0)
+           unlink_error (st->orig_file_name);
+
+         return true;
+       }
+    }
+  return false;
+}
+
+static void
+file_count_links (struct tar_stat_info *st)
+{
+  if (hard_dereference_option)
+    return;
+  if (st->stat.st_nlink > 1)
+    {
+      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)))
+            && (duplicate = hash_insert (link_table, lp))))
+       xalloc_die ();
+      
+      if (duplicate != lp)
+       abort ();
+      lp->nlink--;
+    }
+}
+
+/* For each dumped file, check if all its links were dumped. Emit
+   warnings if it is not so. */
+void
+check_links (void)
+{
+  struct link *lp;
+
+  if (!link_table)
+    return;
+
+  for (lp = hash_get_first (link_table); lp;
+       lp = hash_get_next (link_table, lp))
+    {
+      if (lp->nlink)
+       {
+         WARN ((0, 0, _("Missing links to %s."), quote (lp->name)));
+       }
+    }
+}
+
+

 /* 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
 /* 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 an incremental
-   dump where it's irrelevant.  PARENT_DEVICE is the device of P's
-   parent directory; it is examined only if TOP_LEVEL is zero.
-
-   Set global CURRENT_STAT to stat output for this file.  */
+   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. */

 
 /* 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_file (char *p, int top_level, dev_t parent_device)
+static void
+dump_file0 (struct tar_stat_info *st, const char *p,
+           int top_level, dev_t parent_device)

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

-  union block *exhdr;
-  char save_typeflag;
-  struct utimbuf restore_times;
-  off_t restore_size;
-
-  /* FIXME: `header' and `upperbound' might be used uninitialized in this
-     function.  Reported by Bruno Haible.  */
+  off_t original_size;
+  struct timespec original_ctime;
+  struct timespec restore_times[2];
+  off_t block_ordinal = -1;
+  bool is_dir;

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

-  if (deref_stat (dereference_option, p, &current_stat) != 0)
+  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, &st->stat) != 0)

     {
     {

-      WARN ((0, errno, _("Cannot add file %s"), p));
-      if (!ignore_failed_read_option)
-       exit_status = TAREXIT_FAILURE;
+      stat_diag (p);

       return;
     }
       return;
     }

-
-  restore_times.actime = current_stat.st_atime;
-  restore_times.modtime = current_stat.st_mtime;
-  restore_size = current_stat.st_size;
+  st->archive_file_size = original_size = st->stat.st_size;
+  st->atime = restore_times[0] = get_stat_atime (&st->stat);
+  st->mtime = restore_times[1] = get_stat_mtime (&st->stat);
+  st->ctime = original_ctime = get_stat_ctime (&st->stat);

 
 #ifdef S_ISHIDDEN
 
 #ifdef S_ISHIDDEN

-  if (S_ISHIDDEN (current_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)


@@ -974,619 +1532,277 @@ dump_file (char *p, int top_level, dev_t parent_device)
 #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.  */
-
-  if ((0 < top_level || !incremental_option)
-      && !S_ISDIR (current_stat.st_mode)
-      && current_stat.st_mtime < newer_mtime_option
-      && (!after_date_option || current_stat.st_ctime < newer_ctime_option))
+     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 (!(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: is unchanged; not dumped"), 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;
     }
 
       return;
     }
 

-#if !MSDOS

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

-
-  if (ar_dev && current_stat.st_dev == ar_dev && current_stat.st_ino == ar_ino)
+  if (sys_file_is_archive (st))

     {
     {

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

       return;
     }
       return;
     }

-#endif

 
 

-  if (S_ISDIR (current_stat.st_mode))
-    {
-      DIR *directory;
-      struct dirent *entry;
-      char *namebuf;
-      size_t buflen;
-      size_t len;
-      dev_t our_device = current_stat.st_dev;
+  if (is_avoided_name (p))
+    return;

 
 

-      /* If this tar program is installed suid root, like for Amanda, the
-        access might look like denied, while it is not really.
+  is_dir = S_ISDIR (st->stat.st_mode) != 0;

 
 

-        FIXME: I have the feeling this test is done too early.  Couldn't it
-        just be bundled in later actions?  I guess that the proper support
-        of --ignore-failed-read is the key of the current writing.  */
+  if (!is_dir && dump_hard_link (st))
+    return;
+
+  if (is_dir || S_ISREG (st->stat.st_mode) || S_ISCTG (st->stat.st_mode))
+    {
+      bool ok;
+      int fd = -1;
+      struct stat final_stat;

 
 

-      if (access (p, R_OK) == -1 && geteuid () != 0)
+      if (is_dir || file_dumpable_p (st))

        {
        {

-         WARN ((0, errno, _("Cannot add directory %s"), p));
-         if (!ignore_failed_read_option)
-           exit_status = TAREXIT_FAILURE;
-         return;
+         fd = open (p,
+                    (O_RDONLY | O_BINARY
+                     | (is_dir ? O_DIRECTORY | O_NONBLOCK : 0)
+                     | (atime_preserve_option == system_atime_preserve
+                        ? O_NOATIME
+                        : 0)));
+         if (fd < 0)
+           {
+             if (!top_level && errno == ENOENT)
+               WARNOPT (WARN_FILE_REMOVED,
+                        (0, 0, _("%s: File removed before we read it"),
+                         quotearg_colon (p)));
+             else
+               open_diag (p);
+             return;
+           }

        }
 
        }
 

-      /* Build new prototype name.  Ensure exactly one trailing slash.  */
-
-      len = strlen (p);
-      buflen = len + NAME_FIELD_SIZE;
-      namebuf = xmalloc (buflen + 1);
-      strncpy (namebuf, p, buflen);
-      while (len >= 1 && namebuf[len - 1] == '/')
-       len--;
-      namebuf[len++] = '/';
-      namebuf[len] = '\0';
-
-      if (! is_avoided_name (namebuf))
+      if (is_dir)

        {
        {

-         /* The condition above used to be "archive_format != V7_FORMAT".
-            GNU tar was not writing directory blocks at all.  Daniel Trinkle
-            writes: ``All old versions of tar I have ever seen have
-            correctly archived an empty directory.  The really old ones I
-            checked included HP-UX 7 and Mt. Xinu More/BSD.  There may be
-            some subtle reason for the exclusion that I don't know, but the
-            current behavior is broken.''  I do not know those subtle
-            reasons either, so until these are reported (anew?), just allow
-            directory blocks to be written even with old archives.  */
-
-         current_stat.st_size = 0;     /* force 0 size on dir */
-
-         /* FIXME: If people could really read standard archives, this
-            should be:
-
-            header
-              = start_header (standard_option ? p : namebuf, &current_stat);
-
-            but since they'd interpret DIRTYPE blocks as regular
-            files, we'd better put the / on the name.  */
-
-         header = start_header (namebuf, &current_stat);
+         const char *tag_file_name;
+         ensure_slash (&st->orig_file_name);
+         ensure_slash (&st->file_name);

 
 

-         if (incremental_option)
-           header->header.typeflag = GNUTYPE_DUMPDIR;
-         else /* if (standard_option) */
-           header->header.typeflag = DIRTYPE;
-
-         /* If we're gnudumping, we aren't done yet so don't close it.  */
+         if (check_exclusion_tags (st->orig_file_name, &tag_file_name)
+             == exclusion_tag_all)
+           {
+             exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                    _("directory not dumped"));
+             return;
+           }
+         
+         ok = dump_dir (fd, st, top_level, parent_device);

 
 

-         if (!incremental_option)
-           finish_header (header);     /* done with directory header */
+         /* dump_dir consumes FD if successful.  */
+         if (ok)
+           fd = -1;

        }
        }

-
-      if (incremental_option && gnu_list_name->dir_contents)
+      else

        {
        {

-         off_t sizeleft;
-         off_t totsize;
-         size_t bufsize;
-         union block *start;
-         ssize_t count;
-         const char *buffer, *p_buffer;
-
-         buffer = gnu_list_name->dir_contents; /* FOO */
-         totsize = 0;
-         for (p_buffer = buffer; p_buffer && *p_buffer;)
-           {
-             size_t tmp;
+         enum dump_status status;

 
 

-             tmp = strlen (p_buffer) + 1;
-             totsize += tmp;
-             p_buffer += tmp;
-           }
-         totsize++;
-         OFF_TO_CHARS (totsize, header->header.size);
-         finish_header (header);
-         p_buffer = buffer;
-         sizeleft = totsize;
-         while (sizeleft > 0)
+         if (fd != -1 && sparse_option && ST_IS_SPARSE (st->stat))

            {
            {

-             if (multi_volume_option)
-               {
-                 assign_string (&save_name, p);
-                 save_sizeleft = sizeleft;
-                 save_totsize = totsize;
-               }
-             start = find_next_block ();
-             bufsize = available_space_after (start);
-             if (sizeleft < bufsize)
-               {
-                 bufsize = sizeleft;
-                 count = bufsize % BLOCKSIZE;
-                 if (count)
-                   memset (start->buffer + sizeleft, 0, BLOCKSIZE - count);
-               }
-             memcpy (start->buffer, p_buffer, bufsize);
-             sizeleft -= bufsize;
-             p_buffer += bufsize;
-             set_next_block_after (start + (bufsize - 1) / BLOCKSIZE);
+             status = sparse_dump_file (fd, st);
+             if (status == dump_status_not_implemented)
+               status = dump_regular_file (fd, st);

            }
            }

-         if (multi_volume_option)
-           assign_string (&save_name, 0);
-         if (atime_preserve_option)
-           utime (p, &restore_times);
-         return;
-       }
+         else
+           status = dump_regular_file (fd, st);

 
 

-      /* See if we are about to recurse into a directory, and avoid doing
-        so if the user wants that we do not descend into directories.  */
+         switch (status)
+           {
+           case dump_status_ok:
+           case dump_status_short:
+             mv_end ();
+             file_count_links (st);
+             break;

 
 

-      if (no_recurse_option)
-       return;
+           case dump_status_fail:
+             break;

 
 

-      /* See if we are crossing from one file system to another, and
-        avoid doing so if the user only wants to dump one file system.  */
+           case dump_status_not_implemented:
+             abort ();
+           }

 
 

-      if (one_file_system_option && !top_level
-         && parent_device != current_stat.st_dev)
-       {
-         if (verbose_option)
-           WARN ((0, 0, _("%s: On a different filesystem; not dumped"), p));
-         return;
+         ok = status == dump_status_ok;

        }
 
        }
 

-      /* Now output all the files in the directory.  */
-
-      errno = 0;               /* FIXME: errno should be read-only */
-
-      directory = opendir (p);
-      if (!directory)
+      if (ok)

        {
        {

-         ERROR ((0, errno, _("Cannot open directory %s"), p));
-         return;
+         /* If possible, reopen a directory if we are preserving
+            atimes, so that we can set just the atime on systems with
+            _FIOSATIME.  */
+         if (fd < 0 && is_dir
+             && atime_preserve_option == replace_atime_preserve)
+           fd = open (p, O_RDONLY | O_BINARY | O_DIRECTORY | O_NONBLOCK);
+
+         if ((fd < 0
+              ? deref_stat (dereference_option, p, &final_stat)
+              : fstat (fd, &final_stat))
+             != 0)
+           {
+             stat_diag (p);
+             ok = false;
+           }

        }
 
        }
 

-      /* FIXME: Should speed this up by cd-ing into the dir.  */
-
-      while (entry = readdir (directory), entry)
+      if (ok)

        {
        {

-         /* Skip `.', `..', and excluded file names.  */
-
-         if (is_dot_or_dotdot (entry->d_name))
-           continue;
-
-         if ((int) NAMLEN (entry) + len >= buflen)
+         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)

            {
            {

-             buflen = len + NAMLEN (entry);
-             namebuf = xrealloc (namebuf, buflen + 1);
+             WARNOPT (WARN_FILE_CHANGED,
+                      (0, 0, _("%s: file changed as we read it"),
+                       quotearg_colon (p)));
+             if (exit_status == TAREXIT_SUCCESS)
+               exit_status = TAREXIT_DIFFERS;

            }
            }

-         strcpy (namebuf + len, entry->d_name);
-         if (!excluded_name (namebuf))
-           dump_file (namebuf, 0, our_device);
+         else if (atime_preserve_option == replace_atime_preserve
+                  && set_file_atime (fd, p, restore_times) != 0)
+           utime_error (p);

        }
 
        }
 

-      closedir (directory);
-      free (namebuf);
-      if (atime_preserve_option)
-       utime (p, &restore_times);
-      return;
-    }
-  else if (is_avoided_name (p))
-    return;
-  else
-    {
-      /* Check for multiple links.
-
-        We maintain a list of all such files that we've written so far.  Any
-        time we see another, we check the list and avoid dumping the data
-        again if we've done it once already.  */
-
-      if (1 < current_stat.st_nlink)
+      if (0 <= fd && close (fd) != 0)

        {
        {

-         struct link *lp;
-
-         /* FIXME: First quick and dirty.  Hashing, etc later.  */
-
-         for (lp = linklist; lp; lp = lp->next)
-           if (lp->ino == current_stat.st_ino
-               && lp->dev == current_stat.st_dev)
-             {
-               char *link_name = lp->name;
-
-               /* We found a link.  */
-
-               while (!absolute_names_option && *link_name == '/')
-                 {
-                   static int warned_once;
-                   if (!warned_once)
-                     {
-                       warned_once = 1;
-                       WARN ((0, 0,
-                              _("Removing leading `/' from link names")));
-                     }
-                   link_name++;
-                 }
-               if (strlen (link_name) >= NAME_FIELD_SIZE)
-                 write_long (link_name, GNUTYPE_LONGLINK);
-               assign_string (&current_link_name, link_name);
-
-               current_stat.st_size = 0;
-               header = start_header (p, &current_stat);
-               strncpy (header->header.linkname,
-                        link_name, NAME_FIELD_SIZE);
-
-               /* Force null truncated.  */
-
-               header->header.linkname[NAME_FIELD_SIZE - 1] = 0;
-
-               header->header.typeflag = LNKTYPE;
-               finish_header (header);
-
-               /* FIXME: Maybe remove from list after all links found?  */
-
-               if (remove_files_option)
-                 if (unlink (p) == -1)
-                   ERROR ((0, errno, _("Cannot remove %s"), p));
-
-               /* We dumped it.  */
-               return;
-             }
-
-         /* Not found.  Add it to the list of possible links.  */
-
-         lp = xmalloc (sizeof (struct link) + strlen (p));
-         lp->ino = current_stat.st_ino;
-         lp->dev = current_stat.st_dev;
-         strcpy (lp->name, p);
-         lp->next = linklist;
-         linklist = lp;
+         close_diag (p);
+         ok = false;

        }
 
        }
 

-      /* This is not a link to a previously dumped file, so dump it.  */
-
-      if (S_ISREG (current_stat.st_mode)
-         || S_ISCTG (current_stat.st_mode))
+      if (ok && remove_files_option)

        {
        {

-         int f;                        /* file descriptor */
-         size_t bufsize;
-         ssize_t count;
-         off_t sizeleft;
-         union block *start;
-         int header_moved;
-         char isextended = 0;
-         int upperbound;
-
-         header_moved = 0;
-
-         if (sparse_option)
+         if (is_dir)

            {
            {

-             /* Check the size of the file against the number of blocks
-                allocated for it, counting both data and indirect blocks.
-                If there is a smaller number of blocks that would be
-                necessary to accommodate a file of this size, this is safe
-                to say that we have a sparse file: at least one of those
-                blocks in the file is just a useless hole.  For sparse
-                files not having more hole blocks than indirect blocks, the
-                sparseness will go undetected.  */
-
-             /* Bruno Haible sent me these statistics for Linux.  It seems
-                that some filesystems count indirect blocks in st_blocks,
-                while others do not seem to:
-
-                minix-fs   tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
-                extfs      tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
-                ext2fs     tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
-                msdos-fs   tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
-
-                Dick Streefland reports the previous numbers as misleading,
-                because ext2fs use 12 direct blocks, while minix-fs uses only
-                6 direct blocks.  Dick gets:
-
-                ext2   size=20480      ls listed blocks=21
-                minix  size=20480      ls listed blocks=21
-                msdos  size=20480      ls listed blocks=20
-
-                It seems that indirect blocks *are* included in st_blocks.
-                The minix filesystem does not account for phantom blocks in
-                st_blocks, so `du' and `ls -s' give wrong results.  So, the
-                --sparse option would not work on a minix filesystem.  */
-
-             if (ST_NBLOCKS (current_stat)
-                 < (current_stat.st_size / ST_NBLOCKSIZE
-                    + (current_stat.st_size % ST_NBLOCKSIZE != 0)))
-               {
-                 off_t filesize = current_stat.st_size;
-                 int counter;
-
-                 header = start_header (p, &current_stat);
-                 header->header.typeflag = GNUTYPE_SPARSE;
-                 header_moved = 1;
-
-                 /* Call the routine that figures out the layout of the
-                    sparse file in question.  UPPERBOUND is the index of the
-                    last element of the "sparsearray," i.e., the number of
-                    elements it needed to describe the file.  */
-
-                 upperbound = deal_with_sparse (p, header);
-
-                 /* See if we'll need an extended header later.  */
-
-                 if (upperbound > SPARSES_IN_OLDGNU_HEADER - 1)
-                   header->oldgnu_header.isextended = 1;
-
-                 /* We store the "real" file size so we can show that in
-                    case someone wants to list the archive, i.e., tar tvf
-                    <file>.  It might be kind of disconcerting if the
-                    shrunken file size was the one that showed up.  */
-
-                 OFF_TO_CHARS (current_stat.st_size,
-                               header->oldgnu_header.realsize);
-
-                 /* This will be the new "size" of the file, i.e., the size
-                    of the file minus the blocks of holes that we're
-                    skipping over.  */
-
-                 find_new_file_size (&filesize, upperbound);
-                 current_stat.st_size = filesize;
-                 OFF_TO_CHARS (filesize, header->header.size);
-
-                 for (counter = 0; counter < SPARSES_IN_OLDGNU_HEADER; counter++)
-                   {
-                     if (!sparsearray[counter].numbytes)
-                       break;
-
-                     OFF_TO_CHARS (sparsearray[counter].offset,
-                                   header->oldgnu_header.sp[counter].offset);
-                     SIZE_TO_CHARS (sparsearray[counter].numbytes,
-                                    header->oldgnu_header.sp[counter].numbytes);
-                   }
-
-               }
+             if (rmdir (p) != 0 && errno != ENOTEMPTY)
+               rmdir_error (p);

            }
          else
            }
          else

-           upperbound = SPARSES_IN_OLDGNU_HEADER - 1;
-
-         sizeleft = current_stat.st_size;
-
-         /* Don't bother opening empty, world readable files.  Also do not open
-            files when archive is meant for /dev/null.  */
-
-         if (dev_null_output
-             || (sizeleft == 0
-                 && MODE_R == (MODE_R & current_stat.st_mode)))
-           f = -1;
-         else
-           {
-             f = open (p, O_RDONLY | O_BINARY);
-             if (f < 0)
-               {
-                 WARN ((0, errno, _("Cannot add file %s"), p));
-                 if (!ignore_failed_read_option)
-                   exit_status = TAREXIT_FAILURE;
-                 return;
-               }
-           }
-
-         /* If the file is sparse, we've already taken care of this.  */
-
-         if (!header_moved)
-           header = start_header (p, &current_stat);
-
-         /* Mark contiguous files, if we support them.  */
-
-         if (archive_format != V7_FORMAT && S_ISCTG (current_stat.st_mode))
-           header->header.typeflag = CONTTYPE;
-
-         isextended = header->oldgnu_header.isextended;
-         save_typeflag = header->header.typeflag;
-         finish_header (header);
-         if (isextended)
-           {
-             int counter;
-             /* static */ int index_offset = SPARSES_IN_OLDGNU_HEADER;
-
-           extend:
-             exhdr = find_next_block ();
-             memset (exhdr->buffer, 0, BLOCKSIZE);
-             for (counter = 0; counter < SPARSES_IN_SPARSE_HEADER; counter++)
-               {
-                 if (counter + index_offset > upperbound)
-                   break;
-
-                 SIZE_TO_CHARS (sparsearray[counter + index_offset].numbytes,
-                                exhdr->sparse_header.sp[counter].numbytes);
-                 OFF_TO_CHARS (sparsearray[counter + index_offset].offset,
-                               exhdr->sparse_header.sp[counter].offset);
-               }
-             set_next_block_after (exhdr);
-             if (index_offset + counter <= upperbound)
-               {
-                 index_offset += counter;
-                 exhdr->sparse_header.isextended = 1;
-                 goto extend;
-               }
-
-           }
-         if (save_typeflag == GNUTYPE_SPARSE)
-           {
-             if (f < 0
-                 || finish_sparse_file (f, &sizeleft, current_stat.st_size, p))
-               goto padit;
-           }
-         else
-           while (sizeleft > 0)
-             {
-               if (multi_volume_option)
-                 {
-                   assign_string (&save_name, p);
-                   save_sizeleft = sizeleft;
-                   save_totsize = current_stat.st_size;
-                 }
-               start = find_next_block ();
-
-               bufsize = available_space_after (start);
-
-               if (sizeleft < bufsize)
-                 {
-                   /* Last read -- zero out area beyond.  */
-
-                   bufsize = sizeleft;
-                   count = bufsize % BLOCKSIZE;
-                   if (count)
-                     memset (start->buffer + sizeleft, 0, BLOCKSIZE - count);
-                 }
-               if (f < 0)
-                 count = bufsize;
-               else
-                 count = safe_read (f, start->buffer, bufsize);
-               if (count < 0)
-                 {
-                   char buf[UINTMAX_STRSIZE_BOUND];
-                   ERROR ((0, errno,
-                           _("Read error at byte %s, reading %lu bytes, in file %s"),
-                           STRINGIFY_BIGINT (current_stat.st_size - sizeleft,
-                                             buf),
-                           (unsigned long) bufsize, p));
-                   goto padit;
-                 }
-               sizeleft -= count;
-
-               /* This is nonportable (the type of set_next_block_after's arg).  */
-
-               set_next_block_after (start + (count - 1) / BLOCKSIZE);
-
-               if (count == bufsize)
-                 continue;
-               else
-                 {
-                   char buf[UINTMAX_STRSIZE_BOUND];
-                   ERROR ((0, 0,
-                           _("File %s shrunk by %s bytes, padding with zeros"),
-                           p, STRINGIFY_BIGINT (sizeleft, buf)));
-                   goto padit;         /* short read */
-                 }
-             }
-
-         if (multi_volume_option)
-           assign_string (&save_name, 0);
-
-         if (f >= 0)

            {
            {

-             struct stat final_stat;
-             if (fstat (f, &final_stat) != 0)
-               ERROR ((0, errno, "%s: fstat", p));
-             else if (final_stat.st_mtime != restore_times.modtime
-                      || final_stat.st_size != restore_size)
-               ERROR ((0, errno, _("%s: file changed as we read it"), p));
-             if (close (f) != 0)
-               ERROR ((0, errno, _("%s: close"), p));
-             if (atime_preserve_option)
-               utime (p, &restore_times);
+             if (unlink (p) != 0)
+               unlink_error (p);

            }
            }

-         if (remove_files_option)
-           {
-             if (unlink (p) == -1)
-               ERROR ((0, errno, _("Cannot remove %s"), p));
-           }
-         return;
-
-         /* File shrunk or gave error, pad out tape to match the size we
-            specified in the header.  */
-
-       padit:
-         while (sizeleft > 0)
-           {
-             save_sizeleft = sizeleft;
-             start = find_next_block ();
-             memset (start->buffer, 0, BLOCKSIZE);
-             set_next_block_after (start);
-             sizeleft -= BLOCKSIZE;
-           }
-         if (multi_volume_option)
-           assign_string (&save_name, 0);
-         if (f >= 0)
-           {
-             close (f);
-             if (atime_preserve_option)
-               utime (p, &restore_times);
-           }
-         return;

        }
        }

+
+      return;
+    }

 #ifdef HAVE_READLINK
 #ifdef HAVE_READLINK

-      else if (S_ISLNK (current_stat.st_mode))
+  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 = readlink (p, buffer, linklen + 1);
+      if (size < 0)

        {
        {

-         int size;
-         char *buffer = (char *) alloca (PATH_MAX + 1);
-
-         size = readlink (p, buffer, PATH_MAX + 1);
-         if (size < 0)
-           {
-             WARN ((0, errno, _("Cannot add file %s"), p));
-             if (!ignore_failed_read_option)
-               exit_status = TAREXIT_FAILURE;
-             return;
-           }
-         buffer[size] = '\0';
-         if (size >= NAME_FIELD_SIZE)
-           write_long (buffer, GNUTYPE_LONGLINK);
-         assign_string (&current_link_name, buffer);
-
-         current_stat.st_size = 0;     /* force 0 size on symlink */
-         header = start_header (p, &current_stat);
-         strncpy (header->header.linkname, buffer, NAME_FIELD_SIZE);
-         header->header.linkname[NAME_FIELD_SIZE - 1] = '\0';
-         header->header.typeflag = SYMTYPE;
-         finish_header (header);       /* nothing more to do to it */
-         if (remove_files_option)
-           {
-             if (unlink (p) == -1)
-               ERROR ((0, errno, _("Cannot remove %s"), p));
-           }
+         readlink_diag (p);

          return;
        }
          return;
        }

-#endif
-      else if (S_ISCHR (current_stat.st_mode))
-       type = CHRTYPE;
-      else if (S_ISBLK (current_stat.st_mode))
-       type = BLKTYPE;
-      else if (S_ISFIFO (current_stat.st_mode)
-              || S_ISSOCK (current_stat.st_mode))
-       type = FIFOTYPE;
-#ifdef S_ISDOOR
-      else if (S_ISDOOR (current_stat.st_mode))
+      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)

        {
        {

-         WARN ((0, 0, _("%s: door ignored"), p));
-         return;
+         if (unlink (p) == -1)
+           unlink_error (p);

        }
        }

+      file_count_links (st);
+      return;
+    }

 #endif
 #endif

-      else
-       goto unknown;
+  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)

-    goto unknown;
+    {
+      unknown_file_error (p);
+      return;
+    }

 
 

-  current_stat.st_size = 0;    /* force 0 size */
-  header = start_header (p, &current_stat);
+  block_ordinal = current_block_ordinal ();
+  st->stat.st_size = 0;        /* force 0 size */
+  header = start_header (st);
+  if (!header)
+    return;

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

-      MAJOR_TO_CHARS (major (current_stat.st_rdev), header->header.devmajor);
-      MINOR_TO_CHARS (minor (current_stat.st_rdev), header->header.devminor);
+      MAJOR_TO_CHARS (major (st->stat.st_rdev),
+                     header->header.devmajor);
+      MINOR_TO_CHARS (minor (st->stat.st_rdev),
+                     header->header.devminor);

     }
 
     }
 

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

   if (remove_files_option)
     {
       if (unlink (p) == -1)
   if (remove_files_option)
     {
       if (unlink (p) == -1)

-       ERROR ((0, errno, _("Cannot remove %s"), p));
+       unlink_error (p);

     }
     }

-  return;
+}

 
 

-unknown:
-  ERROR ((0, 0, _("%s: Unknown file type; file ignored"), p));
+void
+dump_file (const char *p, int top_level, dev_t parent_device)
+{
+  struct tar_stat_info st;
+  tar_stat_init (&st);
+  dump_file0 (&st, p, top_level, parent_device);
+  if (listed_incremental_option)
+    update_parent_directory (p);
+  tar_stat_destroy (&st);

 }
 }