X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fbuffer.c;h=ab067520f54f9ef5cc05c876e3df3d0b22e14a4d;hb=45ccda119355a1087450039a250359c1d0de0d08;hp=8daf39e0a0dc047ba789376275723784f740358e;hpb=203dea13a40bae5c6d2dfa221036babd0e345ffe;p=chaz%2Ftar diff --git a/src/buffer.c b/src/buffer.c index 8daf39e..95e8a26 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -1,89 +1,67 @@ /* Buffer management for tar. - Copyright 1988, 92, 93, 94, 96, 97, 1999 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 - Free Software Foundation; either version 2, or (at your option) any later - version. - - This program is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General - Public License for more details. - - 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 -#include "system.h" + Copyright 1988, 1992-1994, 1996-1997, 1999-2010, 2013-2014 Free + Software Foundation, Inc. -#include -#include -#ifndef time -time_t time (); -#endif + This file is part of GNU tar. -#if MSDOS -# include -#endif + GNU tar is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. -#if XENIX -# include -#endif + GNU tar is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -#include + You should have received a copy of the GNU General Public License + along with this program. If not, see . -#include "common.h" -#include "rmt.h" + Written by John Gilmore, on 1985-08-25. */ + +#include +#include -#define DEBUG_FORK 0 /* if nonzero, childs are born stopped */ +#include + +#include +#include +#include +#include -#define PREAD 0 /* read file descriptor from pipe() */ -#define PWRITE 1 /* write file descriptor from pipe() */ +#include "common.h" +#include /* 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]*" - /* 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 */ +static 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 */ -/* Where we write list messages (not errors, not interactions) to. Stdout - unless we're writing a pipe, in which case stderr. */ +/* Where we write list messages (not errors, not interactions) to. */ FILE *stdlis; -static void backspace_output PARAMS ((void)); -static int new_volume PARAMS ((enum access_mode)); -static void 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; @@ -92,1599 +70,1931 @@ static pid_t child_pid; 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; + +static void (*flush_write_ptr) (size_t); +static void (*flush_read_ptr) (void); + -/* Functions. */ +char *volume_label; +char *continued_file_name; +uintmax_t continued_file_size; +uintmax_t continued_file_offset; -#if DEBUG_FORK + +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; -} + +/* 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 -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? | -`------------------------------------------------------*/ + +static struct tar_stat_info dummy; 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. | -`-----------------------------------------------------------------------*/ + +/* 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 + +/* Time-related functions */ -/*-------------------------------------------------------. -| Set ARCHIVE for writing, then compressing an archive. | -`-------------------------------------------------------*/ +static 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 -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 */ +double +compute_duration (void) +{ + struct timespec now; + gettime (&now); + duration += ((now.tv_sec - last_stat_time.tv_sec) + + (now.tv_nsec - last_stat_time.tv_nsec) / 1e9); + gettime (&last_stat_time); + return duration; +} -/*---------------------------------------------------------------------. -| 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). | -`---------------------------------------------------------------------*/ + +/* 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 { - struct stat stbuf; + enum compress_type type; + char const *program; + char const *option; +}; + +static struct zip_magic const magic[] = { + { ct_none, 0, 0 }, + { ct_tar, 0, 0 }, + { ct_compress, 2, "\037\235" }, + { ct_gzip, 2, "\037\213" }, + { ct_bzip2, 3, "BZh" }, + { ct_lzip, 4, "LZIP" }, + { ct_lzma, 6, "\xFFLZMA" }, + { ct_lzop, 4, "\211LZO" }, + { ct_xz, 6, "\xFD" "7zXZ" }, +}; + +#define NMAGIC (sizeof(magic)/sizeof(magic[0])) + +static struct zip_program zip_program[] = { + { ct_compress, COMPRESS_PROGRAM, "-Z" }, + { ct_compress, GZIP_PROGRAM, "-z" }, + { ct_gzip, GZIP_PROGRAM, "-z" }, + { ct_bzip2, BZIP2_PROGRAM, "-j" }, + { ct_bzip2, "lbzip2", "-j" }, + { ct_lzip, LZIP_PROGRAM, "--lzip" }, + { ct_lzma, LZMA_PROGRAM, "--lzma" }, + { ct_lzma, XZ_PROGRAM, "-J" }, + { ct_lzop, LZOP_PROGRAM, "--lzop" }, + { ct_xz, XZ_PROGRAM, "-J" }, + { ct_none } +}; + +static struct zip_program const * +find_zip_program (enum compress_type type, int *pstate) +{ + int i; - 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; - - if (pipe (parent_pipe) < 0) - FATAL_ERROR ((0, errno, _("Cannot open pipe"))); + struct zip_program const *zp; - 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; - xdup2 (parent_pipe[PREAD], STDIN_FILENO, _("(child) Pipe to stdin")); - xclose (parent_pipe[PWRITE]); + /* 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! */ - - program_name = _("tar (grandchild)"); + records_read = 0; + record_end = record_start; /* set up for 1st record = # 0 */ - /* Prepare for reblocking the data from the compressor into the archive. */ + return archive; +} + +static int +print_stats (FILE *fp, const char *text, tarlong numbytes) +{ + char abbr[LONGEST_HUMAN_READABLE + 1]; + char rate[LONGEST_HUMAN_READABLE + 1]; + int n = 0; + + int human_opts = human_autoscale | human_base_1024 | human_SI | human_B; + + if (text && text[0]) + n += fprintf (fp, "%s: ", gettext (text)); + return n + fprintf (fp, TARLONG_FORMAT " (%s, %s/s)", + numbytes, + human_readable (numbytes, abbr, human_opts, 1, 1), + (0 < duration && numbytes / duration < (uintmax_t) -1 + ? human_readable (numbytes / duration, rate, human_opts, 1, 1) + : "?")); +} - xdup2 (child_pipe[PREAD], STDIN_FILENO, _("(grandchild) Pipe to stdin")); - xclose (child_pipe[PWRITE]); +/* Format totals to file FP. FORMATS is an array of strings to output + before each data item (bytes read, written, deleted, in that order). + EOR is a delimiter to output after each item (used only if deleting + from the archive), EOL is a delimiter to add at the end of the output + line. */ +int +format_total_stats (FILE *fp, const char **formats, int eor, int eol) +{ + int n; + + switch (subcommand_option) + { + case CREATE_SUBCOMMAND: + case CAT_SUBCOMMAND: + case UPDATE_SUBCOMMAND: + case APPEND_SUBCOMMAND: + n = print_stats (fp, formats[TF_WRITE], + prev_written + bytes_written); + break; - if (strcmp (archive_name_array[0], "-") == 0) - archive = STDOUT_FILENO; - else - archive = rmtcreat (archive_name_array[0], MODE_RW, rsh_command_option); - if (archive < 0) - FATAL_ERROR ((0, errno, _("Cannot open archive %s"), - archive_name_array[0])); + case DELETE_SUBCOMMAND: + { + char buf[UINTMAX_STRSIZE_BOUND]; + n = print_stats (fp, formats[TF_READ], + records_read * record_size); + + fputc (eor, fp); + n++; + + n += print_stats (fp, formats[TF_WRITE], + prev_written + bytes_written); + + fputc (eor, fp); + n++; + + if (formats[TF_DELETED] && formats[TF_DELETED][0]) + n += fprintf (fp, "%s: ", gettext (formats[TF_DELETED])); + n += fprintf (fp, "%s", + STRINGIFY_BIGINT ((records_read - records_skipped) + * record_size + - (prev_written + bytes_written), buf)); + } + break; - /* Let's read out of the stdin pipe and write an archive. */ + case EXTRACT_SUBCOMMAND: + case LIST_SUBCOMMAND: + case DIFF_SUBCOMMAND: + n = print_stats (fp, _(formats[TF_READ]), + records_read * record_size); + break; - while (1) + default: + abort (); + } + if (eol) { - ssize_t status = 0; - char *cursor; - size_t length; - - /* Assemble a record. */ + fputc (eol, fp); + n++; + } + return n; +} - for (length = 0, cursor = record_start->buffer; - length < record_size; - length += status, cursor += status) - { - size_t size = record_size - length; +const char *default_total_format[] = { + N_("Total bytes read"), + /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */ + N_("Total bytes written"), + N_("Total bytes deleted") +}; - if (size < BLOCKSIZE) - size = BLOCKSIZE; - status = safe_read (STDIN_FILENO, cursor, size); - if (status <= 0) - break; - } +void +print_total_stats (void) +{ + format_total_stats (stderr, default_total_format, '\n', '\n'); +} - 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 -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"))); + + tar_stat_destroy (¤t_stat_info); - /* The new born child tar is here! */ + record_index = 0; + init_buffer (); - program_name = _("tar (child)"); + /* 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 + 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; + } + if (verify_option) + archive = rmtopen (archive_name_array[0], O_RDWR | O_CREAT | O_BINARY, + MODE_RW, rsh_command_option); + else + archive = rmtcreat (archive_name_array[0], MODE_RW, + rsh_command_option); + break; - /* 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; - - read_error_count = 0; + case ACCESS_READ: + find_next_block (); /* read it in, check for EOF */ + 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"))); + case ACCESS_UPDATE: + case ACCESS_WRITE: + records_written = 0; + break; + } +} - if (status != count) - { - ERROR ((0, 0, _("Write to compression program short %lu bytes"), - (unsigned long) (count - status))); - count = status; - } +/* Perform a write to flush the buffer. */ +static ssize_t +_flush_write (void) +{ + ssize_t status; - cursor += count; - maximum -= count; - } + 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 (); -#if 0 - close_archive (); -#endif - exit (exit_status); + if (status && multi_volume_option && !inhibit_map) + { + struct bufmap *map = bufmap_locate (status); + if (map) + { + size_t delta = status - map->start * BLOCKSIZE; + if (delta > map->sizeleft) + delta = map->sizeleft; + map->sizeleft -= delta; + if (map->sizeleft == 0) + map = map->next; + bufmap_reset (map, map ? (- map->start) : 0); + } + } + return status; } -#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 + && (warning_option & WARN_RECORD_SIZE) + && record_start_block == 0 && status != 0 + && archive_is_dev ()) + { + unsigned long rsize = status / BLOCKSIZE; + WARN ((0, 0, + ngettext ("Record size = %lu block", + "Record size = %lu blocks", + rsize), + rsize)); + } + + while (left % BLOCKSIZE != 0 + || (left && status && read_full_records)) + { + if (status) + while ((status = rmtread (archive, more, left)) == SAFE_READ_ERROR) + archive_read_error (); - /* 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) */ + if (status == 0) + break; - if (!real_s_name) - real_s_name = (char *) xmalloc (PATH_MAX); - /* FIXME: real_s_name is never freed. */ + if (! read_full_records) + { + unsigned long rest = record_size - left; - save_name = NULL; + FATAL_ERROR ((0, 0, + ngettext ("Unaligned block (%lu byte) in archive", + "Unaligned block (%lu bytes) in archive", + rest), + rest)); + } - if (multi_volume_option) - { - record_start - = (union block *) valloc (record_size + (2 * BLOCKSIZE)); - if (record_start) - record_start += 2; + 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; - /* 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 (¤t_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 (¤t_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 -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; - } + +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 (¤t_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; + +#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 (¤t_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 (¤t_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 -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 (¤t_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. | -`-------------------------*/ + +/* 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)); - } - -#if !MSDOS - - if (child_pid) + for (;;) { - int wait_status; - - while (waitpid (child_pid, &wait_status, 0) == -1) - if (errno != EINTR) - { - ERROR ((0, errno, _("While waiting for child"))); - break; - } - - if (WIFSIGNALED (wait_status)) - { - /* SIGPIPE is OK, everything else is a problem. */ - - if (WTERMSIG (wait_status) != SIGPIPE) - ERROR ((0, 0, _("Child died with signal %d"), - WTERMSIG (wait_status))); - } - else - { - /* Child voluntarily terminated -- but why? /bin/sh returns - SIGPIPE + 128 if its child, then do nothing. */ - - if (WEXITSTATUS (wait_status) - && WEXITSTATUS (wait_status) != (SIGPIPE + 128)) - ERROR ((0, 0, _("Child returned status %d"), - WEXITSTATUS (wait_status))); - } + 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; } -#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); + short_read (status); } -/*------------------------------------------------. -| Called to initialize the global volume number. | -`------------------------------------------------*/ - -void -init_volume_number (void) +/* Simple flush write (no multi-volume or label extensions) */ +static void +simple_flush_write (size_t level __attribute__((unused))) { - FILE *file = fopen (volno_file_option, "r"); + ssize_t status; - if (file) + status = _flush_write (); + if (status != record_size) + archive_write_error (status); + else { - fscanf (file, "%d", &global_volno); - if (fclose (file) == EOF) - ERROR ((0, errno, "%s", volno_file_option)); + 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. | -`-------------------------------------------------------*/ + +/* GNU flush functions. These support multi-volume and archive labels in + GNU and PAX archive formats. */ -void -closeout_volume_number (void) +static void +_gnu_flush_read (void) { - FILE *file = fopen (volno_file_option, "w"); + size_t status; /* result from system call */ - if (file) + checkpoint_run (false); + + /* Clear the count of errors. This only applies to a single call to + flush_read. */ + + read_error_count = 0; /* clear error count */ + + if (write_archive_to_stdout && record_start_block != 0) { - fprintf (file, "%d\n", global_volno); - if (fclose (file) == EOF) - ERROR ((0, errno, "%s", volno_file_option)); + archive = STDOUT_FILENO; + status = sys_write_archive_buffer (); + archive = STDIN_FILENO; + if (status != record_size) + 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. | -`-----------------------------------------------------------------------*/ + 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); +} -static int -new_volume (enum access_mode access) +static void +gnu_flush_read (void) { - static FILE *read_file = NULL; - static int looped = 0; + flush_read_ptr = simple_flush_read; /* Avoid recursion */ + _gnu_flush_read (); + flush_read_ptr = gnu_flush_read; +} - int status; +static void +_gnu_flush_write (size_t buffer_level) +{ + ssize_t status; + union block *header; + char *copy_ptr; + size_t copy_size; + size_t bufsize; + struct bufmap *map; - 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; + status = _flush_write (); + if (status != record_size && !multi_volume_option) + archive_write_error (status); + else + { + if (status) + records_written++; + bytes_written += status; + } - if (now_verifying) - return 0; - if (verify_option) - verify_volume (); + if (status == record_size) + { + return; + } - if (status = rmtclose (archive), status < 0) - WARN ((0, errno, _("WARNING: Cannot close %s (%d, %d)"), - *archive_name_cursor, archive, status)); + map = bufmap_locate (status); - global_volno++; - volno++; - archive_name_cursor++; - if (archive_name_cursor == archive_name_array + archive_names) + if (status % BLOCKSIZE) { - archive_name_cursor = archive_name_array; - looped = 1; + ERROR ((0, 0, _("write did not end on a block boundary"))); + archive_write_error (status); } - tryagain: - if (looped) - { - /* We have to prompt from now on. */ + /* In multi-volume mode. */ + /* ENXIO is for the UNIX PC. */ + if (status < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO) + archive_write_error (status); - 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 */ - { - pid_t child = fork (); - switch (child) - { - 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: - { - int wait_status; - while (waitpid (child, &wait_status, 0) == -1) - if (errno != EINTR) - { - ERROR ((0, errno, - _("While waiting for child"))); - break; - } - } - break; - } - } -#endif /* not MSDOS */ - break; - } - } - } + if (!new_volume (ACCESS_WRITE)) + return; - if (verify_option) - archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW, - rsh_command_option); - else - switch (access) - { - case ACCESS_READ: - archive = rmtopen (*archive_name_cursor, O_RDONLY, MODE_RW, - rsh_command_option); - break; + tar_stat_destroy (&dummy); - case ACCESS_WRITE: - if (backup_option) - maybe_backup_file (*archive_name_cursor, 1); - archive = rmtcreat (*archive_name_cursor, MODE_RW, - rsh_command_option); - break; + increase_volume_number (); + prev_written += bytes_written; + bytes_written = 0; - case ACCESS_UPDATE: - archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW, - rsh_command_option); - break; - } + copy_ptr = record_start->buffer + status; + copy_size = buffer_level - status; - if (archive < 0) + /* Switch to the next buffer */ + record_index = !record_index; + init_buffer (); + + inhibit_map = 1; + + if (volume_label_option) + add_volume_label (); + + 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) { - WARN ((0, errno, _("Cannot open %s"), *archive_name_cursor)); - if (!verify_option && access == ACCESS_WRITE && backup_option) - undo_last_backup (); - goto tryagain; + memcpy (header->buffer, copy_ptr, bufsize); + copy_ptr += bufsize; + copy_size -= bufsize; + set_next_block_after (header + (bufsize - 1) / BLOCKSIZE); + header = find_next_block (); + bufsize = available_space_after (header); } + memcpy (header->buffer, copy_ptr, copy_size); + memset (header->buffer + copy_size, 0, bufsize - copy_size); + set_next_block_after (header + (copy_size - 1) / BLOCKSIZE); + find_next_block (); +} -#if MSDOS - setmode (archive, O_BINARY); -#endif +static void +gnu_flush_write (size_t buffer_level) +{ + flush_write_ptr = simple_flush_write; /* Avoid recursion */ + _gnu_flush_write (buffer_level); + flush_write_ptr = gnu_flush_write; +} + +void +flush_read (void) +{ + flush_read_ptr (); +} + +void +flush_write (void) +{ + flush_write_ptr (record_size); +} + +void +open_archive (enum access_mode wanted_access) +{ + flush_read_ptr = gnu_flush_read; + flush_write_ptr = gnu_flush_write; + + _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 (); }