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;
79 decode_xform (char *file_name, void *data)
81 int type = *(int*)data;
86 /* FIXME: It is not quite clear how and to which extent are the symbolic
87 links subject to filename transformation. In the absence of another
88 solution, symbolic links are exempt from component stripping and
89 name suffix normalization, but subject to filename transformation
94 file_name = safer_name_suffix (file_name, true, absolute_names_option);
98 file_name = safer_name_suffix (file_name, false, absolute_names_option);
102 if (strip_name_components)
104 size_t prefix_len = stripped_prefix_len (file_name,
105 strip_name_components);
106 if (prefix_len == (size_t) -1)
107 prefix_len = strlen (file_name);
108 file_name += prefix_len;
114 transform_member_name (char **pinput, int type)
116 return transform_name_fp (pinput, type, decode_xform, &type);
120 transform_stat_info (int typeflag, struct tar_stat_info *stat_info)
122 if (typeflag == GNUTYPE_VOLHDR)
123 /* Name transformations don't apply to volume headers. */
126 transform_member_name (&stat_info->file_name, XFORM_REGFILE);
130 transform_member_name (&stat_info->link_name, XFORM_SYMLINK);
134 transform_member_name (&stat_info->link_name, XFORM_LINK);
138 /* Main loop for reading an archive. */
140 read_and (void (*do_something) (void))
142 enum read_header status = HEADER_STILL_UNREAD;
143 enum read_header prev_status;
144 struct timespec mtime;
149 open_archive (ACCESS_READ);
152 prev_status = status;
153 tar_stat_destroy (¤t_stat_info);
155 status = read_header (¤t_header, ¤t_stat_info,
159 case HEADER_STILL_UNREAD:
160 case HEADER_SUCCESS_EXTENDED:
165 /* Valid header. We should decode next field (mode) first.
166 Ensure incoming names are null terminated. */
167 decode_header (current_header, ¤t_stat_info,
169 if (! name_match (current_stat_info.file_name)
170 || (NEWER_OPTION_INITIALIZED (newer_mtime_option)
171 /* FIXME: We get mtime now, and again later; this causes
172 duplicate diagnostics if header.mtime is bogus. */
174 = TIME_FROM_HEADER (current_header->header.mtime)),
175 /* FIXME: Grab fractional time stamps from
178 current_stat_info.mtime = mtime,
179 OLDER_TAR_STAT_TIME (current_stat_info, m)))
180 || excluded_name (current_stat_info.file_name))
182 switch (current_header->header.typeflag)
185 case GNUTYPE_MULTIVOL:
189 if (show_omitted_dirs_option)
190 WARN ((0, 0, _("%s: Omitting"),
191 quotearg_colon (current_stat_info.file_name)));
198 transform_stat_info (current_header->header.typeflag,
203 case HEADER_ZERO_BLOCK:
204 if (block_number_option)
206 char buf[UINTMAX_STRSIZE_BOUND];
207 fprintf (stdlis, _("block %s: ** Block of NULs **\n"),
208 STRINGIFY_BIGINT (current_block_ordinal (), buf));
211 set_next_block_after (current_header);
213 if (!ignore_zeros_option)
215 char buf[UINTMAX_STRSIZE_BOUND];
217 status = read_header (¤t_header, ¤t_stat_info,
219 if (status == HEADER_ZERO_BLOCK)
222 * According to POSIX tar specs, this is wrong, but on the web
223 * there are some tar specs that can trigger this, and some tar
224 * implementations create tars according to that spec. For now,
225 * let's not be pedantic about issuing the warning.
228 WARNOPT (WARN_ALONE_ZERO_BLOCK,
229 (0, 0, _("A lone zero block at %s"),
230 STRINGIFY_BIGINT (current_block_ordinal (), buf)));
234 status = prev_status;
237 case HEADER_END_OF_FILE:
238 if (block_number_option)
240 char buf[UINTMAX_STRSIZE_BOUND];
241 fprintf (stdlis, _("block %s: ** End of File **\n"),
242 STRINGIFY_BIGINT (current_block_ordinal (), buf));
247 /* If the previous header was good, tell them that we are
248 skipping bad ones. */
249 set_next_block_after (current_header);
252 case HEADER_STILL_UNREAD:
253 ERROR ((0, 0, _("This does not look like a tar archive")));
256 case HEADER_ZERO_BLOCK:
258 if (block_number_option)
260 char buf[UINTMAX_STRSIZE_BOUND];
261 off_t block_ordinal = current_block_ordinal ();
262 block_ordinal -= recent_long_name_blocks;
263 block_ordinal -= recent_long_link_blocks;
264 fprintf (stdlis, _("block %s: "),
265 STRINGIFY_BIGINT (block_ordinal, buf));
267 ERROR ((0, 0, _("Skipping to next header")));
270 case HEADER_END_OF_FILE:
272 /* We are in the middle of a cascade of errors. */
275 case HEADER_SUCCESS_EXTENDED:
282 while (!all_names_found (¤t_stat_info));
285 names_notfound (); /* print names not found */
288 /* Print a header block, based on tar options. */
292 off_t block_ordinal = current_block_ordinal ();
294 /* Print the header block. */
296 print_header (¤t_stat_info, current_header, block_ordinal);
298 if (incremental_option)
300 if (verbose_option > 2)
302 if (is_dumpdir (¤t_stat_info))
303 list_dumpdir (current_stat_info.dumpdir,
304 dumpdir_size (current_stat_info.dumpdir));
311 /* Check header checksum */
312 /* The standard BSD tar sources create the checksum by adding up the
313 bytes in the header as type char. I think the type char was unsigned
314 on the PDP-11, but it's signed on the Next and Sun. It looks like the
315 sources to BSD tar were never changed to compute the checksum
316 correctly, so both the Sun and Next add the bytes of the header as
317 signed chars. This doesn't cause a problem until you get a file with
318 a name containing characters with the high bit set. So tar_checksum
319 computes two checksums -- signed and unsigned. */
322 tar_checksum (union block *header, bool silent)
325 int unsigned_sum = 0; /* the POSIX one :-) */
326 int signed_sum = 0; /* the Sun one :-( */
328 uintmax_t parsed_sum;
332 for (i = sizeof *header; i-- != 0;)
334 unsigned_sum += (unsigned char) *p;
335 signed_sum += (signed char) (*p++);
338 if (unsigned_sum == 0)
339 return HEADER_ZERO_BLOCK;
341 /* Adjust checksum to count the "chksum" field as blanks. */
343 for (i = sizeof header->header.chksum; i-- != 0;)
345 unsigned_sum -= (unsigned char) header->header.chksum[i];
346 signed_sum -= (signed char) (header->header.chksum[i]);
348 unsigned_sum += ' ' * sizeof header->header.chksum;
349 signed_sum += ' ' * sizeof header->header.chksum;
351 parsed_sum = from_header (header->header.chksum,
352 sizeof header->header.chksum, 0,
354 (uintmax_t) TYPE_MAXIMUM (int), true, silent);
355 if (parsed_sum == (uintmax_t) -1)
356 return HEADER_FAILURE;
358 recorded_sum = parsed_sum;
360 if (unsigned_sum != recorded_sum && signed_sum != recorded_sum)
361 return HEADER_FAILURE;
363 return HEADER_SUCCESS;
366 /* Read a block that's supposed to be a header block. Return its
367 address in *RETURN_BLOCK, and if it is good, the file's size
368 and names (file name, link name) in *INFO.
370 Return one of enum read_header describing the status of the
373 The MODE parameter instructs read_header what to do with special
374 header blocks, i.e.: extended POSIX, GNU long name or long link,
377 read_header_auto process them automatically,
378 read_header_x_raw when a special header is read, return
379 HEADER_SUCCESS_EXTENDED without actually
380 processing the header,
381 read_header_x_global when a POSIX global header is read,
382 decode it and return HEADER_SUCCESS_EXTENDED.
384 You must always set_next_block_after(*return_block) to skip past
385 the header which this routine reads. */
388 read_header (union block **return_block, struct tar_stat_info *info,
389 enum read_header_mode mode)
392 union block *header_copy;
394 union block *data_block;
395 size_t size, written;
396 union block *next_long_name = 0;
397 union block *next_long_link = 0;
398 size_t next_long_name_blocks = 0;
399 size_t next_long_link_blocks = 0;
403 enum read_header status;
405 header = find_next_block ();
406 *return_block = header;
408 return HEADER_END_OF_FILE;
410 if ((status = tar_checksum (header, false)) != HEADER_SUCCESS)
413 /* Good block. Decode file size and return. */
415 if (header->header.typeflag == LNKTYPE)
416 info->stat.st_size = 0; /* links 0 size on tape */
418 info->stat.st_size = OFF_FROM_HEADER (header->header.size);
420 if (header->header.typeflag == GNUTYPE_LONGNAME
421 || header->header.typeflag == GNUTYPE_LONGLINK
422 || header->header.typeflag == XHDTYPE
423 || header->header.typeflag == XGLTYPE
424 || header->header.typeflag == SOLARIS_XHDTYPE)
426 if (mode == read_header_x_raw)
427 return HEADER_SUCCESS_EXTENDED;
428 else if (header->header.typeflag == GNUTYPE_LONGNAME
429 || header->header.typeflag == GNUTYPE_LONGLINK)
431 size_t name_size = info->stat.st_size;
432 size_t n = name_size % BLOCKSIZE;
433 size = name_size + BLOCKSIZE;
435 size += BLOCKSIZE - n;
437 if (name_size != info->stat.st_size || size < name_size)
440 header_copy = xmalloc (size + 1);
442 if (header->header.typeflag == GNUTYPE_LONGNAME)
445 free (next_long_name);
446 next_long_name = header_copy;
447 next_long_name_blocks = size / BLOCKSIZE;
452 free (next_long_link);
453 next_long_link = header_copy;
454 next_long_link_blocks = size / BLOCKSIZE;
457 set_next_block_after (header);
458 *header_copy = *header;
459 bp = header_copy->buffer + BLOCKSIZE;
461 for (size -= BLOCKSIZE; size > 0; size -= written)
463 data_block = find_next_block ();
466 ERROR ((0, 0, _("Unexpected EOF in archive")));
469 written = available_space_after (data_block);
473 memcpy (bp, data_block->buffer, written);
475 set_next_block_after ((union block *)
476 (data_block->buffer + written - 1));
481 else if (header->header.typeflag == XHDTYPE
482 || header->header.typeflag == SOLARIS_XHDTYPE)
483 xheader_read (&info->xhdr, header,
484 OFF_FROM_HEADER (header->header.size));
485 else if (header->header.typeflag == XGLTYPE)
489 if (!recent_global_header)
490 recent_global_header = xmalloc (sizeof *recent_global_header);
491 memcpy (recent_global_header, header,
492 sizeof *recent_global_header);
493 memset (&xhdr, 0, sizeof xhdr);
494 xheader_read (&xhdr, header,
495 OFF_FROM_HEADER (header->header.size));
496 xheader_decode_global (&xhdr);
497 xheader_destroy (&xhdr);
498 if (mode == read_header_x_global)
499 return HEADER_SUCCESS_EXTENDED;
508 struct posix_header const *h = &header->header;
509 char namebuf[sizeof h->prefix + 1 + NAME_FIELD_SIZE + 1];
511 if (recent_long_name)
512 free (recent_long_name);
516 name = next_long_name->buffer + BLOCKSIZE;
517 recent_long_name = next_long_name;
518 recent_long_name_blocks = next_long_name_blocks;
522 /* Accept file names as specified by POSIX.1-1996
526 if (h->prefix[0] && strcmp (h->magic, TMAGIC) == 0)
528 memcpy (np, h->prefix, sizeof h->prefix);
529 np[sizeof h->prefix] = '\0';
533 memcpy (np, h->name, sizeof h->name);
534 np[sizeof h->name] = '\0';
536 recent_long_name = 0;
537 recent_long_name_blocks = 0;
539 assign_string (&info->orig_file_name, name);
540 assign_string (&info->file_name, name);
541 info->had_trailing_slash = strip_trailing_slashes (info->file_name);
543 if (recent_long_link)
544 free (recent_long_link);
548 name = next_long_link->buffer + BLOCKSIZE;
549 recent_long_link = next_long_link;
550 recent_long_link_blocks = next_long_link_blocks;
554 memcpy (namebuf, h->linkname, sizeof h->linkname);
555 namebuf[sizeof h->linkname] = '\0';
557 recent_long_link = 0;
558 recent_long_link_blocks = 0;
560 assign_string (&info->link_name, name);
562 return HEADER_SUCCESS;
567 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
569 /* Decode things from a file HEADER block into STAT_INFO, also setting
570 *FORMAT_POINTER depending on the header block format. If
571 DO_USER_GROUP, decode the user/group information (this is useful
572 for extraction, but waste time when merely listing).
574 read_header() has already decoded the checksum and length, so we don't.
576 This routine should *not* be called twice for the same block, since
577 the two calls might use different DO_USER_GROUP values and thus
578 might end up with different uid/gid for the two calls. If anybody
579 wants the uid/gid they should decode it first, and other callers
580 should decode it without uid/gid before calling a routine,
581 e.g. print_header, that assumes decoded data. */
583 decode_header (union block *header, struct tar_stat_info *stat_info,
584 enum archive_format *format_pointer, int do_user_group)
586 enum archive_format format;
587 unsigned hbits; /* high bits of the file mode. */
588 mode_t mode = MODE_FROM_HEADER (header->header.mode, &hbits);
590 if (strcmp (header->header.magic, TMAGIC) == 0)
592 if (header->star_header.prefix[130] == 0
593 && ISOCTAL (header->star_header.atime[0])
594 && header->star_header.atime[11] == ' '
595 && ISOCTAL (header->star_header.ctime[0])
596 && header->star_header.ctime[11] == ' ')
597 format = STAR_FORMAT;
598 else if (stat_info->xhdr.size)
599 format = POSIX_FORMAT;
601 format = USTAR_FORMAT;
603 else if (strcmp (header->buffer + offsetof (struct posix_header, magic),
606 format = hbits ? OLDGNU_FORMAT : GNU_FORMAT;
609 *format_pointer = format;
611 stat_info->stat.st_mode = mode;
612 stat_info->mtime.tv_sec = TIME_FROM_HEADER (header->header.mtime);
613 stat_info->mtime.tv_nsec = 0;
614 assign_string (&stat_info->uname,
615 header->header.uname[0] ? header->header.uname : NULL);
616 assign_string (&stat_info->gname,
617 header->header.gname[0] ? header->header.gname : NULL);
619 if (format == OLDGNU_FORMAT && incremental_option)
621 stat_info->atime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.atime);
622 stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.ctime);
623 stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
625 else if (format == STAR_FORMAT)
627 stat_info->atime.tv_sec = TIME_FROM_HEADER (header->star_header.atime);
628 stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->star_header.ctime);
629 stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
632 stat_info->atime = stat_info->ctime = start_time;
634 if (format == V7_FORMAT)
636 stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
637 stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
638 stat_info->stat.st_rdev = 0;
644 /* FIXME: Decide if this should somewhat depend on -p. */
646 if (numeric_owner_option
647 || !*header->header.uname
648 || !uname_to_uid (header->header.uname, &stat_info->stat.st_uid))
649 stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
651 if (numeric_owner_option
652 || !*header->header.gname
653 || !gname_to_gid (header->header.gname, &stat_info->stat.st_gid))
654 stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
657 switch (header->header.typeflag)
661 stat_info->stat.st_rdev =
662 makedev (MAJOR_FROM_HEADER (header->header.devmajor),
663 MINOR_FROM_HEADER (header->header.devminor));
667 stat_info->stat.st_rdev = 0;
671 stat_info->archive_file_size = stat_info->stat.st_size;
672 xheader_decode (stat_info);
674 if (sparse_member_p (stat_info))
676 sparse_fixup_header (stat_info);
677 stat_info->is_sparse = true;
681 stat_info->is_sparse = false;
682 if (((current_format == GNU_FORMAT
683 || current_format == OLDGNU_FORMAT)
684 && current_header->header.typeflag == GNUTYPE_DUMPDIR)
685 || stat_info->dumpdir)
686 stat_info->is_dumpdir = true;
691 /* Convert buffer at WHERE0 of size DIGS from external format to
692 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
693 are of type TYPE. The buffer must represent a value in the range
694 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
695 numbers instead of the other GNU extensions. Return -1 on error,
696 diagnosing the error if TYPE is nonnull and if !SILENT. */
698 from_header (char const *where0, size_t digs, char const *type,
699 uintmax_t minus_minval, uintmax_t maxval,
700 bool octal_only, bool silent)
703 char const *where = where0;
704 char const *lim = where + digs;
707 /* Accommodate buggy tar of unknown vintage, which outputs leading
708 NUL if the previous field overflows. */
711 /* Accommodate older tars, which output leading spaces. */
718 /* TRANSLATORS: %s is type of the value (gid_t, uid_t,
720 _("Blanks in header where numeric %s value expected"),
724 if (!ISSPACE ((unsigned char) *where))
730 if (ISODIGIT (*where))
732 char const *where1 = where;
733 uintmax_t overflow = 0;
737 value += *where++ - '0';
738 if (where == lim || ! ISODIGIT (*where))
740 overflow |= value ^ (value << LG_8 >> LG_8);
744 /* Parse the output of older, unportable tars, which generate
745 negative values in two's complement octal. If the leading
746 nonzero digit is 1, we can't recover the original value
747 reliably; so do this only if the digit is 2 or more. This
748 catches the common case of 32-bit negative time stamps. */
749 if ((overflow || maxval < value) && '2' <= *where1 && type)
751 /* Compute the negative of the input value, assuming two's
753 int digit = (*where1 - '0') | 4;
761 if (where == lim || ! ISODIGIT (*where))
763 digit = *where - '0';
764 overflow |= value ^ (value << LG_8 >> LG_8);
770 if (!overflow && value <= minus_minval)
774 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
775 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
776 (int) (where - where1), where1, type));
785 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
786 _("Archive octal value %.*s is out of %s range"),
787 (int) (where - where1), where1, type));
793 /* Suppress the following extensions. */
795 else if (*where == '-' || *where == '+')
797 /* Parse base-64 output produced only by tar test versions
798 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
799 Support for this will be withdrawn in future releases. */
803 static bool warned_once;
807 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
810 negative = *where++ == '-';
812 && (dig = base64_map[(unsigned char) *where]) < 64)
814 if (value << LG_64 >> LG_64 != value)
816 char *string = alloca (digs + 1);
817 memcpy (string, where0, digs);
821 _("Archive signed base-64 string %s is out of %s range"),
822 quote (string), type));
825 value = (value << LG_64) | dig;
829 else if (*where == '\200' /* positive base-256 */
830 || *where == '\377' /* negative base-256 */)
832 /* Parse base-256 output. A nonnegative number N is
833 represented as (256**DIGS)/2 + N; a negative number -N is
834 represented as (256**DIGS) - N, i.e. as two's complement.
835 The representation guarantees that the leading bit is
836 always on, so that we don't confuse this format with the
837 others (assuming ASCII bytes of 8 bits or more). */
838 int signbit = *where & (1 << (LG_256 - 2));
839 uintmax_t topbits = (((uintmax_t) - signbit)
840 << (CHAR_BIT * sizeof (uintmax_t)
841 - LG_256 - (LG_256 - 2)));
842 value = (*where++ & ((1 << (LG_256 - 2)) - 1)) - signbit;
845 value = (value << LG_256) + (unsigned char) *where++;
848 if (((value << LG_256 >> LG_256) | topbits) != value)
852 _("Archive base-256 value is out of %s range"),
862 if (where != lim && *where && !ISSPACE ((unsigned char) *where))
866 char buf[1000]; /* Big enough to represent any header. */
867 static struct quoting_options *o;
871 o = clone_quoting_options (0);
872 set_quoting_style (o, locale_quoting_style);
875 while (where0 != lim && ! lim[-1])
877 quotearg_buffer (buf, sizeof buf, where0, lim - where, o);
880 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
881 _("Archive contains %.*s where numeric %s value expected"),
882 (int) sizeof buf, buf, type));
888 if (value <= (negative ? minus_minval : maxval))
889 return negative ? -value : value;
893 char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
894 char maxval_buf[UINTMAX_STRSIZE_BOUND];
895 char value_buf[UINTMAX_STRSIZE_BOUND + 1];
896 char *minval_string = STRINGIFY_BIGINT (minus_minval, minval_buf + 1);
897 char *value_string = STRINGIFY_BIGINT (value, value_buf + 1);
899 *--value_string = '-';
901 *--minval_string = '-';
902 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
903 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
905 minval_string, STRINGIFY_BIGINT (maxval, maxval_buf)));
912 gid_from_header (const char *p, size_t s)
914 return from_header (p, s, "gid_t",
915 - (uintmax_t) TYPE_MINIMUM (gid_t),
916 (uintmax_t) TYPE_MAXIMUM (gid_t),
921 major_from_header (const char *p, size_t s)
923 return from_header (p, s, "major_t",
924 - (uintmax_t) TYPE_MINIMUM (major_t),
925 (uintmax_t) TYPE_MAXIMUM (major_t), false, false);
929 minor_from_header (const char *p, size_t s)
931 return from_header (p, s, "minor_t",
932 - (uintmax_t) TYPE_MINIMUM (minor_t),
933 (uintmax_t) TYPE_MAXIMUM (minor_t), false, false);
936 /* Convert P to the file mode, as understood by tar.
937 Store unrecognized mode bits (from 10th up) in HBITS. */
939 mode_from_header (const char *p, size_t s, unsigned *hbits)
941 unsigned u = from_header (p, s, "mode_t",
942 - (uintmax_t) TYPE_MINIMUM (mode_t),
943 TYPE_MAXIMUM (uintmax_t), false, false);
944 mode_t mode = ((u & TSUID ? S_ISUID : 0)
945 | (u & TSGID ? S_ISGID : 0)
946 | (u & TSVTX ? S_ISVTX : 0)
947 | (u & TUREAD ? S_IRUSR : 0)
948 | (u & TUWRITE ? S_IWUSR : 0)
949 | (u & TUEXEC ? S_IXUSR : 0)
950 | (u & TGREAD ? S_IRGRP : 0)
951 | (u & TGWRITE ? S_IWGRP : 0)
952 | (u & TGEXEC ? S_IXGRP : 0)
953 | (u & TOREAD ? S_IROTH : 0)
954 | (u & TOWRITE ? S_IWOTH : 0)
955 | (u & TOEXEC ? S_IXOTH : 0));
961 off_from_header (const char *p, size_t s)
963 /* Negative offsets are not allowed in tar files, so invoke
964 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
965 return from_header (p, s, "off_t", (uintmax_t) 0,
966 (uintmax_t) TYPE_MAXIMUM (off_t), false, false);
970 time_from_header (const char *p, size_t s)
972 return from_header (p, s, "time_t",
973 - (uintmax_t) TYPE_MINIMUM (time_t),
974 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
978 uid_from_header (const char *p, size_t s)
980 return from_header (p, s, "uid_t",
981 - (uintmax_t) TYPE_MINIMUM (uid_t),
982 (uintmax_t) TYPE_MAXIMUM (uid_t), false, false);
986 uintmax_from_header (const char *p, size_t s)
988 return from_header (p, s, "uintmax_t", (uintmax_t) 0,
989 TYPE_MAXIMUM (uintmax_t), false, false);
993 /* Return a printable representation of T. The result points to
994 static storage that can be reused in the next call to this
995 function, to ctime, or to asctime. If FULL_TIME, then output the
996 time stamp to its full resolution; otherwise, just output it to
997 1-minute resolution. */
999 tartime (struct timespec t, bool full_time)
1001 enum { fraclen = sizeof ".FFFFFFFFF" - 1 };
1002 static char buffer[max (UINTMAX_STRSIZE_BOUND + 1,
1003 INT_STRLEN_BOUND (int) + 16)
1006 time_t s = t.tv_sec;
1008 bool negative = s < 0;
1011 if (negative && ns != 0)
1014 ns = 1000000000 - ns;
1017 tm = utc_option ? gmtime (&s) : localtime (&s);
1022 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d:%02d",
1023 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
1024 tm->tm_hour, tm->tm_min, tm->tm_sec);
1025 code_ns_fraction (ns, buffer + strlen (buffer));
1028 sprintf (buffer, "%04ld-%02d-%02d %02d:%02d",
1029 tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
1030 tm->tm_hour, tm->tm_min);
1034 /* The time stamp cannot be broken down, most likely because it
1035 is out of range. Convert it as an integer,
1036 right-adjusted in a field with the same width as the usual
1037 4-year ISO time format. */
1038 p = umaxtostr (negative ? - (uintmax_t) s : s,
1039 buffer + sizeof buffer - UINTMAX_STRSIZE_BOUND - fraclen);
1042 while ((buffer + sizeof buffer - sizeof "YYYY-MM-DD HH:MM"
1043 + (full_time ? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1047 code_ns_fraction (ns, buffer + sizeof buffer - 1 - fraclen);
1051 /* Actually print it.
1053 Plain and fancy file header block logging. Non-verbose just prints
1054 the name, e.g. for "tar t" or "tar x". This should just contain
1055 file names, so it can be fed back into tar with xargs or the "-T"
1056 option. The verbose option can give a bunch of info, one line per
1057 file. I doubt anybody tries to parse its format, or if they do,
1058 they shouldn't. Unix tar is pretty random here anyway. */
1061 /* Width of "user/group size", with initial value chosen
1062 heuristically. This grows as needed, though this may cause some
1063 stairstepping in the output. Make it too small and the output will
1064 almost always look ragged. Make it too large and the output will
1065 be spaced out too far. */
1066 static int ugswidth = 19;
1068 /* Width of printed time stamps. It grows if longer time stamps are
1069 found (typically, those with nanosecond resolution). Like
1070 USGWIDTH, some stairstepping may occur. */
1071 static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1;
1073 static bool volume_label_printed = false;
1076 simple_print_header (struct tar_stat_info *st, union block *blk,
1077 off_t block_ordinal)
1080 char const *time_stamp;
1084 /* These hold formatted ints. */
1085 char uform[UINTMAX_STRSIZE_BOUND], gform[UINTMAX_STRSIZE_BOUND];
1087 char size[2 * UINTMAX_STRSIZE_BOUND];
1088 /* holds formatted size or major,minor */
1089 char uintbuf[UINTMAX_STRSIZE_BOUND];
1093 if (show_transformed_names_option)
1094 temp_name = st->file_name ? st->file_name : st->orig_file_name;
1096 temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
1098 if (block_number_option)
1100 char buf[UINTMAX_STRSIZE_BOUND];
1101 if (block_ordinal < 0)
1102 block_ordinal = current_block_ordinal ();
1103 block_ordinal -= recent_long_name_blocks;
1104 block_ordinal -= recent_long_link_blocks;
1105 fprintf (stdlis, _("block %s: "),
1106 STRINGIFY_BIGINT (block_ordinal, buf));
1109 if (verbose_option <= 1)
1111 /* Just the fax, mam. */
1112 fprintf (stdlis, "%s\n", quotearg (temp_name));
1116 /* File type and modes. */
1119 switch (blk->header.typeflag)
1121 case GNUTYPE_VOLHDR:
1122 volume_label_printed = true;
1126 case GNUTYPE_MULTIVOL:
1130 case GNUTYPE_LONGNAME:
1131 case GNUTYPE_LONGLINK:
1133 ERROR ((0, 0, _("Unexpected long name header")));
1136 case GNUTYPE_SPARSE:
1140 if (temp_name[strlen (temp_name) - 1] == '/')
1146 case GNUTYPE_DUMPDIR:
1169 pax_decode_mode (st->stat.st_mode, modes + 1);
1173 time_stamp = tartime (st->mtime, full_time_option);
1174 time_stamp_len = strlen (time_stamp);
1175 if (datewidth < time_stamp_len)
1176 datewidth = time_stamp_len;
1178 /* User and group names. */
1182 && current_format != V7_FORMAT
1183 && !numeric_owner_option)
1187 /* Try parsing it as an unsigned integer first, and as a
1188 uid_t if that fails. This method can list positive user
1189 ids that are too large to fit in a uid_t. */
1190 uintmax_t u = from_header (blk->header.uid,
1191 sizeof blk->header.uid, 0,
1193 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1196 user = STRINGIFY_BIGINT (u, uform);
1199 sprintf (uform, "%ld",
1200 (long) UID_FROM_HEADER (blk->header.uid));
1207 && current_format != V7_FORMAT
1208 && !numeric_owner_option)
1212 /* Try parsing it as an unsigned integer first, and as a
1213 gid_t if that fails. This method can list positive group
1214 ids that are too large to fit in a gid_t. */
1215 uintmax_t g = from_header (blk->header.gid,
1216 sizeof blk->header.gid, 0,
1218 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1221 group = STRINGIFY_BIGINT (g, gform);
1224 sprintf (gform, "%ld",
1225 (long) GID_FROM_HEADER (blk->header.gid));
1230 /* Format the file size or major/minor device numbers. */
1232 switch (blk->header.typeflag)
1237 STRINGIFY_BIGINT (major (st->stat.st_rdev), uintbuf));
1240 STRINGIFY_BIGINT (minor (st->stat.st_rdev), uintbuf));
1244 /* st->stat.st_size keeps stored file size */
1245 strcpy (size, STRINGIFY_BIGINT (st->stat.st_size, uintbuf));
1249 /* Figure out padding and print the whole line. */
1251 sizelen = strlen (size);
1252 pad = strlen (user) + 1 + strlen (group) + 1 + sizelen;
1256 fprintf (stdlis, "%s %s/%s %*s %-*s",
1257 modes, user, group, ugswidth - pad + sizelen, size,
1258 datewidth, time_stamp);
1260 fprintf (stdlis, " %s", quotearg (temp_name));
1262 switch (blk->header.typeflag)
1265 fprintf (stdlis, " -> %s\n", quotearg (st->link_name));
1269 fprintf (stdlis, _(" link to %s\n"), quotearg (st->link_name));
1274 char type_string[2];
1275 type_string[0] = blk->header.typeflag;
1276 type_string[1] = '\0';
1277 fprintf (stdlis, _(" unknown file type %s\n"),
1278 quote (type_string));
1284 case GNUTYPE_SPARSE:
1290 case GNUTYPE_DUMPDIR:
1291 putc ('\n', stdlis);
1294 case GNUTYPE_LONGLINK:
1295 fprintf (stdlis, _("--Long Link--\n"));
1298 case GNUTYPE_LONGNAME:
1299 fprintf (stdlis, _("--Long Name--\n"));
1302 case GNUTYPE_VOLHDR:
1303 fprintf (stdlis, _("--Volume Header--\n"));
1306 case GNUTYPE_MULTIVOL:
1309 (UINTMAX_FROM_HEADER (blk->oldgnu_header.offset),
1311 fprintf (stdlis, _("--Continued at byte %s--\n"), size);
1320 print_volume_label (void)
1322 struct tar_stat_info vstat;
1324 enum archive_format dummy;
1326 memset (&vblk, 0, sizeof (vblk));
1327 vblk.header.typeflag = GNUTYPE_VOLHDR;
1328 if (recent_global_header)
1329 memcpy (vblk.header.mtime, recent_global_header->header.mtime,
1330 sizeof vblk.header.mtime);
1331 tar_stat_init (&vstat);
1332 assign_string (&vstat.file_name, ".");
1333 decode_header (&vblk, &vstat, &dummy, 0);
1334 assign_string (&vstat.file_name, volume_label);
1335 simple_print_header (&vstat, &vblk, 0);
1336 tar_stat_destroy (&vstat);
1340 print_header (struct tar_stat_info *st, union block *blk,
1341 off_t block_ordinal)
1343 if (current_format == POSIX_FORMAT && !volume_label_printed && volume_label)
1345 print_volume_label ();
1346 volume_label_printed = true;
1349 simple_print_header (st, blk, block_ordinal);
1352 /* Print a similar line when we make a directory automatically. */
1354 print_for_mkdir (char *dirname, int length, mode_t mode)
1358 if (verbose_option > 1)
1360 /* File type and modes. */
1363 pax_decode_mode (mode, modes + 1);
1365 if (block_number_option)
1367 char buf[UINTMAX_STRSIZE_BOUND];
1368 fprintf (stdlis, _("block %s: "),
1369 STRINGIFY_BIGINT (current_block_ordinal (), buf));
1372 fprintf (stdlis, "%s %*s %.*s\n", modes, ugswidth + 1 + datewidth,
1373 _("Creating directory:"), length, quotearg (dirname));
1377 /* Skip over SIZE bytes of data in blocks in the archive. */
1379 skip_file (off_t size)
1383 /* FIXME: Make sure mv_begin_read is always called before it */
1385 if (seekable_archive)
1387 off_t nblk = seek_archive (size);
1389 size -= nblk * BLOCKSIZE;
1391 seekable_archive = false;
1394 mv_size_left (size);
1398 x = find_next_block ();
1400 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1402 set_next_block_after (x);
1404 mv_size_left (size);
1408 /* Skip the current member in the archive.
1409 NOTE: Current header must be decoded before calling this function. */
1413 if (!current_stat_info.skipped)
1415 char save_typeflag = current_header->header.typeflag;
1416 set_next_block_after (current_header);
1418 mv_begin_read (¤t_stat_info);
1420 if (current_stat_info.is_sparse)
1421 sparse_skip_file (¤t_stat_info);
1422 else if (save_typeflag != DIRTYPE)
1423 skip_file (current_stat_info.stat.st_size);
1430 test_archive_label ()
1435 open_archive (ACCESS_READ);
1436 if (read_header (¤t_header, ¤t_stat_info, read_header_auto)
1439 decode_header (current_header,
1440 ¤t_stat_info, ¤t_format, 0);
1441 if (current_header->header.typeflag == GNUTYPE_VOLHDR)
1442 assign_string (&volume_label, current_header->header.name);
1447 print_volume_label ();
1448 if (!name_match (volume_label) && multi_volume_option)
1450 char *s = drop_volume_label_suffix (volume_label);