1 /* List a tar archive, with support routines for reading a tar archive.
3 Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,
4 2001, 2003, 2004, 2005, 2006, 2007, 2010 Free Software Foundation, Inc.
6 Written by John Gilmore, on 1985-08-26.
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 3, or (at your option) any later
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
16 Public License for more details.
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
28 #define max(a, b) ((a) < (b) ? (b) : (a))
30 union block
*current_header
; /* points to current archive header */
31 enum archive_format current_format
; /* recognized format */
32 union block
*recent_long_name
; /* recent long name header and contents */
33 union block
*recent_long_link
; /* likewise, for long link */
34 size_t recent_long_name_blocks
; /* number of blocks in recent_long_name */
35 size_t recent_long_link_blocks
; /* likewise, for long link */
36 union block
*recent_global_header
; /* Recent global header block */
38 #define GID_FROM_HEADER(where) gid_from_header (where, sizeof (where))
39 #define MAJOR_FROM_HEADER(where) major_from_header (where, sizeof (where))
40 #define MINOR_FROM_HEADER(where) minor_from_header (where, sizeof (where))
41 #define MODE_FROM_HEADER(where, hbits) \
42 mode_from_header (where, sizeof (where), hbits)
43 #define TIME_FROM_HEADER(where) time_from_header (where, sizeof (where))
44 #define UID_FROM_HEADER(where) uid_from_header (where, sizeof (where))
46 static gid_t
gid_from_header (const char *buf
, size_t size
);
47 static major_t
major_from_header (const char *buf
, size_t size
);
48 static minor_t
minor_from_header (const char *buf
, size_t size
);
49 static mode_t
mode_from_header (const char *buf
, size_t size
, unsigned *hbits
);
50 static time_t time_from_header (const char *buf
, size_t size
);
51 static uid_t
uid_from_header (const char *buf
, size_t size
);
52 static uintmax_t from_header (const char *, size_t, const char *,
53 uintmax_t, uintmax_t, bool, bool);
55 /* Base 64 digits; see Internet RFC 2045 Table 1. */
56 static char const base_64_digits
[64] =
58 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
59 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
60 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
61 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
62 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
65 /* Table of base-64 digit values indexed by unsigned chars.
66 The value is 64 for unsigned chars that are not base-64 digits. */
67 static char base64_map
[UCHAR_MAX
+ 1];
73 memset (base64_map
, 64, sizeof base64_map
);
74 for (i
= 0; i
< 64; i
++)
75 base64_map
[(int) base_64_digits
[i
]] = i
;
79 decode_xform (char *file_name
, void *data
)
81 int type
= *(int*)data
;
86 /* FIXME: It is not quite clear how and to which extent are the symbolic
87 links subject to filename transformation. In the absence of another
88 solution, symbolic links are exempt from component stripping and
89 name suffix normalization, but subject to filename transformation
94 file_name
= safer_name_suffix (file_name
, true, absolute_names_option
);
98 file_name
= safer_name_suffix (file_name
, false, absolute_names_option
);
102 if (strip_name_components
)
104 size_t prefix_len
= stripped_prefix_len (file_name
,
105 strip_name_components
);
106 if (prefix_len
== (size_t) -1)
107 prefix_len
= strlen (file_name
);
108 file_name
+= prefix_len
;
114 transform_member_name (char **pinput
, int type
)
116 return transform_name_fp (pinput
, type
, decode_xform
, &type
);
120 transform_stat_info (int typeflag
, struct tar_stat_info
*stat_info
)
122 if (typeflag
== GNUTYPE_VOLHDR
)
123 /* Name transformations don't apply to volume headers. */
126 transform_member_name (&stat_info
->file_name
, XFORM_REGFILE
);
130 transform_member_name (&stat_info
->link_name
, XFORM_SYMLINK
);
134 transform_member_name (&stat_info
->link_name
, XFORM_LINK
);
138 /* Main loop for reading an archive. */
140 read_and (void (*do_something
) (void))
142 enum read_header status
= HEADER_STILL_UNREAD
;
143 enum read_header prev_status
;
144 struct timespec mtime
;
149 open_archive (ACCESS_READ
);
152 prev_status
= status
;
153 tar_stat_destroy (¤t_stat_info
);
155 status
= read_header (¤t_header
, ¤t_stat_info
,
159 case HEADER_STILL_UNREAD
:
160 case HEADER_SUCCESS_EXTENDED
:
165 /* Valid header. We should decode next field (mode) first.
166 Ensure incoming names are null terminated. */
167 decode_header (current_header
, ¤t_stat_info
,
169 if (! name_match (current_stat_info
.file_name
)
170 || (NEWER_OPTION_INITIALIZED (newer_mtime_option
)
171 /* FIXME: We get mtime now, and again later; this causes
172 duplicate diagnostics if header.mtime is bogus. */
174 = TIME_FROM_HEADER (current_header
->header
.mtime
)),
175 /* FIXME: Grab fractional time stamps from
178 current_stat_info
.mtime
= mtime
,
179 OLDER_TAR_STAT_TIME (current_stat_info
, m
)))
180 || excluded_name (current_stat_info
.file_name
))
182 switch (current_header
->header
.typeflag
)
185 case GNUTYPE_MULTIVOL
:
189 if (show_omitted_dirs_option
)
190 WARN ((0, 0, _("%s: Omitting"),
191 quotearg_colon (current_stat_info
.file_name
)));
198 transform_stat_info (current_header
->header
.typeflag
,
203 case HEADER_ZERO_BLOCK
:
204 if (block_number_option
)
206 char buf
[UINTMAX_STRSIZE_BOUND
];
207 fprintf (stdlis
, _("block %s: ** Block of NULs **\n"),
208 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
211 set_next_block_after (current_header
);
213 if (!ignore_zeros_option
)
215 char buf
[UINTMAX_STRSIZE_BOUND
];
217 status
= read_header (¤t_header
, ¤t_stat_info
,
219 if (status
== HEADER_ZERO_BLOCK
)
221 WARNOPT (WARN_ALONE_ZERO_BLOCK
,
222 (0, 0, _("A lone zero block at %s"),
223 STRINGIFY_BIGINT (current_block_ordinal (), buf
)));
226 status
= prev_status
;
229 case HEADER_END_OF_FILE
:
230 if (block_number_option
)
232 char buf
[UINTMAX_STRSIZE_BOUND
];
233 fprintf (stdlis
, _("block %s: ** End of File **\n"),
234 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
239 /* If the previous header was good, tell them that we are
240 skipping bad ones. */
241 set_next_block_after (current_header
);
244 case HEADER_STILL_UNREAD
:
245 ERROR ((0, 0, _("This does not look like a tar archive")));
248 case HEADER_ZERO_BLOCK
:
250 if (block_number_option
)
252 char buf
[UINTMAX_STRSIZE_BOUND
];
253 off_t block_ordinal
= current_block_ordinal ();
254 block_ordinal
-= recent_long_name_blocks
;
255 block_ordinal
-= recent_long_link_blocks
;
256 fprintf (stdlis
, _("block %s: "),
257 STRINGIFY_BIGINT (block_ordinal
, buf
));
259 ERROR ((0, 0, _("Skipping to next header")));
262 case HEADER_END_OF_FILE
:
264 /* We are in the middle of a cascade of errors. */
267 case HEADER_SUCCESS_EXTENDED
:
274 while (!all_names_found (¤t_stat_info
));
277 names_notfound (); /* print names not found */
280 /* Print a header block, based on tar options. */
284 off_t block_ordinal
= current_block_ordinal ();
286 /* Print the header block. */
288 print_header (¤t_stat_info
, current_header
, block_ordinal
);
290 if (incremental_option
)
292 if (verbose_option
> 2)
294 if (is_dumpdir (¤t_stat_info
))
295 list_dumpdir (current_stat_info
.dumpdir
,
296 dumpdir_size (current_stat_info
.dumpdir
));
303 /* Check header checksum */
304 /* The standard BSD tar sources create the checksum by adding up the
305 bytes in the header as type char. I think the type char was unsigned
306 on the PDP-11, but it's signed on the Next and Sun. It looks like the
307 sources to BSD tar were never changed to compute the checksum
308 correctly, so both the Sun and Next add the bytes of the header as
309 signed chars. This doesn't cause a problem until you get a file with
310 a name containing characters with the high bit set. So tar_checksum
311 computes two checksums -- signed and unsigned. */
314 tar_checksum (union block
*header
, bool silent
)
317 int unsigned_sum
= 0; /* the POSIX one :-) */
318 int signed_sum
= 0; /* the Sun one :-( */
320 uintmax_t parsed_sum
;
324 for (i
= sizeof *header
; i
-- != 0;)
326 unsigned_sum
+= (unsigned char) *p
;
327 signed_sum
+= (signed char) (*p
++);
330 if (unsigned_sum
== 0)
331 return HEADER_ZERO_BLOCK
;
333 /* Adjust checksum to count the "chksum" field as blanks. */
335 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
337 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
338 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
340 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
341 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
343 parsed_sum
= from_header (header
->header
.chksum
,
344 sizeof header
->header
.chksum
, 0,
346 (uintmax_t) TYPE_MAXIMUM (int), true, silent
);
347 if (parsed_sum
== (uintmax_t) -1)
348 return HEADER_FAILURE
;
350 recorded_sum
= parsed_sum
;
352 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
353 return HEADER_FAILURE
;
355 return HEADER_SUCCESS
;
358 /* Read a block that's supposed to be a header block. Return its
359 address in *RETURN_BLOCK, and if it is good, the file's size
360 and names (file name, link name) in *INFO.
362 Return one of enum read_header describing the status of the
365 The MODE parameter instructs read_header what to do with special
366 header blocks, i.e.: extended POSIX, GNU long name or long link,
369 read_header_auto process them automatically,
370 read_header_x_raw when a special header is read, return
371 HEADER_SUCCESS_EXTENDED without actually
372 processing the header,
373 read_header_x_global when a POSIX global header is read,
374 decode it and return HEADER_SUCCESS_EXTENDED.
376 You must always set_next_block_after(*return_block) to skip past
377 the header which this routine reads. */
380 read_header (union block
**return_block
, struct tar_stat_info
*info
,
381 enum read_header_mode mode
)
384 union block
*header_copy
;
386 union block
*data_block
;
387 size_t size
, written
;
388 union block
*next_long_name
= 0;
389 union block
*next_long_link
= 0;
390 size_t next_long_name_blocks
= 0;
391 size_t next_long_link_blocks
= 0;
395 enum read_header status
;
397 header
= find_next_block ();
398 *return_block
= header
;
400 return HEADER_END_OF_FILE
;
402 if ((status
= tar_checksum (header
, false)) != HEADER_SUCCESS
)
405 /* Good block. Decode file size and return. */
407 if (header
->header
.typeflag
== LNKTYPE
)
408 info
->stat
.st_size
= 0; /* links 0 size on tape */
410 info
->stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
412 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
413 || header
->header
.typeflag
== GNUTYPE_LONGLINK
414 || header
->header
.typeflag
== XHDTYPE
415 || header
->header
.typeflag
== XGLTYPE
416 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
418 if (mode
== read_header_x_raw
)
419 return HEADER_SUCCESS_EXTENDED
;
420 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
421 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
423 size_t name_size
= info
->stat
.st_size
;
424 size_t n
= name_size
% BLOCKSIZE
;
425 size
= name_size
+ BLOCKSIZE
;
427 size
+= BLOCKSIZE
- n
;
429 if (name_size
!= info
->stat
.st_size
|| size
< name_size
)
432 header_copy
= xmalloc (size
+ 1);
434 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
437 free (next_long_name
);
438 next_long_name
= header_copy
;
439 next_long_name_blocks
= size
/ BLOCKSIZE
;
444 free (next_long_link
);
445 next_long_link
= header_copy
;
446 next_long_link_blocks
= size
/ BLOCKSIZE
;
449 set_next_block_after (header
);
450 *header_copy
= *header
;
451 bp
= header_copy
->buffer
+ BLOCKSIZE
;
453 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
455 data_block
= find_next_block ();
458 ERROR ((0, 0, _("Unexpected EOF in archive")));
461 written
= available_space_after (data_block
);
465 memcpy (bp
, data_block
->buffer
, written
);
467 set_next_block_after ((union block
*)
468 (data_block
->buffer
+ written
- 1));
473 else if (header
->header
.typeflag
== XHDTYPE
474 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
475 xheader_read (&info
->xhdr
, header
,
476 OFF_FROM_HEADER (header
->header
.size
));
477 else if (header
->header
.typeflag
== XGLTYPE
)
481 if (!recent_global_header
)
482 recent_global_header
= xmalloc (sizeof *recent_global_header
);
483 memcpy (recent_global_header
, header
,
484 sizeof *recent_global_header
);
485 memset (&xhdr
, 0, sizeof xhdr
);
486 xheader_read (&xhdr
, header
,
487 OFF_FROM_HEADER (header
->header
.size
));
488 xheader_decode_global (&xhdr
);
489 xheader_destroy (&xhdr
);
490 if (mode
== read_header_x_global
)
491 return HEADER_SUCCESS_EXTENDED
;
500 struct posix_header
const *h
= &header
->header
;
501 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
503 if (recent_long_name
)
504 free (recent_long_name
);
508 name
= next_long_name
->buffer
+ BLOCKSIZE
;
509 recent_long_name
= next_long_name
;
510 recent_long_name_blocks
= next_long_name_blocks
;
514 /* Accept file names as specified by POSIX.1-1996
518 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
520 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
521 np
[sizeof h
->prefix
] = '\0';
525 memcpy (np
, h
->name
, sizeof h
->name
);
526 np
[sizeof h
->name
] = '\0';
528 recent_long_name
= 0;
529 recent_long_name_blocks
= 0;
531 assign_string (&info
->orig_file_name
, name
);
532 assign_string (&info
->file_name
, name
);
533 info
->had_trailing_slash
= strip_trailing_slashes (info
->file_name
);
535 if (recent_long_link
)
536 free (recent_long_link
);
540 name
= next_long_link
->buffer
+ BLOCKSIZE
;
541 recent_long_link
= next_long_link
;
542 recent_long_link_blocks
= next_long_link_blocks
;
546 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
547 namebuf
[sizeof h
->linkname
] = '\0';
549 recent_long_link
= 0;
550 recent_long_link_blocks
= 0;
552 assign_string (&info
->link_name
, name
);
554 return HEADER_SUCCESS
;
559 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
561 /* Decode things from a file HEADER block into STAT_INFO, also setting
562 *FORMAT_POINTER depending on the header block format. If
563 DO_USER_GROUP, decode the user/group information (this is useful
564 for extraction, but waste time when merely listing).
566 read_header() has already decoded the checksum and length, so we don't.
568 This routine should *not* be called twice for the same block, since
569 the two calls might use different DO_USER_GROUP values and thus
570 might end up with different uid/gid for the two calls. If anybody
571 wants the uid/gid they should decode it first, and other callers
572 should decode it without uid/gid before calling a routine,
573 e.g. print_header, that assumes decoded data. */
575 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
576 enum archive_format
*format_pointer
, int do_user_group
)
578 enum archive_format format
;
579 unsigned hbits
; /* high bits of the file mode. */
580 mode_t mode
= MODE_FROM_HEADER (header
->header
.mode
, &hbits
);
582 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
584 if (header
->star_header
.prefix
[130] == 0
585 && ISOCTAL (header
->star_header
.atime
[0])
586 && header
->star_header
.atime
[11] == ' '
587 && ISOCTAL (header
->star_header
.ctime
[0])
588 && header
->star_header
.ctime
[11] == ' ')
589 format
= STAR_FORMAT
;
590 else if (stat_info
->xhdr
.size
)
591 format
= POSIX_FORMAT
;
593 format
= USTAR_FORMAT
;
595 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
596 format
= hbits
? OLDGNU_FORMAT
: GNU_FORMAT
;
599 *format_pointer
= format
;
601 stat_info
->stat
.st_mode
= mode
;
602 stat_info
->mtime
.tv_sec
= TIME_FROM_HEADER (header
->header
.mtime
);
603 stat_info
->mtime
.tv_nsec
= 0;
604 assign_string (&stat_info
->uname
,
605 header
->header
.uname
[0] ? header
->header
.uname
: NULL
);
606 assign_string (&stat_info
->gname
,
607 header
->header
.gname
[0] ? header
->header
.gname
: NULL
);
609 if (format
== OLDGNU_FORMAT
&& incremental_option
)
611 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
612 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
613 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
615 else if (format
== STAR_FORMAT
)
617 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.atime
);
618 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.ctime
);
619 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
622 stat_info
->atime
= stat_info
->ctime
= start_time
;
624 if (format
== V7_FORMAT
)
626 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
627 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
628 stat_info
->stat
.st_rdev
= 0;
634 /* FIXME: Decide if this should somewhat depend on -p. */
636 if (numeric_owner_option
637 || !*header
->header
.uname
638 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
639 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
641 if (numeric_owner_option
642 || !*header
->header
.gname
643 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
644 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
647 switch (header
->header
.typeflag
)
651 stat_info
->stat
.st_rdev
=
652 makedev (MAJOR_FROM_HEADER (header
->header
.devmajor
),
653 MINOR_FROM_HEADER (header
->header
.devminor
));
657 stat_info
->stat
.st_rdev
= 0;
661 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
662 xheader_decode (stat_info
);
664 if (sparse_member_p (stat_info
))
666 sparse_fixup_header (stat_info
);
667 stat_info
->is_sparse
= true;
671 stat_info
->is_sparse
= false;
672 if (((current_format
== GNU_FORMAT
673 || current_format
== OLDGNU_FORMAT
)
674 && current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
675 || stat_info
->dumpdir
)
676 stat_info
->is_dumpdir
= true;
681 /* Convert buffer at WHERE0 of size DIGS from external format to
682 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
683 are of type TYPE. The buffer must represent a value in the range
684 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
685 numbers instead of the other GNU extensions. Return -1 on error,
686 diagnosing the error if TYPE is nonnull and if !SILENT. */
688 from_header (char const *where0
, size_t digs
, char const *type
,
689 uintmax_t minus_minval
, uintmax_t maxval
,
690 bool octal_only
, bool silent
)
693 char const *where
= where0
;
694 char const *lim
= where
+ digs
;
697 /* Accommodate buggy tar of unknown vintage, which outputs leading
698 NUL if the previous field overflows. */
701 /* Accommodate older tars, which output leading spaces. */
708 /* TRANSLATORS: %s is type of the value (gid_t, uid_t,
710 _("Blanks in header where numeric %s value expected"),
714 if (!ISSPACE ((unsigned char) *where
))
720 if (ISODIGIT (*where
))
722 char const *where1
= where
;
723 uintmax_t overflow
= 0;
727 value
+= *where
++ - '0';
728 if (where
== lim
|| ! ISODIGIT (*where
))
730 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
734 /* Parse the output of older, unportable tars, which generate
735 negative values in two's complement octal. If the leading
736 nonzero digit is 1, we can't recover the original value
737 reliably; so do this only if the digit is 2 or more. This
738 catches the common case of 32-bit negative time stamps. */
739 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
741 /* Compute the negative of the input value, assuming two's
743 int digit
= (*where1
- '0') | 4;
751 if (where
== lim
|| ! ISODIGIT (*where
))
753 digit
= *where
- '0';
754 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
760 if (!overflow
&& value
<= minus_minval
)
764 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
765 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
766 (int) (where
- where1
), where1
, type
));
775 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
776 _("Archive octal value %.*s is out of %s range"),
777 (int) (where
- where1
), where1
, type
));
783 /* Suppress the following extensions. */
785 else if (*where
== '-' || *where
== '+')
787 /* Parse base-64 output produced only by tar test versions
788 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
789 Support for this will be withdrawn in future releases. */
793 static bool warned_once
;
797 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
800 negative
= *where
++ == '-';
802 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
804 if (value
<< LG_64
>> LG_64
!= value
)
806 char *string
= alloca (digs
+ 1);
807 memcpy (string
, where0
, digs
);
811 _("Archive signed base-64 string %s is out of %s range"),
812 quote (string
), type
));
815 value
= (value
<< LG_64
) | dig
;
819 else if (*where
== '\200' /* positive base-256 */
820 || *where
== '\377' /* negative base-256 */)
822 /* Parse base-256 output. A nonnegative number N is
823 represented as (256**DIGS)/2 + N; a negative number -N is
824 represented as (256**DIGS) - N, i.e. as two's complement.
825 The representation guarantees that the leading bit is
826 always on, so that we don't confuse this format with the
827 others (assuming ASCII bytes of 8 bits or more). */
828 int signbit
= *where
& (1 << (LG_256
- 2));
829 uintmax_t topbits
= (((uintmax_t) - signbit
)
830 << (CHAR_BIT
* sizeof (uintmax_t)
831 - LG_256
- (LG_256
- 2)));
832 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
835 value
= (value
<< LG_256
) + (unsigned char) *where
++;
838 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
842 _("Archive base-256 value is out of %s range"),
852 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
856 char buf
[1000]; /* Big enough to represent any header. */
857 static struct quoting_options
*o
;
861 o
= clone_quoting_options (0);
862 set_quoting_style (o
, locale_quoting_style
);
865 while (where0
!= lim
&& ! lim
[-1])
867 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
870 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
871 _("Archive contains %.*s where numeric %s value expected"),
872 (int) sizeof buf
, buf
, type
));
878 if (value
<= (negative
? minus_minval
: maxval
))
879 return negative
? -value
: value
;
883 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
884 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
885 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
886 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
887 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
889 *--value_string
= '-';
891 *--minval_string
= '-';
892 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
893 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
895 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
902 gid_from_header (const char *p
, size_t s
)
904 return from_header (p
, s
, "gid_t",
905 - (uintmax_t) TYPE_MINIMUM (gid_t
),
906 (uintmax_t) TYPE_MAXIMUM (gid_t
),
911 major_from_header (const char *p
, size_t s
)
913 return from_header (p
, s
, "major_t",
914 - (uintmax_t) TYPE_MINIMUM (major_t
),
915 (uintmax_t) TYPE_MAXIMUM (major_t
), false, false);
919 minor_from_header (const char *p
, size_t s
)
921 return from_header (p
, s
, "minor_t",
922 - (uintmax_t) TYPE_MINIMUM (minor_t
),
923 (uintmax_t) TYPE_MAXIMUM (minor_t
), false, false);
926 /* Convert P to the file mode, as understood by tar.
927 Store unrecognized mode bits (from 10th up) in HBITS. */
929 mode_from_header (const char *p
, size_t s
, unsigned *hbits
)
931 unsigned u
= from_header (p
, s
, "mode_t",
932 - (uintmax_t) TYPE_MINIMUM (mode_t
),
933 TYPE_MAXIMUM (uintmax_t), false, false);
934 mode_t mode
= ((u
& TSUID
? S_ISUID
: 0)
935 | (u
& TSGID
? S_ISGID
: 0)
936 | (u
& TSVTX
? S_ISVTX
: 0)
937 | (u
& TUREAD
? S_IRUSR
: 0)
938 | (u
& TUWRITE
? S_IWUSR
: 0)
939 | (u
& TUEXEC
? S_IXUSR
: 0)
940 | (u
& TGREAD
? S_IRGRP
: 0)
941 | (u
& TGWRITE
? S_IWGRP
: 0)
942 | (u
& TGEXEC
? S_IXGRP
: 0)
943 | (u
& TOREAD
? S_IROTH
: 0)
944 | (u
& TOWRITE
? S_IWOTH
: 0)
945 | (u
& TOEXEC
? S_IXOTH
: 0));
951 off_from_header (const char *p
, size_t s
)
953 /* Negative offsets are not allowed in tar files, so invoke
954 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
955 return from_header (p
, s
, "off_t", (uintmax_t) 0,
956 (uintmax_t) TYPE_MAXIMUM (off_t
), false, false);
960 time_from_header (const char *p
, size_t s
)
962 return from_header (p
, s
, "time_t",
963 - (uintmax_t) TYPE_MINIMUM (time_t),
964 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
968 uid_from_header (const char *p
, size_t s
)
970 return from_header (p
, s
, "uid_t",
971 - (uintmax_t) TYPE_MINIMUM (uid_t
),
972 (uintmax_t) TYPE_MAXIMUM (uid_t
), false, false);
976 uintmax_from_header (const char *p
, size_t s
)
978 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
979 TYPE_MAXIMUM (uintmax_t), false, false);
983 /* Return a printable representation of T. The result points to
984 static storage that can be reused in the next call to this
985 function, to ctime, or to asctime. If FULL_TIME, then output the
986 time stamp to its full resolution; otherwise, just output it to
987 1-minute resolution. */
989 tartime (struct timespec t
, bool full_time
)
991 enum { fraclen
= sizeof ".FFFFFFFFF" - 1 };
992 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
993 INT_STRLEN_BOUND (int) + 16)
998 bool negative
= s
< 0;
1001 if (negative
&& ns
!= 0)
1004 ns
= 1000000000 - ns
;
1007 tm
= utc_option
? gmtime (&s
) : localtime (&s
);
1012 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
1013 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
1014 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
1015 code_ns_fraction (ns
, buffer
+ strlen (buffer
));
1018 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d",
1019 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
1020 tm
->tm_hour
, tm
->tm_min
);
1024 /* The time stamp cannot be broken down, most likely because it
1025 is out of range. Convert it as an integer,
1026 right-adjusted in a field with the same width as the usual
1027 4-year ISO time format. */
1028 p
= umaxtostr (negative
? - (uintmax_t) s
: s
,
1029 buffer
+ sizeof buffer
- UINTMAX_STRSIZE_BOUND
- fraclen
);
1032 while ((buffer
+ sizeof buffer
- sizeof "YYYY-MM-DD HH:MM"
1033 + (full_time
? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1037 code_ns_fraction (ns
, buffer
+ sizeof buffer
- 1 - fraclen
);
1041 /* Actually print it.
1043 Plain and fancy file header block logging. Non-verbose just prints
1044 the name, e.g. for "tar t" or "tar x". This should just contain
1045 file names, so it can be fed back into tar with xargs or the "-T"
1046 option. The verbose option can give a bunch of info, one line per
1047 file. I doubt anybody tries to parse its format, or if they do,
1048 they shouldn't. Unix tar is pretty random here anyway. */
1051 /* Width of "user/group size", with initial value chosen
1052 heuristically. This grows as needed, though this may cause some
1053 stairstepping in the output. Make it too small and the output will
1054 almost always look ragged. Make it too large and the output will
1055 be spaced out too far. */
1056 static int ugswidth
= 19;
1058 /* Width of printed time stamps. It grows if longer time stamps are
1059 found (typically, those with nanosecond resolution). Like
1060 USGWIDTH, some stairstepping may occur. */
1061 static int datewidth
= sizeof "YYYY-MM-DD HH:MM" - 1;
1063 static bool volume_label_printed
= false;
1066 simple_print_header (struct tar_stat_info
*st
, union block
*blk
,
1067 off_t block_ordinal
)
1070 char const *time_stamp
;
1074 /* These hold formatted ints. */
1075 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
1077 char size
[2 * UINTMAX_STRSIZE_BOUND
];
1078 /* holds formatted size or major,minor */
1079 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
1083 if (show_transformed_names_option
)
1084 temp_name
= st
->file_name
? st
->file_name
: st
->orig_file_name
;
1086 temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
1088 if (block_number_option
)
1090 char buf
[UINTMAX_STRSIZE_BOUND
];
1091 if (block_ordinal
< 0)
1092 block_ordinal
= current_block_ordinal ();
1093 block_ordinal
-= recent_long_name_blocks
;
1094 block_ordinal
-= recent_long_link_blocks
;
1095 fprintf (stdlis
, _("block %s: "),
1096 STRINGIFY_BIGINT (block_ordinal
, buf
));
1099 if (verbose_option
<= 1)
1101 /* Just the fax, mam. */
1102 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
1106 /* File type and modes. */
1109 switch (blk
->header
.typeflag
)
1111 case GNUTYPE_VOLHDR
:
1112 volume_label_printed
= true;
1116 case GNUTYPE_MULTIVOL
:
1120 case GNUTYPE_LONGNAME
:
1121 case GNUTYPE_LONGLINK
:
1123 ERROR ((0, 0, _("Unexpected long name header")));
1126 case GNUTYPE_SPARSE
:
1130 if (temp_name
[strlen (temp_name
) - 1] == '/')
1136 case GNUTYPE_DUMPDIR
:
1159 pax_decode_mode (st
->stat
.st_mode
, modes
+ 1);
1163 time_stamp
= tartime (st
->mtime
, full_time_option
);
1164 time_stamp_len
= strlen (time_stamp
);
1165 if (datewidth
< time_stamp_len
)
1166 datewidth
= time_stamp_len
;
1168 /* User and group names. */
1172 && current_format
!= V7_FORMAT
1173 && !numeric_owner_option
)
1177 /* Try parsing it as an unsigned integer first, and as a
1178 uid_t if that fails. This method can list positive user
1179 ids that are too large to fit in a uid_t. */
1180 uintmax_t u
= from_header (blk
->header
.uid
,
1181 sizeof blk
->header
.uid
, 0,
1183 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1186 user
= STRINGIFY_BIGINT (u
, uform
);
1189 sprintf (uform
, "%ld",
1190 (long) UID_FROM_HEADER (blk
->header
.uid
));
1197 && current_format
!= V7_FORMAT
1198 && !numeric_owner_option
)
1202 /* Try parsing it as an unsigned integer first, and as a
1203 gid_t if that fails. This method can list positive group
1204 ids that are too large to fit in a gid_t. */
1205 uintmax_t g
= from_header (blk
->header
.gid
,
1206 sizeof blk
->header
.gid
, 0,
1208 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1211 group
= STRINGIFY_BIGINT (g
, gform
);
1214 sprintf (gform
, "%ld",
1215 (long) GID_FROM_HEADER (blk
->header
.gid
));
1220 /* Format the file size or major/minor device numbers. */
1222 switch (blk
->header
.typeflag
)
1227 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1230 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1234 /* st->stat.st_size keeps stored file size */
1235 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1239 /* Figure out padding and print the whole line. */
1241 sizelen
= strlen (size
);
1242 pad
= strlen (user
) + 1 + strlen (group
) + 1 + sizelen
;
1246 fprintf (stdlis
, "%s %s/%s %*s %-*s",
1247 modes
, user
, group
, ugswidth
- pad
+ sizelen
, size
,
1248 datewidth
, time_stamp
);
1250 fprintf (stdlis
, " %s", quotearg (temp_name
));
1252 switch (blk
->header
.typeflag
)
1255 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1259 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1264 char type_string
[2];
1265 type_string
[0] = blk
->header
.typeflag
;
1266 type_string
[1] = '\0';
1267 fprintf (stdlis
, _(" unknown file type %s\n"),
1268 quote (type_string
));
1274 case GNUTYPE_SPARSE
:
1280 case GNUTYPE_DUMPDIR
:
1281 putc ('\n', stdlis
);
1284 case GNUTYPE_LONGLINK
:
1285 fprintf (stdlis
, _("--Long Link--\n"));
1288 case GNUTYPE_LONGNAME
:
1289 fprintf (stdlis
, _("--Long Name--\n"));
1292 case GNUTYPE_VOLHDR
:
1293 fprintf (stdlis
, _("--Volume Header--\n"));
1296 case GNUTYPE_MULTIVOL
:
1299 (UINTMAX_FROM_HEADER (blk
->oldgnu_header
.offset
),
1301 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1310 print_volume_label (void)
1312 struct tar_stat_info vstat
;
1314 enum archive_format dummy
;
1316 memset (&vblk
, 0, sizeof (vblk
));
1317 vblk
.header
.typeflag
= GNUTYPE_VOLHDR
;
1318 if (recent_global_header
)
1319 memcpy (vblk
.header
.mtime
, recent_global_header
->header
.mtime
,
1320 sizeof vblk
.header
.mtime
);
1321 tar_stat_init (&vstat
);
1322 assign_string (&vstat
.file_name
, ".");
1323 decode_header (&vblk
, &vstat
, &dummy
, 0);
1324 assign_string (&vstat
.file_name
, volume_label
);
1325 simple_print_header (&vstat
, &vblk
, 0);
1326 tar_stat_destroy (&vstat
);
1330 print_header (struct tar_stat_info
*st
, union block
*blk
,
1331 off_t block_ordinal
)
1333 if (current_format
== POSIX_FORMAT
&& !volume_label_printed
&& volume_label
)
1335 print_volume_label ();
1336 volume_label_printed
= true;
1339 simple_print_header (st
, blk
, block_ordinal
);
1342 /* Print a similar line when we make a directory automatically. */
1344 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1348 if (verbose_option
> 1)
1350 /* File type and modes. */
1353 pax_decode_mode (mode
, modes
+ 1);
1355 if (block_number_option
)
1357 char buf
[UINTMAX_STRSIZE_BOUND
];
1358 fprintf (stdlis
, _("block %s: "),
1359 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1362 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ 1 + datewidth
,
1363 _("Creating directory:"), length
, quotearg (dirname
));
1367 /* Skip over SIZE bytes of data in blocks in the archive. */
1369 skip_file (off_t size
)
1373 /* FIXME: Make sure mv_begin_read is always called before it */
1375 if (seekable_archive
)
1377 off_t nblk
= seek_archive (size
);
1379 size
-= nblk
* BLOCKSIZE
;
1381 seekable_archive
= false;
1384 mv_size_left (size
);
1388 x
= find_next_block ();
1390 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1392 set_next_block_after (x
);
1394 mv_size_left (size
);
1398 /* Skip the current member in the archive.
1399 NOTE: Current header must be decoded before calling this function. */
1403 if (!current_stat_info
.skipped
)
1405 char save_typeflag
= current_header
->header
.typeflag
;
1406 set_next_block_after (current_header
);
1408 mv_begin_read (¤t_stat_info
);
1410 if (current_stat_info
.is_sparse
)
1411 sparse_skip_file (¤t_stat_info
);
1412 else if (save_typeflag
!= DIRTYPE
)
1413 skip_file (current_stat_info
.stat
.st_size
);
1420 test_archive_label ()
1425 open_archive (ACCESS_READ
);
1426 if (read_header (¤t_header
, ¤t_stat_info
, read_header_auto
)
1429 decode_header (current_header
,
1430 ¤t_stat_info
, ¤t_format
, 0);
1431 if (current_header
->header
.typeflag
== GNUTYPE_VOLHDR
)
1432 assign_string (&volume_label
, current_header
->header
.name
);
1437 print_volume_label ();
1438 if (!name_match (volume_label
) && multi_volume_option
)
1440 char *s
= drop_volume_label_suffix (volume_label
);