/* Buffer management for tar.
- Copyright 1988, 92, 93, 94, 96, 97, 99, 2000 Free Software Foundation, Inc.
+
+ Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
+ 2003, 2004, 2005 Free Software Foundation, Inc.
+
Written by John Gilmore, on 1985-08-25.
This program is free software; you can redistribute it and/or modify it
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. */
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
-#include "system.h"
+#include <system.h>
#include <signal.h>
-#include <time.h>
-#ifndef time
-time_t time ();
-#endif
-
-#if MSDOS
-# include <process.h>
-#endif
-
-#if XENIX
-# include <sys/inode.h>
-#endif
#include <fnmatch.h>
#include <human.h>
#include <quotearg.h>
#include "common.h"
-#include "rmt.h"
-
-#define PREAD 0 /* read file descriptor from pipe() */
-#define PWRITE 1 /* write file descriptor from pipe() */
+#include <rmt.h>
/* Number of retries before giving up on read. */
#define READ_ERROR_MAX 10
/* Globbing pattern to append to volume label if initial match failed. */
#define VOLUME_LABEL_APPEND " Volume [1-9]*"
-\f
+
/* Variables. */
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 */
+static int record_index;
-/* FIXME: The following four variables should ideally be static to this
- module. However, this cannot be done yet, as update.c uses the first
- three a lot, and compare.c uses the fourth. The cleanup continues! */
+/* FIXME: The following variables should ideally be static to this
+ module. However, this cannot be done yet. The cleanup continues! */
union block *record_start; /* start of record of archive */
union block *record_end; /* last+1 block of archive record */
union block *current_block; /* current block of archive */
enum access_mode access_mode; /* how do we handle the archive */
-static struct stat archive_stat; /* stat block for archive file */
+off_t records_read; /* number of records read from this archive */
+off_t records_written; /* likewise, for records written */
static off_t record_start_block; /* block ordinal at record_start */
-/* Where we write list messages (not errors, not interactions) to. Stdout
- unless we're writing a pipe, in which case stderr. */
+/* Where we write list messages (not errors, not interactions) to. */
FILE *stdlis;
-static void backspace_output PARAMS ((void));
-static int new_volume PARAMS ((enum access_mode));
-static void archive_write_error PARAMS ((ssize_t)) __attribute__ ((noreturn));
-static void archive_read_error PARAMS ((void));
-
-#if !MSDOS
-/* Obnoxious test to see if dimwit is trying to dump the archive. */
-dev_t ar_dev;
-ino_t ar_ino;
-#endif
+static void backspace_output (void);
/* PID of child program, if compress_option or remote archive access. */
static pid_t child_pid;
static int read_error_count;
/* Have we hit EOF yet? */
-static int hit_eof;
+static bool hit_eof;
/* Checkpointing counter */
static int checkpoint;
-/* We're reading, but we just read the last block and its time to update. */
-/* As least EXTERN like this one as possible. FIXME! */
-extern int time_to_start_writing;
+static bool read_full_records = false;
-int file_to_switch_to = -1; /* if remote update, close archive, and use
- this descriptor to write to */
+/* 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;
+
+\f
+char *volume_label;
+char *continued_file_name;
+uintmax_t continued_file_size;
+uintmax_t continued_file_offset;
+\f
static int volno = 1; /* which volume of a multi-volume tape we're
on */
static int global_volno = 1; /* volume number to print in external
messages */
-/* The pointer save_name, which is set in function dump_file() of module
- create.c, points to the original long filename instead of the new,
- shorter mangled name that is set in start_header() of module create.c.
- The pointer save_name is only used in multi-volume mode when the file
- being processed is non-sparse; if a file is split between volumes, the
- save_name is used in generating the LF_MULTIVOL record on the second
- volume. (From Pierce Cantrell, 1991-08-13.) */
-
-char *save_name; /* name of the file we are currently writing */
-off_t save_totsize; /* total size of file we are writing, only
- valid if save_name is nonzero */
-off_t save_sizeleft; /* where we are in the file we are writing,
- only valid if save_name is nonzero */
-
-int write_archive_to_stdout;
+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 */
+
+void
+mv_begin (struct tar_stat_info *st)
+{
+ if (multi_volume_option)
+ {
+ assign_string (&save_name, st->orig_file_name);
+ save_totsize = save_sizeleft = st->stat.st_size;
+ }
+}
+
+void
+mv_end ()
+{
+ if (multi_volume_option)
+ assign_string (&save_name, 0);
+}
+
+void
+mv_total_size (off_t size)
+{
+ save_totsize = size;
+}
+
+void
+mv_size_left (off_t size)
+{
+ save_sizeleft = size;
+}
+
\f
/* Functions. */
+void
+clear_read_error_count (void)
+{
+ read_error_count = 0;
+}
+
+\f
+/* Time-related functions */
+
+double duration;
+
+void
+set_start_time ()
+{
+ gettime (&start_time);
+}
+
+void
+compute_duration ()
+{
+ struct timespec now;
+ gettime (&now);
+ duration += ((now.tv_sec - start_time.tv_sec)
+ + (now.tv_nsec - start_time.tv_nsec) / 1e9);
+ set_start_time ();
+}
+
+\f
+/* Compression detection */
+
+enum compress_type {
+ ct_none,
+ ct_compress,
+ ct_gzip,
+ ct_bzip2
+};
+
+struct zip_magic
+{
+ enum compress_type type;
+ size_t length;
+ char *magic;
+ char *program;
+ char *option;
+};
+
+static struct zip_magic const magic[] = {
+ { ct_none, },
+ { ct_compress, 2, "\037\235", "compress", "-Z" },
+ { ct_gzip, 2, "\037\213", "gzip", "-z" },
+ { ct_bzip2, 3, "BZh", "bzip2", "-j" },
+};
+
+#define NMAGIC (sizeof(magic)/sizeof(magic[0]))
+
+#define compress_option(t) magic[t].option
+#define compress_program(t) magic[t].program
+
+/* Check if the file ARCHIVE is a compressed archive. */
+enum compress_type
+check_compressed_archive ()
+{
+ struct zip_magic const *p;
+ bool sfr;
+
+ /* 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 */
+ find_next_block ();
+
+ /* Restore global values */
+ read_full_records = sfr;
+
+ if (tar_checksum (record_start, true) == HEADER_SUCCESS)
+ /* Probably a valid header */
+ return ct_none;
+
+ for (p = magic + 1; p < magic + NMAGIC; p++)
+ if (memcmp (record_start->buffer, p->magic, p->length) == 0)
+ return p->type;
+
+ return ct_none;
+}
+
+/* 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 ()
+{
+ archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY,
+ MODE_RW, rsh_command_option);
+ if (archive == -1)
+ return archive;
+
+ if (!multi_volume_option)
+ {
+ enum compress_type type = check_compressed_archive ();
+
+ if (type == ct_none)
+ return archive;
+
+ /* FD is not needed any more */
+ rmtclose (archive);
+
+ hit_eof = false; /* It might have been set by find_next_block in
+ check_compressed_archive */
+
+ /* Open compressed archive */
+ use_compress_program_option = compress_program (type);
+ child_pid = sys_child_open_for_uncompress ();
+ read_full_records = true;
+ }
+
+ records_read = 0;
+ record_end = record_start; /* set up for 1st record = # 0 */
+
+ return archive;
+}
+\f
+
void
print_total_written (void)
{
char bytes[sizeof (tarlong) * CHAR_BIT];
char abbr[LONGEST_HUMAN_READABLE + 1];
char rate[LONGEST_HUMAN_READABLE + 1];
- double seconds;
-#if HAVE_CLOCK_GETTIME
- struct timespec now;
- if (clock_gettime (CLOCK_REALTIME, &now) == 0)
- seconds = ((now.tv_sec - start_timespec.tv_sec)
- + (now.tv_nsec - start_timespec.tv_nsec) / 1e9);
- else
-#endif
- seconds = time (0) - start_time;
+ int human_opts = human_autoscale | human_base_1024 | human_SI | human_B;
sprintf (bytes, TARLONG_FORMAT, written);
/* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */
- fprintf (stderr, _("Total bytes written: %s (%sB, %sB/s)\n"), bytes,
- human_readable ((uintmax_t) written, abbr, 1, -1024),
- (0 < seconds && written / seconds < (uintmax_t) -1
- ? human_readable ((uintmax_t) (written / seconds), rate, 1, -1024)
+ fprintf (stderr, _("Total bytes written: %s (%s, %s/s)\n"), bytes,
+ human_readable (written, abbr, human_opts, 1, 1),
+ (0 < duration && written / duration < (uintmax_t) -1
+ ? human_readable (written / duration, rate, human_opts, 1, 1)
: "?"));
}
{
if (hit_eof)
{
- hit_eof = 0;
+ hit_eof = false;
current_block = record_start;
record_end = record_start + blocking_factor;
access_mode = ACCESS_WRITE;
flush_archive ();
if (current_block == record_end)
{
- hit_eof = 1;
+ hit_eof = true;
return 0;
}
}
return current_block;
}
-/* Indicate that we have used all blocks up thru BLOCK.
- FIXME: should the arg have an off-by-1? */
+/* Indicate that we have used all blocks up thru BLOCK. */
void
set_next_block_after (union block *block)
{
/* Return the number of bytes comprising the space between POINTER
through the end of the current buffer of blocks. This space is
available for filling with data, or taking data from. POINTER is
- usually (but not always) the result previous find_next_block call. */
+ usually (but not always) the result of previous find_next_block call. */
size_t
available_space_after (union block *pointer)
{
}
/* Close file having descriptor FD, and abort if close unsuccessful. */
-static void
+void
xclose (int fd)
{
if (close (fd) != 0)
close_error (_("(pipe)"));
}
-/* Duplicate file descriptor FROM into becoming INTO.
- INTO is closed first and has to be the next available slot. */
-static void
-xdup2 (int from, int into)
-{
- if (from != into)
- {
- int status = close (into);
-
- if (status != 0 && errno != EBADF)
- {
- int e = errno;
- FATAL_ERROR ((0, e, _("Cannot close")));
- }
- status = dup (from);
- if (status != into)
- {
- if (status < 0)
- {
- int e = errno;
- FATAL_ERROR ((0, e, _("Cannot dup")));
- }
- abort ();
- }
- xclose (from);
- }
-}
-
-#if MSDOS
-
-/* Set ARCHIVE for writing, then compressing an archive. */
static void
-child_open_for_compress (void)
+init_buffer ()
{
- FATAL_ERROR ((0, 0, _("Cannot use compressed or remote archives")));
+ if (!record_buffer[record_index])
+ page_aligned_alloc (&record_buffer[record_index], record_size);
+
+ record_start = record_buffer[record_index];
+ current_block = record_start;
+ record_end = record_start + blocking_factor;
}
-/* Set ARCHIVE for uncompressing, then reading an archive. */
+/* Open an archive file. The argument specifies whether we are
+ reading or writing, or both. */
static void
-child_open_for_uncompress (void)
-{
- FATAL_ERROR ((0, 0, _("Cannot use compressed or remote archives")));
-}
-
-#else /* not MSDOS */
-
-/* Return nonzero if NAME is the name of a regular file, or if the file
- does not exist (so it would be created as a regular file). */
-static int
-is_regular_file (const char *name)
-{
- struct stat stbuf;
-
- if (stat (name, &stbuf) == 0)
- return S_ISREG (stbuf.st_mode);
- else
- return errno == ENOENT;
-}
-
-static ssize_t
-write_archive_buffer (void)
+_open_archive (enum access_mode wanted_access)
{
- ssize_t status;
- ssize_t written = 0;
+ int backed_up_flag = 0;
- while (0 <= (status = rmtwrite (archive, record_start->buffer + written,
- record_size - written)))
+ if (index_file_name)
{
- written += status;
- if (written == record_size
- || _isrmt (archive) || ! S_ISFIFO (archive_stat.st_mode))
- break;
+ stdlis = fopen (index_file_name, "w");
+ if (! stdlis)
+ open_error (index_file_name);
}
+ else
+ stdlis = to_stdout_option ? stderr : stdout;
- return written ? written : status;
-}
-
-/* Set ARCHIVE for writing, then compressing an archive. */
-static void
-child_open_for_compress (void)
-{
- int parent_pipe[2];
- int child_pipe[2];
- pid_t grandchild_pid;
- int wait_status;
-
- xpipe (parent_pipe);
- child_pid = xfork ();
-
- if (child_pid > 0)
- {
- /* The parent tar is still here! Just clean up. */
+ if (record_size == 0)
+ FATAL_ERROR ((0, 0, _("Invalid value for record_size")));
- archive = parent_pipe[PWRITE];
- xclose (parent_pipe[PREAD]);
- return;
- }
+ if (archive_names == 0)
+ FATAL_ERROR ((0, 0, _("No archive name given")));
- /* The new born child tar is here! */
+ tar_stat_destroy (¤t_stat_info);
+ save_name = 0;
+ real_s_name = 0;
- program_name = _("tar (child)");
+ record_index = 0;
+ init_buffer ();
+
+ /* When updating the archive, we start with reading. */
+ access_mode = wanted_access == ACCESS_UPDATE ? ACCESS_READ : wanted_access;
- xdup2 (parent_pipe[PREAD], STDIN_FILENO);
- xclose (parent_pipe[PWRITE]);
+ read_full_records = read_full_records_option;
- /* Check if we need a grandchild tar. This happens only if either:
- a) we are writing stdout: to force reblocking;
- b) the file is to be accessed by rmt: compressor doesn't know how;
- c) the file is not a plain file. */
+ records_read = 0;
- if (strcmp (archive_name_array[0], "-") != 0
- && !_remdev (archive_name_array[0])
- && is_regular_file (archive_name_array[0]))
+ if (use_compress_program_option)
{
- if (backup_option)
- maybe_backup_file (archive_name_array[0], 1);
-
- /* We don't need a grandchild tar. Open the archive and launch the
- compressor. */
-
- archive = creat (archive_name_array[0], MODE_RW);
- if (archive < 0)
+ switch (wanted_access)
{
- int saved_errno = errno;
-
- if (backup_option)
- undo_last_backup ();
- errno = saved_errno;
- open_fatal (archive_name_array[0]);
- }
- xdup2 (archive, STDOUT_FILENO);
- execlp (use_compress_program_option, use_compress_program_option,
- (char *) 0);
- exec_fatal (use_compress_program_option);
- }
-
- /* We do need a grandchild tar. */
-
- xpipe (child_pipe);
- grandchild_pid = xfork ();
-
- if (grandchild_pid == 0)
- {
- /* The newborn grandchild tar is here! Launch the compressor. */
-
- program_name = _("tar (grandchild)");
-
- xdup2 (child_pipe[PWRITE], STDOUT_FILENO);
- xclose (child_pipe[PREAD]);
- execlp (use_compress_program_option, use_compress_program_option,
- (char *) 0);
- exec_fatal (use_compress_program_option);
- }
-
- /* The child tar is still here! */
+ case ACCESS_READ:
+ child_pid = sys_child_open_for_uncompress ();
+ read_full_records = true;
+ record_end = record_start; /* set up for 1st record = # 0 */
+ break;
- /* Prepare for reblocking the data from the compressor into the archive. */
+ case ACCESS_WRITE:
+ child_pid = sys_child_open_for_compress ();
+ break;
- xdup2 (child_pipe[PREAD], STDIN_FILENO);
- xclose (child_pipe[PWRITE]);
+ case ACCESS_UPDATE:
+ abort (); /* Should not happen */
+ break;
+ }
- if (strcmp (archive_name_array[0], "-") == 0)
- archive = STDOUT_FILENO;
- else
- {
- archive = rmtcreat (archive_name_array[0], MODE_RW, rsh_command_option);
- if (archive < 0)
- open_fatal (archive_name_array[0]);
+ if (wanted_access == ACCESS_WRITE
+ && strcmp (archive_name_array[0], "-") == 0)
+ stdlis = stderr;
}
-
- /* Let's read out of the stdin pipe and write an archive. */
-
- while (1)
+ else if (strcmp (archive_name_array[0], "-") == 0)
{
- ssize_t status = 0;
- char *cursor;
- size_t length;
-
- /* Assemble a record. */
+ read_full_records = true; /* could be a pipe, be safe */
+ if (verify_option)
+ FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
- for (length = 0, cursor = record_start->buffer;
- length < record_size;
- length += status, cursor += status)
+ switch (wanted_access)
{
- size_t size = record_size - length;
+ case ACCESS_READ:
+ {
+ enum compress_type type;
- if (size < BLOCKSIZE)
- size = BLOCKSIZE;
- status = safe_read (STDIN_FILENO, cursor, size);
- if (status <= 0)
- break;
- }
+ archive = STDIN_FILENO;
- if (status < 0)
- read_fatal (use_compress_program_option);
+ type = check_compressed_archive (archive);
+ if (type != ct_none)
+ FATAL_ERROR ((0, 0,
+ _("Archive is compressed. Use %s option"),
+ compress_option (type)));
+ }
+ break;
- /* Copy the record. */
+ case ACCESS_WRITE:
+ archive = STDOUT_FILENO;
+ stdlis = stderr;
+ break;
- if (status == 0)
- {
- /* We hit the end of the file. Write last record at
- full length, as the only role of the grandchild is
- doing proper reblocking. */
-
- if (length > 0)
- {
- memset (record_start->buffer + length, 0, record_size - length);
- status = write_archive_buffer ();
- if (status != record_size)
- archive_write_error (status);
- }
-
- /* There is nothing else to read, break out. */
+ case ACCESS_UPDATE:
+ archive = STDIN_FILENO;
+ stdlis = stderr;
+ write_archive_to_stdout = true;
break;
}
-
- status = write_archive_buffer ();
- if (status != record_size)
- archive_write_error (status);
}
-
-#if 0
- close_archive ();
-#endif
-
- /* Propagate any failure of the grandchild back to the parent. */
-
- while (waitpid (grandchild_pid, &wait_status, 0) == -1)
- if (errno != EINTR)
+ 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)
{
- waitpid_error (use_compress_program_option);
+ case ACCESS_READ:
+ archive = open_compressed_archive ();
break;
- }
-
- if (WIFSIGNALED (wait_status))
- {
- kill (child_pid, WTERMSIG (wait_status));
- exit_status = TAREXIT_FAILURE;
- }
- else if (WEXITSTATUS (wait_status) != 0)
- exit_status = WEXITSTATUS (wait_status);
- exit (exit_status);
-}
-
-/* Set ARCHIVE for uncompressing, then reading an archive. */
-static void
-child_open_for_uncompress (void)
-{
- int parent_pipe[2];
- int child_pipe[2];
- pid_t grandchild_pid;
- int wait_status;
+ case ACCESS_WRITE:
+ if (backup_option)
+ {
+ maybe_backup_file (archive_name_array[0], 1);
+ backed_up_flag = 1;
+ }
+ archive = rmtcreat (archive_name_array[0], MODE_RW,
+ rsh_command_option);
+ break;
- xpipe (parent_pipe);
- child_pid = xfork ();
+ case ACCESS_UPDATE:
+ archive = rmtopen (archive_name_array[0], O_RDWR | O_CREAT | O_BINARY,
+ MODE_RW, rsh_command_option);
+ break;
+ }
- if (child_pid > 0)
+ if (archive < 0
+ || (! _isrmt (archive) && !sys_get_archive_stat ()))
{
- /* The parent tar is still here! Just clean up. */
+ int saved_errno = errno;
- read_full_records_option = 1;
- archive = parent_pipe[PREAD];
- xclose (parent_pipe[PWRITE]);
- return;
+ if (backed_up_flag)
+ undo_last_backup ();
+ errno = saved_errno;
+ open_fatal (archive_name_array[0]);
}
- /* The newborn child tar is here! */
-
- program_name = _("tar (child)");
+ sys_detect_dev_null_output ();
+ sys_save_archive_dev_ino ();
+ SET_BINARY_MODE (archive);
- xdup2 (parent_pipe[PWRITE], STDOUT_FILENO);
- xclose (parent_pipe[PREAD]);
+ switch (wanted_access)
+ {
+ case ACCESS_UPDATE:
+ records_written = 0;
+ record_end = record_start; /* set up for 1st record = # 0 */
- /* Check if we need a grandchild tar. This happens only if either:
- a) we're reading stdin: to force unblocking;
- b) the file is to be accessed by rmt: compressor doesn't know how;
- c) the file is not a plain file. */
+ case ACCESS_READ:
+ find_next_block (); /* read it in, check for EOF */
+ break;
- if (strcmp (archive_name_array[0], "-") != 0
- && !_remdev (archive_name_array[0])
- && is_regular_file (archive_name_array[0]))
- {
- /* We don't need a grandchild tar. Open the archive and lauch the
- uncompressor. */
-
- archive = open (archive_name_array[0], O_RDONLY | O_BINARY, MODE_RW);
- if (archive < 0)
- open_fatal (archive_name_array[0]);
- xdup2 (archive, STDIN_FILENO);
- execlp (use_compress_program_option, use_compress_program_option,
- "-d", (char *) 0);
- exec_fatal (use_compress_program_option);
+ case ACCESS_WRITE:
+ records_written = 0;
+ break;
}
+}
- /* We do need a grandchild tar. */
+/* Perform a write to flush the buffer. */
+ssize_t
+_flush_write (void)
+{
+ ssize_t status;
- xpipe (child_pipe);
- grandchild_pid = xfork ();
+ if (checkpoint_option && !(++checkpoint % 10))
+ /* TRANSLATORS: This is a ``checkpoint of write operation'',
+ *not* ``Writing a checkpoint''.
+ E.g. in Spanish ``Punto de comprobaci@'on de escritura'',
+ *not* ``Escribiendo un punto de comprobaci@'on'' */
+ WARN ((0, 0, _("Write checkpoint %d"), checkpoint));
- if (grandchild_pid == 0)
+ if (tape_length_option && tape_length_option <= bytes_written)
{
- /* The newborn grandchild tar is here! Launch the uncompressor. */
-
- program_name = _("tar (grandchild)");
-
- xdup2 (child_pipe[PREAD], STDIN_FILENO);
- xclose (child_pipe[PWRITE]);
- execlp (use_compress_program_option, use_compress_program_option,
- "-d", (char *) 0);
- exec_fatal (use_compress_program_option);
+ errno = ENOSPC;
+ status = 0;
}
+ else if (dev_null_output)
+ status = record_size;
+ else
+ status = sys_write_archive_buffer ();
- /* The child tar is still here! */
-
- /* Prepare for unblocking the data from the archive into the
- uncompressor. */
+ return status;
+}
- xdup2 (child_pipe[PWRITE], STDOUT_FILENO);
- xclose (child_pipe[PREAD]);
-
- if (strcmp (archive_name_array[0], "-") == 0)
- archive = STDIN_FILENO;
- else
- archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY,
- MODE_RW, rsh_command_option);
- if (archive < 0)
- open_fatal (archive_name_array[0]);
-
- /* Let's read the archive and pipe it into stdout. */
-
- while (1)
- {
- char *cursor;
- size_t maximum;
- size_t count;
- ssize_t status;
-
- read_error_count = 0;
-
- error_loop:
- status = rmtread (archive, record_start->buffer, record_size);
- if (status < 0)
- {
- archive_read_error ();
- goto error_loop;
- }
- if (status == 0)
- break;
- cursor = record_start->buffer;
- maximum = status;
- while (maximum)
- {
- count = maximum < BLOCKSIZE ? maximum : BLOCKSIZE;
- status = full_write (STDOUT_FILENO, cursor, count);
- if (status < 0)
- write_error (use_compress_program_option);
-
- if (status != count)
- {
- ERROR ((0, 0, _("Write to compression program short %lu bytes"),
- (unsigned long) (count - status)));
- count = status;
- }
-
- cursor += count;
- maximum -= count;
- }
- }
-
- xclose (STDOUT_FILENO);
-#if 0
- close_archive ();
-#endif
-
- /* Propagate any failure of the grandchild back to the parent. */
-
- while (waitpid (grandchild_pid, &wait_status, 0) == -1)
- if (errno != EINTR)
- {
- waitpid_error (use_compress_program_option);
- break;
- }
-
- if (WIFSIGNALED (wait_status))
+/* Handle write errors on the archive. Write errors are always fatal.
+ Hitting the end of a volume does not cause a write error unless the
+ write was the first record of the volume. */
+void
+archive_write_error (ssize_t status)
+{
+ /* It might be useful to know how much was written before the error
+ occurred. */
+ if (totals_option)
{
- kill (child_pid, WTERMSIG (wait_status));
- exit_status = TAREXIT_FAILURE;
+ int e = errno;
+ print_total_written ();
+ errno = e;
}
- else if (WEXITSTATUS (wait_status) != 0)
- exit_status = WEXITSTATUS (wait_status);
- exit (exit_status);
+ write_fatal_details (*archive_name_cursor, status, record_size);
}
-#endif /* not MSDOS */
-
-/* Check the LABEL block 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
- multi-volume mode. */
-static int
-check_label_pattern (union block *label)
+/* Handle read errors on the archive. If the read should be retried,
+ return to the caller. */
+void
+archive_read_error (void)
{
- char *string;
- int result;
+ read_error (*archive_name_cursor);
- if (fnmatch (volume_label_option, label->header.name, 0) == 0)
- return 1;
+ if (record_start_block == 0)
+ FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
- if (!multi_volume_option)
- return 0;
+ /* Read error in mid archive. We retry up to READ_ERROR_MAX times and
+ then give up on reading the archive. */
- string = xmalloc (strlen (volume_label_option)
- + sizeof VOLUME_LABEL_APPEND + 1);
- strcpy (string, volume_label_option);
- strcat (string, VOLUME_LABEL_APPEND);
- result = fnmatch (string, label->header.name, 0) == 0;
- free (string);
- return result;
+ if (read_error_count++ > READ_ERROR_MAX)
+ FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
+ return;
}
-/* Open an archive file. The argument specifies whether we are
- reading or writing, or both. */
-void
-open_archive (enum access_mode wanted_access)
+static void
+short_read (size_t status)
{
- int backed_up_flag = 0;
-
- stdlis = to_stdout_option ? stderr : stdout;
-
- if (record_size == 0)
- FATAL_ERROR ((0, 0, _("Invalid value for record_size")));
-
- if (archive_names == 0)
- FATAL_ERROR ((0, 0, _("No archive name given")));
+ size_t left; /* bytes left */
+ char *more; /* pointer to next byte to read */
- current_file_name = 0;
- current_link_name = 0;
- save_name = 0;
- real_s_name = 0;
+ more = record_start->buffer + status;
+ left = record_size - status;
- if (multi_volume_option)
+ while (left % BLOCKSIZE != 0
+ || (left && status && read_full_records))
{
- if (verify_option)
- FATAL_ERROR ((0, 0, _("Cannot verify multi-volume archives")));
- record_start = valloc (record_size + (2 * BLOCKSIZE));
- if (record_start)
- record_start += 2;
- }
- else
- record_start = valloc (record_size);
- if (!record_start)
- FATAL_ERROR ((0, 0, _("Cannot allocate memory for blocking factor %d"),
- blocking_factor));
-
- current_block = record_start;
- record_end = record_start + blocking_factor;
- /* When updating the archive, we start with reading. */
- access_mode = wanted_access == ACCESS_UPDATE ? ACCESS_READ : wanted_access;
+ if (status)
+ while ((status = rmtread (archive, more, left)) == SAFE_READ_ERROR)
+ archive_read_error ();
- if (use_compress_program_option)
- {
- if (multi_volume_option)
- FATAL_ERROR ((0, 0, _("Cannot use multi-volume compressed archives")));
- if (verify_option)
- FATAL_ERROR ((0, 0, _("Cannot verify compressed archives")));
+ if (status == 0)
+ break;
- switch (wanted_access)
+ if (! read_full_records)
{
- case ACCESS_READ:
- child_open_for_uncompress ();
- break;
-
- case ACCESS_WRITE:
- child_open_for_compress ();
- break;
+ unsigned long rest = record_size - left;
- case ACCESS_UPDATE:
- FATAL_ERROR ((0, 0, _("Cannot update compressed archives")));
- break;
+ FATAL_ERROR ((0, 0,
+ ngettext ("Unaligned block (%lu byte) in archive",
+ "Unaligned block (%lu bytes) in archive",
+ rest),
+ rest));
}
- if (wanted_access == ACCESS_WRITE
- && strcmp (archive_name_array[0], "-") == 0)
- stdlis = stderr;
+ /* User warned us about this. Fix up. */
+
+ left -= status;
+ more += status;
}
- else if (strcmp (archive_name_array[0], "-") == 0)
+
+ /* FIXME: for size=0, multi-volume support. On the first record, warn
+ about the problem. */
+
+ if (!read_full_records && verbose_option > 1
+ && record_start_block == 0 && status != 0)
{
- read_full_records_option = 1; /* could be a pipe, be safe */
- if (verify_option)
- FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
+ unsigned long rsize = (record_size - left) / BLOCKSIZE;
+ WARN ((0, 0,
+ ngettext ("Record size = %lu block",
+ "Record size = %lu blocks",
+ rsize),
+ rsize));
+ }
- switch (wanted_access)
- {
- case ACCESS_READ:
- archive = STDIN_FILENO;
- break;
+ record_end = record_start + (record_size - left) / BLOCKSIZE;
+ records_read++;
+}
- case ACCESS_WRITE:
- archive = STDOUT_FILENO;
- stdlis = stderr;
- break;
+/* Perform a read to flush the buffer. */
+size_t
+_flush_read (void)
+{
+ size_t status; /* result from system call */
- case ACCESS_UPDATE:
- archive = STDIN_FILENO;
- stdlis = stderr;
- write_archive_to_stdout = 1;
- 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)
- {
- case ACCESS_READ:
- archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY,
- MODE_RW, rsh_command_option);
- break;
+ if (checkpoint_option && !(++checkpoint % 10))
+ /* TRANSLATORS: This is a ``checkpoint of read operation'',
+ *not* ``Reading a checkpoint''.
+ E.g. in Spanish ``Punto de comprobaci@'on de lectura'',
+ *not* ``Leyendo un punto de comprobaci@'on'' */
+ WARN ((0, 0, _("Read checkpoint %d"), checkpoint));
- case ACCESS_WRITE:
- if (backup_option)
- {
- maybe_backup_file (archive_name_array[0], 1);
- backed_up_flag = 1;
- }
- archive = rmtcreat (archive_name_array[0], MODE_RW,
- rsh_command_option);
- break;
+ /* Clear the count of errors. This only applies to a single call to
+ flush_read. */
- case ACCESS_UPDATE:
- archive = rmtopen (archive_name_array[0], O_RDWR | O_CREAT | O_BINARY,
- MODE_RW, rsh_command_option);
- break;
- }
+ read_error_count = 0; /* clear error count */
- if (archive < 0
- || (! _isrmt (archive) && fstat (archive, &archive_stat) < 0))
+ if (write_archive_to_stdout && record_start_block != 0)
{
- int saved_errno = errno;
-
- if (backed_up_flag)
- undo_last_backup ();
- errno = saved_errno;
- open_fatal (archive_name_array[0]);
+ archive = STDOUT_FILENO;
+ status = sys_write_archive_buffer ();
+ archive = STDIN_FILENO;
+ if (status != record_size)
+ archive_write_error (status);
}
-#if !MSDOS
+ status = rmtread (archive, record_start->buffer, record_size);
+ if (status == record_size)
+ records_read++;
+ return status;
+}
- /* Detect if outputting to "/dev/null". */
- {
- static char const dev_null[] = "/dev/null";
- struct stat dev_null_stat;
-
- dev_null_output =
- (strcmp (archive_name_array[0], dev_null) == 0
- || (! _isrmt (archive)
- && S_ISCHR (archive_stat.st_mode)
- && stat (dev_null, &dev_null_stat) == 0
- && archive_stat.st_dev == dev_null_stat.st_dev
- && archive_stat.st_ino == dev_null_stat.st_ino));
- }
+/* Flush the current buffer to/from the archive. */
+void
+flush_archive (void)
+{
+ record_start_block += record_end - record_start;
+ current_block = record_start;
+ record_end = record_start + blocking_factor;
- if (!_isrmt (archive) && S_ISREG (archive_stat.st_mode))
+ if (access_mode == ACCESS_READ && time_to_start_writing)
{
- ar_dev = archive_stat.st_dev;
- ar_ino = archive_stat.st_ino;
+ access_mode = ACCESS_WRITE;
+ time_to_start_writing = false;
+ backspace_output ();
}
- else
- ar_dev = 0;
-
-#endif /* not MSDOS */
-
-#if MSDOS
- setmode (archive, O_BINARY);
-#endif
- switch (wanted_access)
+ switch (access_mode)
{
case ACCESS_READ:
- case ACCESS_UPDATE:
- record_end = record_start; /* set up for 1st record = # 0 */
- find_next_block (); /* read it in, check for EOF */
-
- if (volume_label_option)
- {
- union block *label = find_next_block ();
-
- if (!label)
- FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
- quote (volume_label_option)));
- if (!check_label_pattern (label))
- FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
- quote_n (0, label->header.name),
- quote_n (1, volume_label_option)));
- }
+ flush_read ();
break;
case ACCESS_WRITE:
- if (volume_label_option)
- {
- memset (record_start, 0, BLOCKSIZE);
- if (multi_volume_option)
- sprintf (record_start->header.name, "%s Volume 1",
- volume_label_option);
- else
- strcpy (record_start->header.name, volume_label_option);
-
- assign_string (¤t_file_name, record_start->header.name);
-
- record_start->header.typeflag = GNUTYPE_VOLHDR;
- TIME_TO_CHARS (start_time, record_start->header.mtime);
- finish_header (record_start);
-#if 0
- current_block++;
-#endif
- }
+ flush_write ();
break;
+
+ case ACCESS_UPDATE:
+ abort ();
}
}
-/* Perform a write to flush the buffer. */
-void
-flush_write (void)
+/* Backspace the archive descriptor by one record worth. If it's a
+ tape, MTIOCTOP will work. If it's something else, try to seek on
+ it. If we can't seek, we lose! */
+static void
+backspace_output (void)
{
- int copy_back;
- ssize_t status;
+#ifdef MTIOCTOP
+ {
+ struct mtop operation;
- if (checkpoint_option && !(++checkpoint % 10))
- WARN ((0, 0, _("Write checkpoint %d"), checkpoint));
+ operation.mt_op = MTBSR;
+ operation.mt_count = 1;
+ if (rmtioctl (archive, MTIOCTOP, (char *) &operation) >= 0)
+ return;
+ if (errno == EIO && rmtioctl (archive, MTIOCTOP, (char *) &operation) >= 0)
+ return;
+ }
+#endif
- if (tape_length_option && tape_length_option <= bytes_written)
- {
- errno = ENOSPC;
- status = 0;
- }
- else if (dev_null_output)
- status = record_size;
- else
- status = write_archive_buffer ();
- if (status != record_size && !multi_volume_option)
- archive_write_error (status);
+ {
+ off_t position = rmtlseek (archive, (off_t) 0, SEEK_CUR);
- if (status > 0)
- bytes_written += status;
+ /* Seek back to the beginning of this record and start writing there. */
- if (status == record_size)
- {
- if (multi_volume_option)
- {
- char *cursor;
+ position -= record_size;
+ if (position < 0)
+ position = 0;
+ if (rmtlseek (archive, position, SEEK_SET) != position)
+ {
+ /* Lseek failed. Try a different method. */
- if (!save_name)
- {
- assign_string (&real_s_name, 0);
- real_s_totsize = 0;
- real_s_sizeleft = 0;
- return;
- }
+ WARN ((0, 0,
+ _("Cannot backspace archive file; it may be unreadable without -i")));
- cursor = save_name + FILESYSTEM_PREFIX_LEN (save_name);
- while (*cursor == '/')
- cursor++;
+ /* Replace the first part of the record with NULs. */
- assign_string (&real_s_name, cursor);
- real_s_totsize = save_totsize;
- real_s_sizeleft = save_sizeleft;
- }
- return;
- }
+ if (record_start->buffer != output_start)
+ memset (record_start->buffer, 0,
+ output_start - record_start->buffer);
+ }
+ }
+}
- /* We're multivol. Panic if we didn't get the right kind of response. */
+off_t
+seek_archive (off_t size)
+{
+ off_t start = current_block_ordinal ();
+ off_t offset;
+ off_t nrec, nblk;
+ off_t skipped = (blocking_factor - (current_block - record_start));
- /* ENXIO is for the UNIX PC. */
- if (status < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO)
- archive_write_error (status);
+ size -= skipped * BLOCKSIZE;
- /* If error indicates a short write, we just move to the next tape. */
+ if (size < record_size)
+ return 0;
+ /* FIXME: flush? */
- if (!new_volume (ACCESS_WRITE))
- return;
+ /* Compute number of records to skip */
+ nrec = size / record_size;
+ offset = rmtlseek (archive, nrec * record_size, SEEK_CUR);
+ if (offset < 0)
+ return offset;
- if (totals_option)
- prev_written += bytes_written;
- bytes_written = 0;
+ if (offset % record_size)
+ FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary")));
- if (volume_label_option && real_s_name)
- {
- copy_back = 2;
- record_start -= 2;
- }
- else if (volume_label_option || real_s_name)
- {
- copy_back = 1;
- record_start--;
- }
- else
- copy_back = 0;
+ /* Convert to number of records */
+ offset /= BLOCKSIZE;
+ /* Compute number of skipped blocks */
+ nblk = offset - start;
- if (volume_label_option)
- {
- memset (record_start, 0, BLOCKSIZE);
- sprintf (record_start->header.name, "%s Volume %d",
- volume_label_option, volno);
- TIME_TO_CHARS (start_time, record_start->header.mtime);
- record_start->header.typeflag = GNUTYPE_VOLHDR;
- finish_header (record_start);
- }
+ /* Update buffering info */
+ records_read += nblk / blocking_factor;
+ record_start_block = offset - blocking_factor;
+ current_block = record_end;
- if (real_s_name)
- {
- int tmp;
+ return nblk;
+}
- if (volume_label_option)
- record_start++;
+/* Close the archive file. */
+void
+close_archive (void)
+{
+ if (time_to_start_writing || access_mode == ACCESS_WRITE)
+ flush_archive ();
- memset (record_start, 0, BLOCKSIZE);
+ sys_drain_input_pipe ();
- /* 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. */
+ compute_duration ();
+ if (verify_option)
+ verify_volume ();
- strcpy (record_start->header.name, real_s_name);
- record_start->header.typeflag = GNUTYPE_MULTIVOL;
- OFF_TO_CHARS (real_s_sizeleft, record_start->header.size);
- OFF_TO_CHARS (real_s_totsize - real_s_sizeleft,
- record_start->oldgnu_header.offset);
- tmp = verbose_option;
- verbose_option = 0;
- finish_header (record_start);
- verbose_option = tmp;
+ if (rmtclose (archive) != 0)
+ close_warn (*archive_name_cursor);
- if (volume_label_option)
- record_start--;
- }
+ sys_wait_for_child (child_pid);
- status = write_archive_buffer ();
- if (status != record_size)
- archive_write_error (status);
+ 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]);
+}
- bytes_written += status;
+/* Called to initialize the global volume number. */
+void
+init_volume_number (void)
+{
+ FILE *file = fopen (volno_file_option, "r");
- if (copy_back)
+ if (file)
{
- record_start += copy_back;
- memcpy (current_block,
- record_start + blocking_factor - copy_back,
- copy_back * BLOCKSIZE);
- current_block += copy_back;
-
- if (real_s_sizeleft >= copy_back * BLOCKSIZE)
- real_s_sizeleft -= copy_back * BLOCKSIZE;
- else if ((real_s_sizeleft + BLOCKSIZE - 1) / BLOCKSIZE <= copy_back)
- assign_string (&real_s_name, 0);
- else
- {
- char *cursor = save_name + FILESYSTEM_PREFIX_LEN (save_name);
-
- while (*cursor == '/')
- cursor++;
-
- assign_string (&real_s_name, cursor);
- real_s_sizeleft = save_sizeleft;
- real_s_totsize = save_totsize;
- }
- copy_back = 0;
+ if (fscanf (file, "%d", &global_volno) != 1
+ || global_volno < 0)
+ FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"),
+ quotearg_colon (volno_file_option)));
+ if (ferror (file))
+ read_error (volno_file_option);
+ if (fclose (file) != 0)
+ close_error (volno_file_option);
}
+ else if (errno != ENOENT)
+ open_error (volno_file_option);
}
-/* Handle write errors on the archive. Write errors are always fatal.
- Hitting the end of a volume does not cause a write error unless the
- write was the first record of the volume. */
-static void
-archive_write_error (ssize_t status)
+/* Called to write out the closing global volume number. */
+void
+closeout_volume_number (void)
{
- /* It might be useful to know how much was written before the error
- occurred. */
- if (totals_option)
+ FILE *file = fopen (volno_file_option, "w");
+
+ if (file)
{
- int e = errno;
- print_total_written ();
- errno = e;
+ fprintf (file, "%d\n", global_volno);
+ if (ferror (file))
+ write_error (volno_file_option);
+ if (fclose (file) != 0)
+ close_error (volno_file_option);
}
-
- write_fatal_details (*archive_name_cursor, status, record_size);
+ else
+ open_error (volno_file_option);
}
-/* Handle read errors on the archive. If the read should be retried,
- return to the caller. */
+\f
static void
-archive_read_error (void)
+increase_volume_number ()
{
- read_error (*archive_name_cursor);
-
- if (record_start_block == 0)
- FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
-
- /* Read error in mid archive. We retry up to READ_ERROR_MAX times and
- then give up on reading the archive. */
-
- if (read_error_count++ > READ_ERROR_MAX)
- FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
- return;
+ global_volno++;
+ if (global_volno < 0)
+ FATAL_ERROR ((0, 0, _("Volume number overflow")));
+ volno++;
}
-/* Perform a read to flush the buffer. */
-void
-flush_read (void)
+/* We've hit the end of the old volume. Close it and open the next one.
+ Return nonzero on success.
+*/
+static bool
+new_volume (enum access_mode mode)
{
- ssize_t status; /* result from system call */
- size_t left; /* bytes left */
- char *more; /* pointer to next byte to read */
+ static FILE *read_file;
+ static int looped;
- if (checkpoint_option && !(++checkpoint % 10))
- WARN ((0, 0, _("Read checkpoint %d"), checkpoint));
+ if (!read_file && !info_script_option)
+ /* FIXME: if fopen is used, it will never be closed. */
+ read_file = archive == STDIN_FILENO ? fopen (TTY_NAME, "r") : stdin;
- /* Clear the count of errors. This only applies to a single call to
- flush_read. */
+ if (now_verifying)
+ return false;
+ if (verify_option)
+ verify_volume ();
- read_error_count = 0; /* clear error count */
+ assign_string (&volume_label, NULL);
+ assign_string (&continued_file_name, NULL);
+ continued_file_size = continued_file_offset = 0;
+
+ if (rmtclose (archive) != 0)
+ close_warn (*archive_name_cursor);
- if (write_archive_to_stdout && record_start_block != 0)
+ archive_name_cursor++;
+ if (archive_name_cursor == archive_name_array + archive_names)
{
- archive = STDOUT_FILENO;
- status = write_archive_buffer ();
- archive = STDIN_FILENO;
- if (status != record_size)
- archive_write_error (status);
+ archive_name_cursor = archive_name_array;
+ looped = 1;
}
- if (multi_volume_option)
- {
- if (save_name)
- {
- char *cursor = save_name + FILESYSTEM_PREFIX_LEN (save_name);
- while (*cursor == '/')
- cursor++;
+ tryagain:
+ if (looped)
+ {
+ /* We have to prompt from now on. */
- assign_string (&real_s_name, cursor);
- real_s_sizeleft = save_sizeleft;
- real_s_totsize = save_totsize;
- }
- else
+ if (info_script_option)
{
- assign_string (&real_s_name, 0);
- real_s_totsize = 0;
- real_s_sizeleft = 0;
+ if (volno_file_option)
+ closeout_volume_number ();
+ if (system (info_script_option) != 0)
+ FATAL_ERROR ((0, 0, _("%s command failed"),
+ quote (info_script_option)));
}
- }
-
- error_loop:
- status = rmtread (archive, record_start->buffer, record_size);
- if (status == record_size)
- return;
-
- if ((status == 0
- || (status < 0 && errno == ENOSPC)
- || (status > 0 && !read_full_records_option))
- && multi_volume_option)
- {
- union block *cursor;
+ else
+ while (1)
+ {
+ char input_buffer[80];
- try_volume:
- switch (subcommand_option)
- {
- case APPEND_SUBCOMMAND:
- case CAT_SUBCOMMAND:
- case UPDATE_SUBCOMMAND:
- if (!new_volume (ACCESS_UPDATE))
- return;
- break;
+ fputc ('\007', stderr);
+ fprintf (stderr,
+ _("Prepare volume #%d for %s and hit return: "),
+ global_volno + 1, quote (*archive_name_cursor));
+ fflush (stderr);
- default:
- if (!new_volume (ACCESS_READ))
- return;
- break;
- }
+ if (fgets (input_buffer, sizeof input_buffer, read_file) == 0)
+ {
+ WARN ((0, 0, _("EOF where user reply was expected")));
- vol_error:
- status = rmtread (archive, record_start->buffer, record_size);
- if (status < 0)
- {
- archive_read_error ();
- goto vol_error;
- }
- if (status != record_size)
- goto short_read;
+ if (subcommand_option != EXTRACT_SUBCOMMAND
+ && subcommand_option != LIST_SUBCOMMAND
+ && subcommand_option != DIFF_SUBCOMMAND)
+ WARN ((0, 0, _("WARNING: Archive is incomplete")));
- cursor = record_start;
+ fatal_exit ();
+ }
+ if (input_buffer[0] == '\n'
+ || input_buffer[0] == 'y'
+ || input_buffer[0] == 'Y')
+ break;
- if (cursor->header.typeflag == GNUTYPE_VOLHDR)
- {
- if (volume_label_option)
- {
- if (!check_label_pattern (cursor))
+ switch (input_buffer[0])
+ {
+ case '?':
{
- WARN ((0, 0, _("Volume %s does not match %s"),
- quote_n (0, cursor->header.name),
- quote_n (1, volume_label_option)));
- volno--;
- global_volno--;
- goto try_volume;
+ /* FIXME: Might it be useful to disable the '!' command? */
+ fprintf (stderr, _("\
+ n [name] Give a new file name for the next (and subsequent) volume(s)\n\
+ q Abort tar\n\
+ ! Spawn a subshell\n\
+ ? Print this list\n"));
}
- }
- if (verbose_option)
- fprintf (stdlis, _("Reading %s\n"), quote (cursor->header.name));
- cursor++;
- }
- else if (volume_label_option)
- WARN ((0, 0, _("WARNING: No volume header")));
+ break;
- if (real_s_name)
- {
- uintmax_t s1, s2;
- if (cursor->header.typeflag != GNUTYPE_MULTIVOL
- || strcmp (cursor->header.name, real_s_name))
- {
- WARN ((0, 0, _("%s is not continued on this volume"),
- quote (real_s_name)));
- volno--;
- global_volno--;
- goto try_volume;
- }
- s1 = UINTMAX_FROM_HEADER (cursor->header.size);
- s2 = UINTMAX_FROM_HEADER (cursor->oldgnu_header.offset);
- if (real_s_totsize != s1 + s2 || s1 + s2 < s2)
- {
- char totsizebuf[UINTMAX_STRSIZE_BOUND];
- char s1buf[UINTMAX_STRSIZE_BOUND];
- char s2buf[UINTMAX_STRSIZE_BOUND];
-
- WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
- quote (cursor->header.name),
- STRINGIFY_BIGINT (save_totsize, totsizebuf),
- STRINGIFY_BIGINT (s1, s1buf),
- STRINGIFY_BIGINT (s2, s2buf)));
- volno--;
- global_volno--;
- goto try_volume;
- }
- if (real_s_totsize - real_s_sizeleft
- != OFF_FROM_HEADER (cursor->oldgnu_header.offset))
- {
- WARN ((0, 0, _("This volume is out of sequence")));
- volno--;
- global_volno--;
- goto try_volume;
- }
- cursor++;
- }
- current_block = cursor;
- return;
- }
- else if (status < 0)
- {
- archive_read_error ();
- goto error_loop; /* try again */
- }
+ case 'q':
+ /* Quit. */
- short_read:
- more = record_start->buffer + status;
- left = record_size - status;
+ WARN ((0, 0, _("No new volume; exiting.\n")));
- while (left % BLOCKSIZE != 0)
- {
- if (status)
- while ((status = rmtread (archive, more, left)) < 0)
- archive_read_error ();
+ if (subcommand_option != EXTRACT_SUBCOMMAND
+ && subcommand_option != LIST_SUBCOMMAND
+ && subcommand_option != DIFF_SUBCOMMAND)
+ WARN ((0, 0, _("WARNING: Archive is incomplete")));
- if (status == 0)
- {
- ERROR ((0, 0, _("%d garbage bytes ignored at end of archive"),
- (int) ((record_size - left) % BLOCKSIZE)));
- break;
- }
+ fatal_exit ();
- if (! read_full_records_option)
- FATAL_ERROR ((0, 0, _("Unaligned block (%lu bytes) in archive"),
- (unsigned long) (record_size - left)));
-
- /* User warned us about this. Fix up. */
+ case 'n':
+ /* Get new file name. */
- left -= status;
- more += status;
- }
+ {
+ char *name = &input_buffer[1];
+ char *cursor;
- /* FIXME: for size=0, multi-volume support. On the first record, warn
- about the problem. */
+ for (name = input_buffer + 1;
+ *name == ' ' || *name == '\t';
+ name++)
+ ;
- if (!read_full_records_option && verbose_option
- && record_start_block == 0 && status > 0)
- WARN ((0, 0, _("Record size = %lu blocks"),
- (unsigned long) ((record_size - left) / BLOCKSIZE)));
+ for (cursor = name; *cursor && *cursor != '\n'; cursor++)
+ ;
+ *cursor = '\0';
- record_end = record_start + (record_size - left) / BLOCKSIZE;
-}
+ /* FIXME: the following allocation is never reclaimed. */
+ *archive_name_cursor = xstrdup (name);
+ }
+ break;
-/* Flush the current buffer to/from the archive. */
-void
-flush_archive (void)
-{
- record_start_block += record_end - record_start;
- current_block = record_start;
- record_end = record_start + blocking_factor;
+ case '!':
+ sys_spawn_shell ();
+ break;
+ }
+ }
+ }
- if (access_mode == ACCESS_READ && time_to_start_writing)
+ if (strcmp (archive_name_cursor[0], "-") == 0)
{
- access_mode = ACCESS_WRITE;
- time_to_start_writing = 0;
+ read_full_records = true;
+ archive = STDIN_FILENO;
+ }
+ else if (verify_option)
+ archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW,
+ rsh_command_option);
+ else
+ switch (mode)
+ {
+ case ACCESS_READ:
+ archive = rmtopen (*archive_name_cursor, O_RDONLY, MODE_RW,
+ rsh_command_option);
+ break;
- if (file_to_switch_to >= 0)
- {
- if (rmtclose (archive) != 0)
- close_warn (*archive_name_cursor);
+ case ACCESS_WRITE:
+ if (backup_option)
+ maybe_backup_file (*archive_name_cursor, 1);
+ archive = rmtcreat (*archive_name_cursor, MODE_RW,
+ rsh_command_option);
+ break;
- archive = file_to_switch_to;
- }
- else
- backspace_output ();
+ case ACCESS_UPDATE:
+ archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW,
+ rsh_command_option);
+ break;
+ }
+
+ if (archive < 0)
+ {
+ open_warn (*archive_name_cursor);
+ if (!verify_option && mode == ACCESS_WRITE && backup_option)
+ undo_last_backup ();
+ goto tryagain;
}
- switch (access_mode)
+ SET_BINARY_MODE (archive);
+
+ return true;
+}
+
+bool
+try_new_volume ()
+{
+ size_t status;
+ enum read_header rc;
+ union block *block;
+
+ switch (subcommand_option)
{
- case ACCESS_READ:
- flush_read ();
+ case APPEND_SUBCOMMAND:
+ case CAT_SUBCOMMAND:
+ case UPDATE_SUBCOMMAND:
+ if (!new_volume (ACCESS_UPDATE))
+ return true;
break;
- case ACCESS_WRITE:
- flush_write ();
+ default:
+ if (!new_volume (ACCESS_READ))
+ return true;
break;
-
- case ACCESS_UPDATE:
- abort ();
}
-}
-/* Backspace the archive descriptor by one record worth. If it's a
- tape, MTIOCTOP will work. If it's something else, try to seek on
- it. If we can't seek, we lose! */
-static void
-backspace_output (void)
-{
-#ifdef MTIOCTOP
- {
- struct mtop operation;
+ while ((status = rmtread (archive, record_start->buffer, record_size))
+ == SAFE_READ_ERROR)
+ archive_read_error ();
- operation.mt_op = MTBSR;
- operation.mt_count = 1;
- if (rmtioctl (archive, MTIOCTOP, (char *) &operation) >= 0)
- return;
- if (errno == EIO && rmtioctl (archive, MTIOCTOP, (char *) &operation) >= 0)
- return;
- }
-#endif
+ if (status != record_size)
+ short_read (status);
- {
- off_t position = rmtlseek (archive, (off_t) 0, SEEK_CUR);
+ again:
+ block = current_block;
+ rc = read_header (true);
+ switch (rc)
+ {
+ case HEADER_SUCCESS_EXTENDED:
+ if (current_header->header.typeflag == XGLTYPE)
+ {
+ struct tar_stat_info dummy;
+ xheader_read (current_header,
+ OFF_FROM_HEADER (current_header->header.size));
+ xheader_decode_global ();
+ xheader_destroy (&extended_header);
+ tar_stat_init (&dummy);
+ xheader_decode (&dummy); /* decodes values from the global header */
+ tar_stat_destroy (&dummy);
+ }
+ break;
+
+ case HEADER_SUCCESS:
+ if (current_header->header.typeflag == GNUTYPE_VOLHDR)
+ assign_string (&volume_label, current_header->header.name);
+ else if (current_header->header.typeflag == GNUTYPE_MULTIVOL)
+ {
+ assign_string (&continued_file_name, current_header->header.name);
+ continued_file_size =
+ UINTMAX_FROM_HEADER (current_header->header.size);
+ continued_file_offset =
+ UINTMAX_FROM_HEADER (current_header->oldgnu_header.offset);
+ }
+ else
+ break;
+ set_next_block_after (current_header);
+ goto again;
- /* Seek back to the beginning of this record and start writing there. */
+ case HEADER_ZERO_BLOCK:
+ case HEADER_END_OF_FILE:
+ case HEADER_FAILURE:
+ current_block = block;
+ break;
- position -= record_size;
- if (position < 0)
- position = 0;
- if (rmtlseek (archive, position, SEEK_SET) != position)
- {
- /* Lseek failed. Try a different method. */
+ default:
+ abort ();
+ }
- WARN ((0, 0,
- _("Cannot backspace archive file; it may be unreadable without -i")));
+ if (real_s_name)
+ {
+ uintmax_t s;
+ if (continued_file_name
+ && strcmp (continued_file_name, real_s_name))
+ {
+ WARN ((0, 0, _("%s is not continued on this volume"),
+ quote (real_s_name)));
+ return false;
+ }
- /* Replace the first part of the record with NULs. */
+ s = continued_file_size + continued_file_offset;
- if (record_start->buffer != output_start)
- memset (record_start->buffer, 0,
- output_start - record_start->buffer);
- }
- }
+ if (real_s_totsize != s || s < continued_file_offset)
+ {
+ char totsizebuf[UINTMAX_STRSIZE_BOUND];
+ char s1buf[UINTMAX_STRSIZE_BOUND];
+ char s2buf[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 (continued_file_size, s1buf),
+ STRINGIFY_BIGINT (continued_file_offset, s2buf)));
+ return false;
+ }
+
+ if (real_s_totsize - real_s_sizeleft != continued_file_offset)
+ {
+ WARN ((0, 0, _("This volume is out of sequence")));
+ return false;
+ }
+ }
+
+ increase_volume_number ();
+ return true;
}
-/* Close the archive file. */
-void
-close_archive (void)
+\f
+/* Check the LABEL block 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
+ multi-volume mode. */
+static bool
+check_label_pattern (union block *label)
{
- if (time_to_start_writing || access_mode == ACCESS_WRITE)
- flush_archive ();
-
-#if !MSDOS
+ char *string;
+ bool result;
- /* Manage to fully drain a pipe we might be reading, so to not break it on
- the producer after the EOF block. FIXME: one of these days, GNU tar
- might become clever enough to just stop working, once there is no more
- work to do, we might have to revise this area in such time. */
+ if (! memchr (label->header.name, '\0', sizeof label->header.name))
+ return false;
- if (access_mode == ACCESS_READ
- && ! _isrmt (archive)
- && S_ISFIFO (archive_stat.st_mode))
- while (rmtread (archive, record_start->buffer, record_size) > 0)
- continue;
-#endif
+ if (fnmatch (volume_label_option, label->header.name, 0) == 0)
+ return true;
- if (verify_option)
- verify_volume ();
+ if (!multi_volume_option)
+ return false;
- if (rmtclose (archive) != 0)
- close_warn (*archive_name_cursor);
+ string = xmalloc (strlen (volume_label_option)
+ + sizeof VOLUME_LABEL_APPEND + 1);
+ strcpy (string, volume_label_option);
+ strcat (string, VOLUME_LABEL_APPEND);
+ result = fnmatch (string, label->header.name, 0) == 0;
+ free (string);
+ return result;
+}
-#if !MSDOS
+/* Check if the next block contains a volume label and if this matches
+ the one given in the command line */
+static void
+match_volume_label (void)
+{
+ union block *label = find_next_block ();
+
+ if (!label)
+ FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
+ quote (volume_label_option)));
+ if (!check_label_pattern (label))
+ FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
+ quote_n (0, label->header.name),
+ quote_n (1, volume_label_option)));
+}
- if (child_pid)
+/* Mark the archive with volume label STR. */
+static void
+_write_volume_label (const char *str)
+{
+ if (archive_format == POSIX_FORMAT)
+ xheader_store ("GNU.volume.label", NULL, str);
+ else
{
- int wait_status;
+ union block *label = find_next_block ();
+
+ memset (label, 0, BLOCKSIZE);
+
+ strcpy (label->header.name, volume_label_option);
+ assign_string (¤t_stat_info.file_name,
+ label->header.name);
+ current_stat_info.had_trailing_slash =
+ strip_trailing_slashes (current_stat_info.file_name);
+
+ label->header.typeflag = GNUTYPE_VOLHDR;
+ TIME_TO_CHARS (start_time.tv_sec, label->header.mtime);
+ finish_header (¤t_stat_info, label, -1);
+ set_next_block_after (label);
+ }
+}
- while (waitpid (child_pid, &wait_status, 0) == -1)
- if (errno != EINTR)
- {
- waitpid_error (use_compress_program_option);
- break;
- }
+#define VOL_SUFFIX "Volume"
- if (WIFSIGNALED (wait_status))
- ERROR ((0, 0, _("Child died with signal %d"),
- WTERMSIG (wait_status)));
- else if (WEXITSTATUS (wait_status) != 0)
- ERROR ((0, 0, _("Child returned status %d"),
- WEXITSTATUS (wait_status)));
- }
-#endif /* !MSDOS */
+/* Add a volume label to a part of multi-volume archive */
+static void
+add_volume_label (void)
+{
+ char buf[UINTMAX_STRSIZE_BOUND];
+ char *p = STRINGIFY_BIGINT (volno, buf);
+ char *s = xmalloc (strlen (volume_label_option) + sizeof VOL_SUFFIX
+ + strlen (p) + 2);
+ sprintf (s, "%s %s %s", volume_label_option, VOL_SUFFIX, p);
+ _write_volume_label (s);
+ free (s);
+}
- if (current_file_name)
- free (current_file_name);
- if (current_link_name)
- free (current_link_name);
- if (save_name)
- free (save_name);
- if (real_s_name)
- free (real_s_name);
- free (multi_volume_option ? record_start - 2 : record_start);
+/* Add a volume label to the current archive */
+static void
+write_volume_label (void)
+{
+ if (multi_volume_option)
+ add_volume_label ();
+ else
+ _write_volume_label (volume_label_option);
}
-/* Called to initialize the global volume number. */
-void
-init_volume_number (void)
+/* Write GNU multi-volume header */
+static void
+gnu_add_multi_volume_header (void)
{
- FILE *file = fopen (volno_file_option, "r");
+ int tmp;
+ union block *block = find_next_block ();
+
+ if (strlen (real_s_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)));
+
+ 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);
+ block->header.typeflag = GNUTYPE_MULTIVOL;
+
+ OFF_TO_CHARS (real_s_sizeleft, block->header.size);
+ OFF_TO_CHARS (real_s_totsize - real_s_sizeleft,
+ block->oldgnu_header.offset);
+
+ tmp = verbose_option;
+ verbose_option = 0;
+ finish_header (¤t_stat_info, block, -1);
+ verbose_option = tmp;
+ set_next_block_after (block);
+}
- if (file)
+/* 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)
+{
+ if (archive_format == POSIX_FORMAT)
{
- fscanf (file, "%d", &global_volno);
- if (ferror (file))
- read_error (volno_file_option);
- if (fclose (file) != 0)
- close_error (volno_file_option);
+ off_t d = real_s_totsize - real_s_sizeleft;
+ xheader_store ("GNU.volume.size", NULL, &real_s_sizeleft);
+ xheader_store ("GNU.volume.offset", NULL, &d);
}
- else if (errno != ENOENT)
- open_error (volno_file_option);
+ else
+ gnu_add_multi_volume_header ();
}
-/* Called to write out the closing global volume number. */
-void
-closeout_volume_number (void)
+/* Synchronize multi-volume globals */
+static void
+multi_volume_sync ()
{
- FILE *file = fopen (volno_file_option, "w");
-
- if (file)
+ if (multi_volume_option)
{
- fprintf (file, "%d\n", global_volno);
- if (ferror (file))
- write_error (volno_file_option);
- if (fclose (file) != 0)
- close_error (volno_file_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;
+ }
}
- else
- open_error (volno_file_option);
}
-/* We've hit the end of the old volume. Close it and open the next one.
- Return nonzero on success. */
-static int
-new_volume (enum access_mode access)
+\f
+/* Low-level flush functions */
+
+/* Simple flush read (no multi-volume or label extensions) */
+static void
+simple_flush_read (void)
{
- static FILE *read_file;
- static int looped;
+ size_t status; /* result from system call */
- if (!read_file && !info_script_option)
- /* FIXME: if fopen is used, it will never be closed. */
- read_file = archive == STDIN_FILENO ? fopen (TTY_NAME, "r") : stdin;
+ if (checkpoint_option && !(++checkpoint % 10))
+ /* TRANSLATORS: This is a ``checkpoint of read operation'',
+ *not* ``Reading a checkpoint''.
+ E.g. in Spanish ``Punto de comprobaci@'on de lectura'',
+ *not* ``Leyendo un punto de comprobaci@'on'' */
+ WARN ((0, 0, _("Read checkpoint %d"), checkpoint));
- if (now_verifying)
- return 0;
- if (verify_option)
- verify_volume ();
+ /* Clear the count of errors. This only applies to a single call to
+ flush_read. */
- if (rmtclose (archive) != 0)
- close_warn (*archive_name_cursor);
+ read_error_count = 0; /* clear error count */
- global_volno++;
- volno++;
- archive_name_cursor++;
- if (archive_name_cursor == archive_name_array + archive_names)
+ if (write_archive_to_stdout && record_start_block != 0)
{
- archive_name_cursor = archive_name_array;
- looped = 1;
+ archive = STDOUT_FILENO;
+ status = sys_write_archive_buffer ();
+ archive = STDIN_FILENO;
+ if (status != record_size)
+ archive_write_error (status);
}
-
- tryagain:
- if (looped)
+
+ for (;;)
{
- /* We have to prompt from now on. */
-
- if (info_script_option)
+ status = rmtread (archive, record_start->buffer, record_size);
+ if (status == record_size)
{
- if (volno_file_option)
- closeout_volume_number ();
- system (info_script_option);
+ records_read++;
+ return;
}
- else
- while (1)
- {
- char input_buffer[80];
+ if (status == SAFE_READ_ERROR)
+ {
+ archive_read_error ();
+ continue; /* try again */
+ }
+ break;
+ }
+ short_read (status);
+}
- fputc ('\007', stderr);
- fprintf (stderr,
- _("Prepare volume #%d for %s and hit return: "),
- global_volno, quote (*archive_name_cursor));
- fflush (stderr);
+/* Simple flush write (no multi-volume or label extensions) */
+static void
+simple_flush_write (void)
+{
+ ssize_t status;
- if (fgets (input_buffer, sizeof input_buffer, read_file) == 0)
- {
- WARN ((0, 0, _("EOF where user reply was expected")));
+ status = _flush_write ();
+ if (status != record_size)
+ archive_write_error (status);
+ else
+ {
+ records_written++;
+ bytes_written += status;
+ }
+}
- if (subcommand_option != EXTRACT_SUBCOMMAND
- && subcommand_option != LIST_SUBCOMMAND
- && subcommand_option != DIFF_SUBCOMMAND)
- WARN ((0, 0, _("WARNING: Archive is incomplete")));
+\f
+/* GNU flush functions. These support multi-volume and archive labels in
+ GNU and PAX archive formats. */
- fatal_exit ();
- }
- if (input_buffer[0] == '\n'
- || input_buffer[0] == 'y'
- || input_buffer[0] == 'Y')
- break;
+static void
+_gnu_flush_read (void)
+{
+ size_t status; /* result from system call */
- switch (input_buffer[0])
- {
- case '?':
- {
- fprintf (stderr, _("\
- n [name] Give a new file name for the next (and subsequent) volume(s)\n\
- q Abort tar\n\
- ! Spawn a subshell\n\
- ? Print this list\n"));
- }
- break;
+ if (checkpoint_option && !(++checkpoint % 10))
+ /* TRANSLATORS: This is a ``checkpoint of read operation'',
+ *not* ``Reading a checkpoint''.
+ E.g. in Spanish ``Punto de comprobaci@'on de lectura'',
+ *not* ``Leyendo un punto de comprobaci@'on'' */
+ WARN ((0, 0, _("Read checkpoint %d"), checkpoint));
- case 'q':
- /* Quit. */
+ /* Clear the count of errors. This only applies to a single call to
+ flush_read. */
- WARN ((0, 0, _("No new volume; exiting.\n")));
+ read_error_count = 0; /* clear error count */
- if (subcommand_option != EXTRACT_SUBCOMMAND
- && subcommand_option != LIST_SUBCOMMAND
- && subcommand_option != DIFF_SUBCOMMAND)
- WARN ((0, 0, _("WARNING: Archive is incomplete")));
+ if (write_archive_to_stdout && record_start_block != 0)
+ {
+ archive = STDOUT_FILENO;
+ status = sys_write_archive_buffer ();
+ archive = STDIN_FILENO;
+ if (status != record_size)
+ archive_write_error (status);
+ }
- fatal_exit ();
+ multi_volume_sync ();
- case 'n':
- /* Get new file name. */
+ for (;;)
+ {
+ status = rmtread (archive, record_start->buffer, record_size);
+ if (status == record_size)
+ {
+ records_read++;
+ return;
+ }
- {
- char *name = &input_buffer[1];
- char *cursor;
+ /* The condition below used to include
+ || (status > 0 && !read_full_records)
+ This is incorrect since even if new_volume() succeeds, the
+ subsequent call to rmtread will overwrite the chunk of data
+ already read in the buffer, so the processing will fail */
+ if ((status == 0
+ || (status == SAFE_READ_ERROR && errno == ENOSPC))
+ && multi_volume_option)
+ {
+ while (!try_new_volume ())
+ ;
+ return;
+ }
+ else if (status == SAFE_READ_ERROR)
+ {
+ archive_read_error ();
+ continue;
+ }
+ break;
+ }
+ short_read (status);
+}
- while (*name == ' ' || *name == '\t')
- name++;
- cursor = name;
- while (*cursor && *cursor != '\n')
- cursor++;
- *cursor = '\0';
+static void
+gnu_flush_read (void)
+{
+ flush_read = simple_flush_read; /* Avoid recursion */
+ _gnu_flush_read ();
+ flush_read = gnu_flush_read;
+}
- /* FIXME: the following allocation is never reclaimed. */
- *archive_name_cursor = xstrdup (name);
- }
- break;
+static void
+_gnu_flush_write (void)
+{
+ ssize_t status;
+ union block *header;
+ char *copy_ptr;
+ size_t copy_size;
+ size_t bufsize;
+
+ status = _flush_write ();
+ if (status != record_size && !multi_volume_option)
+ archive_write_error (status);
+ else
+ {
+ records_written++;
+ bytes_written += status;
+ }
- case '!':
-#if MSDOS
- spawnl (P_WAIT, getenv ("COMSPEC"), "-", 0);
-#else /* not MSDOS */
- {
- pid_t child;
- const char *shell = getenv ("SHELL");
- if (! shell)
- shell = "/bin/sh";
- child = xfork ();
- if (child == 0)
- {
- execlp (shell, "-sh", "-i", 0);
- exec_fatal (shell);
- }
- else
- {
- int wait_status;
- while (waitpid (child, &wait_status, 0) == -1)
- if (errno != EINTR)
- {
- waitpid_error (shell);
- break;
- }
- }
- }
-#endif /* not MSDOS */
- break;
- }
- }
+ if (status == record_size)
+ {
+ multi_volume_sync ();
+ return;
}
- if (verify_option)
- archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW,
- rsh_command_option);
- else
- switch (access)
- {
- case ACCESS_READ:
- archive = rmtopen (*archive_name_cursor, O_RDONLY, MODE_RW,
- rsh_command_option);
- break;
+ /* In multi-volume mode. */
+ /* ENXIO is for the UNIX PC. */
+ if (status < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO)
+ archive_write_error (status);
- case ACCESS_WRITE:
- if (backup_option)
- maybe_backup_file (*archive_name_cursor, 1);
- archive = rmtcreat (*archive_name_cursor, MODE_RW,
- rsh_command_option);
- break;
+ if (!new_volume (ACCESS_WRITE))
+ return;
- case ACCESS_UPDATE:
- archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW,
- rsh_command_option);
- break;
- }
+ xheader_destroy (&extended_header);
+
+ increase_volume_number ();
+ if (totals_option)
+ prev_written += bytes_written;
+ bytes_written = 0;
- if (archive < 0)
+ copy_ptr = record_start->buffer + status;
+ copy_size = record_size - status;
+ /* Switch to the next buffer */
+ record_index = !record_index;
+ init_buffer ();
+
+ if (volume_label_option)
+ add_volume_label ();
+
+ if (real_s_name)
+ add_multi_volume_header ();
+
+ header = write_extended (XGLTYPE, NULL, find_next_block ());
+ bufsize = available_space_after (header);
+ while (bufsize < copy_size)
{
- open_warn (*archive_name_cursor);
- if (!verify_option && access == ACCESS_WRITE && backup_option)
- undo_last_backup ();
- goto tryagain;
+ memcpy (header->buffer, copy_ptr, bufsize);
+ copy_ptr += bufsize;
+ copy_size -= bufsize;
+ set_next_block_after (header + (bufsize - 1) / BLOCKSIZE);
+ header = find_next_block ();
+ bufsize = available_space_after (header);
}
+ 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);
+ find_next_block ();
+}
-#if MSDOS
- setmode (archive, O_BINARY);
-#endif
+static void
+gnu_flush_write (void)
+{
+ flush_write = simple_flush_write; /* Avoid recursion */
+ _gnu_flush_write ();
+ flush_write = gnu_flush_write;
+}
+
+void
+open_archive (enum access_mode wanted_access)
+{
+ flush_read = gnu_flush_read;
+ flush_write = gnu_flush_write;
- return 1;
+ _open_archive (wanted_access);
+ switch (wanted_access)
+ {
+ case ACCESS_READ:
+ if (volume_label_option)
+ match_volume_label ();
+ break;
+
+ case ACCESS_WRITE:
+ records_written = 0;
+ if (volume_label_option)
+ write_volume_label ();
+ break;
+ }
}
projects / chaz / tar / blobdiff