]> Dogcows Code - chaz/tar/blobdiff - src/create.c
Improve listed incremental dumps.
[chaz/tar] / src / create.c
index 6e7d158b63e07916b143668b687d25d66503067b..072732a6195250bd1a9ff436971de709a590bf6f 100644 (file)
@@ -1,13 +1,13 @@
 /* Create a tar archive.
 
    Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
 /* Create a tar archive.
 
    Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
-   2003, 2004, 2005 Free Software Foundation, Inc.
+   2003, 2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
 
    Written by John Gilmore, on 1985-08-25.
 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
 
    Written by John Gilmore, on 1985-08-25.
 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
-   Free Software Foundation; either version 2, or (at your option) any later
+   Free Software Foundation; either version 3, or (at your option) any later
    version.
 
    This program is distributed in the hope that it will be useful, but
    version.
 
    This program is distributed in the hope that it will be useful, but
@@ -22,7 +22,6 @@
 #include <system.h>
 
 #include <quotearg.h>
 #include <system.h>
 
 #include <quotearg.h>
-#include <utimens.h>
 
 #include "common.h"
 #include <hash.h>
 
 #include "common.h"
 #include <hash.h>
@@ -34,6 +33,112 @@ struct link
     size_t nlink;
     char name[1];
   };
     size_t nlink;
     char name[1];
   };
+
+struct exclusion_tag
+{
+  const char *name;
+  size_t length;
+  enum exclusion_tag_type type;
+  bool (*predicate) (const char *name);
+  struct exclusion_tag *next;
+};
+
+static struct exclusion_tag *exclusion_tags;
+
+void
+add_exclusion_tag (const char *name, enum exclusion_tag_type type,
+                  bool (*predicate) (const char *name))
+{
+  struct exclusion_tag *tag = xmalloc (sizeof tag[0]);
+  tag->next = exclusion_tags;
+  tag->name = name;
+  tag->type = type;
+  tag->predicate = predicate;
+  tag->length = strlen (name);
+  exclusion_tags = tag;
+}
+
+void
+exclusion_tag_warning (const char *dirname, const char *tagname,
+                      const char *message)
+{
+  if (verbose_option)
+    WARNOPT (WARN_CACHEDIR,
+            (0, 0,
+             _("%s: contains a cache directory tag %s; %s"),
+             quotearg_colon (dirname),
+             quotearg_n (1, tagname),
+             message));
+}
+
+enum exclusion_tag_type 
+check_exclusion_tags (const char *dirname, const char **tag_file_name)
+{
+  static char *tagname;
+  static size_t tagsize;
+  struct exclusion_tag *tag;
+  size_t dlen = strlen (dirname);
+  int addslash = !ISSLASH (dirname[dlen-1]);
+  char *nptr = NULL;
+  
+  for (tag = exclusion_tags; tag; tag = tag->next)
+    {
+      size_t size = dlen + addslash + tag->length + 1;
+      if (size > tagsize)
+       {
+         tagsize = size;
+         tagname = xrealloc (tagname, tagsize);
+       }
+
+      if (!nptr)
+       {
+         strcpy (tagname, dirname);
+         nptr = tagname + dlen;
+         if (addslash)
+           *nptr++ = '/';
+       }
+      strcpy (nptr, tag->name);
+      if (access (tagname, F_OK) == 0
+         && (!tag->predicate || tag->predicate (tagname)))
+       {
+         if (tag_file_name)
+           *tag_file_name = tag->name;
+         return tag->type;
+       }
+    }
+
+  return exclusion_tag_none;
+}
+
+/* Exclusion predicate to test if the named file (usually "CACHEDIR.TAG")
+   contains a valid header, as described at:
+       http://www.brynosaurus.com/cachedir
+   Applications can write this file into directories they create
+   for use as caches containing purely regenerable, non-precious data,
+   allowing us to avoid archiving them if --exclude-caches is specified. */
+
+#define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55"
+#define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1)
+
+bool
+cachedir_file_p (const char *name)
+{
+  bool tag_present = false;
+  int fd = open (name, O_RDONLY);
+  if (fd >= 0)
+    {
+      static char tagbuf[CACHEDIR_SIGNATURE_SIZE];
+
+      if (read (fd, tagbuf, CACHEDIR_SIGNATURE_SIZE)
+         == CACHEDIR_SIGNATURE_SIZE
+         && memcmp (tagbuf, CACHEDIR_SIGNATURE, CACHEDIR_SIGNATURE_SIZE) == 0)
+       tag_present = true;
+
+      close (fd);
+    }
+  return tag_present;
+}
+
 \f
 /* The maximum uintmax_t value that can be represented with DIGITS digits,
    assuming that each digit is BITS_PER_DIGIT wide.  */
 \f
 /* The maximum uintmax_t value that can be represented with DIGITS digits,
    assuming that each digit is BITS_PER_DIGIT wide.  */
@@ -109,6 +214,73 @@ to_base256 (int negative, uintmax_t value, char *where, size_t size)
   while (i);
 }
 
   while (i);
 }
 
+
+static bool
+to_chars (int negative, uintmax_t value, size_t valsize,
+         uintmax_t (*substitute) (int *),
+         char *where, size_t size, const char *type);
+
+static bool
+to_chars_subst (int negative, int gnu_format, uintmax_t value, size_t valsize,
+               uintmax_t (*substitute) (int *),
+               char *where, size_t size, const char *type)
+{
+  uintmax_t maxval = (gnu_format
+                     ? MAX_VAL_WITH_DIGITS (size - 1, LG_256)
+                     : MAX_VAL_WITH_DIGITS (size - 1, LG_8));
+  char valbuf[UINTMAX_STRSIZE_BOUND + 1];
+  char maxbuf[UINTMAX_STRSIZE_BOUND];
+  char minbuf[UINTMAX_STRSIZE_BOUND + 1];
+  char const *minval_string;
+  char const *maxval_string = STRINGIFY_BIGINT (maxval, maxbuf);
+  char const *value_string;
+
+  if (gnu_format)
+    {
+      uintmax_t m = maxval + 1 ? maxval + 1 : maxval / 2 + 1;
+      char *p = STRINGIFY_BIGINT (m, minbuf + 1);
+      *--p = '-';
+      minval_string = p;
+    }
+  else
+    minval_string = "0";
+
+  if (negative)
+    {
+      char *p = STRINGIFY_BIGINT (- value, valbuf + 1);
+      *--p = '-';
+      value_string = p;
+    }
+  else
+    value_string = STRINGIFY_BIGINT (value, valbuf);
+
+  if (substitute)
+    {
+      int negsub;
+      uintmax_t sub = substitute (&negsub) & maxval;
+      /* NOTE: This is one of the few places where GNU_FORMAT differs from
+        OLDGNU_FORMAT.  The actual differences are:
+
+        1. In OLDGNU_FORMAT all strings in a tar header end in \0
+        2. Incremental archives use oldgnu_header.
+        
+        Apart from this they are completely identical. */
+      uintmax_t s = (negsub &= archive_format == GNU_FORMAT) ? - sub : sub;
+      char subbuf[UINTMAX_STRSIZE_BOUND + 1];
+      char *sub_string = STRINGIFY_BIGINT (s, subbuf + 1);
+      if (negsub)
+       *--sub_string = '-';
+      WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
+            value_string, type, minval_string, maxval_string,
+            sub_string));
+      return to_chars (negsub, s, valsize, 0, where, size, type);
+    }
+  else
+    ERROR ((0, 0, _("value %s out of %s range %s..%s"),
+           value_string, type, minval_string, maxval_string));
+  return false;
+}
+
 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
    external form, using SUBSTITUTE (...) if VALUE won't fit.  Output
    to buffer WHERE with size SIZE.  NEGATIVE is 1 iff VALUE was
 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
    external form, using SUBSTITUTE (...) if VALUE won't fit.  Output
    to buffer WHERE with size SIZE.  NEGATIVE is 1 iff VALUE was
@@ -123,103 +295,61 @@ to_base256 (int negative, uintmax_t value, char *where, size_t size)
    SUBSTITUTE the address of an 0-or-1 flag recording whether the
    substitute value is negative.  */
 
    SUBSTITUTE the address of an 0-or-1 flag recording whether the
    substitute value is negative.  */
 
-static void
+static bool
 to_chars (int negative, uintmax_t value, size_t valsize,
          uintmax_t (*substitute) (int *),
          char *where, size_t size, const char *type)
 {
 to_chars (int negative, uintmax_t value, size_t valsize,
          uintmax_t (*substitute) (int *),
          char *where, size_t size, const char *type)
 {
-  int base256_allowed = (archive_format == GNU_FORMAT
-                        || archive_format == OLDGNU_FORMAT);
+  int gnu_format = (archive_format == GNU_FORMAT
+                   || archive_format == OLDGNU_FORMAT);
 
   /* Generate the POSIX octal representation if the number fits.  */
   if (! negative && value <= MAX_VAL_WITH_DIGITS (size - 1, LG_8))
     {
       where[size - 1] = '\0';
       to_octal (value, where, size - 1);
 
   /* Generate the POSIX octal representation if the number fits.  */
   if (! negative && value <= MAX_VAL_WITH_DIGITS (size - 1, LG_8))
     {
       where[size - 1] = '\0';
       to_octal (value, where, size - 1);
+      return true;
     }
     }
-
-  /* Otherwise, generate the base-256 representation if we are
-     generating an old or new GNU format and if the number fits.  */
-  else if (((negative ? -1 - value : value)
-           <= MAX_VAL_WITH_DIGITS (size - 1, LG_256))
-          && base256_allowed)
-    {
-      where[0] = negative ? -1 : 1 << (LG_256 - 1);
-      to_base256 (negative, value, where + 1, size - 1);
-    }
-
-  /* Otherwise, if the number is negative, and if it would not cause
-     ambiguity on this host by confusing positive with negative
-     values, then generate the POSIX octal representation of the value
-     modulo 2**(field bits).  The resulting tar file is
-     machine-dependent, since it depends on the host word size.  Yuck!
-     But this is the traditional behavior.  */
-  else if (negative && valsize * CHAR_BIT <= (size - 1) * LG_8)
-    {
-      static int warned_once;
-      if (! warned_once)
-       {
-         warned_once = 1;
-         WARN ((0, 0, _("Generating negative octal headers")));
-       }
-      where[size - 1] = '\0';
-      to_octal (value & MAX_VAL_WITH_DIGITS (valsize * CHAR_BIT, 1),
-               where, size - 1);
-    }
-
-  /* Otherwise, output a substitute value if possible (with a
-     warning), and an error message if not.  */
-  else
+  else if (gnu_format)
     {
     {
-      uintmax_t maxval = (base256_allowed
-                         ? MAX_VAL_WITH_DIGITS (size - 1, LG_256)
-                         : MAX_VAL_WITH_DIGITS (size - 1, LG_8));
-      char valbuf[UINTMAX_STRSIZE_BOUND + 1];
-      char maxbuf[UINTMAX_STRSIZE_BOUND];
-      char minbuf[UINTMAX_STRSIZE_BOUND + 1];
-      char const *minval_string;
-      char const *maxval_string = STRINGIFY_BIGINT (maxval, maxbuf);
-      char const *value_string;
-
-      if (base256_allowed)
-       {
-         uintmax_t m = maxval + 1 ? maxval + 1 : maxval / 2 + 1;
-         char *p = STRINGIFY_BIGINT (m, minbuf + 1);
-         *--p = '-';
-         minval_string = p;
-       }
-      else
-       minval_string = "0";
+      /* Try to cope with the number by using traditional GNU format
+        methods */
 
 
-      if (negative)
+      /* Generate the base-256 representation if the number fits.  */
+      if (((negative ? -1 - value : value)
+          <= MAX_VAL_WITH_DIGITS (size - 1, LG_256)))
        {
        {
-         char *p = STRINGIFY_BIGINT (- value, valbuf + 1);
-         *--p = '-';
-         value_string = p;
+         where[0] = negative ? -1 : 1 << (LG_256 - 1);
+         to_base256 (negative, value, where + 1, size - 1);
+         return true;
        }
        }
-      else
-       value_string = STRINGIFY_BIGINT (value, valbuf);
 
 
-      if (substitute)
+      /* Otherwise, if the number is negative, and if it would not cause
+        ambiguity on this host by confusing positive with negative
+        values, then generate the POSIX octal representation of the value
+        modulo 2**(field bits).  The resulting tar file is
+        machine-dependent, since it depends on the host word size.  Yuck!
+        But this is the traditional behavior.  */
+      else if (negative && valsize * CHAR_BIT <= (size - 1) * LG_8)
        {
        {
-         int negsub;
-         uintmax_t sub = substitute (&negsub) & maxval;
-         /* FIXME: This is the only place where GNU_FORMAT differs from
-             OLDGNU_FORMAT. 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));
-         to_chars (negsub, s, valsize, 0, where, size, type);
+         static int warned_once;
+         if (! warned_once)
+           {
+             warned_once = 1;
+             WARN ((0, 0, _("Generating negative octal headers")));
+           }
+         where[size - 1] = '\0';
+         to_octal (value & MAX_VAL_WITH_DIGITS (valsize * CHAR_BIT, 1),
+                   where, size - 1);
+         return true;
        }
        }
-      else
-       ERROR ((0, 0, _("value %s out of %s range %s..%s"),
-               value_string, type, minval_string, maxval_string));
+      /* Otherwise fall back to substitution, if possible: */
     }
     }
+  else
+    substitute = NULL; /* No substitution for formats, other than GNU */
+
+  return to_chars_subst (negative, gnu_format, value, valsize, substitute,
+                        where, size, type);
 }
 
 static uintmax_t
 }
 
 static uintmax_t
@@ -238,25 +368,25 @@ gid_substitute (int *negative)
   return r;
 }
 
   return r;
 }
 
-void
+bool
 gid_to_chars (gid_t v, char *p, size_t s)
 {
 gid_to_chars (gid_t v, char *p, size_t s)
 {
-  to_chars (v < 0, (uintmax_t) v, sizeof v, gid_substitute, p, s, "gid_t");
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, gid_substitute, p, s, "gid_t");
 }
 
 }
 
-void
+bool
 major_to_chars (major_t v, char *p, size_t s)
 {
 major_to_chars (major_t v, char *p, size_t s)
 {
-  to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "major_t");
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "major_t");
 }
 
 }
 
-void
+bool
 minor_to_chars (minor_t v, char *p, size_t s)
 {
 minor_to_chars (minor_t v, char *p, size_t s)
 {
-  to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "minor_t");
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "minor_t");
 }
 
 }
 
-void
+bool
 mode_to_chars (mode_t v, char *p, size_t s)
 {
   /* In the common case where the internal and external mode bits are the same,
 mode_to_chars (mode_t v, char *p, size_t s)
 {
   /* In the common case where the internal and external mode bits are the same,
@@ -272,7 +402,8 @@ mode_to_chars (mode_t v, char *p, size_t s)
       && S_IROTH == TOREAD && S_IWOTH == TOWRITE && S_IXOTH == TOEXEC
       && archive_format != POSIX_FORMAT
       && archive_format != USTAR_FORMAT
       && S_IROTH == TOREAD && S_IWOTH == TOWRITE && S_IXOTH == TOEXEC
       && archive_format != POSIX_FORMAT
       && archive_format != USTAR_FORMAT
-      && archive_format != GNU_FORMAT)
+      && archive_format != GNU_FORMAT
+      && archive_format != OLDGNU_FORMAT)
     {
       negative = v < 0;
       u = v;
     {
       negative = v < 0;
       u = v;
@@ -293,25 +424,25 @@ mode_to_chars (mode_t v, char *p, size_t s)
           | (v & S_IWOTH ? TOWRITE : 0)
           | (v & S_IXOTH ? TOEXEC : 0));
     }
           | (v & S_IWOTH ? TOWRITE : 0)
           | (v & S_IXOTH ? TOEXEC : 0));
     }
-  to_chars (negative, u, sizeof v, 0, p, s, "mode_t");
+  return to_chars (negative, u, sizeof v, 0, p, s, "mode_t");
 }
 
 }
 
-void
+bool
 off_to_chars (off_t v, char *p, size_t s)
 {
 off_to_chars (off_t v, char *p, size_t s)
 {
-  to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "off_t");
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "off_t");
 }
 
 }
 
-void
+bool
 size_to_chars (size_t v, char *p, size_t s)
 {
 size_to_chars (size_t v, char *p, size_t s)
 {
-  to_chars (0, (uintmax_t) v, sizeof v, 0, p, s, "size_t");
+  return to_chars (0, (uintmax_t) v, sizeof v, 0, p, s, "size_t");
 }
 
 }
 
-void
+bool
 time_to_chars (time_t v, char *p, size_t s)
 {
 time_to_chars (time_t v, char *p, size_t s)
 {
-  to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "time_t");
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "time_t");
 }
 
 static uintmax_t
 }
 
 static uintmax_t
@@ -330,16 +461,16 @@ uid_substitute (int *negative)
   return r;
 }
 
   return r;
 }
 
-void
+bool
 uid_to_chars (uid_t v, char *p, size_t s)
 {
 uid_to_chars (uid_t v, char *p, size_t s)
 {
-  to_chars (v < 0, (uintmax_t) v, sizeof v, uid_substitute, p, s, "uid_t");
+  return to_chars (v < 0, (uintmax_t) v, sizeof v, uid_substitute, p, s, "uid_t");
 }
 
 }
 
-void
+bool
 uintmax_to_chars (uintmax_t v, char *p, size_t s)
 {
 uintmax_to_chars (uintmax_t v, char *p, size_t s)
 {
-  to_chars (0, v, sizeof v, 0, p, s, "uintmax_t");
+  return to_chars (0, v, sizeof v, 0, p, s, "uintmax_t");
 }
 
 void
 }
 
 void
@@ -361,7 +492,7 @@ bool
 file_dumpable_p (struct tar_stat_info *st)
 {
   if (dev_null_output)
 file_dumpable_p (struct tar_stat_info *st)
 {
   if (dev_null_output)
-    return totals_option && sparse_option && sparse_file_p (st);
+    return totals_option && sparse_option && ST_IS_SPARSE (st->stat);
   return !(st->archive_file_size == 0
           && (st->stat.st_mode & MODE_R) == MODE_R);
 }
   return !(st->archive_file_size == 0
           && (st->stat.st_mode & MODE_R) == MODE_R);
 }
@@ -475,7 +606,7 @@ split_long_name (const char *name, size_t length)
   size_t i;
 
   if (length > PREFIX_FIELD_SIZE)
   size_t i;
 
   if (length > PREFIX_FIELD_SIZE)
-    length = PREFIX_FIELD_SIZE+2;
+    length = PREFIX_FIELD_SIZE + 1;
   for (i = length - 1; i > 0; i--)
     if (ISSLASH (name[i]))
       break;
   for (i = length - 1; i > 0; i--)
     if (ISSLASH (name[i]))
       break;
@@ -576,19 +707,29 @@ write_long_name (struct tar_stat_info *st)
   return write_short_name (st);
 }
 
   return write_short_name (st);
 }
 
-static union block *
-write_extended (struct tar_stat_info *st, union block *old_header)
+union block *
+write_extended (bool global, struct tar_stat_info *st, union block *old_header)
 {
   union block *header, hp;
   char *p;
 {
   union block *header, hp;
   char *p;
+  int type;
 
 
-  if (extended_header.buffer || extended_header.stk == NULL)
+  if (st->xhdr.buffer || st->xhdr.stk == NULL)
     return old_header;
 
     return old_header;
 
-  xheader_finish (&extended_header);
+  xheader_finish (&st->xhdr);
   memcpy (hp.buffer, old_header, sizeof (hp));
   memcpy (hp.buffer, old_header, sizeof (hp));
-  p = xheader_xhdr_name (st);
-  xheader_write (XHDTYPE, p, &extended_header);
+  if (global)
+    {
+      type = XGLTYPE;
+      p = xheader_ghdr_name ();
+    }
+  else
+    {
+      type = XHDTYPE;
+      p = xheader_xhdr_name (st);
+    }
+  xheader_write (type, p, &st->xhdr);
   free (p);
   header = find_next_block ();
   memcpy (header, &hp.buffer, sizeof (hp.buffer));
   free (p);
   header = find_next_block ();
   memcpy (header, &hp.buffer, sizeof (hp.buffer));
@@ -634,7 +775,8 @@ start_header (struct tar_stat_info *st)
   if (mode_option)
     st->stat.st_mode =
       ((st->stat.st_mode & ~MODE_ALL)
   if (mode_option)
     st->stat.st_mode =
       ((st->stat.st_mode & ~MODE_ALL)
-       | mode_adjust (st->stat.st_mode, mode_option, initial_umask));
+       | mode_adjust (st->stat.st_mode, S_ISDIR (st->stat.st_mode) != 0,
+                     initial_umask, mode_option, NULL));
 
   /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
      for a few tars and came up with the following interoperability
 
   /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
      for a few tars and came up with the following interoperability
@@ -672,7 +814,8 @@ start_header (struct tar_stat_info *st)
        xheader_store ("uid", st, NULL);
        uid = 0;
       }
        xheader_store ("uid", st, NULL);
        uid = 0;
       }
-    UID_TO_CHARS (uid, header->header.uid);
+    if (!UID_TO_CHARS (uid, header->header.uid))
+      return NULL;
   }
 
   {
   }
 
   {
@@ -683,7 +826,8 @@ start_header (struct tar_stat_info *st)
        xheader_store ("gid", st, NULL);
        gid = 0;
       }
        xheader_store ("gid", st, NULL);
        gid = 0;
       }
-    GID_TO_CHARS (gid, header->header.gid);
+    if (!GID_TO_CHARS (gid, header->header.gid))
+      return NULL;
   }
 
   {
   }
 
   {
@@ -694,20 +838,22 @@ start_header (struct tar_stat_info *st)
        xheader_store ("size", st, NULL);
        size = 0;
       }
        xheader_store ("size", st, NULL);
        size = 0;
       }
-    OFF_TO_CHARS (size, header->header.size);
+    if (!OFF_TO_CHARS (size, header->header.size))
+      return NULL;
   }
 
   {
   }
 
   {
-    struct timespec mtime = st->mtime;
+    struct timespec mtime = set_mtime_option ? mtime_option : st->mtime;
     if (archive_format == POSIX_FORMAT)
       {
        if (MAX_OCTAL_VAL (header->header.mtime) < mtime.tv_sec
            || mtime.tv_nsec != 0)
     if (archive_format == POSIX_FORMAT)
       {
        if (MAX_OCTAL_VAL (header->header.mtime) < mtime.tv_sec
            || mtime.tv_nsec != 0)
-         xheader_store ("mtime", st, NULL);
+         xheader_store ("mtime", st, &mtime);
        if (MAX_OCTAL_VAL (header->header.mtime) < mtime.tv_sec)
          mtime.tv_sec = 0;
       }
        if (MAX_OCTAL_VAL (header->header.mtime) < mtime.tv_sec)
          mtime.tv_sec = 0;
       }
-    TIME_TO_CHARS (mtime.tv_sec, header->header.mtime);
+    if (!TIME_TO_CHARS (mtime.tv_sec, header->header.mtime))
+      return NULL;
   }
 
   /* FIXME */
   }
 
   /* FIXME */
@@ -723,7 +869,8 @@ start_header (struct tar_stat_info *st)
          xheader_store ("devmajor", st, NULL);
          devmajor = 0;
        }
          xheader_store ("devmajor", st, NULL);
          devmajor = 0;
        }
-      MAJOR_TO_CHARS (devmajor, header->header.devmajor);
+      if (!MAJOR_TO_CHARS (devmajor, header->header.devmajor))
+       return NULL;
 
       if (archive_format == POSIX_FORMAT
          && MAX_OCTAL_VAL (header->header.devminor) < devminor)
 
       if (archive_format == POSIX_FORMAT
          && MAX_OCTAL_VAL (header->header.devminor) < devminor)
@@ -731,12 +878,14 @@ start_header (struct tar_stat_info *st)
          xheader_store ("devminor", st, NULL);
          devminor = 0;
        }
          xheader_store ("devminor", st, NULL);
          devminor = 0;
        }
-      MINOR_TO_CHARS (devminor, header->header.devminor);
+      if (!MINOR_TO_CHARS (devminor, header->header.devminor))
+       return NULL;
     }
   else if (archive_format != GNU_FORMAT && archive_format != OLDGNU_FORMAT)
     {
     }
   else if (archive_format != GNU_FORMAT && archive_format != OLDGNU_FORMAT)
     {
-      MAJOR_TO_CHARS (0, header->header.devmajor);
-      MINOR_TO_CHARS (0, header->header.devminor);
+      if (!(MAJOR_TO_CHARS (0, header->header.devmajor)
+           && MINOR_TO_CHARS (0, header->header.devminor)))
+       return NULL;
     }
 
   if (archive_format == POSIX_FORMAT)
     }
 
   if (archive_format == POSIX_FORMAT)
@@ -852,7 +1001,7 @@ finish_header (struct tar_stat_info *st,
       print_header (st, block_ordinal);
     }
 
       print_header (st, block_ordinal);
     }
 
-  header = write_extended (st, header);
+  header = write_extended (false, st, header);
   simple_finish_header (header);
 }
 \f
   simple_finish_header (header);
 }
 \f
@@ -863,7 +1012,7 @@ pad_archive (off_t size_left)
   union block *blk;
   while (size_left > 0)
     {
   union block *blk;
   while (size_left > 0)
     {
-      save_sizeleft = size_left;
+      mv_size_left (size_left);
       blk = find_next_block ();
       memset (blk->buffer, 0, BLOCKSIZE);
       set_next_block_after (blk);
       blk = find_next_block ();
       memset (blk->buffer, 0, BLOCKSIZE);
       set_next_block_after (blk);
@@ -889,16 +1038,13 @@ dump_regular_file (int fd, struct tar_stat_info *st)
 
   finish_header (st, blk, block_ordinal);
 
 
   finish_header (st, blk, block_ordinal);
 
+  mv_begin (st);
   while (size_left > 0)
     {
       size_t bufsize, count;
   while (size_left > 0)
     {
       size_t bufsize, count;
+      
+      mv_size_left (size_left);
 
 
-      if (multi_volume_option)
-       {
-         assign_string (&save_name, st->orig_file_name);
-         save_sizeleft = size_left;
-         save_totsize = st->stat.st_size;
-       }
       blk = find_next_block ();
 
       bufsize = available_space_after (blk);
       blk = find_next_block ();
 
       bufsize = available_space_after (blk);
@@ -921,104 +1067,36 @@ dump_regular_file (int fd, struct tar_stat_info *st)
          return dump_status_short;
        }
       size_left -= count;
          return dump_status_short;
        }
       size_left -= count;
-      if (count)
-       set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
+      set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
 
       if (count != bufsize)
        {
          char buf[UINTMAX_STRSIZE_BOUND];
          memset (blk->buffer + count, 0, bufsize - count);
 
       if (count != bufsize)
        {
          char buf[UINTMAX_STRSIZE_BOUND];
          memset (blk->buffer + count, 0, bufsize - count);
-         WARN ((0, 0,
-                ngettext ("%s: File shrank by %s byte; padding with zeros",
-                          "%s: File shrank by %s bytes; padding with zeros",
-                          size_left),
-                quotearg_colon (st->orig_file_name),
-                STRINGIFY_BIGINT (size_left, buf)));
-         if (! ignore_failed_read_option)
-           exit_status = TAREXIT_FAILURE;
-         pad_archive (size_left - (bufsize-count));
+         WARNOPT (WARN_FILE_SHRANK,
+                  (0, 0,
+                   ngettext ("%s: File shrank by %s byte; padding with zeros",
+                             "%s: File shrank by %s bytes; padding with zeros",
+                             size_left),
+                   quotearg_colon (st->orig_file_name),
+                   STRINGIFY_BIGINT (size_left, buf)));
+         if (! ignore_failed_read_option) 
+           exit_status = TAREXIT_DIFFERS;
+         pad_archive (size_left - (bufsize - count));
          return dump_status_short;
        }
     }
   return dump_status_ok;
 }
 
          return dump_status_short;
        }
     }
   return dump_status_ok;
 }
 
-static void
-dump_regular_finish (int fd, struct tar_stat_info *st,
-                    struct timespec original_ctime)
-{
-  if (fd >= 0)
-    {
-      struct stat final_stat;
-      if (fstat (fd, &final_stat) != 0)
-       {
-         stat_diag (st->orig_file_name);
-       }
-      else if (timespec_cmp (get_stat_ctime (&final_stat), original_ctime)
-              != 0)
-       {
-         WARN ((0, 0, _("%s: file changed as we read it"),
-                quotearg_colon (st->orig_file_name)));
-       }
-      if (close (fd) != 0)
-       {
-         close_diag (st->orig_file_name);
-       }
-    }
-  if (remove_files_option)
-    {
-      if (unlink (st->orig_file_name) == -1)
-       unlink_error (st->orig_file_name);
-    }
-}
-
-/* Look in directory DIRNAME for a cache directory tag file
-   with the magic name "CACHEDIR.TAG" and a standard header,
-   as described at:
-       http://www.brynosaurus.com/cachedir
-   Applications can write this file into directories they create
-   for use as caches containing purely regenerable, non-precious data,
-   allowing us to avoid archiving them if --exclude-caches is specified. */
-
-#define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55"
-#define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1)
-
-static bool
-check_cache_directory (char *dirname)
-{
-  static char tagname[] = "CACHEDIR.TAG";
-  char *tagpath;
-  int fd;
-  int tag_present = false;
-
-  tagpath = xmalloc (strlen (dirname) + strlen (tagname) + 1);
-  strcpy (tagpath, dirname);
-  strcat (tagpath, tagname);
-
-  fd = open (tagpath, O_RDONLY);
-  if (fd >= 0)
-    {
-      static char tagbuf[CACHEDIR_SIGNATURE_SIZE];
-
-      if (read (fd, tagbuf, CACHEDIR_SIGNATURE_SIZE)
-         == CACHEDIR_SIGNATURE_SIZE
-         && memcmp (tagbuf, CACHEDIR_SIGNATURE, CACHEDIR_SIGNATURE_SIZE) == 0)
-       tag_present = true;
-
-      close (fd);
-    }
-
-  free (tagpath);
-
-  return tag_present;
-}
-
+\f
 static void
 dump_dir0 (char *directory,
           struct tar_stat_info *st, int top_level, dev_t parent_device)
 {
   dev_t our_device = st->stat.st_dev;
 static void
 dump_dir0 (char *directory,
           struct tar_stat_info *st, int top_level, dev_t parent_device)
 {
   dev_t our_device = st->stat.st_dev;
-
+  const char *tag_file_name;
+  
   if (!is_avoided_name (st->orig_file_name))
     {
       union block *blk = NULL;
   if (!is_avoided_name (st->orig_file_name))
     {
       union block *blk = NULL;
@@ -1029,7 +1107,7 @@ dump_dir0 (char *directory,
       if (!blk)
        return;
 
       if (!blk)
        return;
 
-      if (incremental_option)
+      if (incremental_option && archive_format != POSIX_FORMAT)
        blk->header.typeflag = GNUTYPE_DUMPDIR;
       else /* if (standard_option) */
        blk->header.typeflag = DIRTYPE;
        blk->header.typeflag = GNUTYPE_DUMPDIR;
       else /* if (standard_option) */
        blk->header.typeflag = DIRTYPE;
@@ -1040,51 +1118,51 @@ dump_dir0 (char *directory,
        finish_header (st, blk, block_ordinal);
       else if (gnu_list_name->dir_contents)
        {
        finish_header (st, blk, block_ordinal);
       else if (gnu_list_name->dir_contents)
        {
-         off_t size_left;
-         off_t totsize;
-         size_t bufsize;
-         ssize_t count;
-         const char *buffer, *p_buffer;
-
-         block_ordinal = current_block_ordinal ();
-         buffer = gnu_list_name->dir_contents; /* FOO */
-         totsize = 0;
-         if (buffer)
-           for (p_buffer = buffer; *p_buffer; )
-             {
-               size_t size = strlen (p_buffer) + 1;
-               totsize += size;
-               p_buffer += size;
-             }
-         totsize++;
-         OFF_TO_CHARS (totsize, blk->header.size);
-         finish_header (st, blk, block_ordinal);
-         p_buffer = buffer;
-         size_left = totsize;
-         while (size_left > 0)
+         if (archive_format == POSIX_FORMAT)
            {
            {
-             if (multi_volume_option)
-               {
-                 assign_string (&save_name, st->orig_file_name);
-                 save_sizeleft = size_left;
-                 save_totsize = totsize;
-               }
-             blk = find_next_block ();
-             bufsize = available_space_after (blk);
-             if (size_left < bufsize)
+             xheader_store ("GNU.dumpdir", st, gnu_list_name->dir_contents);
+             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 = gnu_list_name->dir_contents;
+             if (buffer)
+               totsize = dumpdir_size (buffer);
+             else
+               totsize = 0;
+             OFF_TO_CHARS (totsize, blk->header.size);
+             finish_header (st, blk, block_ordinal);
+             p_buffer = buffer;
+             size_left = totsize;
+
+             mv_begin (st);
+             mv_total_size (totsize);
+             while (size_left > 0)
                {
                {
-                 bufsize = size_left;
-                 count = bufsize % BLOCKSIZE;
-                 if (count)
-                   memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
+                 mv_size_left (size_left);
+                 blk = find_next_block ();
+                 bufsize = available_space_after (blk);
+                 if (size_left < bufsize)
+                   {
+                     bufsize = size_left;
+                     count = bufsize % BLOCKSIZE;
+                     if (count)
+                       memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
+                   }
+                 memcpy (blk->buffer, p_buffer, bufsize);
+                 size_left -= bufsize;
+                 p_buffer += bufsize;
+                 set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
                }
                }
-             memcpy (blk->buffer, p_buffer, bufsize);
-             size_left -= bufsize;
-             p_buffer += bufsize;
-             set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
+             mv_end ();
            }
            }
-         if (multi_volume_option)
-           assign_string (&save_name, 0);
          return;
        }
     }
          return;
        }
     }
@@ -1097,47 +1175,67 @@ dump_dir0 (char *directory,
       && parent_device != st->stat.st_dev)
     {
       if (verbose_option)
       && parent_device != st->stat.st_dev)
     {
       if (verbose_option)
-       WARN ((0, 0,
-              _("%s: file is on a different filesystem; not dumped"),
-              quotearg_colon (st->orig_file_name)));
-      return;
+       WARNOPT (WARN_XDEV,
+                (0, 0,
+                 _("%s: file is on a different filesystem; not dumped"),
+                 quotearg_colon (st->orig_file_name)));
     }
     }
-
-  if (exclude_caches_option
-      && check_cache_directory(st->orig_file_name))
+  else
     {
     {
-      if (verbose_option)
-       WARN ((0, 0,
-              _("%s: contains a cache directory tag; not dumped"),
-              quotearg_colon (st->orig_file_name)));
-      return;
-    }
-
-  {
-    char const *entry;
-    size_t entry_len;
-    char *name_buf = xstrdup (st->orig_file_name);
-    size_t name_size = strlen (name_buf);
-    size_t name_len = name_size;
+      char *name_buf;
+      size_t name_size;
+      
+      switch (check_exclusion_tags (st->orig_file_name, &tag_file_name))
+       {
+       case exclusion_tag_all:
+         /* Handled in dump_file0 */
+         break;
+         
+       case exclusion_tag_none:
+         {
+           char const *entry;
+           size_t entry_len;
+           size_t name_len;
 
 
-    /* Now output all the files in the directory.  */
-    /* FIXME: Should speed this up by cd-ing into the dir.  */
+           name_buf = xstrdup (st->orig_file_name);
+           name_size = name_len = strlen (name_buf);
 
 
-    for (entry = directory; (entry_len = strlen (entry)) != 0;
-        entry += entry_len + 1)
-      {
-       if (name_size < name_len + entry_len)
-         {
-           name_size = name_len + entry_len;
-           name_buf = xrealloc (name_buf, name_size + 1);
+           /* Now output all the files in the directory.  */
+           /* FIXME: Should speed this up by cd-ing into the dir.  */
+           for (entry = directory; (entry_len = strlen (entry)) != 0;
+                entry += entry_len + 1)
+             {
+               if (name_size < name_len + entry_len)
+                 {
+                   name_size = name_len + entry_len;
+                   name_buf = xrealloc (name_buf, name_size + 1);
+                 }
+               strcpy (name_buf + name_len, entry);
+               if (!excluded_name (name_buf))
+                 dump_file (name_buf, 0, our_device);
+             }
+           
+           free (name_buf);
          }
          }
-       strcpy (name_buf + name_len, entry);
-       if (!excluded_name (name_buf))
+         break;
+
+       case exclusion_tag_contents:
+         exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                _("contents not dumped"));
+         name_size = strlen (st->orig_file_name) + strlen (tag_file_name) + 1;
+         name_buf = xmalloc (name_size);
+         strcpy (name_buf, st->orig_file_name);
+         strcat (name_buf, tag_file_name);
          dump_file (name_buf, 0, our_device);
          dump_file (name_buf, 0, our_device);
-      }
-
-    free (name_buf);
-  }
+         free (name_buf);
+         break;
+      
+       case exclusion_tag_under:
+         exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                _("contents not dumped"));
+         break;
+       }
+    }
 }
 
 /* Ensure exactly one trailing slash.  */
 }
 
 /* Ensure exactly one trailing slash.  */
@@ -1154,20 +1252,15 @@ ensure_slash (char **pstr)
 }
 
 static bool
 }
 
 static bool
-dump_dir (struct tar_stat_info *st, int top_level, dev_t parent_device)
+dump_dir (int fd, struct tar_stat_info *st, int top_level, dev_t parent_device)
 {
 {
-  char *directory;
-
-  directory = savedir (st->orig_file_name);
+  char *directory = fdsavedir (fd);
   if (!directory)
     {
       savedir_diag (st->orig_file_name);
       return false;
     }
 
   if (!directory)
     {
       savedir_diag (st->orig_file_name);
       return false;
     }
 
-  ensure_slash (&st->orig_file_name);
-  ensure_slash (&st->file_name);
-
   dump_dir0 (directory, st, top_level, parent_device);
 
   free (directory);
   dump_dir0 (directory, st, top_level, parent_device);
 
   free (directory);
@@ -1180,10 +1273,10 @@ dump_dir (struct tar_stat_info *st, int top_level, dev_t parent_device)
 void
 create_archive (void)
 {
 void
 create_archive (void)
 {
-  char *p;
+  const char *p;
 
   open_archive (ACCESS_WRITE);
 
   open_archive (ACCESS_WRITE);
-  xheader_write_global ();
+  buffer_write_global_xheader ();
 
   if (incremental_option)
     {
 
   if (incremental_option)
     {
@@ -1210,7 +1303,7 @@ create_archive (void)
              }
            memcpy (buffer, p, plen);
            if (! ISSLASH (buffer[plen - 1]))
              }
            memcpy (buffer, p, plen);
            if (! ISSLASH (buffer[plen - 1]))
-             buffer[plen++] = '/';
+             buffer[plen++] = DIRECTORY_SEPARATOR;
            q = gnu_list_name->dir_contents;
            if (q)
              while (*q)
            q = gnu_list_name->dir_contents;
            if (q)
              while (*q)
@@ -1266,10 +1359,11 @@ compare_links (void const *entry1, void const *entry2)
 }
 
 static void
 }
 
 static void
-unknown_file_error (char *p)
+unknown_file_error (char const *p)
 {
 {
-  WARN ((0, 0, _("%s: Unknown file type; file ignored"),
-        quotearg_colon (p)));
+  WARNOPT (WARN_FILE_IGNORED,
+          (0, 0, _("%s: Unknown file type; file ignored"),
+           quotearg_colon (p)));
   if (!ignore_failed_read_option)
     exit_status = TAREXIT_FAILURE;
 }
   if (!ignore_failed_read_option)
     exit_status = TAREXIT_FAILURE;
 }
@@ -1282,12 +1376,12 @@ unknown_file_error (char *p)
    again if we've done it once already.  */
 static Hash_table *link_table;
 
    again if we've done it once already.  */
 static Hash_table *link_table;
 
-/* Try to dump stat as a hard link to another file in the archive. If
-   succeeded returns true */
+/* Try to dump stat as a hard link to another file in the archive.
+   Return true if successful.  */
 static bool
 dump_hard_link (struct tar_stat_info *st)
 {
 static bool
 dump_hard_link (struct tar_stat_info *st)
 {
-  if (link_table && st->stat.st_nlink > 1)
+  if (link_table && (st->stat.st_nlink > 1 || remove_files_option))
     {
       struct link lp;
       struct link *duplicate;
     {
       struct link lp;
       struct link *duplicate;
@@ -1314,7 +1408,7 @@ dump_hard_link (struct tar_stat_info *st)
          st->stat.st_size = 0;
          blk = start_header (st);
          if (!blk)
          st->stat.st_size = 0;
          blk = start_header (st);
          if (!blk)
-           return true;
+           return false;
          tar_copy_str (blk->header.linkname, link_name, NAME_FIELD_SIZE);
 
          blk->header.typeflag = LNKTYPE;
          tar_copy_str (blk->header.linkname, link_name, NAME_FIELD_SIZE);
 
          blk->header.typeflag = LNKTYPE;
@@ -1332,22 +1426,31 @@ dump_hard_link (struct tar_stat_info *st)
 static void
 file_count_links (struct tar_stat_info *st)
 {
 static void
 file_count_links (struct tar_stat_info *st)
 {
+  if (hard_dereference_option)
+    return;
   if (st->stat.st_nlink > 1)
     {
       struct link *duplicate;
   if (st->stat.st_nlink > 1)
     {
       struct link *duplicate;
-      struct link *lp = xmalloc (offsetof (struct link, name)
-                                + strlen (st->orig_file_name) + 1);
+      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;
       lp->ino = st->stat.st_ino;
       lp->dev = st->stat.st_dev;
       lp->nlink = st->stat.st_nlink;
-      strcpy (lp->name, st->orig_file_name);
-
+      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 (! ((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 (duplicate != lp)
        abort ();
       lp->nlink--;
@@ -1369,7 +1472,7 @@ check_links (void)
     {
       if (lp->nlink)
        {
     {
       if (lp->nlink)
        {
-         WARN ((0, 0, _("Missing links to %s.\n"), quote (lp->name)));
+         WARN ((0, 0, _("Missing links to %s."), quote (lp->name)));
        }
     }
 }
        }
     }
 }
@@ -1385,14 +1488,16 @@ check_links (void)
    exit_status to failure, a clear diagnostic has been issued.  */
 
 static void
    exit_status to failure, a clear diagnostic has been issued.  */
 
 static void
-dump_file0 (struct tar_stat_info *st, char *p,
+dump_file0 (struct tar_stat_info *st, const char *p,
            int top_level, dev_t parent_device)
 {
   union block *header;
   char type;
            int top_level, dev_t parent_device)
 {
   union block *header;
   char type;
+  off_t original_size;
   struct timespec original_ctime;
   struct timespec restore_times[2];
   off_t block_ordinal = -1;
   struct timespec original_ctime;
   struct timespec restore_times[2];
   off_t block_ordinal = -1;
+  bool is_dir;
 
   if (interactive_option && !confirm ("add", p))
     return;
 
   if (interactive_option && !confirm ("add", p))
     return;
@@ -1401,12 +1506,14 @@ dump_file0 (struct tar_stat_info *st, char *p,
   assign_string (&st->file_name,
                  safer_name_suffix (p, false, absolute_names_option));
 
   assign_string (&st->file_name,
                  safer_name_suffix (p, false, absolute_names_option));
 
+  transform_name (&st->file_name, XFORM_REGFILE);
+
   if (deref_stat (dereference_option, p, &st->stat) != 0)
     {
       stat_diag (p);
       return;
     }
   if (deref_stat (dereference_option, p, &st->stat) != 0)
     {
       stat_diag (p);
       return;
     }
-  st->archive_file_size = st->stat.st_size;
+  st->archive_file_size = original_size = st->stat.st_size;
   st->atime = restore_times[0] = get_stat_atime (&st->stat);
   st->mtime = restore_times[1] = get_stat_mtime (&st->stat);
   st->ctime = original_ctime = get_stat_ctime (&st->stat);
   st->atime = restore_times[0] = get_stat_atime (&st->stat);
   st->mtime = restore_times[1] = get_stat_mtime (&st->stat);
   st->ctime = original_ctime = get_stat_ctime (&st->stat);
@@ -1426,70 +1533,90 @@ dump_file0 (struct tar_stat_info *st, char *p,
 
   /* See if we want only new files, and check if this one is too old to
      put in the archive.
 
   /* See if we want only new files, and check if this one is too old to
      put in the archive.
-
+     
      This check is omitted if incremental_option is set *and* the
      requested file is not explicitely listed in the command line. */
      This check is omitted if incremental_option is set *and* the
      requested file is not explicitely listed in the command line. */
-
+  
   if (!(incremental_option && !is_individual_file (p))
       && !S_ISDIR (st->stat.st_mode)
       && OLDER_TAR_STAT_TIME (*st, m)
       && (!after_date_option || OLDER_TAR_STAT_TIME (*st, c)))
     {
       if (!incremental_option && verbose_option)
   if (!(incremental_option && !is_individual_file (p))
       && !S_ISDIR (st->stat.st_mode)
       && OLDER_TAR_STAT_TIME (*st, m)
       && (!after_date_option || OLDER_TAR_STAT_TIME (*st, c)))
     {
       if (!incremental_option && verbose_option)
-       WARN ((0, 0, _("%s: file is unchanged; not dumped"),
-              quotearg_colon (p)));
+       WARNOPT (WARN_FILE_UNCHANGED,
+                (0, 0, _("%s: file is unchanged; not dumped"),
+                 quotearg_colon (p)));
       return;
     }
 
   /* See if we are trying to dump the archive.  */
   if (sys_file_is_archive (st))
     {
       return;
     }
 
   /* See if we are trying to dump the archive.  */
   if (sys_file_is_archive (st))
     {
-      WARN ((0, 0, _("%s: file is the archive; not dumped"),
-            quotearg_colon (p)));
+      WARNOPT (WARN_IGNORE_ARCHIVE,
+              (0, 0, _("%s: file is the archive; not dumped"),
+               quotearg_colon (p)));
       return;
     }
 
   if (is_avoided_name (p))
     return;
       return;
     }
 
   if (is_avoided_name (p))
     return;
-  if (S_ISDIR (st->stat.st_mode))
-    {
-      dump_dir (st, top_level, parent_device);
-      if (atime_preserve_option)
-       utimens (p, restore_times);
-      return;
-    }
-  else
+
+  is_dir = S_ISDIR (st->stat.st_mode) != 0;
+
+  if (!is_dir && dump_hard_link (st))
+    return;
+
+  if (is_dir || S_ISREG (st->stat.st_mode) || S_ISCTG (st->stat.st_mode))
     {
     {
-      /* Check for multiple links.  */
-      if (dump_hard_link (st))
-       return;
+      bool ok;
+      int fd = -1;
+      struct stat final_stat;
 
 
-      /* This is not a link to a previously dumped file, so dump it.  */
+      if (is_dir || file_dumpable_p (st))
+       {
+         fd = open (p,
+                    (O_RDONLY | O_BINARY
+                     | (is_dir ? O_DIRECTORY | O_NONBLOCK : 0)
+                     | (atime_preserve_option == system_atime_preserve
+                        ? O_NOATIME
+                        : 0)));
+         if (fd < 0)
+           {
+             if (!top_level && errno == ENOENT)
+               WARNOPT (WARN_FILE_REMOVED,
+                        (0, 0, _("%s: File removed before we read it"),
+                         quotearg_colon (p)));
+             else
+               open_diag (p);
+             return;
+           }
+       }
 
 
-      if (S_ISREG (st->stat.st_mode)
-         || S_ISCTG (st->stat.st_mode))
+      if (is_dir)
        {
        {
-         int fd;
-         enum dump_status status;
+         const char *tag_file_name;
+         ensure_slash (&st->orig_file_name);
+         ensure_slash (&st->file_name);
 
 
-         if (file_dumpable_p (st))
+         if (check_exclusion_tags (st->orig_file_name, &tag_file_name)
+             == exclusion_tag_all)
            {
            {
-             fd = open (st->orig_file_name,
-                        O_RDONLY | O_BINARY);
-             if (fd < 0)
-               {
-                 if (!top_level && errno == ENOENT)
-                   WARN ((0, 0, _("%s: File removed before we read it"),
-                          quotearg_colon (st->orig_file_name)));
-                 else
-                   open_diag (st->orig_file_name);
-                 return;
-               }
+             exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                    _("directory not dumped"));
+             return;
            }
            }
-         else
+         
+         ok = dump_dir (fd, st, top_level, parent_device);
+
+         /* dump_dir consumes FD if successful.  */
+         if (ok)
            fd = -1;
            fd = -1;
+       }
+      else
+       {
+         enum dump_status status;
 
 
-         if (fd != -1 && sparse_option && sparse_file_p (st))
+         if (fd != -1 && sparse_option && ST_IS_SPARSE (st->stat))
            {
              status = sparse_dump_file (fd, st);
              if (status == dump_status_not_implemented)
            {
              status = sparse_dump_file (fd, st);
              if (status == dump_status_not_implemented)
@@ -1501,90 +1628,143 @@ dump_file0 (struct tar_stat_info *st, char *p,
          switch (status)
            {
            case dump_status_ok:
          switch (status)
            {
            case dump_status_ok:
-             if (multi_volume_option)
-               assign_string (&save_name, 0);
-             dump_regular_finish (fd, st, original_ctime);
-             break;
-
            case dump_status_short:
            case dump_status_short:
-             if (multi_volume_option)
-               assign_string (&save_name, 0);
-             close (fd);
+             mv_end ();
+             file_count_links (st);
              break;
 
            case dump_status_fail:
              break;
 
            case dump_status_fail:
-             close (fd);
-             return;
+             break;
 
            case dump_status_not_implemented:
              abort ();
            }
 
 
            case dump_status_not_implemented:
              abort ();
            }
 
-         if (atime_preserve_option)
-           utimens (st->orig_file_name, restore_times);
-         file_count_links (st);
-         return;
+         ok = status == dump_status_ok;
        }
        }
-#ifdef HAVE_READLINK
-      else if (S_ISLNK (st->stat.st_mode))
+
+      if (ok)
        {
        {
-         char *buffer;
-         int size;
-         size_t linklen = st->stat.st_size;
-         if (linklen != st->stat.st_size || linklen + 1 == 0)
-           xalloc_die ();
-         buffer = (char *) alloca (linklen + 1);
-         size = readlink (p, buffer, linklen + 1);
-         if (size < 0)
+         /* If possible, reopen a directory if we are preserving
+            atimes, so that we can set just the atime on systems with
+            _FIOSATIME.  */
+         if (fd < 0 && is_dir
+             && atime_preserve_option == replace_atime_preserve)
+           fd = open (p, O_RDONLY | O_BINARY | O_DIRECTORY | O_NONBLOCK);
+
+         if ((fd < 0
+              ? deref_stat (dereference_option, p, &final_stat)
+              : fstat (fd, &final_stat))
+             != 0)
            {
            {
-             readlink_diag (p);
-             return;
+             stat_diag (p);
+             ok = false;
            }
            }
-         buffer[size] = '\0';
-         assign_string (&st->link_name, buffer);
-         if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT) < size)
-           write_long_link (st);
+       }
 
 
-         block_ordinal = current_block_ordinal ();
-         st->stat.st_size = 0; /* force 0 size on symlink */
-         header = start_header (st);
-         if (!header)
-           return;
-         tar_copy_str (header->header.linkname, buffer, NAME_FIELD_SIZE);
-         header->header.typeflag = SYMTYPE;
-         finish_header (st, header, block_ordinal);
-         /* nothing more to do to it */
-
-         if (remove_files_option)
+      if (ok)
+       {
+         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)
            {
            {
-             if (unlink (p) == -1)
-               unlink_error (p);
+             WARNOPT (WARN_FILE_CHANGED,
+                      (0, 0, _("%s: file changed as we read it"),
+                       quotearg_colon (p)));
+             if (exit_status == TAREXIT_SUCCESS)
+               exit_status = TAREXIT_DIFFERS;
            }
            }
-         file_count_links (st);
-         return;
+         else if (atime_preserve_option == replace_atime_preserve
+                  && set_file_atime (fd, p, restore_times) != 0)
+           utime_error (p);
        }
        }
-#endif
-      else if (S_ISCHR (st->stat.st_mode))
-       type = CHRTYPE;
-      else if (S_ISBLK (st->stat.st_mode))
-       type = BLKTYPE;
-      else if (S_ISFIFO (st->stat.st_mode))
-       type = FIFOTYPE;
-      else if (S_ISSOCK (st->stat.st_mode))
+
+      if (0 <= fd && close (fd) != 0)
        {
        {
-         WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p)));
-         return;
+         close_diag (p);
+         ok = false;
        }
        }
-      else if (S_ISDOOR (st->stat.st_mode))
+
+      if (ok && remove_files_option)
        {
        {
-         WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p)));
-         return;
+         if (is_dir)
+           {
+             if (rmdir (p) != 0 && errno != ENOTEMPTY)
+               rmdir_error (p);
+           }
+         else
+           {
+             if (unlink (p) != 0)
+               unlink_error (p);
+           }
        }
        }
-      else
+
+      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 = readlink (p, buffer, linklen + 1);
+      if (size < 0)
        {
        {
-         unknown_file_error (p);
+         readlink_diag (p);
          return;
        }
          return;
        }
+      buffer[size] = '\0';
+      assign_string (&st->link_name, buffer);
+      transform_name (&st->link_name, XFORM_SYMLINK);
+      if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT) < size)
+       write_long_link (st);
+
+      block_ordinal = current_block_ordinal ();
+      st->stat.st_size = 0;    /* force 0 size on symlink */
+      header = start_header (st);
+      if (!header)
+       return;
+      tar_copy_str (header->header.linkname, st->link_name, NAME_FIELD_SIZE);
+      header->header.typeflag = SYMTYPE;
+      finish_header (st, header, block_ordinal);
+      /* nothing more to do to it */
+
+      if (remove_files_option)
+       {
+         if (unlink (p) == -1)
+           unlink_error (p);
+       }
+      file_count_links (st);
+      return;
+    }
+#endif
+  else if (S_ISCHR (st->stat.st_mode))
+    type = CHRTYPE;
+  else if (S_ISBLK (st->stat.st_mode))
+    type = BLKTYPE;
+  else if (S_ISFIFO (st->stat.st_mode))
+    type = FIFOTYPE;
+  else if (S_ISSOCK (st->stat.st_mode))
+    {
+      WARNOPT (WARN_FILE_IGNORED,
+              (0, 0, _("%s: socket ignored"), quotearg_colon (p)));
+      return;
+    }
+  else if (S_ISDOOR (st->stat.st_mode))
+    {
+      WARNOPT (WARN_FILE_IGNORED,
+              (0, 0, _("%s: door ignored"), quotearg_colon (p)));
+      return;
+    }
+  else
+    {
+      unknown_file_error (p);
+      return;
     }
 
   if (archive_format == V7_FORMAT)
     }
 
   if (archive_format == V7_FORMAT)
@@ -1617,7 +1797,7 @@ dump_file0 (struct tar_stat_info *st, char *p,
 }
 
 void
 }
 
 void
-dump_file (char *p, int top_level, dev_t parent_device)
+dump_file (const char *p, int top_level, dev_t parent_device)
 {
   struct tar_stat_info st;
   tar_stat_init (&st);
 {
   struct tar_stat_info st;
   tar_stat_init (&st);
This page took 0.05967 seconds and 4 git commands to generate.