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
285 and names (file name, link name) in *info.
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_primitive (bool raw_extended_headers
, struct tar_stat_info
*info
)
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 info
->stat
.st_size
= 0; /* links 0 size on tape */
326 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
= info
->stat
.st_size
;
340 size_t n
= name_size
% BLOCKSIZE
;
341 size
= name_size
+ BLOCKSIZE
;
343 size
+= BLOCKSIZE
- n
;
345 if (name_size
!= info
->stat
.st_size
|| size
< name_size
)
348 header_copy
= xmalloc (size
+ 1);
350 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
353 free (next_long_name
);
354 next_long_name
= header_copy
;
355 next_long_name_blocks
= size
/ BLOCKSIZE
;
360 free (next_long_link
);
361 next_long_link
= header_copy
;
362 next_long_link_blocks
= size
/ BLOCKSIZE
;
365 set_next_block_after (header
);
366 *header_copy
= *header
;
367 bp
= header_copy
->buffer
+ BLOCKSIZE
;
369 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
371 data_block
= find_next_block ();
374 ERROR ((0, 0, _("Unexpected EOF in archive")));
377 written
= available_space_after (data_block
);
381 memcpy (bp
, data_block
->buffer
, written
);
383 set_next_block_after ((union block
*)
384 (data_block
->buffer
+ written
- 1));
389 else if (header
->header
.typeflag
== XHDTYPE
390 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
391 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
392 else if (header
->header
.typeflag
== XGLTYPE
)
394 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
395 xheader_decode_global ();
396 xheader_destroy (&extended_header
);
405 struct posix_header
const *h
= ¤t_header
->header
;
406 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
408 if (recent_long_name
)
409 free (recent_long_name
);
413 name
= next_long_name
->buffer
+ BLOCKSIZE
;
414 recent_long_name
= next_long_name
;
415 recent_long_name_blocks
= next_long_name_blocks
;
419 /* Accept file names as specified by POSIX.1-1996
423 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
425 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
426 np
[sizeof h
->prefix
] = '\0';
430 memcpy (np
, h
->name
, sizeof h
->name
);
431 np
[sizeof h
->name
] = '\0';
433 recent_long_name
= 0;
434 recent_long_name_blocks
= 0;
436 assign_string (&info
->orig_file_name
, name
);
437 assign_string (&info
->file_name
, name
);
438 info
->had_trailing_slash
= strip_trailing_slashes (info
->file_name
);
440 if (recent_long_link
)
441 free (recent_long_link
);
445 name
= next_long_link
->buffer
+ BLOCKSIZE
;
446 recent_long_link
= next_long_link
;
447 recent_long_link_blocks
= next_long_link_blocks
;
451 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
452 namebuf
[sizeof h
->linkname
] = '\0';
454 recent_long_link
= 0;
455 recent_long_link_blocks
= 0;
457 assign_string (&info
->link_name
, name
);
459 return HEADER_SUCCESS
;
465 read_header (bool raw_extended_headers
)
467 return read_header_primitive (raw_extended_headers
, ¤t_stat_info
);
470 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
472 /* Decode things from a file HEADER block into STAT_INFO, also setting
473 *FORMAT_POINTER depending on the header block format. If
474 DO_USER_GROUP, decode the user/group information (this is useful
475 for extraction, but waste time when merely listing).
477 read_header() has already decoded the checksum and length, so we don't.
479 This routine should *not* be called twice for the same block, since
480 the two calls might use different DO_USER_GROUP values and thus
481 might end up with different uid/gid for the two calls. If anybody
482 wants the uid/gid they should decode it first, and other callers
483 should decode it without uid/gid before calling a routine,
484 e.g. print_header, that assumes decoded data. */
486 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
487 enum archive_format
*format_pointer
, int do_user_group
)
489 enum archive_format format
;
491 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
493 if (header
->star_header
.prefix
[130] == 0
494 && ISOCTAL (header
->star_header
.atime
[0])
495 && header
->star_header
.atime
[11] == ' '
496 && ISOCTAL (header
->star_header
.ctime
[0])
497 && header
->star_header
.ctime
[11] == ' ')
498 format
= STAR_FORMAT
;
499 else if (extended_header
.size
)
500 format
= POSIX_FORMAT
;
502 format
= USTAR_FORMAT
;
504 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
505 format
= OLDGNU_FORMAT
;
508 *format_pointer
= format
;
510 stat_info
->stat
.st_mode
= MODE_FROM_HEADER (header
->header
.mode
);
511 stat_info
->mtime
.tv_sec
= TIME_FROM_HEADER (header
->header
.mtime
);
512 stat_info
->mtime
.tv_nsec
= 0;
513 assign_string (&stat_info
->uname
,
514 header
->header
.uname
[0] ? header
->header
.uname
: NULL
);
515 assign_string (&stat_info
->gname
,
516 header
->header
.gname
[0] ? header
->header
.gname
: NULL
);
518 if (format
== OLDGNU_FORMAT
&& incremental_option
)
520 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
521 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
522 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
524 else if (format
== STAR_FORMAT
)
526 stat_info
->atime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.atime
);
527 stat_info
->ctime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.ctime
);
528 stat_info
->atime
.tv_nsec
= stat_info
->ctime
.tv_nsec
= 0;
531 stat_info
->atime
= stat_info
->ctime
= start_time
;
533 if (format
== V7_FORMAT
)
535 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
536 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
537 stat_info
->stat
.st_rdev
= 0;
543 /* FIXME: Decide if this should somewhat depend on -p. */
545 if (numeric_owner_option
546 || !*header
->header
.uname
547 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
548 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
550 if (numeric_owner_option
551 || !*header
->header
.gname
552 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
553 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
556 switch (header
->header
.typeflag
)
560 stat_info
->stat
.st_rdev
=
561 makedev (MAJOR_FROM_HEADER (header
->header
.devmajor
),
562 MINOR_FROM_HEADER (header
->header
.devminor
));
566 stat_info
->stat
.st_rdev
= 0;
570 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
571 xheader_decode (stat_info
);
573 if (sparse_member_p (stat_info
))
575 sparse_fixup_header (stat_info
);
576 stat_info
->is_sparse
= true;
580 stat_info
->is_sparse
= false;
581 if (((current_format
== GNU_FORMAT
582 || current_format
== OLDGNU_FORMAT
)
583 && current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
584 || stat_info
->dumpdir
)
585 stat_info
->is_dumpdir
= true;
589 /* Convert buffer at WHERE0 of size DIGS from external format to
590 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
591 are of type TYPE. The buffer must represent a value in the range
592 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
593 numbers instead of the other GNU extensions. Return -1 on error,
594 diagnosing the error if TYPE is nonnull and if !SILENT. */
596 from_header (char const *where0
, size_t digs
, char const *type
,
597 uintmax_t minus_minval
, uintmax_t maxval
,
598 bool octal_only
, bool silent
)
601 char const *where
= where0
;
602 char const *lim
= where
+ digs
;
605 /* Accommodate buggy tar of unknown vintage, which outputs leading
606 NUL if the previous field overflows. */
609 /* Accommodate older tars, which output leading spaces. */
616 /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
617 _("Blanks in header where numeric %s value expected"),
621 if (!ISSPACE ((unsigned char) *where
))
627 if (ISODIGIT (*where
))
629 char const *where1
= where
;
630 uintmax_t overflow
= 0;
634 value
+= *where
++ - '0';
635 if (where
== lim
|| ! ISODIGIT (*where
))
637 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
641 /* Parse the output of older, unportable tars, which generate
642 negative values in two's complement octal. If the leading
643 nonzero digit is 1, we can't recover the original value
644 reliably; so do this only if the digit is 2 or more. This
645 catches the common case of 32-bit negative time stamps. */
646 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
648 /* Compute the negative of the input value, assuming two's
650 int digit
= (*where1
- '0') | 4;
658 if (where
== lim
|| ! ISODIGIT (*where
))
660 digit
= *where
- '0';
661 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
667 if (!overflow
&& value
<= minus_minval
)
671 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
672 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
673 (int) (where
- where1
), where1
, type
));
682 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
683 _("Archive octal value %.*s is out of %s range"),
684 (int) (where
- where1
), where1
, type
));
690 /* Suppress the following extensions. */
692 else if (*where
== '-' || *where
== '+')
694 /* Parse base-64 output produced only by tar test versions
695 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
696 Support for this will be withdrawn in future releases. */
700 static bool warned_once
;
704 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
707 negative
= *where
++ == '-';
709 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
711 if (value
<< LG_64
>> LG_64
!= value
)
713 char *string
= alloca (digs
+ 1);
714 memcpy (string
, where0
, digs
);
718 _("Archive signed base-64 string %s is out of %s range"),
719 quote (string
), type
));
722 value
= (value
<< LG_64
) | dig
;
726 else if (*where
== '\200' /* positive base-256 */
727 || *where
== '\377' /* negative base-256 */)
729 /* Parse base-256 output. A nonnegative number N is
730 represented as (256**DIGS)/2 + N; a negative number -N is
731 represented as (256**DIGS) - N, i.e. as two's complement.
732 The representation guarantees that the leading bit is
733 always on, so that we don't confuse this format with the
734 others (assuming ASCII bytes of 8 bits or more). */
735 int signbit
= *where
& (1 << (LG_256
- 2));
736 uintmax_t topbits
= (((uintmax_t) - signbit
)
737 << (CHAR_BIT
* sizeof (uintmax_t)
738 - LG_256
- (LG_256
- 2)));
739 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
742 value
= (value
<< LG_256
) + (unsigned char) *where
++;
745 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
749 _("Archive base-256 value is out of %s range"),
759 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
763 char buf
[1000]; /* Big enough to represent any header. */
764 static struct quoting_options
*o
;
768 o
= clone_quoting_options (0);
769 set_quoting_style (o
, locale_quoting_style
);
772 while (where0
!= lim
&& ! lim
[-1])
774 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
777 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
778 _("Archive contains %.*s where numeric %s value expected"),
779 (int) sizeof buf
, buf
, type
));
785 if (value
<= (negative
? minus_minval
: maxval
))
786 return negative
? -value
: value
;
790 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
791 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
792 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
793 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
794 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
796 *--value_string
= '-';
798 *--minval_string
= '-';
799 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
800 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
802 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
809 gid_from_header (const char *p
, size_t s
)
811 return from_header (p
, s
, "gid_t",
812 - (uintmax_t) TYPE_MINIMUM (gid_t
),
813 (uintmax_t) TYPE_MAXIMUM (gid_t
),
818 major_from_header (const char *p
, size_t s
)
820 return from_header (p
, s
, "major_t",
821 - (uintmax_t) TYPE_MINIMUM (major_t
),
822 (uintmax_t) TYPE_MAXIMUM (major_t
), false, false);
826 minor_from_header (const char *p
, size_t s
)
828 return from_header (p
, s
, "minor_t",
829 - (uintmax_t) TYPE_MINIMUM (minor_t
),
830 (uintmax_t) TYPE_MAXIMUM (minor_t
), false, false);
834 mode_from_header (const char *p
, size_t s
)
836 /* Do not complain about unrecognized mode bits. */
837 unsigned u
= from_header (p
, s
, "mode_t",
838 - (uintmax_t) TYPE_MINIMUM (mode_t
),
839 TYPE_MAXIMUM (uintmax_t), false, false);
840 return ((u
& TSUID
? S_ISUID
: 0)
841 | (u
& TSGID
? S_ISGID
: 0)
842 | (u
& TSVTX
? S_ISVTX
: 0)
843 | (u
& TUREAD
? S_IRUSR
: 0)
844 | (u
& TUWRITE
? S_IWUSR
: 0)
845 | (u
& TUEXEC
? S_IXUSR
: 0)
846 | (u
& TGREAD
? S_IRGRP
: 0)
847 | (u
& TGWRITE
? S_IWGRP
: 0)
848 | (u
& TGEXEC
? S_IXGRP
: 0)
849 | (u
& TOREAD
? S_IROTH
: 0)
850 | (u
& TOWRITE
? S_IWOTH
: 0)
851 | (u
& TOEXEC
? S_IXOTH
: 0));
855 off_from_header (const char *p
, size_t s
)
857 /* Negative offsets are not allowed in tar files, so invoke
858 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
859 return from_header (p
, s
, "off_t", (uintmax_t) 0,
860 (uintmax_t) TYPE_MAXIMUM (off_t
), false, false);
864 size_from_header (const char *p
, size_t s
)
866 return from_header (p
, s
, "size_t", (uintmax_t) 0,
867 (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
871 time_from_header (const char *p
, size_t s
)
873 return from_header (p
, s
, "time_t",
874 - (uintmax_t) TYPE_MINIMUM (time_t),
875 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
879 uid_from_header (const char *p
, size_t s
)
881 return from_header (p
, s
, "uid_t",
882 - (uintmax_t) TYPE_MINIMUM (uid_t
),
883 (uintmax_t) TYPE_MAXIMUM (uid_t
), false, false);
887 uintmax_from_header (const char *p
, size_t s
)
889 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
890 TYPE_MAXIMUM (uintmax_t), false, false);
894 /* Return a printable representation of T. The result points to
895 static storage that can be reused in the next call to this
896 function, to ctime, or to asctime. If FULL_TIME, then output the
897 time stamp to its full resolution; otherwise, just output it to
898 1-minute resolution. */
900 tartime (struct timespec t
, bool full_time
)
902 enum { fraclen
= sizeof ".FFFFFFFFF" - 1 };
903 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
904 INT_STRLEN_BOUND (int) + 16)
909 bool negative
= s
< 0;
912 if (negative
&& ns
!= 0)
915 ns
= 1000000000 - ns
;
918 tm
= utc_option
? gmtime (&s
) : localtime (&s
);
923 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
924 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
925 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
926 code_ns_fraction (ns
, buffer
+ strlen (buffer
));
929 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d",
930 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
931 tm
->tm_hour
, tm
->tm_min
);
935 /* The time stamp cannot be broken down, most likely because it
936 is out of range. Convert it as an integer,
937 right-adjusted in a field with the same width as the usual
938 4-year ISO time format. */
939 p
= umaxtostr (negative
? - (uintmax_t) s
: s
,
940 buffer
+ sizeof buffer
- UINTMAX_STRSIZE_BOUND
- fraclen
);
943 while ((buffer
+ sizeof buffer
- sizeof "YYYY-MM-DD HH:MM"
944 + (full_time
? sizeof ":SS.FFFFFFFFF" - 1 : 0))
948 code_ns_fraction (ns
, buffer
+ sizeof buffer
- 1 - fraclen
);
952 /* Actually print it.
954 Plain and fancy file header block logging. Non-verbose just prints
955 the name, e.g. for "tar t" or "tar x". This should just contain
956 file names, so it can be fed back into tar with xargs or the "-T"
957 option. The verbose option can give a bunch of info, one line per
958 file. I doubt anybody tries to parse its format, or if they do,
959 they shouldn't. Unix tar is pretty random here anyway. */
962 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
963 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
965 /* Width of "user/group size", with initial value chosen
966 heuristically. This grows as needed, though this may cause some
967 stairstepping in the output. Make it too small and the output will
968 almost always look ragged. Make it too large and the output will
969 be spaced out too far. */
970 static int ugswidth
= 19;
972 /* Width of printed time stamps. It grows if longer time stamps are
973 found (typically, those with nanosecond resolution). Like
974 USGWIDTH, some stairstepping may occur. */
975 static int datewidth
= sizeof "YYYY-MM-DD HH:MM" - 1;
978 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
981 char const *time_stamp
;
983 char *temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
985 /* These hold formatted ints. */
986 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
988 char size
[2 * UINTMAX_STRSIZE_BOUND
];
989 /* holds formatted size or major,minor */
990 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
994 if (test_label_option
&& current_header
->header
.typeflag
!= GNUTYPE_VOLHDR
)
997 if (show_stored_names_option
)
999 switch (subcommand_option
)
1001 case CAT_SUBCOMMAND
:
1002 case UPDATE_SUBCOMMAND
:
1003 case APPEND_SUBCOMMAND
:
1004 case CREATE_SUBCOMMAND
:
1005 temp_name
= st
->file_name
? st
->file_name
: st
->orig_file_name
;
1009 temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
1013 temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
1015 if (block_number_option
)
1017 char buf
[UINTMAX_STRSIZE_BOUND
];
1018 if (block_ordinal
< 0)
1019 block_ordinal
= current_block_ordinal ();
1020 block_ordinal
-= recent_long_name_blocks
;
1021 block_ordinal
-= recent_long_link_blocks
;
1022 fprintf (stdlis
, _("block %s: "),
1023 STRINGIFY_BIGINT (block_ordinal
, buf
));
1026 if (verbose_option
<= 1)
1028 /* Just the fax, mam. */
1029 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
1033 /* File type and modes. */
1036 switch (current_header
->header
.typeflag
)
1038 case GNUTYPE_VOLHDR
:
1042 case GNUTYPE_MULTIVOL
:
1050 case GNUTYPE_LONGNAME
:
1051 case GNUTYPE_LONGLINK
:
1053 ERROR ((0, 0, _("Unexpected long name header")));
1056 case GNUTYPE_SPARSE
:
1060 if (temp_name
[strlen (temp_name
) - 1] == '/')
1066 case GNUTYPE_DUMPDIR
:
1089 pax_decode_mode (st
->stat
.st_mode
, modes
+ 1);
1093 time_stamp
= tartime (st
->mtime
, false);
1094 time_stamp_len
= strlen (time_stamp
);
1095 if (datewidth
< time_stamp_len
)
1096 datewidth
= time_stamp_len
;
1098 /* User and group names. */
1102 && current_format
!= V7_FORMAT
1103 && !numeric_owner_option
)
1107 /* Try parsing it as an unsigned integer first, and as a
1108 uid_t if that fails. This method can list positive user
1109 ids that are too large to fit in a uid_t. */
1110 uintmax_t u
= from_header (current_header
->header
.uid
,
1111 sizeof current_header
->header
.uid
, 0,
1113 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1116 user
= STRINGIFY_BIGINT (u
, uform
);
1119 sprintf (uform
, "%ld",
1120 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1127 && current_format
!= V7_FORMAT
1128 && !numeric_owner_option
)
1132 /* Try parsing it as an unsigned integer first, and as a
1133 gid_t if that fails. This method can list positive group
1134 ids that are too large to fit in a gid_t. */
1135 uintmax_t g
= from_header (current_header
->header
.gid
,
1136 sizeof current_header
->header
.gid
, 0,
1138 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1141 group
= STRINGIFY_BIGINT (g
, gform
);
1144 sprintf (gform
, "%ld",
1145 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1150 /* Format the file size or major/minor device numbers. */
1152 switch (current_header
->header
.typeflag
)
1157 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1160 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1164 /* st->stat.st_size keeps stored file size */
1165 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1169 /* Figure out padding and print the whole line. */
1171 sizelen
= strlen (size
);
1172 pad
= strlen (user
) + 1 + strlen (group
) + 1 + sizelen
;
1176 fprintf (stdlis
, "%s %s/%s %*s %-*s",
1177 modes
, user
, group
, ugswidth
- pad
+ sizelen
, size
,
1178 datewidth
, time_stamp
);
1180 fprintf (stdlis
, " %s", quotearg (temp_name
));
1182 switch (current_header
->header
.typeflag
)
1185 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1189 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1194 char type_string
[2];
1195 type_string
[0] = current_header
->header
.typeflag
;
1196 type_string
[1] = '\0';
1197 fprintf (stdlis
, _(" unknown file type %s\n"),
1198 quote (type_string
));
1204 case GNUTYPE_SPARSE
:
1210 case GNUTYPE_DUMPDIR
:
1211 putc ('\n', stdlis
);
1214 case GNUTYPE_LONGLINK
:
1215 fprintf (stdlis
, _("--Long Link--\n"));
1218 case GNUTYPE_LONGNAME
:
1219 fprintf (stdlis
, _("--Long Name--\n"));
1222 case GNUTYPE_VOLHDR
:
1223 fprintf (stdlis
, _("--Volume Header--\n"));
1226 case GNUTYPE_MULTIVOL
:
1229 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1231 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1235 fprintf (stdlis
, _("--Mangled file names--\n"));
1242 /* Print a similar line when we make a directory automatically. */
1244 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1248 if (verbose_option
> 1)
1250 /* File type and modes. */
1253 pax_decode_mode (mode
, modes
+ 1);
1255 if (block_number_option
)
1257 char buf
[UINTMAX_STRSIZE_BOUND
];
1258 fprintf (stdlis
, _("block %s: "),
1259 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1262 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ 1 + datewidth
,
1263 _("Creating directory:"), length
, quotearg (dirname
));
1267 /* Skip over SIZE bytes of data in blocks in the archive. */
1269 skip_file (off_t size
)
1273 /* FIXME: Make sure mv_begin is always called before it */
1275 if (seekable_archive
)
1277 off_t nblk
= seek_archive (size
);
1279 size
-= nblk
* BLOCKSIZE
;
1281 seekable_archive
= false;
1284 mv_size_left (size
);
1288 x
= find_next_block ();
1290 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1292 set_next_block_after (x
);
1294 mv_size_left (size
);
1298 /* Skip the current member in the archive.
1299 NOTE: Current header must be decoded before calling this function. */
1303 if (!current_stat_info
.skipped
)
1305 char save_typeflag
= current_header
->header
.typeflag
;
1306 set_next_block_after (current_header
);
1308 mv_begin (¤t_stat_info
);
1310 if (current_stat_info
.is_sparse
)
1311 sparse_skip_file (¤t_stat_info
);
1312 else if (save_typeflag
!= DIRTYPE
)
1313 skip_file (current_stat_info
.stat
.st_size
);