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 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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);
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
.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
.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), 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
)
374 if (raw_extended_headers
)
375 return HEADER_SUCCESS_EXTENDED
;
376 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
377 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
379 size_t name_size
= current_stat_info
.stat
.st_size
;
380 size_t n
= name_size
% BLOCKSIZE
;
381 size
= name_size
+ BLOCKSIZE
;
383 size
+= BLOCKSIZE
- n
;
385 if (name_size
!= current_stat_info
.stat
.st_size
389 header_copy
= xmalloc (size
+ 1);
391 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
394 free (next_long_name
);
395 next_long_name
= header_copy
;
396 next_long_name_blocks
= size
/ BLOCKSIZE
;
401 free (next_long_link
);
402 next_long_link
= header_copy
;
403 next_long_link_blocks
= size
/ BLOCKSIZE
;
406 set_next_block_after (header
);
407 *header_copy
= *header
;
408 bp
= header_copy
->buffer
+ BLOCKSIZE
;
410 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
412 data_block
= find_next_block ();
415 ERROR ((0, 0, _("Unexpected EOF in archive")));
418 written
= available_space_after (data_block
);
422 memcpy (bp
, data_block
->buffer
, written
);
424 set_next_block_after ((union block
*)
425 (data_block
->buffer
+ written
- 1));
430 else if (header
->header
.typeflag
== 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 /* Prevent later references to current_header from
470 mistakenly treating this as an old GNU header.
471 This assignment invalidates h->prefix. */
472 current_header
->oldgnu_header
.isextended
= 0;
474 memcpy (np
, h
->name
, sizeof h
->name
);
475 np
[sizeof h
->name
] = '\0';
477 recent_long_name
= 0;
478 recent_long_name_blocks
= 0;
480 assign_string (¤t_stat_info
.orig_file_name
, name
);
481 assign_string (¤t_stat_info
.file_name
, name
);
482 current_stat_info
.had_trailing_slash
= strip_trailing_slashes (current_stat_info
.file_name
);
484 if (recent_long_link
)
485 free (recent_long_link
);
489 name
= next_long_link
->buffer
+ BLOCKSIZE
;
490 recent_long_link
= next_long_link
;
491 recent_long_link_blocks
= next_long_link_blocks
;
495 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
496 namebuf
[sizeof h
->linkname
] = '\0';
498 recent_long_link
= 0;
499 recent_long_link_blocks
= 0;
501 assign_string (¤t_stat_info
.link_name
, name
);
503 return HEADER_SUCCESS
;
508 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
510 /* Decode things from a file HEADER block into STAT_INFO, also setting
511 *FORMAT_POINTER depending on the header block format. If
512 DO_USER_GROUP, decode the user/group information (this is useful
513 for extraction, but waste time when merely listing).
515 read_header() has already decoded the checksum and length, so we don't.
517 This routine should *not* be called twice for the same block, since
518 the two calls might use different DO_USER_GROUP values and thus
519 might end up with different uid/gid for the two calls. If anybody
520 wants the uid/gid they should decode it first, and other callers
521 should decode it without uid/gid before calling a routine,
522 e.g. print_header, that assumes decoded data. */
524 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
525 enum archive_format
*format_pointer
, int do_user_group
)
527 enum archive_format format
;
529 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
531 if (header
->star_header
.prefix
[130] == 0
532 && ISOCTAL (header
->star_header
.atime
[0])
533 && header
->star_header
.atime
[11] == ' '
534 && ISOCTAL (header
->star_header
.ctime
[0])
535 && header
->star_header
.ctime
[11] == ' ')
536 format
= STAR_FORMAT
;
537 else if (extended_header
.size
)
538 format
= POSIX_FORMAT
;
540 format
= USTAR_FORMAT
;
542 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
543 format
= OLDGNU_FORMAT
;
546 *format_pointer
= format
;
548 stat_info
->stat
.st_mode
= MODE_FROM_HEADER (header
->header
.mode
);
549 stat_info
->stat
.st_mtime
= TIME_FROM_HEADER (header
->header
.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
);
554 stat_info
->devmajor
= MAJOR_FROM_HEADER (header
->header
.devmajor
);
555 stat_info
->devminor
= MINOR_FROM_HEADER (header
->header
.devminor
);
557 stat_info
->stat
.st_atime
= start_time
;
558 stat_info
->stat
.st_ctime
= start_time
;
560 if (format
== OLDGNU_FORMAT
&& incremental_option
)
562 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
563 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
566 if (format
== V7_FORMAT
)
568 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
569 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
570 stat_info
->stat
.st_rdev
= 0;
575 if (format
== STAR_FORMAT
)
577 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->star_header
.atime
);
578 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->star_header
.ctime
);
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
= makedev (stat_info
->devmajor
,
601 stat_info
->devminor
);
605 stat_info
->stat
.st_rdev
= 0;
609 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
610 xheader_decode (stat_info
);
612 if (sparse_member_p (stat_info
))
614 sparse_fixup_header (stat_info
);
615 stat_info
->is_sparse
= true;
618 stat_info
->is_sparse
= false;
621 /* Convert buffer at WHERE0 of size DIGS from external format to
622 uintmax_t. The data is of type TYPE. The buffer must represent a
623 value in the range -MINUS_MINVAL through MAXVAL. DIGS must be
624 positive. SILENT=true inhibits printing diagnostic messages.
625 Return -1 on error, diagnosing the error if TYPE is
628 from_header (char const *where0
, size_t digs
, char const *type
,
629 uintmax_t minus_minval
, uintmax_t maxval
, bool silent
)
632 char const *where
= where0
;
633 char const *lim
= where
+ digs
;
636 /* Accommodate buggy tar of unknown vintage, which outputs leading
637 NUL if the previous field overflows. */
640 /* Accommodate older tars, which output leading spaces. */
647 /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
648 _("Blanks in header where numeric %s value expected"),
652 if (!ISSPACE ((unsigned char) *where
))
658 if (ISODIGIT (*where
))
660 char const *where1
= where
;
661 uintmax_t overflow
= 0;
665 value
+= *where
++ - '0';
666 if (where
== lim
|| ! ISODIGIT (*where
))
668 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
672 /* Parse the output of older, unportable tars, which generate
673 negative values in two's complement octal. If the leading
674 nonzero digit is 1, we can't recover the original value
675 reliably; so do this only if the digit is 2 or more. This
676 catches the common case of 32-bit negative time stamps. */
677 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
679 /* Compute the negative of the input value, assuming two's
681 int digit
= (*where1
- '0') | 4;
689 if (where
== lim
|| ! ISODIGIT (*where
))
691 digit
= *where
- '0';
692 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
698 if (!overflow
&& value
<= minus_minval
)
702 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
703 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
704 (int) (where
- where1
), where1
, type
));
713 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
714 _("Archive octal value %.*s is out of %s range"),
715 (int) (where
- where1
), where1
, type
));
719 else if (*where
== '-' || *where
== '+')
721 /* Parse base-64 output produced only by tar test versions
722 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
723 Support for this will be withdrawn in future releases. */
725 static int warned_once
;
731 _("Archive contains obsolescent base-64 headers")));
733 negative
= *where
++ == '-';
735 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
737 if (value
<< LG_64
>> LG_64
!= value
)
739 char *string
= alloca (digs
+ 1);
740 memcpy (string
, where0
, digs
);
744 _("Archive signed base-64 string %s is out of %s range"),
745 quote (string
), type
));
748 value
= (value
<< LG_64
) | dig
;
752 else if (*where
== '\200' /* positive base-256 */
753 || *where
== '\377' /* negative base-256 */)
755 /* Parse base-256 output. A nonnegative number N is
756 represented as (256**DIGS)/2 + N; a negative number -N is
757 represented as (256**DIGS) - N, i.e. as two's complement.
758 The representation guarantees that the leading bit is
759 always on, so that we don't confuse this format with the
760 others (assuming ASCII bytes of 8 bits or more). */
761 int signbit
= *where
& (1 << (LG_256
- 2));
762 uintmax_t topbits
= (((uintmax_t) - signbit
)
763 << (CHAR_BIT
* sizeof (uintmax_t)
764 - LG_256
- (LG_256
- 2)));
765 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
768 value
= (value
<< LG_256
) + (unsigned char) *where
++;
771 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
775 _("Archive base-256 value is out of %s range"),
785 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
789 char buf
[1000]; /* Big enough to represent any header. */
790 static struct quoting_options
*o
;
794 o
= clone_quoting_options (0);
795 set_quoting_style (o
, locale_quoting_style
);
798 while (where0
!= lim
&& ! lim
[-1])
800 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
803 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
804 _("Archive contains %.*s where numeric %s value expected"),
805 (int) sizeof buf
, buf
, type
));
811 if (value
<= (negative
? minus_minval
: maxval
))
812 return negative
? -value
: value
;
816 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
817 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
818 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
819 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
820 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
822 *--value_string
= '-';
824 *--minval_string
= '-';
825 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
826 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
828 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
835 gid_from_header (const char *p
, size_t s
)
837 return from_header (p
, s
, "gid_t",
838 - (uintmax_t) TYPE_MINIMUM (gid_t
),
839 (uintmax_t) TYPE_MAXIMUM (gid_t
),
844 major_from_header (const char *p
, size_t s
)
846 return from_header (p
, s
, "major_t",
847 - (uintmax_t) TYPE_MINIMUM (major_t
),
848 (uintmax_t) TYPE_MAXIMUM (major_t
), false);
852 minor_from_header (const char *p
, size_t s
)
854 return from_header (p
, s
, "minor_t",
855 - (uintmax_t) TYPE_MINIMUM (minor_t
),
856 (uintmax_t) TYPE_MAXIMUM (minor_t
), false);
860 mode_from_header (const char *p
, size_t s
)
862 /* Do not complain about unrecognized mode bits. */
863 unsigned u
= from_header (p
, s
, "mode_t",
864 - (uintmax_t) TYPE_MINIMUM (mode_t
),
865 TYPE_MAXIMUM (uintmax_t), false);
866 return ((u
& TSUID
? S_ISUID
: 0)
867 | (u
& TSGID
? S_ISGID
: 0)
868 | (u
& TSVTX
? S_ISVTX
: 0)
869 | (u
& TUREAD
? S_IRUSR
: 0)
870 | (u
& TUWRITE
? S_IWUSR
: 0)
871 | (u
& TUEXEC
? S_IXUSR
: 0)
872 | (u
& TGREAD
? S_IRGRP
: 0)
873 | (u
& TGWRITE
? S_IWGRP
: 0)
874 | (u
& TGEXEC
? S_IXGRP
: 0)
875 | (u
& TOREAD
? S_IROTH
: 0)
876 | (u
& TOWRITE
? S_IWOTH
: 0)
877 | (u
& TOEXEC
? S_IXOTH
: 0));
881 off_from_header (const char *p
, size_t s
)
883 /* Negative offsets are not allowed in tar files, so invoke
884 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
885 return from_header (p
, s
, "off_t", (uintmax_t) 0,
886 (uintmax_t) TYPE_MAXIMUM (off_t
), false);
890 size_from_header (const char *p
, size_t s
)
892 return from_header (p
, s
, "size_t", (uintmax_t) 0,
893 (uintmax_t) TYPE_MAXIMUM (size_t), false);
897 time_from_header (const char *p
, size_t s
)
899 return from_header (p
, s
, "time_t",
900 - (uintmax_t) TYPE_MINIMUM (time_t),
901 (uintmax_t) TYPE_MAXIMUM (time_t), false);
905 uid_from_header (const char *p
, size_t s
)
907 return from_header (p
, s
, "uid_t",
908 - (uintmax_t) TYPE_MINIMUM (uid_t
),
909 (uintmax_t) TYPE_MAXIMUM (uid_t
), false);
913 uintmax_from_header (const char *p
, size_t s
)
915 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
916 TYPE_MAXIMUM (uintmax_t), false);
920 /* Format O as a null-terminated decimal string into BUF _backwards_;
921 return pointer to start of result. */
923 stringify_uintmax_t_backwards (uintmax_t o
, char *buf
)
927 *--buf
= '0' + (int) (o
% 10);
928 while ((o
/= 10) != 0);
932 /* Return a printable representation of T. The result points to
933 static storage that can be reused in the next call to this
934 function, to ctime, or to asctime. */
938 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
939 INT_STRLEN_BOUND (int) + 16)];
946 char const *time_stamp
= p
+ 4;
947 for (p
+= 16; p
[3] != '\n'; p
++)
953 /* Use ISO 8610 format. See:
954 http://www.cl.cam.ac.uk/~mgk25/iso-time.html */
955 struct tm
*tm
= utc_option
? gmtime (&t
) : localtime (&t
);
958 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
959 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
960 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
965 /* The time stamp cannot be broken down, most likely because it
966 is out of range. Convert it as an integer,
967 right-adjusted in a field with the same width as the usual
968 19-byte 4-year ISO time format. */
969 p
= stringify_uintmax_t_backwards (t
< 0 ? - (uintmax_t) t
: (uintmax_t) t
,
970 buffer
+ sizeof buffer
);
973 while (buffer
+ sizeof buffer
- 19 - 1 < p
)
978 /* Actually print it.
980 Plain and fancy file header block logging. Non-verbose just prints
981 the name, e.g. for "tar t" or "tar x". This should just contain
982 file names, so it can be fed back into tar with xargs or the "-T"
983 option. The verbose option can give a bunch of info, one line per
984 file. I doubt anybody tries to parse its format, or if they do,
985 they shouldn't. Unix tar is pretty random here anyway. */
988 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
989 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
991 /* UGSWIDTH starts with 18, so with user and group names <= 8 chars, the
992 columns never shift during the listing. */
994 static int ugswidth
= UGSWIDTH
; /* maximum width encountered so far */
996 /* DATEWIDTH is the number of columns taken by the date and time fields. */
998 # define DATEWIDTH 19
1000 # define DATEWIDTH 18
1004 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
1007 char const *time_stamp
;
1008 char *temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
1010 /* These hold formatted ints. */
1011 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
1013 char size
[2 * UINTMAX_STRSIZE_BOUND
];
1014 /* holds formatted size or major,minor */
1015 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
1018 if (block_number_option
)
1020 char buf
[UINTMAX_STRSIZE_BOUND
];
1021 if (block_ordinal
< 0)
1022 block_ordinal
= current_block_ordinal ();
1023 block_ordinal
-= recent_long_name_blocks
;
1024 block_ordinal
-= recent_long_link_blocks
;
1025 fprintf (stdlis
, _("block %s: "),
1026 STRINGIFY_BIGINT (block_ordinal
, buf
));
1029 if (verbose_option
<= 1)
1031 /* Just the fax, mam. */
1032 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
1036 /* File type and modes. */
1039 switch (current_header
->header
.typeflag
)
1041 case GNUTYPE_VOLHDR
:
1045 case GNUTYPE_MULTIVOL
:
1053 case GNUTYPE_LONGNAME
:
1054 case GNUTYPE_LONGLINK
:
1056 ERROR ((0, 0, _("Unexpected long name header")));
1059 case GNUTYPE_SPARSE
:
1063 if (temp_name
[strlen (temp_name
) - 1] == '/')
1069 case GNUTYPE_DUMPDIR
:
1092 decode_mode (st
->stat
.st_mode
, modes
+ 1);
1096 time_stamp
= tartime (st
->stat
.st_mtime
);
1098 /* User and group names. */
1100 if (st
->uname
&& current_format
!= V7_FORMAT
1101 && !numeric_owner_option
)
1105 /* Try parsing it as an unsigned integer first, and as a
1106 uid_t if that fails. This method can list positive user
1107 ids that are too large to fit in a uid_t. */
1108 uintmax_t u
= from_header (current_header
->header
.uid
,
1109 sizeof current_header
->header
.uid
, 0,
1111 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1114 user
= STRINGIFY_BIGINT (u
, uform
);
1117 sprintf (uform
, "%ld",
1118 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1123 if (st
->gname
&& current_format
!= V7_FORMAT
1124 && !numeric_owner_option
)
1128 /* Try parsing it as an unsigned integer first, and as a
1129 gid_t if that fails. This method can list positive group
1130 ids that are too large to fit in a gid_t. */
1131 uintmax_t g
= from_header (current_header
->header
.gid
,
1132 sizeof current_header
->header
.gid
, 0,
1134 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1137 group
= STRINGIFY_BIGINT (g
, gform
);
1140 sprintf (gform
, "%ld",
1141 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1146 /* Format the file size or major/minor device numbers. */
1148 switch (current_header
->header
.typeflag
)
1153 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1156 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1160 /* st->stat.st_size keeps stored file size */
1161 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1165 /* Figure out padding and print the whole line. */
1167 pad
= strlen (user
) + strlen (group
) + strlen (size
) + 1;
1171 fprintf (stdlis
, "%s %s/%s %*s%s %s",
1172 modes
, user
, group
, ugswidth
- pad
, "", size
, time_stamp
);
1174 fprintf (stdlis
, " %s", quotearg (temp_name
));
1176 switch (current_header
->header
.typeflag
)
1179 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1183 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1188 char type_string
[2];
1189 type_string
[0] = current_header
->header
.typeflag
;
1190 type_string
[1] = '\0';
1191 fprintf (stdlis
, _(" unknown file type %s\n"),
1192 quote (type_string
));
1198 case GNUTYPE_SPARSE
:
1204 case GNUTYPE_DUMPDIR
:
1205 putc ('\n', stdlis
);
1208 case GNUTYPE_LONGLINK
:
1209 fprintf (stdlis
, _("--Long Link--\n"));
1212 case GNUTYPE_LONGNAME
:
1213 fprintf (stdlis
, _("--Long Name--\n"));
1216 case GNUTYPE_VOLHDR
:
1217 fprintf (stdlis
, _("--Volume Header--\n"));
1220 case GNUTYPE_MULTIVOL
:
1223 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1225 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1229 fprintf (stdlis
, _("--Mangled file names--\n"));
1236 /* Print a similar line when we make a directory automatically. */
1238 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1242 if (verbose_option
> 1)
1244 /* File type and modes. */
1247 decode_mode (mode
, modes
+ 1);
1249 if (block_number_option
)
1251 char buf
[UINTMAX_STRSIZE_BOUND
];
1252 fprintf (stdlis
, _("block %s: "),
1253 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1256 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ DATEWIDTH
,
1257 _("Creating directory:"), length
, quotearg (dirname
));
1261 /* Skip over SIZE bytes of data in blocks in the archive. */
1263 skip_file (off_t size
)
1267 if (multi_volume_option
)
1269 save_totsize
= size
;
1270 save_sizeleft
= size
;
1273 if (seekable_archive
)
1275 off_t nblk
= seek_archive (size
);
1278 size
-= nblk
* BLOCKSIZE
;
1279 if (multi_volume_option
) /* Argh.. */
1280 save_sizeleft
-= nblk
* BLOCKSIZE
;
1283 seekable_archive
= false;
1288 x
= find_next_block ();
1290 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1292 set_next_block_after (x
);
1294 if (multi_volume_option
)
1295 save_sizeleft
-= BLOCKSIZE
;
1299 /* Skip the current member in the archive.
1300 NOTE: Current header must be decoded before calling this function. */
1304 char save_typeflag
= current_header
->header
.typeflag
;
1305 set_next_block_after (current_header
);
1307 assign_string (&save_name
, current_stat_info
.file_name
);
1309 if (current_stat_info
.is_sparse
)
1310 sparse_skip_file (¤t_stat_info
);
1311 else if (save_typeflag
!= DIRTYPE
)
1312 skip_file (current_stat_info
.stat
.st_size
);