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
)));
144 status
= prev_status
;
147 case HEADER_END_OF_FILE
:
148 if (block_number_option
)
150 char buf
[UINTMAX_STRSIZE_BOUND
];
151 fprintf (stdlis
, _("block %s: ** End of File **\n"),
152 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
157 /* If the previous header was good, tell them that we are
158 skipping bad ones. */
159 set_next_block_after (current_header
);
162 case HEADER_STILL_UNREAD
:
163 ERROR ((0, 0, _("This does not look like a tar archive")));
166 case HEADER_ZERO_BLOCK
:
168 ERROR ((0, 0, _("Skipping to next header")));
171 case HEADER_END_OF_FILE
:
173 /* We are in the middle of a cascade of errors. */
176 case HEADER_SUCCESS_EXTENDED
:
183 while (!all_names_found (¤t_stat_info
));
186 names_notfound (); /* print names not found */
189 /* Print a header block, based on tar options. */
193 /* Print the header block. */
195 decode_header (current_header
, ¤t_stat_info
, ¤t_format
, 0);
197 print_header (¤t_stat_info
, -1);
199 if (incremental_option
&& current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
202 size_t written
, check
;
203 union block
*data_block
;
205 set_next_block_after (current_header
);
206 if (multi_volume_option
)
208 assign_string (&save_name
, current_stat_info
.file_name
);
209 save_totsize
= current_stat_info
.stat
.st_size
;
211 for (size
= current_stat_info
.stat
.st_size
; size
> 0; size
-= written
)
213 if (multi_volume_option
)
214 save_sizeleft
= size
;
215 data_block
= find_next_block ();
218 ERROR ((0, 0, _("Unexpected EOF in archive")));
219 break; /* FIXME: What happens, then? */
221 written
= available_space_after (data_block
);
225 check
= fwrite (data_block
->buffer
, sizeof (char), written
, stdlis
);
226 set_next_block_after ((union block
*)
227 (data_block
->buffer
+ written
- 1));
228 if (check
!= written
)
230 write_error_details (current_stat_info
.file_name
, check
, written
);
231 skip_file (size
- written
);
235 if (multi_volume_option
)
236 assign_string (&save_name
, 0);
237 fputc ('\n', stdlis
);
243 if (multi_volume_option
)
244 assign_string (&save_name
, current_stat_info
.file_name
);
248 if (multi_volume_option
)
249 assign_string (&save_name
, 0);
252 /* Read a block that's supposed to be a header block. Return its
253 address in "current_header", and if it is good, the file's size in
254 current_stat_info.stat.st_size.
256 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
257 block full of zeros (EOF marker).
259 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
260 GNU long name and link headers into later headers.
262 You must always set_next_block_after(current_header) to skip past
263 the header which this routine reads. */
265 /* The standard BSD tar sources create the checksum by adding up the
266 bytes in the header as type char. I think the type char was unsigned
267 on the PDP-11, but it's signed on the Next and Sun. It looks like the
268 sources to BSD tar were never changed to compute the checksum
269 correctly, so both the Sun and Next add the bytes of the header as
270 signed chars. This doesn't cause a problem until you get a file with
271 a name containing characters with the high bit set. So read_header
272 computes two checksums -- signed and unsigned. */
275 read_header (bool raw_extended_headers
)
278 int unsigned_sum
; /* the POSIX one :-) */
279 int signed_sum
; /* the Sun one :-( */
281 uintmax_t parsed_sum
;
284 union block
*header_copy
;
286 union block
*data_block
;
287 size_t size
, written
;
288 union block
*next_long_name
= 0;
289 union block
*next_long_link
= 0;
290 size_t next_long_name_blocks
;
291 size_t next_long_link_blocks
;
295 header
= find_next_block ();
296 current_header
= header
;
298 return HEADER_END_OF_FILE
;
303 for (i
= sizeof *header
; i
-- != 0;)
305 unsigned_sum
+= (unsigned char) *p
;
306 signed_sum
+= (signed char) (*p
++);
309 if (unsigned_sum
== 0)
310 return HEADER_ZERO_BLOCK
;
312 /* Adjust checksum to count the "chksum" field as blanks. */
314 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
316 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
317 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
319 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
320 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
322 parsed_sum
= from_header (header
->header
.chksum
,
323 sizeof header
->header
.chksum
, 0,
325 (uintmax_t) TYPE_MAXIMUM (int));
326 if (parsed_sum
== (uintmax_t) -1)
327 return HEADER_FAILURE
;
329 recorded_sum
= parsed_sum
;
331 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
332 return HEADER_FAILURE
;
334 /* Good block. Decode file size and return. */
336 if (header
->header
.typeflag
== LNKTYPE
)
337 current_stat_info
.stat
.st_size
= 0; /* links 0 size on tape */
339 current_stat_info
.stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
341 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
342 || header
->header
.typeflag
== GNUTYPE_LONGLINK
343 || header
->header
.typeflag
== XHDTYPE
344 || header
->header
.typeflag
== XGLTYPE
)
346 if (raw_extended_headers
)
347 return HEADER_SUCCESS_EXTENDED
;
348 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
349 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
351 size_t name_size
= current_stat_info
.stat
.st_size
;
352 size
= name_size
- name_size
% BLOCKSIZE
+ 2 * BLOCKSIZE
;
353 if (name_size
!= current_stat_info
.stat
.st_size
357 header_copy
= xmalloc (size
+ 1);
359 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
362 free (next_long_name
);
363 next_long_name
= header_copy
;
364 next_long_name_blocks
= size
/ BLOCKSIZE
;
369 free (next_long_link
);
370 next_long_link
= header_copy
;
371 next_long_link_blocks
= size
/ BLOCKSIZE
;
374 set_next_block_after (header
);
375 *header_copy
= *header
;
376 bp
= header_copy
->buffer
+ BLOCKSIZE
;
378 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
380 data_block
= find_next_block ();
383 ERROR ((0, 0, _("Unexpected EOF in archive")));
386 written
= available_space_after (data_block
);
390 memcpy (bp
, data_block
->buffer
, written
);
392 set_next_block_after ((union block
*)
393 (data_block
->buffer
+ written
- 1));
398 else if (header
->header
.typeflag
== XHDTYPE
399 || header
->header
.typeflag
== XGLTYPE
)
400 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
408 struct posix_header
const *h
= ¤t_header
->header
;
409 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
411 if (recent_long_name
)
412 free (recent_long_name
);
416 name
= next_long_name
->buffer
+ BLOCKSIZE
;
417 recent_long_name
= next_long_name
;
418 recent_long_name_blocks
= next_long_name_blocks
;
422 /* Accept file names as specified by POSIX.1-1996
426 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
428 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
429 np
[sizeof h
->prefix
] = '\0';
433 /* Prevent later references to current_header from
434 mistakenly treating this as an old GNU header.
435 This assignment invalidates h->prefix. */
436 current_header
->oldgnu_header
.isextended
= 0;
438 memcpy (np
, h
->name
, sizeof h
->name
);
439 np
[sizeof h
->name
] = '\0';
441 recent_long_name
= 0;
442 recent_long_name_blocks
= 0;
444 assign_string (¤t_stat_info
.orig_file_name
, name
);
445 assign_string (¤t_stat_info
.file_name
, name
);
446 current_stat_info
.had_trailing_slash
= strip_trailing_slashes (current_stat_info
.file_name
);
448 if (recent_long_link
)
449 free (recent_long_link
);
453 name
= next_long_link
->buffer
+ BLOCKSIZE
;
454 recent_long_link
= next_long_link
;
455 recent_long_link_blocks
= next_long_link_blocks
;
459 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
460 namebuf
[sizeof h
->linkname
] = '\0';
462 recent_long_link
= 0;
463 recent_long_link_blocks
= 0;
465 assign_string (¤t_stat_info
.link_name
, name
);
467 return HEADER_SUCCESS
;
472 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
474 /* Decode things from a file HEADER block into STAT_INFO, also setting
475 *FORMAT_POINTER depending on the header block format. If
476 DO_USER_GROUP, decode the user/group information (this is useful
477 for extraction, but waste time when merely listing).
479 read_header() has already decoded the checksum and length, so we don't.
481 This routine should *not* be called twice for the same block, since
482 the two calls might use different DO_USER_GROUP values and thus
483 might end up with different uid/gid for the two calls. If anybody
484 wants the uid/gid they should decode it first, and other callers
485 should decode it without uid/gid before calling a routine,
486 e.g. print_header, that assumes decoded data. */
488 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
489 enum archive_format
*format_pointer
, int do_user_group
)
491 enum archive_format format
;
493 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
495 if (header
->star_header
.prefix
[130] == 0
496 && ISOCTAL (header
->star_header
.atime
[0])
497 && header
->star_header
.atime
[11] == ' '
498 && ISOCTAL (header
->star_header
.ctime
[0])
499 && header
->star_header
.ctime
[11] == ' ')
500 format
= STAR_FORMAT
;
501 else if (extended_header
.size
)
502 format
= POSIX_FORMAT
;
504 format
= USTAR_FORMAT
;
506 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
507 format
= OLDGNU_FORMAT
;
510 *format_pointer
= format
;
512 stat_info
->stat
.st_mode
= MODE_FROM_HEADER (header
->header
.mode
);
513 stat_info
->stat
.st_mtime
= TIME_FROM_HEADER (header
->header
.mtime
);
514 assign_string (&stat_info
->uname
, header
->header
.uname
);
515 assign_string (&stat_info
->gname
, header
->header
.gname
);
516 stat_info
->devmajor
= MAJOR_FROM_HEADER (header
->header
.devmajor
);
517 stat_info
->devminor
= MINOR_FROM_HEADER (header
->header
.devminor
);
519 stat_info
->stat
.st_atime
= start_time
;
520 stat_info
->stat
.st_ctime
= start_time
;
522 if (format
== OLDGNU_FORMAT
&& incremental_option
)
524 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
525 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
528 if (format
== V7_FORMAT
)
530 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
531 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
532 stat_info
->stat
.st_rdev
= 0;
537 if (format
== STAR_FORMAT
)
539 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->star_header
.atime
);
540 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->star_header
.ctime
);
545 /* FIXME: Decide if this should somewhat depend on -p. */
547 if (numeric_owner_option
548 || !*header
->header
.uname
549 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
550 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
552 if (numeric_owner_option
553 || !*header
->header
.gname
554 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
555 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
558 switch (header
->header
.typeflag
)
562 stat_info
->stat
.st_rdev
= makedev (stat_info
->devmajor
, stat_info
->devminor
);
566 stat_info
->stat
.st_rdev
= 0;
570 current_stat_info
.archive_file_size
= current_stat_info
.stat
.st_size
;
571 if (extended_header
.size
)
572 xheader_decode (stat_info
);
575 /* Convert buffer at WHERE0 of size DIGS from external format to
576 uintmax_t. The data is of type TYPE. The buffer must represent a
577 value in the range -MINUS_MINVAL through MAXVAL. DIGS must be
578 positive. Return -1 on error, diagnosing the error if TYPE is
581 from_header (char const *where0
, size_t digs
, char const *type
,
582 uintmax_t minus_minval
, uintmax_t maxval
)
585 char const *where
= where0
;
586 char const *lim
= where
+ digs
;
589 /* Accommodate buggy tar of unknown vintage, which outputs leading
590 NUL if the previous field overflows. */
593 /* Accommodate older tars, which output leading spaces. */
600 _("Blanks in header where numeric %s value expected"),
604 if (!ISSPACE ((unsigned char) *where
))
610 if (ISODIGIT (*where
))
612 char const *where1
= where
;
613 uintmax_t overflow
= 0;
617 value
+= *where
++ - '0';
618 if (where
== lim
|| ! ISODIGIT (*where
))
620 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
624 /* Parse the output of older, unportable tars, which generate
625 negative values in two's complement octal. If the leading
626 nonzero digit is 1, we can't recover the original value
627 reliably; so do this only if the digit is 2 or more. This
628 catches the common case of 32-bit negative time stamps. */
629 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
631 /* Compute the negative of the input value, assuming two's
633 int digit
= (*where1
- '0') | 4;
641 if (where
== lim
|| ! ISODIGIT (*where
))
643 digit
= *where
- '0';
644 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
650 if (!overflow
&& value
<= minus_minval
)
653 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
654 (int) (where
- where1
), where1
, type
));
663 _("Archive octal value %.*s is out of %s range"),
664 (int) (where
- where1
), where1
, type
));
668 else if (*where
== '-' || *where
== '+')
670 /* Parse base-64 output produced only by tar test versions
671 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
672 Support for this will be withdrawn in future releases. */
674 static int warned_once
;
679 _("Archive contains obsolescent base-64 headers")));
681 negative
= *where
++ == '-';
683 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
685 if (value
<< LG_64
>> LG_64
!= value
)
687 char *string
= alloca (digs
+ 1);
688 memcpy (string
, where0
, digs
);
692 _("Archive signed base-64 string %s is out of %s range"),
693 quote (string
), type
));
696 value
= (value
<< LG_64
) | dig
;
700 else if (*where
== '\200' /* positive base-256 */
701 || *where
== '\377' /* negative base-256 */)
703 /* Parse base-256 output. A nonnegative number N is
704 represented as (256**DIGS)/2 + N; a negative number -N is
705 represented as (256**DIGS) - N, i.e. as two's complement.
706 The representation guarantees that the leading bit is
707 always on, so that we don't confuse this format with the
708 others (assuming ASCII bytes of 8 bits or more). */
709 int signbit
= *where
& (1 << (LG_256
- 2));
710 uintmax_t topbits
= (((uintmax_t) - signbit
)
711 << (CHAR_BIT
* sizeof (uintmax_t)
712 - LG_256
- (LG_256
- 2)));
713 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
716 value
= (value
<< LG_256
) + (unsigned char) *where
++;
719 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
723 _("Archive base-256 value is out of %s range"),
733 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
737 char buf
[1000]; /* Big enough to represent any header. */
738 static struct quoting_options
*o
;
742 o
= clone_quoting_options (0);
743 set_quoting_style (o
, locale_quoting_style
);
746 while (where0
!= lim
&& ! lim
[-1])
748 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
750 _("Archive contains %.*s where numeric %s value expected"),
751 (int) sizeof buf
, buf
, type
));
757 if (value
<= (negative
? minus_minval
: maxval
))
758 return negative
? -value
: value
;
762 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
763 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
764 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
765 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
766 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
768 *--value_string
= '-';
770 *--minval_string
= '-';
771 ERROR ((0, 0, _("Archive value %s is out of %s range %s.%s"),
773 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
780 gid_from_header (const char *p
, size_t s
)
782 return from_header (p
, s
, "gid_t",
783 - (uintmax_t) TYPE_MINIMUM (gid_t
),
784 (uintmax_t) TYPE_MAXIMUM (gid_t
));
788 major_from_header (const char *p
, size_t s
)
790 return from_header (p
, s
, "major_t",
791 - (uintmax_t) TYPE_MINIMUM (major_t
),
792 (uintmax_t) TYPE_MAXIMUM (major_t
));
796 minor_from_header (const char *p
, size_t s
)
798 return from_header (p
, s
, "minor_t",
799 - (uintmax_t) TYPE_MINIMUM (minor_t
),
800 (uintmax_t) TYPE_MAXIMUM (minor_t
));
804 mode_from_header (const char *p
, size_t s
)
806 /* Do not complain about unrecognized mode bits. */
807 unsigned u
= from_header (p
, s
, "mode_t",
808 - (uintmax_t) TYPE_MINIMUM (mode_t
),
809 TYPE_MAXIMUM (uintmax_t));
810 return ((u
& TSUID
? S_ISUID
: 0)
811 | (u
& TSGID
? S_ISGID
: 0)
812 | (u
& TSVTX
? S_ISVTX
: 0)
813 | (u
& TUREAD
? S_IRUSR
: 0)
814 | (u
& TUWRITE
? S_IWUSR
: 0)
815 | (u
& TUEXEC
? S_IXUSR
: 0)
816 | (u
& TGREAD
? S_IRGRP
: 0)
817 | (u
& TGWRITE
? S_IWGRP
: 0)
818 | (u
& TGEXEC
? S_IXGRP
: 0)
819 | (u
& TOREAD
? S_IROTH
: 0)
820 | (u
& TOWRITE
? S_IWOTH
: 0)
821 | (u
& TOEXEC
? S_IXOTH
: 0));
825 off_from_header (const char *p
, size_t s
)
827 /* Negative offsets are not allowed in tar files, so invoke
828 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
829 return from_header (p
, s
, "off_t", (uintmax_t) 0,
830 (uintmax_t) TYPE_MAXIMUM (off_t
));
834 size_from_header (const char *p
, size_t s
)
836 return from_header (p
, s
, "size_t", (uintmax_t) 0,
837 (uintmax_t) TYPE_MAXIMUM (size_t));
841 time_from_header (const char *p
, size_t s
)
843 return from_header (p
, s
, "time_t",
844 - (uintmax_t) TYPE_MINIMUM (time_t),
845 (uintmax_t) TYPE_MAXIMUM (time_t));
849 uid_from_header (const char *p
, size_t s
)
851 return from_header (p
, s
, "uid_t",
852 - (uintmax_t) TYPE_MINIMUM (uid_t
),
853 (uintmax_t) TYPE_MAXIMUM (uid_t
));
857 uintmax_from_header (const char *p
, size_t s
)
859 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
860 TYPE_MAXIMUM (uintmax_t));
864 /* Format O as a null-terminated decimal string into BUF _backwards_;
865 return pointer to start of result. */
867 stringify_uintmax_t_backwards (uintmax_t o
, char *buf
)
871 *--buf
= '0' + (int) (o
% 10);
872 while ((o
/= 10) != 0);
876 /* Return a printable representation of T. The result points to
877 static storage that can be reused in the next call to this
878 function, to ctime, or to asctime. */
882 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
883 INT_STRLEN_BOUND (int) + 16)];
890 char const *time_stamp
= p
+ 4;
891 for (p
+= 16; p
[3] != '\n'; p
++)
897 /* Use ISO 8610 format. See:
898 http://www.cl.cam.ac.uk/~mgk25/iso-time.html */
899 struct tm
*tm
= localtime (&t
);
902 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
903 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
904 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
909 /* The time stamp cannot be broken down, most likely because it
910 is out of range. Convert it as an integer,
911 right-adjusted in a field with the same width as the usual
912 19-byte 4-year ISO time format. */
913 p
= stringify_uintmax_t_backwards (t
< 0 ? - (uintmax_t) t
: (uintmax_t) t
,
914 buffer
+ sizeof buffer
);
917 while (buffer
+ sizeof buffer
- 19 - 1 < p
)
922 /* Actually print it.
924 Plain and fancy file header block logging. Non-verbose just prints
925 the name, e.g. for "tar t" or "tar x". This should just contain
926 file names, so it can be fed back into tar with xargs or the "-T"
927 option. The verbose option can give a bunch of info, one line per
928 file. I doubt anybody tries to parse its format, or if they do,
929 they shouldn't. Unix tar is pretty random here anyway. */
932 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
933 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
935 /* UGSWIDTH starts with 18, so with user and group names <= 8 chars, the
936 columns never shift during the listing. */
938 static int ugswidth
= UGSWIDTH
; /* maximum width encountered so far */
940 /* DATEWIDTH is the number of columns taken by the date and time fields. */
942 # define DATEWIDTH 19
944 # define DATEWIDTH 18
948 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
951 char const *time_stamp
;
952 char *temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
954 /* These hold formatted ints. */
955 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
957 char size
[2 * UINTMAX_STRSIZE_BOUND
];
958 /* holds formatted size or major,minor */
959 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
962 if (block_number_option
)
964 char buf
[UINTMAX_STRSIZE_BOUND
];
965 if (block_ordinal
< 0)
966 block_ordinal
= current_block_ordinal ();
967 block_ordinal
-= recent_long_name_blocks
;
968 block_ordinal
-= recent_long_link_blocks
;
969 fprintf (stdlis
, _("block %s: "),
970 STRINGIFY_BIGINT (block_ordinal
, buf
));
973 if (verbose_option
<= 1)
975 /* Just the fax, mam. */
976 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
980 /* File type and modes. */
983 switch (current_header
->header
.typeflag
)
989 case GNUTYPE_MULTIVOL
:
997 case GNUTYPE_LONGNAME
:
998 case GNUTYPE_LONGLINK
:
1000 ERROR ((0, 0, _("Visible longname error")));
1003 case GNUTYPE_SPARSE
:
1007 if (temp_name
[strlen (temp_name
) - 1] == '/')
1013 case GNUTYPE_DUMPDIR
:
1036 decode_mode (st
->stat
.st_mode
, modes
+ 1);
1040 time_stamp
= tartime (st
->stat
.st_mtime
);
1042 /* User and group names. */
1044 if (st
->uname
&& current_format
!= V7_FORMAT
1045 && !numeric_owner_option
)
1049 /* Try parsing it as an unsigned integer first, and as a
1050 uid_t if that fails. This method can list positive user
1051 ids that are too large to fit in a uid_t. */
1052 uintmax_t u
= from_header (current_header
->header
.uid
,
1053 sizeof current_header
->header
.uid
, 0,
1055 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1057 user
= STRINGIFY_BIGINT (u
, uform
);
1060 sprintf (uform
, "%ld",
1061 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1066 if (st
->gname
&& current_format
!= V7_FORMAT
1067 && !numeric_owner_option
)
1071 /* Try parsing it as an unsigned integer first, and as a
1072 gid_t if that fails. This method can list positive group
1073 ids that are too large to fit in a gid_t. */
1074 uintmax_t g
= from_header (current_header
->header
.gid
,
1075 sizeof current_header
->header
.gid
, 0,
1077 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1079 group
= STRINGIFY_BIGINT (g
, gform
);
1082 sprintf (gform
, "%ld",
1083 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1088 /* Format the file size or major/minor device numbers. */
1090 switch (current_header
->header
.typeflag
)
1095 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1098 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1100 case GNUTYPE_SPARSE
:
1103 (UINTMAX_FROM_HEADER (current_header
1104 ->oldgnu_header
.realsize
),
1108 /* st->stat.st_size keeps stored file size */
1109 strcpy (size
, STRINGIFY_BIGINT (st
->archive_file_size
, uintbuf
));
1113 /* Figure out padding and print the whole line. */
1115 pad
= strlen (user
) + strlen (group
) + strlen (size
) + 1;
1119 fprintf (stdlis
, "%s %s/%s %*s%s %s",
1120 modes
, user
, group
, ugswidth
- pad
, "", size
, time_stamp
);
1122 fprintf (stdlis
, " %s", quotearg (temp_name
));
1124 switch (current_header
->header
.typeflag
)
1127 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1131 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1136 char type_string
[2];
1137 type_string
[0] = current_header
->header
.typeflag
;
1138 type_string
[1] = '\0';
1139 fprintf (stdlis
, _(" unknown file type %s\n"),
1140 quote (type_string
));
1146 case GNUTYPE_SPARSE
:
1152 case GNUTYPE_DUMPDIR
:
1153 putc ('\n', stdlis
);
1156 case GNUTYPE_LONGLINK
:
1157 fprintf (stdlis
, _("--Long Link--\n"));
1160 case GNUTYPE_LONGNAME
:
1161 fprintf (stdlis
, _("--Long Name--\n"));
1164 case GNUTYPE_VOLHDR
:
1165 fprintf (stdlis
, _("--Volume Header--\n"));
1168 case GNUTYPE_MULTIVOL
:
1171 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1173 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1177 fprintf (stdlis
, _("--Mangled file names--\n"));
1184 /* Print a similar line when we make a directory automatically. */
1186 print_for_mkdir (char *pathname
, int length
, mode_t mode
)
1190 if (verbose_option
> 1)
1192 /* File type and modes. */
1195 decode_mode (mode
, modes
+ 1);
1197 if (block_number_option
)
1199 char buf
[UINTMAX_STRSIZE_BOUND
];
1200 fprintf (stdlis
, _("block %s: "),
1201 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1204 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ DATEWIDTH
,
1205 _("Creating directory:"), length
, quotearg (pathname
));
1209 /* Skip over SIZE bytes of data in blocks in the archive. */
1211 skip_file (off_t size
)
1215 if (multi_volume_option
)
1217 save_totsize
= size
;
1218 save_sizeleft
= size
;
1223 x
= find_next_block ();
1225 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1227 set_next_block_after (x
);
1229 if (multi_volume_option
)
1230 save_sizeleft
-= BLOCKSIZE
;
1234 /* Skip the current member in the archive. */
1238 char save_typeflag
= current_header
->header
.typeflag
;
1239 set_next_block_after (current_header
);
1241 if (current_format
== OLDGNU_FORMAT
1242 && current_header
->oldgnu_header
.isextended
)
1247 exhdr
= find_next_block ();
1249 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1250 set_next_block_after (exhdr
);
1252 while (exhdr
->sparse_header
.isextended
);
1255 if (save_typeflag
!= DIRTYPE
)
1256 skip_file (current_stat_info
.stat
.st_size
);