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
)
436 free (next_long_name
);
437 next_long_name
= header_copy
;
438 next_long_name_blocks
= size
/ BLOCKSIZE
;
442 free (next_long_link
);
443 next_long_link
= header_copy
;
444 next_long_link_blocks
= size
/ BLOCKSIZE
;
447 set_next_block_after (header
);
448 *header_copy
= *header
;
449 bp
= header_copy
->buffer
+ BLOCKSIZE
;
451 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
453 data_block
= find_next_block ();
456 ERROR ((0, 0, _("Unexpected EOF in archive")));
459 written
= available_space_after (data_block
);
463 memcpy (bp
, data_block
->buffer
, written
);
465 set_next_block_after ((union block
*)
466 (data_block
->buffer
+ written
- 1));
471 else if (header
->header
.typeflag
== XHDTYPE
472 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
473 xheader_read (&info
->xhdr
, header
,
474 OFF_FROM_HEADER (header
->header
.size
));
475 else if (header
->header
.typeflag
== XGLTYPE
)
479 if (!recent_global_header
)
480 recent_global_header
= xmalloc (sizeof *recent_global_header
);
481 memcpy (recent_global_header
, header
,
482 sizeof *recent_global_header
);
483 memset (&xhdr
, 0, sizeof xhdr
);
484 xheader_read (&xhdr
, header
,
485 OFF_FROM_HEADER (header
->header
.size
));
486 xheader_decode_global (&xhdr
);
487 xheader_destroy (&xhdr
);
488 if (mode
== read_header_x_global
)
489 return HEADER_SUCCESS_EXTENDED
;
498 struct posix_header
const *h
= &header
->header
;
499 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
501 free (recent_long_name
);
505 name
= next_long_name
->buffer
+ BLOCKSIZE
;
506 recent_long_name
= next_long_name
;
507 recent_long_name_blocks
= next_long_name_blocks
;
511 /* Accept file names as specified by POSIX.1-1996
515 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
517 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
518 np
[sizeof h
->prefix
] = '\0';
522 memcpy (np
, h
->name
, sizeof h
->name
);
523 np
[sizeof h
->name
] = '\0';
525 recent_long_name
= 0;
526 recent_long_name_blocks
= 0;
528 assign_string (&info
->orig_file_name
, name
);
529 assign_string (&info
->file_name
, name
);
530 info
->had_trailing_slash
= strip_trailing_slashes (info
->file_name
);
532 free (recent_long_link
);
536 name
= next_long_link
->buffer
+ BLOCKSIZE
;
537 recent_long_link
= next_long_link
;
538 recent_long_link_blocks
= next_long_link_blocks
;
542 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
543 namebuf
[sizeof h
->linkname
] = '\0';
545 recent_long_link
= 0;
546 recent_long_link_blocks
= 0;
548 assign_string (&info
->link_name
, name
);
550 return HEADER_SUCCESS
;
555 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
557 /* Decode things from a file HEADER block into STAT_INFO, also setting
558 *FORMAT_POINTER depending on the header block format. If
559 DO_USER_GROUP, decode the user/group information (this is useful
560 for extraction, but waste time when merely listing).
562 read_header() has already decoded the checksum and length, so we don't.
564 This routine should *not* be called twice for the same block, since
565 the two calls might use different DO_USER_GROUP values and thus
566 might end up with different uid/gid for the two calls. If anybody
567 wants the uid/gid they should decode it first, and other callers
568 should decode it without uid/gid before calling a routine,
569 e.g. print_header, that assumes decoded data. */
571 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
572 enum archive_format
*format_pointer
, int do_user_group
)
574 enum archive_format format
;
575 unsigned hbits
; /* high bits of the file mode. */
576 mode_t mode
= MODE_FROM_HEADER (header
->header
.mode
, &hbits
);
578 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
580 if (header
->star_header
.prefix
[130] == 0
581 && ISOCTAL (header
->star_header
.atime
[0])
582 && header
->star_header
.atime
[11] == ' '
583 && ISOCTAL (header
->star_header
.ctime
[0])
584 && header
->star_header
.ctime
[11] == ' ')
585 format
= STAR_FORMAT
;
586 else if (stat_info
->xhdr
.size
)
587 format
= POSIX_FORMAT
;
589 format
= USTAR_FORMAT
;
591 else if (strcmp (header
->buffer
+ offsetof (struct posix_header
, magic
),
594 format
= hbits
? OLDGNU_FORMAT
: GNU_FORMAT
;
597 *format_pointer
= format
;
599 stat_info
->stat
.st_mode
= mode
;
600 stat_info
->mtime
.tv_sec
= TIME_FROM_HEADER (header
->header
.mtime
);
601 stat_info
->mtime
.tv_nsec
= 0;
602 assign_string (&stat_info
->uname
,
603 header
->header
.uname
[0] ? header
->header
.uname
: NULL
);
604 assign_string (&stat_info
->gname
,
605 header
->header
.gname
[0] ? header
->header
.gname
: NULL
);
607 if (format
== OLDGNU_FORMAT
&& incremental_option
)
609 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
610 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
611 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
613 else if (format
== STAR_FORMAT
)
615 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.atime
);
616 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.ctime
);
617 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
620 stat_info
->atime
= stat_info
->ctime
= start_time
;
622 if (format
== V7_FORMAT
)
624 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
625 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
626 stat_info
->stat
.st_rdev
= 0;
632 /* FIXME: Decide if this should somewhat depend on -p. */
634 if (numeric_owner_option
635 || !*header
->header
.uname
636 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
637 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
639 if (numeric_owner_option
640 || !*header
->header
.gname
641 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
642 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
645 switch (header
->header
.typeflag
)
649 stat_info
->stat
.st_rdev
=
650 makedev (MAJOR_FROM_HEADER (header
->header
.devmajor
),
651 MINOR_FROM_HEADER (header
->header
.devminor
));
655 stat_info
->stat
.st_rdev
= 0;
659 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
660 xheader_decode (stat_info
);
662 if (sparse_member_p (stat_info
))
664 sparse_fixup_header (stat_info
);
665 stat_info
->is_sparse
= true;
669 stat_info
->is_sparse
= false;
670 if (((current_format
== GNU_FORMAT
671 || current_format
== OLDGNU_FORMAT
)
672 && current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
673 || stat_info
->dumpdir
)
674 stat_info
->is_dumpdir
= true;
679 /* Convert buffer at WHERE0 of size DIGS from external format to
680 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
681 are of type TYPE. The buffer must represent a value in the range
682 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
683 numbers instead of the other GNU extensions. Return -1 on error,
684 diagnosing the error if TYPE is nonnull and if !SILENT. */
686 from_header (char const *where0
, size_t digs
, char const *type
,
687 uintmax_t minus_minval
, uintmax_t maxval
,
688 bool octal_only
, bool silent
)
691 char const *where
= where0
;
692 char const *lim
= where
+ digs
;
695 /* Accommodate buggy tar of unknown vintage, which outputs leading
696 NUL if the previous field overflows. */
699 /* Accommodate older tars, which output leading spaces. */
706 /* TRANSLATORS: %s is type of the value (gid_t, uid_t,
708 _("Blanks in header where numeric %s value expected"),
712 if (!ISSPACE ((unsigned char) *where
))
718 if (ISODIGIT (*where
))
720 char const *where1
= where
;
721 uintmax_t overflow
= 0;
725 value
+= *where
++ - '0';
726 if (where
== lim
|| ! ISODIGIT (*where
))
728 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
732 /* Parse the output of older, unportable tars, which generate
733 negative values in two's complement octal. If the leading
734 nonzero digit is 1, we can't recover the original value
735 reliably; so do this only if the digit is 2 or more. This
736 catches the common case of 32-bit negative time stamps. */
737 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
739 /* Compute the negative of the input value, assuming two's
741 int digit
= (*where1
- '0') | 4;
749 if (where
== lim
|| ! ISODIGIT (*where
))
751 digit
= *where
- '0';
752 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
758 if (!overflow
&& value
<= minus_minval
)
762 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
763 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
764 (int) (where
- where1
), where1
, type
));
773 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
774 _("Archive octal value %.*s is out of %s range"),
775 (int) (where
- where1
), where1
, type
));
781 /* Suppress the following extensions. */
783 else if (*where
== '-' || *where
== '+')
785 /* Parse base-64 output produced only by tar test versions
786 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
787 Support for this will be withdrawn in future releases. */
791 static bool warned_once
;
795 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
798 negative
= *where
++ == '-';
800 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
802 if (value
<< LG_64
>> LG_64
!= value
)
804 char *string
= alloca (digs
+ 1);
805 memcpy (string
, where0
, digs
);
809 _("Archive signed base-64 string %s is out of %s range"),
810 quote (string
), type
));
813 value
= (value
<< LG_64
) | dig
;
817 else if (*where
== '\200' /* positive base-256 */
818 || *where
== '\377' /* negative base-256 */)
820 /* Parse base-256 output. A nonnegative number N is
821 represented as (256**DIGS)/2 + N; a negative number -N is
822 represented as (256**DIGS) - N, i.e. as two's complement.
823 The representation guarantees that the leading bit is
824 always on, so that we don't confuse this format with the
825 others (assuming ASCII bytes of 8 bits or more). */
826 int signbit
= *where
& (1 << (LG_256
- 2));
827 uintmax_t topbits
= (((uintmax_t) - signbit
)
828 << (CHAR_BIT
* sizeof (uintmax_t)
829 - LG_256
- (LG_256
- 2)));
830 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
833 value
= (value
<< LG_256
) + (unsigned char) *where
++;
836 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
840 _("Archive base-256 value is out of %s range"),
850 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
854 char buf
[1000]; /* Big enough to represent any header. */
855 static struct quoting_options
*o
;
859 o
= clone_quoting_options (0);
860 set_quoting_style (o
, locale_quoting_style
);
863 while (where0
!= lim
&& ! lim
[-1])
865 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
868 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
869 _("Archive contains %.*s where numeric %s value expected"),
870 (int) sizeof buf
, buf
, type
));
876 if (value
<= (negative
? minus_minval
: maxval
))
877 return negative
? -value
: value
;
881 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
882 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
883 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
884 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
885 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
887 *--value_string
= '-';
889 *--minval_string
= '-';
890 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
891 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
893 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
900 gid_from_header (const char *p
, size_t s
)
902 return from_header (p
, s
, "gid_t",
903 - (uintmax_t) TYPE_MINIMUM (gid_t
),
904 (uintmax_t) TYPE_MAXIMUM (gid_t
),
909 major_from_header (const char *p
, size_t s
)
911 return from_header (p
, s
, "major_t",
912 - (uintmax_t) TYPE_MINIMUM (major_t
),
913 (uintmax_t) TYPE_MAXIMUM (major_t
), false, false);
917 minor_from_header (const char *p
, size_t s
)
919 return from_header (p
, s
, "minor_t",
920 - (uintmax_t) TYPE_MINIMUM (minor_t
),
921 (uintmax_t) TYPE_MAXIMUM (minor_t
), false, false);
924 /* Convert P to the file mode, as understood by tar.
925 Store unrecognized mode bits (from 10th up) in HBITS. */
927 mode_from_header (const char *p
, size_t s
, unsigned *hbits
)
929 unsigned u
= from_header (p
, s
, "mode_t",
930 - (uintmax_t) TYPE_MINIMUM (mode_t
),
931 TYPE_MAXIMUM (uintmax_t), false, false);
932 mode_t mode
= ((u
& TSUID
? S_ISUID
: 0)
933 | (u
& TSGID
? S_ISGID
: 0)
934 | (u
& TSVTX
? S_ISVTX
: 0)
935 | (u
& TUREAD
? S_IRUSR
: 0)
936 | (u
& TUWRITE
? S_IWUSR
: 0)
937 | (u
& TUEXEC
? S_IXUSR
: 0)
938 | (u
& TGREAD
? S_IRGRP
: 0)
939 | (u
& TGWRITE
? S_IWGRP
: 0)
940 | (u
& TGEXEC
? S_IXGRP
: 0)
941 | (u
& TOREAD
? S_IROTH
: 0)
942 | (u
& TOWRITE
? S_IWOTH
: 0)
943 | (u
& TOEXEC
? S_IXOTH
: 0));
949 off_from_header (const char *p
, size_t s
)
951 /* Negative offsets are not allowed in tar files, so invoke
952 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
953 return from_header (p
, s
, "off_t", (uintmax_t) 0,
954 (uintmax_t) TYPE_MAXIMUM (off_t
), false, false);
958 time_from_header (const char *p
, size_t s
)
960 return from_header (p
, s
, "time_t",
961 - (uintmax_t) TYPE_MINIMUM (time_t),
962 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
966 uid_from_header (const char *p
, size_t s
)
968 return from_header (p
, s
, "uid_t",
969 - (uintmax_t) TYPE_MINIMUM (uid_t
),
970 (uintmax_t) TYPE_MAXIMUM (uid_t
), false, false);
974 uintmax_from_header (const char *p
, size_t s
)
976 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
977 TYPE_MAXIMUM (uintmax_t), false, false);
981 /* Return a printable representation of T. The result points to
982 static storage that can be reused in the next call to this
983 function, to ctime, or to asctime. If FULL_TIME, then output the
984 time stamp to its full resolution; otherwise, just output it to
985 1-minute resolution. */
987 tartime (struct timespec t
, bool full_time
)
989 enum { fraclen
= sizeof ".FFFFFFFFF" - 1 };
990 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
991 INT_STRLEN_BOUND (int) + 16)
996 bool negative
= s
< 0;
999 if (negative
&& ns
!= 0)
1002 ns
= 1000000000 - ns
;
1005 tm
= utc_option
? gmtime (&s
) : localtime (&s
);
1010 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
1011 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
1012 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
1013 code_ns_fraction (ns
, buffer
+ strlen (buffer
));
1016 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d",
1017 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
1018 tm
->tm_hour
, tm
->tm_min
);
1022 /* The time stamp cannot be broken down, most likely because it
1023 is out of range. Convert it as an integer,
1024 right-adjusted in a field with the same width as the usual
1025 4-year ISO time format. */
1026 p
= umaxtostr (negative
? - (uintmax_t) s
: s
,
1027 buffer
+ sizeof buffer
- UINTMAX_STRSIZE_BOUND
- fraclen
);
1030 while ((buffer
+ sizeof buffer
- sizeof "YYYY-MM-DD HH:MM"
1031 + (full_time
? sizeof ":SS.FFFFFFFFF" - 1 : 0))
1035 code_ns_fraction (ns
, buffer
+ sizeof buffer
- 1 - fraclen
);
1039 /* Actually print it.
1041 Plain and fancy file header block logging. Non-verbose just prints
1042 the name, e.g. for "tar t" or "tar x". This should just contain
1043 file names, so it can be fed back into tar with xargs or the "-T"
1044 option. The verbose option can give a bunch of info, one line per
1045 file. I doubt anybody tries to parse its format, or if they do,
1046 they shouldn't. Unix tar is pretty random here anyway. */
1049 /* Width of "user/group size", with initial value chosen
1050 heuristically. This grows as needed, though this may cause some
1051 stairstepping in the output. Make it too small and the output will
1052 almost always look ragged. Make it too large and the output will
1053 be spaced out too far. */
1054 static int ugswidth
= 19;
1056 /* Width of printed time stamps. It grows if longer time stamps are
1057 found (typically, those with nanosecond resolution). Like
1058 USGWIDTH, some stairstepping may occur. */
1059 static int datewidth
= sizeof "YYYY-MM-DD HH:MM" - 1;
1061 static bool volume_label_printed
= false;
1064 simple_print_header (struct tar_stat_info
*st
, union block
*blk
,
1065 off_t block_ordinal
)
1068 char const *time_stamp
;
1072 /* These hold formatted ints. */
1073 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
1075 char size
[2 * UINTMAX_STRSIZE_BOUND
];
1076 /* holds formatted size or major,minor */
1077 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
1081 if (show_transformed_names_option
)
1082 temp_name
= st
->file_name
? st
->file_name
: st
->orig_file_name
;
1084 temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
1086 if (block_number_option
)
1088 char buf
[UINTMAX_STRSIZE_BOUND
];
1089 if (block_ordinal
< 0)
1090 block_ordinal
= current_block_ordinal ();
1091 block_ordinal
-= recent_long_name_blocks
;
1092 block_ordinal
-= recent_long_link_blocks
;
1093 fprintf (stdlis
, _("block %s: "),
1094 STRINGIFY_BIGINT (block_ordinal
, buf
));
1097 if (verbose_option
<= 1)
1099 /* Just the fax, mam. */
1100 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
1104 /* File type and modes. */
1107 switch (blk
->header
.typeflag
)
1109 case GNUTYPE_VOLHDR
:
1110 volume_label_printed
= true;
1114 case GNUTYPE_MULTIVOL
:
1118 case GNUTYPE_LONGNAME
:
1119 case GNUTYPE_LONGLINK
:
1121 ERROR ((0, 0, _("Unexpected long name header")));
1124 case GNUTYPE_SPARSE
:
1128 if (temp_name
[strlen (temp_name
) - 1] == '/')
1134 case GNUTYPE_DUMPDIR
:
1157 pax_decode_mode (st
->stat
.st_mode
, modes
+ 1);
1161 time_stamp
= tartime (st
->mtime
, full_time_option
);
1162 time_stamp_len
= strlen (time_stamp
);
1163 if (datewidth
< time_stamp_len
)
1164 datewidth
= time_stamp_len
;
1166 /* User and group names. */
1170 && current_format
!= V7_FORMAT
1171 && !numeric_owner_option
)
1175 /* Try parsing it as an unsigned integer first, and as a
1176 uid_t if that fails. This method can list positive user
1177 ids that are too large to fit in a uid_t. */
1178 uintmax_t u
= from_header (blk
->header
.uid
,
1179 sizeof blk
->header
.uid
, 0,
1181 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1184 user
= STRINGIFY_BIGINT (u
, uform
);
1187 sprintf (uform
, "%ld",
1188 (long) UID_FROM_HEADER (blk
->header
.uid
));
1195 && current_format
!= V7_FORMAT
1196 && !numeric_owner_option
)
1200 /* Try parsing it as an unsigned integer first, and as a
1201 gid_t if that fails. This method can list positive group
1202 ids that are too large to fit in a gid_t. */
1203 uintmax_t g
= from_header (blk
->header
.gid
,
1204 sizeof blk
->header
.gid
, 0,
1206 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1209 group
= STRINGIFY_BIGINT (g
, gform
);
1212 sprintf (gform
, "%ld",
1213 (long) GID_FROM_HEADER (blk
->header
.gid
));
1218 /* Format the file size or major/minor device numbers. */
1220 switch (blk
->header
.typeflag
)
1225 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1228 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1232 /* st->stat.st_size keeps stored file size */
1233 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1237 /* Figure out padding and print the whole line. */
1239 sizelen
= strlen (size
);
1240 pad
= strlen (user
) + 1 + strlen (group
) + 1 + sizelen
;
1244 fprintf (stdlis
, "%s %s/%s %*s %-*s",
1245 modes
, user
, group
, ugswidth
- pad
+ sizelen
, size
,
1246 datewidth
, time_stamp
);
1248 fprintf (stdlis
, " %s", quotearg (temp_name
));
1250 switch (blk
->header
.typeflag
)
1253 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1257 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1262 char type_string
[2];
1263 type_string
[0] = blk
->header
.typeflag
;
1264 type_string
[1] = '\0';
1265 fprintf (stdlis
, _(" unknown file type %s\n"),
1266 quote (type_string
));
1272 case GNUTYPE_SPARSE
:
1278 case GNUTYPE_DUMPDIR
:
1279 putc ('\n', stdlis
);
1282 case GNUTYPE_LONGLINK
:
1283 fprintf (stdlis
, _("--Long Link--\n"));
1286 case GNUTYPE_LONGNAME
:
1287 fprintf (stdlis
, _("--Long Name--\n"));
1290 case GNUTYPE_VOLHDR
:
1291 fprintf (stdlis
, _("--Volume Header--\n"));
1294 case GNUTYPE_MULTIVOL
:
1297 (UINTMAX_FROM_HEADER (blk
->oldgnu_header
.offset
),
1299 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1308 print_volume_label (void)
1310 struct tar_stat_info vstat
;
1312 enum archive_format dummy
;
1314 memset (&vblk
, 0, sizeof (vblk
));
1315 vblk
.header
.typeflag
= GNUTYPE_VOLHDR
;
1316 if (recent_global_header
)
1317 memcpy (vblk
.header
.mtime
, recent_global_header
->header
.mtime
,
1318 sizeof vblk
.header
.mtime
);
1319 tar_stat_init (&vstat
);
1320 assign_string (&vstat
.file_name
, ".");
1321 decode_header (&vblk
, &vstat
, &dummy
, 0);
1322 assign_string (&vstat
.file_name
, volume_label
);
1323 simple_print_header (&vstat
, &vblk
, 0);
1324 tar_stat_destroy (&vstat
);
1328 print_header (struct tar_stat_info
*st
, union block
*blk
,
1329 off_t block_ordinal
)
1331 if (current_format
== POSIX_FORMAT
&& !volume_label_printed
&& volume_label
)
1333 print_volume_label ();
1334 volume_label_printed
= true;
1337 simple_print_header (st
, blk
, block_ordinal
);
1340 /* Print a similar line when we make a directory automatically. */
1342 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1346 if (verbose_option
> 1)
1348 /* File type and modes. */
1351 pax_decode_mode (mode
, modes
+ 1);
1353 if (block_number_option
)
1355 char buf
[UINTMAX_STRSIZE_BOUND
];
1356 fprintf (stdlis
, _("block %s: "),
1357 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1360 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ 1 + datewidth
,
1361 _("Creating directory:"), length
, quotearg (dirname
));
1365 /* Skip over SIZE bytes of data in blocks in the archive. */
1367 skip_file (off_t size
)
1371 /* FIXME: Make sure mv_begin_read is always called before it */
1373 if (seekable_archive
)
1375 off_t nblk
= seek_archive (size
);
1377 size
-= nblk
* BLOCKSIZE
;
1379 seekable_archive
= false;
1382 mv_size_left (size
);
1386 x
= find_next_block ();
1388 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1390 set_next_block_after (x
);
1392 mv_size_left (size
);
1396 /* Skip the current member in the archive.
1397 NOTE: Current header must be decoded before calling this function. */
1401 if (!current_stat_info
.skipped
)
1403 char save_typeflag
= current_header
->header
.typeflag
;
1404 set_next_block_after (current_header
);
1406 mv_begin_read (¤t_stat_info
);
1408 if (current_stat_info
.is_sparse
)
1409 sparse_skip_file (¤t_stat_info
);
1410 else if (save_typeflag
!= DIRTYPE
)
1411 skip_file (current_stat_info
.stat
.st_size
);
1418 test_archive_label ()
1423 open_archive (ACCESS_READ
);
1424 if (read_header (¤t_header
, ¤t_stat_info
, read_header_auto
)
1427 decode_header (current_header
,
1428 ¤t_stat_info
, ¤t_format
, 0);
1429 if (current_header
->header
.typeflag
== GNUTYPE_VOLHDR
)
1430 assign_string (&volume_label
, current_header
->header
.name
);
1435 print_volume_label ();
1436 if (!name_match (volume_label
) && multi_volume_option
)
1438 char *s
= drop_volume_label_suffix (volume_label
);