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   int type = *(int*)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, int type)
 509 {
 510   return transform_name_fp (pinput, type, 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   switch (header->header.typeflag)
 633     {
 634     case SYMTYPE:
 635       transform_member_name (&stat_info->link_name, XFORM_SYMLINK);
 636       break;
 637
 638     case LNKTYPE:
 639       transform_member_name (&stat_info->link_name, XFORM_LINK);
 640     }
 641 }
 642
 643 /* Convert buffer at WHERE0 of size DIGS from external format to
 644    uintmax_t.  DIGS must be positive.  If TYPE is nonnull, the data
 645    are of type TYPE.  The buffer must represent a value in the range
 646    -MINUS_MINVAL through MAXVAL.  If OCTAL_ONLY, allow only octal
 647    numbers instead of the other GNU extensions.  Return -1 on error,
 648    diagnosing the error if TYPE is nonnull and if !SILENT.  */
 649 static uintmax_t
 650 from_header (char const *where0, size_t digs, char const *type,
 651              uintmax_t minus_minval, uintmax_t maxval,
 652              bool octal_only, bool silent)
 653 {
 654   uintmax_t value;
 655   char const *where = where0;
 656   char const *lim = where + digs;
 657   int negative = 0;
 658
 659   /* Accommodate buggy tar of unknown vintage, which outputs leading
 660      NUL if the previous field overflows.  */
 661   where += !*where;
 662
 663   /* Accommodate older tars, which output leading spaces.  */
 664   for (;;)
 665     {
 666       if (where == lim)
 667         {
 668           if (type && !silent)
 669             ERROR ((0, 0,
 670                     /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
 671                     _("Blanks in header where numeric %s value expected"),
 672                     type));
 673           return -1;
 674         }
 675       if (!ISSPACE ((unsigned char) *where))
 676         break;
 677       where++;
 678     }
 679
 680   value = 0;
 681   if (ISODIGIT (*where))
 682     {
 683       char const *where1 = where;
 684       uintmax_t overflow = 0;
 685
 686       for (;;)
 687         {
 688           value += *where++ - '0';
 689           if (where == lim || ! ISODIGIT (*where))
 690             break;
 691           overflow |= value ^ (value << LG_8 >> LG_8);
 692           value <<= LG_8;
 693         }
 694
 695       /* Parse the output of older, unportable tars, which generate
 696          negative values in two's complement octal.  If the leading
 697          nonzero digit is 1, we can't recover the original value
 698          reliably; so do this only if the digit is 2 or more.  This
 699          catches the common case of 32-bit negative time stamps.  */
 700       if ((overflow || maxval < value) && '2' <= *where1 && type)
 701         {
 702           /* Compute the negative of the input value, assuming two's
 703              complement.  */
 704           int digit = (*where1 - '0') | 4;
 705           overflow = 0;
 706           value = 0;
 707           where = where1;
 708           for (;;)
 709             {
 710               value += 7 - digit;
 711               where++;
 712               if (where == lim || ! ISODIGIT (*where))
 713                 break;
 714               digit = *where - '0';
 715               overflow |= value ^ (value << LG_8 >> LG_8);
 716               value <<= LG_8;
 717             }
 718           value++;
 719           overflow |= !value;
 720
 721           if (!overflow && value <= minus_minval)
 722             {
 723               if (!silent)
 724                 WARN ((0, 0,
 725                        /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
 726                        _("Archive octal value %.*s is out of %s range; assuming two's complement"),
 727                        (int) (where - where1), where1, type));
 728               negative = 1;
 729             }
 730         }
 731
 732       if (overflow)
 733         {
 734           if (type && !silent)
 735             ERROR ((0, 0,
 736                     /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
 737                     _("Archive octal value %.*s is out of %s range"),
 738                     (int) (where - where1), where1, type));
 739           return -1;
 740         }
 741     }
 742   else if (octal_only)
 743     {
 744       /* Suppress the following extensions.  */
 745     }
 746   else if (*where == '-' || *where == '+')
 747     {
 748       /* Parse base-64 output produced only by tar test versions
 749          1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
 750          Support for this will be withdrawn in future releases.  */
 751       int dig;
 752       if (!silent)
 753         {
 754           static bool warned_once;
 755           if (! warned_once)
 756             {
 757               warned_once = true;
 758               WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
 759             }
 760         }
 761       negative = *where++ == '-';
 762       while (where != lim
 763              && (dig = base64_map[(unsigned char) *where]) < 64)
 764         {
 765           if (value << LG_64 >> LG_64 != value)
 766             {
 767               char *string = alloca (digs + 1);
 768               memcpy (string, where0, digs);
 769               string[digs] = '\0';
 770               if (type && !silent)
 771                 ERROR ((0, 0,
 772                         _("Archive signed base-64 string %s is out of %s range"),
 773                         quote (string), type));
 774               return -1;
 775             }
 776           value = (value << LG_64) | dig;
 777           where++;
 778         }
 779     }
 780   else if (*where == '\200' /* positive base-256 */
 781            || *where == '\377' /* negative base-256 */)
 782     {
 783       /* Parse base-256 output.  A nonnegative number N is
 784          represented as (256**DIGS)/2 + N; a negative number -N is
 785          represented as (256**DIGS) - N, i.e. as two's complement.
 786          The representation guarantees that the leading bit is
 787          always on, so that we don't confuse this format with the
 788          others (assuming ASCII bytes of 8 bits or more).  */
 789       int signbit = *where & (1 << (LG_256 - 2));
 790       uintmax_t topbits = (((uintmax_t) - signbit)
 791                            << (CHAR_BIT * sizeof (uintmax_t)
 792                                - LG_256 - (LG_256 - 2)));
 793       value = (*where++ & ((1 << (LG_256 - 2)) - 1)) - signbit;
 794       for (;;)
 795         {
 796           value = (value << LG_256) + (unsigned char) *where++;
 797           if (where == lim)
 798             break;
 799           if (((value << LG_256 >> LG_256) | topbits) != value)
 800             {
 801               if (type && !silent)
 802                 ERROR ((0, 0,
 803                         _("Archive base-256 value is out of %s range"),
 804                         type));
 805               return -1;
 806             }
 807         }
 808       negative = signbit;
 809       if (negative)
 810         value = -value;
 811     }
 812
 813   if (where != lim && *where && !ISSPACE ((unsigned char) *where))
 814     {
 815       if (type)
 816         {
 817           char buf[1000]; /* Big enough to represent any header.  */
 818           static struct quoting_options *o;
 819
 820           if (!o)
 821             {
 822               o = clone_quoting_options (0);
 823               set_quoting_style (o, locale_quoting_style);
 824             }
 825
 826           while (where0 != lim && ! lim[-1])
 827             lim--;
 828           quotearg_buffer (buf, sizeof buf, where0, lim - where, o);
 829           if (!silent)
 830             ERROR ((0, 0,
 831                     /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
 832                     _("Archive contains %.*s where numeric %s value expected"),
 833                     (int) sizeof buf, buf, type));
 834         }
 835
 836       return -1;
 837     }
 838
 839   if (value <= (negative ? minus_minval : maxval))
 840     return negative ? -value : value;
 841
 842   if (type && !silent)
 843     {
 844       char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
 845       char maxval_buf[UINTMAX_STRSIZE_BOUND];
 846       char value_buf[UINTMAX_STRSIZE_BOUND + 1];
 847       char *minval_string = STRINGIFY_BIGINT (minus_minval, minval_buf + 1);
 848       char *value_string = STRINGIFY_BIGINT (value, value_buf + 1);
 849       if (negative)
 850         *--value_string = '-';
 851       if (minus_minval)
 852         *--minval_string = '-';
 853       /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
 854       ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
 855               value_string, type,
 856               minval_string, STRINGIFY_BIGINT (maxval, maxval_buf)));
 857     }
 858
 859   return -1;
 860 }
 861
 862 gid_t
 863 gid_from_header (const char *p, size_t s)
 864 {
 865   return from_header (p, s, "gid_t",
 866                       - (uintmax_t) TYPE_MINIMUM (gid_t),
 867                       (uintmax_t) TYPE_MAXIMUM (gid_t),
 868                       false, false);
 869 }
 870
 871 major_t
 872 major_from_header (const char *p, size_t s)
 873 {
 874   return from_header (p, s, "major_t",
 875                       - (uintmax_t) TYPE_MINIMUM (major_t),
 876                       (uintmax_t) TYPE_MAXIMUM (major_t), false, false);
 877 }
 878
 879 minor_t
 880 minor_from_header (const char *p, size_t s)
 881 {
 882   return from_header (p, s, "minor_t",
 883                       - (uintmax_t) TYPE_MINIMUM (minor_t),
 884                       (uintmax_t) TYPE_MAXIMUM (minor_t), false, false);
 885 }
 886
 887 mode_t
 888 mode_from_header (const char *p, size_t s)
 889 {
 890   /* Do not complain about unrecognized mode bits.  */
 891   unsigned u = from_header (p, s, "mode_t",
 892                             - (uintmax_t) TYPE_MINIMUM (mode_t),
 893                             TYPE_MAXIMUM (uintmax_t), false, false);
 894   return ((u & TSUID ? S_ISUID : 0)
 895           | (u & TSGID ? S_ISGID : 0)
 896           | (u & TSVTX ? S_ISVTX : 0)
 897           | (u & TUREAD ? S_IRUSR : 0)
 898           | (u & TUWRITE ? S_IWUSR : 0)
 899           | (u & TUEXEC ? S_IXUSR : 0)
 900           | (u & TGREAD ? S_IRGRP : 0)
 901           | (u & TGWRITE ? S_IWGRP : 0)
 902           | (u & TGEXEC ? S_IXGRP : 0)
 903           | (u & TOREAD ? S_IROTH : 0)
 904           | (u & TOWRITE ? S_IWOTH : 0)
 905           | (u & TOEXEC ? S_IXOTH : 0));
 906 }
 907
 908 off_t
 909 off_from_header (const char *p, size_t s)
 910 {
 911   /* Negative offsets are not allowed in tar files, so invoke
 912      from_header with minimum value 0, not TYPE_MINIMUM (off_t).  */
 913   return from_header (p, s, "off_t", (uintmax_t) 0,
 914                       (uintmax_t) TYPE_MAXIMUM (off_t), false, false);
 915 }
 916
 917 size_t
 918 size_from_header (const char *p, size_t s)
 919 {
 920   return from_header (p, s, "size_t", (uintmax_t) 0,
 921                       (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
 922 }
 923
 924 time_t
 925 time_from_header (const char *p, size_t s)
 926 {
 927   return from_header (p, s, "time_t",
 928                       - (uintmax_t) TYPE_MINIMUM (time_t),
 929                       (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
 930 }
 931
 932 uid_t
 933 uid_from_header (const char *p, size_t s)
 934 {
 935   return from_header (p, s, "uid_t",
 936                       - (uintmax_t) TYPE_MINIMUM (uid_t),
 937                       (uintmax_t) TYPE_MAXIMUM (uid_t), false, false);
 938 }
 939
 940 uintmax_t
 941 uintmax_from_header (const char *p, size_t s)
 942 {
 943   return from_header (p, s, "uintmax_t", (uintmax_t) 0,
 944                       TYPE_MAXIMUM (uintmax_t), false, false);
 945 }
 946
 947
 948 /* Return a printable representation of T.  The result points to
 949    static storage that can be reused in the next call to this
 950    function, to ctime, or to asctime.  If FULL_TIME, then output the
 951    time stamp to its full resolution; otherwise, just output it to
 952    1-minute resolution.  */
 953 char const *
 954 tartime (struct timespec t, bool full_time)
 955 {
 956   enum { fraclen = sizeof ".FFFFFFFFF" - 1 };
 957   static char buffer[max (UINTMAX_STRSIZE_BOUND + 1,
 958                           INT_STRLEN_BOUND (int) + 16)
 959                      + fraclen];
 960   struct tm *tm;
 961   time_t s = t.tv_sec;
 962   int ns = t.tv_nsec;
 963   bool negative = s < 0;
 964   char *p;
 965
 966   if (negative && ns != 0)
 967     {
 968       s++;
 969       ns = 1000000000 - ns;
 970     }
 971
 972   tm = utc_option ? gmtime (&s) : localtime (&s);
 973   if (tm)
 974     {
 975       if (full_time)
 976         {
 977           sprintf (buffer, "%04ld-%02d-%02d %02d:%02d:%02d",
 978                    tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
 979                    tm->tm_hour, tm->tm_min, tm->tm_sec);
 980           code_ns_fraction (ns, buffer + strlen (buffer));
 981         }
 982       else
 983         sprintf (buffer, "%04ld-%02d-%02d %02d:%02d",
 984                  tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
 985                  tm->tm_hour, tm->tm_min);
 986       return buffer;
 987     }
 988
 989   /* The time stamp cannot be broken down, most likely because it
 990      is out of range.  Convert it as an integer,
 991      right-adjusted in a field with the same width as the usual
 992      4-year ISO time format.  */
 993   p = umaxtostr (negative ? - (uintmax_t) s : s,
 994                  buffer + sizeof buffer - UINTMAX_STRSIZE_BOUND - fraclen);
 995   if (negative)
 996     *--p = '-';
 997   while ((buffer + sizeof buffer - sizeof "YYYY-MM-DD HH:MM"
 998           + (full_time ? sizeof ":SS.FFFFFFFFF" - 1 : 0))
 999          < p)
1000     *--p = ' ';
1001   if (full_time)
1002     code_ns_fraction (ns, buffer + sizeof buffer - 1 - fraclen);
1003   return p;
1004 }
1005
1006 /* Actually print it.
1007
1008    Plain and fancy file header block logging.  Non-verbose just prints
1009    the name, e.g. for "tar t" or "tar x".  This should just contain
1010    file names, so it can be fed back into tar with xargs or the "-T"
1011    option.  The verbose option can give a bunch of info, one line per
1012    file.  I doubt anybody tries to parse its format, or if they do,
1013    they shouldn't.  Unix tar is pretty random here anyway.  */
1014
1015
1016 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
1017    HEAD_STANDARD, which must be set up in advance.  Not very clean..  */
1018
1019 /* Width of "user/group size", with initial value chosen
1020    heuristically.  This grows as needed, though this may cause some
1021    stairstepping in the output.  Make it too small and the output will
1022    almost always look ragged.  Make it too large and the output will
1023    be spaced out too far.  */
1024 static int ugswidth = 19;
1025
1026 /* Width of printed time stamps.  It grows if longer time stamps are
1027    found (typically, those with nanosecond resolution).  Like
1028    USGWIDTH, some stairstepping may occur.  */
1029 static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1;
1030
1031 void
1032 print_header (struct tar_stat_info *st, off_t block_ordinal)
1033 {
1034   char modes[11];
1035   char const *time_stamp;
1036   int time_stamp_len;
1037   char *temp_name;
1038
1039   /* These hold formatted ints.  */
1040   char uform[UINTMAX_STRSIZE_BOUND], gform[UINTMAX_STRSIZE_BOUND];
1041   char *user, *group;
1042   char size[2 * UINTMAX_STRSIZE_BOUND];
1043                                 /* holds formatted size or major,minor */
1044   char uintbuf[UINTMAX_STRSIZE_BOUND];
1045   int pad;
1046   int sizelen;
1047
1048   if (test_label_option && current_header->header.typeflag != GNUTYPE_VOLHDR)
1049     return;
1050
1051   if (show_transformed_names_option)
1052     temp_name = st->file_name ? st->file_name : st->orig_file_name;
1053   else
1054     temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
1055
1056   if (block_number_option)
1057     {
1058       char buf[UINTMAX_STRSIZE_BOUND];
1059       if (block_ordinal < 0)
1060         block_ordinal = current_block_ordinal ();
1061       block_ordinal -= recent_long_name_blocks;
1062       block_ordinal -= recent_long_link_blocks;
1063       fprintf (stdlis, _("block %s: "),
1064                STRINGIFY_BIGINT (block_ordinal, buf));
1065     }
1066
1067   if (verbose_option <= 1)
1068     {
1069       /* Just the fax, mam.  */
1070       fprintf (stdlis, "%s\n", quotearg (temp_name));
1071     }
1072   else
1073     {
1074       /* File type and modes.  */
1075
1076       modes[0] = '?';
1077       switch (current_header->header.typeflag)
1078         {
1079         case GNUTYPE_VOLHDR:
1080           modes[0] = 'V';
1081           break;
1082
1083         case GNUTYPE_MULTIVOL:
1084           modes[0] = 'M';
1085           break;
1086
1087         case GNUTYPE_LONGNAME:
1088         case GNUTYPE_LONGLINK:
1089           modes[0] = 'L';
1090           ERROR ((0, 0, _("Unexpected long name header")));
1091           break;
1092
1093         case GNUTYPE_SPARSE:
1094         case REGTYPE:
1095         case AREGTYPE:
1096           modes[0] = '-';
1097           if (temp_name[strlen (temp_name) - 1] == '/')
1098             modes[0] = 'd';
1099           break;
1100         case LNKTYPE:
1101           modes[0] = 'h';
1102           break;
1103         case GNUTYPE_DUMPDIR:
1104           modes[0] = 'd';
1105           break;
1106         case DIRTYPE:
1107           modes[0] = 'd';
1108           break;
1109         case SYMTYPE:
1110           modes[0] = 'l';
1111           break;
1112         case BLKTYPE:
1113           modes[0] = 'b';
1114           break;
1115         case CHRTYPE:
1116           modes[0] = 'c';
1117           break;
1118         case FIFOTYPE:
1119           modes[0] = 'p';
1120           break;
1121         case CONTTYPE:
1122           modes[0] = 'C';
1123           break;
1124         }
1125
1126       pax_decode_mode (st->stat.st_mode, modes + 1);
1127
1128       /* Time stamp.  */
1129
1130       time_stamp = tartime (st->mtime, false);
1131       time_stamp_len = strlen (time_stamp);
1132       if (datewidth < time_stamp_len)
1133         datewidth = time_stamp_len;
1134
1135       /* User and group names.  */
1136
1137       if (st->uname
1138           && st->uname[0]
1139           && current_format != V7_FORMAT
1140           && !numeric_owner_option)
1141         user = st->uname;
1142       else
1143         {
1144           /* Try parsing it as an unsigned integer first, and as a
1145              uid_t if that fails.  This method can list positive user
1146              ids that are too large to fit in a uid_t.  */
1147           uintmax_t u = from_header (current_header->header.uid,
1148                                      sizeof current_header->header.uid, 0,
1149                                      (uintmax_t) 0,
1150                                      (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1151                                      false, false);
1152           if (u != -1)
1153             user = STRINGIFY_BIGINT (u, uform);
1154           else
1155             {
1156               sprintf (uform, "%ld",
1157                        (long) UID_FROM_HEADER (current_header->header.uid));
1158               user = uform;
1159             }
1160         }
1161
1162       if (st->gname
1163           && st->gname[0]
1164           && current_format != V7_FORMAT
1165           && !numeric_owner_option)
1166         group = st->gname;
1167       else
1168         {
1169           /* Try parsing it as an unsigned integer first, and as a
1170              gid_t if that fails.  This method can list positive group
1171              ids that are too large to fit in a gid_t.  */
1172           uintmax_t g = from_header (current_header->header.gid,
1173                                      sizeof current_header->header.gid, 0,
1174                                      (uintmax_t) 0,
1175                                      (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1176                                      false, false);
1177           if (g != -1)
1178             group = STRINGIFY_BIGINT (g, gform);
1179           else
1180             {
1181               sprintf (gform, "%ld",
1182                        (long) GID_FROM_HEADER (current_header->header.gid));
1183               group = gform;
1184             }
1185         }
1186
1187       /* Format the file size or major/minor device numbers.  */
1188
1189       switch (current_header->header.typeflag)
1190         {
1191         case CHRTYPE:
1192         case BLKTYPE:
1193           strcpy (size,
1194                   STRINGIFY_BIGINT (major (st->stat.st_rdev), uintbuf));
1195           strcat (size, ",");
1196           strcat (size,
1197                   STRINGIFY_BIGINT (minor (st->stat.st_rdev), uintbuf));
1198           break;
1199
1200         default:
1201           /* st->stat.st_size keeps stored file size */
1202           strcpy (size, STRINGIFY_BIGINT (st->stat.st_size, uintbuf));
1203           break;
1204         }
1205
1206       /* Figure out padding and print the whole line.  */
1207
1208       sizelen = strlen (size);
1209       pad = strlen (user) + 1 + strlen (group) + 1 + sizelen;
1210       if (pad > ugswidth)
1211         ugswidth = pad;
1212
1213       fprintf (stdlis, "%s %s/%s %*s %-*s",
1214                modes, user, group, ugswidth - pad + sizelen, size,
1215                datewidth, time_stamp);
1216
1217       fprintf (stdlis, " %s", quotearg (temp_name));
1218
1219       switch (current_header->header.typeflag)
1220         {
1221         case SYMTYPE:
1222           fprintf (stdlis, " -> %s\n", quotearg (st->link_name));
1223           break;
1224
1225         case LNKTYPE:
1226           fprintf (stdlis, _(" link to %s\n"), quotearg (st->link_name));
1227           break;
1228
1229         default:
1230           {
1231             char type_string[2];
1232             type_string[0] = current_header->header.typeflag;
1233             type_string[1] = '\0';
1234             fprintf (stdlis, _(" unknown file type %s\n"),
1235                      quote (type_string));
1236           }
1237           break;
1238
1239         case AREGTYPE:
1240         case REGTYPE:
1241         case GNUTYPE_SPARSE:
1242         case CHRTYPE:
1243         case BLKTYPE:
1244         case DIRTYPE:
1245         case FIFOTYPE:
1246         case CONTTYPE:
1247         case GNUTYPE_DUMPDIR:
1248           putc ('\n', stdlis);
1249           break;
1250
1251         case GNUTYPE_LONGLINK:
1252           fprintf (stdlis, _("--Long Link--\n"));
1253           break;
1254
1255         case GNUTYPE_LONGNAME:
1256           fprintf (stdlis, _("--Long Name--\n"));
1257           break;
1258
1259         case GNUTYPE_VOLHDR:
1260           fprintf (stdlis, _("--Volume Header--\n"));
1261           break;
1262
1263         case GNUTYPE_MULTIVOL:
1264           strcpy (size,
1265                   STRINGIFY_BIGINT
1266                   (UINTMAX_FROM_HEADER (current_header->oldgnu_header.offset),
1267                    uintbuf));
1268           fprintf (stdlis, _("--Continued at byte %s--\n"), size);
1269           break;
1270         }
1271     }
1272   fflush (stdlis);
1273 }
1274
1275 /* Print a similar line when we make a directory automatically.  */
1276 void
1277 print_for_mkdir (char *dirname, int length, mode_t mode)
1278 {
1279   char modes[11];
1280
1281   if (verbose_option > 1)
1282     {
1283       /* File type and modes.  */
1284
1285       modes[0] = 'd';
1286       pax_decode_mode (mode, modes + 1);
1287
1288       if (block_number_option)
1289         {
1290           char buf[UINTMAX_STRSIZE_BOUND];
1291           fprintf (stdlis, _("block %s: "),
1292                    STRINGIFY_BIGINT (current_block_ordinal (), buf));
1293         }
1294
1295       fprintf (stdlis, "%s %*s %.*s\n", modes, ugswidth + 1 + datewidth,
1296                _("Creating directory:"), length, quotearg (dirname));
1297     }
1298 }
1299
1300 /* Skip over SIZE bytes of data in blocks in the archive.  */
1301 void
1302 skip_file (off_t size)
1303 {
1304   union block *x;
1305
1306   /* FIXME: Make sure mv_begin is always called before it */
1307
1308   if (seekable_archive)
1309     {
1310       off_t nblk = seek_archive (size);
1311       if (nblk >= 0)
1312         size -= nblk * BLOCKSIZE;
1313       else
1314         seekable_archive = false;
1315     }
1316
1317   mv_size_left (size);
1318
1319   while (size > 0)
1320     {
1321       x = find_next_block ();
1322       if (! x)
1323         FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1324
1325       set_next_block_after (x);
1326       size -= BLOCKSIZE;
1327       mv_size_left (size);
1328     }
1329 }
1330
1331 /* Skip the current member in the archive.
1332    NOTE: Current header must be decoded before calling this function. */
1333 void
1334 skip_member (void)
1335 {
1336   if (!current_stat_info.skipped)
1337     {
1338       char save_typeflag = current_header->header.typeflag;
1339       set_next_block_after (current_header);
1340
1341       mv_begin (&current_stat_info);
1342
1343       if (current_stat_info.is_sparse)
1344         sparse_skip_file (&current_stat_info);
1345       else if (save_typeflag != DIRTYPE)
1346         skip_file (current_stat_info.stat.st_size);
1347
1348       mv_end ();
1349     }
1350 }