1 /* List a tar archive, with support routines for reading a tar archive.
3 Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,
4 2001, 2003, 2004, 2005, 2006 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 current_stat_info
.mtime
= mtime
,
103 OLDER_TAR_STAT_TIME (current_stat_info
, 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 off_t block_ordinal
= current_block_ordinal ();
209 /* Print the header block. */
211 decode_header (current_header
, ¤t_stat_info
, ¤t_format
, 0);
213 print_header (¤t_stat_info
, block_ordinal
);
215 if (incremental_option
)
217 if (verbose_option
> 2)
219 if (is_dumpdir (¤t_stat_info
))
220 list_dumpdir (current_stat_info
.dumpdir
,
221 dumpdir_size (current_stat_info
.dumpdir
));
228 /* Check header checksum */
229 /* The standard BSD tar sources create the checksum by adding up the
230 bytes in the header as type char. I think the type char was unsigned
231 on the PDP-11, but it's signed on the Next and Sun. It looks like the
232 sources to BSD tar were never changed to compute the checksum
233 correctly, so both the Sun and Next add the bytes of the header as
234 signed chars. This doesn't cause a problem until you get a file with
235 a name containing characters with the high bit set. So tar_checksum
236 computes two checksums -- signed and unsigned. */
239 tar_checksum (union block
*header
, bool silent
)
242 int unsigned_sum
= 0; /* the POSIX one :-) */
243 int signed_sum
= 0; /* the Sun one :-( */
245 uintmax_t parsed_sum
;
249 for (i
= sizeof *header
; i
-- != 0;)
251 unsigned_sum
+= (unsigned char) *p
;
252 signed_sum
+= (signed char) (*p
++);
255 if (unsigned_sum
== 0)
256 return HEADER_ZERO_BLOCK
;
258 /* Adjust checksum to count the "chksum" field as blanks. */
260 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
262 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
263 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
265 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
266 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
268 parsed_sum
= from_header (header
->header
.chksum
,
269 sizeof header
->header
.chksum
, 0,
271 (uintmax_t) TYPE_MAXIMUM (int), true, silent
);
272 if (parsed_sum
== (uintmax_t) -1)
273 return HEADER_FAILURE
;
275 recorded_sum
= parsed_sum
;
277 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
278 return HEADER_FAILURE
;
280 return HEADER_SUCCESS
;
283 /* Read a block that's supposed to be a header block. Return its
284 address in "current_header", and if it is good, the file's size in
285 current_stat_info.stat.st_size.
287 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
288 block full of zeros (EOF marker).
290 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
291 GNU long name and link headers into later headers.
293 You must always set_next_block_after(current_header) to skip past
294 the header which this routine reads. */
297 read_header (bool raw_extended_headers
)
300 union block
*header_copy
;
302 union block
*data_block
;
303 size_t size
, written
;
304 union block
*next_long_name
= 0;
305 union block
*next_long_link
= 0;
306 size_t next_long_name_blocks
;
307 size_t next_long_link_blocks
;
311 enum read_header status
;
313 header
= find_next_block ();
314 current_header
= header
;
316 return HEADER_END_OF_FILE
;
318 if ((status
= tar_checksum (header
, false)) != HEADER_SUCCESS
)
321 /* Good block. Decode file size and return. */
323 if (header
->header
.typeflag
== LNKTYPE
)
324 current_stat_info
.stat
.st_size
= 0; /* links 0 size on tape */
326 current_stat_info
.stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
328 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
329 || header
->header
.typeflag
== GNUTYPE_LONGLINK
330 || header
->header
.typeflag
== XHDTYPE
331 || header
->header
.typeflag
== XGLTYPE
332 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
334 if (raw_extended_headers
)
335 return HEADER_SUCCESS_EXTENDED
;
336 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
337 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
339 size_t name_size
= current_stat_info
.stat
.st_size
;
340 size_t n
= name_size
% BLOCKSIZE
;
341 size
= name_size
+ BLOCKSIZE
;
343 size
+= BLOCKSIZE
- n
;
345 if (name_size
!= current_stat_info
.stat
.st_size
349 header_copy
= xmalloc (size
+ 1);
351 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
354 free (next_long_name
);
355 next_long_name
= header_copy
;
356 next_long_name_blocks
= size
/ BLOCKSIZE
;
361 free (next_long_link
);
362 next_long_link
= header_copy
;
363 next_long_link_blocks
= size
/ BLOCKSIZE
;
366 set_next_block_after (header
);
367 *header_copy
= *header
;
368 bp
= header_copy
->buffer
+ BLOCKSIZE
;
370 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
372 data_block
= find_next_block ();
375 ERROR ((0, 0, _("Unexpected EOF in archive")));
378 written
= available_space_after (data_block
);
382 memcpy (bp
, data_block
->buffer
, written
);
384 set_next_block_after ((union block
*)
385 (data_block
->buffer
+ written
- 1));
390 else if (header
->header
.typeflag
== XHDTYPE
391 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
392 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
393 else if (header
->header
.typeflag
== XGLTYPE
)
395 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
396 xheader_decode_global ();
397 xheader_destroy (&extended_header
);
406 struct posix_header
const *h
= ¤t_header
->header
;
407 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
409 if (recent_long_name
)
410 free (recent_long_name
);
414 name
= next_long_name
->buffer
+ BLOCKSIZE
;
415 recent_long_name
= next_long_name
;
416 recent_long_name_blocks
= next_long_name_blocks
;
420 /* Accept file names as specified by POSIX.1-1996
424 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
426 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
427 np
[sizeof h
->prefix
] = '\0';
431 memcpy (np
, h
->name
, sizeof h
->name
);
432 np
[sizeof h
->name
] = '\0';
434 recent_long_name
= 0;
435 recent_long_name_blocks
= 0;
437 assign_string (¤t_stat_info
.orig_file_name
, name
);
438 assign_string (¤t_stat_info
.file_name
, name
);
439 current_stat_info
.had_trailing_slash
= strip_trailing_slashes (current_stat_info
.file_name
);
441 if (recent_long_link
)
442 free (recent_long_link
);
446 name
= next_long_link
->buffer
+ BLOCKSIZE
;
447 recent_long_link
= next_long_link
;
448 recent_long_link_blocks
= next_long_link_blocks
;
452 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
453 namebuf
[sizeof h
->linkname
] = '\0';
455 recent_long_link
= 0;
456 recent_long_link_blocks
= 0;
458 assign_string (¤t_stat_info
.link_name
, name
);
460 return HEADER_SUCCESS
;
465 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
467 /* Decode things from a file HEADER block into STAT_INFO, also setting
468 *FORMAT_POINTER depending on the header block format. If
469 DO_USER_GROUP, decode the user/group information (this is useful
470 for extraction, but waste time when merely listing).
472 read_header() has already decoded the checksum and length, so we don't.
474 This routine should *not* be called twice for the same block, since
475 the two calls might use different DO_USER_GROUP values and thus
476 might end up with different uid/gid for the two calls. If anybody
477 wants the uid/gid they should decode it first, and other callers
478 should decode it without uid/gid before calling a routine,
479 e.g. print_header, that assumes decoded data. */
481 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
482 enum archive_format
*format_pointer
, int do_user_group
)
484 enum archive_format format
;
486 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
488 if (header
->star_header
.prefix
[130] == 0
489 && ISOCTAL (header
->star_header
.atime
[0])
490 && header
->star_header
.atime
[11] == ' '
491 && ISOCTAL (header
->star_header
.ctime
[0])
492 && header
->star_header
.ctime
[11] == ' ')
493 format
= STAR_FORMAT
;
494 else if (extended_header
.size
)
495 format
= POSIX_FORMAT
;
497 format
= USTAR_FORMAT
;
499 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
500 format
= OLDGNU_FORMAT
;
503 *format_pointer
= format
;
505 stat_info
->stat
.st_mode
= MODE_FROM_HEADER (header
->header
.mode
);
506 stat_info
->mtime
.tv_sec
= TIME_FROM_HEADER (header
->header
.mtime
);
507 stat_info
->mtime
.tv_nsec
= 0;
508 assign_string (&stat_info
->uname
,
509 header
->header
.uname
[0] ? header
->header
.uname
: NULL
);
510 assign_string (&stat_info
->gname
,
511 header
->header
.gname
[0] ? header
->header
.gname
: NULL
);
513 if (format
== OLDGNU_FORMAT
&& incremental_option
)
515 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
516 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
517 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
519 else if (format
== STAR_FORMAT
)
521 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.atime
);
522 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.ctime
);
523 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
526 stat_info
->atime
= stat_info
->ctime
= start_time
;
528 if (format
== V7_FORMAT
)
530 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
531 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
532 stat_info
->stat
.st_rdev
= 0;
538 /* FIXME: Decide if this should somewhat depend on -p. */
540 if (numeric_owner_option
541 || !*header
->header
.uname
542 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
543 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
545 if (numeric_owner_option
546 || !*header
->header
.gname
547 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
548 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
551 switch (header
->header
.typeflag
)
555 stat_info
->stat
.st_rdev
=
556 makedev (MAJOR_FROM_HEADER (header
->header
.devmajor
),
557 MINOR_FROM_HEADER (header
->header
.devminor
));
561 stat_info
->stat
.st_rdev
= 0;
565 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
566 xheader_decode (stat_info
);
568 if (sparse_member_p (stat_info
))
570 sparse_fixup_header (stat_info
);
571 stat_info
->is_sparse
= true;
575 stat_info
->is_sparse
= false;
576 if (((current_format
== GNU_FORMAT
577 || current_format
== OLDGNU_FORMAT
)
578 && current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
579 || stat_info
->dumpdir
)
580 stat_info
->is_dumpdir
= true;
584 /* Convert buffer at WHERE0 of size DIGS from external format to
585 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
586 are of type TYPE. The buffer must represent a value in the range
587 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
588 numbers instead of the other GNU extensions. Return -1 on error,
589 diagnosing the error if TYPE is nonnull and if !SILENT. */
591 from_header (char const *where0
, size_t digs
, char const *type
,
592 uintmax_t minus_minval
, uintmax_t maxval
,
593 bool octal_only
, bool silent
)
596 char const *where
= where0
;
597 char const *lim
= where
+ digs
;
600 /* Accommodate buggy tar of unknown vintage, which outputs leading
601 NUL if the previous field overflows. */
604 /* Accommodate older tars, which output leading spaces. */
611 /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
612 _("Blanks in header where numeric %s value expected"),
616 if (!ISSPACE ((unsigned char) *where
))
622 if (ISODIGIT (*where
))
624 char const *where1
= where
;
625 uintmax_t overflow
= 0;
629 value
+= *where
++ - '0';
630 if (where
== lim
|| ! ISODIGIT (*where
))
632 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
636 /* Parse the output of older, unportable tars, which generate
637 negative values in two's complement octal. If the leading
638 nonzero digit is 1, we can't recover the original value
639 reliably; so do this only if the digit is 2 or more. This
640 catches the common case of 32-bit negative time stamps. */
641 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
643 /* Compute the negative of the input value, assuming two's
645 int digit
= (*where1
- '0') | 4;
653 if (where
== lim
|| ! ISODIGIT (*where
))
655 digit
= *where
- '0';
656 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
662 if (!overflow
&& value
<= minus_minval
)
666 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
667 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
668 (int) (where
- where1
), where1
, type
));
677 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
678 _("Archive octal value %.*s is out of %s range"),
679 (int) (where
- where1
), where1
, type
));
685 /* Suppress the following extensions. */
687 else if (*where
== '-' || *where
== '+')
689 /* Parse base-64 output produced only by tar test versions
690 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
691 Support for this will be withdrawn in future releases. */
695 static bool warned_once
;
699 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
702 negative
= *where
++ == '-';
704 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
706 if (value
<< LG_64
>> LG_64
!= value
)
708 char *string
= alloca (digs
+ 1);
709 memcpy (string
, where0
, digs
);
713 _("Archive signed base-64 string %s is out of %s range"),
714 quote (string
), type
));
717 value
= (value
<< LG_64
) | dig
;
721 else if (*where
== '\200' /* positive base-256 */
722 || *where
== '\377' /* negative base-256 */)
724 /* Parse base-256 output. A nonnegative number N is
725 represented as (256**DIGS)/2 + N; a negative number -N is
726 represented as (256**DIGS) - N, i.e. as two's complement.
727 The representation guarantees that the leading bit is
728 always on, so that we don't confuse this format with the
729 others (assuming ASCII bytes of 8 bits or more). */
730 int signbit
= *where
& (1 << (LG_256
- 2));
731 uintmax_t topbits
= (((uintmax_t) - signbit
)
732 << (CHAR_BIT
* sizeof (uintmax_t)
733 - LG_256
- (LG_256
- 2)));
734 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
737 value
= (value
<< LG_256
) + (unsigned char) *where
++;
740 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
744 _("Archive base-256 value is out of %s range"),
754 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
758 char buf
[1000]; /* Big enough to represent any header. */
759 static struct quoting_options
*o
;
763 o
= clone_quoting_options (0);
764 set_quoting_style (o
, locale_quoting_style
);
767 while (where0
!= lim
&& ! lim
[-1])
769 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
772 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
773 _("Archive contains %.*s where numeric %s value expected"),
774 (int) sizeof buf
, buf
, type
));
780 if (value
<= (negative
? minus_minval
: maxval
))
781 return negative
? -value
: value
;
785 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
786 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
787 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
788 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
789 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
791 *--value_string
= '-';
793 *--minval_string
= '-';
794 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
795 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
797 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
804 gid_from_header (const char *p
, size_t s
)
806 return from_header (p
, s
, "gid_t",
807 - (uintmax_t) TYPE_MINIMUM (gid_t
),
808 (uintmax_t) TYPE_MAXIMUM (gid_t
),
813 major_from_header (const char *p
, size_t s
)
815 return from_header (p
, s
, "major_t",
816 - (uintmax_t) TYPE_MINIMUM (major_t
),
817 (uintmax_t) TYPE_MAXIMUM (major_t
), false, false);
821 minor_from_header (const char *p
, size_t s
)
823 return from_header (p
, s
, "minor_t",
824 - (uintmax_t) TYPE_MINIMUM (minor_t
),
825 (uintmax_t) TYPE_MAXIMUM (minor_t
), false, false);
829 mode_from_header (const char *p
, size_t s
)
831 /* Do not complain about unrecognized mode bits. */
832 unsigned u
= from_header (p
, s
, "mode_t",
833 - (uintmax_t) TYPE_MINIMUM (mode_t
),
834 TYPE_MAXIMUM (uintmax_t), false, false);
835 return ((u
& TSUID
? S_ISUID
: 0)
836 | (u
& TSGID
? S_ISGID
: 0)
837 | (u
& TSVTX
? S_ISVTX
: 0)
838 | (u
& TUREAD
? S_IRUSR
: 0)
839 | (u
& TUWRITE
? S_IWUSR
: 0)
840 | (u
& TUEXEC
? S_IXUSR
: 0)
841 | (u
& TGREAD
? S_IRGRP
: 0)
842 | (u
& TGWRITE
? S_IWGRP
: 0)
843 | (u
& TGEXEC
? S_IXGRP
: 0)
844 | (u
& TOREAD
? S_IROTH
: 0)
845 | (u
& TOWRITE
? S_IWOTH
: 0)
846 | (u
& TOEXEC
? S_IXOTH
: 0));
850 off_from_header (const char *p
, size_t s
)
852 /* Negative offsets are not allowed in tar files, so invoke
853 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
854 return from_header (p
, s
, "off_t", (uintmax_t) 0,
855 (uintmax_t) TYPE_MAXIMUM (off_t
), false, false);
859 size_from_header (const char *p
, size_t s
)
861 return from_header (p
, s
, "size_t", (uintmax_t) 0,
862 (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
866 time_from_header (const char *p
, size_t s
)
868 return from_header (p
, s
, "time_t",
869 - (uintmax_t) TYPE_MINIMUM (time_t),
870 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
874 uid_from_header (const char *p
, size_t s
)
876 return from_header (p
, s
, "uid_t",
877 - (uintmax_t) TYPE_MINIMUM (uid_t
),
878 (uintmax_t) TYPE_MAXIMUM (uid_t
), false, false);
882 uintmax_from_header (const char *p
, size_t s
)
884 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
885 TYPE_MAXIMUM (uintmax_t), false, false);
889 /* Return a printable representation of T. The result points to
890 static storage that can be reused in the next call to this
891 function, to ctime, or to asctime. If FULL_TIME, then output the
892 time stamp to its full resolution; otherwise, just output it to
893 1-minute resolution. */
895 tartime (struct timespec t
, bool full_time
)
897 enum { fraclen
= sizeof ".FFFFFFFFF" - 1 };
898 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
899 INT_STRLEN_BOUND (int) + 16)
904 bool negative
= s
< 0;
907 if (negative
&& ns
!= 0)
910 ns
= 1000000000 - ns
;
913 tm
= utc_option
? gmtime (&s
) : localtime (&s
);
918 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
919 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
920 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
921 code_ns_fraction (ns
, buffer
+ strlen (buffer
));
924 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d",
925 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
926 tm
->tm_hour
, tm
->tm_min
);
930 /* The time stamp cannot be broken down, most likely because it
931 is out of range. Convert it as an integer,
932 right-adjusted in a field with the same width as the usual
933 4-year ISO time format. */
934 p
= umaxtostr (negative
? - (uintmax_t) s
: s
,
935 buffer
+ sizeof buffer
- UINTMAX_STRSIZE_BOUND
- fraclen
);
938 while ((buffer
+ sizeof buffer
- sizeof "YYYY-MM-DD HH:MM"
939 + (full_time
? sizeof ":SS.FFFFFFFFF" - 1 : 0))
943 code_ns_fraction (ns
, buffer
+ sizeof buffer
- 1 - fraclen
);
947 /* Actually print it.
949 Plain and fancy file header block logging. Non-verbose just prints
950 the name, e.g. for "tar t" or "tar x". This should just contain
951 file names, so it can be fed back into tar with xargs or the "-T"
952 option. The verbose option can give a bunch of info, one line per
953 file. I doubt anybody tries to parse its format, or if they do,
954 they shouldn't. Unix tar is pretty random here anyway. */
957 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
958 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
960 /* Width of "user/group size", with initial value chosen
961 heuristically. This grows as needed, though this may cause some
962 stairstepping in the output. Make it too small and the output will
963 almost always look ragged. Make it too large and the output will
964 be spaced out too far. */
965 static int ugswidth
= 19;
967 /* Width of printed time stamps. It grows if longer time stamps are
968 found (typically, those with nanosecond resolution). Like
969 USGWIDTH, some stairstepping may occur. */
970 static int datewidth
= sizeof "YYYY-MM-DD HH:MM" - 1;
973 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
976 char const *time_stamp
;
978 char *temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
980 /* These hold formatted ints. */
981 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
983 char size
[2 * UINTMAX_STRSIZE_BOUND
];
984 /* holds formatted size or major,minor */
985 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
989 if (test_label_option
&& current_header
->header
.typeflag
!= GNUTYPE_VOLHDR
)
992 if (show_stored_names_option
)
994 switch (subcommand_option
)
997 case UPDATE_SUBCOMMAND
:
998 case APPEND_SUBCOMMAND
:
999 case CREATE_SUBCOMMAND
:
1000 temp_name
= st
->file_name
? st
->file_name
: st
->orig_file_name
;
1004 temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
1008 temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
1010 if (block_number_option
)
1012 char buf
[UINTMAX_STRSIZE_BOUND
];
1013 if (block_ordinal
< 0)
1014 block_ordinal
= current_block_ordinal ();
1015 block_ordinal
-= recent_long_name_blocks
;
1016 block_ordinal
-= recent_long_link_blocks
;
1017 fprintf (stdlis
, _("block %s: "),
1018 STRINGIFY_BIGINT (block_ordinal
, buf
));
1021 if (verbose_option
<= 1)
1023 /* Just the fax, mam. */
1024 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
1028 /* File type and modes. */
1031 switch (current_header
->header
.typeflag
)
1033 case GNUTYPE_VOLHDR
:
1037 case GNUTYPE_MULTIVOL
:
1045 case GNUTYPE_LONGNAME
:
1046 case GNUTYPE_LONGLINK
:
1048 ERROR ((0, 0, _("Unexpected long name header")));
1051 case GNUTYPE_SPARSE
:
1055 if (temp_name
[strlen (temp_name
) - 1] == '/')
1061 case GNUTYPE_DUMPDIR
:
1084 pax_decode_mode (st
->stat
.st_mode
, modes
+ 1);
1088 time_stamp
= tartime (st
->mtime
, false);
1089 time_stamp_len
= strlen (time_stamp
);
1090 if (datewidth
< time_stamp_len
)
1091 datewidth
= time_stamp_len
;
1093 /* User and group names. */
1097 && current_format
!= V7_FORMAT
1098 && !numeric_owner_option
)
1102 /* Try parsing it as an unsigned integer first, and as a
1103 uid_t if that fails. This method can list positive user
1104 ids that are too large to fit in a uid_t. */
1105 uintmax_t u
= from_header (current_header
->header
.uid
,
1106 sizeof current_header
->header
.uid
, 0,
1108 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1111 user
= STRINGIFY_BIGINT (u
, uform
);
1114 sprintf (uform
, "%ld",
1115 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1122 && current_format
!= V7_FORMAT
1123 && !numeric_owner_option
)
1127 /* Try parsing it as an unsigned integer first, and as a
1128 gid_t if that fails. This method can list positive group
1129 ids that are too large to fit in a gid_t. */
1130 uintmax_t g
= from_header (current_header
->header
.gid
,
1131 sizeof current_header
->header
.gid
, 0,
1133 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1136 group
= STRINGIFY_BIGINT (g
, gform
);
1139 sprintf (gform
, "%ld",
1140 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1145 /* Format the file size or major/minor device numbers. */
1147 switch (current_header
->header
.typeflag
)
1152 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1155 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1159 /* st->stat.st_size keeps stored file size */
1160 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1164 /* Figure out padding and print the whole line. */
1166 sizelen
= strlen (size
);
1167 pad
= strlen (user
) + 1 + strlen (group
) + 1 + sizelen
;
1171 fprintf (stdlis
, "%s %s/%s %*s %-*s",
1172 modes
, user
, group
, ugswidth
- pad
+ sizelen
, size
,
1173 datewidth
, time_stamp
);
1175 fprintf (stdlis
, " %s", quotearg (temp_name
));
1177 switch (current_header
->header
.typeflag
)
1180 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1184 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1189 char type_string
[2];
1190 type_string
[0] = current_header
->header
.typeflag
;
1191 type_string
[1] = '\0';
1192 fprintf (stdlis
, _(" unknown file type %s\n"),
1193 quote (type_string
));
1199 case GNUTYPE_SPARSE
:
1205 case GNUTYPE_DUMPDIR
:
1206 putc ('\n', stdlis
);
1209 case GNUTYPE_LONGLINK
:
1210 fprintf (stdlis
, _("--Long Link--\n"));
1213 case GNUTYPE_LONGNAME
:
1214 fprintf (stdlis
, _("--Long Name--\n"));
1217 case GNUTYPE_VOLHDR
:
1218 fprintf (stdlis
, _("--Volume Header--\n"));
1221 case GNUTYPE_MULTIVOL
:
1224 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1226 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1230 fprintf (stdlis
, _("--Mangled file names--\n"));
1237 /* Print a similar line when we make a directory automatically. */
1239 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1243 if (verbose_option
> 1)
1245 /* File type and modes. */
1248 pax_decode_mode (mode
, modes
+ 1);
1250 if (block_number_option
)
1252 char buf
[UINTMAX_STRSIZE_BOUND
];
1253 fprintf (stdlis
, _("block %s: "),
1254 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1257 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ 1 + datewidth
,
1258 _("Creating directory:"), length
, quotearg (dirname
));
1262 /* Skip over SIZE bytes of data in blocks in the archive. */
1264 skip_file (off_t size
)
1268 /* FIXME: Make sure mv_begin is always called before it */
1270 if (seekable_archive
)
1272 off_t nblk
= seek_archive (size
);
1274 size
-= nblk
* BLOCKSIZE
;
1276 seekable_archive
= false;
1279 mv_size_left (size
);
1283 x
= find_next_block ();
1285 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1287 set_next_block_after (x
);
1289 mv_size_left (size
);
1293 /* Skip the current member in the archive.
1294 NOTE: Current header must be decoded before calling this function. */
1298 if (!current_stat_info
.skipped
)
1300 char save_typeflag
= current_header
->header
.typeflag
;
1301 set_next_block_after (current_header
);
1303 mv_begin (¤t_stat_info
);
1305 if (current_stat_info
.is_sparse
)
1306 sparse_skip_file (¤t_stat_info
);
1307 else if (save_typeflag
!= DIRTYPE
)
1308 skip_file (current_stat_info
.stat
.st_size
);