Fix some problems with negative and out-of-range integers.

[chaz/tar] / src / list.c

diff --git a/src/list.c b/src/list.c
index ddf044df0e1f1621b8669aceacbf42df43b2c297..8ba07cd95490182fbd2dfa3b469ff4f9b1e17e02 100644 (file)
--- a/src/list.c
+++ b/src/list.c
@@ -1,13 +1,14 @@
 /* List a tar archive, with support routines for reading a tar archive.
 
    Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,
 /* List a tar archive, with support routines for reading a tar archive.
 
    Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,

-   2001, 2003, 2004, 2005 Free Software Foundation, Inc.
+   2001, 2003, 2004, 2005, 2006, 2007, 2010, 2012
+   Free Software Foundation, Inc.

 
    Written by John Gilmore, on 1985-08-26.
 
    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-26.
 
    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


@@ -25,17 +26,30 @@
 
 #include "common.h"
 
 
 #include "common.h"
 

-#define max(a, b) ((a) < (b) ? (b) : (a))
-

 union block *current_header;   /* points to current archive header */
 enum archive_format current_format; /* recognized format */
 union block *recent_long_name; /* recent long name header and contents */
 union block *recent_long_link; /* likewise, for long link */
 size_t recent_long_name_blocks;        /* number of blocks in recent_long_name */
 size_t recent_long_link_blocks;        /* likewise, for long link */
 union block *current_header;   /* points to current archive header */
 enum archive_format current_format; /* recognized format */
 union block *recent_long_name; /* recent long name header and contents */
 union block *recent_long_link; /* likewise, for long link */
 size_t recent_long_name_blocks;        /* number of blocks in recent_long_name */
 size_t recent_long_link_blocks;        /* likewise, for long link */

-
-static uintmax_t from_header (const char *, size_t, const char *,
-                             uintmax_t, uintmax_t, bool, bool);
+static union block *recent_global_header; /* Recent global header block */
+
+#define GID_FROM_HEADER(where) gid_from_header (where, sizeof (where))
+#define MAJOR_FROM_HEADER(where) major_from_header (where, sizeof (where))
+#define MINOR_FROM_HEADER(where) minor_from_header (where, sizeof (where))
+#define MODE_FROM_HEADER(where, hbits) \
+  mode_from_header (where, sizeof (where), hbits)
+#define TIME_FROM_HEADER(where) time_from_header (where, sizeof (where))
+#define UID_FROM_HEADER(where) uid_from_header (where, sizeof (where))
+
+static gid_t gid_from_header (const char *buf, size_t size);
+static major_t major_from_header (const char *buf, size_t size);
+static minor_t minor_from_header (const char *buf, size_t size);
+static mode_t mode_from_header (const char *buf, size_t size, bool *hbits);
+static time_t time_from_header (const char *buf, size_t size);
+static uid_t uid_from_header (const char *buf, size_t size);
+static intmax_t from_header (const char *, size_t, const char *,
+                            intmax_t, uintmax_t, bool, bool);

 
 /* Base 64 digits; see Internet RFC 2045 Table 1.  */
 static char const base_64_digits[64] =
 
 /* Base 64 digits; see Internet RFC 2045 Table 1.  */
 static char const base_64_digits[64] =


@@ -60,6 +74,66 @@ base64_init (void)
     base64_map[(int) base_64_digits[i]] = i;
 }
 
     base64_map[(int) base_64_digits[i]] = i;
 }
 

+static char *
+decode_xform (char *file_name, void *data)
+{
+  int type = *(int*)data;
+
+  switch (type)
+    {
+    case XFORM_SYMLINK:
+      /* FIXME: It is not quite clear how and to which extent are the symbolic
+        links subject to filename transformation.  In the absence of another
+        solution, symbolic links are exempt from component stripping and
+        name suffix normalization, but subject to filename transformation
+        proper. */
+      return file_name;
+
+    case XFORM_LINK:
+      file_name = safer_name_suffix (file_name, true, absolute_names_option);
+      break;
+
+    case XFORM_REGFILE:
+      file_name = safer_name_suffix (file_name, false, absolute_names_option);
+      break;
+    }
+
+  if (strip_name_components)
+    {
+      size_t prefix_len = stripped_prefix_len (file_name,
+                                              strip_name_components);
+      if (prefix_len == (size_t) -1)
+       prefix_len = strlen (file_name);
+      file_name += prefix_len;
+    }
+  return file_name;
+}
+
+static bool
+transform_member_name (char **pinput, int type)
+{
+  return transform_name_fp (pinput, type, decode_xform, &type);
+}
+
+void
+transform_stat_info (int typeflag, struct tar_stat_info *stat_info)
+{
+  if (typeflag == GNUTYPE_VOLHDR)
+    /* Name transformations don't apply to volume headers. */
+    return;
+
+  transform_member_name (&stat_info->file_name, XFORM_REGFILE);
+  switch (typeflag)
+    {
+    case SYMTYPE:
+      transform_member_name (&stat_info->link_name, XFORM_SYMLINK);
+      break;
+
+    case LNKTYPE:
+      transform_member_name (&stat_info->link_name, XFORM_LINK);
+    }
+}
+

 /* Main loop for reading an archive.  */
 void
 read_and (void (*do_something) (void))
 /* Main loop for reading an archive.  */
 void
 read_and (void (*do_something) (void))


@@ -76,9 +150,9 @@ read_and (void (*do_something) (void))
     {
       prev_status = status;
       tar_stat_destroy (&current_stat_info);
     {
       prev_status = status;
       tar_stat_destroy (&current_stat_info);

-      xheader_destroy (&extended_header);

 
 

-      status = read_header (false);
+      status = read_header (&current_header, &current_stat_info,
+                            read_header_auto);

       switch (status)
        {
        case HEADER_STILL_UNREAD:
       switch (status)
        {
        case HEADER_STILL_UNREAD:


@@ -89,7 +163,8 @@ read_and (void (*do_something) (void))
 
          /* Valid header.  We should decode next field (mode) first.
             Ensure incoming names are null terminated.  */
 
          /* Valid header.  We should decode next field (mode) first.
             Ensure incoming names are null terminated.  */

-
+         decode_header (current_header, &current_stat_info,
+                        &current_format, 1);

          if (! name_match (current_stat_info.file_name)
              || (NEWER_OPTION_INITIALIZED (newer_mtime_option)
                  /* FIXME: We get mtime now, and again later; this causes
          if (! name_match (current_stat_info.file_name)
              || (NEWER_OPTION_INITIALIZED (newer_mtime_option)
                  /* FIXME: We get mtime now, and again later; this causes


@@ -99,15 +174,14 @@ read_and (void (*do_something) (void))
                      /* FIXME: Grab fractional time stamps from
                         extended header.  */
                      mtime.tv_nsec = 0,
                      /* FIXME: Grab fractional time stamps from
                         extended header.  */
                      mtime.tv_nsec = 0,

-                     set_stat_mtime (&current_stat_info.stat, mtime),
-                     OLDER_STAT_TIME (current_stat_info.stat, m)))
+                     current_stat_info.mtime = mtime,
+                     OLDER_TAR_STAT_TIME (current_stat_info, m)))

              || excluded_name (current_stat_info.file_name))
            {
              switch (current_header->header.typeflag)
                {
                case GNUTYPE_VOLHDR:
                case GNUTYPE_MULTIVOL:
              || excluded_name (current_stat_info.file_name))
            {
              switch (current_header->header.typeflag)
                {
                case GNUTYPE_VOLHDR:
                case GNUTYPE_MULTIVOL:

-               case GNUTYPE_NAMES:

                  break;
 
                case DIRTYPE:
                  break;
 
                case DIRTYPE:


@@ -116,13 +190,12 @@ read_and (void (*do_something) (void))
                           quotearg_colon (current_stat_info.file_name)));
                  /* Fall through.  */
                default:
                           quotearg_colon (current_stat_info.file_name)));
                  /* Fall through.  */
                default:

-                 decode_header (current_header,
-                                &current_stat_info, &current_format, 0);

                  skip_member ();
                  continue;
                }
            }
                  skip_member ();
                  continue;
                }
            }

-
+         transform_stat_info (current_header->header.typeflag,
+                              &current_stat_info);

          (*do_something) ();
          continue;
 
          (*do_something) ();
          continue;
 


@@ -140,11 +213,13 @@ read_and (void (*do_something) (void))
            {
              char buf[UINTMAX_STRSIZE_BOUND];
 
            {
              char buf[UINTMAX_STRSIZE_BOUND];
 

-             status = read_header (false);
+             status = read_header (&current_header, &current_stat_info,
+                                   read_header_auto);

              if (status == HEADER_ZERO_BLOCK)
                break;
              if (status == HEADER_ZERO_BLOCK)
                break;

-             WARN ((0, 0, _("A lone zero block at %s"),
-                    STRINGIFY_BIGINT (current_block_ordinal (), buf)));
+             WARNOPT (WARN_ALONE_ZERO_BLOCK,
+                      (0, 0, _("A lone zero block at %s"),
+                       STRINGIFY_BIGINT (current_block_ordinal (), buf)));

              break;
            }
          status = prev_status;
              break;
            }
          status = prev_status;


@@ -205,63 +280,23 @@ read_and (void (*do_something) (void))
 void
 list_archive (void)
 {
 void
 list_archive (void)
 {

-  /* Print the header block.  */
+  off_t block_ordinal = current_block_ordinal ();

 
 

-  decode_header (current_header, &current_stat_info, &current_format, 0);
+  /* Print the header block.  */

   if (verbose_option)
   if (verbose_option)

-    print_header (&current_stat_info, -1);
+    print_header (&current_stat_info, current_header, block_ordinal);

 
 

-  if (incremental_option && current_header->header.typeflag == GNUTYPE_DUMPDIR)
+  if (incremental_option)

     {
     {

-      off_t size;
-      size_t written, check;
-      union block *data_block;
-
-      set_next_block_after (current_header);
-      if (multi_volume_option)
+      if (verbose_option > 2)

        {
        {

-         assign_string (&save_name, current_stat_info.orig_file_name);
-         save_totsize = current_stat_info.stat.st_size;
-       }
-      for (size = current_stat_info.stat.st_size; size > 0; size -= written)
-       {
-         if (multi_volume_option)
-           save_sizeleft = size;
-         data_block = find_next_block ();
-         if (!data_block)
-           {
-             ERROR ((0, 0, _("Unexpected EOF in archive")));
-             break;            /* FIXME: What happens, then?  */
-           }
-         written = available_space_after (data_block);
-         if (written > size)
-           written = size;
-         errno = 0;
-         check = fwrite (data_block->buffer, sizeof (char), written, stdlis);
-         set_next_block_after ((union block *)
-                               (data_block->buffer + written - 1));
-         if (check != written)
-           {
-             write_error_details (current_stat_info.file_name, check, written);
-             skip_file (size - written);
-             break;
-           }
+         if (is_dumpdir (&current_stat_info))
+           list_dumpdir (current_stat_info.dumpdir,
+                         dumpdir_size (current_stat_info.dumpdir));

        }
        }

-      if (multi_volume_option)
-       assign_string (&save_name, 0);
-      fputc ('\n', stdlis);
-      fflush (stdlis);
-      return;
-

     }
 
     }
 

-  if (multi_volume_option)
-    assign_string (&save_name, current_stat_info.orig_file_name);
-

   skip_member ();
   skip_member ();

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

 }
 
 /* Check header checksum */
 }
 
 /* Check header checksum */


@@ -281,7 +316,7 @@ tar_checksum (union block *header, bool silent)
   int unsigned_sum = 0;                /* the POSIX one :-) */
   int signed_sum = 0;          /* the Sun one :-( */
   int recorded_sum;
   int unsigned_sum = 0;                /* the POSIX one :-) */
   int signed_sum = 0;          /* the Sun one :-( */
   int recorded_sum;

-  uintmax_t parsed_sum;
+  int parsed_sum;

   char *p;
 
   p = header->buffer;
   char *p;
 
   p = header->buffer;


@@ -306,9 +341,8 @@ tar_checksum (union block *header, bool silent)
 
   parsed_sum = from_header (header->header.chksum,
                            sizeof header->header.chksum, 0,
 
   parsed_sum = from_header (header->header.chksum,
                            sizeof header->header.chksum, 0,

-                           (uintmax_t) 0,
-                           (uintmax_t) TYPE_MAXIMUM (int), true, silent);
-  if (parsed_sum == (uintmax_t) -1)
+                           0, INT_MAX, true, silent);
+  if (parsed_sum < 0)

     return HEADER_FAILURE;
 
   recorded_sum = parsed_sum;
     return HEADER_FAILURE;
 
   recorded_sum = parsed_sum;


@@ -320,20 +354,29 @@ tar_checksum (union block *header, bool silent)
 }
 
 /* Read a block that's supposed to be a header block.  Return its
 }
 
 /* Read a block that's supposed to be a header block.  Return its

-   address in "current_header", and if it is good, the file's size in
-   current_stat_info.stat.st_size.
+   address in *RETURN_BLOCK, and if it is good, the file's size
+   and names (file name, link name) in *INFO.
+
+   Return one of enum read_header describing the status of the
+   operation.

 
 

-   Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
-   block full of zeros (EOF marker).
+   The MODE parameter instructs read_header what to do with special
+   header blocks, i.e.: extended POSIX, GNU long name or long link,
+   etc.:

 
 

-   If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
-   GNU long name and link headers into later headers.
+     read_header_auto        process them automatically,
+     read_header_x_raw       when a special header is read, return
+                             HEADER_SUCCESS_EXTENDED without actually
+                            processing the header,
+     read_header_x_global    when a POSIX global header is read,
+                             decode it and return HEADER_SUCCESS_EXTENDED.

 
 

-   You must always set_next_block_after(current_header) to skip past
+   You must always set_next_block_after(*return_block) to skip past

    the header which this routine reads.  */
 
 enum read_header
    the header which this routine reads.  */
 
 enum read_header

-read_header (bool raw_extended_headers)
+read_header (union block **return_block, struct tar_stat_info *info,
+            enum read_header_mode mode)

 {
   union block *header;
   union block *header_copy;
 {
   union block *header;
   union block *header_copy;


@@ -342,15 +385,15 @@ read_header (bool raw_extended_headers)
   size_t size, written;
   union block *next_long_name = 0;
   union block *next_long_link = 0;
   size_t size, written;
   union block *next_long_name = 0;
   union block *next_long_link = 0;

-  size_t next_long_name_blocks;
-  size_t next_long_link_blocks;
+  size_t next_long_name_blocks = 0;
+  size_t next_long_link_blocks = 0;

 
   while (1)
     {
       enum read_header status;
 
       header = find_next_block ();
 
   while (1)
     {
       enum read_header status;
 
       header = find_next_block ();

-      current_header = header;
+      *return_block = header;

       if (!header)
        return HEADER_END_OF_FILE;
 
       if (!header)
        return HEADER_END_OF_FILE;
 


@@ -360,9 +403,13 @@ read_header (bool raw_extended_headers)
       /* Good block.  Decode file size and return.  */
 
       if (header->header.typeflag == LNKTYPE)
       /* Good block.  Decode file size and return.  */
 
       if (header->header.typeflag == LNKTYPE)

-       current_stat_info.stat.st_size = 0;     /* links 0 size on tape */
+       info->stat.st_size = 0; /* links 0 size on tape */

       else
       else

-       current_stat_info.stat.st_size = OFF_FROM_HEADER (header->header.size);
+       {
+         info->stat.st_size = OFF_FROM_HEADER (header->header.size);
+         if (info->stat.st_size < 0)
+           return HEADER_FAILURE;
+       }

 
       if (header->header.typeflag == GNUTYPE_LONGNAME
          || header->header.typeflag == GNUTYPE_LONGLINK
 
       if (header->header.typeflag == GNUTYPE_LONGNAME
          || header->header.typeflag == GNUTYPE_LONGLINK


@@ -370,34 +417,31 @@ read_header (bool raw_extended_headers)
          || header->header.typeflag == XGLTYPE
          || header->header.typeflag == SOLARIS_XHDTYPE)
        {
          || header->header.typeflag == XGLTYPE
          || header->header.typeflag == SOLARIS_XHDTYPE)
        {

-         if (raw_extended_headers)
+         if (mode == read_header_x_raw)

            return HEADER_SUCCESS_EXTENDED;
          else if (header->header.typeflag == GNUTYPE_LONGNAME
                   || header->header.typeflag == GNUTYPE_LONGLINK)
            {
            return HEADER_SUCCESS_EXTENDED;
          else if (header->header.typeflag == GNUTYPE_LONGNAME
                   || header->header.typeflag == GNUTYPE_LONGLINK)
            {

-             size_t name_size = current_stat_info.stat.st_size;
+             size_t name_size = info->stat.st_size;

              size_t n = name_size % BLOCKSIZE;
              size = name_size + BLOCKSIZE;
              if (n)
                size += BLOCKSIZE - n;
 
              size_t n = name_size % BLOCKSIZE;
              size = name_size + BLOCKSIZE;
              if (n)
                size += BLOCKSIZE - n;
 

-             if (name_size != current_stat_info.stat.st_size
-                 || size < name_size)
+             if (name_size != info->stat.st_size || size < name_size)

                xalloc_die ();
 
              header_copy = xmalloc (size + 1);
 
              if (header->header.typeflag == GNUTYPE_LONGNAME)
                {
                xalloc_die ();
 
              header_copy = xmalloc (size + 1);
 
              if (header->header.typeflag == GNUTYPE_LONGNAME)
                {

-                 if (next_long_name)
-                   free (next_long_name);
+                 free (next_long_name);

                  next_long_name = header_copy;
                  next_long_name_blocks = size / BLOCKSIZE;
                }
              else
                {
                  next_long_name = header_copy;
                  next_long_name_blocks = size / BLOCKSIZE;
                }
              else
                {

-                 if (next_long_link)
-                   free (next_long_link);
+                 free (next_long_link);

                  next_long_link = header_copy;
                  next_long_link_blocks = size / BLOCKSIZE;
                }
                  next_long_link = header_copy;
                  next_long_link_blocks = size / BLOCKSIZE;
                }


@@ -428,11 +472,23 @@ read_header (bool raw_extended_headers)
            }
          else if (header->header.typeflag == XHDTYPE
                   || header->header.typeflag == SOLARIS_XHDTYPE)
            }
          else if (header->header.typeflag == XHDTYPE
                   || header->header.typeflag == SOLARIS_XHDTYPE)

-           xheader_read (header, OFF_FROM_HEADER (header->header.size));
+           xheader_read (&info->xhdr, header,
+                         OFF_FROM_HEADER (header->header.size));

          else if (header->header.typeflag == XGLTYPE)
            {
          else if (header->header.typeflag == XGLTYPE)
            {

-             xheader_read (header, OFF_FROM_HEADER (header->header.size));
-             xheader_decode_global ();
+             struct xheader xhdr;
+
+             if (!recent_global_header)
+               recent_global_header = xmalloc (sizeof *recent_global_header);
+             memcpy (recent_global_header, header,
+                     sizeof *recent_global_header);
+             memset (&xhdr, 0, sizeof xhdr);
+             xheader_read (&xhdr, header,
+                           OFF_FROM_HEADER (header->header.size));
+             xheader_decode_global (&xhdr);
+             xheader_destroy (&xhdr);
+             if (mode == read_header_x_global)
+               return HEADER_SUCCESS_EXTENDED;

            }
 
          /* Loop!  */
            }
 
          /* Loop!  */


@@ -441,11 +497,10 @@ read_header (bool raw_extended_headers)
       else
        {
          char const *name;
       else
        {
          char const *name;

-         struct posix_header const *h = &current_header->header;
+         struct posix_header const *h = &header->header;

          char namebuf[sizeof h->prefix + 1 + NAME_FIELD_SIZE + 1];
 
          char namebuf[sizeof h->prefix + 1 + NAME_FIELD_SIZE + 1];
 

-         if (recent_long_name)
-           free (recent_long_name);
+         free (recent_long_name);

 
          if (next_long_name)
            {
 
          if (next_long_name)
            {


@@ -472,12 +527,11 @@ read_header (bool raw_extended_headers)
              recent_long_name = 0;
              recent_long_name_blocks = 0;
            }
              recent_long_name = 0;
              recent_long_name_blocks = 0;
            }

-         assign_string (&current_stat_info.orig_file_name, name);
-         assign_string (&current_stat_info.file_name, name);
-         current_stat_info.had_trailing_slash = strip_trailing_slashes (current_stat_info.file_name);
+         assign_string (&info->orig_file_name, name);
+         assign_string (&info->file_name, name);
+         info->had_trailing_slash = strip_trailing_slashes (info->file_name);

 
 

-         if (recent_long_link)
-           free (recent_long_link);
+         free (recent_long_link);

 
          if (next_long_link)
            {
 
          if (next_long_link)
            {


@@ -493,7 +547,7 @@ read_header (bool raw_extended_headers)
              recent_long_link = 0;
              recent_long_link_blocks = 0;
            }
              recent_long_link = 0;
              recent_long_link_blocks = 0;
            }

-         assign_string (&current_stat_info.link_name, name);
+         assign_string (&info->link_name, name);

 
          return HEADER_SUCCESS;
        }
 
          return HEADER_SUCCESS;
        }


@@ -520,9 +574,8 @@ decode_header (union block *header, struct tar_stat_info *stat_info,
               enum archive_format *format_pointer, int do_user_group)
 {
   enum archive_format format;
               enum archive_format *format_pointer, int do_user_group)
 {
   enum archive_format format;

-  struct timespec atime;
-  struct timespec ctime;
-  struct timespec mtime;
+  bool hbits;
+  mode_t mode = MODE_FROM_HEADER (header->header.mode, &hbits);

 
   if (strcmp (header->header.magic, TMAGIC) == 0)
     {
 
   if (strcmp (header->header.magic, TMAGIC) == 0)
     {


@@ -532,43 +585,43 @@ decode_header (union block *header, struct tar_stat_info *stat_info,
          && ISOCTAL (header->star_header.ctime[0])
          && header->star_header.ctime[11] == ' ')
        format = STAR_FORMAT;
          && ISOCTAL (header->star_header.ctime[0])
          && header->star_header.ctime[11] == ' ')
        format = STAR_FORMAT;

-      else if (extended_header.size)
+      else if (stat_info->xhdr.size)

        format = POSIX_FORMAT;
       else
        format = USTAR_FORMAT;
     }
        format = POSIX_FORMAT;
       else
        format = USTAR_FORMAT;
     }

-  else if (strcmp (header->header.magic, OLDGNU_MAGIC) == 0)
-    format = OLDGNU_FORMAT;
+  else if (strcmp (header->buffer + offsetof (struct posix_header, magic),
+                  OLDGNU_MAGIC)
+          == 0)
+    format = hbits ? OLDGNU_FORMAT : GNU_FORMAT;

   else
     format = V7_FORMAT;
   *format_pointer = format;
 
   else
     format = V7_FORMAT;
   *format_pointer = format;
 

-  stat_info->stat.st_mode = MODE_FROM_HEADER (header->header.mode);
-  mtime.tv_sec = TIME_FROM_HEADER (header->header.mtime);
-  mtime.tv_nsec = 0;
-  set_stat_mtime (&stat_info->stat, mtime);
+  stat_info->stat.st_mode = mode;
+  stat_info->mtime.tv_sec = TIME_FROM_HEADER (header->header.mtime);
+  stat_info->mtime.tv_nsec = 0;

   assign_string (&stat_info->uname,
                 header->header.uname[0] ? header->header.uname : NULL);
   assign_string (&stat_info->gname,
                 header->header.gname[0] ? header->header.gname : NULL);
 
   assign_string (&stat_info->uname,
                 header->header.uname[0] ? header->header.uname : NULL);
   assign_string (&stat_info->gname,
                 header->header.gname[0] ? header->header.gname : NULL);
 

+  xheader_xattr_init (stat_info);
+

   if (format == OLDGNU_FORMAT && incremental_option)
     {
   if (format == OLDGNU_FORMAT && incremental_option)
     {

-      atime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.atime);
-      ctime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.ctime);
-      atime.tv_nsec = ctime.tv_nsec = 0;
+      stat_info->atime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.atime);
+      stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.ctime);
+      stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;

     }
   else if (format == STAR_FORMAT)
     {
     }
   else if (format == STAR_FORMAT)
     {

-      atime.tv_sec = TIME_FROM_HEADER (header->star_header.atime);
-      ctime.tv_sec = TIME_FROM_HEADER (header->star_header.ctime);
-      atime.tv_nsec = ctime.tv_nsec = 0;
+      stat_info->atime.tv_sec = TIME_FROM_HEADER (header->star_header.atime);
+      stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->star_header.ctime);
+      stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;

     }
   else
     }
   else

-    atime = ctime = start_time;
-
-  set_stat_atime (&stat_info->stat, atime);
-  set_stat_ctime (&stat_info->stat, ctime);
+    stat_info->atime = stat_info->ctime = start_time;

 
   if (format == V7_FORMAT)
     {
 
   if (format == V7_FORMAT)
     {


@@ -616,24 +669,42 @@ decode_header (union block *header, struct tar_stat_info *stat_info,
       stat_info->is_sparse = true;
     }
   else
       stat_info->is_sparse = true;
     }
   else

-    stat_info->is_sparse = false;
+    {
+      stat_info->is_sparse = false;
+      if (((current_format == GNU_FORMAT
+           || current_format == OLDGNU_FORMAT)
+          && current_header->header.typeflag == GNUTYPE_DUMPDIR)
+          || stat_info->dumpdir)
+       stat_info->is_dumpdir = true;
+    }

 }
 
 }
 

+

 /* Convert buffer at WHERE0 of size DIGS from external format to
 /* Convert buffer at WHERE0 of size DIGS from external format to

-   uintmax_t.  DIGS must be positive.  If TYPE is nonnull, the data
-   are of type TYPE.  The buffer must represent a value in the range
-   -MINUS_MINVAL through MAXVAL.  If OCTAL_ONLY, allow only octal
+   intmax_t.  DIGS must be positive.  If TYPE is nonnull, the data are
+   of type TYPE.  The buffer must represent a value in the range
+   MINVAL through MAXVAL; if the mathematically correct result V would
+   be greater than INTMAX_MAX, return a negative integer V such that
+   (uintmax_t) V yields the correct result.  If OCTAL_ONLY, allow only octal

    numbers instead of the other GNU extensions.  Return -1 on error,
    diagnosing the error if TYPE is nonnull and if !SILENT.  */
    numbers instead of the other GNU extensions.  Return -1 on error,
    diagnosing the error if TYPE is nonnull and if !SILENT.  */

-static uintmax_t
+#if ! (INTMAX_MAX <= UINTMAX_MAX && - (INTMAX_MIN + 1) <= UINTMAX_MAX)
+# error "from_header internally represents intmax_t as uintmax_t + sign"
+#endif
+#if ! (UINTMAX_MAX / 2 <= INTMAX_MAX)
+# error "from_header returns intmax_t to represent uintmax_t"
+#endif
+static intmax_t

 from_header (char const *where0, size_t digs, char const *type,
 from_header (char const *where0, size_t digs, char const *type,

-            uintmax_t minus_minval, uintmax_t maxval,
+            intmax_t minval, uintmax_t maxval,

             bool octal_only, bool silent)
 {
   uintmax_t value;
             bool octal_only, bool silent)
 {
   uintmax_t value;

+  uintmax_t uminval = minval;
+  uintmax_t minus_minval = - uminval;

   char const *where = where0;
   char const *lim = where + digs;
   char const *where = where0;
   char const *lim = where + digs;

-  int negative = 0;
+  bool negative = false;

 
   /* Accommodate buggy tar of unknown vintage, which outputs leading
      NUL if the previous field overflows.  */
 
   /* Accommodate buggy tar of unknown vintage, which outputs leading
      NUL if the previous field overflows.  */


@@ -646,7 +717,8 @@ from_header (char const *where0, size_t digs, char const *type,
        {
          if (type && !silent)
            ERROR ((0, 0,
        {
          if (type && !silent)
            ERROR ((0, 0,

-                   /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
+                   /* TRANSLATORS: %s is type of the value (gid_t, uid_t,
+                      etc.) */

                    _("Blanks in header where numeric %s value expected"),
                    type));
          return -1;
                    _("Blanks in header where numeric %s value expected"),
                    type));
          return -1;


@@ -660,14 +732,14 @@ from_header (char const *where0, size_t digs, char const *type,
   if (ISODIGIT (*where))
     {
       char const *where1 = where;
   if (ISODIGIT (*where))
     {
       char const *where1 = where;

-      uintmax_t overflow = 0;
+      bool overflow = false;

 
       for (;;)
        {
          value += *where++ - '0';
          if (where == lim || ! ISODIGIT (*where))
            break;
 
       for (;;)
        {
          value += *where++ - '0';
          if (where == lim || ! ISODIGIT (*where))
            break;

-         overflow |= value ^ (value << LG_8 >> LG_8);
+         overflow |= value != (value << LG_8 >> LG_8);

          value <<= LG_8;
        }
 
          value <<= LG_8;
        }
 


@@ -691,7 +763,7 @@ from_header (char const *where0, size_t digs, char const *type,
              if (where == lim || ! ISODIGIT (*where))
                break;
              digit = *where - '0';
              if (where == lim || ! ISODIGIT (*where))
                break;
              digit = *where - '0';

-             overflow |= value ^ (value << LG_8 >> LG_8);
+             overflow |= value != (value << LG_8 >> LG_8);

              value <<= LG_8;
            }
          value++;
              value <<= LG_8;
            }
          value++;


@@ -704,7 +776,7 @@ from_header (char const *where0, size_t digs, char const *type,
                       /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
                       _("Archive octal value %.*s is out of %s range; assuming two's complement"),
                       (int) (where - where1), where1, type));
                       /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
                       _("Archive octal value %.*s is out of %s range; assuming two's complement"),
                       (int) (where - where1), where1, type));

-             negative = 1;
+             negative = true;

            }
        }
 
            }
        }
 


@@ -784,7 +856,7 @@ from_header (char const *where0, size_t digs, char const *type,
              return -1;
            }
        }
              return -1;
            }
        }

-      negative = signbit;
+      negative = signbit != 0;

       if (negative)
        value = -value;
     }
       if (negative)
        value = -value;
     }


@@ -804,7 +876,7 @@ from_header (char const *where0, size_t digs, char const *type,
 
          while (where0 != lim && ! lim[-1])
            lim--;
 
          while (where0 != lim && ! lim[-1])
            lim--;

-         quotearg_buffer (buf, sizeof buf, where0, lim - where, o);
+         quotearg_buffer (buf, sizeof buf, where0, lim - where0, o);

          if (!silent)
            ERROR ((0, 0,
                    /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
          if (!silent)
            ERROR ((0, 0,
                    /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */


@@ -816,7 +888,7 @@ from_header (char const *where0, size_t digs, char const *type,
     }
 
   if (value <= (negative ? minus_minval : maxval))
     }
 
   if (value <= (negative ? minus_minval : maxval))

-    return negative ? -value : value;
+    return represent_uintmax (negative ? -value : value);

 
   if (type && !silent)
     {
 
   if (type && !silent)
     {


@@ -838,50 +910,52 @@ from_header (char const *where0, size_t digs, char const *type,
   return -1;
 }
 
   return -1;
 }
 

-gid_t
+static gid_t

 gid_from_header (const char *p, size_t s)
 {
   return from_header (p, s, "gid_t",
 gid_from_header (const char *p, size_t s)
 {
   return from_header (p, s, "gid_t",

-                     - (uintmax_t) TYPE_MINIMUM (gid_t),
-                     (uintmax_t) TYPE_MAXIMUM (gid_t),
+                     TYPE_MINIMUM (gid_t), TYPE_MAXIMUM (gid_t),

                      false, false);
 }
 
                      false, false);
 }
 

-major_t
+static major_t

 major_from_header (const char *p, size_t s)
 {
   return from_header (p, s, "major_t",
 major_from_header (const char *p, size_t s)
 {
   return from_header (p, s, "major_t",

-                     - (uintmax_t) TYPE_MINIMUM (major_t),
-                     (uintmax_t) TYPE_MAXIMUM (major_t), false, false);
+                     TYPE_MINIMUM (major_t), TYPE_MAXIMUM (major_t),
+                     false, false);

 }
 
 }
 

-minor_t
+static minor_t

 minor_from_header (const char *p, size_t s)
 {
   return from_header (p, s, "minor_t",
 minor_from_header (const char *p, size_t s)
 {
   return from_header (p, s, "minor_t",

-                     - (uintmax_t) TYPE_MINIMUM (minor_t),
-                     (uintmax_t) TYPE_MAXIMUM (minor_t), false, false);
+                     TYPE_MINIMUM (minor_t), TYPE_MAXIMUM (minor_t),
+                     false, false);

 }
 
 }
 

-mode_t
-mode_from_header (const char *p, size_t s)
+/* Convert P to the file mode, as understood by tar.
+   Set *HBITS if there are any unrecognized bits.  */
+static mode_t
+mode_from_header (const char *p, size_t s, bool *hbits)

 {
 {

-  /* Do not complain about unrecognized mode bits.  */
-  unsigned u = from_header (p, s, "mode_t",
-                           - (uintmax_t) TYPE_MINIMUM (mode_t),
-                           TYPE_MAXIMUM (uintmax_t), false, false);
-  return ((u & TSUID ? S_ISUID : 0)
-         | (u & TSGID ? S_ISGID : 0)
-         | (u & TSVTX ? S_ISVTX : 0)
-         | (u & TUREAD ? S_IRUSR : 0)
-         | (u & TUWRITE ? S_IWUSR : 0)
-         | (u & TUEXEC ? S_IXUSR : 0)
-         | (u & TGREAD ? S_IRGRP : 0)
-         | (u & TGWRITE ? S_IWGRP : 0)
-         | (u & TGEXEC ? S_IXGRP : 0)
-         | (u & TOREAD ? S_IROTH : 0)
-         | (u & TOWRITE ? S_IWOTH : 0)
-         | (u & TOEXEC ? S_IXOTH : 0));
+  intmax_t u = from_header (p, s, "mode_t",
+                           INTMAX_MIN, UINTMAX_MAX,
+                           false, false);
+  mode_t mode = ((u & TSUID ? S_ISUID : 0)
+                | (u & TSGID ? S_ISGID : 0)
+                | (u & TSVTX ? S_ISVTX : 0)
+                | (u & TUREAD ? S_IRUSR : 0)
+                | (u & TUWRITE ? S_IWUSR : 0)
+                | (u & TUEXEC ? S_IXUSR : 0)
+                | (u & TGREAD ? S_IRGRP : 0)
+                | (u & TGWRITE ? S_IWGRP : 0)
+                | (u & TGEXEC ? S_IXGRP : 0)
+                | (u & TOREAD ? S_IROTH : 0)
+                | (u & TOWRITE ? S_IWOTH : 0)
+                | (u & TOEXEC ? S_IXOTH : 0));
+  *hbits = (u & ~07777) != 0;
+  return mode;

 }
 
 off_t
 }
 
 off_t


@@ -889,38 +963,31 @@ off_from_header (const char *p, size_t s)
 {
   /* Negative offsets are not allowed in tar files, so invoke
      from_header with minimum value 0, not TYPE_MINIMUM (off_t).  */
 {
   /* Negative offsets are not allowed in tar files, so invoke
      from_header with minimum value 0, not TYPE_MINIMUM (off_t).  */

-  return from_header (p, s, "off_t", (uintmax_t) 0,
-                     (uintmax_t) TYPE_MAXIMUM (off_t), false, false);
-}
-
-size_t
-size_from_header (const char *p, size_t s)
-{
-  return from_header (p, s, "size_t", (uintmax_t) 0,
-                     (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
+  return from_header (p, s, "off_t",
+                     0, TYPE_MAXIMUM (off_t),
+                     false, false);

 }
 
 }
 

-time_t
+static time_t

 time_from_header (const char *p, size_t s)
 {
   return from_header (p, s, "time_t",
 time_from_header (const char *p, size_t s)
 {
   return from_header (p, s, "time_t",

-                     - (uintmax_t) TYPE_MINIMUM (time_t),
-                     (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
+                     TYPE_MINIMUM (time_t), TYPE_MAXIMUM (time_t),
+                     false, false);

 }
 
 }
 

-uid_t
+static uid_t

 uid_from_header (const char *p, size_t s)
 {
   return from_header (p, s, "uid_t",
 uid_from_header (const char *p, size_t s)
 {
   return from_header (p, s, "uid_t",

-                     - (uintmax_t) TYPE_MINIMUM (uid_t),
-                     (uintmax_t) TYPE_MAXIMUM (uid_t), false, false);
+                     TYPE_MINIMUM (uid_t), TYPE_MAXIMUM (uid_t),
+                     false, false);

 }
 
 uintmax_t
 uintmax_from_header (const char *p, size_t s)
 {
 }
 
 uintmax_t
 uintmax_from_header (const char *p, size_t s)
 {

-  return from_header (p, s, "uintmax_t", (uintmax_t) 0,
-                     TYPE_MAXIMUM (uintmax_t), false, false);
+  return from_header (p, s, "uintmax_t", 0, UINTMAX_MAX, false, false);

 }
 
 
 }
 
 


@@ -992,9 +1059,6 @@ tartime (struct timespec t, bool full_time)
    they shouldn't.  Unix tar is pretty random here anyway.  */
 
 
    they shouldn't.  Unix tar is pretty random here anyway.  */
 
 

-/* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
-   HEAD_STANDARD, which must be set up in advance.  Not very clean..  */
-

 /* Width of "user/group size", with initial value chosen
    heuristically.  This grows as needed, though this may cause some
    stairstepping in the output.  Make it too small and the output will
 /* Width of "user/group size", with initial value chosen
    heuristically.  This grows as needed, though this may cause some
    stairstepping in the output.  Make it too small and the output will


@@ -1007,16 +1071,20 @@ static int ugswidth = 19;
    USGWIDTH, some stairstepping may occur.  */
 static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1;
 
    USGWIDTH, some stairstepping may occur.  */
 static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1;
 

-void
-print_header (struct tar_stat_info *st, off_t block_ordinal)
+static bool volume_label_printed = false;
+
+static void
+simple_print_header (struct tar_stat_info *st, union block *blk,
+                    off_t block_ordinal)

 {
 {

-  char modes[11];
+  char modes[12];

   char const *time_stamp;
   int time_stamp_len;
   char const *time_stamp;
   int time_stamp_len;

-  char *temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
+  char *temp_name;

 
   /* These hold formatted ints.  */
 
   /* These hold formatted ints.  */

-  char uform[UINTMAX_STRSIZE_BOUND], gform[UINTMAX_STRSIZE_BOUND];
+  char uform[max (INT_BUFSIZE_BOUND (intmax_t), UINTMAX_STRSIZE_BOUND)];
+  char gform[sizeof uform];

   char *user, *group;
   char size[2 * UINTMAX_STRSIZE_BOUND];
                                /* holds formatted size or major,minor */
   char *user, *group;
   char size[2 * UINTMAX_STRSIZE_BOUND];
                                /* holds formatted size or major,minor */


@@ -1024,6 +1092,11 @@ print_header (struct tar_stat_info *st, off_t block_ordinal)
   int pad;
   int sizelen;
 
   int pad;
   int sizelen;
 

+  if (show_transformed_names_option)
+    temp_name = st->file_name ? st->file_name : st->orig_file_name;
+  else
+    temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
+

   if (block_number_option)
     {
       char buf[UINTMAX_STRSIZE_BOUND];
   if (block_number_option)
     {
       char buf[UINTMAX_STRSIZE_BOUND];


@@ -1045,9 +1118,10 @@ print_header (struct tar_stat_info *st, off_t block_ordinal)
       /* File type and modes.  */
 
       modes[0] = '?';
       /* File type and modes.  */
 
       modes[0] = '?';

-      switch (current_header->header.typeflag)
+      switch (blk->header.typeflag)

        {
        case GNUTYPE_VOLHDR:
        {
        case GNUTYPE_VOLHDR:

+         volume_label_printed = true;

          modes[0] = 'V';
          break;
 
          modes[0] = 'V';
          break;
 


@@ -1055,10 +1129,6 @@ print_header (struct tar_stat_info *st, off_t block_ordinal)
          modes[0] = 'M';
          break;
 
          modes[0] = 'M';
          break;
 

-       case GNUTYPE_NAMES:
-         modes[0] = 'N';
-         break;
-

        case GNUTYPE_LONGNAME:
        case GNUTYPE_LONGLINK:
          modes[0] = 'L';
        case GNUTYPE_LONGNAME:
        case GNUTYPE_LONGLINK:
          modes[0] = 'L';


@@ -1100,9 +1170,12 @@ print_header (struct tar_stat_info *st, off_t block_ordinal)
 
       pax_decode_mode (st->stat.st_mode, modes + 1);
 
 
       pax_decode_mode (st->stat.st_mode, modes + 1);
 

+      /* extended attributes:  GNU `ls -l'-like preview */
+      xattrs_print_char (st, modes + 10);
+

       /* Time stamp.  */
 
       /* Time stamp.  */
 

-      time_stamp = tartime (get_stat_mtime (&st->stat), false);
+      time_stamp = tartime (st->mtime, full_time_option);

       time_stamp_len = strlen (time_stamp);
       if (datewidth < time_stamp_len)
        datewidth = time_stamp_len;
       time_stamp_len = strlen (time_stamp);
       if (datewidth < time_stamp_len)
        datewidth = time_stamp_len;


@@ -1119,19 +1192,13 @@ print_header (struct tar_stat_info *st, off_t block_ordinal)
          /* Try parsing it as an unsigned integer first, and as a
             uid_t if that fails.  This method can list positive user
             ids that are too large to fit in a uid_t.  */
          /* Try parsing it as an unsigned integer first, and as a
             uid_t if that fails.  This method can list positive user
             ids that are too large to fit in a uid_t.  */

-         uintmax_t u = from_header (current_header->header.uid,
-                                    sizeof current_header->header.uid, 0,
-                                    (uintmax_t) 0,
-                                    (uintmax_t) TYPE_MAXIMUM (uintmax_t),
+         uintmax_t u = from_header (blk->header.uid,
+                                    sizeof blk->header.uid, 0,
+                                    0, UINTMAX_MAX,

                                     false, false);
                                     false, false);

-         if (u != -1)
-           user = STRINGIFY_BIGINT (u, uform);
-         else
-           {
-             sprintf (uform, "%ld",
-                      (long) UID_FROM_HEADER (current_header->header.uid));
-             user = uform;
-           }
+         user = (u != -1
+                 ? STRINGIFY_BIGINT (u, uform)
+                 : imaxtostr (UID_FROM_HEADER (blk->header.uid), uform));

        }
 
       if (st->gname
        }
 
       if (st->gname


@@ -1144,24 +1211,18 @@ print_header (struct tar_stat_info *st, off_t block_ordinal)
          /* Try parsing it as an unsigned integer first, and as a
             gid_t if that fails.  This method can list positive group
             ids that are too large to fit in a gid_t.  */
          /* Try parsing it as an unsigned integer first, and as a
             gid_t if that fails.  This method can list positive group
             ids that are too large to fit in a gid_t.  */

-         uintmax_t g = from_header (current_header->header.gid,
-                                    sizeof current_header->header.gid, 0,
-                                    (uintmax_t) 0,
-                                    (uintmax_t) TYPE_MAXIMUM (uintmax_t),
+         uintmax_t g = from_header (blk->header.gid,
+                                    sizeof blk->header.gid, 0,
+                                    0, UINTMAX_MAX,

                                     false, false);
                                     false, false);

-         if (g != -1)
-           group = STRINGIFY_BIGINT (g, gform);
-         else
-           {
-             sprintf (gform, "%ld",
-                      (long) GID_FROM_HEADER (current_header->header.gid));
-             group = gform;
-           }
+         group = (g != -1
+                  ? STRINGIFY_BIGINT (g, gform)
+                  : imaxtostr (GID_FROM_HEADER (blk->header.gid), gform));

        }
 
       /* Format the file size or major/minor device numbers.  */
 
        }
 
       /* Format the file size or major/minor device numbers.  */
 

-      switch (current_header->header.typeflag)
+      switch (blk->header.typeflag)

        {
        case CHRTYPE:
        case BLKTYPE:
        {
        case CHRTYPE:
        case BLKTYPE:


@@ -1191,7 +1252,7 @@ print_header (struct tar_stat_info *st, off_t block_ordinal)
 
       fprintf (stdlis, " %s", quotearg (temp_name));
 
 
       fprintf (stdlis, " %s", quotearg (temp_name));
 

-      switch (current_header->header.typeflag)
+      switch (blk->header.typeflag)

        {
        case SYMTYPE:
          fprintf (stdlis, " -> %s\n", quotearg (st->link_name));
        {
        case SYMTYPE:
          fprintf (stdlis, " -> %s\n", quotearg (st->link_name));


@@ -1204,7 +1265,7 @@ print_header (struct tar_stat_info *st, off_t block_ordinal)
        default:
          {
            char type_string[2];
        default:
          {
            char type_string[2];

-           type_string[0] = current_header->header.typeflag;
+           type_string[0] = blk->header.typeflag;

            type_string[1] = '\0';
            fprintf (stdlis, _(" unknown file type %s\n"),
                     quote (type_string));
            type_string[1] = '\0';
            fprintf (stdlis, _(" unknown file type %s\n"),
                     quote (type_string));


@@ -1238,17 +1299,48 @@ print_header (struct tar_stat_info *st, off_t block_ordinal)
        case GNUTYPE_MULTIVOL:
          strcpy (size,
                  STRINGIFY_BIGINT
        case GNUTYPE_MULTIVOL:
          strcpy (size,
                  STRINGIFY_BIGINT

-                 (UINTMAX_FROM_HEADER (current_header->oldgnu_header.offset),
+                 (UINTMAX_FROM_HEADER (blk->oldgnu_header.offset),

                   uintbuf));
          fprintf (stdlis, _("--Continued at byte %s--\n"), size);
          break;
                   uintbuf));
          fprintf (stdlis, _("--Continued at byte %s--\n"), size);
          break;

-
-       case GNUTYPE_NAMES:
-         fprintf (stdlis, _("--Mangled file names--\n"));
-         break;

        }
     }
   fflush (stdlis);
        }
     }
   fflush (stdlis);

+  xattrs_print (st);
+}
+
+
+static void
+print_volume_label (void)
+{
+  struct tar_stat_info vstat;
+  union block vblk;
+  enum archive_format dummy;
+
+  memset (&vblk, 0, sizeof (vblk));
+  vblk.header.typeflag = GNUTYPE_VOLHDR;
+  if (recent_global_header)
+    memcpy (vblk.header.mtime, recent_global_header->header.mtime,
+           sizeof vblk.header.mtime);
+  tar_stat_init (&vstat);
+  assign_string (&vstat.file_name, ".");
+  decode_header (&vblk, &vstat, &dummy, 0);
+  assign_string (&vstat.file_name, volume_label);
+  simple_print_header (&vstat, &vblk, 0);
+  tar_stat_destroy (&vstat);
+}
+
+void
+print_header (struct tar_stat_info *st, union block *blk,
+             off_t block_ordinal)
+{
+  if (current_format == POSIX_FORMAT && !volume_label_printed && volume_label)
+    {
+      print_volume_label ();
+      volume_label_printed = true;
+    }
+
+  simple_print_header (st, blk, block_ordinal);

 }
 
 /* Print a similar line when we make a directory automatically.  */
 }
 
 /* Print a similar line when we make a directory automatically.  */


@@ -1271,8 +1363,8 @@ print_for_mkdir (char *dirname, int length, mode_t mode)
                   STRINGIFY_BIGINT (current_block_ordinal (), buf));
        }
 
                   STRINGIFY_BIGINT (current_block_ordinal (), buf));
        }
 

-      fprintf (stdlis, "%s %*s %.*s\n", modes, ugswidth + 1 + datewidth,
-              _("Creating directory:"), length, quotearg (dirname));
+      fprintf (stdlis, "%s %*s %s\n", modes, ugswidth + 1 + datewidth,
+              _("Creating directory:"), quotearg (dirname));

     }
 }
 
     }
 }
 


@@ -1282,25 +1374,19 @@ skip_file (off_t size)
 {
   union block *x;
 
 {
   union block *x;
 

-  if (multi_volume_option)
-    {
-      save_totsize = size;
-      save_sizeleft = size;
-    }
+  /* FIXME: Make sure mv_begin_read is always called before it */

 
   if (seekable_archive)
     {
       off_t nblk = seek_archive (size);
       if (nblk >= 0)
 
   if (seekable_archive)
     {
       off_t nblk = seek_archive (size);
       if (nblk >= 0)

-       {
-         size -= nblk * BLOCKSIZE;
-         if (multi_volume_option) /* Argh.. */
-           save_sizeleft -= nblk * BLOCKSIZE;
-       }
+       size -= nblk * BLOCKSIZE;

       else
        seekable_archive = false;
     }
 
       else
        seekable_archive = false;
     }
 

+  mv_size_left (size);
+

   while (size > 0)
     {
       x = find_next_block ();
   while (size > 0)
     {
       x = find_next_block ();


@@ -1309,8 +1395,7 @@ skip_file (off_t size)
 
       set_next_block_after (x);
       size -= BLOCKSIZE;
 
       set_next_block_after (x);
       size -= BLOCKSIZE;

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

     }
 }
 
     }
 }
 


@@ -1319,13 +1404,49 @@ skip_file (off_t size)
 void
 skip_member (void)
 {
 void
 skip_member (void)
 {

-  char save_typeflag = current_header->header.typeflag;
-  set_next_block_after (current_header);
+  if (!current_stat_info.skipped)
+    {
+      char save_typeflag = current_header->header.typeflag;
+      set_next_block_after (current_header);
+
+      mv_begin_read (&current_stat_info);
+
+      if (current_stat_info.is_sparse)
+       sparse_skip_file (&current_stat_info);
+      else if (save_typeflag != DIRTYPE)
+       skip_file (current_stat_info.stat.st_size);
+
+      mv_end ();
+    }
+}
+
+void
+test_archive_label (void)
+{
+  base64_init ();
+  name_gather ();

 
 

-  assign_string (&save_name, current_stat_info.orig_file_name);
+  open_archive (ACCESS_READ);
+  if (read_header (&current_header, &current_stat_info, read_header_auto)
+      == HEADER_SUCCESS)
+    {
+      decode_header (current_header,
+                    &current_stat_info, &current_format, 0);
+      if (current_header->header.typeflag == GNUTYPE_VOLHDR)
+       assign_string (&volume_label, current_header->header.name);

 
 

-  if (current_stat_info.is_sparse)
-    sparse_skip_file (&current_stat_info);
-  else if (save_typeflag != DIRTYPE)
-    skip_file (current_stat_info.stat.st_size);
+      if (volume_label)
+       {
+         if (verbose_option)
+           print_volume_label ();
+         if (!name_match (volume_label) && multi_volume_option)
+           {
+             char *s = drop_volume_label_suffix (volume_label);
+             name_match (s);
+             free (s);
+           }
+       }
+    }
+  close_archive ();
+  label_notfound ();

 }
 }