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. */
22 /* Define to non-zero for forcing old ctime format instead of ISO format. */
30 #define max(a, b) ((a) < (b) ? (b) : (a))
32 union block
*current_header
; /* points to current archive header */
33 enum archive_format current_format
; /* recognized format */
34 union block
*recent_long_name
; /* recent long name header and contents */
35 union block
*recent_long_link
; /* likewise, for long link */
36 size_t recent_long_name_blocks
; /* number of blocks in recent_long_name */
37 size_t recent_long_link_blocks
; /* likewise, for long link */
39 static uintmax_t from_header (const char *, size_t, const char *,
40 uintmax_t, uintmax_t, bool, bool);
42 /* Base 64 digits; see Internet RFC 2045 Table 1. */
43 static char const base_64_digits
[64] =
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 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
48 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
49 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
52 /* Table of base-64 digit values indexed by unsigned chars.
53 The value is 64 for unsigned chars that are not base-64 digits. */
54 static char base64_map
[UCHAR_MAX
+ 1];
60 memset (base64_map
, 64, sizeof base64_map
);
61 for (i
= 0; i
< 64; i
++)
62 base64_map
[(int) base_64_digits
[i
]] = i
;
65 /* Main loop for reading an archive. */
67 read_and (void (*do_something
) (void))
69 enum read_header status
= HEADER_STILL_UNREAD
;
70 enum read_header prev_status
;
75 open_archive (ACCESS_READ
);
79 tar_stat_destroy (¤t_stat_info
);
80 xheader_destroy (&extended_header
);
82 status
= read_header (false);
85 case HEADER_STILL_UNREAD
:
86 case HEADER_SUCCESS_EXTENDED
:
91 /* Valid header. We should decode next field (mode) first.
92 Ensure incoming names are null terminated. */
94 if (! name_match (current_stat_info
.file_name
)
95 || (NEWER_OPTION_INITIALIZED (newer_mtime_option
)
96 /* FIXME: We get mtime now, and again later; this causes
97 duplicate diagnostics if header.mtime is bogus. */
98 && ((current_stat_info
.stat
.st_mtime
99 = TIME_FROM_HEADER (current_header
->header
.mtime
)),
101 /* FIXME: Grab fractional time stamps from
103 current_stat_info
.stat
.st_mtim
.ST_MTIM_NSEC
= 0,
105 OLDER_STAT_TIME (current_stat_info
.stat
, m
)))
106 || excluded_name (current_stat_info
.file_name
))
108 switch (current_header
->header
.typeflag
)
111 case GNUTYPE_MULTIVOL
:
116 if (show_omitted_dirs_option
)
117 WARN ((0, 0, _("%s: Omitting"),
118 quotearg_colon (current_stat_info
.file_name
)));
121 decode_header (current_header
,
122 ¤t_stat_info
, ¤t_format
, 0);
131 case HEADER_ZERO_BLOCK
:
132 if (block_number_option
)
134 char buf
[UINTMAX_STRSIZE_BOUND
];
135 fprintf (stdlis
, _("block %s: ** Block of NULs **\n"),
136 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
139 set_next_block_after (current_header
);
141 if (!ignore_zeros_option
)
143 char buf
[UINTMAX_STRSIZE_BOUND
];
145 status
= read_header (false);
146 if (status
== HEADER_ZERO_BLOCK
)
148 WARN ((0, 0, _("A lone zero block at %s"),
149 STRINGIFY_BIGINT (current_block_ordinal (), buf
)));
152 status
= prev_status
;
155 case HEADER_END_OF_FILE
:
156 if (block_number_option
)
158 char buf
[UINTMAX_STRSIZE_BOUND
];
159 fprintf (stdlis
, _("block %s: ** End of File **\n"),
160 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
165 /* If the previous header was good, tell them that we are
166 skipping bad ones. */
167 set_next_block_after (current_header
);
170 case HEADER_STILL_UNREAD
:
171 ERROR ((0, 0, _("This does not look like a tar archive")));
174 case HEADER_ZERO_BLOCK
:
176 if (block_number_option
)
178 char buf
[UINTMAX_STRSIZE_BOUND
];
179 off_t block_ordinal
= current_block_ordinal ();
180 block_ordinal
-= recent_long_name_blocks
;
181 block_ordinal
-= recent_long_link_blocks
;
182 fprintf (stdlis
, _("block %s: "),
183 STRINGIFY_BIGINT (block_ordinal
, buf
));
185 ERROR ((0, 0, _("Skipping to next header")));
188 case HEADER_END_OF_FILE
:
190 /* We are in the middle of a cascade of errors. */
193 case HEADER_SUCCESS_EXTENDED
:
200 while (!all_names_found (¤t_stat_info
));
203 names_notfound (); /* print names not found */
206 /* Print a header block, based on tar options. */
210 /* Print the header block. */
212 decode_header (current_header
, ¤t_stat_info
, ¤t_format
, 0);
214 print_header (¤t_stat_info
, -1);
216 if (incremental_option
&& current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
219 size_t written
, check
;
220 union block
*data_block
;
222 set_next_block_after (current_header
);
223 if (multi_volume_option
)
225 assign_string (&save_name
, current_stat_info
.orig_file_name
);
226 save_totsize
= current_stat_info
.stat
.st_size
;
228 for (size
= current_stat_info
.stat
.st_size
; size
> 0; size
-= written
)
230 if (multi_volume_option
)
231 save_sizeleft
= size
;
232 data_block
= find_next_block ();
235 ERROR ((0, 0, _("Unexpected EOF in archive")));
236 break; /* FIXME: What happens, then? */
238 written
= available_space_after (data_block
);
242 check
= fwrite (data_block
->buffer
, sizeof (char), written
, stdlis
);
243 set_next_block_after ((union block
*)
244 (data_block
->buffer
+ written
- 1));
245 if (check
!= written
)
247 write_error_details (current_stat_info
.file_name
, check
, written
);
248 skip_file (size
- written
);
252 if (multi_volume_option
)
253 assign_string (&save_name
, 0);
254 fputc ('\n', stdlis
);
260 if (multi_volume_option
)
261 assign_string (&save_name
, current_stat_info
.orig_file_name
);
265 if (multi_volume_option
)
266 assign_string (&save_name
, 0);
269 /* Check header checksum */
270 /* The standard BSD tar sources create the checksum by adding up the
271 bytes in the header as type char. I think the type char was unsigned
272 on the PDP-11, but it's signed on the Next and Sun. It looks like the
273 sources to BSD tar were never changed to compute the checksum
274 correctly, so both the Sun and Next add the bytes of the header as
275 signed chars. This doesn't cause a problem until you get a file with
276 a name containing characters with the high bit set. So tar_checksum
277 computes two checksums -- signed and unsigned. */
280 tar_checksum (union block
*header
, bool silent
)
283 int unsigned_sum
= 0; /* the POSIX one :-) */
284 int signed_sum
= 0; /* the Sun one :-( */
286 uintmax_t parsed_sum
;
290 for (i
= sizeof *header
; i
-- != 0;)
292 unsigned_sum
+= (unsigned char) *p
;
293 signed_sum
+= (signed char) (*p
++);
296 if (unsigned_sum
== 0)
297 return HEADER_ZERO_BLOCK
;
299 /* Adjust checksum to count the "chksum" field as blanks. */
301 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
303 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
304 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
306 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
307 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
309 parsed_sum
= from_header (header
->header
.chksum
,
310 sizeof header
->header
.chksum
, 0,
312 (uintmax_t) TYPE_MAXIMUM (int), true, silent
);
313 if (parsed_sum
== (uintmax_t) -1)
314 return HEADER_FAILURE
;
316 recorded_sum
= parsed_sum
;
318 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
319 return HEADER_FAILURE
;
321 return HEADER_SUCCESS
;
324 /* Read a block that's supposed to be a header block. Return its
325 address in "current_header", and if it is good, the file's size in
326 current_stat_info.stat.st_size.
328 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
329 block full of zeros (EOF marker).
331 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
332 GNU long name and link headers into later headers.
334 You must always set_next_block_after(current_header) to skip past
335 the header which this routine reads. */
338 read_header (bool raw_extended_headers
)
341 union block
*header_copy
;
343 union block
*data_block
;
344 size_t size
, written
;
345 union block
*next_long_name
= 0;
346 union block
*next_long_link
= 0;
347 size_t next_long_name_blocks
;
348 size_t next_long_link_blocks
;
352 enum read_header status
;
354 header
= find_next_block ();
355 current_header
= header
;
357 return HEADER_END_OF_FILE
;
359 if ((status
= tar_checksum (header
, false)) != HEADER_SUCCESS
)
362 /* Good block. Decode file size and return. */
364 if (header
->header
.typeflag
== LNKTYPE
)
365 current_stat_info
.stat
.st_size
= 0; /* links 0 size on tape */
367 current_stat_info
.stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
369 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
370 || header
->header
.typeflag
== GNUTYPE_LONGLINK
371 || header
->header
.typeflag
== XHDTYPE
372 || header
->header
.typeflag
== XGLTYPE
373 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
375 if (raw_extended_headers
)
376 return HEADER_SUCCESS_EXTENDED
;
377 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
378 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
380 size_t name_size
= current_stat_info
.stat
.st_size
;
381 size_t n
= name_size
% BLOCKSIZE
;
382 size
= name_size
+ BLOCKSIZE
;
384 size
+= BLOCKSIZE
- n
;
386 if (name_size
!= current_stat_info
.stat
.st_size
390 header_copy
= xmalloc (size
+ 1);
392 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
395 free (next_long_name
);
396 next_long_name
= header_copy
;
397 next_long_name_blocks
= size
/ BLOCKSIZE
;
402 free (next_long_link
);
403 next_long_link
= header_copy
;
404 next_long_link_blocks
= size
/ BLOCKSIZE
;
407 set_next_block_after (header
);
408 *header_copy
= *header
;
409 bp
= header_copy
->buffer
+ BLOCKSIZE
;
411 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
413 data_block
= find_next_block ();
416 ERROR ((0, 0, _("Unexpected EOF in archive")));
419 written
= available_space_after (data_block
);
423 memcpy (bp
, data_block
->buffer
, written
);
425 set_next_block_after ((union block
*)
426 (data_block
->buffer
+ written
- 1));
431 else if (header
->header
.typeflag
== XHDTYPE
432 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
433 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
434 else if (header
->header
.typeflag
== XGLTYPE
)
436 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
437 xheader_decode_global ();
446 struct posix_header
const *h
= ¤t_header
->header
;
447 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
449 if (recent_long_name
)
450 free (recent_long_name
);
454 name
= next_long_name
->buffer
+ BLOCKSIZE
;
455 recent_long_name
= next_long_name
;
456 recent_long_name_blocks
= next_long_name_blocks
;
460 /* Accept file names as specified by POSIX.1-1996
464 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
466 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
467 np
[sizeof h
->prefix
] = '\0';
471 memcpy (np
, h
->name
, sizeof h
->name
);
472 np
[sizeof h
->name
] = '\0';
474 recent_long_name
= 0;
475 recent_long_name_blocks
= 0;
477 assign_string (¤t_stat_info
.orig_file_name
, name
);
478 assign_string (¤t_stat_info
.file_name
, name
);
479 current_stat_info
.had_trailing_slash
= strip_trailing_slashes (current_stat_info
.file_name
);
481 if (recent_long_link
)
482 free (recent_long_link
);
486 name
= next_long_link
->buffer
+ BLOCKSIZE
;
487 recent_long_link
= next_long_link
;
488 recent_long_link_blocks
= next_long_link_blocks
;
492 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
493 namebuf
[sizeof h
->linkname
] = '\0';
495 recent_long_link
= 0;
496 recent_long_link_blocks
= 0;
498 assign_string (¤t_stat_info
.link_name
, name
);
500 return HEADER_SUCCESS
;
505 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
507 /* Decode things from a file HEADER block into STAT_INFO, also setting
508 *FORMAT_POINTER depending on the header block format. If
509 DO_USER_GROUP, decode the user/group information (this is useful
510 for extraction, but waste time when merely listing).
512 read_header() has already decoded the checksum and length, so we don't.
514 This routine should *not* be called twice for the same block, since
515 the two calls might use different DO_USER_GROUP values and thus
516 might end up with different uid/gid for the two calls. If anybody
517 wants the uid/gid they should decode it first, and other callers
518 should decode it without uid/gid before calling a routine,
519 e.g. print_header, that assumes decoded data. */
521 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
522 enum archive_format
*format_pointer
, int do_user_group
)
524 enum archive_format format
;
526 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
528 if (header
->star_header
.prefix
[130] == 0
529 && ISOCTAL (header
->star_header
.atime
[0])
530 && header
->star_header
.atime
[11] == ' '
531 && ISOCTAL (header
->star_header
.ctime
[0])
532 && header
->star_header
.ctime
[11] == ' ')
533 format
= STAR_FORMAT
;
534 else if (extended_header
.size
)
535 format
= POSIX_FORMAT
;
537 format
= USTAR_FORMAT
;
539 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
540 format
= OLDGNU_FORMAT
;
543 *format_pointer
= format
;
545 stat_info
->stat
.st_mode
= MODE_FROM_HEADER (header
->header
.mode
);
546 stat_info
->stat
.st_mtime
= TIME_FROM_HEADER (header
->header
.mtime
);
547 assign_string (&stat_info
->uname
,
548 header
->header
.uname
[0] ? header
->header
.uname
: NULL
);
549 assign_string (&stat_info
->gname
,
550 header
->header
.gname
[0] ? header
->header
.gname
: NULL
);
551 stat_info
->devmajor
= MAJOR_FROM_HEADER (header
->header
.devmajor
);
552 stat_info
->devminor
= MINOR_FROM_HEADER (header
->header
.devminor
);
554 stat_info
->stat
.st_atime
= start_time
;
555 stat_info
->stat
.st_ctime
= start_time
;
557 if (format
== OLDGNU_FORMAT
&& incremental_option
)
559 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
560 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
563 if (format
== V7_FORMAT
)
565 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
566 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
567 stat_info
->stat
.st_rdev
= 0;
572 if (format
== STAR_FORMAT
)
574 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->star_header
.atime
);
575 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->star_header
.ctime
);
580 /* FIXME: Decide if this should somewhat depend on -p. */
582 if (numeric_owner_option
583 || !*header
->header
.uname
584 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
585 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
587 if (numeric_owner_option
588 || !*header
->header
.gname
589 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
590 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
593 switch (header
->header
.typeflag
)
597 stat_info
->stat
.st_rdev
= makedev (stat_info
->devmajor
,
598 stat_info
->devminor
);
602 stat_info
->stat
.st_rdev
= 0;
606 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
607 xheader_decode (stat_info
);
609 if (sparse_member_p (stat_info
))
611 sparse_fixup_header (stat_info
);
612 stat_info
->is_sparse
= true;
615 stat_info
->is_sparse
= false;
618 /* Convert buffer at WHERE0 of size DIGS from external format to
619 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
620 are of type TYPE. The buffer must represent a value in the range
621 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
622 numbers instead of the other GNU extensions. Return -1 on error,
623 diagnosing the error if TYPE is nonnull and if !SILENT. */
625 from_header (char const *where0
, size_t digs
, char const *type
,
626 uintmax_t minus_minval
, uintmax_t maxval
,
627 bool octal_only
, bool silent
)
630 char const *where
= where0
;
631 char const *lim
= where
+ digs
;
634 /* Accommodate buggy tar of unknown vintage, which outputs leading
635 NUL if the previous field overflows. */
638 /* Accommodate older tars, which output leading spaces. */
645 /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
646 _("Blanks in header where numeric %s value expected"),
650 if (!ISSPACE ((unsigned char) *where
))
656 if (ISODIGIT (*where
))
658 char const *where1
= where
;
659 uintmax_t overflow
= 0;
663 value
+= *where
++ - '0';
664 if (where
== lim
|| ! ISODIGIT (*where
))
666 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
670 /* Parse the output of older, unportable tars, which generate
671 negative values in two's complement octal. If the leading
672 nonzero digit is 1, we can't recover the original value
673 reliably; so do this only if the digit is 2 or more. This
674 catches the common case of 32-bit negative time stamps. */
675 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
677 /* Compute the negative of the input value, assuming two's
679 int digit
= (*where1
- '0') | 4;
687 if (where
== lim
|| ! ISODIGIT (*where
))
689 digit
= *where
- '0';
690 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
696 if (!overflow
&& value
<= minus_minval
)
700 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
701 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
702 (int) (where
- where1
), where1
, type
));
711 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
712 _("Archive octal value %.*s is out of %s range"),
713 (int) (where
- where1
), where1
, type
));
719 /* Suppress the following extensions. */
721 else if (*where
== '-' || *where
== '+')
723 /* Parse base-64 output produced only by tar test versions
724 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
725 Support for this will be withdrawn in future releases. */
729 static bool warned_once
;
733 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
736 negative
= *where
++ == '-';
738 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
740 if (value
<< LG_64
>> LG_64
!= value
)
742 char *string
= alloca (digs
+ 1);
743 memcpy (string
, where0
, digs
);
747 _("Archive signed base-64 string %s is out of %s range"),
748 quote (string
), type
));
751 value
= (value
<< LG_64
) | dig
;
755 else if (*where
== '\200' /* positive base-256 */
756 || *where
== '\377' /* negative base-256 */)
758 /* Parse base-256 output. A nonnegative number N is
759 represented as (256**DIGS)/2 + N; a negative number -N is
760 represented as (256**DIGS) - N, i.e. as two's complement.
761 The representation guarantees that the leading bit is
762 always on, so that we don't confuse this format with the
763 others (assuming ASCII bytes of 8 bits or more). */
764 int signbit
= *where
& (1 << (LG_256
- 2));
765 uintmax_t topbits
= (((uintmax_t) - signbit
)
766 << (CHAR_BIT
* sizeof (uintmax_t)
767 - LG_256
- (LG_256
- 2)));
768 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
771 value
= (value
<< LG_256
) + (unsigned char) *where
++;
774 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
778 _("Archive base-256 value is out of %s range"),
788 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
792 char buf
[1000]; /* Big enough to represent any header. */
793 static struct quoting_options
*o
;
797 o
= clone_quoting_options (0);
798 set_quoting_style (o
, locale_quoting_style
);
801 while (where0
!= lim
&& ! lim
[-1])
803 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
806 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
807 _("Archive contains %.*s where numeric %s value expected"),
808 (int) sizeof buf
, buf
, type
));
814 if (value
<= (negative
? minus_minval
: maxval
))
815 return negative
? -value
: value
;
819 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
820 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
821 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
822 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
823 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
825 *--value_string
= '-';
827 *--minval_string
= '-';
828 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
829 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
831 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
838 gid_from_header (const char *p
, size_t s
)
840 return from_header (p
, s
, "gid_t",
841 - (uintmax_t) TYPE_MINIMUM (gid_t
),
842 (uintmax_t) TYPE_MAXIMUM (gid_t
),
847 major_from_header (const char *p
, size_t s
)
849 return from_header (p
, s
, "major_t",
850 - (uintmax_t) TYPE_MINIMUM (major_t
),
851 (uintmax_t) TYPE_MAXIMUM (major_t
), false, false);
855 minor_from_header (const char *p
, size_t s
)
857 return from_header (p
, s
, "minor_t",
858 - (uintmax_t) TYPE_MINIMUM (minor_t
),
859 (uintmax_t) TYPE_MAXIMUM (minor_t
), false, false);
863 mode_from_header (const char *p
, size_t s
)
865 /* Do not complain about unrecognized mode bits. */
866 unsigned u
= from_header (p
, s
, "mode_t",
867 - (uintmax_t) TYPE_MINIMUM (mode_t
),
868 TYPE_MAXIMUM (uintmax_t), false, false);
869 return ((u
& TSUID
? S_ISUID
: 0)
870 | (u
& TSGID
? S_ISGID
: 0)
871 | (u
& TSVTX
? S_ISVTX
: 0)
872 | (u
& TUREAD
? S_IRUSR
: 0)
873 | (u
& TUWRITE
? S_IWUSR
: 0)
874 | (u
& TUEXEC
? S_IXUSR
: 0)
875 | (u
& TGREAD
? S_IRGRP
: 0)
876 | (u
& TGWRITE
? S_IWGRP
: 0)
877 | (u
& TGEXEC
? S_IXGRP
: 0)
878 | (u
& TOREAD
? S_IROTH
: 0)
879 | (u
& TOWRITE
? S_IWOTH
: 0)
880 | (u
& TOEXEC
? S_IXOTH
: 0));
884 off_from_header (const char *p
, size_t s
)
886 /* Negative offsets are not allowed in tar files, so invoke
887 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
888 return from_header (p
, s
, "off_t", (uintmax_t) 0,
889 (uintmax_t) TYPE_MAXIMUM (off_t
), false, false);
893 size_from_header (const char *p
, size_t s
)
895 return from_header (p
, s
, "size_t", (uintmax_t) 0,
896 (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
900 time_from_header (const char *p
, size_t s
)
902 return from_header (p
, s
, "time_t",
903 - (uintmax_t) TYPE_MINIMUM (time_t),
904 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
908 uid_from_header (const char *p
, size_t s
)
910 return from_header (p
, s
, "uid_t",
911 - (uintmax_t) TYPE_MINIMUM (uid_t
),
912 (uintmax_t) TYPE_MAXIMUM (uid_t
), false, false);
916 uintmax_from_header (const char *p
, size_t s
)
918 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
919 TYPE_MAXIMUM (uintmax_t), false, false);
923 /* Return a printable representation of T. The result points to
924 static storage that can be reused in the next call to this
925 function, to ctime, or to asctime. */
929 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
930 INT_STRLEN_BOUND (int) + 16)];
937 char const *time_stamp
= p
+ 4;
938 for (p
+= 16; p
[3] != '\n'; p
++)
944 /* Use ISO 8610 format. See:
945 http://www.cl.cam.ac.uk/~mgk25/iso-time.html */
946 struct tm
*tm
= utc_option
? gmtime (&t
) : localtime (&t
);
949 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
950 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
951 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
956 /* The time stamp cannot be broken down, most likely because it
957 is out of range. Convert it as an integer,
958 right-adjusted in a field with the same width as the usual
959 19-byte 4-year ISO time format. */
960 p
= stringify_uintmax_t_backwards (t
< 0 ? - (uintmax_t) t
: (uintmax_t) t
,
961 buffer
+ sizeof buffer
);
964 while (buffer
+ sizeof buffer
- 19 - 1 < p
)
969 /* Actually print it.
971 Plain and fancy file header block logging. Non-verbose just prints
972 the name, e.g. for "tar t" or "tar x". This should just contain
973 file names, so it can be fed back into tar with xargs or the "-T"
974 option. The verbose option can give a bunch of info, one line per
975 file. I doubt anybody tries to parse its format, or if they do,
976 they shouldn't. Unix tar is pretty random here anyway. */
979 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
980 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
982 /* UGSWIDTH starts with 18, so with user and group names <= 8 chars, the
983 columns never shift during the listing. */
985 static int ugswidth
= UGSWIDTH
; /* maximum width encountered so far */
987 /* DATEWIDTH is the number of columns taken by the date and time fields. */
989 # define DATEWIDTH 19
991 # define DATEWIDTH 18
995 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
998 char const *time_stamp
;
999 char *temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
1001 /* These hold formatted ints. */
1002 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
1004 char size
[2 * UINTMAX_STRSIZE_BOUND
];
1005 /* holds formatted size or major,minor */
1006 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
1009 if (block_number_option
)
1011 char buf
[UINTMAX_STRSIZE_BOUND
];
1012 if (block_ordinal
< 0)
1013 block_ordinal
= current_block_ordinal ();
1014 block_ordinal
-= recent_long_name_blocks
;
1015 block_ordinal
-= recent_long_link_blocks
;
1016 fprintf (stdlis
, _("block %s: "),
1017 STRINGIFY_BIGINT (block_ordinal
, buf
));
1020 if (verbose_option
<= 1)
1022 /* Just the fax, mam. */
1023 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
1027 /* File type and modes. */
1030 switch (current_header
->header
.typeflag
)
1032 case GNUTYPE_VOLHDR
:
1036 case GNUTYPE_MULTIVOL
:
1044 case GNUTYPE_LONGNAME
:
1045 case GNUTYPE_LONGLINK
:
1047 ERROR ((0, 0, _("Unexpected long name header")));
1050 case GNUTYPE_SPARSE
:
1054 if (temp_name
[strlen (temp_name
) - 1] == '/')
1060 case GNUTYPE_DUMPDIR
:
1083 pax_decode_mode (st
->stat
.st_mode
, modes
+ 1);
1087 time_stamp
= tartime (st
->stat
.st_mtime
);
1089 /* User and group names. */
1093 && current_format
!= V7_FORMAT
1094 && !numeric_owner_option
)
1098 /* Try parsing it as an unsigned integer first, and as a
1099 uid_t if that fails. This method can list positive user
1100 ids that are too large to fit in a uid_t. */
1101 uintmax_t u
= from_header (current_header
->header
.uid
,
1102 sizeof current_header
->header
.uid
, 0,
1104 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1107 user
= STRINGIFY_BIGINT (u
, uform
);
1110 sprintf (uform
, "%ld",
1111 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1118 && current_format
!= V7_FORMAT
1119 && !numeric_owner_option
)
1123 /* Try parsing it as an unsigned integer first, and as a
1124 gid_t if that fails. This method can list positive group
1125 ids that are too large to fit in a gid_t. */
1126 uintmax_t g
= from_header (current_header
->header
.gid
,
1127 sizeof current_header
->header
.gid
, 0,
1129 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1132 group
= STRINGIFY_BIGINT (g
, gform
);
1135 sprintf (gform
, "%ld",
1136 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1141 /* Format the file size or major/minor device numbers. */
1143 switch (current_header
->header
.typeflag
)
1148 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1151 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1155 /* st->stat.st_size keeps stored file size */
1156 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1160 /* Figure out padding and print the whole line. */
1162 pad
= strlen (user
) + strlen (group
) + strlen (size
) + 1;
1166 fprintf (stdlis
, "%s %s/%s %*s%s %s",
1167 modes
, user
, group
, ugswidth
- pad
, "", size
, time_stamp
);
1169 fprintf (stdlis
, " %s", quotearg (temp_name
));
1171 switch (current_header
->header
.typeflag
)
1174 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1178 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1183 char type_string
[2];
1184 type_string
[0] = current_header
->header
.typeflag
;
1185 type_string
[1] = '\0';
1186 fprintf (stdlis
, _(" unknown file type %s\n"),
1187 quote (type_string
));
1193 case GNUTYPE_SPARSE
:
1199 case GNUTYPE_DUMPDIR
:
1200 putc ('\n', stdlis
);
1203 case GNUTYPE_LONGLINK
:
1204 fprintf (stdlis
, _("--Long Link--\n"));
1207 case GNUTYPE_LONGNAME
:
1208 fprintf (stdlis
, _("--Long Name--\n"));
1211 case GNUTYPE_VOLHDR
:
1212 fprintf (stdlis
, _("--Volume Header--\n"));
1215 case GNUTYPE_MULTIVOL
:
1218 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1220 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1224 fprintf (stdlis
, _("--Mangled file names--\n"));
1231 /* Print a similar line when we make a directory automatically. */
1233 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1237 if (verbose_option
> 1)
1239 /* File type and modes. */
1242 pax_decode_mode (mode
, modes
+ 1);
1244 if (block_number_option
)
1246 char buf
[UINTMAX_STRSIZE_BOUND
];
1247 fprintf (stdlis
, _("block %s: "),
1248 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1251 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ DATEWIDTH
,
1252 _("Creating directory:"), length
, quotearg (dirname
));
1256 /* Skip over SIZE bytes of data in blocks in the archive. */
1258 skip_file (off_t size
)
1262 if (multi_volume_option
)
1264 save_totsize
= size
;
1265 save_sizeleft
= size
;
1268 if (seekable_archive
)
1270 off_t nblk
= seek_archive (size
);
1273 size
-= nblk
* BLOCKSIZE
;
1274 if (multi_volume_option
) /* Argh.. */
1275 save_sizeleft
-= nblk
* BLOCKSIZE
;
1278 seekable_archive
= false;
1283 x
= find_next_block ();
1285 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1287 set_next_block_after (x
);
1289 if (multi_volume_option
)
1290 save_sizeleft
-= BLOCKSIZE
;
1294 /* Skip the current member in the archive.
1295 NOTE: Current header must be decoded before calling this function. */
1299 char save_typeflag
= current_header
->header
.typeflag
;
1300 set_next_block_after (current_header
);
1302 assign_string (&save_name
, current_stat_info
.orig_file_name
);
1304 if (current_stat_info
.is_sparse
)
1305 sparse_skip_file (¤t_stat_info
);
1306 else if (save_typeflag
!= DIRTYPE
)
1307 skip_file (current_stat_info
.stat
.st_size
);