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 int type = *(int*)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, int type)
519 return transform_name_fp (pinput, type, 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);
641 switch (header->header.typeflag)
644 transform_member_name (&stat_info->link_name, XFORM_SYMLINK);
648 transform_member_name (&stat_info->link_name, XFORM_LINK);
652 /* Convert buffer at WHERE0 of size DIGS from external format to
653 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
654 are of type TYPE. The buffer must represent a value in the range
655 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
656 numbers instead of the other GNU extensions. Return -1 on error,
657 diagnosing the error if TYPE is nonnull and if !SILENT. */
659 from_header (char const *where0, size_t digs, char const *type,
660 uintmax_t minus_minval, uintmax_t maxval,
661 bool octal_only, bool silent)
664 char const *where = where0;
665 char const *lim = where + digs;
668 /* Accommodate buggy tar of unknown vintage, which outputs leading
669 NUL if the previous field overflows. */
672 /* Accommodate older tars, which output leading spaces. */
679 /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
680 _("Blanks in header where numeric %s value expected"),
684 if (!ISSPACE ((unsigned char) *where))
690 if (ISODIGIT (*where))
692 char const *where1 = where;
693 uintmax_t overflow = 0;
697 value += *where++ - '0';
698 if (where == lim || ! ISODIGIT (*where))
700 overflow |= value ^ (value << LG_8 >> LG_8);
704 /* Parse the output of older, unportable tars, which generate
705 negative values in two's complement octal. If the leading
706 nonzero digit is 1, we can't recover the original value
707 reliably; so do this only if the digit is 2 or more. This
708 catches the common case of 32-bit negative time stamps. */
709 if ((overflow || maxval < value) && '2' <= *where1 && type)
711 /* Compute the negative of the input value, assuming two's
713 int digit = (*where1 - '0') | 4;
721 if (where == lim || ! ISODIGIT (*where))
723 digit = *where - '0';
724 overflow |= value ^ (value << LG_8 >> LG_8);
730 if (!overflow && value <= minus_minval)
734 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
735 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
736 (int) (where - where1), where1, type));
745 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
746 _("Archive octal value %.*s is out of %s range"),
747 (int) (where - where1), where1, type));
753 /* Suppress the following extensions. */
755 else if (*where == '-' || *where == '+')
757 /* Parse base-64 output produced only by tar test versions
758 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
759 Support for this will be withdrawn in future releases. */
763 static bool warned_once;
767 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
770 negative = *where++ == '-';
772 && (dig = base64_map[(unsigned char) *where]) < 64)
774 if (value << LG_64 >> LG_64 != value)
776 char *string = alloca (digs + 1);
777 memcpy (string, where0, digs);
781 _("Archive signed base-64 string %s is out of %s range"),
782 quote (string), type));
785 value = (value << LG_64) | dig;
789 else if (*where == '\200' /* positive base-256 */
790 || *where == '\377' /* negative base-256 */)
792 /* Parse base-256 output. A nonnegative number N is
793 represented as (256**DIGS)/2 + N; a negative number -N is
794 represented as (256**DIGS) - N, i.e. as two's complement.
795 The representation guarantees that the leading bit is
796 always on, so that we don't confuse this format with the
797 others (assuming ASCII bytes of 8 bits or more). */
798 int signbit = *where & (1 << (LG_256 - 2));
799 uintmax_t topbits = (((uintmax_t) - signbit)
800 << (CHAR_BIT * sizeof (uintmax_t)
801 - LG_256 - (LG_256 - 2)));
802 value = (*where++ & ((1 << (LG_256 - 2)) - 1)) - signbit;
805 value = (value << LG_256) + (unsigned char) *where++;
808 if (((value << LG_256 >> LG_256) | topbits) != value)
812 _("Archive base-256 value is out of %s range"),
822 if (where != lim && *where && !ISSPACE ((unsigned char) *where))
826 char buf[1000]; /* Big enough to represent any header. */
827 static struct quoting_options *o;
831 o = clone_quoting_options (0);
832 set_quoting_style (o, locale_quoting_style);
835 while (where0 != lim && ! lim[-1])
837 quotearg_buffer (buf, sizeof buf, where0, lim - where, o);
840 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
841 _("Archive contains %.*s where numeric %s value expected"),
842 (int) sizeof buf, buf, type));
848 if (value <= (negative ? minus_minval : maxval))
849 return negative ? -value : value;
853 char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
854 char maxval_buf[UINTMAX_STRSIZE_BOUND];
855 char value_buf[UINTMAX_STRSIZE_BOUND + 1];
856 char *minval_string = STRINGIFY_BIGINT (minus_minval, minval_buf + 1);
857 char *value_string = STRINGIFY_BIGINT (value, value_buf + 1);
859 *--value_string = '-';
861 *--minval_string = '-';
862 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
863 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
865 minval_string, STRINGIFY_BIGINT (maxval, maxval_buf)));
872 gid_from_header (const char *p, size_t s)
874 return from_header (p, s, "gid_t",
875 - (uintmax_t) TYPE_MINIMUM (gid_t),
876 (uintmax_t) TYPE_MAXIMUM (gid_t),
881 major_from_header (const char *p, size_t s)
883 return from_header (p, s, "major_t",
884 - (uintmax_t) TYPE_MINIMUM (major_t),
885 (uintmax_t) TYPE_MAXIMUM (major_t), false, false);
889 minor_from_header (const char *p, size_t s)
891 return from_header (p, s, "minor_t",
892 - (uintmax_t) TYPE_MINIMUM (minor_t),
893 (uintmax_t) TYPE_MAXIMUM (minor_t), false, false);
897 mode_from_header (const char *p, size_t s)
899 /* Do not complain about unrecognized mode bits. */
900 unsigned u = from_header (p, s, "mode_t",
901 - (uintmax_t) TYPE_MINIMUM (mode_t),
902 TYPE_MAXIMUM (uintmax_t), false, false);
903 return ((u & TSUID ? S_ISUID : 0)
904 | (u & TSGID ? S_ISGID : 0)
905 | (u & TSVTX ? S_ISVTX : 0)
906 | (u & TUREAD ? S_IRUSR : 0)
907 | (u & TUWRITE ? S_IWUSR : 0)
908 | (u & TUEXEC ? S_IXUSR : 0)
909 | (u & TGREAD ? S_IRGRP : 0)
910 | (u & TGWRITE ? S_IWGRP : 0)
911 | (u & TGEXEC ? S_IXGRP : 0)
912 | (u & TOREAD ? S_IROTH : 0)
913 | (u & TOWRITE ? S_IWOTH : 0)
914 | (u & TOEXEC ? S_IXOTH : 0));
918 off_from_header (const char *p, size_t s)
920 /* Negative offsets are not allowed in tar files, so invoke
921 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
922 return from_header (p, s, "off_t", (uintmax_t) 0,
923 (uintmax_t) TYPE_MAXIMUM (off_t), false, false);
927 size_from_header (const char *p, size_t s)
929 return from_header (p, s, "size_t", (uintmax_t) 0,
930 (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
934 time_from_header (const char *p, size_t s)
936 return from_header (p, s, "time_t",
937 - (uintmax_t) TYPE_MINIMUM (time_t),
938 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
942 uid_from_header (const char *p, size_t s)
944 return from_header (p, s, "uid_t",
945 - (uintmax_t) TYPE_MINIMUM (uid_t),
946 (uintmax_t) TYPE_MAXIMUM (uid_t), false, false);
950 uintmax_from_header (const char *p, size_t s)
952 return from_header (p, s, "uintmax_t", (uintmax_t) 0,
953 TYPE_MAXIMUM (uintmax_t), false, false);
957 /* Return a printable representation of T. The result points to
958 static storage that can be reused in the next call to this
959 function, to ctime, or to asctime. If FULL_TIME, then output the
960 time stamp to its full resolution; otherwise, just output it to
961 1-minute resolution. */
963 tartime (struct timespec t, bool full_time)
965 enum { fraclen = sizeof ".FFFFFFFFF" - 1 };
966 static char buffer[max (UINTMAX_STRSIZE_BOUND + 1,
967 INT_STRLEN_BOUND (int) + 16)
972 bool negative = s < 0;
975 if (negative && ns != 0)
978 ns = 1000000000 - ns;
981 tm = utc_option ? gmtime (&s) : localtime (&s);
986 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d:%02d",
987 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
988 tm->tm_hour, tm->tm_min, tm->tm_sec);
989 code_ns_fraction (ns, buffer + strlen (buffer));
992 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d",
993 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
994 tm->tm_hour, tm->tm_min);
998 /* The time stamp cannot be broken down, most likely because it
999 is out of range. Convert it as an integer,
1000 right-adjusted in a field with the same width as the usual
1001 4-year ISO time format. */
1002 p = umaxtostr (negative ? - (uintmax_t) s : s,
1003 buffer + sizeof buffer - UINTMAX_STRSIZE_BOUND - fraclen);
1006 while ((buffer + sizeof buffer - sizeof "YYYY-MM-DD HH:MM"
1007 + (full_time ? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1011 code_ns_fraction (ns, buffer + sizeof buffer - 1 - fraclen);
1015 /* Actually print it.
1017 Plain and fancy file header block logging. Non-verbose just prints
1018 the name, e.g. for "tar t" or "tar x". This should just contain
1019 file names, so it can be fed back into tar with xargs or the "-T"
1020 option. The verbose option can give a bunch of info, one line per
1021 file. I doubt anybody tries to parse its format, or if they do,
1022 they shouldn't. Unix tar is pretty random here anyway. */
1025 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
1026 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
1028 /* Width of "user/group size", with initial value chosen
1029 heuristically. This grows as needed, though this may cause some
1030 stairstepping in the output. Make it too small and the output will
1031 almost always look ragged. Make it too large and the output will
1032 be spaced out too far. */
1033 static int ugswidth = 19;
1035 /* Width of printed time stamps. It grows if longer time stamps are
1036 found (typically, those with nanosecond resolution). Like
1037 USGWIDTH, some stairstepping may occur. */
1038 static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1;
1041 print_header (struct tar_stat_info *st, off_t block_ordinal)
1044 char const *time_stamp;
1048 /* These hold formatted ints. */
1049 char uform[UINTMAX_STRSIZE_BOUND], gform[UINTMAX_STRSIZE_BOUND];
1051 char size[2 * UINTMAX_STRSIZE_BOUND];
1052 /* holds formatted size or major,minor */
1053 char uintbuf[UINTMAX_STRSIZE_BOUND];
1057 if (test_label_option && current_header->header.typeflag != GNUTYPE_VOLHDR)
1060 if (show_transformed_names_option)
1061 temp_name = st->file_name ? st->file_name : st->orig_file_name;
1063 temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
1065 if (block_number_option)
1067 char buf[UINTMAX_STRSIZE_BOUND];
1068 if (block_ordinal < 0)
1069 block_ordinal = current_block_ordinal ();
1070 block_ordinal -= recent_long_name_blocks;
1071 block_ordinal -= recent_long_link_blocks;
1072 fprintf (stdlis, _("block %s: "),
1073 STRINGIFY_BIGINT (block_ordinal, buf));
1076 if (verbose_option <= 1)
1078 /* Just the fax, mam. */
1079 fprintf (stdlis, "%s\n", quotearg (temp_name));
1083 /* File type and modes. */
1086 switch (current_header->header.typeflag)
1088 case GNUTYPE_VOLHDR:
1092 case GNUTYPE_MULTIVOL:
1096 case GNUTYPE_LONGNAME:
1097 case GNUTYPE_LONGLINK:
1099 ERROR ((0, 0, _("Unexpected long name header")));
1102 case GNUTYPE_SPARSE:
1106 if (temp_name[strlen (temp_name) - 1] == '/')
1112 case GNUTYPE_DUMPDIR:
1135 pax_decode_mode (st->stat.st_mode, modes + 1);
1139 time_stamp = tartime (st->mtime, false);
1140 time_stamp_len = strlen (time_stamp);
1141 if (datewidth < time_stamp_len)
1142 datewidth = time_stamp_len;
1144 /* User and group names. */
1148 && current_format != V7_FORMAT
1149 && !numeric_owner_option)
1153 /* Try parsing it as an unsigned integer first, and as a
1154 uid_t if that fails. This method can list positive user
1155 ids that are too large to fit in a uid_t. */
1156 uintmax_t u = from_header (current_header->header.uid,
1157 sizeof current_header->header.uid, 0,
1159 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1162 user = STRINGIFY_BIGINT (u, uform);
1165 sprintf (uform, "%ld",
1166 (long) UID_FROM_HEADER (current_header->header.uid));
1173 && current_format != V7_FORMAT
1174 && !numeric_owner_option)
1178 /* Try parsing it as an unsigned integer first, and as a
1179 gid_t if that fails. This method can list positive group
1180 ids that are too large to fit in a gid_t. */
1181 uintmax_t g = from_header (current_header->header.gid,
1182 sizeof current_header->header.gid, 0,
1184 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1187 group = STRINGIFY_BIGINT (g, gform);
1190 sprintf (gform, "%ld",
1191 (long) GID_FROM_HEADER (current_header->header.gid));
1196 /* Format the file size or major/minor device numbers. */
1198 switch (current_header->header.typeflag)
1203 STRINGIFY_BIGINT (major (st->stat.st_rdev), uintbuf));
1206 STRINGIFY_BIGINT (minor (st->stat.st_rdev), uintbuf));
1210 /* st->stat.st_size keeps stored file size */
1211 strcpy (size, STRINGIFY_BIGINT (st->stat.st_size, uintbuf));
1215 /* Figure out padding and print the whole line. */
1217 sizelen = strlen (size);
1218 pad = strlen (user) + 1 + strlen (group) + 1 + sizelen;
1222 fprintf (stdlis, "%s %s/%s %*s %-*s",
1223 modes, user, group, ugswidth - pad + sizelen, size,
1224 datewidth, time_stamp);
1226 fprintf (stdlis, " %s", quotearg (temp_name));
1228 switch (current_header->header.typeflag)
1231 fprintf (stdlis, " -> %s\n", quotearg (st->link_name));
1235 fprintf (stdlis, _(" link to %s\n"), quotearg (st->link_name));
1240 char type_string[2];
1241 type_string[0] = current_header->header.typeflag;
1242 type_string[1] = '\0';
1243 fprintf (stdlis, _(" unknown file type %s\n"),
1244 quote (type_string));
1250 case GNUTYPE_SPARSE:
1256 case GNUTYPE_DUMPDIR:
1257 putc ('\n', stdlis);
1260 case GNUTYPE_LONGLINK:
1261 fprintf (stdlis, _("--Long Link--\n"));
1264 case GNUTYPE_LONGNAME:
1265 fprintf (stdlis, _("--Long Name--\n"));
1268 case GNUTYPE_VOLHDR:
1269 fprintf (stdlis, _("--Volume Header--\n"));
1272 case GNUTYPE_MULTIVOL:
1275 (UINTMAX_FROM_HEADER (current_header->oldgnu_header.offset),
1277 fprintf (stdlis, _("--Continued at byte %s--\n"), size);
1284 /* Print a similar line when we make a directory automatically. */
1286 print_for_mkdir (char *dirname, int length, mode_t mode)
1290 if (verbose_option > 1)
1292 /* File type and modes. */
1295 pax_decode_mode (mode, modes + 1);
1297 if (block_number_option)
1299 char buf[UINTMAX_STRSIZE_BOUND];
1300 fprintf (stdlis, _("block %s: "),
1301 STRINGIFY_BIGINT (current_block_ordinal (), buf));
1304 fprintf (stdlis, "%s %*s %.*s\n", modes, ugswidth + 1 + datewidth,
1305 _("Creating directory:"), length, quotearg (dirname));
1309 /* Skip over SIZE bytes of data in blocks in the archive. */
1311 skip_file (off_t size)
1315 /* FIXME: Make sure mv_begin is always called before it */
1317 if (seekable_archive)
1319 off_t nblk = seek_archive (size);
1321 size -= nblk * BLOCKSIZE;
1323 seekable_archive = false;
1326 mv_size_left (size);
1330 x = find_next_block ();
1332 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1334 set_next_block_after (x);
1336 mv_size_left (size);
1340 /* Skip the current member in the archive.
1341 NOTE: Current header must be decoded before calling this function. */
1345 if (!current_stat_info.skipped)
1347 char save_typeflag = current_header->header.typeflag;
1348 set_next_block_after (current_header);
1350 mv_begin (¤t_stat_info);
1352 if (current_stat_info.is_sparse)
1353 sparse_skip_file (¤t_stat_info);
1354 else if (save_typeflag != DIRTYPE)
1355 skip_file (current_stat_info.stat.st_size);