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