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