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