1 /* List a tar archive, with support routines for reading a tar archive.
3 Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,
4 2001, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
6 Written by John Gilmore, on 1985-08-26.
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 3, or (at your option) any later
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
16 Public License for more details.
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
28 #define max(a, b) ((a) < (b) ? (b) : (a))
30 union block
*current_header
; /* points to current archive header */
31 enum archive_format current_format
; /* recognized format */
32 union block
*recent_long_name
; /* recent long name header and contents */
33 union block
*recent_long_link
; /* likewise, for long link */
34 size_t recent_long_name_blocks
; /* number of blocks in recent_long_name */
35 size_t recent_long_link_blocks
; /* likewise, for long link */
37 static uintmax_t from_header (const char *, size_t, const char *,
38 uintmax_t, uintmax_t, bool, bool);
40 /* Base 64 digits; see Internet RFC 2045 Table 1. */
41 static char const base_64_digits
[64] =
43 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
44 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
45 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
46 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
47 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
50 /* Table of base-64 digit values indexed by unsigned chars.
51 The value is 64 for unsigned chars that are not base-64 digits. */
52 static char base64_map
[UCHAR_MAX
+ 1];
58 memset (base64_map
, 64, sizeof base64_map
);
59 for (i
= 0; i
< 64; i
++)
60 base64_map
[(int) base_64_digits
[i
]] = i
;
63 /* Main loop for reading an archive. */
65 read_and (void (*do_something
) (void))
67 enum read_header status
= HEADER_STILL_UNREAD
;
68 enum read_header prev_status
;
69 struct timespec mtime
;
74 open_archive (ACCESS_READ
);
78 tar_stat_destroy (¤t_stat_info
);
80 status
= read_header (false);
83 case HEADER_STILL_UNREAD
:
84 case HEADER_SUCCESS_EXTENDED
:
89 /* Valid header. We should decode next field (mode) first.
90 Ensure incoming names are null terminated. */
92 if (! name_match (current_stat_info
.file_name
)
93 || (NEWER_OPTION_INITIALIZED (newer_mtime_option
)
94 /* FIXME: We get mtime now, and again later; this causes
95 duplicate diagnostics if header.mtime is bogus. */
97 = TIME_FROM_HEADER (current_header
->header
.mtime
)),
98 /* FIXME: Grab fractional time stamps from
101 current_stat_info
.mtime
= mtime
,
102 OLDER_TAR_STAT_TIME (current_stat_info
, m
)))
103 || excluded_name (current_stat_info
.file_name
))
105 switch (current_header
->header
.typeflag
)
108 case GNUTYPE_MULTIVOL
:
112 if (show_omitted_dirs_option
)
113 WARN ((0, 0, _("%s: Omitting"),
114 quotearg_colon (current_stat_info
.file_name
)));
117 decode_header (current_header
,
118 ¤t_stat_info
, ¤t_format
, 0);
127 case HEADER_ZERO_BLOCK
:
128 if (block_number_option
)
130 char buf
[UINTMAX_STRSIZE_BOUND
];
131 fprintf (stdlis
, _("block %s: ** Block of NULs **\n"),
132 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
135 set_next_block_after (current_header
);
137 if (!ignore_zeros_option
)
139 char buf
[UINTMAX_STRSIZE_BOUND
];
141 status
= read_header (false);
142 if (status
== HEADER_ZERO_BLOCK
)
144 WARNOPT (WARN_ALONE_ZERO_BLOCK
,
145 (0, 0, _("A lone zero block at %s"),
146 STRINGIFY_BIGINT (current_block_ordinal (), buf
)));
149 status
= prev_status
;
152 case HEADER_END_OF_FILE
:
153 if (block_number_option
)
155 char buf
[UINTMAX_STRSIZE_BOUND
];
156 fprintf (stdlis
, _("block %s: ** End of File **\n"),
157 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
162 /* If the previous header was good, tell them that we are
163 skipping bad ones. */
164 set_next_block_after (current_header
);
167 case HEADER_STILL_UNREAD
:
168 ERROR ((0, 0, _("This does not look like a tar archive")));
171 case HEADER_ZERO_BLOCK
:
173 if (block_number_option
)
175 char buf
[UINTMAX_STRSIZE_BOUND
];
176 off_t block_ordinal
= current_block_ordinal ();
177 block_ordinal
-= recent_long_name_blocks
;
178 block_ordinal
-= recent_long_link_blocks
;
179 fprintf (stdlis
, _("block %s: "),
180 STRINGIFY_BIGINT (block_ordinal
, buf
));
182 ERROR ((0, 0, _("Skipping to next header")));
185 case HEADER_END_OF_FILE
:
187 /* We are in the middle of a cascade of errors. */
190 case HEADER_SUCCESS_EXTENDED
:
197 while (!all_names_found (¤t_stat_info
));
200 names_notfound (); /* print names not found */
203 /* Print a header block, based on tar options. */
207 off_t block_ordinal
= current_block_ordinal ();
208 /* Print the header block. */
210 decode_header (current_header
, ¤t_stat_info
, ¤t_format
, 0);
212 print_header (¤t_stat_info
, block_ordinal
);
214 if (incremental_option
)
216 if (verbose_option
> 2)
218 if (is_dumpdir (¤t_stat_info
))
219 list_dumpdir (current_stat_info
.dumpdir
,
220 dumpdir_size (current_stat_info
.dumpdir
));
227 /* Check header checksum */
228 /* The standard BSD tar sources create the checksum by adding up the
229 bytes in the header as type char. I think the type char was unsigned
230 on the PDP-11, but it's signed on the Next and Sun. It looks like the
231 sources to BSD tar were never changed to compute the checksum
232 correctly, so both the Sun and Next add the bytes of the header as
233 signed chars. This doesn't cause a problem until you get a file with
234 a name containing characters with the high bit set. So tar_checksum
235 computes two checksums -- signed and unsigned. */
238 tar_checksum (union block
*header
, bool silent
)
241 int unsigned_sum
= 0; /* the POSIX one :-) */
242 int signed_sum
= 0; /* the Sun one :-( */
244 uintmax_t parsed_sum
;
248 for (i
= sizeof *header
; i
-- != 0;)
250 unsigned_sum
+= (unsigned char) *p
;
251 signed_sum
+= (signed char) (*p
++);
254 if (unsigned_sum
== 0)
255 return HEADER_ZERO_BLOCK
;
257 /* Adjust checksum to count the "chksum" field as blanks. */
259 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
261 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
262 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
264 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
265 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
267 parsed_sum
= from_header (header
->header
.chksum
,
268 sizeof header
->header
.chksum
, 0,
270 (uintmax_t) TYPE_MAXIMUM (int), true, silent
);
271 if (parsed_sum
== (uintmax_t) -1)
272 return HEADER_FAILURE
;
274 recorded_sum
= parsed_sum
;
276 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
277 return HEADER_FAILURE
;
279 return HEADER_SUCCESS
;
282 /* Read a block that's supposed to be a header block. Return its
283 address in "current_header", and if it is good, the file's size
284 and names (file name, link name) in *info.
286 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
287 block full of zeros (EOF marker).
289 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
290 GNU long name and link headers into later headers.
292 You must always set_next_block_after(current_header) to skip past
293 the header which this routine reads. */
296 read_header_primitive (bool raw_extended_headers
, struct tar_stat_info
*info
)
299 union block
*header_copy
;
301 union block
*data_block
;
302 size_t size
, written
;
303 union block
*next_long_name
= 0;
304 union block
*next_long_link
= 0;
305 size_t next_long_name_blocks
= 0;
306 size_t next_long_link_blocks
= 0;
310 enum read_header status
;
312 header
= find_next_block ();
313 current_header
= header
;
315 return HEADER_END_OF_FILE
;
317 if ((status
= tar_checksum (header
, false)) != HEADER_SUCCESS
)
320 /* Good block. Decode file size and return. */
322 if (header
->header
.typeflag
== LNKTYPE
)
323 info
->stat
.st_size
= 0; /* links 0 size on tape */
325 info
->stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
327 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
328 || header
->header
.typeflag
== GNUTYPE_LONGLINK
329 || header
->header
.typeflag
== XHDTYPE
330 || header
->header
.typeflag
== XGLTYPE
331 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
333 if (raw_extended_headers
)
334 return HEADER_SUCCESS_EXTENDED
;
335 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
336 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
338 size_t name_size
= info
->stat
.st_size
;
339 size_t n
= name_size
% BLOCKSIZE
;
340 size
= name_size
+ BLOCKSIZE
;
342 size
+= BLOCKSIZE
- n
;
344 if (name_size
!= info
->stat
.st_size
|| size
< name_size
)
347 header_copy
= xmalloc (size
+ 1);
349 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
352 free (next_long_name
);
353 next_long_name
= header_copy
;
354 next_long_name_blocks
= size
/ BLOCKSIZE
;
359 free (next_long_link
);
360 next_long_link
= header_copy
;
361 next_long_link_blocks
= size
/ BLOCKSIZE
;
364 set_next_block_after (header
);
365 *header_copy
= *header
;
366 bp
= header_copy
->buffer
+ BLOCKSIZE
;
368 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
370 data_block
= find_next_block ();
373 ERROR ((0, 0, _("Unexpected EOF in archive")));
376 written
= available_space_after (data_block
);
380 memcpy (bp
, data_block
->buffer
, written
);
382 set_next_block_after ((union block
*)
383 (data_block
->buffer
+ written
- 1));
388 else if (header
->header
.typeflag
== XHDTYPE
389 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
390 xheader_read (&info
->xhdr
, header
,
391 OFF_FROM_HEADER (header
->header
.size
));
392 else if (header
->header
.typeflag
== XGLTYPE
)
395 memset (&xhdr
, 0, sizeof xhdr
);
396 xheader_read (&xhdr
, header
,
397 OFF_FROM_HEADER (header
->header
.size
));
398 xheader_decode_global (&xhdr
);
399 xheader_destroy (&xhdr
);
408 struct posix_header
const *h
= ¤t_header
->header
;
409 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
411 if (recent_long_name
)
412 free (recent_long_name
);
416 name
= next_long_name
->buffer
+ BLOCKSIZE
;
417 recent_long_name
= next_long_name
;
418 recent_long_name_blocks
= next_long_name_blocks
;
422 /* Accept file names as specified by POSIX.1-1996
426 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
428 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
429 np
[sizeof h
->prefix
] = '\0';
433 memcpy (np
, h
->name
, sizeof h
->name
);
434 np
[sizeof h
->name
] = '\0';
436 recent_long_name
= 0;
437 recent_long_name_blocks
= 0;
439 assign_string (&info
->orig_file_name
, name
);
440 assign_string (&info
->file_name
, name
);
441 info
->had_trailing_slash
= strip_trailing_slashes (info
->file_name
);
443 if (recent_long_link
)
444 free (recent_long_link
);
448 name
= next_long_link
->buffer
+ BLOCKSIZE
;
449 recent_long_link
= next_long_link
;
450 recent_long_link_blocks
= next_long_link_blocks
;
454 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
455 namebuf
[sizeof h
->linkname
] = '\0';
457 recent_long_link
= 0;
458 recent_long_link_blocks
= 0;
460 assign_string (&info
->link_name
, name
);
462 return HEADER_SUCCESS
;
468 read_header (bool raw_extended_headers
)
470 return read_header_primitive (raw_extended_headers
, ¤t_stat_info
);
474 decode_xform (char *file_name
, void *data
)
476 int type
= *(int*)data
;
481 /* FIXME: It is not quite clear how and to which extent are the symbolic
482 links subject to filename transformation. In the absence of another
483 solution, symbolic links are exempt from component stripping and
484 name suffix normalization, but subject to filename transformation
489 file_name
= safer_name_suffix (file_name
, true, absolute_names_option
);
493 file_name
= safer_name_suffix (file_name
, false, absolute_names_option
);
497 if (strip_name_components
)
499 size_t prefix_len
= stripped_prefix_len (file_name
,
500 strip_name_components
);
501 if (prefix_len
== (size_t) -1)
502 prefix_len
= strlen (file_name
);
503 file_name
+= prefix_len
;
509 transform_member_name (char **pinput
, int type
)
511 return transform_name_fp (pinput
, type
, decode_xform
, &type
);
514 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
516 /* Decode things from a file HEADER block into STAT_INFO, also setting
517 *FORMAT_POINTER depending on the header block format. If
518 DO_USER_GROUP, decode the user/group information (this is useful
519 for extraction, but waste time when merely listing).
521 read_header() has already decoded the checksum and length, so we don't.
523 This routine should *not* be called twice for the same block, since
524 the two calls might use different DO_USER_GROUP values and thus
525 might end up with different uid/gid for the two calls. If anybody
526 wants the uid/gid they should decode it first, and other callers
527 should decode it without uid/gid before calling a routine,
528 e.g. print_header, that assumes decoded data. */
530 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
531 enum archive_format
*format_pointer
, int do_user_group
)
533 enum archive_format format
;
534 unsigned hbits
; /* high bits of the file mode. */
535 mode_t mode
= MODE_FROM_HEADER (header
->header
.mode
, &hbits
);
537 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
539 if (header
->star_header
.prefix
[130] == 0
540 && ISOCTAL (header
->star_header
.atime
[0])
541 && header
->star_header
.atime
[11] == ' '
542 && ISOCTAL (header
->star_header
.ctime
[0])
543 && header
->star_header
.ctime
[11] == ' ')
544 format
= STAR_FORMAT
;
545 else if (stat_info
->xhdr
.size
)
546 format
= POSIX_FORMAT
;
548 format
= USTAR_FORMAT
;
550 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
551 format
= hbits
? OLDGNU_FORMAT
: GNU_FORMAT
;
554 *format_pointer
= format
;
556 stat_info
->stat
.st_mode
= mode
;
557 stat_info
->mtime
.tv_sec
= TIME_FROM_HEADER (header
->header
.mtime
);
558 stat_info
->mtime
.tv_nsec
= 0;
559 assign_string (&stat_info
->uname
,
560 header
->header
.uname
[0] ? header
->header
.uname
: NULL
);
561 assign_string (&stat_info
->gname
,
562 header
->header
.gname
[0] ? header
->header
.gname
: NULL
);
564 if (format
== OLDGNU_FORMAT
&& incremental_option
)
566 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
567 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
568 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
570 else if (format
== STAR_FORMAT
)
572 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.atime
);
573 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.ctime
);
574 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
577 stat_info
->atime
= stat_info
->ctime
= start_time
;
579 if (format
== V7_FORMAT
)
581 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
582 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
583 stat_info
->stat
.st_rdev
= 0;
589 /* FIXME: Decide if this should somewhat depend on -p. */
591 if (numeric_owner_option
592 || !*header
->header
.uname
593 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
594 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
596 if (numeric_owner_option
597 || !*header
->header
.gname
598 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
599 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
602 switch (header
->header
.typeflag
)
606 stat_info
->stat
.st_rdev
=
607 makedev (MAJOR_FROM_HEADER (header
->header
.devmajor
),
608 MINOR_FROM_HEADER (header
->header
.devminor
));
612 stat_info
->stat
.st_rdev
= 0;
616 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
617 xheader_decode (stat_info
);
619 if (sparse_member_p (stat_info
))
621 sparse_fixup_header (stat_info
);
622 stat_info
->is_sparse
= true;
626 stat_info
->is_sparse
= false;
627 if (((current_format
== GNU_FORMAT
628 || current_format
== OLDGNU_FORMAT
)
629 && current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
630 || stat_info
->dumpdir
)
631 stat_info
->is_dumpdir
= true;
634 transform_member_name (&stat_info
->file_name
, XFORM_REGFILE
);
635 switch (header
->header
.typeflag
)
638 transform_member_name (&stat_info
->link_name
, XFORM_SYMLINK
);
642 transform_member_name (&stat_info
->link_name
, XFORM_LINK
);
646 /* Convert buffer at WHERE0 of size DIGS from external format to
647 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
648 are of type TYPE. The buffer must represent a value in the range
649 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
650 numbers instead of the other GNU extensions. Return -1 on error,
651 diagnosing the error if TYPE is nonnull and if !SILENT. */
653 from_header (char const *where0
, size_t digs
, char const *type
,
654 uintmax_t minus_minval
, uintmax_t maxval
,
655 bool octal_only
, bool silent
)
658 char const *where
= where0
;
659 char const *lim
= where
+ digs
;
662 /* Accommodate buggy tar of unknown vintage, which outputs leading
663 NUL if the previous field overflows. */
666 /* Accommodate older tars, which output leading spaces. */
673 /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
674 _("Blanks in header where numeric %s value expected"),
678 if (!ISSPACE ((unsigned char) *where
))
684 if (ISODIGIT (*where
))
686 char const *where1
= where
;
687 uintmax_t overflow
= 0;
691 value
+= *where
++ - '0';
692 if (where
== lim
|| ! ISODIGIT (*where
))
694 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
698 /* Parse the output of older, unportable tars, which generate
699 negative values in two's complement octal. If the leading
700 nonzero digit is 1, we can't recover the original value
701 reliably; so do this only if the digit is 2 or more. This
702 catches the common case of 32-bit negative time stamps. */
703 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
705 /* Compute the negative of the input value, assuming two's
707 int digit
= (*where1
- '0') | 4;
715 if (where
== lim
|| ! ISODIGIT (*where
))
717 digit
= *where
- '0';
718 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
724 if (!overflow
&& value
<= minus_minval
)
728 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
729 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
730 (int) (where
- where1
), where1
, type
));
739 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
740 _("Archive octal value %.*s is out of %s range"),
741 (int) (where
- where1
), where1
, type
));
747 /* Suppress the following extensions. */
749 else if (*where
== '-' || *where
== '+')
751 /* Parse base-64 output produced only by tar test versions
752 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
753 Support for this will be withdrawn in future releases. */
757 static bool warned_once
;
761 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
764 negative
= *where
++ == '-';
766 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
768 if (value
<< LG_64
>> LG_64
!= value
)
770 char *string
= alloca (digs
+ 1);
771 memcpy (string
, where0
, digs
);
775 _("Archive signed base-64 string %s is out of %s range"),
776 quote (string
), type
));
779 value
= (value
<< LG_64
) | dig
;
783 else if (*where
== '\200' /* positive base-256 */
784 || *where
== '\377' /* negative base-256 */)
786 /* Parse base-256 output. A nonnegative number N is
787 represented as (256**DIGS)/2 + N; a negative number -N is
788 represented as (256**DIGS) - N, i.e. as two's complement.
789 The representation guarantees that the leading bit is
790 always on, so that we don't confuse this format with the
791 others (assuming ASCII bytes of 8 bits or more). */
792 int signbit
= *where
& (1 << (LG_256
- 2));
793 uintmax_t topbits
= (((uintmax_t) - signbit
)
794 << (CHAR_BIT
* sizeof (uintmax_t)
795 - LG_256
- (LG_256
- 2)));
796 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
799 value
= (value
<< LG_256
) + (unsigned char) *where
++;
802 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
806 _("Archive base-256 value is out of %s range"),
816 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
820 char buf
[1000]; /* Big enough to represent any header. */
821 static struct quoting_options
*o
;
825 o
= clone_quoting_options (0);
826 set_quoting_style (o
, locale_quoting_style
);
829 while (where0
!= lim
&& ! lim
[-1])
831 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
834 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
835 _("Archive contains %.*s where numeric %s value expected"),
836 (int) sizeof buf
, buf
, type
));
842 if (value
<= (negative
? minus_minval
: maxval
))
843 return negative
? -value
: value
;
847 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
848 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
849 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
850 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
851 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
853 *--value_string
= '-';
855 *--minval_string
= '-';
856 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
857 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
859 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
866 gid_from_header (const char *p
, size_t s
)
868 return from_header (p
, s
, "gid_t",
869 - (uintmax_t) TYPE_MINIMUM (gid_t
),
870 (uintmax_t) TYPE_MAXIMUM (gid_t
),
875 major_from_header (const char *p
, size_t s
)
877 return from_header (p
, s
, "major_t",
878 - (uintmax_t) TYPE_MINIMUM (major_t
),
879 (uintmax_t) TYPE_MAXIMUM (major_t
), false, false);
883 minor_from_header (const char *p
, size_t s
)
885 return from_header (p
, s
, "minor_t",
886 - (uintmax_t) TYPE_MINIMUM (minor_t
),
887 (uintmax_t) TYPE_MAXIMUM (minor_t
), false, false);
890 /* Convert P to the file mode, as understood by tar.
891 Store unrecognized mode bits (from 10th up) in HBITS. */
893 mode_from_header (const char *p
, size_t s
, unsigned *hbits
)
895 unsigned u
= from_header (p
, s
, "mode_t",
896 - (uintmax_t) TYPE_MINIMUM (mode_t
),
897 TYPE_MAXIMUM (uintmax_t), false, false);
898 mode_t mode
= ((u
& TSUID
? S_ISUID
: 0)
899 | (u
& TSGID
? S_ISGID
: 0)
900 | (u
& TSVTX
? S_ISVTX
: 0)
901 | (u
& TUREAD
? S_IRUSR
: 0)
902 | (u
& TUWRITE
? S_IWUSR
: 0)
903 | (u
& TUEXEC
? S_IXUSR
: 0)
904 | (u
& TGREAD
? S_IRGRP
: 0)
905 | (u
& TGWRITE
? S_IWGRP
: 0)
906 | (u
& TGEXEC
? S_IXGRP
: 0)
907 | (u
& TOREAD
? S_IROTH
: 0)
908 | (u
& TOWRITE
? S_IWOTH
: 0)
909 | (u
& TOEXEC
? S_IXOTH
: 0));
915 off_from_header (const char *p
, size_t s
)
917 /* Negative offsets are not allowed in tar files, so invoke
918 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
919 return from_header (p
, s
, "off_t", (uintmax_t) 0,
920 (uintmax_t) TYPE_MAXIMUM (off_t
), false, false);
924 size_from_header (const char *p
, size_t s
)
926 return from_header (p
, s
, "size_t", (uintmax_t) 0,
927 (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
931 time_from_header (const char *p
, size_t s
)
933 return from_header (p
, s
, "time_t",
934 - (uintmax_t) TYPE_MINIMUM (time_t),
935 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
939 uid_from_header (const char *p
, size_t s
)
941 return from_header (p
, s
, "uid_t",
942 - (uintmax_t) TYPE_MINIMUM (uid_t
),
943 (uintmax_t) TYPE_MAXIMUM (uid_t
), false, false);
947 uintmax_from_header (const char *p
, size_t s
)
949 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
950 TYPE_MAXIMUM (uintmax_t), false, false);
954 /* Return a printable representation of T. The result points to
955 static storage that can be reused in the next call to this
956 function, to ctime, or to asctime. If FULL_TIME, then output the
957 time stamp to its full resolution; otherwise, just output it to
958 1-minute resolution. */
960 tartime (struct timespec t
, bool full_time
)
962 enum { fraclen
= sizeof ".FFFFFFFFF" - 1 };
963 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
964 INT_STRLEN_BOUND (int) + 16)
969 bool negative
= s
< 0;
972 if (negative
&& ns
!= 0)
975 ns
= 1000000000 - ns
;
978 tm
= utc_option
? gmtime (&s
) : localtime (&s
);
983 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
984 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
985 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
986 code_ns_fraction (ns
, buffer
+ strlen (buffer
));
989 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d",
990 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
991 tm
->tm_hour
, tm
->tm_min
);
995 /* The time stamp cannot be broken down, most likely because it
996 is out of range. Convert it as an integer,
997 right-adjusted in a field with the same width as the usual
998 4-year ISO time format. */
999 p
= umaxtostr (negative
? - (uintmax_t) s
: s
,
1000 buffer
+ sizeof buffer
- UINTMAX_STRSIZE_BOUND
- fraclen
);
1003 while ((buffer
+ sizeof buffer
- sizeof "YYYY-MM-DD HH:MM"
1004 + (full_time
? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1008 code_ns_fraction (ns
, buffer
+ sizeof buffer
- 1 - fraclen
);
1012 /* Actually print it.
1014 Plain and fancy file header block logging. Non-verbose just prints
1015 the name, e.g. for "tar t" or "tar x". This should just contain
1016 file names, so it can be fed back into tar with xargs or the "-T"
1017 option. The verbose option can give a bunch of info, one line per
1018 file. I doubt anybody tries to parse its format, or if they do,
1019 they shouldn't. Unix tar is pretty random here anyway. */
1022 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
1023 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
1025 /* Width of "user/group size", with initial value chosen
1026 heuristically. This grows as needed, though this may cause some
1027 stairstepping in the output. Make it too small and the output will
1028 almost always look ragged. Make it too large and the output will
1029 be spaced out too far. */
1030 static int ugswidth
= 19;
1032 /* Width of printed time stamps. It grows if longer time stamps are
1033 found (typically, those with nanosecond resolution). Like
1034 USGWIDTH, some stairstepping may occur. */
1035 static int datewidth
= sizeof "YYYY-MM-DD HH:MM" - 1;
1038 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
1041 char const *time_stamp
;
1045 /* These hold formatted ints. */
1046 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
1048 char size
[2 * UINTMAX_STRSIZE_BOUND
];
1049 /* holds formatted size or major,minor */
1050 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
1054 if (test_label_option
&& current_header
->header
.typeflag
!= GNUTYPE_VOLHDR
)
1057 if (show_transformed_names_option
)
1058 temp_name
= st
->file_name
? st
->file_name
: st
->orig_file_name
;
1060 temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
1062 if (block_number_option
)
1064 char buf
[UINTMAX_STRSIZE_BOUND
];
1065 if (block_ordinal
< 0)
1066 block_ordinal
= current_block_ordinal ();
1067 block_ordinal
-= recent_long_name_blocks
;
1068 block_ordinal
-= recent_long_link_blocks
;
1069 fprintf (stdlis
, _("block %s: "),
1070 STRINGIFY_BIGINT (block_ordinal
, buf
));
1073 if (verbose_option
<= 1)
1075 /* Just the fax, mam. */
1076 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
1080 /* File type and modes. */
1083 switch (current_header
->header
.typeflag
)
1085 case GNUTYPE_VOLHDR
:
1089 case GNUTYPE_MULTIVOL
:
1093 case GNUTYPE_LONGNAME
:
1094 case GNUTYPE_LONGLINK
:
1096 ERROR ((0, 0, _("Unexpected long name header")));
1099 case GNUTYPE_SPARSE
:
1103 if (temp_name
[strlen (temp_name
) - 1] == '/')
1109 case GNUTYPE_DUMPDIR
:
1132 pax_decode_mode (st
->stat
.st_mode
, modes
+ 1);
1136 time_stamp
= tartime (st
->mtime
, false);
1137 time_stamp_len
= strlen (time_stamp
);
1138 if (datewidth
< time_stamp_len
)
1139 datewidth
= time_stamp_len
;
1141 /* User and group names. */
1145 && current_format
!= V7_FORMAT
1146 && !numeric_owner_option
)
1150 /* Try parsing it as an unsigned integer first, and as a
1151 uid_t if that fails. This method can list positive user
1152 ids that are too large to fit in a uid_t. */
1153 uintmax_t u
= from_header (current_header
->header
.uid
,
1154 sizeof current_header
->header
.uid
, 0,
1156 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1159 user
= STRINGIFY_BIGINT (u
, uform
);
1162 sprintf (uform
, "%ld",
1163 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1170 && current_format
!= V7_FORMAT
1171 && !numeric_owner_option
)
1175 /* Try parsing it as an unsigned integer first, and as a
1176 gid_t if that fails. This method can list positive group
1177 ids that are too large to fit in a gid_t. */
1178 uintmax_t g
= from_header (current_header
->header
.gid
,
1179 sizeof current_header
->header
.gid
, 0,
1181 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1184 group
= STRINGIFY_BIGINT (g
, gform
);
1187 sprintf (gform
, "%ld",
1188 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1193 /* Format the file size or major/minor device numbers. */
1195 switch (current_header
->header
.typeflag
)
1200 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1203 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1207 /* st->stat.st_size keeps stored file size */
1208 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1212 /* Figure out padding and print the whole line. */
1214 sizelen
= strlen (size
);
1215 pad
= strlen (user
) + 1 + strlen (group
) + 1 + sizelen
;
1219 fprintf (stdlis
, "%s %s/%s %*s %-*s",
1220 modes
, user
, group
, ugswidth
- pad
+ sizelen
, size
,
1221 datewidth
, time_stamp
);
1223 fprintf (stdlis
, " %s", quotearg (temp_name
));
1225 switch (current_header
->header
.typeflag
)
1228 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1232 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1237 char type_string
[2];
1238 type_string
[0] = current_header
->header
.typeflag
;
1239 type_string
[1] = '\0';
1240 fprintf (stdlis
, _(" unknown file type %s\n"),
1241 quote (type_string
));
1247 case GNUTYPE_SPARSE
:
1253 case GNUTYPE_DUMPDIR
:
1254 putc ('\n', stdlis
);
1257 case GNUTYPE_LONGLINK
:
1258 fprintf (stdlis
, _("--Long Link--\n"));
1261 case GNUTYPE_LONGNAME
:
1262 fprintf (stdlis
, _("--Long Name--\n"));
1265 case GNUTYPE_VOLHDR
:
1266 fprintf (stdlis
, _("--Volume Header--\n"));
1269 case GNUTYPE_MULTIVOL
:
1272 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1274 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1281 /* Print a similar line when we make a directory automatically. */
1283 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1287 if (verbose_option
> 1)
1289 /* File type and modes. */
1292 pax_decode_mode (mode
, modes
+ 1);
1294 if (block_number_option
)
1296 char buf
[UINTMAX_STRSIZE_BOUND
];
1297 fprintf (stdlis
, _("block %s: "),
1298 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1301 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ 1 + datewidth
,
1302 _("Creating directory:"), length
, quotearg (dirname
));
1306 /* Skip over SIZE bytes of data in blocks in the archive. */
1308 skip_file (off_t size
)
1312 /* FIXME: Make sure mv_begin is always called before it */
1314 if (seekable_archive
)
1316 off_t nblk
= seek_archive (size
);
1318 size
-= nblk
* BLOCKSIZE
;
1320 seekable_archive
= false;
1323 mv_size_left (size
);
1327 x
= find_next_block ();
1329 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1331 set_next_block_after (x
);
1333 mv_size_left (size
);
1337 /* Skip the current member in the archive.
1338 NOTE: Current header must be decoded before calling this function. */
1342 if (!current_stat_info
.skipped
)
1344 char save_typeflag
= current_header
->header
.typeflag
;
1345 set_next_block_after (current_header
);
1347 mv_begin (¤t_stat_info
);
1349 if (current_stat_info
.is_sparse
)
1350 sparse_skip_file (¤t_stat_info
);
1351 else if (save_typeflag
!= DIRTYPE
)
1352 skip_file (current_stat_info
.stat
.st_size
);