1 /* List a tar archive, with support routines for reading a tar archive.
3 Copyright 1988, 1992-1994, 1996-2001, 2003-2007, 2010, 2012-2014 Free
4 Software Foundation, Inc.
6 This file is part of GNU tar.
8 GNU tar is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 GNU tar is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 Written by John Gilmore, on 1985-08-26. */
29 union block
*current_header
; /* points to current archive header */
30 enum archive_format current_format
; /* recognized format */
31 union block
*recent_long_name
; /* recent long name header and contents */
32 union block
*recent_long_link
; /* likewise, for long link */
33 size_t recent_long_name_blocks
; /* number of blocks in recent_long_name */
34 size_t recent_long_link_blocks
; /* likewise, for long link */
35 static union block
*recent_global_header
; /* Recent global header block */
37 #define GID_FROM_HEADER(where) gid_from_header (where, sizeof (where))
38 #define MAJOR_FROM_HEADER(where) major_from_header (where, sizeof (where))
39 #define MINOR_FROM_HEADER(where) minor_from_header (where, sizeof (where))
40 #define MODE_FROM_HEADER(where, hbits) \
41 mode_from_header (where, sizeof (where), hbits)
42 #define TIME_FROM_HEADER(where) time_from_header (where, sizeof (where))
43 #define UID_FROM_HEADER(where) uid_from_header (where, sizeof (where))
45 static gid_t
gid_from_header (const char *buf
, size_t size
);
46 static major_t
major_from_header (const char *buf
, size_t size
);
47 static minor_t
minor_from_header (const char *buf
, size_t size
);
48 static mode_t
mode_from_header (const char *buf
, size_t size
, bool *hbits
);
49 static time_t time_from_header (const char *buf
, size_t size
);
50 static uid_t
uid_from_header (const char *buf
, size_t size
);
51 static intmax_t from_header (const char *, size_t, const char *,
52 intmax_t, uintmax_t, bool, bool);
54 /* Base 64 digits; see Internet RFC 2045 Table 1. */
55 static char const base_64_digits
[64] =
57 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
58 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
59 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
60 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
61 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
64 /* Table of base-64 digit values indexed by unsigned chars.
65 The value is 64 for unsigned chars that are not base-64 digits. */
66 static char base64_map
[UCHAR_MAX
+ 1];
72 memset (base64_map
, 64, sizeof base64_map
);
73 for (i
= 0; i
< 64; i
++)
74 base64_map
[(int) base_64_digits
[i
]] = i
;
78 decode_xform (char *file_name
, void *data
)
80 int type
= *(int*)data
;
85 /* FIXME: It is not quite clear how and to which extent are the symbolic
86 links subject to filename transformation. In the absence of another
87 solution, symbolic links are exempt from component stripping and
88 name suffix normalization, but subject to filename transformation
93 file_name
= safer_name_suffix (file_name
, true, absolute_names_option
);
97 file_name
= safer_name_suffix (file_name
, false, absolute_names_option
);
101 if (strip_name_components
)
103 size_t prefix_len
= stripped_prefix_len (file_name
,
104 strip_name_components
);
105 if (prefix_len
== (size_t) -1)
106 prefix_len
= strlen (file_name
);
107 file_name
+= prefix_len
;
113 transform_member_name (char **pinput
, int type
)
115 return transform_name_fp (pinput
, type
, decode_xform
, &type
);
119 enforce_one_top_level (char **pfile_name
)
121 char *file_name
= *pfile_name
;
124 for (p
= file_name
; *p
&& (ISSLASH (*p
) || *p
== '.'); p
++)
130 if (strncmp (p
, one_top_level_dir
, strlen (one_top_level_dir
)) == 0)
132 int pos
= strlen (one_top_level_dir
);
133 if (ISSLASH (p
[pos
]) || p
[pos
] == 0)
137 *pfile_name
= new_name (one_top_level_dir
, file_name
);
138 normalize_filename_x (*pfile_name
);
143 transform_stat_info (int typeflag
, struct tar_stat_info
*stat_info
)
145 if (typeflag
== GNUTYPE_VOLHDR
)
146 /* Name transformations don't apply to volume headers. */
149 transform_member_name (&stat_info
->file_name
, XFORM_REGFILE
);
153 transform_member_name (&stat_info
->link_name
, XFORM_SYMLINK
);
157 transform_member_name (&stat_info
->link_name
, XFORM_LINK
);
160 if (one_top_level_option
)
161 enforce_one_top_level (¤t_stat_info
.file_name
);
164 /* Main loop for reading an archive. */
166 read_and (void (*do_something
) (void))
168 enum read_header status
= HEADER_STILL_UNREAD
;
169 enum read_header prev_status
;
170 struct timespec mtime
;
175 open_archive (ACCESS_READ
);
178 prev_status
= status
;
179 tar_stat_destroy (¤t_stat_info
);
181 status
= read_header (¤t_header
, ¤t_stat_info
,
185 case HEADER_STILL_UNREAD
:
186 case HEADER_SUCCESS_EXTENDED
:
191 /* Valid header. We should decode next field (mode) first.
192 Ensure incoming names are null terminated. */
193 decode_header (current_header
, ¤t_stat_info
,
195 if (! name_match (current_stat_info
.file_name
)
196 || (NEWER_OPTION_INITIALIZED (newer_mtime_option
)
197 /* FIXME: We get mtime now, and again later; this causes
198 duplicate diagnostics if header.mtime is bogus. */
200 = TIME_FROM_HEADER (current_header
->header
.mtime
)),
201 /* FIXME: Grab fractional time stamps from
204 current_stat_info
.mtime
= mtime
,
205 OLDER_TAR_STAT_TIME (current_stat_info
, m
)))
206 || excluded_name (current_stat_info
.file_name
))
208 switch (current_header
->header
.typeflag
)
211 case GNUTYPE_MULTIVOL
:
215 if (show_omitted_dirs_option
)
216 WARN ((0, 0, _("%s: Omitting"),
217 quotearg_colon (current_stat_info
.file_name
)));
225 transform_stat_info (current_header
->header
.typeflag
,
230 case HEADER_ZERO_BLOCK
:
231 if (block_number_option
)
233 char buf
[UINTMAX_STRSIZE_BOUND
];
234 fprintf (stdlis
, _("block %s: ** Block of NULs **\n"),
235 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
238 set_next_block_after (current_header
);
240 if (!ignore_zeros_option
)
242 char buf
[UINTMAX_STRSIZE_BOUND
];
244 status
= read_header (¤t_header
, ¤t_stat_info
,
246 if (status
== HEADER_ZERO_BLOCK
)
248 WARNOPT (WARN_ALONE_ZERO_BLOCK
,
249 (0, 0, _("A lone zero block at %s"),
250 STRINGIFY_BIGINT (current_block_ordinal (), buf
)));
253 status
= prev_status
;
256 case HEADER_END_OF_FILE
:
257 if (block_number_option
)
259 char buf
[UINTMAX_STRSIZE_BOUND
];
260 fprintf (stdlis
, _("block %s: ** End of File **\n"),
261 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
266 /* If the previous header was good, tell them that we are
267 skipping bad ones. */
268 set_next_block_after (current_header
);
271 case HEADER_STILL_UNREAD
:
272 ERROR ((0, 0, _("This does not look like a tar archive")));
275 case HEADER_ZERO_BLOCK
:
277 if (block_number_option
)
279 char buf
[UINTMAX_STRSIZE_BOUND
];
280 off_t block_ordinal
= current_block_ordinal ();
281 block_ordinal
-= recent_long_name_blocks
;
282 block_ordinal
-= recent_long_link_blocks
;
283 fprintf (stdlis
, _("block %s: "),
284 STRINGIFY_BIGINT (block_ordinal
, buf
));
286 ERROR ((0, 0, _("Skipping to next header")));
289 case HEADER_END_OF_FILE
:
291 /* We are in the middle of a cascade of errors. */
294 case HEADER_SUCCESS_EXTENDED
:
301 while (!all_names_found (¤t_stat_info
));
304 names_notfound (); /* print names not found */
307 /* Print a header block, based on tar options. */
311 off_t block_ordinal
= current_block_ordinal ();
313 /* Print the header block. */
315 print_header (¤t_stat_info
, current_header
, block_ordinal
);
317 if (incremental_option
)
319 if (verbose_option
> 2)
321 if (is_dumpdir (¤t_stat_info
))
322 list_dumpdir (current_stat_info
.dumpdir
,
323 dumpdir_size (current_stat_info
.dumpdir
));
330 /* Check header checksum */
331 /* The standard BSD tar sources create the checksum by adding up the
332 bytes in the header as type char. I think the type char was unsigned
333 on the PDP-11, but it's signed on the Next and Sun. It looks like the
334 sources to BSD tar were never changed to compute the checksum
335 correctly, so both the Sun and Next add the bytes of the header as
336 signed chars. This doesn't cause a problem until you get a file with
337 a name containing characters with the high bit set. So tar_checksum
338 computes two checksums -- signed and unsigned. */
341 tar_checksum (union block
*header
, bool silent
)
344 int unsigned_sum
= 0; /* the POSIX one :-) */
345 int signed_sum
= 0; /* the Sun one :-( */
351 for (i
= sizeof *header
; i
-- != 0;)
353 unsigned_sum
+= (unsigned char) *p
;
354 signed_sum
+= (signed char) (*p
++);
357 if (unsigned_sum
== 0)
358 return HEADER_ZERO_BLOCK
;
360 /* Adjust checksum to count the "chksum" field as blanks. */
362 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
364 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
365 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
367 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
368 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
370 parsed_sum
= from_header (header
->header
.chksum
,
371 sizeof header
->header
.chksum
, 0,
372 0, INT_MAX
, true, silent
);
374 return HEADER_FAILURE
;
376 recorded_sum
= parsed_sum
;
378 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
379 return HEADER_FAILURE
;
381 return HEADER_SUCCESS
;
384 /* Read a block that's supposed to be a header block. Return its
385 address in *RETURN_BLOCK, and if it is good, the file's size
386 and names (file name, link name) in *INFO.
388 Return one of enum read_header describing the status of the
391 The MODE parameter instructs read_header what to do with special
392 header blocks, i.e.: extended POSIX, GNU long name or long link,
395 read_header_auto process them automatically,
396 read_header_x_raw when a special header is read, return
397 HEADER_SUCCESS_EXTENDED without actually
398 processing the header,
399 read_header_x_global when a POSIX global header is read,
400 decode it and return HEADER_SUCCESS_EXTENDED.
402 You must always set_next_block_after(*return_block) to skip past
403 the header which this routine reads. */
406 read_header (union block
**return_block
, struct tar_stat_info
*info
,
407 enum read_header_mode mode
)
410 union block
*header_copy
;
412 union block
*data_block
;
413 size_t size
, written
;
414 union block
*next_long_name
= 0;
415 union block
*next_long_link
= 0;
416 size_t next_long_name_blocks
= 0;
417 size_t next_long_link_blocks
= 0;
421 enum read_header status
;
423 header
= find_next_block ();
424 *return_block
= header
;
426 return HEADER_END_OF_FILE
;
428 if ((status
= tar_checksum (header
, false)) != HEADER_SUCCESS
)
431 /* Good block. Decode file size and return. */
433 if (header
->header
.typeflag
== LNKTYPE
)
434 info
->stat
.st_size
= 0; /* links 0 size on tape */
437 info
->stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
438 if (info
->stat
.st_size
< 0)
439 return HEADER_FAILURE
;
442 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
443 || header
->header
.typeflag
== GNUTYPE_LONGLINK
444 || header
->header
.typeflag
== XHDTYPE
445 || header
->header
.typeflag
== XGLTYPE
446 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
448 if (mode
== read_header_x_raw
)
449 return HEADER_SUCCESS_EXTENDED
;
450 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
451 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
453 size_t name_size
= info
->stat
.st_size
;
454 size_t n
= name_size
% BLOCKSIZE
;
455 size
= name_size
+ BLOCKSIZE
;
457 size
+= BLOCKSIZE
- n
;
459 if (name_size
!= info
->stat
.st_size
|| size
< name_size
)
462 header_copy
= xmalloc (size
+ 1);
464 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
466 free (next_long_name
);
467 next_long_name
= header_copy
;
468 next_long_name_blocks
= size
/ BLOCKSIZE
;
472 free (next_long_link
);
473 next_long_link
= header_copy
;
474 next_long_link_blocks
= size
/ BLOCKSIZE
;
477 set_next_block_after (header
);
478 *header_copy
= *header
;
479 bp
= header_copy
->buffer
+ BLOCKSIZE
;
481 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
483 data_block
= find_next_block ();
486 ERROR ((0, 0, _("Unexpected EOF in archive")));
489 written
= available_space_after (data_block
);
493 memcpy (bp
, data_block
->buffer
, written
);
495 set_next_block_after ((union block
*)
496 (data_block
->buffer
+ written
- 1));
501 else if (header
->header
.typeflag
== XHDTYPE
502 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
503 xheader_read (&info
->xhdr
, header
,
504 OFF_FROM_HEADER (header
->header
.size
));
505 else if (header
->header
.typeflag
== XGLTYPE
)
509 if (!recent_global_header
)
510 recent_global_header
= xmalloc (sizeof *recent_global_header
);
511 memcpy (recent_global_header
, header
,
512 sizeof *recent_global_header
);
513 memset (&xhdr
, 0, sizeof xhdr
);
514 xheader_read (&xhdr
, header
,
515 OFF_FROM_HEADER (header
->header
.size
));
516 xheader_decode_global (&xhdr
);
517 xheader_destroy (&xhdr
);
518 if (mode
== read_header_x_global
)
519 return HEADER_SUCCESS_EXTENDED
;
528 struct posix_header
const *h
= &header
->header
;
529 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
531 free (recent_long_name
);
535 name
= next_long_name
->buffer
+ BLOCKSIZE
;
536 recent_long_name
= next_long_name
;
537 recent_long_name_blocks
= next_long_name_blocks
;
541 /* Accept file names as specified by POSIX.1-1996
545 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
547 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
548 np
[sizeof h
->prefix
] = '\0';
552 memcpy (np
, h
->name
, sizeof h
->name
);
553 np
[sizeof h
->name
] = '\0';
555 recent_long_name
= 0;
556 recent_long_name_blocks
= 0;
558 assign_string (&info
->orig_file_name
, name
);
559 assign_string (&info
->file_name
, name
);
560 info
->had_trailing_slash
= strip_trailing_slashes (info
->file_name
);
562 free (recent_long_link
);
566 name
= next_long_link
->buffer
+ BLOCKSIZE
;
567 recent_long_link
= next_long_link
;
568 recent_long_link_blocks
= next_long_link_blocks
;
572 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
573 namebuf
[sizeof h
->linkname
] = '\0';
575 recent_long_link
= 0;
576 recent_long_link_blocks
= 0;
578 assign_string (&info
->link_name
, name
);
580 return HEADER_SUCCESS
;
585 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
587 /* Decode things from a file HEADER block into STAT_INFO, also setting
588 *FORMAT_POINTER depending on the header block format. If
589 DO_USER_GROUP, decode the user/group information (this is useful
590 for extraction, but waste time when merely listing).
592 read_header() has already decoded the checksum and length, so we don't.
594 This routine should *not* be called twice for the same block, since
595 the two calls might use different DO_USER_GROUP values and thus
596 might end up with different uid/gid for the two calls. If anybody
597 wants the uid/gid they should decode it first, and other callers
598 should decode it without uid/gid before calling a routine,
599 e.g. print_header, that assumes decoded data. */
601 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
602 enum archive_format
*format_pointer
, int do_user_group
)
604 enum archive_format format
;
606 mode_t mode
= MODE_FROM_HEADER (header
->header
.mode
, &hbits
);
608 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
610 if (header
->star_header
.prefix
[130] == 0
611 && ISOCTAL (header
->star_header
.atime
[0])
612 && header
->star_header
.atime
[11] == ' '
613 && ISOCTAL (header
->star_header
.ctime
[0])
614 && header
->star_header
.ctime
[11] == ' ')
615 format
= STAR_FORMAT
;
616 else if (stat_info
->xhdr
.size
)
617 format
= POSIX_FORMAT
;
619 format
= USTAR_FORMAT
;
621 else if (strcmp (header
->buffer
+ offsetof (struct posix_header
, magic
),
624 format
= hbits
? OLDGNU_FORMAT
: GNU_FORMAT
;
627 *format_pointer
= format
;
629 stat_info
->stat
.st_mode
= mode
;
630 stat_info
->mtime
.tv_sec
= TIME_FROM_HEADER (header
->header
.mtime
);
631 stat_info
->mtime
.tv_nsec
= 0;
632 assign_string (&stat_info
->uname
,
633 header
->header
.uname
[0] ? header
->header
.uname
: NULL
);
634 assign_string (&stat_info
->gname
,
635 header
->header
.gname
[0] ? header
->header
.gname
: NULL
);
637 xheader_xattr_init (stat_info
);
639 if (format
== OLDGNU_FORMAT
&& incremental_option
)
641 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
642 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
643 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
645 else if (format
== STAR_FORMAT
)
647 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.atime
);
648 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.ctime
);
649 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
652 stat_info
->atime
= stat_info
->ctime
= start_time
;
654 if (format
== V7_FORMAT
)
656 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
657 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
658 stat_info
->stat
.st_rdev
= 0;
664 /* FIXME: Decide if this should somewhat depend on -p. */
666 if (numeric_owner_option
667 || !*header
->header
.uname
668 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
669 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
671 if (numeric_owner_option
672 || !*header
->header
.gname
673 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
674 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
677 switch (header
->header
.typeflag
)
681 stat_info
->stat
.st_rdev
=
682 makedev (MAJOR_FROM_HEADER (header
->header
.devmajor
),
683 MINOR_FROM_HEADER (header
->header
.devminor
));
687 stat_info
->stat
.st_rdev
= 0;
691 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
692 xheader_decode (stat_info
);
694 if (sparse_member_p (stat_info
))
696 sparse_fixup_header (stat_info
);
697 stat_info
->is_sparse
= true;
701 stat_info
->is_sparse
= false;
702 if (((current_format
== GNU_FORMAT
703 || current_format
== OLDGNU_FORMAT
)
704 && current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
705 || stat_info
->dumpdir
)
706 stat_info
->is_dumpdir
= true;
711 /* Convert buffer at WHERE0 of size DIGS from external format to
712 intmax_t. DIGS must be positive. If TYPE is nonnull, the data are
713 of type TYPE. The buffer must represent a value in the range
714 MINVAL through MAXVAL; if the mathematically correct result V would
715 be greater than INTMAX_MAX, return a negative integer V such that
716 (uintmax_t) V yields the correct result. If OCTAL_ONLY, allow only octal
717 numbers instead of the other GNU extensions. Return -1 on error,
718 diagnosing the error if TYPE is nonnull and if !SILENT. */
719 #if ! (INTMAX_MAX <= UINTMAX_MAX && - (INTMAX_MIN + 1) <= UINTMAX_MAX)
720 # error "from_header internally represents intmax_t as uintmax_t + sign"
722 #if ! (UINTMAX_MAX / 2 <= INTMAX_MAX)
723 # error "from_header returns intmax_t to represent uintmax_t"
726 from_header (char const *where0
, size_t digs
, char const *type
,
727 intmax_t minval
, uintmax_t maxval
,
728 bool octal_only
, bool silent
)
731 uintmax_t uminval
= minval
;
732 uintmax_t minus_minval
= - uminval
;
733 char const *where
= where0
;
734 char const *lim
= where
+ digs
;
735 bool negative
= false;
737 /* Accommodate buggy tar of unknown vintage, which outputs leading
738 NUL if the previous field overflows. */
741 /* Accommodate older tars, which output leading spaces. */
748 /* TRANSLATORS: %s is type of the value (gid_t, uid_t,
750 _("Blanks in header where numeric %s value expected"),
754 if (!isspace ((unsigned char) *where
))
760 if (ISODIGIT (*where
))
762 char const *where1
= where
;
763 bool overflow
= false;
767 value
+= *where
++ - '0';
768 if (where
== lim
|| ! ISODIGIT (*where
))
770 overflow
|= value
!= (value
<< LG_8
>> LG_8
);
774 /* Parse the output of older, unportable tars, which generate
775 negative values in two's complement octal. If the leading
776 nonzero digit is 1, we can't recover the original value
777 reliably; so do this only if the digit is 2 or more. This
778 catches the common case of 32-bit negative time stamps. */
779 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
781 /* Compute the negative of the input value, assuming two's
783 int digit
= (*where1
- '0') | 4;
791 if (where
== lim
|| ! ISODIGIT (*where
))
793 digit
= *where
- '0';
794 overflow
|= value
!= (value
<< LG_8
>> LG_8
);
800 if (!overflow
&& value
<= minus_minval
)
804 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
805 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
806 (int) (where
- where1
), where1
, type
));
815 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
816 _("Archive octal value %.*s is out of %s range"),
817 (int) (where
- where1
), where1
, type
));
823 /* Suppress the following extensions. */
825 else if (*where
== '-' || *where
== '+')
827 /* Parse base-64 output produced only by tar test versions
828 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
829 Support for this will be withdrawn in future releases. */
833 static bool warned_once
;
837 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
840 negative
= *where
++ == '-';
842 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
844 if (value
<< LG_64
>> LG_64
!= value
)
846 char *string
= alloca (digs
+ 1);
847 memcpy (string
, where0
, digs
);
851 _("Archive signed base-64 string %s is out of %s range"),
852 quote (string
), type
));
855 value
= (value
<< LG_64
) | dig
;
859 else if (*where
== '\200' /* positive base-256 */
860 || *where
== '\377' /* negative base-256 */)
862 /* Parse base-256 output. A nonnegative number N is
863 represented as (256**DIGS)/2 + N; a negative number -N is
864 represented as (256**DIGS) - N, i.e. as two's complement.
865 The representation guarantees that the leading bit is
866 always on, so that we don't confuse this format with the
867 others (assuming ASCII bytes of 8 bits or more). */
868 int signbit
= *where
& (1 << (LG_256
- 2));
869 uintmax_t topbits
= (((uintmax_t) - signbit
)
870 << (CHAR_BIT
* sizeof (uintmax_t)
871 - LG_256
- (LG_256
- 2)));
872 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
875 value
= (value
<< LG_256
) + (unsigned char) *where
++;
878 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
882 _("Archive base-256 value is out of %s range"),
887 negative
= signbit
!= 0;
892 if (where
!= lim
&& *where
&& !isspace ((unsigned char) *where
))
896 char buf
[1000]; /* Big enough to represent any header. */
897 static struct quoting_options
*o
;
901 o
= clone_quoting_options (0);
902 set_quoting_style (o
, locale_quoting_style
);
905 while (where0
!= lim
&& ! lim
[-1])
907 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where0
, o
);
910 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
911 _("Archive contains %.*s where numeric %s value expected"),
912 (int) sizeof buf
, buf
, type
));
918 if (value
<= (negative
? minus_minval
: maxval
))
919 return represent_uintmax (negative
? -value
: value
);
923 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
924 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
925 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
926 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
927 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
929 *--value_string
= '-';
931 *--minval_string
= '-';
932 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
933 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
935 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
942 gid_from_header (const char *p
, size_t s
)
944 return from_header (p
, s
, "gid_t",
945 TYPE_MINIMUM (gid_t
), TYPE_MAXIMUM (gid_t
),
950 major_from_header (const char *p
, size_t s
)
952 return from_header (p
, s
, "major_t",
953 TYPE_MINIMUM (major_t
), TYPE_MAXIMUM (major_t
),
958 minor_from_header (const char *p
, size_t s
)
960 return from_header (p
, s
, "minor_t",
961 TYPE_MINIMUM (minor_t
), TYPE_MAXIMUM (minor_t
),
965 /* Convert P to the file mode, as understood by tar.
966 Set *HBITS if there are any unrecognized bits. */
968 mode_from_header (const char *p
, size_t s
, bool *hbits
)
970 intmax_t u
= from_header (p
, s
, "mode_t",
971 INTMAX_MIN
, UINTMAX_MAX
,
973 mode_t mode
= ((u
& TSUID
? S_ISUID
: 0)
974 | (u
& TSGID
? S_ISGID
: 0)
975 | (u
& TSVTX
? S_ISVTX
: 0)
976 | (u
& TUREAD
? S_IRUSR
: 0)
977 | (u
& TUWRITE
? S_IWUSR
: 0)
978 | (u
& TUEXEC
? S_IXUSR
: 0)
979 | (u
& TGREAD
? S_IRGRP
: 0)
980 | (u
& TGWRITE
? S_IWGRP
: 0)
981 | (u
& TGEXEC
? S_IXGRP
: 0)
982 | (u
& TOREAD
? S_IROTH
: 0)
983 | (u
& TOWRITE
? S_IWOTH
: 0)
984 | (u
& TOEXEC
? S_IXOTH
: 0));
985 *hbits
= (u
& ~07777) != 0;
990 off_from_header (const char *p
, size_t s
)
992 /* Negative offsets are not allowed in tar files, so invoke
993 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
994 return from_header (p
, s
, "off_t",
995 0, TYPE_MAXIMUM (off_t
),
1000 time_from_header (const char *p
, size_t s
)
1002 return from_header (p
, s
, "time_t",
1003 TYPE_MINIMUM (time_t), TYPE_MAXIMUM (time_t),
1008 uid_from_header (const char *p
, size_t s
)
1010 return from_header (p
, s
, "uid_t",
1011 TYPE_MINIMUM (uid_t
), TYPE_MAXIMUM (uid_t
),
1016 uintmax_from_header (const char *p
, size_t s
)
1018 return from_header (p
, s
, "uintmax_t", 0, UINTMAX_MAX
, false, false);
1022 /* Return a printable representation of T. The result points to
1023 static storage that can be reused in the next call to this
1024 function, to ctime, or to asctime. If FULL_TIME, then output the
1025 time stamp to its full resolution; otherwise, just output it to
1026 1-minute resolution. */
1028 tartime (struct timespec t
, bool full_time
)
1030 enum { fraclen
= sizeof ".FFFFFFFFF" - 1 };
1031 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
1032 INT_STRLEN_BOUND (int) + 16)
1035 time_t s
= t
.tv_sec
;
1037 bool negative
= s
< 0;
1040 if (negative
&& ns
!= 0)
1043 ns
= 1000000000 - ns
;
1046 tm
= utc_option
? gmtime (&s
) : localtime (&s
);
1051 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
1052 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
1053 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
1054 code_ns_fraction (ns
, buffer
+ strlen (buffer
));
1057 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d",
1058 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
1059 tm
->tm_hour
, tm
->tm_min
);
1063 /* The time stamp cannot be broken down, most likely because it
1064 is out of range. Convert it as an integer,
1065 right-adjusted in a field with the same width as the usual
1066 4-year ISO time format. */
1067 p
= umaxtostr (negative
? - (uintmax_t) s
: s
,
1068 buffer
+ sizeof buffer
- UINTMAX_STRSIZE_BOUND
- fraclen
);
1071 while ((buffer
+ sizeof buffer
- sizeof "YYYY-MM-DD HH:MM"
1072 + (full_time
? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1076 code_ns_fraction (ns
, buffer
+ sizeof buffer
- 1 - fraclen
);
1080 /* Actually print it.
1082 Plain and fancy file header block logging. Non-verbose just prints
1083 the name, e.g. for "tar t" or "tar x". This should just contain
1084 file names, so it can be fed back into tar with xargs or the "-T"
1085 option. The verbose option can give a bunch of info, one line per
1086 file. I doubt anybody tries to parse its format, or if they do,
1087 they shouldn't. Unix tar is pretty random here anyway. */
1090 /* Width of "user/group size", with initial value chosen
1091 heuristically. This grows as needed, though this may cause some
1092 stairstepping in the output. Make it too small and the output will
1093 almost always look ragged. Make it too large and the output will
1094 be spaced out too far. */
1095 static int ugswidth
= 19;
1097 /* Width of printed time stamps. It grows if longer time stamps are
1098 found (typically, those with nanosecond resolution). Like
1099 USGWIDTH, some stairstepping may occur. */
1100 static int datewidth
= sizeof "YYYY-MM-DD HH:MM" - 1;
1102 static bool volume_label_printed
= false;
1105 simple_print_header (struct tar_stat_info
*st
, union block
*blk
,
1106 off_t block_ordinal
)
1109 char const *time_stamp
;
1113 /* These hold formatted ints. */
1114 char uform
[max (INT_BUFSIZE_BOUND (intmax_t), UINTMAX_STRSIZE_BOUND
)];
1115 char gform
[sizeof uform
];
1117 char size
[2 * UINTMAX_STRSIZE_BOUND
];
1118 /* holds formatted size or major,minor */
1119 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
1123 if (show_transformed_names_option
)
1124 temp_name
= st
->file_name
? st
->file_name
: st
->orig_file_name
;
1126 temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
1128 if (block_number_option
)
1130 char buf
[UINTMAX_STRSIZE_BOUND
];
1131 if (block_ordinal
< 0)
1132 block_ordinal
= current_block_ordinal ();
1133 block_ordinal
-= recent_long_name_blocks
;
1134 block_ordinal
-= recent_long_link_blocks
;
1135 fprintf (stdlis
, _("block %s: "),
1136 STRINGIFY_BIGINT (block_ordinal
, buf
));
1139 if (verbose_option
<= 1)
1141 /* Just the fax, mam. */
1142 fputs (quotearg (temp_name
), stdlis
);
1143 if (show_transformed_names_option
&& st
->had_trailing_slash
)
1144 fputc ('/', stdlis
);
1145 fputc ('\n', stdlis
);
1149 /* File type and modes. */
1152 switch (blk
->header
.typeflag
)
1154 case GNUTYPE_VOLHDR
:
1155 volume_label_printed
= true;
1159 case GNUTYPE_MULTIVOL
:
1163 case GNUTYPE_LONGNAME
:
1164 case GNUTYPE_LONGLINK
:
1166 ERROR ((0, 0, _("Unexpected long name header")));
1169 case GNUTYPE_SPARSE
:
1172 modes
[0] = st
->had_trailing_slash
? 'd' : '-';
1177 case GNUTYPE_DUMPDIR
:
1200 pax_decode_mode (st
->stat
.st_mode
, modes
+ 1);
1202 /* extended attributes: GNU `ls -l'-like preview */
1203 xattrs_print_char (st
, modes
+ 10);
1207 time_stamp
= tartime (st
->mtime
, full_time_option
);
1208 time_stamp_len
= strlen (time_stamp
);
1209 if (datewidth
< time_stamp_len
)
1210 datewidth
= time_stamp_len
;
1212 /* User and group names. */
1216 && current_format
!= V7_FORMAT
1217 && !numeric_owner_option
)
1221 /* Try parsing it as an unsigned integer first, and as a
1222 uid_t if that fails. This method can list positive user
1223 ids that are too large to fit in a uid_t. */
1224 uintmax_t u
= from_header (blk
->header
.uid
,
1225 sizeof blk
->header
.uid
, 0,
1229 ? STRINGIFY_BIGINT (u
, uform
)
1230 : imaxtostr (UID_FROM_HEADER (blk
->header
.uid
), uform
));
1235 && current_format
!= V7_FORMAT
1236 && !numeric_owner_option
)
1240 /* Try parsing it as an unsigned integer first, and as a
1241 gid_t if that fails. This method can list positive group
1242 ids that are too large to fit in a gid_t. */
1243 uintmax_t g
= from_header (blk
->header
.gid
,
1244 sizeof blk
->header
.gid
, 0,
1248 ? STRINGIFY_BIGINT (g
, gform
)
1249 : imaxtostr (GID_FROM_HEADER (blk
->header
.gid
), gform
));
1252 /* Format the file size or major/minor device numbers. */
1254 switch (blk
->header
.typeflag
)
1259 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1262 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1266 /* st->stat.st_size keeps stored file size */
1267 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1271 /* Figure out padding and print the whole line. */
1273 sizelen
= strlen (size
);
1274 pad
= strlen (user
) + 1 + strlen (group
) + 1 + sizelen
;
1278 fprintf (stdlis
, "%s %s/%s %*s %-*s",
1279 modes
, user
, group
, ugswidth
- pad
+ sizelen
, size
,
1280 datewidth
, time_stamp
);
1282 fprintf (stdlis
, " %s", quotearg (temp_name
));
1283 if (show_transformed_names_option
&& st
->had_trailing_slash
)
1284 fputc ('/', stdlis
);
1286 switch (blk
->header
.typeflag
)
1289 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1293 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1298 char type_string
[2];
1299 type_string
[0] = blk
->header
.typeflag
;
1300 type_string
[1] = '\0';
1301 fprintf (stdlis
, _(" unknown file type %s\n"),
1302 quote (type_string
));
1308 case GNUTYPE_SPARSE
:
1314 case GNUTYPE_DUMPDIR
:
1315 putc ('\n', stdlis
);
1318 case GNUTYPE_LONGLINK
:
1319 fprintf (stdlis
, _("--Long Link--\n"));
1322 case GNUTYPE_LONGNAME
:
1323 fprintf (stdlis
, _("--Long Name--\n"));
1326 case GNUTYPE_VOLHDR
:
1327 fprintf (stdlis
, _("--Volume Header--\n"));
1330 case GNUTYPE_MULTIVOL
:
1333 (UINTMAX_FROM_HEADER (blk
->oldgnu_header
.offset
),
1335 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1345 print_volume_label (void)
1347 struct tar_stat_info vstat
;
1349 enum archive_format dummy
;
1351 memset (&vblk
, 0, sizeof (vblk
));
1352 vblk
.header
.typeflag
= GNUTYPE_VOLHDR
;
1353 if (recent_global_header
)
1354 memcpy (vblk
.header
.mtime
, recent_global_header
->header
.mtime
,
1355 sizeof vblk
.header
.mtime
);
1356 tar_stat_init (&vstat
);
1357 assign_string (&vstat
.file_name
, ".");
1358 decode_header (&vblk
, &vstat
, &dummy
, 0);
1359 assign_string (&vstat
.file_name
, volume_label
);
1360 simple_print_header (&vstat
, &vblk
, 0);
1361 tar_stat_destroy (&vstat
);
1365 print_header (struct tar_stat_info
*st
, union block
*blk
,
1366 off_t block_ordinal
)
1368 if (current_format
== POSIX_FORMAT
&& !volume_label_printed
&& volume_label
)
1370 print_volume_label ();
1371 volume_label_printed
= true;
1374 simple_print_header (st
, blk
, block_ordinal
);
1377 /* Print a similar line when we make a directory automatically. */
1379 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1383 if (verbose_option
> 1)
1385 /* File type and modes. */
1388 pax_decode_mode (mode
, modes
+ 1);
1390 if (block_number_option
)
1392 char buf
[UINTMAX_STRSIZE_BOUND
];
1393 fprintf (stdlis
, _("block %s: "),
1394 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1397 fprintf (stdlis
, "%s %*s %s\n", modes
, ugswidth
+ 1 + datewidth
,
1398 _("Creating directory:"), quotearg (dirname
));
1402 /* Skip over SIZE bytes of data in blocks in the archive. */
1404 skip_file (off_t size
)
1408 /* FIXME: Make sure mv_begin_read is always called before it */
1410 if (seekable_archive
)
1412 off_t nblk
= seek_archive (size
);
1414 size
-= nblk
* BLOCKSIZE
;
1416 seekable_archive
= false;
1419 mv_size_left (size
);
1423 x
= find_next_block ();
1425 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1427 set_next_block_after (x
);
1429 mv_size_left (size
);
1433 /* Skip the current member in the archive.
1434 NOTE: Current header must be decoded before calling this function. */
1438 if (!current_stat_info
.skipped
)
1440 char save_typeflag
= current_header
->header
.typeflag
;
1441 set_next_block_after (current_header
);
1443 mv_begin_read (¤t_stat_info
);
1445 if (current_stat_info
.is_sparse
)
1446 sparse_skip_file (¤t_stat_info
);
1447 else if (save_typeflag
!= DIRTYPE
)
1448 skip_file (current_stat_info
.stat
.st_size
);
1455 test_archive_label (void)
1460 open_archive (ACCESS_READ
);
1461 if (read_header (¤t_header
, ¤t_stat_info
, read_header_auto
)
1464 decode_header (current_header
,
1465 ¤t_stat_info
, ¤t_format
, 0);
1466 if (current_header
->header
.typeflag
== GNUTYPE_VOLHDR
)
1467 assign_string (&volume_label
, current_header
->header
.name
);
1472 print_volume_label ();
1473 if (!name_match (volume_label
) && multi_volume_option
)
1475 char *s
= drop_volume_label_suffix (volume_label
);