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 Free Software Foundation, Inc.
6 Written by John Gilmore, on 1985-08-26.
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any later
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
16 Public License for more details.
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* Define to non-zero for forcing old ctime format instead of ISO format. */
30 #define max(a, b) ((a) < (b) ? (b) : (a))
32 union block
*current_header
; /* points to current archive header */
33 enum archive_format current_format
; /* recognized format */
34 union block
*recent_long_name
; /* recent long name header and contents */
35 union block
*recent_long_link
; /* likewise, for long link */
36 size_t recent_long_name_blocks
; /* number of blocks in recent_long_name */
37 size_t recent_long_link_blocks
; /* likewise, for long link */
39 static uintmax_t from_header (const char *, size_t, const char *,
40 uintmax_t, uintmax_t);
42 /* Base 64 digits; see Internet RFC 2045 Table 1. */
43 static char const base_64_digits
[64] =
45 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
46 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
47 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
48 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
49 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
52 /* Table of base-64 digit values indexed by unsigned chars.
53 The value is 64 for unsigned chars that are not base-64 digits. */
54 static char base64_map
[UCHAR_MAX
+ 1];
60 memset (base64_map
, 64, sizeof base64_map
);
61 for (i
= 0; i
< 64; i
++)
62 base64_map
[(int) base_64_digits
[i
]] = i
;
65 /* Main loop for reading an archive. */
67 read_and (void (*do_something
) (void))
69 enum read_header status
= HEADER_STILL_UNREAD
;
70 enum read_header prev_status
;
74 open_archive (ACCESS_READ
);
79 tar_stat_destroy (¤t_stat_info
);
80 xheader_destroy (&extended_header
);
82 status
= read_header (false);
85 case HEADER_STILL_UNREAD
:
86 case HEADER_SUCCESS_EXTENDED
:
91 /* Valid header. We should decode next field (mode) first.
92 Ensure incoming names are null terminated. */
94 if (! name_match (current_stat_info
.file_name
)
95 || (newer_mtime_option
!= TYPE_MINIMUM (time_t)
96 /* FIXME: We get mtime now, and again later; this causes
97 duplicate diagnostics if header.mtime is bogus. */
98 && ((current_stat_info
.stat
.st_mtime
99 = TIME_FROM_HEADER (current_header
->header
.mtime
))
100 < newer_mtime_option
))
101 || excluded_name (current_stat_info
.file_name
))
103 switch (current_header
->header
.typeflag
)
106 case GNUTYPE_MULTIVOL
:
111 if (show_omitted_dirs_option
)
112 WARN ((0, 0, _("%s: Omitting"),
113 quotearg_colon (current_stat_info
.file_name
)));
124 case HEADER_ZERO_BLOCK
:
125 if (block_number_option
)
127 char buf
[UINTMAX_STRSIZE_BOUND
];
128 fprintf (stdlis
, _("block %s: ** Block of NULs **\n"),
129 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
132 set_next_block_after (current_header
);
134 if (!ignore_zeros_option
)
136 char buf
[UINTMAX_STRSIZE_BOUND
];
138 status
= read_header (false);
139 if (status
== HEADER_ZERO_BLOCK
)
141 WARN ((0, 0, _("A lone zero block at %s"),
142 STRINGIFY_BIGINT (current_block_ordinal (), buf
)));
145 status
= prev_status
;
148 case HEADER_END_OF_FILE
:
149 if (block_number_option
)
151 char buf
[UINTMAX_STRSIZE_BOUND
];
152 fprintf (stdlis
, _("block %s: ** End of File **\n"),
153 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
158 /* If the previous header was good, tell them that we are
159 skipping bad ones. */
160 set_next_block_after (current_header
);
163 case HEADER_STILL_UNREAD
:
164 ERROR ((0, 0, _("This does not look like a tar archive")));
167 case HEADER_ZERO_BLOCK
:
169 ERROR ((0, 0, _("Skipping to next header")));
172 case HEADER_END_OF_FILE
:
174 /* We are in the middle of a cascade of errors. */
177 case HEADER_SUCCESS_EXTENDED
:
184 while (!all_names_found (¤t_stat_info
));
187 names_notfound (); /* print names not found */
190 /* Print a header block, based on tar options. */
194 /* Print the header block. */
196 decode_header (current_header
, ¤t_stat_info
, ¤t_format
, 0);
198 print_header (¤t_stat_info
, -1);
200 if (incremental_option
&& current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
203 size_t written
, check
;
204 union block
*data_block
;
206 set_next_block_after (current_header
);
207 if (multi_volume_option
)
209 assign_string (&save_name
, current_stat_info
.file_name
);
210 save_totsize
= current_stat_info
.stat
.st_size
;
212 for (size
= current_stat_info
.stat
.st_size
; size
> 0; size
-= written
)
214 if (multi_volume_option
)
215 save_sizeleft
= size
;
216 data_block
= find_next_block ();
219 ERROR ((0, 0, _("Unexpected EOF in archive")));
220 break; /* FIXME: What happens, then? */
222 written
= available_space_after (data_block
);
226 check
= fwrite (data_block
->buffer
, sizeof (char), written
, stdlis
);
227 set_next_block_after ((union block
*)
228 (data_block
->buffer
+ written
- 1));
229 if (check
!= written
)
231 write_error_details (current_stat_info
.file_name
, check
, written
);
232 skip_file (size
- written
);
236 if (multi_volume_option
)
237 assign_string (&save_name
, 0);
238 fputc ('\n', stdlis
);
244 if (multi_volume_option
)
245 assign_string (&save_name
, current_stat_info
.file_name
);
249 if (multi_volume_option
)
250 assign_string (&save_name
, 0);
253 /* Read a block that's supposed to be a header block. Return its
254 address in "current_header", and if it is good, the file's size in
255 current_stat_info.stat.st_size.
257 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
258 block full of zeros (EOF marker).
260 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
261 GNU long name and link headers into later headers.
263 You must always set_next_block_after(current_header) to skip past
264 the header which this routine reads. */
266 /* The standard BSD tar sources create the checksum by adding up the
267 bytes in the header as type char. I think the type char was unsigned
268 on the PDP-11, but it's signed on the Next and Sun. It looks like the
269 sources to BSD tar were never changed to compute the checksum
270 correctly, so both the Sun and Next add the bytes of the header as
271 signed chars. This doesn't cause a problem until you get a file with
272 a name containing characters with the high bit set. So read_header
273 computes two checksums -- signed and unsigned. */
276 read_header (bool raw_extended_headers
)
279 int unsigned_sum
; /* the POSIX one :-) */
280 int signed_sum
; /* the Sun one :-( */
282 uintmax_t parsed_sum
;
285 union block
*header_copy
;
287 union block
*data_block
;
288 size_t size
, written
;
289 union block
*next_long_name
= 0;
290 union block
*next_long_link
= 0;
291 size_t next_long_name_blocks
;
292 size_t next_long_link_blocks
;
296 header
= find_next_block ();
297 current_header
= header
;
299 return HEADER_END_OF_FILE
;
304 for (i
= sizeof *header
; i
-- != 0;)
306 unsigned_sum
+= (unsigned char) *p
;
307 signed_sum
+= (signed char) (*p
++);
310 if (unsigned_sum
== 0)
311 return HEADER_ZERO_BLOCK
;
313 /* Adjust checksum to count the "chksum" field as blanks. */
315 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
317 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
318 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
320 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
321 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
323 parsed_sum
= from_header (header
->header
.chksum
,
324 sizeof header
->header
.chksum
, 0,
326 (uintmax_t) TYPE_MAXIMUM (int));
327 if (parsed_sum
== (uintmax_t) -1)
328 return HEADER_FAILURE
;
330 recorded_sum
= parsed_sum
;
332 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
333 return HEADER_FAILURE
;
335 /* Good block. Decode file size and return. */
337 if (header
->header
.typeflag
== LNKTYPE
)
338 current_stat_info
.stat
.st_size
= 0; /* links 0 size on tape */
340 current_stat_info
.stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
342 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
343 || header
->header
.typeflag
== GNUTYPE_LONGLINK
344 || header
->header
.typeflag
== XHDTYPE
345 || header
->header
.typeflag
== XGLTYPE
)
347 if (raw_extended_headers
)
348 return HEADER_SUCCESS_EXTENDED
;
349 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
350 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
352 size_t name_size
= current_stat_info
.stat
.st_size
;
353 size
= name_size
- name_size
% BLOCKSIZE
+ 2 * BLOCKSIZE
;
354 if (name_size
!= current_stat_info
.stat
.st_size
358 header_copy
= xmalloc (size
+ 1);
360 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
363 free (next_long_name
);
364 next_long_name
= header_copy
;
365 next_long_name_blocks
= size
/ BLOCKSIZE
;
370 free (next_long_link
);
371 next_long_link
= header_copy
;
372 next_long_link_blocks
= size
/ BLOCKSIZE
;
375 set_next_block_after (header
);
376 *header_copy
= *header
;
377 bp
= header_copy
->buffer
+ BLOCKSIZE
;
379 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
381 data_block
= find_next_block ();
384 ERROR ((0, 0, _("Unexpected EOF in archive")));
387 written
= available_space_after (data_block
);
391 memcpy (bp
, data_block
->buffer
, written
);
393 set_next_block_after ((union block
*)
394 (data_block
->buffer
+ written
- 1));
399 else if (header
->header
.typeflag
== XHDTYPE
)
400 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
401 else if (header
->header
.typeflag
== XGLTYPE
)
403 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
404 xheader_decode_global ();
413 struct posix_header
const *h
= ¤t_header
->header
;
414 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
416 if (recent_long_name
)
417 free (recent_long_name
);
421 name
= next_long_name
->buffer
+ BLOCKSIZE
;
422 recent_long_name
= next_long_name
;
423 recent_long_name_blocks
= next_long_name_blocks
;
427 /* Accept file names as specified by POSIX.1-1996
431 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
433 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
434 np
[sizeof h
->prefix
] = '\0';
438 /* Prevent later references to current_header from
439 mistakenly treating this as an old GNU header.
440 This assignment invalidates h->prefix. */
441 current_header
->oldgnu_header
.isextended
= 0;
443 memcpy (np
, h
->name
, sizeof h
->name
);
444 np
[sizeof h
->name
] = '\0';
446 recent_long_name
= 0;
447 recent_long_name_blocks
= 0;
449 assign_string (¤t_stat_info
.orig_file_name
, name
);
450 assign_string (¤t_stat_info
.file_name
, name
);
451 current_stat_info
.had_trailing_slash
= strip_trailing_slashes (current_stat_info
.file_name
);
453 if (recent_long_link
)
454 free (recent_long_link
);
458 name
= next_long_link
->buffer
+ BLOCKSIZE
;
459 recent_long_link
= next_long_link
;
460 recent_long_link_blocks
= next_long_link_blocks
;
464 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
465 namebuf
[sizeof h
->linkname
] = '\0';
467 recent_long_link
= 0;
468 recent_long_link_blocks
= 0;
470 assign_string (¤t_stat_info
.link_name
, name
);
472 return HEADER_SUCCESS
;
477 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
479 /* Decode things from a file HEADER block into STAT_INFO, also setting
480 *FORMAT_POINTER depending on the header block format. If
481 DO_USER_GROUP, decode the user/group information (this is useful
482 for extraction, but waste time when merely listing).
484 read_header() has already decoded the checksum and length, so we don't.
486 This routine should *not* be called twice for the same block, since
487 the two calls might use different DO_USER_GROUP values and thus
488 might end up with different uid/gid for the two calls. If anybody
489 wants the uid/gid they should decode it first, and other callers
490 should decode it without uid/gid before calling a routine,
491 e.g. print_header, that assumes decoded data. */
493 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
494 enum archive_format
*format_pointer
, int do_user_group
)
496 enum archive_format format
;
498 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
500 if (header
->star_header
.prefix
[130] == 0
501 && ISOCTAL (header
->star_header
.atime
[0])
502 && header
->star_header
.atime
[11] == ' '
503 && ISOCTAL (header
->star_header
.ctime
[0])
504 && header
->star_header
.ctime
[11] == ' ')
505 format
= STAR_FORMAT
;
506 else if (extended_header
.size
)
507 format
= POSIX_FORMAT
;
509 format
= USTAR_FORMAT
;
511 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
512 format
= OLDGNU_FORMAT
;
515 *format_pointer
= format
;
517 stat_info
->stat
.st_mode
= MODE_FROM_HEADER (header
->header
.mode
);
518 stat_info
->stat
.st_mtime
= TIME_FROM_HEADER (header
->header
.mtime
);
519 assign_string (&stat_info
->uname
, header
->header
.uname
);
520 assign_string (&stat_info
->gname
, header
->header
.gname
);
521 stat_info
->devmajor
= MAJOR_FROM_HEADER (header
->header
.devmajor
);
522 stat_info
->devminor
= MINOR_FROM_HEADER (header
->header
.devminor
);
524 stat_info
->stat
.st_atime
= start_time
;
525 stat_info
->stat
.st_ctime
= start_time
;
527 if (format
== OLDGNU_FORMAT
&& incremental_option
)
529 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
530 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
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;
542 if (format
== STAR_FORMAT
)
544 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->star_header
.atime
);
545 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->star_header
.ctime
);
550 /* FIXME: Decide if this should somewhat depend on -p. */
552 if (numeric_owner_option
553 || !*header
->header
.uname
554 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
555 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
557 if (numeric_owner_option
558 || !*header
->header
.gname
559 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
560 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
563 switch (header
->header
.typeflag
)
567 stat_info
->stat
.st_rdev
= makedev (stat_info
->devmajor
,
568 stat_info
->devminor
);
572 stat_info
->stat
.st_rdev
= 0;
576 xheader_decode (stat_info
);
577 current_stat_info
.archive_file_size
= current_stat_info
.stat
.st_size
;
580 /* Convert buffer at WHERE0 of size DIGS from external format to
581 uintmax_t. The data is of type TYPE. The buffer must represent a
582 value in the range -MINUS_MINVAL through MAXVAL. DIGS must be
583 positive. Return -1 on error, diagnosing the error if TYPE is
586 from_header (char const *where0
, size_t digs
, char const *type
,
587 uintmax_t minus_minval
, uintmax_t maxval
)
590 char const *where
= where0
;
591 char const *lim
= where
+ digs
;
594 /* Accommodate buggy tar of unknown vintage, which outputs leading
595 NUL if the previous field overflows. */
598 /* Accommodate older tars, which output leading spaces. */
605 _("Blanks in header where numeric %s value expected"),
609 if (!ISSPACE ((unsigned char) *where
))
615 if (ISODIGIT (*where
))
617 char const *where1
= where
;
618 uintmax_t overflow
= 0;
622 value
+= *where
++ - '0';
623 if (where
== lim
|| ! ISODIGIT (*where
))
625 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
629 /* Parse the output of older, unportable tars, which generate
630 negative values in two's complement octal. If the leading
631 nonzero digit is 1, we can't recover the original value
632 reliably; so do this only if the digit is 2 or more. This
633 catches the common case of 32-bit negative time stamps. */
634 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
636 /* Compute the negative of the input value, assuming two's
638 int digit
= (*where1
- '0') | 4;
646 if (where
== lim
|| ! ISODIGIT (*where
))
648 digit
= *where
- '0';
649 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
655 if (!overflow
&& value
<= minus_minval
)
658 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
659 (int) (where
- where1
), where1
, type
));
668 _("Archive octal value %.*s is out of %s range"),
669 (int) (where
- where1
), where1
, type
));
673 else if (*where
== '-' || *where
== '+')
675 /* Parse base-64 output produced only by tar test versions
676 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
677 Support for this will be withdrawn in future releases. */
679 static int warned_once
;
684 _("Archive contains obsolescent base-64 headers")));
686 negative
= *where
++ == '-';
688 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
690 if (value
<< LG_64
>> LG_64
!= value
)
692 char *string
= alloca (digs
+ 1);
693 memcpy (string
, where0
, digs
);
697 _("Archive signed base-64 string %s is out of %s range"),
698 quote (string
), type
));
701 value
= (value
<< LG_64
) | dig
;
705 else if (*where
== '\200' /* positive base-256 */
706 || *where
== '\377' /* negative base-256 */)
708 /* Parse base-256 output. A nonnegative number N is
709 represented as (256**DIGS)/2 + N; a negative number -N is
710 represented as (256**DIGS) - N, i.e. as two's complement.
711 The representation guarantees that the leading bit is
712 always on, so that we don't confuse this format with the
713 others (assuming ASCII bytes of 8 bits or more). */
714 int signbit
= *where
& (1 << (LG_256
- 2));
715 uintmax_t topbits
= (((uintmax_t) - signbit
)
716 << (CHAR_BIT
* sizeof (uintmax_t)
717 - LG_256
- (LG_256
- 2)));
718 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
721 value
= (value
<< LG_256
) + (unsigned char) *where
++;
724 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
728 _("Archive base-256 value is out of %s range"),
738 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
742 char buf
[1000]; /* Big enough to represent any header. */
743 static struct quoting_options
*o
;
747 o
= clone_quoting_options (0);
748 set_quoting_style (o
, locale_quoting_style
);
751 while (where0
!= lim
&& ! lim
[-1])
753 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
755 _("Archive contains %.*s where numeric %s value expected"),
756 (int) sizeof buf
, buf
, type
));
762 if (value
<= (negative
? minus_minval
: maxval
))
763 return negative
? -value
: value
;
767 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
768 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
769 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
770 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
771 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
773 *--value_string
= '-';
775 *--minval_string
= '-';
776 ERROR ((0, 0, _("Archive value %s is out of %s range %s.%s"),
778 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
785 gid_from_header (const char *p
, size_t s
)
787 return from_header (p
, s
, "gid_t",
788 - (uintmax_t) TYPE_MINIMUM (gid_t
),
789 (uintmax_t) TYPE_MAXIMUM (gid_t
));
793 major_from_header (const char *p
, size_t s
)
795 return from_header (p
, s
, "major_t",
796 - (uintmax_t) TYPE_MINIMUM (major_t
),
797 (uintmax_t) TYPE_MAXIMUM (major_t
));
801 minor_from_header (const char *p
, size_t s
)
803 return from_header (p
, s
, "minor_t",
804 - (uintmax_t) TYPE_MINIMUM (minor_t
),
805 (uintmax_t) TYPE_MAXIMUM (minor_t
));
809 mode_from_header (const char *p
, size_t s
)
811 /* Do not complain about unrecognized mode bits. */
812 unsigned u
= from_header (p
, s
, "mode_t",
813 - (uintmax_t) TYPE_MINIMUM (mode_t
),
814 TYPE_MAXIMUM (uintmax_t));
815 return ((u
& TSUID
? S_ISUID
: 0)
816 | (u
& TSGID
? S_ISGID
: 0)
817 | (u
& TSVTX
? S_ISVTX
: 0)
818 | (u
& TUREAD
? S_IRUSR
: 0)
819 | (u
& TUWRITE
? S_IWUSR
: 0)
820 | (u
& TUEXEC
? S_IXUSR
: 0)
821 | (u
& TGREAD
? S_IRGRP
: 0)
822 | (u
& TGWRITE
? S_IWGRP
: 0)
823 | (u
& TGEXEC
? S_IXGRP
: 0)
824 | (u
& TOREAD
? S_IROTH
: 0)
825 | (u
& TOWRITE
? S_IWOTH
: 0)
826 | (u
& TOEXEC
? S_IXOTH
: 0));
830 off_from_header (const char *p
, size_t s
)
832 /* Negative offsets are not allowed in tar files, so invoke
833 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
834 return from_header (p
, s
, "off_t", (uintmax_t) 0,
835 (uintmax_t) TYPE_MAXIMUM (off_t
));
839 size_from_header (const char *p
, size_t s
)
841 return from_header (p
, s
, "size_t", (uintmax_t) 0,
842 (uintmax_t) TYPE_MAXIMUM (size_t));
846 time_from_header (const char *p
, size_t s
)
848 return from_header (p
, s
, "time_t",
849 - (uintmax_t) TYPE_MINIMUM (time_t),
850 (uintmax_t) TYPE_MAXIMUM (time_t));
854 uid_from_header (const char *p
, size_t s
)
856 return from_header (p
, s
, "uid_t",
857 - (uintmax_t) TYPE_MINIMUM (uid_t
),
858 (uintmax_t) TYPE_MAXIMUM (uid_t
));
862 uintmax_from_header (const char *p
, size_t s
)
864 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
865 TYPE_MAXIMUM (uintmax_t));
869 /* Format O as a null-terminated decimal string into BUF _backwards_;
870 return pointer to start of result. */
872 stringify_uintmax_t_backwards (uintmax_t o
, char *buf
)
876 *--buf
= '0' + (int) (o
% 10);
877 while ((o
/= 10) != 0);
881 /* Return a printable representation of T. The result points to
882 static storage that can be reused in the next call to this
883 function, to ctime, or to asctime. */
887 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
888 INT_STRLEN_BOUND (int) + 16)];
895 char const *time_stamp
= p
+ 4;
896 for (p
+= 16; p
[3] != '\n'; p
++)
902 /* Use ISO 8610 format. See:
903 http://www.cl.cam.ac.uk/~mgk25/iso-time.html */
904 struct tm
*tm
= utc_option
? gmtime (&t
) : localtime (&t
);
907 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
908 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
909 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
914 /* The time stamp cannot be broken down, most likely because it
915 is out of range. Convert it as an integer,
916 right-adjusted in a field with the same width as the usual
917 19-byte 4-year ISO time format. */
918 p
= stringify_uintmax_t_backwards (t
< 0 ? - (uintmax_t) t
: (uintmax_t) t
,
919 buffer
+ sizeof buffer
);
922 while (buffer
+ sizeof buffer
- 19 - 1 < p
)
927 /* Actually print it.
929 Plain and fancy file header block logging. Non-verbose just prints
930 the name, e.g. for "tar t" or "tar x". This should just contain
931 file names, so it can be fed back into tar with xargs or the "-T"
932 option. The verbose option can give a bunch of info, one line per
933 file. I doubt anybody tries to parse its format, or if they do,
934 they shouldn't. Unix tar is pretty random here anyway. */
937 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
938 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
940 /* UGSWIDTH starts with 18, so with user and group names <= 8 chars, the
941 columns never shift during the listing. */
943 static int ugswidth
= UGSWIDTH
; /* maximum width encountered so far */
945 /* DATEWIDTH is the number of columns taken by the date and time fields. */
947 # define DATEWIDTH 19
949 # define DATEWIDTH 18
953 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
956 char const *time_stamp
;
957 char *temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
959 /* These hold formatted ints. */
960 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
962 char size
[2 * UINTMAX_STRSIZE_BOUND
];
963 /* holds formatted size or major,minor */
964 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
967 if (block_number_option
)
969 char buf
[UINTMAX_STRSIZE_BOUND
];
970 if (block_ordinal
< 0)
971 block_ordinal
= current_block_ordinal ();
972 block_ordinal
-= recent_long_name_blocks
;
973 block_ordinal
-= recent_long_link_blocks
;
974 fprintf (stdlis
, _("block %s: "),
975 STRINGIFY_BIGINT (block_ordinal
, buf
));
978 if (verbose_option
<= 1)
980 /* Just the fax, mam. */
981 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
985 /* File type and modes. */
988 switch (current_header
->header
.typeflag
)
994 case GNUTYPE_MULTIVOL
:
1002 case GNUTYPE_LONGNAME
:
1003 case GNUTYPE_LONGLINK
:
1005 ERROR ((0, 0, _("Visible longname error")));
1008 case GNUTYPE_SPARSE
:
1012 if (temp_name
[strlen (temp_name
) - 1] == '/')
1018 case GNUTYPE_DUMPDIR
:
1041 decode_mode (st
->stat
.st_mode
, modes
+ 1);
1045 time_stamp
= tartime (st
->stat
.st_mtime
);
1047 /* User and group names. */
1049 if (st
->uname
&& current_format
!= V7_FORMAT
1050 && !numeric_owner_option
)
1054 /* Try parsing it as an unsigned integer first, and as a
1055 uid_t if that fails. This method can list positive user
1056 ids that are too large to fit in a uid_t. */
1057 uintmax_t u
= from_header (current_header
->header
.uid
,
1058 sizeof current_header
->header
.uid
, 0,
1060 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1062 user
= STRINGIFY_BIGINT (u
, uform
);
1065 sprintf (uform
, "%ld",
1066 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1071 if (st
->gname
&& current_format
!= V7_FORMAT
1072 && !numeric_owner_option
)
1076 /* Try parsing it as an unsigned integer first, and as a
1077 gid_t if that fails. This method can list positive group
1078 ids that are too large to fit in a gid_t. */
1079 uintmax_t g
= from_header (current_header
->header
.gid
,
1080 sizeof current_header
->header
.gid
, 0,
1082 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1084 group
= STRINGIFY_BIGINT (g
, gform
);
1087 sprintf (gform
, "%ld",
1088 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1093 /* Format the file size or major/minor device numbers. */
1095 switch (current_header
->header
.typeflag
)
1100 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1103 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1105 case GNUTYPE_SPARSE
:
1108 (UINTMAX_FROM_HEADER (current_header
1109 ->oldgnu_header
.realsize
),
1113 /* st->stat.st_size keeps stored file size */
1114 strcpy (size
, STRINGIFY_BIGINT (st
->archive_file_size
, uintbuf
));
1118 /* Figure out padding and print the whole line. */
1120 pad
= strlen (user
) + strlen (group
) + strlen (size
) + 1;
1124 fprintf (stdlis
, "%s %s/%s %*s%s %s",
1125 modes
, user
, group
, ugswidth
- pad
, "", size
, time_stamp
);
1127 fprintf (stdlis
, " %s", quotearg (temp_name
));
1129 switch (current_header
->header
.typeflag
)
1132 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1136 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1141 char type_string
[2];
1142 type_string
[0] = current_header
->header
.typeflag
;
1143 type_string
[1] = '\0';
1144 fprintf (stdlis
, _(" unknown file type %s\n"),
1145 quote (type_string
));
1151 case GNUTYPE_SPARSE
:
1157 case GNUTYPE_DUMPDIR
:
1158 putc ('\n', stdlis
);
1161 case GNUTYPE_LONGLINK
:
1162 fprintf (stdlis
, _("--Long Link--\n"));
1165 case GNUTYPE_LONGNAME
:
1166 fprintf (stdlis
, _("--Long Name--\n"));
1169 case GNUTYPE_VOLHDR
:
1170 fprintf (stdlis
, _("--Volume Header--\n"));
1173 case GNUTYPE_MULTIVOL
:
1176 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1178 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1182 fprintf (stdlis
, _("--Mangled file names--\n"));
1189 /* Print a similar line when we make a directory automatically. */
1191 print_for_mkdir (char *pathname
, int length
, mode_t mode
)
1195 if (verbose_option
> 1)
1197 /* File type and modes. */
1200 decode_mode (mode
, modes
+ 1);
1202 if (block_number_option
)
1204 char buf
[UINTMAX_STRSIZE_BOUND
];
1205 fprintf (stdlis
, _("block %s: "),
1206 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1209 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ DATEWIDTH
,
1210 _("Creating directory:"), length
, quotearg (pathname
));
1214 /* Skip over SIZE bytes of data in blocks in the archive. */
1216 skip_file (off_t size
)
1220 if (multi_volume_option
)
1222 save_totsize
= size
;
1223 save_sizeleft
= size
;
1228 x
= find_next_block ();
1230 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1232 set_next_block_after (x
);
1234 if (multi_volume_option
)
1235 save_sizeleft
-= BLOCKSIZE
;
1239 /* Skip the current member in the archive. */
1243 char save_typeflag
= current_header
->header
.typeflag
;
1244 set_next_block_after (current_header
);
1246 if (current_format
== OLDGNU_FORMAT
1247 && current_header
->oldgnu_header
.isextended
)
1252 exhdr
= find_next_block ();
1254 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1255 set_next_block_after (exhdr
);
1257 while (exhdr
->sparse_header
.isextended
);
1260 if (save_typeflag
!= DIRTYPE
)
1261 skip_file (current_stat_info
.stat
.st_size
);