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)
139 char buf[UINTMAX_STRSIZE_BOUND];
141 status = read_header (false);
142 if (status == HEADER_ZERO_BLOCK)
145 * According to POSIX tar specs, this is wrong, but on the web
146 * there are some tar specs that can trigger this, and some tar
147 * implementations create tars according to that spec. For now,
148 * let's not be pedantic about issuing the warning.
151 WARN ((0, 0, _("A lone zero block at %s"),
152 STRINGIFY_BIGINT (current_block_ordinal (), buf)));
156 status = prev_status;
159 case HEADER_END_OF_FILE:
160 if (block_number_option)
162 char buf[UINTMAX_STRSIZE_BOUND];
163 fprintf (stdlis, _("block %s: ** End of File **\n"),
164 STRINGIFY_BIGINT (current_block_ordinal (), buf));
169 /* If the previous header was good, tell them that we are
170 skipping bad ones. */
171 set_next_block_after (current_header);
174 case HEADER_STILL_UNREAD:
175 ERROR ((0, 0, _("This does not look like a tar archive")));
178 case HEADER_ZERO_BLOCK:
180 if (block_number_option)
182 char buf[UINTMAX_STRSIZE_BOUND];
183 off_t block_ordinal = current_block_ordinal ();
184 block_ordinal -= recent_long_name_blocks;
185 block_ordinal -= recent_long_link_blocks;
186 fprintf (stdlis, _("block %s: "),
187 STRINGIFY_BIGINT (block_ordinal, buf));
189 ERROR ((0, 0, _("Skipping to next header")));
192 case HEADER_END_OF_FILE:
194 /* We are in the middle of a cascade of errors. */
197 case HEADER_SUCCESS_EXTENDED:
204 while (!all_names_found (¤t_stat_info));
207 names_notfound (); /* print names not found */
210 /* Print a header block, based on tar options. */
214 off_t block_ordinal = current_block_ordinal ();
215 /* Print the header block. */
217 decode_header (current_header, ¤t_stat_info, ¤t_format, 0);
219 print_header (¤t_stat_info, block_ordinal);
221 if (incremental_option)
223 if (verbose_option > 2)
225 if (is_dumpdir (¤t_stat_info))
226 list_dumpdir (current_stat_info.dumpdir,
227 dumpdir_size (current_stat_info.dumpdir));
234 /* Check header checksum */
235 /* The standard BSD tar sources create the checksum by adding up the
236 bytes in the header as type char. I think the type char was unsigned
237 on the PDP-11, but it's signed on the Next and Sun. It looks like the
238 sources to BSD tar were never changed to compute the checksum
239 correctly, so both the Sun and Next add the bytes of the header as
240 signed chars. This doesn't cause a problem until you get a file with
241 a name containing characters with the high bit set. So tar_checksum
242 computes two checksums -- signed and unsigned. */
245 tar_checksum (union block *header, bool silent)
248 int unsigned_sum = 0; /* the POSIX one :-) */
249 int signed_sum = 0; /* the Sun one :-( */
251 uintmax_t parsed_sum;
255 for (i = sizeof *header; i-- != 0;)
257 unsigned_sum += (unsigned char) *p;
258 signed_sum += (signed char) (*p++);
261 if (unsigned_sum == 0)
262 return HEADER_ZERO_BLOCK;
264 /* Adjust checksum to count the "chksum" field as blanks. */
266 for (i = sizeof header->header.chksum; i-- != 0;)
268 unsigned_sum -= (unsigned char) header->header.chksum[i];
269 signed_sum -= (signed char) (header->header.chksum[i]);
271 unsigned_sum += ' ' * sizeof header->header.chksum;
272 signed_sum += ' ' * sizeof header->header.chksum;
274 parsed_sum = from_header (header->header.chksum,
275 sizeof header->header.chksum, 0,
277 (uintmax_t) TYPE_MAXIMUM (int), true, silent);
278 if (parsed_sum == (uintmax_t) -1)
279 return HEADER_FAILURE;
281 recorded_sum = parsed_sum;
283 if (unsigned_sum != recorded_sum && signed_sum != recorded_sum)
284 return HEADER_FAILURE;
286 return HEADER_SUCCESS;
289 /* Read a block that's supposed to be a header block. Return its
290 address in "current_header", and if it is good, the file's size
291 and names (file name, link name) in *info.
293 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
294 block full of zeros (EOF marker).
296 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
297 GNU long name and link headers into later headers.
299 You must always set_next_block_after(current_header) to skip past
300 the header which this routine reads. */
303 read_header_primitive (bool raw_extended_headers, struct tar_stat_info *info)
306 union block *header_copy;
308 union block *data_block;
309 size_t size, written;
310 union block *next_long_name = 0;
311 union block *next_long_link = 0;
312 size_t next_long_name_blocks = 0;
313 size_t next_long_link_blocks = 0;
317 enum read_header status;
319 header = find_next_block ();
320 current_header = header;
322 return HEADER_END_OF_FILE;
324 if ((status = tar_checksum (header, false)) != HEADER_SUCCESS)
327 /* Good block. Decode file size and return. */
329 if (header->header.typeflag == LNKTYPE)
330 info->stat.st_size = 0; /* links 0 size on tape */
332 info->stat.st_size = OFF_FROM_HEADER (header->header.size);
334 if (header->header.typeflag == GNUTYPE_LONGNAME
335 || header->header.typeflag == GNUTYPE_LONGLINK
336 || header->header.typeflag == XHDTYPE
337 || header->header.typeflag == XGLTYPE
338 || header->header.typeflag == SOLARIS_XHDTYPE)
340 if (raw_extended_headers)
341 return HEADER_SUCCESS_EXTENDED;
342 else if (header->header.typeflag == GNUTYPE_LONGNAME
343 || header->header.typeflag == GNUTYPE_LONGLINK)
345 size_t name_size = info->stat.st_size;
346 size_t n = name_size % BLOCKSIZE;
347 size = name_size + BLOCKSIZE;
349 size += BLOCKSIZE - n;
351 if (name_size != info->stat.st_size || size < name_size)
354 header_copy = xmalloc (size + 1);
356 if (header->header.typeflag == GNUTYPE_LONGNAME)
359 free (next_long_name);
360 next_long_name = header_copy;
361 next_long_name_blocks = size / BLOCKSIZE;
366 free (next_long_link);
367 next_long_link = header_copy;
368 next_long_link_blocks = size / BLOCKSIZE;
371 set_next_block_after (header);
372 *header_copy = *header;
373 bp = header_copy->buffer + BLOCKSIZE;
375 for (size -= BLOCKSIZE; size > 0; size -= written)
377 data_block = find_next_block ();
380 ERROR ((0, 0, _("Unexpected EOF in archive")));
383 written = available_space_after (data_block);
387 memcpy (bp, data_block->buffer, written);
389 set_next_block_after ((union block *)
390 (data_block->buffer + written - 1));
395 else if (header->header.typeflag == XHDTYPE
396 || header->header.typeflag == SOLARIS_XHDTYPE)
397 xheader_read (&info->xhdr, header,
398 OFF_FROM_HEADER (header->header.size));
399 else if (header->header.typeflag == XGLTYPE)
402 memset (&xhdr, 0, sizeof xhdr);
403 xheader_read (&xhdr, header,
404 OFF_FROM_HEADER (header->header.size));
405 xheader_decode_global (&xhdr);
406 xheader_destroy (&xhdr);
415 struct posix_header const *h = ¤t_header->header;
416 char namebuf[sizeof h->prefix + 1 + NAME_FIELD_SIZE + 1];
418 if (recent_long_name)
419 free (recent_long_name);
423 name = next_long_name->buffer + BLOCKSIZE;
424 recent_long_name = next_long_name;
425 recent_long_name_blocks = next_long_name_blocks;
429 /* Accept file names as specified by POSIX.1-1996
433 if (h->prefix[0] && strcmp (h->magic, TMAGIC) == 0)
435 memcpy (np, h->prefix, sizeof h->prefix);
436 np[sizeof h->prefix] = '\0';
440 memcpy (np, h->name, sizeof h->name);
441 np[sizeof h->name] = '\0';
443 recent_long_name = 0;
444 recent_long_name_blocks = 0;
446 assign_string (&info->orig_file_name, name);
447 assign_string (&info->file_name, name);
448 info->had_trailing_slash = strip_trailing_slashes (info->file_name);
450 if (recent_long_link)
451 free (recent_long_link);
455 name = next_long_link->buffer + BLOCKSIZE;
456 recent_long_link = next_long_link;
457 recent_long_link_blocks = next_long_link_blocks;
461 memcpy (namebuf, h->linkname, sizeof h->linkname);
462 namebuf[sizeof h->linkname] = '\0';
464 recent_long_link = 0;
465 recent_long_link_blocks = 0;
467 assign_string (&info->link_name, name);
469 return HEADER_SUCCESS;
475 read_header (bool raw_extended_headers)
477 return read_header_primitive (raw_extended_headers, ¤t_stat_info);
481 decode_xform (char *file_name, void *data)
483 int type = *(int*)data;
488 /* FIXME: It is not quite clear how and to which extent are the symbolic
489 links subject to filename transformation. In the absence of another
490 solution, symbolic links are exempt from component stripping and
491 name suffix normalization, but subject to filename transformation
496 file_name = safer_name_suffix (file_name, true, absolute_names_option);
500 file_name = safer_name_suffix (file_name, false, absolute_names_option);
504 if (strip_name_components)
506 size_t prefix_len = stripped_prefix_len (file_name,
507 strip_name_components);
508 if (prefix_len == (size_t) -1)
509 prefix_len = strlen (file_name);
510 file_name += prefix_len;
516 transform_member_name (char **pinput, int type)
518 return transform_name_fp (pinput, type, decode_xform, &type);
521 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
523 /* Decode things from a file HEADER block into STAT_INFO, also setting
524 *FORMAT_POINTER depending on the header block format. If
525 DO_USER_GROUP, decode the user/group information (this is useful
526 for extraction, but waste time when merely listing).
528 read_header() has already decoded the checksum and length, so we don't.
530 This routine should *not* be called twice for the same block, since
531 the two calls might use different DO_USER_GROUP values and thus
532 might end up with different uid/gid for the two calls. If anybody
533 wants the uid/gid they should decode it first, and other callers
534 should decode it without uid/gid before calling a routine,
535 e.g. print_header, that assumes decoded data. */
537 decode_header (union block *header, struct tar_stat_info *stat_info,
538 enum archive_format *format_pointer, int do_user_group)
540 enum archive_format format;
542 if (strcmp (header->header.magic, TMAGIC) == 0)
544 if (header->star_header.prefix[130] == 0
545 && ISOCTAL (header->star_header.atime[0])
546 && header->star_header.atime[11] == ' '
547 && ISOCTAL (header->star_header.ctime[0])
548 && header->star_header.ctime[11] == ' ')
549 format = STAR_FORMAT;
550 else if (stat_info->xhdr.size)
551 format = POSIX_FORMAT;
553 format = USTAR_FORMAT;
555 else if (strcmp (header->header.magic, OLDGNU_MAGIC) == 0)
556 format = OLDGNU_FORMAT;
559 *format_pointer = format;
561 stat_info->stat.st_mode = MODE_FROM_HEADER (header->header.mode);
562 stat_info->mtime.tv_sec = TIME_FROM_HEADER (header->header.mtime);
563 stat_info->mtime.tv_nsec = 0;
564 assign_string (&stat_info->uname,
565 header->header.uname[0] ? header->header.uname : NULL);
566 assign_string (&stat_info->gname,
567 header->header.gname[0] ? header->header.gname : NULL);
569 if (format == OLDGNU_FORMAT && incremental_option)
571 stat_info->atime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.atime);
572 stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.ctime);
573 stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
575 else if (format == STAR_FORMAT)
577 stat_info->atime.tv_sec = TIME_FROM_HEADER (header->star_header.atime);
578 stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->star_header.ctime);
579 stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
582 stat_info->atime = stat_info->ctime = start_time;
584 if (format == V7_FORMAT)
586 stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
587 stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
588 stat_info->stat.st_rdev = 0;
594 /* FIXME: Decide if this should somewhat depend on -p. */
596 if (numeric_owner_option
597 || !*header->header.uname
598 || !uname_to_uid (header->header.uname, &stat_info->stat.st_uid))
599 stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
601 if (numeric_owner_option
602 || !*header->header.gname
603 || !gname_to_gid (header->header.gname, &stat_info->stat.st_gid))
604 stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
607 switch (header->header.typeflag)
611 stat_info->stat.st_rdev =
612 makedev (MAJOR_FROM_HEADER (header->header.devmajor),
613 MINOR_FROM_HEADER (header->header.devminor));
617 stat_info->stat.st_rdev = 0;
621 stat_info->archive_file_size = stat_info->stat.st_size;
622 xheader_decode (stat_info);
624 if (sparse_member_p (stat_info))
626 sparse_fixup_header (stat_info);
627 stat_info->is_sparse = true;
631 stat_info->is_sparse = false;
632 if (((current_format == GNU_FORMAT
633 || current_format == OLDGNU_FORMAT)
634 && current_header->header.typeflag == GNUTYPE_DUMPDIR)
635 || stat_info->dumpdir)
636 stat_info->is_dumpdir = true;
639 transform_member_name (&stat_info->file_name, XFORM_REGFILE);
640 switch (header->header.typeflag)
643 transform_member_name (&stat_info->link_name, XFORM_SYMLINK);
647 transform_member_name (&stat_info->link_name, XFORM_LINK);
651 /* Convert buffer at WHERE0 of size DIGS from external format to
652 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
653 are of type TYPE. The buffer must represent a value in the range
654 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
655 numbers instead of the other GNU extensions. Return -1 on error,
656 diagnosing the error if TYPE is nonnull and if !SILENT. */
658 from_header (char const *where0, size_t digs, char const *type,
659 uintmax_t minus_minval, uintmax_t maxval,
660 bool octal_only, bool silent)
663 char const *where = where0;
664 char const *lim = where + digs;
667 /* Accommodate buggy tar of unknown vintage, which outputs leading
668 NUL if the previous field overflows. */
671 /* Accommodate older tars, which output leading spaces. */
678 /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
679 _("Blanks in header where numeric %s value expected"),
683 if (!ISSPACE ((unsigned char) *where))
689 if (ISODIGIT (*where))
691 char const *where1 = where;
692 uintmax_t overflow = 0;
696 value += *where++ - '0';
697 if (where == lim || ! ISODIGIT (*where))
699 overflow |= value ^ (value << LG_8 >> LG_8);
703 /* Parse the output of older, unportable tars, which generate
704 negative values in two's complement octal. If the leading
705 nonzero digit is 1, we can't recover the original value
706 reliably; so do this only if the digit is 2 or more. This
707 catches the common case of 32-bit negative time stamps. */
708 if ((overflow || maxval < value) && '2' <= *where1 && type)
710 /* Compute the negative of the input value, assuming two's
712 int digit = (*where1 - '0') | 4;
720 if (where == lim || ! ISODIGIT (*where))
722 digit = *where - '0';
723 overflow |= value ^ (value << LG_8 >> LG_8);
729 if (!overflow && value <= minus_minval)
733 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
734 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
735 (int) (where - where1), where1, type));
744 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
745 _("Archive octal value %.*s is out of %s range"),
746 (int) (where - where1), where1, type));
752 /* Suppress the following extensions. */
754 else if (*where == '-' || *where == '+')
756 /* Parse base-64 output produced only by tar test versions
757 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
758 Support for this will be withdrawn in future releases. */
762 static bool warned_once;
766 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
769 negative = *where++ == '-';
771 && (dig = base64_map[(unsigned char) *where]) < 64)
773 if (value << LG_64 >> LG_64 != value)
775 char *string = alloca (digs + 1);
776 memcpy (string, where0, digs);
780 _("Archive signed base-64 string %s is out of %s range"),
781 quote (string), type));
784 value = (value << LG_64) | dig;
788 else if (*where == '\200' /* positive base-256 */
789 || *where == '\377' /* negative base-256 */)
791 /* Parse base-256 output. A nonnegative number N is
792 represented as (256**DIGS)/2 + N; a negative number -N is
793 represented as (256**DIGS) - N, i.e. as two's complement.
794 The representation guarantees that the leading bit is
795 always on, so that we don't confuse this format with the
796 others (assuming ASCII bytes of 8 bits or more). */
797 int signbit = *where & (1 << (LG_256 - 2));
798 uintmax_t topbits = (((uintmax_t) - signbit)
799 << (CHAR_BIT * sizeof (uintmax_t)
800 - LG_256 - (LG_256 - 2)));
801 value = (*where++ & ((1 << (LG_256 - 2)) - 1)) - signbit;
804 value = (value << LG_256) + (unsigned char) *where++;
807 if (((value << LG_256 >> LG_256) | topbits) != value)
811 _("Archive base-256 value is out of %s range"),
821 if (where != lim && *where && !ISSPACE ((unsigned char) *where))
825 char buf[1000]; /* Big enough to represent any header. */
826 static struct quoting_options *o;
830 o = clone_quoting_options (0);
831 set_quoting_style (o, locale_quoting_style);
834 while (where0 != lim && ! lim[-1])
836 quotearg_buffer (buf, sizeof buf, where0, lim - where, o);
839 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
840 _("Archive contains %.*s where numeric %s value expected"),
841 (int) sizeof buf, buf, type));
847 if (value <= (negative ? minus_minval : maxval))
848 return negative ? -value : value;
852 char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
853 char maxval_buf[UINTMAX_STRSIZE_BOUND];
854 char value_buf[UINTMAX_STRSIZE_BOUND + 1];
855 char *minval_string = STRINGIFY_BIGINT (minus_minval, minval_buf + 1);
856 char *value_string = STRINGIFY_BIGINT (value, value_buf + 1);
858 *--value_string = '-';
860 *--minval_string = '-';
861 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
862 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
864 minval_string, STRINGIFY_BIGINT (maxval, maxval_buf)));
871 gid_from_header (const char *p, size_t s)
873 return from_header (p, s, "gid_t",
874 - (uintmax_t) TYPE_MINIMUM (gid_t),
875 (uintmax_t) TYPE_MAXIMUM (gid_t),
880 major_from_header (const char *p, size_t s)
882 return from_header (p, s, "major_t",
883 - (uintmax_t) TYPE_MINIMUM (major_t),
884 (uintmax_t) TYPE_MAXIMUM (major_t), false, false);
888 minor_from_header (const char *p, size_t s)
890 return from_header (p, s, "minor_t",
891 - (uintmax_t) TYPE_MINIMUM (minor_t),
892 (uintmax_t) TYPE_MAXIMUM (minor_t), false, false);
896 mode_from_header (const char *p, size_t s)
898 /* Do not complain about unrecognized mode bits. */
899 unsigned u = from_header (p, s, "mode_t",
900 - (uintmax_t) TYPE_MINIMUM (mode_t),
901 TYPE_MAXIMUM (uintmax_t), false, false);
902 return ((u & TSUID ? S_ISUID : 0)
903 | (u & TSGID ? S_ISGID : 0)
904 | (u & TSVTX ? S_ISVTX : 0)
905 | (u & TUREAD ? S_IRUSR : 0)
906 | (u & TUWRITE ? S_IWUSR : 0)
907 | (u & TUEXEC ? S_IXUSR : 0)
908 | (u & TGREAD ? S_IRGRP : 0)
909 | (u & TGWRITE ? S_IWGRP : 0)
910 | (u & TGEXEC ? S_IXGRP : 0)
911 | (u & TOREAD ? S_IROTH : 0)
912 | (u & TOWRITE ? S_IWOTH : 0)
913 | (u & TOEXEC ? S_IXOTH : 0));
917 off_from_header (const char *p, size_t s)
919 /* Negative offsets are not allowed in tar files, so invoke
920 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
921 return from_header (p, s, "off_t", (uintmax_t) 0,
922 (uintmax_t) TYPE_MAXIMUM (off_t), false, false);
926 size_from_header (const char *p, size_t s)
928 return from_header (p, s, "size_t", (uintmax_t) 0,
929 (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
933 time_from_header (const char *p, size_t s)
935 return from_header (p, s, "time_t",
936 - (uintmax_t) TYPE_MINIMUM (time_t),
937 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
941 uid_from_header (const char *p, size_t s)
943 return from_header (p, s, "uid_t",
944 - (uintmax_t) TYPE_MINIMUM (uid_t),
945 (uintmax_t) TYPE_MAXIMUM (uid_t), false, false);
949 uintmax_from_header (const char *p, size_t s)
951 return from_header (p, s, "uintmax_t", (uintmax_t) 0,
952 TYPE_MAXIMUM (uintmax_t), false, false);
956 /* Return a printable representation of T. The result points to
957 static storage that can be reused in the next call to this
958 function, to ctime, or to asctime. If FULL_TIME, then output the
959 time stamp to its full resolution; otherwise, just output it to
960 1-minute resolution. */
962 tartime (struct timespec t, bool full_time)
964 enum { fraclen = sizeof ".FFFFFFFFF" - 1 };
965 static char buffer[max (UINTMAX_STRSIZE_BOUND + 1,
966 INT_STRLEN_BOUND (int) + 16)
971 bool negative = s < 0;
974 if (negative && ns != 0)
977 ns = 1000000000 - ns;
980 tm = utc_option ? gmtime (&s) : localtime (&s);
985 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d:%02d",
986 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
987 tm->tm_hour, tm->tm_min, tm->tm_sec);
988 code_ns_fraction (ns, buffer + strlen (buffer));
991 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d",
992 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
993 tm->tm_hour, tm->tm_min);
997 /* The time stamp cannot be broken down, most likely because it
998 is out of range. Convert it as an integer,
999 right-adjusted in a field with the same width as the usual
1000 4-year ISO time format. */
1001 p = umaxtostr (negative ? - (uintmax_t) s : s,
1002 buffer + sizeof buffer - UINTMAX_STRSIZE_BOUND - fraclen);
1005 while ((buffer + sizeof buffer - sizeof "YYYY-MM-DD HH:MM"
1006 + (full_time ? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1010 code_ns_fraction (ns, buffer + sizeof buffer - 1 - fraclen);
1014 /* Actually print it.
1016 Plain and fancy file header block logging. Non-verbose just prints
1017 the name, e.g. for "tar t" or "tar x". This should just contain
1018 file names, so it can be fed back into tar with xargs or the "-T"
1019 option. The verbose option can give a bunch of info, one line per
1020 file. I doubt anybody tries to parse its format, or if they do,
1021 they shouldn't. Unix tar is pretty random here anyway. */
1024 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
1025 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
1027 /* Width of "user/group size", with initial value chosen
1028 heuristically. This grows as needed, though this may cause some
1029 stairstepping in the output. Make it too small and the output will
1030 almost always look ragged. Make it too large and the output will
1031 be spaced out too far. */
1032 static int ugswidth = 19;
1034 /* Width of printed time stamps. It grows if longer time stamps are
1035 found (typically, those with nanosecond resolution). Like
1036 USGWIDTH, some stairstepping may occur. */
1037 static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1;
1040 print_header (struct tar_stat_info *st, off_t block_ordinal)
1043 char const *time_stamp;
1047 /* These hold formatted ints. */
1048 char uform[UINTMAX_STRSIZE_BOUND], gform[UINTMAX_STRSIZE_BOUND];
1050 char size[2 * UINTMAX_STRSIZE_BOUND];
1051 /* holds formatted size or major,minor */
1052 char uintbuf[UINTMAX_STRSIZE_BOUND];
1056 if (test_label_option && current_header->header.typeflag != GNUTYPE_VOLHDR)
1059 if (show_transformed_names_option)
1060 temp_name = st->file_name ? st->file_name : st->orig_file_name;
1062 temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
1064 if (block_number_option)
1066 char buf[UINTMAX_STRSIZE_BOUND];
1067 if (block_ordinal < 0)
1068 block_ordinal = current_block_ordinal ();
1069 block_ordinal -= recent_long_name_blocks;
1070 block_ordinal -= recent_long_link_blocks;
1071 fprintf (stdlis, _("block %s: "),
1072 STRINGIFY_BIGINT (block_ordinal, buf));
1075 if (verbose_option <= 1)
1077 /* Just the fax, mam. */
1078 fprintf (stdlis, "%s\n", quotearg (temp_name));
1082 /* File type and modes. */
1085 switch (current_header->header.typeflag)
1087 case GNUTYPE_VOLHDR:
1091 case GNUTYPE_MULTIVOL:
1095 case GNUTYPE_LONGNAME:
1096 case GNUTYPE_LONGLINK:
1098 ERROR ((0, 0, _("Unexpected long name header")));
1101 case GNUTYPE_SPARSE:
1105 if (temp_name[strlen (temp_name) - 1] == '/')
1111 case GNUTYPE_DUMPDIR:
1134 pax_decode_mode (st->stat.st_mode, modes + 1);
1138 time_stamp = tartime (st->mtime, false);
1139 time_stamp_len = strlen (time_stamp);
1140 if (datewidth < time_stamp_len)
1141 datewidth = time_stamp_len;
1143 /* User and group names. */
1147 && current_format != V7_FORMAT
1148 && !numeric_owner_option)
1152 /* Try parsing it as an unsigned integer first, and as a
1153 uid_t if that fails. This method can list positive user
1154 ids that are too large to fit in a uid_t. */
1155 uintmax_t u = from_header (current_header->header.uid,
1156 sizeof current_header->header.uid, 0,
1158 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1161 user = STRINGIFY_BIGINT (u, uform);
1164 sprintf (uform, "%ld",
1165 (long) UID_FROM_HEADER (current_header->header.uid));
1172 && current_format != V7_FORMAT
1173 && !numeric_owner_option)
1177 /* Try parsing it as an unsigned integer first, and as a
1178 gid_t if that fails. This method can list positive group
1179 ids that are too large to fit in a gid_t. */
1180 uintmax_t g = from_header (current_header->header.gid,
1181 sizeof current_header->header.gid, 0,
1183 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1186 group = STRINGIFY_BIGINT (g, gform);
1189 sprintf (gform, "%ld",
1190 (long) GID_FROM_HEADER (current_header->header.gid));
1195 /* Format the file size or major/minor device numbers. */
1197 switch (current_header->header.typeflag)
1202 STRINGIFY_BIGINT (major (st->stat.st_rdev), uintbuf));
1205 STRINGIFY_BIGINT (minor (st->stat.st_rdev), uintbuf));
1209 /* st->stat.st_size keeps stored file size */
1210 strcpy (size, STRINGIFY_BIGINT (st->stat.st_size, uintbuf));
1214 /* Figure out padding and print the whole line. */
1216 sizelen = strlen (size);
1217 pad = strlen (user) + 1 + strlen (group) + 1 + sizelen;
1221 fprintf (stdlis, "%s %s/%s %*s %-*s",
1222 modes, user, group, ugswidth - pad + sizelen, size,
1223 datewidth, time_stamp);
1225 fprintf (stdlis, " %s", quotearg (temp_name));
1227 switch (current_header->header.typeflag)
1230 fprintf (stdlis, " -> %s\n", quotearg (st->link_name));
1234 fprintf (stdlis, _(" link to %s\n"), quotearg (st->link_name));
1239 char type_string[2];
1240 type_string[0] = current_header->header.typeflag;
1241 type_string[1] = '\0';
1242 fprintf (stdlis, _(" unknown file type %s\n"),
1243 quote (type_string));
1249 case GNUTYPE_SPARSE:
1255 case GNUTYPE_DUMPDIR:
1256 putc ('\n', stdlis);
1259 case GNUTYPE_LONGLINK:
1260 fprintf (stdlis, _("--Long Link--\n"));
1263 case GNUTYPE_LONGNAME:
1264 fprintf (stdlis, _("--Long Name--\n"));
1267 case GNUTYPE_VOLHDR:
1268 fprintf (stdlis, _("--Volume Header--\n"));
1271 case GNUTYPE_MULTIVOL:
1274 (UINTMAX_FROM_HEADER (current_header->oldgnu_header.offset),
1276 fprintf (stdlis, _("--Continued at byte %s--\n"), size);
1283 /* Print a similar line when we make a directory automatically. */
1285 print_for_mkdir (char *dirname, int length, mode_t mode)
1289 if (verbose_option > 1)
1291 /* File type and modes. */
1294 pax_decode_mode (mode, modes + 1);
1296 if (block_number_option)
1298 char buf[UINTMAX_STRSIZE_BOUND];
1299 fprintf (stdlis, _("block %s: "),
1300 STRINGIFY_BIGINT (current_block_ordinal (), buf));
1303 fprintf (stdlis, "%s %*s %.*s\n", modes, ugswidth + 1 + datewidth,
1304 _("Creating directory:"), length, quotearg (dirname));
1308 /* Skip over SIZE bytes of data in blocks in the archive. */
1310 skip_file (off_t size)
1314 /* FIXME: Make sure mv_begin is always called before it */
1316 if (seekable_archive)
1318 off_t nblk = seek_archive (size);
1320 size -= nblk * BLOCKSIZE;
1322 seekable_archive = false;
1325 mv_size_left (size);
1329 x = find_next_block ();
1331 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1333 set_next_block_after (x);
1335 mv_size_left (size);
1339 /* Skip the current member in the archive.
1340 NOTE: Current header must be decoded before calling this function. */
1344 if (!current_stat_info.skipped)
1346 char save_typeflag = current_header->header.typeflag;
1347 set_next_block_after (current_header);
1349 mv_begin (¤t_stat_info);
1351 if (current_stat_info.is_sparse)
1352 sparse_skip_file (¤t_stat_info);
1353 else if (save_typeflag != DIRTYPE)
1354 skip_file (current_stat_info.stat.st_size);