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 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
400 else if (header
->header
.typeflag
== XGLTYPE
)
402 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
403 xheader_decode_global ();
412 struct posix_header
const *h
= ¤t_header
->header
;
413 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
415 if (recent_long_name
)
416 free (recent_long_name
);
420 name
= next_long_name
->buffer
+ BLOCKSIZE
;
421 recent_long_name
= next_long_name
;
422 recent_long_name_blocks
= next_long_name_blocks
;
426 /* Accept file names as specified by POSIX.1-1996
430 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
432 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
433 np
[sizeof h
->prefix
] = '\0';
437 /* Prevent later references to current_header from
438 mistakenly treating this as an old GNU header.
439 This assignment invalidates h->prefix. */
440 current_header
->oldgnu_header
.isextended
= 0;
442 memcpy (np
, h
->name
, sizeof h
->name
);
443 np
[sizeof h
->name
] = '\0';
445 recent_long_name
= 0;
446 recent_long_name_blocks
= 0;
448 assign_string (¤t_stat_info
.orig_file_name
, name
);
449 assign_string (¤t_stat_info
.file_name
, name
);
450 current_stat_info
.had_trailing_slash
= strip_trailing_slashes (current_stat_info
.file_name
);
452 if (recent_long_link
)
453 free (recent_long_link
);
457 name
= next_long_link
->buffer
+ BLOCKSIZE
;
458 recent_long_link
= next_long_link
;
459 recent_long_link_blocks
= next_long_link_blocks
;
463 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
464 namebuf
[sizeof h
->linkname
] = '\0';
466 recent_long_link
= 0;
467 recent_long_link_blocks
= 0;
469 assign_string (¤t_stat_info
.link_name
, name
);
471 return HEADER_SUCCESS
;
476 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
478 /* Decode things from a file HEADER block into STAT_INFO, also setting
479 *FORMAT_POINTER depending on the header block format. If
480 DO_USER_GROUP, decode the user/group information (this is useful
481 for extraction, but waste time when merely listing).
483 read_header() has already decoded the checksum and length, so we don't.
485 This routine should *not* be called twice for the same block, since
486 the two calls might use different DO_USER_GROUP values and thus
487 might end up with different uid/gid for the two calls. If anybody
488 wants the uid/gid they should decode it first, and other callers
489 should decode it without uid/gid before calling a routine,
490 e.g. print_header, that assumes decoded data. */
492 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
493 enum archive_format
*format_pointer
, int do_user_group
)
495 enum archive_format format
;
497 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
499 if (header
->star_header
.prefix
[130] == 0
500 && ISOCTAL (header
->star_header
.atime
[0])
501 && header
->star_header
.atime
[11] == ' '
502 && ISOCTAL (header
->star_header
.ctime
[0])
503 && header
->star_header
.ctime
[11] == ' ')
504 format
= STAR_FORMAT
;
505 else if (extended_header
.size
)
506 format
= POSIX_FORMAT
;
508 format
= USTAR_FORMAT
;
510 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
511 format
= OLDGNU_FORMAT
;
514 *format_pointer
= format
;
516 stat_info
->stat
.st_mode
= MODE_FROM_HEADER (header
->header
.mode
);
517 stat_info
->stat
.st_mtime
= TIME_FROM_HEADER (header
->header
.mtime
);
518 assign_string (&stat_info
->uname
, header
->header
.uname
);
519 assign_string (&stat_info
->gname
, header
->header
.gname
);
520 stat_info
->devmajor
= MAJOR_FROM_HEADER (header
->header
.devmajor
);
521 stat_info
->devminor
= MINOR_FROM_HEADER (header
->header
.devminor
);
523 stat_info
->stat
.st_atime
= start_time
;
524 stat_info
->stat
.st_ctime
= start_time
;
526 if (format
== OLDGNU_FORMAT
&& incremental_option
)
528 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
529 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
532 if (format
== V7_FORMAT
)
534 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
535 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
536 stat_info
->stat
.st_rdev
= 0;
541 if (format
== STAR_FORMAT
)
543 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->star_header
.atime
);
544 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->star_header
.ctime
);
549 /* FIXME: Decide if this should somewhat depend on -p. */
551 if (numeric_owner_option
552 || !*header
->header
.uname
553 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
554 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
556 if (numeric_owner_option
557 || !*header
->header
.gname
558 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
559 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
562 switch (header
->header
.typeflag
)
566 stat_info
->stat
.st_rdev
= makedev (stat_info
->devmajor
, stat_info
->devminor
);
570 stat_info
->stat
.st_rdev
= 0;
574 current_stat_info
.archive_file_size
= current_stat_info
.stat
.st_size
;
575 xheader_decode (stat_info
);
578 /* Convert buffer at WHERE0 of size DIGS from external format to
579 uintmax_t. The data is of type TYPE. The buffer must represent a
580 value in the range -MINUS_MINVAL through MAXVAL. DIGS must be
581 positive. Return -1 on error, diagnosing the error if TYPE is
584 from_header (char const *where0
, size_t digs
, char const *type
,
585 uintmax_t minus_minval
, uintmax_t maxval
)
588 char const *where
= where0
;
589 char const *lim
= where
+ digs
;
592 /* Accommodate buggy tar of unknown vintage, which outputs leading
593 NUL if the previous field overflows. */
596 /* Accommodate older tars, which output leading spaces. */
603 _("Blanks in header where numeric %s value expected"),
607 if (!ISSPACE ((unsigned char) *where
))
613 if (ISODIGIT (*where
))
615 char const *where1
= where
;
616 uintmax_t overflow
= 0;
620 value
+= *where
++ - '0';
621 if (where
== lim
|| ! ISODIGIT (*where
))
623 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
627 /* Parse the output of older, unportable tars, which generate
628 negative values in two's complement octal. If the leading
629 nonzero digit is 1, we can't recover the original value
630 reliably; so do this only if the digit is 2 or more. This
631 catches the common case of 32-bit negative time stamps. */
632 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
634 /* Compute the negative of the input value, assuming two's
636 int digit
= (*where1
- '0') | 4;
644 if (where
== lim
|| ! ISODIGIT (*where
))
646 digit
= *where
- '0';
647 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
653 if (!overflow
&& value
<= minus_minval
)
656 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
657 (int) (where
- where1
), where1
, type
));
666 _("Archive octal value %.*s is out of %s range"),
667 (int) (where
- where1
), where1
, type
));
671 else if (*where
== '-' || *where
== '+')
673 /* Parse base-64 output produced only by tar test versions
674 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
675 Support for this will be withdrawn in future releases. */
677 static int warned_once
;
682 _("Archive contains obsolescent base-64 headers")));
684 negative
= *where
++ == '-';
686 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
688 if (value
<< LG_64
>> LG_64
!= value
)
690 char *string
= alloca (digs
+ 1);
691 memcpy (string
, where0
, digs
);
695 _("Archive signed base-64 string %s is out of %s range"),
696 quote (string
), type
));
699 value
= (value
<< LG_64
) | dig
;
703 else if (*where
== '\200' /* positive base-256 */
704 || *where
== '\377' /* negative base-256 */)
706 /* Parse base-256 output. A nonnegative number N is
707 represented as (256**DIGS)/2 + N; a negative number -N is
708 represented as (256**DIGS) - N, i.e. as two's complement.
709 The representation guarantees that the leading bit is
710 always on, so that we don't confuse this format with the
711 others (assuming ASCII bytes of 8 bits or more). */
712 int signbit
= *where
& (1 << (LG_256
- 2));
713 uintmax_t topbits
= (((uintmax_t) - signbit
)
714 << (CHAR_BIT
* sizeof (uintmax_t)
715 - LG_256
- (LG_256
- 2)));
716 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
719 value
= (value
<< LG_256
) + (unsigned char) *where
++;
722 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
726 _("Archive base-256 value is out of %s range"),
736 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
740 char buf
[1000]; /* Big enough to represent any header. */
741 static struct quoting_options
*o
;
745 o
= clone_quoting_options (0);
746 set_quoting_style (o
, locale_quoting_style
);
749 while (where0
!= lim
&& ! lim
[-1])
751 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
753 _("Archive contains %.*s where numeric %s value expected"),
754 (int) sizeof buf
, buf
, type
));
760 if (value
<= (negative
? minus_minval
: maxval
))
761 return negative
? -value
: value
;
765 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
766 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
767 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
768 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
769 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
771 *--value_string
= '-';
773 *--minval_string
= '-';
774 ERROR ((0, 0, _("Archive value %s is out of %s range %s.%s"),
776 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
783 gid_from_header (const char *p
, size_t s
)
785 return from_header (p
, s
, "gid_t",
786 - (uintmax_t) TYPE_MINIMUM (gid_t
),
787 (uintmax_t) TYPE_MAXIMUM (gid_t
));
791 major_from_header (const char *p
, size_t s
)
793 return from_header (p
, s
, "major_t",
794 - (uintmax_t) TYPE_MINIMUM (major_t
),
795 (uintmax_t) TYPE_MAXIMUM (major_t
));
799 minor_from_header (const char *p
, size_t s
)
801 return from_header (p
, s
, "minor_t",
802 - (uintmax_t) TYPE_MINIMUM (minor_t
),
803 (uintmax_t) TYPE_MAXIMUM (minor_t
));
807 mode_from_header (const char *p
, size_t s
)
809 /* Do not complain about unrecognized mode bits. */
810 unsigned u
= from_header (p
, s
, "mode_t",
811 - (uintmax_t) TYPE_MINIMUM (mode_t
),
812 TYPE_MAXIMUM (uintmax_t));
813 return ((u
& TSUID
? S_ISUID
: 0)
814 | (u
& TSGID
? S_ISGID
: 0)
815 | (u
& TSVTX
? S_ISVTX
: 0)
816 | (u
& TUREAD
? S_IRUSR
: 0)
817 | (u
& TUWRITE
? S_IWUSR
: 0)
818 | (u
& TUEXEC
? S_IXUSR
: 0)
819 | (u
& TGREAD
? S_IRGRP
: 0)
820 | (u
& TGWRITE
? S_IWGRP
: 0)
821 | (u
& TGEXEC
? S_IXGRP
: 0)
822 | (u
& TOREAD
? S_IROTH
: 0)
823 | (u
& TOWRITE
? S_IWOTH
: 0)
824 | (u
& TOEXEC
? S_IXOTH
: 0));
828 off_from_header (const char *p
, size_t s
)
830 /* Negative offsets are not allowed in tar files, so invoke
831 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
832 return from_header (p
, s
, "off_t", (uintmax_t) 0,
833 (uintmax_t) TYPE_MAXIMUM (off_t
));
837 size_from_header (const char *p
, size_t s
)
839 return from_header (p
, s
, "size_t", (uintmax_t) 0,
840 (uintmax_t) TYPE_MAXIMUM (size_t));
844 time_from_header (const char *p
, size_t s
)
846 return from_header (p
, s
, "time_t",
847 - (uintmax_t) TYPE_MINIMUM (time_t),
848 (uintmax_t) TYPE_MAXIMUM (time_t));
852 uid_from_header (const char *p
, size_t s
)
854 return from_header (p
, s
, "uid_t",
855 - (uintmax_t) TYPE_MINIMUM (uid_t
),
856 (uintmax_t) TYPE_MAXIMUM (uid_t
));
860 uintmax_from_header (const char *p
, size_t s
)
862 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
863 TYPE_MAXIMUM (uintmax_t));
867 /* Format O as a null-terminated decimal string into BUF _backwards_;
868 return pointer to start of result. */
870 stringify_uintmax_t_backwards (uintmax_t o
, char *buf
)
874 *--buf
= '0' + (int) (o
% 10);
875 while ((o
/= 10) != 0);
879 /* Return a printable representation of T. The result points to
880 static storage that can be reused in the next call to this
881 function, to ctime, or to asctime. */
885 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
886 INT_STRLEN_BOUND (int) + 16)];
893 char const *time_stamp
= p
+ 4;
894 for (p
+= 16; p
[3] != '\n'; p
++)
900 /* Use ISO 8610 format. See:
901 http://www.cl.cam.ac.uk/~mgk25/iso-time.html */
902 struct tm
*tm
= localtime (&t
);
905 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
906 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
907 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
912 /* The time stamp cannot be broken down, most likely because it
913 is out of range. Convert it as an integer,
914 right-adjusted in a field with the same width as the usual
915 19-byte 4-year ISO time format. */
916 p
= stringify_uintmax_t_backwards (t
< 0 ? - (uintmax_t) t
: (uintmax_t) t
,
917 buffer
+ sizeof buffer
);
920 while (buffer
+ sizeof buffer
- 19 - 1 < p
)
925 /* Actually print it.
927 Plain and fancy file header block logging. Non-verbose just prints
928 the name, e.g. for "tar t" or "tar x". This should just contain
929 file names, so it can be fed back into tar with xargs or the "-T"
930 option. The verbose option can give a bunch of info, one line per
931 file. I doubt anybody tries to parse its format, or if they do,
932 they shouldn't. Unix tar is pretty random here anyway. */
935 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
936 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
938 /* UGSWIDTH starts with 18, so with user and group names <= 8 chars, the
939 columns never shift during the listing. */
941 static int ugswidth
= UGSWIDTH
; /* maximum width encountered so far */
943 /* DATEWIDTH is the number of columns taken by the date and time fields. */
945 # define DATEWIDTH 19
947 # define DATEWIDTH 18
951 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
954 char const *time_stamp
;
955 char *temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
957 /* These hold formatted ints. */
958 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
960 char size
[2 * UINTMAX_STRSIZE_BOUND
];
961 /* holds formatted size or major,minor */
962 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
965 if (block_number_option
)
967 char buf
[UINTMAX_STRSIZE_BOUND
];
968 if (block_ordinal
< 0)
969 block_ordinal
= current_block_ordinal ();
970 block_ordinal
-= recent_long_name_blocks
;
971 block_ordinal
-= recent_long_link_blocks
;
972 fprintf (stdlis
, _("block %s: "),
973 STRINGIFY_BIGINT (block_ordinal
, buf
));
976 if (verbose_option
<= 1)
978 /* Just the fax, mam. */
979 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
983 /* File type and modes. */
986 switch (current_header
->header
.typeflag
)
992 case GNUTYPE_MULTIVOL
:
1000 case GNUTYPE_LONGNAME
:
1001 case GNUTYPE_LONGLINK
:
1003 ERROR ((0, 0, _("Visible longname error")));
1006 case GNUTYPE_SPARSE
:
1010 if (temp_name
[strlen (temp_name
) - 1] == '/')
1016 case GNUTYPE_DUMPDIR
:
1039 decode_mode (st
->stat
.st_mode
, modes
+ 1);
1043 time_stamp
= tartime (st
->stat
.st_mtime
);
1045 /* User and group names. */
1047 if (st
->uname
&& current_format
!= V7_FORMAT
1048 && !numeric_owner_option
)
1052 /* Try parsing it as an unsigned integer first, and as a
1053 uid_t if that fails. This method can list positive user
1054 ids that are too large to fit in a uid_t. */
1055 uintmax_t u
= from_header (current_header
->header
.uid
,
1056 sizeof current_header
->header
.uid
, 0,
1058 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1060 user
= STRINGIFY_BIGINT (u
, uform
);
1063 sprintf (uform
, "%ld",
1064 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1069 if (st
->gname
&& current_format
!= V7_FORMAT
1070 && !numeric_owner_option
)
1074 /* Try parsing it as an unsigned integer first, and as a
1075 gid_t if that fails. This method can list positive group
1076 ids that are too large to fit in a gid_t. */
1077 uintmax_t g
= from_header (current_header
->header
.gid
,
1078 sizeof current_header
->header
.gid
, 0,
1080 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1082 group
= STRINGIFY_BIGINT (g
, gform
);
1085 sprintf (gform
, "%ld",
1086 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1091 /* Format the file size or major/minor device numbers. */
1093 switch (current_header
->header
.typeflag
)
1098 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1101 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1103 case GNUTYPE_SPARSE
:
1106 (UINTMAX_FROM_HEADER (current_header
1107 ->oldgnu_header
.realsize
),
1111 /* st->stat.st_size keeps stored file size */
1112 strcpy (size
, STRINGIFY_BIGINT (st
->archive_file_size
, uintbuf
));
1116 /* Figure out padding and print the whole line. */
1118 pad
= strlen (user
) + strlen (group
) + strlen (size
) + 1;
1122 fprintf (stdlis
, "%s %s/%s %*s%s %s",
1123 modes
, user
, group
, ugswidth
- pad
, "", size
, time_stamp
);
1125 fprintf (stdlis
, " %s", quotearg (temp_name
));
1127 switch (current_header
->header
.typeflag
)
1130 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1134 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1139 char type_string
[2];
1140 type_string
[0] = current_header
->header
.typeflag
;
1141 type_string
[1] = '\0';
1142 fprintf (stdlis
, _(" unknown file type %s\n"),
1143 quote (type_string
));
1149 case GNUTYPE_SPARSE
:
1155 case GNUTYPE_DUMPDIR
:
1156 putc ('\n', stdlis
);
1159 case GNUTYPE_LONGLINK
:
1160 fprintf (stdlis
, _("--Long Link--\n"));
1163 case GNUTYPE_LONGNAME
:
1164 fprintf (stdlis
, _("--Long Name--\n"));
1167 case GNUTYPE_VOLHDR
:
1168 fprintf (stdlis
, _("--Volume Header--\n"));
1171 case GNUTYPE_MULTIVOL
:
1174 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1176 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1180 fprintf (stdlis
, _("--Mangled file names--\n"));
1187 /* Print a similar line when we make a directory automatically. */
1189 print_for_mkdir (char *pathname
, int length
, mode_t mode
)
1193 if (verbose_option
> 1)
1195 /* File type and modes. */
1198 decode_mode (mode
, modes
+ 1);
1200 if (block_number_option
)
1202 char buf
[UINTMAX_STRSIZE_BOUND
];
1203 fprintf (stdlis
, _("block %s: "),
1204 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1207 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ DATEWIDTH
,
1208 _("Creating directory:"), length
, quotearg (pathname
));
1212 /* Skip over SIZE bytes of data in blocks in the archive. */
1214 skip_file (off_t size
)
1218 if (multi_volume_option
)
1220 save_totsize
= size
;
1221 save_sizeleft
= size
;
1226 x
= find_next_block ();
1228 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1230 set_next_block_after (x
);
1232 if (multi_volume_option
)
1233 save_sizeleft
-= BLOCKSIZE
;
1237 /* Skip the current member in the archive. */
1241 char save_typeflag
= current_header
->header
.typeflag
;
1242 set_next_block_after (current_header
);
1244 if (current_format
== OLDGNU_FORMAT
1245 && current_header
->oldgnu_header
.isextended
)
1250 exhdr
= find_next_block ();
1252 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1253 set_next_block_after (exhdr
);
1255 while (exhdr
->sparse_header
.isextended
);
1258 if (save_typeflag
!= DIRTYPE
)
1259 skip_file (current_stat_info
.stat
.st_size
);