(read_and, list_archive): Simplify code.

(read_header): Fix computation of signed checksums on machines where
char is unsigned.
Do not consider a block to be zero unless all its bytes are zero,
even the checksum bytes.  Do not attempt to parse the checksum of
a zero block.  Fix memory leak with long names and links.
(from_chars): Accommodate a buggy tar that outputs leading NUL
if the previous field overflows.
(skip_extended_headers): Don't assume find_next_block yields nonnull.

diff --git a/src/list.c b/src/list.c
index 1c245319cd57ff0c4147137eb38676d3d6a6a824..2109d8fe36e370e36633e1ff69d868175f6b9db8 100644 (file)
--- a/src/list.c
+++ b/src/list.c
@@ -55,7 +55,6 @@ read_and (void (*do_something) ())
 {
   enum read_header status = HEADER_STILL_UNREAD;
   enum read_header prev_status;
-  char save_typeflag;
 
   base64_init ();
   name_gather ();
@@ -83,7 +82,7 @@ read_and (void (*do_something) ())
              || current_stat.st_mtime < newer_mtime_option
              || excluded_name (current_file_name))
            {
-             int isextended = 0;
+             char save_typeflag;
 
              if (current_header->header.typeflag == GNUTYPE_VOLHDR
                  || current_header->header.typeflag == GNUTYPE_MULTIVOL
@@ -98,28 +97,10 @@ read_and (void (*do_something) ())
 
              /* Skip past it in the archive.  */
 
-             if (current_header->oldgnu_header.isextended)
-               isextended = 1;
              save_typeflag = current_header->header.typeflag;
              set_next_block_after (current_header);
-             if (isextended)
-               {
-#if 0
-                 union block *exhdr;
-
-                 while (1)
-                   {
-                     exhdr = find_next_block ();
-                     if (!exhdr->sparse_header.isextended)
-                       {
-                         set_next_block_after (exhdr);
-                         break;
-                       }
-                   }
-                 set_next_block_after (exhdr);
-#endif
-                 skip_extended_headers ();
-               }
+             if (current_header->oldgnu_header.isextended)
+               skip_extended_headers ();
 
              /* Skip to the next header on the archive.  */
 
@@ -191,8 +172,6 @@ read_and (void (*do_something) ())
 void
 list_archive (void)
 {
-  int isextended = 0;          /* to remember if current_header is extended */
-
   /* Print the header block.  */
 
   if (verbose_option)
@@ -248,37 +227,11 @@ list_archive (void)
 
     }
 
-  /* Check to see if we have an extended header to skip over also.  */
-
-  if (current_header->oldgnu_header.isextended)
-    isextended = 1;
-
-  /* Skip past the header in the archive.  */
+  /* Skip past the header in the archive, and past any extended headers.  */
 
   set_next_block_after (current_header);
-
-  /* If we needed to skip any extended headers, do so now, by reading
-     extended headers and skipping past them in the archive.  */
-
-  if (isextended)
-    {
-#if 0
-      union block *exhdr;
-
-      while (1)
-       {
-         exhdr = find_next_block ();
-
-         if (!exhdr->sparse_header.isextended)
-           {
-             set_next_block_after (exhdr);
-             break;
-           }
-         set_next_block_after (exhdr);
-       }
-#endif
-      skip_extended_headers ();
-    }
+  if (current_header->oldgnu_header.isextended)
+    skip_extended_headers ();
 
   if (multi_volume_option)
     assign_string (&save_name, current_file_name);
@@ -312,16 +265,13 @@ list_archive (void)
    a name containing characters with the high bit set.  So read_header
    computes two checksums -- signed and unsigned.  */
 
-/* FIXME: The signed checksum computation is broken on machines where char's
-   are unsigned.  It's uneasy to handle all cases correctly...  */
-
 enum read_header
 read_header (void)
 {
   size_t i;
-  long unsigned_sum;           /* the POSIX one :-) */
-  long signed_sum;             /* the Sun one :-( */
-  long recorded_sum;
+  int unsigned_sum;            /* the POSIX one :-) */
+  int signed_sum;              /* the Sun one :-( */
+  int recorded_sum;
   uintmax_t parsed_sum;
   char *p;
   union block *header;
@@ -338,43 +288,36 @@ read_header (void)
       if (!header)
        return HEADER_END_OF_FILE;
 
-      parsed_sum = from_chars (header->header.chksum,
-                              sizeof header->header.chksum,
-                              (char *) 0, (uintmax_t) 0,
-                              (uintmax_t) TYPE_MAXIMUM (long));
-      if (parsed_sum == (uintmax_t) -1)
-       return HEADER_FAILURE;
-
-      recorded_sum = parsed_sum;
       unsigned_sum = 0;
       signed_sum = 0;
       p = header->buffer;
       for (i = sizeof (*header); i-- != 0;)
        {
-         /* We can't use unsigned char here because of old compilers,
-            e.g. V7.  */
-
-         unsigned_sum += 0xFF & *p;
-         signed_sum += *p++;
+         unsigned_sum += (unsigned char) *p;
+         signed_sum += signed_char (*p++);
        }
 
+      if (unsigned_sum == 0)
+       return HEADER_ZERO_BLOCK;
+
       /* Adjust checksum to count the "chksum" field as blanks.  */
 
       for (i = sizeof (header->header.chksum); i-- != 0;)
        {
-         unsigned_sum -= 0xFF & header->header.chksum[i];
-         signed_sum -= header->header.chksum[i];
+         unsigned_sum -= (unsigned char) header->header.chksum[i];
+         signed_sum -= signed_char (header->header.chksum[i]);
        }
       unsigned_sum += ' ' * sizeof header->header.chksum;
       signed_sum += ' ' * sizeof header->header.chksum;
 
-      if (unsigned_sum == sizeof header->header.chksum * ' ')
-       {
-         /* This is a zeroed block...whole block is 0's except for the
-            blanks we faked for the checksum field.  */
+      parsed_sum = from_chars (header->header.chksum,
+                              sizeof header->header.chksum,
+                              (char *) 0, (uintmax_t) 0,
+                              (uintmax_t) TYPE_MAXIMUM (int));
+      if (parsed_sum == (uintmax_t) -1)
+       return HEADER_FAILURE;
 
-         return HEADER_ZERO_BLOCK;
-       }
+      recorded_sum = parsed_sum;
 
       if (unsigned_sum != recorded_sum && signed_sum != recorded_sum)
        return HEADER_FAILURE;
@@ -448,6 +391,11 @@ read_header (void)
              name = namebuf;
            }
          assign_string (&current_file_name, name);
+         if (next_long_name)
+           {
+             free (next_long_name);
+             next_long_name = 0;
+           }
          
          name = next_long_link;
          if (! name)
@@ -457,8 +405,12 @@ read_header (void)
              name = namebuf;
            }
          assign_string (&current_link_name, name);
+         if (next_long_link)
+           {
+             free (next_long_link);
+             next_long_link = 0;
+           }
 
-         next_long_link = next_long_name = 0;
          return HEADER_SUCCESS;
        }
     }
@@ -560,17 +512,19 @@ from_chars (char const *where0, size_t digs, char const *type,
   char const *lim = where + digs;
   int negative = 0;
 
+  /* Accommodate older tars, which output leading spaces, and at least one
+     buggy tar, which outputs leading NUL if the previous field overflows.  */
   for (;;)
     {
       if (where == lim)
        {
          if (type)
            ERROR ((0, 0,
-                   _("Blanks in header where numeric %s value expected"),
+                   _("Empty header where numeric %s value expected"),
                    type));
          return -1;
        }
-      if (!ISSPACE ((unsigned char) *where))
+      if (!ISSPACE ((unsigned char) *where) && *where)
        break;
       where++;
     }
@@ -1123,14 +1077,12 @@ skip_extended_headers (void)
 {
   union block *exhdr;
 
-  while (1)
+  do
     {
       exhdr = find_next_block ();
-      if (!exhdr->sparse_header.isextended)
-       {
-         set_next_block_after (exhdr);
-         break;
-       }
+      if (!exhdr)
+       FATAL_ERROR ((0, 0, _("Unexpected EOF on archive file")));
       set_next_block_after (exhdr);
     }
+  while (exhdr->sparse_header.isextended);
 }