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 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 */
37 static uintmax_t from_header (const char *, size_t, const char *,
38 uintmax_t, uintmax_t, bool, bool);
40 /* Base 64 digits; see Internet RFC 2045 Table 1. */
41 static char const base_64_digits[64] =
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', '+', '/'
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];
58 memset (base64_map, 64, sizeof base64_map);
59 for (i = 0; i < 64; i++)
60 base64_map[(int) base_64_digits[i]] = i;
63 /* Main loop for reading an archive. */
65 read_and (void (*do_something) (void))
67 enum read_header status = HEADER_STILL_UNREAD;
68 enum read_header prev_status;
69 struct timespec mtime;
74 open_archive (ACCESS_READ);
78 tar_stat_destroy (¤t_stat_info);
80 status = read_header (false);
83 case HEADER_STILL_UNREAD:
84 case HEADER_SUCCESS_EXTENDED:
89 /* Valid header. We should decode next field (mode) first.
90 Ensure incoming names are null terminated. */
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. */
97 = TIME_FROM_HEADER (current_header->header.mtime)),
98 /* FIXME: Grab fractional time stamps from
101 current_stat_info.mtime = mtime,
102 OLDER_TAR_STAT_TIME (current_stat_info, m)))
103 || excluded_name (current_stat_info.file_name))
105 switch (current_header->header.typeflag)
108 case GNUTYPE_MULTIVOL:
112 if (show_omitted_dirs_option)
113 WARN ((0, 0, _("%s: Omitting"),
114 quotearg_colon (current_stat_info.file_name)));
117 decode_header (current_header,
118 ¤t_stat_info, ¤t_format, 0);
127 case HEADER_ZERO_BLOCK:
128 if (block_number_option)
130 char buf[UINTMAX_STRSIZE_BOUND];
131 fprintf (stdlis, _("block %s: ** Block of NULs **\n"),
132 STRINGIFY_BIGINT (current_block_ordinal (), buf));
135 set_next_block_after (current_header);
137 if (!ignore_zeros_option)
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.
147 char buf[UINTMAX_STRSIZE_BOUND];
149 status = read_header (false);
150 if (status == HEADER_ZERO_BLOCK)
152 WARN ((0, 0, _("A lone zero block at %s"),
153 STRINGIFY_BIGINT (current_block_ordinal (), buf)));
157 status = prev_status;
160 case HEADER_END_OF_FILE:
161 if (block_number_option)
163 char buf[UINTMAX_STRSIZE_BOUND];
164 fprintf (stdlis, _("block %s: ** End of File **\n"),
165 STRINGIFY_BIGINT (current_block_ordinal (), buf));
170 /* If the previous header was good, tell them that we are
171 skipping bad ones. */
172 set_next_block_after (current_header);
175 case HEADER_STILL_UNREAD:
176 ERROR ((0, 0, _("This does not look like a tar archive")));
179 case HEADER_ZERO_BLOCK:
181 if (block_number_option)
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));
190 ERROR ((0, 0, _("Skipping to next header")));
193 case HEADER_END_OF_FILE:
195 /* We are in the middle of a cascade of errors. */
198 case HEADER_SUCCESS_EXTENDED:
205 while (!all_names_found (¤t_stat_info));
208 names_notfound (); /* print names not found */
211 /* Print a header block, based on tar options. */
215 off_t block_ordinal = current_block_ordinal ();
216 /* Print the header block. */
218 decode_header (current_header, ¤t_stat_info, ¤t_format, 0);
220 print_header (¤t_stat_info, block_ordinal);
222 if (incremental_option)
224 if (verbose_option > 2)
226 if (is_dumpdir (¤t_stat_info))
227 list_dumpdir (current_stat_info.dumpdir,
228 dumpdir_size (current_stat_info.dumpdir));
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. */
246 tar_checksum (union block *header, bool silent)
249 int unsigned_sum = 0; /* the POSIX one :-) */
250 int signed_sum = 0; /* the Sun one :-( */
252 uintmax_t parsed_sum;
256 for (i = sizeof *header; i-- != 0;)
258 unsigned_sum += (unsigned char) *p;
259 signed_sum += (signed char) (*p++);
262 if (unsigned_sum == 0)
263 return HEADER_ZERO_BLOCK;
265 /* Adjust checksum to count the "chksum" field as blanks. */
267 for (i = sizeof header->header.chksum; i-- != 0;)
269 unsigned_sum -= (unsigned char) header->header.chksum[i];
270 signed_sum -= (signed char) (header->header.chksum[i]);
272 unsigned_sum += ' ' * sizeof header->header.chksum;
273 signed_sum += ' ' * sizeof header->header.chksum;
275 parsed_sum = from_header (header->header.chksum,
276 sizeof header->header.chksum, 0,
278 (uintmax_t) TYPE_MAXIMUM (int), true, silent);
279 if (parsed_sum == (uintmax_t) -1)
280 return HEADER_FAILURE;
282 recorded_sum = parsed_sum;
284 if (unsigned_sum != recorded_sum && signed_sum != recorded_sum)
285 return HEADER_FAILURE;
287 return HEADER_SUCCESS;
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.
294 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
295 block full of zeros (EOF marker).
297 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
298 GNU long name and link headers into later headers.
300 You must always set_next_block_after(current_header) to skip past
301 the header which this routine reads. */
304 read_header_primitive (bool raw_extended_headers, struct tar_stat_info *info)
307 union block *header_copy;
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;
318 enum read_header status;
320 header = find_next_block ();
321 current_header = header;
323 return HEADER_END_OF_FILE;
325 if ((status = tar_checksum (header, false)) != HEADER_SUCCESS)
328 /* Good block. Decode file size and return. */
330 if (header->header.typeflag == LNKTYPE)
331 info->stat.st_size = 0; /* links 0 size on tape */
333 info->stat.st_size = OFF_FROM_HEADER (header->header.size);
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)
341 if (raw_extended_headers)
342 return HEADER_SUCCESS_EXTENDED;
343 else if (header->header.typeflag == GNUTYPE_LONGNAME
344 || header->header.typeflag == GNUTYPE_LONGLINK)
346 size_t name_size = info->stat.st_size;
347 size_t n = name_size % BLOCKSIZE;
348 size = name_size + BLOCKSIZE;
350 size += BLOCKSIZE - n;
352 if (name_size != info->stat.st_size || size < name_size)
355 header_copy = xmalloc (size + 1);
357 if (header->header.typeflag == GNUTYPE_LONGNAME)
360 free (next_long_name);
361 next_long_name = header_copy;
362 next_long_name_blocks = size / BLOCKSIZE;
367 free (next_long_link);
368 next_long_link = header_copy;
369 next_long_link_blocks = size / BLOCKSIZE;
372 set_next_block_after (header);
373 *header_copy = *header;
374 bp = header_copy->buffer + BLOCKSIZE;
376 for (size -= BLOCKSIZE; size > 0; size -= written)
378 data_block = find_next_block ();
381 ERROR ((0, 0, _("Unexpected EOF in archive")));
384 written = available_space_after (data_block);
388 memcpy (bp, data_block->buffer, written);
390 set_next_block_after ((union block *)
391 (data_block->buffer + written - 1));
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)
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);
416 struct posix_header const *h = ¤t_header->header;
417 char namebuf[sizeof h->prefix + 1 + NAME_FIELD_SIZE + 1];
419 if (recent_long_name)
420 free (recent_long_name);
424 name = next_long_name->buffer + BLOCKSIZE;
425 recent_long_name = next_long_name;
426 recent_long_name_blocks = next_long_name_blocks;
430 /* Accept file names as specified by POSIX.1-1996
434 if (h->prefix[0] && strcmp (h->magic, TMAGIC) == 0)
436 memcpy (np, h->prefix, sizeof h->prefix);
437 np[sizeof h->prefix] = '\0';
441 memcpy (np, h->name, sizeof h->name);
442 np[sizeof h->name] = '\0';
444 recent_long_name = 0;
445 recent_long_name_blocks = 0;
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);
451 if (recent_long_link)
452 free (recent_long_link);
456 name = next_long_link->buffer + BLOCKSIZE;
457 recent_long_link = next_long_link;
458 recent_long_link_blocks = next_long_link_blocks;
462 memcpy (namebuf, h->linkname, sizeof h->linkname);
463 namebuf[sizeof h->linkname] = '\0';
465 recent_long_link = 0;
466 recent_long_link_blocks = 0;
468 assign_string (&info->link_name, name);
470 return HEADER_SUCCESS;
476 read_header (bool raw_extended_headers)
478 return read_header_primitive (raw_extended_headers, ¤t_stat_info);
482 decode_xform (char *file_name, void *data)
484 xform_type type = *(xform_type*)data;
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
497 file_name = safer_name_suffix (file_name, true, absolute_names_option);
501 file_name = safer_name_suffix (file_name, false, absolute_names_option);
505 if (strip_name_components)
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;
517 transform_member_name (char **pinput, xform_type type)
519 return transform_name_fp (pinput, decode_xform, &type);
522 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
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).
529 read_header() has already decoded the checksum and length, so we don't.
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. */
538 decode_header (union block *header, struct tar_stat_info *stat_info,
539 enum archive_format *format_pointer, int do_user_group)
541 enum archive_format format;
543 if (strcmp (header->header.magic, TMAGIC) == 0)
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;
554 format = USTAR_FORMAT;
556 else if (strcmp (header->header.magic, OLDGNU_MAGIC) == 0)
557 format = OLDGNU_FORMAT;
560 *format_pointer = format;
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);
570 if (format == OLDGNU_FORMAT && incremental_option)
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;
576 else if (format == STAR_FORMAT)
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;
583 stat_info->atime = stat_info->ctime = start_time;
585 if (format == V7_FORMAT)
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;
595 /* FIXME: Decide if this should somewhat depend on -p. */
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);
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);
608 switch (header->header.typeflag)
612 stat_info->stat.st_rdev =
613 makedev (MAJOR_FROM_HEADER (header->header.devmajor),
614 MINOR_FROM_HEADER (header->header.devminor));
618 stat_info->stat.st_rdev = 0;
622 stat_info->archive_file_size = stat_info->stat.st_size;
623 xheader_decode (stat_info);
625 if (sparse_member_p (stat_info))
627 sparse_fixup_header (stat_info);
628 stat_info->is_sparse = true;
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;
640 transform_member_name (&stat_info->file_name, xform_regfile);
643 /* Convert buffer at WHERE0 of size DIGS from external format to
644 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
645 are of type TYPE. The buffer must represent a value in the range
646 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
647 numbers instead of the other GNU extensions. Return -1 on error,
648 diagnosing the error if TYPE is nonnull and if !SILENT. */
650 from_header (char const *where0, size_t digs, char const *type,
651 uintmax_t minus_minval, uintmax_t maxval,
652 bool octal_only, bool silent)
655 char const *where = where0;
656 char const *lim = where + digs;
659 /* Accommodate buggy tar of unknown vintage, which outputs leading
660 NUL if the previous field overflows. */
663 /* Accommodate older tars, which output leading spaces. */
670 /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
671 _("Blanks in header where numeric %s value expected"),
675 if (!ISSPACE ((unsigned char) *where))
681 if (ISODIGIT (*where))
683 char const *where1 = where;
684 uintmax_t overflow = 0;
688 value += *where++ - '0';
689 if (where == lim || ! ISODIGIT (*where))
691 overflow |= value ^ (value << LG_8 >> LG_8);
695 /* Parse the output of older, unportable tars, which generate
696 negative values in two's complement octal. If the leading
697 nonzero digit is 1, we can't recover the original value
698 reliably; so do this only if the digit is 2 or more. This
699 catches the common case of 32-bit negative time stamps. */
700 if ((overflow || maxval < value) && '2' <= *where1 && type)
702 /* Compute the negative of the input value, assuming two's
704 int digit = (*where1 - '0') | 4;
712 if (where == lim || ! ISODIGIT (*where))
714 digit = *where - '0';
715 overflow |= value ^ (value << LG_8 >> LG_8);
721 if (!overflow && value <= minus_minval)
725 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
726 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
727 (int) (where - where1), where1, type));
736 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
737 _("Archive octal value %.*s is out of %s range"),
738 (int) (where - where1), where1, type));
744 /* Suppress the following extensions. */
746 else if (*where == '-' || *where == '+')
748 /* Parse base-64 output produced only by tar test versions
749 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
750 Support for this will be withdrawn in future releases. */
754 static bool warned_once;
758 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
761 negative = *where++ == '-';
763 && (dig = base64_map[(unsigned char) *where]) < 64)
765 if (value << LG_64 >> LG_64 != value)
767 char *string = alloca (digs + 1);
768 memcpy (string, where0, digs);
772 _("Archive signed base-64 string %s is out of %s range"),
773 quote (string), type));
776 value = (value << LG_64) | dig;
780 else if (*where == '\200' /* positive base-256 */
781 || *where == '\377' /* negative base-256 */)
783 /* Parse base-256 output. A nonnegative number N is
784 represented as (256**DIGS)/2 + N; a negative number -N is
785 represented as (256**DIGS) - N, i.e. as two's complement.
786 The representation guarantees that the leading bit is
787 always on, so that we don't confuse this format with the
788 others (assuming ASCII bytes of 8 bits or more). */
789 int signbit = *where & (1 << (LG_256 - 2));
790 uintmax_t topbits = (((uintmax_t) - signbit)
791 << (CHAR_BIT * sizeof (uintmax_t)
792 - LG_256 - (LG_256 - 2)));
793 value = (*where++ & ((1 << (LG_256 - 2)) - 1)) - signbit;
796 value = (value << LG_256) + (unsigned char) *where++;
799 if (((value << LG_256 >> LG_256) | topbits) != value)
803 _("Archive base-256 value is out of %s range"),
813 if (where != lim && *where && !ISSPACE ((unsigned char) *where))
817 char buf[1000]; /* Big enough to represent any header. */
818 static struct quoting_options *o;
822 o = clone_quoting_options (0);
823 set_quoting_style (o, locale_quoting_style);
826 while (where0 != lim && ! lim[-1])
828 quotearg_buffer (buf, sizeof buf, where0, lim - where, o);
831 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
832 _("Archive contains %.*s where numeric %s value expected"),
833 (int) sizeof buf, buf, type));
839 if (value <= (negative ? minus_minval : maxval))
840 return negative ? -value : value;
844 char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
845 char maxval_buf[UINTMAX_STRSIZE_BOUND];
846 char value_buf[UINTMAX_STRSIZE_BOUND + 1];
847 char *minval_string = STRINGIFY_BIGINT (minus_minval, minval_buf + 1);
848 char *value_string = STRINGIFY_BIGINT (value, value_buf + 1);
850 *--value_string = '-';
852 *--minval_string = '-';
853 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
854 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
856 minval_string, STRINGIFY_BIGINT (maxval, maxval_buf)));
863 gid_from_header (const char *p, size_t s)
865 return from_header (p, s, "gid_t",
866 - (uintmax_t) TYPE_MINIMUM (gid_t),
867 (uintmax_t) TYPE_MAXIMUM (gid_t),
872 major_from_header (const char *p, size_t s)
874 return from_header (p, s, "major_t",
875 - (uintmax_t) TYPE_MINIMUM (major_t),
876 (uintmax_t) TYPE_MAXIMUM (major_t), false, false);
880 minor_from_header (const char *p, size_t s)
882 return from_header (p, s, "minor_t",
883 - (uintmax_t) TYPE_MINIMUM (minor_t),
884 (uintmax_t) TYPE_MAXIMUM (minor_t), false, false);
888 mode_from_header (const char *p, size_t s)
890 /* Do not complain about unrecognized mode bits. */
891 unsigned u = from_header (p, s, "mode_t",
892 - (uintmax_t) TYPE_MINIMUM (mode_t),
893 TYPE_MAXIMUM (uintmax_t), false, false);
894 return ((u & TSUID ? S_ISUID : 0)
895 | (u & TSGID ? S_ISGID : 0)
896 | (u & TSVTX ? S_ISVTX : 0)
897 | (u & TUREAD ? S_IRUSR : 0)
898 | (u & TUWRITE ? S_IWUSR : 0)
899 | (u & TUEXEC ? S_IXUSR : 0)
900 | (u & TGREAD ? S_IRGRP : 0)
901 | (u & TGWRITE ? S_IWGRP : 0)
902 | (u & TGEXEC ? S_IXGRP : 0)
903 | (u & TOREAD ? S_IROTH : 0)
904 | (u & TOWRITE ? S_IWOTH : 0)
905 | (u & TOEXEC ? S_IXOTH : 0));
909 off_from_header (const char *p, size_t s)
911 /* Negative offsets are not allowed in tar files, so invoke
912 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
913 return from_header (p, s, "off_t", (uintmax_t) 0,
914 (uintmax_t) TYPE_MAXIMUM (off_t), false, false);
918 size_from_header (const char *p, size_t s)
920 return from_header (p, s, "size_t", (uintmax_t) 0,
921 (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
925 time_from_header (const char *p, size_t s)
927 return from_header (p, s, "time_t",
928 - (uintmax_t) TYPE_MINIMUM (time_t),
929 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
933 uid_from_header (const char *p, size_t s)
935 return from_header (p, s, "uid_t",
936 - (uintmax_t) TYPE_MINIMUM (uid_t),
937 (uintmax_t) TYPE_MAXIMUM (uid_t), false, false);
941 uintmax_from_header (const char *p, size_t s)
943 return from_header (p, s, "uintmax_t", (uintmax_t) 0,
944 TYPE_MAXIMUM (uintmax_t), false, false);
948 /* Return a printable representation of T. The result points to
949 static storage that can be reused in the next call to this
950 function, to ctime, or to asctime. If FULL_TIME, then output the
951 time stamp to its full resolution; otherwise, just output it to
952 1-minute resolution. */
954 tartime (struct timespec t, bool full_time)
956 enum { fraclen = sizeof ".FFFFFFFFF" - 1 };
957 static char buffer[max (UINTMAX_STRSIZE_BOUND + 1,
958 INT_STRLEN_BOUND (int) + 16)
963 bool negative = s < 0;
966 if (negative && ns != 0)
969 ns = 1000000000 - ns;
972 tm = utc_option ? gmtime (&s) : localtime (&s);
977 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d:%02d",
978 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
979 tm->tm_hour, tm->tm_min, tm->tm_sec);
980 code_ns_fraction (ns, buffer + strlen (buffer));
983 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d",
984 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
985 tm->tm_hour, tm->tm_min);
989 /* The time stamp cannot be broken down, most likely because it
990 is out of range. Convert it as an integer,
991 right-adjusted in a field with the same width as the usual
992 4-year ISO time format. */
993 p = umaxtostr (negative ? - (uintmax_t) s : s,
994 buffer + sizeof buffer - UINTMAX_STRSIZE_BOUND - fraclen);
997 while ((buffer + sizeof buffer - sizeof "YYYY-MM-DD HH:MM"
998 + (full_time ? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1002 code_ns_fraction (ns, buffer + sizeof buffer - 1 - fraclen);
1006 /* Actually print it.
1008 Plain and fancy file header block logging. Non-verbose just prints
1009 the name, e.g. for "tar t" or "tar x". This should just contain
1010 file names, so it can be fed back into tar with xargs or the "-T"
1011 option. The verbose option can give a bunch of info, one line per
1012 file. I doubt anybody tries to parse its format, or if they do,
1013 they shouldn't. Unix tar is pretty random here anyway. */
1016 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
1017 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
1019 /* Width of "user/group size", with initial value chosen
1020 heuristically. This grows as needed, though this may cause some
1021 stairstepping in the output. Make it too small and the output will
1022 almost always look ragged. Make it too large and the output will
1023 be spaced out too far. */
1024 static int ugswidth = 19;
1026 /* Width of printed time stamps. It grows if longer time stamps are
1027 found (typically, those with nanosecond resolution). Like
1028 USGWIDTH, some stairstepping may occur. */
1029 static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1;
1032 print_header (struct tar_stat_info *st, off_t block_ordinal)
1035 char const *time_stamp;
1039 /* These hold formatted ints. */
1040 char uform[UINTMAX_STRSIZE_BOUND], gform[UINTMAX_STRSIZE_BOUND];
1042 char size[2 * UINTMAX_STRSIZE_BOUND];
1043 /* holds formatted size or major,minor */
1044 char uintbuf[UINTMAX_STRSIZE_BOUND];
1048 if (test_label_option && current_header->header.typeflag != GNUTYPE_VOLHDR)
1051 if (show_transformed_names_option)
1052 temp_name = st->file_name ? st->file_name : st->orig_file_name;
1054 temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
1056 if (block_number_option)
1058 char buf[UINTMAX_STRSIZE_BOUND];
1059 if (block_ordinal < 0)
1060 block_ordinal = current_block_ordinal ();
1061 block_ordinal -= recent_long_name_blocks;
1062 block_ordinal -= recent_long_link_blocks;
1063 fprintf (stdlis, _("block %s: "),
1064 STRINGIFY_BIGINT (block_ordinal, buf));
1067 if (verbose_option <= 1)
1069 /* Just the fax, mam. */
1070 fprintf (stdlis, "%s\n", quotearg (temp_name));
1074 /* File type and modes. */
1077 switch (current_header->header.typeflag)
1079 case GNUTYPE_VOLHDR:
1083 case GNUTYPE_MULTIVOL:
1087 case GNUTYPE_LONGNAME:
1088 case GNUTYPE_LONGLINK:
1090 ERROR ((0, 0, _("Unexpected long name header")));
1093 case GNUTYPE_SPARSE:
1097 if (temp_name[strlen (temp_name) - 1] == '/')
1103 case GNUTYPE_DUMPDIR:
1126 pax_decode_mode (st->stat.st_mode, modes + 1);
1130 time_stamp = tartime (st->mtime, false);
1131 time_stamp_len = strlen (time_stamp);
1132 if (datewidth < time_stamp_len)
1133 datewidth = time_stamp_len;
1135 /* User and group names. */
1139 && current_format != V7_FORMAT
1140 && !numeric_owner_option)
1144 /* Try parsing it as an unsigned integer first, and as a
1145 uid_t if that fails. This method can list positive user
1146 ids that are too large to fit in a uid_t. */
1147 uintmax_t u = from_header (current_header->header.uid,
1148 sizeof current_header->header.uid, 0,
1150 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1153 user = STRINGIFY_BIGINT (u, uform);
1156 sprintf (uform, "%ld",
1157 (long) UID_FROM_HEADER (current_header->header.uid));
1164 && current_format != V7_FORMAT
1165 && !numeric_owner_option)
1169 /* Try parsing it as an unsigned integer first, and as a
1170 gid_t if that fails. This method can list positive group
1171 ids that are too large to fit in a gid_t. */
1172 uintmax_t g = from_header (current_header->header.gid,
1173 sizeof current_header->header.gid, 0,
1175 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1178 group = STRINGIFY_BIGINT (g, gform);
1181 sprintf (gform, "%ld",
1182 (long) GID_FROM_HEADER (current_header->header.gid));
1187 /* Format the file size or major/minor device numbers. */
1189 switch (current_header->header.typeflag)
1194 STRINGIFY_BIGINT (major (st->stat.st_rdev), uintbuf));
1197 STRINGIFY_BIGINT (minor (st->stat.st_rdev), uintbuf));
1201 /* st->stat.st_size keeps stored file size */
1202 strcpy (size, STRINGIFY_BIGINT (st->stat.st_size, uintbuf));
1206 /* Figure out padding and print the whole line. */
1208 sizelen = strlen (size);
1209 pad = strlen (user) + 1 + strlen (group) + 1 + sizelen;
1213 fprintf (stdlis, "%s %s/%s %*s %-*s",
1214 modes, user, group, ugswidth - pad + sizelen, size,
1215 datewidth, time_stamp);
1217 fprintf (stdlis, " %s", quotearg (temp_name));
1219 switch (current_header->header.typeflag)
1222 fprintf (stdlis, " -> %s\n", quotearg (st->link_name));
1226 fprintf (stdlis, _(" link to %s\n"), quotearg (st->link_name));
1231 char type_string[2];
1232 type_string[0] = current_header->header.typeflag;
1233 type_string[1] = '\0';
1234 fprintf (stdlis, _(" unknown file type %s\n"),
1235 quote (type_string));
1241 case GNUTYPE_SPARSE:
1247 case GNUTYPE_DUMPDIR:
1248 putc ('\n', stdlis);
1251 case GNUTYPE_LONGLINK:
1252 fprintf (stdlis, _("--Long Link--\n"));
1255 case GNUTYPE_LONGNAME:
1256 fprintf (stdlis, _("--Long Name--\n"));
1259 case GNUTYPE_VOLHDR:
1260 fprintf (stdlis, _("--Volume Header--\n"));
1263 case GNUTYPE_MULTIVOL:
1266 (UINTMAX_FROM_HEADER (current_header->oldgnu_header.offset),
1268 fprintf (stdlis, _("--Continued at byte %s--\n"), size);
1275 /* Print a similar line when we make a directory automatically. */
1277 print_for_mkdir (char *dirname, int length, mode_t mode)
1281 if (verbose_option > 1)
1283 /* File type and modes. */
1286 pax_decode_mode (mode, modes + 1);
1288 if (block_number_option)
1290 char buf[UINTMAX_STRSIZE_BOUND];
1291 fprintf (stdlis, _("block %s: "),
1292 STRINGIFY_BIGINT (current_block_ordinal (), buf));
1295 fprintf (stdlis, "%s %*s %.*s\n", modes, ugswidth + 1 + datewidth,
1296 _("Creating directory:"), length, quotearg (dirname));
1300 /* Skip over SIZE bytes of data in blocks in the archive. */
1302 skip_file (off_t size)
1306 /* FIXME: Make sure mv_begin is always called before it */
1308 if (seekable_archive)
1310 off_t nblk = seek_archive (size);
1312 size -= nblk * BLOCKSIZE;
1314 seekable_archive = false;
1317 mv_size_left (size);
1321 x = find_next_block ();
1323 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1325 set_next_block_after (x);
1327 mv_size_left (size);
1331 /* Skip the current member in the archive.
1332 NOTE: Current header must be decoded before calling this function. */
1336 if (!current_stat_info.skipped)
1338 char save_typeflag = current_header->header.typeflag;
1339 set_next_block_after (current_header);
1341 mv_begin (¤t_stat_info);
1343 if (current_stat_info.is_sparse)
1344 sparse_skip_file (¤t_stat_info);
1345 else if (save_typeflag != DIRTYPE)
1346 skip_file (current_stat_info.stat.st_size);