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

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