Add SELinux context store/restore/list support.

[chaz/tar] / src / create.c
diff --git a/src/create.c b/src/create.c

index 114688fd79d31a73824ee5b984877d72557cf0fb..36ca30ec6a31487d22ba0fe67fd1399e48ae17a3 100644 (file)
--- a/src/create.c
+++ b/src/create.c
@@ -1,10 +1,14 @@
  /* Create a tar archive.
  /* Create a tar archive.
-   Copyright (C) 1985, 92, 93, 94, 96, 97 Free Software Foundation, Inc.
+
+   Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
+   2003, 2004, 2005, 2006, 2007, 2009, 2010, 2012
+   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,1420 +18,1952 @@
  
     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 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"
+#include <hash.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.  */
+/* Error number to use when an impostor is discovered.
+   Pretend the impostor isn't there.  */
+enum { IMPOSTOR_ERRNO = ENOENT };
  
  struct link
    {
  
  struct link
    {
-    struct link *next;
      dev_t dev;
      ino_t ino;
      dev_t dev;
      ino_t ino;
-    short linkcount;
+    nlink_t nlink;
      char name[1];
    };
  
      char name[1];
    };
  
-struct link *linklist = NULL;  /* points to first link in list */
-\f
+struct exclusion_tag
+{
+  const char *name;
+  size_t length;
+  enum exclusion_tag_type type;
+  bool (*predicate) (int fd);
+  struct exclusion_tag *next;
+};
  
  
-/*------------------------------------------------------------------------.
-| Converts long VALUE into a DIGS-digit field at WHERE, including a       |
-| trailing space and room for a NUL.  For example, 3 for DIGS 3 means one |
-| digit, a space, and room for a NUL.                                     |
-|                                                                         |
-| We assume the trailing NUL is already there and don't fill it in.  This |
-| fact is used by start_header and finish_header, so don't change it!     |
-`------------------------------------------------------------------------*/
+static struct exclusion_tag *exclusion_tags;
  
  
-/* This should be equivalent to: sprintf (WHERE, "%*lo ", DIGS - 2, VALUE);
-   except that sprintf fills in the trailing NUL and we don't.  */
+void
+add_exclusion_tag (const char *name, enum exclusion_tag_type type,
+                  bool (*predicate) (int fd))
+{
+  struct exclusion_tag *tag = xmalloc (sizeof tag[0]);
+  tag->next = exclusion_tags;
+  tag->name = name;
+  tag->type = type;
+  tag->predicate = predicate;
+  tag->length = strlen (name);
+  exclusion_tags = tag;
+}
  
  void
  
  void
-to_oct (long value, int digs, char *where)
+exclusion_tag_warning (const char *dirname, const char *tagname,
+                      const char *message)
  {
  {
-  --digs;                      /* Trailing null slot is left alone */
-  where[--digs] = ' ';         /* put in the space, though */
+  if (verbose_option)
+    WARNOPT (WARN_CACHEDIR,
+            (0, 0,
+             _("%s: contains a cache directory tag %s; %s"),
+             quotearg_colon (dirname),
+             quotearg_n (1, tagname),
+             message));
+}
  
  
-  /* Produce the digits -- at least one.  */
+enum exclusion_tag_type
+check_exclusion_tags (struct tar_stat_info const *st, char const **tag_file_name)
+{
+  struct exclusion_tag *tag;
  
  
-  do
+  for (tag = exclusion_tags; tag; tag = tag->next)
      {
      {
-      where[--digs] = '0' + (char) (value & 7);        /* one octal digit */
-      value >>= 3;
+      int tagfd = subfile_open (st, tag->name, open_read_flags);
+      if (0 <= tagfd)
+       {
+         bool satisfied = !tag->predicate || tag->predicate (tagfd);
+         close (tagfd);
+         if (satisfied)
+           {
+             if (tag_file_name)
+               *tag_file_name = tag->name;
+             return tag->type;
+           }
+       }
      }
      }
-  while (digs > 0 && value != 0);
  
  
-  /* Leading spaces, if necessary.  */
-  while (digs > 0)
-    where[--digs] = ' ';
+  return exclusion_tag_none;
  }
  }
-\f
-/* Writing routines.  */
  
  
-/*-----------------------------------------------------------------------.
-| Just zeroes out the buffer so we don't confuse ourselves with leftover |
-| data.                                                                         |
-`-----------------------------------------------------------------------*/
+/* 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. */
  
  
-static void
-clear_buffer (char *buffer)
+#define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55"
+#define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1)
+
+bool
+cachedir_file_p (int fd)
  {
  {
-  memset (buffer, 0, BLOCKSIZE);
+  char tagbuf[CACHEDIR_SIGNATURE_SIZE];
+
+  return
+    (read (fd, tagbuf, CACHEDIR_SIGNATURE_SIZE) == CACHEDIR_SIGNATURE_SIZE
+     && memcmp (tagbuf, CACHEDIR_SIGNATURE, CACHEDIR_SIGNATURE_SIZE) == 0);
  }
  
  }
  
-/*-------------------------------------------------------------------------.
-| Write the EOT block(s).  We actually zero at least one block, through           |
-| the end of the record.  Old tar, as previous versions of GNU tar, writes |
-| garbage after two zeroed blocks.                                        |
-`-------------------------------------------------------------------------*/
+\f
+/* The maximum uintmax_t value that can be represented with DIGITS digits,
+   assuming that each digit is BITS_PER_DIGIT wide.  */
+#define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
+   ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
+    ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
+    : (uintmax_t) -1)
  
  
-void
-write_eot (void)
+/* 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.  */
+
+static void
+to_octal (uintmax_t value, char *where, size_t size)
  {
  {
-  union block *pointer = find_next_block ();
+  uintmax_t v = value;
+  size_t i = size;
  
  
-  if (pointer)
+  do
      {
      {
-      int space = available_space_after (pointer);
-
-      memset (pointer->buffer, 0, (size_t) space);
-      set_next_block_after (pointer);
+      where[--i] = '0' + (v & ((1 << LG_8) - 1));
+      v >>= LG_8;
      }
      }
+  while (i);
  }
  
  }
  
-/*-----------------------------------------------------.
-| Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block.  |
-`-----------------------------------------------------*/
+/* Copy at most LEN bytes from the string SRC to DST.  Terminate with
+   NUL unless SRC is LEN or more bytes long.  */
  
  
-/* FIXME: Cross recursion between start_header and write_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;
+}
  
  
-static union block *start_header PARAMS ((const char *, struct stat *));
+/* Same as tar_copy_str, but always terminate with NUL if using
+   is OLDGNU format */
  
  static void
  
  static void
-write_long (const char *p, char type)
+tar_name_copy_str (char *dst, const char *src, size_t len)
  {
  {
-  int size = strlen (p) + 1;
-  int bufsize;
-  union block *header;
-  struct stat foo;
+  tar_copy_str (dst, src, len);
+  if (archive_format == OLDGNU_FORMAT)
+    dst[len-1] = 0;
+}
  
  
-  memset (&foo, 0, sizeof foo);
-  foo.st_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.
+   The result is undefined if SIZE is 0 or if VALUE is too large to
+   fit.  */
  
  
-  header = start_header ("././@LongLink", &foo);
-  header->header.typeflag = type;
-  finish_header (header);
+static void
+to_base256 (int negative, uintmax_t value, char *where, size_t size)
+{
+  uintmax_t v = value;
+  uintmax_t propagated_sign_bits =
+    ((uintmax_t) - negative << (CHAR_BIT * sizeof v - LG_256));
+  size_t i = size;
  
  
-  header = find_next_block ();
+  do
+    {
+      where[--i] = v & ((1 << LG_256) - 1);
+      v = propagated_sign_bits | (v >> LG_256);
+    }
+  while (i);
+}
  
  
-  bufsize = available_space_after (header);
+#define GID_TO_CHARS(val, where) gid_to_chars (val, where, sizeof (where))
+#define MAJOR_TO_CHARS(val, where) major_to_chars (val, where, sizeof (where))
+#define MINOR_TO_CHARS(val, where) minor_to_chars (val, where, sizeof (where))
+#define MODE_TO_CHARS(val, where) mode_to_chars (val, where, sizeof (where))
+#define UID_TO_CHARS(val, where) uid_to_chars (val, where, sizeof (where))
  
  
-  while (bufsize < size)
+#define UNAME_TO_CHARS(name,buf) string_to_chars (name, buf, sizeof(buf))
+#define GNAME_TO_CHARS(name,buf) string_to_chars (name, buf, sizeof(buf))
+
+static bool
+to_chars (int negative, uintmax_t value, size_t valsize,
+         uintmax_t (*substitute) (int *),
+         char *where, size_t size, const char *type);
+
+static bool
+to_chars_subst (int negative, int gnu_format, uintmax_t value, size_t valsize,
+               uintmax_t (*substitute) (int *),
+               char *where, size_t size, const char *type)
+{
+  uintmax_t maxval = (gnu_format
+                     ? MAX_VAL_WITH_DIGITS (size - 1, LG_256)
+                     : MAX_VAL_WITH_DIGITS (size - 1, LG_8));
+  char valbuf[UINTMAX_STRSIZE_BOUND + 1];
+  char maxbuf[UINTMAX_STRSIZE_BOUND];
+  char minbuf[UINTMAX_STRSIZE_BOUND + 1];
+  char const *minval_string;
+  char const *maxval_string = STRINGIFY_BIGINT (maxval, maxbuf);
+  char const *value_string;
+
+  if (gnu_format)
      {
      {
-      memcpy (header->buffer, p, (size_t) bufsize);
-      p += bufsize;
-      size -= bufsize;
-      set_next_block_after (header + (bufsize - 1) / BLOCKSIZE);
-      header = find_next_block ();
-      bufsize = available_space_after (header);
+      uintmax_t m = maxval + 1 ? maxval + 1 : maxval / 2 + 1;
+      char *p = STRINGIFY_BIGINT (m, minbuf + 1);
+      *--p = '-';
+      minval_string = p;
      }
      }
-  memcpy (header->buffer, p, (size_t) size);
-  memset (header->buffer + size, 0, (size_t) (bufsize - size));
-  set_next_block_after (header + (size - 1) / BLOCKSIZE);
-}
-\f
-/* Header handling.  */
+  else
+    minval_string = "0";
  
  
-/*---------------------------------------------------------------------.
-| Make a header block for the file name whose stat info is st.  Return |
-| header pointer for success, NULL if the name is too long.           |
-`---------------------------------------------------------------------*/
+  if (negative)
+    {
+      char *p = STRINGIFY_BIGINT (- value, valbuf + 1);
+      *--p = '-';
+      value_string = p;
+    }
+  else
+    value_string = STRINGIFY_BIGINT (value, valbuf);
  
  
-static union block *
-start_header (const char *name, struct stat *st)
+  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
+   negative before being cast to uintmax_t; its original bitpattern
+   can be deduced from VALSIZE, its original size before casting.
+   TYPE is the kind of value being output (useful for diagnostics).
+   Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
+   digits), followed by '\0'.  If this won't work, and if GNU or
+   OLDGNU format is allowed, use '\200' followed by base-256, or (if
+   NEGATIVE is nonzero) '\377' followed by two's complement base-256.
+   If neither format works, use SUBSTITUTE (...)  instead.  Pass to
+   SUBSTITUTE the address of an 0-or-1 flag recording whether the
+   substitute value is negative.  */
+
+static bool
+to_chars (int negative, uintmax_t value, size_t valsize,
+         uintmax_t (*substitute) (int *),
+         char *where, size_t size, const char *type)
  {
  {
-  union block *header;
+  int gnu_format = (archive_format == GNU_FORMAT
+                   || archive_format == OLDGNU_FORMAT);
  
  
-  if (!absolute_names_option)
+  /* 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;
+    }
+  else if (gnu_format)
      {
      {
-      static int warned_once = 0;
+      /* Try to cope with the number by using traditional GNU format
+        methods */
  
  
-#if MSDOS
-      if (name[1] == ':')
+      /* Generate the base-256 representation if the number fits.  */
+      if (((negative ? -1 - value : value)
+          <= MAX_VAL_WITH_DIGITS (size - 1, LG_256)))
         {
         {
-         name += 2;
-         if (!warned_once)
-           {
-             warned_once = 1;
-             WARN ((0, 0, _("Removing drive spec from names in the archive")));
-           }
+         where[0] = negative ? -1 : 1 << (LG_256 - 1);
+         to_base256 (negative, value, where + 1, size - 1);
+         return true;
         }
         }
-#endif
  
  
-      while (*name == '/')
+      /* 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)
         {
         {
-         name++;               /* force relative path */
-         if (!warned_once)
+         static int warned_once;
+         if (! warned_once)
             {
               warned_once = 1;
             {
               warned_once = 1;
-             WARN ((0, 0, _("\
-Removing leading `/' from absolute path names in the archive")));
+             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;
         }
         }
+      /* Otherwise fall back to substitution, if possible: */
      }
      }
-
-  /* Check the file name and put it in the block.  */
-
-  if (strlen (name) >= (size_t) NAME_FIELD_SIZE)
-    write_long (name, GNUTYPE_LONGNAME);
-  header = find_next_block ();
-  memset (header->buffer, 0, sizeof (union block));
-
-  assign_string (&current_file_name, name);
-
-  strncpy (header->header.name, name, NAME_FIELD_SIZE);
-  header->header.name[NAME_FIELD_SIZE - 1] = '\0';
-
-  /* Override some stat fields, if requested to do so.  */
-
-  if (owner_option != (uid_t) -1)
-    st->st_uid = owner_option;
-  if (group_option != (gid_t) -1)
-    st->st_gid = group_option;
-  if (mode_option)
-    st->st_mode = ((st->st_mode & S_IFMT)
-                  | mode_adjust (st->st_mode, mode_option));
-
-  /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
-     for a few tars and came up with the following interoperability
-     matrix:
-
-             WRITER
-       1 2 3 4 5 6 7 8 9   READER
-       . . . . . . . . .   1 = SunOS 4.2 tar
-       # . . # # . . # #   2 = NEC SVR4.0.2 tar
-       . . . # # . . # .   3 = Solaris 2.1 tar
-       . . . . . . . . .   4 = GNU tar 1.11.1
-       . . . . . . . . .   5 = HP-UX 8.07 tar
-       . . . . . . . . .   6 = Ultrix 4.1
-       . . . . . . . . .   7 = AIX 3.2
-       . . . . . . . . .   8 = Hitachi HI-UX 1.03
-       . . . . . . . . .   9 = Omron UNIOS-B 4.3BSD 1.60Beta
-
-            . = works
-            # = ``impossible file type''
-
-     The following mask for old archive removes the `#'s in column 4
-     above, thus making GNU tar both a universal donor and a universal
-     acceptor for Paul's test.  */
-
-  if (archive_format == V7_FORMAT)
-    to_oct ((long) st->st_mode & 07777, 8, header->header.mode);
    else
    else
-    to_oct ((long) st->st_mode, 8, header->header.mode);
+    substitute = NULL; /* No substitution for formats, other than GNU */
  
  
-  to_oct ((long) st->st_uid, 8, header->header.uid);
-  to_oct ((long) st->st_gid, 8, header->header.gid);
-  to_oct ((long) st->st_size, 1 + 12, header->header.size);
-  to_oct ((long) st->st_mtime, 1 + 12, header->header.mtime);
-
-  if (incremental_option)
-    if (archive_format == OLDGNU_FORMAT)
-      {
-       to_oct ((long) st->st_atime, 1 + 12, header->oldgnu_header.atime);
-       to_oct ((long) st->st_ctime, 1 + 12, header->oldgnu_header.ctime);
-      }
+  return to_chars_subst (negative, gnu_format, value, valsize, substitute,
+                        where, size, type);
+}
  
  
-  header->header.typeflag = archive_format == V7_FORMAT ? AREGTYPE : REGTYPE;
+static uintmax_t
+gid_substitute (int *negative)
+{
+  gid_t r;
+#ifdef GID_NOBODY
+  r = GID_NOBODY;
+#else
+  static gid_t gid_nobody;
+  if (!gid_nobody && !gname_to_gid ("nobody", &gid_nobody))
+    gid_nobody = -2;
+  r = gid_nobody;
+#endif
+  *negative = r < 0;
+  return r;
+}
  
  
-  switch (archive_format)
-    {
-    case DEFAULT_FORMAT:
-    case V7_FORMAT:
-      break;
+static bool
+gid_to_chars (gid_t v, char *p, size_t s)
+{
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, gid_substitute, p, s, "gid_t");
+}
  
  
-    case OLDGNU_FORMAT:
-      /* Overwrite header->header.magic and header.version in one blow.  */
-      strcpy (header->header.magic, OLDGNU_MAGIC);
-      break;
+static bool
+major_to_chars (major_t v, char *p, size_t s)
+{
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "major_t");
+}
  
  
-    case POSIX_FORMAT:
-    case GNU_FORMAT:
-      strncpy (header->header.magic, TMAGIC, TMAGLEN);
-      strncpy (header->header.version, TVERSION, TVERSLEN);
-      break;
-    }
+static bool
+minor_to_chars (minor_t v, char *p, size_t s)
+{
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "minor_t");
+}
  
  
-  if (archive_format == V7_FORMAT || numeric_owner_option)
+static bool
+mode_to_chars (mode_t v, char *p, size_t s)
+{
+  /* In the common case where the internal and external mode bits are the same,
+     and we are not using POSIX or GNU format,
+     propagate all unknown bits to the external mode.
+     This matches historical practice.
+     Otherwise, just copy the bits we know about.  */
+  int negative;
+  uintmax_t u;
+  if (S_ISUID == TSUID && S_ISGID == TSGID && S_ISVTX == TSVTX
+      && S_IRUSR == TUREAD && S_IWUSR == TUWRITE && S_IXUSR == TUEXEC
+      && S_IRGRP == TGREAD && S_IWGRP == TGWRITE && S_IXGRP == TGEXEC
+      && S_IROTH == TOREAD && S_IWOTH == TOWRITE && S_IXOTH == TOEXEC
+      && archive_format != POSIX_FORMAT
+      && archive_format != USTAR_FORMAT
+      && archive_format != GNU_FORMAT)
      {
      {
-      /* header->header.[ug]name are left as the empty string.  */
+      negative = v < 0;
+      u = v;
      }
    else
      {
      }
    else
      {
-      uid_to_uname (st->st_uid, header->header.uname);
-      gid_to_gname (st->st_gid, header->header.gname);
+      negative = 0;
+      u = ((v & S_ISUID ? TSUID : 0)
+          | (v & S_ISGID ? TSGID : 0)
+          | (v & S_ISVTX ? TSVTX : 0)
+          | (v & S_IRUSR ? TUREAD : 0)
+          | (v & S_IWUSR ? TUWRITE : 0)
+          | (v & S_IXUSR ? TUEXEC : 0)
+          | (v & S_IRGRP ? TGREAD : 0)
+          | (v & S_IWGRP ? TGWRITE : 0)
+          | (v & S_IXGRP ? TGEXEC : 0)
+          | (v & S_IROTH ? TOREAD : 0)
+          | (v & S_IWOTH ? TOWRITE : 0)
+          | (v & S_IXOTH ? TOEXEC : 0));
      }
      }
+  return to_chars (negative, u, sizeof v, 0, p, s, "mode_t");
+}
  
  
-  return header;
+bool
+off_to_chars (off_t v, char *p, size_t s)
+{
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "off_t");
  }
  
  }
  
-/*-------------------------------------------------------------------------.
-| 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.                            |
-`-------------------------------------------------------------------------*/
+bool
+time_to_chars (time_t v, char *p, size_t s)
+{
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "time_t");
+}
  
  
-void
-finish_header (union block *header)
+static uintmax_t
+uid_substitute (int *negative)
  {
  {
-  int i, sum;
-  char *p;
+  uid_t r;
+#ifdef UID_NOBODY
+  r = UID_NOBODY;
+#else
+  static uid_t uid_nobody;
+  if (!uid_nobody && !uname_to_uid ("nobody", &uid_nobody))
+    uid_nobody = -2;
+  r = uid_nobody;
+#endif
+  *negative = r < 0;
+  return r;
+}
  
  
-  memcpy (header->header.chksum, CHKBLANKS, sizeof (header->header.chksum));
+static bool
+uid_to_chars (uid_t v, char *p, size_t s)
+{
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, uid_substitute, p, s, "uid_t");
+}
  
  
-  sum = 0;
-  p = header->buffer;
-  for (i = sizeof (*header); --i >= 0; )
-    /* We can't use unsigned char here because of old compilers, e.g. V7.  */
-    sum += 0xFF & *p++;
+static bool
+uintmax_to_chars (uintmax_t v, char *p, size_t s)
+{
+  return to_chars (0, v, sizeof v, 0, p, s, "uintmax_t");
+}
  
  
-  /* Fill in the checksum field.  It's formatted differently from the
-     other fields: it has [6] digits, a null, then a space -- rather than
-     digits, a space, then a null.  We use to_oct then write the null in
-     over to_oct's space.  The final space is already there, from
-     checksumming, and to_oct doesn't modify it.
+static void
+string_to_chars (char const *str, char *p, size_t s)
+{
+  tar_copy_str (p, str, s);
+  p[s - 1] = '\0';
+}
  
  
-     This is a fast way to do:
+\f
+/* A directory is always considered dumpable.
+   Otherwise, only regular and contiguous files are considered dumpable.
+   Such a file is dumpable if it is sparse and both --sparse and --totals
+   are specified.
+   Otherwise, it is dumpable unless any of the following conditions occur:
  
  
-     sprintf(header->header.chksum, "%6o", sum);  */
+   a) it is empty *and* world-readable, or
+   b) current archive is /dev/null */
  
  
-  to_oct ((long) sum, 8, header->header.chksum);
-  header->header.chksum[6] = '\0';     /* zap the space */
+static bool
+file_dumpable_p (struct stat const *st)
+{
+  if (S_ISDIR (st->st_mode))
+    return true;
+  if (! (S_ISREG (st->st_mode) || S_ISCTG (st->st_mode)))
+    return false;
+  if (dev_null_output)
+    return totals_option && sparse_option && ST_IS_SPARSE (*st);
+  return ! (st->st_size == 0 && (st->st_mode & MODE_R) == MODE_R);
+}
  
  
-  set_next_block_after (header);
+\f
+/* Writing routines.  */
  
  
-  if (verbose_option
-      && header->header.typeflag != GNUTYPE_LONGLINK
-      && header->header.typeflag != GNUTYPE_LONGNAME)
-    {
-      /* These globals are parameters to print_header, sigh.  */
+/* 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)
+{
+  union block *pointer = find_next_block ();
+  memset (pointer->buffer, 0, BLOCKSIZE);
+  set_next_block_after (pointer);
+  pointer = find_next_block ();
+  memset (pointer->buffer, 0, available_space_after (pointer));
+  set_next_block_after (pointer);
+}
  
  
-      current_header = header;
-      /* current_stat is already set up.  */
-      current_format = archive_format;
-      print_header ();
-    }
+/* 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_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;
  }
  }
-\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.                                           |
-`-------------------------------------------------------------------------*/
+/* Create a new header and store there at most NAME_FIELD_SIZE bytes of
+   the file name */
  
  
-static int
-zero_block_p (char *buffer)
+static union block *
+write_short_name (struct tar_stat_info *st)
  {
  {
-  int counter;
-
-  for (counter = 0; counter < BLOCKSIZE; counter++)
-    if (buffer[counter] != '\0')
-      return 0;
-  return 1;
+  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;
  }
  
  }
  
-/*---.
-| ?  |
-`---*/
+#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
-init_sparsearray (void)
+write_gnu_long_link (struct tar_stat_info *st, const char *p, char type)
  {
  {
-  int counter;
+  size_t size = strlen (p) + 1;
+  size_t bufsize;
+  union block *header;
+  char *tmpname;
+
+  header = start_private_header ("././@LongLink", size, time (NULL));
+  FILL (header->header.mtime, '0');
+  FILL (header->header.mode, '0');
+  FILL (header->header.uid, '0');
+  FILL (header->header.gid, '0');
+  FILL (header->header.devmajor, 0);
+  FILL (header->header.devminor, 0);
+  uid_to_uname (0, &tmpname);
+  UNAME_TO_CHARS (tmpname, header->header.uname);
+  free (tmpname);
+  gid_to_gname (0, &tmpname);
+  GNAME_TO_CHARS (tmpname, header->header.gname);
+  free (tmpname);
+
+  strcpy (header->buffer + offsetof (struct posix_header, magic),
+         OLDGNU_MAGIC);
+  header->header.typeflag = type;
+  finish_header (st, header, -1);
  
  
-  sp_array_size = 10;
+  header = find_next_block ();
  
  
-  /* Make room for our scratch space -- initially is 10 elts long.  */
+  bufsize = available_space_after (header);
  
  
-  sparsearray = (struct sp_array *)
-    xmalloc (sp_array_size * sizeof (struct sp_array));
-  for (counter = 0; counter < sp_array_size; counter++)
+  while (bufsize < size)
      {
      {
-      sparsearray[counter].offset = 0;
-      sparsearray[counter].numbytes = 0;
+      memcpy (header->buffer, p, bufsize);
+      p += bufsize;
+      size -= bufsize;
+      set_next_block_after (header + (bufsize - 1) / BLOCKSIZE);
+      header = find_next_block ();
+      bufsize = available_space_after (header);
      }
      }
+  memcpy (header->buffer, p, size);
+  memset (header->buffer + size, 0, bufsize - size);
+  set_next_block_after (header + (size - 1) / BLOCKSIZE);
  }
  
  }
  
-/*---.
-| ?  |
-`---*/
+static size_t
+split_long_name (const char *name, size_t length)
+{
+  size_t i;
+
+  if (length > PREFIX_FIELD_SIZE + 1)
+    length = PREFIX_FIELD_SIZE + 1;
+  else if (ISSLASH (name[length - 1]))
+    length--;
+  for (i = length - 1; i > 0; i--)
+    if (ISSLASH (name[i]))
+      break;
+  return i;
+}
  
  
-static void
-find_new_file_size (int *filesize, int highest_index)
+static union block *
+write_ustar_long_name (const char *name)
  {
  {
-  int counter;
+  size_t length = strlen (name);
+  size_t i, nlen;
+  union block *header;
  
  
-  *filesize = 0;
-  for (counter = 0;
-       sparsearray[counter].numbytes && counter <= highest_index;
-       counter++)
-    *filesize += sparsearray[counter].numbytes;
-}
+  if (length > PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1)
+    {
+      ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
+             quotearg_colon (name),
+             PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1));
+      return NULL;
+    }
  
  
-/*-----------------------------------------------------------------------.
-| 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.                           |
-`-----------------------------------------------------------------------*/
+  i = split_long_name (name, length);
+  if (i == 0 || (nlen = length - i - 1) > NAME_FIELD_SIZE || nlen == 0)
+    {
+      ERROR ((0, 0,
+             _("%s: file name is too long (cannot be split); not dumped"),
+             quotearg_colon (name)));
+      return NULL;
+    }
  
  
-/* There is little point in trimming small amounts of null data at the head
-   and tail of blocks, only avoid dumping full null blocks.  */
+  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);
  
  
-/* FIXME: this routine might accept bits of algorithmic cleanup, it is
-   too kludgey for my taste...  */
+  return header;
+}
  
  
-static int
-deal_with_sparse (char *name, union block *header)
+/* Write a long link name, depending on the current archive format */
+static void
+write_long_link (struct tar_stat_info *st)
  {
  {
-  long numbytes = 0;
-  long offset = 0;
-  int file;
-  int sparse_index = 0;
-  int count;
-  char buffer[BLOCKSIZE];
+  switch (archive_format)
+    {
+    case POSIX_FORMAT:
+      xheader_store ("linkpath", st, NULL);
+      break;
  
  
-  if (archive_format == OLDGNU_FORMAT)
-    header->oldgnu_header.isextended = 0;
+    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;
  
  
-  if (file = open (name, O_RDONLY), file < 0)
-    /* This problem will be caught later on, so just return.  */
-    return 0;
+    case OLDGNU_FORMAT:
+    case GNU_FORMAT:
+      write_gnu_long_link (st, st->link_name, GNUTYPE_LONGLINK);
+      break;
  
  
-  init_sparsearray ();
-  clear_buffer (buffer);
+    default:
+      abort(); /*FIXME*/
+    }
+}
  
  
-  while (count = read (file, buffer, sizeof buffer), count != 0)
+static union block *
+write_long_name (struct tar_stat_info *st)
+{
+  switch (archive_format)
      {
      {
-      /* Realloc the scratch area as necessary.  FIXME: should reallocate
-        only at beginning of a new instance of non-zero data.  */
+    case POSIX_FORMAT:
+      xheader_store ("path", st, NULL);
+      break;
  
  
-      if (sparse_index > sp_array_size - 1)
+    case V7_FORMAT:
+      if (strlen (st->file_name) > NAME_FIELD_SIZE-1)
         {
         {
-
-         sparsearray = (struct sp_array *)
-           xrealloc (sparsearray,
-                     2 * sp_array_size * sizeof (struct sp_array));
-         sp_array_size *= 2;
+         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;
  
  
-      /* Process one block.  */
+    case USTAR_FORMAT:
+    case STAR_FORMAT:
+      return write_ustar_long_name (st->file_name);
  
  
-      if (count == sizeof buffer)
+    case OLDGNU_FORMAT:
+    case GNU_FORMAT:
+      write_gnu_long_link (st, st->file_name, GNUTYPE_LONGNAME);
+      break;
  
  
-       if (zero_block_p (buffer))
-         {
-           if (numbytes)
-             {
-               sparsearray[sparse_index++].numbytes = numbytes;
-               numbytes = 0;
-             }
-         }
-       else
-         {
-           if (!numbytes)
-             sparsearray[sparse_index].offset = offset;
-           numbytes += count;
-         }
+    default:
+      abort(); /*FIXME*/
+    }
+  return write_short_name (st);
+}
  
  
-      else
+union block *
+write_extended (bool global, struct tar_stat_info *st, union block *old_header)
+{
+  union block *header, hp;
+  char *p;
+  int type;
+  time_t t;
  
  
-       /* Since count < sizeof buffer, we have the last bit of the file.  */
+  if (st->xhdr.buffer || st->xhdr.stk == NULL)
+    return old_header;
  
  
-       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);
+  xheader_finish (&st->xhdr);
+  memcpy (hp.buffer, old_header, sizeof (hp));
+  if (global)
+    {
+      type = XGLTYPE;
+      p = xheader_ghdr_name ();
+      time (&t);
      }
      }
-
-  if (numbytes)
-    sparsearray[sparse_index++].numbytes = numbytes;
    else
      {
    else
      {
-      sparsearray[sparse_index].offset = offset - 1;
-      sparsearray[sparse_index++].numbytes = 1;
+      type = XHDTYPE;
+      p = xheader_xhdr_name (st);
+      t = st->stat.st_mtime;
      }
      }
+  xheader_write (type, p, t, &st->xhdr);
+  free (p);
+  header = find_next_block ();
+  memcpy (header, &hp.buffer, sizeof (hp.buffer));
+  return header;
+}
  
  
-  close (file);
-  return sparse_index - 1;
+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.  */
  
  
-static int
-finish_sparse_file (int file, long *sizeleft, long fullsize, char *name)
+union block *
+start_header (struct tar_stat_info *st)
  {
  {
-  union block *start;
-  int bufsize;
-  int sparse_index = 0;
-  int count;
-  long pos;
-  long nwritten = 0;
-
-  while (*sizeleft > 0)
-    {
-      start = find_next_block ();
-      memset (start->buffer, 0, BLOCKSIZE);
-      bufsize = sparsearray[sparse_index].numbytes;
-      if (!bufsize)
-       {
-         /* We blew it, maybe.  */
+  union block *header;
  
  
-         ERROR ((0, 0, _("Wrote %ld of %ld bytes to file %s"),
-                 fullsize - *sizeleft, fullsize, name));
-         break;
-       }
-      pos = lseek (file, sparsearray[sparse_index++].offset, 0);
+  header = write_header_name (st);
+  if (!header)
+    return NULL;
  
  
-      /* If the number of bytes to be written here exceeds the size of
-        the temporary buffer, do it in steps.  */
+  /* Override some stat fields, if requested to do so.  */
  
  
-      while (bufsize > BLOCKSIZE)
-       {
-#if 0
-         if (amount_read)
-           {
-             count = 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);
-           }
-#endif
-         /* Store the data.  */
+  if (owner_option != (uid_t) -1)
+    st->stat.st_uid = owner_option;
+  if (group_option != (gid_t) -1)
+    st->stat.st_gid = group_option;
+  if (mode_option)
+    st->stat.st_mode =
+      ((st->stat.st_mode & ~MODE_ALL)
+       | mode_adjust (st->stat.st_mode, S_ISDIR (st->stat.st_mode) != 0,
+                     initial_umask, mode_option, NULL));
  
  
-         count = read (file, start->buffer, BLOCKSIZE);
-         if (count < 0)
-           {
-             ERROR ((0, errno, _("\
-Read error at byte %ld, reading %d bytes, in file %s"),
-                        fullsize - *sizeleft, bufsize, name));
-             return 1;
-           }
-         bufsize -= count;
-         *sizeleft -= count;
-         set_next_block_after (start);
-         nwritten += BLOCKSIZE;        /* FIXME: ??? */
-         start = find_next_block ();
-         memset (start->buffer, 0, BLOCKSIZE);
-       }
+  /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
+     for a few tars and came up with the following interoperability
+     matrix:
+
+             WRITER
+       1 2 3 4 5 6 7 8 9   READER
+       . . . . . . . . .   1 = SunOS 4.2 tar
+       # . . # # . . # #   2 = NEC SVR4.0.2 tar
+       . . . # # . . # .   3 = Solaris 2.1 tar
+       . . . . . . . . .   4 = GNU tar 1.11.1
+       . . . . . . . . .   5 = HP-UX 8.07 tar
+       . . . . . . . . .   6 = Ultrix 4.1
+       . . . . . . . . .   7 = AIX 3.2
+       . . . . . . . . .   8 = Hitachi HI-UX 1.03
+       . . . . . . . . .   9 = Omron UNIOS-B 4.3BSD 1.60Beta
+
+            . = works
+            # = "impossible file type"
+
+     The following mask for old archive removes the '#'s in column 4
+     above, thus making GNU tar both a universal donor and a universal
+     acceptor for Paul's test.  */
+
+  if (archive_format == V7_FORMAT || archive_format == USTAR_FORMAT)
+    MODE_TO_CHARS (st->stat.st_mode & MODE_ALL, header->header.mode);
+  else
+    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;
+  }
  
  
+  {
+    gid_t gid = st->stat.st_gid;
+    if (archive_format == POSIX_FORMAT
+       && MAX_OCTAL_VAL (header->header.gid) < gid)
+      {
+       xheader_store ("gid", st, NULL);
+       gid = 0;
+      }
+    if (!GID_TO_CHARS (gid, header->header.gid))
+      return NULL;
+  }
+
+  {
+    off_t size = st->stat.st_size;
+    if (archive_format == POSIX_FORMAT
+       && MAX_OCTAL_VAL (header->header.size) < size)
        {
        {
-       char buffer[BLOCKSIZE];
+       xheader_store ("size", st, NULL);
+       size = 0;
+      }
+    if (!OFF_TO_CHARS (size, header->header.size))
+      return NULL;
+  }
  
  
-       clear_buffer (buffer);
-       count = read (file, buffer, (size_t) bufsize);
-       memcpy (start->buffer, buffer, BLOCKSIZE);
+  {
+    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;
+  }
  
  
-      if (count < 0)
+  /* 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)
         {
         {
-         ERROR ((0, errno,
-                 _("Read error at byte %ld, reading %d bytes, in file %s"),
-                 fullsize - *sizeleft, bufsize, name));
-         return 1;
+         xheader_store ("devmajor", st, NULL);
+         devmajor = 0;
         }
         }
-#if 0
-      if (amount_read >= BLOCKSIZE)
+      if (!MAJOR_TO_CHARS (devmajor, header->header.devmajor))
+       return NULL;
+
+      if (archive_format == POSIX_FORMAT
+         && MAX_OCTAL_VAL (header->header.devminor) < devminor)
         {
         {
-         amount_read = 0;
-         set_next_block_after (start + (count - 1) / BLOCKSIZE);
-         if (count != bufsize)
-           {
-             ERROR ((0, 0,
-                     _("File %s shrunk by %d bytes, padding with zeros"),
-                     name, sizeleft));
-             return 1;
-           }
-         start = find_next_block ();
+         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->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;
+
+  switch (archive_format)
+    {
+    case V7_FORMAT:
+      break;
+
+    case OLDGNU_FORMAT:
+    case GNU_FORMAT:   /*FIXME?*/
+      /* Overwrite header->header.magic and header.version in one blow.  */
+      strcpy (header->buffer + offsetof (struct posix_header, magic),
+             OLDGNU_MAGIC);
+      break;
+
+    case POSIX_FORMAT:
+    case USTAR_FORMAT:
+      strncpy (header->header.magic, TMAGIC, TMAGLEN);
+      strncpy (header->header.version, TVERSION, TVERSLEN);
+      break;
+
+    default:
+      abort ();
+    }
+
+  if (archive_format == V7_FORMAT || numeric_owner_option)
+    {
+      /* header->header.[ug]name are left as the empty string.  */
+    }
+  else
+    {
+      if (owner_name_option)
+       st->uname = xstrdup (owner_name_option);
        else
        else
-       amount_read += bufsize;
-#endif
-      nwritten += count;       /* FIXME: ??? */
-      *sizeleft -= count;
-      set_next_block_after (start);
+       uid_to_uname (st->stat.st_uid, &st->uname);
  
  
+      if (group_name_option)
+       st->gname = xstrdup (group_name_option);
+      else
+       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);
      }
      }
-  free (sparsearray);
-#if 0
-  printf (_("Amount actually written is (I hope) %d.\n"), nwritten);
-  set_next_block_after (start + (count - 1) / BLOCKSIZE);
-#endif
-  return 0;
-}
-\f
-/* Main functions of this module.  */
  
  
-/*---.
-| ?  |
-`---*/
+  if (archive_format == POSIX_FORMAT)
+    {
+      if (acls_option > 0)
+        {
+          if (st->acls_a_ptr)
+            xheader_store ("SCHILY.acl.access", st, NULL);
+          if (st->acls_d_ptr)
+            xheader_store ("SCHILY.acl.default", st, NULL);
+        }
+      if ((selinux_context_option > 0) && st->cntx_name)
+        xheader_store ("RHT.security.selinux", st, NULL);
+      if (xattrs_option > 0)
+        {
+          size_t scan_xattr = 0;
+          struct xattr_array *xattr_map = st->xattr_map;
+
+          while (scan_xattr < st->xattr_map_size)
+            {
+              xheader_store (xattr_map[scan_xattr].xkey, st, &scan_xattr);
+              ++scan_xattr;
+            }
+        }
+    }
+
+  return header;
+}
  
  void
  
  void
-create_archive (void)
+simple_finish_header (union block *header)
  {
  {
+  size_t i;
+  int sum;
    char *p;
  
    char *p;
  
-  open_archive (ACCESS_WRITE);
+  memcpy (header->header.chksum, CHKBLANKS, sizeof header->header.chksum);
  
  
-  if (incremental_option)
-    {
-      char *buffer = xmalloc (PATH_MAX);
-      char *q, *bufp;
+  sum = 0;
+  p = header->buffer;
+  for (i = sizeof *header; i-- != 0; )
+    /* We can't use unsigned char here because of old compilers, e.g. V7.  */
+    sum += 0xFF & *p++;
  
  
-      collect_and_sort_names ();
+  /* Fill in the checksum field.  It's formatted differently from the
+     other fields: it has [6] digits, a null, then a space -- rather than
+     digits, then a null.  We use to_chars.
+     The final space is already there, from
+     checksumming, and to_chars doesn't modify it.
  
  
-      while (p = name_from_list (), p)
-       dump_file (p, -1, 1);
+     This is a fast way to do:
  
  
-      blank_name_list ();
-      while (p = name_from_list (), p)
-       {
-         strcpy (buffer, p);
-         if (p[strlen (p) - 1] != '/')
-           strcat (buffer, "/");
-         bufp = buffer + strlen (buffer);
-         for (q = gnu_list_name->dir_contents;
-              q && *q;
-              q += strlen (q) + 1)
-           {
-             if (*q == 'Y')
-               {
-                 strcpy (bufp, q + 1);
-                 dump_file (buffer, -1, 1);
-               }
-           }
-       }
-      free (buffer);
-    }
-  else
-    {
-      while (p = name_next (1), p)
-       dump_file (p, -1, 1);
-    }
+     sprintf(header->header.chksum, "%6o", sum);  */
  
  
-  write_eot ();
-  close_archive ();
+  uintmax_to_chars ((uintmax_t) sum, header->header.chksum, 7);
  
  
-  if (listed_incremental_option)
-    write_dir_file ();
+  set_next_block_after (header);
  }
  
  }
  
-/*----------------------------------------------------------------------.
-| Dump a single file.  Recurse on directories.  Result is nonzero for   |
-| success.  P is file name to dump.  PARENT_DEVICE is device our parent |
-| directory was on.  TOP_LEVEL tells wether we are a toplevel call.     |
-|                                                                       |
-|  Sets global CURRENT_STAT to stat output for this file.               |
-`----------------------------------------------------------------------*/
+/* Finish off a filled-in header block and write it out.  We also
+   print the file name and/or full info if verbose is on.  If BLOCK_ORDINAL
+   is not negative, is the block ordinal of the first record for this
+   file, which may be a preceding long name or long link record.  */
+void
+finish_header (struct tar_stat_info *st,
+              union block *header, off_t block_ordinal)
+{
+  /* Note: It is important to do this before the call to write_extended(),
+     so that the actual ustar header is printed */
+  if (verbose_option
+      && header->header.typeflag != GNUTYPE_LONGLINK
+      && header->header.typeflag != GNUTYPE_LONGNAME
+      && header->header.typeflag != XHDTYPE
+      && header->header.typeflag != XGLTYPE)
+    {
+      /* FIXME: This global is used in print_header, sigh.  */
+      current_format = archive_format;
+      print_header (st, header, block_ordinal);
+    }
  
  
-/* FIXME: One should make sure that for *every* path leading to setting
-   exit_status to failure, a clear diagnostic has been issued.  */
+  header = write_extended (false, st, header);
+  simple_finish_header (header);
+}
+\f
  
  void
  
  void
-dump_file (char *p, int parent_device, int top_level)
+pad_archive (off_t size_left)
  {
  {
-  union block *header;
-  char type;
-  union block *exhdr;
-  char save_typeflag;
-  struct utimbuf restore_times;
+  union block *blk;
+  while (size_left > 0)
+    {
+      blk = find_next_block ();
+      memset (blk->buffer, 0, BLOCKSIZE);
+      set_next_block_after (blk);
+      size_left -= BLOCKSIZE;
+    }
+}
  
  
-  /* FIXME: `header' and `upperbound' might be used uninitialized in this
-     function.  Reported by Bruno Haible.  */
+static enum dump_status
+dump_regular_file (int fd, struct tar_stat_info *st)
+{
+  off_t size_left = st->stat.st_size;
+  off_t block_ordinal;
+  union block *blk;
  
  
-  if (interactive_option && !confirm ("add", p))
-    return;
+  block_ordinal = current_block_ordinal ();
+  blk = start_header (st);
+  if (!blk)
+    return dump_status_fail;
  
  
-  /* Use stat if following (rather than dumping) 4.2BSD's symbolic links.
-     Otherwise, use lstat (which falls back to stat if no symbolic links).  */
+  /* Mark contiguous files, if we support them.  */
+  if (archive_format != V7_FORMAT && S_ISCTG (st->stat.st_mode))
+    blk->header.typeflag = CONTTYPE;
  
  
-  if (dereference_option != 0
-#ifdef STX_HIDDEN              /* AIX */
-      ? statx (p, &current_stat, STATSIZE, STX_HIDDEN)
-      : statx (p, &current_stat, STATSIZE, STX_HIDDEN | STX_LINK)
-#else
-      ? stat (p, &current_stat) : lstat (p, &current_stat)
-#endif
-      )
+  finish_header (st, blk, block_ordinal);
+
+  mv_begin_write (st->file_name, st->stat.st_size, st->stat.st_size);
+  while (size_left > 0)
      {
      {
-      WARN ((0, errno, _("Cannot add file %s"), p));
-      if (!ignore_failed_read_option)
-       exit_status = TAREXIT_FAILURE;
-      return;
-    }
+      size_t bufsize, count;
  
  
-  restore_times.actime = current_stat.st_atime;
-  restore_times.modtime = current_stat.st_mtime;
+      blk = find_next_block ();
  
  
-#ifdef S_ISHIDDEN
-  if (S_ISHIDDEN (current_stat.st_mode))
-    {
-      char *new = (char *) alloca (strlen (p) + 2);
-      if (new)
+      bufsize = available_space_after (blk);
+
+      if (size_left < bufsize)
         {
         {
-         strcpy (new, p);
-         strcat (new, "@");
-         p = new;
+         /* Last read -- zero out area beyond.  */
+         bufsize = size_left;
+         count = bufsize % BLOCKSIZE;
+         if (count)
+           memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
         }
         }
-    }
-#endif
  
  
-  /* See if we only want new files, and check if this one is too old to
-     put in the archive.  */
+      count = (fd <= 0) ? bufsize : blocking_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 (!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))
-    {
-      if (parent_device == -1)
-       WARN ((0, 0, _("%s: is unchanged; not dumped"), p));
-      /* FIXME: recheck this return.  */
-      return;
+      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)
+           set_exit_status (TAREXIT_DIFFERS);
+         pad_archive (size_left - (bufsize - count));
+         return dump_status_short;
+       }
      }
      }
+  return dump_status_ok;
+}
  
  
-#if !MSDOS
-  /* See if we are trying to dump the archive.  */
+\f
+/* Copy info from the directory identified by ST into the archive.
+   DIRECTORY contains the directory's entries.  */
+
+static void
+dump_dir0 (struct tar_stat_info *st, char const *directory)
+{
+  bool top_level = ! st->parent;
+  const char *tag_file_name;
+  union block *blk = NULL;
+  off_t block_ordinal = current_block_ordinal ();
  
  
-  if (ar_dev && current_stat.st_dev == ar_dev && current_stat.st_ino == ar_ino)
+  st->stat.st_size = 0;        /* force 0 size on dir */
+
+  blk = start_header (st);
+  if (!blk)
+    return;
+
+  if (incremental_option && archive_format != POSIX_FORMAT)
+    blk->header.typeflag = GNUTYPE_DUMPDIR;
+  else /* if (standard_option) */
+    blk->header.typeflag = DIRTYPE;
+
+  /* If we're gnudumping, we aren't done yet so don't close it.  */
+
+  if (!incremental_option)
+    finish_header (st, blk, block_ordinal);
+  else if (gnu_list_name->directory)
      {
      {
-      WARN ((0, 0, _("%s is the archive; not dumped"), p));
+      if (archive_format == POSIX_FORMAT)
+       {
+         xheader_store ("GNU.dumpdir", st,
+                        safe_directory_contents (gnu_list_name->directory));
+         finish_header (st, blk, block_ordinal);
+       }
+      else
+       {
+         off_t size_left;
+         off_t totsize;
+         size_t bufsize;
+         ssize_t count;
+         const char *buffer, *p_buffer;
+
+         block_ordinal = current_block_ordinal ();
+         buffer = safe_directory_contents (gnu_list_name->directory);
+         totsize = dumpdir_size (buffer);
+         OFF_TO_CHARS (totsize, blk->header.size);
+         finish_header (st, blk, block_ordinal);
+         p_buffer = buffer;
+         size_left = totsize;
+
+         mv_begin_write (st->file_name, totsize, totsize);
+         while (size_left > 0)
+           {
+             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);
+           }
+       }
        return;
      }
        return;
      }
-#endif
  
  
-  /* 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 (!recursion_option)
+    return;
  
  
-  if (current_stat.st_nlink > 1
-      && (S_ISREG (current_stat.st_mode)
-#ifdef S_ISCTG
-         || S_ISCTG (current_stat.st_mode)
-#endif
-#ifdef S_ISCHR
-         || S_ISCHR (current_stat.st_mode)
-#endif
-#ifdef S_ISBLK
-         || S_ISBLK (current_stat.st_mode)
-#endif
-#ifdef S_ISFIFO
-         || S_ISFIFO (current_stat.st_mode)
-#endif
-      ))
+  if (one_file_system_option
+      && !top_level
+      && st->parent->stat.st_dev != st->stat.st_dev)
      {
      {
-      struct link *lp;
+      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;
  
  
-      /* FIXME: First quick and dirty.  Hashing, etc later.  */
+      switch (check_exclusion_tags (st, &tag_file_name))
+       {
+       case exclusion_tag_all:
+         /* Handled in dump_file0 */
+         break;
  
  
-      for (lp = linklist; lp; lp = lp->next)
-       if (lp->ino == current_stat.st_ino && lp->dev == current_stat.st_dev)
+       case exclusion_tag_none:
           {
           {
-           char *link_name = lp->name;
+           char const *entry;
+           size_t entry_len;
+           size_t name_len;
  
  
-           /* We found a link.  */
+           name_buf = xstrdup (st->orig_file_name);
+           name_size = name_len = strlen (name_buf);
  
  
-           while (!absolute_names_option && *link_name == '/')
+           /* Now output all the files in the directory.  */
+           for (entry = directory; (entry_len = strlen (entry)) != 0;
+                entry += entry_len + 1)
               {
               {
-               static int warned_once = 0;
-
-               if (!warned_once)
+               if (name_size < name_len + entry_len)
                   {
                   {
-                   warned_once = 1;
-                   WARN ((0, 0, _("\
-Removing leading `/' from absolute links")));
+                   name_size = name_len + entry_len;
+                   name_buf = xrealloc (name_buf, name_size + 1);
                   }
                   }
-               link_name++;
+               strcpy (name_buf + name_len, entry);
+               if (!excluded_name (name_buf))
+                 dump_file (st, entry, name_buf);
               }
               }
-           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);
-           if (header == NULL)
-             {
-               exit_status = TAREXIT_FAILURE;
-               return;
-             }
-           strncpy (header->header.linkname,
-                    link_name, NAME_FIELD_SIZE);
+           free (name_buf);
+         }
+         break;
  
  
-           /* Force null truncated.  */
+       case exclusion_tag_contents:
+         exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                _("contents not dumped"));
+         name_size = strlen (st->orig_file_name) + strlen (tag_file_name) + 1;
+         name_buf = xmalloc (name_size);
+         strcpy (name_buf, st->orig_file_name);
+         strcat (name_buf, tag_file_name);
+         dump_file (st, tag_file_name, name_buf);
+         free (name_buf);
+         break;
  
  
-           header->header.linkname[NAME_FIELD_SIZE - 1] = 0;
+       case exclusion_tag_under:
+         exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                _("contents not dumped"));
+         break;
+       }
+    }
+}
  
  
-           header->header.typeflag = LNKTYPE;
-           finish_header (header);
+/* 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';
+}
  
  
-           /* FIXME: Maybe remove from list after all links found?  */
+/* If we just ran out of file descriptors, release a file descriptor
+   in the directory chain somewhere leading from DIR->parent->parent
+   up through the root.  Return true if successful, false (preserving
+   errno == EMFILE) otherwise.
  
  
-           if (remove_files_option)
-             if (unlink (p) == -1)
-               ERROR ((0, errno, _("Cannot remove %s"), p));
+   Do not release DIR's file descriptor, or DIR's parent, as other
+   code assumes that they work.  On some operating systems, another
+   process can claim file descriptor resources as we release them, and
+   some calls or their emulations require multiple file descriptors,
+   so callers should not give up if a single release doesn't work.  */
  
  
-           /* We dumped it.  */
-           return;
+static bool
+open_failure_recover (struct tar_stat_info const *dir)
+{
+  if (errno == EMFILE && dir && dir->parent)
+    {
+      struct tar_stat_info *p;
+      for (p = dir->parent->parent; p; p = p->parent)
+       if (0 < p->fd && (! p->parent || p->parent->fd <= 0))
+         {
+           tar_stat_close (p);
+           return true;
           }
           }
+      errno = EMFILE;
+    }
+
+  return false;
+}
  
  
-      /* Not found.  Add it to the list of possible links.  */
+/* Return the directory entries of ST, in a dynamically allocated buffer,
+   each entry followed by '\0' and the last followed by an extra '\0'.
+   Return null on failure, setting errno.  */
+char *
+get_directory_entries (struct tar_stat_info *st)
+{
+  while (! (st->dirstream = fdopendir (st->fd)))
+    if (! open_failure_recover (st))
+      return 0;
+  return streamsavedir (st->dirstream);
+}
  
  
-      lp = (struct link *)
-       xmalloc ((size_t) (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;
+/* Dump the directory ST.  Return true if successful, false (emitting
+   diagnostics) otherwise.  Get ST's entries, recurse through its
+   subdirectories, and clean up file descriptors afterwards.  */
+static bool
+dump_dir (struct tar_stat_info *st)
+{
+  char *directory = get_directory_entries (st);
+  if (! directory)
+    {
+      savedir_diag (st->orig_file_name);
+      return false;
      }
  
      }
  
-  /* This is not a link to a previously dumped file, so dump it.  */
+  dump_dir0 (st, directory);
  
  
-  if (S_ISREG (current_stat.st_mode)
-#ifdef S_ISCTG
-      || S_ISCTG (current_stat.st_mode)
-#endif
-      )
+  restore_parent_fd (st);
+  free (directory);
+  return true;
+}
+
+\f
+/* Number of links a file can have without having to be entered into
+   the link table.  Typically this is 1, but in trickier circumstances
+   it is 0.  */
+static nlink_t trivial_link_count;
+
+\f
+/* Main functions of this module.  */
+
+void
+create_archive (void)
+{
+  struct name const *p;
+
+  trivial_link_count = name_count <= 1 && ! dereference_option;
+
+  open_archive (ACCESS_WRITE);
+  buffer_write_global_xheader ();
+
+  if (incremental_option)
      {
      {
-      int f;                   /* file descriptor */
-      long bufsize, count;
-      long sizeleft;
-      union block *start;
-      int header_moved;
-      char isextended = 0;
-      int upperbound;
-#if 0
-      static int cried_once = 0;
-#endif
+      size_t buffer_size = 1000;
+      char *buffer = xmalloc (buffer_size);
+      const char *q;
  
  
-      header_moved = 0;
+      collect_and_sort_names ();
  
  
-      if (sparse_option)
-       {
-         /* 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.  */
-
-         /* tar.h defines ST_NBLOCKS in term of 512 byte sectors, even
-            for HP-UX's which count in 1024 byte units and AIX's which
-            count in 4096 byte units.  So this should work...  */
-
-         /* 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 (current_stat.st_size > ST_NBLOCKS (current_stat) * BLOCKSIZE)
-           {
-             int filesize = current_stat.st_size;
-             int counter;
+      while ((p = name_from_list ()) != NULL)
+       if (!excluded_name (p->name))
+         dump_file (0, p->name, p->name);
  
  
-             header = start_header (p, &current_stat);
-             if (header == NULL)
+      blank_name_list ();
+      while ((p = name_from_list ()) != NULL)
+       if (!excluded_name (p->name))
+         {
+           struct tar_stat_info st;
+           size_t plen = strlen (p->name);
+           if (buffer_size <= plen)
+             {
+               while ((buffer_size *= 2) <= plen)
+                 continue;
+               buffer = xrealloc (buffer, buffer_size);
+             }
+           memcpy (buffer, p->name, plen);
+           if (! ISSLASH (buffer[plen - 1]))
+             buffer[plen++] = DIRECTORY_SEPARATOR;
+           tar_stat_init (&st);
+           q = directory_contents (gnu_list_name->directory);
+           if (q)
+             while (*q)
                 {
                 {
-                 exit_status = TAREXIT_FAILURE;
-                 return;
+                 size_t qlen = strlen (q);
+                 if (*q == 'Y')
+                   {
+                     if (! st.orig_file_name)
+                       {
+                         int fd = openat (chdir_fd, p->name,
+                                          open_searchdir_flags);
+                         if (fd < 0)
+                           {
+                             open_diag (p->name);
+                             break;
+                           }
+                         st.fd = fd;
+                         if (fstat (fd, &st.stat) != 0)
+                           {
+                             stat_diag (p->name);
+                             break;
+                           }
+                         st.orig_file_name = xstrdup (p->name);
+                       }
+                     if (buffer_size < plen + qlen)
+                       {
+                         while ((buffer_size *=2 ) < plen + qlen)
+                           continue;
+                         buffer = xrealloc (buffer, buffer_size);
+                       }
+                     strcpy (buffer + plen, q + 1);
+                     dump_file (&st, q + 1, buffer);
+                   }
+                 q += qlen + 1;
                 }
                 }
-             header->header.typeflag = GNUTYPE_SPARSE;
-             header_moved = 1;
+           tar_stat_destroy (&st);
+         }
+      free (buffer);
+    }
+  else
+    {
+      const char *name;
+      while ((name = name_next (1)) != NULL)
+       if (!excluded_name (name))
+         dump_file (0, name, name);
+    }
  
  
-             /* 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.  */
+  write_eot ();
+  close_archive ();
+  finish_deferred_unlinks ();
+  if (listed_incremental_option)
+    write_directory_file ();
+}
  
  
-             upperbound = deal_with_sparse (p, header);
  
  
-             /* See if we'll need an extended header later.  */
+/* 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;
+}
  
  
-             if (upperbound > SPARSES_IN_OLDGNU_HEADER - 1)
-               header->oldgnu_header.isextended = 1;
+/* 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;
+}
  
  
-             /* 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.  */
+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)
+    set_exit_status (TAREXIT_FAILURE);
+}
  
  
-             to_oct ((long) current_stat.st_size, 1 + 12,
-                     header->oldgnu_header.realsize);
+\f
+/* Handling of hard links */
  
  
-             /* 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.  */
+/* 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;
  
  
-             find_new_file_size (&filesize, upperbound);
-             current_stat.st_size = filesize;
-             to_oct ((long) filesize, 1 + 12, header->header.size);
+/* 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
+      && (trivial_link_count < st->stat.st_nlink || remove_files_option))
+    {
+      struct link lp;
+      struct link *duplicate;
+      off_t block_ordinal;
+      union block *blk;
  
  
-             for (counter = 0; counter < SPARSES_IN_OLDGNU_HEADER; counter++)
-               {
-                 if (!sparsearray[counter].numbytes)
-                   break;
+      lp.ino = st->stat.st_ino;
+      lp.dev = st->stat.st_dev;
  
  
-                 to_oct (sparsearray[counter].offset, 1 + 12,
-                         header->oldgnu_header.sp[counter].offset);
-                 to_oct (sparsearray[counter].numbytes, 1 + 12,
-                         header->oldgnu_header.sp[counter].numbytes);
-               }
+      if ((duplicate = hash_lookup (link_table, &lp)))
+       {
+         /* We found a link.  */
+         char const *link_name = safer_name_suffix (duplicate->name, true,
+                                                    absolute_names_option);
  
  
-           }
-       }
-      else
-       upperbound = SPARSES_IN_OLDGNU_HEADER - 1;
+         duplicate->nlink--;
  
  
-      sizeleft = current_stat.st_size;
+         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);
  
  
-      /* Don't bother opening empty, world readable files.  Also do not open
-        files when archive is meant for /dev/null.  */
+         st->stat.st_size = 0;
+         blk = start_header (st);
+         if (!blk)
+           return false;
+         tar_copy_str (blk->header.linkname, link_name, NAME_FIELD_SIZE);
  
  
-      if (dev_null_output
-         || (sizeleft == 0 && 0444 == (0444 & 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;
-           }
+         blk->header.typeflag = LNKTYPE;
+         finish_header (st, blk, block_ordinal);
+
+         if (remove_files_option)
+           queue_deferred_unlink (st->orig_file_name, false);
+
+         return true;
         }
         }
+    }
+  return false;
+}
+
+static void
+file_count_links (struct tar_stat_info *st)
+{
+  if (hard_dereference_option)
+    return;
+  if (trivial_link_count < st->stat.st_nlink)
+    {
+      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--;
+    }
+}
  
  
-      /* If the file is sparse, we've already taken care of this.  */
+/* 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;
  
  
-      if (!header_moved)
+  for (lp = hash_get_first (link_table); lp;
+       lp = hash_get_next (link_table, lp))
+    {
+      if (lp->nlink)
         {
         {
-         header = start_header (p, &current_stat);
-         if (header == NULL)
-           {
-             if (f >= 0)
-               close (f);
-             exit_status = TAREXIT_FAILURE;
-             return;
-           }
+         WARN ((0, 0, _("Missing links to %s."), quote (lp->name)));
         }
         }
-#ifdef S_ISCTG
-      /* Mark contiguous files, if we support them.  */
+    }
+}
  
  
-      if (archive_format != V7_FORMAT && S_ISCTG (current_stat.st_mode))
-       header->header.typeflag = CONTTYPE;
-#endif
-      isextended = header->oldgnu_header.isextended;
-      save_typeflag = header->header.typeflag;
-      finish_header (header);
-      if (isextended)
-       {
-#if 0
-         int sum = 0;
-#endif
-         int counter;
-#if 0
-         union block *exhdr;
-         int arraybound = SPARSES_IN_SPARSE_HEADER;
-#endif
-         /* static */ int index_offset = SPARSES_IN_OLDGNU_HEADER;
+/* Assuming DIR is the working directory, open FILE, using FLAGS to
+   control the open.  A null DIR means to use ".".  If we are low on
+   file descriptors, try to release one or more from DIR's parents to
+   reuse it.  */
+int
+subfile_open (struct tar_stat_info const *dir, char const *file, int flags)
+{
+  int fd;
  
  
-       extend:
-         exhdr = find_next_block ();
+  static bool initialized;
+  if (! initialized)
+    {
+      /* Initialize any tables that might be needed when file
+        descriptors are exhausted, and whose initialization might
+        require a file descriptor.  This includes the system message
+        catalog and tar's message catalog.  */
+      initialized = true;
+      strerror (ENOENT);
+      gettext ("");
+    }
  
  
-         if (exhdr == NULL)
-           {
-             exit_status = TAREXIT_FAILURE;
-             return;
-           }
-         memset (exhdr->buffer, 0, BLOCKSIZE);
-         for (counter = 0; counter < SPARSES_IN_SPARSE_HEADER; counter++)
-           {
-             if (counter + index_offset > upperbound)
-               break;
-
-             to_oct ((long) sparsearray[counter + index_offset].numbytes,
-                     1 + 12,
-                     exhdr->sparse_header.sp[counter].numbytes);
-             to_oct ((long) sparsearray[counter + index_offset].offset,
-                     1 + 12,
-                     exhdr->sparse_header.sp[counter].offset);
-           }
-         set_next_block_after (exhdr);
-#if 0
-         sum += counter;
-         if (sum < upperbound)
-           goto extend;
-#endif
-         if (index_offset + counter <= upperbound)
-           {
-             index_offset += counter;
-             exhdr->sparse_header.isextended = 1;
-             goto extend;
-           }
+  while ((fd = openat (dir ? dir->fd : chdir_fd, file, flags)) < 0
+        && open_failure_recover (dir))
+    continue;
+  return fd;
+}
  
  
+/* Restore the file descriptor for ST->parent, if it was temporarily
+   closed to conserve file descriptors.  On failure, set the file
+   descriptor to the negative of the corresponding errno value.  Call
+   this every time a subdirectory is ascended from.  */
+void
+restore_parent_fd (struct tar_stat_info const *st)
+{
+  struct tar_stat_info *parent = st->parent;
+  if (parent && ! parent->fd)
+    {
+      int parentfd = openat (st->fd, "..", open_searchdir_flags);
+      struct stat parentstat;
+
+      if (parentfd < 0)
+       parentfd = - errno;
+      else if (! (fstat (parentfd, &parentstat) == 0
+                 && parent->stat.st_ino == parentstat.st_ino
+                 && parent->stat.st_dev == parentstat.st_dev))
+       {
+         close (parentfd);
+         parentfd = IMPOSTOR_ERRNO;
         }
         }
-      if (save_typeflag == GNUTYPE_SPARSE)
+
+      if (parentfd < 0)
         {
         {
-         if (finish_sparse_file (f, &sizeleft, current_stat.st_size, p))
-           goto padit;
+         int origfd = openat (chdir_fd, parent->orig_file_name,
+                              open_searchdir_flags);
+         if (0 <= origfd)
+           {
+             if (fstat (parentfd, &parentstat) == 0
+                 && parent->stat.st_ino == parentstat.st_ino
+                 && parent->stat.st_dev == parentstat.st_dev)
+               parentfd = origfd;
+             else
+               close (origfd);
+           }
         }
         }
-      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);
+      parent->fd = parentfd;
+    }
+}
  
  
-           if (sizeleft < bufsize)
-             {
-               /* Last read -- zero out area beyond.  */
+/* Dump a single file, recursing on directories.  ST is the file's
+   status info, NAME its name relative to the parent directory, and P
+   its full name (which may be relative to the working directory).  */
  
  
-               bufsize = (int) sizeleft;
-               count = bufsize % BLOCKSIZE;
-               if (count)
-                 memset (start->buffer + sizeleft, 0,
-                         (size_t) (BLOCKSIZE - count));
-             }
-           if (f < 0)
-             count = bufsize;
-           else
-             count = read (f, start->buffer, (size_t) bufsize);
-           if (count < 0)
-             {
-               ERROR ((0, errno, _("\
-Read error at byte %ld, reading %d bytes, in file %s"),
-                       (long) (current_stat.st_size - sizeleft), bufsize, p));
-               goto padit;
-             }
-           sizeleft -= count;
+/* FIXME: One should make sure that for *every* path leading to setting
+   exit_status to failure, a clear diagnostic has been issued.  */
  
  
-           /* This is nonportable (the type of set_next_block_after's arg).  */
+static void
+dump_file0 (struct tar_stat_info *st, char const *name, char const *p)
+{
+  union block *header;
+  char type;
+  off_t original_size;
+  struct timespec original_ctime;
+  off_t block_ordinal = -1;
+  int fd = 0;
+  bool is_dir;
+  struct tar_stat_info const *parent = st->parent;
+  bool top_level = ! parent;
+  int parentfd = top_level ? chdir_fd : parent->fd;
+  void (*diag) (char const *) = 0;
  
  
-           set_next_block_after (start + (count - 1) / BLOCKSIZE);
+  if (interactive_option && !confirm ("add", p))
+    return;
  
  
-           if (count == bufsize)
-             continue;
-           ERROR ((0, 0, _("File %s shrunk by %d bytes, padding with zeros"),
-                   p, sizeleft));
-           goto padit;         /* short read */
-         }
+  assign_string (&st->orig_file_name, p);
+  assign_string (&st->file_name,
+                 safer_name_suffix (p, false, absolute_names_option));
  
  
-      if (multi_volume_option)
-       assign_string (&save_name, NULL);
+  transform_name (&st->file_name, XFORM_REGFILE);
  
  
-      if (f >= 0)
-       {
-         close (f);
-         if (atime_preserve_option)
-           utime (p, &restore_times);
-       }
-      if (remove_files_option)
+  if (parentfd < 0 && ! top_level)
+    {
+      errno = - parentfd;
+      diag = open_diag;
+    }
+  else if (fstatat (parentfd, name, &st->stat, fstatat_flags) != 0)
+    diag = stat_diag;
+  else if (file_dumpable_p (&st->stat))
+    {
+      fd = subfile_open (parent, name, open_read_flags);
+      if (fd < 0)
+       diag = open_diag;
+      else
         {
         {
-         if (unlink (p) == -1)
-           ERROR ((0, errno, _("Cannot remove %s"), p));
+         st->fd = fd;
+         if (fstat (fd, &st->stat) != 0)
+           diag = stat_diag;
         }
         }
+    }
+  if (diag)
+    {
+      file_removed_diag (p, top_level, diag);
        return;
        return;
+    }
  
  
-      /* File shrunk or gave error, pad out tape to match the size we
-        specified in the header.  */
+  st->archive_file_size = original_size = st->stat.st_size;
+  st->atime = get_stat_atime (&st->stat);
+  st->mtime = get_stat_mtime (&st->stat);
+  st->ctime = original_ctime = get_stat_ctime (&st->stat);
  
  
-    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, NULL);
-      if (f >= 0)
+#ifdef S_ISHIDDEN
+  if (S_ISHIDDEN (st->stat.st_mode))
+    {
+      char *new = (char *) alloca (strlen (p) + 2);
+      if (new)
         {
         {
-         close (f);
-         if (atime_preserve_option)
-           utime (p, &restore_times);
+         strcpy (new, p);
+         strcat (new, "@");
+         p = new;
         }
         }
-      return;
      }
      }
+#endif
  
  
-#ifdef S_ISLNK
-  else if (S_ISLNK (current_stat.st_mode))
-    {
-      int size;
-      char *buffer = (char *) alloca (PATH_MAX + 1);
+  /* See if we want only new files, and check if this one is too old to
+     put in the archive.
  
  
-      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);
+     This check is omitted if incremental_option is set *and* the
+     requested file is not explicitly listed in the command line.  */
  
  
-      current_stat.st_size = 0;        /* force 0 size on symlink */
-      header = start_header (p, &current_stat);
-      if (header == NULL)
-       {
-         exit_status = TAREXIT_FAILURE;
-         return;
-       }
-      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));
-       }
+  if (! (incremental_option && ! top_level)
+      && !S_ISDIR (st->stat.st_mode)
+      && OLDER_TAR_STAT_TIME (*st, m)
+      && (!after_date_option || OLDER_TAR_STAT_TIME (*st, c)))
+    {
+      if (!incremental_option && verbose_option)
+       WARNOPT (WARN_FILE_UNCHANGED,
+                (0, 0, _("%s: file is unchanged; not dumped"),
+                 quotearg_colon (p)));
        return;
      }
        return;
      }
-#endif /* S_ISLNK */
  
  
-  else if (S_ISDIR (current_stat.st_mode))
+  /* See if we are trying to dump the archive.  */
+  if (sys_file_is_archive (st))
      {
      {
-      DIR *directory;
-      struct dirent *entry;
-      char *namebuf;
-      int buflen;
-      int len;
-      int our_device = current_stat.st_dev;
-
-      /* If this tar program is installed suid root, like for Amanda, the
-        access might look like denied, while it is not really.
+      WARNOPT (WARN_IGNORE_ARCHIVE,
+              (0, 0, _("%s: file is the archive; not dumped"),
+               quotearg_colon (p)));
+      return;
+    }
  
  
-        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.  */
+  is_dir = S_ISDIR (st->stat.st_mode) != 0;
  
  
-      if (access (p, R_OK) == -1 && geteuid () != 0)
-       {
-         WARN ((0, errno, _("Cannot add directory %s"), p));
-         if (!ignore_failed_read_option)
-           exit_status = TAREXIT_FAILURE;
-         return;
-       }
+  if (!is_dir && dump_hard_link (st))
+    return;
  
  
-      /* Build new prototype name.  Ensure exactly one trailing slash.  */
+  if (is_dir || S_ISREG (st->stat.st_mode) || S_ISCTG (st->stat.st_mode))
+    {
+      bool ok;
+      struct stat final_stat;
  
  
-      len = strlen (p);
-      buflen = len + NAME_FIELD_SIZE;
-      namebuf = xmalloc ((size_t) (buflen + 1));
-      strncpy (namebuf, p, (size_t) buflen);
-      while (len >= 1 && namebuf[len - 1] == '/')
-       len--;
-      namebuf[len++] = '/';
-      namebuf[len] = '\0';
+      xattrs_acls_get (parentfd, name, st, 0, !is_dir);
+      xattrs_selinux_get (parentfd, name, st, fd);
+      xattrs_xattrs_get (parentfd, name, st, fd);
  
  
-      if (1)
+      if (is_dir)
         {
         {
-         /* The "1" above used to be "archive_format != V7_FORMAT", GNU tar
-            was just 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.  */
+         const char *tag_file_name;
+         ensure_slash (&st->orig_file_name);
+         ensure_slash (&st->file_name);
  
  
-         current_stat.st_size = 0;     /* force 0 size on dir */
-
-         /* FIXME: If people could really read standard archives, this
-            should be:
+         if (check_exclusion_tags (st, &tag_file_name) == exclusion_tag_all)
+           {
+             exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                    _("directory not dumped"));
+             return;
+           }
  
  
-            header
-              = start_header (standard_option ? p : namebuf, &current_stat);
+         ok = dump_dir (st);
  
  
-            but since they'd interpret DIRTYPE blocks as regular
-            files, we'd better put the / on the name.  */
+         fd = st->fd;
+         parentfd = top_level ? chdir_fd : parent->fd;
+       }
+      else
+       {
+         enum dump_status status;
  
  
-         header = start_header (namebuf, &current_stat);
-         if (header == NULL)
+         if (fd && sparse_option && ST_IS_SPARSE (st->stat))
             {
             {
-             exit_status = TAREXIT_FAILURE;
-             return;   /* eg name too long */
+             status = sparse_dump_file (fd, st);
+             if (status == dump_status_not_implemented)
+               status = dump_regular_file (fd, st);
             }
             }
+         else
+           status = dump_regular_file (fd, st);
+
+         switch (status)
+           {
+           case dump_status_ok:
+           case dump_status_short:
+             file_count_links (st);
+             break;
  
  
-         if (incremental_option)
-           header->header.typeflag = GNUTYPE_DUMPDIR;
-         else /* if (standard_option) */
-           header->header.typeflag = DIRTYPE;
+           case dump_status_fail:
+             break;
  
  
-         /* If we're gnudumping, we aren't done yet so don't close it.  */
+           case dump_status_not_implemented:
+             abort ();
+           }
  
  
-         if (!incremental_option)
-           finish_header (header);     /* done with directory header */
+         ok = status == dump_status_ok;
         }
  
         }
  
-      if (incremental_option && gnu_list_name->dir_contents)
+      if (ok)
         {
         {
-         int sizeleft;
-         int totsize;
-         int bufsize;
-         union block *start;
-         int count;
-         char *buffer, *p_buffer;
-
-         buffer = gnu_list_name->dir_contents; /* FOO */
-         totsize = 0;
-         for (p_buffer = buffer; p_buffer && *p_buffer;)
+         if (fd < 0)
             {
             {
-             int tmp;
-
-             tmp = strlen (p_buffer) + 1;
-             totsize += tmp;
-             p_buffer += tmp;
+             errno = - fd;
+             ok = false;
             }
             }
-         totsize++;
-         to_oct ((long) totsize, 1 + 12, header->header.size);
-         finish_header (header);
-         p_buffer = buffer;
-         sizeleft = totsize;
-         while (sizeleft > 0)
+         else if (fd == 0)
             {
             {
-             if (multi_volume_option)
+             if (parentfd < 0 && ! top_level)
                 {
                 {
-                 assign_string (&save_name, p);
-                 save_sizeleft = sizeleft;
-                 save_totsize = totsize;
+                 errno = - parentfd;
+                 ok = false;
                 }
                 }
-             start = find_next_block ();
-             bufsize = available_space_after (start);
-             if (sizeleft < bufsize)
-               {
-                 bufsize = sizeleft;
-                 count = bufsize % BLOCKSIZE;
-                 if (count)
-                   memset (start->buffer + sizeleft, 0,
-                          (size_t) (BLOCKSIZE - count));
-               }
-             memcpy (start->buffer, p_buffer, (size_t) bufsize);
-             sizeleft -= bufsize;
-             p_buffer += bufsize;
-             set_next_block_after (start + (bufsize - 1) / BLOCKSIZE);
+             else
+               ok = fstatat (parentfd, name, &final_stat, fstatat_flags) == 0;
             }
             }
-         if (multi_volume_option)
-           assign_string (&save_name, NULL);
-         if (atime_preserve_option)
-           utime (p, &restore_times);
-         return;
-       }
+         else
+           ok = fstat (fd, &final_stat) == 0;
  
  
-      /* 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.  */
-
-      if (no_recurse_option)
-       return;
-
-      /* 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.  */
+         if (! ok)
+           file_removed_diag (p, top_level, stat_diag);
+       }
  
  
-      if (one_file_system_option && !top_level
-         && parent_device != current_stat.st_dev)
+      if (ok)
         {
         {
-         if (verbose_option)
-           WARN ((0, 0, _("%s: On a different filesystem; not dumped"), p));
-         return;
+         if ((timespec_cmp (get_stat_ctime (&final_stat), original_ctime) != 0
+              /* Original ctime will change if the file is a directory and
+                 --remove-files is given */
+              && !(remove_files_option && is_dir))
+             || original_size < final_stat.st_size)
+           {
+             WARNOPT (WARN_FILE_CHANGED,
+                      (0, 0, _("%s: file changed as we read it"),
+                       quotearg_colon (p)));
+             set_exit_status (TAREXIT_DIFFERS);
+           }
+         else if (atime_preserve_option == replace_atime_preserve
+                  && fd && (is_dir || original_size != 0)
+                  && set_file_atime (fd, parentfd, name, st->atime) != 0)
+           utime_error (p);
         }
  
         }
  
-      /* Now output all the files in the directory.  */
-
-      errno = 0;               /* FIXME: errno should be read-only */
+      ok &= tar_stat_close (st);
+      if (ok && remove_files_option)
+       queue_deferred_unlink (p, is_dir);
  
  
-      directory = opendir (p);
-      if (!directory)
+      return;
+    }
+#ifdef HAVE_READLINK
+  else if (S_ISLNK (st->stat.st_mode))
+    {
+      char *buffer;
+      int size;
+      size_t linklen = st->stat.st_size;
+      if (linklen != st->stat.st_size || linklen + 1 == 0)
+       xalloc_die ();
+      buffer = (char *) alloca (linklen + 1);
+      size = readlinkat (parentfd, name, buffer, linklen + 1);
+      if (size < 0)
         {
         {
-         ERROR ((0, errno, _("Cannot open directory %s"), p));
+         file_removed_diag (p, top_level, readlink_diag);
           return;
         }
           return;
         }
+      buffer[size] = '\0';
+      assign_string (&st->link_name, buffer);
+      transform_name (&st->link_name, XFORM_SYMLINK);
+      if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT) < size)
+       write_long_link (st);
+
+      xattrs_selinux_get (parentfd, name, st, 0);
+      xattrs_xattrs_get (parentfd, name, st, 0);
+
+      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 */
  
  
-      /* Hack to remove "./" from the front of all the file names.  */
-
-      if (len == 2 && namebuf[0] == '.' && namebuf[1] == '/')
-       len = 0;
-
-      /* FIXME: Should speed this up by cd-ing into the dir.  */
-
-      while (entry = readdir (directory), entry)
-       {
-         /* Skip `.' and `..'.  */
-
-         if (is_dot_or_dotdot (entry->d_name))
-           continue;
-
-         if ((int) NAMLEN (entry) + len >= buflen)
-           {
-             buflen = len + NAMLEN (entry);
-             namebuf = (char *) xrealloc (namebuf, (size_t) (buflen + 1));
-#if 0
-             namebuf[len] = '\0';
-             ERROR ((0, 0, _("File name %s%s too long"),
-                     namebuf, entry->d_name));
-             continue;
-#endif
-           }
-         strcpy (namebuf + len, entry->d_name);
-         if (exclude_option && check_exclude (namebuf))
-           continue;
-         dump_file (namebuf, our_device, 0);
-       }
+      if (remove_files_option)
+       queue_deferred_unlink (p, false);
  
  
-      closedir (directory);
-      free (namebuf);
-      if (atime_preserve_option)
-       utime (p, &restore_times);
+      file_count_links (st);
        return;
      }
        return;
      }
-
-#ifdef S_ISCHR
-  else if (S_ISCHR (current_stat.st_mode))
-    type = CHRTYPE;
  #endif
  #endif
-
-#ifdef S_ISBLK
-  else if (S_ISBLK (current_stat.st_mode))
-    type = BLKTYPE;
-#endif
-
-  /* Avoid screwy apollo lossage where S_IFIFO == S_IFSOCK.  */
-
-#if (_ISP__M68K == 0) && (_ISP__A88K == 0) && defined(S_ISFIFO)
-  else if (S_ISFIFO (current_stat.st_mode))
-    type = FIFOTYPE;
-#endif
-
-#ifdef S_ISSOCK
-  else if (S_ISSOCK (current_stat.st_mode))
-    type = FIFOTYPE;
-#endif
-
+  else if (S_ISCHR (st->stat.st_mode))
+    {
+      type = CHRTYPE;
+      xattrs_acls_get (parentfd, name, st, 0, true);
+      xattrs_selinux_get (parentfd, name, st, 0);
+      xattrs_xattrs_get (parentfd, name, st, 0);
+    }
+  else if (S_ISBLK (st->stat.st_mode))
+    {
+      type = BLKTYPE;
+      xattrs_acls_get (parentfd, name, st, 0, true);
+      xattrs_selinux_get (parentfd, name, st, 0);
+      xattrs_xattrs_get (parentfd, name, st, 0);
+    }
+  else if (S_ISFIFO (st->stat.st_mode))
+    {
+      type = FIFOTYPE;
+      xattrs_acls_get (parentfd, name, st, 0, true);
+      xattrs_selinux_get (parentfd, name, st, 0);
+      xattrs_xattrs_get (parentfd, name, st, 0);
+    }
+  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
    else
-    goto unknown;
+    {
+      unknown_file_error (p);
+      return;
+    }
  
    if (archive_format == V7_FORMAT)
  
    if (archive_format == V7_FORMAT)
-    goto unknown;
-
-  current_stat.st_size = 0;    /* force 0 size */
-  header = start_header (p, &current_stat);
-  if (header == NULL)
      {
      {
-      exit_status = TAREXIT_FAILURE;
-      return;  /* eg name too long */
+      unknown_file_error (p);
+      return;
      }
  
      }
  
+  block_ordinal = current_block_ordinal ();
+  st->stat.st_size = 0;        /* force 0 size */
+  header = start_header (st);
+  if (!header)
+    return;
    header->header.typeflag = type;
  
    header->header.typeflag = type;
  
-#if defined(S_IFBLK) || defined(S_IFCHR)
    if (type != FIFOTYPE)
      {
    if (type != FIFOTYPE)
      {
-      to_oct ((long) major (current_stat.st_rdev), 8,
-             header->header.devmajor);
-      to_oct ((long) minor (current_stat.st_rdev), 8,
-             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);
      }
      }
-#endif
  
  
-  finish_header (header);
+  finish_header (st, header, block_ordinal);
    if (remove_files_option)
    if (remove_files_option)
-    {
-      if (unlink (p) == -1)
-       ERROR ((0, errno, _("Cannot remove %s"), p));
-    }
-  return;
+    queue_deferred_unlink (p, false);
+}
  
  
-unknown:
-  ERROR ((0, 0, _("%s: Unknown file type; file ignored"), p));
+/* Dump a file, recursively.  PARENT describes the file's parent
+   directory, NAME is the file's name relative to PARENT, and FULLNAME
+   its full name, possibly relative to the working directory.  NAME
+   may contain slashes at the top level of invocation.  */
+
+void
+dump_file (struct tar_stat_info *parent, char const *name,
+          char const *fullname)
+{
+  struct tar_stat_info st;
+  tar_stat_init (&st);
+  st.parent = parent;
+  dump_file0 (&st, name, fullname);
+  if (parent && listed_incremental_option)
+    update_parent_directory (parent);
+  tar_stat_destroy (&st);
  }
  }