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
,
567 stat_info
->devminor
);
571 stat_info
->stat
.st_rdev
= 0;
575 xheader_decode (stat_info
);
576 current_stat_info
.archive_file_size
= current_stat_info
.stat
.st_size
;
579 /* Convert buffer at WHERE0 of size DIGS from external format to
580 uintmax_t. The data is of type TYPE. The buffer must represent a
581 value in the range -MINUS_MINVAL through MAXVAL. DIGS must be
582 positive. Return -1 on error, diagnosing the error if TYPE is
585 from_header (char const *where0
, size_t digs
, char const *type
,
586 uintmax_t minus_minval
, uintmax_t maxval
)
589 char const *where
= where0
;
590 char const *lim
= where
+ digs
;
593 /* Accommodate buggy tar of unknown vintage, which outputs leading
594 NUL if the previous field overflows. */
597 /* Accommodate older tars, which output leading spaces. */
604 _("Blanks in header where numeric %s value expected"),
608 if (!ISSPACE ((unsigned char) *where
))
614 if (ISODIGIT (*where
))
616 char const *where1
= where
;
617 uintmax_t overflow
= 0;
621 value
+= *where
++ - '0';
622 if (where
== lim
|| ! ISODIGIT (*where
))
624 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
628 /* Parse the output of older, unportable tars, which generate
629 negative values in two's complement octal. If the leading
630 nonzero digit is 1, we can't recover the original value
631 reliably; so do this only if the digit is 2 or more. This
632 catches the common case of 32-bit negative time stamps. */
633 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
635 /* Compute the negative of the input value, assuming two's
637 int digit
= (*where1
- '0') | 4;
645 if (where
== lim
|| ! ISODIGIT (*where
))
647 digit
= *where
- '0';
648 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
654 if (!overflow
&& value
<= minus_minval
)
657 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
658 (int) (where
- where1
), where1
, type
));
667 _("Archive octal value %.*s is out of %s range"),
668 (int) (where
- where1
), where1
, type
));
672 else if (*where
== '-' || *where
== '+')
674 /* Parse base-64 output produced only by tar test versions
675 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
676 Support for this will be withdrawn in future releases. */
678 static int warned_once
;
683 _("Archive contains obsolescent base-64 headers")));
685 negative
= *where
++ == '-';
687 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
689 if (value
<< LG_64
>> LG_64
!= value
)
691 char *string
= alloca (digs
+ 1);
692 memcpy (string
, where0
, digs
);
696 _("Archive signed base-64 string %s is out of %s range"),
697 quote (string
), type
));
700 value
= (value
<< LG_64
) | dig
;
704 else if (*where
== '\200' /* positive base-256 */
705 || *where
== '\377' /* negative base-256 */)
707 /* Parse base-256 output. A nonnegative number N is
708 represented as (256**DIGS)/2 + N; a negative number -N is
709 represented as (256**DIGS) - N, i.e. as two's complement.
710 The representation guarantees that the leading bit is
711 always on, so that we don't confuse this format with the
712 others (assuming ASCII bytes of 8 bits or more). */
713 int signbit
= *where
& (1 << (LG_256
- 2));
714 uintmax_t topbits
= (((uintmax_t) - signbit
)
715 << (CHAR_BIT
* sizeof (uintmax_t)
716 - LG_256
- (LG_256
- 2)));
717 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
720 value
= (value
<< LG_256
) + (unsigned char) *where
++;
723 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
727 _("Archive base-256 value is out of %s range"),
737 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
741 char buf
[1000]; /* Big enough to represent any header. */
742 static struct quoting_options
*o
;
746 o
= clone_quoting_options (0);
747 set_quoting_style (o
, locale_quoting_style
);
750 while (where0
!= lim
&& ! lim
[-1])
752 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
754 _("Archive contains %.*s where numeric %s value expected"),
755 (int) sizeof buf
, buf
, type
));
761 if (value
<= (negative
? minus_minval
: maxval
))
762 return negative
? -value
: value
;
766 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
767 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
768 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
769 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
770 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
772 *--value_string
= '-';
774 *--minval_string
= '-';
775 ERROR ((0, 0, _("Archive value %s is out of %s range %s.%s"),
777 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
784 gid_from_header (const char *p
, size_t s
)
786 return from_header (p
, s
, "gid_t",
787 - (uintmax_t) TYPE_MINIMUM (gid_t
),
788 (uintmax_t) TYPE_MAXIMUM (gid_t
));
792 major_from_header (const char *p
, size_t s
)
794 return from_header (p
, s
, "major_t",
795 - (uintmax_t) TYPE_MINIMUM (major_t
),
796 (uintmax_t) TYPE_MAXIMUM (major_t
));
800 minor_from_header (const char *p
, size_t s
)
802 return from_header (p
, s
, "minor_t",
803 - (uintmax_t) TYPE_MINIMUM (minor_t
),
804 (uintmax_t) TYPE_MAXIMUM (minor_t
));
808 mode_from_header (const char *p
, size_t s
)
810 /* Do not complain about unrecognized mode bits. */
811 unsigned u
= from_header (p
, s
, "mode_t",
812 - (uintmax_t) TYPE_MINIMUM (mode_t
),
813 TYPE_MAXIMUM (uintmax_t));
814 return ((u
& TSUID
? S_ISUID
: 0)
815 | (u
& TSGID
? S_ISGID
: 0)
816 | (u
& TSVTX
? S_ISVTX
: 0)
817 | (u
& TUREAD
? S_IRUSR
: 0)
818 | (u
& TUWRITE
? S_IWUSR
: 0)
819 | (u
& TUEXEC
? S_IXUSR
: 0)
820 | (u
& TGREAD
? S_IRGRP
: 0)
821 | (u
& TGWRITE
? S_IWGRP
: 0)
822 | (u
& TGEXEC
? S_IXGRP
: 0)
823 | (u
& TOREAD
? S_IROTH
: 0)
824 | (u
& TOWRITE
? S_IWOTH
: 0)
825 | (u
& TOEXEC
? S_IXOTH
: 0));
829 off_from_header (const char *p
, size_t s
)
831 /* Negative offsets are not allowed in tar files, so invoke
832 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
833 return from_header (p
, s
, "off_t", (uintmax_t) 0,
834 (uintmax_t) TYPE_MAXIMUM (off_t
));
838 size_from_header (const char *p
, size_t s
)
840 return from_header (p
, s
, "size_t", (uintmax_t) 0,
841 (uintmax_t) TYPE_MAXIMUM (size_t));
845 time_from_header (const char *p
, size_t s
)
847 return from_header (p
, s
, "time_t",
848 - (uintmax_t) TYPE_MINIMUM (time_t),
849 (uintmax_t) TYPE_MAXIMUM (time_t));
853 uid_from_header (const char *p
, size_t s
)
855 return from_header (p
, s
, "uid_t",
856 - (uintmax_t) TYPE_MINIMUM (uid_t
),
857 (uintmax_t) TYPE_MAXIMUM (uid_t
));
861 uintmax_from_header (const char *p
, size_t s
)
863 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
864 TYPE_MAXIMUM (uintmax_t));
868 /* Format O as a null-terminated decimal string into BUF _backwards_;
869 return pointer to start of result. */
871 stringify_uintmax_t_backwards (uintmax_t o
, char *buf
)
875 *--buf
= '0' + (int) (o
% 10);
876 while ((o
/= 10) != 0);
880 /* Return a printable representation of T. The result points to
881 static storage that can be reused in the next call to this
882 function, to ctime, or to asctime. */
886 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
887 INT_STRLEN_BOUND (int) + 16)];
894 char const *time_stamp
= p
+ 4;
895 for (p
+= 16; p
[3] != '\n'; p
++)
901 /* Use ISO 8610 format. See:
902 http://www.cl.cam.ac.uk/~mgk25/iso-time.html */
903 struct tm
*tm
= utc_option
? gmtime (&t
) : localtime (&t
);
906 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
907 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
908 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
913 /* The time stamp cannot be broken down, most likely because it
914 is out of range. Convert it as an integer,
915 right-adjusted in a field with the same width as the usual
916 19-byte 4-year ISO time format. */
917 p
= stringify_uintmax_t_backwards (t
< 0 ? - (uintmax_t) t
: (uintmax_t) t
,
918 buffer
+ sizeof buffer
);
921 while (buffer
+ sizeof buffer
- 19 - 1 < p
)
926 /* Actually print it.
928 Plain and fancy file header block logging. Non-verbose just prints
929 the name, e.g. for "tar t" or "tar x". This should just contain
930 file names, so it can be fed back into tar with xargs or the "-T"
931 option. The verbose option can give a bunch of info, one line per
932 file. I doubt anybody tries to parse its format, or if they do,
933 they shouldn't. Unix tar is pretty random here anyway. */
936 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
937 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
939 /* UGSWIDTH starts with 18, so with user and group names <= 8 chars, the
940 columns never shift during the listing. */
942 static int ugswidth
= UGSWIDTH
; /* maximum width encountered so far */
944 /* DATEWIDTH is the number of columns taken by the date and time fields. */
946 # define DATEWIDTH 19
948 # define DATEWIDTH 18
952 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
955 char const *time_stamp
;
956 char *temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
958 /* These hold formatted ints. */
959 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
961 char size
[2 * UINTMAX_STRSIZE_BOUND
];
962 /* holds formatted size or major,minor */
963 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
966 if (block_number_option
)
968 char buf
[UINTMAX_STRSIZE_BOUND
];
969 if (block_ordinal
< 0)
970 block_ordinal
= current_block_ordinal ();
971 block_ordinal
-= recent_long_name_blocks
;
972 block_ordinal
-= recent_long_link_blocks
;
973 fprintf (stdlis
, _("block %s: "),
974 STRINGIFY_BIGINT (block_ordinal
, buf
));
977 if (verbose_option
<= 1)
979 /* Just the fax, mam. */
980 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
984 /* File type and modes. */
987 switch (current_header
->header
.typeflag
)
993 case GNUTYPE_MULTIVOL
:
1001 case GNUTYPE_LONGNAME
:
1002 case GNUTYPE_LONGLINK
:
1004 ERROR ((0, 0, _("Visible longname error")));
1007 case GNUTYPE_SPARSE
:
1011 if (temp_name
[strlen (temp_name
) - 1] == '/')
1017 case GNUTYPE_DUMPDIR
:
1040 decode_mode (st
->stat
.st_mode
, modes
+ 1);
1044 time_stamp
= tartime (st
->stat
.st_mtime
);
1046 /* User and group names. */
1048 if (st
->uname
&& current_format
!= V7_FORMAT
1049 && !numeric_owner_option
)
1053 /* Try parsing it as an unsigned integer first, and as a
1054 uid_t if that fails. This method can list positive user
1055 ids that are too large to fit in a uid_t. */
1056 uintmax_t u
= from_header (current_header
->header
.uid
,
1057 sizeof current_header
->header
.uid
, 0,
1059 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1061 user
= STRINGIFY_BIGINT (u
, uform
);
1064 sprintf (uform
, "%ld",
1065 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1070 if (st
->gname
&& current_format
!= V7_FORMAT
1071 && !numeric_owner_option
)
1075 /* Try parsing it as an unsigned integer first, and as a
1076 gid_t if that fails. This method can list positive group
1077 ids that are too large to fit in a gid_t. */
1078 uintmax_t g
= from_header (current_header
->header
.gid
,
1079 sizeof current_header
->header
.gid
, 0,
1081 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1083 group
= STRINGIFY_BIGINT (g
, gform
);
1086 sprintf (gform
, "%ld",
1087 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1092 /* Format the file size or major/minor device numbers. */
1094 switch (current_header
->header
.typeflag
)
1099 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1102 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1104 case GNUTYPE_SPARSE
:
1107 (UINTMAX_FROM_HEADER (current_header
1108 ->oldgnu_header
.realsize
),
1112 /* st->stat.st_size keeps stored file size */
1113 strcpy (size
, STRINGIFY_BIGINT (st
->archive_file_size
, uintbuf
));
1117 /* Figure out padding and print the whole line. */
1119 pad
= strlen (user
) + strlen (group
) + strlen (size
) + 1;
1123 fprintf (stdlis
, "%s %s/%s %*s%s %s",
1124 modes
, user
, group
, ugswidth
- pad
, "", size
, time_stamp
);
1126 fprintf (stdlis
, " %s", quotearg (temp_name
));
1128 switch (current_header
->header
.typeflag
)
1131 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1135 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1140 char type_string
[2];
1141 type_string
[0] = current_header
->header
.typeflag
;
1142 type_string
[1] = '\0';
1143 fprintf (stdlis
, _(" unknown file type %s\n"),
1144 quote (type_string
));
1150 case GNUTYPE_SPARSE
:
1156 case GNUTYPE_DUMPDIR
:
1157 putc ('\n', stdlis
);
1160 case GNUTYPE_LONGLINK
:
1161 fprintf (stdlis
, _("--Long Link--\n"));
1164 case GNUTYPE_LONGNAME
:
1165 fprintf (stdlis
, _("--Long Name--\n"));
1168 case GNUTYPE_VOLHDR
:
1169 fprintf (stdlis
, _("--Volume Header--\n"));
1172 case GNUTYPE_MULTIVOL
:
1175 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1177 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1181 fprintf (stdlis
, _("--Mangled file names--\n"));
1188 /* Print a similar line when we make a directory automatically. */
1190 print_for_mkdir (char *pathname
, int length
, mode_t mode
)
1194 if (verbose_option
> 1)
1196 /* File type and modes. */
1199 decode_mode (mode
, modes
+ 1);
1201 if (block_number_option
)
1203 char buf
[UINTMAX_STRSIZE_BOUND
];
1204 fprintf (stdlis
, _("block %s: "),
1205 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1208 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ DATEWIDTH
,
1209 _("Creating directory:"), length
, quotearg (pathname
));
1213 /* Skip over SIZE bytes of data in blocks in the archive. */
1215 skip_file (off_t size
)
1219 if (multi_volume_option
)
1221 save_totsize
= size
;
1222 save_sizeleft
= size
;
1227 x
= find_next_block ();
1229 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1231 set_next_block_after (x
);
1233 if (multi_volume_option
)
1234 save_sizeleft
-= BLOCKSIZE
;
1238 /* Skip the current member in the archive. */
1242 char save_typeflag
= current_header
->header
.typeflag
;
1243 set_next_block_after (current_header
);
1245 if (current_format
== OLDGNU_FORMAT
1246 && current_header
->oldgnu_header
.isextended
)
1251 exhdr
= find_next_block ();
1253 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1254 set_next_block_after (exhdr
);
1256 while (exhdr
->sparse_header
.isextended
);
1259 if (save_typeflag
!= DIRTYPE
)
1260 skip_file (current_stat_info
.stat
.st_size
);