]> Dogcows Code - chaz/tar/blobdiff - src/create.c
tar: don't worry about fdopendir closing its argument
[chaz/tar] / src / create.c
index f2db9c27fd542ff234c97f93f3cd309d9c8c290d..9dc928d347839ad4c8bc63f59cd790c5d0fef341 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, 2010 Free Software Foundation, Inc.
 
    Written by John Gilmore, on 1985-08-25.
 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
 
    Written by John Gilmore, on 1985-08-25.
 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
-   Free Software Foundation; either version 2, or (at your option) any later
+   Free Software Foundation; either version 3, or (at your option) any later
    version.
 
    This program is distributed in the hope that it will be useful, but
    version.
 
    This program is distributed in the hope that it will be useful, but
 #include "common.h"
 #include <hash.h>
 
 #include "common.h"
 #include <hash.h>
 
+/* Error number to use when an impostor is discovered.
+   Pretend the impostor isn't there.  */
+enum { IMPOSTOR_ERRNO = ENOENT };
+
 struct link
   {
     dev_t dev;
     ino_t ino;
 struct link
   {
     dev_t dev;
     ino_t ino;
-    size_t nlink;
+    nlink_t nlink;
     char name[1];
   };
     char name[1];
   };
+
+struct exclusion_tag
+{
+  const char *name;
+  size_t length;
+  enum exclusion_tag_type type;
+  bool (*predicate) (int fd);
+  struct exclusion_tag *next;
+};
+
+static struct exclusion_tag *exclusion_tags;
+
+void
+add_exclusion_tag (const char *name, enum exclusion_tag_type type,
+                  bool (*predicate) (int fd))
+{
+  struct exclusion_tag *tag = xmalloc (sizeof tag[0]);
+  tag->next = exclusion_tags;
+  tag->name = name;
+  tag->type = type;
+  tag->predicate = predicate;
+  tag->length = strlen (name);
+  exclusion_tags = tag;
+}
+
+void
+exclusion_tag_warning (const char *dirname, const char *tagname,
+                      const char *message)
+{
+  if (verbose_option)
+    WARNOPT (WARN_CACHEDIR,
+            (0, 0,
+             _("%s: contains a cache directory tag %s; %s"),
+             quotearg_colon (dirname),
+             quotearg_n (1, tagname),
+             message));
+}
+
+enum exclusion_tag_type
+check_exclusion_tags (struct tar_stat_info const *st, char const **tag_file_name)
+{
+  struct exclusion_tag *tag;
+
+  for (tag = exclusion_tags; tag; tag = tag->next)
+    {
+      int tagfd = subfile_open (st, tag->name, open_read_flags);
+      if (0 <= tagfd)
+       {
+         bool satisfied = !tag->predicate || tag->predicate (tagfd);
+         close (tagfd);
+         if (satisfied)
+           {
+             if (tag_file_name)
+               *tag_file_name = tag->name;
+             return tag->type;
+           }
+       }
+    }
+
+  return exclusion_tag_none;
+}
+
+/* Exclusion predicate to test if the named file (usually "CACHEDIR.TAG")
+   contains a valid header, as described at:
+       http://www.brynosaurus.com/cachedir
+   Applications can write this file into directories they create
+   for use as caches containing purely regenerable, non-precious data,
+   allowing us to avoid archiving them if --exclude-caches is specified. */
+
+#define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55"
+#define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1)
+
+bool
+cachedir_file_p (int fd)
+{
+  char tagbuf[CACHEDIR_SIGNATURE_SIZE];
+
+  return
+    (read (fd, tagbuf, CACHEDIR_SIGNATURE_SIZE) == CACHEDIR_SIGNATURE_SIZE
+     && memcmp (tagbuf, CACHEDIR_SIGNATURE, CACHEDIR_SIGNATURE_SIZE) == 0);
+}
+
 \f
 /* The maximum uintmax_t value that can be represented with DIGITS digits,
    assuming that each digit is BITS_PER_DIGIT wide.  */
 \f
 /* The maximum uintmax_t value that can be represented with DIGITS digits,
    assuming that each digit is BITS_PER_DIGIT wide.  */
@@ -108,6 +194,14 @@ to_base256 (int negative, uintmax_t value, char *where, size_t size)
   while (i);
 }
 
   while (i);
 }
 
+#define GID_TO_CHARS(val, where) gid_to_chars (val, where, sizeof (where))
+#define MAJOR_TO_CHARS(val, where) major_to_chars (val, where, sizeof (where))
+#define MINOR_TO_CHARS(val, where) minor_to_chars (val, where, sizeof (where))
+#define MODE_TO_CHARS(val, where) mode_to_chars (val, where, sizeof (where))
+#define UID_TO_CHARS(val, where) uid_to_chars (val, where, sizeof (where))
+
+#define UNAME_TO_CHARS(name,buf) string_to_chars (name, buf, sizeof(buf))
+#define GNAME_TO_CHARS(name,buf) string_to_chars (name, buf, sizeof(buf))
 
 static bool
 to_chars (int negative, uintmax_t value, size_t valsize,
 
 static bool
 to_chars (int negative, uintmax_t value, size_t valsize,
@@ -128,7 +222,7 @@ to_chars_subst (int negative, int gnu_format, uintmax_t value, size_t valsize,
   char const *minval_string;
   char const *maxval_string = STRINGIFY_BIGINT (maxval, maxbuf);
   char const *value_string;
   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;
   if (gnu_format)
     {
       uintmax_t m = maxval + 1 ? maxval + 1 : maxval / 2 + 1;
@@ -138,7 +232,7 @@ to_chars_subst (int negative, int gnu_format, uintmax_t value, size_t valsize,
     }
   else
     minval_string = "0";
     }
   else
     minval_string = "0";
-  
+
   if (negative)
     {
       char *p = STRINGIFY_BIGINT (- value, valbuf + 1);
   if (negative)
     {
       char *p = STRINGIFY_BIGINT (- value, valbuf + 1);
@@ -147,13 +241,18 @@ to_chars_subst (int negative, int gnu_format, uintmax_t value, size_t valsize,
     }
   else
     value_string = STRINGIFY_BIGINT (value, valbuf);
     }
   else
     value_string = STRINGIFY_BIGINT (value, valbuf);
-         
+
   if (substitute)
     {
       int negsub;
       uintmax_t sub = substitute (&negsub) & maxval;
   if (substitute)
     {
       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. */
+      /* 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);
       uintmax_t s = (negsub &= archive_format == GNU_FORMAT) ? - sub : sub;
       char subbuf[UINTMAX_STRSIZE_BOUND + 1];
       char *sub_string = STRINGIFY_BIGINT (s, subbuf + 1);
@@ -236,7 +335,7 @@ to_chars (int negative, uintmax_t value, size_t valsize,
     }
   else
     substitute = NULL; /* No substitution for formats, other than GNU */
     }
   else
     substitute = NULL; /* No substitution for formats, other than GNU */
-  
+
   return to_chars_subst (negative, gnu_format, value, valsize, substitute,
                         where, size, type);
 }
   return to_chars_subst (negative, gnu_format, value, valsize, substitute,
                         where, size, type);
 }
@@ -257,25 +356,25 @@ gid_substitute (int *negative)
   return r;
 }
 
   return r;
 }
 
-bool
+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");
 }
 
 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");
 }
 
-bool
+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");
 }
 
 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");
 }
 
-bool
+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");
 }
 
 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");
 }
 
-bool
+static bool
 mode_to_chars (mode_t v, char *p, size_t s)
 {
   /* In the common case where the internal and external mode bits are the same,
 mode_to_chars (mode_t v, char *p, size_t s)
 {
   /* In the common case where the internal and external mode bits are the same,
@@ -321,12 +420,6 @@ 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");
 }
 
   return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "off_t");
 }
 
-bool
-size_to_chars (size_t v, char *p, size_t s)
-{
-  return to_chars (0, (uintmax_t) v, sizeof v, 0, p, s, "size_t");
-}
-
 bool
 time_to_chars (time_t v, char *p, size_t s)
 {
 bool
 time_to_chars (time_t v, char *p, size_t s)
 {
@@ -349,19 +442,19 @@ uid_substitute (int *negative)
   return r;
 }
 
   return r;
 }
 
-bool
+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");
 }
 
 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");
 }
 
-bool
+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");
 }
 
 uintmax_to_chars (uintmax_t v, char *p, size_t s)
 {
   return to_chars (0, v, sizeof v, 0, p, s, "uintmax_t");
 }
 
-void
+static void
 string_to_chars (char const *str, char *p, size_t s)
 {
   tar_copy_str (p, str, s);
 string_to_chars (char const *str, char *p, size_t s)
 {
   tar_copy_str (p, str, s);
@@ -369,20 +462,25 @@ string_to_chars (char const *str, char *p, size_t s)
 }
 
 \f
 }
 
 \f
-/* A file is considered dumpable if it is sparse and both --sparse and --totals
+/* A directory is always considered dumpable.
+   Otherwise, only regular and contiguous files are considered dumpable.
+   Such a file is dumpable if it is sparse and both --sparse and --totals
    are specified.
    Otherwise, it is dumpable unless any of the following conditions occur:
 
    a) it is empty *and* world-readable, or
    b) current archive is /dev/null */
 
    are specified.
    Otherwise, it is dumpable unless any of the following conditions occur:
 
    a) it is empty *and* world-readable, or
    b) current archive is /dev/null */
 
-bool
-file_dumpable_p (struct tar_stat_info *st)
+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)
   if (dev_null_output)
-    return totals_option && sparse_option && sparse_file_p (st);
-  return !(st->archive_file_size == 0
-          && (st->stat.st_mode & MODE_R) == MODE_R);
+    return totals_option && sparse_option && ST_IS_SPARSE (*st);
+  return ! (st->st_size == 0 && (st->st_mode & MODE_R) == MODE_R);
 }
 
 \f
 }
 
 \f
@@ -404,9 +502,8 @@ write_eot (void)
 
 /* Write a "private" header */
 union block *
 
 /* Write a "private" header */
 union block *
-start_private_header (const char *name, size_t size)
+start_private_header (const char *name, size_t size, time_t t)
 {
 {
-  time_t t;
   union block *header = find_next_block ();
 
   memset (header->buffer, 0, sizeof (union block));
   union block *header = find_next_block ();
 
   memset (header->buffer, 0, sizeof (union block));
@@ -414,7 +511,6 @@ start_private_header (const char *name, size_t size)
   tar_name_copy_str (header->header.name, name, NAME_FIELD_SIZE);
   OFF_TO_CHARS (size, header->header.size);
 
   tar_name_copy_str (header->header.name, name, NAME_FIELD_SIZE);
   OFF_TO_CHARS (size, header->header.size);
 
-  time (&t);
   TIME_TO_CHARS (t, header->header.mtime);
   MODE_TO_CHARS (S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH, header->header.mode);
   UID_TO_CHARS (getuid (), header->header.uid);
   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);
@@ -452,13 +548,13 @@ write_gnu_long_link (struct tar_stat_info *st, const char *p, char type)
   union block *header;
   char *tmpname;
 
   union block *header;
   char *tmpname;
 
-  header = start_private_header ("././@LongLink", size);
-  FILL(header->header.mtime, '0');
-  FILL(header->header.mode, '0');
-  FILL(header->header.uid, '0');
-  FILL(header->header.gid, '0');
-  FILL(header->header.devmajor, 0);
-  FILL(header->header.devminor, 0);
+  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);
   uid_to_uname (0, &tmpname);
   UNAME_TO_CHARS (tmpname, header->header.uname);
   free (tmpname);
@@ -493,8 +589,10 @@ split_long_name (const char *name, size_t length)
 {
   size_t i;
 
 {
   size_t i;
 
-  if (length > PREFIX_FIELD_SIZE)
+  if (length > PREFIX_FIELD_SIZE + 1)
     length = PREFIX_FIELD_SIZE + 1;
     length = PREFIX_FIELD_SIZE + 1;
+  else if (ISSLASH (name[length - 1]))
+    length--;
   for (i = length - 1; i > 0; i--)
     if (ISSLASH (name[i]))
       break;
   for (i = length - 1; i > 0; i--)
     if (ISSLASH (name[i]))
       break;
@@ -505,7 +603,7 @@ static union block *
 write_ustar_long_name (const char *name)
 {
   size_t length = strlen (name);
 write_ustar_long_name (const char *name)
 {
   size_t length = strlen (name);
-  size_t i;
+  size_t i, nlen;
   union block *header;
 
   if (length > PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1)
   union block *header;
 
   if (length > PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1)
@@ -517,7 +615,7 @@ write_ustar_long_name (const char *name)
     }
 
   i = split_long_name (name, length);
     }
 
   i = split_long_name (name, length);
-  if (i == 0 || length - i - 1 > NAME_FIELD_SIZE)
+  if (i == 0 || (nlen = length - i - 1) > NAME_FIELD_SIZE || nlen == 0)
     {
       ERROR ((0, 0,
              _("%s: file name is too long (cannot be split); not dumped"),
     {
       ERROR ((0, 0,
              _("%s: file name is too long (cannot be split); not dumped"),
@@ -601,23 +699,26 @@ write_extended (bool global, struct tar_stat_info *st, union block *old_header)
   union block *header, hp;
   char *p;
   int type;
   union block *header, hp;
   char *p;
   int type;
+  time_t t;
 
 
-  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));
   if (global)
     {
       type = XGLTYPE;
       p = xheader_ghdr_name ();
   memcpy (hp.buffer, old_header, sizeof (hp));
   if (global)
     {
       type = XGLTYPE;
       p = xheader_ghdr_name ();
+      time (&t);
     }
   else
     {
       type = XHDTYPE;
       p = xheader_xhdr_name (st);
     }
   else
     {
       type = XHDTYPE;
       p = xheader_xhdr_name (st);
+      t = st->stat.st_mtime;
     }
     }
-  xheader_write (type, p, &extended_header);
+  xheader_write (type, p, t, &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));
@@ -663,7 +764,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
@@ -730,12 +832,12 @@ start_header (struct tar_stat_info *st)
   }
 
   {
   }
 
   {
-    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;
       }
@@ -881,11 +983,9 @@ finish_header (struct tar_stat_info *st,
       && header->header.typeflag != XHDTYPE
       && header->header.typeflag != XGLTYPE)
     {
       && header->header.typeflag != XHDTYPE
       && header->header.typeflag != XGLTYPE)
     {
-      /* These globals are parameters to print_header, sigh.  */
-
-      current_header = header;
+      /* FIXME: This global is used in print_header, sigh.  */
       current_format = archive_format;
       current_format = archive_format;
-      print_header (st, block_ordinal);
+      print_header (st, header, block_ordinal);
     }
 
   header = write_extended (false, st, header);
     }
 
   header = write_extended (false, st, header);
@@ -899,7 +999,6 @@ pad_archive (off_t size_left)
   union block *blk;
   while (size_left > 0)
     {
   union block *blk;
   while (size_left > 0)
     {
-      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);
@@ -925,13 +1024,11 @@ 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);
+  mv_begin_write (st->file_name, st->stat.st_size, st->stat.st_size);
   while (size_left > 0)
     {
       size_t bufsize, count;
 
   while (size_left > 0)
     {
       size_t bufsize, count;
 
-      mv_size_left (size_left);
-
       blk = find_next_block ();
 
       bufsize = available_space_after (blk);
       blk = find_next_block ();
 
       bufsize = available_space_after (blk);
@@ -945,7 +1042,7 @@ dump_regular_file (int fd, struct tar_stat_info *st)
            memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
        }
 
            memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
        }
 
-      count = (fd < 0) ? bufsize : safe_read (fd, blk->buffer, bufsize);
+      count = (fd <= 0) ? bufsize : safe_read (fd, blk->buffer, bufsize);
       if (count == SAFE_READ_ERROR)
        {
          read_diag_details (st->orig_file_name,
       if (count == SAFE_READ_ERROR)
        {
          read_diag_details (st->orig_file_name,
@@ -954,143 +1051,98 @@ 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)));
+         WARNOPT (WARN_FILE_SHRANK,
+                  (0, 0,
+                   ngettext ("%s: File shrank by %s byte; padding with zeros",
+                             "%s: File shrank by %s bytes; padding with zeros",
+                             size_left),
+                   quotearg_colon (st->orig_file_name),
+                   STRINGIFY_BIGINT (size_left, buf)));
          if (! ignore_failed_read_option)
          if (! ignore_failed_read_option)
-           exit_status = TAREXIT_FAILURE;
-         pad_archive (size_left - (bufsize-count));
+           set_exit_status (TAREXIT_DIFFERS);
+         pad_archive (size_left - (bufsize - count));
          return dump_status_short;
        }
     }
   return dump_status_ok;
 }
 
          return dump_status_short;
        }
     }
   return dump_status_ok;
 }
 
-/* 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)
+\f
+/* Copy info from the directory identified by ST into the archive.
+   DIRECTORY contains the directory's entries.  */
 
 
-static bool
-check_cache_directory (char *dirname)
+static void
+dump_dir0 (struct tar_stat_info *st, char const *directory)
 {
 {
-  static char tagname[] = "CACHEDIR.TAG";
-  char *tagpath;
-  int fd;
-  int tag_present = false;
+  bool top_level = ! st->parent;
+  const char *tag_file_name;
+  union block *blk = NULL;
+  off_t block_ordinal = current_block_ordinal ();
 
 
-  tagpath = xmalloc (strlen (dirname) + strlen (tagname) + 1);
-  strcpy (tagpath, dirname);
-  strcat (tagpath, tagname);
+  st->stat.st_size = 0;        /* force 0 size on dir */
 
 
-  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);
-    }
+  blk = start_header (st);
+  if (!blk)
+    return;
 
 
-  free (tagpath);
+  if (incremental_option && archive_format != POSIX_FORMAT)
+    blk->header.typeflag = GNUTYPE_DUMPDIR;
+  else /* if (standard_option) */
+    blk->header.typeflag = DIRTYPE;
 
 
-  return tag_present;
-}
-
-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;
+  /* If we're gnudumping, we aren't done yet so don't close it.  */
 
 
-  if (!is_avoided_name (st->orig_file_name))
+  if (!incremental_option)
+    finish_header (st, blk, block_ordinal);
+  else if (gnu_list_name->directory)
     {
     {
-      union block *blk = NULL;
-      off_t block_ordinal = current_block_ordinal ();
-      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 (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;
 
 
-      /* If we're gnudumping, we aren't done yet so don't close it.  */
+         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;
 
 
-      if (!incremental_option)
-       finish_header (st, blk, block_ordinal);
-      else if (gnu_list_name->dir_contents)
-       {
-         if (archive_format == POSIX_FORMAT)
-           {
-             xheader_store ("GNU.dumpdir", st, gnu_list_name->dir_contents);
-             finish_header (st, blk, block_ordinal);
-           }
-         else
+         mv_begin_write (st->file_name, totsize, totsize);
+         while (size_left > 0)
            {
            {
-             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)
+             blk = find_next_block ();
+             bufsize = available_space_after (blk);
+             if (size_left < bufsize)
                {
                {
-                 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);
+                 bufsize = size_left;
+                 count = bufsize % BLOCKSIZE;
+                 if (count)
+                   memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
                }
                }
-             mv_end ();
+             memcpy (blk->buffer, p_buffer, bufsize);
+             size_left -= bufsize;
+             p_buffer += bufsize;
+             set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
            }
            }
-         return;
        }
        }
+      return;
     }
 
   if (!recursion_option)
     }
 
   if (!recursion_option)
@@ -1098,50 +1150,69 @@ dump_dir0 (char *directory,
 
   if (one_file_system_option
       && !top_level
 
   if (one_file_system_option
       && !top_level
-      && parent_device != st->stat.st_dev)
+      && st->parent->stat.st_dev != st->stat.st_dev)
     {
       if (verbose_option)
     {
       if (verbose_option)
-       WARN ((0, 0,
-              _("%s: file is on a different filesystem; not dumped"),
-              quotearg_colon (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;
 
 
-    /* Now output all the files in the directory.  */
-    /* FIXME: Should speed this up by cd-ing into the dir.  */
+      switch (check_exclusion_tags (st, &tag_file_name))
+       {
+       case exclusion_tag_all:
+         /* Handled in dump_file0 */
+         break;
 
 
-    for (entry = directory; (entry_len = strlen (entry)) != 0;
-        entry += entry_len + 1)
-      {
-       if (name_size < name_len + entry_len)
+       case exclusion_tag_none:
          {
          {
-           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);
-      }
+           char const *entry;
+           size_t entry_len;
+           size_t name_len;
 
 
-    free (name_buf);
-  }
+           name_buf = xstrdup (st->orig_file_name);
+           name_size = name_len = strlen (name_buf);
+
+           /* Now output all the files in the directory.  */
+           for (entry = directory; (entry_len = strlen (entry)) != 0;
+                entry += entry_len + 1)
+             {
+               if (name_size < name_len + entry_len)
+                 {
+                   name_size = name_len + entry_len;
+                   name_buf = xrealloc (name_buf, name_size + 1);
+                 }
+               strcpy (name_buf + name_len, entry);
+               if (!excluded_name (name_buf))
+                 dump_file (st, entry, name_buf);
+             }
+
+           free (name_buf);
+         }
+         break;
+
+       case exclusion_tag_contents:
+         exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                _("contents not dumped"));
+         name_size = strlen (st->orig_file_name) + strlen (tag_file_name) + 1;
+         name_buf = xmalloc (name_size);
+         strcpy (name_buf, st->orig_file_name);
+         strcat (name_buf, tag_file_name);
+         dump_file (st, tag_file_name, name_buf);
+         free (name_buf);
+         break;
+
+       case exclusion_tag_under:
+         exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                _("contents not dumped"));
+         break;
+       }
+    }
 }
 
 /* Ensure exactly one trailing slash.  */
 }
 
 /* Ensure exactly one trailing slash.  */
@@ -1157,35 +1228,85 @@ ensure_slash (char **pstr)
   (*pstr)[len] = '\0';
 }
 
   (*pstr)[len] = '\0';
 }
 
+/* If we just ran out of file descriptors, release a file descriptor
+   in the directory chain somewhere leading from DIR->parent->parent
+   up through the root.  Return true if successful, false (preserving
+   errno == EMFILE) otherwise.
+
+   Do not release DIR's file descriptor, or DIR's parent, as other
+   code assumes that they work.  On some operating systems, another
+   process can claim file descriptor resources as we release them, and
+   some calls or their emulations require multiple file descriptors,
+   so callers should not give up if a single release doesn't work.  */
+
+static bool
+open_failure_recover (struct tar_stat_info const *dir)
+{
+  if (errno == EMFILE && dir && dir->parent)
+    {
+      struct tar_stat_info *p;
+      for (p = dir->parent->parent; p; p = p->parent)
+       if (0 < p->fd && (! p->parent || p->parent->fd <= 0))
+         {
+           tar_stat_close (p);
+           return true;
+         }
+      errno = EMFILE;
+    }
+
+  return false;
+}
+
+/* Return the directory entries of ST, in a dynamically allocated buffer,
+   each entry followed by '\0' and the last followed by an extra '\0'.
+   Return null on failure, setting errno.  */
+char *
+get_directory_entries (struct tar_stat_info *st)
+{
+  while (! (st->dirstream = fdopendir (st->fd)))
+    if (! open_failure_recover (st))
+      return 0;
+  return streamsavedir (st->dirstream);
+}
+
+/* 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
 static bool
-dump_dir (int fd, struct tar_stat_info *st, int top_level, dev_t parent_device)
+dump_dir (struct tar_stat_info *st)
 {
 {
-  char *directory = fdsavedir (fd);
-  if (!directory)
+  char *directory = get_directory_entries (st);
+  if (! directory)
     {
       savedir_diag (st->orig_file_name);
       return false;
     }
 
     {
       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);
+  dump_dir0 (st, directory);
 
 
+  restore_parent_fd (st);
   free (directory);
   return true;
 }
 
   free (directory);
   return true;
 }
 
+\f
+/* Number of links a file can have without having to be entered into
+   the link table.  Typically this is 1, but in trickier circumstances
+   it is 0.  */
+static nlink_t trivial_link_count;
+
 \f
 /* Main functions of this module.  */
 
 void
 create_archive (void)
 {
 \f
 /* Main functions of this module.  */
 
 void
 create_archive (void)
 {
-  char *p;
+  struct name const *p;
+
+  trivial_link_count = name_count <= 1 && ! dereference_option;
 
   open_archive (ACCESS_WRITE);
 
   open_archive (ACCESS_WRITE);
-  xheader_write_global ();
+  buffer_write_global_xheader ();
 
   if (incremental_option)
     {
 
   if (incremental_option)
     {
@@ -1196,30 +1317,48 @@ create_archive (void)
       collect_and_sort_names ();
 
       while ((p = name_from_list ()) != NULL)
       collect_and_sort_names ();
 
       while ((p = name_from_list ()) != NULL)
-       if (!excluded_name (p))
-         dump_file (p, -1, (dev_t) 0);
+       if (!excluded_name (p->name))
+         dump_file (0, p->name, p->name);
 
       blank_name_list ();
       while ((p = name_from_list ()) != NULL)
 
       blank_name_list ();
       while ((p = name_from_list ()) != NULL)
-       if (!excluded_name (p))
+       if (!excluded_name (p->name))
          {
          {
-           size_t plen = strlen (p);
+           struct tar_stat_info st;
+           size_t plen = strlen (p->name);
            if (buffer_size <= plen)
              {
                while ((buffer_size *= 2) <= plen)
                  continue;
                buffer = xrealloc (buffer, buffer_size);
              }
            if (buffer_size <= plen)
              {
                while ((buffer_size *= 2) <= plen)
                  continue;
                buffer = xrealloc (buffer, buffer_size);
              }
-           memcpy (buffer, p, plen);
+           memcpy (buffer, p->name, plen);
            if (! ISSLASH (buffer[plen - 1]))
            if (! ISSLASH (buffer[plen - 1]))
-             buffer[plen++] = '/';
-           q = gnu_list_name->dir_contents;
+             buffer[plen++] = DIRECTORY_SEPARATOR;
+           tar_stat_init (&st);
+           q = directory_contents (gnu_list_name->directory);
            if (q)
              while (*q)
                {
                  size_t qlen = strlen (q);
                  if (*q == 'Y')
                    {
            if (q)
              while (*q)
                {
                  size_t qlen = strlen (q);
                  if (*q == 'Y')
                    {
+                     if (! st.orig_file_name)
+                       {
+                         int fd = open (p->name, open_searchdir_flags);
+                         if (fd < 0)
+                           {
+                             open_diag (p->name);
+                             break;
+                           }
+                         st.fd = fd;
+                         if (fstat (fd, &st.stat) != 0)
+                           {
+                             stat_diag (p->name);
+                             break;
+                           }
+                         st.orig_file_name = xstrdup (p->name);
+                       }
                      if (buffer_size < plen + qlen)
                        {
                          while ((buffer_size *=2 ) < plen + qlen)
                      if (buffer_size < plen + qlen)
                        {
                          while ((buffer_size *=2 ) < plen + qlen)
@@ -1227,23 +1366,25 @@ create_archive (void)
                          buffer = xrealloc (buffer, buffer_size);
                        }
                      strcpy (buffer + plen, q + 1);
                          buffer = xrealloc (buffer, buffer_size);
                        }
                      strcpy (buffer + plen, q + 1);
-                     dump_file (buffer, -1, (dev_t) 0);
+                     dump_file (&st, q + 1, buffer);
                    }
                  q += qlen + 1;
                }
                    }
                  q += qlen + 1;
                }
+           tar_stat_destroy (&st);
          }
       free (buffer);
     }
   else
     {
          }
       free (buffer);
     }
   else
     {
-      while ((p = name_next (1)) != NULL)
-       if (!excluded_name (p))
-         dump_file (p, 1, (dev_t) 0);
+      const char *name;
+      while ((name = name_next (1)) != NULL)
+       if (!excluded_name (name))
+         dump_file (0, name, name);
     }
 
   write_eot ();
   close_archive ();
     }
 
   write_eot ();
   close_archive ();
-
+  finish_deferred_unlinks ();
   if (listed_incremental_option)
     write_directory_file ();
 }
   if (listed_incremental_option)
     write_directory_file ();
 }
@@ -1270,10 +1411,11 @@ compare_links (void const *entry1, void const *entry2)
 static void
 unknown_file_error (char const *p)
 {
 static void
 unknown_file_error (char const *p)
 {
-  WARN ((0, 0, _("%s: Unknown file type; file ignored"),
-        quotearg_colon (p)));
+  WARNOPT (WARN_FILE_IGNORED,
+          (0, 0, _("%s: Unknown file type; file ignored"),
+           quotearg_colon (p)));
   if (!ignore_failed_read_option)
   if (!ignore_failed_read_option)
-    exit_status = TAREXIT_FAILURE;
+    set_exit_status (TAREXIT_FAILURE);
 }
 
 \f
 }
 
 \f
@@ -1289,7 +1431,8 @@ static Hash_table *link_table;
 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
+      && (trivial_link_count < st->stat.st_nlink || remove_files_option))
     {
       struct link lp;
       struct link *duplicate;
     {
       struct link lp;
       struct link *duplicate;
@@ -1322,8 +1465,8 @@ dump_hard_link (struct tar_stat_info *st)
          blk->header.typeflag = LNKTYPE;
          finish_header (st, blk, block_ordinal);
 
          blk->header.typeflag = LNKTYPE;
          finish_header (st, blk, block_ordinal);
 
-         if (remove_files_option && unlink (st->orig_file_name) != 0)
-           unlink_error (st->orig_file_name);
+         if (remove_files_option)
+           queue_deferred_unlink (st->orig_file_name, false);
 
          return true;
        }
 
          return true;
        }
@@ -1334,15 +1477,24 @@ 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 (st->stat.st_nlink > 1)
+  if (hard_dereference_option)
+    return;
+  if (trivial_link_count < st->stat.st_nlink)
     {
       struct link *duplicate;
     {
       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,
 
       if (! ((link_table
              || (link_table = hash_initialize (0, 0, hash_link,
@@ -1371,31 +1523,101 @@ 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)));
        }
     }
 }
 
        }
     }
 }
 
+/* Assuming DIR is the working directory, open FILE, using FLAGS to
+   control the open.  A null DIR means to use ".".  If we are low on
+   file descriptors, try to release one or more from DIR's parents to
+   reuse it.  */
+int
+subfile_open (struct tar_stat_info const *dir, char const *file, int flags)
+{
+  int fd;
+
+  static bool initialized;
+  if (! initialized)
+    {
+      /* Initialize any tables that might be needed when file
+        descriptors are exhausted, and whose initialization might
+        require a file descriptor.  This includes the system message
+        catalog and tar's message catalog.  */
+      initialized = true;
+      strerror (ENOENT);
+      gettext ("");
+    }
+
+  while ((fd = openat (dir ? dir->fd : AT_FDCWD, file, flags)) < 0
+        && open_failure_recover (dir))
+    continue;
+  return fd;
+}
 
 
-/* Dump a single file, recursing on directories.  P is the file name
-   to dump.  TOP_LEVEL tells whether this is a top-level call; zero
-   means no, positive means yes, and negative means the top level
-   of an incremental dump.  PARENT_DEVICE is the device of P's
-   parent directory; it is examined only if TOP_LEVEL is zero. */
+/* Restore the file descriptor for ST->parent, if it was temporarily
+   closed to conserve file descriptors.  On failure, set the file
+   descriptor to the negative of the corresponding errno value.  Call
+   this every time a subdirectory is ascended from.  */
+void
+restore_parent_fd (struct tar_stat_info const *st)
+{
+  struct tar_stat_info *parent = st->parent;
+  if (parent && ! parent->fd)
+    {
+      int parentfd = openat (st->fd, "..", open_searchdir_flags);
+      struct stat parentstat;
+
+      if (parentfd < 0)
+       parentfd = - errno;
+      else if (! (fstat (parentfd, &parentstat) == 0
+                 && parent->stat.st_ino == parentstat.st_ino
+                 && parent->stat.st_dev == parentstat.st_dev))
+       {
+         close (parentfd);
+         parentfd = IMPOSTOR_ERRNO;
+       }
+
+      if (parentfd < 0)
+       {
+         int origfd = open (parent->orig_file_name, open_searchdir_flags);
+         if (0 <= origfd)
+           {
+             if (fstat (parentfd, &parentstat) == 0
+                 && parent->stat.st_ino == parentstat.st_ino
+                 && parent->stat.st_dev == parentstat.st_dev)
+               parentfd = origfd;
+             else
+               close (origfd);
+           }
+       }
+
+      parent->fd = parentfd;
+    }
+}
+
+/* Dump a single file, recursing on directories.  ST is the file's
+   status info, NAME its name relative to the parent directory, and P
+   its full name (which may be relative to the working directory).  */
 
 /* FIXME: One should make sure that for *every* path leading to setting
    exit_status to failure, a clear diagnostic has been issued.  */
 
 static void
 
 /* FIXME: One should make sure that for *every* path leading to setting
    exit_status to failure, a clear diagnostic has been issued.  */
 
 static void
-dump_file0 (struct tar_stat_info *st, char const *p,
-           int top_level, dev_t parent_device)
+dump_file0 (struct tar_stat_info *st, char const *name, char const *p)
 {
   union block *header;
   char type;
 {
   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;
+  int fd = 0;
   bool is_dir;
   bool is_dir;
+  struct tar_stat_info const *parent = st->parent;
+  bool top_level = ! parent;
+  int parentfd = top_level ? AT_FDCWD : parent->fd;
+  void (*diag) (char const *) = 0;
 
   if (interactive_option && !confirm ("add", p))
     return;
 
   if (interactive_option && !confirm ("add", p))
     return;
@@ -1404,12 +1626,34 @@ dump_file0 (struct tar_stat_info *st, char const *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));
 
-  if (deref_stat (dereference_option, p, &st->stat) != 0)
+  transform_name (&st->file_name, XFORM_REGFILE);
+
+  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
+       {
+         st->fd = fd;
+         if (fstat (fd, &st->stat) != 0)
+           diag = stat_diag;
+       }
+    }
+  if (diag)
     {
     {
-      stat_diag (p);
+      file_removed_diag (p, top_level, diag);
       return;
     }
       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);
@@ -1439,22 +1683,21 @@ dump_file0 (struct tar_stat_info *st, char const *p,
       && (!after_date_option || OLDER_TAR_STAT_TIME (*st, c)))
     {
       if (!incremental_option && verbose_option)
       && (!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;
     }
 
       return;
     }
 
-  if (is_avoided_name (p))
-    return;
-
   is_dir = S_ISDIR (st->stat.st_mode) != 0;
 
   if (!is_dir && dump_hard_link (st))
   is_dir = S_ISDIR (st->stat.st_mode) != 0;
 
   if (!is_dir && dump_hard_link (st))
@@ -1463,41 +1706,31 @@ dump_file0 (struct tar_stat_info *st, char const *p,
   if (is_dir || S_ISREG (st->stat.st_mode) || S_ISCTG (st->stat.st_mode))
     {
       bool ok;
   if (is_dir || S_ISREG (st->stat.st_mode) || S_ISCTG (st->stat.st_mode))
     {
       bool ok;
-      int fd = -1;
       struct stat final_stat;
 
       struct stat final_stat;
 
-      if (is_dir || file_dumpable_p (st))
+      if (is_dir)
        {
        {
-         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)
+         const char *tag_file_name;
+         ensure_slash (&st->orig_file_name);
+         ensure_slash (&st->file_name);
+
+         if (check_exclusion_tags (st, &tag_file_name) == exclusion_tag_all)
            {
            {
-             if (!top_level && errno == ENOENT)
-               WARN ((0, 0, _("%s: File removed before we read it"),
-                      quotearg_colon (p)));
-             else
-               open_diag (p);
+             exclusion_tag_warning (st->orig_file_name, tag_file_name,
+                                    _("directory not dumped"));
              return;
            }
              return;
            }
-       }
 
 
-      if (is_dir)
-       {
-         ok = dump_dir (fd, st, top_level, parent_device);
+         ok = dump_dir (st);
 
 
-         /* dump_dir consumes FD if successful.  */
-         if (ok)
-           fd = -1;
+         fd = st->fd;
+         parentfd = top_level ? AT_FDCWD : parent->fd;
        }
       else
        {
          enum dump_status status;
 
        }
       else
        {
          enum dump_status status;
 
-         if (fd != -1 && sparse_option && sparse_file_p (st))
+         if (fd && 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)
@@ -1510,7 +1743,7 @@ dump_file0 (struct tar_stat_info *st, char const *p,
            {
            case dump_status_ok:
            case dump_status_short:
            {
            case dump_status_ok:
            case dump_status_short:
-             mv_end ();
+             file_count_links (st);
              break;
 
            case dump_status_fail:
              break;
 
            case dump_status_fail:
@@ -1520,59 +1753,54 @@ dump_file0 (struct tar_stat_info *st, char const *p,
              abort ();
            }
 
              abort ();
            }
 
-         file_count_links (st);
-         
          ok = status == dump_status_ok;
        }
 
       if (ok)
        {
          ok = status == dump_status_ok;
        }
 
       if (ok)
        {
-         /* 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)
+         if (fd < 0)
            {
            {
-             stat_diag (p);
+             errno = - fd;
              ok = false;
            }
              ok = false;
            }
+         else if (fd == 0)
+           {
+             if (parentfd < 0 && ! top_level)
+               {
+                 errno = - parentfd;
+                 ok = false;
+               }
+             else
+               ok = fstatat (parentfd, name, &final_stat, fstatat_flags) == 0;
+           }
+         else
+           ok = fstat (fd, &final_stat) == 0;
+
+         if (! ok)
+           file_removed_diag (p, top_level, stat_diag);
        }
 
       if (ok)
        {
        }
 
       if (ok)
        {
-         if (timespec_cmp (get_stat_ctime (&final_stat), original_ctime) != 0)
-           WARN ((0, 0, _("%s: file changed as we read it"),
-                  quotearg_colon (p)));
+         if ((timespec_cmp (get_stat_ctime (&final_stat), original_ctime) != 0
+              /* Original ctime will change if the file is a directory and
+                 --remove-files is given */
+              && !(remove_files_option && is_dir))
+             || original_size < final_stat.st_size)
+           {
+             WARNOPT (WARN_FILE_CHANGED,
+                      (0, 0, _("%s: file changed as we read it"),
+                       quotearg_colon (p)));
+             set_exit_status (TAREXIT_DIFFERS);
+           }
          else if (atime_preserve_option == replace_atime_preserve
                   && set_file_atime (fd, p, restore_times) != 0)
            utime_error (p);
        }
 
          else if (atime_preserve_option == replace_atime_preserve
                   && set_file_atime (fd, p, restore_times) != 0)
            utime_error (p);
        }
 
-      if (0 <= fd && close (fd) != 0)
-       {
-         close_diag (p);
-         ok = false;
-       }
-
+      ok &= tar_stat_close (st);
       if (ok && remove_files_option)
       if (ok && remove_files_option)
-       {
-         if (is_dir)
-           {
-             if (rmdir (p) != 0 && errno != ENOTEMPTY)
-               rmdir_error (p);
-           }
-         else
-           {
-             if (unlink (p) != 0)
-               unlink_error (p);
-           }
-       }
+       queue_deferred_unlink (p, is_dir);
 
       return;
     }
 
       return;
     }
@@ -1585,14 +1813,15 @@ dump_file0 (struct tar_stat_info *st, char const *p,
       if (linklen != st->stat.st_size || linklen + 1 == 0)
        xalloc_die ();
       buffer = (char *) alloca (linklen + 1);
       if (linklen != st->stat.st_size || linklen + 1 == 0)
        xalloc_die ();
       buffer = (char *) alloca (linklen + 1);
-      size = readlink (p, buffer, linklen + 1);
+      size = readlinkat (parentfd, name, buffer, linklen + 1);
       if (size < 0)
        {
       if (size < 0)
        {
-         readlink_diag (p);
+         file_removed_diag (p, top_level, readlink_diag);
          return;
        }
       buffer[size] = '\0';
       assign_string (&st->link_name, buffer);
          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);
 
       if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT) < size)
        write_long_link (st);
 
@@ -1601,16 +1830,14 @@ dump_file0 (struct tar_stat_info *st, char const *p,
       header = start_header (st);
       if (!header)
        return;
       header = start_header (st);
       if (!header)
        return;
-      tar_copy_str (header->header.linkname, buffer, NAME_FIELD_SIZE);
+      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)
       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);
-       }
+       queue_deferred_unlink (p, false);
+
       file_count_links (st);
       return;
     }
       file_count_links (st);
       return;
     }
@@ -1623,12 +1850,14 @@ dump_file0 (struct tar_stat_info *st, char const *p,
     type = FIFOTYPE;
   else if (S_ISSOCK (st->stat.st_mode))
     {
     type = FIFOTYPE;
   else if (S_ISSOCK (st->stat.st_mode))
     {
-      WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p)));
+      WARNOPT (WARN_FILE_IGNORED,
+              (0, 0, _("%s: socket ignored"), quotearg_colon (p)));
       return;
     }
   else if (S_ISDOOR (st->stat.st_mode))
     {
       return;
     }
   else if (S_ISDOOR (st->stat.st_mode))
     {
-      WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p)));
+      WARNOPT (WARN_FILE_IGNORED,
+              (0, 0, _("%s: door ignored"), quotearg_colon (p)));
       return;
     }
   else
       return;
     }
   else
@@ -1660,19 +1889,23 @@ dump_file0 (struct tar_stat_info *st, char const *p,
 
   finish_header (st, header, block_ordinal);
   if (remove_files_option)
 
   finish_header (st, header, block_ordinal);
   if (remove_files_option)
-    {
-      if (unlink (p) == -1)
-       unlink_error (p);
-    }
+    queue_deferred_unlink (p, false);
 }
 
 }
 
+/* Dump a file, recursively.  PARENT describes the file's parent
+   directory, NAME is the file's name relative to PARENT, and FULLNAME
+   its full name, possibly relative to the working directory.  NAME
+   may contain slashes at the top level of invocation.  */
+
 void
 void
-dump_file (char *p, int top_level, dev_t parent_device)
+dump_file (struct tar_stat_info *parent, char const *name,
+          char const *fullname)
 {
   struct tar_stat_info st;
   tar_stat_init (&st);
 {
   struct tar_stat_info st;
   tar_stat_init (&st);
-  dump_file0 (&st, p, top_level, parent_device);
-  if (listed_incremental_option)
-    update_parent_directory (p);
+  st.parent = parent;
+  dump_file0 (&st, name, fullname);
+  if (parent && listed_incremental_option)
+    update_parent_directory (parent);
   tar_stat_destroy (&st);
 }
   tar_stat_destroy (&st);
 }
This page took 0.054111 seconds and 4 git commands to generate.