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
,
85 case HEADER_STILL_UNREAD
:
86 case HEADER_SUCCESS_EXTENDED
:
91 /* Valid header. We should decode next field (mode) first.
92 Ensure incoming names are null terminated. */
93 decode_header (current_header
, ¤t_stat_info
,
95 if (! name_match (current_stat_info
.file_name
)
96 || (NEWER_OPTION_INITIALIZED (newer_mtime_option
)
97 /* FIXME: We get mtime now, and again later; this causes
98 duplicate diagnostics if header.mtime is bogus. */
100 = TIME_FROM_HEADER (current_header
->header
.mtime
)),
101 /* FIXME: Grab fractional time stamps from
104 current_stat_info
.mtime
= mtime
,
105 OLDER_TAR_STAT_TIME (current_stat_info
, m
)))
106 || excluded_name (current_stat_info
.file_name
))
108 switch (current_header
->header
.typeflag
)
111 case GNUTYPE_MULTIVOL
:
115 if (show_omitted_dirs_option
)
116 WARN ((0, 0, _("%s: Omitting"),
117 quotearg_colon (current_stat_info
.file_name
)));
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
,
144 if (status
== HEADER_ZERO_BLOCK
)
146 WARNOPT (WARN_ALONE_ZERO_BLOCK
,
147 (0, 0, _("A lone zero block at %s"),
148 STRINGIFY_BIGINT (current_block_ordinal (), buf
)));
151 status
= prev_status
;
154 case HEADER_END_OF_FILE
:
155 if (block_number_option
)
157 char buf
[UINTMAX_STRSIZE_BOUND
];
158 fprintf (stdlis
, _("block %s: ** End of File **\n"),
159 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
164 /* If the previous header was good, tell them that we are
165 skipping bad ones. */
166 set_next_block_after (current_header
);
169 case HEADER_STILL_UNREAD
:
170 ERROR ((0, 0, _("This does not look like a tar archive")));
173 case HEADER_ZERO_BLOCK
:
175 if (block_number_option
)
177 char buf
[UINTMAX_STRSIZE_BOUND
];
178 off_t block_ordinal
= current_block_ordinal ();
179 block_ordinal
-= recent_long_name_blocks
;
180 block_ordinal
-= recent_long_link_blocks
;
181 fprintf (stdlis
, _("block %s: "),
182 STRINGIFY_BIGINT (block_ordinal
, buf
));
184 ERROR ((0, 0, _("Skipping to next header")));
187 case HEADER_END_OF_FILE
:
189 /* We are in the middle of a cascade of errors. */
192 case HEADER_SUCCESS_EXTENDED
:
199 while (!all_names_found (¤t_stat_info
));
202 names_notfound (); /* print names not found */
205 /* Print a header block, based on tar options. */
209 off_t block_ordinal
= current_block_ordinal ();
211 /* Print the header block. */
213 print_header (¤t_stat_info
, current_header
, block_ordinal
);
215 if (incremental_option
)
217 if (verbose_option
> 2)
219 if (is_dumpdir (¤t_stat_info
))
220 list_dumpdir (current_stat_info
.dumpdir
,
221 dumpdir_size (current_stat_info
.dumpdir
));
228 /* Check header checksum */
229 /* The standard BSD tar sources create the checksum by adding up the
230 bytes in the header as type char. I think the type char was unsigned
231 on the PDP-11, but it's signed on the Next and Sun. It looks like the
232 sources to BSD tar were never changed to compute the checksum
233 correctly, so both the Sun and Next add the bytes of the header as
234 signed chars. This doesn't cause a problem until you get a file with
235 a name containing characters with the high bit set. So tar_checksum
236 computes two checksums -- signed and unsigned. */
239 tar_checksum (union block
*header
, bool silent
)
242 int unsigned_sum
= 0; /* the POSIX one :-) */
243 int signed_sum
= 0; /* the Sun one :-( */
245 uintmax_t parsed_sum
;
249 for (i
= sizeof *header
; i
-- != 0;)
251 unsigned_sum
+= (unsigned char) *p
;
252 signed_sum
+= (signed char) (*p
++);
255 if (unsigned_sum
== 0)
256 return HEADER_ZERO_BLOCK
;
258 /* Adjust checksum to count the "chksum" field as blanks. */
260 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
262 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
263 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
265 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
266 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
268 parsed_sum
= from_header (header
->header
.chksum
,
269 sizeof header
->header
.chksum
, 0,
271 (uintmax_t) TYPE_MAXIMUM (int), true, silent
);
272 if (parsed_sum
== (uintmax_t) -1)
273 return HEADER_FAILURE
;
275 recorded_sum
= parsed_sum
;
277 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
278 return HEADER_FAILURE
;
280 return HEADER_SUCCESS
;
283 /* Read a block that's supposed to be a header block. Return its
284 address in *RETURN_BLOCK, and if it is good, the file's size
285 and names (file name, link name) in *INFO.
287 Return one of enum read_header describing the status of the
290 The MODE parameter instructs read_header what to do with special
291 header blocks, i.e.: extended POSIX, GNU long name or long link,
294 read_header_auto process them automatically,
295 read_header_x_raw when a special header is read, return
296 HEADER_SUCCESS_EXTENDED without actually
297 processing the header,
298 read_header_x_global when a POSIX global header is read,
299 decode it and return HEADER_SUCCESS_EXTENDED.
301 You must always set_next_block_after(*return_block) to skip past
302 the header which this routine reads. */
305 read_header (union block
**return_block
, struct tar_stat_info
*info
,
306 enum read_header_mode mode
)
309 union block
*header_copy
;
311 union block
*data_block
;
312 size_t size
, written
;
313 union block
*next_long_name
= 0;
314 union block
*next_long_link
= 0;
315 size_t next_long_name_blocks
= 0;
316 size_t next_long_link_blocks
= 0;
320 enum read_header status
;
322 header
= find_next_block ();
323 *return_block
= header
;
325 return HEADER_END_OF_FILE
;
327 if ((status
= tar_checksum (header
, false)) != HEADER_SUCCESS
)
330 /* Good block. Decode file size and return. */
332 if (header
->header
.typeflag
== LNKTYPE
)
333 info
->stat
.st_size
= 0; /* links 0 size on tape */
335 info
->stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
337 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
338 || header
->header
.typeflag
== GNUTYPE_LONGLINK
339 || header
->header
.typeflag
== XHDTYPE
340 || header
->header
.typeflag
== XGLTYPE
341 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
343 if (mode
== read_header_x_raw
)
344 return HEADER_SUCCESS_EXTENDED
;
345 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
346 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
348 size_t name_size
= info
->stat
.st_size
;
349 size_t n
= name_size
% BLOCKSIZE
;
350 size
= name_size
+ BLOCKSIZE
;
352 size
+= BLOCKSIZE
- n
;
354 if (name_size
!= info
->stat
.st_size
|| size
< name_size
)
357 header_copy
= xmalloc (size
+ 1);
359 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
362 free (next_long_name
);
363 next_long_name
= header_copy
;
364 next_long_name_blocks
= size
/ BLOCKSIZE
;
369 free (next_long_link
);
370 next_long_link
= header_copy
;
371 next_long_link_blocks
= size
/ BLOCKSIZE
;
374 set_next_block_after (header
);
375 *header_copy
= *header
;
376 bp
= header_copy
->buffer
+ BLOCKSIZE
;
378 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
380 data_block
= find_next_block ();
383 ERROR ((0, 0, _("Unexpected EOF in archive")));
386 written
= available_space_after (data_block
);
390 memcpy (bp
, data_block
->buffer
, written
);
392 set_next_block_after ((union block
*)
393 (data_block
->buffer
+ written
- 1));
398 else if (header
->header
.typeflag
== XHDTYPE
399 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
400 xheader_read (&info
->xhdr
, header
,
401 OFF_FROM_HEADER (header
->header
.size
));
402 else if (header
->header
.typeflag
== XGLTYPE
)
406 if (!recent_global_header
)
407 recent_global_header
= xmalloc (sizeof *recent_global_header
);
408 memcpy (recent_global_header
, header
,
409 sizeof *recent_global_header
);
410 memset (&xhdr
, 0, sizeof xhdr
);
411 xheader_read (&xhdr
, header
,
412 OFF_FROM_HEADER (header
->header
.size
));
413 xheader_decode_global (&xhdr
);
414 xheader_destroy (&xhdr
);
415 if (mode
== read_header_x_global
)
416 return HEADER_SUCCESS_EXTENDED
;
425 struct posix_header
const *h
= &header
->header
;
426 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
428 if (recent_long_name
)
429 free (recent_long_name
);
433 name
= next_long_name
->buffer
+ BLOCKSIZE
;
434 recent_long_name
= next_long_name
;
435 recent_long_name_blocks
= next_long_name_blocks
;
439 /* Accept file names as specified by POSIX.1-1996
443 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
445 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
446 np
[sizeof h
->prefix
] = '\0';
450 memcpy (np
, h
->name
, sizeof h
->name
);
451 np
[sizeof h
->name
] = '\0';
453 recent_long_name
= 0;
454 recent_long_name_blocks
= 0;
456 assign_string (&info
->orig_file_name
, name
);
457 assign_string (&info
->file_name
, name
);
458 info
->had_trailing_slash
= strip_trailing_slashes (info
->file_name
);
460 if (recent_long_link
)
461 free (recent_long_link
);
465 name
= next_long_link
->buffer
+ BLOCKSIZE
;
466 recent_long_link
= next_long_link
;
467 recent_long_link_blocks
= next_long_link_blocks
;
471 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
472 namebuf
[sizeof h
->linkname
] = '\0';
474 recent_long_link
= 0;
475 recent_long_link_blocks
= 0;
477 assign_string (&info
->link_name
, name
);
479 return HEADER_SUCCESS
;
485 decode_xform (char *file_name
, void *data
)
487 int type
= *(int*)data
;
492 /* FIXME: It is not quite clear how and to which extent are the symbolic
493 links subject to filename transformation. In the absence of another
494 solution, symbolic links are exempt from component stripping and
495 name suffix normalization, but subject to filename transformation
500 file_name
= safer_name_suffix (file_name
, true, absolute_names_option
);
504 file_name
= safer_name_suffix (file_name
, false, absolute_names_option
);
508 if (strip_name_components
)
510 size_t prefix_len
= stripped_prefix_len (file_name
,
511 strip_name_components
);
512 if (prefix_len
== (size_t) -1)
513 prefix_len
= strlen (file_name
);
514 file_name
+= prefix_len
;
520 transform_member_name (char **pinput
, int type
)
522 return transform_name_fp (pinput
, type
, decode_xform
, &type
);
525 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
527 /* Decode things from a file HEADER block into STAT_INFO, also setting
528 *FORMAT_POINTER depending on the header block format. If
529 DO_USER_GROUP, decode the user/group information (this is useful
530 for extraction, but waste time when merely listing).
532 read_header() has already decoded the checksum and length, so we don't.
534 This routine should *not* be called twice for the same block, since
535 the two calls might use different DO_USER_GROUP values and thus
536 might end up with different uid/gid for the two calls. If anybody
537 wants the uid/gid they should decode it first, and other callers
538 should decode it without uid/gid before calling a routine,
539 e.g. print_header, that assumes decoded data. */
541 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
542 enum archive_format
*format_pointer
, int do_user_group
)
544 enum archive_format format
;
545 unsigned hbits
; /* high bits of the file mode. */
546 mode_t mode
= MODE_FROM_HEADER (header
->header
.mode
, &hbits
);
548 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
550 if (header
->star_header
.prefix
[130] == 0
551 && ISOCTAL (header
->star_header
.atime
[0])
552 && header
->star_header
.atime
[11] == ' '
553 && ISOCTAL (header
->star_header
.ctime
[0])
554 && header
->star_header
.ctime
[11] == ' ')
555 format
= STAR_FORMAT
;
556 else if (stat_info
->xhdr
.size
)
557 format
= POSIX_FORMAT
;
559 format
= USTAR_FORMAT
;
561 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
562 format
= hbits
? OLDGNU_FORMAT
: GNU_FORMAT
;
565 *format_pointer
= format
;
567 stat_info
->stat
.st_mode
= mode
;
568 stat_info
->mtime
.tv_sec
= TIME_FROM_HEADER (header
->header
.mtime
);
569 stat_info
->mtime
.tv_nsec
= 0;
570 assign_string (&stat_info
->uname
,
571 header
->header
.uname
[0] ? header
->header
.uname
: NULL
);
572 assign_string (&stat_info
->gname
,
573 header
->header
.gname
[0] ? header
->header
.gname
: NULL
);
575 if (format
== OLDGNU_FORMAT
&& incremental_option
)
577 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
578 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
579 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
581 else if (format
== STAR_FORMAT
)
583 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.atime
);
584 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.ctime
);
585 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
588 stat_info
->atime
= stat_info
->ctime
= start_time
;
590 if (format
== V7_FORMAT
)
592 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
593 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
594 stat_info
->stat
.st_rdev
= 0;
600 /* FIXME: Decide if this should somewhat depend on -p. */
602 if (numeric_owner_option
603 || !*header
->header
.uname
604 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
605 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
607 if (numeric_owner_option
608 || !*header
->header
.gname
609 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
610 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
613 switch (header
->header
.typeflag
)
617 stat_info
->stat
.st_rdev
=
618 makedev (MAJOR_FROM_HEADER (header
->header
.devmajor
),
619 MINOR_FROM_HEADER (header
->header
.devminor
));
623 stat_info
->stat
.st_rdev
= 0;
627 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
628 xheader_decode (stat_info
);
630 if (sparse_member_p (stat_info
))
632 sparse_fixup_header (stat_info
);
633 stat_info
->is_sparse
= true;
637 stat_info
->is_sparse
= false;
638 if (((current_format
== GNU_FORMAT
639 || current_format
== OLDGNU_FORMAT
)
640 && current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
641 || stat_info
->dumpdir
)
642 stat_info
->is_dumpdir
= true;
645 transform_member_name (&stat_info
->file_name
, XFORM_REGFILE
);
646 switch (header
->header
.typeflag
)
649 transform_member_name (&stat_info
->link_name
, XFORM_SYMLINK
);
653 transform_member_name (&stat_info
->link_name
, XFORM_LINK
);
657 /* Convert buffer at WHERE0 of size DIGS from external format to
658 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
659 are of type TYPE. The buffer must represent a value in the range
660 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
661 numbers instead of the other GNU extensions. Return -1 on error,
662 diagnosing the error if TYPE is nonnull and if !SILENT. */
664 from_header (char const *where0
, size_t digs
, char const *type
,
665 uintmax_t minus_minval
, uintmax_t maxval
,
666 bool octal_only
, bool silent
)
669 char const *where
= where0
;
670 char const *lim
= where
+ digs
;
673 /* Accommodate buggy tar of unknown vintage, which outputs leading
674 NUL if the previous field overflows. */
677 /* Accommodate older tars, which output leading spaces. */
684 /* TRANSLATORS: %s is type of the value (gid_t, uid_t,
686 _("Blanks in header where numeric %s value expected"),
690 if (!ISSPACE ((unsigned char) *where
))
696 if (ISODIGIT (*where
))
698 char const *where1
= where
;
699 uintmax_t overflow
= 0;
703 value
+= *where
++ - '0';
704 if (where
== lim
|| ! ISODIGIT (*where
))
706 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
710 /* Parse the output of older, unportable tars, which generate
711 negative values in two's complement octal. If the leading
712 nonzero digit is 1, we can't recover the original value
713 reliably; so do this only if the digit is 2 or more. This
714 catches the common case of 32-bit negative time stamps. */
715 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
717 /* Compute the negative of the input value, assuming two's
719 int digit
= (*where1
- '0') | 4;
727 if (where
== lim
|| ! ISODIGIT (*where
))
729 digit
= *where
- '0';
730 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
736 if (!overflow
&& value
<= minus_minval
)
740 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
741 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
742 (int) (where
- where1
), where1
, type
));
751 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
752 _("Archive octal value %.*s is out of %s range"),
753 (int) (where
- where1
), where1
, type
));
759 /* Suppress the following extensions. */
761 else if (*where
== '-' || *where
== '+')
763 /* Parse base-64 output produced only by tar test versions
764 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
765 Support for this will be withdrawn in future releases. */
769 static bool warned_once
;
773 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
776 negative
= *where
++ == '-';
778 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
780 if (value
<< LG_64
>> LG_64
!= value
)
782 char *string
= alloca (digs
+ 1);
783 memcpy (string
, where0
, digs
);
787 _("Archive signed base-64 string %s is out of %s range"),
788 quote (string
), type
));
791 value
= (value
<< LG_64
) | dig
;
795 else if (*where
== '\200' /* positive base-256 */
796 || *where
== '\377' /* negative base-256 */)
798 /* Parse base-256 output. A nonnegative number N is
799 represented as (256**DIGS)/2 + N; a negative number -N is
800 represented as (256**DIGS) - N, i.e. as two's complement.
801 The representation guarantees that the leading bit is
802 always on, so that we don't confuse this format with the
803 others (assuming ASCII bytes of 8 bits or more). */
804 int signbit
= *where
& (1 << (LG_256
- 2));
805 uintmax_t topbits
= (((uintmax_t) - signbit
)
806 << (CHAR_BIT
* sizeof (uintmax_t)
807 - LG_256
- (LG_256
- 2)));
808 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
811 value
= (value
<< LG_256
) + (unsigned char) *where
++;
814 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
818 _("Archive base-256 value is out of %s range"),
828 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
832 char buf
[1000]; /* Big enough to represent any header. */
833 static struct quoting_options
*o
;
837 o
= clone_quoting_options (0);
838 set_quoting_style (o
, locale_quoting_style
);
841 while (where0
!= lim
&& ! lim
[-1])
843 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
846 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
847 _("Archive contains %.*s where numeric %s value expected"),
848 (int) sizeof buf
, buf
, type
));
854 if (value
<= (negative
? minus_minval
: maxval
))
855 return negative
? -value
: value
;
859 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
860 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
861 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
862 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
863 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
865 *--value_string
= '-';
867 *--minval_string
= '-';
868 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
869 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
871 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
878 gid_from_header (const char *p
, size_t s
)
880 return from_header (p
, s
, "gid_t",
881 - (uintmax_t) TYPE_MINIMUM (gid_t
),
882 (uintmax_t) TYPE_MAXIMUM (gid_t
),
887 major_from_header (const char *p
, size_t s
)
889 return from_header (p
, s
, "major_t",
890 - (uintmax_t) TYPE_MINIMUM (major_t
),
891 (uintmax_t) TYPE_MAXIMUM (major_t
), false, false);
895 minor_from_header (const char *p
, size_t s
)
897 return from_header (p
, s
, "minor_t",
898 - (uintmax_t) TYPE_MINIMUM (minor_t
),
899 (uintmax_t) TYPE_MAXIMUM (minor_t
), false, false);
902 /* Convert P to the file mode, as understood by tar.
903 Store unrecognized mode bits (from 10th up) in HBITS. */
905 mode_from_header (const char *p
, size_t s
, unsigned *hbits
)
907 unsigned u
= from_header (p
, s
, "mode_t",
908 - (uintmax_t) TYPE_MINIMUM (mode_t
),
909 TYPE_MAXIMUM (uintmax_t), false, false);
910 mode_t mode
= ((u
& TSUID
? S_ISUID
: 0)
911 | (u
& TSGID
? S_ISGID
: 0)
912 | (u
& TSVTX
? S_ISVTX
: 0)
913 | (u
& TUREAD
? S_IRUSR
: 0)
914 | (u
& TUWRITE
? S_IWUSR
: 0)
915 | (u
& TUEXEC
? S_IXUSR
: 0)
916 | (u
& TGREAD
? S_IRGRP
: 0)
917 | (u
& TGWRITE
? S_IWGRP
: 0)
918 | (u
& TGEXEC
? S_IXGRP
: 0)
919 | (u
& TOREAD
? S_IROTH
: 0)
920 | (u
& TOWRITE
? S_IWOTH
: 0)
921 | (u
& TOEXEC
? S_IXOTH
: 0));
927 off_from_header (const char *p
, size_t s
)
929 /* Negative offsets are not allowed in tar files, so invoke
930 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
931 return from_header (p
, s
, "off_t", (uintmax_t) 0,
932 (uintmax_t) TYPE_MAXIMUM (off_t
), false, false);
936 size_from_header (const char *p
, size_t s
)
938 return from_header (p
, s
, "size_t", (uintmax_t) 0,
939 (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
943 time_from_header (const char *p
, size_t s
)
945 return from_header (p
, s
, "time_t",
946 - (uintmax_t) TYPE_MINIMUM (time_t),
947 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
951 uid_from_header (const char *p
, size_t s
)
953 return from_header (p
, s
, "uid_t",
954 - (uintmax_t) TYPE_MINIMUM (uid_t
),
955 (uintmax_t) TYPE_MAXIMUM (uid_t
), false, false);
959 uintmax_from_header (const char *p
, size_t s
)
961 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
962 TYPE_MAXIMUM (uintmax_t), false, false);
966 /* Return a printable representation of T. The result points to
967 static storage that can be reused in the next call to this
968 function, to ctime, or to asctime. If FULL_TIME, then output the
969 time stamp to its full resolution; otherwise, just output it to
970 1-minute resolution. */
972 tartime (struct timespec t
, bool full_time
)
974 enum { fraclen
= sizeof ".FFFFFFFFF" - 1 };
975 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
976 INT_STRLEN_BOUND (int) + 16)
981 bool negative
= s
< 0;
984 if (negative
&& ns
!= 0)
987 ns
= 1000000000 - ns
;
990 tm
= utc_option
? gmtime (&s
) : localtime (&s
);
995 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
996 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
997 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
998 code_ns_fraction (ns
, buffer
+ strlen (buffer
));
1001 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d",
1002 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
1003 tm
->tm_hour
, tm
->tm_min
);
1007 /* The time stamp cannot be broken down, most likely because it
1008 is out of range. Convert it as an integer,
1009 right-adjusted in a field with the same width as the usual
1010 4-year ISO time format. */
1011 p
= umaxtostr (negative
? - (uintmax_t) s
: s
,
1012 buffer
+ sizeof buffer
- UINTMAX_STRSIZE_BOUND
- fraclen
);
1015 while ((buffer
+ sizeof buffer
- sizeof "YYYY-MM-DD HH:MM"
1016 + (full_time
? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1020 code_ns_fraction (ns
, buffer
+ sizeof buffer
- 1 - fraclen
);
1024 /* Actually print it.
1026 Plain and fancy file header block logging. Non-verbose just prints
1027 the name, e.g. for "tar t" or "tar x". This should just contain
1028 file names, so it can be fed back into tar with xargs or the "-T"
1029 option. The verbose option can give a bunch of info, one line per
1030 file. I doubt anybody tries to parse its format, or if they do,
1031 they shouldn't. Unix tar is pretty random here anyway. */
1034 /* Width of "user/group size", with initial value chosen
1035 heuristically. This grows as needed, though this may cause some
1036 stairstepping in the output. Make it too small and the output will
1037 almost always look ragged. Make it too large and the output will
1038 be spaced out too far. */
1039 static int ugswidth
= 19;
1041 /* Width of printed time stamps. It grows if longer time stamps are
1042 found (typically, those with nanosecond resolution). Like
1043 USGWIDTH, some stairstepping may occur. */
1044 static int datewidth
= sizeof "YYYY-MM-DD HH:MM" - 1;
1046 static bool volume_label_printed
= false;
1049 simple_print_header (struct tar_stat_info
*st
, union block
*blk
,
1050 off_t block_ordinal
)
1053 char const *time_stamp
;
1057 /* These hold formatted ints. */
1058 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
1060 char size
[2 * UINTMAX_STRSIZE_BOUND
];
1061 /* holds formatted size or major,minor */
1062 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
1066 if (show_transformed_names_option
)
1067 temp_name
= st
->file_name
? st
->file_name
: st
->orig_file_name
;
1069 temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
1071 if (block_number_option
)
1073 char buf
[UINTMAX_STRSIZE_BOUND
];
1074 if (block_ordinal
< 0)
1075 block_ordinal
= current_block_ordinal ();
1076 block_ordinal
-= recent_long_name_blocks
;
1077 block_ordinal
-= recent_long_link_blocks
;
1078 fprintf (stdlis
, _("block %s: "),
1079 STRINGIFY_BIGINT (block_ordinal
, buf
));
1082 if (verbose_option
<= 1)
1084 /* Just the fax, mam. */
1085 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
1089 /* File type and modes. */
1092 switch (blk
->header
.typeflag
)
1094 case GNUTYPE_VOLHDR
:
1095 volume_label_printed
= true;
1099 case GNUTYPE_MULTIVOL
:
1103 case GNUTYPE_LONGNAME
:
1104 case GNUTYPE_LONGLINK
:
1106 ERROR ((0, 0, _("Unexpected long name header")));
1109 case GNUTYPE_SPARSE
:
1113 if (temp_name
[strlen (temp_name
) - 1] == '/')
1119 case GNUTYPE_DUMPDIR
:
1142 pax_decode_mode (st
->stat
.st_mode
, modes
+ 1);
1146 time_stamp
= tartime (st
->mtime
, full_time_option
);
1147 time_stamp_len
= strlen (time_stamp
);
1148 if (datewidth
< time_stamp_len
)
1149 datewidth
= time_stamp_len
;
1151 /* User and group names. */
1155 && current_format
!= V7_FORMAT
1156 && !numeric_owner_option
)
1160 /* Try parsing it as an unsigned integer first, and as a
1161 uid_t if that fails. This method can list positive user
1162 ids that are too large to fit in a uid_t. */
1163 uintmax_t u
= from_header (blk
->header
.uid
,
1164 sizeof blk
->header
.uid
, 0,
1166 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1169 user
= STRINGIFY_BIGINT (u
, uform
);
1172 sprintf (uform
, "%ld",
1173 (long) UID_FROM_HEADER (blk
->header
.uid
));
1180 && current_format
!= V7_FORMAT
1181 && !numeric_owner_option
)
1185 /* Try parsing it as an unsigned integer first, and as a
1186 gid_t if that fails. This method can list positive group
1187 ids that are too large to fit in a gid_t. */
1188 uintmax_t g
= from_header (blk
->header
.gid
,
1189 sizeof blk
->header
.gid
, 0,
1191 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1194 group
= STRINGIFY_BIGINT (g
, gform
);
1197 sprintf (gform
, "%ld",
1198 (long) GID_FROM_HEADER (blk
->header
.gid
));
1203 /* Format the file size or major/minor device numbers. */
1205 switch (blk
->header
.typeflag
)
1210 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1213 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1217 /* st->stat.st_size keeps stored file size */
1218 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1222 /* Figure out padding and print the whole line. */
1224 sizelen
= strlen (size
);
1225 pad
= strlen (user
) + 1 + strlen (group
) + 1 + sizelen
;
1229 fprintf (stdlis
, "%s %s/%s %*s %-*s",
1230 modes
, user
, group
, ugswidth
- pad
+ sizelen
, size
,
1231 datewidth
, time_stamp
);
1233 fprintf (stdlis
, " %s", quotearg (temp_name
));
1235 switch (blk
->header
.typeflag
)
1238 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1242 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1247 char type_string
[2];
1248 type_string
[0] = blk
->header
.typeflag
;
1249 type_string
[1] = '\0';
1250 fprintf (stdlis
, _(" unknown file type %s\n"),
1251 quote (type_string
));
1257 case GNUTYPE_SPARSE
:
1263 case GNUTYPE_DUMPDIR
:
1264 putc ('\n', stdlis
);
1267 case GNUTYPE_LONGLINK
:
1268 fprintf (stdlis
, _("--Long Link--\n"));
1271 case GNUTYPE_LONGNAME
:
1272 fprintf (stdlis
, _("--Long Name--\n"));
1275 case GNUTYPE_VOLHDR
:
1276 fprintf (stdlis
, _("--Volume Header--\n"));
1279 case GNUTYPE_MULTIVOL
:
1282 (UINTMAX_FROM_HEADER (blk
->oldgnu_header
.offset
),
1284 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1293 print_volume_label (void)
1295 struct tar_stat_info vstat
;
1297 enum archive_format dummy
;
1299 memset (&vblk
, 0, sizeof (vblk
));
1300 vblk
.header
.typeflag
= GNUTYPE_VOLHDR
;
1301 if (recent_global_header
)
1302 memcpy (vblk
.header
.mtime
, recent_global_header
->header
.mtime
,
1303 sizeof vblk
.header
.mtime
);
1304 tar_stat_init (&vstat
);
1305 assign_string (&vstat
.file_name
, ".");
1306 decode_header (&vblk
, &vstat
, &dummy
, 0);
1307 assign_string (&vstat
.file_name
, volume_label
);
1308 simple_print_header (&vstat
, &vblk
, 0);
1309 tar_stat_destroy (&vstat
);
1313 print_header (struct tar_stat_info
*st
, union block
*blk
,
1314 off_t block_ordinal
)
1316 if (current_format
== POSIX_FORMAT
&& !volume_label_printed
&& volume_label
)
1318 print_volume_label ();
1319 volume_label_printed
= true;
1322 simple_print_header (st
, blk
, block_ordinal
);
1325 /* Print a similar line when we make a directory automatically. */
1327 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1331 if (verbose_option
> 1)
1333 /* File type and modes. */
1336 pax_decode_mode (mode
, modes
+ 1);
1338 if (block_number_option
)
1340 char buf
[UINTMAX_STRSIZE_BOUND
];
1341 fprintf (stdlis
, _("block %s: "),
1342 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1345 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ 1 + datewidth
,
1346 _("Creating directory:"), length
, quotearg (dirname
));
1350 /* Skip over SIZE bytes of data in blocks in the archive. */
1352 skip_file (off_t size
)
1356 /* FIXME: Make sure mv_begin is always called before it */
1358 if (seekable_archive
)
1360 off_t nblk
= seek_archive (size
);
1362 size
-= nblk
* BLOCKSIZE
;
1364 seekable_archive
= false;
1367 mv_size_left (size
);
1371 x
= find_next_block ();
1373 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1375 set_next_block_after (x
);
1377 mv_size_left (size
);
1381 /* Skip the current member in the archive.
1382 NOTE: Current header must be decoded before calling this function. */
1386 if (!current_stat_info
.skipped
)
1388 char save_typeflag
= current_header
->header
.typeflag
;
1389 set_next_block_after (current_header
);
1391 mv_begin (¤t_stat_info
);
1393 if (current_stat_info
.is_sparse
)
1394 sparse_skip_file (¤t_stat_info
);
1395 else if (save_typeflag
!= DIRTYPE
)
1396 skip_file (current_stat_info
.stat
.st_size
);
1403 test_archive_label ()
1408 open_archive (ACCESS_READ
);
1409 if (read_header (¤t_header
, ¤t_stat_info
, read_header_auto
)
1412 decode_header (current_header
,
1413 ¤t_stat_info
, ¤t_format
, 0);
1414 if (current_header
->header
.typeflag
== GNUTYPE_VOLHDR
)
1415 assign_string (&volume_label
, current_header
->header
.name
);
1420 print_volume_label ();
1421 if (!name_match (volume_label
) && multi_volume_option
)
1423 char *s
= drop_volume_label_suffix (volume_label
);