git.cworth.org Git - tar/blob - src/list.c

   1 /* List a tar archive, with support routines for reading a tar archive.
   2
   3    Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,
   4    2001, 2003, 2004, 2005, 2006, 2007, 2010 Free Software Foundation, Inc.
   5
   6    Written by John Gilmore, on 1985-08-26.
   7
   8    This program is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by the
  10    Free Software Foundation; either version 3, or (at your option) any later
  11    version.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
  16    Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License along
  19    with this program; if not, write to the Free Software Foundation, Inc.,
  20    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  21
  22 #include <system.h>
  23 #include <inttostr.h>
  24 #include <quotearg.h>
  25
  26 #include "common.h"
  27
  28 #define max(a, b) ((a) < (b) ? (b) : (a))
  29
  30 union block *current_header;    /* points to current archive header */
  31 enum archive_format current_format; /* recognized format */
  32 union block *recent_long_name;  /* recent long name header and contents */
  33 union block *recent_long_link;  /* likewise, for long link */
  34 size_t recent_long_name_blocks; /* number of blocks in recent_long_name */
  35 size_t recent_long_link_blocks; /* likewise, for long link */
  36 union block *recent_global_header; /* Recent global header block */
  37
  38 #define GID_FROM_HEADER(where) gid_from_header (where, sizeof (where))
  39 #define MAJOR_FROM_HEADER(where) major_from_header (where, sizeof (where))
  40 #define MINOR_FROM_HEADER(where) minor_from_header (where, sizeof (where))
  41 #define MODE_FROM_HEADER(where, hbits) \
  42   mode_from_header (where, sizeof (where), hbits)
  43 #define TIME_FROM_HEADER(where) time_from_header (where, sizeof (where))
  44 #define UID_FROM_HEADER(where) uid_from_header (where, sizeof (where))
  45
  46 static gid_t gid_from_header (const char *buf, size_t size);
  47 static major_t major_from_header (const char *buf, size_t size);
  48 static minor_t minor_from_header (const char *buf, size_t size);
  49 static mode_t mode_from_header (const char *buf, size_t size, unsigned *hbits);
  50 static time_t time_from_header (const char *buf, size_t size);
  51 static uid_t uid_from_header (const char *buf, size_t size);
  52 static uintmax_t from_header (const char *, size_t, const char *,
  53                               uintmax_t, uintmax_t, bool, bool);
  54
  55 /* Base 64 digits; see Internet RFC 2045 Table 1.  */
  56 static char const base_64_digits[64] =
  57 {
  58   'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
  59   'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
  60   'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
  61   'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
  62   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
  63 };
  64
  65 /* Table of base-64 digit values indexed by unsigned chars.
  66    The value is 64 for unsigned chars that are not base-64 digits.  */
  67 static char base64_map[UCHAR_MAX + 1];
  68
  69 static void
  70 base64_init (void)
  71 {
  72   int i;
  73   memset (base64_map, 64, sizeof base64_map);
  74   for (i = 0; i < 64; i++)
  75     base64_map[(int) base_64_digits[i]] = i;
  76 }
  77
  78 /* Main loop for reading an archive.  */
  79 void
  80 read_and (void (*do_something) (void))
  81 {
  82   enum read_header status = HEADER_STILL_UNREAD;
  83   enum read_header prev_status;
  84   struct timespec mtime;
  85
  86   base64_init ();
  87   name_gather ();
  88
  89   open_archive (ACCESS_READ);
  90   do
  91     {
  92       prev_status = status;
  93       tar_stat_destroy (&current_stat_info);
  94
  95       status = read_header (&current_header, &current_stat_info,
  96                             read_header_auto);
  97       switch (status)
  98         {
  99         case HEADER_STILL_UNREAD:
 100         case HEADER_SUCCESS_EXTENDED:
 101           abort ();
 102
 103         case HEADER_SUCCESS:
 104
 105           /* Valid header.  We should decode next field (mode) first.
 106              Ensure incoming names are null terminated.  */
 107           decode_header (current_header, &current_stat_info,
 108                          &current_format, 1);
 109           if (! name_match (current_stat_info.file_name)
 110               || (NEWER_OPTION_INITIALIZED (newer_mtime_option)
 111                   /* FIXME: We get mtime now, and again later; this causes
 112                      duplicate diagnostics if header.mtime is bogus.  */
 113                   && ((mtime.tv_sec
 114                        = TIME_FROM_HEADER (current_header->header.mtime)),
 115                       /* FIXME: Grab fractional time stamps from
 116                          extended header.  */
 117                       mtime.tv_nsec = 0,
 118                       current_stat_info.mtime = mtime,
 119                       OLDER_TAR_STAT_TIME (current_stat_info, m)))
 120               || excluded_name (current_stat_info.file_name))
 121             {
 122               switch (current_header->header.typeflag)
 123                 {
 124                 case GNUTYPE_VOLHDR:
 125                 case GNUTYPE_MULTIVOL:
 126                   break;
 127
 128                 case DIRTYPE:
 129                   if (show_omitted_dirs_option)
 130                     WARN ((0, 0, _("%s: Omitting"),
 131                            quotearg_colon (current_stat_info.file_name)));
 132                   /* Fall through.  */
 133                 default:
 134                   skip_member ();
 135                   continue;
 136                 }
 137             }
 138
 139           (*do_something) ();
 140           continue;
 141
 142         case HEADER_ZERO_BLOCK:
 143           if (block_number_option)
 144             {
 145               char buf[UINTMAX_STRSIZE_BOUND];
 146               fprintf (stdlis, _("block %s: ** Block of NULs **\n"),
 147                        STRINGIFY_BIGINT (current_block_ordinal (), buf));
 148             }
 149
 150           set_next_block_after (current_header);
 151
 152           if (!ignore_zeros_option)
 153             {
 154               char buf[UINTMAX_STRSIZE_BOUND];
 155
 156               status = read_header (&current_header, &current_stat_info,
 157                                     read_header_auto);
 158               if (status == HEADER_ZERO_BLOCK)
 159                 break;
 160               WARNOPT (WARN_ALONE_ZERO_BLOCK,
 161                        (0, 0, _("A lone zero block at %s"),
 162                         STRINGIFY_BIGINT (current_block_ordinal (), buf)));
 163               break;
 164             }
 165           status = prev_status;
 166           continue;
 167
 168         case HEADER_END_OF_FILE:
 169           if (block_number_option)
 170             {
 171               char buf[UINTMAX_STRSIZE_BOUND];
 172               fprintf (stdlis, _("block %s: ** End of File **\n"),
 173                        STRINGIFY_BIGINT (current_block_ordinal (), buf));
 174             }
 175           break;
 176
 177         case HEADER_FAILURE:
 178           /* If the previous header was good, tell them that we are
 179              skipping bad ones.  */
 180           set_next_block_after (current_header);
 181           switch (prev_status)
 182             {
 183             case HEADER_STILL_UNREAD:
 184               ERROR ((0, 0, _("This does not look like a tar archive")));
 185               /* Fall through.  */
 186
 187             case HEADER_ZERO_BLOCK:
 188             case HEADER_SUCCESS:
 189               if (block_number_option)
 190                 {
 191                   char buf[UINTMAX_STRSIZE_BOUND];
 192                   off_t block_ordinal = current_block_ordinal ();
 193                   block_ordinal -= recent_long_name_blocks;
 194                   block_ordinal -= recent_long_link_blocks;
 195                   fprintf (stdlis, _("block %s: "),
 196                            STRINGIFY_BIGINT (block_ordinal, buf));
 197                 }
 198               ERROR ((0, 0, _("Skipping to next header")));
 199               break;
 200
 201             case HEADER_END_OF_FILE:
 202             case HEADER_FAILURE:
 203               /* We are in the middle of a cascade of errors.  */
 204               break;
 205
 206             case HEADER_SUCCESS_EXTENDED:
 207               abort ();
 208             }
 209           continue;
 210         }
 211       break;
 212     }
 213   while (!all_names_found (&current_stat_info));
 214
 215   close_archive ();
 216   names_notfound ();            /* print names not found */
 217 }
 218
 219 /* Print a header block, based on tar options.  */
 220 void
 221 list_archive (void)
 222 {
 223   off_t block_ordinal = current_block_ordinal ();
 224
 225   /* Print the header block.  */
 226   if (verbose_option)
 227     print_header (&current_stat_info, current_header, block_ordinal);
 228
 229   if (incremental_option)
 230     {
 231       if (verbose_option > 2)
 232         {
 233           if (is_dumpdir (&current_stat_info))
 234             list_dumpdir (current_stat_info.dumpdir,
 235                           dumpdir_size (current_stat_info.dumpdir));
 236         }
 237     }
 238
 239   skip_member ();
 240 }
 241
 242 /* Check header checksum */
 243 /* The standard BSD tar sources create the checksum by adding up the
 244    bytes in the header as type char.  I think the type char was unsigned
 245    on the PDP-11, but it's signed on the Next and Sun.  It looks like the
 246    sources to BSD tar were never changed to compute the checksum
 247    correctly, so both the Sun and Next add the bytes of the header as
 248    signed chars.  This doesn't cause a problem until you get a file with
 249    a name containing characters with the high bit set.  So tar_checksum
 250    computes two checksums -- signed and unsigned.  */
 251
 252 enum read_header
 253 tar_checksum (union block *header, bool silent)
 254 {
 255   size_t i;
 256   int unsigned_sum = 0;         /* the POSIX one :-) */
 257   int signed_sum = 0;           /* the Sun one :-( */
 258   int recorded_sum;
 259   uintmax_t parsed_sum;
 260   char *p;
 261
 262   p = header->buffer;
 263   for (i = sizeof *header; i-- != 0;)
 264     {
 265       unsigned_sum += (unsigned char) *p;
 266       signed_sum += (signed char) (*p++);
 267     }
 268
 269   if (unsigned_sum == 0)
 270     return HEADER_ZERO_BLOCK;
 271
 272   /* Adjust checksum to count the "chksum" field as blanks.  */
 273
 274   for (i = sizeof header->header.chksum; i-- != 0;)
 275     {
 276       unsigned_sum -= (unsigned char) header->header.chksum[i];
 277       signed_sum -= (signed char) (header->header.chksum[i]);
 278     }
 279   unsigned_sum += ' ' * sizeof header->header.chksum;
 280   signed_sum += ' ' * sizeof header->header.chksum;
 281
 282   parsed_sum = from_header (header->header.chksum,
 283                             sizeof header->header.chksum, 0,
 284                             (uintmax_t) 0,
 285                             (uintmax_t) TYPE_MAXIMUM (int), true, silent);
 286   if (parsed_sum == (uintmax_t) -1)
 287     return HEADER_FAILURE;
 288
 289   recorded_sum = parsed_sum;
 290
 291   if (unsigned_sum != recorded_sum && signed_sum != recorded_sum)
 292     return HEADER_FAILURE;
 293
 294   return HEADER_SUCCESS;
 295 }
 296
 297 /* Read a block that's supposed to be a header block.  Return its
 298    address in *RETURN_BLOCK, and if it is good, the file's size
 299    and names (file name, link name) in *INFO.
 300
 301    Return one of enum read_header describing the status of the
 302    operation.
 303
 304    The MODE parameter instructs read_header what to do with special
 305    header blocks, i.e.: extended POSIX, GNU long name or long link,
 306    etc.:
 307
 308      read_header_auto        process them automatically,
 309      read_header_x_raw       when a special header is read, return
 310                              HEADER_SUCCESS_EXTENDED without actually
 311                              processing the header,
 312      read_header_x_global    when a POSIX global header is read,
 313                              decode it and return HEADER_SUCCESS_EXTENDED.
 314
 315    You must always set_next_block_after(*return_block) to skip past
 316    the header which this routine reads.  */
 317
 318 enum read_header
 319 read_header (union block **return_block, struct tar_stat_info *info,
 320              enum read_header_mode mode)
 321 {
 322   union block *header;
 323   union block *header_copy;
 324   char *bp;
 325   union block *data_block;
 326   size_t size, written;
 327   union block *next_long_name = 0;
 328   union block *next_long_link = 0;
 329   size_t next_long_name_blocks = 0;
 330   size_t next_long_link_blocks = 0;
 331
 332   while (1)
 333     {
 334       enum read_header status;
 335
 336       header = find_next_block ();
 337       *return_block = header;
 338       if (!header)
 339         return HEADER_END_OF_FILE;
 340
 341       if ((status = tar_checksum (header, false)) != HEADER_SUCCESS)
 342         return status;
 343
 344       /* Good block.  Decode file size and return.  */
 345
 346       if (header->header.typeflag == LNKTYPE)
 347         info->stat.st_size = 0; /* links 0 size on tape */
 348       else
 349         info->stat.st_size = OFF_FROM_HEADER (header->header.size);
 350
 351       if (header->header.typeflag == GNUTYPE_LONGNAME
 352           || header->header.typeflag == GNUTYPE_LONGLINK
 353           || header->header.typeflag == XHDTYPE
 354           || header->header.typeflag == XGLTYPE
 355           || header->header.typeflag == SOLARIS_XHDTYPE)
 356         {
 357           if (mode == read_header_x_raw)
 358             return HEADER_SUCCESS_EXTENDED;
 359           else if (header->header.typeflag == GNUTYPE_LONGNAME
 360                    || header->header.typeflag == GNUTYPE_LONGLINK)
 361             {
 362               size_t name_size = info->stat.st_size;
 363               size_t n = name_size % BLOCKSIZE;
 364               size = name_size + BLOCKSIZE;
 365               if (n)
 366                 size += BLOCKSIZE - n;
 367
 368               if (name_size != info->stat.st_size || size < name_size)
 369                 xalloc_die ();
 370
 371               header_copy = xmalloc (size + 1);
 372
 373               if (header->header.typeflag == GNUTYPE_LONGNAME)
 374                 {
 375                   if (next_long_name)
 376                     free (next_long_name);
 377                   next_long_name = header_copy;
 378                   next_long_name_blocks = size / BLOCKSIZE;
 379                 }
 380               else
 381                 {
 382                   if (next_long_link)
 383                     free (next_long_link);
 384                   next_long_link = header_copy;
 385                   next_long_link_blocks = size / BLOCKSIZE;
 386                 }
 387
 388               set_next_block_after (header);
 389               *header_copy = *header;
 390               bp = header_copy->buffer + BLOCKSIZE;
 391
 392               for (size -= BLOCKSIZE; size > 0; size -= written)
 393                 {
 394                   data_block = find_next_block ();
 395                   if (! data_block)
 396                     {
 397                       ERROR ((0, 0, _("Unexpected EOF in archive")));
 398                       break;
 399                     }
 400                   written = available_space_after (data_block);
 401                   if (written > size)
 402                     written = size;
 403
 404                   memcpy (bp, data_block->buffer, written);
 405                   bp += written;
 406                   set_next_block_after ((union block *)
 407                                         (data_block->buffer + written - 1));
 408                 }
 409
 410               *bp = '\0';
 411             }
 412           else if (header->header.typeflag == XHDTYPE
 413                    || header->header.typeflag == SOLARIS_XHDTYPE)
 414             xheader_read (&info->xhdr, header,
 415                           OFF_FROM_HEADER (header->header.size));
 416           else if (header->header.typeflag == XGLTYPE)
 417             {
 418               struct xheader xhdr;
 419
 420               if (!recent_global_header)
 421                 recent_global_header = xmalloc (sizeof *recent_global_header);
 422               memcpy (recent_global_header, header,
 423                       sizeof *recent_global_header);
 424               memset (&xhdr, 0, sizeof xhdr);
 425               xheader_read (&xhdr, header,
 426                             OFF_FROM_HEADER (header->header.size));
 427               xheader_decode_global (&xhdr);
 428               xheader_destroy (&xhdr);
 429               if (mode == read_header_x_global)
 430                 return HEADER_SUCCESS_EXTENDED;
 431             }
 432
 433           /* Loop!  */
 434
 435         }
 436       else
 437         {
 438           char const *name;
 439           struct posix_header const *h = &header->header;
 440           char namebuf[sizeof h->prefix + 1 + NAME_FIELD_SIZE + 1];
 441
 442           if (recent_long_name)
 443             free (recent_long_name);
 444
 445           if (next_long_name)
 446             {
 447               name = next_long_name->buffer + BLOCKSIZE;
 448               recent_long_name = next_long_name;
 449               recent_long_name_blocks = next_long_name_blocks;
 450             }
 451           else
 452             {
 453               /* Accept file names as specified by POSIX.1-1996
 454                  section 10.1.1.  */
 455               char *np = namebuf;
 456
 457               if (h->prefix[0] && strcmp (h->magic, TMAGIC) == 0)
 458                 {
 459                   memcpy (np, h->prefix, sizeof h->prefix);
 460                   np[sizeof h->prefix] = '\0';
 461                   np += strlen (np);
 462                   *np++ = '/';
 463                 }
 464               memcpy (np, h->name, sizeof h->name);
 465               np[sizeof h->name] = '\0';
 466               name = namebuf;
 467               recent_long_name = 0;
 468               recent_long_name_blocks = 0;
 469             }
 470           assign_string (&info->orig_file_name, name);
 471           assign_string (&info->file_name, name);
 472           info->had_trailing_slash = strip_trailing_slashes (info->file_name);
 473
 474           if (recent_long_link)
 475             free (recent_long_link);
 476
 477           if (next_long_link)
 478             {
 479               name = next_long_link->buffer + BLOCKSIZE;
 480               recent_long_link = next_long_link;
 481               recent_long_link_blocks = next_long_link_blocks;
 482             }
 483           else
 484             {
 485               memcpy (namebuf, h->linkname, sizeof h->linkname);
 486               namebuf[sizeof h->linkname] = '\0';
 487               name = namebuf;
 488               recent_long_link = 0;
 489               recent_long_link_blocks = 0;
 490             }
 491           assign_string (&info->link_name, name);
 492
 493           return HEADER_SUCCESS;
 494         }
 495     }
 496 }
 497
 498 static char *
 499 decode_xform (char *file_name, void *data)
 500 {
 501   int type = *(int*)data;
 502
 503   switch (type)
 504     {
 505     case XFORM_SYMLINK:
 506       /* FIXME: It is not quite clear how and to which extent are the symbolic
 507          links subject to filename transformation.  In the absence of another
 508          solution, symbolic links are exempt from component stripping and
 509          name suffix normalization, but subject to filename transformation
 510          proper. */
 511       return file_name;
 512
 513     case XFORM_LINK:
 514       file_name = safer_name_suffix (file_name, true, absolute_names_option);
 515       break;
 516
 517     case XFORM_REGFILE:
 518       file_name = safer_name_suffix (file_name, false, absolute_names_option);
 519       break;
 520     }
 521
 522   if (strip_name_components)
 523     {
 524       size_t prefix_len = stripped_prefix_len (file_name,
 525                                                strip_name_components);
 526       if (prefix_len == (size_t) -1)
 527         prefix_len = strlen (file_name);
 528       file_name += prefix_len;
 529     }
 530   return file_name;
 531 }
 532
 533 static bool
 534 transform_member_name (char **pinput, int type)
 535 {
 536   return transform_name_fp (pinput, type, decode_xform, &type);
 537 }
 538
 539 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
 540
 541 /* Decode things from a file HEADER block into STAT_INFO, also setting
 542    *FORMAT_POINTER depending on the header block format.  If
 543    DO_USER_GROUP, decode the user/group information (this is useful
 544    for extraction, but waste time when merely listing).
 545
 546    read_header() has already decoded the checksum and length, so we don't.
 547
 548    This routine should *not* be called twice for the same block, since
 549    the two calls might use different DO_USER_GROUP values and thus
 550    might end up with different uid/gid for the two calls.  If anybody
 551    wants the uid/gid they should decode it first, and other callers
 552    should decode it without uid/gid before calling a routine,
 553    e.g. print_header, that assumes decoded data.  */
 554 void
 555 decode_header (union block *header, struct tar_stat_info *stat_info,
 556                enum archive_format *format_pointer, int do_user_group)
 557 {
 558   enum archive_format format;
 559   unsigned hbits; /* high bits of the file mode. */
 560   mode_t mode = MODE_FROM_HEADER (header->header.mode, &hbits);
 561
 562   if (strcmp (header->header.magic, TMAGIC) == 0)
 563     {
 564       if (header->star_header.prefix[130] == 0
 565           && ISOCTAL (header->star_header.atime[0])
 566           && header->star_header.atime[11] == ' '
 567           && ISOCTAL (header->star_header.ctime[0])
 568           && header->star_header.ctime[11] == ' ')
 569         format = STAR_FORMAT;
 570       else if (stat_info->xhdr.size)
 571         format = POSIX_FORMAT;
 572       else
 573         format = USTAR_FORMAT;
 574     }
 575   else if (strcmp (header->header.magic, OLDGNU_MAGIC) == 0)
 576     format = hbits ? OLDGNU_FORMAT : GNU_FORMAT;
 577   else
 578     format = V7_FORMAT;
 579   *format_pointer = format;
 580
 581   stat_info->stat.st_mode = mode;
 582   stat_info->mtime.tv_sec = TIME_FROM_HEADER (header->header.mtime);
 583   stat_info->mtime.tv_nsec = 0;
 584   assign_string (&stat_info->uname,
 585                  header->header.uname[0] ? header->header.uname : NULL);
 586   assign_string (&stat_info->gname,
 587                  header->header.gname[0] ? header->header.gname : NULL);
 588
 589   if (format == OLDGNU_FORMAT && incremental_option)
 590     {
 591       stat_info->atime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.atime);
 592       stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.ctime);
 593       stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
 594     }
 595   else if (format == STAR_FORMAT)
 596     {
 597       stat_info->atime.tv_sec = TIME_FROM_HEADER (header->star_header.atime);
 598       stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->star_header.ctime);
 599       stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
 600     }
 601   else
 602     stat_info->atime = stat_info->ctime = start_time;
 603
 604   if (format == V7_FORMAT)
 605     {
 606       stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
 607       stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
 608       stat_info->stat.st_rdev = 0;
 609     }
 610   else
 611     {
 612       if (do_user_group)
 613         {
 614           /* FIXME: Decide if this should somewhat depend on -p.  */
 615
 616           if (numeric_owner_option
 617               || !*header->header.uname
 618               || !uname_to_uid (header->header.uname, &stat_info->stat.st_uid))
 619             stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
 620
 621           if (numeric_owner_option
 622               || !*header->header.gname
 623               || !gname_to_gid (header->header.gname, &stat_info->stat.st_gid))
 624             stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
 625         }
 626
 627       switch (header->header.typeflag)
 628         {
 629         case BLKTYPE:
 630         case CHRTYPE:
 631           stat_info->stat.st_rdev =
 632             makedev (MAJOR_FROM_HEADER (header->header.devmajor),
 633                      MINOR_FROM_HEADER (header->header.devminor));
 634           break;
 635
 636         default:
 637           stat_info->stat.st_rdev = 0;
 638         }
 639     }
 640
 641   stat_info->archive_file_size = stat_info->stat.st_size;
 642   xheader_decode (stat_info);
 643
 644   if (sparse_member_p (stat_info))
 645     {
 646       sparse_fixup_header (stat_info);
 647       stat_info->is_sparse = true;
 648     }
 649   else
 650     {
 651       stat_info->is_sparse = false;
 652       if (((current_format == GNU_FORMAT
 653             || current_format == OLDGNU_FORMAT)
 654            && current_header->header.typeflag == GNUTYPE_DUMPDIR)
 655           || stat_info->dumpdir)
 656         stat_info->is_dumpdir = true;
 657     }
 658
 659   if (header->header.typeflag == GNUTYPE_VOLHDR)
 660     /* Name transformations don't apply to volume headers. */
 661     return;
 662
 663   transform_member_name (&stat_info->file_name, XFORM_REGFILE);
 664   switch (header->header.typeflag)
 665     {
 666     case SYMTYPE:
 667       transform_member_name (&stat_info->link_name, XFORM_SYMLINK);
 668       break;
 669
 670     case LNKTYPE:
 671       transform_member_name (&stat_info->link_name, XFORM_LINK);
 672     }
 673 }
 674
 675 /* Convert buffer at WHERE0 of size DIGS from external format to
 676    uintmax_t.  DIGS must be positive.  If TYPE is nonnull, the data
 677    are of type TYPE.  The buffer must represent a value in the range
 678    -MINUS_MINVAL through MAXVAL.  If OCTAL_ONLY, allow only octal
 679    numbers instead of the other GNU extensions.  Return -1 on error,
 680    diagnosing the error if TYPE is nonnull and if !SILENT.  */
 681 static uintmax_t
 682 from_header (char const *where0, size_t digs, char const *type,
 683              uintmax_t minus_minval, uintmax_t maxval,
 684              bool octal_only, bool silent)
 685 {
 686   uintmax_t value;
 687   char const *where = where0;
 688   char const *lim = where + digs;
 689   int negative = 0;
 690
 691   /* Accommodate buggy tar of unknown vintage, which outputs leading
 692      NUL if the previous field overflows.  */
 693   where += !*where;
 694
 695   /* Accommodate older tars, which output leading spaces.  */
 696   for (;;)
 697     {
 698       if (where == lim)
 699         {
 700           if (type && !silent)
 701             ERROR ((0, 0,
 702                     /* TRANSLATORS: %s is type of the value (gid_t, uid_t,
 703                        etc.) */
 704                     _("Blanks in header where numeric %s value expected"),
 705                     type));
 706           return -1;
 707         }
 708       if (!ISSPACE ((unsigned char) *where))
 709         break;
 710       where++;
 711     }
 712
 713   value = 0;
 714   if (ISODIGIT (*where))
 715     {
 716       char const *where1 = where;
 717       uintmax_t overflow = 0;
 718
 719       for (;;)
 720         {
 721           value += *where++ - '0';
 722           if (where == lim || ! ISODIGIT (*where))
 723             break;
 724           overflow |= value ^ (value << LG_8 >> LG_8);
 725           value <<= LG_8;
 726         }
 727
 728       /* Parse the output of older, unportable tars, which generate
 729          negative values in two's complement octal.  If the leading
 730          nonzero digit is 1, we can't recover the original value
 731          reliably; so do this only if the digit is 2 or more.  This
 732          catches the common case of 32-bit negative time stamps.  */
 733       if ((overflow || maxval < value) && '2' <= *where1 && type)
 734         {
 735           /* Compute the negative of the input value, assuming two's
 736              complement.  */
 737           int digit = (*where1 - '0') | 4;
 738           overflow = 0;
 739           value = 0;
 740           where = where1;
 741           for (;;)
 742             {
 743               value += 7 - digit;
 744               where++;
 745               if (where == lim || ! ISODIGIT (*where))
 746                 break;
 747               digit = *where - '0';
 748               overflow |= value ^ (value << LG_8 >> LG_8);
 749               value <<= LG_8;
 750             }
 751           value++;
 752           overflow |= !value;
 753
 754           if (!overflow && value <= minus_minval)
 755             {
 756               if (!silent)
 757                 WARN ((0, 0,
 758                        /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
 759                        _("Archive octal value %.*s is out of %s range; assuming two's complement"),
 760                        (int) (where - where1), where1, type));
 761               negative = 1;
 762             }
 763         }
 764
 765       if (overflow)
 766         {
 767           if (type && !silent)
 768             ERROR ((0, 0,
 769                     /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
 770                     _("Archive octal value %.*s is out of %s range"),
 771                     (int) (where - where1), where1, type));
 772           return -1;
 773         }
 774     }
 775   else if (octal_only)
 776     {
 777       /* Suppress the following extensions.  */
 778     }
 779   else if (*where == '-' || *where == '+')
 780     {
 781       /* Parse base-64 output produced only by tar test versions
 782          1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
 783          Support for this will be withdrawn in future releases.  */
 784       int dig;
 785       if (!silent)
 786         {
 787           static bool warned_once;
 788           if (! warned_once)
 789             {
 790               warned_once = true;
 791               WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
 792             }
 793         }
 794       negative = *where++ == '-';
 795       while (where != lim
 796              && (dig = base64_map[(unsigned char) *where]) < 64)
 797         {
 798           if (value << LG_64 >> LG_64 != value)
 799             {
 800               char *string = alloca (digs + 1);
 801               memcpy (string, where0, digs);
 802               string[digs] = '\0';
 803               if (type && !silent)
 804                 ERROR ((0, 0,
 805                         _("Archive signed base-64 string %s is out of %s range"),
 806                         quote (string), type));
 807               return -1;
 808             }
 809           value = (value << LG_64) | dig;
 810           where++;
 811         }
 812     }
 813   else if (*where == '\200' /* positive base-256 */
 814            || *where == '\377' /* negative base-256 */)
 815     {
 816       /* Parse base-256 output.  A nonnegative number N is
 817          represented as (256**DIGS)/2 + N; a negative number -N is
 818          represented as (256**DIGS) - N, i.e. as two's complement.
 819          The representation guarantees that the leading bit is
 820          always on, so that we don't confuse this format with the
 821          others (assuming ASCII bytes of 8 bits or more).  */
 822       int signbit = *where & (1 << (LG_256 - 2));
 823       uintmax_t topbits = (((uintmax_t) - signbit)
 824                            << (CHAR_BIT * sizeof (uintmax_t)
 825                                - LG_256 - (LG_256 - 2)));
 826       value = (*where++ & ((1 << (LG_256 - 2)) - 1)) - signbit;
 827       for (;;)
 828         {
 829           value = (value << LG_256) + (unsigned char) *where++;
 830           if (where == lim)
 831             break;
 832           if (((value << LG_256 >> LG_256) | topbits) != value)
 833             {
 834               if (type && !silent)
 835                 ERROR ((0, 0,
 836                         _("Archive base-256 value is out of %s range"),
 837                         type));
 838               return -1;
 839             }
 840         }
 841       negative = signbit;
 842       if (negative)
 843         value = -value;
 844     }
 845
 846   if (where != lim && *where && !ISSPACE ((unsigned char) *where))
 847     {
 848       if (type)
 849         {
 850           char buf[1000]; /* Big enough to represent any header.  */
 851           static struct quoting_options *o;
 852
 853           if (!o)
 854             {
 855               o = clone_quoting_options (0);
 856               set_quoting_style (o, locale_quoting_style);
 857             }
 858
 859           while (where0 != lim && ! lim[-1])
 860             lim--;
 861           quotearg_buffer (buf, sizeof buf, where0, lim - where, o);
 862           if (!silent)
 863             ERROR ((0, 0,
 864                     /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
 865                     _("Archive contains %.*s where numeric %s value expected"),
 866                     (int) sizeof buf, buf, type));
 867         }
 868
 869       return -1;
 870     }
 871
 872   if (value <= (negative ? minus_minval : maxval))
 873     return negative ? -value : value;
 874
 875   if (type && !silent)
 876     {
 877       char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
 878       char maxval_buf[UINTMAX_STRSIZE_BOUND];
 879       char value_buf[UINTMAX_STRSIZE_BOUND + 1];
 880       char *minval_string = STRINGIFY_BIGINT (minus_minval, minval_buf + 1);
 881       char *value_string = STRINGIFY_BIGINT (value, value_buf + 1);
 882       if (negative)
 883         *--value_string = '-';
 884       if (minus_minval)
 885         *--minval_string = '-';
 886       /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
 887       ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
 888               value_string, type,
 889               minval_string, STRINGIFY_BIGINT (maxval, maxval_buf)));
 890     }
 891
 892   return -1;
 893 }
 894
 895 static gid_t
 896 gid_from_header (const char *p, size_t s)
 897 {
 898   return from_header (p, s, "gid_t",
 899                       - (uintmax_t) TYPE_MINIMUM (gid_t),
 900                       (uintmax_t) TYPE_MAXIMUM (gid_t),
 901                       false, false);
 902 }
 903
 904 static major_t
 905 major_from_header (const char *p, size_t s)
 906 {
 907   return from_header (p, s, "major_t",
 908                       - (uintmax_t) TYPE_MINIMUM (major_t),
 909                       (uintmax_t) TYPE_MAXIMUM (major_t), false, false);
 910 }
 911
 912 static minor_t
 913 minor_from_header (const char *p, size_t s)
 914 {
 915   return from_header (p, s, "minor_t",
 916                       - (uintmax_t) TYPE_MINIMUM (minor_t),
 917                       (uintmax_t) TYPE_MAXIMUM (minor_t), false, false);
 918 }
 919
 920 /* Convert P to the file mode, as understood by tar.
 921    Store unrecognized mode bits (from 10th up) in HBITS. */
 922 static mode_t
 923 mode_from_header (const char *p, size_t s, unsigned *hbits)
 924 {
 925   unsigned u = from_header (p, s, "mode_t",
 926                             - (uintmax_t) TYPE_MINIMUM (mode_t),
 927                             TYPE_MAXIMUM (uintmax_t), false, false);
 928   mode_t mode = ((u & TSUID ? S_ISUID : 0)
 929                  | (u & TSGID ? S_ISGID : 0)
 930                  | (u & TSVTX ? S_ISVTX : 0)
 931                  | (u & TUREAD ? S_IRUSR : 0)
 932                  | (u & TUWRITE ? S_IWUSR : 0)
 933                  | (u & TUEXEC ? S_IXUSR : 0)
 934                  | (u & TGREAD ? S_IRGRP : 0)
 935                  | (u & TGWRITE ? S_IWGRP : 0)
 936                  | (u & TGEXEC ? S_IXGRP : 0)
 937                  | (u & TOREAD ? S_IROTH : 0)
 938                  | (u & TOWRITE ? S_IWOTH : 0)
 939                  | (u & TOEXEC ? S_IXOTH : 0));
 940   *hbits = mode ^ u;
 941   return mode;
 942 }
 943
 944 off_t
 945 off_from_header (const char *p, size_t s)
 946 {
 947   /* Negative offsets are not allowed in tar files, so invoke
 948      from_header with minimum value 0, not TYPE_MINIMUM (off_t).  */
 949   return from_header (p, s, "off_t", (uintmax_t) 0,
 950                       (uintmax_t) TYPE_MAXIMUM (off_t), false, false);
 951 }
 952
 953 static time_t
 954 time_from_header (const char *p, size_t s)
 955 {
 956   return from_header (p, s, "time_t",
 957                       - (uintmax_t) TYPE_MINIMUM (time_t),
 958                       (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
 959 }
 960
 961 static uid_t
 962 uid_from_header (const char *p, size_t s)
 963 {
 964   return from_header (p, s, "uid_t",
 965                       - (uintmax_t) TYPE_MINIMUM (uid_t),
 966                       (uintmax_t) TYPE_MAXIMUM (uid_t), false, false);
 967 }
 968
 969 uintmax_t
 970 uintmax_from_header (const char *p, size_t s)
 971 {
 972   return from_header (p, s, "uintmax_t", (uintmax_t) 0,
 973                       TYPE_MAXIMUM (uintmax_t), false, false);
 974 }
 975
 976
 977 /* Return a printable representation of T.  The result points to
 978    static storage that can be reused in the next call to this
 979    function, to ctime, or to asctime.  If FULL_TIME, then output the
 980    time stamp to its full resolution; otherwise, just output it to
 981    1-minute resolution.  */
 982 char const *
 983 tartime (struct timespec t, bool full_time)
 984 {
 985   enum { fraclen = sizeof ".FFFFFFFFF" - 1 };
 986   static char buffer[max (UINTMAX_STRSIZE_BOUND + 1,
 987                           INT_STRLEN_BOUND (int) + 16)
 988                      + fraclen];
 989   struct tm *tm;
 990   time_t s = t.tv_sec;
 991   int ns = t.tv_nsec;
 992   bool negative = s < 0;
 993   char *p;
 994
 995   if (negative && ns != 0)
 996     {
 997       s++;
 998       ns = 1000000000 - ns;
 999     }
1000
1001   tm = utc_option ? gmtime (&s) : localtime (&s);
1002   if (tm)
1003     {
1004       if (full_time)
1005         {
1006           sprintf (buffer, "%04ld-%02d-%02d %02d:%02d:%02d",
1007                    tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
1008                    tm->tm_hour, tm->tm_min, tm->tm_sec);
1009           code_ns_fraction (ns, buffer + strlen (buffer));
1010         }
1011       else
1012         sprintf (buffer, "%04ld-%02d-%02d %02d:%02d",
1013                  tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
1014                  tm->tm_hour, tm->tm_min);
1015       return buffer;
1016     }
1017
1018   /* The time stamp cannot be broken down, most likely because it
1019      is out of range.  Convert it as an integer,
1020      right-adjusted in a field with the same width as the usual
1021      4-year ISO time format.  */
1022   p = umaxtostr (negative ? - (uintmax_t) s : s,
1023                  buffer + sizeof buffer - UINTMAX_STRSIZE_BOUND - fraclen);
1024   if (negative)
1025     *--p = '-';
1026   while ((buffer + sizeof buffer - sizeof "YYYY-MM-DD HH:MM"
1027           + (full_time ? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1028          < p)
1029     *--p = ' ';
1030   if (full_time)
1031     code_ns_fraction (ns, buffer + sizeof buffer - 1 - fraclen);
1032   return p;
1033 }
1034
1035 /* Actually print it.
1036
1037    Plain and fancy file header block logging.  Non-verbose just prints
1038    the name, e.g. for "tar t" or "tar x".  This should just contain
1039    file names, so it can be fed back into tar with xargs or the "-T"
1040    option.  The verbose option can give a bunch of info, one line per
1041    file.  I doubt anybody tries to parse its format, or if they do,
1042    they shouldn't.  Unix tar is pretty random here anyway.  */
1043
1044
1045 /* Width of "user/group size", with initial value chosen
1046    heuristically.  This grows as needed, though this may cause some
1047    stairstepping in the output.  Make it too small and the output will
1048    almost always look ragged.  Make it too large and the output will
1049    be spaced out too far.  */
1050 static int ugswidth = 19;
1051
1052 /* Width of printed time stamps.  It grows if longer time stamps are
1053    found (typically, those with nanosecond resolution).  Like
1054    USGWIDTH, some stairstepping may occur.  */
1055 static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1;
1056
1057 static bool volume_label_printed = false;
1058
1059 static void
1060 simple_print_header (struct tar_stat_info *st, union block *blk,
1061                      off_t block_ordinal)
1062 {
1063   char modes[11];
1064   char const *time_stamp;
1065   int time_stamp_len;
1066   char *temp_name;
1067
1068   /* These hold formatted ints.  */
1069   char uform[UINTMAX_STRSIZE_BOUND], gform[UINTMAX_STRSIZE_BOUND];
1070   char *user, *group;
1071   char size[2 * UINTMAX_STRSIZE_BOUND];
1072                                 /* holds formatted size or major,minor */
1073   char uintbuf[UINTMAX_STRSIZE_BOUND];
1074   int pad;
1075   int sizelen;
1076
1077   if (show_transformed_names_option)
1078     temp_name = st->file_name ? st->file_name : st->orig_file_name;
1079   else
1080     temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
1081
1082   if (block_number_option)
1083     {
1084       char buf[UINTMAX_STRSIZE_BOUND];
1085       if (block_ordinal < 0)
1086         block_ordinal = current_block_ordinal ();
1087       block_ordinal -= recent_long_name_blocks;
1088       block_ordinal -= recent_long_link_blocks;
1089       fprintf (stdlis, _("block %s: "),
1090                STRINGIFY_BIGINT (block_ordinal, buf));
1091     }
1092
1093   if (verbose_option <= 1)
1094     {
1095       /* Just the fax, mam.  */
1096       fprintf (stdlis, "%s\n", quotearg (temp_name));
1097     }
1098   else
1099     {
1100       /* File type and modes.  */
1101
1102       modes[0] = '?';
1103       switch (blk->header.typeflag)
1104         {
1105         case GNUTYPE_VOLHDR:
1106           volume_label_printed = true;
1107           modes[0] = 'V';
1108           break;
1109
1110         case GNUTYPE_MULTIVOL:
1111           modes[0] = 'M';
1112           break;
1113
1114         case GNUTYPE_LONGNAME:
1115         case GNUTYPE_LONGLINK:
1116           modes[0] = 'L';
1117           ERROR ((0, 0, _("Unexpected long name header")));
1118           break;
1119
1120         case GNUTYPE_SPARSE:
1121         case REGTYPE:
1122         case AREGTYPE:
1123           modes[0] = '-';
1124           if (temp_name[strlen (temp_name) - 1] == '/')
1125             modes[0] = 'd';
1126           break;
1127         case LNKTYPE:
1128           modes[0] = 'h';
1129           break;
1130         case GNUTYPE_DUMPDIR:
1131           modes[0] = 'd';
1132           break;
1133         case DIRTYPE:
1134           modes[0] = 'd';
1135           break;
1136         case SYMTYPE:
1137           modes[0] = 'l';
1138           break;
1139         case BLKTYPE:
1140           modes[0] = 'b';
1141           break;
1142         case CHRTYPE:
1143           modes[0] = 'c';
1144           break;
1145         case FIFOTYPE:
1146           modes[0] = 'p';
1147           break;
1148         case CONTTYPE:
1149           modes[0] = 'C';
1150           break;
1151         }
1152
1153       pax_decode_mode (st->stat.st_mode, modes + 1);
1154
1155       /* Time stamp.  */
1156
1157       time_stamp = tartime (st->mtime, full_time_option);
1158       time_stamp_len = strlen (time_stamp);
1159       if (datewidth < time_stamp_len)
1160         datewidth = time_stamp_len;
1161
1162       /* User and group names.  */
1163
1164       if (st->uname
1165           && st->uname[0]
1166           && current_format != V7_FORMAT
1167           && !numeric_owner_option)
1168         user = st->uname;
1169       else
1170         {
1171           /* Try parsing it as an unsigned integer first, and as a
1172              uid_t if that fails.  This method can list positive user
1173              ids that are too large to fit in a uid_t.  */
1174           uintmax_t u = from_header (blk->header.uid,
1175                                      sizeof blk->header.uid, 0,
1176                                      (uintmax_t) 0,
1177                                      (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1178                                      false, false);
1179           if (u != -1)
1180             user = STRINGIFY_BIGINT (u, uform);
1181           else
1182             {
1183               sprintf (uform, "%ld",
1184                        (long) UID_FROM_HEADER (blk->header.uid));
1185               user = uform;
1186             }
1187         }
1188
1189       if (st->gname
1190           && st->gname[0]
1191           && current_format != V7_FORMAT
1192           && !numeric_owner_option)
1193         group = st->gname;
1194       else
1195         {
1196           /* Try parsing it as an unsigned integer first, and as a
1197              gid_t if that fails.  This method can list positive group
1198              ids that are too large to fit in a gid_t.  */
1199           uintmax_t g = from_header (blk->header.gid,
1200                                      sizeof blk->header.gid, 0,
1201                                      (uintmax_t) 0,
1202                                      (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1203                                      false, false);
1204           if (g != -1)
1205             group = STRINGIFY_BIGINT (g, gform);
1206           else
1207             {
1208               sprintf (gform, "%ld",
1209                        (long) GID_FROM_HEADER (blk->header.gid));
1210               group = gform;
1211             }
1212         }
1213
1214       /* Format the file size or major/minor device numbers.  */
1215
1216       switch (blk->header.typeflag)
1217         {
1218         case CHRTYPE:
1219         case BLKTYPE:
1220           strcpy (size,
1221                   STRINGIFY_BIGINT (major (st->stat.st_rdev), uintbuf));
1222           strcat (size, ",");
1223           strcat (size,
1224                   STRINGIFY_BIGINT (minor (st->stat.st_rdev), uintbuf));
1225           break;
1226
1227         default:
1228           /* st->stat.st_size keeps stored file size */
1229           strcpy (size, STRINGIFY_BIGINT (st->stat.st_size, uintbuf));
1230           break;
1231         }
1232
1233       /* Figure out padding and print the whole line.  */
1234
1235       sizelen = strlen (size);
1236       pad = strlen (user) + 1 + strlen (group) + 1 + sizelen;
1237       if (pad > ugswidth)
1238         ugswidth = pad;
1239
1240       fprintf (stdlis, "%s %s/%s %*s %-*s",
1241                modes, user, group, ugswidth - pad + sizelen, size,
1242                datewidth, time_stamp);
1243
1244       fprintf (stdlis, " %s", quotearg (temp_name));
1245
1246       switch (blk->header.typeflag)
1247         {
1248         case SYMTYPE:
1249           fprintf (stdlis, " -> %s\n", quotearg (st->link_name));
1250           break;
1251
1252         case LNKTYPE:
1253           fprintf (stdlis, _(" link to %s\n"), quotearg (st->link_name));
1254           break;
1255
1256         default:
1257           {
1258             char type_string[2];
1259             type_string[0] = blk->header.typeflag;
1260             type_string[1] = '\0';
1261             fprintf (stdlis, _(" unknown file type %s\n"),
1262                      quote (type_string));
1263           }
1264           break;
1265
1266         case AREGTYPE:
1267         case REGTYPE:
1268         case GNUTYPE_SPARSE:
1269         case CHRTYPE:
1270         case BLKTYPE:
1271         case DIRTYPE:
1272         case FIFOTYPE:
1273         case CONTTYPE:
1274         case GNUTYPE_DUMPDIR:
1275           putc ('\n', stdlis);
1276           break;
1277
1278         case GNUTYPE_LONGLINK:
1279           fprintf (stdlis, _("--Long Link--\n"));
1280           break;
1281
1282         case GNUTYPE_LONGNAME:
1283           fprintf (stdlis, _("--Long Name--\n"));
1284           break;
1285
1286         case GNUTYPE_VOLHDR:
1287           fprintf (stdlis, _("--Volume Header--\n"));
1288           break;
1289
1290         case GNUTYPE_MULTIVOL:
1291           strcpy (size,
1292                   STRINGIFY_BIGINT
1293                   (UINTMAX_FROM_HEADER (blk->oldgnu_header.offset),
1294                    uintbuf));
1295           fprintf (stdlis, _("--Continued at byte %s--\n"), size);
1296           break;
1297         }
1298     }
1299   fflush (stdlis);
1300 }
1301
1302
1303 static void
1304 print_volume_label (void)
1305 {
1306   struct tar_stat_info vstat;
1307   union block vblk;
1308   enum archive_format dummy;
1309
1310   memset (&vblk, 0, sizeof (vblk));
1311   vblk.header.typeflag = GNUTYPE_VOLHDR;
1312   if (recent_global_header)
1313     memcpy (vblk.header.mtime, recent_global_header->header.mtime,
1314             sizeof vblk.header.mtime);
1315   tar_stat_init (&vstat);
1316   assign_string (&vstat.file_name, ".");
1317   decode_header (&vblk, &vstat, &dummy, 0);
1318   assign_string (&vstat.file_name, volume_label);
1319   simple_print_header (&vstat, &vblk, 0);
1320   tar_stat_destroy (&vstat);
1321 }
1322
1323 void
1324 print_header (struct tar_stat_info *st, union block *blk,
1325               off_t block_ordinal)
1326 {
1327   if (current_format == POSIX_FORMAT && !volume_label_printed && volume_label)
1328     {
1329       print_volume_label ();
1330       volume_label_printed = true;
1331     }
1332
1333   simple_print_header (st, blk, block_ordinal);
1334 }
1335
1336 /* Print a similar line when we make a directory automatically.  */
1337 void
1338 print_for_mkdir (char *dirname, int length, mode_t mode)
1339 {
1340   char modes[11];
1341
1342   if (verbose_option > 1)
1343     {
1344       /* File type and modes.  */
1345
1346       modes[0] = 'd';
1347       pax_decode_mode (mode, modes + 1);
1348
1349       if (block_number_option)
1350         {
1351           char buf[UINTMAX_STRSIZE_BOUND];
1352           fprintf (stdlis, _("block %s: "),
1353                    STRINGIFY_BIGINT (current_block_ordinal (), buf));
1354         }
1355
1356       fprintf (stdlis, "%s %*s %.*s\n", modes, ugswidth + 1 + datewidth,
1357                _("Creating directory:"), length, quotearg (dirname));
1358     }
1359 }
1360
1361 /* Skip over SIZE bytes of data in blocks in the archive.  */
1362 void
1363 skip_file (off_t size)
1364 {
1365   union block *x;
1366
1367   /* FIXME: Make sure mv_begin_read is always called before it */
1368
1369   if (seekable_archive)
1370     {
1371       off_t nblk = seek_archive (size);
1372       if (nblk >= 0)
1373         size -= nblk * BLOCKSIZE;
1374       else
1375         seekable_archive = false;
1376     }
1377
1378   mv_size_left (size);
1379
1380   while (size > 0)
1381     {
1382       x = find_next_block ();
1383       if (! x)
1384         FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1385
1386       set_next_block_after (x);
1387       size -= BLOCKSIZE;
1388       mv_size_left (size);
1389     }
1390 }
1391
1392 /* Skip the current member in the archive.
1393    NOTE: Current header must be decoded before calling this function. */
1394 void
1395 skip_member (void)
1396 {
1397   if (!current_stat_info.skipped)
1398     {
1399       char save_typeflag = current_header->header.typeflag;
1400       set_next_block_after (current_header);
1401
1402       mv_begin_read (&current_stat_info);
1403
1404       if (current_stat_info.is_sparse)
1405         sparse_skip_file (&current_stat_info);
1406       else if (save_typeflag != DIRTYPE)
1407         skip_file (current_stat_info.stat.st_size);
1408
1409       mv_end ();
1410     }
1411 }
1412
1413 void
1414 test_archive_label ()
1415 {
1416   base64_init ();
1417   name_gather ();
1418
1419   open_archive (ACCESS_READ);
1420   if (read_header (&current_header, &current_stat_info, read_header_auto)
1421       == HEADER_SUCCESS)
1422     {
1423       decode_header (current_header,
1424                      &current_stat_info, &current_format, 0);
1425       if (current_header->header.typeflag == GNUTYPE_VOLHDR)
1426         assign_string (&volume_label, current_header->header.name);
1427
1428       if (volume_label)
1429         {
1430           if (verbose_option)
1431             print_volume_label ();
1432           if (!name_match (volume_label) && multi_volume_option)
1433             {
1434               char *s = drop_volume_label_suffix (volume_label);
1435               name_match (s);
1436               free (s);
1437             }
1438         }
1439     }
1440   close_archive ();
1441   label_notfound ();
1442 }