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 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 2, or (at your option) any later
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
16 Public License for more details.
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
28 #define max(a, b) ((a) < (b) ? (b) : (a))
30 union block
*current_header
; /* points to current archive header */
31 enum archive_format current_format
; /* recognized format */
32 union block
*recent_long_name
; /* recent long name header and contents */
33 union block
*recent_long_link
; /* likewise, for long link */
34 size_t recent_long_name_blocks
; /* number of blocks in recent_long_name */
35 size_t recent_long_link_blocks
; /* likewise, for long link */
37 static uintmax_t from_header (const char *, size_t, const char *,
38 uintmax_t, uintmax_t, bool, bool);
40 /* Base 64 digits; see Internet RFC 2045 Table 1. */
41 static char const base_64_digits
[64] =
43 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
44 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
45 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
46 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
47 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
50 /* Table of base-64 digit values indexed by unsigned chars.
51 The value is 64 for unsigned chars that are not base-64 digits. */
52 static char base64_map
[UCHAR_MAX
+ 1];
58 memset (base64_map
, 64, sizeof base64_map
);
59 for (i
= 0; i
< 64; i
++)
60 base64_map
[(int) base_64_digits
[i
]] = i
;
63 /* Main loop for reading an archive. */
65 read_and (void (*do_something
) (void))
67 enum read_header status
= HEADER_STILL_UNREAD
;
68 enum read_header prev_status
;
69 struct timespec mtime
;
74 open_archive (ACCESS_READ
);
78 tar_stat_destroy (¤t_stat_info
);
79 xheader_destroy (&extended_header
);
81 status
= read_header (false);
84 case HEADER_STILL_UNREAD
:
85 case HEADER_SUCCESS_EXTENDED
:
90 /* Valid header. We should decode next field (mode) first.
91 Ensure incoming names are null terminated. */
93 if (! name_match (current_stat_info
.file_name
)
94 || (NEWER_OPTION_INITIALIZED (newer_mtime_option
)
95 /* FIXME: We get mtime now, and again later; this causes
96 duplicate diagnostics if header.mtime is bogus. */
98 = TIME_FROM_HEADER (current_header
->header
.mtime
)),
99 /* FIXME: Grab fractional time stamps from
102 set_stat_mtime (¤t_stat_info
.stat
, mtime
),
103 OLDER_STAT_TIME (current_stat_info
.stat
, m
)))
104 || excluded_name (current_stat_info
.file_name
))
106 switch (current_header
->header
.typeflag
)
109 case GNUTYPE_MULTIVOL
:
114 if (show_omitted_dirs_option
)
115 WARN ((0, 0, _("%s: Omitting"),
116 quotearg_colon (current_stat_info
.file_name
)));
119 decode_header (current_header
,
120 ¤t_stat_info
, ¤t_format
, 0);
129 case HEADER_ZERO_BLOCK
:
130 if (block_number_option
)
132 char buf
[UINTMAX_STRSIZE_BOUND
];
133 fprintf (stdlis
, _("block %s: ** Block of NULs **\n"),
134 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
137 set_next_block_after (current_header
);
139 if (!ignore_zeros_option
)
141 char buf
[UINTMAX_STRSIZE_BOUND
];
143 status
= read_header (false);
144 if (status
== HEADER_ZERO_BLOCK
)
146 WARN ((0, 0, _("A lone zero block at %s"),
147 STRINGIFY_BIGINT (current_block_ordinal (), buf
)));
150 status
= prev_status
;
153 case HEADER_END_OF_FILE
:
154 if (block_number_option
)
156 char buf
[UINTMAX_STRSIZE_BOUND
];
157 fprintf (stdlis
, _("block %s: ** End of File **\n"),
158 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
163 /* If the previous header was good, tell them that we are
164 skipping bad ones. */
165 set_next_block_after (current_header
);
168 case HEADER_STILL_UNREAD
:
169 ERROR ((0, 0, _("This does not look like a tar archive")));
172 case HEADER_ZERO_BLOCK
:
174 if (block_number_option
)
176 char buf
[UINTMAX_STRSIZE_BOUND
];
177 off_t block_ordinal
= current_block_ordinal ();
178 block_ordinal
-= recent_long_name_blocks
;
179 block_ordinal
-= recent_long_link_blocks
;
180 fprintf (stdlis
, _("block %s: "),
181 STRINGIFY_BIGINT (block_ordinal
, buf
));
183 ERROR ((0, 0, _("Skipping to next header")));
186 case HEADER_END_OF_FILE
:
188 /* We are in the middle of a cascade of errors. */
191 case HEADER_SUCCESS_EXTENDED
:
198 while (!all_names_found (¤t_stat_info
));
201 names_notfound (); /* print names not found */
204 /* Print a header block, based on tar options. */
208 /* Print the header block. */
210 decode_header (current_header
, ¤t_stat_info
, ¤t_format
, 0);
212 print_header (¤t_stat_info
, -1);
214 if (incremental_option
&& current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
217 size_t written
, check
;
218 union block
*data_block
;
220 set_next_block_after (current_header
);
221 if (multi_volume_option
)
223 assign_string (&save_name
, current_stat_info
.orig_file_name
);
224 save_totsize
= current_stat_info
.stat
.st_size
;
226 for (size
= current_stat_info
.stat
.st_size
; size
> 0; size
-= written
)
228 if (multi_volume_option
)
229 save_sizeleft
= size
;
230 data_block
= find_next_block ();
233 ERROR ((0, 0, _("Unexpected EOF in archive")));
234 break; /* FIXME: What happens, then? */
236 written
= available_space_after (data_block
);
240 check
= fwrite (data_block
->buffer
, sizeof (char), written
, stdlis
);
241 set_next_block_after ((union block
*)
242 (data_block
->buffer
+ written
- 1));
243 if (check
!= written
)
245 write_error_details (current_stat_info
.file_name
, check
, written
);
246 skip_file (size
- written
);
250 if (multi_volume_option
)
251 assign_string (&save_name
, 0);
252 fputc ('\n', stdlis
);
258 if (multi_volume_option
)
259 assign_string (&save_name
, current_stat_info
.orig_file_name
);
263 if (multi_volume_option
)
264 assign_string (&save_name
, 0);
267 /* Check header checksum */
268 /* The standard BSD tar sources create the checksum by adding up the
269 bytes in the header as type char. I think the type char was unsigned
270 on the PDP-11, but it's signed on the Next and Sun. It looks like the
271 sources to BSD tar were never changed to compute the checksum
272 correctly, so both the Sun and Next add the bytes of the header as
273 signed chars. This doesn't cause a problem until you get a file with
274 a name containing characters with the high bit set. So tar_checksum
275 computes two checksums -- signed and unsigned. */
278 tar_checksum (union block
*header
, bool silent
)
281 int unsigned_sum
= 0; /* the POSIX one :-) */
282 int signed_sum
= 0; /* the Sun one :-( */
284 uintmax_t parsed_sum
;
288 for (i
= sizeof *header
; i
-- != 0;)
290 unsigned_sum
+= (unsigned char) *p
;
291 signed_sum
+= (signed char) (*p
++);
294 if (unsigned_sum
== 0)
295 return HEADER_ZERO_BLOCK
;
297 /* Adjust checksum to count the "chksum" field as blanks. */
299 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
301 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
302 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
304 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
305 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
307 parsed_sum
= from_header (header
->header
.chksum
,
308 sizeof header
->header
.chksum
, 0,
310 (uintmax_t) TYPE_MAXIMUM (int), true, silent
);
311 if (parsed_sum
== (uintmax_t) -1)
312 return HEADER_FAILURE
;
314 recorded_sum
= parsed_sum
;
316 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
317 return HEADER_FAILURE
;
319 return HEADER_SUCCESS
;
322 /* Read a block that's supposed to be a header block. Return its
323 address in "current_header", and if it is good, the file's size in
324 current_stat_info.stat.st_size.
326 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
327 block full of zeros (EOF marker).
329 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
330 GNU long name and link headers into later headers.
332 You must always set_next_block_after(current_header) to skip past
333 the header which this routine reads. */
336 read_header (bool raw_extended_headers
)
339 union block
*header_copy
;
341 union block
*data_block
;
342 size_t size
, written
;
343 union block
*next_long_name
= 0;
344 union block
*next_long_link
= 0;
345 size_t next_long_name_blocks
;
346 size_t next_long_link_blocks
;
350 enum read_header status
;
352 header
= find_next_block ();
353 current_header
= header
;
355 return HEADER_END_OF_FILE
;
357 if ((status
= tar_checksum (header
, false)) != HEADER_SUCCESS
)
360 /* Good block. Decode file size and return. */
362 if (header
->header
.typeflag
== LNKTYPE
)
363 current_stat_info
.stat
.st_size
= 0; /* links 0 size on tape */
365 current_stat_info
.stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
367 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
368 || header
->header
.typeflag
== GNUTYPE_LONGLINK
369 || header
->header
.typeflag
== XHDTYPE
370 || header
->header
.typeflag
== XGLTYPE
371 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
373 if (raw_extended_headers
)
374 return HEADER_SUCCESS_EXTENDED
;
375 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
376 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
378 size_t name_size
= current_stat_info
.stat
.st_size
;
379 size_t n
= name_size
% BLOCKSIZE
;
380 size
= name_size
+ BLOCKSIZE
;
382 size
+= BLOCKSIZE
- n
;
384 if (name_size
!= current_stat_info
.stat
.st_size
388 header_copy
= xmalloc (size
+ 1);
390 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
393 free (next_long_name
);
394 next_long_name
= header_copy
;
395 next_long_name_blocks
= size
/ BLOCKSIZE
;
400 free (next_long_link
);
401 next_long_link
= header_copy
;
402 next_long_link_blocks
= size
/ BLOCKSIZE
;
405 set_next_block_after (header
);
406 *header_copy
= *header
;
407 bp
= header_copy
->buffer
+ BLOCKSIZE
;
409 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
411 data_block
= find_next_block ();
414 ERROR ((0, 0, _("Unexpected EOF in archive")));
417 written
= available_space_after (data_block
);
421 memcpy (bp
, data_block
->buffer
, written
);
423 set_next_block_after ((union block
*)
424 (data_block
->buffer
+ written
- 1));
429 else if (header
->header
.typeflag
== XHDTYPE
430 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
431 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
432 else if (header
->header
.typeflag
== XGLTYPE
)
434 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
435 xheader_decode_global ();
444 struct posix_header
const *h
= ¤t_header
->header
;
445 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
447 if (recent_long_name
)
448 free (recent_long_name
);
452 name
= next_long_name
->buffer
+ BLOCKSIZE
;
453 recent_long_name
= next_long_name
;
454 recent_long_name_blocks
= next_long_name_blocks
;
458 /* Accept file names as specified by POSIX.1-1996
462 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
464 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
465 np
[sizeof h
->prefix
] = '\0';
469 memcpy (np
, h
->name
, sizeof h
->name
);
470 np
[sizeof h
->name
] = '\0';
472 recent_long_name
= 0;
473 recent_long_name_blocks
= 0;
475 assign_string (¤t_stat_info
.orig_file_name
, name
);
476 assign_string (¤t_stat_info
.file_name
, name
);
477 current_stat_info
.had_trailing_slash
= strip_trailing_slashes (current_stat_info
.file_name
);
479 if (recent_long_link
)
480 free (recent_long_link
);
484 name
= next_long_link
->buffer
+ BLOCKSIZE
;
485 recent_long_link
= next_long_link
;
486 recent_long_link_blocks
= next_long_link_blocks
;
490 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
491 namebuf
[sizeof h
->linkname
] = '\0';
493 recent_long_link
= 0;
494 recent_long_link_blocks
= 0;
496 assign_string (¤t_stat_info
.link_name
, name
);
498 return HEADER_SUCCESS
;
503 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
505 /* Decode things from a file HEADER block into STAT_INFO, also setting
506 *FORMAT_POINTER depending on the header block format. If
507 DO_USER_GROUP, decode the user/group information (this is useful
508 for extraction, but waste time when merely listing).
510 read_header() has already decoded the checksum and length, so we don't.
512 This routine should *not* be called twice for the same block, since
513 the two calls might use different DO_USER_GROUP values and thus
514 might end up with different uid/gid for the two calls. If anybody
515 wants the uid/gid they should decode it first, and other callers
516 should decode it without uid/gid before calling a routine,
517 e.g. print_header, that assumes decoded data. */
519 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
520 enum archive_format
*format_pointer
, int do_user_group
)
522 enum archive_format format
;
523 struct timespec atime
;
524 struct timespec ctime
;
525 struct timespec mtime
;
527 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
529 if (header
->star_header
.prefix
[130] == 0
530 && ISOCTAL (header
->star_header
.atime
[0])
531 && header
->star_header
.atime
[11] == ' '
532 && ISOCTAL (header
->star_header
.ctime
[0])
533 && header
->star_header
.ctime
[11] == ' ')
534 format
= STAR_FORMAT
;
535 else if (extended_header
.size
)
536 format
= POSIX_FORMAT
;
538 format
= USTAR_FORMAT
;
540 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
541 format
= OLDGNU_FORMAT
;
544 *format_pointer
= format
;
546 stat_info
->stat
.st_mode
= MODE_FROM_HEADER (header
->header
.mode
);
547 mtime
.tv_sec
= TIME_FROM_HEADER (header
->header
.mtime
);
549 set_stat_mtime (&stat_info
->stat
, mtime
);
550 assign_string (&stat_info
->uname
,
551 header
->header
.uname
[0] ? header
->header
.uname
: NULL
);
552 assign_string (&stat_info
->gname
,
553 header
->header
.gname
[0] ? header
->header
.gname
: NULL
);
555 if (format
== OLDGNU_FORMAT
&& incremental_option
)
557 atime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
558 ctime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
559 atime
.tv_nsec
= ctime
.tv_nsec
= 0;
561 else if (format
== STAR_FORMAT
)
563 atime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.atime
);
564 ctime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.ctime
);
565 atime
.tv_nsec
= ctime
.tv_nsec
= 0;
568 atime
= ctime
= start_time
;
570 set_stat_atime (&stat_info
->stat
, atime
);
571 set_stat_ctime (&stat_info
->stat
, ctime
);
573 if (format
== V7_FORMAT
)
575 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
576 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
577 stat_info
->stat
.st_rdev
= 0;
583 /* FIXME: Decide if this should somewhat depend on -p. */
585 if (numeric_owner_option
586 || !*header
->header
.uname
587 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
588 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
590 if (numeric_owner_option
591 || !*header
->header
.gname
592 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
593 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
596 switch (header
->header
.typeflag
)
600 stat_info
->stat
.st_rdev
=
601 makedev (MAJOR_FROM_HEADER (header
->header
.devmajor
),
602 MINOR_FROM_HEADER (header
->header
.devminor
));
606 stat_info
->stat
.st_rdev
= 0;
610 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
611 xheader_decode (stat_info
);
613 if (sparse_member_p (stat_info
))
615 sparse_fixup_header (stat_info
);
616 stat_info
->is_sparse
= true;
619 stat_info
->is_sparse
= false;
622 /* Convert buffer at WHERE0 of size DIGS from external format to
623 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
624 are of type TYPE. The buffer must represent a value in the range
625 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
626 numbers instead of the other GNU extensions. Return -1 on error,
627 diagnosing the error if TYPE is nonnull and if !SILENT. */
629 from_header (char const *where0
, size_t digs
, char const *type
,
630 uintmax_t minus_minval
, uintmax_t maxval
,
631 bool octal_only
, bool silent
)
634 char const *where
= where0
;
635 char const *lim
= where
+ digs
;
638 /* Accommodate buggy tar of unknown vintage, which outputs leading
639 NUL if the previous field overflows. */
642 /* Accommodate older tars, which output leading spaces. */
649 /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
650 _("Blanks in header where numeric %s value expected"),
654 if (!ISSPACE ((unsigned char) *where
))
660 if (ISODIGIT (*where
))
662 char const *where1
= where
;
663 uintmax_t overflow
= 0;
667 value
+= *where
++ - '0';
668 if (where
== lim
|| ! ISODIGIT (*where
))
670 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
674 /* Parse the output of older, unportable tars, which generate
675 negative values in two's complement octal. If the leading
676 nonzero digit is 1, we can't recover the original value
677 reliably; so do this only if the digit is 2 or more. This
678 catches the common case of 32-bit negative time stamps. */
679 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
681 /* Compute the negative of the input value, assuming two's
683 int digit
= (*where1
- '0') | 4;
691 if (where
== lim
|| ! ISODIGIT (*where
))
693 digit
= *where
- '0';
694 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
700 if (!overflow
&& value
<= minus_minval
)
704 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
705 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
706 (int) (where
- where1
), where1
, type
));
715 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
716 _("Archive octal value %.*s is out of %s range"),
717 (int) (where
- where1
), where1
, type
));
723 /* Suppress the following extensions. */
725 else if (*where
== '-' || *where
== '+')
727 /* Parse base-64 output produced only by tar test versions
728 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
729 Support for this will be withdrawn in future releases. */
733 static bool warned_once
;
737 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
740 negative
= *where
++ == '-';
742 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
744 if (value
<< LG_64
>> LG_64
!= value
)
746 char *string
= alloca (digs
+ 1);
747 memcpy (string
, where0
, digs
);
751 _("Archive signed base-64 string %s is out of %s range"),
752 quote (string
), type
));
755 value
= (value
<< LG_64
) | dig
;
759 else if (*where
== '\200' /* positive base-256 */
760 || *where
== '\377' /* negative base-256 */)
762 /* Parse base-256 output. A nonnegative number N is
763 represented as (256**DIGS)/2 + N; a negative number -N is
764 represented as (256**DIGS) - N, i.e. as two's complement.
765 The representation guarantees that the leading bit is
766 always on, so that we don't confuse this format with the
767 others (assuming ASCII bytes of 8 bits or more). */
768 int signbit
= *where
& (1 << (LG_256
- 2));
769 uintmax_t topbits
= (((uintmax_t) - signbit
)
770 << (CHAR_BIT
* sizeof (uintmax_t)
771 - LG_256
- (LG_256
- 2)));
772 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
775 value
= (value
<< LG_256
) + (unsigned char) *where
++;
778 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
782 _("Archive base-256 value is out of %s range"),
792 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
796 char buf
[1000]; /* Big enough to represent any header. */
797 static struct quoting_options
*o
;
801 o
= clone_quoting_options (0);
802 set_quoting_style (o
, locale_quoting_style
);
805 while (where0
!= lim
&& ! lim
[-1])
807 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
810 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
811 _("Archive contains %.*s where numeric %s value expected"),
812 (int) sizeof buf
, buf
, type
));
818 if (value
<= (negative
? minus_minval
: maxval
))
819 return negative
? -value
: value
;
823 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
824 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
825 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
826 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
827 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
829 *--value_string
= '-';
831 *--minval_string
= '-';
832 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
833 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
835 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
842 gid_from_header (const char *p
, size_t s
)
844 return from_header (p
, s
, "gid_t",
845 - (uintmax_t) TYPE_MINIMUM (gid_t
),
846 (uintmax_t) TYPE_MAXIMUM (gid_t
),
851 major_from_header (const char *p
, size_t s
)
853 return from_header (p
, s
, "major_t",
854 - (uintmax_t) TYPE_MINIMUM (major_t
),
855 (uintmax_t) TYPE_MAXIMUM (major_t
), false, false);
859 minor_from_header (const char *p
, size_t s
)
861 return from_header (p
, s
, "minor_t",
862 - (uintmax_t) TYPE_MINIMUM (minor_t
),
863 (uintmax_t) TYPE_MAXIMUM (minor_t
), false, false);
867 mode_from_header (const char *p
, size_t s
)
869 /* Do not complain about unrecognized mode bits. */
870 unsigned u
= from_header (p
, s
, "mode_t",
871 - (uintmax_t) TYPE_MINIMUM (mode_t
),
872 TYPE_MAXIMUM (uintmax_t), false, false);
873 return ((u
& TSUID
? S_ISUID
: 0)
874 | (u
& TSGID
? S_ISGID
: 0)
875 | (u
& TSVTX
? S_ISVTX
: 0)
876 | (u
& TUREAD
? S_IRUSR
: 0)
877 | (u
& TUWRITE
? S_IWUSR
: 0)
878 | (u
& TUEXEC
? S_IXUSR
: 0)
879 | (u
& TGREAD
? S_IRGRP
: 0)
880 | (u
& TGWRITE
? S_IWGRP
: 0)
881 | (u
& TGEXEC
? S_IXGRP
: 0)
882 | (u
& TOREAD
? S_IROTH
: 0)
883 | (u
& TOWRITE
? S_IWOTH
: 0)
884 | (u
& TOEXEC
? S_IXOTH
: 0));
888 off_from_header (const char *p
, size_t s
)
890 /* Negative offsets are not allowed in tar files, so invoke
891 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
892 return from_header (p
, s
, "off_t", (uintmax_t) 0,
893 (uintmax_t) TYPE_MAXIMUM (off_t
), false, false);
897 size_from_header (const char *p
, size_t s
)
899 return from_header (p
, s
, "size_t", (uintmax_t) 0,
900 (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
904 time_from_header (const char *p
, size_t s
)
906 return from_header (p
, s
, "time_t",
907 - (uintmax_t) TYPE_MINIMUM (time_t),
908 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
912 uid_from_header (const char *p
, size_t s
)
914 return from_header (p
, s
, "uid_t",
915 - (uintmax_t) TYPE_MINIMUM (uid_t
),
916 (uintmax_t) TYPE_MAXIMUM (uid_t
), false, false);
920 uintmax_from_header (const char *p
, size_t s
)
922 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
923 TYPE_MAXIMUM (uintmax_t), false, false);
927 /* Return a printable representation of T. The result points to
928 static storage that can be reused in the next call to this
929 function, to ctime, or to asctime. If FULL_TIME, then output the
930 time stamp to its full resolution; otherwise, just output it to
931 1-minute resolution. */
933 tartime (struct timespec t
, bool full_time
)
935 enum { fraclen
= sizeof ".FFFFFFFFF" - 1 };
936 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
937 INT_STRLEN_BOUND (int) + 16)
942 bool negative
= s
< 0;
945 if (negative
&& ns
!= 0)
948 ns
= 1000000000 - ns
;
951 tm
= utc_option
? gmtime (&s
) : localtime (&s
);
956 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
957 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
958 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
959 code_ns_fraction (ns
, buffer
+ strlen (buffer
));
962 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d",
963 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
964 tm
->tm_hour
, tm
->tm_min
);
968 /* The time stamp cannot be broken down, most likely because it
969 is out of range. Convert it as an integer,
970 right-adjusted in a field with the same width as the usual
971 4-year ISO time format. */
972 p
= umaxtostr (negative
? - (uintmax_t) s
: s
,
973 buffer
+ sizeof buffer
- UINTMAX_STRSIZE_BOUND
- fraclen
);
976 while ((buffer
+ sizeof buffer
- sizeof "YYYY-MM-DD HH:MM"
977 + (full_time
? sizeof ":SS.FFFFFFFFF" - 1 : 0))
981 code_ns_fraction (ns
, buffer
+ sizeof buffer
- 1 - fraclen
);
985 /* Actually print it.
987 Plain and fancy file header block logging. Non-verbose just prints
988 the name, e.g. for "tar t" or "tar x". This should just contain
989 file names, so it can be fed back into tar with xargs or the "-T"
990 option. The verbose option can give a bunch of info, one line per
991 file. I doubt anybody tries to parse its format, or if they do,
992 they shouldn't. Unix tar is pretty random here anyway. */
995 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
996 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
998 /* Width of "user/group size", with initial value chosen
999 heuristically. This grows as needed, though this may cause some
1000 stairstepping in the output. Make it too small and the output will
1001 almost always look ragged. Make it too large and the output will
1002 be spaced out too far. */
1003 static int ugswidth
= 19;
1005 /* Width of printed time stamps. It grows if longer time stamps are
1006 found (typically, those with nanosecond resolution). Like
1007 USGWIDTH, some stairstepping may occur. */
1008 static int datewidth
= sizeof "YYYY-MM-DD HH:MM" - 1;
1011 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
1014 char const *time_stamp
;
1016 char *temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
1018 /* These hold formatted ints. */
1019 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
1021 char size
[2 * UINTMAX_STRSIZE_BOUND
];
1022 /* holds formatted size or major,minor */
1023 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
1027 if (block_number_option
)
1029 char buf
[UINTMAX_STRSIZE_BOUND
];
1030 if (block_ordinal
< 0)
1031 block_ordinal
= current_block_ordinal ();
1032 block_ordinal
-= recent_long_name_blocks
;
1033 block_ordinal
-= recent_long_link_blocks
;
1034 fprintf (stdlis
, _("block %s: "),
1035 STRINGIFY_BIGINT (block_ordinal
, buf
));
1038 if (verbose_option
<= 1)
1040 /* Just the fax, mam. */
1041 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
1045 /* File type and modes. */
1048 switch (current_header
->header
.typeflag
)
1050 case GNUTYPE_VOLHDR
:
1054 case GNUTYPE_MULTIVOL
:
1062 case GNUTYPE_LONGNAME
:
1063 case GNUTYPE_LONGLINK
:
1065 ERROR ((0, 0, _("Unexpected long name header")));
1068 case GNUTYPE_SPARSE
:
1072 if (temp_name
[strlen (temp_name
) - 1] == '/')
1078 case GNUTYPE_DUMPDIR
:
1101 pax_decode_mode (st
->stat
.st_mode
, modes
+ 1);
1105 time_stamp
= tartime (get_stat_mtime (&st
->stat
), false);
1106 time_stamp_len
= strlen (time_stamp
);
1107 if (datewidth
< time_stamp_len
)
1108 datewidth
= time_stamp_len
;
1110 /* User and group names. */
1114 && current_format
!= V7_FORMAT
1115 && !numeric_owner_option
)
1119 /* Try parsing it as an unsigned integer first, and as a
1120 uid_t if that fails. This method can list positive user
1121 ids that are too large to fit in a uid_t. */
1122 uintmax_t u
= from_header (current_header
->header
.uid
,
1123 sizeof current_header
->header
.uid
, 0,
1125 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1128 user
= STRINGIFY_BIGINT (u
, uform
);
1131 sprintf (uform
, "%ld",
1132 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1139 && current_format
!= V7_FORMAT
1140 && !numeric_owner_option
)
1144 /* Try parsing it as an unsigned integer first, and as a
1145 gid_t if that fails. This method can list positive group
1146 ids that are too large to fit in a gid_t. */
1147 uintmax_t g
= from_header (current_header
->header
.gid
,
1148 sizeof current_header
->header
.gid
, 0,
1150 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1153 group
= STRINGIFY_BIGINT (g
, gform
);
1156 sprintf (gform
, "%ld",
1157 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1162 /* Format the file size or major/minor device numbers. */
1164 switch (current_header
->header
.typeflag
)
1169 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1172 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1176 /* st->stat.st_size keeps stored file size */
1177 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1181 /* Figure out padding and print the whole line. */
1183 sizelen
= strlen (size
);
1184 pad
= strlen (user
) + 1 + strlen (group
) + 1 + sizelen
;
1188 fprintf (stdlis
, "%s %s/%s %*s %-*s",
1189 modes
, user
, group
, ugswidth
- pad
+ sizelen
, size
,
1190 datewidth
, time_stamp
);
1192 fprintf (stdlis
, " %s", quotearg (temp_name
));
1194 switch (current_header
->header
.typeflag
)
1197 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1201 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1206 char type_string
[2];
1207 type_string
[0] = current_header
->header
.typeflag
;
1208 type_string
[1] = '\0';
1209 fprintf (stdlis
, _(" unknown file type %s\n"),
1210 quote (type_string
));
1216 case GNUTYPE_SPARSE
:
1222 case GNUTYPE_DUMPDIR
:
1223 putc ('\n', stdlis
);
1226 case GNUTYPE_LONGLINK
:
1227 fprintf (stdlis
, _("--Long Link--\n"));
1230 case GNUTYPE_LONGNAME
:
1231 fprintf (stdlis
, _("--Long Name--\n"));
1234 case GNUTYPE_VOLHDR
:
1235 fprintf (stdlis
, _("--Volume Header--\n"));
1238 case GNUTYPE_MULTIVOL
:
1241 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1243 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1247 fprintf (stdlis
, _("--Mangled file names--\n"));
1254 /* Print a similar line when we make a directory automatically. */
1256 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1260 if (verbose_option
> 1)
1262 /* File type and modes. */
1265 pax_decode_mode (mode
, modes
+ 1);
1267 if (block_number_option
)
1269 char buf
[UINTMAX_STRSIZE_BOUND
];
1270 fprintf (stdlis
, _("block %s: "),
1271 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1274 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ 1 + datewidth
,
1275 _("Creating directory:"), length
, quotearg (dirname
));
1279 /* Skip over SIZE bytes of data in blocks in the archive. */
1281 skip_file (off_t size
)
1285 if (multi_volume_option
)
1287 save_totsize
= size
;
1288 save_sizeleft
= size
;
1291 if (seekable_archive
)
1293 off_t nblk
= seek_archive (size
);
1296 size
-= nblk
* BLOCKSIZE
;
1297 if (multi_volume_option
) /* Argh.. */
1298 save_sizeleft
-= nblk
* BLOCKSIZE
;
1301 seekable_archive
= false;
1306 x
= find_next_block ();
1308 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1310 set_next_block_after (x
);
1312 if (multi_volume_option
)
1313 save_sizeleft
-= BLOCKSIZE
;
1317 /* Skip the current member in the archive.
1318 NOTE: Current header must be decoded before calling this function. */
1322 char save_typeflag
= current_header
->header
.typeflag
;
1323 set_next_block_after (current_header
);
1325 assign_string (&save_name
, current_stat_info
.orig_file_name
);
1327 if (current_stat_info
.is_sparse
)
1328 sparse_skip_file (¤t_stat_info
);
1329 else if (save_typeflag
!= DIRTYPE
)
1330 skip_file (current_stat_info
.stat
.st_size
);