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