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   int type = *(int*)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, int type)
 518 {
 519   return transform_name_fp (pinput, type, 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   switch (header->header.typeflag)
 642     {
 643     case SYMTYPE:
 644       transform_member_name (&stat_info->link_name, XFORM_SYMLINK);
 645       break;
 646
 647     case LNKTYPE:
 648       transform_member_name (&stat_info->link_name, XFORM_LINK);
 649     }
 650 }
 651
 652 /* Convert buffer at WHERE0 of size DIGS from external format to
 653    uintmax_t.  DIGS must be positive.  If TYPE is nonnull, the data
 654    are of type TYPE.  The buffer must represent a value in the range
 655    -MINUS_MINVAL through MAXVAL.  If OCTAL_ONLY, allow only octal
 656    numbers instead of the other GNU extensions.  Return -1 on error,
 657    diagnosing the error if TYPE is nonnull and if !SILENT.  */
 658 static uintmax_t
 659 from_header (char const *where0, size_t digs, char const *type,
 660              uintmax_t minus_minval, uintmax_t maxval,
 661              bool octal_only, bool silent)
 662 {
 663   uintmax_t value;
 664   char const *where = where0;
 665   char const *lim = where + digs;
 666   int negative = 0;
 667
 668   /* Accommodate buggy tar of unknown vintage, which outputs leading
 669      NUL if the previous field overflows.  */
 670   where += !*where;
 671
 672   /* Accommodate older tars, which output leading spaces.  */
 673   for (;;)
 674     {
 675       if (where == lim)
 676         {
 677           if (type && !silent)
 678             ERROR ((0, 0,
 679                     /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
 680                     _("Blanks in header where numeric %s value expected"),
 681                     type));
 682           return -1;
 683         }
 684       if (!ISSPACE ((unsigned char) *where))
 685         break;
 686       where++;
 687     }
 688
 689   value = 0;
 690   if (ISODIGIT (*where))
 691     {
 692       char const *where1 = where;
 693       uintmax_t overflow = 0;
 694
 695       for (;;)
 696         {
 697           value += *where++ - '0';
 698           if (where == lim || ! ISODIGIT (*where))
 699             break;
 700           overflow |= value ^ (value << LG_8 >> LG_8);
 701           value <<= LG_8;
 702         }
 703
 704       /* Parse the output of older, unportable tars, which generate
 705          negative values in two's complement octal.  If the leading
 706          nonzero digit is 1, we can't recover the original value
 707          reliably; so do this only if the digit is 2 or more.  This
 708          catches the common case of 32-bit negative time stamps.  */
 709       if ((overflow || maxval < value) && '2' <= *where1 && type)
 710         {
 711           /* Compute the negative of the input value, assuming two's
 712              complement.  */
 713           int digit = (*where1 - '0') | 4;
 714           overflow = 0;
 715           value = 0;
 716           where = where1;
 717           for (;;)
 718             {
 719               value += 7 - digit;
 720               where++;
 721               if (where == lim || ! ISODIGIT (*where))
 722                 break;
 723               digit = *where - '0';
 724               overflow |= value ^ (value << LG_8 >> LG_8);
 725               value <<= LG_8;
 726             }
 727           value++;
 728           overflow |= !value;
 729
 730           if (!overflow && value <= minus_minval)
 731             {
 732               if (!silent)
 733                 WARN ((0, 0,
 734                        /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
 735                        _("Archive octal value %.*s is out of %s range; assuming two's complement"),
 736                        (int) (where - where1), where1, type));
 737               negative = 1;
 738             }
 739         }
 740
 741       if (overflow)
 742         {
 743           if (type && !silent)
 744             ERROR ((0, 0,
 745                     /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
 746                     _("Archive octal value %.*s is out of %s range"),
 747                     (int) (where - where1), where1, type));
 748           return -1;
 749         }
 750     }
 751   else if (octal_only)
 752     {
 753       /* Suppress the following extensions.  */
 754     }
 755   else if (*where == '-' || *where == '+')
 756     {
 757       /* Parse base-64 output produced only by tar test versions
 758          1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
 759          Support for this will be withdrawn in future releases.  */
 760       int dig;
 761       if (!silent)
 762         {
 763           static bool warned_once;
 764           if (! warned_once)
 765             {
 766               warned_once = true;
 767               WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
 768             }
 769         }
 770       negative = *where++ == '-';
 771       while (where != lim
 772              && (dig = base64_map[(unsigned char) *where]) < 64)
 773         {
 774           if (value << LG_64 >> LG_64 != value)
 775             {
 776               char *string = alloca (digs + 1);
 777               memcpy (string, where0, digs);
 778               string[digs] = '\0';
 779               if (type && !silent)
 780                 ERROR ((0, 0,
 781                         _("Archive signed base-64 string %s is out of %s range"),
 782                         quote (string), type));
 783               return -1;
 784             }
 785           value = (value << LG_64) | dig;
 786           where++;
 787         }
 788     }
 789   else if (*where == '\200' /* positive base-256 */
 790            || *where == '\377' /* negative base-256 */)
 791     {
 792       /* Parse base-256 output.  A nonnegative number N is
 793          represented as (256**DIGS)/2 + N; a negative number -N is
 794          represented as (256**DIGS) - N, i.e. as two's complement.
 795          The representation guarantees that the leading bit is
 796          always on, so that we don't confuse this format with the
 797          others (assuming ASCII bytes of 8 bits or more).  */
 798       int signbit = *where & (1 << (LG_256 - 2));
 799       uintmax_t topbits = (((uintmax_t) - signbit)
 800                            << (CHAR_BIT * sizeof (uintmax_t)
 801                                - LG_256 - (LG_256 - 2)));
 802       value = (*where++ & ((1 << (LG_256 - 2)) - 1)) - signbit;
 803       for (;;)
 804         {
 805           value = (value << LG_256) + (unsigned char) *where++;
 806           if (where == lim)
 807             break;
 808           if (((value << LG_256 >> LG_256) | topbits) != value)
 809             {
 810               if (type && !silent)
 811                 ERROR ((0, 0,
 812                         _("Archive base-256 value is out of %s range"),
 813                         type));
 814               return -1;
 815             }
 816         }
 817       negative = signbit;
 818       if (negative)
 819         value = -value;
 820     }
 821
 822   if (where != lim && *where && !ISSPACE ((unsigned char) *where))
 823     {
 824       if (type)
 825         {
 826           char buf[1000]; /* Big enough to represent any header.  */
 827           static struct quoting_options *o;
 828
 829           if (!o)
 830             {
 831               o = clone_quoting_options (0);
 832               set_quoting_style (o, locale_quoting_style);
 833             }
 834
 835           while (where0 != lim && ! lim[-1])
 836             lim--;
 837           quotearg_buffer (buf, sizeof buf, where0, lim - where, o);
 838           if (!silent)
 839             ERROR ((0, 0,
 840                     /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
 841                     _("Archive contains %.*s where numeric %s value expected"),
 842                     (int) sizeof buf, buf, type));
 843         }
 844
 845       return -1;
 846     }
 847
 848   if (value <= (negative ? minus_minval : maxval))
 849     return negative ? -value : value;
 850
 851   if (type && !silent)
 852     {
 853       char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
 854       char maxval_buf[UINTMAX_STRSIZE_BOUND];
 855       char value_buf[UINTMAX_STRSIZE_BOUND + 1];
 856       char *minval_string = STRINGIFY_BIGINT (minus_minval, minval_buf + 1);
 857       char *value_string = STRINGIFY_BIGINT (value, value_buf + 1);
 858       if (negative)
 859         *--value_string = '-';
 860       if (minus_minval)
 861         *--minval_string = '-';
 862       /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
 863       ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
 864               value_string, type,
 865               minval_string, STRINGIFY_BIGINT (maxval, maxval_buf)));
 866     }
 867
 868   return -1;
 869 }
 870
 871 gid_t
 872 gid_from_header (const char *p, size_t s)
 873 {
 874   return from_header (p, s, "gid_t",
 875                       - (uintmax_t) TYPE_MINIMUM (gid_t),
 876                       (uintmax_t) TYPE_MAXIMUM (gid_t),
 877                       false, false);
 878 }
 879
 880 major_t
 881 major_from_header (const char *p, size_t s)
 882 {
 883   return from_header (p, s, "major_t",
 884                       - (uintmax_t) TYPE_MINIMUM (major_t),
 885                       (uintmax_t) TYPE_MAXIMUM (major_t), false, false);
 886 }
 887
 888 minor_t
 889 minor_from_header (const char *p, size_t s)
 890 {
 891   return from_header (p, s, "minor_t",
 892                       - (uintmax_t) TYPE_MINIMUM (minor_t),
 893                       (uintmax_t) TYPE_MAXIMUM (minor_t), false, false);
 894 }
 895
 896 mode_t
 897 mode_from_header (const char *p, size_t s)
 898 {
 899   /* Do not complain about unrecognized mode bits.  */
 900   unsigned u = from_header (p, s, "mode_t",
 901                             - (uintmax_t) TYPE_MINIMUM (mode_t),
 902                             TYPE_MAXIMUM (uintmax_t), false, false);
 903   return ((u & TSUID ? S_ISUID : 0)
 904           | (u & TSGID ? S_ISGID : 0)
 905           | (u & TSVTX ? S_ISVTX : 0)
 906           | (u & TUREAD ? S_IRUSR : 0)
 907           | (u & TUWRITE ? S_IWUSR : 0)
 908           | (u & TUEXEC ? S_IXUSR : 0)
 909           | (u & TGREAD ? S_IRGRP : 0)
 910           | (u & TGWRITE ? S_IWGRP : 0)
 911           | (u & TGEXEC ? S_IXGRP : 0)
 912           | (u & TOREAD ? S_IROTH : 0)
 913           | (u & TOWRITE ? S_IWOTH : 0)
 914           | (u & TOEXEC ? S_IXOTH : 0));
 915 }
 916
 917 off_t
 918 off_from_header (const char *p, size_t s)
 919 {
 920   /* Negative offsets are not allowed in tar files, so invoke
 921      from_header with minimum value 0, not TYPE_MINIMUM (off_t).  */
 922   return from_header (p, s, "off_t", (uintmax_t) 0,
 923                       (uintmax_t) TYPE_MAXIMUM (off_t), false, false);
 924 }
 925
 926 size_t
 927 size_from_header (const char *p, size_t s)
 928 {
 929   return from_header (p, s, "size_t", (uintmax_t) 0,
 930                       (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
 931 }
 932
 933 time_t
 934 time_from_header (const char *p, size_t s)
 935 {
 936   return from_header (p, s, "time_t",
 937                       - (uintmax_t) TYPE_MINIMUM (time_t),
 938                       (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
 939 }
 940
 941 uid_t
 942 uid_from_header (const char *p, size_t s)
 943 {
 944   return from_header (p, s, "uid_t",
 945                       - (uintmax_t) TYPE_MINIMUM (uid_t),
 946                       (uintmax_t) TYPE_MAXIMUM (uid_t), false, false);
 947 }
 948
 949 uintmax_t
 950 uintmax_from_header (const char *p, size_t s)
 951 {
 952   return from_header (p, s, "uintmax_t", (uintmax_t) 0,
 953                       TYPE_MAXIMUM (uintmax_t), false, false);
 954 }
 955
 956
 957 /* Return a printable representation of T.  The result points to
 958    static storage that can be reused in the next call to this
 959    function, to ctime, or to asctime.  If FULL_TIME, then output the
 960    time stamp to its full resolution; otherwise, just output it to
 961    1-minute resolution.  */
 962 char const *
 963 tartime (struct timespec t, bool full_time)
 964 {
 965   enum { fraclen = sizeof ".FFFFFFFFF" - 1 };
 966   static char buffer[max (UINTMAX_STRSIZE_BOUND + 1,
 967                           INT_STRLEN_BOUND (int) + 16)
 968                      + fraclen];
 969   struct tm *tm;
 970   time_t s = t.tv_sec;
 971   int ns = t.tv_nsec;
 972   bool negative = s < 0;
 973   char *p;
 974
 975   if (negative && ns != 0)
 976     {
 977       s++;
 978       ns = 1000000000 - ns;
 979     }
 980
 981   tm = utc_option ? gmtime (&s) : localtime (&s);
 982   if (tm)
 983     {
 984       if (full_time)
 985         {
 986           sprintf (buffer, "%04ld-%02d-%02d %02d:%02d:%02d",
 987                    tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
 988                    tm->tm_hour, tm->tm_min, tm->tm_sec);
 989           code_ns_fraction (ns, buffer + strlen (buffer));
 990         }
 991       else
 992         sprintf (buffer, "%04ld-%02d-%02d %02d:%02d",
 993                  tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
 994                  tm->tm_hour, tm->tm_min);
 995       return buffer;
 996     }
 997
 998   /* The time stamp cannot be broken down, most likely because it
 999      is out of range.  Convert it as an integer,
1000      right-adjusted in a field with the same width as the usual
1001      4-year ISO time format.  */
1002   p = umaxtostr (negative ? - (uintmax_t) s : s,
1003                  buffer + sizeof buffer - UINTMAX_STRSIZE_BOUND - fraclen);
1004   if (negative)
1005     *--p = '-';
1006   while ((buffer + sizeof buffer - sizeof "YYYY-MM-DD HH:MM"
1007           + (full_time ? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1008          < p)
1009     *--p = ' ';
1010   if (full_time)
1011     code_ns_fraction (ns, buffer + sizeof buffer - 1 - fraclen);
1012   return p;
1013 }
1014
1015 /* Actually print it.
1016
1017    Plain and fancy file header block logging.  Non-verbose just prints
1018    the name, e.g. for "tar t" or "tar x".  This should just contain
1019    file names, so it can be fed back into tar with xargs or the "-T"
1020    option.  The verbose option can give a bunch of info, one line per
1021    file.  I doubt anybody tries to parse its format, or if they do,
1022    they shouldn't.  Unix tar is pretty random here anyway.  */
1023
1024
1025 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
1026    HEAD_STANDARD, which must be set up in advance.  Not very clean..  */
1027
1028 /* Width of "user/group size", with initial value chosen
1029    heuristically.  This grows as needed, though this may cause some
1030    stairstepping in the output.  Make it too small and the output will
1031    almost always look ragged.  Make it too large and the output will
1032    be spaced out too far.  */
1033 static int ugswidth = 19;
1034
1035 /* Width of printed time stamps.  It grows if longer time stamps are
1036    found (typically, those with nanosecond resolution).  Like
1037    USGWIDTH, some stairstepping may occur.  */
1038 static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1;
1039
1040 void
1041 print_header (struct tar_stat_info *st, off_t block_ordinal)
1042 {
1043   char modes[11];
1044   char const *time_stamp;
1045   int time_stamp_len;
1046   char *temp_name;
1047
1048   /* These hold formatted ints.  */
1049   char uform[UINTMAX_STRSIZE_BOUND], gform[UINTMAX_STRSIZE_BOUND];
1050   char *user, *group;
1051   char size[2 * UINTMAX_STRSIZE_BOUND];
1052                                 /* holds formatted size or major,minor */
1053   char uintbuf[UINTMAX_STRSIZE_BOUND];
1054   int pad;
1055   int sizelen;
1056
1057   if (test_label_option && current_header->header.typeflag != GNUTYPE_VOLHDR)
1058     return;
1059
1060   if (show_transformed_names_option)
1061     temp_name = st->file_name ? st->file_name : st->orig_file_name;
1062   else
1063     temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
1064
1065   if (block_number_option)
1066     {
1067       char buf[UINTMAX_STRSIZE_BOUND];
1068       if (block_ordinal < 0)
1069         block_ordinal = current_block_ordinal ();
1070       block_ordinal -= recent_long_name_blocks;
1071       block_ordinal -= recent_long_link_blocks;
1072       fprintf (stdlis, _("block %s: "),
1073                STRINGIFY_BIGINT (block_ordinal, buf));
1074     }
1075
1076   if (verbose_option <= 1)
1077     {
1078       /* Just the fax, mam.  */
1079       fprintf (stdlis, "%s\n", quotearg (temp_name));
1080     }
1081   else
1082     {
1083       /* File type and modes.  */
1084
1085       modes[0] = '?';
1086       switch (current_header->header.typeflag)
1087         {
1088         case GNUTYPE_VOLHDR:
1089           modes[0] = 'V';
1090           break;
1091
1092         case GNUTYPE_MULTIVOL:
1093           modes[0] = 'M';
1094           break;
1095
1096         case GNUTYPE_LONGNAME:
1097         case GNUTYPE_LONGLINK:
1098           modes[0] = 'L';
1099           ERROR ((0, 0, _("Unexpected long name header")));
1100           break;
1101
1102         case GNUTYPE_SPARSE:
1103         case REGTYPE:
1104         case AREGTYPE:
1105           modes[0] = '-';
1106           if (temp_name[strlen (temp_name) - 1] == '/')
1107             modes[0] = 'd';
1108           break;
1109         case LNKTYPE:
1110           modes[0] = 'h';
1111           break;
1112         case GNUTYPE_DUMPDIR:
1113           modes[0] = 'd';
1114           break;
1115         case DIRTYPE:
1116           modes[0] = 'd';
1117           break;
1118         case SYMTYPE:
1119           modes[0] = 'l';
1120           break;
1121         case BLKTYPE:
1122           modes[0] = 'b';
1123           break;
1124         case CHRTYPE:
1125           modes[0] = 'c';
1126           break;
1127         case FIFOTYPE:
1128           modes[0] = 'p';
1129           break;
1130         case CONTTYPE:
1131           modes[0] = 'C';
1132           break;
1133         }
1134
1135       pax_decode_mode (st->stat.st_mode, modes + 1);
1136
1137       /* Time stamp.  */
1138
1139       time_stamp = tartime (st->mtime, false);
1140       time_stamp_len = strlen (time_stamp);
1141       if (datewidth < time_stamp_len)
1142         datewidth = time_stamp_len;
1143
1144       /* User and group names.  */
1145
1146       if (st->uname
1147           && st->uname[0]
1148           && current_format != V7_FORMAT
1149           && !numeric_owner_option)
1150         user = st->uname;
1151       else
1152         {
1153           /* Try parsing it as an unsigned integer first, and as a
1154              uid_t if that fails.  This method can list positive user
1155              ids that are too large to fit in a uid_t.  */
1156           uintmax_t u = from_header (current_header->header.uid,
1157                                      sizeof current_header->header.uid, 0,
1158                                      (uintmax_t) 0,
1159                                      (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1160                                      false, false);
1161           if (u != -1)
1162             user = STRINGIFY_BIGINT (u, uform);
1163           else
1164             {
1165               sprintf (uform, "%ld",
1166                        (long) UID_FROM_HEADER (current_header->header.uid));
1167               user = uform;
1168             }
1169         }
1170
1171       if (st->gname
1172           && st->gname[0]
1173           && current_format != V7_FORMAT
1174           && !numeric_owner_option)
1175         group = st->gname;
1176       else
1177         {
1178           /* Try parsing it as an unsigned integer first, and as a
1179              gid_t if that fails.  This method can list positive group
1180              ids that are too large to fit in a gid_t.  */
1181           uintmax_t g = from_header (current_header->header.gid,
1182                                      sizeof current_header->header.gid, 0,
1183                                      (uintmax_t) 0,
1184                                      (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1185                                      false, false);
1186           if (g != -1)
1187             group = STRINGIFY_BIGINT (g, gform);
1188           else
1189             {
1190               sprintf (gform, "%ld",
1191                        (long) GID_FROM_HEADER (current_header->header.gid));
1192               group = gform;
1193             }
1194         }
1195
1196       /* Format the file size or major/minor device numbers.  */
1197
1198       switch (current_header->header.typeflag)
1199         {
1200         case CHRTYPE:
1201         case BLKTYPE:
1202           strcpy (size,
1203                   STRINGIFY_BIGINT (major (st->stat.st_rdev), uintbuf));
1204           strcat (size, ",");
1205           strcat (size,
1206                   STRINGIFY_BIGINT (minor (st->stat.st_rdev), uintbuf));
1207           break;
1208
1209         default:
1210           /* st->stat.st_size keeps stored file size */
1211           strcpy (size, STRINGIFY_BIGINT (st->stat.st_size, uintbuf));
1212           break;
1213         }
1214
1215       /* Figure out padding and print the whole line.  */
1216
1217       sizelen = strlen (size);
1218       pad = strlen (user) + 1 + strlen (group) + 1 + sizelen;
1219       if (pad > ugswidth)
1220         ugswidth = pad;
1221
1222       fprintf (stdlis, "%s %s/%s %*s %-*s",
1223                modes, user, group, ugswidth - pad + sizelen, size,
1224                datewidth, time_stamp);
1225
1226       fprintf (stdlis, " %s", quotearg (temp_name));
1227
1228       switch (current_header->header.typeflag)
1229         {
1230         case SYMTYPE:
1231           fprintf (stdlis, " -> %s\n", quotearg (st->link_name));
1232           break;
1233
1234         case LNKTYPE:
1235           fprintf (stdlis, _(" link to %s\n"), quotearg (st->link_name));
1236           break;
1237
1238         default:
1239           {
1240             char type_string[2];
1241             type_string[0] = current_header->header.typeflag;
1242             type_string[1] = '\0';
1243             fprintf (stdlis, _(" unknown file type %s\n"),
1244                      quote (type_string));
1245           }
1246           break;
1247
1248         case AREGTYPE:
1249         case REGTYPE:
1250         case GNUTYPE_SPARSE:
1251         case CHRTYPE:
1252         case BLKTYPE:
1253         case DIRTYPE:
1254         case FIFOTYPE:
1255         case CONTTYPE:
1256         case GNUTYPE_DUMPDIR:
1257           putc ('\n', stdlis);
1258           break;
1259
1260         case GNUTYPE_LONGLINK:
1261           fprintf (stdlis, _("--Long Link--\n"));
1262           break;
1263
1264         case GNUTYPE_LONGNAME:
1265           fprintf (stdlis, _("--Long Name--\n"));
1266           break;
1267
1268         case GNUTYPE_VOLHDR:
1269           fprintf (stdlis, _("--Volume Header--\n"));
1270           break;
1271
1272         case GNUTYPE_MULTIVOL:
1273           strcpy (size,
1274                   STRINGIFY_BIGINT
1275                   (UINTMAX_FROM_HEADER (current_header->oldgnu_header.offset),
1276                    uintbuf));
1277           fprintf (stdlis, _("--Continued at byte %s--\n"), size);
1278           break;
1279         }
1280     }
1281   fflush (stdlis);
1282 }
1283
1284 /* Print a similar line when we make a directory automatically.  */
1285 void
1286 print_for_mkdir (char *dirname, int length, mode_t mode)
1287 {
1288   char modes[11];
1289
1290   if (verbose_option > 1)
1291     {
1292       /* File type and modes.  */
1293
1294       modes[0] = 'd';
1295       pax_decode_mode (mode, modes + 1);
1296
1297       if (block_number_option)
1298         {
1299           char buf[UINTMAX_STRSIZE_BOUND];
1300           fprintf (stdlis, _("block %s: "),
1301                    STRINGIFY_BIGINT (current_block_ordinal (), buf));
1302         }
1303
1304       fprintf (stdlis, "%s %*s %.*s\n", modes, ugswidth + 1 + datewidth,
1305                _("Creating directory:"), length, quotearg (dirname));
1306     }
1307 }
1308
1309 /* Skip over SIZE bytes of data in blocks in the archive.  */
1310 void
1311 skip_file (off_t size)
1312 {
1313   union block *x;
1314
1315   /* FIXME: Make sure mv_begin is always called before it */
1316
1317   if (seekable_archive)
1318     {
1319       off_t nblk = seek_archive (size);
1320       if (nblk >= 0)
1321         size -= nblk * BLOCKSIZE;
1322       else
1323         seekable_archive = false;
1324     }
1325
1326   mv_size_left (size);
1327
1328   while (size > 0)
1329     {
1330       x = find_next_block ();
1331       if (! x)
1332         FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1333
1334       set_next_block_after (x);
1335       size -= BLOCKSIZE;
1336       mv_size_left (size);
1337     }
1338 }
1339
1340 /* Skip the current member in the archive.
1341    NOTE: Current header must be decoded before calling this function. */
1342 void
1343 skip_member (void)
1344 {
1345   if (!current_stat_info.skipped)
1346     {
1347       char save_typeflag = current_header->header.typeflag;
1348       set_next_block_after (current_header);
1349
1350       mv_begin (&current_stat_info);
1351
1352       if (current_stat_info.is_sparse)
1353         sparse_skip_file (&current_stat_info);
1354       else if (save_typeflag != DIRTYPE)
1355         skip_file (current_stat_info.stat.st_size);
1356
1357       mv_end ();
1358     }
1359 }