/* List a tar archive, with support routines for reading a tar archive.
Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,
- 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
+ 2001, 2003, 2004, 2005, 2006, 2007, 2010 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
+ Free Software Foundation; either version 3, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but
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. */
-
-/* Define to non-zero for forcing old ctime format instead of ISO format. */
-#undef USE_OLD_CTIME
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
#include <system.h>
+#include <inttostr.h>
#include <quotearg.h>
#include "common.h"
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 */
+union block *recent_global_header; /* Recent global header block */
static uintmax_t from_header (const char *, size_t, const char *,
uintmax_t, uintmax_t, bool, bool);
{
enum read_header status = HEADER_STILL_UNREAD;
enum read_header prev_status;
+ struct timespec mtime;
base64_init ();
name_gather ();
{
prev_status = status;
tar_stat_destroy (¤t_stat_info);
- xheader_destroy (&extended_header);
- status = read_header (false);
+ status = read_header (¤t_header, ¤t_stat_info,
+ read_header_auto);
switch (status)
{
case HEADER_STILL_UNREAD:
/* Valid header. We should decode next field (mode) first.
Ensure incoming names are null terminated. */
-
+ 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_info.stat.st_mtime
+ && ((mtime.tv_sec
= TIME_FROM_HEADER (current_header->header.mtime)),
-#ifdef ST_MTIM_NSEC
/* FIXME: Grab fractional time stamps from
extended header. */
- current_stat_info.stat.st_mtim.ST_MTIM_NSEC = 0,
-#endif
- OLDER_STAT_TIME (current_stat_info.stat, m)))
+ 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:
quotearg_colon (current_stat_info.file_name)));
/* Fall through. */
default:
- decode_header (current_header,
- ¤t_stat_info, ¤t_format, 0);
skip_member ();
continue;
}
{
char buf[UINTMAX_STRSIZE_BOUND];
- status = read_header (false);
+ status = read_header (¤t_header, ¤t_stat_info,
+ read_header_auto);
if (status == HEADER_ZERO_BLOCK)
break;
- WARN ((0, 0, _("A lone zero block at %s"),
- STRINGIFY_BIGINT (current_block_ordinal (), buf)));
+ WARNOPT (WARN_ALONE_ZERO_BLOCK,
+ (0, 0, _("A lone zero block at %s"),
+ STRINGIFY_BIGINT (current_block_ordinal (), buf)));
break;
}
status = prev_status;
void
list_archive (void)
{
- /* Print the header block. */
+ off_t block_ordinal = current_block_ordinal ();
- decode_header (current_header, ¤t_stat_info, ¤t_format, 0);
+ /* Print the header block. */
if (verbose_option)
- print_header (¤t_stat_info, -1);
+ 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)
+ if (verbose_option > 2)
{
- assign_string (&save_name, current_stat_info.file_name);
- save_totsize = current_stat_info.stat.st_size;
- }
- for (size = current_stat_info.stat.st_size; size > 0; size -= written)
- {
- 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_stat_info.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_stat_info.file_name);
-
skip_member ();
-
- if (multi_volume_option)
- assign_string (&save_name, 0);
}
/* Check header checksum */
}
/* 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_info.stat.st_size.
+ address in *RETURN_BLOCK, and if it is good, the file's size
+ and names (file name, link name) in *INFO.
- Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a
- block full of zeros (EOF marker).
+ Return one of enum read_header describing the status of the
+ operation.
- If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the
- GNU long name and link headers into later headers.
+ The MODE parameter instructs read_header what to do with special
+ header blocks, i.e.: extended POSIX, GNU long name or long link,
+ etc.:
- You must always set_next_block_after(current_header) to skip past
+ 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 (bool raw_extended_headers)
+read_header (union block **return_block, struct tar_stat_info *info,
+ enum read_header_mode mode)
{
union block *header;
union block *header_copy;
size_t size, written;
union block *next_long_name = 0;
union block *next_long_link = 0;
- size_t next_long_name_blocks;
- size_t next_long_link_blocks;
+ 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;
/* Good block. Decode file size and return. */
if (header->header.typeflag == LNKTYPE)
- current_stat_info.stat.st_size = 0; /* links 0 size on tape */
+ info->stat.st_size = 0; /* links 0 size on tape */
else
- current_stat_info.stat.st_size = OFF_FROM_HEADER (header->header.size);
+ info->stat.st_size = OFF_FROM_HEADER (header->header.size);
if (header->header.typeflag == GNUTYPE_LONGNAME
|| header->header.typeflag == GNUTYPE_LONGLINK
|| header->header.typeflag == XHDTYPE
- || header->header.typeflag == XGLTYPE)
+ || header->header.typeflag == XGLTYPE
+ || header->header.typeflag == SOLARIS_XHDTYPE)
{
- if (raw_extended_headers)
+ 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 = current_stat_info.stat.st_size;
+ size_t name_size = info->stat.st_size;
size_t n = name_size % BLOCKSIZE;
size = name_size + BLOCKSIZE;
if (n)
size += BLOCKSIZE - n;
- if (name_size != current_stat_info.stat.st_size
- || size < name_size)
+ if (name_size != info->stat.st_size || size < name_size)
xalloc_die ();
header_copy = xmalloc (size + 1);
*bp = '\0';
}
- else if (header->header.typeflag == XHDTYPE)
- xheader_read (header, OFF_FROM_HEADER (header->header.size));
+ 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)
{
- xheader_read (header, OFF_FROM_HEADER (header->header.size));
- xheader_decode_global ();
+ 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];
if (recent_long_name)
recent_long_name = 0;
recent_long_name_blocks = 0;
}
- assign_string (¤t_stat_info.orig_file_name, name);
- assign_string (¤t_stat_info.file_name, name);
- current_stat_info.had_trailing_slash = strip_trailing_slashes (current_stat_info.file_name);
+ assign_string (&info->orig_file_name, name);
+ assign_string (&info->file_name, name);
+ info->had_trailing_slash = strip_trailing_slashes (info->file_name);
if (recent_long_link)
free (recent_long_link);
recent_long_link = 0;
recent_long_link_blocks = 0;
}
- assign_string (¤t_stat_info.link_name, name);
+ assign_string (&info->link_name, name);
return HEADER_SUCCESS;
}
}
}
+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;
+}
+
+bool
+transform_member_name (char **pinput, int type)
+{
+ return transform_name_fp (pinput, type, decode_xform, &type);
+}
+
#define ISOCTAL(c) ((c)>='0'&&(c)<='7')
/* Decode things from a file HEADER block into STAT_INFO, also setting
enum archive_format *format_pointer, int do_user_group)
{
enum archive_format format;
+ unsigned hbits; /* high bits of the file mode. */
+ mode_t mode = MODE_FROM_HEADER (header->header.mode, &hbits);
if (strcmp (header->header.magic, TMAGIC) == 0)
{
&& ISOCTAL (header->star_header.ctime[0])
&& header->star_header.ctime[11] == ' ')
format = STAR_FORMAT;
- else if (extended_header.size)
+ else if (stat_info->xhdr.size)
format = POSIX_FORMAT;
else
format = USTAR_FORMAT;
}
else if (strcmp (header->header.magic, OLDGNU_MAGIC) == 0)
- format = OLDGNU_FORMAT;
+ format = hbits ? OLDGNU_FORMAT : GNU_FORMAT;
else
format = V7_FORMAT;
*format_pointer = format;
- stat_info->stat.st_mode = MODE_FROM_HEADER (header->header.mode);
- stat_info->stat.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);
- stat_info->devmajor = MAJOR_FROM_HEADER (header->header.devmajor);
- stat_info->devminor = MINOR_FROM_HEADER (header->header.devminor);
-
- stat_info->stat.st_atime = start_time;
- stat_info->stat.st_ctime = start_time;
if (format == OLDGNU_FORMAT && incremental_option)
{
- stat_info->stat.st_atime = TIME_FROM_HEADER (header->oldgnu_header.atime);
- stat_info->stat.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)
{
}
else
{
-
- if (format == STAR_FORMAT)
- {
- stat_info->stat.st_atime = TIME_FROM_HEADER (header->star_header.atime);
- stat_info->stat.st_ctime = TIME_FROM_HEADER (header->star_header.ctime);
- }
-
if (do_user_group)
{
/* FIXME: Decide if this should somewhat depend on -p. */
{
case BLKTYPE:
case CHRTYPE:
- stat_info->stat.st_rdev = makedev (stat_info->devmajor,
- stat_info->devminor);
+ stat_info->stat.st_rdev =
+ makedev (MAJOR_FROM_HEADER (header->header.devmajor),
+ MINOR_FROM_HEADER (header->header.devminor));
break;
default:
stat_info->is_sparse = true;
}
else
- stat_info->is_sparse = false;
+ {
+ 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;
+ }
+
+ transform_member_name (&stat_info->file_name, XFORM_REGFILE);
+ switch (header->header.typeflag)
+ {
+ case SYMTYPE:
+ transform_member_name (&stat_info->link_name, XFORM_SYMLINK);
+ break;
+
+ case LNKTYPE:
+ transform_member_name (&stat_info->link_name, XFORM_LINK);
+ }
}
/* Convert buffer at WHERE0 of size DIGS from external format to
{
if (type && !silent)
ERROR ((0, 0,
- /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */
+ /* TRANSLATORS: %s is type of the value (gid_t, uid_t,
+ etc.) */
_("Blanks in header where numeric %s value expected"),
type));
return -1;
(uintmax_t) TYPE_MAXIMUM (minor_t), false, false);
}
+/* Convert P to the file mode, as understood by tar.
+ Store unrecognized mode bits (from 10th up) in HBITS. */
mode_t
-mode_from_header (const char *p, size_t s)
+mode_from_header (const char *p, size_t s, unsigned *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), false, false);
- 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));
+ 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 = mode ^ u;
+ return mode;
}
off_t
}
-/* 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 = utc_option ? gmtime (&t) : localtime (&t);
+
+ tm = utc_option ? gmtime (&s) : localtime (&s);
if (tm)
{
- 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);
+ 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 (struct tar_stat_info *st, off_t block_ordinal)
+static void
+simple_print_header (struct tar_stat_info *st, union block *blk,
+ off_t block_ordinal)
{
char modes[11];
char const *time_stamp;
- char *temp_name = st->orig_file_name ? st->orig_file_name : st->file_name;
+ int time_stamp_len;
+ char *temp_name;
/* These hold formatted ints. */
char uform[UINTMAX_STRSIZE_BOUND], gform[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)
{
/* 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:
modes[0] = 'L';
break;
}
- decode_mode (st->stat.st_mode, modes + 1);
+ pax_decode_mode (st->stat.st_mode, modes + 1);
/* Time stamp. */
- time_stamp = tartime (st->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 (st->uname && current_format != V7_FORMAT
+ if (st->uname
+ && st->uname[0]
+ && current_format != V7_FORMAT
&& !numeric_owner_option)
user = st->uname;
else
/* 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 (current_header->header.uid,
- sizeof current_header->header.uid, 0,
+ uintmax_t u = from_header (blk->header.uid,
+ sizeof blk->header.uid, 0,
(uintmax_t) 0,
(uintmax_t) TYPE_MAXIMUM (uintmax_t),
false, false);
else
{
sprintf (uform, "%ld",
- (long) UID_FROM_HEADER (current_header->header.uid));
+ (long) UID_FROM_HEADER (blk->header.uid));
user = uform;
}
}
- if (st->gname && current_format != V7_FORMAT
+ if (st->gname
+ && st->gname[0]
+ && current_format != V7_FORMAT
&& !numeric_owner_option)
group = st->gname;
else
/* 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 (current_header->header.gid,
- sizeof current_header->header.gid, 0,
+ uintmax_t g = from_header (blk->header.gid,
+ sizeof blk->header.gid, 0,
(uintmax_t) 0,
(uintmax_t) TYPE_MAXIMUM (uintmax_t),
false, false);
else
{
sprintf (gform, "%ld",
- (long) GID_FROM_HEADER (current_header->header.gid));
+ (long) GID_FROM_HEADER (blk->header.gid));
group = gform;
}
}
/* Format the file size or major/minor device numbers. */
- switch (current_header->header.typeflag)
+ switch (blk->header.typeflag)
{
case CHRTYPE:
case BLKTYPE:
/* 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 (temp_name));
- switch (current_header->header.typeflag)
+ switch (blk->header.typeflag)
{
case SYMTYPE:
fprintf (stdlis, " -> %s\n", quotearg (st->link_name));
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));
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);
}
+
+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 *dirname, int length, mode_t mode)
/* 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,
+ fprintf (stdlis, "%s %*s %.*s\n", modes, ugswidth + 1 + datewidth,
_("Creating directory:"), length, quotearg (dirname));
}
}
{
union block *x;
- if (multi_volume_option)
- {
- save_totsize = size;
- save_sizeleft = size;
- }
+ /* FIXME: Make sure mv_begin_read is always called before it */
if (seekable_archive)
{
off_t nblk = seek_archive (size);
if (nblk >= 0)
- {
- size -= nblk * BLOCKSIZE;
- if (multi_volume_option) /* Argh.. */
- save_sizeleft -= nblk * BLOCKSIZE;
- }
+ 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);
}
}
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);
- assign_string (&save_name, current_stat_info.file_name);
+ mv_begin_read (¤t_stat_info);
- 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);
+ 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 ()
+{
+ base64_init ();
+ name_gather ();
+
+ open_archive (ACCESS_READ);
+ if (read_header (¤t_header, ¤t_stat_info, read_header_auto)
+ == HEADER_SUCCESS)
+ {
+ 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)
+ {
+ 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);
+ }
+ }
+ }
+ close_archive ();
+ label_notfound ();
}