X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fbuffer.c;h=5977f5a56ed80b17ad6723646fcb46b405928d64;hb=d659cbaccdc1f3279c49107cf15f15a639738529;hp=6514461fc719992e7efbb459ece4141715c937cf;hpb=363eb1d48afd94adb4488443dd26bbb3724a2fb6;p=chaz%2Ftar diff --git a/src/buffer.c b/src/buffer.c index 6514461..5977f5a 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -1,872 +1,696 @@ /* Buffer management for tar. - Copyright (C) 1988, 1992 Free Software Foundation - -This file is part of GNU Tar. - -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 2, or (at your option) -any later version. - -GNU Tar is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GNU Tar; see the file COPYING. If not, write to -the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ - -/* - * Buffer management for tar. - * - * Written by John Gilmore, ihnp4!hoptoad!gnu, on 25 August 1985. - */ - -#include -#include -#ifndef STDC_HEADERS -extern int errno; -#endif -#include /* For non-Berkeley systems */ -#include -#include -time_t time (); -#ifdef HAVE_SYS_MTIO_H -#include -#include -#endif + Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001, + 2003, 2004, 2005 Free Software Foundation, Inc. -#ifdef BSD42 -#include -#else -#ifndef V7 -#include -#endif -#endif + Written by John Gilmore, on 1985-08-25. -#ifdef __MSDOS__ -#include -#endif + 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. -#ifdef XENIX -#include -#endif + 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. -#include "tar.h" -#include "port.h" -#include "rmt.h" -#include "regex.h" + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ -/* Either stdout or stderr: The thing we write messages (standard msgs, not - errors) to. Stdout unless we're writing a pipe, in which case stderr */ -FILE *msg_file = stdout; +#include -#define STDIN 0 /* Standard input file descriptor */ -#define STDOUT 1 /* Standard output file descriptor */ +#include -#define PREAD 0 /* Read file descriptor from pipe() */ -#define PWRITE 1 /* Write file descriptor from pipe() */ +#include +#include +#include -#define MAGIC_STAT 105 /* Magic status returned by child, if - it can't exec. We hope compress/sh - never return this status! */ +#include "common.h" +#include -void *valloc (); +/* Number of retries before giving up on read. */ +#define READ_ERROR_MAX 10 -void writeerror (); -void readerror (); +/* Globbing pattern to append to volume label if initial match failed. */ +#define VOLUME_LABEL_APPEND " Volume [1-9]*" + +/* Variables. */ -void ck_pipe (); -void ck_close (); +static tarlong prev_written; /* bytes written on previous volumes */ +static tarlong bytes_written; /* bytes written on this volume */ +static void *record_buffer; /* allocated memory */ -int backspace_output (); -extern void finish_header (); -void flush_archive (); -int isfile (); -int new_volume (); -void verify_volume (); -extern void to_oct (); +/* FIXME: The following variables should ideally be static to this + module. However, this cannot be done yet. The cleanup continues! */ -#ifndef __MSDOS__ -/* Obnoxious test to see if dimwit is trying to dump the archive */ -dev_t ar_dev; -ino_t ar_ino; -#endif +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 */ -/* - * The record pointed to by save_rec should not be overlaid - * when reading in a new tape block. Copy it to record_save_area first, and - * change the pointer in *save_rec to point to record_save_area. - * Saved_recno records the record number at the time of the save. - * This is used by annofile() to print the record number of a file's - * header record. - */ -static union record **save_rec; -union record record_save_area; -static long saved_recno; - -/* - * PID of child program, if f_compress or remote archive access. - */ -static int childpid = 0; - -/* - * Record number of the start of this block of records - */ -long baserec; - -/* - * Error recovery stuff - */ -static int r_error_count; - -/* - * Have we hit EOF yet? - */ -static int hit_eof; +static off_t record_start_block; /* block ordinal at record_start */ -/* Checkpointing counter */ -static int checkpoint; +/* Where we write list messages (not errors, not interactions) to. */ +FILE *stdlis; -/* JF we're reading, but we just read the last record and its time to update */ -extern time_to_start_writing; -int file_to_switch_to = -1; /* If remote update, close archive, and use - this descriptor to write to */ +static void backspace_output (void); +static bool new_volume (enum access_mode); -static int volno = 1; /* JF which volume of a multi-volume tape - we're on */ -static int global_volno = 1; /* Volume number to print in external messages. */ +/* PID of child program, if compress_option or remote archive access. */ +static pid_t child_pid; -char *save_name = 0; /* Name of the file we are currently writing */ -long save_totsize; /* total size of file we are writing. Only - valid if save_name is non_zero */ -long save_sizeleft; /* Where we are in the file we are writing. - Only valid if save_name is non-zero */ +/* Error recovery stuff */ +static int read_error_count; -int write_archive_to_stdout; +/* Have we hit EOF yet? */ +static bool hit_eof; -/* Used by fl_read and fl_write to store the real info about saved names */ -static char real_s_name[NAMSIZ]; -static long real_s_totsize; -static long real_s_sizeleft; +/* Checkpointing counter */ +static int checkpoint; -/* Reset the EOF flag (if set), and re-set ar_record, etc */ +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 + + As least EXTERN like this one as possible. (?? --gray) + FIXME: Either eliminate it or move it to common.h. +*/ +extern bool time_to_start_writing; + +static int volno = 1; /* which volume of a multi-volume tape we're + on */ +static int global_volno = 1; /* volume number to print in external + messages */ + +/* The pointer save_name, which is set in function dump_file() of module + create.c, points to the original long filename instead of the new, + shorter mangled name that is set in start_header() of module create.c. + The pointer save_name is only used in multi-volume mode when the file + being processed is non-sparse; if a file is split between volumes, the + save_name is used in generating the LF_MULTIVOL record on the second + volume. (From Pierce Cantrell, 1991-08-13.) */ + +char *save_name; /* name of the file we are currently writing */ +off_t save_totsize; /* total size of file we are writing, only + valid if save_name is nonzero */ +off_t save_sizeleft; /* where we are in the file we are writing, + only valid if save_name is nonzero */ + +bool write_archive_to_stdout; + +/* Used by flush_read and flush_write to store the real info about saved + names. */ +static char *real_s_name; +static off_t real_s_totsize; +static off_t real_s_sizeleft; + +/* Functions. */ void -reset_eof () +clear_read_error_count (void) { - if (hit_eof) - { - hit_eof = 0; - ar_record = ar_block; - ar_last = ar_block + blocking; - ar_reading = 0; - } + read_error_count = 0; } -/* - * Return the location of the next available input or output record. - * 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 record * -findrec () + +/* Time-related functions */ + +double duration; + +void +set_start_time () { - if (ar_record == ar_last) - { - if (hit_eof) - return (union record *) NULL; /* EOF */ - flush_archive (); - if (ar_record == ar_last) - { - hit_eof++; - return (union record *) NULL; /* EOF */ - } - } - return ar_record; + gettime (&start_time); } - -/* - * Indicate that we have used all records up thru the argument. - * (should the arg have an off-by-1? XXX FIXME) - */ void -userec (rec) - union record *rec; +compute_duration () { - while (rec >= ar_record) - ar_record++; - /* - * Do NOT flush the archive here. If we do, the same - * argument to userec() could mean the next record (if the - * input block is exactly one record long), which is not what - * is intended. - */ - if (ar_record > ar_last) - abort (); + struct timespec now; + gettime (&now); + duration += ((now.tv_sec - start_time.tv_sec) + + (now.tv_nsec - start_time.tv_nsec) / 1e9); + set_start_time (); } + +/* Compression detection */ + +enum compress_type { + ct_none, + ct_compress, + ct_gzip, + ct_bzip2 +}; -/* - * Return a pointer to the end of the current records buffer. - * All the space between findrec() and endofrecs() is available - * for filling with data, or taking data from. - */ -union record * -endofrecs () +struct zip_magic { - return ar_last; -} + enum compress_type type; + size_t length; + char *magic; + char *program; + char *option; +}; + +static struct zip_magic const magic[] = { + { ct_none, }, + { ct_compress, 2, "\037\235", "compress", "-Z" }, + { ct_gzip, 2, "\037\213", "gzip", "-z" }, + { ct_bzip2, 3, "BZh", "bzip2", "-j" }, +}; + +#define NMAGIC (sizeof(magic)/sizeof(magic[0])) + +#define compress_option(t) magic[t].option +#define compress_program(t) magic[t].program + +/* Check if the file ARCHIVE is a compressed archive. */ +enum compress_type +check_compressed_archive () +{ + struct zip_magic const *p; + bool sfr; + /* Prepare global data needed for find_next_block: */ + record_end = record_start; /* set up for 1st record = # 0 */ + sfr = read_full_records; + read_full_records = true; /* Suppress fatal error on reading a partial + record */ + find_next_block (); -/* - * Duplicate a file descriptor into a certain slot. - * Equivalent to BSD "dup2" with error reporting. - */ -void -dupto (from, to, msg) - int from, to; - char *msg; + /* Restore global values */ + read_full_records = sfr; + + if (tar_checksum (record_start, true) == HEADER_SUCCESS) + /* Probably a valid header */ + return ct_none; + + for (p = magic + 1; p < magic + NMAGIC; p++) + if (memcmp (record_start->buffer, p->magic, p->length) == 0) + return p->type; + + return ct_none; +} + +/* Open an archive named archive_name_array[0]. Detect if it is + a compressed archive of known type and use corresponding decompression + program if so */ +int +open_compressed_archive () { - int err; + archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY, + MODE_RW, rsh_command_option); + if (archive == -1) + return archive; - if (from != to) + if (!multi_volume_option) { - err = close (to); - if (err < 0 && errno != EBADF) - { - msg_perror ("Cannot close descriptor %d", to); - exit (EX_SYSTEM); - } - err = dup (from); - if (err != to) - { - msg_perror ("cannot dup %s", msg); - exit (EX_SYSTEM); - } - ck_close (from); + enum compress_type type = check_compressed_archive (); + + if (type == ct_none) + return archive; + + /* FD is not needed any more */ + rmtclose (archive); + + hit_eof = false; /* It might have been set by find_next_block in + check_compressed_archive */ + + /* Open compressed archive */ + use_compress_program_option = compress_program (type); + child_pid = sys_child_open_for_uncompress (); + read_full_records = true; } -} -#ifdef __MSDOS__ -void -child_open () -{ - fprintf (stderr, "MS-DOS %s can't use compressed or remote archives\n", tar); - exit (EX_ARGSBAD); + records_read = 0; + record_end = record_start; /* set up for 1st record = # 0 */ + + return archive; } + -#else void -child_open () +print_total_written (void) { - int pipe[2]; - int err = 0; - int nar; + tarlong written = prev_written + bytes_written; + char bytes[sizeof (tarlong) * CHAR_BIT]; + char abbr[LONGEST_HUMAN_READABLE + 1]; + char rate[LONGEST_HUMAN_READABLE + 1]; - int kidpipe[2]; - int kidchildpid; + int human_opts = human_autoscale | human_base_1024 | human_SI | human_B; -#define READ 0 -#define WRITE 1 + sprintf (bytes, TARLONG_FORMAT, written); - ck_pipe (pipe); - - childpid = fork (); - if (childpid < 0) - { - msg_perror ("cannot fork"); - exit (EX_SYSTEM); - } - if (childpid > 0) - { - /* We're the parent. Clean up and be happy */ - /* This, at least, is easy */ + /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */ + fprintf (stderr, _("Total bytes written: %s (%s, %s/s)\n"), bytes, + human_readable (written, abbr, human_opts, 1, 1), + (0 < duration && written / duration < (uintmax_t) -1 + ? human_readable (written / duration, rate, human_opts, 1, 1) + : "?")); +} - if (ar_reading) - { - f_reblock++; - archive = pipe[READ]; - ck_close (pipe[WRITE]); - } - else - { - archive = pipe[WRITE]; - ck_close (pipe[READ]); - } - return; - } +/* Compute and return the block ordinal at current_block. */ +off_t +current_block_ordinal (void) +{ + return record_start_block + (current_block - record_start); +} - /* We're the kid */ - if (ar_reading) - { - dupto (pipe[WRITE], STDOUT, "(child) pipe to stdout"); - ck_close (pipe[READ]); - } - else +/* If the EOF flag is set, reset it, as well as current_block, etc. */ +void +reset_eof (void) +{ + if (hit_eof) { - dupto (pipe[READ], STDIN, "(child) pipe to stdin"); - ck_close (pipe[WRITE]); + hit_eof = false; + current_block = record_start; + record_end = record_start + blocking_factor; + access_mode = ACCESS_WRITE; } +} - /* We need a child tar only if - 1: we're reading/writing stdin/out (to force reblocking) - 2: the file is to be accessed by rmt (compress doesn't know how) - 3: the file is not a plain file */ -#ifdef NO_REMOTE - if (!(ar_files[0][0] == '-' && ar_files[0][1] == '\0') && isfile (ar_files[0])) -#else - if (!(ar_files[0][0] == '-' && ar_files[0][1] == '\0') && !_remdev (ar_files[0]) && isfile (ar_files[0])) -#endif +/* 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) { - /* We don't need a child tar. Open the archive */ - if (ar_reading) - { - archive = open (ar_files[0], O_RDONLY | O_BINARY, 0666); - if (archive < 0) - { - msg_perror ("can't open archive %s", ar_files[0]); - exit (EX_BADARCH); - } - dupto (archive, STDIN, "archive to stdin"); - /* close(archive); */ - } - else + if (hit_eof) + return 0; + flush_archive (); + if (current_block == record_end) { - archive = creat (ar_files[0], 0666); - if (archive < 0) - { - msg_perror ("can't open archive %s", ar_files[0]); - exit (EX_BADARCH); - } - dupto (archive, STDOUT, "archive to stdout"); - /* close(archive); */ + hit_eof = true; + return 0; } } - else - { - /* We need a child tar */ - ck_pipe (kidpipe); - - kidchildpid = fork (); - if (kidchildpid < 0) - { - msg_perror ("child can't fork"); - exit (EX_SYSTEM); - } - - if (kidchildpid > 0) - { - /* About to exec compress: set up the files */ - if (ar_reading) - { - dupto (kidpipe[READ], STDIN, "((child)) pipe to stdin"); - ck_close (kidpipe[WRITE]); - /* dup2(pipe[WRITE],STDOUT); */ - } - else - { - /* dup2(pipe[READ],STDIN); */ - dupto (kidpipe[WRITE], STDOUT, "((child)) pipe to stdout"); - ck_close (kidpipe[READ]); - } - /* ck_close(pipe[READ]); */ - /* ck_close(pipe[WRITE]); */ - /* ck_close(kidpipe[READ]); - ck_close(kidpipe[WRITE]); */ - } - else - { - /* Grandchild. Do the right thing, namely sit here and - read/write the archive, and feed stuff back to compress */ - tar = "tar (child)"; - if (ar_reading) - { - dupto (kidpipe[WRITE], STDOUT, "[child] pipe to stdout"); - ck_close (kidpipe[READ]); - } - else - { - dupto (kidpipe[READ], STDIN, "[child] pipe to stdin"); - ck_close (kidpipe[WRITE]); - } + return current_block; +} - if (ar_files[0][0] == '-' && ar_files[0][1] == '\0') - { - if (ar_reading) - archive = STDIN; - else - archive = STDOUT; - } - else /* This can't happen if (ar_reading==2) - archive = rmtopen(ar_files[0], O_RDWR|O_CREAT|O_BINARY, 0666); - else */ if (ar_reading) - archive = rmtopen (ar_files[0], O_RDONLY | O_BINARY, 0666); - else - archive = rmtcreat (ar_files[0], 0666); +/* Indicate that we have used all blocks up thru BLOCK. */ +void +set_next_block_after (union block *block) +{ + while (block >= current_block) + current_block++; - if (archive < 0) - { - msg_perror ("can't open archive %s", ar_files[0]); - exit (EX_BADARCH); - } + /* 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 (ar_reading) - { - for (;;) - { - char *ptr; - int max, count; - - r_error_count = 0; - error_loop: - err = rmtread (archive, ar_block->charptr, (int) (blocksize)); - if (err < 0) - { - readerror (); - goto error_loop; - } - if (err == 0) - break; - ptr = ar_block->charptr; - max = err; - while (max) - { - count = (max < RECORDSIZE) ? max : RECORDSIZE; - err = write (STDOUT, ptr, count); - if (err != count) - { - if (err < 0) - { - msg_perror ("can't write to compress"); - exit (EX_SYSTEM); - } - else - msg ("write to compress short %d bytes", count - err); - count = (err < 0) ? 0 : err; - } - ptr += count; - max -= count; - } - } - } - else - { - for (;;) - { - int n; - char *ptr; - - n = blocksize; - ptr = ar_block->charptr; - while (n) - { - err = read (STDIN, ptr, (n < RECORDSIZE) ? n : RECORDSIZE); - if (err <= 0) - break; - n -= err; - ptr += err; - } - /* EOF */ - if (err == 0) - { - if (f_compress < 2) - blocksize -= n; - else - bzero (ar_block->charptr + blocksize - n, n); - err = rmtwrite (archive, ar_block->charptr, blocksize); - if (err != (blocksize)) - writeerror (err); - if (f_compress < 2) - blocksize += n; - break; - } - if (n) - { - msg_perror ("can't read from compress"); - exit (EX_SYSTEM); - } - err = rmtwrite (archive, ar_block->charptr, (int) blocksize); - if (err != blocksize) - writeerror (err); - } - } + if (current_block > record_end) + abort (); +} - /* close_archive(); */ - exit (0); - } - } - /* So we should exec compress (-d) */ - if (ar_reading) - execlp ("compress", "compress", "-d", (char *) 0); - else - execlp ("compress", "compress", (char *) 0); - msg_perror ("can't exec compress"); - _exit (EX_SYSTEM); +/* 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; } +/* Close file having descriptor FD, and abort if close unsuccessful. */ +void +xclose (int fd) +{ + if (close (fd) != 0) + close_error (_("(pipe)")); +} -/* return non-zero if p is the name of a directory */ -int -isfile (p) - char *p; +/* Check the LABEL block against the volume label, seen as a globbing + pattern. Return true if the pattern matches. In case of failure, + retry matching a volume sequence number before giving up in + multi-volume mode. */ +static bool +check_label_pattern (union block *label) { - struct stat stbuf; + char *string; + bool result; - if (stat (p, &stbuf) < 0) - return 1; - if (S_ISREG (stbuf.st_mode)) - return 1; - return 0; -} + if (! memchr (label->header.name, '\0', sizeof label->header.name)) + return false; -#endif + if (fnmatch (volume_label_option, label->header.name, 0) == 0) + return true; + + if (!multi_volume_option) + return false; -/* - * Open an archive file. The argument specifies whether we are - * reading or writing. - */ -/* JF if the arg is 2, open for reading and writing. */ + 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; +} + +/* Open an archive file. The argument specifies whether we are + reading or writing, or both. */ void -open_archive (reading) - int reading; +open_archive (enum access_mode wanted_access) { - msg_file = f_exstdout ? stderr : stdout; + int backed_up_flag = 0; - if (blocksize == 0) + if (index_file_name) { - msg ("invalid value for blocksize"); - exit (EX_ARGSBAD); + stdlis = fopen (index_file_name, "w"); + if (! stdlis) + open_error (index_file_name); } + else + stdlis = to_stdout_option ? stderr : stdout; - if (n_ar_files == 0) - { - msg ("No archive name given, what should I do?"); - exit (EX_BADARCH); - } + if (record_size == 0) + FATAL_ERROR ((0, 0, _("Invalid value for record_size"))); - /*NOSTRICT*/ - if (f_multivol) - { - ar_block = (union record *) valloc ((unsigned) (blocksize + (2 * RECORDSIZE))); - if (ar_block) - ar_block += 2; - } - else - ar_block = (union record *) valloc ((unsigned) blocksize); - if (!ar_block) - { - msg ("could not allocate memory for blocking factor %d", - blocking); - exit (EX_ARGSBAD); - } + if (archive_names == 0) + FATAL_ERROR ((0, 0, _("No archive name given"))); - ar_record = ar_block; - ar_last = ar_block + blocking; - ar_reading = reading; + tar_stat_destroy (¤t_stat_info); + save_name = 0; + real_s_name = 0; - if (f_multivol && f_verify) - { - msg ("cannot verify multi-volume archives"); - exit (EX_ARGSBAD); - } + record_start = + page_aligned_alloc (&record_buffer, + (record_size + + (multi_volume_option ? 2 * BLOCKSIZE : 0))); + if (multi_volume_option) + record_start += 2; + + current_block = record_start; + record_end = record_start + blocking_factor; + /* When updating the archive, we start with reading. */ + access_mode = wanted_access == ACCESS_UPDATE ? ACCESS_READ : wanted_access; + + read_full_records = read_full_records_option; - if (f_compress) + records_read = 0; + + if (use_compress_program_option) { - if (reading == 2 || f_verify) - { - msg ("cannot update or verify compressed archives"); - exit (EX_ARGSBAD); - } - if (f_multivol) + switch (wanted_access) { - msg ("cannot use multi-volume compressed archives"); - exit (EX_ARGSBAD); + 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; } - child_open (); - if (!reading && ar_files[0][0] == '-' && ar_files[0][1] == '\0') - msg_file = stderr; - /* child_open(rem_host, rem_file); */ + + if (wanted_access == ACCESS_WRITE + && strcmp (archive_name_array[0], "-") == 0) + stdlis = stderr; } - else if (ar_files[0][0] == '-' && ar_files[0][1] == '\0') + else if (strcmp (archive_name_array[0], "-") == 0) { - f_reblock++; /* Could be a pipe, be safe */ - if (f_verify) - { - msg ("can't verify stdin/stdout archive"); - exit (EX_ARGSBAD); - } - if (reading == 2) - { - archive = STDIN; - msg_file = stderr; - write_archive_to_stdout++; - } - else if (reading) - archive = STDIN; - else + 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) { - archive = STDOUT; - msg_file = stderr; + case ACCESS_READ: + { + enum compress_type type; + + archive = STDIN_FILENO; + + type = check_compressed_archive (archive); + if (type != ct_none) + FATAL_ERROR ((0, 0, + _("Archive is compressed. Use %s option"), + compress_option (type))); + } + break; + + case ACCESS_WRITE: + archive = STDOUT_FILENO; + stdlis = stderr; + break; + + case ACCESS_UPDATE: + archive = STDIN_FILENO; + stdlis = stderr; + write_archive_to_stdout = true; + break; } } - else if (reading == 2 || f_verify) - { - archive = rmtopen (ar_files[0], O_RDWR | O_CREAT | O_BINARY, 0666); - } - else if (reading) - { - archive = rmtopen (ar_files[0], O_RDONLY | O_BINARY, 0666); - } + 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 (); + break; + + 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; + + case ACCESS_UPDATE: + archive = rmtopen (archive_name_array[0], O_RDWR | O_CREAT | O_BINARY, + MODE_RW, rsh_command_option); + break; + } + + if (archive < 0 + || (! _isrmt (archive) && !sys_get_archive_stat ())) { - archive = rmtcreat (ar_files[0], 0666); - } - if (archive < 0) - { - msg_perror ("can't open %s", ar_files[0]); - exit (EX_BADARCH); - } -#ifndef __MSDOS__ - if (!_isrmt (archive)) - { - struct stat tmp_stat; + int saved_errno = errno; - fstat (archive, &tmp_stat); - if (S_ISREG (tmp_stat.st_mode)) - { - ar_dev = tmp_stat.st_dev; - ar_ino = tmp_stat.st_ino; - } + if (backed_up_flag) + undo_last_backup (); + errno = saved_errno; + open_fatal (archive_name_array[0]); } -#endif -#ifdef __MSDOS__ - setmode (archive, O_BINARY); -#endif + sys_detect_dev_null_output (); + sys_save_archive_dev_ino (); + SET_BINARY_MODE (archive); - if (reading) + switch (wanted_access) { - ar_last = ar_block; /* Set up for 1st block = # 0 */ - (void) findrec (); /* Read it in, check for EOF */ + case ACCESS_UPDATE: + records_written = 0; + record_end = record_start; /* set up for 1st record = # 0 */ - if (f_volhdr) - { - union record *head; -#if 0 - char *ptr; + case ACCESS_READ: + find_next_block (); /* read it in, check for EOF */ - if (f_multivol) - { - ptr = malloc (strlen (f_volhdr) + 20); - sprintf (ptr, "%s Volume %d", f_volhdr, 1); - } - else - ptr = f_volhdr; -#endif - head = findrec (); - if (!head) - { - msg ("Archive not labelled to match %s", f_volhdr); - exit (EX_BADVOL); - } - if (re_match (label_pattern, head->header.arch_name, - strlen (head->header.arch_name), 0, 0) < 0) - { - msg ("Volume mismatch! %s!=%s", f_volhdr, - head->header.arch_name); - exit (EX_BADVOL); - } -#if 0 - if (strcmp (ptr, head->header.name)) - { - msg ("Volume mismatch! %s!=%s", ptr, head->header.name); - exit (EX_BADVOL); - } - if (ptr != f_volhdr) - free (ptr); -#endif + if (volume_label_option) + { + union block *label = find_next_block (); + + if (!label) + FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"), + quote (volume_label_option))); + if (!check_label_pattern (label)) + FATAL_ERROR ((0, 0, _("Volume %s does not match %s"), + quote_n (0, label->header.name), + quote_n (1, volume_label_option))); } - } - else if (f_volhdr) - { - bzero ((void *) ar_block, RECORDSIZE); - if (f_multivol) - sprintf (ar_block->header.arch_name, "%s Volume 1", f_volhdr); - else - strcpy (ar_block->header.arch_name, f_volhdr); - ar_block->header.linkflag = LF_VOLHDR; - to_oct (time (0), 1 + 12, ar_block->header.mtime); - finish_header (ar_block); - /* ar_record++; */ - } -} + break; + case ACCESS_WRITE: + records_written = 0; + if (volume_label_option) + { + memset (record_start, 0, BLOCKSIZE); + if (multi_volume_option) + sprintf (record_start->header.name, "%s Volume 1", + volume_label_option); + else + strcpy (record_start->header.name, volume_label_option); -/* - * Remember a union record * as pointing to something that we - * need to keep when reading onward in the file. Only one such - * thing can be remembered at once, and it only works when reading - * an archive. - * - * We calculate "offset" then add it because some compilers end up - * adding (baserec+ar_record), doing a 9-bit shift of baserec, then - * subtracting ar_block from that, shifting it back, losing the top 9 bits. - */ -void -saverec (pointer) - union record **pointer; -{ - long offset; + assign_string (¤t_stat_info.file_name, + record_start->header.name); + current_stat_info.had_trailing_slash = + strip_trailing_slashes (current_stat_info.file_name); - save_rec = pointer; - offset = ar_record - ar_block; - saved_recno = baserec + offset; + record_start->header.typeflag = GNUTYPE_VOLHDR; + TIME_TO_CHARS (start_time.tv_sec, record_start->header.mtime); + finish_header (¤t_stat_info, record_start, -1); + } + break; + } } -/* - * Perform a write to flush the buffer. - */ - -/*send_buffer_to_file(); - if(new_volume) { - deal_with_new_volume_stuff(); - send_buffer_to_file(); - } - */ - +/* Perform a write to flush the buffer. */ void -fl_write () +flush_write (void) { - int err; int copy_back; - static long bytes_written = 0; + ssize_t status; + + if (checkpoint_option && !(++checkpoint % 10)) + /* TRANSLATORS: This is a ``checkpoint of write operation'', + *not* ``Writing a checkpoint''. + E.g. in Spanish ``Punto de comprobaci@'on de escritura'', + *not* ``Escribiendo un punto de comprobaci@'on'' */ + WARN ((0, 0, _("Write checkpoint %d"), checkpoint)); - if (f_checkpoint && !(++checkpoint % 10)) - msg ("Write checkpoint %d\n", checkpoint); - if (tape_length && bytes_written >= tape_length * 1024) + if (tape_length_option && tape_length_option <= bytes_written) { errno = ENOSPC; - err = 0; + status = 0; } + else if (dev_null_output) + status = record_size; else - err = rmtwrite (archive, ar_block->charptr, (int) blocksize); - if (err != blocksize && !f_multivol) - writeerror (err); - else if (f_totals) - tot_written += blocksize; - - if (err > 0) - bytes_written += err; - if (err == blocksize) + status = sys_write_archive_buffer (); + if (status != record_size && !multi_volume_option) + archive_write_error (status); + + if (status > 0) + { + records_written++; + bytes_written += status; + } + + if (status == record_size) { - if (f_multivol) + if (multi_volume_option) { - if (!save_name) + if (save_name) + { + assign_string (&real_s_name, + safer_name_suffix (save_name, false, + absolute_names_option)); + real_s_totsize = save_totsize; + real_s_sizeleft = save_sizeleft; + } + else { - real_s_name[0] = '\0'; + assign_string (&real_s_name, 0); real_s_totsize = 0; real_s_sizeleft = 0; - return; } -#ifdef __MSDOS__ - if (save_name[1] == ':') - save_name += 2; -#endif - while (*save_name == '/') - save_name++; - - strcpy (real_s_name, save_name); - real_s_totsize = save_totsize; - real_s_sizeleft = save_sizeleft; } return; } - /* We're multivol Panic if we didn't get the right kind of response */ - /* ENXIO is for the UNIX PC */ - if (err < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO) - writeerror (err); + /* We're multivol. Panic if we didn't get the right kind of response. */ + + /* ENXIO is for the UNIX PC. */ + if (status < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO) + archive_write_error (status); - /* If error indicates a short write, we just move to the next tape. */ + /* If error indicates a short write, we just move to the next tape. */ - if (new_volume (0) < 0) + if (!new_volume (ACCESS_WRITE)) return; + + if (totals_option) + prev_written += bytes_written; bytes_written = 0; - if (f_volhdr && real_s_name[0]) + + if (volume_label_option && real_s_name) { copy_back = 2; - ar_block -= 2; + record_start -= 2; } - else if (f_volhdr || real_s_name[0]) + else if (volume_label_option || real_s_name) { copy_back = 1; - ar_block--; + record_start--; } else copy_back = 0; - if (f_volhdr) + + if (volume_label_option) { - bzero ((void *) ar_block, RECORDSIZE); - sprintf (ar_block->header.arch_name, "%s Volume %d", f_volhdr, volno); - to_oct (time (0), 1 + 12, ar_block->header.mtime); - ar_block->header.linkflag = LF_VOLHDR; - finish_header (ar_block); + memset (record_start, 0, BLOCKSIZE); + sprintf (record_start->header.name, "%s Volume %d", + volume_label_option, volno); + TIME_TO_CHARS (start_time.tv_sec, record_start->header.mtime); + record_start->header.typeflag = GNUTYPE_VOLHDR; + finish_header (¤t_stat_info, record_start, -1); } - if (real_s_name[0]) + + if (real_s_name) { int tmp; - if (f_volhdr) - ar_block++; - bzero ((void *) ar_block, RECORDSIZE); - strcpy (ar_block->header.arch_name, real_s_name); - ar_block->header.linkflag = LF_MULTIVOL; - to_oct ((long) real_s_sizeleft, 1 + 12, - ar_block->header.size); - to_oct ((long) real_s_totsize - real_s_sizeleft, - 1 + 12, ar_block->header.offset); - tmp = f_verbose; - f_verbose = 0; - finish_header (ar_block); - f_verbose = tmp; - if (f_volhdr) - ar_block--; + if (volume_label_option) + record_start++; + + if (strlen (real_s_name) > NAME_FIELD_SIZE) + WARN ((0, 0, + _("%s: file name too long to be stored in a GNU multivolume header, truncated"), + quotearg_colon (real_s_name))); + + memset (record_start, 0, BLOCKSIZE); + + /* FIXME: Michael P Urban writes: [a long name file] is being written + when a new volume rolls around [...] Looks like the wrong value is + being preserved in real_s_name, though. */ + + strncpy (record_start->header.name, real_s_name, NAME_FIELD_SIZE); + 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 (¤t_stat_info, record_start, -1); + verbose_option = tmp; + + if (volume_label_option) + record_start--; } - err = rmtwrite (archive, ar_block->charptr, (int) blocksize); - if (err != blocksize) - writeerror (err); - else if (f_totals) - tot_written += blocksize; + status = sys_write_archive_buffer (); + if (status != record_size) + archive_write_error (status); + bytes_written += status; - bytes_written = blocksize; if (copy_back) { - ar_block += copy_back; - bcopy ((void *) (ar_block + blocking - copy_back), - (void *) ar_record, - copy_back * RECORDSIZE); - ar_record += copy_back; - - if (real_s_sizeleft >= copy_back * RECORDSIZE) - real_s_sizeleft -= copy_back * RECORDSIZE; - else if ((real_s_sizeleft + RECORDSIZE - 1) / RECORDSIZE <= copy_back) - real_s_name[0] = '\0'; + record_start += copy_back; + memcpy (current_block, + record_start + blocking_factor - copy_back, + copy_back * BLOCKSIZE); + current_block += copy_back; + + if (real_s_sizeleft >= copy_back * BLOCKSIZE) + real_s_sizeleft -= copy_back * BLOCKSIZE; + else if ((real_s_sizeleft + BLOCKSIZE - 1) / BLOCKSIZE <= copy_back) + assign_string (&real_s_name, 0); else { -#ifdef __MSDOS__ - if (save_name[1] == ':') - save_name += 2; -#endif - while (*save_name == '/') - save_name++; - - strcpy (real_s_name, save_name); + assign_string (&real_s_name, + safer_name_suffix (save_name, false, + absolute_names_option)); real_s_sizeleft = save_sizeleft; real_s_totsize = save_totsize; } @@ -874,707 +698,595 @@ fl_write () } } -/* 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 block of the volume */ - +/* 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 -writeerror (err) - int err; +archive_write_error (ssize_t status) { - if (err < 0) - { - msg_perror ("can't write to %s", ar_files[cur_ar_file]); - exit (EX_BADARCH); - } - else + /* It might be useful to know how much was written before the error + occurred. */ + if (totals_option) { - msg ("only wrote %u of %u bytes to %s", err, blocksize, ar_files[cur_ar_file]); - exit (EX_BADARCH); + int e = errno; + print_total_written (); + errno = e; } + + write_fatal_details (*archive_name_cursor, status, record_size); } -/* - * Handle read errors on the archive. - * - * If the read should be retried, readerror() returns to the caller. - */ +/* Handle read errors on the archive. If the read should be retried, + return to the caller. */ void -readerror () +archive_read_error (void) { -# define READ_ERROR_MAX 10 + read_error (*archive_name_cursor); + + if (record_start_block == 0) + FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now"))); + + /* Read error in mid archive. We retry up to READ_ERROR_MAX times and + then give up on reading the archive. */ + + if (read_error_count++ > READ_ERROR_MAX) + FATAL_ERROR ((0, 0, _("Too many errors, quitting"))); + return; +} - read_error_flag++; /* Tell callers */ +static void +short_read (size_t status) +{ + size_t left; /* bytes left */ + char *more; /* pointer to next byte to read */ - msg_perror ("read error on %s", ar_files[cur_ar_file]); + more = record_start->buffer + status; + left = record_size - status; - if (baserec == 0) + while (left % BLOCKSIZE != 0 + || (left && status && read_full_records)) { - /* First block of tape. Probably stupidity error */ - exit (EX_BADARCH); + if (status) + while ((status = rmtread (archive, more, left)) == SAFE_READ_ERROR) + archive_read_error (); + + if (status == 0) + break; + + if (! read_full_records) + { + unsigned long rest = record_size - left; + + FATAL_ERROR ((0, 0, + ngettext ("Unaligned block (%lu byte) in archive", + "Unaligned block (%lu bytes) in archive", + rest), + rest)); + } + + /* User warned us about this. Fix up. */ + + left -= status; + more += status; } - /* - * Read error in mid archive. We retry up to READ_ERROR_MAX times - * and then give up on reading the archive. We set read_error_flag - * for our callers, so they can cope if they want. - */ - if (r_error_count++ > READ_ERROR_MAX) + /* FIXME: for size=0, multi-volume support. On the first record, warn + about the problem. */ + + if (!read_full_records && verbose_option > 1 + && record_start_block == 0 && status != 0) { - msg ("Too many errors, quitting."); - exit (EX_BADARCH); + unsigned long rsize = (record_size - left) / BLOCKSIZE; + WARN ((0, 0, + ngettext ("Record size = %lu block", + "Record size = %lu blocks", + rsize), + rsize)); } - return; -} + record_end = record_start + (record_size - left) / BLOCKSIZE; + records_read++; +} -/* - * Perform a read to flush the buffer. - */ +/* Perform a read to flush the buffer. */ void -fl_read () +flush_read (void) { - int err; /* Result from system call */ - int left; /* Bytes left */ - char *more; /* Pointer to next byte to read */ - - if (f_checkpoint && !(++checkpoint % 10)) - msg ("Read checkpoint %d\n", checkpoint); - - /* - * Clear the count of errors. This only applies to a single - * call to fl_read. We leave read_error_flag alone; it is - * only turned off by higher level software. - */ - r_error_count = 0; /* Clear error count */ - - /* - * If we are about to wipe out a record that - * somebody needs to keep, copy it out to a holding - * area and adjust somebody's pointer to it. - */ - if (save_rec && - *save_rec >= ar_record && - *save_rec < ar_last) - { - record_save_area = **save_rec; - *save_rec = &record_save_area; - } - if (write_archive_to_stdout && baserec != 0) + size_t status; /* result from system call */ + + if (checkpoint_option && !(++checkpoint % 10)) + /* TRANSLATORS: This is a ``checkpoint of read operation'', + *not* ``Reading a checkpoint''. + E.g. in Spanish ``Punto de comprobaci@'on de lectura'', + *not* ``Leyendo un punto de comprobaci@'on'' */ + WARN ((0, 0, _("Read checkpoint %d"), checkpoint)); + + /* 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) { - err = rmtwrite (1, ar_block->charptr, blocksize); - if (err != blocksize) - writeerror (err); + archive = STDOUT_FILENO; + status = sys_write_archive_buffer (); + archive = STDIN_FILENO; + if (status != record_size) + archive_write_error (status); } - if (f_multivol) + if (multi_volume_option) { if (save_name) { - if (save_name != real_s_name) - { -#ifdef __MSDOS__ - if (save_name[1] == ':') - save_name += 2; -#endif - while (*save_name == '/') - save_name++; - - strcpy (real_s_name, save_name); - save_name = real_s_name; - } - real_s_totsize = save_totsize; + assign_string (&real_s_name, + safer_name_suffix (save_name, false, + absolute_names_option)); real_s_sizeleft = save_sizeleft; - + real_s_totsize = save_totsize; } else { - real_s_name[0] = '\0'; + assign_string (&real_s_name, 0); real_s_totsize = 0; real_s_sizeleft = 0; } } -error_loop: - err = rmtread (archive, ar_block->charptr, (int) blocksize); - if (err == blocksize) - return; + error_loop: + 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 ((err == 0 || (err < 0 && errno == ENOSPC) || (err > 0 && !f_reblock)) && f_multivol) + if ((status == 0 + || (status == SAFE_READ_ERROR && errno == ENOSPC)) + && multi_volume_option) { - union record *head; + union block *cursor; try_volume: - if (new_volume ((cmd_mode == CMD_APPEND || cmd_mode == CMD_CAT || cmd_mode == CMD_UPDATE) ? 2 : 1) < 0) - return; - vol_error: - err = rmtread (archive, ar_block->charptr, (int) blocksize); - if (err < 0) + switch (subcommand_option) { - readerror (); - goto vol_error; + case APPEND_SUBCOMMAND: + case CAT_SUBCOMMAND: + case UPDATE_SUBCOMMAND: + if (!new_volume (ACCESS_UPDATE)) + return; + break; + + default: + if (!new_volume (ACCESS_READ)) + return; + break; } - if (err != blocksize) - goto short_read; - head = ar_block; + while ((status = rmtread (archive, record_start->buffer, record_size)) + == SAFE_READ_ERROR) + archive_read_error (); - if (head->header.linkflag == LF_VOLHDR) - { - if (f_volhdr) - { -#if 0 - char *ptr; + if (status != record_size) + short_read (status); - ptr = (char *) malloc (strlen (f_volhdr) + 20); - sprintf (ptr, "%s Volume %d", f_volhdr, volno); -#endif - if (re_match (label_pattern, head->header.arch_name, - strlen (head->header.arch_name), - 0, 0) < 0) - { - msg ("Volume mismatch! %s!=%s", f_volhdr, - head->header.arch_name); - --volno; - --global_volno; - goto try_volume; - } + cursor = record_start; -#if 0 - if (strcmp (ptr, head->header.name)) + if (cursor->header.typeflag == GNUTYPE_VOLHDR) + { + if (volume_label_option) + { + if (!check_label_pattern (cursor)) { - msg ("Volume mismatch! %s!=%s", ptr, head->header.name); - --volno; - --global_volno; - free (ptr); + WARN ((0, 0, _("Volume %s does not match %s"), + quote_n (0, cursor->header.name), + quote_n (1, volume_label_option))); + volno--; + global_volno--; goto try_volume; } - free (ptr); -#endif } - if (f_verbose) - fprintf (msg_file, "Reading %s\n", head->header.arch_name); - head++; - } - else if (f_volhdr) - { - msg ("Warning: No volume header!"); + if (verbose_option) + fprintf (stdlis, _("Reading %s\n"), quote (cursor->header.name)); + cursor++; } + else if (volume_label_option) + WARN ((0, 0, _("WARNING: No volume header"))); - if (real_s_name[0]) + if (real_s_name) { - long from_oct (); - - if (head->header.linkflag != LF_MULTIVOL || strcmp (head->header.arch_name, real_s_name)) + uintmax_t s1, s2; + if (cursor->header.typeflag != GNUTYPE_MULTIVOL + || strncmp (cursor->header.name, real_s_name, NAME_FIELD_SIZE)) { - msg ("%s is not continued on this volume!", real_s_name); - --volno; - --global_volno; + WARN ((0, 0, _("%s is not continued on this volume"), + quote (real_s_name))); + volno--; + global_volno--; goto try_volume; } - if (real_s_totsize != from_oct (1 + 12, head->header.size) + from_oct (1 + 12, head->header.offset)) + s1 = UINTMAX_FROM_HEADER (cursor->header.size); + s2 = UINTMAX_FROM_HEADER (cursor->oldgnu_header.offset); + if (real_s_totsize != s1 + s2 || s1 + s2 < s2) { - msg ("%s is the wrong size (%ld!=%ld+%ld)", - head->header.arch_name, save_totsize, - from_oct (1 + 12, head->header.size), - from_oct (1 + 12, head->header.offset)); - --volno; - --global_volno; + char totsizebuf[UINTMAX_STRSIZE_BOUND]; + char s1buf[UINTMAX_STRSIZE_BOUND]; + char s2buf[UINTMAX_STRSIZE_BOUND]; + + WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"), + quote (cursor->header.name), + STRINGIFY_BIGINT (save_totsize, totsizebuf), + STRINGIFY_BIGINT (s1, s1buf), + STRINGIFY_BIGINT (s2, s2buf))); + volno--; + global_volno--; goto try_volume; } - if (real_s_totsize - real_s_sizeleft != from_oct (1 + 12, head->header.offset)) + if (real_s_totsize - real_s_sizeleft + != OFF_FROM_HEADER (cursor->oldgnu_header.offset)) { - msg ("This volume is out of sequence"); - --volno; - --global_volno; + WARN ((0, 0, _("This volume is out of sequence"))); + volno--; + global_volno--; goto try_volume; } - head++; + cursor++; } - ar_record = head; + current_block = cursor; + records_read++; return; } - else if (err < 0) + else if (status == SAFE_READ_ERROR) { - readerror (); - goto error_loop; /* Try again */ + archive_read_error (); + goto error_loop; /* try again */ } -short_read: - more = ar_block->charptr + err; - left = blocksize - err; + short_read (status); +} -again: - if (0 == (((unsigned) left) % RECORDSIZE)) - { - /* FIXME, for size=0, multi vol support */ - /* On the first block, warn about the problem */ - if (!f_reblock && baserec == 0 && f_verbose && err > 0) - { - /* msg("Blocksize = %d record%s", - err / RECORDSIZE, (err > RECORDSIZE)? "s": "");*/ - msg ("Blocksize = %d records", err / RECORDSIZE); - } - ar_last = ar_block + ((unsigned) (blocksize - left)) / RECORDSIZE; - return; - } - if (f_reblock) +/* Flush the current buffer to/from the archive. */ +void +flush_archive (void) +{ + record_start_block += record_end - record_start; + current_block = record_start; + record_end = record_start + blocking_factor; + + if (access_mode == ACCESS_READ && time_to_start_writing) { - /* - * User warned us about this. Fix up. - */ - if (left > 0) - { - error2loop: - err = rmtread (archive, more, (int) left); - if (err < 0) - { - readerror (); - goto error2loop; /* Try again */ - } - if (err == 0) - { - msg ("archive %s EOF not on block boundary", ar_files[cur_ar_file]); - exit (EX_BADARCH); - } - left -= err; - more += err; - goto again; - } + access_mode = ACCESS_WRITE; + time_to_start_writing = false; + backspace_output (); } - else + + switch (access_mode) { - msg ("only read %d bytes from archive %s", err, ar_files[cur_ar_file]); - exit (EX_BADARCH); + case ACCESS_READ: + flush_read (); + break; + + case ACCESS_WRITE: + flush_write (); + break; + + case ACCESS_UPDATE: + abort (); } } +/* Backspace the archive descriptor by one record worth. If it's a + tape, MTIOCTOP will work. If it's something else, try to seek on + it. If we can't seek, we lose! */ +static void +backspace_output (void) +{ +#ifdef MTIOCTOP + { + struct mtop operation; -/* - * Flush the current buffer to/from the archive. - */ -void -flush_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 + + { + 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) + { + /* Lseek failed. Try a different method. */ + + WARN ((0, 0, + _("Cannot backspace archive file; it may be unreadable without -i"))); + + /* 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); + } + } +} + +off_t +seek_archive (off_t size) { - int c; + off_t start = current_block_ordinal (); + off_t offset; + off_t nrec, nblk; + off_t skipped = (blocking_factor - (current_block - record_start)); - baserec += ar_last - ar_block;/* Keep track of block #s */ - ar_record = ar_block; /* Restore pointer to start */ - ar_last = ar_block + blocking;/* Restore pointer to end */ + size -= skipped * BLOCKSIZE; - if (ar_reading) - { - if (time_to_start_writing) - { - time_to_start_writing = 0; - ar_reading = 0; + if (size < record_size) + return 0; + /* FIXME: flush? */ - if (file_to_switch_to >= 0) - { - if ((c = rmtclose (archive)) < 0) - msg_perror ("Warning: can't close %s(%d,%d)", ar_files[cur_ar_file], archive, c); + /* Compute number of records to skip */ + nrec = size / record_size; + offset = rmtlseek (archive, nrec * record_size, SEEK_CUR); + if (offset < 0) + return offset; - archive = file_to_switch_to; - } - else - (void) backspace_output (); - fl_write (); - } - else - fl_read (); - } - else - { - fl_write (); - } + if (offset % record_size) + FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary"))); + + /* Convert to number of records */ + offset /= BLOCKSIZE; + /* Compute number of skipped blocks */ + nblk = offset - start; + + /* Update buffering info */ + records_read += nblk / blocking_factor; + record_start_block = offset - blocking_factor; + current_block = record_end; + + return nblk; } -/* Backspace the archive descriptor by one blocks 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! */ -int -backspace_output () +/* Close the archive file. */ +void +close_archive (void) { - long cur; - /* int er; */ - extern char *output_start; + if (time_to_start_writing || access_mode == ACCESS_WRITE) + flush_archive (); -#ifdef MTIOCTOP - struct mtop t; - - t.mt_op = MTBSR; - t.mt_count = 1; - if ((rmtioctl (archive, MTIOCTOP, &t)) >= 0) - return 1; - if (errno == EIO && (rmtioctl (archive, MTIOCTOP, &t)) >= 0) - return 1; -#endif + sys_drain_input_pipe (); + + compute_duration (); + if (verify_option) + verify_volume (); + + if (rmtclose (archive) != 0) + close_warn (*archive_name_cursor); - cur = rmtlseek (archive, 0L, 1); - cur -= blocksize; - /* Seek back to the beginning of this block and - start writing there. */ + sys_wait_for_child (child_pid); + + tar_stat_destroy (¤t_stat_info); + if (save_name) + free (save_name); + if (real_s_name) + free (real_s_name); + free (record_buffer); +} + +/* Called to initialize the global volume number. */ +void +init_volume_number (void) +{ + FILE *file = fopen (volno_file_option, "r"); - if (rmtlseek (archive, cur, 0) != cur) + if (file) { - /* Lseek failed. Try a different method */ - msg ("Couldn't backspace archive file. It may be unreadable without -i."); - /* Replace the first part of the block with nulls */ - if (ar_block->charptr != output_start) - bzero (ar_block->charptr, output_start - ar_block->charptr); - return 2; + 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); } - return 3; + else if (errno != ENOENT) + open_error (volno_file_option); } - -/* - * Close the archive file. - */ +/* Called to write out the closing global volume number. */ void -close_archive () +closeout_volume_number (void) { - int child; - int status; - int c; + FILE *file = fopen (volno_file_option, "w"); - if (time_to_start_writing || !ar_reading) - flush_archive (); - if (cmd_mode == CMD_DELETE) + if (file) { - off_t pos; - - pos = rmtlseek (archive, 0L, 1); -#ifndef __MSDOS__ - (void) ftruncate (archive, pos); -#else - (void) rmtwrite (archive, "", 0); -#endif + fprintf (file, "%d\n", global_volno); + if (ferror (file)) + write_error (volno_file_option); + if (fclose (file) != 0) + close_error (volno_file_option); } - if (f_verify) + else + open_error (volno_file_option); +} + +/* We've hit the end of the old volume. Close it and open the next one. + Return nonzero on success. +*/ +static bool +new_volume (enum access_mode mode) +{ + static FILE *read_file; + static int looped; + + 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 (now_verifying) + return false; + if (verify_option) verify_volume (); - if ((c = rmtclose (archive)) < 0) - msg_perror ("Warning: can't close %s(%d,%d)", ar_files[cur_ar_file], archive, c); + if (rmtclose (archive) != 0) + close_warn (*archive_name_cursor); -#ifndef __MSDOS__ - if (childpid) + global_volno++; + if (global_volno < 0) + FATAL_ERROR ((0, 0, _("Volume number overflow"))); + volno++; + archive_name_cursor++; + if (archive_name_cursor == archive_name_array + archive_names) { - /* - * Loop waiting for the right child to die, or for - * no more kids. - */ - while (((child = wait (&status)) != childpid) && child != -1) - ; - - if (child != -1) + archive_name_cursor = archive_name_array; + looped = 1; + } + + tryagain: + if (looped) + { + /* We have to prompt from now on. */ + + if (info_script_option) { + if (volno_file_option) + closeout_volume_number (); + if (system (info_script_option) != 0) + FATAL_ERROR ((0, 0, _("%s command failed"), + quote (info_script_option))); + } + else + while (1) { - if (WIFSIGNALED (status)) + char input_buffer[80]; + + fputc ('\007', stderr); + fprintf (stderr, + _("Prepare volume #%d for %s and hit return: "), + global_volno, quote (*archive_name_cursor)); + fflush (stderr); + + if (fgets (input_buffer, sizeof input_buffer, read_file) == 0) { - /* SIGPIPE is OK, everything else is a problem. */ - if (WTERMSIG (status) != SIGPIPE) - msg ("child died with signal %d%s", WTERMSIG (status), - WIFCOREDUMPED (status) ? " (core dumped)" : ""); + 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 (); } - else + if (input_buffer[0] == '\n' + || input_buffer[0] == 'y' + || input_buffer[0] == 'Y') + break; + + switch (input_buffer[0]) { - /* Child voluntarily terminated -- but why? */ - if (WEXITSTATUS (status) == MAGIC_STAT) - { - exit (EX_SYSTEM); /* Child had trouble */ - } - if (WEXITSTATUS (status) == (SIGPIPE + 128)) - { - /* - * /bin/sh returns this if its child - * dies with SIGPIPE. 'Sok. - */ - break; - } - else if (WEXITSTATUS (status)) - msg ("child returned status %d", - WEXITSTATUS (status)); - } - } - } -#endif /* __MSDOS__ */ - } + case '?': + { + /* FIXME: Might it be useful to disable the '!' command? */ + fprintf (stderr, _("\ + n [name] Give a new file name for the next (and subsequent) volume(s)\n\ + q Abort tar\n\ + ! Spawn a subshell\n\ + ? Print this list\n")); + } + break; + case 'q': + /* Quit. */ -#ifdef DONTDEF - /* - * Message management. - * - * anno writes a message prefix on stream (eg stdout, stderr). - * - * The specified prefix is normally output followed by a colon and a space. - * However, if other command line options are set, more output can come - * out, such as the record # within the archive. - * - * If the specified prefix is NULL, no output is produced unless the - * command line option(s) are set. - * - * If the third argument is 1, the "saved" record # is used; if 0, the - * "current" record # is used. - */ - void - anno (stream, prefix, savedp) - FILE *stream; - char *prefix; - int savedp; - { -# define MAXANNO 50 - char buffer[MAXANNO]; /* Holds annorecment */ -# define ANNOWIDTH 13 - int space; - long offset; - int save_e; - - save_e = errno; - /* Make sure previous output gets out in sequence */ - if (stream == stderr) - fflush (stdout); - if (f_sayblock) - { - if (prefix) - { - fputs (prefix, stream); - putc (' ', stream); - } - offset = ar_record - ar_block; - (void) sprintf (buffer, "rec %d: ", - savedp ? saved_recno : - baserec + offset); - fputs (buffer, stream); - space = ANNOWIDTH - strlen (buffer); - if (space > 0) - { - fprintf (stream, "%*s", space, ""); - } - } - else if (prefix) - { - fputs (prefix, stream); - fputs (": ", stream); - } - errno = save_e; - } -#endif + WARN ((0, 0, _("No new volume; exiting.\n"))); - /* Called to initialize the global volume number. */ - int - init_volume_number () - { - FILE *vf; + if (subcommand_option != EXTRACT_SUBCOMMAND + && subcommand_option != LIST_SUBCOMMAND + && subcommand_option != DIFF_SUBCOMMAND) + WARN ((0, 0, _("WARNING: Archive is incomplete"))); - vf = fopen (f_volno_file, "r"); - if (!vf && errno != ENOENT) - msg_perror ("%s", f_volno_file); + fatal_exit (); - if (vf) - { - fscanf (vf, "%d", &global_volno); - fclose (vf); - } - } + case 'n': + /* Get new file name. */ - /* Called to write out the closing global volume number. */ - int - closeout_volume_number () - { - FILE *vf; + { + char *name = &input_buffer[1]; + char *cursor; - vf = fopen (f_volno_file, "w"); - if (!vf) - msg_perror ("%s", f_volno_file); - else - { - fprintf (vf, "%d\n", global_volno); - fclose (vf); - } - } + for (name = input_buffer + 1; + *name == ' ' || *name == '\t'; + name++) + ; - /* We've hit the end of the old volume. Close it and open the next one */ - /* Values for type: 0: writing 1: reading 2: updating */ - int - new_volume (type) - int type; - { - int c; - char inbuf[80]; - char *p; - static FILE *read_file = 0; - extern int now_verifying; - extern char TTY_NAME[]; - static int looped = 0; - - if (!read_file && !f_run_script_at_end) - read_file = (archive == 0) ? fopen (TTY_NAME, "r") : stdin; - - if (now_verifying) - return -1; - if (f_verify) - verify_volume (); - if ((c = rmtclose (archive)) < 0) - msg_perror ("Warning: can't close %s(%d,%d)", ar_files[cur_ar_file], archive, c); - - global_volno++; - volno++; - cur_ar_file++; - if (cur_ar_file == n_ar_files) - { - cur_ar_file = 0; - looped = 1; - } + for (cursor = name; *cursor && *cursor != '\n'; cursor++) + ; + *cursor = '\0'; - tryagain: - if (looped) - { - /* We have to prompt from now on. */ - if (f_run_script_at_end) - system (info_script); - else - for (;;) - { - fprintf (msg_file, "\007Prepare volume #%d for %s and hit return: ", global_volno, ar_files[cur_ar_file]); - fflush (msg_file); - if (fgets (inbuf, sizeof (inbuf), read_file) == 0) - { - fprintf (msg_file, "EOF? What does that mean?"); - if (cmd_mode != CMD_EXTRACT && cmd_mode != CMD_LIST && cmd_mode != CMD_DIFF) - msg ("Warning: Archive is INCOMPLETE!"); - exit (EX_BADARCH); + /* FIXME: the following allocation is never reclaimed. */ + *archive_name_cursor = xstrdup (name); } - if (inbuf[0] == '\n' || inbuf[0] == 'y' || inbuf[0] == 'Y') break; - switch (inbuf[0]) - { - case '?': - { - fprintf (msg_file, "\ - n [name] Give a new filename 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 (msg_file, "No new volume; exiting.\n"); - if (cmd_mode != CMD_EXTRACT && cmd_mode != CMD_LIST && cmd_mode != CMD_DIFF) - msg ("Warning: Archive is INCOMPLETE!"); - exit (EX_BADARCH); - - case 'n': /* Get new file name */ - { - char *q, *r; - static char *old_name; - - for (q = &inbuf[1]; *q == ' ' || *q == '\t'; q++) - ; - for (r = q; *r; r++) - if (*r == '\n') - *r = '\0'; - old_name = p = (char *) malloc ((unsigned) (strlen (q) + 2)); - if (p == 0) - { - msg ("Can't allocate memory for name"); - exit (EX_SYSTEM); - } - (void) strcpy (p, q); - ar_files[cur_ar_file] = p; - } - break; - - case '!': -#ifdef __MSDOS__ - spawnl (P_WAIT, getenv ("COMSPEC"), "-", 0); -#else - /* JF this needs work! */ - switch (fork ()) - { - case -1: - msg_perror ("can't fork!"); - break; - case 0: - p = getenv ("SHELL"); - if (p == 0) - p = "/bin/sh"; - execlp (p, "-sh", "-i", 0); - msg_perror ("can't exec a shell %s", p); - _exit (55); - default: - wait (0); - break; - } -#endif - break; - } - } - } - - - if (type == 2 || f_verify) - archive = rmtopen (ar_files[cur_ar_file], O_RDWR | O_CREAT, 0666); - else if (type == 1) - archive = rmtopen (ar_files[cur_ar_file], O_RDONLY, 0666); - else if (type == 0) - archive = rmtcreat (ar_files[cur_ar_file], 0666); - else - archive = -1; + case '!': + sys_spawn_shell (); + break; + } + } + } - if (archive < 0) + if (strcmp (archive_name_cursor[0], "-") == 0) + { + read_full_records = true; + archive = STDIN_FILENO; + } + else if (verify_option) + archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW, + rsh_command_option); + else + switch (mode) { - msg_perror ("can't open %s", ar_files[cur_ar_file]); - goto tryagain; + case ACCESS_READ: + archive = rmtopen (*archive_name_cursor, O_RDONLY, MODE_RW, + rsh_command_option); + break; + + case ACCESS_WRITE: + if (backup_option) + maybe_backup_file (*archive_name_cursor, 1); + archive = rmtcreat (*archive_name_cursor, MODE_RW, + rsh_command_option); + break; + + case ACCESS_UPDATE: + archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW, + rsh_command_option); + break; } -#ifdef __MSDOS__ - setmode (archive, O_BINARY); -#endif - return 0; - } - /* this is a useless function that takes a buffer returned by wantbytes - and does nothing with it. If the function called by wantbytes returns - an error indicator (non-zero), this function is called for the rest of - the file. - */ - int - no_op (size, data) - int size; - char *data; - { - return 0; - } + if (archive < 0) + { + open_warn (*archive_name_cursor); + if (!verify_option && mode == ACCESS_WRITE && backup_option) + undo_last_backup (); + goto tryagain; + } - /* Some other routine wants SIZE bytes in the archive. For each chunk of - the archive, call FUNC with the size of the chunk, and the address of - the chunk it can work with. - */ - int - wantbytes (size, func) - long size; - int (*func) (); - { - char *data; - long data_size; + SET_BINARY_MODE (archive); - while (size) - { - data = findrec ()->charptr; - if (data == NULL) - { /* Check it... */ - msg ("Unexpected EOF on archive file"); - return -1; - } - data_size = endofrecs ()->charptr - data; - if (data_size > size) - data_size = size; - if ((*func) (data_size, data)) - func = no_op; - userec ((union record *) (data + data_size - 1)); - size -= data_size; - } - return 0; - } + return true; +}