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
)));
129 case HEADER_ZERO_BLOCK
:
130 if (block_number_option
)
132 char buf
[UINTMAX_STRSIZE_BOUND
];
133 fprintf (stdlis
, _("block %s: ** Block of NULs **\n"),
134 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
137 set_next_block_after (current_header
);
139 if (!ignore_zeros_option
)
141 char buf
[UINTMAX_STRSIZE_BOUND
];
143 status
= read_header (false);
144 if (status
== HEADER_ZERO_BLOCK
)
146 WARN ((0, 0, _("A lone zero block at %s"),
147 STRINGIFY_BIGINT (current_block_ordinal (), buf
)));
150 status
= prev_status
;
153 case HEADER_END_OF_FILE
:
154 if (block_number_option
)
156 char buf
[UINTMAX_STRSIZE_BOUND
];
157 fprintf (stdlis
, _("block %s: ** End of File **\n"),
158 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
163 /* If the previous header was good, tell them that we are
164 skipping bad ones. */
165 set_next_block_after (current_header
);
168 case HEADER_STILL_UNREAD
:
169 ERROR ((0, 0, _("This does not look like a tar archive")));
172 case HEADER_ZERO_BLOCK
:
174 ERROR ((0, 0, _("Skipping to next header")));
177 case HEADER_END_OF_FILE
:
179 /* We are in the middle of a cascade of errors. */
182 case HEADER_SUCCESS_EXTENDED
:
189 while (!all_names_found (¤t_stat_info
));
192 names_notfound (); /* print names not found */
195 /* Print a header block, based on tar options. */
199 /* Print the header block. */
201 decode_header (current_header
, ¤t_stat_info
, ¤t_format
, 0);
203 print_header (¤t_stat_info
, -1);
205 if (incremental_option
&& current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
208 size_t written
, check
;
209 union block
*data_block
;
211 set_next_block_after (current_header
);
212 if (multi_volume_option
)
214 assign_string (&save_name
, current_stat_info
.file_name
);
215 save_totsize
= current_stat_info
.stat
.st_size
;
217 for (size
= current_stat_info
.stat
.st_size
; size
> 0; size
-= written
)
219 if (multi_volume_option
)
220 save_sizeleft
= size
;
221 data_block
= find_next_block ();
224 ERROR ((0, 0, _("Unexpected EOF in archive")));
225 break; /* FIXME: What happens, then? */
227 written
= available_space_after (data_block
);
231 check
= fwrite (data_block
->buffer
, sizeof (char), written
, stdlis
);
232 set_next_block_after ((union block
*)
233 (data_block
->buffer
+ written
- 1));
234 if (check
!= written
)
236 write_error_details (current_stat_info
.file_name
, check
, written
);
237 skip_file (size
- written
);
241 if (multi_volume_option
)
242 assign_string (&save_name
, 0);
243 fputc ('\n', stdlis
);
249 if (multi_volume_option
)
250 assign_string (&save_name
, current_stat_info
.file_name
);
254 if (multi_volume_option
)
255 assign_string (&save_name
, 0);
258 /* Read a block that's supposed to be a header block. Return its
259 address in "current_header", and if it is good, the file's size in
260 current_stat_info.stat.st_size.
262 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
263 block full of zeros (EOF marker).
265 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
266 GNU long name and link headers into later headers.
268 You must always set_next_block_after(current_header) to skip past
269 the header which this routine reads. */
271 /* The standard BSD tar sources create the checksum by adding up the
272 bytes in the header as type char. I think the type char was unsigned
273 on the PDP-11, but it's signed on the Next and Sun. It looks like the
274 sources to BSD tar were never changed to compute the checksum
275 correctly, so both the Sun and Next add the bytes of the header as
276 signed chars. This doesn't cause a problem until you get a file with
277 a name containing characters with the high bit set. So read_header
278 computes two checksums -- signed and unsigned. */
281 read_header (bool raw_extended_headers
)
284 int unsigned_sum
; /* the POSIX one :-) */
285 int signed_sum
; /* the Sun one :-( */
287 uintmax_t parsed_sum
;
290 union block
*header_copy
;
292 union block
*data_block
;
293 size_t size
, written
;
294 union block
*next_long_name
= 0;
295 union block
*next_long_link
= 0;
296 size_t next_long_name_blocks
;
297 size_t next_long_link_blocks
;
301 header
= find_next_block ();
302 current_header
= header
;
304 return HEADER_END_OF_FILE
;
309 for (i
= sizeof *header
; i
-- != 0;)
311 unsigned_sum
+= (unsigned char) *p
;
312 signed_sum
+= (signed char) (*p
++);
315 if (unsigned_sum
== 0)
316 return HEADER_ZERO_BLOCK
;
318 /* Adjust checksum to count the "chksum" field as blanks. */
320 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
322 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
323 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
325 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
326 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
328 parsed_sum
= from_header (header
->header
.chksum
,
329 sizeof header
->header
.chksum
, 0,
331 (uintmax_t) TYPE_MAXIMUM (int));
332 if (parsed_sum
== (uintmax_t) -1)
333 return HEADER_FAILURE
;
335 recorded_sum
= parsed_sum
;
337 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
338 return HEADER_FAILURE
;
340 /* Good block. Decode file size and return. */
342 if (header
->header
.typeflag
== LNKTYPE
)
343 current_stat_info
.stat
.st_size
= 0; /* links 0 size on tape */
345 current_stat_info
.stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
347 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
348 || header
->header
.typeflag
== GNUTYPE_LONGLINK
349 || header
->header
.typeflag
== XHDTYPE
350 || header
->header
.typeflag
== XGLTYPE
)
352 if (raw_extended_headers
)
353 return HEADER_SUCCESS_EXTENDED
;
354 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
355 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
357 size_t name_size
= current_stat_info
.stat
.st_size
;
358 size
= name_size
- name_size
% BLOCKSIZE
+ 2 * BLOCKSIZE
;
359 if (name_size
!= current_stat_info
.stat
.st_size
363 header_copy
= xmalloc (size
+ 1);
365 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
368 free (next_long_name
);
369 next_long_name
= header_copy
;
370 next_long_name_blocks
= size
/ BLOCKSIZE
;
375 free (next_long_link
);
376 next_long_link
= header_copy
;
377 next_long_link_blocks
= size
/ BLOCKSIZE
;
380 set_next_block_after (header
);
381 *header_copy
= *header
;
382 bp
= header_copy
->buffer
+ BLOCKSIZE
;
384 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
386 data_block
= find_next_block ();
389 ERROR ((0, 0, _("Unexpected EOF in archive")));
392 written
= available_space_after (data_block
);
396 memcpy (bp
, data_block
->buffer
, written
);
398 set_next_block_after ((union block
*)
399 (data_block
->buffer
+ written
- 1));
404 else if (header
->header
.typeflag
== XHDTYPE
)
405 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
406 else if (header
->header
.typeflag
== XGLTYPE
)
408 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
409 xheader_decode_global ();
418 struct posix_header
const *h
= ¤t_header
->header
;
419 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
421 if (recent_long_name
)
422 free (recent_long_name
);
426 name
= next_long_name
->buffer
+ BLOCKSIZE
;
427 recent_long_name
= next_long_name
;
428 recent_long_name_blocks
= next_long_name_blocks
;
432 /* Accept file names as specified by POSIX.1-1996
436 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
438 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
439 np
[sizeof h
->prefix
] = '\0';
443 /* Prevent later references to current_header from
444 mistakenly treating this as an old GNU header.
445 This assignment invalidates h->prefix. */
446 current_header
->oldgnu_header
.isextended
= 0;
448 memcpy (np
, h
->name
, sizeof h
->name
);
449 np
[sizeof h
->name
] = '\0';
451 recent_long_name
= 0;
452 recent_long_name_blocks
= 0;
454 assign_string (¤t_stat_info
.orig_file_name
, name
);
455 assign_string (¤t_stat_info
.file_name
, name
);
456 current_stat_info
.had_trailing_slash
= strip_trailing_slashes (current_stat_info
.file_name
);
458 if (recent_long_link
)
459 free (recent_long_link
);
463 name
= next_long_link
->buffer
+ BLOCKSIZE
;
464 recent_long_link
= next_long_link
;
465 recent_long_link_blocks
= next_long_link_blocks
;
469 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
470 namebuf
[sizeof h
->linkname
] = '\0';
472 recent_long_link
= 0;
473 recent_long_link_blocks
= 0;
475 assign_string (¤t_stat_info
.link_name
, name
);
477 return HEADER_SUCCESS
;
482 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
484 /* Decode things from a file HEADER block into STAT_INFO, also setting
485 *FORMAT_POINTER depending on the header block format. If
486 DO_USER_GROUP, decode the user/group information (this is useful
487 for extraction, but waste time when merely listing).
489 read_header() has already decoded the checksum and length, so we don't.
491 This routine should *not* be called twice for the same block, since
492 the two calls might use different DO_USER_GROUP values and thus
493 might end up with different uid/gid for the two calls. If anybody
494 wants the uid/gid they should decode it first, and other callers
495 should decode it without uid/gid before calling a routine,
496 e.g. print_header, that assumes decoded data. */
498 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
499 enum archive_format
*format_pointer
, int do_user_group
)
501 enum archive_format format
;
503 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
505 if (header
->star_header
.prefix
[130] == 0
506 && ISOCTAL (header
->star_header
.atime
[0])
507 && header
->star_header
.atime
[11] == ' '
508 && ISOCTAL (header
->star_header
.ctime
[0])
509 && header
->star_header
.ctime
[11] == ' ')
510 format
= STAR_FORMAT
;
511 else if (extended_header
.size
)
512 format
= POSIX_FORMAT
;
514 format
= USTAR_FORMAT
;
516 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
517 format
= OLDGNU_FORMAT
;
520 *format_pointer
= format
;
522 stat_info
->stat
.st_mode
= MODE_FROM_HEADER (header
->header
.mode
);
523 stat_info
->stat
.st_mtime
= TIME_FROM_HEADER (header
->header
.mtime
);
524 assign_string (&stat_info
->uname
, header
->header
.uname
);
525 assign_string (&stat_info
->gname
, header
->header
.gname
);
526 stat_info
->devmajor
= MAJOR_FROM_HEADER (header
->header
.devmajor
);
527 stat_info
->devminor
= MINOR_FROM_HEADER (header
->header
.devminor
);
529 stat_info
->stat
.st_atime
= start_time
;
530 stat_info
->stat
.st_ctime
= start_time
;
532 if (format
== OLDGNU_FORMAT
&& incremental_option
)
534 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
535 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
538 if (format
== V7_FORMAT
)
540 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
541 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
542 stat_info
->stat
.st_rdev
= 0;
547 if (format
== STAR_FORMAT
)
549 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->star_header
.atime
);
550 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->star_header
.ctime
);
555 /* FIXME: Decide if this should somewhat depend on -p. */
557 if (numeric_owner_option
558 || !*header
->header
.uname
559 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
560 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
562 if (numeric_owner_option
563 || !*header
->header
.gname
564 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
565 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
568 switch (header
->header
.typeflag
)
572 stat_info
->stat
.st_rdev
= makedev (stat_info
->devmajor
,
573 stat_info
->devminor
);
577 stat_info
->stat
.st_rdev
= 0;
581 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
582 xheader_decode (stat_info
);
584 if (sparse_member_p (stat_info
))
586 sparse_fixup_header (stat_info
);
587 stat_info
->is_sparse
= true;
591 /* Convert buffer at WHERE0 of size DIGS from external format to
592 uintmax_t. The data is of type TYPE. The buffer must represent a
593 value in the range -MINUS_MINVAL through MAXVAL. DIGS must be
594 positive. Return -1 on error, diagnosing the error if TYPE is
597 from_header (char const *where0
, size_t digs
, char const *type
,
598 uintmax_t minus_minval
, uintmax_t maxval
)
601 char const *where
= where0
;
602 char const *lim
= where
+ digs
;
605 /* Accommodate buggy tar of unknown vintage, which outputs leading
606 NUL if the previous field overflows. */
609 /* Accommodate older tars, which output leading spaces. */
616 _("Blanks in header where numeric %s value expected"),
620 if (!ISSPACE ((unsigned char) *where
))
626 if (ISODIGIT (*where
))
628 char const *where1
= where
;
629 uintmax_t overflow
= 0;
633 value
+= *where
++ - '0';
634 if (where
== lim
|| ! ISODIGIT (*where
))
636 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
640 /* Parse the output of older, unportable tars, which generate
641 negative values in two's complement octal. If the leading
642 nonzero digit is 1, we can't recover the original value
643 reliably; so do this only if the digit is 2 or more. This
644 catches the common case of 32-bit negative time stamps. */
645 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
647 /* Compute the negative of the input value, assuming two's
649 int digit
= (*where1
- '0') | 4;
657 if (where
== lim
|| ! ISODIGIT (*where
))
659 digit
= *where
- '0';
660 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
666 if (!overflow
&& value
<= minus_minval
)
669 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
670 (int) (where
- where1
), where1
, type
));
679 _("Archive octal value %.*s is out of %s range"),
680 (int) (where
- where1
), where1
, type
));
684 else if (*where
== '-' || *where
== '+')
686 /* Parse base-64 output produced only by tar test versions
687 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
688 Support for this will be withdrawn in future releases. */
690 static int warned_once
;
695 _("Archive contains obsolescent base-64 headers")));
697 negative
= *where
++ == '-';
699 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
701 if (value
<< LG_64
>> LG_64
!= value
)
703 char *string
= alloca (digs
+ 1);
704 memcpy (string
, where0
, digs
);
708 _("Archive signed base-64 string %s is out of %s range"),
709 quote (string
), type
));
712 value
= (value
<< LG_64
) | dig
;
716 else if (*where
== '\200' /* positive base-256 */
717 || *where
== '\377' /* negative base-256 */)
719 /* Parse base-256 output. A nonnegative number N is
720 represented as (256**DIGS)/2 + N; a negative number -N is
721 represented as (256**DIGS) - N, i.e. as two's complement.
722 The representation guarantees that the leading bit is
723 always on, so that we don't confuse this format with the
724 others (assuming ASCII bytes of 8 bits or more). */
725 int signbit
= *where
& (1 << (LG_256
- 2));
726 uintmax_t topbits
= (((uintmax_t) - signbit
)
727 << (CHAR_BIT
* sizeof (uintmax_t)
728 - LG_256
- (LG_256
- 2)));
729 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
732 value
= (value
<< LG_256
) + (unsigned char) *where
++;
735 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
739 _("Archive base-256 value is out of %s range"),
749 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
753 char buf
[1000]; /* Big enough to represent any header. */
754 static struct quoting_options
*o
;
758 o
= clone_quoting_options (0);
759 set_quoting_style (o
, locale_quoting_style
);
762 while (where0
!= lim
&& ! lim
[-1])
764 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
766 _("Archive contains %.*s where numeric %s value expected"),
767 (int) sizeof buf
, buf
, type
));
773 if (value
<= (negative
? minus_minval
: maxval
))
774 return negative
? -value
: value
;
778 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
779 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
780 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
781 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
782 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
784 *--value_string
= '-';
786 *--minval_string
= '-';
787 ERROR ((0, 0, _("Archive value %s is out of %s range %s.%s"),
789 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
796 gid_from_header (const char *p
, size_t s
)
798 return from_header (p
, s
, "gid_t",
799 - (uintmax_t) TYPE_MINIMUM (gid_t
),
800 (uintmax_t) TYPE_MAXIMUM (gid_t
));
804 major_from_header (const char *p
, size_t s
)
806 return from_header (p
, s
, "major_t",
807 - (uintmax_t) TYPE_MINIMUM (major_t
),
808 (uintmax_t) TYPE_MAXIMUM (major_t
));
812 minor_from_header (const char *p
, size_t s
)
814 return from_header (p
, s
, "minor_t",
815 - (uintmax_t) TYPE_MINIMUM (minor_t
),
816 (uintmax_t) TYPE_MAXIMUM (minor_t
));
820 mode_from_header (const char *p
, size_t s
)
822 /* Do not complain about unrecognized mode bits. */
823 unsigned u
= from_header (p
, s
, "mode_t",
824 - (uintmax_t) TYPE_MINIMUM (mode_t
),
825 TYPE_MAXIMUM (uintmax_t));
826 return ((u
& TSUID
? S_ISUID
: 0)
827 | (u
& TSGID
? S_ISGID
: 0)
828 | (u
& TSVTX
? S_ISVTX
: 0)
829 | (u
& TUREAD
? S_IRUSR
: 0)
830 | (u
& TUWRITE
? S_IWUSR
: 0)
831 | (u
& TUEXEC
? S_IXUSR
: 0)
832 | (u
& TGREAD
? S_IRGRP
: 0)
833 | (u
& TGWRITE
? S_IWGRP
: 0)
834 | (u
& TGEXEC
? S_IXGRP
: 0)
835 | (u
& TOREAD
? S_IROTH
: 0)
836 | (u
& TOWRITE
? S_IWOTH
: 0)
837 | (u
& TOEXEC
? S_IXOTH
: 0));
841 off_from_header (const char *p
, size_t s
)
843 /* Negative offsets are not allowed in tar files, so invoke
844 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
845 return from_header (p
, s
, "off_t", (uintmax_t) 0,
846 (uintmax_t) TYPE_MAXIMUM (off_t
));
850 size_from_header (const char *p
, size_t s
)
852 return from_header (p
, s
, "size_t", (uintmax_t) 0,
853 (uintmax_t) TYPE_MAXIMUM (size_t));
857 time_from_header (const char *p
, size_t s
)
859 return from_header (p
, s
, "time_t",
860 - (uintmax_t) TYPE_MINIMUM (time_t),
861 (uintmax_t) TYPE_MAXIMUM (time_t));
865 uid_from_header (const char *p
, size_t s
)
867 return from_header (p
, s
, "uid_t",
868 - (uintmax_t) TYPE_MINIMUM (uid_t
),
869 (uintmax_t) TYPE_MAXIMUM (uid_t
));
873 uintmax_from_header (const char *p
, size_t s
)
875 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
876 TYPE_MAXIMUM (uintmax_t));
880 /* Format O as a null-terminated decimal string into BUF _backwards_;
881 return pointer to start of result. */
883 stringify_uintmax_t_backwards (uintmax_t o
, char *buf
)
887 *--buf
= '0' + (int) (o
% 10);
888 while ((o
/= 10) != 0);
892 /* Return a printable representation of T. The result points to
893 static storage that can be reused in the next call to this
894 function, to ctime, or to asctime. */
898 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
899 INT_STRLEN_BOUND (int) + 16)];
906 char const *time_stamp
= p
+ 4;
907 for (p
+= 16; p
[3] != '\n'; p
++)
913 /* Use ISO 8610 format. See:
914 http://www.cl.cam.ac.uk/~mgk25/iso-time.html */
915 struct tm
*tm
= utc_option
? gmtime (&t
) : localtime (&t
);
918 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
919 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
920 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
925 /* The time stamp cannot be broken down, most likely because it
926 is out of range. Convert it as an integer,
927 right-adjusted in a field with the same width as the usual
928 19-byte 4-year ISO time format. */
929 p
= stringify_uintmax_t_backwards (t
< 0 ? - (uintmax_t) t
: (uintmax_t) t
,
930 buffer
+ sizeof buffer
);
933 while (buffer
+ sizeof buffer
- 19 - 1 < p
)
938 /* Actually print it.
940 Plain and fancy file header block logging. Non-verbose just prints
941 the name, e.g. for "tar t" or "tar x". This should just contain
942 file names, so it can be fed back into tar with xargs or the "-T"
943 option. The verbose option can give a bunch of info, one line per
944 file. I doubt anybody tries to parse its format, or if they do,
945 they shouldn't. Unix tar is pretty random here anyway. */
948 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
949 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
951 /* UGSWIDTH starts with 18, so with user and group names <= 8 chars, the
952 columns never shift during the listing. */
954 static int ugswidth
= UGSWIDTH
; /* maximum width encountered so far */
956 /* DATEWIDTH is the number of columns taken by the date and time fields. */
958 # define DATEWIDTH 19
960 # define DATEWIDTH 18
964 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
967 char const *time_stamp
;
968 char *temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
970 /* These hold formatted ints. */
971 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
973 char size
[2 * UINTMAX_STRSIZE_BOUND
];
974 /* holds formatted size or major,minor */
975 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
978 if (block_number_option
)
980 char buf
[UINTMAX_STRSIZE_BOUND
];
981 if (block_ordinal
< 0)
982 block_ordinal
= current_block_ordinal ();
983 block_ordinal
-= recent_long_name_blocks
;
984 block_ordinal
-= recent_long_link_blocks
;
985 fprintf (stdlis
, _("block %s: "),
986 STRINGIFY_BIGINT (block_ordinal
, buf
));
989 if (verbose_option
<= 1)
991 /* Just the fax, mam. */
992 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
996 /* File type and modes. */
999 switch (current_header
->header
.typeflag
)
1001 case GNUTYPE_VOLHDR
:
1005 case GNUTYPE_MULTIVOL
:
1013 case GNUTYPE_LONGNAME
:
1014 case GNUTYPE_LONGLINK
:
1016 ERROR ((0, 0, _("Visible longname error")));
1019 case GNUTYPE_SPARSE
:
1023 if (temp_name
[strlen (temp_name
) - 1] == '/')
1029 case GNUTYPE_DUMPDIR
:
1052 decode_mode (st
->stat
.st_mode
, modes
+ 1);
1056 time_stamp
= tartime (st
->stat
.st_mtime
);
1058 /* User and group names. */
1060 if (st
->uname
&& current_format
!= V7_FORMAT
1061 && !numeric_owner_option
)
1065 /* Try parsing it as an unsigned integer first, and as a
1066 uid_t if that fails. This method can list positive user
1067 ids that are too large to fit in a uid_t. */
1068 uintmax_t u
= from_header (current_header
->header
.uid
,
1069 sizeof current_header
->header
.uid
, 0,
1071 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1073 user
= STRINGIFY_BIGINT (u
, uform
);
1076 sprintf (uform
, "%ld",
1077 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1082 if (st
->gname
&& current_format
!= V7_FORMAT
1083 && !numeric_owner_option
)
1087 /* Try parsing it as an unsigned integer first, and as a
1088 gid_t if that fails. This method can list positive group
1089 ids that are too large to fit in a gid_t. */
1090 uintmax_t g
= from_header (current_header
->header
.gid
,
1091 sizeof current_header
->header
.gid
, 0,
1093 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1095 group
= STRINGIFY_BIGINT (g
, gform
);
1098 sprintf (gform
, "%ld",
1099 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1104 /* Format the file size or major/minor device numbers. */
1106 switch (current_header
->header
.typeflag
)
1111 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1114 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1118 /* st->stat.st_size keeps stored file size */
1119 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1123 /* Figure out padding and print the whole line. */
1125 pad
= strlen (user
) + strlen (group
) + strlen (size
) + 1;
1129 fprintf (stdlis
, "%s %s/%s %*s%s %s",
1130 modes
, user
, group
, ugswidth
- pad
, "", size
, time_stamp
);
1132 fprintf (stdlis
, " %s", quotearg (temp_name
));
1134 switch (current_header
->header
.typeflag
)
1137 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1141 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1146 char type_string
[2];
1147 type_string
[0] = current_header
->header
.typeflag
;
1148 type_string
[1] = '\0';
1149 fprintf (stdlis
, _(" unknown file type %s\n"),
1150 quote (type_string
));
1156 case GNUTYPE_SPARSE
:
1162 case GNUTYPE_DUMPDIR
:
1163 putc ('\n', stdlis
);
1166 case GNUTYPE_LONGLINK
:
1167 fprintf (stdlis
, _("--Long Link--\n"));
1170 case GNUTYPE_LONGNAME
:
1171 fprintf (stdlis
, _("--Long Name--\n"));
1174 case GNUTYPE_VOLHDR
:
1175 fprintf (stdlis
, _("--Volume Header--\n"));
1178 case GNUTYPE_MULTIVOL
:
1181 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1183 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1187 fprintf (stdlis
, _("--Mangled file names--\n"));
1194 /* Print a similar line when we make a directory automatically. */
1196 print_for_mkdir (char *pathname
, int length
, mode_t mode
)
1200 if (verbose_option
> 1)
1202 /* File type and modes. */
1205 decode_mode (mode
, modes
+ 1);
1207 if (block_number_option
)
1209 char buf
[UINTMAX_STRSIZE_BOUND
];
1210 fprintf (stdlis
, _("block %s: "),
1211 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1214 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ DATEWIDTH
,
1215 _("Creating directory:"), length
, quotearg (pathname
));
1219 /* Skip over SIZE bytes of data in blocks in the archive. */
1221 skip_file (off_t size
)
1225 if (multi_volume_option
)
1227 save_totsize
= size
;
1228 save_sizeleft
= size
;
1233 x
= find_next_block ();
1235 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1237 set_next_block_after (x
);
1239 if (multi_volume_option
)
1240 save_sizeleft
-= BLOCKSIZE
;
1244 /* Skip the current member in the archive. */
1248 char save_typeflag
= current_header
->header
.typeflag
;
1249 set_next_block_after (current_header
);
1251 assign_string (&save_name
, current_stat_info
.file_name
);
1253 if (sparse_member_p (¤t_stat_info
))
1254 sparse_skip_file (¤t_stat_info
);
1255 else if (save_typeflag
!= DIRTYPE
)
1256 skip_file (current_stat_info
.stat
.st_size
);