1 /* List a tar archive, with support routines for reading a tar archive.
3 Copyright 1988, 1992-1994, 1996-2001, 2003-2007, 2010, 2012-2014 Free
4 Software Foundation, Inc.
6 This file is part of GNU tar.
8 GNU tar is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 GNU tar is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 Written by John Gilmore, on 1985-08-26. */
29 union block *current_header; /* points to current archive header */
30 enum archive_format current_format; /* recognized format */
31 union block *recent_long_name; /* recent long name header and contents */
32 union block *recent_long_link; /* likewise, for long link */
33 size_t recent_long_name_blocks; /* number of blocks in recent_long_name */
34 size_t recent_long_link_blocks; /* likewise, for long link */
35 static union block *recent_global_header; /* Recent global header block */
37 #define GID_FROM_HEADER(where) gid_from_header (where, sizeof (where))
38 #define MAJOR_FROM_HEADER(where) major_from_header (where, sizeof (where))
39 #define MINOR_FROM_HEADER(where) minor_from_header (where, sizeof (where))
40 #define MODE_FROM_HEADER(where, hbits) \
41 mode_from_header (where, sizeof (where), hbits)
42 #define TIME_FROM_HEADER(where) time_from_header (where, sizeof (where))
43 #define UID_FROM_HEADER(where) uid_from_header (where, sizeof (where))
45 static gid_t gid_from_header (const char *buf, size_t size);
46 static major_t major_from_header (const char *buf, size_t size);
47 static minor_t minor_from_header (const char *buf, size_t size);
48 static mode_t mode_from_header (const char *buf, size_t size, bool *hbits);
49 static time_t time_from_header (const char *buf, size_t size);
50 static uid_t uid_from_header (const char *buf, size_t size);
51 static intmax_t from_header (const char *, size_t, const char *,
52 intmax_t, uintmax_t, bool, bool);
54 /* Base 64 digits; see Internet RFC 2045 Table 1. */
55 static char const base_64_digits[64] =
57 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
58 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
59 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
60 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
61 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
64 /* Table of base-64 digit values indexed by unsigned chars.
65 The value is 64 for unsigned chars that are not base-64 digits. */
66 static char base64_map[UCHAR_MAX + 1];
72 memset (base64_map, 64, sizeof base64_map);
73 for (i = 0; i < 64; i++)
74 base64_map[(int) base_64_digits[i]] = i;
78 decode_xform (char *file_name, void *data)
80 int type = *(int*)data;
85 /* FIXME: It is not quite clear how and to which extent are the symbolic
86 links subject to filename transformation. In the absence of another
87 solution, symbolic links are exempt from component stripping and
88 name suffix normalization, but subject to filename transformation
93 file_name = safer_name_suffix (file_name, true, absolute_names_option);
97 file_name = safer_name_suffix (file_name, false, absolute_names_option);
101 if (strip_name_components)
103 size_t prefix_len = stripped_prefix_len (file_name,
104 strip_name_components);
105 if (prefix_len == (size_t) -1)
106 prefix_len = strlen (file_name);
107 file_name += prefix_len;
113 transform_member_name (char **pinput, int type)
115 return transform_name_fp (pinput, type, decode_xform, &type);
119 enforce_one_top_level (char **pfile_name)
121 char *file_name = *pfile_name;
124 for (p = file_name; *p && (ISSLASH (*p) || *p == '.'); p++)
130 if (strncmp (p, one_top_level_dir, strlen (one_top_level_dir)) == 0)
132 int pos = strlen (one_top_level_dir);
133 if (ISSLASH (p[pos]) || p[pos] == 0)
137 *pfile_name = new_name (one_top_level_dir, file_name);
138 normalize_filename_x (*pfile_name);
143 transform_stat_info (int typeflag, struct tar_stat_info *stat_info)
145 if (typeflag == GNUTYPE_VOLHDR)
146 /* Name transformations don't apply to volume headers. */
149 transform_member_name (&stat_info->file_name, XFORM_REGFILE);
153 transform_member_name (&stat_info->link_name, XFORM_SYMLINK);
157 transform_member_name (&stat_info->link_name, XFORM_LINK);
160 if (one_top_level_option)
161 enforce_one_top_level (¤t_stat_info.file_name);
164 /* Main loop for reading an archive. */
166 read_and (void (*do_something) (void))
168 enum read_header status = HEADER_STILL_UNREAD;
169 enum read_header prev_status;
170 struct timespec mtime;
175 open_archive (ACCESS_READ);
178 prev_status = status;
179 tar_stat_destroy (¤t_stat_info);
181 status = read_header (¤t_header, ¤t_stat_info,
185 case HEADER_STILL_UNREAD:
186 case HEADER_SUCCESS_EXTENDED:
191 /* Valid header. We should decode next field (mode) first.
192 Ensure incoming names are null terminated. */
193 decode_header (current_header, ¤t_stat_info,
195 if (! name_match (current_stat_info.file_name)
196 || (NEWER_OPTION_INITIALIZED (newer_mtime_option)
197 /* FIXME: We get mtime now, and again later; this causes
198 duplicate diagnostics if header.mtime is bogus. */
200 = TIME_FROM_HEADER (current_header->header.mtime)),
201 /* FIXME: Grab fractional time stamps from
204 current_stat_info.mtime = mtime,
205 OLDER_TAR_STAT_TIME (current_stat_info, m)))
206 || excluded_name (current_stat_info.file_name,
207 current_stat_info.parent))
209 switch (current_header->header.typeflag)
212 case GNUTYPE_MULTIVOL:
216 if (show_omitted_dirs_option)
217 WARN ((0, 0, _("%s: Omitting"),
218 quotearg_colon (current_stat_info.file_name)));
226 transform_stat_info (current_header->header.typeflag,
231 case HEADER_ZERO_BLOCK:
232 if (block_number_option)
234 char buf[UINTMAX_STRSIZE_BOUND];
235 fprintf (stdlis, _("block %s: ** Block of NULs **\n"),
236 STRINGIFY_BIGINT (current_block_ordinal (), buf));
239 set_next_block_after (current_header);
241 if (!ignore_zeros_option)
243 char buf[UINTMAX_STRSIZE_BOUND];
245 status = read_header (¤t_header, ¤t_stat_info,
247 if (status == HEADER_ZERO_BLOCK)
249 WARNOPT (WARN_ALONE_ZERO_BLOCK,
250 (0, 0, _("A lone zero block at %s"),
251 STRINGIFY_BIGINT (current_block_ordinal (), buf)));
254 status = prev_status;
257 case HEADER_END_OF_FILE:
258 if (block_number_option)
260 char buf[UINTMAX_STRSIZE_BOUND];
261 fprintf (stdlis, _("block %s: ** End of File **\n"),
262 STRINGIFY_BIGINT (current_block_ordinal (), buf));
267 /* If the previous header was good, tell them that we are
268 skipping bad ones. */
269 set_next_block_after (current_header);
272 case HEADER_STILL_UNREAD:
273 ERROR ((0, 0, _("This does not look like a tar archive")));
276 case HEADER_ZERO_BLOCK:
278 if (block_number_option)
280 char buf[UINTMAX_STRSIZE_BOUND];
281 off_t block_ordinal = current_block_ordinal ();
282 block_ordinal -= recent_long_name_blocks;
283 block_ordinal -= recent_long_link_blocks;
284 fprintf (stdlis, _("block %s: "),
285 STRINGIFY_BIGINT (block_ordinal, buf));
287 ERROR ((0, 0, _("Skipping to next header")));
290 case HEADER_END_OF_FILE:
292 /* We are in the middle of a cascade of errors. */
295 case HEADER_SUCCESS_EXTENDED:
302 while (!all_names_found (¤t_stat_info));
305 names_notfound (); /* print names not found */
308 /* Print a header block, based on tar options. */
312 off_t block_ordinal = current_block_ordinal ();
314 /* Print the header block. */
316 print_header (¤t_stat_info, current_header, block_ordinal);
318 if (incremental_option)
320 if (verbose_option > 2)
322 if (is_dumpdir (¤t_stat_info))
323 list_dumpdir (current_stat_info.dumpdir,
324 dumpdir_size (current_stat_info.dumpdir));
331 /* Check header checksum */
332 /* The standard BSD tar sources create the checksum by adding up the
333 bytes in the header as type char. I think the type char was unsigned
334 on the PDP-11, but it's signed on the Next and Sun. It looks like the
335 sources to BSD tar were never changed to compute the checksum
336 correctly, so both the Sun and Next add the bytes of the header as
337 signed chars. This doesn't cause a problem until you get a file with
338 a name containing characters with the high bit set. So tar_checksum
339 computes two checksums -- signed and unsigned. */
342 tar_checksum (union block *header, bool silent)
345 int unsigned_sum = 0; /* the POSIX one :-) */
346 int signed_sum = 0; /* the Sun one :-( */
352 for (i = sizeof *header; i-- != 0;)
354 unsigned_sum += (unsigned char) *p;
355 signed_sum += (signed char) (*p++);
358 if (unsigned_sum == 0)
359 return HEADER_ZERO_BLOCK;
361 /* Adjust checksum to count the "chksum" field as blanks. */
363 for (i = sizeof header->header.chksum; i-- != 0;)
365 unsigned_sum -= (unsigned char) header->header.chksum[i];
366 signed_sum -= (signed char) (header->header.chksum[i]);
368 unsigned_sum += ' ' * sizeof header->header.chksum;
369 signed_sum += ' ' * sizeof header->header.chksum;
371 parsed_sum = from_header (header->header.chksum,
372 sizeof header->header.chksum, 0,
373 0, INT_MAX, true, silent);
375 return HEADER_FAILURE;
377 recorded_sum = parsed_sum;
379 if (unsigned_sum != recorded_sum && signed_sum != recorded_sum)
380 return HEADER_FAILURE;
382 return HEADER_SUCCESS;
385 /* Read a block that's supposed to be a header block. Return its
386 address in *RETURN_BLOCK, and if it is good, the file's size
387 and names (file name, link name) in *INFO.
389 Return one of enum read_header describing the status of the
392 The MODE parameter instructs read_header what to do with special
393 header blocks, i.e.: extended POSIX, GNU long name or long link,
396 read_header_auto process them automatically,
397 read_header_x_raw when a special header is read, return
398 HEADER_SUCCESS_EXTENDED without actually
399 processing the header,
400 read_header_x_global when a POSIX global header is read,
401 decode it and return HEADER_SUCCESS_EXTENDED.
403 You must always set_next_block_after(*return_block) to skip past
404 the header which this routine reads. */
407 read_header (union block **return_block, struct tar_stat_info *info,
408 enum read_header_mode mode)
411 union block *header_copy;
413 union block *data_block;
414 size_t size, written;
415 union block *next_long_name = 0;
416 union block *next_long_link = 0;
417 size_t next_long_name_blocks = 0;
418 size_t next_long_link_blocks = 0;
422 enum read_header status;
424 header = find_next_block ();
425 *return_block = header;
427 return HEADER_END_OF_FILE;
429 if ((status = tar_checksum (header, false)) != HEADER_SUCCESS)
432 /* Good block. Decode file size and return. */
434 if (header->header.typeflag == LNKTYPE)
435 info->stat.st_size = 0; /* links 0 size on tape */
438 info->stat.st_size = OFF_FROM_HEADER (header->header.size);
439 if (info->stat.st_size < 0)
440 return HEADER_FAILURE;
443 if (header->header.typeflag == GNUTYPE_LONGNAME
444 || header->header.typeflag == GNUTYPE_LONGLINK
445 || header->header.typeflag == XHDTYPE
446 || header->header.typeflag == XGLTYPE
447 || header->header.typeflag == SOLARIS_XHDTYPE)
449 if (mode == read_header_x_raw)
450 return HEADER_SUCCESS_EXTENDED;
451 else if (header->header.typeflag == GNUTYPE_LONGNAME
452 || header->header.typeflag == GNUTYPE_LONGLINK)
454 size_t name_size = info->stat.st_size;
455 size_t n = name_size % BLOCKSIZE;
456 size = name_size + BLOCKSIZE;
458 size += BLOCKSIZE - n;
460 if (name_size != info->stat.st_size || size < name_size)
463 header_copy = xmalloc (size + 1);
465 if (header->header.typeflag == GNUTYPE_LONGNAME)
467 free (next_long_name);
468 next_long_name = header_copy;
469 next_long_name_blocks = size / BLOCKSIZE;
473 free (next_long_link);
474 next_long_link = header_copy;
475 next_long_link_blocks = size / BLOCKSIZE;
478 set_next_block_after (header);
479 *header_copy = *header;
480 bp = header_copy->buffer + BLOCKSIZE;
482 for (size -= BLOCKSIZE; size > 0; size -= written)
484 data_block = find_next_block ();
487 ERROR ((0, 0, _("Unexpected EOF in archive")));
490 written = available_space_after (data_block);
494 memcpy (bp, data_block->buffer, written);
496 set_next_block_after ((union block *)
497 (data_block->buffer + written - 1));
502 else if (header->header.typeflag == XHDTYPE
503 || header->header.typeflag == SOLARIS_XHDTYPE)
504 xheader_read (&info->xhdr, header,
505 OFF_FROM_HEADER (header->header.size));
506 else if (header->header.typeflag == XGLTYPE)
510 if (!recent_global_header)
511 recent_global_header = xmalloc (sizeof *recent_global_header);
512 memcpy (recent_global_header, header,
513 sizeof *recent_global_header);
514 memset (&xhdr, 0, sizeof xhdr);
515 xheader_read (&xhdr, header,
516 OFF_FROM_HEADER (header->header.size));
517 xheader_decode_global (&xhdr);
518 xheader_destroy (&xhdr);
519 if (mode == read_header_x_global)
520 return HEADER_SUCCESS_EXTENDED;
529 struct posix_header const *h = &header->header;
530 char namebuf[sizeof h->prefix + 1 + NAME_FIELD_SIZE + 1];
532 free (recent_long_name);
536 name = next_long_name->buffer + BLOCKSIZE;
537 recent_long_name = next_long_name;
538 recent_long_name_blocks = next_long_name_blocks;
542 /* Accept file names as specified by POSIX.1-1996
546 if (h->prefix[0] && strcmp (h->magic, TMAGIC) == 0)
548 memcpy (np, h->prefix, sizeof h->prefix);
549 np[sizeof h->prefix] = '\0';
553 memcpy (np, h->name, sizeof h->name);
554 np[sizeof h->name] = '\0';
556 recent_long_name = 0;
557 recent_long_name_blocks = 0;
559 assign_string (&info->orig_file_name, name);
560 assign_string (&info->file_name, name);
561 info->had_trailing_slash = strip_trailing_slashes (info->file_name);
563 free (recent_long_link);
567 name = next_long_link->buffer + BLOCKSIZE;
568 recent_long_link = next_long_link;
569 recent_long_link_blocks = next_long_link_blocks;
573 memcpy (namebuf, h->linkname, sizeof h->linkname);
574 namebuf[sizeof h->linkname] = '\0';
576 recent_long_link = 0;
577 recent_long_link_blocks = 0;
579 assign_string (&info->link_name, name);
581 return HEADER_SUCCESS;
586 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
588 /* Decode things from a file HEADER block into STAT_INFO, also setting
589 *FORMAT_POINTER depending on the header block format. If
590 DO_USER_GROUP, decode the user/group information (this is useful
591 for extraction, but waste time when merely listing).
593 read_header() has already decoded the checksum and length, so we don't.
595 This routine should *not* be called twice for the same block, since
596 the two calls might use different DO_USER_GROUP values and thus
597 might end up with different uid/gid for the two calls. If anybody
598 wants the uid/gid they should decode it first, and other callers
599 should decode it without uid/gid before calling a routine,
600 e.g. print_header, that assumes decoded data. */
602 decode_header (union block *header, struct tar_stat_info *stat_info,
603 enum archive_format *format_pointer, int do_user_group)
605 enum archive_format format;
607 mode_t mode = MODE_FROM_HEADER (header->header.mode, &hbits);
609 if (strcmp (header->header.magic, TMAGIC) == 0)
611 if (header->star_header.prefix[130] == 0
612 && ISOCTAL (header->star_header.atime[0])
613 && header->star_header.atime[11] == ' '
614 && ISOCTAL (header->star_header.ctime[0])
615 && header->star_header.ctime[11] == ' ')
616 format = STAR_FORMAT;
617 else if (stat_info->xhdr.size)
618 format = POSIX_FORMAT;
620 format = USTAR_FORMAT;
622 else if (strcmp (header->buffer + offsetof (struct posix_header, magic),
625 format = hbits ? OLDGNU_FORMAT : GNU_FORMAT;
628 *format_pointer = format;
630 stat_info->stat.st_mode = mode;
631 stat_info->mtime.tv_sec = TIME_FROM_HEADER (header->header.mtime);
632 stat_info->mtime.tv_nsec = 0;
633 assign_string (&stat_info->uname,
634 header->header.uname[0] ? header->header.uname : NULL);
635 assign_string (&stat_info->gname,
636 header->header.gname[0] ? header->header.gname : NULL);
638 xheader_xattr_init (stat_info);
640 if (format == OLDGNU_FORMAT && incremental_option)
642 stat_info->atime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.atime);
643 stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.ctime);
644 stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
646 else if (format == STAR_FORMAT)
648 stat_info->atime.tv_sec = TIME_FROM_HEADER (header->star_header.atime);
649 stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->star_header.ctime);
650 stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
653 stat_info->atime = stat_info->ctime = start_time;
655 if (format == V7_FORMAT)
657 stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
658 stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
659 stat_info->stat.st_rdev = 0;
665 /* FIXME: Decide if this should somewhat depend on -p. */
667 if (numeric_owner_option
668 || !*header->header.uname
669 || !uname_to_uid (header->header.uname, &stat_info->stat.st_uid))
670 stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
672 if (numeric_owner_option
673 || !*header->header.gname
674 || !gname_to_gid (header->header.gname, &stat_info->stat.st_gid))
675 stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
678 switch (header->header.typeflag)
682 stat_info->stat.st_rdev =
683 makedev (MAJOR_FROM_HEADER (header->header.devmajor),
684 MINOR_FROM_HEADER (header->header.devminor));
688 stat_info->stat.st_rdev = 0;
692 stat_info->archive_file_size = stat_info->stat.st_size;
693 xheader_decode (stat_info);
695 if (sparse_member_p (stat_info))
697 sparse_fixup_header (stat_info);
698 stat_info->is_sparse = true;
702 stat_info->is_sparse = false;
703 if (((current_format == GNU_FORMAT
704 || current_format == OLDGNU_FORMAT)
705 && current_header->header.typeflag == GNUTYPE_DUMPDIR)
706 || stat_info->dumpdir)
707 stat_info->is_dumpdir = true;
712 /* Convert buffer at WHERE0 of size DIGS from external format to
713 intmax_t. DIGS must be positive. If TYPE is nonnull, the data are
714 of type TYPE. The buffer must represent a value in the range
715 MINVAL through MAXVAL; if the mathematically correct result V would
716 be greater than INTMAX_MAX, return a negative integer V such that
717 (uintmax_t) V yields the correct result. If OCTAL_ONLY, allow only octal
718 numbers instead of the other GNU extensions. Return -1 on error,
719 diagnosing the error if TYPE is nonnull and if !SILENT. */
720 #if ! (INTMAX_MAX <= UINTMAX_MAX && - (INTMAX_MIN + 1) <= UINTMAX_MAX)
721 # error "from_header internally represents intmax_t as uintmax_t + sign"
723 #if ! (UINTMAX_MAX / 2 <= INTMAX_MAX)
724 # error "from_header returns intmax_t to represent uintmax_t"
727 from_header (char const *where0, size_t digs, char const *type,
728 intmax_t minval, uintmax_t maxval,
729 bool octal_only, bool silent)
732 uintmax_t uminval = minval;
733 uintmax_t minus_minval = - uminval;
734 char const *where = where0;
735 char const *lim = where + digs;
736 bool negative = false;
738 /* Accommodate buggy tar of unknown vintage, which outputs leading
739 NUL if the previous field overflows. */
742 /* Accommodate older tars, which output leading spaces. */
749 /* TRANSLATORS: %s is type of the value (gid_t, uid_t,
751 _("Blanks in header where numeric %s value expected"),
755 if (!isspace ((unsigned char) *where))
761 if (ISODIGIT (*where))
763 char const *where1 = where;
764 bool overflow = false;
768 value += *where++ - '0';
769 if (where == lim || ! ISODIGIT (*where))
771 overflow |= value != (value << LG_8 >> LG_8);
775 /* Parse the output of older, unportable tars, which generate
776 negative values in two's complement octal. If the leading
777 nonzero digit is 1, we can't recover the original value
778 reliably; so do this only if the digit is 2 or more. This
779 catches the common case of 32-bit negative time stamps. */
780 if ((overflow || maxval < value) && '2' <= *where1 && type)
782 /* Compute the negative of the input value, assuming two's
784 int digit = (*where1 - '0') | 4;
792 if (where == lim || ! ISODIGIT (*where))
794 digit = *where - '0';
795 overflow |= value != (value << LG_8 >> LG_8);
801 if (!overflow && value <= minus_minval)
805 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
806 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
807 (int) (where - where1), where1, type));
816 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
817 _("Archive octal value %.*s is out of %s range"),
818 (int) (where - where1), where1, type));
824 /* Suppress the following extensions. */
826 else if (*where == '-' || *where == '+')
828 /* Parse base-64 output produced only by tar test versions
829 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
830 Support for this will be withdrawn in future releases. */
834 static bool warned_once;
838 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
841 negative = *where++ == '-';
843 && (dig = base64_map[(unsigned char) *where]) < 64)
845 if (value << LG_64 >> LG_64 != value)
847 char *string = alloca (digs + 1);
848 memcpy (string, where0, digs);
852 _("Archive signed base-64 string %s is out of %s range"),
853 quote (string), type));
856 value = (value << LG_64) | dig;
860 else if (*where == '\200' /* positive base-256 */
861 || *where == '\377' /* negative base-256 */)
863 /* Parse base-256 output. A nonnegative number N is
864 represented as (256**DIGS)/2 + N; a negative number -N is
865 represented as (256**DIGS) - N, i.e. as two's complement.
866 The representation guarantees that the leading bit is
867 always on, so that we don't confuse this format with the
868 others (assuming ASCII bytes of 8 bits or more). */
869 int signbit = *where & (1 << (LG_256 - 2));
870 uintmax_t topbits = (((uintmax_t) - signbit)
871 << (CHAR_BIT * sizeof (uintmax_t)
872 - LG_256 - (LG_256 - 2)));
873 value = (*where++ & ((1 << (LG_256 - 2)) - 1)) - signbit;
876 value = (value << LG_256) + (unsigned char) *where++;
879 if (((value << LG_256 >> LG_256) | topbits) != value)
883 _("Archive base-256 value is out of %s range"),
888 negative = signbit != 0;
893 if (where != lim && *where && !isspace ((unsigned char) *where))
897 char buf[1000]; /* Big enough to represent any header. */
898 static struct quoting_options *o;
902 o = clone_quoting_options (0);
903 set_quoting_style (o, locale_quoting_style);
906 while (where0 != lim && ! lim[-1])
908 quotearg_buffer (buf, sizeof buf, where0, lim - where0, o);
911 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
912 _("Archive contains %.*s where numeric %s value expected"),
913 (int) sizeof buf, buf, type));
919 if (value <= (negative ? minus_minval : maxval))
920 return represent_uintmax (negative ? -value : value);
924 char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
925 char maxval_buf[UINTMAX_STRSIZE_BOUND];
926 char value_buf[UINTMAX_STRSIZE_BOUND + 1];
927 char *minval_string = STRINGIFY_BIGINT (minus_minval, minval_buf + 1);
928 char *value_string = STRINGIFY_BIGINT (value, value_buf + 1);
930 *--value_string = '-';
932 *--minval_string = '-';
933 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
934 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
936 minval_string, STRINGIFY_BIGINT (maxval, maxval_buf)));
943 gid_from_header (const char *p, size_t s)
945 return from_header (p, s, "gid_t",
946 TYPE_MINIMUM (gid_t), TYPE_MAXIMUM (gid_t),
951 major_from_header (const char *p, size_t s)
953 return from_header (p, s, "major_t",
954 TYPE_MINIMUM (major_t), TYPE_MAXIMUM (major_t),
959 minor_from_header (const char *p, size_t s)
961 return from_header (p, s, "minor_t",
962 TYPE_MINIMUM (minor_t), TYPE_MAXIMUM (minor_t),
966 /* Convert P to the file mode, as understood by tar.
967 Set *HBITS if there are any unrecognized bits. */
969 mode_from_header (const char *p, size_t s, bool *hbits)
971 intmax_t u = from_header (p, s, "mode_t",
972 INTMAX_MIN, UINTMAX_MAX,
974 mode_t mode = ((u & TSUID ? S_ISUID : 0)
975 | (u & TSGID ? S_ISGID : 0)
976 | (u & TSVTX ? S_ISVTX : 0)
977 | (u & TUREAD ? S_IRUSR : 0)
978 | (u & TUWRITE ? S_IWUSR : 0)
979 | (u & TUEXEC ? S_IXUSR : 0)
980 | (u & TGREAD ? S_IRGRP : 0)
981 | (u & TGWRITE ? S_IWGRP : 0)
982 | (u & TGEXEC ? S_IXGRP : 0)
983 | (u & TOREAD ? S_IROTH : 0)
984 | (u & TOWRITE ? S_IWOTH : 0)
985 | (u & TOEXEC ? S_IXOTH : 0));
986 *hbits = (u & ~07777) != 0;
991 off_from_header (const char *p, size_t s)
993 /* Negative offsets are not allowed in tar files, so invoke
994 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
995 return from_header (p, s, "off_t",
996 0, TYPE_MAXIMUM (off_t),
1001 time_from_header (const char *p, size_t s)
1003 return from_header (p, s, "time_t",
1004 TYPE_MINIMUM (time_t), TYPE_MAXIMUM (time_t),
1009 uid_from_header (const char *p, size_t s)
1011 return from_header (p, s, "uid_t",
1012 TYPE_MINIMUM (uid_t), TYPE_MAXIMUM (uid_t),
1017 uintmax_from_header (const char *p, size_t s)
1019 return from_header (p, s, "uintmax_t", 0, UINTMAX_MAX, false, false);
1023 /* Return a printable representation of T. The result points to
1024 static storage that can be reused in the next call to this
1025 function, to ctime, or to asctime. If FULL_TIME, then output the
1026 time stamp to its full resolution; otherwise, just output it to
1027 1-minute resolution. */
1029 tartime (struct timespec t, bool full_time)
1031 enum { fraclen = sizeof ".FFFFFFFFF" - 1 };
1032 static char buffer[max (UINTMAX_STRSIZE_BOUND + 1,
1033 INT_STRLEN_BOUND (int) + 16)
1036 time_t s = t.tv_sec;
1038 bool negative = s < 0;
1041 if (negative && ns != 0)
1044 ns = 1000000000 - ns;
1047 tm = utc_option ? gmtime (&s) : localtime (&s);
1052 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d:%02d",
1053 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
1054 tm->tm_hour, tm->tm_min, tm->tm_sec);
1055 code_ns_fraction (ns, buffer + strlen (buffer));
1058 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d",
1059 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
1060 tm->tm_hour, tm->tm_min);
1064 /* The time stamp cannot be broken down, most likely because it
1065 is out of range. Convert it as an integer,
1066 right-adjusted in a field with the same width as the usual
1067 4-year ISO time format. */
1068 p = umaxtostr (negative ? - (uintmax_t) s : s,
1069 buffer + sizeof buffer - UINTMAX_STRSIZE_BOUND - fraclen);
1072 while ((buffer + sizeof buffer - sizeof "YYYY-MM-DD HH:MM"
1073 + (full_time ? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1077 code_ns_fraction (ns, buffer + sizeof buffer - 1 - fraclen);
1081 /* Actually print it.
1083 Plain and fancy file header block logging. Non-verbose just prints
1084 the name, e.g. for "tar t" or "tar x". This should just contain
1085 file names, so it can be fed back into tar with xargs or the "-T"
1086 option. The verbose option can give a bunch of info, one line per
1087 file. I doubt anybody tries to parse its format, or if they do,
1088 they shouldn't. Unix tar is pretty random here anyway. */
1091 /* Width of "user/group size", with initial value chosen
1092 heuristically. This grows as needed, though this may cause some
1093 stairstepping in the output. Make it too small and the output will
1094 almost always look ragged. Make it too large and the output will
1095 be spaced out too far. */
1096 static int ugswidth = 19;
1098 /* Width of printed time stamps. It grows if longer time stamps are
1099 found (typically, those with nanosecond resolution). Like
1100 USGWIDTH, some stairstepping may occur. */
1101 static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1;
1103 static bool volume_label_printed = false;
1106 simple_print_header (struct tar_stat_info *st, union block *blk,
1107 off_t block_ordinal)
1110 char const *time_stamp;
1114 /* These hold formatted ints. */
1115 char uform[max (INT_BUFSIZE_BOUND (intmax_t), UINTMAX_STRSIZE_BOUND)];
1116 char gform[sizeof uform];
1118 char size[2 * UINTMAX_STRSIZE_BOUND];
1119 /* holds formatted size or major,minor */
1120 char uintbuf[UINTMAX_STRSIZE_BOUND];
1124 if (show_transformed_names_option)
1125 temp_name = st->file_name ? st->file_name : st->orig_file_name;
1127 temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
1129 if (block_number_option)
1131 char buf[UINTMAX_STRSIZE_BOUND];
1132 if (block_ordinal < 0)
1133 block_ordinal = current_block_ordinal ();
1134 block_ordinal -= recent_long_name_blocks;
1135 block_ordinal -= recent_long_link_blocks;
1136 fprintf (stdlis, _("block %s: "),
1137 STRINGIFY_BIGINT (block_ordinal, buf));
1140 if (verbose_option <= 1)
1142 /* Just the fax, mam. */
1143 fputs (quotearg (temp_name), stdlis);
1144 if (show_transformed_names_option && st->had_trailing_slash)
1145 fputc ('/', stdlis);
1146 fputc ('\n', stdlis);
1150 /* File type and modes. */
1153 switch (blk->header.typeflag)
1155 case GNUTYPE_VOLHDR:
1156 volume_label_printed = true;
1160 case GNUTYPE_MULTIVOL:
1164 case GNUTYPE_LONGNAME:
1165 case GNUTYPE_LONGLINK:
1167 ERROR ((0, 0, _("Unexpected long name header")));
1170 case GNUTYPE_SPARSE:
1173 modes[0] = st->had_trailing_slash ? 'd' : '-';
1178 case GNUTYPE_DUMPDIR:
1201 pax_decode_mode (st->stat.st_mode, modes + 1);
1203 /* extended attributes: GNU `ls -l'-like preview */
1204 xattrs_print_char (st, modes + 10);
1208 time_stamp = tartime (st->mtime, full_time_option);
1209 time_stamp_len = strlen (time_stamp);
1210 if (datewidth < time_stamp_len)
1211 datewidth = time_stamp_len;
1213 /* User and group names. */
1217 && current_format != V7_FORMAT
1218 && !numeric_owner_option)
1222 /* Try parsing it as an unsigned integer first, and as a
1223 uid_t if that fails. This method can list positive user
1224 ids that are too large to fit in a uid_t. */
1225 uintmax_t u = from_header (blk->header.uid,
1226 sizeof blk->header.uid, 0,
1230 ? STRINGIFY_BIGINT (u, uform)
1231 : imaxtostr (UID_FROM_HEADER (blk->header.uid), uform));
1236 && current_format != V7_FORMAT
1237 && !numeric_owner_option)
1241 /* Try parsing it as an unsigned integer first, and as a
1242 gid_t if that fails. This method can list positive group
1243 ids that are too large to fit in a gid_t. */
1244 uintmax_t g = from_header (blk->header.gid,
1245 sizeof blk->header.gid, 0,
1249 ? STRINGIFY_BIGINT (g, gform)
1250 : imaxtostr (GID_FROM_HEADER (blk->header.gid), gform));
1253 /* Format the file size or major/minor device numbers. */
1255 switch (blk->header.typeflag)
1260 STRINGIFY_BIGINT (major (st->stat.st_rdev), uintbuf));
1263 STRINGIFY_BIGINT (minor (st->stat.st_rdev), uintbuf));
1267 /* st->stat.st_size keeps stored file size */
1268 strcpy (size, STRINGIFY_BIGINT (st->stat.st_size, uintbuf));
1272 /* Figure out padding and print the whole line. */
1274 sizelen = strlen (size);
1275 pad = strlen (user) + 1 + strlen (group) + 1 + sizelen;
1279 fprintf (stdlis, "%s %s/%s %*s %-*s",
1280 modes, user, group, ugswidth - pad + sizelen, size,
1281 datewidth, time_stamp);
1283 fprintf (stdlis, " %s", quotearg (temp_name));
1284 if (show_transformed_names_option && st->had_trailing_slash)
1285 fputc ('/', stdlis);
1287 switch (blk->header.typeflag)
1290 fprintf (stdlis, " -> %s\n", quotearg (st->link_name));
1294 fprintf (stdlis, _(" link to %s\n"), quotearg (st->link_name));
1299 char type_string[2];
1300 type_string[0] = blk->header.typeflag;
1301 type_string[1] = '\0';
1302 fprintf (stdlis, _(" unknown file type %s\n"),
1303 quote (type_string));
1309 case GNUTYPE_SPARSE:
1315 case GNUTYPE_DUMPDIR:
1316 putc ('\n', stdlis);
1319 case GNUTYPE_LONGLINK:
1320 fprintf (stdlis, _("--Long Link--\n"));
1323 case GNUTYPE_LONGNAME:
1324 fprintf (stdlis, _("--Long Name--\n"));
1327 case GNUTYPE_VOLHDR:
1328 fprintf (stdlis, _("--Volume Header--\n"));
1331 case GNUTYPE_MULTIVOL:
1334 (UINTMAX_FROM_HEADER (blk->oldgnu_header.offset),
1336 fprintf (stdlis, _("--Continued at byte %s--\n"), size);
1346 print_volume_label (void)
1348 struct tar_stat_info vstat;
1350 enum archive_format dummy;
1352 memset (&vblk, 0, sizeof (vblk));
1353 vblk.header.typeflag = GNUTYPE_VOLHDR;
1354 if (recent_global_header)
1355 memcpy (vblk.header.mtime, recent_global_header->header.mtime,
1356 sizeof vblk.header.mtime);
1357 tar_stat_init (&vstat);
1358 assign_string (&vstat.file_name, ".");
1359 decode_header (&vblk, &vstat, &dummy, 0);
1360 assign_string (&vstat.file_name, volume_label);
1361 simple_print_header (&vstat, &vblk, 0);
1362 tar_stat_destroy (&vstat);
1366 print_header (struct tar_stat_info *st, union block *blk,
1367 off_t block_ordinal)
1369 if (current_format == POSIX_FORMAT && !volume_label_printed && volume_label)
1371 print_volume_label ();
1372 volume_label_printed = true;
1375 simple_print_header (st, blk, block_ordinal);
1378 /* Print a similar line when we make a directory automatically. */
1380 print_for_mkdir (char *dirname, int length, mode_t mode)
1384 if (verbose_option > 1)
1386 /* File type and modes. */
1389 pax_decode_mode (mode, modes + 1);
1391 if (block_number_option)
1393 char buf[UINTMAX_STRSIZE_BOUND];
1394 fprintf (stdlis, _("block %s: "),
1395 STRINGIFY_BIGINT (current_block_ordinal (), buf));
1398 fprintf (stdlis, "%s %*s %s\n", modes, ugswidth + 1 + datewidth,
1399 _("Creating directory:"), quotearg (dirname));
1403 /* Skip over SIZE bytes of data in blocks in the archive. */
1405 skip_file (off_t size)
1409 /* FIXME: Make sure mv_begin_read is always called before it */
1411 if (seekable_archive)
1413 off_t nblk = seek_archive (size);
1415 size -= nblk * BLOCKSIZE;
1417 seekable_archive = false;
1420 mv_size_left (size);
1424 x = find_next_block ();
1426 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1428 set_next_block_after (x);
1430 mv_size_left (size);
1434 /* Skip the current member in the archive.
1435 NOTE: Current header must be decoded before calling this function. */
1439 if (!current_stat_info.skipped)
1441 char save_typeflag = current_header->header.typeflag;
1442 set_next_block_after (current_header);
1444 mv_begin_read (¤t_stat_info);
1446 if (current_stat_info.is_sparse)
1447 sparse_skip_file (¤t_stat_info);
1448 else if (save_typeflag != DIRTYPE)
1449 skip_file (current_stat_info.stat.st_size);
1456 test_archive_label (void)
1461 open_archive (ACCESS_READ);
1462 if (read_header (¤t_header, ¤t_stat_info, read_header_auto)
1465 decode_header (current_header,
1466 ¤t_stat_info, ¤t_format, 0);
1467 if (current_header->header.typeflag == GNUTYPE_VOLHDR)
1468 assign_string (&volume_label, current_header->header.name);
1473 print_volume_label ();
1474 if (!name_match (volume_label) && multi_volume_option)
1476 char *s = drop_volume_label_suffix (volume_label);