git.gag.com Git - debian/tar/blob - src/list.c

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