Fix unrecognized option.

[chaz/tar] / src / buffer.c

diff --git a/src/buffer.c b/src/buffer.c
index 49ea37f615134c74fff6c37712f98d60551c5972..7638bb1fce71c3e0ffc14b48480b6c5692e9a965 100644 (file)
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1,10 +1,14 @@
 /* Buffer management for tar.
 /* Buffer management for tar.

-   Copyright (C) 1988, 92, 93, 94, 96, 97, 1999 Free Software Foundation, Inc.
+
+   Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
+   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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
    under the terms of the GNU General Public License as published by the
    Written by John Gilmore, on 1985-08-25.
 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the

-   Free Software Foundation; either version 2, or (at your option) any later
+   Free Software Foundation; either version 3, or (at your option) any later

    version.
 
    This program is distributed in the hope that it will be useful, but
    version.
 
    This program is distributed in the hope that it will be useful, but


@@ -14,74 +18,50 @@
 
    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.,
 
    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.  */
-
-/* Enable GNU extensions in fnmatch.h.  */
-#ifndef _GNU_SOURCE
-# define _GNU_SOURCE 1
-#endif
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */

 
 

-#include "system.h"
+#include <system.h>
+#include <system-ioctl.h>

 
 #include <signal.h>
 
 #include <signal.h>

-#include <time.h>
-time_t time ();
-
-#if MSDOS
-# include <process.h>
-#endif
-
-#if XENIX
-# include <sys/inode.h>
-#endif

 
 

+#include <closeout.h>

 #include <fnmatch.h>
 #include <fnmatch.h>

+#include <human.h>
+#include <quotearg.h>

 
 #include "common.h"
 
 #include "common.h"

-#include "rmt.h"
-
-#define DEBUG_FORK 0           /* if nonzero, childs are born stopped */
-
-#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.  */
 
 /* Number of retries before giving up on read.  */

-#define        READ_ERROR_MAX 10
+#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.  */
 
 /* Variables.  */
 

-static tarlong prev_written;   /* bytes written on previous volumes */
-static tarlong bytes_written;  /* bytes written on this volume */
+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 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 */
+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 */
+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 */

 
 static off_t record_start_block; /* block ordinal at record_start */
 
 
 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;
 
 FILE *stdlis;
 

-static void backspace_output PARAMS ((void));
-static int new_volume PARAMS ((enum access_mode));
-static void write_error PARAMS ((ssize_t));
-static void 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;
 
 /* PID of child program, if compress_option or remote archive access.  */
 static pid_t child_pid;


@@ -90,1605 +70,1895 @@ static pid_t child_pid;
 static int read_error_count;
 
 /* Have we hit EOF yet?  */
 static int read_error_count;
 
 /* Have we hit EOF yet?  */

-static int 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;
-
-int file_to_switch_to = -1;    /* if remote update, close archive, and use
-                                  this descriptor to write to */
-
-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 non NULL */
-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 = 0;
-
-/* Used by flush_read and flush_write to store the real info about saved
-   names.  */
-static char *real_s_name = NULL;
-static off_t real_s_totsize;
-static off_t real_s_sizeleft;
+static bool hit_eof;
+
+static bool read_full_records = false;
+
+/* We're reading, but we just read the last block and it's time to update.
+   Declared in update.c
+
+   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);
+

 \f
 \f

-/* Functions.  */
+char *volume_label;
+char *continued_file_name;
+uintmax_t continued_file_size;
+uintmax_t continued_file_offset;

 
 

-#if DEBUG_FORK
+\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 */

 
 

-static pid_t
-myfork (void)
-{
-  pid_t result = fork();
+bool write_archive_to_stdout;

 
 

-  if (result == 0)
-    kill (getpid (), SIGSTOP);
-  return result;
-}
+\f
+/* Multi-volume tracking support */
+
+/* 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.

 
 

-# define fork myfork
+   When reading from a multi-volume archive, the list degrades to a
+   single element, which keeps information about the member currently
+   being read.
+*/

 
 

-#endif /* DEBUG FORK */
+struct bufmap
+{
+  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
 
 void

-print_total_written (void)
+mv_begin_write (const char *file_name, off_t totsize, off_t sizeleft)

 {
 {

-  fprintf (stderr, _("Total bytes written: "));
-  fprintf (stderr, TARLONG_FORMAT, prev_written + bytes_written);
-  fprintf (stderr, "\n");
+  if (multi_volume_option)
+    {
+      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;
+    }

 }
 
 }
 

-/*--------------------------------------------------------.
-| Compute and return the block ordinal at current_block.  |
-`--------------------------------------------------------*/
-
-off_t
-current_block_ordinal (void)
+static struct bufmap *
+bufmap_locate (size_t off)

 {
 {

-  return record_start_block + (current_block - record_start);
-}
+  struct bufmap *map;

 
 

-/*------------------------------------------------------------------.
-| If the EOF flag is set, reset it, as well as current_block, etc.  |
-`------------------------------------------------------------------*/
+  for (map = bufmap_head; map; map = map->next)
+    {
+      if (!map->next
+         || off < map->next->start * BLOCKSIZE)
+       break;
+    }
+  return map;
+}

 
 

-void
-reset_eof (void)
+static void
+bufmap_free (struct bufmap *mark)

 {
 {

-  if (hit_eof)
+  struct bufmap *map;
+  for (map = bufmap_head; map && map != mark; )

     {
     {

-      hit_eof = 0;
-      current_block = record_start;
-      record_end = record_start + blocking_factor;
-      access_mode = ACCESS_WRITE;
+      struct bufmap *next = map->next;
+      free (map->file_name);
+      free (map);
+      map = next;

     }
     }

+  bufmap_head = map;
+  if (!bufmap_head)
+    bufmap_tail = bufmap_head;

 }
 
 }
 

-/*-------------------------------------------------------------------------.
-| Return the location of the next available input or output block.        |
-| Return NULL for EOF.  Once we have returned NULL, we just keep returning |
-| it, to avoid accidentally going on to the next file on the tape.        |
-`-------------------------------------------------------------------------*/
-
-union block *
-find_next_block (void)
+static void
+bufmap_reset (struct bufmap *map, ssize_t fixup)

 {
 {

-  if (current_block == record_end)
+  bufmap_free (map);
+  if (map)

     {
     {

-      if (hit_eof)
-       return NULL;
-      flush_archive ();
-      if (current_block == record_end)
-       {
-         hit_eof = 1;
-         return NULL;
-       }
+      for (; map; map = map->next)
+       map->start += fixup;

     }
     }

-  return current_block;

 }
 
 }
 

-/*------------------------------------------------------.
-| Indicate that we have used all blocks up thru BLOCK.  |
-|                                                      |
-| FIXME: should the arg have an off-by-1?              |
-`------------------------------------------------------*/
+\f
+static struct tar_stat_info dummy;

 
 void
 
 void

-set_next_block_after (union block *block)
+buffer_write_global_xheader (void)

 {
 {

-  while (block >= current_block)
-    current_block++;
-
-  /* Do *not* flush the archive here.  If we do, the same argument to
-     set_next_block_after could mean the next block (if the input record
-     is exactly one block long), which is not what is intended.  */
-
-  if (current_block > record_end)
-    abort ();
+  xheader_write_global (&dummy.xhdr);

 }
 
 }
 

-/*------------------------------------------------------------------------.
-| 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.                      |
-`------------------------------------------------------------------------*/
-
-size_t
-available_space_after (union block *pointer)
+void
+mv_begin_read (struct tar_stat_info *st)

 {
 {

-  return record_end->buffer - pointer->buffer;
+  mv_begin_write (st->orig_file_name, st->stat.st_size, st->stat.st_size);

 }
 
 }
 

-/*------------------------------------------------------------------.
-| Close file having descriptor FD, and abort if close unsucessful.  |
-`------------------------------------------------------------------*/
+void
+mv_end (void)
+{
+  if (multi_volume_option)
+    bufmap_free (NULL);
+}

 
 

-static void
-xclose (int fd)
+void
+mv_size_left (off_t size)

 {
 {

-  if (close (fd) < 0)
-    FATAL_ERROR ((0, errno, _("Cannot close file #%d"), fd));
+  if (bufmap_head)
+    bufmap_head->sizeleft = size;

 }
 
 }
 

-/*-----------------------------------------------------------------------.
-| Duplicate file descriptor FROM into becoming INTO, or else, issue     |
-| MESSAGE.  INTO is closed first and has to be the next available slot.         |
-`-----------------------------------------------------------------------*/
+\f
+/* Functions.  */

 
 

-static void
-xdup2 (int from, int into, const char *message)
+void
+clear_read_error_count (void)

 {
 {

-  if (from != into)
-    {
-      int status = close (into);
-
-      if (status < 0 && errno != EBADF)
-       FATAL_ERROR ((0, errno, _("Cannot close descriptor %d"), into));
-      status = dup (from);
-      if (status != into)
-       FATAL_ERROR ((0, errno, _("Cannot properly duplicate %s"), message));
-      xclose (from);
-    }
+  read_error_count = 0;

 }
 
 }
 

-#if MSDOS
+\f
+/* Time-related functions */

 
 

-/*-------------------------------------------------------.
-| Set ARCHIVE for writing, then compressing an archive.         |
-`-------------------------------------------------------*/
+double duration;

 
 

-static void
-child_open_for_compress (void)
+void
+set_start_time (void)

 {
 {

-  FATAL_ERROR ((0, 0, _("Cannot use compressed or remote archives")));
+  gettime (&start_time);
+  volume_start_time = start_time;
+  last_stat_time = start_time;

 }
 
 }
 

-/*---------------------------------------------------------.
-| Set ARCHIVE for uncompressing, then reading an archive.  |
-`---------------------------------------------------------*/
-

 static void
 static void

-child_open_for_uncompress (void)
+set_volume_start_time (void)

 {
 {

-  FATAL_ERROR ((0, 0, _("Cannot use compressed or remote archives")));
+  gettime (&volume_start_time);
+  last_stat_time = volume_start_time;

 }
 
 }
 

-#else /* not MSDOS */
+void
+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 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).          |
-`---------------------------------------------------------------------*/
+\f
+/* Compression detection */
+
+enum compress_type {
+  ct_none,             /* Unknown compression type */
+  ct_tar,              /* Plain tar file */
+  ct_compress,
+  ct_gzip,
+  ct_bzip2,
+  ct_lzip,
+  ct_lzma,
+  ct_lzop,
+  ct_xz
+};
+
+static enum compress_type archive_compression_type = ct_none;
+
+struct zip_magic
+{
+  enum compress_type type;
+  size_t length;
+  char const *magic;
+};

 
 

-static int
-is_regular_file (const char *name)
+struct zip_program
+{
+  enum compress_type type;
+  char const *program;
+  char const *option;
+};
+
+static struct zip_magic const magic[] = {
+  { ct_none, },
+  { ct_tar },
+  { 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]))
+
+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)

 {
 {

-  struct stat stbuf;
+  int i;

 
 

-  if (stat (name, &stbuf) == 0)
-    return S_ISREG (stbuf.st_mode);
-  else
-    return errno == ENOENT;
+  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;

 }
 
 }
 

-static ssize_t
-write_archive_buffer (void)
+const char *
+first_decompress_program (int *pstate)

 {
 {

-  ssize_t status;
-  ssize_t written = 0;
+  struct zip_program const *zp;

 
 

-  while (0 <= (status = rmtwrite (archive, record_start->buffer + written,
-                                 record_size - written)))
-    {
-      written += status;
-      if (written == record_size
-         || _isrmt (archive) || ! S_ISFIFO (archive_stat.st_mode))
-       break;
-    }
+  if (use_compress_program_option)
+    return use_compress_program_option;

 
 

-  return written ? written : status;
-}
+  if (archive_compression_type == ct_none)
+    return NULL;

 
 

-/*-------------------------------------------------------.
-| Set ARCHIVE for writing, then compressing an archive.         |
-`-------------------------------------------------------*/
+  *pstate = 0;
+  zp = find_zip_program (archive_compression_type, pstate);
+  return zp ? zp->program : NULL;
+}

 
 

-static void
-child_open_for_compress (void)
+const char *
+next_decompress_program (int *pstate)

 {
 {

-  int parent_pipe[2];
-  int child_pipe[2];
-  pid_t grandchild_pid;
+  struct zip_program const *zp;

 
 

-  if (pipe (parent_pipe) < 0)
-    FATAL_ERROR ((0, errno, _("Cannot open pipe")));
-
-  child_pid = fork ();
-  if (child_pid < 0)
-    FATAL_ERROR ((0, errno, _("Cannot fork")));
+  if (use_compress_program_option)
+    return NULL;
+  zp = find_zip_program (archive_compression_type, pstate);
+  return zp ? zp->program : NULL;
+}

 
 

-  if (child_pid > 0)
-    {
-      /* The parent tar is still here!  Just clean up.  */
+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;
+}

 
 

-      archive = parent_pipe[PWRITE];
-      xclose (parent_pipe[PREAD]);
-      return;
-    }
+/* Check if the file ARCHIVE is a compressed archive. */
+static enum compress_type
+check_compressed_archive (bool *pshort)
+{
+  struct zip_magic const *p;
+  bool sfr;
+  bool temp;

 
 

-  /* The new born child tar is here!  */
+  if (!pshort)
+    pshort = &temp;

 
 

-  program_name = _("tar (child)");
+  /* 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;

 
 

-  xclose (parent_pipe[PWRITE]);
-  xdup2 (parent_pipe[PREAD], STDIN_FILENO, _("(child) Pipe to stdin"));
+  /* Restore global values */
+  read_full_records = sfr;

 
 

-  /* 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.  */
+  if (tar_checksum (record_start, true) == HEADER_SUCCESS)
+    /* Probably a valid header */
+    return ct_tar;

 
 

-  if (strcmp (archive_name_array[0], "-") != 0
-      && !_remdev (archive_name_array[0])
-      && is_regular_file (archive_name_array[0]))
-    {
-      if (backup_option)
-       maybe_backup_file (archive_name_array[0], 1);
+  for (p = magic + 2; p < magic + NMAGIC; p++)
+    if (memcmp (record_start->buffer, p->magic, p->length) == 0)
+      return p->type;

 
 

-      /* We don't need a grandchild tar.  Open the archive and launch the
-        compressor.  */
+  return ct_none;
+}

 
 

-      archive = creat (archive_name_array[0], MODE_RW);
-      if (archive < 0)
-       {
-         int saved_errno = errno;
+/* Guess if the archive is seekable. */
+static void
+guess_seekable_archive (void)
+{
+  struct stat st;

 
 

-         if (backup_option)
-           undo_last_backup ();
-         FATAL_ERROR ((0, saved_errno, _("Cannot open archive %s"),
-                       archive_name_array[0]));
-       }
-      xdup2 (archive, STDOUT_FILENO, _("Archive to stdout"));
-      execlp (use_compress_program_option, use_compress_program_option,
-             (char *) 0);
-      FATAL_ERROR ((0, errno, _("Cannot exec %s"),
-                   use_compress_program_option));
+  if (subcommand_option == DELETE_SUBCOMMAND)
+    {
+      /* The current code in delete.c is based on the assumption that
+        skip_member() reads all data from the archive. So, we should
+        make sure it won't use seeks. On the other hand, the same code
+        depends on the ability to backspace a record in the archive,
+        so setting seekable_archive to false is technically incorrect.
+         However, it is tested only in skip_member(), so it's not a
+        problem. */
+      seekable_archive = false;

     }
 
     }
 

-  /* We do need a grandchild tar.  */
+  if (seek_option != -1)
+    {
+      seekable_archive = !!seek_option;
+      return;
+    }

 
 

-  if (pipe (child_pipe) < 0)
-    FATAL_ERROR ((0, errno, _("Cannot open pipe")));
+  if (!multi_volume_option && !use_compress_program_option
+      && fstat (archive, &st) == 0)
+    seekable_archive = S_ISREG (st.st_mode);
+  else
+    seekable_archive = false;
+}

 
 

-  grandchild_pid = fork ();
-  if (grandchild_pid < 0)
-    FATAL_ERROR ((0, errno, _("Child cannot fork")));
+/* 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 */
+static int
+open_compressed_archive (void)
+{
+  archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY,
+                     MODE_RW, rsh_command_option);
+  if (archive == -1)
+    return archive;

 
 

-  if (grandchild_pid > 0)
+  if (!multi_volume_option)

     {
     {

-      /* The child tar is still here!  Launch the compressor.  */
-
-      xdup2 (child_pipe[PWRITE], STDOUT_FILENO,
-            _("((child)) Pipe to stdout"));
-      xclose (child_pipe[PREAD]);
-      execlp (use_compress_program_option, use_compress_program_option,
-             (char *) 0);
-      FATAL_ERROR ((0, errno, _("Cannot exec %s"),
-                   use_compress_program_option));
+      if (!use_compress_program_option)
+        {
+          bool shortfile;
+          enum compress_type type = check_compressed_archive (&shortfile);
+
+          switch (type)
+            {
+            case ct_tar:
+              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_compression_program_by_suffix (archive_name_array[0], NULL);
+              if (!use_compress_program_option)
+               return archive;
+              break;
+
+            default:
+              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 */
+
+      /* Open compressed archive */
+      child_pid = sys_child_open_for_uncompress ();
+      read_full_records = true;

     }
 
     }
 

-  /* The new born grandchild tar is here!  */
+  records_read = 0;
+  record_end = record_start; /* set up for 1st record = # 0 */

 
 

-  program_name = _("tar (grandchild)");
+  return archive;
+}
+\f

 
 

-  /* Prepare for reblocking the data from the compressor into the archive.  */
+static void
+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];

 
 

-  xdup2 (child_pipe[PREAD], STDIN_FILENO, _("(grandchild) Pipe to stdin"));
-  xclose (child_pipe[PWRITE]);
+  int human_opts = human_autoscale | human_base_1024 | human_SI | human_B;

 
 

-  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)
-    FATAL_ERROR ((0, errno, _("Cannot open archive %s"),
-                 archive_name_array[0]));
+  sprintf (bytes, TARLONG_FORMAT, numbytes);

 
 

-  /* Let's read out of the stdin pipe and write an archive.  */
+  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)
+            : "?"));
+}

 
 

-  while (1)
+void
+print_total_stats (void)
+{
+  switch (subcommand_option)

     {
     {

-      ssize_t status = 0;
-      char *cursor;
-      size_t length;
+    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);
+      break;

 
 

-      /* Assemble a record.  */
+    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));
+      }
+      break;

 
 

-      for (length = 0, cursor = record_start->buffer;
-          length < record_size;
-          length += status, cursor += status)
-       {
-         size_t size = record_size - length;
+    case EXTRACT_SUBCOMMAND:
+    case LIST_SUBCOMMAND:
+    case DIFF_SUBCOMMAND:
+      print_stats (stderr, _("Total bytes read"),
+                   records_read * record_size);
+      break;

 
 

-         if (size < BLOCKSIZE)
-           size = BLOCKSIZE;
-         status = safe_read (STDIN_FILENO, cursor, size);
-         if (status <= 0)
-           break;
-       }
+    default:
+      abort ();
+    }
+}

 
 

-      if (status < 0)
-       FATAL_ERROR ((0, errno, _("Cannot read from compression program")));
+/* Compute and return the block ordinal at current_block.  */
+off_t
+current_block_ordinal (void)
+{
+  return record_start_block + (current_block - record_start);
+}

 
 

-      /* Copy the record.  */
+/* If the EOF flag is set, reset it, as well as current_block, etc.  */
+void
+reset_eof (void)
+{
+  if (hit_eof)
+    {
+      hit_eof = false;
+      current_block = record_start;
+      record_end = record_start + blocking_factor;
+      access_mode = ACCESS_WRITE;
+    }
+}

 
 

-      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.  */
+/* Return the location of the next available input or output block.
+   Return zero for EOF.  Once we have returned zero, we just keep returning
+   it, to avoid accidentally going on to the next file on the tape.  */
+union block *
+find_next_block (void)
+{
+  if (current_block == record_end)
+    {
+      if (hit_eof)
+        return 0;
+      flush_archive ();
+      if (current_block == record_end)
+        {
+          hit_eof = true;
+          return 0;
+        }
+    }
+  return current_block;
+}

 
 

-         if (length > 0)
-           {
-             memset (record_start->buffer + length, 0, record_size - length);
-             status = write_archive_buffer ();
-             if (status != record_size)
-               write_error (status);
-           }
+/* Indicate that we have used all blocks up thru BLOCK. */
+void
+set_next_block_after (union block *block)
+{
+  while (block >= current_block)
+    current_block++;

 
 

-         /* There is nothing else to read, break out.  */
-         break;
-       }
+  /* Do *not* flush the archive here.  If we do, the same argument to
+     set_next_block_after could mean the next block (if the input record
+     is exactly one block long), which is not what is intended.  */

 
 

-      status = write_archive_buffer ();
-      if (status != record_size)
-       write_error (status);
-    }
+  if (current_block > record_end)
+    abort ();
+}

 
 

-#if 0
-  close_archive ();
-#endif
-  exit (exit_status);
+/* 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 of previous find_next_block call.  */
+size_t
+available_space_after (union block *pointer)
+{
+  return record_end->buffer - pointer->buffer;

 }
 
 }
 

-/*---------------------------------------------------------.
-| Set ARCHIVE for uncompressing, then reading an archive.  |
-`---------------------------------------------------------*/
+/* Close file having descriptor FD, and abort if close unsuccessful.  */
+void
+xclose (int fd)
+{
+  if (close (fd) != 0)
+    close_error (_("(pipe)"));
+}

 
 static void
 
 static void

-child_open_for_uncompress (void)
+init_buffer (void)

 {
 {

-  int parent_pipe[2];
-  int child_pipe[2];
-  pid_t grandchild_pid;
+  if (! record_buffer_aligned[record_index])
+    record_buffer_aligned[record_index] =
+      page_aligned_alloc (&record_buffer[record_index], record_size);

 
 

-  if (pipe (parent_pipe) < 0)
-    FATAL_ERROR ((0, errno, _("Cannot open pipe")));
+  record_start = record_buffer_aligned[record_index];
+  current_block = record_start;
+  record_end = record_start + blocking_factor;
+}

 
 

-  child_pid = fork ();
-  if (child_pid < 0)
-    FATAL_ERROR ((0, errno, _("Cannot fork")));
+/* Open an archive file.  The argument specifies whether we are
+   reading or writing, or both.  */
+static void
+_open_archive (enum access_mode wanted_access)
+{
+  int backed_up_flag = 0;

 
 

-  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")));

 
 

-      read_full_records_option = 1;
-      archive = parent_pipe[PREAD];
-      xclose (parent_pipe[PWRITE]);
-      return;
-    }
+  if (archive_names == 0)
+    FATAL_ERROR ((0, 0, _("No archive name given")));

 
 

-  /* The new born child tar is here!  */
+  tar_stat_destroy (&current_stat_info);

 
 

-  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[PWRITE], STDOUT_FILENO, _("(child) Pipe to stdout"));
-  xclose (parent_pipe[PREAD]);
+  read_full_records = read_full_records_option;

 
 

-  /* 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.  */
+  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)

     {
     {

-      /* 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)
-       FATAL_ERROR ((0, errno, _("Cannot open archive %s"),
-                     archive_name_array[0]));
-      xdup2 (archive, STDIN_FILENO, _("Archive to stdin"));
-      execlp (use_compress_program_option, use_compress_program_option,
-             "-d", (char *) 0);
-      FATAL_ERROR ((0, errno, _("Cannot exec %s"),
-                   use_compress_program_option));
+      switch (wanted_access)
+        {
+        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;
+
+        case ACCESS_WRITE:
+          child_pid = sys_child_open_for_compress ();
+          break;
+
+        case ACCESS_UPDATE:
+          abort (); /* Should not happen */
+          break;
+        }
+
+      if (!index_file_name
+          && wanted_access == ACCESS_WRITE
+          && strcmp (archive_name_array[0], "-") == 0)
+        stdlis = stderr;

     }
     }

-
-  /* We do need a grandchild tar.  */
-
-  if (pipe (child_pipe) < 0)
-    FATAL_ERROR ((0, errno, _("Cannot open pipe")));
-
-  grandchild_pid = fork ();
-  if (grandchild_pid < 0)
-    FATAL_ERROR ((0, errno, _("Child cannot fork")));
-
-  if (grandchild_pid > 0)
+  else if (strcmp (archive_name_array[0], "-") == 0)

     {
     {

-      /* The child tar is still here!  Launch the uncompressor.  */
-
-      xdup2 (child_pipe[PREAD], STDIN_FILENO, _("((child)) Pipe to stdin"));
-      xclose (child_pipe[PWRITE]);
-      execlp (use_compress_program_option, use_compress_program_option,
-             "-d", (char *) 0);
-      FATAL_ERROR ((0, errno, _("Cannot exec %s"),
-                   use_compress_program_option));
+      read_full_records = true; /* could be a pipe, be safe */
+      if (verify_option)
+        FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
+
+      switch (wanted_access)
+        {
+        case ACCESS_READ:
+          {
+            bool shortfile;
+            enum compress_type type;
+
+            archive = STDIN_FILENO;
+
+            type = check_compressed_archive (&shortfile);
+            if (type != ct_tar && type != ct_none)
+              FATAL_ERROR ((0, 0,
+                            _("Archive is compressed. Use %s option"),
+                            compress_option (type)));
+            if (shortfile)
+              ERROR ((0, 0, _("This does not look like a tar archive")));
+          }
+          break;
+
+        case ACCESS_WRITE:
+          archive = STDOUT_FILENO;
+          if (!index_file_name)
+            stdlis = stderr;
+          break;
+
+        case ACCESS_UPDATE:
+          archive = STDIN_FILENO;
+          write_archive_to_stdout = true;
+          record_end = record_start; /* set up for 1st record = # 0 */
+          if (!index_file_name)
+            stdlis = stderr;
+          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 = open_compressed_archive ();
+       if (archive >= 0)
+         guess_seekable_archive ();
+        break;

 
 

-  /* The new born grandchild tar is here!  */
-
-  program_name = _("tar (grandchild)");
+      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;

 
 

-  /* Prepare for unblocking the data from the archive into the uncompressor.  */
+      case ACCESS_UPDATE:
+        archive = rmtopen (archive_name_array[0],
+                           O_RDWR | O_CREAT | O_BINARY,
+                           MODE_RW, rsh_command_option);
+
+        switch (check_compressed_archive (NULL))
+          {
+          case ct_none:
+          case ct_tar:
+            break;
+
+          default:
+            FATAL_ERROR ((0, 0,
+                          _("Cannot update compressed archives")));
+          }
+        break;
+      }

 
 

-  xdup2 (child_pipe[PWRITE], STDOUT_FILENO, _("(grandchild) Pipe to stdout"));
-  xclose (child_pipe[PREAD]);
+  if (archive < 0
+      || (! _isrmt (archive) && !sys_get_archive_stat ()))
+    {
+      int saved_errno = errno;

 
 

-  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)
-    FATAL_ERROR ((0, errno, _("Cannot open archive %s"),
-                 archive_name_array[0]));
+      if (backed_up_flag)
+        undo_last_backup ();
+      errno = saved_errno;
+      open_fatal (archive_name_array[0]);
+    }

 
 

-  /* Let's read the archive and pipe it into stdout.  */
+  sys_detect_dev_null_output ();
+  sys_save_archive_dev_ino ();
+  SET_BINARY_MODE (archive);

 
 

-  while (1)
+  switch (wanted_access)

     {
     {

-      char *cursor;
-      size_t maximum;
-      size_t count;
-      ssize_t status;
+    case ACCESS_READ:
+      find_next_block ();       /* read it in, check for EOF */
+      break;

 
 

-      read_error_count = 0;
+    case ACCESS_UPDATE:
+    case ACCESS_WRITE:
+      records_written = 0;
+      break;
+    }
+}

 
 

-    error_loop:
-      status = rmtread (archive, record_start->buffer, record_size);
-      if (status < 0)
-       {
-         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)
-           FATAL_ERROR ((0, errno, _("\
-Cannot write to compression program")));
+/* Perform a write to flush the buffer.  */
+static ssize_t
+_flush_write (void)
+{
+  ssize_t status;

 
 

-         if (status != count)
-           {
-             ERROR ((0, 0, _("\
-Write to compression program short %lu bytes"),
-                     (unsigned long) (count - status)));
-             count = status;
-           }
+  checkpoint_run (true);
+  if (tape_length_option && tape_length_option <= bytes_written)
+    {
+      errno = ENOSPC;
+      status = 0;
+    }
+  else if (dev_null_output)
+    status = record_size;
+  else
+    status = sys_write_archive_buffer ();

 
 

-         cursor += count;
-         maximum -= count;
+  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);

        }
     }
        }
     }

-
-#if 0
-  close_archive ();
-#endif
-  exit (exit_status);
+  return status;

 }
 
 }
 

-#endif /* not MSDOS */
+/* 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)
+    {
+      int e = errno;
+      print_total_stats ();
+      errno = e;
+    }

 
 

-/*--------------------------------------------------------------------------.
-| 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.  |
-`--------------------------------------------------------------------------*/
+  write_fatal_details (*archive_name_cursor, status, record_size);
+}

 
 

-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 access)
+static bool
+archive_is_dev (void)

 {
 {

-  int backed_up_flag = 0;
+  struct stat st;

 
 

-  stdlis = to_stdout_option ? stderr : stdout;
+  if (fstat (archive, &st))
+    {
+      stat_diag (*archive_name_cursor);
+      return false;
+    }
+  return S_ISBLK (st.st_mode) || S_ISCHR (st.st_mode);
+}

 
 

-  if (record_size == 0)
-    FATAL_ERROR ((0, 0, _("Invalid value for record_size")));
+static void
+short_read (size_t status)
+{
+  size_t left;                  /* bytes left */
+  char *more;                   /* pointer to next byte to read */

 
 

-  if (archive_names == 0)
-    FATAL_ERROR ((0, 0, _("No archive name given")));
+  more = record_start->buffer + status;
+  left = record_size - status;

 
 

-  current_file_name = NULL;
-  current_link_name = NULL;
+  if (left && left % BLOCKSIZE == 0
+      && verbose_option
+      && 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));
+    }

 
 

-  /* FIXME: According to POSIX.1, PATH_MAX may well not be a compile-time
-     constant, and the value from sysconf (_SC_PATH_MAX) may well not be any
-     size that is reasonable to allocate a buffer.  In the GNU system, there
-     is no fixed limit.  The only correct thing to do is to use dynamic
-     allocation.  (Roland McGrath)  */
+  while (left % BLOCKSIZE != 0
+         || (left && status && read_full_records))
+    {
+      if (status)
+        while ((status = rmtread (archive, more, left)) == SAFE_READ_ERROR)
+          archive_read_error ();

 
 

-  if (!real_s_name)
-    real_s_name = (char *) xmalloc (PATH_MAX);
-  /* FIXME: real_s_name is never freed.  */
+      if (status == 0)
+        break;

 
 

-  save_name = NULL;
+      if (! read_full_records)
+        {
+          unsigned long rest = record_size - left;

 
 

-  if (multi_volume_option)
-    {
-      record_start
-       = (union block *) valloc (record_size + (2 * BLOCKSIZE));
-      if (record_start)
-       record_start += 2;
+          FATAL_ERROR ((0, 0,
+                        ngettext ("Unaligned block (%lu byte) in archive",
+                                  "Unaligned block (%lu bytes) in archive",
+                                  rest),
+                        rest));
+        }
+
+      left -= status;
+      more += status;

     }
     }

-  else
-    record_start = (union block *) valloc (record_size);
-  if (!record_start)
-    FATAL_ERROR ((0, 0, _("Could not allocate memory for blocking factor %d"),
-                 blocking_factor));

 
 

+  record_end = record_start + (record_size - left) / BLOCKSIZE;
+  records_read++;
+}
+
+/*  Flush the current buffer to/from the archive.  */
+void
+flush_archive (void)
+{
+  size_t buffer_level = current_block->buffer - record_start->buffer;
+  record_start_block += record_end - record_start;

   current_block = record_start;
   record_end = record_start + blocking_factor;
   current_block = record_start;
   record_end = record_start + blocking_factor;

-  /* When updating the archive, we start with reading.  */
-  access_mode = access == ACCESS_UPDATE ? ACCESS_READ : access;

 
 

-  if (multi_volume_option && verify_option)
-    FATAL_ERROR ((0, 0, _("Cannot verify multi-volume archives")));
+  if (access_mode == ACCESS_READ && time_to_start_writing)
+    {
+      access_mode = ACCESS_WRITE;
+      time_to_start_writing = false;
+      backspace_output ();
+    }

 
 

-  if (use_compress_program_option)
+  switch (access_mode)

     {
     {

-      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")));
+    case ACCESS_READ:
+      flush_read ();
+      break;

 
 

-      switch (access)
-       {
-       case ACCESS_READ:
-         child_open_for_uncompress ();
-         break;
+    case ACCESS_WRITE:
+      flush_write_ptr (buffer_level);
+      break;

 
 

-       case ACCESS_WRITE:
-         child_open_for_compress ();
-         break;
+    case ACCESS_UPDATE:
+      abort ();
+    }
+}

 
 

-       case ACCESS_UPDATE:
-         FATAL_ERROR ((0, 0, _("Cannot update compressed archives")));
-         break;
-       }
+/* 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;

 
 

-      if (access == ACCESS_WRITE && strcmp (archive_name_array[0], "-") == 0)
-       stdlis = stderr;
-    }
-  else if (strcmp (archive_name_array[0], "-") == 0)
-    {
-      read_full_records_option = 1; /* could be a pipe, be safe */
-      if (verify_option)
-       FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
+    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

 
 

-      switch (access)
-       {
-       case ACCESS_READ:
-         archive = STDIN_FILENO;
-         break;
-
-       case ACCESS_WRITE:
-         archive = STDOUT_FILENO;
-         stdlis = stderr;
-         break;
-
-       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 (access)
+  {
+    off_t position = rmtlseek (archive, (off_t) 0, SEEK_CUR);
+
+    /* Seek back to the beginning of this record and start writing there.  */
+
+    position -= record_size;
+    if (position < 0)
+      position = 0;
+    if (rmtlseek (archive, position, SEEK_SET) != position)

       {
       {

-      case ACCESS_READ:
-       archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY,
-                          MODE_RW, rsh_command_option);
-       break;
+        /* Lseek failed.  Try a different method.  */

 
 

-      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;
+        WARN ((0, 0,
+               _("Cannot backspace archive file; it may be unreadable without -i")));

 
 

-      case ACCESS_UPDATE:
-       archive = rmtopen (archive_name_array[0], O_RDWR | O_CREAT | O_BINARY,
-                          MODE_RW, rsh_command_option);
-       break;
+        /* Replace the first part of the record with NULs.  */
+
+        if (record_start->buffer != output_start)
+          memset (record_start->buffer, 0,
+                  output_start - record_start->buffer);

       }
       }

+  }
+}

 
 

-  if (archive < 0
-      || (! _isrmt (archive) && fstat (archive, &archive_stat) < 0))
-    {
-      int saved_errno = errno;
+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))
+                  * BLOCKSIZE;

 
 

-      if (backed_up_flag)
-       undo_last_backup ();
-      FATAL_ERROR ((0, saved_errno, "%s", archive_name_array[0]));
-    }
+  if (size <= skipped)
+    return 0;

 
 

-#if !MSDOS
+  /* Compute number of records to skip */
+  nrec = (size - skipped) / record_size;
+  if (nrec == 0)
+    return 0;
+  offset = rmtlseek (archive, nrec * record_size, SEEK_CUR);
+  if (offset < 0)
+    return offset;

 
 

-  /* 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
-          && S_ISCHR (dev_null_stat.st_mode)
-          && archive_stat.st_rdev == dev_null_stat.st_rdev));
-  }
+  if (offset % record_size)
+    FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary")));

 
 

-  if (!_isrmt (archive) && S_ISREG (archive_stat.st_mode))
-    {
-      ar_dev = archive_stat.st_dev;
-      ar_ino = archive_stat.st_ino;
-    }
-  else
-    ar_dev = 0;
+  /* Convert to number of records */
+  offset /= BLOCKSIZE;
+  /* Compute number of skipped blocks */
+  nblk = offset - start;

 
 

-#endif /* not MSDOS */
+  /* Update buffering info */
+  records_read += nblk / blocking_factor;
+  record_start_block = offset - blocking_factor;
+  current_block = record_end;

 
 

-#if MSDOS
-  setmode (archive, O_BINARY);
-#endif
+  return nblk;
+}

 
 

-  switch (access)
+/* Close the archive file.  */
+void
+close_archive (void)
+{
+  if (time_to_start_writing || access_mode == ACCESS_WRITE)

     {
     {

-    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 */
+      flush_archive ();
+      if (current_block > record_start)
+        flush_archive ();
+    }

 
 

-      if (volume_label_option)
-       {
-         union block *label = find_next_block ();
-
-         if (!label)
-           FATAL_ERROR ((0, 0, _("Archive not labelled to match `%s'"),
-                         volume_label_option));
-         if (!check_label_pattern (label))
-           FATAL_ERROR ((0, 0, _("Volume `%s' does not match `%s'"),
-                         label->header.name, volume_label_option));
-       }
-      break;
+  compute_duration ();
+  if (verify_option)
+    verify_volume ();

 
 

-    case ACCESS_WRITE:
-      if (volume_label_option)
-       {
-         memset ((void *) 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);
+  if (rmtclose (archive) != 0)
+    close_error (*archive_name_cursor);

 
 

-         assign_string (&current_file_name, record_start->header.name);
+  sys_wait_for_child (child_pid, hit_eof);

 
 

-         record_start->header.typeflag = GNUTYPE_VOLHDR;
-         TIME_TO_CHARS (time (0), record_start->header.mtime);
-         finish_header (record_start);
-#if 0
-         current_block++;
-#endif
-       }
-      break;
-    }
+  tar_stat_destroy (&current_stat_info);
+  free (record_buffer[0]);
+  free (record_buffer[1]);
+  bufmap_free (NULL);

 }
 
 }
 

-/*--------------------------------------.
-| Perform a write to flush the buffer.  |
-`--------------------------------------*/
-
+/* Called to initialize the global volume number.  */

 void
 void

-flush_write (void)
+init_volume_number (void)

 {
 {

-  int copy_back;
-  ssize_t status;
-
-  if (checkpoint_option && !(++checkpoint % 10))
-    WARN ((0, 0, _("Write checkpoint %d"), checkpoint));
+  FILE *file = fopen (volno_file_option, "r");

 
 

-  if (tape_length_option && tape_length_option <= bytes_written)
+  if (file)

     {
     {

-      errno = ENOSPC;          /* FIXME: errno should be read-only */
-      status = 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 (dev_null_output)
-    status = record_size;
-  else
-    status = write_archive_buffer ();
-  if (status != record_size && !multi_volume_option)
-    write_error (status);
+  else if (errno != ENOENT)
+    open_error (volno_file_option);
+}

 
 

-  if (status > 0)
-    bytes_written += status;
+/* Called to write out the closing global volume number.  */
+void
+closeout_volume_number (void)
+{
+  FILE *file = fopen (volno_file_option, "w");

 
 

-  if (status == record_size)
+  if (file)

     {
     {

-      if (multi_volume_option)
-       {
-         char *cursor;
+      fprintf (file, "%d\n", global_volno);
+      if (ferror (file))
+        write_error (volno_file_option);
+      if (fclose (file) != 0)
+        close_error (volno_file_option);
+    }
+  else
+    open_error (volno_file_option);
+}

 
 

-         if (!save_name)
-           {
-             real_s_name[0] = '\0';
-             real_s_totsize = 0;
-             real_s_sizeleft = 0;
-             return;
-           }
+\f
+static void
+increase_volume_number (void)
+{
+  global_volno++;
+  if (global_volno < 0)
+    FATAL_ERROR ((0, 0, _("Volume number overflow")));
+  volno++;
+}

 
 

-         cursor = save_name + FILESYSTEM_PREFIX_LEN (save_name);
-         while (*cursor == '/')
-           cursor++;
+static void
+change_tape_menu (FILE *read_file)
+{
+  char *input_buffer = NULL;
+  size_t size = 0;
+  bool stop = false;

 
 

-         strcpy (real_s_name, cursor);
-         real_s_totsize = save_totsize;
-         real_s_sizeleft = save_sizeleft;
-       }
-      return;
+  while (!stop)
+    {
+      fputc ('\007', stderr);
+      fprintf (stderr,
+               _("Prepare volume #%d for %s and hit return: "),
+               global_volno + 1, quote (*archive_name_cursor));
+      fflush (stderr);
+
+      if (getline (&input_buffer, &size, read_file) <= 0)
+        {
+          WARN ((0, 0, _("EOF where user reply was expected")));
+
+          if (subcommand_option != EXTRACT_SUBCOMMAND
+              && subcommand_option != LIST_SUBCOMMAND
+              && subcommand_option != DIFF_SUBCOMMAND)
+            WARN ((0, 0, _("WARNING: Archive is incomplete")));
+
+          fatal_exit ();
+        }
+
+      if (input_buffer[0] == '\n'
+          || input_buffer[0] == 'y'
+          || input_buffer[0] == 'Y')
+        break;
+
+      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\
+ y or newline  Continue operation\n"));
+            if (!restrict_option)
+              fprintf (stderr, _(" !             Spawn a subshell\n"));
+            fprintf (stderr, _(" ?             Print this list\n"));
+          }
+          break;
+
+        case 'q':
+          /* Quit.  */
+
+          WARN ((0, 0, _("No new volume; exiting.\n")));
+
+          if (subcommand_option != EXTRACT_SUBCOMMAND
+              && subcommand_option != LIST_SUBCOMMAND
+              && subcommand_option != DIFF_SUBCOMMAND)
+            WARN ((0, 0, _("WARNING: Archive is incomplete")));
+
+          fatal_exit ();
+
+        case 'n':
+          /* Get new file name.  */
+
+          {
+            char *name;
+            char *cursor;
+
+            for (name = input_buffer + 1;
+                 *name == ' ' || *name == '\t';
+                 name++)
+              ;
+
+            for (cursor = name; *cursor && *cursor != '\n'; cursor++)
+              ;
+            *cursor = '\0';
+
+            if (name[0])
+              {
+                /* FIXME: the following allocation is never reclaimed.  */
+                *archive_name_cursor = xstrdup (name);
+                stop = true;
+              }
+            else
+              fprintf (stderr, "%s",
+                       _("File name not specified. Try again.\n"));
+          }
+          break;
+
+        case '!':
+          if (!restrict_option)
+            {
+              sys_spawn_shell ();
+              break;
+            }
+          /* FALL THROUGH */
+
+        default:
+          fprintf (stderr, _("Invalid input. Type ? for help.\n"));
+        }

     }
     }

+  free (input_buffer);
+}

 
 

-  /* We're multivol.  Panic if we didn't get the right kind of response.  */
+/* 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)
+{
+  static FILE *read_file;
+  static int looped;
+  int prompt;

 
 

-  /* ENXIO is for the UNIX PC.  */
-  if (status < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO)
-    write_error (status);
+  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 error indicates a short write, we just move to the next tape.  */
+  if (now_verifying)
+    return false;
+  if (verify_option)
+    verify_volume ();

 
 

-  if (!new_volume (ACCESS_WRITE))
-    return;
+  assign_string (&volume_label, NULL);
+  assign_string (&continued_file_name, NULL);
+  continued_file_size = continued_file_offset = 0;
+  current_block = record_start;

 
 

-  if (totals_option)
-    prev_written += bytes_written;
-  bytes_written = 0;
+  if (rmtclose (archive) != 0)
+    close_error (*archive_name_cursor);

 
 

-  if (volume_label_option && real_s_name[0])
-    {
-      copy_back = 2;
-      record_start -= 2;
-    }
-  else if (volume_label_option || real_s_name[0])
+  archive_name_cursor++;
+  if (archive_name_cursor == archive_name_array + archive_names)

     {
     {

-      copy_back = 1;
-      record_start--;
+      archive_name_cursor = archive_name_array;
+      looped = 1;

     }
     }

-  else
-    copy_back = 0;
+  prompt = looped;

 
 

-  if (volume_label_option)
+ tryagain:
+  if (prompt)

     {
     {

-      memset ((void *) record_start, 0, BLOCKSIZE);
-      sprintf (record_start->header.name, "%s Volume %d", volume_label_option, volno);
-      TIME_TO_CHARS (time (0), record_start->header.mtime);
-      record_start->header.typeflag = GNUTYPE_VOLHDR;
-      finish_header (record_start);
+      /* We have to prompt from now on.  */
+
+      if (info_script_option)
+        {
+          if (volno_file_option)
+            closeout_volume_number ();
+          if (sys_exec_info_script (archive_name_cursor, global_volno+1))
+            FATAL_ERROR ((0, 0, _("%s command failed"),
+                          quote (info_script_option)));
+        }
+      else
+        change_tape_menu (read_file);

     }
 
     }
 

-  if (real_s_name[0])
+  if (strcmp (archive_name_cursor[0], "-") == 0)

     {
     {

-      int tmp;
-
-      if (volume_label_option)
-       record_start++;
-
-      memset ((void *) record_start, 0, BLOCKSIZE);
+      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);
+       guess_seekable_archive ();
+        break;

 
 

-      /* 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.  */
+      case ACCESS_WRITE:
+        if (backup_option)
+          maybe_backup_file (*archive_name_cursor, 1);
+        archive = rmtcreat (*archive_name_cursor, MODE_RW,
+                            rsh_command_option);
+        break;

 
 

-      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;
+      case ACCESS_UPDATE:
+        archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW,
+                           rsh_command_option);
+        break;
+      }

 
 

-      if (volume_label_option)
-       record_start--;
+  if (archive < 0)
+    {
+      open_warn (*archive_name_cursor);
+      if (!verify_option && mode == ACCESS_WRITE && backup_option)
+        undo_last_backup ();
+      prompt = 1;
+      goto tryagain;

     }
 
     }
 

-  status = write_archive_buffer ();
-  if (status != record_size)
-    write_error (status);
-
-  bytes_written += status;
+  SET_BINARY_MODE (archive);

 
 

-  if (copy_back)
-    {
-      record_start += copy_back;
-      memcpy ((void *) current_block,
-             (void *) (record_start + blocking_factor - copy_back),
-             (size_t) (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)
-       real_s_name[0] = '\0';
-      else
-       {
-         char *cursor = save_name + FILESYSTEM_PREFIX_LEN (save_name);
+  return true;
+}

 
 

-         while (*cursor == '/')
-           cursor++;
+static bool
+read_header0 (struct tar_stat_info *info)
+{
+  enum read_header rc;

 
 

-         strcpy (real_s_name, cursor);
-         real_s_sizeleft = save_sizeleft;
-         real_s_totsize = save_totsize;
-       }
-      copy_back = 0;
+  tar_stat_init (info);
+  rc = read_header (&current_header, info, read_header_auto);
+  if (rc == HEADER_SUCCESS)
+    {
+      set_next_block_after (current_header);
+      return true;

     }
     }

+  ERROR ((0, 0, _("This does not look like a tar archive")));
+  return false;

 }
 
 }
 

-/*---------------------------------------------------------------------.
-| 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
-write_error (ssize_t status)
+static bool
+try_new_volume (void)

 {
 {

-  int saved_errno = errno;
+  size_t status;
+  union block *header;
+  enum access_mode acc;

 
 

-  /* It might be useful to know how much was written before the error
-     occured.  Beware that mere printing maybe change errno value.  */
-  if (totals_option)
-    print_total_written ();
+  switch (subcommand_option)
+    {
+    case APPEND_SUBCOMMAND:
+    case CAT_SUBCOMMAND:
+    case UPDATE_SUBCOMMAND:
+      acc = ACCESS_UPDATE;
+      break;

 
 

-  if (status < 0)
-    FATAL_ERROR ((0, saved_errno, _("Cannot write to %s"),
-                 *archive_name_cursor));
-  else
-    FATAL_ERROR ((0, 0, _("Only wrote %lu of %lu bytes to %s"),
-                 (unsigned long) status, (unsigned long) record_size,
-                 *archive_name_cursor));
-}
+    default:
+      acc = ACCESS_READ;
+      break;
+    }

 
 

-/*-------------------------------------------------------------------.
-| Handle read errors on the archive.  If the read should be retried, |
-| returns to the caller.                                            |
-`-------------------------------------------------------------------*/
+  if (!new_volume (acc))
+    return true;

 
 

-static void
-read_error (void)
-{
-  WARN ((0, errno, _("Read error on %s"), *archive_name_cursor));
+  while ((status = rmtread (archive, record_start->buffer, record_size))
+         == SAFE_READ_ERROR)
+    archive_read_error ();

 
 

-  if (record_start_block == 0)
-    FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
+  if (status != record_size)
+    short_read (status);

 
 

-  /* Read error in mid archive.  We retry up to READ_ERROR_MAX times and
-     then give up on reading the archive.  */
+  header = find_next_block ();
+  if (!header)
+    return false;

 
 

-  if (read_error_count++ > READ_ERROR_MAX)
-    FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
-  return;
-}
+  switch (header->header.typeflag)
+    {
+    case XGLTYPE:
+      {
+       tar_stat_init (&dummy);
+       if (read_header (&header, &dummy, read_header_x_global)
+           != HEADER_SUCCESS_EXTENDED)
+         {
+           ERROR ((0, 0, _("This does not look like a tar archive")));
+           return false;
+         }

 
 

-/*-------------------------------------.
-| Perform a read to flush the buffer.  |
-`-------------------------------------*/
+        xheader_decode (&dummy); /* decodes values from the global header */
+        tar_stat_destroy (&dummy);

 
 

-void
-flush_read (void)
-{
-  ssize_t status;              /* result from system call */
-  size_t left;                 /* bytes left */
-  char *more;                  /* pointer to next byte to read */
+       /* 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
+          of a PAX header. This is incorrect, and should be fixed
+           in the future versions. In the meantime we must be
+          prepared to correctly list and extract such archives.

 
 

-  if (checkpoint_option && !(++checkpoint % 10))
-    WARN ((0, 0, _("Read checkpoint %d"), checkpoint));
+          If this happens, the following call to read_header returns
+          HEADER_FAILURE, which is ignored.

 
 

-  /* Clear the count of errors.  This only applies to a single call to
-     flush_read.  */
+          See also tests/multiv07.at */

 
 

-  read_error_count = 0;                /* clear error count */
+       switch (read_header (&header, &dummy, read_header_auto))
+         {
+         case HEADER_SUCCESS:
+           set_next_block_after (header);
+           break;

 
 

-  if (write_archive_to_stdout && record_start_block != 0)
-    {
-      status = write_archive_buffer ();
-      if (status != record_size)
-       write_error (status);
-    }
-  if (multi_volume_option)
-    {
-      if (save_name)
-       {
-         char *cursor = save_name + FILESYSTEM_PREFIX_LEN (save_name);
+         case HEADER_FAILURE:
+           break;

 
 

-         while (*cursor == '/')
-           cursor++;
+         default:
+           ERROR ((0, 0, _("This does not look like a tar archive")));
+           return false;
+         }
+        break;
+      }

 
 

-         strcpy (real_s_name, cursor);
-         real_s_sizeleft = save_sizeleft;
-         real_s_totsize = save_totsize;
-       }
-      else
-       {
-         real_s_name[0] = '\0';
-         real_s_totsize = 0;
-         real_s_sizeleft = 0;
-       }
-    }
+    case GNUTYPE_VOLHDR:
+      if (!read_header0 (&dummy))
+        return false;
+      tar_stat_destroy (&dummy);
+      assign_string (&volume_label, current_header->header.name);
+      set_next_block_after (header);
+      header = find_next_block ();
+      if (header->header.typeflag != GNUTYPE_MULTIVOL)
+        break;
+      /* FALL THROUGH */
+
+    case GNUTYPE_MULTIVOL:
+      if (!read_header0 (&dummy))
+        return false;
+      tar_stat_destroy (&dummy);
+      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);
+      break;

 
 

-error_loop:
-  status = rmtread (archive, record_start->buffer, record_size);
-  if (status == record_size)
-    return;
+    default:
+      break;
+    }

 
 

-  if ((status == 0
-       || (status < 0 && errno == ENOSPC)
-       || (status > 0 && !read_full_records_option))
-      && multi_volume_option)
+  if (bufmap_head)

     {
     {

-      union block *cursor;
+      uintmax_t s;
+      if (!continued_file_name
+          || strcmp (continued_file_name, bufmap_head->file_name))
+        {
+          if ((archive_format == GNU_FORMAT || archive_format == OLDGNU_FORMAT)
+              && 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 (bufmap_head->file_name)));
+          else
+            {
+              WARN ((0, 0, _("%s is not continued on this volume"),
+                     quote (bufmap_head->file_name)));
+              return false;
+            }
+        }
+
+      s = continued_file_size + continued_file_offset;
+
+      if (bufmap_head->sizetotal != 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 (bufmap_head->sizetotal, totsizebuf),
+                 STRINGIFY_BIGINT (continued_file_size, s1buf),
+                 STRINGIFY_BIGINT (continued_file_offset, s2buf)));
+          return false;
+        }
+
+      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 (bufmap_head->sizetotal, totsizebuf),
+                 STRINGIFY_BIGINT (bufmap_head->sizeleft, s1buf),
+                 STRINGIFY_BIGINT (continued_file_offset, s2buf)));
+
+          return false;
+        }
+    }

 
 

-    try_volume:
-      switch (subcommand_option)
-       {
-       case APPEND_SUBCOMMAND:
-       case CAT_SUBCOMMAND:
-       case UPDATE_SUBCOMMAND:
-         if (!new_volume (ACCESS_UPDATE))
-           return;
-         break;
-
-       default:
-         if (!new_volume (ACCESS_READ))
-           return;
-         break;
-       }
+  increase_volume_number ();
+  return true;
+}

 
 

-    vol_error:
-      status = rmtread (archive, record_start->buffer, record_size);
-      if (status < 0)
-       {
-         read_error ();
-         goto vol_error;
-       }
-      if (status != record_size)
-       goto short_read;
+\f
+#define VOLUME_TEXT " Volume "
+#define VOLUME_TEXT_LEN (sizeof VOLUME_TEXT - 1)

 
 

-      cursor = record_start;
+char *
+drop_volume_label_suffix (const char *label)
+{
+  const char *p;
+  size_t len = strlen (label);

 
 

-      if (cursor->header.typeflag == GNUTYPE_VOLHDR)
-       {
-         if (volume_label_option)
-           {
-             if (!check_label_pattern (cursor))
-               {
-                 WARN ((0, 0, _("Volume `%s' does not match `%s'"),
-                        cursor->header.name, volume_label_option));
-                 volno--;
-                 global_volno--;
-                 goto try_volume;
-               }
-           }
-         if (verbose_option)
-           fprintf (stdlis, _("Reading %s\n"), cursor->header.name);
-         cursor++;
-       }
-      else if (volume_label_option)
-       WARN ((0, 0, _("WARNING: No volume header")));
+  if (len < 1)
+    return NULL;

 
 

-      if (real_s_name[0])
+  for (p = label + len - 1; p > label && isdigit ((unsigned char) *p); p--)
+    ;
+  if (p > label && p - (VOLUME_TEXT_LEN - 1) > label)
+    {
+      p -= VOLUME_TEXT_LEN - 1;
+      if (memcmp (p, VOLUME_TEXT, VOLUME_TEXT_LEN) == 0)

        {
        {

-         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"),
-                    real_s_name));
-             volno--;
-             global_volno--;
-             goto try_volume;
-           }
-         s1 = UINTMAX_FROM_CHARS (cursor->header.size);
-         s2 = UINTMAX_FROM_CHARS (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)"),
-                    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_CHARS (cursor->oldgnu_header.offset))
-           {
-             WARN ((0, 0, _("This volume is out of sequence")));
-             volno--;
-             global_volno--;
-             goto try_volume;
-           }
-         cursor++;
+         char *s = xmalloc ((len = p - label) + 1);
+         memcpy (s, label, len);
+         s[len] = 0;
+         return s;

        }
        }

-      current_block = cursor;
-      return;
-    }
-  else if (status < 0)
-    {
-      read_error ();
-      goto error_loop;         /* try again */

     }
 
     }
 

-short_read:
-  more = record_start->buffer + status;
-  left = record_size - status;
+  return NULL;
+}

 
 

-again:
-  if (left % BLOCKSIZE == 0)
-    {
-      /* FIXME: for size=0, multi-volume support.  On the first record, warn
-        about the problem.  */
+/* 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
+   multi-volume mode.  */
+static bool
+check_label_pattern (const char *label)
+{
+  char *string;
+  bool result = false;

 
 

-      if (!read_full_records_option && verbose_option
-         && record_start_block == 0 && status > 0)
-       WARN ((0, 0, _("Record size = %lu blocks"),
-              (unsigned long) (status / BLOCKSIZE)));
+  if (fnmatch (volume_label_option, label, 0) == 0)
+    return true;

 
 

-      record_end = record_start + (record_size - left) / BLOCKSIZE;
+  if (!multi_volume_option)
+    return false;

 
 

-      return;
+  string = drop_volume_label_suffix (label);
+  if (string)
+    {
+      result = fnmatch (string, volume_label_option, 0) == 0;
+      free (string);

     }
     }

-  if (read_full_records_option)
+  return result;
+}
+
+/* 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)
+{
+  if (!volume_label)

     {
     {

-      /* User warned us about this.  Fix up.  */
+      union block *label = find_next_block ();

 
 

-      if (left > 0)
+      if (!label)
+       FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
+                     quote (volume_label_option)));
+      if (label->header.typeflag == GNUTYPE_VOLHDR)

        {
        {

-       error2loop:
-         status = rmtread (archive, more, left);
-         if (status < 0)
+         if (memchr (label->header.name, '\0', sizeof label->header.name))
+           assign_string (&volume_label, label->header.name);
+         else

            {
            {

-             read_error ();
-             goto error2loop;  /* try again */
+             volume_label = xmalloc (sizeof (label->header.name) + 1);
+             memcpy (volume_label, label->header.name,
+                     sizeof (label->header.name));
+             volume_label[sizeof (label->header.name)] = 0;

            }
            }

-         if (status == 0)
-           FATAL_ERROR ((0, 0, _("Archive %s EOF not on block boundary"),
-                         *archive_name_cursor));
-         left -= status;
-         more += status;
-         goto again;
+       }
+      else if (label->header.typeflag == XGLTYPE)
+       {
+         struct tar_stat_info st;
+         tar_stat_init (&st);
+         xheader_read (&st.xhdr, label,
+                       OFF_FROM_HEADER (label->header.size));
+         xheader_decode (&st);
+         tar_stat_destroy (&st);

        }
     }
        }
     }

-  else
-    FATAL_ERROR ((0, 0, _("Only read %lu bytes from archive %s"),
-                 (unsigned long) status, *archive_name_cursor));
-}

 
 

-/*-----------------------------------------------.
-| Flush the current buffer to/from the archive.         |
-`-----------------------------------------------*/
+  if (!volume_label)
+    FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
+                  quote (volume_label_option)));

 
 

-void
-flush_archive (void)
-{
-  record_start_block += record_end - record_start;
-  current_block = record_start;
-  record_end = record_start + blocking_factor;
+  if (!check_label_pattern (volume_label))
+    FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
+                  quote_n (0, volume_label),
+                  quote_n (1, volume_label_option)));
+}

 
 

-  if (access_mode == ACCESS_READ && time_to_start_writing)
+/* 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", &dummy, str);
+  else

     {
     {

-      access_mode = ACCESS_WRITE;
-      time_to_start_writing = 0;
+      union block *label = find_next_block ();

 
 

-      if (file_to_switch_to >= 0)
-       {
-         int status = rmtclose (archive);
+      memset (label, 0, BLOCKSIZE);

 
 

-         if (status < 0)
-           WARN ((0, errno, _("WARNING: Cannot close %s (%d, %d)"),
-                  *archive_name_cursor, archive, status));
+      strcpy (label->header.name, str);
+      assign_string (&current_stat_info.file_name,
+                     label->header.name);
+      current_stat_info.had_trailing_slash =
+        strip_trailing_slashes (current_stat_info.file_name);

 
 

-         archive = file_to_switch_to;
-       }
-      else
-       backspace_output ();
+      label->header.typeflag = GNUTYPE_VOLHDR;
+      TIME_TO_CHARS (start_time.tv_sec, label->header.mtime);
+      finish_header (&current_stat_info, label, -1);
+      set_next_block_after (label);

     }
     }

+}

 
 

-  switch (access_mode)
-    {
-    case ACCESS_READ:
-      flush_read ();
-      break;
+#define VOL_SUFFIX "Volume"

 
 

-    case ACCESS_WRITE:
-      flush_write ();
-      break;
+/* 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);
+}

 
 

-    case ACCESS_UPDATE:
-      abort ();
+static void
+add_chunk_header (struct bufmap *map)
+{
+  if (archive_format == POSIX_FORMAT)
+    {
+      off_t block_ordinal;
+      union block *blk;
+      struct tar_stat_info st;
+
+      memset (&st, 0, sizeof st);
+      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",
+                                               volno);
+      st.file_name = st.orig_file_name;
+      st.archive_file_size = st.stat.st_size = map->sizeleft;
+
+      block_ordinal = current_block_ordinal ();
+      blk = start_header (&st);
+      if (!blk)
+        abort (); /* FIXME */
+      finish_header (&st, blk, block_ordinal);
+      free (st.orig_file_name);

     }
 }
 
     }
 }
 

-/*-------------------------------------------------------------------------.
-| Backspace the archive descriptor by one record worth.  If its a tape,           |
-| MTIOCTOP will work.  If its something else, we try to seek on it.  If we |
-| can't seek, we lose!                                                    |
-`-------------------------------------------------------------------------*/

 
 

+/* Add a volume label to the current archive */

 static void
 static void

-backspace_output (void)
+write_volume_label (void)

 {
 {

-#ifdef MTIOCTOP
-  {
-    struct mtop operation;
+  if (multi_volume_option)
+    add_volume_label ();
+  else
+    _write_volume_label (volume_label_option);
+}

 
 

-    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
+/* Write GNU multi-volume header */
+static void
+gnu_add_multi_volume_header (struct bufmap *map)
+{
+  int tmp;
+  union block *block = find_next_block ();

 
 

-  {
-    off_t position = rmtlseek (archive, (off_t) 0, SEEK_CUR);
+  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 (map->file_name)));

 
 

-    /* Seek back to the beginning of this record and start writing there.  */
+  memset (block, 0, BLOCKSIZE);

 
 

-    position -= record_size;
-    if (rmtlseek (archive, position, SEEK_SET) != position)
-      {
-       /* Lseek failed.  Try a different method.  */
+  strncpy (block->header.name, map->file_name, NAME_FIELD_SIZE);
+  block->header.typeflag = GNUTYPE_MULTIVOL;

 
 

-       WARN ((0, 0, _("\
-Could not backspace archive file; it may be unreadable without -i")));
+  OFF_TO_CHARS (map->sizeleft, block->header.size);
+  OFF_TO_CHARS (map->sizetotal - map->sizeleft,
+                block->oldgnu_header.offset);

 
 

-       /* Replace the first part of the record with NULs.  */
+  tmp = verbose_option;
+  verbose_option = 0;
+  finish_header (&current_stat_info, block, -1);
+  verbose_option = tmp;
+  set_next_block_after (block);
+}

 
 

-       if (record_start->buffer != output_start)
-         memset (record_start->buffer, 0,
-                 (size_t) (output_start - record_start->buffer));
-      }
-  }
+/* Add a multi volume header to the current archive. The exact header format
+   depends on the archive format. */
+static void
+add_multi_volume_header (struct bufmap *map)
+{
+  if (archive_format == POSIX_FORMAT)
+    {
+      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 (map);

 }
 
 }
 

-/*-------------------------.
-| Close the archive file.  |
-`-------------------------*/
+\f
+/* Low-level flush functions */

 
 

-void
-close_archive (void)
+/* Simple flush read (no multi-volume or label extensions) */
+static void
+simple_flush_read (void)

 {
 {

-  if (time_to_start_writing || access_mode == ACCESS_WRITE)
-    flush_archive ();
+  size_t status;                /* result from system call */

 
 

-#if !MSDOS
+  checkpoint_run (false);

 
 

-  /* 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.  */
+  /* Clear the count of errors.  This only applies to a single call to
+     flush_read.  */

 
 

-  if (access_mode == ACCESS_READ
-      && ! _isrmt (archive)
-      && S_ISFIFO (archive_stat.st_mode))
-    while (rmtread (archive, record_start->buffer, record_size) > 0)
-      continue;
-#endif
+  read_error_count = 0;         /* clear error count */

 
 

-  if (! _isrmt (archive) && subcommand_option == DELETE_SUBCOMMAND)
+  if (write_archive_to_stdout && record_start_block != 0)

     {
     {

-#if MSDOS
-      int status = write (archive, "", 0);
-#else
-      off_t pos = lseek (archive, (off_t) 0, SEEK_CUR);
-      int status = pos < 0 ? -1 : ftruncate (archive, pos);
-#endif
-      if (status != 0)
-       WARN ((0, errno, _("WARNING: Cannot truncate %s"),
-              *archive_name_cursor));
+      archive = STDOUT_FILENO;
+      status = sys_write_archive_buffer ();
+      archive = STDIN_FILENO;
+      if (status != record_size)
+        archive_write_error (status);

     }
     }

-  if (verify_option)
-    verify_volume ();

 
 

-  {
-    int status = rmtclose (archive);
-
-    if (status < 0)
-      WARN ((0, errno, _("WARNING: Cannot close %s (%d, %d)"),
-            *archive_name_cursor, archive, status));
-  }
+  for (;;)
+    {
+      status = rmtread (archive, record_start->buffer, record_size);
+      if (status == record_size)
+        {
+          records_read++;
+          return;
+        }
+      if (status == SAFE_READ_ERROR)
+        {
+          archive_read_error ();
+          continue;             /* try again */
+        }
+      break;
+    }
+  short_read (status);
+}

 
 

-#if !MSDOS
+/* Simple flush write (no multi-volume or label extensions) */
+static void
+simple_flush_write (size_t level __attribute__((unused)))
+{
+  ssize_t status;

 
 

-  if (child_pid)
+  status = _flush_write ();
+  if (status != record_size)
+    archive_write_error (status);
+  else

     {
     {

-      WAIT_T wait_status;
-      pid_t child;
+      records_written++;
+      bytes_written += status;
+    }
+}

 
 

-      /* Loop waiting for the right child to die, or for no more kids.  */
+\f
+/* GNU flush functions. These support multi-volume and archive labels in
+   GNU and PAX archive formats. */

 
 

-      while ((child = wait (&wait_status), child != child_pid)
-            && child != -1)
-       continue;
+static void
+_gnu_flush_read (void)
+{
+  size_t status;                /* result from system call */

 
 

-      if (child != -1)
-       {
-         if (WIFSIGNALED (wait_status)
-#if 0
-             && !WIFSTOPPED (wait_status)
-#endif
-             )
-           {
-             /* SIGPIPE is OK, everything else is a problem.  */
+  checkpoint_run (false);

 
 

-             if (WTERMSIG (wait_status) != SIGPIPE)
-               ERROR ((0, 0, _("Child died with signal %d%s"),
-                       WTERMSIG (wait_status),
-                       WCOREDUMP (wait_status) ? _(" (core dumped)") : ""));
-           }
-         else
-           {
-             /* Child voluntarily terminated -- but why?  /bin/sh returns
-                SIGPIPE + 128 if its child, then do nothing.  */
+  /* Clear the count of errors.  This only applies to a single call to
+     flush_read.  */

 
 

-             if (WEXITSTATUS (wait_status) != (SIGPIPE + 128)
-                 && WEXITSTATUS (wait_status))
-               ERROR ((0, 0, _("Child returned status %d"),
-                       WEXITSTATUS (wait_status)));
-           }
-       }
+  read_error_count = 0;         /* clear error count */
+
+  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);

     }
     }

-#endif /* !MSDOS */
-
-  if (current_file_name)
-    free (current_file_name);
-  if (current_link_name)
-    free (current_link_name);
-  if (save_name)
-    free (save_name);
-  free (multi_volume_option ? record_start - 2 : record_start);
+
+  for (;;)
+    {
+      status = rmtread (archive, record_start->buffer, record_size);
+      if (status == record_size)
+        {
+          records_read++;
+          return;
+        }
+
+      /* 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 ())
+            ;
+         if (current_block == record_end)
+           /* Necessary for blocking_factor == 1 */
+           flush_archive();
+          return;
+        }
+      else if (status == SAFE_READ_ERROR)
+        {
+          archive_read_error ();
+          continue;
+        }
+      break;
+    }
+  short_read (status);

 }
 
 }
 

-/*------------------------------------------------.
-| Called to initialize the global volume number.  |
-`------------------------------------------------*/
+static void
+gnu_flush_read (void)
+{
+  flush_read_ptr = simple_flush_read; /* Avoid recursion */
+  _gnu_flush_read ();
+  flush_read_ptr = gnu_flush_read;
+}

 
 

-void
-init_volume_number (void)
+static void
+_gnu_flush_write (size_t buffer_level)

 {
 {

-  FILE *file = fopen (volno_file_option, "r");
+  ssize_t status;
+  union block *header;
+  char *copy_ptr;
+  size_t copy_size;
+  size_t bufsize;
+  struct bufmap *map;

 
 

-  if (file)
+  status = _flush_write ();
+  if (status != record_size && !multi_volume_option)
+    archive_write_error (status);
+  else

     {
     {

-      fscanf (file, "%d", &global_volno);
-      if (fclose (file) == EOF)
-       ERROR ((0, errno, "%s", volno_file_option));
+      if (status)
+        records_written++;
+      bytes_written += status;

     }
     }

-  else if (errno != ENOENT)
-    ERROR ((0, errno, "%s", volno_file_option));
-}

 
 

-/*-------------------------------------------------------.
-| Called to write out the closing global volume number.         |
-`-------------------------------------------------------*/
+  if (status == record_size)
+    {
+      return;
+    }

 
 

-void
-closeout_volume_number (void)
-{
-  FILE *file = fopen (volno_file_option, "w");
+  map = bufmap_locate (status);

 
 

-  if (file)
+  if (status % BLOCKSIZE)

     {
     {

-      fprintf (file, "%d\n", global_volno);
-      if (fclose (file) == EOF)
-       ERROR ((0, errno, "%s", volno_file_option));
+      ERROR ((0, 0, _("write did not end on a block boundary")));
+      archive_write_error (status);

     }
     }

-  else
-    ERROR ((0, errno, "%s", volno_file_option));
-}

 
 

-/*-----------------------------------------------------------------------.
-| We've hit the end of the old volume.  Close it and open the next one.         |
-| Return nonzero on success.                                            |
-`-----------------------------------------------------------------------*/
+  /* In multi-volume mode. */
+  /* ENXIO is for the UNIX PC.  */
+  if (status < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO)
+    archive_write_error (status);

 
 

-static int
-new_volume (enum access_mode access)
-{
-  static FILE *read_file = NULL;
-  static int looped = 0;
+  if (!new_volume (ACCESS_WRITE))
+    return;

 
 

-  int status;
+  tar_stat_destroy (&dummy);

 
 

-  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;
+  increase_volume_number ();
+  prev_written += bytes_written;
+  bytes_written = 0;

 
 

-  if (now_verifying)
-    return 0;
-  if (verify_option)
-    verify_volume ();
+  copy_ptr = record_start->buffer + status;
+  copy_size = buffer_level - status;

 
 

-  if (status = rmtclose (archive), status < 0)
-    WARN ((0, errno, _("WARNING: Cannot close %s (%d, %d)"),
-          *archive_name_cursor, archive, status));
+  /* Switch to the next buffer */
+  record_index = !record_index;
+  init_buffer ();

 
 

-  global_volno++;
-  volno++;
-  archive_name_cursor++;
-  if (archive_name_cursor == archive_name_array + archive_names)
-    {
-      archive_name_cursor = archive_name_array;
-      looped = 1;
-    }
+  inhibit_map = 1;

 
 

- tryagain:
-  if (looped)
-    {
-      /* We have to prompt from now on.  */
+  if (volume_label_option)
+    add_volume_label ();

 
 

-      if (info_script_option)
-       {
-         if (volno_file_option)
-           closeout_volume_number ();
-         system (info_script_option);
-       }
-      else
-       while (1)
-         {
-           char input_buffer[80];
-
-           fputc ('\007', stderr);
-           fprintf (stderr,
-                    _("Prepare volume #%d for %s and hit return: "),
-                    global_volno, *archive_name_cursor);
-           fflush (stderr);
-
-           if (fgets (input_buffer, sizeof (input_buffer), read_file) == 0)
-             {
-               fprintf (stderr, _("EOF where user reply was expected"));
-
-               if (subcommand_option != EXTRACT_SUBCOMMAND
-                   && subcommand_option != LIST_SUBCOMMAND
-                   && subcommand_option != DIFF_SUBCOMMAND)
-                 WARN ((0, 0, _("WARNING: Archive is incomplete")));
-
-               apply_delayed_set_stat ();
-               exit (TAREXIT_FAILURE);
-             }
-           if (input_buffer[0] == '\n'
-               || input_buffer[0] == 'y'
-               || input_buffer[0] == 'Y')
-             break;
-
-           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;
-
-             case 'q':
-               /* Quit.  */
-
-               fprintf (stdlis, _("No new volume; exiting.\n"));
-
-               if (subcommand_option != EXTRACT_SUBCOMMAND
-                   && subcommand_option != LIST_SUBCOMMAND
-                   && subcommand_option != DIFF_SUBCOMMAND)
-                 WARN ((0, 0, _("WARNING: Archive is incomplete")));
-
-               apply_delayed_set_stat ();
-               exit (TAREXIT_FAILURE);
-
-             case 'n':
-               /* Get new file name.  */
-
-               {
-                 char *name = &input_buffer[1];
-                 char *cursor;
-
-                 while (*name == ' ' || *name == '\t')
-                   name++;
-                 cursor = name;
-                 while (*cursor && *cursor != '\n')
-                   cursor++;
-                 *cursor = '\0';
-
-                 /* FIXME: the following allocation is never reclaimed.  */
-                 *archive_name_cursor = xstrdup (name);
-               }
-               break;
-
-             case '!':
-#if MSDOS
-               spawnl (P_WAIT, getenv ("COMSPEC"), "-", 0);
-#else /* not MSDOS */
-               switch (fork ())
-                 {
-                 case -1:
-                   WARN ((0, errno, _("Cannot fork!")));
-                   break;
-
-                 case 0:
-                   {
-                     const char *shell = getenv ("SHELL");
-
-                     if (shell == NULL)
-                       shell = "/bin/sh";
-                     execlp (shell, "-sh", "-i", 0);
-                     FATAL_ERROR ((0, errno, _("Cannot exec a shell %s"),
-                                   shell));
-                   }
-
-                 default:
-                   {
-                     WAIT_T wait_status;
-
-                     wait (&wait_status);
-                   }
-                   break;
-                 }
-
-               /* FIXME: I'm not sure if that's all that has to be done
-                  here.  (jk)  */
-
-#endif /* not MSDOS */
-               break;
-             }
-         }
+  if (map)
+    add_multi_volume_header (map);
+
+  write_extended (true, &dummy, find_next_block ());
+  tar_stat_destroy (&dummy);
+
+  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);
+      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 (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;
+static void
+gnu_flush_write (size_t buffer_level)
+{
+  flush_write_ptr = simple_flush_write; /* Avoid recursion */
+  _gnu_flush_write (buffer_level);
+  flush_write_ptr = gnu_flush_write;
+}

 
 

-      case ACCESS_WRITE:
-       if (backup_option)
-         maybe_backup_file (*archive_name_cursor, 1);
-       archive = rmtcreat (*archive_name_cursor, MODE_RW,
-                           rsh_command_option);
-       break;
+void
+flush_read (void)
+{
+  flush_read_ptr ();
+}

 
 

-      case ACCESS_UPDATE:
-       archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW,
-                          rsh_command_option);
-       break;
-      }
+void
+flush_write (void)
+{
+  flush_write_ptr (record_size);
+}

 
 

-  if (archive < 0)
-    {
-      WARN ((0, errno, _("Cannot open %s"), *archive_name_cursor));
-      if (!verify_option && access == ACCESS_WRITE && backup_option)
-       undo_last_backup ();
-      goto tryagain;
-    }
+void
+open_archive (enum access_mode wanted_access)
+{
+  flush_read_ptr = gnu_flush_read;
+  flush_write_ptr = gnu_flush_write;

 
 

-#if MSDOS
-  setmode (archive, O_BINARY);
-#endif
+  _open_archive (wanted_access);
+  switch (wanted_access)
+    {
+    case ACCESS_READ:
+    case ACCESS_UPDATE:
+      if (volume_label_option)
+        match_volume_label ();
+      break;

 
 

-  return 1;
+    case ACCESS_WRITE:
+      records_written = 0;
+      if (volume_label_option)
+        write_volume_label ();
+      break;
+    }
+  set_volume_start_time ();

 }
 }