Improve listed incremental dumps.

[chaz/tar] / src / compare.c

diff --git a/src/compare.c b/src/compare.c
index 7e5d565e15202ad81f3ab3e81d2bc0aad94284a5..b45c6160b6636555902ba174516e6ade22c86ba5 100644 (file)
--- a/src/compare.c
+++ b/src/compare.c
@@ -1,13 +1,13 @@
 /* Diff files from a tar archive.
 
    Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
 /* Diff files from a tar archive.
 
    Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,

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

 
    Written by John Gilmore, on 1987-04-30.
 
    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 1987-04-30.
 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the

-   Free Software Foundation; either version 2, or (at your option) any later
+   Free Software Foundation; either version 3, or (at your option) any later

    version.
 
    This program is distributed in the hope that it will be useful, but
    version.
 
    This program is distributed in the hope that it will be useful, but


@@ -17,27 +17,17 @@
 
    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
 
    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,

-   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */

 
 #include <system.h>
 
 #include <system.h>

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

 
 #if HAVE_LINUX_FD_H
 # include <linux/fd.h>
 #endif
 
 
 #if HAVE_LINUX_FD_H
 # include <linux/fd.h>
 #endif
 

-#include <quotearg.h>
-

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

+#include <quotearg.h>

 #include <rmt.h>
 #include <stdarg.h>
 
 #include <rmt.h>
 #include <stdarg.h>
 


@@ -56,19 +46,20 @@ diff_init (void)
 {
   void *ptr;
   diff_buffer = page_aligned_alloc (&ptr, record_size);
 {
   void *ptr;
   diff_buffer = page_aligned_alloc (&ptr, record_size);

+  if (listed_incremental_option)
+    read_directory_file ();

 }
 
 /* Sigh about something that differs by writing a MESSAGE to stdlis,
    given MESSAGE is nonzero.  Also set the exit status if not already.  */
 void
 }
 
 /* Sigh about something that differs by writing a MESSAGE to stdlis,
    given MESSAGE is nonzero.  Also set the exit status if not already.  */
 void

-report_difference (struct tar_stat_info *st __attribute__ ((unused)),
-                  const char *fmt, ...)
+report_difference (struct tar_stat_info *st, const char *fmt, ...)

 {
   if (fmt)
     {
       va_list ap;
 
 {
   if (fmt)
     {
       va_list ap;
 

-      fprintf (stdlis, "%s: ", quotearg_colon (current_stat_info.file_name));
+      fprintf (stdlis, "%s: ", quotearg_colon (st->file_name));

       va_start (ap, fmt);
       vfprintf (stdlis, fmt, ap);
       va_end (ap);
       va_start (ap, fmt);
       vfprintf (stdlis, fmt, ap);
       va_end (ap);


@@ -119,36 +110,20 @@ process_rawdata (size_t bytes, char *buffer)
   return 1;
 }
 
   return 1;
 }
 

-/* Directory contents, only for GNUTYPE_DUMPDIR.  */
-
-static char *dumpdir_cursor;
-
-static int
-process_dumpdir (size_t bytes, char *buffer)
-{
-  if (memcmp (buffer, dumpdir_cursor, bytes))
-    {
-      report_difference (&current_stat_info, _("Contents differ"));
-      return 0;
-    }
-
-  dumpdir_cursor += bytes;
-  return 1;
-}
-

 /* Some other routine wants SIZE bytes in the archive.  For each chunk
    of the archive, call PROCESSOR with the size of the chunk, and the
    address of the chunk it can work with.  The PROCESSOR should return
 /* Some other routine wants SIZE bytes in the archive.  For each chunk
    of the archive, call PROCESSOR with the size of the chunk, and the
    address of the chunk it can work with.  The PROCESSOR should return

-   nonzero for success.  It it return error once, continue skipping
+   nonzero for success.  Once it returns error, continue skipping

    without calling PROCESSOR anymore.  */
    without calling PROCESSOR anymore.  */

+

 static void
 static void

-read_and_process (off_t size, int (*processor) (size_t, char *))
+read_and_process (struct tar_stat_info *st, int (*processor) (size_t, char *))

 {
   union block *data_block;
   size_t data_size;
 {
   union block *data_block;
   size_t data_size;

+  off_t size = st->stat.st_size;

 
 

-  if (multi_volume_option)
-    save_sizeleft = size;
+  mv_begin (st);

   while (size)
     {
       data_block = find_next_block ();
   while (size)
     {
       data_block = find_next_block ();


@@ -166,9 +141,9 @@ read_and_process (off_t size, int (*processor) (size_t, char *))
       set_next_block_after ((union block *)
                            (data_block->buffer + data_size - 1));
       size -= data_size;
       set_next_block_after ((union block *)
                            (data_block->buffer + data_size - 1));
       size -= data_size;

-      if (multi_volume_option)
-       save_sizeleft -= data_size;
+      mv_size_left (size);

     }
     }

+  mv_end ();

 }
 
 /* Call either stat or lstat over STAT_DATA, depending on
 }
 
 /* Call either stat or lstat over STAT_DATA, depending on


@@ -194,7 +169,7 @@ get_stat_data (char const *file_name, struct stat *stat_data)
 
 \f
 static void
 
 \f
 static void

-diff_dir ()
+diff_dir (void)

 {
   struct stat stat_data;
 
 {
   struct stat stat_data;
 


@@ -209,11 +184,12 @@ diff_dir ()
 }
 
 static void
 }
 
 static void

-diff_file ()
+diff_file (void)

 {
 {

+  char const *file_name = current_stat_info.file_name;

   struct stat stat_data;
 
   struct stat stat_data;
 

-  if (!get_stat_data (current_stat_info.file_name, &stat_data))
+  if (!get_stat_data (file_name, &stat_data))

     skip_member ();
   else if (!S_ISREG (stat_data.st_mode))
     {
     skip_member ();
   else if (!S_ISREG (stat_data.st_mode))
     {


@@ -231,63 +207,58 @@ diff_file ()
       if (!sys_compare_gid (&stat_data, &current_stat_info.stat))
        report_difference (&current_stat_info, _("Gid differs"));
 
       if (!sys_compare_gid (&stat_data, &current_stat_info.stat))
        report_difference (&current_stat_info, _("Gid differs"));
 

-      if (stat_data.st_mtime != current_stat_info.stat.st_mtime)
+      if (tar_timespec_cmp (get_stat_mtime (&stat_data),
+                            current_stat_info.mtime))

        report_difference (&current_stat_info, _("Mod time differs"));
        report_difference (&current_stat_info, _("Mod time differs"));

-      if (current_header->header.typeflag != GNUTYPE_SPARSE &&
-         stat_data.st_size != current_stat_info.stat.st_size)
+      if (current_header->header.typeflag != GNUTYPE_SPARSE
+         && stat_data.st_size != current_stat_info.stat.st_size)

        {
          report_difference (&current_stat_info, _("Size differs"));
          skip_member ();
        }
       else
        {
        {
          report_difference (&current_stat_info, _("Size differs"));
          skip_member ();
        }
       else
        {

-         int fd = open (current_stat_info.file_name, O_RDONLY | O_BINARY);
+         int atime_flag =
+           (atime_preserve_option == system_atime_preserve
+            ? O_NOATIME
+            : 0);
+
+         diff_handle = open (file_name, O_RDONLY | O_BINARY | atime_flag);

 
 

-         if (fd < 0)
+         if (diff_handle < 0)

            {
            {

-             open_error (current_stat_info.file_name);
+             open_error (file_name);

              skip_member ();
              report_difference (&current_stat_info, NULL);
            }
          else
            {
              int status;
              skip_member ();
              report_difference (&current_stat_info, NULL);
            }
          else
            {
              int status;

-             struct utimbuf restore_times;
-             
-             restore_times.actime = stat_data.st_atime;
-             restore_times.modtime = stat_data.st_mtime;

 
              if (current_stat_info.is_sparse)
                sparse_diff_file (diff_handle, &current_stat_info);
              else
 
              if (current_stat_info.is_sparse)
                sparse_diff_file (diff_handle, &current_stat_info);
              else

+               read_and_process (&current_stat_info, process_rawdata);
+
+             if (atime_preserve_option == replace_atime_preserve)

                {
                {

-                 if (multi_volume_option)
-                   {
-                     assign_string (&save_name, current_stat_info.file_name);
-                     save_totsize = current_stat_info.stat.st_size;
-                     /* save_sizeleft is set in read_and_process.  */
-                   }
-
-                 read_and_process (current_stat_info.stat.st_size,
-                                   process_rawdata);
-
-                 if (multi_volume_option)
-                   assign_string (&save_name, 0);
+                 struct timespec ts[2];
+                 ts[0] = get_stat_atime (&stat_data);
+                 ts[1] = get_stat_mtime (&stat_data);
+                 if (set_file_atime (diff_handle, file_name, ts) != 0)
+                   utime_error (file_name);

                }
 
                }
 

-             status = close (fd);
+             status = close (diff_handle);

              if (status != 0)
              if (status != 0)

-               close_error (current_stat_info.file_name);
-
-             if (atime_preserve_option)
-               utime (current_stat_info.file_name, &restore_times);
+               close_error (file_name);

            }
        }
     }
 }
 
 static void
            }
        }
     }
 }
 
 static void

-diff_link ()
+diff_link (void)

 {
   struct stat file_data;
   struct stat link_data;
 {
   struct stat file_data;
   struct stat link_data;


@@ -302,7 +273,7 @@ diff_link ()
 
 #ifdef HAVE_READLINK
 static void
 
 #ifdef HAVE_READLINK
 static void

-diff_symlink ()
+diff_symlink (void)

 {
   size_t len = strlen (current_stat_info.link_name);
   char *linkbuf = alloca (len + 1);
 {
   size_t len = strlen (current_stat_info.link_name);
   char *linkbuf = alloca (len + 1);


@@ -324,7 +295,7 @@ diff_symlink ()
 #endif
 
 static void
 #endif
 
 static void

-diff_special ()
+diff_special (void)

 {
   struct stat stat_data;
 
 {
   struct stat stat_data;
 


@@ -357,34 +328,71 @@ diff_special ()
     report_difference (&current_stat_info, _("Mode differs"));
 }
 
     report_difference (&current_stat_info, _("Mode differs"));
 }
 

+static int
+dumpdir_cmp (const char *a, const char *b)
+{
+  size_t len;
+  
+  while (*a)
+    switch (*a)
+      {
+      case 'Y':
+      case 'N':
+       if (!strchr ("YN", *b))
+         return 1;
+       if (strcmp(a + 1, b + 1))
+         return 1;
+       len = strlen (a) + 1;
+       a += len;
+       b += len;
+       break;
+       
+      case 'D':
+       if (strcmp(a, b))
+         return 1;
+       len = strlen (a) + 1;
+       a += len;
+       b += len;
+       break;
+       
+      case 'R':
+      case 'T':
+      case 'X':
+       return *b;
+      }
+  return *b;
+}
+

 static void
 static void

-diff_dumpdir ()
+diff_dumpdir (void)

 {
 {

-  char *dumpdir_buffer = get_directory_contents (current_stat_info.file_name,
-                                                0);
+  const char *dumpdir_buffer;
+  dev_t dev = 0;
+  struct stat stat_data;

 
 

-  if (multi_volume_option)
+  if (deref_stat (true, current_stat_info.file_name, &stat_data))

     {
     {

-      assign_string (&save_name, current_stat_info.file_name);
-      save_totsize = current_stat_info.stat.st_size;
-      /* save_sizeleft is set in read_and_process.  */
+      if (errno == ENOENT)
+       stat_warn (current_stat_info.file_name);
+      else
+       stat_error (current_stat_info.file_name);

     }
     }

+  else
+    dev = stat_data.st_dev;
+
+  dumpdir_buffer = scan_directory (current_stat_info.file_name, dev, false);

 
   if (dumpdir_buffer)
     {
 
   if (dumpdir_buffer)
     {

-      dumpdir_cursor = dumpdir_buffer;
-      read_and_process (current_stat_info.stat.st_size, process_dumpdir);
-      free (dumpdir_buffer);
+      if (dumpdir_cmp (current_stat_info.dumpdir, dumpdir_buffer))
+       report_difference (&current_stat_info, _("Contents differ"));

     }
   else
     }
   else

-    read_and_process (current_stat_info.stat.st_size, process_noop);
-
-  if (multi_volume_option)
-    assign_string (&save_name, 0);
+    read_and_process (&current_stat_info, process_noop);

 }
 
 static void
 }
 
 static void

-diff_multivol ()
+diff_multivol (void)

 {
   struct stat stat_data;
   int fd, status;
 {
   struct stat stat_data;
   int fd, status;


@@ -395,7 +403,7 @@ diff_multivol ()
       diff_dir ();
       return;
     }
       diff_dir ();
       return;
     }

-  
+

   if (!get_stat_data (current_stat_info.file_name, &stat_data))
     return;
 
   if (!get_stat_data (current_stat_info.file_name, &stat_data))
     return;
 


@@ -415,7 +423,7 @@ diff_multivol ()
     }
 
   fd = open (current_stat_info.file_name, O_RDONLY | O_BINARY);
     }
 
   fd = open (current_stat_info.file_name, O_RDONLY | O_BINARY);

-  
+

   if (fd < 0)
     {
       open_error (current_stat_info.file_name);
   if (fd < 0)
     {
       open_error (current_stat_info.file_name);


@@ -431,18 +439,8 @@ diff_multivol ()
       return;
     }
 
       return;
     }
 

-  if (multi_volume_option)
-    {
-      assign_string (&save_name, current_stat_info.file_name);
-      save_totsize = stat_data.st_size;
-      /* save_sizeleft is set in read_and_process.  */
-    }
-
-  read_and_process (current_stat_info.stat.st_size, process_rawdata);
+  read_and_process (&current_stat_info, process_rawdata);

 
 

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

   status = close (fd);
   if (status != 0)
     close_error (current_stat_info.file_name);
   status = close (fd);
   if (status != 0)
     close_error (current_stat_info.file_name);


@@ -468,7 +466,7 @@ diff_archive (void)
   switch (current_header->header.typeflag)
     {
     default:
   switch (current_header->header.typeflag)
     {
     default:

-      ERROR ((0, 0, _("%s: Unknown file type '%c', diffed as normal file"),
+      ERROR ((0, 0, _("%s: Unknown file type `%c', diffed as normal file"),

              quotearg_colon (current_stat_info.file_name),
              current_header->header.typeflag));
       /* Fall through.  */
              quotearg_colon (current_stat_info.file_name),
              current_header->header.typeflag));
       /* Fall through.  */


@@ -495,7 +493,7 @@ diff_archive (void)
       diff_symlink ();
       break;
 #endif
       diff_symlink ();
       break;
 #endif

-      
+

     case CHRTYPE:
     case BLKTYPE:
     case FIFOTYPE:
     case CHRTYPE:
     case BLKTYPE:
     case FIFOTYPE:


@@ -503,10 +501,9 @@ diff_archive (void)
       break;
 
     case GNUTYPE_DUMPDIR:
       break;
 
     case GNUTYPE_DUMPDIR:

-      diff_dumpdir ();
-      /* Fall through.  */
-      

     case DIRTYPE:
     case DIRTYPE:

+      if (is_dumpdir (&current_stat_info))
+       diff_dumpdir ();

       diff_dir ();
       break;
 
       diff_dir ();
       break;
 


@@ -600,12 +597,26 @@ verify_volume (void)
                            "VERIFY FAILURE: %d invalid headers detected",
                            counter), counter));
        }
                            "VERIFY FAILURE: %d invalid headers detected",
                            counter), counter));
        }

-      if (status == HEADER_ZERO_BLOCK || status == HEADER_END_OF_FILE)
+      if (status == HEADER_END_OF_FILE)

        break;
        break;

+      if (status == HEADER_ZERO_BLOCK)
+       {
+         set_next_block_after (current_header);
+          if (!ignore_zeros_option)
+            {
+             char buf[UINTMAX_STRSIZE_BOUND];

 
 

+             status = read_header (false);
+             if (status == HEADER_ZERO_BLOCK)
+               break;
+             WARNOPT (WARN_ALONE_ZERO_BLOCK,
+                      (0, 0, _("A lone zero block at %s"),
+                       STRINGIFY_BIGINT (current_block_ordinal (), buf)));
+            }
+       }
+      

       diff_archive ();
       tar_stat_destroy (&current_stat_info);
       diff_archive ();
       tar_stat_destroy (&current_stat_info);

-      xheader_destroy (&extended_header);

     }
 
   access_mode = ACCESS_WRITE;
     }
 
   access_mode = ACCESS_WRITE;