1 /* List a tar archive, with support routines for reading a tar archive.
3 Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,
4 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
6 Written by John Gilmore, on 1985-08-26.
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any later
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
16 Public License for more details.
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
28 #define max(a, b) ((a) < (b) ? (b) : (a))
30 union block
*current_header
; /* points to current archive header */
31 enum archive_format current_format
; /* recognized format */
32 union block
*recent_long_name
; /* recent long name header and contents */
33 union block
*recent_long_link
; /* likewise, for long link */
34 size_t recent_long_name_blocks
; /* number of blocks in recent_long_name */
35 size_t recent_long_link_blocks
; /* likewise, for long link */
37 static uintmax_t from_header (const char *, size_t, const char *,
38 uintmax_t, uintmax_t, bool, bool);
40 /* Base 64 digits; see Internet RFC 2045 Table 1. */
41 static char const base_64_digits
[64] =
43 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
44 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
45 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
46 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
47 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
50 /* Table of base-64 digit values indexed by unsigned chars.
51 The value is 64 for unsigned chars that are not base-64 digits. */
52 static char base64_map
[UCHAR_MAX
+ 1];
58 memset (base64_map
, 64, sizeof base64_map
);
59 for (i
= 0; i
< 64; i
++)
60 base64_map
[(int) base_64_digits
[i
]] = i
;
63 /* Main loop for reading an archive. */
65 read_and (void (*do_something
) (void))
67 enum read_header status
= HEADER_STILL_UNREAD
;
68 enum read_header prev_status
;
69 struct timespec mtime
;
74 open_archive (ACCESS_READ
);
78 tar_stat_destroy (¤t_stat_info
);
79 xheader_destroy (&extended_header
);
81 status
= read_header (false);
84 case HEADER_STILL_UNREAD
:
85 case HEADER_SUCCESS_EXTENDED
:
90 /* Valid header. We should decode next field (mode) first.
91 Ensure incoming names are null terminated. */
93 if (! name_match (current_stat_info
.file_name
)
94 || (NEWER_OPTION_INITIALIZED (newer_mtime_option
)
95 /* FIXME: We get mtime now, and again later; this causes
96 duplicate diagnostics if header.mtime is bogus. */
98 = TIME_FROM_HEADER (current_header
->header
.mtime
)),
99 /* FIXME: Grab fractional time stamps from
102 set_stat_mtime (¤t_stat_info
.stat
, mtime
),
103 OLDER_STAT_TIME (current_stat_info
.stat
, m
)))
104 || excluded_name (current_stat_info
.file_name
))
106 switch (current_header
->header
.typeflag
)
109 case GNUTYPE_MULTIVOL
:
114 if (show_omitted_dirs_option
)
115 WARN ((0, 0, _("%s: Omitting"),
116 quotearg_colon (current_stat_info
.file_name
)));
119 decode_header (current_header
,
120 ¤t_stat_info
, ¤t_format
, 0);
129 case HEADER_ZERO_BLOCK
:
130 if (block_number_option
)
132 char buf
[UINTMAX_STRSIZE_BOUND
];
133 fprintf (stdlis
, _("block %s: ** Block of NULs **\n"),
134 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
137 set_next_block_after (current_header
);
139 if (!ignore_zeros_option
)
141 char buf
[UINTMAX_STRSIZE_BOUND
];
143 status
= read_header (false);
144 if (status
== HEADER_ZERO_BLOCK
)
146 WARN ((0, 0, _("A lone zero block at %s"),
147 STRINGIFY_BIGINT (current_block_ordinal (), buf
)));
150 status
= prev_status
;
153 case HEADER_END_OF_FILE
:
154 if (block_number_option
)
156 char buf
[UINTMAX_STRSIZE_BOUND
];
157 fprintf (stdlis
, _("block %s: ** End of File **\n"),
158 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
163 /* If the previous header was good, tell them that we are
164 skipping bad ones. */
165 set_next_block_after (current_header
);
168 case HEADER_STILL_UNREAD
:
169 ERROR ((0, 0, _("This does not look like a tar archive")));
172 case HEADER_ZERO_BLOCK
:
174 if (block_number_option
)
176 char buf
[UINTMAX_STRSIZE_BOUND
];
177 off_t block_ordinal
= current_block_ordinal ();
178 block_ordinal
-= recent_long_name_blocks
;
179 block_ordinal
-= recent_long_link_blocks
;
180 fprintf (stdlis
, _("block %s: "),
181 STRINGIFY_BIGINT (block_ordinal
, buf
));
183 ERROR ((0, 0, _("Skipping to next header")));
186 case HEADER_END_OF_FILE
:
188 /* We are in the middle of a cascade of errors. */
191 case HEADER_SUCCESS_EXTENDED
:
198 while (!all_names_found (¤t_stat_info
));
201 names_notfound (); /* print names not found */
204 /* Print a header block, based on tar options. */
208 /* Print the header block. */
210 decode_header (current_header
, ¤t_stat_info
, ¤t_format
, 0);
212 print_header (¤t_stat_info
, -1);
214 if (incremental_option
&& current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
217 size_t written
, check
;
218 union block
*data_block
;
220 set_next_block_after (current_header
);
221 if (multi_volume_option
)
223 assign_string (&save_name
, current_stat_info
.orig_file_name
);
224 save_totsize
= current_stat_info
.stat
.st_size
;
226 for (size
= current_stat_info
.stat
.st_size
; size
> 0; size
-= written
)
228 if (multi_volume_option
)
229 save_sizeleft
= size
;
230 data_block
= find_next_block ();
233 ERROR ((0, 0, _("Unexpected EOF in archive")));
234 break; /* FIXME: What happens, then? */
236 written
= available_space_after (data_block
);
239 set_next_block_after ((union block
*)
240 (data_block
->buffer
+ written
- 1));
241 if (verbose_option
> 2)
242 list_dumpdir (data_block
->buffer
, written
);
244 if (multi_volume_option
)
245 assign_string (&save_name
, 0);
250 if (multi_volume_option
)
251 assign_string (&save_name
, current_stat_info
.orig_file_name
);
255 if (multi_volume_option
)
256 assign_string (&save_name
, 0);
259 /* Check header checksum */
260 /* The standard BSD tar sources create the checksum by adding up the
261 bytes in the header as type char. I think the type char was unsigned
262 on the PDP-11, but it's signed on the Next and Sun. It looks like the
263 sources to BSD tar were never changed to compute the checksum
264 correctly, so both the Sun and Next add the bytes of the header as
265 signed chars. This doesn't cause a problem until you get a file with
266 a name containing characters with the high bit set. So tar_checksum
267 computes two checksums -- signed and unsigned. */
270 tar_checksum (union block
*header
, bool silent
)
273 int unsigned_sum
= 0; /* the POSIX one :-) */
274 int signed_sum
= 0; /* the Sun one :-( */
276 uintmax_t parsed_sum
;
280 for (i
= sizeof *header
; i
-- != 0;)
282 unsigned_sum
+= (unsigned char) *p
;
283 signed_sum
+= (signed char) (*p
++);
286 if (unsigned_sum
== 0)
287 return HEADER_ZERO_BLOCK
;
289 /* Adjust checksum to count the "chksum" field as blanks. */
291 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
293 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
294 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
296 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
297 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
299 parsed_sum
= from_header (header
->header
.chksum
,
300 sizeof header
->header
.chksum
, 0,
302 (uintmax_t) TYPE_MAXIMUM (int), true, silent
);
303 if (parsed_sum
== (uintmax_t) -1)
304 return HEADER_FAILURE
;
306 recorded_sum
= parsed_sum
;
308 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
309 return HEADER_FAILURE
;
311 return HEADER_SUCCESS
;
314 /* Read a block that's supposed to be a header block. Return its
315 address in "current_header", and if it is good, the file's size in
316 current_stat_info.stat.st_size.
318 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
319 block full of zeros (EOF marker).
321 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
322 GNU long name and link headers into later headers.
324 You must always set_next_block_after(current_header) to skip past
325 the header which this routine reads. */
328 read_header (bool raw_extended_headers
)
331 union block
*header_copy
;
333 union block
*data_block
;
334 size_t size
, written
;
335 union block
*next_long_name
= 0;
336 union block
*next_long_link
= 0;
337 size_t next_long_name_blocks
;
338 size_t next_long_link_blocks
;
342 enum read_header status
;
344 header
= find_next_block ();
345 current_header
= header
;
347 return HEADER_END_OF_FILE
;
349 if ((status
= tar_checksum (header
, false)) != HEADER_SUCCESS
)
352 /* Good block. Decode file size and return. */
354 if (header
->header
.typeflag
== LNKTYPE
)
355 current_stat_info
.stat
.st_size
= 0; /* links 0 size on tape */
357 current_stat_info
.stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
359 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
360 || header
->header
.typeflag
== GNUTYPE_LONGLINK
361 || header
->header
.typeflag
== XHDTYPE
362 || header
->header
.typeflag
== XGLTYPE
363 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
365 if (raw_extended_headers
)
366 return HEADER_SUCCESS_EXTENDED
;
367 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
368 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
370 size_t name_size
= current_stat_info
.stat
.st_size
;
371 size_t n
= name_size
% BLOCKSIZE
;
372 size
= name_size
+ BLOCKSIZE
;
374 size
+= BLOCKSIZE
- n
;
376 if (name_size
!= current_stat_info
.stat
.st_size
380 header_copy
= xmalloc (size
+ 1);
382 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
385 free (next_long_name
);
386 next_long_name
= header_copy
;
387 next_long_name_blocks
= size
/ BLOCKSIZE
;
392 free (next_long_link
);
393 next_long_link
= header_copy
;
394 next_long_link_blocks
= size
/ BLOCKSIZE
;
397 set_next_block_after (header
);
398 *header_copy
= *header
;
399 bp
= header_copy
->buffer
+ BLOCKSIZE
;
401 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
403 data_block
= find_next_block ();
406 ERROR ((0, 0, _("Unexpected EOF in archive")));
409 written
= available_space_after (data_block
);
413 memcpy (bp
, data_block
->buffer
, written
);
415 set_next_block_after ((union block
*)
416 (data_block
->buffer
+ written
- 1));
421 else if (header
->header
.typeflag
== XHDTYPE
422 || header
->header
.typeflag
== SOLARIS_XHDTYPE
)
423 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
424 else if (header
->header
.typeflag
== XGLTYPE
)
426 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
427 xheader_decode_global ();
436 struct posix_header
const *h
= ¤t_header
->header
;
437 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
439 if (recent_long_name
)
440 free (recent_long_name
);
444 name
= next_long_name
->buffer
+ BLOCKSIZE
;
445 recent_long_name
= next_long_name
;
446 recent_long_name_blocks
= next_long_name_blocks
;
450 /* Accept file names as specified by POSIX.1-1996
454 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
456 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
457 np
[sizeof h
->prefix
] = '\0';
461 memcpy (np
, h
->name
, sizeof h
->name
);
462 np
[sizeof h
->name
] = '\0';
464 recent_long_name
= 0;
465 recent_long_name_blocks
= 0;
467 assign_string (¤t_stat_info
.orig_file_name
, name
);
468 assign_string (¤t_stat_info
.file_name
, name
);
469 current_stat_info
.had_trailing_slash
= strip_trailing_slashes (current_stat_info
.file_name
);
471 if (recent_long_link
)
472 free (recent_long_link
);
476 name
= next_long_link
->buffer
+ BLOCKSIZE
;
477 recent_long_link
= next_long_link
;
478 recent_long_link_blocks
= next_long_link_blocks
;
482 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
483 namebuf
[sizeof h
->linkname
] = '\0';
485 recent_long_link
= 0;
486 recent_long_link_blocks
= 0;
488 assign_string (¤t_stat_info
.link_name
, name
);
490 return HEADER_SUCCESS
;
495 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
497 /* Decode things from a file HEADER block into STAT_INFO, also setting
498 *FORMAT_POINTER depending on the header block format. If
499 DO_USER_GROUP, decode the user/group information (this is useful
500 for extraction, but waste time when merely listing).
502 read_header() has already decoded the checksum and length, so we don't.
504 This routine should *not* be called twice for the same block, since
505 the two calls might use different DO_USER_GROUP values and thus
506 might end up with different uid/gid for the two calls. If anybody
507 wants the uid/gid they should decode it first, and other callers
508 should decode it without uid/gid before calling a routine,
509 e.g. print_header, that assumes decoded data. */
511 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
512 enum archive_format
*format_pointer
, int do_user_group
)
514 enum archive_format format
;
515 struct timespec atime
;
516 struct timespec ctime
;
517 struct timespec mtime
;
519 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
521 if (header
->star_header
.prefix
[130] == 0
522 && ISOCTAL (header
->star_header
.atime
[0])
523 && header
->star_header
.atime
[11] == ' '
524 && ISOCTAL (header
->star_header
.ctime
[0])
525 && header
->star_header
.ctime
[11] == ' ')
526 format
= STAR_FORMAT
;
527 else if (extended_header
.size
)
528 format
= POSIX_FORMAT
;
530 format
= USTAR_FORMAT
;
532 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
533 format
= OLDGNU_FORMAT
;
536 *format_pointer
= format
;
538 stat_info
->stat
.st_mode
= MODE_FROM_HEADER (header
->header
.mode
);
539 mtime
.tv_sec
= TIME_FROM_HEADER (header
->header
.mtime
);
541 set_stat_mtime (&stat_info
->stat
, mtime
);
542 assign_string (&stat_info
->uname
,
543 header
->header
.uname
[0] ? header
->header
.uname
: NULL
);
544 assign_string (&stat_info
->gname
,
545 header
->header
.gname
[0] ? header
->header
.gname
: NULL
);
547 if (format
== OLDGNU_FORMAT
&& incremental_option
)
549 atime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
550 ctime
.tv_sec
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
551 atime
.tv_nsec
= ctime
.tv_nsec
= 0;
553 else if (format
== STAR_FORMAT
)
555 atime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.atime
);
556 ctime
.tv_sec
= TIME_FROM_HEADER (header
->star_header
.ctime
);
557 atime
.tv_nsec
= ctime
.tv_nsec
= 0;
560 atime
= ctime
= start_time
;
562 set_stat_atime (&stat_info
->stat
, atime
);
563 set_stat_ctime (&stat_info
->stat
, ctime
);
565 if (format
== V7_FORMAT
)
567 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
568 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
569 stat_info
->stat
.st_rdev
= 0;
575 /* FIXME: Decide if this should somewhat depend on -p. */
577 if (numeric_owner_option
578 || !*header
->header
.uname
579 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
580 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
582 if (numeric_owner_option
583 || !*header
->header
.gname
584 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
585 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
588 switch (header
->header
.typeflag
)
592 stat_info
->stat
.st_rdev
=
593 makedev (MAJOR_FROM_HEADER (header
->header
.devmajor
),
594 MINOR_FROM_HEADER (header
->header
.devminor
));
598 stat_info
->stat
.st_rdev
= 0;
602 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
603 xheader_decode (stat_info
);
605 if (sparse_member_p (stat_info
))
607 sparse_fixup_header (stat_info
);
608 stat_info
->is_sparse
= true;
611 stat_info
->is_sparse
= false;
614 /* Convert buffer at WHERE0 of size DIGS from external format to
615 uintmax_t. DIGS must be positive. If TYPE is nonnull, the data
616 are of type TYPE. The buffer must represent a value in the range
617 -MINUS_MINVAL through MAXVAL. If OCTAL_ONLY, allow only octal
618 numbers instead of the other GNU extensions. Return -1 on error,
619 diagnosing the error if TYPE is nonnull and if !SILENT. */
621 from_header (char const *where0
, size_t digs
, char const *type
,
622 uintmax_t minus_minval
, uintmax_t maxval
,
623 bool octal_only
, bool silent
)
626 char const *where
= where0
;
627 char const *lim
= where
+ digs
;
630 /* Accommodate buggy tar of unknown vintage, which outputs leading
631 NUL if the previous field overflows. */
634 /* Accommodate older tars, which output leading spaces. */
641 /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
642 _("Blanks in header where numeric %s value expected"),
646 if (!ISSPACE ((unsigned char) *where
))
652 if (ISODIGIT (*where
))
654 char const *where1
= where
;
655 uintmax_t overflow
= 0;
659 value
+= *where
++ - '0';
660 if (where
== lim
|| ! ISODIGIT (*where
))
662 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
666 /* Parse the output of older, unportable tars, which generate
667 negative values in two's complement octal. If the leading
668 nonzero digit is 1, we can't recover the original value
669 reliably; so do this only if the digit is 2 or more. This
670 catches the common case of 32-bit negative time stamps. */
671 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
673 /* Compute the negative of the input value, assuming two's
675 int digit
= (*where1
- '0') | 4;
683 if (where
== lim
|| ! ISODIGIT (*where
))
685 digit
= *where
- '0';
686 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
692 if (!overflow
&& value
<= minus_minval
)
696 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
697 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
698 (int) (where
- where1
), where1
, type
));
707 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
708 _("Archive octal value %.*s is out of %s range"),
709 (int) (where
- where1
), where1
, type
));
715 /* Suppress the following extensions. */
717 else if (*where
== '-' || *where
== '+')
719 /* Parse base-64 output produced only by tar test versions
720 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
721 Support for this will be withdrawn in future releases. */
725 static bool warned_once
;
729 WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
732 negative
= *where
++ == '-';
734 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
736 if (value
<< LG_64
>> LG_64
!= value
)
738 char *string
= alloca (digs
+ 1);
739 memcpy (string
, where0
, digs
);
743 _("Archive signed base-64 string %s is out of %s range"),
744 quote (string
), type
));
747 value
= (value
<< LG_64
) | dig
;
751 else if (*where
== '\200' /* positive base-256 */
752 || *where
== '\377' /* negative base-256 */)
754 /* Parse base-256 output. A nonnegative number N is
755 represented as (256**DIGS)/2 + N; a negative number -N is
756 represented as (256**DIGS) - N, i.e. as two's complement.
757 The representation guarantees that the leading bit is
758 always on, so that we don't confuse this format with the
759 others (assuming ASCII bytes of 8 bits or more). */
760 int signbit
= *where
& (1 << (LG_256
- 2));
761 uintmax_t topbits
= (((uintmax_t) - signbit
)
762 << (CHAR_BIT
* sizeof (uintmax_t)
763 - LG_256
- (LG_256
- 2)));
764 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
767 value
= (value
<< LG_256
) + (unsigned char) *where
++;
770 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
774 _("Archive base-256 value is out of %s range"),
784 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
788 char buf
[1000]; /* Big enough to represent any header. */
789 static struct quoting_options
*o
;
793 o
= clone_quoting_options (0);
794 set_quoting_style (o
, locale_quoting_style
);
797 while (where0
!= lim
&& ! lim
[-1])
799 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
802 /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
803 _("Archive contains %.*s where numeric %s value expected"),
804 (int) sizeof buf
, buf
, type
));
810 if (value
<= (negative
? minus_minval
: maxval
))
811 return negative
? -value
: value
;
815 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
816 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
817 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
818 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
819 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
821 *--value_string
= '-';
823 *--minval_string
= '-';
824 /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
825 ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
827 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
834 gid_from_header (const char *p
, size_t s
)
836 return from_header (p
, s
, "gid_t",
837 - (uintmax_t) TYPE_MINIMUM (gid_t
),
838 (uintmax_t) TYPE_MAXIMUM (gid_t
),
843 major_from_header (const char *p
, size_t s
)
845 return from_header (p
, s
, "major_t",
846 - (uintmax_t) TYPE_MINIMUM (major_t
),
847 (uintmax_t) TYPE_MAXIMUM (major_t
), false, false);
851 minor_from_header (const char *p
, size_t s
)
853 return from_header (p
, s
, "minor_t",
854 - (uintmax_t) TYPE_MINIMUM (minor_t
),
855 (uintmax_t) TYPE_MAXIMUM (minor_t
), false, false);
859 mode_from_header (const char *p
, size_t s
)
861 /* Do not complain about unrecognized mode bits. */
862 unsigned u
= from_header (p
, s
, "mode_t",
863 - (uintmax_t) TYPE_MINIMUM (mode_t
),
864 TYPE_MAXIMUM (uintmax_t), false, false);
865 return ((u
& TSUID
? S_ISUID
: 0)
866 | (u
& TSGID
? S_ISGID
: 0)
867 | (u
& TSVTX
? S_ISVTX
: 0)
868 | (u
& TUREAD
? S_IRUSR
: 0)
869 | (u
& TUWRITE
? S_IWUSR
: 0)
870 | (u
& TUEXEC
? S_IXUSR
: 0)
871 | (u
& TGREAD
? S_IRGRP
: 0)
872 | (u
& TGWRITE
? S_IWGRP
: 0)
873 | (u
& TGEXEC
? S_IXGRP
: 0)
874 | (u
& TOREAD
? S_IROTH
: 0)
875 | (u
& TOWRITE
? S_IWOTH
: 0)
876 | (u
& TOEXEC
? S_IXOTH
: 0));
880 off_from_header (const char *p
, size_t s
)
882 /* Negative offsets are not allowed in tar files, so invoke
883 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
884 return from_header (p
, s
, "off_t", (uintmax_t) 0,
885 (uintmax_t) TYPE_MAXIMUM (off_t
), false, false);
889 size_from_header (const char *p
, size_t s
)
891 return from_header (p
, s
, "size_t", (uintmax_t) 0,
892 (uintmax_t) TYPE_MAXIMUM (size_t), false, false);
896 time_from_header (const char *p
, size_t s
)
898 return from_header (p
, s
, "time_t",
899 - (uintmax_t) TYPE_MINIMUM (time_t),
900 (uintmax_t) TYPE_MAXIMUM (time_t), false, false);
904 uid_from_header (const char *p
, size_t s
)
906 return from_header (p
, s
, "uid_t",
907 - (uintmax_t) TYPE_MINIMUM (uid_t
),
908 (uintmax_t) TYPE_MAXIMUM (uid_t
), false, false);
912 uintmax_from_header (const char *p
, size_t s
)
914 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
915 TYPE_MAXIMUM (uintmax_t), false, false);
919 /* Return a printable representation of T. The result points to
920 static storage that can be reused in the next call to this
921 function, to ctime, or to asctime. If FULL_TIME, then output the
922 time stamp to its full resolution; otherwise, just output it to
923 1-minute resolution. */
925 tartime (struct timespec t
, bool full_time
)
927 enum { fraclen
= sizeof ".FFFFFFFFF" - 1 };
928 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
929 INT_STRLEN_BOUND (int) + 16)
934 bool negative
= s
< 0;
937 if (negative
&& ns
!= 0)
940 ns
= 1000000000 - ns
;
943 tm
= utc_option
? gmtime (&s
) : localtime (&s
);
948 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
949 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
950 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
951 code_ns_fraction (ns
, buffer
+ strlen (buffer
));
954 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d",
955 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
956 tm
->tm_hour
, tm
->tm_min
);
960 /* The time stamp cannot be broken down, most likely because it
961 is out of range. Convert it as an integer,
962 right-adjusted in a field with the same width as the usual
963 4-year ISO time format. */
964 p
= umaxtostr (negative
? - (uintmax_t) s
: s
,
965 buffer
+ sizeof buffer
- UINTMAX_STRSIZE_BOUND
- fraclen
);
968 while ((buffer
+ sizeof buffer
- sizeof "YYYY-MM-DD HH:MM"
969 + (full_time
? sizeof ":SS.FFFFFFFFF" - 1 : 0))
973 code_ns_fraction (ns
, buffer
+ sizeof buffer
- 1 - fraclen
);
977 /* Actually print it.
979 Plain and fancy file header block logging. Non-verbose just prints
980 the name, e.g. for "tar t" or "tar x". This should just contain
981 file names, so it can be fed back into tar with xargs or the "-T"
982 option. The verbose option can give a bunch of info, one line per
983 file. I doubt anybody tries to parse its format, or if they do,
984 they shouldn't. Unix tar is pretty random here anyway. */
987 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
988 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
990 /* Width of "user/group size", with initial value chosen
991 heuristically. This grows as needed, though this may cause some
992 stairstepping in the output. Make it too small and the output will
993 almost always look ragged. Make it too large and the output will
994 be spaced out too far. */
995 static int ugswidth
= 19;
997 /* Width of printed time stamps. It grows if longer time stamps are
998 found (typically, those with nanosecond resolution). Like
999 USGWIDTH, some stairstepping may occur. */
1000 static int datewidth
= sizeof "YYYY-MM-DD HH:MM" - 1;
1003 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
1006 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
];
1019 if (block_number_option
)
1021 char buf
[UINTMAX_STRSIZE_BOUND
];
1022 if (block_ordinal
< 0)
1023 block_ordinal
= current_block_ordinal ();
1024 block_ordinal
-= recent_long_name_blocks
;
1025 block_ordinal
-= recent_long_link_blocks
;
1026 fprintf (stdlis
, _("block %s: "),
1027 STRINGIFY_BIGINT (block_ordinal
, buf
));
1030 if (verbose_option
<= 1)
1032 /* Just the fax, mam. */
1033 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
1037 /* File type and modes. */
1040 switch (current_header
->header
.typeflag
)
1042 case GNUTYPE_VOLHDR
:
1046 case GNUTYPE_MULTIVOL
:
1054 case GNUTYPE_LONGNAME
:
1055 case GNUTYPE_LONGLINK
:
1057 ERROR ((0, 0, _("Unexpected long name header")));
1060 case GNUTYPE_SPARSE
:
1064 if (temp_name
[strlen (temp_name
) - 1] == '/')
1070 case GNUTYPE_DUMPDIR
:
1093 pax_decode_mode (st
->stat
.st_mode
, modes
+ 1);
1097 time_stamp
= tartime (get_stat_mtime (&st
->stat
), false);
1098 time_stamp_len
= strlen (time_stamp
);
1099 if (datewidth
< time_stamp_len
)
1100 datewidth
= time_stamp_len
;
1102 /* User and group names. */
1106 && current_format
!= V7_FORMAT
1107 && !numeric_owner_option
)
1111 /* Try parsing it as an unsigned integer first, and as a
1112 uid_t if that fails. This method can list positive user
1113 ids that are too large to fit in a uid_t. */
1114 uintmax_t u
= from_header (current_header
->header
.uid
,
1115 sizeof current_header
->header
.uid
, 0,
1117 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1120 user
= STRINGIFY_BIGINT (u
, uform
);
1123 sprintf (uform
, "%ld",
1124 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1131 && current_format
!= V7_FORMAT
1132 && !numeric_owner_option
)
1136 /* Try parsing it as an unsigned integer first, and as a
1137 gid_t if that fails. This method can list positive group
1138 ids that are too large to fit in a gid_t. */
1139 uintmax_t g
= from_header (current_header
->header
.gid
,
1140 sizeof current_header
->header
.gid
, 0,
1142 (uintmax_t) TYPE_MAXIMUM (uintmax_t),
1145 group
= STRINGIFY_BIGINT (g
, gform
);
1148 sprintf (gform
, "%ld",
1149 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1154 /* Format the file size or major/minor device numbers. */
1156 switch (current_header
->header
.typeflag
)
1161 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1164 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1168 /* st->stat.st_size keeps stored file size */
1169 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1173 /* Figure out padding and print the whole line. */
1175 sizelen
= strlen (size
);
1176 pad
= strlen (user
) + 1 + strlen (group
) + 1 + sizelen
;
1180 fprintf (stdlis
, "%s %s/%s %*s %-*s",
1181 modes
, user
, group
, ugswidth
- pad
+ sizelen
, size
,
1182 datewidth
, time_stamp
);
1184 fprintf (stdlis
, " %s", quotearg (temp_name
));
1186 switch (current_header
->header
.typeflag
)
1189 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1193 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1198 char type_string
[2];
1199 type_string
[0] = current_header
->header
.typeflag
;
1200 type_string
[1] = '\0';
1201 fprintf (stdlis
, _(" unknown file type %s\n"),
1202 quote (type_string
));
1208 case GNUTYPE_SPARSE
:
1214 case GNUTYPE_DUMPDIR
:
1215 putc ('\n', stdlis
);
1218 case GNUTYPE_LONGLINK
:
1219 fprintf (stdlis
, _("--Long Link--\n"));
1222 case GNUTYPE_LONGNAME
:
1223 fprintf (stdlis
, _("--Long Name--\n"));
1226 case GNUTYPE_VOLHDR
:
1227 fprintf (stdlis
, _("--Volume Header--\n"));
1230 case GNUTYPE_MULTIVOL
:
1233 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1235 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1239 fprintf (stdlis
, _("--Mangled file names--\n"));
1246 /* Print a similar line when we make a directory automatically. */
1248 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1252 if (verbose_option
> 1)
1254 /* File type and modes. */
1257 pax_decode_mode (mode
, modes
+ 1);
1259 if (block_number_option
)
1261 char buf
[UINTMAX_STRSIZE_BOUND
];
1262 fprintf (stdlis
, _("block %s: "),
1263 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1266 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ 1 + datewidth
,
1267 _("Creating directory:"), length
, quotearg (dirname
));
1271 /* Skip over SIZE bytes of data in blocks in the archive. */
1273 skip_file (off_t size
)
1277 if (multi_volume_option
)
1279 save_totsize
= size
;
1280 save_sizeleft
= size
;
1283 if (seekable_archive
)
1285 off_t nblk
= seek_archive (size
);
1288 size
-= nblk
* BLOCKSIZE
;
1289 if (multi_volume_option
) /* Argh.. */
1290 save_sizeleft
-= nblk
* BLOCKSIZE
;
1293 seekable_archive
= false;
1298 x
= find_next_block ();
1300 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1302 set_next_block_after (x
);
1304 if (multi_volume_option
)
1305 save_sizeleft
-= BLOCKSIZE
;
1309 /* Skip the current member in the archive.
1310 NOTE: Current header must be decoded before calling this function. */
1314 char save_typeflag
= current_header
->header
.typeflag
;
1315 set_next_block_after (current_header
);
1317 assign_string (&save_name
, current_stat_info
.orig_file_name
);
1319 if (current_stat_info
.is_sparse
)
1320 sparse_skip_file (¤t_stat_info
);
1321 else if (save_typeflag
!= DIRTYPE
)
1322 skip_file (current_stat_info
.stat
.st_size
);