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 static uintmax_t from_header (const char *, size_t, const char *,
  39                               uintmax_t, uintmax_t, bool, bool);
  40
  41 /* Base 64 digits; see Internet RFC 2045 Table 1.  */
  42 static char const base_64_digits[64] =
  43 {
  44   'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
  45   'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
  46   'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
  47   'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
  48   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
  49 };
  50
  51 /* Table of base-64 digit values indexed by unsigned chars.
  52    The value is 64 for unsigned chars that are not base-64 digits.  */
  53 static char base64_map[UCHAR_MAX + 1];
  54
  55 static void
  56 base64_init (void)
  57 {
  58   int i;
  59   memset (base64_map, 64, sizeof base64_map);
  60   for (i = 0; i < 64; i++)
  61     base64_map[(int) base_64_digits[i]] = i;
  62 }
  63
  64 /* Main loop for reading an archive.  */
  65 void
  66 read_and (void (*do_something) (void))
  67 {
  68   enum read_header status = HEADER_STILL_UNREAD;
  69   enum read_header prev_status;
  70   struct timespec mtime;
  71
  72   base64_init ();
  73   name_gather ();
  74
  75   open_archive (ACCESS_READ);
  76   do
  77     {
  78       prev_status = status;
  79       tar_stat_destroy (&current_stat_info);
  80
  81       status = read_header (&current_header, &current_stat_info,
  82                             read_header_auto);
  83       switch (status)
  84         {
  85         case HEADER_STILL_UNREAD:
  86         case HEADER_SUCCESS_EXTENDED:
  87           abort ();
  88
  89         case HEADER_SUCCESS:
  90
  91           /* Valid header.  We should decode next field (mode) first.
  92              Ensure incoming names are null terminated.  */
  93
  94           if (! name_match (current_stat_info.file_name)
  95               || (NEWER_OPTION_INITIALIZED (newer_mtime_option)
  96                   /* FIXME: We get mtime now, and again later; this causes
  97                      duplicate diagnostics if header.mtime is bogus.  */
  98                   && ((mtime.tv_sec
  99                        = TIME_FROM_HEADER (current_header->header.mtime)),
 100                       /* FIXME: Grab fractional time stamps from
 101                          extended header.  */
 102                       mtime.tv_nsec = 0,
 103                       current_stat_info.mtime = mtime,
 104                       OLDER_TAR_STAT_TIME (current_stat_info, m)))
 105               || excluded_name (current_stat_info.file_name))
 106             {
 107               switch (current_header->header.typeflag)
 108                 {
 109                 case GNUTYPE_VOLHDR:
 110                 case GNUTYPE_MULTIVOL:
 111                   break;
 112
 113                 case DIRTYPE:
 114                   if (show_omitted_dirs_option)
 115                     WARN ((0, 0, _("%s: Omitting"),
 116                            quotearg_colon (current_stat_info.file_name)));
 117                   /* Fall through.  */
 118                 default:
 119                   decode_header (current_header,
 120                                  &current_stat_info, &current_format, 0);
 121                   skip_member ();
 122                   continue;
 123                 }
 124             }
 125
 126           (*do_something) ();
 127           continue;
 128
 129         case HEADER_ZERO_BLOCK:
 130           if (block_number_option)
 131             {
 132               char buf[UINTMAX_STRSIZE_BOUND];
 133               fprintf (stdlis, _("block %s: ** Block of NULs **\n"),
 134                        STRINGIFY_BIGINT (current_block_ordinal (), buf));
 135             }
 136
 137           set_next_block_after (current_header);
 138
 139           if (!ignore_zeros_option)
 140             {
 141               char buf[UINTMAX_STRSIZE_BOUND];
 142
 143               status = read_header (&current_header, &current_stat_info,
 144                                     read_header_auto);
 145               if (status == HEADER_ZERO_BLOCK)
 146                 break;
 147               /*
 148                * According to POSIX tar specs, this is wrong, but on the web
 149                * there are some tar specs that can trigger this, and some tar
 150                * implementations create tars according to that spec.  For now,
 151                * let's not be pedantic about issuing the warning.
 152                */
 153 #if 0
 154               WARNOPT (WARN_ALONE_ZERO_BLOCK,
 155                        (0, 0, _("A lone zero block at %s"),
 156                         STRINGIFY_BIGINT (current_block_ordinal (), buf)));
 157 #endif
 158               break;
 159             }
 160           status = prev_status;
 161           continue;
 162
 163         case HEADER_END_OF_FILE:
 164           if (block_number_option)
 165             {
 166               char buf[UINTMAX_STRSIZE_BOUND];
 167               fprintf (stdlis, _("block %s: ** End of File **\n"),
 168                        STRINGIFY_BIGINT (current_block_ordinal (), buf));
 169             }
 170           break;
 171
 172         case HEADER_FAILURE:
 173           /* If the previous header was good, tell them that we are
 174              skipping bad ones.  */
 175           set_next_block_after (current_header);
 176           switch (prev_status)
 177             {
 178             case HEADER_STILL_UNREAD:
 179               ERROR ((0, 0, _("This does not look like a tar archive")));
 180               /* Fall through.  */
 181
 182             case HEADER_ZERO_BLOCK:
 183             case HEADER_SUCCESS:
 184               if (block_number_option)
 185                 {
 186                   char buf[UINTMAX_STRSIZE_BOUND];
 187                   off_t block_ordinal = current_block_ordinal ();
 188                   block_ordinal -= recent_long_name_blocks;
 189                   block_ordinal -= recent_long_link_blocks;
 190                   fprintf (stdlis, _("block %s: "),
 191                            STRINGIFY_BIGINT (block_ordinal, buf));
 192                 }
 193               ERROR ((0, 0, _("Skipping to next header")));
 194               break;
 195
 196             case HEADER_END_OF_FILE:
 197             case HEADER_FAILURE:
 198               /* We are in the middle of a cascade of errors.  */
 199               break;
 200
 201             case HEADER_SUCCESS_EXTENDED:
 202               abort ();
 203             }
 204           continue;
 205         }
 206       break;
 207     }
 208   while (!all_names_found (&current_stat_info));
 209
 210   close_archive ();
 211   names_notfound ();            /* print names not found */
 212 }
 213
 214 /* Print a header block, based on tar options.  */
 215 void
 216 list_archive (void)
 217 {
 218   off_t block_ordinal = current_block_ordinal ();
 219
 220   /* Print the header block.  */
 221
 222   decode_header (current_header, &current_stat_info, &current_format, 0);
 223   if (verbose_option)
 224     print_header (&current_stat_info, current_header, block_ordinal);
 225
 226   if (incremental_option)
 227     {
 228       if (verbose_option > 2)
 229         {
 230           if (is_dumpdir (&current_stat_info))
 231             list_dumpdir (current_stat_info.dumpdir,
 232                           dumpdir_size (current_stat_info.dumpdir));
 233         }
 234     }
 235
 236   skip_member ();
 237 }
 238
 239 /* Check header checksum */
 240 /* The standard BSD tar sources create the checksum by adding up the
 241    bytes in the header as type char.  I think the type char was unsigned
 242    on the PDP-11, but it's signed on the Next and Sun.  It looks like the
 243    sources to BSD tar were never changed to compute the checksum
 244    correctly, so both the Sun and Next add the bytes of the header as
 245    signed chars.  This doesn't cause a problem until you get a file with
 246    a name containing characters with the high bit set.  So tar_checksum
 247    computes two checksums -- signed and unsigned.  */
 248
 249 enum read_header
 250 tar_checksum (union block *header, bool silent)
 251 {
 252   size_t i;
 253   int unsigned_sum = 0;         /* the POSIX one :-) */
 254   int signed_sum = 0;           /* the Sun one :-( */
 255   int recorded_sum;
 256   uintmax_t parsed_sum;
 257   char *p;
 258
 259   p = header->buffer;
 260   for (i = sizeof *header; i-- != 0;)
 261     {
 262       unsigned_sum += (unsigned char) *p;
 263       signed_sum += (signed char) (*p++);
 264     }
 265
 266   if (unsigned_sum == 0)
 267     return HEADER_ZERO_BLOCK;
 268
 269   /* Adjust checksum to count the "chksum" field as blanks.  */
 270
 271   for (i = sizeof header->header.chksum; i-- != 0;)
 272     {
 273       unsigned_sum -= (unsigned char) header->header.chksum[i];
 274       signed_sum -= (signed char) (header->header.chksum[i]);
 275     }
 276   unsigned_sum += ' ' * sizeof header->header.chksum;
 277   signed_sum += ' ' * sizeof header->header.chksum;
 278
 279   parsed_sum = from_header (header->header.chksum,
 280                             sizeof header->header.chksum, 0,
 281                             (uintmax_t) 0,
 282                             (uintmax_t) TYPE_MAXIMUM (int), true, silent);
 283   if (parsed_sum == (uintmax_t) -1)
 284     return HEADER_FAILURE;
 285
 286   recorded_sum = parsed_sum;
 287
 288   if (unsigned_sum != recorded_sum && signed_sum != recorded_sum)
 289     return HEADER_FAILURE;
 290
 291   return HEADER_SUCCESS;
 292 }
 293
 294 /* Read a block that's supposed to be a header block.  Return its
 295    address in *RETURN_BLOCK, and if it is good, the file's size
 296    and names (file name, link name) in *INFO.
 297
 298    Return one of enum read_header describing the status of the
 299    operation.
 300
 301    The MODE parameter instructs read_header what to do with special
 302    header blocks, i.e.: extended POSIX, GNU long name or long link,
 303    etc.:
 304
 305      read_header_auto        process them automatically,
 306      read_header_x_raw       when a special header is read, return
 307                              HEADER_SUCCESS_EXTENDED without actually
 308                              processing the header,
 309      read_header_x_global    when a POSIX global header is read,
 310                              decode it and return HEADER_SUCCESS_EXTENDED.
 311
 312    You must always set_next_block_after(*return_block) to skip past
 313    the header which this routine reads.  */
 314
 315 enum read_header
 316 read_header (union block **return_block, struct tar_stat_info *info,
 317              enum read_header_mode mode)
 318 {
 319   union block *header;
 320   union block *header_copy;
 321   char *bp;
 322   union block *data_block;
 323   size_t size, written;
 324   union block *next_long_name = 0;
 325   union block *next_long_link = 0;
 326   size_t next_long_name_blocks = 0;
 327   size_t next_long_link_blocks = 0;
 328
 329   while (1)
 330     {
 331       enum read_header status;
 332
 333       header = find_next_block ();
 334       *return_block = header;
 335       if (!header)
 336         return HEADER_END_OF_FILE;
 337
 338       if ((status = tar_checksum (header, false)) != HEADER_SUCCESS)
 339         return status;
 340
 341       /* Good block.  Decode file size and return.  */
 342
 343       if (header->header.typeflag == LNKTYPE)
 344         info->stat.st_size = 0; /* links 0 size on tape */
 345       else
 346         info->stat.st_size = OFF_FROM_HEADER (header->header.size);
 347
 348       if (header->header.typeflag == GNUTYPE_LONGNAME
 349           || header->header.typeflag == GNUTYPE_LONGLINK
 350           || header->header.typeflag == XHDTYPE
 351           || header->header.typeflag == XGLTYPE
 352           || header->header.typeflag == SOLARIS_XHDTYPE)
 353         {
 354           if (mode == read_header_x_raw)
 355             return HEADER_SUCCESS_EXTENDED;
 356           else if (header->header.typeflag == GNUTYPE_LONGNAME
 357                    || header->header.typeflag == GNUTYPE_LONGLINK)
 358             {
 359               size_t name_size = info->stat.st_size;
 360               size_t n = name_size % BLOCKSIZE;
 361               size = name_size + BLOCKSIZE;
 362               if (n)
 363                 size += BLOCKSIZE - n;
 364
 365               if (name_size != info->stat.st_size || size < name_size)
 366                 xalloc_die ();
 367
 368               header_copy = xmalloc (size + 1);
 369
 370               if (header->header.typeflag == GNUTYPE_LONGNAME)
 371                 {
 372                   if (next_long_name)
 373                     free (next_long_name);
 374                   next_long_name = header_copy;
 375                   next_long_name_blocks = size / BLOCKSIZE;
 376                 }
 377               else
 378                 {
 379                   if (next_long_link)
 380                     free (next_long_link);
 381                   next_long_link = header_copy;
 382                   next_long_link_blocks = size / BLOCKSIZE;
 383                 }
 384
 385               set_next_block_after (header);
 386               *header_copy = *header;
 387               bp = header_copy->buffer + BLOCKSIZE;
 388
 389               for (size -= BLOCKSIZE; size > 0; size -= written)
 390                 {
 391                   data_block = find_next_block ();
 392                   if (! data_block)
 393                     {
 394                       ERROR ((0, 0, _("Unexpected EOF in archive")));
 395                       break;
 396                     }
 397                   written = available_space_after (data_block);
 398                   if (written > size)
 399                     written = size;
 400
 401                   memcpy (bp, data_block->buffer, written);
 402                   bp += written;
 403                   set_next_block_after ((union block *)
 404                                         (data_block->buffer + written - 1));
 405                 }
 406
 407               *bp = '\0';
 408             }
 409           else if (header->header.typeflag == XHDTYPE
 410                    || header->header.typeflag == SOLARIS_XHDTYPE)
 411             xheader_read (&info->xhdr, header,
 412                           OFF_FROM_HEADER (header->header.size));
 413           else if (header->header.typeflag == XGLTYPE)
 414             {
 415               struct xheader xhdr;
 416
 417               if (!recent_global_header)
 418                 recent_global_header = xmalloc (sizeof *recent_global_header);
 419               memcpy (recent_global_header, header,
 420                       sizeof *recent_global_header);
 421               memset (&xhdr, 0, sizeof xhdr);
 422               xheader_read (&xhdr, header,
 423                             OFF_FROM_HEADER (header->header.size));
 424               xheader_decode_global (&xhdr);
 425               xheader_destroy (&xhdr);
 426               if (mode == read_header_x_global)
 427                 return HEADER_SUCCESS_EXTENDED;
 428             }
 429
 430           /* Loop!  */
 431
 432         }
 433       else
 434         {
 435           char const *name;
 436           struct posix_header const *h = &header->header;
 437           char namebuf[sizeof h->prefix + 1 + NAME_FIELD_SIZE + 1];
 438
 439           if (recent_long_name)
 440             free (recent_long_name);
 441
 442           if (next_long_name)
 443             {
 444               name = next_long_name->buffer + BLOCKSIZE;
 445               recent_long_name = next_long_name;
 446               recent_long_name_blocks = next_long_name_blocks;
 447             }
 448           else
 449             {
 450               /* Accept file names as specified by POSIX.1-1996
 451                  section 10.1.1.  */
 452               char *np = namebuf;
 453
 454               if (h->prefix[0] && strcmp (h->magic, TMAGIC) == 0)
 455                 {
 456                   memcpy (np, h->prefix, sizeof h->prefix);
 457                   np[sizeof h->prefix] = '\0';
 458                   np += strlen (np);
 459                   *np++ = '/';
 460                 }
 461               memcpy (np, h->name, sizeof h->name);
 462               np[sizeof h->name] = '\0';
 463               name = namebuf;
 464               recent_long_name = 0;
 465               recent_long_name_blocks = 0;
 466             }
 467           assign_string (&info->orig_file_name, name);
 468           assign_string (&info->file_name, name);
 469           info->had_trailing_slash = strip_trailing_slashes (info->file_name);
 470
 471           if (recent_long_link)
 472             free (recent_long_link);
 473
 474           if (next_long_link)
 475             {
 476               name = next_long_link->buffer + BLOCKSIZE;
 477               recent_long_link = next_long_link;
 478               recent_long_link_blocks = next_long_link_blocks;
 479             }
 480           else
 481             {
 482               memcpy (namebuf, h->linkname, sizeof h->linkname);
 483               namebuf[sizeof h->linkname] = '\0';
 484               name = namebuf;
 485               recent_long_link = 0;
 486               recent_long_link_blocks = 0;
 487             }
 488           assign_string (&info->link_name, name);
 489
 490           return HEADER_SUCCESS;
 491         }
 492     }
 493 }
 494
 495 static char *
 496 decode_xform (char *file_name, void *data)
 497 {
 498   int type = *(int*)data;
 499
 500   switch (type)
 501     {
 502     case XFORM_SYMLINK:
 503       /* FIXME: It is not quite clear how and to which extent are the symbolic
 504          links subject to filename transformation.  In the absence of another
 505          solution, symbolic links are exempt from component stripping and
 506          name suffix normalization, but subject to filename transformation
 507          proper. */
 508       return file_name;
 509
 510     case XFORM_LINK:
 511       file_name = safer_name_suffix (file_name, true, absolute_names_option);
 512       break;
 513
 514     case XFORM_REGFILE:
 515       file_name = safer_name_suffix (file_name, false, absolute_names_option);
 516       break;
 517     }
 518
 519   if (strip_name_components)
 520     {
 521       size_t prefix_len = stripped_prefix_len (file_name,
 522                                                strip_name_components);
 523       if (prefix_len == (size_t) -1)
 524         prefix_len = strlen (file_name);
 525       file_name += prefix_len;
 526     }
 527   return file_name;
 528 }
 529
 530 bool
 531 transform_member_name (char **pinput, int type)
 532 {
 533   return transform_name_fp (pinput, type, decode_xform, &type);
 534 }
 535
 536 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
 537
 538 /* Decode things from a file HEADER block into STAT_INFO, also setting
 539    *FORMAT_POINTER depending on the header block format.  If
 540    DO_USER_GROUP, decode the user/group information (this is useful
 541    for extraction, but waste time when merely listing).
 542
 543    read_header() has already decoded the checksum and length, so we don't.
 544
 545    This routine should *not* be called twice for the same block, since
 546    the two calls might use different DO_USER_GROUP values and thus
 547    might end up with different uid/gid for the two calls.  If anybody
 548    wants the uid/gid they should decode it first, and other callers
 549    should decode it without uid/gid before calling a routine,
 550    e.g. print_header, that assumes decoded data.  */
 551 void
 552 decode_header (union block *header, struct tar_stat_info *stat_info,
 553                enum archive_format *format_pointer, int do_user_group)
 554 {
 555   enum archive_format format;
 556   unsigned hbits; /* high bits of the file mode. */
 557   mode_t mode = MODE_FROM_HEADER (header->header.mode, &hbits);
 558
 559   if (strcmp (header->header.magic, TMAGIC) == 0)
 560     {
 561       if (header->star_header.prefix[130] == 0
 562           && ISOCTAL (header->star_header.atime[0])
 563           && header->star_header.atime[11] == ' '
 564           && ISOCTAL (header->star_header.ctime[0])
 565           && header->star_header.ctime[11] == ' ')
 566         format = STAR_FORMAT;
 567       else if (stat_info->xhdr.size)
 568         format = POSIX_FORMAT;
 569       else
 570         format = USTAR_FORMAT;
 571     }
 572   else if (strcmp (header->header.magic, OLDGNU_MAGIC) == 0)
 573     format = hbits ? OLDGNU_FORMAT : GNU_FORMAT;
 574   else
 575     format = V7_FORMAT;
 576   *format_pointer = format;
 577
 578   stat_info->stat.st_mode = mode;
 579   stat_info->mtime.tv_sec = TIME_FROM_HEADER (header->header.mtime);
 580   stat_info->mtime.tv_nsec = 0;
 581   assign_string (&stat_info->uname,
 582                  header->header.uname[0] ? header->header.uname : NULL);
 583   assign_string (&stat_info->gname,
 584                  header->header.gname[0] ? header->header.gname : NULL);
 585
 586   if (format == OLDGNU_FORMAT && incremental_option)
 587     {
 588       stat_info->atime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.atime);
 589       stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.ctime);
 590       stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
 591     }
 592   else if (format == STAR_FORMAT)
 593     {
 594       stat_info->atime.tv_sec = TIME_FROM_HEADER (header->star_header.atime);
 595       stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->star_header.ctime);
 596       stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
 597     }
 598   else
 599     stat_info->atime = stat_info->ctime = start_time;
 600
 601   if (format == V7_FORMAT)
 602     {
 603       stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
 604       stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
 605       stat_info->stat.st_rdev = 0;
 606     }
 607   else
 608     {
 609       if (do_user_group)
 610         {
 611           /* FIXME: Decide if this should somewhat depend on -p.  */
 612
 613           if (numeric_owner_option
 614               || !*header->header.uname
 615               || !uname_to_uid (header->header.uname, &stat_info->stat.st_uid))
 616             stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
 617
 618           if (numeric_owner_option
 619               || !*header->header.gname
 620               || !gname_to_gid (header->header.gname, &stat_info->stat.st_gid))
 621             stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
 622         }
 623
 624       switch (header->header.typeflag)
 625         {
 626         case BLKTYPE:
 627         case CHRTYPE:
 628           stat_info->stat.st_rdev =
 629             makedev (MAJOR_FROM_HEADER (header->header.devmajor),
 630                      MINOR_FROM_HEADER (header->header.devminor));
 631           break;
 632
 633         default:
 634           stat_info->stat.st_rdev = 0;
 635         }
 636     }
 637
 638   stat_info->archive_file_size = stat_info->stat.st_size;
 639   xheader_decode (stat_info);
 640
 641   if (sparse_member_p (stat_info))
 642     {
 643       sparse_fixup_header (stat_info);
 644       stat_info->is_sparse = true;
 645     }
 646   else
 647     {
 648       stat_info->is_sparse = false;
 649       if (((current_format == GNU_FORMAT
 650             || current_format == OLDGNU_FORMAT)
 651            && current_header->header.typeflag == GNUTYPE_DUMPDIR)
 652           || stat_info->dumpdir)
 653         stat_info->is_dumpdir = true;
 654     }
 655
 656   transform_member_name (&stat_info->file_name, XFORM_REGFILE);
 657   switch (header->header.typeflag)
 658     {
 659     case SYMTYPE:
 660       transform_member_name (&stat_info->link_name, XFORM_SYMLINK);
 661       break;
 662
 663     case LNKTYPE:
 664       transform_member_name (&stat_info->link_name, XFORM_LINK);
 665     }
 666 }
 667
 668 /* Convert buffer at WHERE0 of size DIGS from external format to
 669    uintmax_t.  DIGS must be positive.  If TYPE is nonnull, the data
 670    are of type TYPE.  The buffer must represent a value in the range
 671    -MINUS_MINVAL through MAXVAL.  If OCTAL_ONLY, allow only octal
 672    numbers instead of the other GNU extensions.  Return -1 on error,
 673    diagnosing the error if TYPE is nonnull and if !SILENT.  */
 674 static uintmax_t
 675 from_header (char const *where0, size_t digs, char const *type,
 676              uintmax_t minus_minval, uintmax_t maxval,
 677              bool octal_only, bool silent)
 678 {
 679   uintmax_t value;
 680   char const *where = where0;
 681   char const *lim = where + digs;
 682   int negative = 0;
 683
 684   /* Accommodate buggy tar of unknown vintage, which outputs leading
 685      NUL if the previous field overflows.  */
 686   where += !*where;
 687
 688   /* Accommodate older tars, which output leading spaces.  */
 689   for (;;)
 690     {
 691       if (where == lim)
 692         {
 693           if (type && !silent)
 694             ERROR ((0, 0,
 695                     /* TRANSLATORS: %s is type of the value (gid_t, uid_t,
 696                        etc.) */
 697                     _("Blanks in header where numeric %s value expected"),
 698                     type));
 699           return -1;
 700         }
 701       if (!ISSPACE ((unsigned char) *where))
 702         break;
 703       where++;
 704     }
 705
 706   value = 0;
 707   if (ISODIGIT (*where))
 708     {
 709       char const *where1 = where;
 710       uintmax_t overflow = 0;
 711
 712       for (;;)
 713         {
 714           value += *where++ - '0';
 715           if (where == lim || ! ISODIGIT (*where))
 716             break;
 717           overflow |= value ^ (value << LG_8 >> LG_8);
 718           value <<= LG_8;
 719         }
 720
 721       /* Parse the output of older, unportable tars, which generate
 722          negative values in two's complement octal.  If the leading
 723          nonzero digit is 1, we can't recover the original value
 724          reliably; so do this only if the digit is 2 or more.  This
 725          catches the common case of 32-bit negative time stamps.  */
 726       if ((overflow || maxval < value) && '2' <= *where1 && type)
 727         {
 728           /* Compute the negative of the input value, assuming two's
 729              complement.  */
 730           int digit = (*where1 - '0') | 4;
 731           overflow = 0;
 732           value = 0;
 733           where = where1;
 734           for (;;)
 735             {
 736               value += 7 - digit;
 737               where++;
 738               if (where == lim || ! ISODIGIT (*where))
 739                 break;
 740               digit = *where - '0';
 741               overflow |= value ^ (value << LG_8 >> LG_8);
 742               value <<= LG_8;
 743             }
 744           value++;
 745           overflow |= !value;
 746
 747           if (!overflow && value <= minus_minval)
 748             {
 749               if (!silent)
 750                 WARN ((0, 0,
 751                        /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
 752                        _("Archive octal value %.*s is out of %s range; assuming two's complement"),
 753                        (int) (where - where1), where1, type));
 754               negative = 1;
 755             }
 756         }
 757
 758       if (overflow)
 759         {
 760           if (type && !silent)
 761             ERROR ((0, 0,
 762                     /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
 763                     _("Archive octal value %.*s is out of %s range"),
 764                     (int) (where - where1), where1, type));
 765           return -1;
 766         }
 767     }
 768   else if (octal_only)
 769     {
 770       /* Suppress the following extensions.  */
 771     }
 772   else if (*where == '-' || *where == '+')
 773     {
 774       /* Parse base-64 output produced only by tar test versions
 775          1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
 776          Support for this will be withdrawn in future releases.  */
 777       int dig;
 778       if (!silent)
 779         {
 780           static bool warned_once;
 781           if (! warned_once)
 782             {
 783               warned_once = true;
 784               WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
 785             }
 786         }
 787       negative = *where++ == '-';
 788       while (where != lim
 789              && (dig = base64_map[(unsigned char) *where]) < 64)
 790         {
 791           if (value << LG_64 >> LG_64 != value)
 792             {
 793               char *string = alloca (digs + 1);
 794               memcpy (string, where0, digs);
 795               string[digs] = '\0';
 796               if (type && !silent)
 797                 ERROR ((0, 0,
 798                         _("Archive signed base-64 string %s is out of %s range"),
 799                         quote (string), type));
 800               return -1;
 801             }
 802           value = (value << LG_64) | dig;
 803           where++;
 804         }
 805     }
 806   else if (*where == '\200' /* positive base-256 */
 807            || *where == '\377' /* negative base-256 */)
 808     {
 809       /* Parse base-256 output.  A nonnegative number N is
 810          represented as (256**DIGS)/2 + N; a negative number -N is
 811          represented as (256**DIGS) - N, i.e. as two's complement.
 812          The representation guarantees that the leading bit is
 813          always on, so that we don't confuse this format with the
 814          others (assuming ASCII bytes of 8 bits or more).  */
 815       int signbit = *where & (1 << (LG_256 - 2));
 816       uintmax_t topbits = (((uintmax_t) - signbit)
 817                            << (CHAR_BIT * sizeof (uintmax_t)
 818                                - LG_256 - (LG_256 - 2)));
 819       value = (*where++ & ((1 << (LG_256 - 2)) - 1)) - signbit;
 820       for (;;)
 821         {
 822           value = (value << LG_256) + (unsigned char) *where++;
 823           if (where == lim)
 824             break;
 825           if (((value << LG_256 >> LG_256) | topbits) != value)
 826             {
 827               if (type && !silent)
 828                 ERROR ((0, 0,
 829                         _("Archive base-256 value is out of %s range"),
 830                         type));
 831               return -1;
 832             }
 833         }
 834       negative = signbit;
 835       if (negative)
 836         value = -value;
 837     }
 838
 839   if (where != lim && *where && !ISSPACE ((unsigned char) *where))
 840     {
 841       if (type)
 842         {
 843           char buf[1000]; /* Big enough to represent any header.  */
 844           static struct quoting_options *o;
 845
 846           if (!o)
 847             {
 848               o = clone_quoting_options (0);
 849               set_quoting_style (o, locale_quoting_style);
 850             }
 851
 852           while (where0 != lim && ! lim[-1])
 853             lim--;
 854           quotearg_buffer (buf, sizeof buf, where0, lim - where, o);
 855           if (!silent)
 856             ERROR ((0, 0,
 857                     /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
 858                     _("Archive contains %.*s where numeric %s value expected"),
 859                     (int) sizeof buf, buf, type));
 860         }
 861
 862       return -1;
 863     }
 864
 865   if (value <= (negative ? minus_minval : maxval))
 866     return negative ? -value : value;
 867
 868   if (type && !silent)
 869     {
 870       char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
 871       char maxval_buf[UINTMAX_STRSIZE_BOUND];
 872       char value_buf[UINTMAX_STRSIZE_BOUND + 1];
 873       char *minval_string = STRINGIFY_BIGINT (minus_minval, minval_buf + 1);
 874       char *value_string = STRINGIFY_BIGINT (value, value_buf + 1);
 875       if (negative)
 876         *--value_string = '-';
 877       if (minus_minval)
 878         *--minval_string = '-';
 879       /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
 880       ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
 881               value_string, type,
 882               minval_string, STRINGIFY_BIGINT (maxval, maxval_buf)));
 883     }
 884
 885   return -1;
 886 }
 887
 888 gid_t
 889 gid_from_header (const char *p, size_t s)
 890 {
 891   return from_header (p, s, "gid_t",
 892                       - (uintmax_t) TYPE_MINIMUM (gid_t),
 893                       (uintmax_t) TYPE_MAXIMUM (gid_t),
 894                       false, false);
 895 }
 896
 897 major_t
 898 major_from_header (const char *p, size_t s)
 899 {
 900   return from_header (p, s, "major_t",
 901                       - (uintmax_t) TYPE_MINIMUM (major_t),
 902                       (uintmax_t) TYPE_MAXIMUM (major_t), false, false);
 903 }
 904
 905 minor_t
 906 minor_from_header (const char *p, size_t s)
 907 {
 908   return from_header (p, s, "minor_t",
 909                       - (uintmax_t) TYPE_MINIMUM (minor_t),
 910                       (uintmax_t) TYPE_MAXIMUM (minor_t), false, false);
 911 }
 912
 913 /* Convert P to the file mode, as understood by tar.
 914    Store unrecognized mode bits (from 10th up) in HBITS. */
 915 mode_t
 916 mode_from_header (const char *p, size_t s, unsigned *hbits)
 917 {
 918   unsigned u = from_header (p, s, "mode_t",
 919                             - (uintmax_t) TYPE_MINIMUM (mode_t),
 920                             TYPE_MAXIMUM (uintmax_t), false, false);
 921   mode_t mode = ((u & TSUID ? S_ISUID : 0)
 922                  | (u & TSGID ? S_ISGID : 0)
 923                  | (u & TSVTX ? S_ISVTX : 0)
 924                  | (u & TUREAD ? S_IRUSR : 0)
 925                  | (u & TUWRITE ? S_IWUSR : 0)
 926                  | (u & TUEXEC ? S_IXUSR : 0)
 927                  | (u & TGREAD ? S_IRGRP : 0)
 928                  | (u & TGWRITE ? S_IWGRP : 0)
 929                  | (u & TGEXEC ? S_IXGRP : 0)
 930                  | (u & TOREAD ? S_IROTH : 0)
 931                  | (u & TOWRITE ? S_IWOTH : 0)
 932                  | (u & TOEXEC ? S_IXOTH : 0));
 933   *hbits = mode ^ u;
 934   return mode;
 935 }
 936
 937 off_t
 938 off_from_header (const char *p, size_t s)
 939 {
 940   /* Negative offsets are not allowed in tar files, so invoke
 941      from_header with minimum value 0, not TYPE_MINIMUM (off_t).  */
 942   return from_header (p, s, "off_t", (uintmax_t) 0,
 943                       (uintmax_t) TYPE_MAXIMUM (off_t), false, false);
 944 }
 945
 946 size_t
 947 size_from_header (const char *p, size_t s)
 948 {
 949   return from_header (p, s, "size_t", (uintmax_t) 0,
 950                       (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
 951 }
 952
 953 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 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, false);
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 void
1304 print_volume_label ()
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 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 (&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       char *s = NULL;
1424
1425       decode_header (current_header,
1426                      &current_stat_info, &current_format, 0);
1427       if (current_header->header.typeflag == GNUTYPE_VOLHDR)
1428         assign_string (&volume_label, current_header->header.name);
1429
1430       if (volume_label
1431           && (name_match (volume_label)
1432               || (multi_volume_option
1433                   && (s = drop_volume_label_suffix (volume_label))
1434                   && name_match (s))))
1435         if (verbose_option)
1436           print_volume_label ();
1437       free (s);
1438     }
1439   close_archive ();
1440   names_notfound ();
1441 }