1 /* List a tar archive, with support routines for reading a tar archive.
3 Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,
4 2001, 2003, 2004, 2005, 2006, 2007, 2010 Free Software Foundation, Inc.
6 Written by John Gilmore, on 1985-08-26.
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 3, or (at your option) any later
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
16 Public License for more details.
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
28 #define max(a, b) ((a) < (b) ? (b) : (a))
30 union block *current_header; /* points to current archive header */
31 enum archive_format current_format; /* recognized format */
32 union block *recent_long_name; /* recent long name header and contents */
33 union block *recent_long_link; /* likewise, for long link */
34 size_t recent_long_name_blocks; /* number of blocks in recent_long_name */
35 size_t recent_long_link_blocks; /* likewise, for long link */
36 union block *recent_global_header; /* Recent global header block */
38 #define GID_FROM_HEADER(where) gid_from_header (where, sizeof (where))
39 #define MAJOR_FROM_HEADER(where) major_from_header (where, sizeof (where))
40 #define MINOR_FROM_HEADER(where) minor_from_header (where, sizeof (where))
41 #define MODE_FROM_HEADER(where, hbits) \
42 mode_from_header (where, sizeof (where), hbits)
43 #define TIME_FROM_HEADER(where) time_from_header (where, sizeof (where))
44 #define UID_FROM_HEADER(where) uid_from_header (where, sizeof (where))
46 static gid_t gid_from_header (const char *buf, size_t size);
47 static major_t major_from_header (const char *buf, size_t size);
48 static minor_t minor_from_header (const char *buf, size_t size);
49 static mode_t mode_from_header (const char *buf, size_t size, unsigned *hbits);
50 static time_t time_from_header (const char *buf, size_t size);
51 static uid_t uid_from_header (const char *buf, size_t size);
52 static uintmax_t from_header (const char *, size_t, const char *,
53 uintmax_t, uintmax_t, bool, bool);
55 /* Base 64 digits; see Internet RFC 2045 Table 1. */
56 static char const base_64_digits[64] =
58 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
59 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
60 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
61 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
62 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
65 /* Table of base-64 digit values indexed by unsigned chars.
66 The value is 64 for unsigned chars that are not base-64 digits. */
67 static char base64_map[UCHAR_MAX + 1];
73 memset (base64_map, 64, sizeof base64_map);
74 for (i = 0; i < 64; i++)
75 base64_map[(int) base_64_digits[i]] = i;
78 /* Main loop for reading an archive. */
80 read_and (void (*do_something) (void))
82 enum read_header status = HEADER_STILL_UNREAD;
83 enum read_header prev_status;
84 struct timespec mtime;
89 open_archive (ACCESS_READ);
93 tar_stat_destroy (¤t_stat_info);
95 status = read_header (¤t_header, ¤t_stat_info,
99 case HEADER_STILL_UNREAD:
100 case HEADER_SUCCESS_EXTENDED:
105 /* Valid header. We should decode next field (mode) first.
106 Ensure incoming names are null terminated. */
107 decode_header (current_header, ¤t_stat_info,
109 if (! name_match (current_stat_info.file_name)
110 || (NEWER_OPTION_INITIALIZED (newer_mtime_option)
111 /* FIXME: We get mtime now, and again later; this causes
112 duplicate diagnostics if header.mtime is bogus. */
114 = TIME_FROM_HEADER (current_header->header.mtime)),
115 /* FIXME: Grab fractional time stamps from
118 current_stat_info.mtime = mtime,
119 OLDER_TAR_STAT_TIME (current_stat_info, m)))
120 || excluded_name (current_stat_info.file_name))
122 switch (current_header->header.typeflag)
125 case GNUTYPE_MULTIVOL:
129 if (show_omitted_dirs_option)
130 WARN ((0, 0, _("%s: Omitting"),
131 quotearg_colon (current_stat_info.file_name)));
142 case HEADER_ZERO_BLOCK:
143 if (block_number_option)
145 char buf[UINTMAX_STRSIZE_BOUND];
146 fprintf (stdlis, _("block %s: ** Block of NULs **\n"),
147 STRINGIFY_BIGINT (current_block_ordinal (), buf));
150 set_next_block_after (current_header);
152 if (!ignore_zeros_option)
154 char buf[UINTMAX_STRSIZE_BOUND];
156 status = read_header (¤t_header, ¤t_stat_info,
158 if (status == HEADER_ZERO_BLOCK)
161 * According to POSIX tar specs, this is wrong, but on the web
162 * there are some tar specs that can trigger this, and some tar
163 * implementations create tars according to that spec. For now,
164 * let's not be pedantic about issuing the warning.
167 WARNOPT (WARN_ALONE_ZERO_BLOCK,
168 (0, 0, _("A lone zero block at %s"),
169 STRINGIFY_BIGINT (current_block_ordinal (), buf)));
173 status = prev_status;
176 case HEADER_END_OF_FILE:
177 if (block_number_option)
179 char buf[UINTMAX_STRSIZE_BOUND];
180 fprintf (stdlis, _("block %s: ** End of File **\n"),
181 STRINGIFY_BIGINT (current_block_ordinal (), buf));
186 /* If the previous header was good, tell them that we are
187 skipping bad ones. */
188 set_next_block_after (current_header);
191 case HEADER_STILL_UNREAD:
192 ERROR ((0, 0, _("This does not look like a tar archive")));
195 case HEADER_ZERO_BLOCK:
197 if (block_number_option)
199 char buf[UINTMAX_STRSIZE_BOUND];
200 off_t block_ordinal = current_block_ordinal ();
201 block_ordinal -= recent_long_name_blocks;
202 block_ordinal -= recent_long_link_blocks;
203 fprintf (stdlis, _("block %s: "),
204 STRINGIFY_BIGINT (block_ordinal, buf));
206 ERROR ((0, 0, _("Skipping to next header")));
209 case HEADER_END_OF_FILE:
211 /* We are in the middle of a cascade of errors. */
214 case HEADER_SUCCESS_EXTENDED:
221 while (!all_names_found (¤t_stat_info));
224 names_notfound (); /* print names not found */
227 /* Print a header block, based on tar options. */
231 off_t block_ordinal = current_block_ordinal ();
233 /* Print the header block. */
235 print_header (¤t_stat_info, current_header, block_ordinal);
237 if (incremental_option)
239 if (verbose_option > 2)
241 if (is_dumpdir (¤t_stat_info))
242 list_dumpdir (current_stat_info.dumpdir,
243 dumpdir_size (current_stat_info.dumpdir));
250 /* Check header checksum */
251 /* The standard BSD tar sources create the checksum by adding up the
252 bytes in the header as type char. I think the type char was unsigned
253 on the PDP-11, but it's signed on the Next and Sun. It looks like the
254 sources to BSD tar were never changed to compute the checksum
255 correctly, so both the Sun and Next add the bytes of the header as
256 signed chars. This doesn't cause a problem until you get a file with
257 a name containing characters with the high bit set. So tar_checksum
258 computes two checksums -- signed and unsigned. */
261 tar_checksum (union block *header, bool silent)
264 int unsigned_sum = 0; /* the POSIX one :-) */
265 int signed_sum = 0; /* the Sun one :-( */
267 uintmax_t parsed_sum;
271 for (i = sizeof *header; i-- != 0;)
273 unsigned_sum += (unsigned char) *p;
274 signed_sum += (signed char) (*p++);
277 if (unsigned_sum == 0)
278 return HEADER_ZERO_BLOCK;
280 /* Adjust checksum to count the "chksum" field as blanks. */
282 for (i = sizeof header->header.chksum; i-- != 0;)
284 unsigned_sum -= (unsigned char) header->header.chksum[i];
285 signed_sum -= (signed char) (header->header.chksum[i]);
287 unsigned_sum += ' ' * sizeof header->header.chksum;
288 signed_sum += ' ' * sizeof header->header.chksum;
290 parsed_sum = from_header (header->header.chksum,
291 sizeof header->header.chksum, 0,
293 (uintmax_t) TYPE_MAXIMUM (int), true, silent);
294 if (parsed_sum == (uintmax_t) -1)
295 return HEADER_FAILURE;
297 recorded_sum = parsed_sum;
299 if (unsigned_sum != recorded_sum && signed_sum != recorded_sum)
300 return HEADER_FAILURE;
302 return HEADER_SUCCESS;
305 /* Read a block that's supposed to be a header block. Return its
306 address in *RETURN_BLOCK, and if it is good, the file's size
307 and names (file name, link name) in *INFO.
309 Return one of enum read_header describing the status of the
312 The MODE parameter instructs read_header what to do with special
313 header blocks, i.e.: extended POSIX, GNU long name or long link,
316 read_header_auto process them automatically,
317 read_header_x_raw when a special header is read, return
318 HEADER_SUCCESS_EXTENDED without actually
319 processing the header,
320 read_header_x_global when a POSIX global header is read,
321 decode it and return HEADER_SUCCESS_EXTENDED.
323 You must always set_next_block_after(*return_block) to skip past
324 the header which this routine reads. */
327 read_header (union block **return_block, struct tar_stat_info *info,
328 enum read_header_mode mode)
331 union block *header_copy;
333 union block *data_block;
334 size_t size, written;
335 union block *next_long_name = 0;
336 union block *next_long_link = 0;
337 size_t next_long_name_blocks = 0;
338 size_t next_long_link_blocks = 0;
342 enum read_header status;
344 header = find_next_block ();
345 *return_block = header;
347 return HEADER_END_OF_FILE;
349 if ((status = tar_checksum (header, false)) != HEADER_SUCCESS)
352 /* Good block. Decode file size and return. */
354 if (header->header.typeflag == LNKTYPE)
355 info->stat.st_size = 0; /* links 0 size on tape */
357 info->stat.st_size = OFF_FROM_HEADER (header->header.size);
359 if (header->header.typeflag == GNUTYPE_LONGNAME
360 || header->header.typeflag == GNUTYPE_LONGLINK
361 || header->header.typeflag == XHDTYPE
362 || header->header.typeflag == XGLTYPE
363 || header->header.typeflag == SOLARIS_XHDTYPE)
365 if (mode == read_header_x_raw)
366 return HEADER_SUCCESS_EXTENDED;
367 else if (header->header.typeflag == GNUTYPE_LONGNAME
368 || header->header.typeflag == GNUTYPE_LONGLINK)
370 size_t name_size = info->stat.st_size;
371 size_t n = name_size % BLOCKSIZE;
372 size = name_size + BLOCKSIZE;
374 size += BLOCKSIZE - n;
376 if (name_size != info->stat.st_size || size < name_size)
379 header_copy = xmalloc (size + 1);
381 if (header->header.typeflag == GNUTYPE_LONGNAME)
384 free (next_long_name);
385 next_long_name = header_copy;
386 next_long_name_blocks = size / BLOCKSIZE;
391 free (next_long_link);
392 next_long_link = header_copy;
393 next_long_link_blocks = size / BLOCKSIZE;
396 set_next_block_after (header);
397 *header_copy = *header;
398 bp = header_copy->buffer + BLOCKSIZE;
400 for (size -= BLOCKSIZE; size > 0; size -= written)
402 data_block = find_next_block ();
405 ERROR ((0, 0, _("Unexpected EOF in archive")));
408 written = available_space_after (data_block);
412 memcpy (bp, data_block->buffer, written);
414 set_next_block_after ((union block *)
415 (data_block->buffer + written - 1));
420 else if (header->header.typeflag == XHDTYPE
421 || header->header.typeflag == SOLARIS_XHDTYPE)
422 xheader_read (&info->xhdr, header,
423 OFF_FROM_HEADER (header->header.size));
424 else if (header->header.typeflag == XGLTYPE)
428 if (!recent_global_header)
429 recent_global_header = xmalloc (sizeof *recent_global_header);
430 memcpy (recent_global_header, header,
431 sizeof *recent_global_header);
432 memset (&xhdr, 0, sizeof xhdr);
433 xheader_read (&xhdr, header,
434 OFF_FROM_HEADER (header->header.size));
435 xheader_decode_global (&xhdr);
436 xheader_destroy (&xhdr);
437 if (mode == read_header_x_global)
438 return HEADER_SUCCESS_EXTENDED;
447 struct posix_header const *h = &header->header;
448 char namebuf[sizeof h->prefix + 1 + NAME_FIELD_SIZE + 1];
450 if (recent_long_name)
451 free (recent_long_name);
455 name = next_long_name->buffer + BLOCKSIZE;
456 recent_long_name = next_long_name;
457 recent_long_name_blocks = next_long_name_blocks;
461 /* Accept file names as specified by POSIX.1-1996
465 if (h->prefix[0] && strcmp (h->magic, TMAGIC) == 0)
467 memcpy (np, h->prefix, sizeof h->prefix);
468 np[sizeof h->prefix] = '\0';
472 memcpy (np, h->name, sizeof h->name);
473 np[sizeof h->name] = '\0';
475 recent_long_name = 0;
476 recent_long_name_blocks = 0;
478 assign_string (&info->orig_file_name, name);
479 assign_string (&info->file_name, name);
480 info->had_trailing_slash = strip_trailing_slashes (info->file_name);
482 if (recent_long_link)
483 free (recent_long_link);
487 name = next_long_link->buffer + BLOCKSIZE;
488 recent_long_link = next_long_link;
489 recent_long_link_blocks = next_long_link_blocks;
493 memcpy (namebuf, h->linkname, sizeof h->linkname);
494 namebuf[sizeof h->linkname] = '\0';
496 recent_long_link = 0;
497 recent_long_link_blocks = 0;
499 assign_string (&info->link_name, name);
501 return HEADER_SUCCESS;
507 decode_xform (char *file_name, void *data)
509 int type = *(int*)data;
514 /* FIXME: It is not quite clear how and to which extent are the symbolic
515 links subject to filename transformation. In the absence of another
516 solution, symbolic links are exempt from component stripping and
517 name suffix normalization, but subject to filename transformation
522 file_name = safer_name_suffix (file_name, true, absolute_names_option);
526 file_name = safer_name_suffix (file_name, false, absolute_names_option);
530 if (strip_name_components)
532 size_t prefix_len = stripped_prefix_len (file_name,
533 strip_name_components);
534 if (prefix_len == (size_t) -1)
535 prefix_len = strlen (file_name);
536 file_name += prefix_len;
542 transform_member_name (char **pinput, int type)
544 return transform_name_fp (pinput, type, decode_xform, &type);
547 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
549 /* Decode things from a file HEADER block into STAT_INFO, also setting
550 *FORMAT_POINTER depending on the header block format. If
551 DO_USER_GROUP, decode the user/group information (this is useful
552 for extraction, but waste time when merely listing).
554 read_header() has already decoded the checksum and length, so we don't.
556 This routine should *not* be called twice for the same block, since
557 the two calls might use different DO_USER_GROUP values and thus
558 might end up with different uid/gid for the two calls. If anybody
559 wants the uid/gid they should decode it first, and other callers
560 should decode it without uid/gid before calling a routine,
561 e.g. print_header, that assumes decoded data. */
563 decode_header (union block *header, struct tar_stat_info *stat_info,
564 enum archive_format *format_pointer, int do_user_group)
566 enum archive_format format;
567 unsigned hbits; /* high bits of the file mode. */
568 mode_t mode = MODE_FROM_HEADER (header->header.mode, &hbits);
570 if (strcmp (header->header.magic, TMAGIC) == 0)
572 if (header->star_header.prefix[130] == 0
573 && ISOCTAL (header->star_header.atime[0])
574 && header->star_header.atime[11] == ' '
575 && ISOCTAL (header->star_header.ctime[0])
576 && header->star_header.ctime[11] == ' ')
577 format = STAR_FORMAT;
578 else if (stat_info->xhdr.size)
579 format = POSIX_FORMAT;
581 format = USTAR_FORMAT;
583 else if (strcmp (header->header.magic, OLDGNU_MAGIC) == 0)
584 format = hbits ? OLDGNU_FORMAT : GNU_FORMAT;
587 *format_pointer = format;
589 stat_info->stat.st_mode = mode;
590 stat_info->mtime.tv_sec = TIME_FROM_HEADER (header->header.mtime);
591 stat_info->mtime.tv_nsec = 0;
592 assign_string (&stat_info->uname,
593 header->header.uname[0] ? header->header.uname : NULL);
594 assign_string (&stat_info->gname,
595 header->header.gname[0] ? header->header.gname : NULL);
597 if (format == OLDGNU_FORMAT && incremental_option)
599 stat_info->atime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.atime);
600 stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.ctime);
601 stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
603 else if (format == STAR_FORMAT)
605 stat_info->atime.tv_sec = TIME_FROM_HEADER (header->star_header.atime);
606 stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->star_header.ctime);
607 stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
610 stat_info->atime = stat_info->ctime = start_time;
612 if (format == V7_FORMAT)
614 stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
615 stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
616 stat_info->stat.st_rdev = 0;
622 /* FIXME: Decide if this should somewhat depend on -p. */
624 if (numeric_owner_option
625 || !*header->header.uname
626 || !uname_to_uid (header->header.uname, &stat_info->stat.st_uid))
627 stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
629 if (numeric_owner_option
630 || !*header->header.gname
631 || !gname_to_gid (header->header.gname, &stat_info->stat.st_gid))
632 stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
635 switch (header->header.typeflag)
639 stat_info->stat.st_rdev =
640 makedev (MAJOR_FROM_HEADER (header->header.devmajor),
641 MINOR_FROM_HEADER (header->header.devminor));
645 stat_info->stat.st_rdev = 0;
649 stat_info->archive_file_size = stat_info->stat.st_size;
650 xheader_decode (stat_info);
652 if (sparse_member_p (stat_info))
654 sparse_fixup_header (stat_info);
655 stat_info->is_sparse = true;
659 stat_info->is_sparse = false;
660 if (((current_format == GNU_FORMAT
661 || current_format == OLDGNU_FORMAT)
662 && current_header->header.typeflag == GNUTYPE_DUMPDIR)
663 || stat_info->dumpdir)
664 stat_info->is_dumpdir = true;
667 if (header->header.typeflag == GNUTYPE_VOLHDR)
668 /* Name transformations don't apply to volume headers. */
671 transform_member_name (&stat_info->file_name, XFORM_REGFILE);
672 switch (header->header.typeflag)
675 transform_member_name (&stat_info->link_name, XFORM_SYMLINK);
679 transform_member_name (&stat_info->link_name, XFORM_LINK);
683 /* Convert buffer at WHERE0 of size DIGS from external format to
684 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
685 are of type TYPE. The buffer must represent a value in the range
686 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
687 numbers instead of the other GNU extensions. Return -1 on error,
688 diagnosing the error if TYPE is nonnull and if !SILENT. */
690 from_header (char const *where0, size_t digs, char const *type,
691 uintmax_t minus_minval, uintmax_t maxval,
692 bool octal_only, bool silent)
695 char const *where = where0;
696 char const *lim = where + digs;
699 /* Accommodate buggy tar of unknown vintage, which outputs leading
700 NUL if the previous field overflows. */
703 /* Accommodate older tars, which output leading spaces. */
710 /* TRANSLATORS: %s is type of the value (gid_t, uid_t,
712 _("Blanks in header where numeric %s value expected"),
716 if (!ISSPACE ((unsigned char) *where))
722 if (ISODIGIT (*where))
724 char const *where1 = where;
725 uintmax_t overflow = 0;
729 value += *where++ - '0';
730 if (where == lim || ! ISODIGIT (*where))
732 overflow |= value ^ (value << LG_8 >> LG_8);
736 /* Parse the output of older, unportable tars, which generate
737 negative values in two's complement octal. If the leading
738 nonzero digit is 1, we can't recover the original value
739 reliably; so do this only if the digit is 2 or more. This
740 catches the common case of 32-bit negative time stamps. */
741 if ((overflow || maxval < value) && '2' <= *where1 && type)
743 /* Compute the negative of the input value, assuming two's
745 int digit = (*where1 - '0') | 4;
753 if (where == lim || ! ISODIGIT (*where))
755 digit = *where - '0';
756 overflow |= value ^ (value << LG_8 >> LG_8);
762 if (!overflow && value <= minus_minval)
766 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
767 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
768 (int) (where - where1), where1, type));
777 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
778 _("Archive octal value %.*s is out of %s range"),
779 (int) (where - where1), where1, type));
785 /* Suppress the following extensions. */
787 else if (*where == '-' || *where == '+')
789 /* Parse base-64 output produced only by tar test versions
790 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
791 Support for this will be withdrawn in future releases. */
795 static bool warned_once;
799 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
802 negative = *where++ == '-';
804 && (dig = base64_map[(unsigned char) *where]) < 64)
806 if (value << LG_64 >> LG_64 != value)
808 char *string = alloca (digs + 1);
809 memcpy (string, where0, digs);
813 _("Archive signed base-64 string %s is out of %s range"),
814 quote (string), type));
817 value = (value << LG_64) | dig;
821 else if (*where == '\200' /* positive base-256 */
822 || *where == '\377' /* negative base-256 */)
824 /* Parse base-256 output. A nonnegative number N is
825 represented as (256**DIGS)/2 + N; a negative number -N is
826 represented as (256**DIGS) - N, i.e. as two's complement.
827 The representation guarantees that the leading bit is
828 always on, so that we don't confuse this format with the
829 others (assuming ASCII bytes of 8 bits or more). */
830 int signbit = *where & (1 << (LG_256 - 2));
831 uintmax_t topbits = (((uintmax_t) - signbit)
832 << (CHAR_BIT * sizeof (uintmax_t)
833 - LG_256 - (LG_256 - 2)));
834 value = (*where++ & ((1 << (LG_256 - 2)) - 1)) - signbit;
837 value = (value << LG_256) + (unsigned char) *where++;
840 if (((value << LG_256 >> LG_256) | topbits) != value)
844 _("Archive base-256 value is out of %s range"),
854 if (where != lim && *where && !ISSPACE ((unsigned char) *where))
858 char buf[1000]; /* Big enough to represent any header. */
859 static struct quoting_options *o;
863 o = clone_quoting_options (0);
864 set_quoting_style (o, locale_quoting_style);
867 while (where0 != lim && ! lim[-1])
869 quotearg_buffer (buf, sizeof buf, where0, lim - where, o);
872 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
873 _("Archive contains %.*s where numeric %s value expected"),
874 (int) sizeof buf, buf, type));
880 if (value <= (negative ? minus_minval : maxval))
881 return negative ? -value : value;
885 char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
886 char maxval_buf[UINTMAX_STRSIZE_BOUND];
887 char value_buf[UINTMAX_STRSIZE_BOUND + 1];
888 char *minval_string = STRINGIFY_BIGINT (minus_minval, minval_buf + 1);
889 char *value_string = STRINGIFY_BIGINT (value, value_buf + 1);
891 *--value_string = '-';
893 *--minval_string = '-';
894 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
895 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
897 minval_string, STRINGIFY_BIGINT (maxval, maxval_buf)));
904 gid_from_header (const char *p, size_t s)
906 return from_header (p, s, "gid_t",
907 - (uintmax_t) TYPE_MINIMUM (gid_t),
908 (uintmax_t) TYPE_MAXIMUM (gid_t),
913 major_from_header (const char *p, size_t s)
915 return from_header (p, s, "major_t",
916 - (uintmax_t) TYPE_MINIMUM (major_t),
917 (uintmax_t) TYPE_MAXIMUM (major_t), false, false);
921 minor_from_header (const char *p, size_t s)
923 return from_header (p, s, "minor_t",
924 - (uintmax_t) TYPE_MINIMUM (minor_t),
925 (uintmax_t) TYPE_MAXIMUM (minor_t), false, false);
928 /* Convert P to the file mode, as understood by tar.
929 Store unrecognized mode bits (from 10th up) in HBITS. */
931 mode_from_header (const char *p, size_t s, unsigned *hbits)
933 unsigned u = from_header (p, s, "mode_t",
934 - (uintmax_t) TYPE_MINIMUM (mode_t),
935 TYPE_MAXIMUM (uintmax_t), false, false);
936 mode_t mode = ((u & TSUID ? S_ISUID : 0)
937 | (u & TSGID ? S_ISGID : 0)
938 | (u & TSVTX ? S_ISVTX : 0)
939 | (u & TUREAD ? S_IRUSR : 0)
940 | (u & TUWRITE ? S_IWUSR : 0)
941 | (u & TUEXEC ? S_IXUSR : 0)
942 | (u & TGREAD ? S_IRGRP : 0)
943 | (u & TGWRITE ? S_IWGRP : 0)
944 | (u & TGEXEC ? S_IXGRP : 0)
945 | (u & TOREAD ? S_IROTH : 0)
946 | (u & TOWRITE ? S_IWOTH : 0)
947 | (u & TOEXEC ? S_IXOTH : 0));
953 off_from_header (const char *p, size_t s)
955 /* Negative offsets are not allowed in tar files, so invoke
956 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
957 return from_header (p, s, "off_t", (uintmax_t) 0,
958 (uintmax_t) TYPE_MAXIMUM (off_t), false, false);
962 time_from_header (const char *p, size_t s)
964 return from_header (p, s, "time_t",
965 - (uintmax_t) TYPE_MINIMUM (time_t),
966 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
970 uid_from_header (const char *p, size_t s)
972 return from_header (p, s, "uid_t",
973 - (uintmax_t) TYPE_MINIMUM (uid_t),
974 (uintmax_t) TYPE_MAXIMUM (uid_t), false, false);
978 uintmax_from_header (const char *p, size_t s)
980 return from_header (p, s, "uintmax_t", (uintmax_t) 0,
981 TYPE_MAXIMUM (uintmax_t), false, false);
985 /* Return a printable representation of T. The result points to
986 static storage that can be reused in the next call to this
987 function, to ctime, or to asctime. If FULL_TIME, then output the
988 time stamp to its full resolution; otherwise, just output it to
989 1-minute resolution. */
991 tartime (struct timespec t, bool full_time)
993 enum { fraclen = sizeof ".FFFFFFFFF" - 1 };
994 static char buffer[max (UINTMAX_STRSIZE_BOUND + 1,
995 INT_STRLEN_BOUND (int) + 16)
1000 bool negative = s < 0;
1003 if (negative && ns != 0)
1006 ns = 1000000000 - ns;
1009 tm = utc_option ? gmtime (&s) : localtime (&s);
1014 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d:%02d",
1015 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
1016 tm->tm_hour, tm->tm_min, tm->tm_sec);
1017 code_ns_fraction (ns, buffer + strlen (buffer));
1020 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d",
1021 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
1022 tm->tm_hour, tm->tm_min);
1026 /* The time stamp cannot be broken down, most likely because it
1027 is out of range. Convert it as an integer,
1028 right-adjusted in a field with the same width as the usual
1029 4-year ISO time format. */
1030 p = umaxtostr (negative ? - (uintmax_t) s : s,
1031 buffer + sizeof buffer - UINTMAX_STRSIZE_BOUND - fraclen);
1034 while ((buffer + sizeof buffer - sizeof "YYYY-MM-DD HH:MM"
1035 + (full_time ? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1039 code_ns_fraction (ns, buffer + sizeof buffer - 1 - fraclen);
1043 /* Actually print it.
1045 Plain and fancy file header block logging. Non-verbose just prints
1046 the name, e.g. for "tar t" or "tar x". This should just contain
1047 file names, so it can be fed back into tar with xargs or the "-T"
1048 option. The verbose option can give a bunch of info, one line per
1049 file. I doubt anybody tries to parse its format, or if they do,
1050 they shouldn't. Unix tar is pretty random here anyway. */
1053 /* Width of "user/group size", with initial value chosen
1054 heuristically. This grows as needed, though this may cause some
1055 stairstepping in the output. Make it too small and the output will
1056 almost always look ragged. Make it too large and the output will
1057 be spaced out too far. */
1058 static int ugswidth = 19;
1060 /* Width of printed time stamps. It grows if longer time stamps are
1061 found (typically, those with nanosecond resolution). Like
1062 USGWIDTH, some stairstepping may occur. */
1063 static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1;
1065 static bool volume_label_printed = false;
1068 simple_print_header (struct tar_stat_info *st, union block *blk,
1069 off_t block_ordinal)
1072 char const *time_stamp;
1076 /* These hold formatted ints. */
1077 char uform[UINTMAX_STRSIZE_BOUND], gform[UINTMAX_STRSIZE_BOUND];
1079 char size[2 * UINTMAX_STRSIZE_BOUND];
1080 /* holds formatted size or major,minor */
1081 char uintbuf[UINTMAX_STRSIZE_BOUND];
1085 if (show_transformed_names_option)
1086 temp_name = st->file_name ? st->file_name : st->orig_file_name;
1088 temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
1090 if (block_number_option)
1092 char buf[UINTMAX_STRSIZE_BOUND];
1093 if (block_ordinal < 0)
1094 block_ordinal = current_block_ordinal ();
1095 block_ordinal -= recent_long_name_blocks;
1096 block_ordinal -= recent_long_link_blocks;
1097 fprintf (stdlis, _("block %s: "),
1098 STRINGIFY_BIGINT (block_ordinal, buf));
1101 if (verbose_option <= 1)
1103 /* Just the fax, mam. */
1104 fprintf (stdlis, "%s\n", quotearg (temp_name));
1108 /* File type and modes. */
1111 switch (blk->header.typeflag)
1113 case GNUTYPE_VOLHDR:
1114 volume_label_printed = true;
1118 case GNUTYPE_MULTIVOL:
1122 case GNUTYPE_LONGNAME:
1123 case GNUTYPE_LONGLINK:
1125 ERROR ((0, 0, _("Unexpected long name header")));
1128 case GNUTYPE_SPARSE:
1132 if (temp_name[strlen (temp_name) - 1] == '/')
1138 case GNUTYPE_DUMPDIR:
1161 pax_decode_mode (st->stat.st_mode, modes + 1);
1165 time_stamp = tartime (st->mtime, full_time_option);
1166 time_stamp_len = strlen (time_stamp);
1167 if (datewidth < time_stamp_len)
1168 datewidth = time_stamp_len;
1170 /* User and group names. */
1174 && current_format != V7_FORMAT
1175 && !numeric_owner_option)
1179 /* Try parsing it as an unsigned integer first, and as a
1180 uid_t if that fails. This method can list positive user
1181 ids that are too large to fit in a uid_t. */
1182 uintmax_t u = from_header (blk->header.uid,
1183 sizeof blk->header.uid, 0,
1185 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1188 user = STRINGIFY_BIGINT (u, uform);
1191 sprintf (uform, "%ld",
1192 (long) UID_FROM_HEADER (blk->header.uid));
1199 && current_format != V7_FORMAT
1200 && !numeric_owner_option)
1204 /* Try parsing it as an unsigned integer first, and as a
1205 gid_t if that fails. This method can list positive group
1206 ids that are too large to fit in a gid_t. */
1207 uintmax_t g = from_header (blk->header.gid,
1208 sizeof blk->header.gid, 0,
1210 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1213 group = STRINGIFY_BIGINT (g, gform);
1216 sprintf (gform, "%ld",
1217 (long) GID_FROM_HEADER (blk->header.gid));
1222 /* Format the file size or major/minor device numbers. */
1224 switch (blk->header.typeflag)
1229 STRINGIFY_BIGINT (major (st->stat.st_rdev), uintbuf));
1232 STRINGIFY_BIGINT (minor (st->stat.st_rdev), uintbuf));
1236 /* st->stat.st_size keeps stored file size */
1237 strcpy (size, STRINGIFY_BIGINT (st->stat.st_size, uintbuf));
1241 /* Figure out padding and print the whole line. */
1243 sizelen = strlen (size);
1244 pad = strlen (user) + 1 + strlen (group) + 1 + sizelen;
1248 fprintf (stdlis, "%s %s/%s %*s %-*s",
1249 modes, user, group, ugswidth - pad + sizelen, size,
1250 datewidth, time_stamp);
1252 fprintf (stdlis, " %s", quotearg (temp_name));
1254 switch (blk->header.typeflag)
1257 fprintf (stdlis, " -> %s\n", quotearg (st->link_name));
1261 fprintf (stdlis, _(" link to %s\n"), quotearg (st->link_name));
1266 char type_string[2];
1267 type_string[0] = blk->header.typeflag;
1268 type_string[1] = '\0';
1269 fprintf (stdlis, _(" unknown file type %s\n"),
1270 quote (type_string));
1276 case GNUTYPE_SPARSE:
1282 case GNUTYPE_DUMPDIR:
1283 putc ('\n', stdlis);
1286 case GNUTYPE_LONGLINK:
1287 fprintf (stdlis, _("--Long Link--\n"));
1290 case GNUTYPE_LONGNAME:
1291 fprintf (stdlis, _("--Long Name--\n"));
1294 case GNUTYPE_VOLHDR:
1295 fprintf (stdlis, _("--Volume Header--\n"));
1298 case GNUTYPE_MULTIVOL:
1301 (UINTMAX_FROM_HEADER (blk->oldgnu_header.offset),
1303 fprintf (stdlis, _("--Continued at byte %s--\n"), size);
1312 print_volume_label (void)
1314 struct tar_stat_info vstat;
1316 enum archive_format dummy;
1318 memset (&vblk, 0, sizeof (vblk));
1319 vblk.header.typeflag = GNUTYPE_VOLHDR;
1320 if (recent_global_header)
1321 memcpy (vblk.header.mtime, recent_global_header->header.mtime,
1322 sizeof vblk.header.mtime);
1323 tar_stat_init (&vstat);
1324 assign_string (&vstat.file_name, ".");
1325 decode_header (&vblk, &vstat, &dummy, 0);
1326 assign_string (&vstat.file_name, volume_label);
1327 simple_print_header (&vstat, &vblk, 0);
1328 tar_stat_destroy (&vstat);
1332 print_header (struct tar_stat_info *st, union block *blk,
1333 off_t block_ordinal)
1335 if (current_format == POSIX_FORMAT && !volume_label_printed && volume_label)
1337 print_volume_label ();
1338 volume_label_printed = true;
1341 simple_print_header (st, blk, block_ordinal);
1344 /* Print a similar line when we make a directory automatically. */
1346 print_for_mkdir (char *dirname, int length, mode_t mode)
1350 if (verbose_option > 1)
1352 /* File type and modes. */
1355 pax_decode_mode (mode, modes + 1);
1357 if (block_number_option)
1359 char buf[UINTMAX_STRSIZE_BOUND];
1360 fprintf (stdlis, _("block %s: "),
1361 STRINGIFY_BIGINT (current_block_ordinal (), buf));
1364 fprintf (stdlis, "%s %*s %.*s\n", modes, ugswidth + 1 + datewidth,
1365 _("Creating directory:"), length, quotearg (dirname));
1369 /* Skip over SIZE bytes of data in blocks in the archive. */
1371 skip_file (off_t size)
1375 /* FIXME: Make sure mv_begin_read is always called before it */
1377 if (seekable_archive)
1379 off_t nblk = seek_archive (size);
1381 size -= nblk * BLOCKSIZE;
1383 seekable_archive = false;
1386 mv_size_left (size);
1390 x = find_next_block ();
1392 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1394 set_next_block_after (x);
1396 mv_size_left (size);
1400 /* Skip the current member in the archive.
1401 NOTE: Current header must be decoded before calling this function. */
1405 if (!current_stat_info.skipped)
1407 char save_typeflag = current_header->header.typeflag;
1408 set_next_block_after (current_header);
1410 mv_begin_read (¤t_stat_info);
1412 if (current_stat_info.is_sparse)
1413 sparse_skip_file (¤t_stat_info);
1414 else if (save_typeflag != DIRTYPE)
1415 skip_file (current_stat_info.stat.st_size);
1422 test_archive_label ()
1427 open_archive (ACCESS_READ);
1428 if (read_header (¤t_header, ¤t_stat_info, read_header_auto)
1431 decode_header (current_header,
1432 ¤t_stat_info, ¤t_format, 0);
1433 if (current_header->header.typeflag == GNUTYPE_VOLHDR)
1434 assign_string (&volume_label, current_header->header.name);
1439 print_volume_label ();
1440 if (!name_match (volume_label) && multi_volume_option)
1442 char *s = drop_volume_label_suffix (volume_label);