* NEWS: Update.

[chaz/tar] / src / compare.c

diff --git a/src/compare.c b/src/compare.c
index b623562c550a5749161f428e18f8b0c28838b081..f3723049ed055b3b4ef7d96c5d5c23914b0ab9d8 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,
-   2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+   2003, 2004, 2005, 2006, 2007 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
-   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
@@ -110,27 +110,10 @@ process_rawdata (size_t bytes, char *buffer)
   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
-   nonzero for success.  It it return error once, continue skipping
+   nonzero for success.  Once it returns error, continue skipping
    without calling PROCESSOR anymore.  */
 
 static void
@@ -345,14 +328,49 @@ diff_special (void)
     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
 diff_dumpdir (void)
 {
   char *dumpdir_buffer;
   dev_t dev = 0;
-  struct stat stat;
+  struct stat stat_data;
 
-  if (deref_stat (true, current_stat_info.file_name, &stat))
+  if (deref_stat (true, current_stat_info.file_name, &stat_data))
     {
       if (errno == ENOENT)
        stat_warn (current_stat_info.file_name);
@@ -360,15 +378,14 @@ diff_dumpdir (void)
        stat_error (current_stat_info.file_name);
     }
   else
-    dev = stat.st_dev;
+    dev = stat_data.st_dev;
 
   dumpdir_buffer = get_directory_contents (current_stat_info.file_name, dev);
 
   if (dumpdir_buffer)
     {
-      dumpdir_cursor = dumpdir_buffer;
-      read_and_process (&current_stat_info, process_dumpdir);
-      free (dumpdir_buffer);
+      if (dumpdir_cmp (current_stat_info.dumpdir, dumpdir_buffer))
+       report_difference (&current_stat_info, _("Contents differ"));
     }
   else
     read_and_process (&current_stat_info, process_noop);
@@ -484,10 +501,9 @@ diff_archive (void)
       break;
 
     case GNUTYPE_DUMPDIR:
-      diff_dumpdir ();
-      /* Fall through.  */
-
     case DIRTYPE:
+      if (is_dumpdir (&current_stat_info))
+       diff_dumpdir ();
       diff_dir ();
       break;
 
@@ -581,12 +597,25 @@ verify_volume (void)
                            "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;
+      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;
+             WARN ((0, 0, _("A lone zero block at %s"),
+                   STRINGIFY_BIGINT (current_block_ordinal (), buf)));
+            }
+       }
+      
       diff_archive ();
       tar_stat_destroy (&current_stat_info);
-      xheader_destroy (&extended_header);
     }
 
   access_mode = ACCESS_WRITE;