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 static uintmax_t from_header (const char *, size_t, const char *,
39 uintmax_t, uintmax_t, bool, bool);
41 /* Base 64 digits; see Internet RFC 2045 Table 1. */
42 static char const base_64_digits
[64] =
44 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
45 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
46 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
47 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
48 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
51 /* Table of base-64 digit values indexed by unsigned chars.
52 The value is 64 for unsigned chars that are not base-64 digits. */
53 static char base64_map
[UCHAR_MAX
+ 1];
59 memset (base64_map
, 64, sizeof base64_map
);
60 for (i
= 0; i
< 64; i
++)
61 base64_map
[(int) base_64_digits
[i
]] = i
;
64 /* Main loop for reading an archive. */
66 read_and (void (*do_something
) (void))
68 enum read_header status
= HEADER_STILL_UNREAD
;
69 enum read_header prev_status
;
70 struct timespec mtime
;
75 open_archive (ACCESS_READ
);
79 tar_stat_destroy (¤t_stat_info
);
81 status
= read_header (¤t_header
, ¤t_stat_info
, false);
84 case HEADER_STILL_UNREAD
:
85 case HEADER_SUCCESS_EXTENDED
:
90 /* Valid header. We should decode next field (mode) first.
91 Ensure incoming names are null terminated. */
93 if (! name_match (current_stat_info
.file_name
)
94 || (NEWER_OPTION_INITIALIZED (newer_mtime_option
)
95 /* FIXME: We get mtime now, and again later; this causes
96 duplicate diagnostics if header.mtime is bogus. */
98 = TIME_FROM_HEADER (current_header
->header
.mtime
)),
99 /* FIXME: Grab fractional time stamps from
102 current_stat_info
.mtime
= mtime
,
103 OLDER_TAR_STAT_TIME (current_stat_info
, m
)))
104 || excluded_name (current_stat_info
.file_name
))
106 switch (current_header
->header
.typeflag
)
109 case GNUTYPE_MULTIVOL
:
113 if (show_omitted_dirs_option
)
114 WARN ((0, 0, _("%s: Omitting"),
115 quotearg_colon (current_stat_info
.file_name
)));
118 decode_header (current_header
,
119 ¤t_stat_info
, ¤t_format
, 0);
128 case HEADER_ZERO_BLOCK
:
129 if (block_number_option
)
131 char buf
[UINTMAX_STRSIZE_BOUND
];
132 fprintf (stdlis
, _("block %s: ** Block of NULs **\n"),
133 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
136 set_next_block_after (current_header
);
138 if (!ignore_zeros_option
)
140 char buf
[UINTMAX_STRSIZE_BOUND
];
142 status
= read_header (¤t_header
, ¤t_stat_info
, false);
143 if (status
== HEADER_ZERO_BLOCK
)
145 WARNOPT (WARN_ALONE_ZERO_BLOCK
,
146 (0, 0, _("A lone zero block at %s"),
147 STRINGIFY_BIGINT (current_block_ordinal (), buf
)));
150 status
= prev_status
;
153 case HEADER_END_OF_FILE
:
154 if (block_number_option
)
156 char buf
[UINTMAX_STRSIZE_BOUND
];
157 fprintf (stdlis
, _("block %s: ** End of File **\n"),
158 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
163 /* If the previous header was good, tell them that we are
164 skipping bad ones. */
165 set_next_block_after (current_header
);
168 case HEADER_STILL_UNREAD
:
169 ERROR ((0, 0, _("This does not look like a tar archive")));
172 case HEADER_ZERO_BLOCK
:
174 if (block_number_option
)
176 char buf
[UINTMAX_STRSIZE_BOUND
];
177 off_t block_ordinal
= current_block_ordinal ();
178 block_ordinal
-= recent_long_name_blocks
;
179 block_ordinal
-= recent_long_link_blocks
;
180 fprintf (stdlis
, _("block %s: "),
181 STRINGIFY_BIGINT (block_ordinal
, buf
));
183 ERROR ((0, 0, _("Skipping to next header")));
186 case HEADER_END_OF_FILE
:
188 /* We are in the middle of a cascade of errors. */
191 case HEADER_SUCCESS_EXTENDED
:
198 while (!all_names_found (¤t_stat_info
));
201 names_notfound (); /* print names not found */
204 /* Print a header block, based on tar options. */
208 off_t block_ordinal
= current_block_ordinal ();
210 /* Print the header block. */
212 decode_header (current_header
, ¤t_stat_info
, ¤t_format
, 0);
214 print_header (¤t_stat_info
, current_header
, block_ordinal
);
216 if (incremental_option
)
218 if (verbose_option
> 2)
220 if (is_dumpdir (¤t_stat_info
))
221 list_dumpdir (current_stat_info
.dumpdir
,
222 dumpdir_size (current_stat_info
.dumpdir
));
229 /* Check header checksum */
230 /* The standard BSD tar sources create the checksum by adding up the
231 bytes in the header as type char. I think the type char was unsigned
232 on the PDP-11, but it's signed on the Next and Sun. It looks like the
233 sources to BSD tar were never changed to compute the checksum
234 correctly, so both the Sun and Next add the bytes of the header as
235 signed chars. This doesn't cause a problem until you get a file with
236 a name containing characters with the high bit set. So tar_checksum
237 computes two checksums -- signed and unsigned. */
240 tar_checksum (union block
*header
, bool silent
)
243 int unsigned_sum
= 0; /* the POSIX one :-) */
244 int signed_sum
= 0; /* the Sun one :-( */
246 uintmax_t parsed_sum
;
250 for (i
= sizeof *header
; i
-- != 0;)
252 unsigned_sum
+= (unsigned char) *p
;
253 signed_sum
+= (signed char) (*p
++);
256 if (unsigned_sum
== 0)
257 return HEADER_ZERO_BLOCK
;
259 /* Adjust checksum to count the "chksum" field as blanks. */
261 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
263 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
264 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
266 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
267 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
269 parsed_sum
= from_header (header
->header
.chksum
,
270 sizeof header
->header
.chksum
, 0,
272 (uintmax_t) TYPE_MAXIMUM (int), true, silent
);
273 if (parsed_sum
== (uintmax_t) -1)
274 return HEADER_FAILURE
;
276 recorded_sum
= parsed_sum
;
278 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
279 return HEADER_FAILURE
;
281 return HEADER_SUCCESS
;
284 /* Read a block that's supposed to be a header block. Return its
285 address in "current_header", and if it is good, the file's size
286 and names (file name, link name) in *info.
288 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
289 block full of zeros (EOF marker).
291 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
292 GNU long name and link headers into later headers.
294 You must always set_next_block_after(current_header) to skip past
295 the header which this routine reads. */
298 read_header (union block
**return_block
, struct tar_stat_info
*info
,
299 bool raw_extended_headers
)
302 union block
*header_copy
;
304 union block
*data_block
;
305 size_t size
, written
;
306 union block
*next_long_name
= 0;
307 union block
*next_long_link
= 0;
308 size_t next_long_name_blocks
= 0;
309 size_t next_long_link_blocks
= 0;
313 enum read_header status
;
315 header
= find_next_block ();
316 *return_block
= header
;
318 return HEADER_END_OF_FILE
;
320 if ((status
= tar_checksum (header
, false)) != HEADER_SUCCESS
)
323 /* Good block. Decode file size and return. */
325 if (header
->header
.typeflag
== LNKTYPE
)
326 info
->stat
.st_size
= 0; /* links 0 size on tape */
328 info
->stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
330 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
331 || header
->header
.typeflag
== GNUTYPE_LONGLINK
332 || header
->header
.typeflag
== XHDTYPE
333 || header
->header
.typeflag
== XGLTYPE
334 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
336 if (raw_extended_headers
)
337 return HEADER_SUCCESS_EXTENDED
;
338 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
339 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
341 size_t name_size
= info
->stat
.st_size
;
342 size_t n
= name_size
% BLOCKSIZE
;
343 size
= name_size
+ BLOCKSIZE
;
345 size
+= BLOCKSIZE
- n
;
347 if (name_size
!= info
->stat
.st_size
|| size
< name_size
)
350 header_copy
= xmalloc (size
+ 1);
352 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
355 free (next_long_name
);
356 next_long_name
= header_copy
;
357 next_long_name_blocks
= size
/ BLOCKSIZE
;
362 free (next_long_link
);
363 next_long_link
= header_copy
;
364 next_long_link_blocks
= size
/ BLOCKSIZE
;
367 set_next_block_after (header
);
368 *header_copy
= *header
;
369 bp
= header_copy
->buffer
+ BLOCKSIZE
;
371 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
373 data_block
= find_next_block ();
376 ERROR ((0, 0, _("Unexpected EOF in archive")));
379 written
= available_space_after (data_block
);
383 memcpy (bp
, data_block
->buffer
, written
);
385 set_next_block_after ((union block
*)
386 (data_block
->buffer
+ written
- 1));
391 else if (header
->header
.typeflag
== XHDTYPE
392 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
393 xheader_read (&info
->xhdr
, header
,
394 OFF_FROM_HEADER (header
->header
.size
));
395 else if (header
->header
.typeflag
== XGLTYPE
)
399 if (!recent_global_header
)
400 recent_global_header
= xmalloc (sizeof *recent_global_header
);
401 memcpy (recent_global_header
, header
,
402 sizeof *recent_global_header
);
403 memset (&xhdr
, 0, sizeof xhdr
);
404 xheader_read (&xhdr
, header
,
405 OFF_FROM_HEADER (header
->header
.size
));
406 xheader_decode_global (&xhdr
);
407 xheader_destroy (&xhdr
);
416 struct posix_header
const *h
= &header
->header
;
417 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
419 if (recent_long_name
)
420 free (recent_long_name
);
424 name
= next_long_name
->buffer
+ BLOCKSIZE
;
425 recent_long_name
= next_long_name
;
426 recent_long_name_blocks
= next_long_name_blocks
;
430 /* Accept file names as specified by POSIX.1-1996
434 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
436 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
437 np
[sizeof h
->prefix
] = '\0';
441 memcpy (np
, h
->name
, sizeof h
->name
);
442 np
[sizeof h
->name
] = '\0';
444 recent_long_name
= 0;
445 recent_long_name_blocks
= 0;
447 assign_string (&info
->orig_file_name
, name
);
448 assign_string (&info
->file_name
, name
);
449 info
->had_trailing_slash
= strip_trailing_slashes (info
->file_name
);
451 if (recent_long_link
)
452 free (recent_long_link
);
456 name
= next_long_link
->buffer
+ BLOCKSIZE
;
457 recent_long_link
= next_long_link
;
458 recent_long_link_blocks
= next_long_link_blocks
;
462 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
463 namebuf
[sizeof h
->linkname
] = '\0';
465 recent_long_link
= 0;
466 recent_long_link_blocks
= 0;
468 assign_string (&info
->link_name
, name
);
470 return HEADER_SUCCESS
;
476 decode_xform (char *file_name
, void *data
)
478 int type
= *(int*)data
;
483 /* FIXME: It is not quite clear how and to which extent are the symbolic
484 links subject to filename transformation. In the absence of another
485 solution, symbolic links are exempt from component stripping and
486 name suffix normalization, but subject to filename transformation
491 file_name
= safer_name_suffix (file_name
, true, absolute_names_option
);
495 file_name
= safer_name_suffix (file_name
, false, absolute_names_option
);
499 if (strip_name_components
)
501 size_t prefix_len
= stripped_prefix_len (file_name
,
502 strip_name_components
);
503 if (prefix_len
== (size_t) -1)
504 prefix_len
= strlen (file_name
);
505 file_name
+= prefix_len
;
511 transform_member_name (char **pinput
, int type
)
513 return transform_name_fp (pinput
, type
, decode_xform
, &type
);
516 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
518 /* Decode things from a file HEADER block into STAT_INFO, also setting
519 *FORMAT_POINTER depending on the header block format. If
520 DO_USER_GROUP, decode the user/group information (this is useful
521 for extraction, but waste time when merely listing).
523 read_header() has already decoded the checksum and length, so we don't.
525 This routine should *not* be called twice for the same block, since
526 the two calls might use different DO_USER_GROUP values and thus
527 might end up with different uid/gid for the two calls. If anybody
528 wants the uid/gid they should decode it first, and other callers
529 should decode it without uid/gid before calling a routine,
530 e.g. print_header, that assumes decoded data. */
532 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
533 enum archive_format
*format_pointer
, int do_user_group
)
535 enum archive_format format
;
536 unsigned hbits
; /* high bits of the file mode. */
537 mode_t mode
= MODE_FROM_HEADER (header
->header
.mode
, &hbits
);
539 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
541 if (header
->star_header
.prefix
[130] == 0
542 && ISOCTAL (header
->star_header
.atime
[0])
543 && header
->star_header
.atime
[11] == ' '
544 && ISOCTAL (header
->star_header
.ctime
[0])
545 && header
->star_header
.ctime
[11] == ' ')
546 format
= STAR_FORMAT
;
547 else if (stat_info
->xhdr
.size
)
548 format
= POSIX_FORMAT
;
550 format
= USTAR_FORMAT
;
552 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
553 format
= hbits
? OLDGNU_FORMAT
: GNU_FORMAT
;
556 *format_pointer
= format
;
558 stat_info
->stat
.st_mode
= mode
;
559 stat_info
->mtime
.tv_sec
= TIME_FROM_HEADER (header
->header
.mtime
);
560 stat_info
->mtime
.tv_nsec
= 0;
561 assign_string (&stat_info
->uname
,
562 header
->header
.uname
[0] ? header
->header
.uname
: NULL
);
563 assign_string (&stat_info
->gname
,
564 header
->header
.gname
[0] ? header
->header
.gname
: NULL
);
566 if (format
== OLDGNU_FORMAT
&& incremental_option
)
568 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
569 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
570 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
572 else if (format
== STAR_FORMAT
)
574 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.atime
);
575 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.ctime
);
576 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
579 stat_info
->atime
= stat_info
->ctime
= start_time
;
581 if (format
== V7_FORMAT
)
583 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
584 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
585 stat_info
->stat
.st_rdev
= 0;
591 /* FIXME: Decide if this should somewhat depend on -p. */
593 if (numeric_owner_option
594 || !*header
->header
.uname
595 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
596 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
598 if (numeric_owner_option
599 || !*header
->header
.gname
600 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
601 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
604 switch (header
->header
.typeflag
)
608 stat_info
->stat
.st_rdev
=
609 makedev (MAJOR_FROM_HEADER (header
->header
.devmajor
),
610 MINOR_FROM_HEADER (header
->header
.devminor
));
614 stat_info
->stat
.st_rdev
= 0;
618 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
619 xheader_decode (stat_info
);
621 if (sparse_member_p (stat_info
))
623 sparse_fixup_header (stat_info
);
624 stat_info
->is_sparse
= true;
628 stat_info
->is_sparse
= false;
629 if (((current_format
== GNU_FORMAT
630 || current_format
== OLDGNU_FORMAT
)
631 && current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
632 || stat_info
->dumpdir
)
633 stat_info
->is_dumpdir
= true;
636 transform_member_name (&stat_info
->file_name
, XFORM_REGFILE
);
637 switch (header
->header
.typeflag
)
640 transform_member_name (&stat_info
->link_name
, XFORM_SYMLINK
);
644 transform_member_name (&stat_info
->link_name
, XFORM_LINK
);
648 /* Convert buffer at WHERE0 of size DIGS from external format to
649 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
650 are of type TYPE. The buffer must represent a value in the range
651 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
652 numbers instead of the other GNU extensions. Return -1 on error,
653 diagnosing the error if TYPE is nonnull and if !SILENT. */
655 from_header (char const *where0
, size_t digs
, char const *type
,
656 uintmax_t minus_minval
, uintmax_t maxval
,
657 bool octal_only
, bool silent
)
660 char const *where
= where0
;
661 char const *lim
= where
+ digs
;
664 /* Accommodate buggy tar of unknown vintage, which outputs leading
665 NUL if the previous field overflows. */
668 /* Accommodate older tars, which output leading spaces. */
675 /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
676 _("Blanks in header where numeric %s value expected"),
680 if (!ISSPACE ((unsigned char) *where
))
686 if (ISODIGIT (*where
))
688 char const *where1
= where
;
689 uintmax_t overflow
= 0;
693 value
+= *where
++ - '0';
694 if (where
== lim
|| ! ISODIGIT (*where
))
696 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
700 /* Parse the output of older, unportable tars, which generate
701 negative values in two's complement octal. If the leading
702 nonzero digit is 1, we can't recover the original value
703 reliably; so do this only if the digit is 2 or more. This
704 catches the common case of 32-bit negative time stamps. */
705 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
707 /* Compute the negative of the input value, assuming two's
709 int digit
= (*where1
- '0') | 4;
717 if (where
== lim
|| ! ISODIGIT (*where
))
719 digit
= *where
- '0';
720 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
726 if (!overflow
&& value
<= minus_minval
)
730 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
731 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
732 (int) (where
- where1
), where1
, type
));
741 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
742 _("Archive octal value %.*s is out of %s range"),
743 (int) (where
- where1
), where1
, type
));
749 /* Suppress the following extensions. */
751 else if (*where
== '-' || *where
== '+')
753 /* Parse base-64 output produced only by tar test versions
754 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
755 Support for this will be withdrawn in future releases. */
759 static bool warned_once
;
763 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
766 negative
= *where
++ == '-';
768 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
770 if (value
<< LG_64
>> LG_64
!= value
)
772 char *string
= alloca (digs
+ 1);
773 memcpy (string
, where0
, digs
);
777 _("Archive signed base-64 string %s is out of %s range"),
778 quote (string
), type
));
781 value
= (value
<< LG_64
) | dig
;
785 else if (*where
== '\200' /* positive base-256 */
786 || *where
== '\377' /* negative base-256 */)
788 /* Parse base-256 output. A nonnegative number N is
789 represented as (256**DIGS)/2 + N; a negative number -N is
790 represented as (256**DIGS) - N, i.e. as two's complement.
791 The representation guarantees that the leading bit is
792 always on, so that we don't confuse this format with the
793 others (assuming ASCII bytes of 8 bits or more). */
794 int signbit
= *where
& (1 << (LG_256
- 2));
795 uintmax_t topbits
= (((uintmax_t) - signbit
)
796 << (CHAR_BIT
* sizeof (uintmax_t)
797 - LG_256
- (LG_256
- 2)));
798 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
801 value
= (value
<< LG_256
) + (unsigned char) *where
++;
804 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
808 _("Archive base-256 value is out of %s range"),
818 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
822 char buf
[1000]; /* Big enough to represent any header. */
823 static struct quoting_options
*o
;
827 o
= clone_quoting_options (0);
828 set_quoting_style (o
, locale_quoting_style
);
831 while (where0
!= lim
&& ! lim
[-1])
833 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
836 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
837 _("Archive contains %.*s where numeric %s value expected"),
838 (int) sizeof buf
, buf
, type
));
844 if (value
<= (negative
? minus_minval
: maxval
))
845 return negative
? -value
: value
;
849 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
850 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
851 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
852 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
853 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
855 *--value_string
= '-';
857 *--minval_string
= '-';
858 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
859 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
861 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
868 gid_from_header (const char *p
, size_t s
)
870 return from_header (p
, s
, "gid_t",
871 - (uintmax_t) TYPE_MINIMUM (gid_t
),
872 (uintmax_t) TYPE_MAXIMUM (gid_t
),
877 major_from_header (const char *p
, size_t s
)
879 return from_header (p
, s
, "major_t",
880 - (uintmax_t) TYPE_MINIMUM (major_t
),
881 (uintmax_t) TYPE_MAXIMUM (major_t
), false, false);
885 minor_from_header (const char *p
, size_t s
)
887 return from_header (p
, s
, "minor_t",
888 - (uintmax_t) TYPE_MINIMUM (minor_t
),
889 (uintmax_t) TYPE_MAXIMUM (minor_t
), false, false);
892 /* Convert P to the file mode, as understood by tar.
893 Store unrecognized mode bits (from 10th up) in HBITS. */
895 mode_from_header (const char *p
, size_t s
, unsigned *hbits
)
897 unsigned u
= from_header (p
, s
, "mode_t",
898 - (uintmax_t) TYPE_MINIMUM (mode_t
),
899 TYPE_MAXIMUM (uintmax_t), false, false);
900 mode_t mode
= ((u
& TSUID
? S_ISUID
: 0)
901 | (u
& TSGID
? S_ISGID
: 0)
902 | (u
& TSVTX
? S_ISVTX
: 0)
903 | (u
& TUREAD
? S_IRUSR
: 0)
904 | (u
& TUWRITE
? S_IWUSR
: 0)
905 | (u
& TUEXEC
? S_IXUSR
: 0)
906 | (u
& TGREAD
? S_IRGRP
: 0)
907 | (u
& TGWRITE
? S_IWGRP
: 0)
908 | (u
& TGEXEC
? S_IXGRP
: 0)
909 | (u
& TOREAD
? S_IROTH
: 0)
910 | (u
& TOWRITE
? S_IWOTH
: 0)
911 | (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 /* Width of "user/group size", with initial value chosen
1025 heuristically. This grows as needed, though this may cause some
1026 stairstepping in the output. Make it too small and the output will
1027 almost always look ragged. Make it too large and the output will
1028 be spaced out too far. */
1029 static int ugswidth
= 19;
1031 /* Width of printed time stamps. It grows if longer time stamps are
1032 found (typically, those with nanosecond resolution). Like
1033 USGWIDTH, some stairstepping may occur. */
1034 static int datewidth
= sizeof "YYYY-MM-DD HH:MM" - 1;
1036 static bool volume_label_printed
= false;
1039 simple_print_header (struct tar_stat_info
*st
, union block
*blk
,
1040 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
&& blk
->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 (blk
->header
.typeflag
)
1087 case GNUTYPE_VOLHDR
:
1088 volume_label_printed
= true;
1092 case GNUTYPE_MULTIVOL
:
1096 case GNUTYPE_LONGNAME
:
1097 case GNUTYPE_LONGLINK
:
1099 ERROR ((0, 0, _("Unexpected long name header")));
1102 case GNUTYPE_SPARSE
:
1106 if (temp_name
[strlen (temp_name
) - 1] == '/')
1112 case GNUTYPE_DUMPDIR
:
1135 pax_decode_mode (st
->stat
.st_mode
, modes
+ 1);
1139 time_stamp
= tartime (st
->mtime
, false);
1140 time_stamp_len
= strlen (time_stamp
);
1141 if (datewidth
< time_stamp_len
)
1142 datewidth
= time_stamp_len
;
1144 /* User and group names. */
1148 && current_format
!= V7_FORMAT
1149 && !numeric_owner_option
)
1153 /* Try parsing it as an unsigned integer first, and as a
1154 uid_t if that fails. This method can list positive user
1155 ids that are too large to fit in a uid_t. */
1156 uintmax_t u
= from_header (blk
->header
.uid
,
1157 sizeof blk
->header
.uid
, 0,
1159 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1162 user
= STRINGIFY_BIGINT (u
, uform
);
1165 sprintf (uform
, "%ld",
1166 (long) UID_FROM_HEADER (blk
->header
.uid
));
1173 && current_format
!= V7_FORMAT
1174 && !numeric_owner_option
)
1178 /* Try parsing it as an unsigned integer first, and as a
1179 gid_t if that fails. This method can list positive group
1180 ids that are too large to fit in a gid_t. */
1181 uintmax_t g
= from_header (blk
->header
.gid
,
1182 sizeof blk
->header
.gid
, 0,
1184 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1187 group
= STRINGIFY_BIGINT (g
, gform
);
1190 sprintf (gform
, "%ld",
1191 (long) GID_FROM_HEADER (blk
->header
.gid
));
1196 /* Format the file size or major/minor device numbers. */
1198 switch (blk
->header
.typeflag
)
1203 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1206 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1210 /* st->stat.st_size keeps stored file size */
1211 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1215 /* Figure out padding and print the whole line. */
1217 sizelen
= strlen (size
);
1218 pad
= strlen (user
) + 1 + strlen (group
) + 1 + sizelen
;
1222 fprintf (stdlis
, "%s %s/%s %*s %-*s",
1223 modes
, user
, group
, ugswidth
- pad
+ sizelen
, size
,
1224 datewidth
, time_stamp
);
1226 fprintf (stdlis
, " %s", quotearg (temp_name
));
1228 switch (blk
->header
.typeflag
)
1231 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1235 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1240 char type_string
[2];
1241 type_string
[0] = blk
->header
.typeflag
;
1242 type_string
[1] = '\0';
1243 fprintf (stdlis
, _(" unknown file type %s\n"),
1244 quote (type_string
));
1250 case GNUTYPE_SPARSE
:
1256 case GNUTYPE_DUMPDIR
:
1257 putc ('\n', stdlis
);
1260 case GNUTYPE_LONGLINK
:
1261 fprintf (stdlis
, _("--Long Link--\n"));
1264 case GNUTYPE_LONGNAME
:
1265 fprintf (stdlis
, _("--Long Name--\n"));
1268 case GNUTYPE_VOLHDR
:
1269 fprintf (stdlis
, _("--Volume Header--\n"));
1272 case GNUTYPE_MULTIVOL
:
1275 (UINTMAX_FROM_HEADER (blk
->oldgnu_header
.offset
),
1277 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1286 print_header (struct tar_stat_info
*st
, union block
*blk
,
1287 off_t block_ordinal
)
1289 if (current_format
== POSIX_FORMAT
&& !volume_label_printed
&& volume_label
)
1291 struct tar_stat_info vstat
;
1293 enum archive_format dummy
;
1295 volume_label_printed
= true;
1297 memset (&vblk
, 0, sizeof (vblk
));
1298 vblk
.header
.typeflag
= GNUTYPE_VOLHDR
;
1299 if (recent_global_header
)
1300 memcpy (vblk
.header
.mtime
, recent_global_header
->header
.mtime
,
1301 sizeof vblk
.header
.mtime
);
1302 tar_stat_init (&vstat
);
1303 assign_string (&vstat
.file_name
, ".");
1304 decode_header (&vblk
, &vstat
, &dummy
, 0);
1305 assign_string (&vstat
.file_name
, volume_label
);
1306 simple_print_header (&vstat
, &vblk
, block_ordinal
);
1307 tar_stat_destroy (&vstat
);
1309 simple_print_header (st
, blk
, block_ordinal
);
1312 /* Print a similar line when we make a directory automatically. */
1314 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1318 if (verbose_option
> 1)
1320 /* File type and modes. */
1323 pax_decode_mode (mode
, modes
+ 1);
1325 if (block_number_option
)
1327 char buf
[UINTMAX_STRSIZE_BOUND
];
1328 fprintf (stdlis
, _("block %s: "),
1329 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1332 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ 1 + datewidth
,
1333 _("Creating directory:"), length
, quotearg (dirname
));
1337 /* Skip over SIZE bytes of data in blocks in the archive. */
1339 skip_file (off_t size
)
1343 /* FIXME: Make sure mv_begin is always called before it */
1345 if (seekable_archive
)
1347 off_t nblk
= seek_archive (size
);
1349 size
-= nblk
* BLOCKSIZE
;
1351 seekable_archive
= false;
1354 mv_size_left (size
);
1358 x
= find_next_block ();
1360 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1362 set_next_block_after (x
);
1364 mv_size_left (size
);
1368 /* Skip the current member in the archive.
1369 NOTE: Current header must be decoded before calling this function. */
1373 if (!current_stat_info
.skipped
)
1375 char save_typeflag
= current_header
->header
.typeflag
;
1376 set_next_block_after (current_header
);
1378 mv_begin (¤t_stat_info
);
1380 if (current_stat_info
.is_sparse
)
1381 sparse_skip_file (¤t_stat_info
);
1382 else if (save_typeflag
!= DIRTYPE
)
1383 skip_file (current_stat_info
.stat
.st_size
);