1 /* List a tar archive, with support routines for reading a tar archive.
3 Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,
4 2001, 2003, 2004, 2005, 2006, 2007, 2010 Free Software Foundation, Inc.
6 Written by John Gilmore, on 1985-08-26.
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
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.
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. */
28 #define max(a, b) ((a) < (b) ? (b) : (a))
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 union block *recent_global_header; /* Recent global header block */
38 static uintmax_t from_header (const char *, size_t, const char *,
39 uintmax_t, uintmax_t, bool, bool);
41 /* Base 64 digits; see Internet RFC 2045 Table 1. */
42 static char const base_64_digits[64] =
44 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
45 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
46 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
47 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
48 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
51 /* Table of base-64 digit values indexed by unsigned chars.
52 The value is 64 for unsigned chars that are not base-64 digits. */
53 static char base64_map[UCHAR_MAX + 1];
59 memset (base64_map, 64, sizeof base64_map);
60 for (i = 0; i < 64; i++)
61 base64_map[(int) base_64_digits[i]] = i;
64 /* Main loop for reading an archive. */
66 read_and (void (*do_something) (void))
68 enum read_header status = HEADER_STILL_UNREAD;
69 enum read_header prev_status;
70 struct timespec mtime;
75 open_archive (ACCESS_READ);
79 tar_stat_destroy (¤t_stat_info);
81 status = read_header (¤t_header, ¤t_stat_info,
85 case HEADER_STILL_UNREAD:
86 case HEADER_SUCCESS_EXTENDED:
91 /* Valid header. We should decode next field (mode) first.
92 Ensure incoming names are null terminated. */
94 if (! name_match (current_stat_info.file_name)
95 || (NEWER_OPTION_INITIALIZED (newer_mtime_option)
96 /* FIXME: We get mtime now, and again later; this causes
97 duplicate diagnostics if header.mtime is bogus. */
99 = TIME_FROM_HEADER (current_header->header.mtime)),
100 /* FIXME: Grab fractional time stamps from
103 current_stat_info.mtime = mtime,
104 OLDER_TAR_STAT_TIME (current_stat_info, m)))
105 || excluded_name (current_stat_info.file_name))
107 switch (current_header->header.typeflag)
110 case GNUTYPE_MULTIVOL:
114 if (show_omitted_dirs_option)
115 WARN ((0, 0, _("%s: Omitting"),
116 quotearg_colon (current_stat_info.file_name)));
119 decode_header (current_header,
120 ¤t_stat_info, ¤t_format, 0);
129 case HEADER_ZERO_BLOCK:
130 if (block_number_option)
132 char buf[UINTMAX_STRSIZE_BOUND];
133 fprintf (stdlis, _("block %s: ** Block of NULs **\n"),
134 STRINGIFY_BIGINT (current_block_ordinal (), buf));
137 set_next_block_after (current_header);
139 if (!ignore_zeros_option)
141 char buf[UINTMAX_STRSIZE_BOUND];
143 status = read_header (¤t_header, ¤t_stat_info,
145 if (status == HEADER_ZERO_BLOCK)
148 * According to POSIX tar specs, this is wrong, but on the web
149 * there are some tar specs that can trigger this, and some tar
150 * implementations create tars according to that spec. For now,
151 * let's not be pedantic about issuing the warning.
154 WARNOPT (WARN_ALONE_ZERO_BLOCK,
155 (0, 0, _("A lone zero block at %s"),
156 STRINGIFY_BIGINT (current_block_ordinal (), buf)));
160 status = prev_status;
163 case HEADER_END_OF_FILE:
164 if (block_number_option)
166 char buf[UINTMAX_STRSIZE_BOUND];
167 fprintf (stdlis, _("block %s: ** End of File **\n"),
168 STRINGIFY_BIGINT (current_block_ordinal (), buf));
173 /* If the previous header was good, tell them that we are
174 skipping bad ones. */
175 set_next_block_after (current_header);
178 case HEADER_STILL_UNREAD:
179 ERROR ((0, 0, _("This does not look like a tar archive")));
182 case HEADER_ZERO_BLOCK:
184 if (block_number_option)
186 char buf[UINTMAX_STRSIZE_BOUND];
187 off_t block_ordinal = current_block_ordinal ();
188 block_ordinal -= recent_long_name_blocks;
189 block_ordinal -= recent_long_link_blocks;
190 fprintf (stdlis, _("block %s: "),
191 STRINGIFY_BIGINT (block_ordinal, buf));
193 ERROR ((0, 0, _("Skipping to next header")));
196 case HEADER_END_OF_FILE:
198 /* We are in the middle of a cascade of errors. */
201 case HEADER_SUCCESS_EXTENDED:
208 while (!all_names_found (¤t_stat_info));
211 names_notfound (); /* print names not found */
214 /* Print a header block, based on tar options. */
218 off_t block_ordinal = current_block_ordinal ();
220 /* Print the header block. */
222 decode_header (current_header, ¤t_stat_info, ¤t_format, 0);
224 print_header (¤t_stat_info, current_header, block_ordinal);
226 if (incremental_option)
228 if (verbose_option > 2)
230 if (is_dumpdir (¤t_stat_info))
231 list_dumpdir (current_stat_info.dumpdir,
232 dumpdir_size (current_stat_info.dumpdir));
239 /* Check header checksum */
240 /* The standard BSD tar sources create the checksum by adding up the
241 bytes in the header as type char. I think the type char was unsigned
242 on the PDP-11, but it's signed on the Next and Sun. It looks like the
243 sources to BSD tar were never changed to compute the checksum
244 correctly, so both the Sun and Next add the bytes of the header as
245 signed chars. This doesn't cause a problem until you get a file with
246 a name containing characters with the high bit set. So tar_checksum
247 computes two checksums -- signed and unsigned. */
250 tar_checksum (union block *header, bool silent)
253 int unsigned_sum = 0; /* the POSIX one :-) */
254 int signed_sum = 0; /* the Sun one :-( */
256 uintmax_t parsed_sum;
260 for (i = sizeof *header; i-- != 0;)
262 unsigned_sum += (unsigned char) *p;
263 signed_sum += (signed char) (*p++);
266 if (unsigned_sum == 0)
267 return HEADER_ZERO_BLOCK;
269 /* Adjust checksum to count the "chksum" field as blanks. */
271 for (i = sizeof header->header.chksum; i-- != 0;)
273 unsigned_sum -= (unsigned char) header->header.chksum[i];
274 signed_sum -= (signed char) (header->header.chksum[i]);
276 unsigned_sum += ' ' * sizeof header->header.chksum;
277 signed_sum += ' ' * sizeof header->header.chksum;
279 parsed_sum = from_header (header->header.chksum,
280 sizeof header->header.chksum, 0,
282 (uintmax_t) TYPE_MAXIMUM (int), true, silent);
283 if (parsed_sum == (uintmax_t) -1)
284 return HEADER_FAILURE;
286 recorded_sum = parsed_sum;
288 if (unsigned_sum != recorded_sum && signed_sum != recorded_sum)
289 return HEADER_FAILURE;
291 return HEADER_SUCCESS;
294 /* Read a block that's supposed to be a header block. Return its
295 address in *RETURN_BLOCK, and if it is good, the file's size
296 and names (file name, link name) in *INFO.
298 Return one of enum read_header describing the status of the
301 The MODE parameter instructs read_header what to do with special
302 header blocks, i.e.: extended POSIX, GNU long name or long link,
305 read_header_auto process them automatically,
306 read_header_x_raw when a special header is read, return
307 HEADER_SUCCESS_EXTENDED without actually
308 processing the header,
309 read_header_x_global when a POSIX global header is read,
310 decode it and return HEADER_SUCCESS_EXTENDED.
312 You must always set_next_block_after(*return_block) to skip past
313 the header which this routine reads. */
316 read_header (union block **return_block, struct tar_stat_info *info,
317 enum read_header_mode mode)
320 union block *header_copy;
322 union block *data_block;
323 size_t size, written;
324 union block *next_long_name = 0;
325 union block *next_long_link = 0;
326 size_t next_long_name_blocks = 0;
327 size_t next_long_link_blocks = 0;
331 enum read_header status;
333 header = find_next_block ();
334 *return_block = header;
336 return HEADER_END_OF_FILE;
338 if ((status = tar_checksum (header, false)) != HEADER_SUCCESS)
341 /* Good block. Decode file size and return. */
343 if (header->header.typeflag == LNKTYPE)
344 info->stat.st_size = 0; /* links 0 size on tape */
346 info->stat.st_size = OFF_FROM_HEADER (header->header.size);
348 if (header->header.typeflag == GNUTYPE_LONGNAME
349 || header->header.typeflag == GNUTYPE_LONGLINK
350 || header->header.typeflag == XHDTYPE
351 || header->header.typeflag == XGLTYPE
352 || header->header.typeflag == SOLARIS_XHDTYPE)
354 if (mode == read_header_x_raw)
355 return HEADER_SUCCESS_EXTENDED;
356 else if (header->header.typeflag == GNUTYPE_LONGNAME
357 || header->header.typeflag == GNUTYPE_LONGLINK)
359 size_t name_size = info->stat.st_size;
360 size_t n = name_size % BLOCKSIZE;
361 size = name_size + BLOCKSIZE;
363 size += BLOCKSIZE - n;
365 if (name_size != info->stat.st_size || size < name_size)
368 header_copy = xmalloc (size + 1);
370 if (header->header.typeflag == GNUTYPE_LONGNAME)
373 free (next_long_name);
374 next_long_name = header_copy;
375 next_long_name_blocks = size / BLOCKSIZE;
380 free (next_long_link);
381 next_long_link = header_copy;
382 next_long_link_blocks = size / BLOCKSIZE;
385 set_next_block_after (header);
386 *header_copy = *header;
387 bp = header_copy->buffer + BLOCKSIZE;
389 for (size -= BLOCKSIZE; size > 0; size -= written)
391 data_block = find_next_block ();
394 ERROR ((0, 0, _("Unexpected EOF in archive")));
397 written = available_space_after (data_block);
401 memcpy (bp, data_block->buffer, written);
403 set_next_block_after ((union block *)
404 (data_block->buffer + written - 1));
409 else if (header->header.typeflag == XHDTYPE
410 || header->header.typeflag == SOLARIS_XHDTYPE)
411 xheader_read (&info->xhdr, header,
412 OFF_FROM_HEADER (header->header.size));
413 else if (header->header.typeflag == XGLTYPE)
417 if (!recent_global_header)
418 recent_global_header = xmalloc (sizeof *recent_global_header);
419 memcpy (recent_global_header, header,
420 sizeof *recent_global_header);
421 memset (&xhdr, 0, sizeof xhdr);
422 xheader_read (&xhdr, header,
423 OFF_FROM_HEADER (header->header.size));
424 xheader_decode_global (&xhdr);
425 xheader_destroy (&xhdr);
426 if (mode == read_header_x_global)
427 return HEADER_SUCCESS_EXTENDED;
436 struct posix_header const *h = &header->header;
437 char namebuf[sizeof h->prefix + 1 + NAME_FIELD_SIZE + 1];
439 if (recent_long_name)
440 free (recent_long_name);
444 name = next_long_name->buffer + BLOCKSIZE;
445 recent_long_name = next_long_name;
446 recent_long_name_blocks = next_long_name_blocks;
450 /* Accept file names as specified by POSIX.1-1996
454 if (h->prefix[0] && strcmp (h->magic, TMAGIC) == 0)
456 memcpy (np, h->prefix, sizeof h->prefix);
457 np[sizeof h->prefix] = '\0';
461 memcpy (np, h->name, sizeof h->name);
462 np[sizeof h->name] = '\0';
464 recent_long_name = 0;
465 recent_long_name_blocks = 0;
467 assign_string (&info->orig_file_name, name);
468 assign_string (&info->file_name, name);
469 info->had_trailing_slash = strip_trailing_slashes (info->file_name);
471 if (recent_long_link)
472 free (recent_long_link);
476 name = next_long_link->buffer + BLOCKSIZE;
477 recent_long_link = next_long_link;
478 recent_long_link_blocks = next_long_link_blocks;
482 memcpy (namebuf, h->linkname, sizeof h->linkname);
483 namebuf[sizeof h->linkname] = '\0';
485 recent_long_link = 0;
486 recent_long_link_blocks = 0;
488 assign_string (&info->link_name, name);
490 return HEADER_SUCCESS;
496 decode_xform (char *file_name, void *data)
498 int type = *(int*)data;
503 /* FIXME: It is not quite clear how and to which extent are the symbolic
504 links subject to filename transformation. In the absence of another
505 solution, symbolic links are exempt from component stripping and
506 name suffix normalization, but subject to filename transformation
511 file_name = safer_name_suffix (file_name, true, absolute_names_option);
515 file_name = safer_name_suffix (file_name, false, absolute_names_option);
519 if (strip_name_components)
521 size_t prefix_len = stripped_prefix_len (file_name,
522 strip_name_components);
523 if (prefix_len == (size_t) -1)
524 prefix_len = strlen (file_name);
525 file_name += prefix_len;
531 transform_member_name (char **pinput, int type)
533 return transform_name_fp (pinput, type, decode_xform, &type);
536 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
538 /* Decode things from a file HEADER block into STAT_INFO, also setting
539 *FORMAT_POINTER depending on the header block format. If
540 DO_USER_GROUP, decode the user/group information (this is useful
541 for extraction, but waste time when merely listing).
543 read_header() has already decoded the checksum and length, so we don't.
545 This routine should *not* be called twice for the same block, since
546 the two calls might use different DO_USER_GROUP values and thus
547 might end up with different uid/gid for the two calls. If anybody
548 wants the uid/gid they should decode it first, and other callers
549 should decode it without uid/gid before calling a routine,
550 e.g. print_header, that assumes decoded data. */
552 decode_header (union block *header, struct tar_stat_info *stat_info,
553 enum archive_format *format_pointer, int do_user_group)
555 enum archive_format format;
556 unsigned hbits; /* high bits of the file mode. */
557 mode_t mode = MODE_FROM_HEADER (header->header.mode, &hbits);
559 if (strcmp (header->header.magic, TMAGIC) == 0)
561 if (header->star_header.prefix[130] == 0
562 && ISOCTAL (header->star_header.atime[0])
563 && header->star_header.atime[11] == ' '
564 && ISOCTAL (header->star_header.ctime[0])
565 && header->star_header.ctime[11] == ' ')
566 format = STAR_FORMAT;
567 else if (stat_info->xhdr.size)
568 format = POSIX_FORMAT;
570 format = USTAR_FORMAT;
572 else if (strcmp (header->header.magic, OLDGNU_MAGIC) == 0)
573 format = hbits ? OLDGNU_FORMAT : GNU_FORMAT;
576 *format_pointer = format;
578 stat_info->stat.st_mode = mode;
579 stat_info->mtime.tv_sec = TIME_FROM_HEADER (header->header.mtime);
580 stat_info->mtime.tv_nsec = 0;
581 assign_string (&stat_info->uname,
582 header->header.uname[0] ? header->header.uname : NULL);
583 assign_string (&stat_info->gname,
584 header->header.gname[0] ? header->header.gname : NULL);
586 if (format == OLDGNU_FORMAT && incremental_option)
588 stat_info->atime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.atime);
589 stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.ctime);
590 stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
592 else if (format == STAR_FORMAT)
594 stat_info->atime.tv_sec = TIME_FROM_HEADER (header->star_header.atime);
595 stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->star_header.ctime);
596 stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
599 stat_info->atime = stat_info->ctime = start_time;
601 if (format == V7_FORMAT)
603 stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
604 stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
605 stat_info->stat.st_rdev = 0;
611 /* FIXME: Decide if this should somewhat depend on -p. */
613 if (numeric_owner_option
614 || !*header->header.uname
615 || !uname_to_uid (header->header.uname, &stat_info->stat.st_uid))
616 stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
618 if (numeric_owner_option
619 || !*header->header.gname
620 || !gname_to_gid (header->header.gname, &stat_info->stat.st_gid))
621 stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
624 switch (header->header.typeflag)
628 stat_info->stat.st_rdev =
629 makedev (MAJOR_FROM_HEADER (header->header.devmajor),
630 MINOR_FROM_HEADER (header->header.devminor));
634 stat_info->stat.st_rdev = 0;
638 stat_info->archive_file_size = stat_info->stat.st_size;
639 xheader_decode (stat_info);
641 if (sparse_member_p (stat_info))
643 sparse_fixup_header (stat_info);
644 stat_info->is_sparse = true;
648 stat_info->is_sparse = false;
649 if (((current_format == GNU_FORMAT
650 || current_format == OLDGNU_FORMAT)
651 && current_header->header.typeflag == GNUTYPE_DUMPDIR)
652 || stat_info->dumpdir)
653 stat_info->is_dumpdir = true;
656 transform_member_name (&stat_info->file_name, XFORM_REGFILE);
657 switch (header->header.typeflag)
660 transform_member_name (&stat_info->link_name, XFORM_SYMLINK);
664 transform_member_name (&stat_info->link_name, XFORM_LINK);
668 /* Convert buffer at WHERE0 of size DIGS from external format to
669 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
670 are of type TYPE. The buffer must represent a value in the range
671 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
672 numbers instead of the other GNU extensions. Return -1 on error,
673 diagnosing the error if TYPE is nonnull and if !SILENT. */
675 from_header (char const *where0, size_t digs, char const *type,
676 uintmax_t minus_minval, uintmax_t maxval,
677 bool octal_only, bool silent)
680 char const *where = where0;
681 char const *lim = where + digs;
684 /* Accommodate buggy tar of unknown vintage, which outputs leading
685 NUL if the previous field overflows. */
688 /* Accommodate older tars, which output leading spaces. */
695 /* TRANSLATORS: %s is type of the value (gid_t, uid_t,
697 _("Blanks in header where numeric %s value expected"),
701 if (!ISSPACE ((unsigned char) *where))
707 if (ISODIGIT (*where))
709 char const *where1 = where;
710 uintmax_t overflow = 0;
714 value += *where++ - '0';
715 if (where == lim || ! ISODIGIT (*where))
717 overflow |= value ^ (value << LG_8 >> LG_8);
721 /* Parse the output of older, unportable tars, which generate
722 negative values in two's complement octal. If the leading
723 nonzero digit is 1, we can't recover the original value
724 reliably; so do this only if the digit is 2 or more. This
725 catches the common case of 32-bit negative time stamps. */
726 if ((overflow || maxval < value) && '2' <= *where1 && type)
728 /* Compute the negative of the input value, assuming two's
730 int digit = (*where1 - '0') | 4;
738 if (where == lim || ! ISODIGIT (*where))
740 digit = *where - '0';
741 overflow |= value ^ (value << LG_8 >> LG_8);
747 if (!overflow && value <= minus_minval)
751 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
752 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
753 (int) (where - where1), where1, type));
762 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
763 _("Archive octal value %.*s is out of %s range"),
764 (int) (where - where1), where1, type));
770 /* Suppress the following extensions. */
772 else if (*where == '-' || *where == '+')
774 /* Parse base-64 output produced only by tar test versions
775 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
776 Support for this will be withdrawn in future releases. */
780 static bool warned_once;
784 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
787 negative = *where++ == '-';
789 && (dig = base64_map[(unsigned char) *where]) < 64)
791 if (value << LG_64 >> LG_64 != value)
793 char *string = alloca (digs + 1);
794 memcpy (string, where0, digs);
798 _("Archive signed base-64 string %s is out of %s range"),
799 quote (string), type));
802 value = (value << LG_64) | dig;
806 else if (*where == '\200' /* positive base-256 */
807 || *where == '\377' /* negative base-256 */)
809 /* Parse base-256 output. A nonnegative number N is
810 represented as (256**DIGS)/2 + N; a negative number -N is
811 represented as (256**DIGS) - N, i.e. as two's complement.
812 The representation guarantees that the leading bit is
813 always on, so that we don't confuse this format with the
814 others (assuming ASCII bytes of 8 bits or more). */
815 int signbit = *where & (1 << (LG_256 - 2));
816 uintmax_t topbits = (((uintmax_t) - signbit)
817 << (CHAR_BIT * sizeof (uintmax_t)
818 - LG_256 - (LG_256 - 2)));
819 value = (*where++ & ((1 << (LG_256 - 2)) - 1)) - signbit;
822 value = (value << LG_256) + (unsigned char) *where++;
825 if (((value << LG_256 >> LG_256) | topbits) != value)
829 _("Archive base-256 value is out of %s range"),
839 if (where != lim && *where && !ISSPACE ((unsigned char) *where))
843 char buf[1000]; /* Big enough to represent any header. */
844 static struct quoting_options *o;
848 o = clone_quoting_options (0);
849 set_quoting_style (o, locale_quoting_style);
852 while (where0 != lim && ! lim[-1])
854 quotearg_buffer (buf, sizeof buf, where0, lim - where, o);
857 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
858 _("Archive contains %.*s where numeric %s value expected"),
859 (int) sizeof buf, buf, type));
865 if (value <= (negative ? minus_minval : maxval))
866 return negative ? -value : value;
870 char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
871 char maxval_buf[UINTMAX_STRSIZE_BOUND];
872 char value_buf[UINTMAX_STRSIZE_BOUND + 1];
873 char *minval_string = STRINGIFY_BIGINT (minus_minval, minval_buf + 1);
874 char *value_string = STRINGIFY_BIGINT (value, value_buf + 1);
876 *--value_string = '-';
878 *--minval_string = '-';
879 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
880 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
882 minval_string, STRINGIFY_BIGINT (maxval, maxval_buf)));
889 gid_from_header (const char *p, size_t s)
891 return from_header (p, s, "gid_t",
892 - (uintmax_t) TYPE_MINIMUM (gid_t),
893 (uintmax_t) TYPE_MAXIMUM (gid_t),
898 major_from_header (const char *p, size_t s)
900 return from_header (p, s, "major_t",
901 - (uintmax_t) TYPE_MINIMUM (major_t),
902 (uintmax_t) TYPE_MAXIMUM (major_t), false, false);
906 minor_from_header (const char *p, size_t s)
908 return from_header (p, s, "minor_t",
909 - (uintmax_t) TYPE_MINIMUM (minor_t),
910 (uintmax_t) TYPE_MAXIMUM (minor_t), false, false);
913 /* Convert P to the file mode, as understood by tar.
914 Store unrecognized mode bits (from 10th up) in HBITS. */
916 mode_from_header (const char *p, size_t s, unsigned *hbits)
918 unsigned u = from_header (p, s, "mode_t",
919 - (uintmax_t) TYPE_MINIMUM (mode_t),
920 TYPE_MAXIMUM (uintmax_t), false, false);
921 mode_t mode = ((u & TSUID ? S_ISUID : 0)
922 | (u & TSGID ? S_ISGID : 0)
923 | (u & TSVTX ? S_ISVTX : 0)
924 | (u & TUREAD ? S_IRUSR : 0)
925 | (u & TUWRITE ? S_IWUSR : 0)
926 | (u & TUEXEC ? S_IXUSR : 0)
927 | (u & TGREAD ? S_IRGRP : 0)
928 | (u & TGWRITE ? S_IWGRP : 0)
929 | (u & TGEXEC ? S_IXGRP : 0)
930 | (u & TOREAD ? S_IROTH : 0)
931 | (u & TOWRITE ? S_IWOTH : 0)
932 | (u & TOEXEC ? S_IXOTH : 0));
938 off_from_header (const char *p, size_t s)
940 /* Negative offsets are not allowed in tar files, so invoke
941 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
942 return from_header (p, s, "off_t", (uintmax_t) 0,
943 (uintmax_t) TYPE_MAXIMUM (off_t), false, false);
947 size_from_header (const char *p, size_t s)
949 return from_header (p, s, "size_t", (uintmax_t) 0,
950 (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
954 time_from_header (const char *p, size_t s)
956 return from_header (p, s, "time_t",
957 - (uintmax_t) TYPE_MINIMUM (time_t),
958 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
962 uid_from_header (const char *p, size_t s)
964 return from_header (p, s, "uid_t",
965 - (uintmax_t) TYPE_MINIMUM (uid_t),
966 (uintmax_t) TYPE_MAXIMUM (uid_t), false, false);
970 uintmax_from_header (const char *p, size_t s)
972 return from_header (p, s, "uintmax_t", (uintmax_t) 0,
973 TYPE_MAXIMUM (uintmax_t), false, false);
977 /* Return a printable representation of T. The result points to
978 static storage that can be reused in the next call to this
979 function, to ctime, or to asctime. If FULL_TIME, then output the
980 time stamp to its full resolution; otherwise, just output it to
981 1-minute resolution. */
983 tartime (struct timespec t, bool full_time)
985 enum { fraclen = sizeof ".FFFFFFFFF" - 1 };
986 static char buffer[max (UINTMAX_STRSIZE_BOUND + 1,
987 INT_STRLEN_BOUND (int) + 16)
992 bool negative = s < 0;
995 if (negative && ns != 0)
998 ns = 1000000000 - ns;
1001 tm = utc_option ? gmtime (&s) : localtime (&s);
1006 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d:%02d",
1007 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
1008 tm->tm_hour, tm->tm_min, tm->tm_sec);
1009 code_ns_fraction (ns, buffer + strlen (buffer));
1012 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d",
1013 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
1014 tm->tm_hour, tm->tm_min);
1018 /* The time stamp cannot be broken down, most likely because it
1019 is out of range. Convert it as an integer,
1020 right-adjusted in a field with the same width as the usual
1021 4-year ISO time format. */
1022 p = umaxtostr (negative ? - (uintmax_t) s : s,
1023 buffer + sizeof buffer - UINTMAX_STRSIZE_BOUND - fraclen);
1026 while ((buffer + sizeof buffer - sizeof "YYYY-MM-DD HH:MM"
1027 + (full_time ? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1031 code_ns_fraction (ns, buffer + sizeof buffer - 1 - fraclen);
1035 /* Actually print it.
1037 Plain and fancy file header block logging. Non-verbose just prints
1038 the name, e.g. for "tar t" or "tar x". This should just contain
1039 file names, so it can be fed back into tar with xargs or the "-T"
1040 option. The verbose option can give a bunch of info, one line per
1041 file. I doubt anybody tries to parse its format, or if they do,
1042 they shouldn't. Unix tar is pretty random here anyway. */
1045 /* Width of "user/group size", with initial value chosen
1046 heuristically. This grows as needed, though this may cause some
1047 stairstepping in the output. Make it too small and the output will
1048 almost always look ragged. Make it too large and the output will
1049 be spaced out too far. */
1050 static int ugswidth = 19;
1052 /* Width of printed time stamps. It grows if longer time stamps are
1053 found (typically, those with nanosecond resolution). Like
1054 USGWIDTH, some stairstepping may occur. */
1055 static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1;
1057 static bool volume_label_printed = false;
1060 simple_print_header (struct tar_stat_info *st, union block *blk,
1061 off_t block_ordinal)
1064 char const *time_stamp;
1068 /* These hold formatted ints. */
1069 char uform[UINTMAX_STRSIZE_BOUND], gform[UINTMAX_STRSIZE_BOUND];
1071 char size[2 * UINTMAX_STRSIZE_BOUND];
1072 /* holds formatted size or major,minor */
1073 char uintbuf[UINTMAX_STRSIZE_BOUND];
1077 if (show_transformed_names_option)
1078 temp_name = st->file_name ? st->file_name : st->orig_file_name;
1080 temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
1082 if (block_number_option)
1084 char buf[UINTMAX_STRSIZE_BOUND];
1085 if (block_ordinal < 0)
1086 block_ordinal = current_block_ordinal ();
1087 block_ordinal -= recent_long_name_blocks;
1088 block_ordinal -= recent_long_link_blocks;
1089 fprintf (stdlis, _("block %s: "),
1090 STRINGIFY_BIGINT (block_ordinal, buf));
1093 if (verbose_option <= 1)
1095 /* Just the fax, mam. */
1096 fprintf (stdlis, "%s\n", quotearg (temp_name));
1100 /* File type and modes. */
1103 switch (blk->header.typeflag)
1105 case GNUTYPE_VOLHDR:
1106 volume_label_printed = true;
1110 case GNUTYPE_MULTIVOL:
1114 case GNUTYPE_LONGNAME:
1115 case GNUTYPE_LONGLINK:
1117 ERROR ((0, 0, _("Unexpected long name header")));
1120 case GNUTYPE_SPARSE:
1124 if (temp_name[strlen (temp_name) - 1] == '/')
1130 case GNUTYPE_DUMPDIR:
1153 pax_decode_mode (st->stat.st_mode, modes + 1);
1157 time_stamp = tartime (st->mtime, false);
1158 time_stamp_len = strlen (time_stamp);
1159 if (datewidth < time_stamp_len)
1160 datewidth = time_stamp_len;
1162 /* User and group names. */
1166 && current_format != V7_FORMAT
1167 && !numeric_owner_option)
1171 /* Try parsing it as an unsigned integer first, and as a
1172 uid_t if that fails. This method can list positive user
1173 ids that are too large to fit in a uid_t. */
1174 uintmax_t u = from_header (blk->header.uid,
1175 sizeof blk->header.uid, 0,
1177 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1180 user = STRINGIFY_BIGINT (u, uform);
1183 sprintf (uform, "%ld",
1184 (long) UID_FROM_HEADER (blk->header.uid));
1191 && current_format != V7_FORMAT
1192 && !numeric_owner_option)
1196 /* Try parsing it as an unsigned integer first, and as a
1197 gid_t if that fails. This method can list positive group
1198 ids that are too large to fit in a gid_t. */
1199 uintmax_t g = from_header (blk->header.gid,
1200 sizeof blk->header.gid, 0,
1202 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1205 group = STRINGIFY_BIGINT (g, gform);
1208 sprintf (gform, "%ld",
1209 (long) GID_FROM_HEADER (blk->header.gid));
1214 /* Format the file size or major/minor device numbers. */
1216 switch (blk->header.typeflag)
1221 STRINGIFY_BIGINT (major (st->stat.st_rdev), uintbuf));
1224 STRINGIFY_BIGINT (minor (st->stat.st_rdev), uintbuf));
1228 /* st->stat.st_size keeps stored file size */
1229 strcpy (size, STRINGIFY_BIGINT (st->stat.st_size, uintbuf));
1233 /* Figure out padding and print the whole line. */
1235 sizelen = strlen (size);
1236 pad = strlen (user) + 1 + strlen (group) + 1 + sizelen;
1240 fprintf (stdlis, "%s %s/%s %*s %-*s",
1241 modes, user, group, ugswidth - pad + sizelen, size,
1242 datewidth, time_stamp);
1244 fprintf (stdlis, " %s", quotearg (temp_name));
1246 switch (blk->header.typeflag)
1249 fprintf (stdlis, " -> %s\n", quotearg (st->link_name));
1253 fprintf (stdlis, _(" link to %s\n"), quotearg (st->link_name));
1258 char type_string[2];
1259 type_string[0] = blk->header.typeflag;
1260 type_string[1] = '\0';
1261 fprintf (stdlis, _(" unknown file type %s\n"),
1262 quote (type_string));
1268 case GNUTYPE_SPARSE:
1274 case GNUTYPE_DUMPDIR:
1275 putc ('\n', stdlis);
1278 case GNUTYPE_LONGLINK:
1279 fprintf (stdlis, _("--Long Link--\n"));
1282 case GNUTYPE_LONGNAME:
1283 fprintf (stdlis, _("--Long Name--\n"));
1286 case GNUTYPE_VOLHDR:
1287 fprintf (stdlis, _("--Volume Header--\n"));
1290 case GNUTYPE_MULTIVOL:
1293 (UINTMAX_FROM_HEADER (blk->oldgnu_header.offset),
1295 fprintf (stdlis, _("--Continued at byte %s--\n"), size);
1304 print_volume_label ()
1306 struct tar_stat_info vstat;
1308 enum archive_format dummy;
1310 memset (&vblk, 0, sizeof (vblk));
1311 vblk.header.typeflag = GNUTYPE_VOLHDR;
1312 if (recent_global_header)
1313 memcpy (vblk.header.mtime, recent_global_header->header.mtime,
1314 sizeof vblk.header.mtime);
1315 tar_stat_init (&vstat);
1316 assign_string (&vstat.file_name, ".");
1317 decode_header (&vblk, &vstat, &dummy, 0);
1318 assign_string (&vstat.file_name, volume_label);
1319 simple_print_header (&vstat, &vblk, 0);
1320 tar_stat_destroy (&vstat);
1324 print_header (struct tar_stat_info *st, union block *blk,
1325 off_t block_ordinal)
1327 if (current_format == POSIX_FORMAT && !volume_label_printed && volume_label)
1329 print_volume_label ();
1330 volume_label_printed = true;
1333 simple_print_header (st, blk, block_ordinal);
1336 /* Print a similar line when we make a directory automatically. */
1338 print_for_mkdir (char *dirname, int length, mode_t mode)
1342 if (verbose_option > 1)
1344 /* File type and modes. */
1347 pax_decode_mode (mode, modes + 1);
1349 if (block_number_option)
1351 char buf[UINTMAX_STRSIZE_BOUND];
1352 fprintf (stdlis, _("block %s: "),
1353 STRINGIFY_BIGINT (current_block_ordinal (), buf));
1356 fprintf (stdlis, "%s %*s %.*s\n", modes, ugswidth + 1 + datewidth,
1357 _("Creating directory:"), length, quotearg (dirname));
1361 /* Skip over SIZE bytes of data in blocks in the archive. */
1363 skip_file (off_t size)
1367 /* FIXME: Make sure mv_begin is always called before it */
1369 if (seekable_archive)
1371 off_t nblk = seek_archive (size);
1373 size -= nblk * BLOCKSIZE;
1375 seekable_archive = false;
1378 mv_size_left (size);
1382 x = find_next_block ();
1384 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1386 set_next_block_after (x);
1388 mv_size_left (size);
1392 /* Skip the current member in the archive.
1393 NOTE: Current header must be decoded before calling this function. */
1397 if (!current_stat_info.skipped)
1399 char save_typeflag = current_header->header.typeflag;
1400 set_next_block_after (current_header);
1402 mv_begin (¤t_stat_info);
1404 if (current_stat_info.is_sparse)
1405 sparse_skip_file (¤t_stat_info);
1406 else if (save_typeflag != DIRTYPE)
1407 skip_file (current_stat_info.stat.st_size);
1414 test_archive_label ()
1419 open_archive (ACCESS_READ);
1420 if (read_header (¤t_header, ¤t_stat_info, read_header_auto)
1425 decode_header (current_header,
1426 ¤t_stat_info, ¤t_format, 0);
1427 if (current_header->header.typeflag == GNUTYPE_VOLHDR)
1428 assign_string (&volume_label, current_header->header.name);
1431 && (name_match (volume_label)
1432 || (multi_volume_option
1433 && (s = drop_volume_label_suffix (volume_label))
1434 && name_match (s))))
1436 print_volume_label ();