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 if (block_number_option
)
176 char buf
[UINTMAX_STRSIZE_BOUND
];
177 off_t block_ordinal
= current_block_ordinal ();
178 block_ordinal
-= recent_long_name_blocks
;
179 block_ordinal
-= recent_long_link_blocks
;
180 fprintf (stdlis
, _("block %s: "),
181 STRINGIFY_BIGINT (block_ordinal
, buf
));
183 ERROR ((0, 0, _("Skipping to next header")));
186 case HEADER_END_OF_FILE
:
188 /* We are in the middle of a cascade of errors. */
191 case HEADER_SUCCESS_EXTENDED
:
198 while (!all_names_found (¤t_stat_info
));
201 names_notfound (); /* print names not found */
204 /* Print a header block, based on tar options. */
208 /* Print the header block. */
210 decode_header (current_header
, ¤t_stat_info
, ¤t_format
, 0);
212 print_header (¤t_stat_info
, -1);
214 if (incremental_option
&& current_header
->header
.typeflag
== GNUTYPE_DUMPDIR
)
217 size_t written
, check
;
218 union block
*data_block
;
220 set_next_block_after (current_header
);
221 if (multi_volume_option
)
223 assign_string (&save_name
, current_stat_info
.file_name
);
224 save_totsize
= current_stat_info
.stat
.st_size
;
226 for (size
= current_stat_info
.stat
.st_size
; size
> 0; size
-= written
)
228 if (multi_volume_option
)
229 save_sizeleft
= size
;
230 data_block
= find_next_block ();
233 ERROR ((0, 0, _("Unexpected EOF in archive")));
234 break; /* FIXME: What happens, then? */
236 written
= available_space_after (data_block
);
240 check
= fwrite (data_block
->buffer
, sizeof (char), written
, stdlis
);
241 set_next_block_after ((union block
*)
242 (data_block
->buffer
+ written
- 1));
243 if (check
!= written
)
245 write_error_details (current_stat_info
.file_name
, check
, written
);
246 skip_file (size
- written
);
250 if (multi_volume_option
)
251 assign_string (&save_name
, 0);
252 fputc ('\n', stdlis
);
258 if (multi_volume_option
)
259 assign_string (&save_name
, current_stat_info
.file_name
);
263 if (multi_volume_option
)
264 assign_string (&save_name
, 0);
267 /* Read a block that's supposed to be a header block. Return its
268 address in "current_header", and if it is good, the file's size in
269 current_stat_info.stat.st_size.
271 Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
272 block full of zeros (EOF marker).
274 If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
275 GNU long name and link headers into later headers.
277 You must always set_next_block_after(current_header) to skip past
278 the header which this routine reads. */
280 /* The standard BSD tar sources create the checksum by adding up the
281 bytes in the header as type char. I think the type char was unsigned
282 on the PDP-11, but it's signed on the Next and Sun. It looks like the
283 sources to BSD tar were never changed to compute the checksum
284 correctly, so both the Sun and Next add the bytes of the header as
285 signed chars. This doesn't cause a problem until you get a file with
286 a name containing characters with the high bit set. So read_header
287 computes two checksums -- signed and unsigned. */
290 read_header (bool raw_extended_headers
)
293 int unsigned_sum
; /* the POSIX one :-) */
294 int signed_sum
; /* the Sun one :-( */
296 uintmax_t parsed_sum
;
299 union block
*header_copy
;
301 union block
*data_block
;
302 size_t size
, written
;
303 union block
*next_long_name
= 0;
304 union block
*next_long_link
= 0;
305 size_t next_long_name_blocks
;
306 size_t next_long_link_blocks
;
310 header
= find_next_block ();
311 current_header
= header
;
313 return HEADER_END_OF_FILE
;
318 for (i
= sizeof *header
; i
-- != 0;)
320 unsigned_sum
+= (unsigned char) *p
;
321 signed_sum
+= (signed char) (*p
++);
324 if (unsigned_sum
== 0)
325 return HEADER_ZERO_BLOCK
;
327 /* Adjust checksum to count the "chksum" field as blanks. */
329 for (i
= sizeof header
->header
.chksum
; i
-- != 0;)
331 unsigned_sum
-= (unsigned char) header
->header
.chksum
[i
];
332 signed_sum
-= (signed char) (header
->header
.chksum
[i
]);
334 unsigned_sum
+= ' ' * sizeof header
->header
.chksum
;
335 signed_sum
+= ' ' * sizeof header
->header
.chksum
;
337 parsed_sum
= from_header (header
->header
.chksum
,
338 sizeof header
->header
.chksum
, 0,
340 (uintmax_t) TYPE_MAXIMUM (int));
341 if (parsed_sum
== (uintmax_t) -1)
342 return HEADER_FAILURE
;
344 recorded_sum
= parsed_sum
;
346 if (unsigned_sum
!= recorded_sum
&& signed_sum
!= recorded_sum
)
347 return HEADER_FAILURE
;
349 /* Good block. Decode file size and return. */
351 if (header
->header
.typeflag
== LNKTYPE
)
352 current_stat_info
.stat
.st_size
= 0; /* links 0 size on tape */
354 current_stat_info
.stat
.st_size
= OFF_FROM_HEADER (header
->header
.size
);
356 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
357 || header
->header
.typeflag
== GNUTYPE_LONGLINK
358 || header
->header
.typeflag
== XHDTYPE
359 || header
->header
.typeflag
== XGLTYPE
)
361 if (raw_extended_headers
)
362 return HEADER_SUCCESS_EXTENDED
;
363 else if (header
->header
.typeflag
== GNUTYPE_LONGNAME
364 || header
->header
.typeflag
== GNUTYPE_LONGLINK
)
366 size_t name_size
= current_stat_info
.stat
.st_size
;
367 size
= name_size
- name_size
% BLOCKSIZE
+ 2 * BLOCKSIZE
;
368 if (name_size
!= current_stat_info
.stat
.st_size
372 header_copy
= xmalloc (size
+ 1);
374 if (header
->header
.typeflag
== GNUTYPE_LONGNAME
)
377 free (next_long_name
);
378 next_long_name
= header_copy
;
379 next_long_name_blocks
= size
/ BLOCKSIZE
;
384 free (next_long_link
);
385 next_long_link
= header_copy
;
386 next_long_link_blocks
= size
/ BLOCKSIZE
;
389 set_next_block_after (header
);
390 *header_copy
= *header
;
391 bp
= header_copy
->buffer
+ BLOCKSIZE
;
393 for (size
-= BLOCKSIZE
; size
> 0; size
-= written
)
395 data_block
= find_next_block ();
398 ERROR ((0, 0, _("Unexpected EOF in archive")));
401 written
= available_space_after (data_block
);
405 memcpy (bp
, data_block
->buffer
, written
);
407 set_next_block_after ((union block
*)
408 (data_block
->buffer
+ written
- 1));
413 else if (header
->header
.typeflag
== XHDTYPE
)
414 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
415 else if (header
->header
.typeflag
== XGLTYPE
)
417 xheader_read (header
, OFF_FROM_HEADER (header
->header
.size
));
418 xheader_decode_global ();
427 struct posix_header
const *h
= ¤t_header
->header
;
428 char namebuf
[sizeof h
->prefix
+ 1 + NAME_FIELD_SIZE
+ 1];
430 if (recent_long_name
)
431 free (recent_long_name
);
435 name
= next_long_name
->buffer
+ BLOCKSIZE
;
436 recent_long_name
= next_long_name
;
437 recent_long_name_blocks
= next_long_name_blocks
;
441 /* Accept file names as specified by POSIX.1-1996
445 if (h
->prefix
[0] && strcmp (h
->magic
, TMAGIC
) == 0)
447 memcpy (np
, h
->prefix
, sizeof h
->prefix
);
448 np
[sizeof h
->prefix
] = '\0';
452 /* Prevent later references to current_header from
453 mistakenly treating this as an old GNU header.
454 This assignment invalidates h->prefix. */
455 current_header
->oldgnu_header
.isextended
= 0;
457 memcpy (np
, h
->name
, sizeof h
->name
);
458 np
[sizeof h
->name
] = '\0';
460 recent_long_name
= 0;
461 recent_long_name_blocks
= 0;
463 assign_string (¤t_stat_info
.orig_file_name
, name
);
464 assign_string (¤t_stat_info
.file_name
, name
);
465 current_stat_info
.had_trailing_slash
= strip_trailing_slashes (current_stat_info
.file_name
);
467 if (recent_long_link
)
468 free (recent_long_link
);
472 name
= next_long_link
->buffer
+ BLOCKSIZE
;
473 recent_long_link
= next_long_link
;
474 recent_long_link_blocks
= next_long_link_blocks
;
478 memcpy (namebuf
, h
->linkname
, sizeof h
->linkname
);
479 namebuf
[sizeof h
->linkname
] = '\0';
481 recent_long_link
= 0;
482 recent_long_link_blocks
= 0;
484 assign_string (¤t_stat_info
.link_name
, name
);
486 return HEADER_SUCCESS
;
491 #define ISOCTAL(c) ((c)>='0'&&(c)<='7')
493 /* Decode things from a file HEADER block into STAT_INFO, also setting
494 *FORMAT_POINTER depending on the header block format. If
495 DO_USER_GROUP, decode the user/group information (this is useful
496 for extraction, but waste time when merely listing).
498 read_header() has already decoded the checksum and length, so we don't.
500 This routine should *not* be called twice for the same block, since
501 the two calls might use different DO_USER_GROUP values and thus
502 might end up with different uid/gid for the two calls. If anybody
503 wants the uid/gid they should decode it first, and other callers
504 should decode it without uid/gid before calling a routine,
505 e.g. print_header, that assumes decoded data. */
507 decode_header (union block
*header
, struct tar_stat_info
*stat_info
,
508 enum archive_format
*format_pointer
, int do_user_group
)
510 enum archive_format format
;
512 if (strcmp (header
->header
.magic
, TMAGIC
) == 0)
514 if (header
->star_header
.prefix
[130] == 0
515 && ISOCTAL (header
->star_header
.atime
[0])
516 && header
->star_header
.atime
[11] == ' '
517 && ISOCTAL (header
->star_header
.ctime
[0])
518 && header
->star_header
.ctime
[11] == ' ')
519 format
= STAR_FORMAT
;
520 else if (extended_header
.size
)
521 format
= POSIX_FORMAT
;
523 format
= USTAR_FORMAT
;
525 else if (strcmp (header
->header
.magic
, OLDGNU_MAGIC
) == 0)
526 format
= OLDGNU_FORMAT
;
529 *format_pointer
= format
;
531 stat_info
->stat
.st_mode
= MODE_FROM_HEADER (header
->header
.mode
);
532 stat_info
->stat
.st_mtime
= TIME_FROM_HEADER (header
->header
.mtime
);
533 assign_string (&stat_info
->uname
, header
->header
.uname
);
534 assign_string (&stat_info
->gname
, header
->header
.gname
);
535 stat_info
->devmajor
= MAJOR_FROM_HEADER (header
->header
.devmajor
);
536 stat_info
->devminor
= MINOR_FROM_HEADER (header
->header
.devminor
);
538 stat_info
->stat
.st_atime
= start_time
;
539 stat_info
->stat
.st_ctime
= start_time
;
541 if (format
== OLDGNU_FORMAT
&& incremental_option
)
543 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->oldgnu_header
.atime
);
544 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->oldgnu_header
.ctime
);
547 if (format
== V7_FORMAT
)
549 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
550 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
551 stat_info
->stat
.st_rdev
= 0;
556 if (format
== STAR_FORMAT
)
558 stat_info
->stat
.st_atime
= TIME_FROM_HEADER (header
->star_header
.atime
);
559 stat_info
->stat
.st_ctime
= TIME_FROM_HEADER (header
->star_header
.ctime
);
564 /* FIXME: Decide if this should somewhat depend on -p. */
566 if (numeric_owner_option
567 || !*header
->header
.uname
568 || !uname_to_uid (header
->header
.uname
, &stat_info
->stat
.st_uid
))
569 stat_info
->stat
.st_uid
= UID_FROM_HEADER (header
->header
.uid
);
571 if (numeric_owner_option
572 || !*header
->header
.gname
573 || !gname_to_gid (header
->header
.gname
, &stat_info
->stat
.st_gid
))
574 stat_info
->stat
.st_gid
= GID_FROM_HEADER (header
->header
.gid
);
577 switch (header
->header
.typeflag
)
581 stat_info
->stat
.st_rdev
= makedev (stat_info
->devmajor
,
582 stat_info
->devminor
);
586 stat_info
->stat
.st_rdev
= 0;
590 stat_info
->archive_file_size
= stat_info
->stat
.st_size
;
591 xheader_decode (stat_info
);
593 if (sparse_member_p (stat_info
))
595 sparse_fixup_header (stat_info
);
596 stat_info
->is_sparse
= true;
600 /* Convert buffer at WHERE0 of size DIGS from external format to
601 uintmax_t. The data is of type TYPE. The buffer must represent a
602 value in the range -MINUS_MINVAL through MAXVAL. DIGS must be
603 positive. Return -1 on error, diagnosing the error if TYPE is
606 from_header (char const *where0
, size_t digs
, char const *type
,
607 uintmax_t minus_minval
, uintmax_t maxval
)
610 char const *where
= where0
;
611 char const *lim
= where
+ digs
;
614 /* Accommodate buggy tar of unknown vintage, which outputs leading
615 NUL if the previous field overflows. */
618 /* Accommodate older tars, which output leading spaces. */
625 _("Blanks in header where numeric %s value expected"),
629 if (!ISSPACE ((unsigned char) *where
))
635 if (ISODIGIT (*where
))
637 char const *where1
= where
;
638 uintmax_t overflow
= 0;
642 value
+= *where
++ - '0';
643 if (where
== lim
|| ! ISODIGIT (*where
))
645 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
649 /* Parse the output of older, unportable tars, which generate
650 negative values in two's complement octal. If the leading
651 nonzero digit is 1, we can't recover the original value
652 reliably; so do this only if the digit is 2 or more. This
653 catches the common case of 32-bit negative time stamps. */
654 if ((overflow
|| maxval
< value
) && '2' <= *where1
&& type
)
656 /* Compute the negative of the input value, assuming two's
658 int digit
= (*where1
- '0') | 4;
666 if (where
== lim
|| ! ISODIGIT (*where
))
668 digit
= *where
- '0';
669 overflow
|= value
^ (value
<< LG_8
>> LG_8
);
675 if (!overflow
&& value
<= minus_minval
)
678 _("Archive octal value %.*s is out of %s range; assuming two's complement"),
679 (int) (where
- where1
), where1
, type
));
688 _("Archive octal value %.*s is out of %s range"),
689 (int) (where
- where1
), where1
, type
));
693 else if (*where
== '-' || *where
== '+')
695 /* Parse base-64 output produced only by tar test versions
696 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
697 Support for this will be withdrawn in future releases. */
699 static int warned_once
;
704 _("Archive contains obsolescent base-64 headers")));
706 negative
= *where
++ == '-';
708 && (dig
= base64_map
[(unsigned char) *where
]) < 64)
710 if (value
<< LG_64
>> LG_64
!= value
)
712 char *string
= alloca (digs
+ 1);
713 memcpy (string
, where0
, digs
);
717 _("Archive signed base-64 string %s is out of %s range"),
718 quote (string
), type
));
721 value
= (value
<< LG_64
) | dig
;
725 else if (*where
== '\200' /* positive base-256 */
726 || *where
== '\377' /* negative base-256 */)
728 /* Parse base-256 output. A nonnegative number N is
729 represented as (256**DIGS)/2 + N; a negative number -N is
730 represented as (256**DIGS) - N, i.e. as two's complement.
731 The representation guarantees that the leading bit is
732 always on, so that we don't confuse this format with the
733 others (assuming ASCII bytes of 8 bits or more). */
734 int signbit
= *where
& (1 << (LG_256
- 2));
735 uintmax_t topbits
= (((uintmax_t) - signbit
)
736 << (CHAR_BIT
* sizeof (uintmax_t)
737 - LG_256
- (LG_256
- 2)));
738 value
= (*where
++ & ((1 << (LG_256
- 2)) - 1)) - signbit
;
741 value
= (value
<< LG_256
) + (unsigned char) *where
++;
744 if (((value
<< LG_256
>> LG_256
) | topbits
) != value
)
748 _("Archive base-256 value is out of %s range"),
758 if (where
!= lim
&& *where
&& !ISSPACE ((unsigned char) *where
))
762 char buf
[1000]; /* Big enough to represent any header. */
763 static struct quoting_options
*o
;
767 o
= clone_quoting_options (0);
768 set_quoting_style (o
, locale_quoting_style
);
771 while (where0
!= lim
&& ! lim
[-1])
773 quotearg_buffer (buf
, sizeof buf
, where0
, lim
- where
, o
);
775 _("Archive contains %.*s where numeric %s value expected"),
776 (int) sizeof buf
, buf
, type
));
782 if (value
<= (negative
? minus_minval
: maxval
))
783 return negative
? -value
: value
;
787 char minval_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
788 char maxval_buf
[UINTMAX_STRSIZE_BOUND
];
789 char value_buf
[UINTMAX_STRSIZE_BOUND
+ 1];
790 char *minval_string
= STRINGIFY_BIGINT (minus_minval
, minval_buf
+ 1);
791 char *value_string
= STRINGIFY_BIGINT (value
, value_buf
+ 1);
793 *--value_string
= '-';
795 *--minval_string
= '-';
796 ERROR ((0, 0, _("Archive value %s is out of %s range %s.%s"),
798 minval_string
, STRINGIFY_BIGINT (maxval
, maxval_buf
)));
805 gid_from_header (const char *p
, size_t s
)
807 return from_header (p
, s
, "gid_t",
808 - (uintmax_t) TYPE_MINIMUM (gid_t
),
809 (uintmax_t) TYPE_MAXIMUM (gid_t
));
813 major_from_header (const char *p
, size_t s
)
815 return from_header (p
, s
, "major_t",
816 - (uintmax_t) TYPE_MINIMUM (major_t
),
817 (uintmax_t) TYPE_MAXIMUM (major_t
));
821 minor_from_header (const char *p
, size_t s
)
823 return from_header (p
, s
, "minor_t",
824 - (uintmax_t) TYPE_MINIMUM (minor_t
),
825 (uintmax_t) TYPE_MAXIMUM (minor_t
));
829 mode_from_header (const char *p
, size_t s
)
831 /* Do not complain about unrecognized mode bits. */
832 unsigned u
= from_header (p
, s
, "mode_t",
833 - (uintmax_t) TYPE_MINIMUM (mode_t
),
834 TYPE_MAXIMUM (uintmax_t));
835 return ((u
& TSUID
? S_ISUID
: 0)
836 | (u
& TSGID
? S_ISGID
: 0)
837 | (u
& TSVTX
? S_ISVTX
: 0)
838 | (u
& TUREAD
? S_IRUSR
: 0)
839 | (u
& TUWRITE
? S_IWUSR
: 0)
840 | (u
& TUEXEC
? S_IXUSR
: 0)
841 | (u
& TGREAD
? S_IRGRP
: 0)
842 | (u
& TGWRITE
? S_IWGRP
: 0)
843 | (u
& TGEXEC
? S_IXGRP
: 0)
844 | (u
& TOREAD
? S_IROTH
: 0)
845 | (u
& TOWRITE
? S_IWOTH
: 0)
846 | (u
& TOEXEC
? S_IXOTH
: 0));
850 off_from_header (const char *p
, size_t s
)
852 /* Negative offsets are not allowed in tar files, so invoke
853 from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
854 return from_header (p
, s
, "off_t", (uintmax_t) 0,
855 (uintmax_t) TYPE_MAXIMUM (off_t
));
859 size_from_header (const char *p
, size_t s
)
861 return from_header (p
, s
, "size_t", (uintmax_t) 0,
862 (uintmax_t) TYPE_MAXIMUM (size_t));
866 time_from_header (const char *p
, size_t s
)
868 return from_header (p
, s
, "time_t",
869 - (uintmax_t) TYPE_MINIMUM (time_t),
870 (uintmax_t) TYPE_MAXIMUM (time_t));
874 uid_from_header (const char *p
, size_t s
)
876 return from_header (p
, s
, "uid_t",
877 - (uintmax_t) TYPE_MINIMUM (uid_t
),
878 (uintmax_t) TYPE_MAXIMUM (uid_t
));
882 uintmax_from_header (const char *p
, size_t s
)
884 return from_header (p
, s
, "uintmax_t", (uintmax_t) 0,
885 TYPE_MAXIMUM (uintmax_t));
889 /* Format O as a null-terminated decimal string into BUF _backwards_;
890 return pointer to start of result. */
892 stringify_uintmax_t_backwards (uintmax_t o
, char *buf
)
896 *--buf
= '0' + (int) (o
% 10);
897 while ((o
/= 10) != 0);
901 /* Return a printable representation of T. The result points to
902 static storage that can be reused in the next call to this
903 function, to ctime, or to asctime. */
907 static char buffer
[max (UINTMAX_STRSIZE_BOUND
+ 1,
908 INT_STRLEN_BOUND (int) + 16)];
915 char const *time_stamp
= p
+ 4;
916 for (p
+= 16; p
[3] != '\n'; p
++)
922 /* Use ISO 8610 format. See:
923 http://www.cl.cam.ac.uk/~mgk25/iso-time.html */
924 struct tm
*tm
= utc_option
? gmtime (&t
) : localtime (&t
);
927 sprintf (buffer
, "%04ld-%02d-%02d %02d:%02d:%02d",
928 tm
->tm_year
+ 1900L, tm
->tm_mon
+ 1, tm
->tm_mday
,
929 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
934 /* The time stamp cannot be broken down, most likely because it
935 is out of range. Convert it as an integer,
936 right-adjusted in a field with the same width as the usual
937 19-byte 4-year ISO time format. */
938 p
= stringify_uintmax_t_backwards (t
< 0 ? - (uintmax_t) t
: (uintmax_t) t
,
939 buffer
+ sizeof buffer
);
942 while (buffer
+ sizeof buffer
- 19 - 1 < p
)
947 /* Actually print it.
949 Plain and fancy file header block logging. Non-verbose just prints
950 the name, e.g. for "tar t" or "tar x". This should just contain
951 file names, so it can be fed back into tar with xargs or the "-T"
952 option. The verbose option can give a bunch of info, one line per
953 file. I doubt anybody tries to parse its format, or if they do,
954 they shouldn't. Unix tar is pretty random here anyway. */
957 /* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
958 HEAD_STANDARD, which must be set up in advance. Not very clean.. */
960 /* UGSWIDTH starts with 18, so with user and group names <= 8 chars, the
961 columns never shift during the listing. */
963 static int ugswidth
= UGSWIDTH
; /* maximum width encountered so far */
965 /* DATEWIDTH is the number of columns taken by the date and time fields. */
967 # define DATEWIDTH 19
969 # define DATEWIDTH 18
973 print_header (struct tar_stat_info
*st
, off_t block_ordinal
)
976 char const *time_stamp
;
977 char *temp_name
= st
->orig_file_name
? st
->orig_file_name
: st
->file_name
;
979 /* These hold formatted ints. */
980 char uform
[UINTMAX_STRSIZE_BOUND
], gform
[UINTMAX_STRSIZE_BOUND
];
982 char size
[2 * UINTMAX_STRSIZE_BOUND
];
983 /* holds formatted size or major,minor */
984 char uintbuf
[UINTMAX_STRSIZE_BOUND
];
987 if (block_number_option
)
989 char buf
[UINTMAX_STRSIZE_BOUND
];
990 if (block_ordinal
< 0)
991 block_ordinal
= current_block_ordinal ();
992 block_ordinal
-= recent_long_name_blocks
;
993 block_ordinal
-= recent_long_link_blocks
;
994 fprintf (stdlis
, _("block %s: "),
995 STRINGIFY_BIGINT (block_ordinal
, buf
));
998 if (verbose_option
<= 1)
1000 /* Just the fax, mam. */
1001 fprintf (stdlis
, "%s\n", quotearg (temp_name
));
1005 /* File type and modes. */
1008 switch (current_header
->header
.typeflag
)
1010 case GNUTYPE_VOLHDR
:
1014 case GNUTYPE_MULTIVOL
:
1022 case GNUTYPE_LONGNAME
:
1023 case GNUTYPE_LONGLINK
:
1025 ERROR ((0, 0, _("Visible longname error")));
1028 case GNUTYPE_SPARSE
:
1032 if (temp_name
[strlen (temp_name
) - 1] == '/')
1038 case GNUTYPE_DUMPDIR
:
1061 decode_mode (st
->stat
.st_mode
, modes
+ 1);
1065 time_stamp
= tartime (st
->stat
.st_mtime
);
1067 /* User and group names. */
1069 if (st
->uname
&& current_format
!= V7_FORMAT
1070 && !numeric_owner_option
)
1074 /* Try parsing it as an unsigned integer first, and as a
1075 uid_t if that fails. This method can list positive user
1076 ids that are too large to fit in a uid_t. */
1077 uintmax_t u
= from_header (current_header
->header
.uid
,
1078 sizeof current_header
->header
.uid
, 0,
1080 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1082 user
= STRINGIFY_BIGINT (u
, uform
);
1085 sprintf (uform
, "%ld",
1086 (long) UID_FROM_HEADER (current_header
->header
.uid
));
1091 if (st
->gname
&& current_format
!= V7_FORMAT
1092 && !numeric_owner_option
)
1096 /* Try parsing it as an unsigned integer first, and as a
1097 gid_t if that fails. This method can list positive group
1098 ids that are too large to fit in a gid_t. */
1099 uintmax_t g
= from_header (current_header
->header
.gid
,
1100 sizeof current_header
->header
.gid
, 0,
1102 (uintmax_t) TYPE_MAXIMUM (uintmax_t));
1104 group
= STRINGIFY_BIGINT (g
, gform
);
1107 sprintf (gform
, "%ld",
1108 (long) GID_FROM_HEADER (current_header
->header
.gid
));
1113 /* Format the file size or major/minor device numbers. */
1115 switch (current_header
->header
.typeflag
)
1120 STRINGIFY_BIGINT (major (st
->stat
.st_rdev
), uintbuf
));
1123 STRINGIFY_BIGINT (minor (st
->stat
.st_rdev
), uintbuf
));
1127 /* st->stat.st_size keeps stored file size */
1128 strcpy (size
, STRINGIFY_BIGINT (st
->stat
.st_size
, uintbuf
));
1132 /* Figure out padding and print the whole line. */
1134 pad
= strlen (user
) + strlen (group
) + strlen (size
) + 1;
1138 fprintf (stdlis
, "%s %s/%s %*s%s %s",
1139 modes
, user
, group
, ugswidth
- pad
, "", size
, time_stamp
);
1141 fprintf (stdlis
, " %s", quotearg (temp_name
));
1143 switch (current_header
->header
.typeflag
)
1146 fprintf (stdlis
, " -> %s\n", quotearg (st
->link_name
));
1150 fprintf (stdlis
, _(" link to %s\n"), quotearg (st
->link_name
));
1155 char type_string
[2];
1156 type_string
[0] = current_header
->header
.typeflag
;
1157 type_string
[1] = '\0';
1158 fprintf (stdlis
, _(" unknown file type %s\n"),
1159 quote (type_string
));
1165 case GNUTYPE_SPARSE
:
1171 case GNUTYPE_DUMPDIR
:
1172 putc ('\n', stdlis
);
1175 case GNUTYPE_LONGLINK
:
1176 fprintf (stdlis
, _("--Long Link--\n"));
1179 case GNUTYPE_LONGNAME
:
1180 fprintf (stdlis
, _("--Long Name--\n"));
1183 case GNUTYPE_VOLHDR
:
1184 fprintf (stdlis
, _("--Volume Header--\n"));
1187 case GNUTYPE_MULTIVOL
:
1190 (UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
),
1192 fprintf (stdlis
, _("--Continued at byte %s--\n"), size
);
1196 fprintf (stdlis
, _("--Mangled file names--\n"));
1203 /* Print a similar line when we make a directory automatically. */
1205 print_for_mkdir (char *dirname
, int length
, mode_t mode
)
1209 if (verbose_option
> 1)
1211 /* File type and modes. */
1214 decode_mode (mode
, modes
+ 1);
1216 if (block_number_option
)
1218 char buf
[UINTMAX_STRSIZE_BOUND
];
1219 fprintf (stdlis
, _("block %s: "),
1220 STRINGIFY_BIGINT (current_block_ordinal (), buf
));
1223 fprintf (stdlis
, "%s %*s %.*s\n", modes
, ugswidth
+ DATEWIDTH
,
1224 _("Creating directory:"), length
, quotearg (dirname
));
1228 /* Skip over SIZE bytes of data in blocks in the archive. */
1230 skip_file (off_t size
)
1234 if (multi_volume_option
)
1236 save_totsize
= size
;
1237 save_sizeleft
= size
;
1242 x
= find_next_block ();
1244 FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
1246 set_next_block_after (x
);
1248 if (multi_volume_option
)
1249 save_sizeleft
-= BLOCKSIZE
;
1253 /* Skip the current member in the archive. */
1257 char save_typeflag
= current_header
->header
.typeflag
;
1258 set_next_block_after (current_header
);
1260 assign_string (&save_name
, current_stat_info
.file_name
);
1262 if (sparse_member_p (¤t_stat_info
))
1263 sparse_skip_file (¤t_stat_info
);
1264 else if (save_typeflag
!= DIRTYPE
)
1265 skip_file (current_stat_info
.stat
.st_size
);