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