/* Buffer management for tar.
- Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
- 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
- Foundation, Inc.
+ Copyright 1988, 1992-1994, 1996-1997, 1999-2010, 2013-2014 Free
+ Software Foundation, Inc.
- Written by John Gilmore, on 1985-08-25.
+ This file is part of GNU tar.
- 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 3, or (at your option) any later
- version.
+ 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.
- 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.
+ 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.
- 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.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
+ 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-25. */
#include <system.h>
#include <system-ioctl.h>
static tarlong prev_written; /* bytes written on previous volumes */
static tarlong bytes_written; /* bytes written on this volume */
static void *record_buffer[2]; /* allocated memory */
-union block *record_buffer_aligned[2];
+static union block *record_buffer_aligned[2];
static int record_index;
/* FIXME: The following variables should ideally be static to this
off_t records_read; /* number of records read from this archive */
off_t records_written; /* likewise, for records written */
extern off_t records_skipped; /* number of records skipped at the start
- of the archive, defined in delete.c */
+ of the archive, defined in delete.c */
static off_t record_start_block; /* block ordinal at record_start */
/* We're reading, but we just read the last block and it's time to update.
Declared in update.c
- As least EXTERN like this one as possible. (?? --gray)
FIXME: Either eliminate it or move it to common.h.
*/
extern bool time_to_start_writing;
bool write_archive_to_stdout;
-void (*flush_write_ptr) (size_t);
-void (*flush_read_ptr) (void);
+static void (*flush_write_ptr) (size_t);
+static void (*flush_read_ptr) (void);
\f
char *volume_label;
bool write_archive_to_stdout;
-/* Used by flush_read and flush_write to store the real info about saved
- names. */
-static char *real_s_name;
-static off_t real_s_totsize;
-static off_t real_s_sizeleft;
-
\f
/* Multi-volume tracking support */
-static char *save_name; /* name of the file we are currently writing */
-static off_t save_totsize; /* total size of file we are writing, only
- valid if save_name is nonzero */
-static off_t save_sizeleft; /* where we are in the file we are writing,
- only valid if save_name is nonzero */
-\f
-static struct tar_stat_info dummy;
+/* When creating a multi-volume archive, each 'bufmap' represents
+ a member stored (perhaps partly) in the current record buffer.
+ After flushing the record to the output media, all bufmaps that
+ represent fully written members are removed from the list, then
+ the sizeleft and start numbers in the remaining bufmaps are updated.
-void
-buffer_write_global_xheader ()
+ When reading from a multi-volume archive, the list degrades to a
+ single element, which keeps information about the member currently
+ being read.
+*/
+
+struct bufmap
{
- xheader_write_global (&dummy.xhdr);
-}
+ struct bufmap *next; /* Pointer to the next map entry */
+ size_t start; /* Offset of the first data block */
+ char *file_name; /* Name of the stored file */
+ off_t sizetotal; /* Size of the stored file */
+ off_t sizeleft; /* Size left to read/write */
+};
+static struct bufmap *bufmap_head, *bufmap_tail;
+
+/* This variable, when set, inhibits updating the bufmap chain after
+ a write. This is necessary when writing extended POSIX headers. */
+static int inhibit_map;
void
-mv_begin (struct tar_stat_info *st)
+mv_begin_write (const char *file_name, off_t totsize, off_t sizeleft)
{
if (multi_volume_option)
{
- assign_string (&save_name, st->orig_file_name);
- save_totsize = save_sizeleft = st->stat.st_size;
+ struct bufmap *bp = xmalloc (sizeof bp[0]);
+ if (bufmap_tail)
+ bufmap_tail->next = bp;
+ else
+ bufmap_head = bp;
+ bufmap_tail = bp;
+
+ bp->next = NULL;
+ bp->start = current_block - record_start;
+ bp->file_name = xstrdup (file_name);
+ bp->sizetotal = totsize;
+ bp->sizeleft = sizeleft;
}
}
+static struct bufmap *
+bufmap_locate (size_t off)
+{
+ struct bufmap *map;
+
+ for (map = bufmap_head; map; map = map->next)
+ {
+ if (!map->next
+ || off < map->next->start * BLOCKSIZE)
+ break;
+ }
+ return map;
+}
+
+static void
+bufmap_free (struct bufmap *mark)
+{
+ struct bufmap *map;
+ for (map = bufmap_head; map && map != mark; )
+ {
+ struct bufmap *next = map->next;
+ free (map->file_name);
+ free (map);
+ map = next;
+ }
+ bufmap_head = map;
+ if (!bufmap_head)
+ bufmap_tail = bufmap_head;
+}
+
+static void
+bufmap_reset (struct bufmap *map, ssize_t fixup)
+{
+ bufmap_free (map);
+ if (map)
+ {
+ for (; map; map = map->next)
+ map->start += fixup;
+ }
+}
+
+\f
+static struct tar_stat_info dummy;
+
void
-mv_end ()
+buffer_write_global_xheader (void)
{
- if (multi_volume_option)
- assign_string (&save_name, 0);
+ xheader_write_global (&dummy.xhdr);
+}
+
+void
+mv_begin_read (struct tar_stat_info *st)
+{
+ mv_begin_write (st->orig_file_name, st->stat.st_size, st->stat.st_size);
}
void
-mv_total_size (off_t size)
+mv_end (void)
{
- save_totsize = size;
+ if (multi_volume_option)
+ bufmap_free (NULL);
}
void
mv_size_left (off_t size)
{
- save_sizeleft = size;
+ if (bufmap_head)
+ bufmap_head->sizeleft = size;
}
\f
\f
/* Time-related functions */
-double duration;
+static double duration;
void
-set_start_time ()
+set_start_time (void)
{
gettime (&start_time);
volume_start_time = start_time;
last_stat_time = start_time;
}
-void
-set_volume_start_time ()
+static void
+set_volume_start_time (void)
{
gettime (&volume_start_time);
last_stat_time = volume_start_time;
}
-void
-compute_duration ()
+double
+compute_duration (void)
{
struct timespec now;
gettime (&now);
duration += ((now.tv_sec - last_stat_time.tv_sec)
+ (now.tv_nsec - last_stat_time.tv_nsec) / 1e9);
gettime (&last_stat_time);
+ return duration;
}
\f
/* Compression detection */
enum compress_type {
- ct_tar, /* Plain tar file */
ct_none, /* Unknown compression type */
+ ct_tar, /* Plain tar file */
ct_compress,
ct_gzip,
ct_bzip2,
ct_xz
};
+static enum compress_type archive_compression_type = ct_none;
+
struct zip_magic
{
enum compress_type type;
size_t length;
- char *magic;
- char *program;
- char *option;
+ char const *magic;
+};
+
+struct zip_program
+{
+ enum compress_type type;
+ char const *program;
+ char const *option;
};
static struct zip_magic const magic[] = {
- { ct_tar },
- { ct_none, },
- { ct_compress, 2, "\037\235", COMPRESS_PROGRAM, "-Z" },
- { ct_gzip, 2, "\037\213", GZIP_PROGRAM, "-z" },
- { ct_bzip2, 3, "BZh", BZIP2_PROGRAM, "-j" },
- { ct_lzip, 4, "LZIP", LZIP_PROGRAM, "--lzip" },
- { ct_lzma, 6, "\xFFLZMA", LZMA_PROGRAM, "--lzma" },
- { ct_lzop, 4, "\211LZO", LZOP_PROGRAM, "--lzop" },
- { ct_xz, 6, "\0xFD7zXZ", XZ_PROGRAM, "-J" },
+ { ct_none, 0, 0 },
+ { ct_tar, 0, 0 },
+ { ct_compress, 2, "\037\235" },
+ { ct_gzip, 2, "\037\213" },
+ { ct_bzip2, 3, "BZh" },
+ { ct_lzip, 4, "LZIP" },
+ { ct_lzma, 6, "\xFFLZMA" },
+ { ct_lzop, 4, "\211LZO" },
+ { ct_xz, 6, "\xFD" "7zXZ" },
};
#define NMAGIC (sizeof(magic)/sizeof(magic[0]))
-#define compress_option(t) magic[t].option
-#define compress_program(t) magic[t].program
+static struct zip_program zip_program[] = {
+ { ct_compress, COMPRESS_PROGRAM, "-Z" },
+ { ct_compress, GZIP_PROGRAM, "-z" },
+ { ct_gzip, GZIP_PROGRAM, "-z" },
+ { ct_bzip2, BZIP2_PROGRAM, "-j" },
+ { ct_bzip2, "lbzip2", "-j" },
+ { ct_lzip, LZIP_PROGRAM, "--lzip" },
+ { ct_lzma, LZMA_PROGRAM, "--lzma" },
+ { ct_lzma, XZ_PROGRAM, "-J" },
+ { ct_lzop, LZOP_PROGRAM, "--lzop" },
+ { ct_xz, XZ_PROGRAM, "-J" },
+ { ct_none }
+};
+
+static struct zip_program const *
+find_zip_program (enum compress_type type, int *pstate)
+{
+ int i;
+
+ for (i = *pstate; zip_program[i].type != ct_none; i++)
+ {
+ if (zip_program[i].type == type)
+ {
+ *pstate = i + 1;
+ return zip_program + i;
+ }
+ }
+ *pstate = i;
+ return NULL;
+}
+
+const char *
+first_decompress_program (int *pstate)
+{
+ struct zip_program const *zp;
+
+ if (use_compress_program_option)
+ return use_compress_program_option;
+
+ if (archive_compression_type == ct_none)
+ return NULL;
+
+ *pstate = 0;
+ zp = find_zip_program (archive_compression_type, pstate);
+ return zp ? zp->program : NULL;
+}
+
+const char *
+next_decompress_program (int *pstate)
+{
+ struct zip_program const *zp;
+
+ if (use_compress_program_option)
+ return NULL;
+ zp = find_zip_program (archive_compression_type, pstate);
+ return zp ? zp->program : NULL;
+}
+
+static const char *
+compress_option (enum compress_type type)
+{
+ struct zip_program const *zp;
+ int i = 0;
+ zp = find_zip_program (type, &i);
+ return zp ? zp->option : NULL;
+}
/* Check if the file ARCHIVE is a compressed archive. */
-enum compress_type
+static enum compress_type
check_compressed_archive (bool *pshort)
{
struct zip_magic const *p;
if (!pshort)
pshort = &temp;
-
+
/* Prepare global data needed for find_next_block: */
record_end = record_start; /* set up for 1st record = # 0 */
sfr = read_full_records;
read_full_records = true; /* Suppress fatal error on reading a partial
record */
*pshort = find_next_block () == 0;
-
+
/* Restore global values */
read_full_records = sfr;
- if (tar_checksum (record_start, true) == HEADER_SUCCESS)
+ if ((strcmp (record_start->header.magic, TMAGIC) == 0 ||
+ strcmp (record_start->buffer + offsetof (struct posix_header, magic),
+ OLDGNU_MAGIC) == 0) &&
+ tar_checksum (record_start, true) == HEADER_SUCCESS)
/* Probably a valid header */
return ct_tar;
/* Guess if the archive is seekable. */
static void
-guess_seekable_archive ()
+guess_seekable_archive (void)
{
struct stat st;
seekable_archive = !!seek_option;
return;
}
-
+
if (!multi_volume_option && !use_compress_program_option
&& fstat (archive, &st) == 0)
seekable_archive = S_ISREG (st.st_mode);
/* Open an archive named archive_name_array[0]. Detect if it is
a compressed archive of known type and use corresponding decompression
program if so */
-int
-open_compressed_archive ()
+static int
+open_compressed_archive (void)
{
archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY,
MODE_RW, rsh_command_option);
if (shortfile)
ERROR ((0, 0, _("This does not look like a tar archive")));
return archive;
-
+
case ct_none:
if (shortfile)
ERROR ((0, 0, _("This does not look like a tar archive")));
- set_comression_program_by_suffix (archive_name_array[0], NULL);
+ set_compression_program_by_suffix (archive_name_array[0], NULL);
if (!use_compress_program_option)
return archive;
break;
default:
- use_compress_program_option = compress_program (type);
+ archive_compression_type = type;
break;
}
}
-
+
/* FD is not needed any more */
rmtclose (archive);
-
+
hit_eof = false; /* It might have been set by find_next_block in
check_compressed_archive */
return archive;
}
\f
-
-static void
+static int
print_stats (FILE *fp, const char *text, tarlong numbytes)
{
- char bytes[sizeof (tarlong) * CHAR_BIT];
char abbr[LONGEST_HUMAN_READABLE + 1];
char rate[LONGEST_HUMAN_READABLE + 1];
-
+ int n = 0;
+
int human_opts = human_autoscale | human_base_1024 | human_SI | human_B;
- sprintf (bytes, TARLONG_FORMAT, numbytes);
-
- fprintf (fp, "%s: %s (%s, %s/s)\n",
- text, bytes,
- human_readable (numbytes, abbr, human_opts, 1, 1),
- (0 < duration && numbytes / duration < (uintmax_t) -1
- ? human_readable (numbytes / duration, rate, human_opts, 1, 1)
- : "?"));
+ if (text && text[0])
+ n += fprintf (fp, "%s: ", gettext (text));
+ return n + fprintf (fp, TARLONG_FORMAT " (%s, %s/s)",
+ numbytes,
+ human_readable (numbytes, abbr, human_opts, 1, 1),
+ (0 < duration && numbytes / duration < (uintmax_t) -1
+ ? human_readable (numbytes / duration, rate, human_opts, 1, 1)
+ : "?"));
}
-void
-print_total_stats ()
+/* Format totals to file FP. FORMATS is an array of strings to output
+ before each data item (bytes read, written, deleted, in that order).
+ EOR is a delimiter to output after each item (used only if deleting
+ from the archive), EOL is a delimiter to add at the end of the output
+ line. */
+int
+format_total_stats (FILE *fp, const char **formats, int eor, int eol)
{
+ int n;
+
switch (subcommand_option)
{
case CREATE_SUBCOMMAND:
case CAT_SUBCOMMAND:
case UPDATE_SUBCOMMAND:
case APPEND_SUBCOMMAND:
- /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */
- print_stats (stderr, _("Total bytes written"),
- prev_written + bytes_written);
+ n = print_stats (fp, formats[TF_WRITE],
+ prev_written + bytes_written);
break;
case DELETE_SUBCOMMAND:
{
char buf[UINTMAX_STRSIZE_BOUND];
- print_stats (stderr, _("Total bytes read"),
- records_read * record_size);
- print_stats (stderr, _("Total bytes written"),
- prev_written + bytes_written);
- fprintf (stderr, _("Total bytes deleted: %s\n"),
- STRINGIFY_BIGINT ((records_read - records_skipped)
- * record_size
- - (prev_written + bytes_written), buf));
+ n = print_stats (fp, formats[TF_READ],
+ records_read * record_size);
+
+ fputc (eor, fp);
+ n++;
+
+ n += print_stats (fp, formats[TF_WRITE],
+ prev_written + bytes_written);
+
+ fputc (eor, fp);
+ n++;
+
+ if (formats[TF_DELETED] && formats[TF_DELETED][0])
+ n += fprintf (fp, "%s: ", gettext (formats[TF_DELETED]));
+ n += fprintf (fp, "%s",
+ STRINGIFY_BIGINT ((records_read - records_skipped)
+ * record_size
+ - (prev_written + bytes_written), buf));
}
break;
case EXTRACT_SUBCOMMAND:
case LIST_SUBCOMMAND:
case DIFF_SUBCOMMAND:
- print_stats (stderr, _("Total bytes read"),
- records_read * record_size);
+ n = print_stats (fp, _(formats[TF_READ]),
+ records_read * record_size);
break;
default:
abort ();
}
+ if (eol)
+ {
+ fputc (eol, fp);
+ n++;
+ }
+ return n;
+}
+
+const char *default_total_format[] = {
+ N_("Total bytes read"),
+ /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */
+ N_("Total bytes written"),
+ N_("Total bytes deleted")
+};
+
+void
+print_total_stats (void)
+{
+ format_total_stats (stderr, default_total_format, '\n', '\n');
}
/* Compute and return the block ordinal at current_block. */
}
static void
-init_buffer ()
+init_buffer (void)
{
if (! record_buffer_aligned[record_index])
record_buffer_aligned[record_index] =
record_end = record_start + blocking_factor;
}
+static void
+check_tty (enum access_mode mode)
+{
+ /* Refuse to read archive from and write it to a tty. */
+ if (strcmp (archive_name_array[0], "-") == 0
+ && isatty (mode == ACCESS_READ ? STDIN_FILENO : STDOUT_FILENO))
+ {
+ FATAL_ERROR ((0, 0,
+ mode == ACCESS_READ
+ ? _("Refusing to read archive contents from terminal "
+ "(missing -f option?)")
+ : _("Refusing to write archive contents to terminal "
+ "(missing -f option?)")));
+ }
+}
+
/* Open an archive file. The argument specifies whether we are
reading or writing, or both. */
static void
FATAL_ERROR ((0, 0, _("No archive name given")));
tar_stat_destroy (¤t_stat_info);
- save_name = 0;
- real_s_name = 0;
record_index = 0;
init_buffer ();
/* When updating the archive, we start with reading. */
access_mode = wanted_access == ACCESS_UPDATE ? ACCESS_READ : wanted_access;
+ check_tty (access_mode);
read_full_records = read_full_records_option;
enum compress_type type;
archive = STDIN_FILENO;
-
type = check_compressed_archive (&shortfile);
if (type != ct_tar && type != ct_none)
FATAL_ERROR ((0, 0,
break;
}
}
- else if (verify_option)
- archive = rmtopen (archive_name_array[0], O_RDWR | O_CREAT | O_BINARY,
- MODE_RW, rsh_command_option);
else
switch (wanted_access)
{
maybe_backup_file (archive_name_array[0], 1);
backed_up_flag = 1;
}
- archive = rmtcreat (archive_name_array[0], MODE_RW,
- rsh_command_option);
+ if (verify_option)
+ archive = rmtopen (archive_name_array[0], O_RDWR | O_CREAT | O_BINARY,
+ MODE_RW, rsh_command_option);
+ else
+ archive = rmtcreat (archive_name_array[0], MODE_RW,
+ rsh_command_option);
break;
case ACCESS_UPDATE:
}
/* Perform a write to flush the buffer. */
-ssize_t
+static ssize_t
_flush_write (void)
{
ssize_t status;
status = record_size;
else
status = sys_write_archive_buffer ();
-
+
+ if (status && multi_volume_option && !inhibit_map)
+ {
+ struct bufmap *map = bufmap_locate (status);
+ if (map)
+ {
+ size_t delta = status - map->start * BLOCKSIZE;
+ if (delta > map->sizeleft)
+ delta = map->sizeleft;
+ map->sizeleft -= delta;
+ if (map->sizeleft == 0)
+ map = map->next;
+ bufmap_reset (map, map ? (- map->start) : 0);
+ }
+ }
return status;
}
}
static bool
-archive_is_dev ()
+archive_is_dev (void)
{
struct stat st;
left = record_size - status;
if (left && left % BLOCKSIZE == 0
- && verbose_option
+ && (warning_option & WARN_RECORD_SIZE)
&& record_start_block == 0 && status != 0
&& archive_is_dev ())
{
unsigned long rsize = status / BLOCKSIZE;
WARN ((0, 0,
- ngettext ("Record size = %lu block",
- "Record size = %lu blocks",
- rsize),
- rsize));
+ ngettext ("Record size = %lu block",
+ "Record size = %lu blocks",
+ rsize),
+ rsize));
}
while (left % BLOCKSIZE != 0
if (size <= skipped)
return 0;
-
+
/* Compute number of records to skip */
nrec = (size - skipped) / record_size;
if (nrec == 0)
sys_wait_for_child (child_pid, hit_eof);
tar_stat_destroy (¤t_stat_info);
- if (save_name)
- free (save_name);
- if (real_s_name)
- free (real_s_name);
free (record_buffer[0]);
free (record_buffer[1]);
+ bufmap_free (NULL);
}
/* Called to initialize the global volume number. */
\f
static void
-increase_volume_number ()
+increase_volume_number (void)
{
global_volno++;
if (global_volno < 0)
volno++;
}
-void
+static void
change_tape_menu (FILE *read_file)
{
char *input_buffer = NULL;
size_t size = 0;
bool stop = false;
-
+
while (!stop)
{
fputc ('\007', stderr);
assign_string (&continued_file_name, NULL);
continued_file_size = continued_file_offset = 0;
current_block = record_start;
-
+
if (rmtclose (archive) != 0)
close_error (*archive_name_cursor);
return false;
}
-bool
-try_new_volume ()
+static bool
+try_new_volume (void)
{
size_t status;
union block *header;
enum access_mode acc;
-
+
switch (subcommand_option)
{
case APPEND_SUBCOMMAND:
if (!new_volume (acc))
return true;
-
+
while ((status = rmtread (archive, record_start->buffer, record_size))
== SAFE_READ_ERROR)
archive_read_error ();
ERROR ((0, 0, _("This does not look like a tar archive")));
return false;
}
-
+
xheader_decode (&dummy); /* decodes values from the global header */
tar_stat_destroy (&dummy);
-
+
/* The initial global header must be immediately followed by
an extended PAX header for the first member in this volume.
However, in some cases tar may split volumes in the middle
HEADER_FAILURE, which is ignored.
See also tests/multiv07.at */
-
+
switch (read_header (&header, &dummy, read_header_auto))
{
case HEADER_SUCCESS:
break;
}
- if (real_s_name)
+ if (bufmap_head)
{
uintmax_t s;
if (!continued_file_name
- || strcmp (continued_file_name, real_s_name))
+ || strcmp (continued_file_name, bufmap_head->file_name))
{
if ((archive_format == GNU_FORMAT || archive_format == OLDGNU_FORMAT)
- && strlen (real_s_name) >= NAME_FIELD_SIZE
- && strncmp (continued_file_name, real_s_name,
+ && strlen (bufmap_head->file_name) >= NAME_FIELD_SIZE
+ && strncmp (continued_file_name, bufmap_head->file_name,
NAME_FIELD_SIZE) == 0)
WARN ((0, 0,
_("%s is possibly continued on this volume: header contains truncated name"),
- quote (real_s_name)));
+ quote (bufmap_head->file_name)));
else
{
WARN ((0, 0, _("%s is not continued on this volume"),
- quote (real_s_name)));
+ quote (bufmap_head->file_name)));
return false;
}
}
s = continued_file_size + continued_file_offset;
- if (real_s_totsize != s || s < continued_file_offset)
+ if (bufmap_head->sizetotal != s || s < continued_file_offset)
{
char totsizebuf[UINTMAX_STRSIZE_BOUND];
char s1buf[UINTMAX_STRSIZE_BOUND];
WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
quote (continued_file_name),
- STRINGIFY_BIGINT (save_totsize, totsizebuf),
+ STRINGIFY_BIGINT (bufmap_head->sizetotal, totsizebuf),
STRINGIFY_BIGINT (continued_file_size, s1buf),
STRINGIFY_BIGINT (continued_file_offset, s2buf)));
return false;
}
- if (real_s_totsize - real_s_sizeleft != continued_file_offset)
+ if (bufmap_head->sizetotal - bufmap_head->sizeleft !=
+ continued_file_offset)
{
char totsizebuf[UINTMAX_STRSIZE_BOUND];
char s1buf[UINTMAX_STRSIZE_BOUND];
char s2buf[UINTMAX_STRSIZE_BOUND];
WARN ((0, 0, _("This volume is out of sequence (%s - %s != %s)"),
- STRINGIFY_BIGINT (real_s_totsize, totsizebuf),
- STRINGIFY_BIGINT (real_s_sizeleft, s1buf),
+ STRINGIFY_BIGINT (bufmap_head->sizetotal, totsizebuf),
+ STRINGIFY_BIGINT (bufmap_head->sizeleft, s1buf),
STRINGIFY_BIGINT (continued_file_offset, s2buf)));
-
+
return false;
}
}
if (len < 1)
return NULL;
-
+
for (p = label + len - 1; p > label && isdigit ((unsigned char) *p); p--)
;
if (p > label && p - (VOLUME_TEXT_LEN - 1) > label)
return NULL;
}
-
+
/* Check LABEL against the volume label, seen as a globbing
pattern. Return true if the pattern matches. In case of failure,
retry matching a volume sequence number before giving up in
if (!volume_label)
{
union block *label = find_next_block ();
-
+
if (!label)
FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
quote (volume_label_option)));
tar_stat_destroy (&st);
}
}
-
+
if (!volume_label)
FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
quote (volume_label_option)));
-
+
if (!check_label_pattern (volume_label))
FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
quote_n (0, volume_label),
}
static void
-add_chunk_header ()
+add_chunk_header (struct bufmap *map)
{
if (archive_format == POSIX_FORMAT)
{
off_t block_ordinal;
union block *blk;
struct tar_stat_info st;
- static size_t real_s_part_no; /* FIXME */
- real_s_part_no++;
memset (&st, 0, sizeof st);
- st.orig_file_name = st.file_name = real_s_name;
+ st.orig_file_name = st.file_name = map->file_name;
st.stat.st_mode = S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH;
st.stat.st_uid = getuid ();
st.stat.st_gid = getgid ();
st.orig_file_name = xheader_format_name (&st,
"%d/GNUFileParts.%p/%f.%n",
- real_s_part_no);
+ volno);
st.file_name = st.orig_file_name;
- st.archive_file_size = st.stat.st_size = real_s_sizeleft;
+ st.archive_file_size = st.stat.st_size = map->sizeleft;
block_ordinal = current_block_ordinal ();
blk = start_header (&st);
/* Write GNU multi-volume header */
static void
-gnu_add_multi_volume_header (void)
+gnu_add_multi_volume_header (struct bufmap *map)
{
int tmp;
union block *block = find_next_block ();
- if (strlen (real_s_name) > NAME_FIELD_SIZE)
+ if (strlen (map->file_name) > NAME_FIELD_SIZE)
WARN ((0, 0,
_("%s: file name too long to be stored in a GNU multivolume header, truncated"),
- quotearg_colon (real_s_name)));
+ quotearg_colon (map->file_name)));
memset (block, 0, BLOCKSIZE);
- /* FIXME: Michael P Urban writes: [a long name file] is being written
- when a new volume rolls around [...] Looks like the wrong value is
- being preserved in real_s_name, though. */
-
- strncpy (block->header.name, real_s_name, NAME_FIELD_SIZE);
+ strncpy (block->header.name, map->file_name, NAME_FIELD_SIZE);
block->header.typeflag = GNUTYPE_MULTIVOL;
- OFF_TO_CHARS (real_s_sizeleft, block->header.size);
- OFF_TO_CHARS (real_s_totsize - real_s_sizeleft,
+ OFF_TO_CHARS (map->sizeleft, block->header.size);
+ OFF_TO_CHARS (map->sizetotal - map->sizeleft,
block->oldgnu_header.offset);
tmp = verbose_option;
/* Add a multi volume header to the current archive. The exact header format
depends on the archive format. */
static void
-add_multi_volume_header (void)
+add_multi_volume_header (struct bufmap *map)
{
if (archive_format == POSIX_FORMAT)
{
- off_t d = real_s_totsize - real_s_sizeleft;
- xheader_store ("GNU.volume.filename", &dummy, real_s_name);
- xheader_store ("GNU.volume.size", &dummy, &real_s_sizeleft);
+ off_t d = map->sizetotal - map->sizeleft;
+ xheader_store ("GNU.volume.filename", &dummy, map->file_name);
+ xheader_store ("GNU.volume.size", &dummy, &map->sizeleft);
xheader_store ("GNU.volume.offset", &dummy, &d);
}
else
- gnu_add_multi_volume_header ();
-}
-
-/* Synchronize multi-volume globals */
-static void
-multi_volume_sync ()
-{
- if (multi_volume_option)
- {
- if (save_name)
- {
- assign_string (&real_s_name,
- safer_name_suffix (save_name, false,
- absolute_names_option));
- real_s_totsize = save_totsize;
- real_s_sizeleft = save_sizeleft;
- }
- else
- {
- assign_string (&real_s_name, 0);
- real_s_totsize = 0;
- real_s_sizeleft = 0;
- }
- }
+ gnu_add_multi_volume_header (map);
}
\f
size_t status; /* result from system call */
checkpoint_run (false);
-
+
/* Clear the count of errors. This only applies to a single call to
flush_read. */
size_t status; /* result from system call */
checkpoint_run (false);
-
+
/* Clear the count of errors. This only applies to a single call to
flush_read. */
archive_write_error (status);
}
- multi_volume_sync ();
-
for (;;)
{
status = rmtread (archive, record_start->buffer, record_size);
char *copy_ptr;
size_t copy_size;
size_t bufsize;
- tarlong wrt;
-
+ struct bufmap *map;
+
status = _flush_write ();
if (status != record_size && !multi_volume_option)
archive_write_error (status);
else
{
if (status)
- records_written++;
+ records_written++;
bytes_written += status;
}
if (status == record_size)
{
- multi_volume_sync ();
return;
}
+ map = bufmap_locate (status);
+
if (status % BLOCKSIZE)
{
ERROR ((0, 0, _("write did not end on a block boundary")));
archive_write_error (status);
}
-
+
/* In multi-volume mode. */
/* ENXIO is for the UNIX PC. */
if (status < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO)
archive_write_error (status);
- real_s_sizeleft -= status;
if (!new_volume (ACCESS_WRITE))
return;
copy_ptr = record_start->buffer + status;
copy_size = buffer_level - status;
-
+
/* Switch to the next buffer */
record_index = !record_index;
init_buffer ();
+ inhibit_map = 1;
+
if (volume_label_option)
add_volume_label ();
- if (real_s_name)
- add_multi_volume_header ();
+ if (map)
+ add_multi_volume_header (map);
write_extended (true, &dummy, find_next_block ());
tar_stat_destroy (&dummy);
-
- if (real_s_name)
- add_chunk_header ();
- wrt = bytes_written;
+
+ if (map)
+ add_chunk_header (map);
header = find_next_block ();
+ bufmap_reset (map, header - record_start);
bufsize = available_space_after (header);
+ inhibit_map = 0;
while (bufsize < copy_size)
{
memcpy (header->buffer, copy_ptr, bufsize);
memcpy (header->buffer, copy_ptr, copy_size);
memset (header->buffer + copy_size, 0, bufsize - copy_size);
set_next_block_after (header + (copy_size - 1) / BLOCKSIZE);
- if (multi_volume_option && wrt < bytes_written)
- {
- /* The value of bytes_written has changed while moving data;
- that means that flush_archive was executed at least once in
- between, and, as a consequence, copy_size bytes were not written
- to disk. We need to update sizeleft variables to compensate for
- that. */
- save_sizeleft += copy_size;
- multi_volume_sync ();
- }
find_next_block ();
}
}
void
-flush_read ()
+flush_read (void)
{
flush_read_ptr ();
}
void
-flush_write ()
+flush_write (void)
{
flush_write_ptr (record_size);
}
projects / chaz / tar / blobdiff