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, 2004 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_OPTION_INITIALIZED (newer_mtime_option
)
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
)),
101 /* FIXME: Grab fractional time stamps from
103 current_stat_info
.stat
.st_mtim
.ST_MTIM_NSEC
= 0,
105 OLDER_STAT_TIME (current_stat_info
.stat
, m
)))
106 || excluded_name (current_stat_info
.file_name
))
108 switch (current_header
->header
.typeflag
)
111 case GNUTYPE_MULTIVOL
:
116 if (show_omitted_dirs_option
)
117 WARN ((0, 0, _("%s: Omitting"),
118 quotearg_colon (current_stat_info
.file_name
)));
121 decode_header (current_header
,
122 ¤t_stat_info
, ¤t_format
, 0);
131 case HEADER_ZERO_BLOCK
:
132 if (block_number_option
)
134 char buf
[UINTMAX_STRSIZE_BOUND
];
135 fprintf (stdlis
, _("block %s: ** Block of NULs **\n"),
136 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
139 set_next_block_after (current_header
);
141 if (!ignore_zeros_option
)
143 char buf
[UINTMAX_STRSIZE_BOUND
];
145 status
= read_header (false);
146 if (status
== HEADER_ZERO_BLOCK
)
148 WARN ((0, 0, _("A lone zero block at %s"),
149 STRINGIFY_BIGINT (current_block_ordinal (), buf
)));
152 status
= prev_status
;
155 case HEADER_END_OF_FILE
:
156 if (block_number_option
)
158 char buf
[UINTMAX_STRSIZE_BOUND
];
159 fprintf (stdlis
, _("block %s: ** End of File **\n"),
160 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
165 /* If the previous header was good, tell them that we are
166 skipping bad ones. */
167 set_next_block_after (current_header
);
170 case HEADER_STILL_UNREAD
:
171 ERROR ((0, 0, _("This does not look like a tar archive")));
174 case HEADER_ZERO_BLOCK
:
176 if (block_number_option
)
178 char buf
[UINTMAX_STRSIZE_BOUND
];
179 off_t block_ordinal
= current_block_ordinal ();
180 block_ordinal
-= recent_long_name_blocks
;
181 block_ordinal
-= recent_long_link_blocks
;
182 fprintf (stdlis
, _("block %s: "),
183 STRINGIFY_BIGINT (block_ordinal
, buf
));
185 ERROR ((0, 0, _("Skipping to next header")));
188 case HEADER_END_OF_FILE
:
190 /* We are in the middle of a cascade of errors. */
193 case HEADER_SUCCESS_EXTENDED
:
200 while (!all_names_found (¤t_stat_info
));
203 names_notfound (); /* print names not found */
206 /* Print a header block, based on tar options. */
210 /* Print the header block. */
212 decode_header (current_header
, ¤t_stat_info
, ¤t_format
, 0);
214 print_header (¤t_stat_info
, -1);
216 if (incremental_option
&& current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
219 size_t written
, check
;
220 union block
*data_block
;
222 set_next_block_after (current_header
);
223 if (multi_volume_option
)
225 assign_string (&save_name
, current_stat_info
.file_name
);
226 save_totsize
= current_stat_info
.stat
.st_size
;
228 for (size
= current_stat_info
.stat
.st_size
; size
> 0; size
-= written
)
230 if (multi_volume_option
)
231 save_sizeleft
= size
;
232 data_block
= find_next_block ();
235 ERROR ((0, 0, _("Unexpected EOF in archive")));
236 break; /* FIXME: What happens, then? */
238 written
= available_space_after (data_block
);
242 check
= fwrite (data_block
->buffer
, sizeof (char), written
, stdlis
);
243 set_next_block_after ((union block
*)
244 (data_block
->buffer
+ written
- 1));
245 if (check
!= written
)
247 write_error_details (current_stat_info
.file_name
, check
, written
);
248 skip_file (size
- written
);
252 if (multi_volume_option
)
253 assign_string (&save_name
, 0);
254 fputc ('\n', stdlis
);
260 if (multi_volume_option
)
261 assign_string (&save_name
, current_stat_info
.file_name
);
265 if (multi_volume_option
)
266 assign_string (&save_name
, 0);
269 /* Read a block that's supposed to be a header block. Return its
270 address in "current_header", and if it is good, the file's size in
271 current_stat_info.stat.st_size.
273 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
274 block full of zeros (EOF marker).
276 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
277 GNU long name and link headers into later headers.
279 You must always set_next_block_after(current_header) to skip past
280 the header which this routine reads. */
282 /* The standard BSD tar sources create the checksum by adding up the
283 bytes in the header as type char. I think the type char was unsigned
284 on the PDP-11, but it's signed on the Next and Sun. It looks like the
285 sources to BSD tar were never changed to compute the checksum
286 correctly, so both the Sun and Next add the bytes of the header as
287 signed chars. This doesn't cause a problem until you get a file with
288 a name containing characters with the high bit set. So read_header
289 computes two checksums -- signed and unsigned. */
292 read_header (bool raw_extended_headers
)
295 int unsigned_sum
; /* the POSIX one :-) */
296 int signed_sum
; /* the Sun one :-( */
298 uintmax_t parsed_sum
;
301 union block
*header_copy
;
303 union block
*data_block
;
304 size_t size
, written
;
305 union block
*next_long_name
= 0;
306 union block
*next_long_link
= 0;
307 size_t next_long_name_blocks
;
308 size_t next_long_link_blocks
;
312 header
= find_next_block ();
313 current_header
= header
;
315 return HEADER_END_OF_FILE
;
320 for (i
= sizeof *header
; i
-- != 0;)
322 unsigned_sum
+= (unsigned char) *p
;
323 signed_sum
+= (signed char) (*p
++);
326 if (unsigned_sum
== 0)
327 return HEADER_ZERO_BLOCK
;
329 /* Adjust checksum to count the "chksum" field as blanks. */
331 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
333 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
334 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
336 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
337 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
339 parsed_sum
= from_header (header
->header
.chksum
,
340 sizeof header
->header
.chksum
, 0,
342 (uintmax_t) TYPE_MAXIMUM (int));
343 if (parsed_sum
== (uintmax_t) -1)
344 return HEADER_FAILURE
;
346 recorded_sum
= parsed_sum
;
348 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
349 return HEADER_FAILURE
;
351 /* Good block. Decode file size and return. */
353 if (header
->header
.typeflag
== LNKTYPE
)
354 current_stat_info
.stat
.st_size
= 0; /* links 0 size on tape */
356 current_stat_info
.stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
358 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
359 || header
->header
.typeflag
== GNUTYPE_LONGLINK
360 || header
->header
.typeflag
== XHDTYPE
361 || header
->header
.typeflag
== XGLTYPE
)
363 if (raw_extended_headers
)
364 return HEADER_SUCCESS_EXTENDED
;
365 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
366 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
368 size_t name_size
= current_stat_info
.stat
.st_size
;
369 size
= name_size
- name_size
% BLOCKSIZE
+ 2 * BLOCKSIZE
;
370 if (name_size
!= current_stat_info
.stat
.st_size
374 header_copy
= xmalloc (size
+ 1);
376 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
379 free (next_long_name
);
380 next_long_name
= header_copy
;
381 next_long_name_blocks
= size
/ BLOCKSIZE
;
386 free (next_long_link
);
387 next_long_link
= header_copy
;
388 next_long_link_blocks
= size
/ BLOCKSIZE
;
391 set_next_block_after (header
);
392 *header_copy
= *header
;
393 bp
= header_copy
->buffer
+ BLOCKSIZE
;
395 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
397 data_block
= find_next_block ();
400 ERROR ((0, 0, _("Unexpected EOF in archive")));
403 written
= available_space_after (data_block
);
407 memcpy (bp
, data_block
->buffer
, written
);
409 set_next_block_after ((union block
*)
410 (data_block
->buffer
+ written
- 1));
415 else if (header
->header
.typeflag
== XHDTYPE
)
416 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
417 else if (header
->header
.typeflag
== XGLTYPE
)
419 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
420 xheader_decode_global ();
429 struct posix_header
const *h
= ¤t_header
->header
;
430 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
432 if (recent_long_name
)
433 free (recent_long_name
);
437 name
= next_long_name
->buffer
+ BLOCKSIZE
;
438 recent_long_name
= next_long_name
;
439 recent_long_name_blocks
= next_long_name_blocks
;
443 /* Accept file names as specified by POSIX.1-1996
447 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
449 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
450 np
[sizeof h
->prefix
] = '\0';
454 /* Prevent later references to current_header from
455 mistakenly treating this as an old GNU header.
456 This assignment invalidates h->prefix. */
457 current_header
->oldgnu_header
.isextended
= 0;
459 memcpy (np
, h
->name
, sizeof h
->name
);
460 np
[sizeof h
->name
] = '\0';
462 recent_long_name
= 0;
463 recent_long_name_blocks
= 0;
465 assign_string (¤t_stat_info
.orig_file_name
, name
);
466 assign_string (¤t_stat_info
.file_name
, name
);
467 current_stat_info
.had_trailing_slash
= strip_trailing_slashes (current_stat_info
.file_name
);
469 if (recent_long_link
)
470 free (recent_long_link
);
474 name
= next_long_link
->buffer
+ BLOCKSIZE
;
475 recent_long_link
= next_long_link
;
476 recent_long_link_blocks
= next_long_link_blocks
;
480 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
481 namebuf
[sizeof h
->linkname
] = '\0';
483 recent_long_link
= 0;
484 recent_long_link_blocks
= 0;
486 assign_string (¤t_stat_info
.link_name
, name
);
488 return HEADER_SUCCESS
;
493 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
495 /* Decode things from a file HEADER block into STAT_INFO, also setting
496 *FORMAT_POINTER depending on the header block format. If
497 DO_USER_GROUP, decode the user/group information (this is useful
498 for extraction, but waste time when merely listing).
500 read_header() has already decoded the checksum and length, so we don't.
502 This routine should *not* be called twice for the same block, since
503 the two calls might use different DO_USER_GROUP values and thus
504 might end up with different uid/gid for the two calls. If anybody
505 wants the uid/gid they should decode it first, and other callers
506 should decode it without uid/gid before calling a routine,
507 e.g. print_header, that assumes decoded data. */
509 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
510 enum archive_format
*format_pointer
, int do_user_group
)
512 enum archive_format format
;
514 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
516 if (header
->star_header
.prefix
[130] == 0
517 && ISOCTAL (header
->star_header
.atime
[0])
518 && header
->star_header
.atime
[11] == ' '
519 && ISOCTAL (header
->star_header
.ctime
[0])
520 && header
->star_header
.ctime
[11] == ' ')
521 format
= STAR_FORMAT
;
522 else if (extended_header
.size
)
523 format
= POSIX_FORMAT
;
525 format
= USTAR_FORMAT
;
527 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
528 format
= OLDGNU_FORMAT
;
531 *format_pointer
= format
;
533 stat_info
->stat
.st_mode
= MODE_FROM_HEADER (header
->header
.mode
);
534 stat_info
->stat
.st_mtime
= TIME_FROM_HEADER (header
->header
.mtime
);
535 assign_string (&stat_info
->uname
,
536 header
->header
.uname
[0] ? header
->header
.uname
: NULL
);
537 assign_string (&stat_info
->gname
,
538 header
->header
.gname
[0] ? header
->header
.gname
: NULL
);
539 stat_info
->devmajor
= MAJOR_FROM_HEADER (header
->header
.devmajor
);
540 stat_info
->devminor
= MINOR_FROM_HEADER (header
->header
.devminor
);
542 stat_info
->stat
.st_atime
= start_time
;
543 stat_info
->stat
.st_ctime
= start_time
;
545 if (format
== OLDGNU_FORMAT
&& incremental_option
)
547 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
548 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
551 if (format
== V7_FORMAT
)
553 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
554 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
555 stat_info
->stat
.st_rdev
= 0;
560 if (format
== STAR_FORMAT
)
562 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->star_header
.atime
);
563 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->star_header
.ctime
);
568 /* FIXME: Decide if this should somewhat depend on -p. */
570 if (numeric_owner_option
571 || !*header
->header
.uname
572 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
573 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
575 if (numeric_owner_option
576 || !*header
->header
.gname
577 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
578 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
581 switch (header
->header
.typeflag
)
585 stat_info
->stat
.st_rdev
= makedev (stat_info
->devmajor
,
586 stat_info
->devminor
);
590 stat_info
->stat
.st_rdev
= 0;
594 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
595 xheader_decode (stat_info
);
597 if (sparse_member_p (stat_info
))
599 sparse_fixup_header (stat_info
);
600 stat_info
->is_sparse
= true;
603 stat_info
->is_sparse
= false;
606 /* Convert buffer at WHERE0 of size DIGS from external format to
607 uintmax_t. The data is of type TYPE. The buffer must represent a
608 value in the range -MINUS_MINVAL through MAXVAL. DIGS must be
609 positive. Return -1 on error, diagnosing the error if TYPE is
612 from_header (char const *where0
, size_t digs
, char const *type
,
613 uintmax_t minus_minval
, uintmax_t maxval
)
616 char const *where
= where0
;
617 char const *lim
= where
+ digs
;
620 /* Accommodate buggy tar of unknown vintage, which outputs leading
621 NUL if the previous field overflows. */
624 /* Accommodate older tars, which output leading spaces. */
631 _("Blanks in header where numeric %s value expected"),
635 if (!ISSPACE ((unsigned char) *where
))
641 if (ISODIGIT (*where
))
643 char const *where1
= where
;
644 uintmax_t overflow
= 0;
648 value
+= *where
++ - '0';
649 if (where
== lim
|| ! ISODIGIT (*where
))
651 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
655 /* Parse the output of older, unportable tars, which generate
656 negative values in two's complement octal. If the leading
657 nonzero digit is 1, we can't recover the original value
658 reliably; so do this only if the digit is 2 or more. This
659 catches the common case of 32-bit negative time stamps. */
660 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
662 /* Compute the negative of the input value, assuming two's
664 int digit
= (*where1
- '0') | 4;
672 if (where
== lim
|| ! ISODIGIT (*where
))
674 digit
= *where
- '0';
675 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
681 if (!overflow
&& value
<= minus_minval
)
684 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
685 (int) (where
- where1
), where1
, type
));
694 _("Archive octal value %.*s is out of %s range"),
695 (int) (where
- where1
), where1
, type
));
699 else if (*where
== '-' || *where
== '+')
701 /* Parse base-64 output produced only by tar test versions
702 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
703 Support for this will be withdrawn in future releases. */
705 static int warned_once
;
710 _("Archive contains obsolescent base-64 headers")));
712 negative
= *where
++ == '-';
714 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
716 if (value
<< LG_64
>> LG_64
!= value
)
718 char *string
= alloca (digs
+ 1);
719 memcpy (string
, where0
, digs
);
723 _("Archive signed base-64 string %s is out of %s range"),
724 quote (string
), type
));
727 value
= (value
<< LG_64
) | dig
;
731 else if (*where
== '\200' /* positive base-256 */
732 || *where
== '\377' /* negative base-256 */)
734 /* Parse base-256 output. A nonnegative number N is
735 represented as (256**DIGS)/2 + N; a negative number -N is
736 represented as (256**DIGS) - N, i.e. as two's complement.
737 The representation guarantees that the leading bit is
738 always on, so that we don't confuse this format with the
739 others (assuming ASCII bytes of 8 bits or more). */
740 int signbit
= *where
& (1 << (LG_256
- 2));
741 uintmax_t topbits
= (((uintmax_t) - signbit
)
742 << (CHAR_BIT
* sizeof (uintmax_t)
743 - LG_256
- (LG_256
- 2)));
744 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
747 value
= (value
<< LG_256
) + (unsigned char) *where
++;
750 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
754 _("Archive base-256 value is out of %s range"),
764 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
768 char buf
[1000]; /* Big enough to represent any header. */
769 static struct quoting_options
*o
;
773 o
= clone_quoting_options (0);
774 set_quoting_style (o
, locale_quoting_style
);
777 while (where0
!= lim
&& ! lim
[-1])
779 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
781 _("Archive contains %.*s where numeric %s value expected"),
782 (int) sizeof buf
, buf
, type
));
788 if (value
<= (negative
? minus_minval
: maxval
))
789 return negative
? -value
: value
;
793 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
794 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
795 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
796 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
797 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
799 *--value_string
= '-';
801 *--minval_string
= '-';
802 ERROR ((0, 0, _("Archive value %s is out of %s range %s.%s"),
804 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
811 gid_from_header (const char *p
, size_t s
)
813 return from_header (p
, s
, "gid_t",
814 - (uintmax_t) TYPE_MINIMUM (gid_t
),
815 (uintmax_t) TYPE_MAXIMUM (gid_t
));
819 major_from_header (const char *p
, size_t s
)
821 return from_header (p
, s
, "major_t",
822 - (uintmax_t) TYPE_MINIMUM (major_t
),
823 (uintmax_t) TYPE_MAXIMUM (major_t
));
827 minor_from_header (const char *p
, size_t s
)
829 return from_header (p
, s
, "minor_t",
830 - (uintmax_t) TYPE_MINIMUM (minor_t
),
831 (uintmax_t) TYPE_MAXIMUM (minor_t
));
835 mode_from_header (const char *p
, size_t s
)
837 /* Do not complain about unrecognized mode bits. */
838 unsigned u
= from_header (p
, s
, "mode_t",
839 - (uintmax_t) TYPE_MINIMUM (mode_t
),
840 TYPE_MAXIMUM (uintmax_t));
841 return ((u
& TSUID
? S_ISUID
: 0)
842 | (u
& TSGID
? S_ISGID
: 0)
843 | (u
& TSVTX
? S_ISVTX
: 0)
844 | (u
& TUREAD
? S_IRUSR
: 0)
845 | (u
& TUWRITE
? S_IWUSR
: 0)
846 | (u
& TUEXEC
? S_IXUSR
: 0)
847 | (u
& TGREAD
? S_IRGRP
: 0)
848 | (u
& TGWRITE
? S_IWGRP
: 0)
849 | (u
& TGEXEC
? S_IXGRP
: 0)
850 | (u
& TOREAD
? S_IROTH
: 0)
851 | (u
& TOWRITE
? S_IWOTH
: 0)
852 | (u
& TOEXEC
? S_IXOTH
: 0));
856 off_from_header (const char *p
, size_t s
)
858 /* Negative offsets are not allowed in tar files, so invoke
859 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
860 return from_header (p
, s
, "off_t", (uintmax_t) 0,
861 (uintmax_t) TYPE_MAXIMUM (off_t
));
865 size_from_header (const char *p
, size_t s
)
867 return from_header (p
, s
, "size_t", (uintmax_t) 0,
868 (uintmax_t) TYPE_MAXIMUM (size_t));
872 time_from_header (const char *p
, size_t s
)
874 return from_header (p
, s
, "time_t",
875 - (uintmax_t) TYPE_MINIMUM (time_t),
876 (uintmax_t) TYPE_MAXIMUM (time_t));
880 uid_from_header (const char *p
, size_t s
)
882 return from_header (p
, s
, "uid_t",
883 - (uintmax_t) TYPE_MINIMUM (uid_t
),
884 (uintmax_t) TYPE_MAXIMUM (uid_t
));
888 uintmax_from_header (const char *p
, size_t s
)
890 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
891 TYPE_MAXIMUM (uintmax_t));
895 /* Format O as a null-terminated decimal string into BUF _backwards_;
896 return pointer to start of result. */
898 stringify_uintmax_t_backwards (uintmax_t o
, char *buf
)
902 *--buf
= '0' + (int) (o
% 10);
903 while ((o
/= 10) != 0);
907 /* Return a printable representation of T. The result points to
908 static storage that can be reused in the next call to this
909 function, to ctime, or to asctime. */
913 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
914 INT_STRLEN_BOUND (int) + 16)];
921 char const *time_stamp
= p
+ 4;
922 for (p
+= 16; p
[3] != '\n'; p
++)
928 /* Use ISO 8610 format. See:
929 http://www.cl.cam.ac.uk/~mgk25/iso-time.html */
930 struct tm
*tm
= utc_option
? gmtime (&t
) : localtime (&t
);
933 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
934 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
935 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
940 /* The time stamp cannot be broken down, most likely because it
941 is out of range. Convert it as an integer,
942 right-adjusted in a field with the same width as the usual
943 19-byte 4-year ISO time format. */
944 p
= stringify_uintmax_t_backwards (t
< 0 ? - (uintmax_t) t
: (uintmax_t) t
,
945 buffer
+ sizeof buffer
);
948 while (buffer
+ sizeof buffer
- 19 - 1 < p
)
953 /* Actually print it.
955 Plain and fancy file header block logging. Non-verbose just prints
956 the name, e.g. for "tar t" or "tar x". This should just contain
957 file names, so it can be fed back into tar with xargs or the "-T"
958 option. The verbose option can give a bunch of info, one line per
959 file. I doubt anybody tries to parse its format, or if they do,
960 they shouldn't. Unix tar is pretty random here anyway. */
963 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
964 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
966 /* UGSWIDTH starts with 18, so with user and group names <= 8 chars, the
967 columns never shift during the listing. */
969 static int ugswidth
= UGSWIDTH
; /* maximum width encountered so far */
971 /* DATEWIDTH is the number of columns taken by the date and time fields. */
973 # define DATEWIDTH 19
975 # define DATEWIDTH 18
979 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
982 char const *time_stamp
;
983 char *temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
985 /* These hold formatted ints. */
986 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
988 char size
[2 * UINTMAX_STRSIZE_BOUND
];
989 /* holds formatted size or major,minor */
990 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
993 if (block_number_option
)
995 char buf
[UINTMAX_STRSIZE_BOUND
];
996 if (block_ordinal
< 0)
997 block_ordinal
= current_block_ordinal ();
998 block_ordinal
-= recent_long_name_blocks
;
999 block_ordinal
-= recent_long_link_blocks
;
1000 fprintf (stdlis
, _("block %s: "),
1001 STRINGIFY_BIGINT (block_ordinal
, buf
));
1004 if (verbose_option
<= 1)
1006 /* Just the fax, mam. */
1007 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
1011 /* File type and modes. */
1014 switch (current_header
->header
.typeflag
)
1016 case GNUTYPE_VOLHDR
:
1020 case GNUTYPE_MULTIVOL
:
1028 case GNUTYPE_LONGNAME
:
1029 case GNUTYPE_LONGLINK
:
1031 ERROR ((0, 0, _("Visible longname error")));
1034 case GNUTYPE_SPARSE
:
1038 if (temp_name
[strlen (temp_name
) - 1] == '/')
1044 case GNUTYPE_DUMPDIR
:
1067 decode_mode (st
->stat
.st_mode
, modes
+ 1);
1071 time_stamp
= tartime (st
->stat
.st_mtime
);
1073 /* User and group names. */
1075 if (st
->uname
&& current_format
!= V7_FORMAT
1076 && !numeric_owner_option
)
1080 /* Try parsing it as an unsigned integer first, and as a
1081 uid_t if that fails. This method can list positive user
1082 ids that are too large to fit in a uid_t. */
1083 uintmax_t u
= from_header (current_header
->header
.uid
,
1084 sizeof current_header
->header
.uid
, 0,
1086 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1088 user
= STRINGIFY_BIGINT (u
, uform
);
1091 sprintf (uform
, "%ld",
1092 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1097 if (st
->gname
&& current_format
!= V7_FORMAT
1098 && !numeric_owner_option
)
1102 /* Try parsing it as an unsigned integer first, and as a
1103 gid_t if that fails. This method can list positive group
1104 ids that are too large to fit in a gid_t. */
1105 uintmax_t g
= from_header (current_header
->header
.gid
,
1106 sizeof current_header
->header
.gid
, 0,
1108 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1110 group
= STRINGIFY_BIGINT (g
, gform
);
1113 sprintf (gform
, "%ld",
1114 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1119 /* Format the file size or major/minor device numbers. */
1121 switch (current_header
->header
.typeflag
)
1126 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1129 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1133 /* st->stat.st_size keeps stored file size */
1134 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1138 /* Figure out padding and print the whole line. */
1140 pad
= strlen (user
) + strlen (group
) + strlen (size
) + 1;
1144 fprintf (stdlis
, "%s %s/%s %*s%s %s",
1145 modes
, user
, group
, ugswidth
- pad
, "", size
, time_stamp
);
1147 fprintf (stdlis
, " %s", quotearg (temp_name
));
1149 switch (current_header
->header
.typeflag
)
1152 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1156 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1161 char type_string
[2];
1162 type_string
[0] = current_header
->header
.typeflag
;
1163 type_string
[1] = '\0';
1164 fprintf (stdlis
, _(" unknown file type %s\n"),
1165 quote (type_string
));
1171 case GNUTYPE_SPARSE
:
1177 case GNUTYPE_DUMPDIR
:
1178 putc ('\n', stdlis
);
1181 case GNUTYPE_LONGLINK
:
1182 fprintf (stdlis
, _("--Long Link--\n"));
1185 case GNUTYPE_LONGNAME
:
1186 fprintf (stdlis
, _("--Long Name--\n"));
1189 case GNUTYPE_VOLHDR
:
1190 fprintf (stdlis
, _("--Volume Header--\n"));
1193 case GNUTYPE_MULTIVOL
:
1196 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1198 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1202 fprintf (stdlis
, _("--Mangled file names--\n"));
1209 /* Print a similar line when we make a directory automatically. */
1211 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1215 if (verbose_option
> 1)
1217 /* File type and modes. */
1220 decode_mode (mode
, modes
+ 1);
1222 if (block_number_option
)
1224 char buf
[UINTMAX_STRSIZE_BOUND
];
1225 fprintf (stdlis
, _("block %s: "),
1226 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1229 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ DATEWIDTH
,
1230 _("Creating directory:"), length
, quotearg (dirname
));
1234 /* Skip over SIZE bytes of data in blocks in the archive. */
1236 skip_file (off_t size
)
1240 if (multi_volume_option
)
1242 save_totsize
= size
;
1243 save_sizeleft
= size
;
1246 if (seekable_archive
)
1248 off_t nblk
= seek_archive (size
);
1251 size
-= nblk
* BLOCKSIZE
;
1252 if (multi_volume_option
) /* Argh.. */
1253 save_sizeleft
-= nblk
* BLOCKSIZE
;
1256 seekable_archive
= false;
1261 x
= find_next_block ();
1263 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1265 set_next_block_after (x
);
1267 if (multi_volume_option
)
1268 save_sizeleft
-= BLOCKSIZE
;
1272 /* Skip the current member in the archive.
1273 NOTE: Current header must be decoded before calling this function. */
1277 char save_typeflag
= current_header
->header
.typeflag
;
1278 set_next_block_after (current_header
);
1280 assign_string (&save_name
, current_stat_info
.file_name
);
1282 if (current_stat_info
.is_sparse
)
1283 sparse_skip_file (¤t_stat_info
);
1284 else if (save_typeflag
!= DIRTYPE
)
1285 skip_file (current_stat_info
.stat
.st_size
);