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 status
= read_header (0);
82 case HEADER_STILL_UNREAD
:
87 /* Valid header. We should decode next field (mode) first.
88 Ensure incoming names are null terminated. */
90 if (! name_match (current_stat_info
.file_name
)
91 || (newer_mtime_option
!= TYPE_MINIMUM (time_t)
92 /* FIXME: We get mtime now, and again later; this causes
93 duplicate diagnostics if header.mtime is bogus. */
94 && ((current_stat_info
.stat
.st_mtime
95 = TIME_FROM_HEADER (current_header
->header
.mtime
))
96 < newer_mtime_option
))
97 || excluded_name (current_stat_info
.file_name
))
99 switch (current_header
->header
.typeflag
)
102 case GNUTYPE_MULTIVOL
:
107 if (show_omitted_dirs_option
)
108 WARN ((0, 0, _("%s: Omitting"),
109 quotearg_colon (current_stat_info
.file_name
)));
120 case HEADER_ZERO_BLOCK
:
121 if (block_number_option
)
123 char buf
[UINTMAX_STRSIZE_BOUND
];
124 fprintf (stdlis
, _("block %s: ** Block of NULs **\n"),
125 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
128 set_next_block_after (current_header
);
129 status
= prev_status
;
130 if (ignore_zeros_option
)
134 case HEADER_END_OF_FILE
:
135 if (block_number_option
)
137 char buf
[UINTMAX_STRSIZE_BOUND
];
138 fprintf (stdlis
, _("block %s: ** End of File **\n"),
139 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
144 /* If the previous header was good, tell them that we are
145 skipping bad ones. */
146 set_next_block_after (current_header
);
149 case HEADER_STILL_UNREAD
:
150 ERROR ((0, 0, _("This does not look like a tar archive")));
153 case HEADER_ZERO_BLOCK
:
155 ERROR ((0, 0, _("Skipping to next header")));
158 case HEADER_END_OF_FILE
:
160 /* We are in the middle of a cascade of errors. */
169 names_notfound (); /* print names not found */
172 /* Print a header block, based on tar options. */
176 /* Print the header block. */
178 decode_header (current_header
, ¤t_stat_info
, ¤t_format
, 0);
182 if (incremental_option
&& current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
185 size_t written
, check
;
186 union block
*data_block
;
188 set_next_block_after (current_header
);
189 if (multi_volume_option
)
191 assign_string (&save_name
, current_stat_info
.file_name
);
192 save_totsize
= current_stat_info
.stat
.st_size
;
194 for (size
= current_stat_info
.stat
.st_size
; size
> 0; size
-= written
)
196 if (multi_volume_option
)
197 save_sizeleft
= size
;
198 data_block
= find_next_block ();
201 ERROR ((0, 0, _("Unexpected EOF in archive")));
202 break; /* FIXME: What happens, then? */
204 written
= available_space_after (data_block
);
208 check
= fwrite (data_block
->buffer
, sizeof (char), written
, stdlis
);
209 set_next_block_after ((union block
*)
210 (data_block
->buffer
+ written
- 1));
211 if (check
!= written
)
213 write_error_details (current_stat_info
.file_name
, check
, written
);
214 skip_file (size
- written
);
218 if (multi_volume_option
)
219 assign_string (&save_name
, 0);
220 fputc ('\n', stdlis
);
226 if (multi_volume_option
)
227 assign_string (&save_name
, current_stat_info
.file_name
);
231 if (multi_volume_option
)
232 assign_string (&save_name
, 0);
235 /* Read a block that's supposed to be a header block. Return its
236 address in "current_header", and if it is good, the file's size in
237 current_stat_info.stat.st_size.
239 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
240 block full of zeros (EOF marker).
242 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
243 GNU long name and link headers into later headers.
245 You must always set_next_block_after(current_header) to skip past
246 the header which this routine reads. */
248 /* The standard BSD tar sources create the checksum by adding up the
249 bytes in the header as type char. I think the type char was unsigned
250 on the PDP-11, but it's signed on the Next and Sun. It looks like the
251 sources to BSD tar were never changed to compute the checksum
252 correctly, so both the Sun and Next add the bytes of the header as
253 signed chars. This doesn't cause a problem until you get a file with
254 a name containing characters with the high bit set. So read_header
255 computes two checksums -- signed and unsigned. */
258 read_header (bool raw_extended_headers
)
261 int unsigned_sum
; /* the POSIX one :-) */
262 int signed_sum
; /* the Sun one :-( */
264 uintmax_t parsed_sum
;
267 union block
*header_copy
;
269 union block
*data_block
;
270 size_t size
, written
;
271 union block
*next_long_name
= 0;
272 union block
*next_long_link
= 0;
273 size_t next_long_name_blocks
;
274 size_t next_long_link_blocks
;
278 header
= find_next_block ();
279 current_header
= header
;
281 return HEADER_END_OF_FILE
;
286 for (i
= sizeof *header
; i
-- != 0;)
288 unsigned_sum
+= (unsigned char) *p
;
289 signed_sum
+= (signed char) (*p
++);
292 if (unsigned_sum
== 0)
293 return HEADER_ZERO_BLOCK
;
295 /* Adjust checksum to count the "chksum" field as blanks. */
297 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
299 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
300 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
302 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
303 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
305 parsed_sum
= from_header (header
->header
.chksum
,
306 sizeof header
->header
.chksum
, 0,
308 (uintmax_t) TYPE_MAXIMUM (int));
309 if (parsed_sum
== (uintmax_t) -1)
310 return HEADER_FAILURE
;
312 recorded_sum
= parsed_sum
;
314 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
315 return HEADER_FAILURE
;
317 /* Good block. Decode file size and return. */
319 if (header
->header
.typeflag
== XHDTYPE
320 || header
->header
.typeflag
== XGLTYPE
)
322 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
326 if (header
->header
.typeflag
== LNKTYPE
)
327 current_stat_info
.stat
.st_size
= 0; /* links 0 size on tape */
329 current_stat_info
.stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
331 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
332 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
334 if (raw_extended_headers
)
335 return HEADER_SUCCESS_EXTENDED
;
338 size_t name_size
= current_stat_info
.stat
.st_size
;
339 size
= name_size
- name_size
% BLOCKSIZE
+ 2 * BLOCKSIZE
;
340 if (name_size
!= current_stat_info
.stat
.st_size
|| size
< name_size
)
344 header_copy
= xmalloc (size
+ 1);
346 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
349 free (next_long_name
);
350 next_long_name
= header_copy
;
351 next_long_name_blocks
= size
/ BLOCKSIZE
;
356 free (next_long_link
);
357 next_long_link
= header_copy
;
358 next_long_link_blocks
= size
/ BLOCKSIZE
;
361 set_next_block_after (header
);
362 *header_copy
= *header
;
363 bp
= header_copy
->buffer
+ BLOCKSIZE
;
365 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
367 data_block
= find_next_block ();
370 ERROR ((0, 0, _("Unexpected EOF in archive")));
373 written
= available_space_after (data_block
);
377 memcpy (bp
, data_block
->buffer
, written
);
379 set_next_block_after ((union block
*)
380 (data_block
->buffer
+ written
- 1));
391 struct posix_header
const *h
= ¤t_header
->header
;
392 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
394 if (recent_long_name
)
395 free (recent_long_name
);
399 name
= next_long_name
->buffer
+ BLOCKSIZE
;
400 recent_long_name
= next_long_name
;
401 recent_long_name_blocks
= next_long_name_blocks
;
405 /* Accept file names as specified by POSIX.1-1996
409 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
411 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
412 np
[sizeof h
->prefix
] = '\0';
416 /* Prevent later references to current_header from
417 mistakenly treating this as an old GNU header.
418 This assignment invalidates h->prefix. */
419 current_header
->oldgnu_header
.isextended
= 0;
421 memcpy (np
, h
->name
, sizeof h
->name
);
422 np
[sizeof h
->name
] = '\0';
424 recent_long_name
= 0;
425 recent_long_name_blocks
= 0;
427 assign_string (¤t_stat_info
.orig_file_name
, name
);
428 assign_string (¤t_stat_info
.file_name
, name
);
429 current_stat_info
.had_trailing_slash
= strip_trailing_slashes (current_stat_info
.file_name
);
431 if (recent_long_link
)
432 free (recent_long_link
);
436 name
= next_long_link
->buffer
+ BLOCKSIZE
;
437 recent_long_link
= next_long_link
;
438 recent_long_link_blocks
= next_long_link_blocks
;
442 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
443 namebuf
[sizeof h
->linkname
] = '\0';
445 recent_long_link
= 0;
446 recent_long_link_blocks
= 0;
448 assign_string (¤t_stat_info
.link_name
, name
);
450 return HEADER_SUCCESS
;
455 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
457 /* Decode things from a file HEADER block into STAT_INFO, also setting
458 *FORMAT_POINTER depending on the header block format. If
459 DO_USER_GROUP, decode the user/group information (this is useful
460 for extraction, but waste time when merely listing).
462 read_header() has already decoded the checksum and length, so we don't.
464 This routine should *not* be called twice for the same block, since
465 the two calls might use different DO_USER_GROUP values and thus
466 might end up with different uid/gid for the two calls. If anybody
467 wants the uid/gid they should decode it first, and other callers
468 should decode it without uid/gid before calling a routine,
469 e.g. print_header, that assumes decoded data. */
471 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
472 enum archive_format
*format_pointer
, int do_user_group
)
474 enum archive_format format
;
476 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
478 if (header
->star_header
.prefix
[130] == 0
479 && ISOCTAL (header
->star_header
.atime
[0])
480 && header
->star_header
.atime
[11] == ' '
481 && ISOCTAL (header
->star_header
.ctime
[0])
482 && header
->star_header
.ctime
[11] == ' ')
483 format
= STAR_FORMAT
;
485 format
= POSIX_FORMAT
;
487 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
488 format
= OLDGNU_FORMAT
;
491 *format_pointer
= format
;
493 stat_info
->stat
.st_mode
= MODE_FROM_HEADER (header
->header
.mode
);
494 stat_info
->stat
.st_mtime
= TIME_FROM_HEADER (header
->header
.mtime
);
495 assign_string (&stat_info
->uname
, header
->header
.uname
);
496 assign_string (&stat_info
->gname
, header
->header
.gname
);
497 stat_info
->devmajor
= MAJOR_FROM_HEADER (header
->header
.devmajor
);
498 stat_info
->devminor
= MINOR_FROM_HEADER (header
->header
.devminor
);
500 if (format
== OLDGNU_FORMAT
&& incremental_option
)
502 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
503 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
506 if (format
== V7_FORMAT
)
508 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
509 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
510 stat_info
->stat
.st_rdev
= 0;
515 if (format
== STAR_FORMAT
)
517 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->star_header
.atime
);
518 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->star_header
.ctime
);
523 /* FIXME: Decide if this should somewhat depend on -p. */
525 if (numeric_owner_option
526 || !*header
->header
.uname
527 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
528 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
530 if (numeric_owner_option
531 || !*header
->header
.gname
532 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
533 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
536 switch (header
->header
.typeflag
)
540 stat_info
->stat
.st_rdev
= makedev (stat_info
->devmajor
, stat_info
->devminor
);
544 stat_info
->stat
.st_rdev
= 0;
548 if (extended_header
.size
)
549 xheader_decode (stat_info
);
552 /* Convert buffer at WHERE0 of size DIGS from external format to
553 uintmax_t. The data is of type TYPE. The buffer must represent a
554 value in the range -MINUS_MINVAL through MAXVAL. DIGS must be
555 positive. Return -1 on error, diagnosing the error if TYPE is
558 from_header (char const *where0
, size_t digs
, char const *type
,
559 uintmax_t minus_minval
, uintmax_t maxval
)
562 char const *where
= where0
;
563 char const *lim
= where
+ digs
;
566 /* Accommodate buggy tar of unknown vintage, which outputs leading
567 NUL if the previous field overflows. */
570 /* Accommodate older tars, which output leading spaces. */
577 _("Blanks in header where numeric %s value expected"),
581 if (!ISSPACE ((unsigned char) *where
))
587 if (ISODIGIT (*where
))
589 char const *where1
= where
;
590 uintmax_t overflow
= 0;
594 value
+= *where
++ - '0';
595 if (where
== lim
|| ! ISODIGIT (*where
))
597 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
601 /* Parse the output of older, unportable tars, which generate
602 negative values in two's complement octal. If the leading
603 nonzero digit is 1, we can't recover the original value
604 reliably; so do this only if the digit is 2 or more. This
605 catches the common case of 32-bit negative time stamps. */
606 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
608 /* Compute the negative of the input value, assuming two's
610 int digit
= (*where1
- '0') | 4;
618 if (where
== lim
|| ! ISODIGIT (*where
))
620 digit
= *where
- '0';
621 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
627 if (!overflow
&& value
<= minus_minval
)
630 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
631 (int) (where
- where1
), where1
, type
));
640 _("Archive octal value %.*s is out of %s range"),
641 (int) (where
- where1
), where1
, type
));
645 else if (*where
== '-' || *where
== '+')
647 /* Parse base-64 output produced only by tar test versions
648 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
649 Support for this will be withdrawn in future releases. */
651 static int warned_once
;
656 _("Archive contains obsolescent base-64 headers")));
658 negative
= *where
++ == '-';
660 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
662 if (value
<< LG_64
>> LG_64
!= value
)
664 char *string
= alloca (digs
+ 1);
665 memcpy (string
, where0
, digs
);
669 _("Archive signed base-64 string %s is out of %s range"),
670 quote (string
), type
));
673 value
= (value
<< LG_64
) | dig
;
677 else if (*where
== '\200' /* positive base-256 */
678 || *where
== '\377' /* negative base-256 */)
680 /* Parse base-256 output. A nonnegative number N is
681 represented as (256**DIGS)/2 + N; a negative number -N is
682 represented as (256**DIGS) - N, i.e. as two's complement.
683 The representation guarantees that the leading bit is
684 always on, so that we don't confuse this format with the
685 others (assuming ASCII bytes of 8 bits or more). */
686 int signbit
= *where
& (1 << (LG_256
- 2));
687 uintmax_t topbits
= (((uintmax_t) - signbit
)
688 << (CHAR_BIT
* sizeof (uintmax_t)
689 - LG_256
- (LG_256
- 2)));
690 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
693 value
= (value
<< LG_256
) + (unsigned char) *where
++;
696 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
700 _("Archive base-256 value is out of %s range"),
710 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
714 char buf
[1000]; /* Big enough to represent any header. */
715 static struct quoting_options
*o
;
719 o
= clone_quoting_options (0);
720 set_quoting_style (o
, locale_quoting_style
);
723 while (where0
!= lim
&& ! lim
[-1])
725 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
727 _("Archive contains %.*s where numeric %s value expected"),
728 (int) sizeof buf
, buf
, type
));
734 if (value
<= (negative
? minus_minval
: maxval
))
735 return negative
? -value
: value
;
739 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
740 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
741 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
742 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
743 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
745 *--value_string
= '-';
747 *--minval_string
= '-';
748 ERROR ((0, 0, _("Archive value %s is out of %s range %s.%s"),
750 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
757 gid_from_header (const char *p
, size_t s
)
759 return from_header (p
, s
, "gid_t",
760 - (uintmax_t) TYPE_MINIMUM (gid_t
),
761 (uintmax_t) TYPE_MAXIMUM (gid_t
));
765 major_from_header (const char *p
, size_t s
)
767 return from_header (p
, s
, "major_t",
768 - (uintmax_t) TYPE_MINIMUM (major_t
),
769 (uintmax_t) TYPE_MAXIMUM (major_t
));
773 minor_from_header (const char *p
, size_t s
)
775 return from_header (p
, s
, "minor_t",
776 - (uintmax_t) TYPE_MINIMUM (minor_t
),
777 (uintmax_t) TYPE_MAXIMUM (minor_t
));
781 mode_from_header (const char *p
, size_t s
)
783 /* Do not complain about unrecognized mode bits. */
784 unsigned u
= from_header (p
, s
, "mode_t",
785 - (uintmax_t) TYPE_MINIMUM (mode_t
),
786 TYPE_MAXIMUM (uintmax_t));
787 return ((u
& TSUID
? S_ISUID
: 0)
788 | (u
& TSGID
? S_ISGID
: 0)
789 | (u
& TSVTX
? S_ISVTX
: 0)
790 | (u
& TUREAD
? S_IRUSR
: 0)
791 | (u
& TUWRITE
? S_IWUSR
: 0)
792 | (u
& TUEXEC
? S_IXUSR
: 0)
793 | (u
& TGREAD
? S_IRGRP
: 0)
794 | (u
& TGWRITE
? S_IWGRP
: 0)
795 | (u
& TGEXEC
? S_IXGRP
: 0)
796 | (u
& TOREAD
? S_IROTH
: 0)
797 | (u
& TOWRITE
? S_IWOTH
: 0)
798 | (u
& TOEXEC
? S_IXOTH
: 0));
802 off_from_header (const char *p
, size_t s
)
804 /* Negative offsets are not allowed in tar files, so invoke
805 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
806 return from_header (p
, s
, "off_t", (uintmax_t) 0,
807 (uintmax_t) TYPE_MAXIMUM (off_t
));
811 size_from_header (const char *p
, size_t s
)
813 return from_header (p
, s
, "size_t", (uintmax_t) 0,
814 (uintmax_t) TYPE_MAXIMUM (size_t));
818 time_from_header (const char *p
, size_t s
)
820 return from_header (p
, s
, "time_t",
821 - (uintmax_t) TYPE_MINIMUM (time_t),
822 (uintmax_t) TYPE_MAXIMUM (time_t));
826 uid_from_header (const char *p
, size_t s
)
828 return from_header (p
, s
, "uid_t",
829 - (uintmax_t) TYPE_MINIMUM (uid_t
),
830 (uintmax_t) TYPE_MAXIMUM (uid_t
));
834 uintmax_from_header (const char *p
, size_t s
)
836 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
837 TYPE_MAXIMUM (uintmax_t));
841 /* Format O as a null-terminated decimal string into BUF _backwards_;
842 return pointer to start of result. */
844 stringify_uintmax_t_backwards (uintmax_t o
, char *buf
)
848 *--buf
= '0' + (int) (o
% 10);
849 while ((o
/= 10) != 0);
853 /* Return a printable representation of T. The result points to
854 static storage that can be reused in the next call to this
855 function, to ctime, or to asctime. */
859 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
860 INT_STRLEN_BOUND (int) + 16)];
867 char const *time_stamp
= p
+ 4;
868 for (p
+= 16; p
[3] != '\n'; p
++)
874 /* Use ISO 8610 format. See:
875 http://www.cl.cam.ac.uk/~mgk25/iso-time.html */
876 struct tm
*tm
= localtime (&t
);
879 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
880 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
881 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
886 /* The time stamp cannot be broken down, most likely because it
887 is out of range. Convert it as an integer,
888 right-adjusted in a field with the same width as the usual
889 19-byte 4-year ISO time format. */
890 p
= stringify_uintmax_t_backwards (t
< 0 ? - (uintmax_t) t
: (uintmax_t) t
,
891 buffer
+ sizeof buffer
);
894 while (buffer
+ sizeof buffer
- 19 - 1 < p
)
899 /* Actually print it.
901 Plain and fancy file header block logging. Non-verbose just prints
902 the name, e.g. for "tar t" or "tar x". This should just contain
903 file names, so it can be fed back into tar with xargs or the "-T"
904 option. The verbose option can give a bunch of info, one line per
905 file. I doubt anybody tries to parse its format, or if they do,
906 they shouldn't. Unix tar is pretty random here anyway. */
909 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
910 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
912 /* UGSWIDTH starts with 18, so with user and group names <= 8 chars, the
913 columns never shift during the listing. */
915 static int ugswidth
= UGSWIDTH
; /* maximum width encountered so far */
917 /* DATEWIDTH is the number of columns taken by the date and time fields. */
919 # define DATEWIDTH 19
921 # define DATEWIDTH 18
925 print_header (off_t block_ordinal
)
928 char const *time_stamp
;
929 char *temp_name
= current_stat_info
.orig_file_name
? current_stat_info
.orig_file_name
: current_stat_info
.file_name
;
931 /* These hold formatted ints. */
932 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
934 char size
[2 * UINTMAX_STRSIZE_BOUND
];
935 /* holds formatted size or major,minor */
936 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
939 if (block_number_option
)
941 char buf
[UINTMAX_STRSIZE_BOUND
];
942 if (block_ordinal
< 0)
943 block_ordinal
= current_block_ordinal ();
944 block_ordinal
-= recent_long_name_blocks
;
945 block_ordinal
-= recent_long_link_blocks
;
946 fprintf (stdlis
, _("block %s: "),
947 STRINGIFY_BIGINT (block_ordinal
, buf
));
950 if (verbose_option
<= 1)
952 /* Just the fax, mam. */
953 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
957 /* File type and modes. */
960 switch (current_header
->header
.typeflag
)
966 case GNUTYPE_MULTIVOL
:
974 case GNUTYPE_LONGNAME
:
975 case GNUTYPE_LONGLINK
:
977 ERROR ((0, 0, _("Visible longname error")));
984 if (temp_name
[strlen (temp_name
) - 1] == '/')
990 case GNUTYPE_DUMPDIR
:
1013 decode_mode (current_stat_info
.stat
.st_mode
, modes
+ 1);
1017 time_stamp
= tartime (current_stat_info
.stat
.st_mtime
);
1019 /* User and group names. */
1021 if (current_stat_info
.uname
&& current_format
!= V7_FORMAT
1022 && !numeric_owner_option
)
1023 user
= current_stat_info
.uname
;
1026 /* Try parsing it as an unsigned integer first, and as a
1027 uid_t if that fails. This method can list positive user
1028 ids that are too large to fit in a uid_t. */
1029 uintmax_t u
= from_header (current_header
->header
.uid
,
1030 sizeof current_header
->header
.uid
, 0,
1032 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1034 user
= STRINGIFY_BIGINT (u
, uform
);
1037 sprintf (uform
, "%ld",
1038 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1043 if (current_stat_info
.gname
&& current_format
!= V7_FORMAT
1044 && !numeric_owner_option
)
1045 group
= current_stat_info
.gname
;
1048 /* Try parsing it as an unsigned integer first, and as a
1049 gid_t if that fails. This method can list positive group
1050 ids that are too large to fit in a gid_t. */
1051 uintmax_t g
= from_header (current_header
->header
.gid
,
1052 sizeof current_header
->header
.gid
, 0,
1054 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1056 group
= STRINGIFY_BIGINT (g
, gform
);
1059 sprintf (gform
, "%ld",
1060 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1065 /* Format the file size or major/minor device numbers. */
1067 switch (current_header
->header
.typeflag
)
1072 STRINGIFY_BIGINT (major (current_stat_info
.stat
.st_rdev
), uintbuf
));
1075 STRINGIFY_BIGINT (minor (current_stat_info
.stat
.st_rdev
), uintbuf
));
1077 case GNUTYPE_SPARSE
:
1080 (UINTMAX_FROM_HEADER (current_header
1081 ->oldgnu_header
.realsize
),
1085 strcpy (size
, STRINGIFY_BIGINT (current_stat_info
.stat
.st_size
, uintbuf
));
1089 /* Figure out padding and print the whole line. */
1091 pad
= strlen (user
) + strlen (group
) + strlen (size
) + 1;
1095 fprintf (stdlis
, "%s %s/%s %*s%s %s",
1096 modes
, user
, group
, ugswidth
- pad
, "", size
, time_stamp
);
1098 fprintf (stdlis
, " %s", quotearg (temp_name
));
1100 switch (current_header
->header
.typeflag
)
1103 fprintf (stdlis
, " -> %s\n", quotearg (current_stat_info
.link_name
));
1107 fprintf (stdlis
, _(" link to %s\n"), quotearg (current_stat_info
.link_name
));
1112 char type_string
[2];
1113 type_string
[0] = current_header
->header
.typeflag
;
1114 type_string
[1] = '\0';
1115 fprintf (stdlis
, _(" unknown file type %s\n"),
1116 quote (type_string
));
1122 case GNUTYPE_SPARSE
:
1128 case GNUTYPE_DUMPDIR
:
1129 putc ('\n', stdlis
);
1132 case GNUTYPE_LONGLINK
:
1133 fprintf (stdlis
, _("--Long Link--\n"));
1136 case GNUTYPE_LONGNAME
:
1137 fprintf (stdlis
, _("--Long Name--\n"));
1140 case GNUTYPE_VOLHDR
:
1141 fprintf (stdlis
, _("--Volume Header--\n"));
1144 case GNUTYPE_MULTIVOL
:
1147 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1149 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1153 fprintf (stdlis
, _("--Mangled file names--\n"));
1160 /* Print a similar line when we make a directory automatically. */
1162 print_for_mkdir (char *pathname
, int length
, mode_t mode
)
1166 if (verbose_option
> 1)
1168 /* File type and modes. */
1171 decode_mode (mode
, modes
+ 1);
1173 if (block_number_option
)
1175 char buf
[UINTMAX_STRSIZE_BOUND
];
1176 fprintf (stdlis
, _("block %s: "),
1177 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1180 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ DATEWIDTH
,
1181 _("Creating directory:"), length
, quotearg (pathname
));
1185 /* Skip over SIZE bytes of data in blocks in the archive. */
1187 skip_file (off_t size
)
1191 if (multi_volume_option
)
1193 save_totsize
= size
;
1194 save_sizeleft
= size
;
1199 x
= find_next_block ();
1201 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1203 set_next_block_after (x
);
1205 if (multi_volume_option
)
1206 save_sizeleft
-= BLOCKSIZE
;
1210 /* Skip the current member in the archive. */
1214 char save_typeflag
= current_header
->header
.typeflag
;
1215 set_next_block_after (current_header
);
1217 if (current_format
== OLDGNU_FORMAT
1218 && current_header
->oldgnu_header
.isextended
)
1223 exhdr
= find_next_block ();
1225 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1226 set_next_block_after (exhdr
);
1228 while (exhdr
->sparse_header
.isextended
);
1231 if (save_typeflag
!= DIRTYPE
)
1232 skip_file (current_stat_info
.stat
.st_size
);