/* List a tar archive, with support routines for reading a tar archive.
- Copyright 1988,92,93,94,96,97,98,99,2000,2001 Free Software Foundation, Inc.
- Written by John Gilmore, on 1985-08-26.
- This program is free software; you can redistribute it and/or modify it
- under the terms of the GNU General Public License as published by the
- Free Software Foundation; either version 2, or (at your option) any later
- version.
+ Copyright 1988, 1992-1994, 1996-2001, 2003-2007, 2010, 2012-2014 Free
+ Software Foundation, Inc.
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
- Public License for more details.
+ This file is part of GNU tar.
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ GNU tar is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
-/* Define to non-zero for forcing old ctime format instead of ISO format. */
-#undef USE_OLD_CTIME
+ GNU tar is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-#include "system.h"
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ Written by John Gilmore, on 1985-08-26. */
+
+#include <system.h>
+#include <inttostr.h>
#include <quotearg.h>
#include "common.h"
-#define max(a, b) ((a) < (b) ? (b) : (a))
-
union block *current_header; /* points to current archive header */
-struct stat current_stat; /* stat struct corresponding */
enum archive_format current_format; /* recognized format */
-
-static uintmax_t from_header PARAMS ((const char *, size_t, const char *,
- uintmax_t, uintmax_t));
+union block *recent_long_name; /* recent long name header and contents */
+union block *recent_long_link; /* likewise, for long link */
+size_t recent_long_name_blocks; /* number of blocks in recent_long_name */
+size_t recent_long_link_blocks; /* likewise, for long link */
+static union block *recent_global_header; /* Recent global header block */
+
+#define GID_FROM_HEADER(where) gid_from_header (where, sizeof (where))
+#define MAJOR_FROM_HEADER(where) major_from_header (where, sizeof (where))
+#define MINOR_FROM_HEADER(where) minor_from_header (where, sizeof (where))
+#define MODE_FROM_HEADER(where, hbits) \
+ mode_from_header (where, sizeof (where), hbits)
+#define TIME_FROM_HEADER(where) time_from_header (where, sizeof (where))
+#define UID_FROM_HEADER(where) uid_from_header (where, sizeof (where))
+
+static gid_t gid_from_header (const char *buf, size_t size);
+static major_t major_from_header (const char *buf, size_t size);
+static minor_t minor_from_header (const char *buf, size_t size);
+static mode_t mode_from_header (const char *buf, size_t size, bool *hbits);
+static time_t time_from_header (const char *buf, size_t size);
+static uid_t uid_from_header (const char *buf, size_t size);
+static intmax_t from_header (const char *, size_t, const char *,
+ intmax_t, uintmax_t, bool, bool);
/* Base 64 digits; see Internet RFC 2045 Table 1. */
static char const base_64_digits[64] =
base64_map[(int) base_64_digits[i]] = i;
}
+static char *
+decode_xform (char *file_name, void *data)
+{
+ int type = *(int*)data;
+
+ switch (type)
+ {
+ case XFORM_SYMLINK:
+ /* FIXME: It is not quite clear how and to which extent are the symbolic
+ links subject to filename transformation. In the absence of another
+ solution, symbolic links are exempt from component stripping and
+ name suffix normalization, but subject to filename transformation
+ proper. */
+ return file_name;
+
+ case XFORM_LINK:
+ file_name = safer_name_suffix (file_name, true, absolute_names_option);
+ break;
+
+ case XFORM_REGFILE:
+ file_name = safer_name_suffix (file_name, false, absolute_names_option);
+ break;
+ }
+
+ if (strip_name_components)
+ {
+ size_t prefix_len = stripped_prefix_len (file_name,
+ strip_name_components);
+ if (prefix_len == (size_t) -1)
+ prefix_len = strlen (file_name);
+ file_name += prefix_len;
+ }
+ return file_name;
+}
+
+static bool
+transform_member_name (char **pinput, int type)
+{
+ return transform_name_fp (pinput, type, decode_xform, &type);
+}
+
+static void
+enforce_one_top_level (char **pfile_name)
+{
+ char *file_name = *pfile_name;
+ char *p;
+
+ for (p = file_name; *p && (ISSLASH (*p) || *p == '.'); p++)
+ ;
+
+ if (!*p)
+ return;
+
+ if (strncmp (p, one_top_level_dir, strlen (one_top_level_dir)) == 0)
+ {
+ int pos = strlen (one_top_level_dir);
+ if (ISSLASH (p[pos]) || p[pos] == 0)
+ return;
+ }
+
+ *pfile_name = new_name (one_top_level_dir, file_name);
+ normalize_filename_x (*pfile_name);
+ free (file_name);
+}
+
+void
+transform_stat_info (int typeflag, struct tar_stat_info *stat_info)
+{
+ if (typeflag == GNUTYPE_VOLHDR)
+ /* Name transformations don't apply to volume headers. */
+ return;
+
+ transform_member_name (&stat_info->file_name, XFORM_REGFILE);
+ switch (typeflag)
+ {
+ case SYMTYPE:
+ transform_member_name (&stat_info->link_name, XFORM_SYMLINK);
+ break;
+
+ case LNKTYPE:
+ transform_member_name (&stat_info->link_name, XFORM_LINK);
+ }
+
+ if (one_top_level_option)
+ enforce_one_top_level (¤t_stat_info.file_name);
+}
+
/* Main loop for reading an archive. */
void
-read_and (void (*do_something) ())
+read_and (void (*do_something) (void))
{
enum read_header status = HEADER_STILL_UNREAD;
enum read_header prev_status;
+ struct timespec mtime;
base64_init ();
name_gather ();
- open_archive (ACCESS_READ);
- while (1)
+ open_archive (ACCESS_READ);
+ do
{
prev_status = status;
- status = read_header ();
+ tar_stat_destroy (¤t_stat_info);
+
+ status = read_header (¤t_header, ¤t_stat_info,
+ read_header_auto);
switch (status)
{
case HEADER_STILL_UNREAD:
+ case HEADER_SUCCESS_EXTENDED:
abort ();
case HEADER_SUCCESS:
/* Valid header. We should decode next field (mode) first.
Ensure incoming names are null terminated. */
-
- if (! name_match (current_file_name)
- || (newer_mtime_option != TYPE_MINIMUM (time_t)
+ decode_header (current_header, ¤t_stat_info,
+ ¤t_format, 1);
+ if (! name_match (current_stat_info.file_name)
+ || (NEWER_OPTION_INITIALIZED (newer_mtime_option)
/* FIXME: We get mtime now, and again later; this causes
duplicate diagnostics if header.mtime is bogus. */
- && ((current_stat.st_mtime
- = TIME_FROM_HEADER (current_header->header.mtime))
- < newer_mtime_option))
- || excluded_name (current_file_name))
+ && ((mtime.tv_sec
+ = TIME_FROM_HEADER (current_header->header.mtime)),
+ /* FIXME: Grab fractional time stamps from
+ extended header. */
+ mtime.tv_nsec = 0,
+ current_stat_info.mtime = mtime,
+ OLDER_TAR_STAT_TIME (current_stat_info, m)))
+ || excluded_name (current_stat_info.file_name))
{
switch (current_header->header.typeflag)
{
case GNUTYPE_VOLHDR:
case GNUTYPE_MULTIVOL:
- case GNUTYPE_NAMES:
break;
-
+
case DIRTYPE:
if (show_omitted_dirs_option)
WARN ((0, 0, _("%s: Omitting"),
- quotearg_colon (current_file_name)));
+ quotearg_colon (current_stat_info.file_name)));
/* Fall through. */
default:
skip_member ();
continue;
}
- }
+ }
+ transform_stat_info (current_header->header.typeflag,
+ ¤t_stat_info);
(*do_something) ();
continue;
}
set_next_block_after (current_header);
+
+ if (!ignore_zeros_option)
+ {
+ char buf[UINTMAX_STRSIZE_BOUND];
+
+ status = read_header (¤t_header, ¤t_stat_info,
+ read_header_auto);
+ if (status == HEADER_ZERO_BLOCK)
+ break;
+ WARNOPT (WARN_ALONE_ZERO_BLOCK,
+ (0, 0, _("A lone zero block at %s"),
+ STRINGIFY_BIGINT (current_block_ordinal (), buf)));
+ break;
+ }
status = prev_status;
- if (ignore_zeros_option)
- continue;
- break;
+ continue;
case HEADER_END_OF_FILE:
if (block_number_option)
case HEADER_ZERO_BLOCK:
case HEADER_SUCCESS:
+ if (block_number_option)
+ {
+ char buf[UINTMAX_STRSIZE_BOUND];
+ off_t block_ordinal = current_block_ordinal ();
+ block_ordinal -= recent_long_name_blocks;
+ block_ordinal -= recent_long_link_blocks;
+ fprintf (stdlis, _("block %s: "),
+ STRINGIFY_BIGINT (block_ordinal, buf));
+ }
ERROR ((0, 0, _("Skipping to next header")));
break;
case HEADER_FAILURE:
/* We are in the middle of a cascade of errors. */
break;
+
+ case HEADER_SUCCESS_EXTENDED:
+ abort ();
}
continue;
}
break;
}
+ while (!all_names_found (¤t_stat_info));
close_archive ();
names_notfound (); /* print names not found */
void
list_archive (void)
{
- /* Print the header block. */
+ off_t block_ordinal = current_block_ordinal ();
+ /* Print the header block. */
if (verbose_option)
- {
- if (verbose_option > 1)
- decode_header (current_header, ¤t_stat, ¤t_format, 0);
- print_header ();
- }
+ print_header (¤t_stat_info, current_header, block_ordinal);
- if (incremental_option && current_header->header.typeflag == GNUTYPE_DUMPDIR)
+ if (incremental_option)
{
- off_t size;
- size_t written, check;
- union block *data_block;
-
- set_next_block_after (current_header);
- if (multi_volume_option)
- {
- assign_string (&save_name, current_file_name);
- save_totsize = current_stat.st_size;
- }
- for (size = current_stat.st_size; size > 0; size -= written)
+ if (verbose_option > 2)
{
- if (multi_volume_option)
- save_sizeleft = size;
- data_block = find_next_block ();
- if (!data_block)
- {
- ERROR ((0, 0, _("Unexpected EOF in archive")));
- break; /* FIXME: What happens, then? */
- }
- written = available_space_after (data_block);
- if (written > size)
- written = size;
- errno = 0;
- check = fwrite (data_block->buffer, sizeof (char), written, stdlis);
- set_next_block_after ((union block *)
- (data_block->buffer + written - 1));
- if (check != written)
- {
- write_error_details (current_file_name, check, written);
- skip_file (size - written);
- break;
- }
+ if (is_dumpdir (¤t_stat_info))
+ list_dumpdir (current_stat_info.dumpdir,
+ dumpdir_size (current_stat_info.dumpdir));
}
- if (multi_volume_option)
- assign_string (&save_name, 0);
- fputc ('\n', stdlis);
- fflush (stdlis);
- return;
-
}
- if (multi_volume_option)
- assign_string (&save_name, current_file_name);
-
skip_member ();
-
- if (multi_volume_option)
- assign_string (&save_name, 0);
}
-/* Read a block that's supposed to be a header block. Return its
- address in "current_header", and if it is good, the file's size in
- current_stat.st_size.
-
- Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
- block full of zeros (EOF marker).
-
- You must always set_next_block_after(current_header) to skip past
- the header which this routine reads. */
-
+/* Check header checksum */
/* The standard BSD tar sources create the checksum by adding up the
bytes in the header as type char. I think the type char was unsigned
on the PDP-11, but it's signed on the Next and Sun. It looks like the
sources to BSD tar were never changed to compute the checksum
correctly, so both the Sun and Next add the bytes of the header as
signed chars. This doesn't cause a problem until you get a file with
- a name containing characters with the high bit set. So read_header
+ a name containing characters with the high bit set. So tar_checksum
computes two checksums -- signed and unsigned. */
enum read_header
-read_header (void)
+tar_checksum (union block *header, bool silent)
{
size_t i;
- int unsigned_sum; /* the POSIX one :-) */
- int signed_sum; /* the Sun one :-( */
+ int unsigned_sum = 0; /* the POSIX one :-) */
+ int signed_sum = 0; /* the Sun one :-( */
int recorded_sum;
- uintmax_t parsed_sum;
+ int parsed_sum;
char *p;
+
+ p = header->buffer;
+ for (i = sizeof *header; i-- != 0;)
+ {
+ unsigned_sum += (unsigned char) *p;
+ signed_sum += (signed char) (*p++);
+ }
+
+ if (unsigned_sum == 0)
+ return HEADER_ZERO_BLOCK;
+
+ /* Adjust checksum to count the "chksum" field as blanks. */
+
+ for (i = sizeof header->header.chksum; i-- != 0;)
+ {
+ unsigned_sum -= (unsigned char) header->header.chksum[i];
+ signed_sum -= (signed char) (header->header.chksum[i]);
+ }
+ unsigned_sum += ' ' * sizeof header->header.chksum;
+ signed_sum += ' ' * sizeof header->header.chksum;
+
+ parsed_sum = from_header (header->header.chksum,
+ sizeof header->header.chksum, 0,
+ 0, INT_MAX, true, silent);
+ if (parsed_sum < 0)
+ return HEADER_FAILURE;
+
+ recorded_sum = parsed_sum;
+
+ if (unsigned_sum != recorded_sum && signed_sum != recorded_sum)
+ return HEADER_FAILURE;
+
+ return HEADER_SUCCESS;
+}
+
+/* Read a block that's supposed to be a header block. Return its
+ address in *RETURN_BLOCK, and if it is good, the file's size
+ and names (file name, link name) in *INFO.
+
+ Return one of enum read_header describing the status of the
+ operation.
+
+ The MODE parameter instructs read_header what to do with special
+ header blocks, i.e.: extended POSIX, GNU long name or long link,
+ etc.:
+
+ read_header_auto process them automatically,
+ read_header_x_raw when a special header is read, return
+ HEADER_SUCCESS_EXTENDED without actually
+ processing the header,
+ read_header_x_global when a POSIX global header is read,
+ decode it and return HEADER_SUCCESS_EXTENDED.
+
+ You must always set_next_block_after(*return_block) to skip past
+ the header which this routine reads. */
+
+enum read_header
+read_header (union block **return_block, struct tar_stat_info *info,
+ enum read_header_mode mode)
+{
union block *header;
- char **longp;
+ union block *header_copy;
char *bp;
union block *data_block;
size_t size, written;
- static char *next_long_name, *next_long_link;
+ union block *next_long_name = 0;
+ union block *next_long_link = 0;
+ size_t next_long_name_blocks = 0;
+ size_t next_long_link_blocks = 0;
while (1)
{
+ enum read_header status;
+
header = find_next_block ();
- current_header = header;
+ *return_block = header;
if (!header)
return HEADER_END_OF_FILE;
- unsigned_sum = 0;
- signed_sum = 0;
- p = header->buffer;
- for (i = sizeof *header; i-- != 0;)
- {
- unsigned_sum += (unsigned char) *p;
- signed_sum += (signed char) (*p++);
- }
-
- if (unsigned_sum == 0)
- return HEADER_ZERO_BLOCK;
+ if ((status = tar_checksum (header, false)) != HEADER_SUCCESS)
+ return status;
- /* Adjust checksum to count the "chksum" field as blanks. */
+ /* Good block. Decode file size and return. */
- for (i = sizeof header->header.chksum; i-- != 0;)
+ if (header->header.typeflag == LNKTYPE)
+ info->stat.st_size = 0; /* links 0 size on tape */
+ else
{
- unsigned_sum -= (unsigned char) header->header.chksum[i];
- signed_sum -= (signed char) (header->header.chksum[i]);
+ info->stat.st_size = OFF_FROM_HEADER (header->header.size);
+ if (info->stat.st_size < 0)
+ return HEADER_FAILURE;
}
- unsigned_sum += ' ' * sizeof header->header.chksum;
- signed_sum += ' ' * sizeof header->header.chksum;
- parsed_sum = from_header (header->header.chksum,
- sizeof header->header.chksum, 0,
- (uintmax_t) 0,
- (uintmax_t) TYPE_MAXIMUM (int));
- if (parsed_sum == (uintmax_t) -1)
- return HEADER_FAILURE;
+ if (header->header.typeflag == GNUTYPE_LONGNAME
+ || header->header.typeflag == GNUTYPE_LONGLINK
+ || header->header.typeflag == XHDTYPE
+ || header->header.typeflag == XGLTYPE
+ || header->header.typeflag == SOLARIS_XHDTYPE)
+ {
+ if (mode == read_header_x_raw)
+ return HEADER_SUCCESS_EXTENDED;
+ else if (header->header.typeflag == GNUTYPE_LONGNAME
+ || header->header.typeflag == GNUTYPE_LONGLINK)
+ {
+ size_t name_size = info->stat.st_size;
+ size_t n = name_size % BLOCKSIZE;
+ size = name_size + BLOCKSIZE;
+ if (n)
+ size += BLOCKSIZE - n;
- recorded_sum = parsed_sum;
+ if (name_size != info->stat.st_size || size < name_size)
+ xalloc_die ();
- if (unsigned_sum != recorded_sum && signed_sum != recorded_sum)
- return HEADER_FAILURE;
+ header_copy = xmalloc (size + 1);
- /* Good block. Decode file size and return. */
+ if (header->header.typeflag == GNUTYPE_LONGNAME)
+ {
+ free (next_long_name);
+ next_long_name = header_copy;
+ next_long_name_blocks = size / BLOCKSIZE;
+ }
+ else
+ {
+ free (next_long_link);
+ next_long_link = header_copy;
+ next_long_link_blocks = size / BLOCKSIZE;
+ }
- if (header->header.typeflag == LNKTYPE)
- current_stat.st_size = 0; /* links 0 size on tape */
- else
- current_stat.st_size = OFF_FROM_HEADER (header->header.size);
+ set_next_block_after (header);
+ *header_copy = *header;
+ bp = header_copy->buffer + BLOCKSIZE;
- if (header->header.typeflag == GNUTYPE_LONGNAME
- || header->header.typeflag == GNUTYPE_LONGLINK)
- {
- longp = ((header->header.typeflag == GNUTYPE_LONGNAME)
- ? &next_long_name
- : &next_long_link);
-
- set_next_block_after (header);
- if (*longp)
- free (*longp);
- size = current_stat.st_size;
- if (size != current_stat.st_size)
- xalloc_die ();
- bp = *longp = xmalloc (size);
-
- for (; size > 0; size -= written)
- {
- data_block = find_next_block ();
- if (! data_block)
+ for (size -= BLOCKSIZE; size > 0; size -= written)
{
- ERROR ((0, 0, _("Unexpected EOF in archive")));
- break;
+ data_block = find_next_block ();
+ if (! data_block)
+ {
+ ERROR ((0, 0, _("Unexpected EOF in archive")));
+ break;
+ }
+ written = available_space_after (data_block);
+ if (written > size)
+ written = size;
+
+ memcpy (bp, data_block->buffer, written);
+ bp += written;
+ set_next_block_after ((union block *)
+ (data_block->buffer + written - 1));
}
- written = available_space_after (data_block);
- if (written > size)
- written = size;
-
- memcpy (bp, data_block->buffer, written);
- bp += written;
- set_next_block_after ((union block *)
- (data_block->buffer + written - 1));
+
+ *bp = '\0';
+ }
+ else if (header->header.typeflag == XHDTYPE
+ || header->header.typeflag == SOLARIS_XHDTYPE)
+ xheader_read (&info->xhdr, header,
+ OFF_FROM_HEADER (header->header.size));
+ else if (header->header.typeflag == XGLTYPE)
+ {
+ struct xheader xhdr;
+
+ if (!recent_global_header)
+ recent_global_header = xmalloc (sizeof *recent_global_header);
+ memcpy (recent_global_header, header,
+ sizeof *recent_global_header);
+ memset (&xhdr, 0, sizeof xhdr);
+ xheader_read (&xhdr, header,
+ OFF_FROM_HEADER (header->header.size));
+ xheader_decode_global (&xhdr);
+ xheader_destroy (&xhdr);
+ if (mode == read_header_x_global)
+ return HEADER_SUCCESS_EXTENDED;
}
/* Loop! */
else
{
char const *name;
- struct posix_header const *h = ¤t_header->header;
+ struct posix_header const *h = &header->header;
char namebuf[sizeof h->prefix + 1 + NAME_FIELD_SIZE + 1];
- name = next_long_name;
- if (! name)
+ free (recent_long_name);
+
+ if (next_long_name)
+ {
+ name = next_long_name->buffer + BLOCKSIZE;
+ recent_long_name = next_long_name;
+ recent_long_name_blocks = next_long_name_blocks;
+ }
+ else
{
/* Accept file names as specified by POSIX.1-1996
section 10.1.1. */
np[sizeof h->prefix] = '\0';
np += strlen (np);
*np++ = '/';
-
- /* Prevent later references to current_header from
- mistakenly treating this as an old GNU header.
- This assignment invalidates h->prefix. */
- current_header->oldgnu_header.isextended = 0;
}
memcpy (np, h->name, sizeof h->name);
np[sizeof h->name] = '\0';
name = namebuf;
+ recent_long_name = 0;
+ recent_long_name_blocks = 0;
}
- assign_string (¤t_file_name, name);
- if (next_long_name)
+ assign_string (&info->orig_file_name, name);
+ assign_string (&info->file_name, name);
+ info->had_trailing_slash = strip_trailing_slashes (info->file_name);
+
+ free (recent_long_link);
+
+ if (next_long_link)
{
- free (next_long_name);
- next_long_name = 0;
+ name = next_long_link->buffer + BLOCKSIZE;
+ recent_long_link = next_long_link;
+ recent_long_link_blocks = next_long_link_blocks;
}
-
- name = next_long_link;
- if (! name)
+ else
{
memcpy (namebuf, h->linkname, sizeof h->linkname);
namebuf[sizeof h->linkname] = '\0';
name = namebuf;
+ recent_long_link = 0;
+ recent_long_link_blocks = 0;
}
- assign_string (¤t_link_name, name);
- if (next_long_link)
- {
- free (next_long_link);
- next_long_link = 0;
- }
+ assign_string (&info->link_name, name);
return HEADER_SUCCESS;
}
}
}
+#define ISOCTAL(c) ((c)>='0'&&(c)<='7')
+
/* Decode things from a file HEADER block into STAT_INFO, also setting
*FORMAT_POINTER depending on the header block format. If
DO_USER_GROUP, decode the user/group information (this is useful
should decode it without uid/gid before calling a routine,
e.g. print_header, that assumes decoded data. */
void
-decode_header (union block *header, struct stat *stat_info,
+decode_header (union block *header, struct tar_stat_info *stat_info,
enum archive_format *format_pointer, int do_user_group)
{
enum archive_format format;
+ bool hbits;
+ mode_t mode = MODE_FROM_HEADER (header->header.mode, &hbits);
if (strcmp (header->header.magic, TMAGIC) == 0)
- format = POSIX_FORMAT;
- else if (strcmp (header->header.magic, OLDGNU_MAGIC) == 0)
- format = OLDGNU_FORMAT;
+ {
+ if (header->star_header.prefix[130] == 0
+ && ISOCTAL (header->star_header.atime[0])
+ && header->star_header.atime[11] == ' '
+ && ISOCTAL (header->star_header.ctime[0])
+ && header->star_header.ctime[11] == ' ')
+ format = STAR_FORMAT;
+ else if (stat_info->xhdr.size)
+ format = POSIX_FORMAT;
+ else
+ format = USTAR_FORMAT;
+ }
+ else if (strcmp (header->buffer + offsetof (struct posix_header, magic),
+ OLDGNU_MAGIC)
+ == 0)
+ format = hbits ? OLDGNU_FORMAT : GNU_FORMAT;
else
format = V7_FORMAT;
*format_pointer = format;
- stat_info->st_mode = MODE_FROM_HEADER (header->header.mode);
- stat_info->st_mtime = TIME_FROM_HEADER (header->header.mtime);
+ stat_info->stat.st_mode = mode;
+ stat_info->mtime.tv_sec = TIME_FROM_HEADER (header->header.mtime);
+ stat_info->mtime.tv_nsec = 0;
+ assign_string (&stat_info->uname,
+ header->header.uname[0] ? header->header.uname : NULL);
+ assign_string (&stat_info->gname,
+ header->header.gname[0] ? header->header.gname : NULL);
+
+ xheader_xattr_init (stat_info);
if (format == OLDGNU_FORMAT && incremental_option)
{
- stat_info->st_atime = TIME_FROM_HEADER (header->oldgnu_header.atime);
- stat_info->st_ctime = TIME_FROM_HEADER (header->oldgnu_header.ctime);
+ stat_info->atime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.atime);
+ stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->oldgnu_header.ctime);
+ stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
+ }
+ else if (format == STAR_FORMAT)
+ {
+ stat_info->atime.tv_sec = TIME_FROM_HEADER (header->star_header.atime);
+ stat_info->ctime.tv_sec = TIME_FROM_HEADER (header->star_header.ctime);
+ stat_info->atime.tv_nsec = stat_info->ctime.tv_nsec = 0;
}
+ else
+ stat_info->atime = stat_info->ctime = start_time;
if (format == V7_FORMAT)
{
- stat_info->st_uid = UID_FROM_HEADER (header->header.uid);
- stat_info->st_gid = GID_FROM_HEADER (header->header.gid);
- stat_info->st_rdev = 0;
+ stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
+ stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
+ stat_info->stat.st_rdev = 0;
}
else
{
if (numeric_owner_option
|| !*header->header.uname
- || !uname_to_uid (header->header.uname, &stat_info->st_uid))
- stat_info->st_uid = UID_FROM_HEADER (header->header.uid);
+ || !uname_to_uid (header->header.uname, &stat_info->stat.st_uid))
+ stat_info->stat.st_uid = UID_FROM_HEADER (header->header.uid);
if (numeric_owner_option
|| !*header->header.gname
- || !gname_to_gid (header->header.gname, &stat_info->st_gid))
- stat_info->st_gid = GID_FROM_HEADER (header->header.gid);
+ || !gname_to_gid (header->header.gname, &stat_info->stat.st_gid))
+ stat_info->stat.st_gid = GID_FROM_HEADER (header->header.gid);
}
+
switch (header->header.typeflag)
{
case BLKTYPE:
- stat_info->st_rdev
- = makedev (MAJOR_FROM_HEADER (header->header.devmajor),
- MINOR_FROM_HEADER (header->header.devminor));
- break;
-
case CHRTYPE:
- stat_info->st_rdev
- = makedev (MAJOR_FROM_HEADER (header->header.devmajor),
- MINOR_FROM_HEADER (header->header.devminor));
+ stat_info->stat.st_rdev =
+ makedev (MAJOR_FROM_HEADER (header->header.devmajor),
+ MINOR_FROM_HEADER (header->header.devminor));
break;
default:
- stat_info->st_rdev = 0;
+ stat_info->stat.st_rdev = 0;
}
}
+
+ stat_info->archive_file_size = stat_info->stat.st_size;
+ xheader_decode (stat_info);
+
+ if (sparse_member_p (stat_info))
+ {
+ sparse_fixup_header (stat_info);
+ stat_info->is_sparse = true;
+ }
+ else
+ {
+ stat_info->is_sparse = false;
+ if (((current_format == GNU_FORMAT
+ || current_format == OLDGNU_FORMAT)
+ && current_header->header.typeflag == GNUTYPE_DUMPDIR)
+ || stat_info->dumpdir)
+ stat_info->is_dumpdir = true;
+ }
}
+
/* Convert buffer at WHERE0 of size DIGS from external format to
- uintmax_t. The data is of type TYPE. The buffer must represent a
- value in the range -MINUS_MINVAL through MAXVAL. DIGS must be
- positive. */
-static uintmax_t
+ intmax_t. DIGS must be positive. If TYPE is nonnull, the data are
+ of type TYPE. The buffer must represent a value in the range
+ MINVAL through MAXVAL; if the mathematically correct result V would
+ be greater than INTMAX_MAX, return a negative integer V such that
+ (uintmax_t) V yields the correct result. If OCTAL_ONLY, allow only octal
+ numbers instead of the other GNU extensions. Return -1 on error,
+ diagnosing the error if TYPE is nonnull and if !SILENT. */
+#if ! (INTMAX_MAX <= UINTMAX_MAX && - (INTMAX_MIN + 1) <= UINTMAX_MAX)
+# error "from_header internally represents intmax_t as uintmax_t + sign"
+#endif
+#if ! (UINTMAX_MAX / 2 <= INTMAX_MAX)
+# error "from_header returns intmax_t to represent uintmax_t"
+#endif
+static intmax_t
from_header (char const *where0, size_t digs, char const *type,
- uintmax_t minus_minval, uintmax_t maxval)
+ intmax_t minval, uintmax_t maxval,
+ bool octal_only, bool silent)
{
uintmax_t value;
+ uintmax_t uminval = minval;
+ uintmax_t minus_minval = - uminval;
char const *where = where0;
char const *lim = where + digs;
- int negative = 0;
+ bool negative = false;
/* Accommodate buggy tar of unknown vintage, which outputs leading
NUL if the previous field overflows. */
{
if (where == lim)
{
- if (type)
+ if (type && !silent)
ERROR ((0, 0,
+ /* TRANSLATORS: %s is type of the value (gid_t, uid_t,
+ etc.) */
_("Blanks in header where numeric %s value expected"),
type));
return -1;
}
- if (!ISSPACE ((unsigned char) *where))
+ if (!isspace ((unsigned char) *where))
break;
where++;
}
if (ISODIGIT (*where))
{
char const *where1 = where;
- uintmax_t overflow = 0;
+ bool overflow = false;
for (;;)
{
value += *where++ - '0';
if (where == lim || ! ISODIGIT (*where))
break;
- overflow |= value ^ (value << LG_8 >> LG_8);
+ overflow |= value != (value << LG_8 >> LG_8);
value <<= LG_8;
}
nonzero digit is 1, we can't recover the original value
reliably; so do this only if the digit is 2 or more. This
catches the common case of 32-bit negative time stamps. */
- if ((overflow || maxval < value) && '2' <= *where1)
+ if ((overflow || maxval < value) && '2' <= *where1 && type)
{
/* Compute the negative of the input value, assuming two's
complement. */
if (where == lim || ! ISODIGIT (*where))
break;
digit = *where - '0';
- overflow |= value ^ (value << LG_8 >> LG_8);
+ overflow |= value != (value << LG_8 >> LG_8);
value <<= LG_8;
}
value++;
if (!overflow && value <= minus_minval)
{
- WARN ((0, 0,
- _("Archive octal value %.*s is out of %s range; assuming two's complement"),
- (int) (where - where1), where1, type));
- negative = 1;
+ if (!silent)
+ WARN ((0, 0,
+ /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
+ _("Archive octal value %.*s is out of %s range; assuming two's complement"),
+ (int) (where - where1), where1, type));
+ negative = true;
}
}
if (overflow)
{
- ERROR ((0, 0,
- _("Archive octal value %.*s is out of %s range"),
- (int) (where - where1), where1, type));
+ if (type && !silent)
+ ERROR ((0, 0,
+ /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
+ _("Archive octal value %.*s is out of %s range"),
+ (int) (where - where1), where1, type));
return -1;
}
}
- else if (type)
+ else if (octal_only)
{
- /* The following forms cannot appear as checksums, so we don't
- check for them if TYPE is null. */
-
- if (*where == '-' || *where == '+')
+ /* Suppress the following extensions. */
+ }
+ else if (*where == '-' || *where == '+')
+ {
+ /* Parse base-64 output produced only by tar test versions
+ 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
+ Support for this will be withdrawn in future releases. */
+ int dig;
+ if (!silent)
{
- /* Parse base-64 output produced only by tar test versions
- 1.13.6 (1999-08-11) through 1.13.11 (1999-08-23).
- Support for this will be withdrawn in future releases. */
- int dig;
- static int warned_once;
+ static bool warned_once;
if (! warned_once)
{
- warned_once = 1;
- WARN ((0, 0,
- _("Archive contains obsolescent base-64 headers")));
+ warned_once = true;
+ WARN ((0, 0, _("Archive contains obsolescent base-64 headers")));
}
- negative = *where++ == '-';
- while (where != lim
- && (dig = base64_map[(unsigned char) *where]) < 64)
+ }
+ negative = *where++ == '-';
+ while (where != lim
+ && (dig = base64_map[(unsigned char) *where]) < 64)
+ {
+ if (value << LG_64 >> LG_64 != value)
{
- if (value << LG_64 >> LG_64 != value)
- {
- char *string = alloca (digs + 1);
- memcpy (string, where0, digs);
- string[digs] = '\0';
- ERROR ((0, 0,
- _("Archive signed base-64 string %s is out of %s range"),
- quote (string), type));
- return -1;
- }
- value = (value << LG_64) | dig;
- where++;
+ char *string = alloca (digs + 1);
+ memcpy (string, where0, digs);
+ string[digs] = '\0';
+ if (type && !silent)
+ ERROR ((0, 0,
+ _("Archive signed base-64 string %s is out of %s range"),
+ quote (string), type));
+ return -1;
}
+ value = (value << LG_64) | dig;
+ where++;
}
- else if (*where == '\200' /* positive base-256 */
- || *where == '\377' /* negative base-256 */)
+ }
+ else if (*where == '\200' /* positive base-256 */
+ || *where == '\377' /* negative base-256 */)
+ {
+ /* Parse base-256 output. A nonnegative number N is
+ represented as (256**DIGS)/2 + N; a negative number -N is
+ represented as (256**DIGS) - N, i.e. as two's complement.
+ The representation guarantees that the leading bit is
+ always on, so that we don't confuse this format with the
+ others (assuming ASCII bytes of 8 bits or more). */
+ int signbit = *where & (1 << (LG_256 - 2));
+ uintmax_t topbits = (((uintmax_t) - signbit)
+ << (CHAR_BIT * sizeof (uintmax_t)
+ - LG_256 - (LG_256 - 2)));
+ value = (*where++ & ((1 << (LG_256 - 2)) - 1)) - signbit;
+ for (;;)
{
- /* Parse base-256 output. A nonnegative number N is
- represented as (256**DIGS)/2 + N; a negative number -N is
- represented as (256**DIGS) - N, i.e. as two's complement.
- The representation guarantees that the leading bit is
- always on, so that we don't confuse this format with the
- others (assuming ASCII bytes of 8 bits or more). */
- int signbit = *where & (1 << (LG_256 - 2));
- uintmax_t topbits = (((uintmax_t) - signbit)
- << (CHAR_BIT * sizeof (uintmax_t)
- - LG_256 - (LG_256 - 2)));
- value = (*where++ & ((1 << (LG_256 - 2)) - 1)) - signbit;
- for (;;)
+ value = (value << LG_256) + (unsigned char) *where++;
+ if (where == lim)
+ break;
+ if (((value << LG_256 >> LG_256) | topbits) != value)
{
- value = (value << LG_256) + (unsigned char) *where++;
- if (where == lim)
- break;
- if (((value << LG_256 >> LG_256) | topbits) != value)
- {
- ERROR ((0, 0,
- _("Archive base-256 value is out of %s range"),
- type));
- return -1;
- }
+ if (type && !silent)
+ ERROR ((0, 0,
+ _("Archive base-256 value is out of %s range"),
+ type));
+ return -1;
}
- negative = signbit;
- if (negative)
- value = -value;
}
+ negative = signbit != 0;
+ if (negative)
+ value = -value;
}
- if (where != lim && *where && !ISSPACE ((unsigned char) *where))
+ if (where != lim && *where && !isspace ((unsigned char) *where))
{
if (type)
{
while (where0 != lim && ! lim[-1])
lim--;
- quotearg_buffer (buf, sizeof buf, where0, lim - where, o);
- ERROR ((0, 0,
- _("Archive contains %.*s where numeric %s value expected"),
- (int) sizeof buf, buf, type));
+ quotearg_buffer (buf, sizeof buf, where0, lim - where0, o);
+ if (!silent)
+ ERROR ((0, 0,
+ /* TRANSLATORS: Second %s is a type name (gid_t,uid_t,etc.) */
+ _("Archive contains %.*s where numeric %s value expected"),
+ (int) sizeof buf, buf, type));
}
return -1;
}
if (value <= (negative ? minus_minval : maxval))
- return negative ? -value : value;
+ return represent_uintmax (negative ? -value : value);
- if (type)
+ if (type && !silent)
{
char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
char maxval_buf[UINTMAX_STRSIZE_BOUND];
*--value_string = '-';
if (minus_minval)
*--minval_string = '-';
+ /* TRANSLATORS: Second %s is type name (gid_t,uid_t,etc.) */
ERROR ((0, 0, _("Archive value %s is out of %s range %s..%s"),
value_string, type,
minval_string, STRINGIFY_BIGINT (maxval, maxval_buf)));
return -1;
}
-gid_t
+static gid_t
gid_from_header (const char *p, size_t s)
{
return from_header (p, s, "gid_t",
- - (uintmax_t) TYPE_MINIMUM (gid_t),
- (uintmax_t) TYPE_MAXIMUM (gid_t));
+ TYPE_MINIMUM (gid_t), TYPE_MAXIMUM (gid_t),
+ false, false);
}
-major_t
+static major_t
major_from_header (const char *p, size_t s)
{
return from_header (p, s, "major_t",
- - (uintmax_t) TYPE_MINIMUM (major_t),
- (uintmax_t) TYPE_MAXIMUM (major_t));
+ TYPE_MINIMUM (major_t), TYPE_MAXIMUM (major_t),
+ false, false);
}
-minor_t
+static minor_t
minor_from_header (const char *p, size_t s)
{
return from_header (p, s, "minor_t",
- - (uintmax_t) TYPE_MINIMUM (minor_t),
- (uintmax_t) TYPE_MAXIMUM (minor_t));
+ TYPE_MINIMUM (minor_t), TYPE_MAXIMUM (minor_t),
+ false, false);
}
-mode_t
-mode_from_header (const char *p, size_t s)
+/* Convert P to the file mode, as understood by tar.
+ Set *HBITS if there are any unrecognized bits. */
+static mode_t
+mode_from_header (const char *p, size_t s, bool *hbits)
{
- /* Do not complain about unrecognized mode bits. */
- unsigned u = from_header (p, s, "mode_t",
- - (uintmax_t) TYPE_MINIMUM (mode_t),
- TYPE_MAXIMUM (uintmax_t));
- return ((u & TSUID ? S_ISUID : 0)
- | (u & TSGID ? S_ISGID : 0)
- | (u & TSVTX ? S_ISVTX : 0)
- | (u & TUREAD ? S_IRUSR : 0)
- | (u & TUWRITE ? S_IWUSR : 0)
- | (u & TUEXEC ? S_IXUSR : 0)
- | (u & TGREAD ? S_IRGRP : 0)
- | (u & TGWRITE ? S_IWGRP : 0)
- | (u & TGEXEC ? S_IXGRP : 0)
- | (u & TOREAD ? S_IROTH : 0)
- | (u & TOWRITE ? S_IWOTH : 0)
- | (u & TOEXEC ? S_IXOTH : 0));
+ intmax_t u = from_header (p, s, "mode_t",
+ INTMAX_MIN, UINTMAX_MAX,
+ false, false);
+ mode_t mode = ((u & TSUID ? S_ISUID : 0)
+ | (u & TSGID ? S_ISGID : 0)
+ | (u & TSVTX ? S_ISVTX : 0)
+ | (u & TUREAD ? S_IRUSR : 0)
+ | (u & TUWRITE ? S_IWUSR : 0)
+ | (u & TUEXEC ? S_IXUSR : 0)
+ | (u & TGREAD ? S_IRGRP : 0)
+ | (u & TGWRITE ? S_IWGRP : 0)
+ | (u & TGEXEC ? S_IXGRP : 0)
+ | (u & TOREAD ? S_IROTH : 0)
+ | (u & TOWRITE ? S_IWOTH : 0)
+ | (u & TOEXEC ? S_IXOTH : 0));
+ *hbits = (u & ~07777) != 0;
+ return mode;
}
off_t
{
/* Negative offsets are not allowed in tar files, so invoke
from_header with minimum value 0, not TYPE_MINIMUM (off_t). */
- return from_header (p, s, "off_t", (uintmax_t) 0,
- (uintmax_t) TYPE_MAXIMUM (off_t));
+ return from_header (p, s, "off_t",
+ 0, TYPE_MAXIMUM (off_t),
+ false, false);
}
-size_t
-size_from_header (const char *p, size_t s)
-{
- return from_header (p, s, "size_t", (uintmax_t) 0,
- (uintmax_t) TYPE_MAXIMUM (size_t));
-}
-
-time_t
+static time_t
time_from_header (const char *p, size_t s)
{
return from_header (p, s, "time_t",
- - (uintmax_t) TYPE_MINIMUM (time_t),
- (uintmax_t) TYPE_MAXIMUM (time_t));
+ TYPE_MINIMUM (time_t), TYPE_MAXIMUM (time_t),
+ false, false);
}
-uid_t
+static uid_t
uid_from_header (const char *p, size_t s)
{
return from_header (p, s, "uid_t",
- - (uintmax_t) TYPE_MINIMUM (uid_t),
- (uintmax_t) TYPE_MAXIMUM (uid_t));
+ TYPE_MINIMUM (uid_t), TYPE_MAXIMUM (uid_t),
+ false, false);
}
uintmax_t
uintmax_from_header (const char *p, size_t s)
{
- return from_header (p, s, "uintmax_t", (uintmax_t) 0,
- TYPE_MAXIMUM (uintmax_t));
+ return from_header (p, s, "uintmax_t", 0, UINTMAX_MAX, false, false);
}
-/* Format O as a null-terminated decimal string into BUF _backwards_;
- return pointer to start of result. */
-char *
-stringify_uintmax_t_backwards (uintmax_t o, char *buf)
-{
- *--buf = '\0';
- do
- *--buf = '0' + (int) (o % 10);
- while ((o /= 10) != 0);
- return buf;
-}
-
/* Return a printable representation of T. The result points to
static storage that can be reused in the next call to this
- function, to ctime, or to asctime. */
+ function, to ctime, or to asctime. If FULL_TIME, then output the
+ time stamp to its full resolution; otherwise, just output it to
+ 1-minute resolution. */
char const *
-tartime (time_t t)
+tartime (struct timespec t, bool full_time)
{
+ enum { fraclen = sizeof ".FFFFFFFFF" - 1 };
static char buffer[max (UINTMAX_STRSIZE_BOUND + 1,
- INT_STRLEN_BOUND (int) + 16)];
+ INT_STRLEN_BOUND (int) + 16)
+ + fraclen];
+ struct tm *tm;
+ time_t s = t.tv_sec;
+ int ns = t.tv_nsec;
+ bool negative = s < 0;
char *p;
-#if USE_OLD_CTIME
- p = ctime (&t);
- if (p)
+ if (negative && ns != 0)
{
- char const *time_stamp = p + 4;
- for (p += 16; p[3] != '\n'; p++)
- p[0] = p[3];
- p[0] = '\0';
- return time_stamp;
+ s++;
+ ns = 1000000000 - ns;
}
-#else
- /* Use ISO 8610 format. See:
- http://www.cl.cam.ac.uk/~mgk25/iso-time.html */
- struct tm *tm = localtime (&t);
+
+ tm = utc_option ? gmtime (&s) : localtime (&s);
if (tm)
{
- sprintf (buffer, "%04d-%02d-%02d %02d:%02d:%02d",
- tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
- tm->tm_hour, tm->tm_min, tm->tm_sec);
+ if (full_time)
+ {
+ sprintf (buffer, "%04ld-%02d-%02d %02d:%02d:%02d",
+ tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
+ tm->tm_hour, tm->tm_min, tm->tm_sec);
+ code_ns_fraction (ns, buffer + strlen (buffer));
+ }
+ else
+ sprintf (buffer, "%04ld-%02d-%02d %02d:%02d",
+ tm->tm_year + 1900L, tm->tm_mon + 1, tm->tm_mday,
+ tm->tm_hour, tm->tm_min);
return buffer;
}
-#endif
/* The time stamp cannot be broken down, most likely because it
is out of range. Convert it as an integer,
right-adjusted in a field with the same width as the usual
- 19-byte 4-year ISO time format. */
- p = stringify_uintmax_t_backwards (t < 0 ? - (uintmax_t) t : (uintmax_t) t,
- buffer + sizeof buffer);
- if (t < 0)
+ 4-year ISO time format. */
+ p = umaxtostr (negative ? - (uintmax_t) s : s,
+ buffer + sizeof buffer - UINTMAX_STRSIZE_BOUND - fraclen);
+ if (negative)
*--p = '-';
- while (buffer + sizeof buffer - 19 - 1 < p)
+ while ((buffer + sizeof buffer - sizeof "YYYY-MM-DD HH:MM"
+ + (full_time ? sizeof ":SS.FFFFFFFFF" - 1 : 0))
+ < p)
*--p = ' ';
+ if (full_time)
+ code_ns_fraction (ns, buffer + sizeof buffer - 1 - fraclen);
return p;
}
they shouldn't. Unix tar is pretty random here anyway. */
-/* FIXME: Note that print_header uses the globals HEAD, HSTAT, and
- HEAD_STANDARD, which must be set up in advance. Not very clean... */
+/* Width of "user/group size", with initial value chosen
+ heuristically. This grows as needed, though this may cause some
+ stairstepping in the output. Make it too small and the output will
+ almost always look ragged. Make it too large and the output will
+ be spaced out too far. */
+static int ugswidth = 19;
-/* UGSWIDTH starts with 18, so with user and group names <= 8 chars, the
- columns never shift during the listing. */
-#define UGSWIDTH 18
-static int ugswidth = UGSWIDTH; /* maximum width encountered so far */
+/* Width of printed time stamps. It grows if longer time stamps are
+ found (typically, those with nanosecond resolution). Like
+ USGWIDTH, some stairstepping may occur. */
+static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1;
-/* DATEWIDTH is the number of columns taken by the date and time fields. */
-#if USE_OLD_CDATE
-# define DATEWIDTH 19
-#else
-# define DATEWIDTH 18
-#endif
+static bool volume_label_printed = false;
-void
-print_header (void)
+static void
+simple_print_header (struct tar_stat_info *st, union block *blk,
+ off_t block_ordinal)
{
- char modes[11];
+ char modes[12];
char const *time_stamp;
+ int time_stamp_len;
+ char *temp_name;
+
/* These hold formatted ints. */
- char uform[UINTMAX_STRSIZE_BOUND], gform[UINTMAX_STRSIZE_BOUND];
+ char uform[max (INT_BUFSIZE_BOUND (intmax_t), UINTMAX_STRSIZE_BOUND)];
+ char gform[sizeof uform];
char *user, *group;
char size[2 * UINTMAX_STRSIZE_BOUND];
/* holds formatted size or major,minor */
char uintbuf[UINTMAX_STRSIZE_BOUND];
int pad;
+ int sizelen;
+
+ if (show_transformed_names_option)
+ temp_name = st->file_name ? st->file_name : st->orig_file_name;
+ else
+ temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
if (block_number_option)
{
char buf[UINTMAX_STRSIZE_BOUND];
+ if (block_ordinal < 0)
+ block_ordinal = current_block_ordinal ();
+ block_ordinal -= recent_long_name_blocks;
+ block_ordinal -= recent_long_link_blocks;
fprintf (stdlis, _("block %s: "),
- STRINGIFY_BIGINT (current_block_ordinal (), buf));
+ STRINGIFY_BIGINT (block_ordinal, buf));
}
if (verbose_option <= 1)
{
/* Just the fax, mam. */
- fprintf (stdlis, "%s\n", quotearg (current_file_name));
+ fputs (quotearg (temp_name), stdlis);
+ if (show_transformed_names_option && st->had_trailing_slash)
+ fputc ('/', stdlis);
+ fputc ('\n', stdlis);
}
else
{
/* File type and modes. */
modes[0] = '?';
- switch (current_header->header.typeflag)
+ switch (blk->header.typeflag)
{
case GNUTYPE_VOLHDR:
+ volume_label_printed = true;
modes[0] = 'V';
break;
modes[0] = 'M';
break;
- case GNUTYPE_NAMES:
- modes[0] = 'N';
- break;
-
case GNUTYPE_LONGNAME:
case GNUTYPE_LONGLINK:
- ERROR ((0, 0, _("Visible longname error")));
+ modes[0] = 'L';
+ ERROR ((0, 0, _("Unexpected long name header")));
break;
case GNUTYPE_SPARSE:
case REGTYPE:
case AREGTYPE:
+ modes[0] = st->had_trailing_slash ? 'd' : '-';
+ break;
case LNKTYPE:
- modes[0] = '-';
- if (current_file_name[strlen (current_file_name) - 1] == '/')
- modes[0] = 'd';
+ modes[0] = 'h';
break;
case GNUTYPE_DUMPDIR:
modes[0] = 'd';
break;
}
- decode_mode (current_stat.st_mode, modes + 1);
+ pax_decode_mode (st->stat.st_mode, modes + 1);
+
+ /* extended attributes: GNU `ls -l'-like preview */
+ xattrs_print_char (st, modes + 10);
/* Time stamp. */
- time_stamp = tartime (current_stat.st_mtime);
+ time_stamp = tartime (st->mtime, full_time_option);
+ time_stamp_len = strlen (time_stamp);
+ if (datewidth < time_stamp_len)
+ datewidth = time_stamp_len;
/* User and group names. */
- if (*current_header->header.uname && current_format != V7_FORMAT
+ if (st->uname
+ && st->uname[0]
+ && current_format != V7_FORMAT
&& !numeric_owner_option)
- user = current_header->header.uname;
+ user = st->uname;
else
- user = STRINGIFY_BIGINT (UINTMAX_FROM_HEADER
- (current_header->header.uid),
- uform);
+ {
+ /* Try parsing it as an unsigned integer first, and as a
+ uid_t if that fails. This method can list positive user
+ ids that are too large to fit in a uid_t. */
+ uintmax_t u = from_header (blk->header.uid,
+ sizeof blk->header.uid, 0,
+ 0, UINTMAX_MAX,
+ false, false);
+ user = (u != -1
+ ? STRINGIFY_BIGINT (u, uform)
+ : imaxtostr (UID_FROM_HEADER (blk->header.uid), uform));
+ }
- if (*current_header->header.gname && current_format != V7_FORMAT
+ if (st->gname
+ && st->gname[0]
+ && current_format != V7_FORMAT
&& !numeric_owner_option)
- group = current_header->header.gname;
+ group = st->gname;
else
- group = STRINGIFY_BIGINT (UINTMAX_FROM_HEADER
- (current_header->header.gid),
- gform);
+ {
+ /* Try parsing it as an unsigned integer first, and as a
+ gid_t if that fails. This method can list positive group
+ ids that are too large to fit in a gid_t. */
+ uintmax_t g = from_header (blk->header.gid,
+ sizeof blk->header.gid, 0,
+ 0, UINTMAX_MAX,
+ false, false);
+ group = (g != -1
+ ? STRINGIFY_BIGINT (g, gform)
+ : imaxtostr (GID_FROM_HEADER (blk->header.gid), gform));
+ }
/* Format the file size or major/minor device numbers. */
- switch (current_header->header.typeflag)
+ switch (blk->header.typeflag)
{
case CHRTYPE:
case BLKTYPE:
strcpy (size,
- STRINGIFY_BIGINT (major (current_stat.st_rdev), uintbuf));
+ STRINGIFY_BIGINT (major (st->stat.st_rdev), uintbuf));
strcat (size, ",");
strcat (size,
- STRINGIFY_BIGINT (minor (current_stat.st_rdev), uintbuf));
- break;
- case GNUTYPE_SPARSE:
- strcpy (size,
- STRINGIFY_BIGINT
- (UINTMAX_FROM_HEADER (current_header
- ->oldgnu_header.realsize),
- uintbuf));
+ STRINGIFY_BIGINT (minor (st->stat.st_rdev), uintbuf));
break;
+
default:
- strcpy (size, STRINGIFY_BIGINT (current_stat.st_size, uintbuf));
+ /* st->stat.st_size keeps stored file size */
+ strcpy (size, STRINGIFY_BIGINT (st->stat.st_size, uintbuf));
break;
}
/* Figure out padding and print the whole line. */
- pad = strlen (user) + strlen (group) + strlen (size) + 1;
+ sizelen = strlen (size);
+ pad = strlen (user) + 1 + strlen (group) + 1 + sizelen;
if (pad > ugswidth)
ugswidth = pad;
- fprintf (stdlis, "%s %s/%s %*s%s %s",
- modes, user, group, ugswidth - pad, "", size, time_stamp);
+ fprintf (stdlis, "%s %s/%s %*s %-*s",
+ modes, user, group, ugswidth - pad + sizelen, size,
+ datewidth, time_stamp);
- fprintf (stdlis, " %s", quotearg (current_file_name));
+ fprintf (stdlis, " %s", quotearg (temp_name));
+ if (show_transformed_names_option && st->had_trailing_slash)
+ fputc ('/', stdlis);
- switch (current_header->header.typeflag)
+ switch (blk->header.typeflag)
{
case SYMTYPE:
- fprintf (stdlis, " -> %s\n", quotearg (current_link_name));
+ fprintf (stdlis, " -> %s\n", quotearg (st->link_name));
break;
case LNKTYPE:
- fprintf (stdlis, _(" link to %s\n"), quotearg (current_link_name));
+ fprintf (stdlis, _(" link to %s\n"), quotearg (st->link_name));
break;
default:
{
char type_string[2];
- type_string[0] = current_header->header.typeflag;
+ type_string[0] = blk->header.typeflag;
type_string[1] = '\0';
fprintf (stdlis, _(" unknown file type %s\n"),
quote (type_string));
putc ('\n', stdlis);
break;
+ case GNUTYPE_LONGLINK:
+ fprintf (stdlis, _("--Long Link--\n"));
+ break;
+
+ case GNUTYPE_LONGNAME:
+ fprintf (stdlis, _("--Long Name--\n"));
+ break;
+
case GNUTYPE_VOLHDR:
fprintf (stdlis, _("--Volume Header--\n"));
break;
case GNUTYPE_MULTIVOL:
strcpy (size,
STRINGIFY_BIGINT
- (UINTMAX_FROM_HEADER (current_header->oldgnu_header.offset),
+ (UINTMAX_FROM_HEADER (blk->oldgnu_header.offset),
uintbuf));
fprintf (stdlis, _("--Continued at byte %s--\n"), size);
break;
-
- case GNUTYPE_NAMES:
- fprintf (stdlis, _("--Mangled file names--\n"));
- break;
}
}
fflush (stdlis);
+ xattrs_print (st);
+}
+
+
+static void
+print_volume_label (void)
+{
+ struct tar_stat_info vstat;
+ union block vblk;
+ enum archive_format dummy;
+
+ memset (&vblk, 0, sizeof (vblk));
+ vblk.header.typeflag = GNUTYPE_VOLHDR;
+ if (recent_global_header)
+ memcpy (vblk.header.mtime, recent_global_header->header.mtime,
+ sizeof vblk.header.mtime);
+ tar_stat_init (&vstat);
+ assign_string (&vstat.file_name, ".");
+ decode_header (&vblk, &vstat, &dummy, 0);
+ assign_string (&vstat.file_name, volume_label);
+ simple_print_header (&vstat, &vblk, 0);
+ tar_stat_destroy (&vstat);
+}
+
+void
+print_header (struct tar_stat_info *st, union block *blk,
+ off_t block_ordinal)
+{
+ if (current_format == POSIX_FORMAT && !volume_label_printed && volume_label)
+ {
+ print_volume_label ();
+ volume_label_printed = true;
+ }
+
+ simple_print_header (st, blk, block_ordinal);
}
/* Print a similar line when we make a directory automatically. */
void
-print_for_mkdir (char *pathname, int length, mode_t mode)
+print_for_mkdir (char *dirname, int length, mode_t mode)
{
char modes[11];
/* File type and modes. */
modes[0] = 'd';
- decode_mode (mode, modes + 1);
+ pax_decode_mode (mode, modes + 1);
if (block_number_option)
{
STRINGIFY_BIGINT (current_block_ordinal (), buf));
}
- fprintf (stdlis, "%s %*s %.*s\n", modes, ugswidth + DATEWIDTH,
- _("Creating directory:"), length, quotearg (pathname));
+ fprintf (stdlis, "%s %*s %s\n", modes, ugswidth + 1 + datewidth,
+ _("Creating directory:"), quotearg (dirname));
}
}
{
union block *x;
- if (multi_volume_option)
+ /* FIXME: Make sure mv_begin_read is always called before it */
+
+ if (seekable_archive)
{
- save_totsize = size;
- save_sizeleft = size;
+ off_t nblk = seek_archive (size);
+ if (nblk >= 0)
+ size -= nblk * BLOCKSIZE;
+ else
+ seekable_archive = false;
}
+ mv_size_left (size);
+
while (size > 0)
{
x = find_next_block ();
set_next_block_after (x);
size -= BLOCKSIZE;
- if (multi_volume_option)
- save_sizeleft -= BLOCKSIZE;
+ mv_size_left (size);
}
}
-/* Skip the current member in the archive. */
+/* Skip the current member in the archive.
+ NOTE: Current header must be decoded before calling this function. */
void
skip_member (void)
{
- char save_typeflag = current_header->header.typeflag;
- set_next_block_after (current_header);
+ if (!current_stat_info.skipped)
+ {
+ char save_typeflag = current_header->header.typeflag;
+ set_next_block_after (current_header);
+
+ mv_begin_read (¤t_stat_info);
- if (current_header->oldgnu_header.isextended)
+ if (current_stat_info.is_sparse)
+ sparse_skip_file (¤t_stat_info);
+ else if (save_typeflag != DIRTYPE)
+ skip_file (current_stat_info.stat.st_size);
+
+ mv_end ();
+ }
+}
+
+void
+test_archive_label (void)
+{
+ base64_init ();
+ name_gather ();
+
+ open_archive (ACCESS_READ);
+ if (read_header (¤t_header, ¤t_stat_info, read_header_auto)
+ == HEADER_SUCCESS)
{
- union block *exhdr;
- do
+ decode_header (current_header,
+ ¤t_stat_info, ¤t_format, 0);
+ if (current_header->header.typeflag == GNUTYPE_VOLHDR)
+ assign_string (&volume_label, current_header->header.name);
+
+ if (volume_label)
{
- exhdr = find_next_block ();
- if (!exhdr)
- FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
- set_next_block_after (exhdr);
+ if (verbose_option)
+ print_volume_label ();
+ if (!name_match (volume_label) && multi_volume_option)
+ {
+ char *s = drop_volume_label_suffix (volume_label);
+ name_match (s);
+ free (s);
+ }
}
- while (exhdr->sparse_header.isextended);
}
-
- if (save_typeflag != DIRTYPE)
- skip_file (current_stat.st_size);
+ close_archive ();
+ label_notfound ();
}
projects / chaz / tar / blobdiff