X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fbuffer.c;h=5977f5a56ed80b17ad6723646fcb46b405928d64;hb=d659cbaccdc1f3279c49107cf15f15a639738529;hp=71843a436972b257970fe5e24d005adc2e4a8568;hpb=6eafcf3c9d4aa1c63f245c48204afe5bc9e0b3cf;p=chaz%2Ftar diff --git a/src/buffer.c b/src/buffer.c index 71843a4..5977f5a 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -1,5 +1,8 @@ /* Buffer management for tar. - Copyright (C) 1988, 92, 93, 94, 96, 97, 1999 Free Software Foundation, Inc. + + Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001, + 2003, 2004, 2005 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 @@ -14,33 +17,18 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., - 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ -#include "system.h" +#include #include -#include -time_t time (); - -#if MSDOS -# include -#endif - -#if XENIX -# include -#endif -#ifndef FNM_LEADING_DIR -# include -#endif +#include +#include +#include #include "common.h" -#include "rmt.h" - -#define DEBUG_FORK 0 /* if nonzero, childs are born stopped */ - -#define PREAD 0 /* read file descriptor from pipe() */ -#define PWRITE 1 /* write file descriptor from pipe() */ +#include /* Number of retries before giving up on read. */ #define READ_ERROR_MAX 10 @@ -50,35 +38,27 @@ time_t time (); /* Variables. */ -static tarlong total_written; /* bytes written on all volumes */ +static tarlong prev_written; /* bytes written on previous volumes */ static tarlong bytes_written; /* bytes written on this volume */ +static void *record_buffer; /* allocated memory */ -/* FIXME: The following four variables should ideally be static to this - module. However, this cannot be done yet, as update.c uses the first - three a lot, and compare.c uses the fourth. The cleanup continues! */ +/* FIXME: The following variables should ideally be static to this + module. However, this cannot be done yet. The cleanup continues! */ union block *record_start; /* start of record of archive */ union block *record_end; /* last+1 block of archive record */ union block *current_block; /* current block of archive */ enum access_mode access_mode; /* how do we handle the archive */ -static struct stat archive_stat; /* stat block for archive file */ +off_t records_read; /* number of records read from this archive */ +off_t records_written; /* likewise, for records written */ static off_t record_start_block; /* block ordinal at record_start */ -/* Where we write list messages (not errors, not interactions) to. Stdout - unless we're writing a pipe, in which case stderr. */ +/* Where we write list messages (not errors, not interactions) to. */ FILE *stdlis; -static void backspace_output PARAMS ((void)); -static int new_volume PARAMS ((enum access_mode)); -static void 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); +static bool new_volume (enum access_mode); /* PID of child program, if compress_option or remote archive access. */ static pid_t child_pid; @@ -87,17 +67,20 @@ static pid_t child_pid; static int read_error_count; /* Have we hit EOF yet? */ -static int hit_eof; +static bool hit_eof; /* Checkpointing counter */ static int checkpoint; -/* We're reading, but we just read the last block and its time to update. */ -/* As least EXTERN like this one as possible. FIXME! */ -extern int time_to_start_writing; +static bool read_full_records = false; + +/* We're reading, but we just read the last block and it's time to update. + Declared in update.c -int file_to_switch_to = -1; /* if remote update, close archive, and use - this descriptor to write to */ + 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 */ @@ -114,106 +97,204 @@ static int global_volno = 1; /* volume number to print in external 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 */ + valid if save_name is nonzero */ off_t save_sizeleft; /* where we are in the file we are writing, only valid if save_name is nonzero */ -int write_archive_to_stdout = 0; +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 = NULL; +static char *real_s_name; static off_t real_s_totsize; static off_t real_s_sizeleft; /* Functions. */ -#if DEBUG_FORK +void +clear_read_error_count (void) +{ + read_error_count = 0; +} + + +/* Time-related functions */ + +double duration; -static pid_t -myfork (void) +void +set_start_time () { - pid_t result = fork(); + gettime (&start_time); +} - if (result == 0) - kill (getpid (), SIGSTOP); - return result; +void +compute_duration () +{ + struct timespec now; + gettime (&now); + duration += ((now.tv_sec - start_time.tv_sec) + + (now.tv_nsec - start_time.tv_nsec) / 1e9); + set_start_time (); } -# define fork myfork + +/* Compression detection */ + +enum compress_type { + ct_none, + ct_compress, + ct_gzip, + ct_bzip2 +}; + +struct zip_magic +{ + enum compress_type type; + size_t length; + char *magic; + char *program; + char *option; +}; + +static struct zip_magic const magic[] = { + { ct_none, }, + { ct_compress, 2, "\037\235", "compress", "-Z" }, + { ct_gzip, 2, "\037\213", "gzip", "-z" }, + { ct_bzip2, 3, "BZh", "bzip2", "-j" }, +}; + +#define NMAGIC (sizeof(magic)/sizeof(magic[0])) + +#define compress_option(t) magic[t].option +#define compress_program(t) magic[t].program + +/* Check if the file ARCHIVE is a compressed archive. */ +enum compress_type +check_compressed_archive () +{ + struct zip_magic const *p; + bool sfr; + + /* Prepare global data needed for find_next_block: */ + record_end = record_start; /* set up for 1st record = # 0 */ + sfr = read_full_records; + read_full_records = true; /* Suppress fatal error on reading a partial + record */ + find_next_block (); -#endif /* DEBUG FORK */ + /* Restore global values */ + read_full_records = sfr; -void -init_total_written (void) + 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 () { - clear_tarlong (total_written); - clear_tarlong (bytes_written); + archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY, + MODE_RW, rsh_command_option); + if (archive == -1) + return archive; + + if (!multi_volume_option) + { + enum compress_type type = check_compressed_archive (); + + if (type == ct_none) + return archive; + + /* FD is not needed any more */ + rmtclose (archive); + + hit_eof = false; /* It might have been set by find_next_block in + check_compressed_archive */ + + /* Open compressed archive */ + use_compress_program_option = compress_program (type); + child_pid = sys_child_open_for_uncompress (); + read_full_records = true; + } + + records_read = 0; + record_end = record_start; /* set up for 1st record = # 0 */ + + return archive; } + void print_total_written (void) { - fprintf (stderr, _("Total bytes written: ")); - print_tarlong (total_written, stderr); - fprintf (stderr, "\n"); -} + 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 human_opts = human_autoscale | human_base_1024 | human_SI | human_B; + + sprintf (bytes, TARLONG_FORMAT, written); -/*--------------------------------------------------------. -| Compute and return the block ordinal at current_block. | -`--------------------------------------------------------*/ + /* 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) + : "?")); +} +/* Compute and return the block ordinal at current_block. */ off_t current_block_ordinal (void) { return record_start_block + (current_block - record_start); } -/*------------------------------------------------------------------. -| If the EOF flag is set, reset it, as well as current_block, etc. | -`------------------------------------------------------------------*/ - +/* If the EOF flag is set, reset it, as well as current_block, etc. */ void reset_eof (void) { if (hit_eof) { - hit_eof = 0; + hit_eof = false; current_block = record_start; record_end = record_start + blocking_factor; access_mode = ACCESS_WRITE; } } -/*-------------------------------------------------------------------------. -| 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. | -`-------------------------------------------------------------------------*/ - +/* 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 NULL; + return 0; flush_archive (); if (current_block == record_end) { - hit_eof = 1; - return NULL; + hit_eof = true; + return 0; } } return current_block; } -/*------------------------------------------------------. -| Indicate that we have used all blocks up thru BLOCK. | -| | -| FIXME: should the arg have an off-by-1? | -`------------------------------------------------------*/ - +/* Indicate that we have used all blocks up thru BLOCK. */ void set_next_block_after (union block *block) { @@ -228,439 +309,42 @@ set_next_block_after (union block *block) abort (); } -/*------------------------------------------------------------------------. -| 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. | -`------------------------------------------------------------------------*/ - +/* 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 unsucessful. | -`------------------------------------------------------------------*/ - -static void +/* Close file having descriptor FD, and abort if close unsuccessful. */ +void xclose (int fd) { - if (close (fd) < 0) - FATAL_ERROR ((0, errno, _("Cannot close file #%d"), fd)); -} - -/*-----------------------------------------------------------------------. -| Duplicate file descriptor FROM into becoming INTO, or else, issue | -| MESSAGE. INTO is closed first and has to be the next available slot. | -`-----------------------------------------------------------------------*/ - -static void -xdup2 (int from, int into, const char *message) -{ - 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); - } -} - -#if MSDOS - -/*-------------------------------------------------------. -| Set ARCHIVE for writing, then compressing an archive. | -`-------------------------------------------------------*/ - -static void -child_open_for_compress (void) -{ - FATAL_ERROR ((0, 0, _("Cannot use compressed or remote archives"))); -} - -/*---------------------------------------------------------. -| Set ARCHIVE for uncompressing, then reading an archive. | -`---------------------------------------------------------*/ - -static void -child_open_for_uncompress (void) -{ - FATAL_ERROR ((0, 0, _("Cannot use compressed or remote archives"))); -} - -#else /* not MSDOS */ - -/*---------------------------------------------------------------------. -| Return nonzero if NAME is the name of a regular file, or if the file | -| does not exist (so it would be created as a regular file). | -`---------------------------------------------------------------------*/ - -static int -is_regular_file (const char *name) -{ - struct stat stbuf; - - if (stat (name, &stbuf) < 0) - return 1; - - if (S_ISREG (stbuf.st_mode)) - return 1; - - return 0; -} - -static ssize_t -write_archive_buffer (void) -{ - ssize_t status; - ssize_t written = 0; - - 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; - } - - return written ? written : status; -} - -/*-------------------------------------------------------. -| Set ARCHIVE for writing, then compressing an archive. | -`-------------------------------------------------------*/ - -static void -child_open_for_compress (void) -{ - int parent_pipe[2]; - int child_pipe[2]; - pid_t grandchild_pid; - - if (pipe (parent_pipe) < 0) - FATAL_ERROR ((0, errno, _("Cannot open pipe"))); - - child_pid = fork (); - if (child_pid < 0) - FATAL_ERROR ((0, errno, _("Cannot fork"))); - - if (child_pid > 0) - { - /* The parent tar is still here! Just clean up. */ - - archive = parent_pipe[PWRITE]; - xclose (parent_pipe[PREAD]); - return; - } - - /* The new born child tar is here! */ - - program_name = _("tar (child)"); - - xdup2 (parent_pipe[PREAD], STDIN_FILENO, _("(child) Pipe to stdin")); - xclose (parent_pipe[PWRITE]); - - /* 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 (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); - - /* We don't need a grandchild tar. Open the archive and launch the - compressor. */ - - archive = creat (archive_name_array[0], MODE_RW); - if (archive < 0) - { - int saved_errno = errno; - - 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)); - } - - /* 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) - { - /* 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)); - } - - /* The new born grandchild tar is here! */ - - program_name = _("tar (grandchild)"); - - /* Prepare for reblocking the data from the compressor into the archive. */ - - xdup2 (child_pipe[PREAD], STDIN_FILENO, _("(grandchild) Pipe to stdin")); - xclose (child_pipe[PWRITE]); - - 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])); - - /* Let's read out of the stdin pipe and write an archive. */ - - while (1) - { - ssize_t status = 0; - char *cursor; - size_t length; - - /* Assemble a record. */ - - for (length = 0, cursor = record_start->buffer; - length < record_size; - length += status, cursor += status) - { - size_t size = record_size - length; - - if (size < BLOCKSIZE) - size = BLOCKSIZE; - status = full_read (STDIN_FILENO, cursor, size); - if (status <= 0) - break; - } - - if (status < 0) - FATAL_ERROR ((0, errno, _("Cannot read from compression program"))); - - /* Copy the record. */ - - if (status == 0) - { - /* We hit the end of the file. Write last record at - full length, as the only role of the grandchild is - doing proper reblocking. */ - - if (length > 0) - { - memset (record_start->buffer + length, 0, record_size - length); - status = write_archive_buffer (); - if (status != record_size) - write_error (status); - } - - /* There is nothing else to read, break out. */ - break; - } - - status = write_archive_buffer (); - if (status != record_size) - write_error (status); - } - -#if 0 - close_archive (); -#endif - exit (exit_status); -} - -/*---------------------------------------------------------. -| Set ARCHIVE for uncompressing, then reading an archive. | -`---------------------------------------------------------*/ - -static void -child_open_for_uncompress (void) -{ - int parent_pipe[2]; - int child_pipe[2]; - pid_t grandchild_pid; - - if (pipe (parent_pipe) < 0) - FATAL_ERROR ((0, errno, _("Cannot open pipe"))); - - child_pid = fork (); - if (child_pid < 0) - FATAL_ERROR ((0, errno, _("Cannot fork"))); - - if (child_pid > 0) - { - /* The parent tar is still here! Just clean up. */ - - read_full_records_option = 1; - archive = parent_pipe[PREAD]; - xclose (parent_pipe[PWRITE]); - return; - } - - /* The new born child tar is here! */ - - program_name = _("tar (child)"); - - xdup2 (parent_pipe[PWRITE], STDOUT_FILENO, _("(child) Pipe to stdout")); - xclose (parent_pipe[PREAD]); - - /* 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. */ - - if (strcmp (archive_name_array[0], "-") != 0 - && !_remdev (archive_name_array[0]) - && is_regular_file (archive_name_array[0])) - { - /* We don't need a grandchild tar. Open the archive and lauch the - uncompressor. */ - - archive = open (archive_name_array[0], O_RDONLY | O_BINARY, MODE_RW); - if (archive < 0) - 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)); - } - - /* 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) - { - /* 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)); - } - - /* The new born grandchild tar is here! */ - - program_name = _("tar (grandchild)"); - - /* Prepare for unblocking the data from the archive into the uncompressor. */ - - xdup2 (child_pipe[PWRITE], STDOUT_FILENO, _("(grandchild) Pipe to stdout")); - xclose (child_pipe[PREAD]); - - if (strcmp (archive_name_array[0], "-") == 0) - archive = STDIN_FILENO; - else - archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY, - MODE_RW, rsh_command_option); - if (archive < 0) - FATAL_ERROR ((0, errno, _("Cannot open archive %s"), - archive_name_array[0])); - - /* Let's read the archive and pipe it into stdout. */ - - while (1) - { - char *cursor; - size_t maximum; - size_t count; - ssize_t status; - - read_error_count = 0; - - error_loop: - status = rmtread (archive, record_start->buffer, record_size); - if (status < 0) - { - 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"))); - - if (status != count) - { - ERROR ((0, 0, _("\ -Write to compression program short %lu bytes"), - (unsigned long) (count - status))); - count = status; - } - - cursor += count; - maximum -= count; - } - } - -#if 0 - close_archive (); -#endif - exit (exit_status); + if (close (fd) != 0) + close_error (_("(pipe)")); } -#endif /* not MSDOS */ - -/*--------------------------------------------------------------------------. -| Check the LABEL block against the volume label, seen as a globbing | -| pattern. Return true if the pattern matches. In case of failure, retry | -| matching a volume sequence number before giving up in multi-volume mode. | -`--------------------------------------------------------------------------*/ - -static int +/* Check 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) { char *string; - int result; + bool result; + + if (! memchr (label->header.name, '\0', sizeof label->header.name)) + return false; if (fnmatch (volume_label_option, label->header.name, 0) == 0) - return 1; + return true; if (!multi_volume_option) - return 0; + return false; string = xmalloc (strlen (volume_label_option) + sizeof VOLUME_LABEL_APPEND + 1); @@ -671,17 +355,21 @@ check_label_pattern (union block *label) return result; } -/*------------------------------------------------------------------------. -| Open an archive file. The argument specifies whether we are reading or | -| writing, or both. | -`------------------------------------------------------------------------*/ - +/* Open an archive file. The argument specifies whether we are + reading or writing, or both. */ void -open_archive (enum access_mode access) +open_archive (enum access_mode wanted_access) { int backed_up_flag = 0; - stdlis = to_stdout_option ? stderr : stdout; + if (index_file_name) + { + stdlis = fopen (index_file_name, "w"); + if (! stdlis) + open_error (index_file_name); + } + else + stdlis = to_stdout_option ? stderr : stdout; if (record_size == 0) FATAL_ERROR ((0, 0, _("Invalid value for record_size"))); @@ -689,77 +377,69 @@ open_archive (enum access_mode access) if (archive_names == 0) FATAL_ERROR ((0, 0, _("No archive name given"))); - current_file_name = NULL; - current_link_name = NULL; - - /* 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 (!real_s_name) - real_s_name = (char *) xmalloc (PATH_MAX); - /* FIXME: real_s_name is never freed. */ - - save_name = NULL; + tar_stat_destroy (¤t_stat_info); + save_name = 0; + real_s_name = 0; + record_start = + page_aligned_alloc (&record_buffer, + (record_size + + (multi_volume_option ? 2 * BLOCKSIZE : 0))); if (multi_volume_option) - { - record_start - = (union block *) valloc (record_size + (2 * BLOCKSIZE)); - if (record_start) - record_start += 2; - } - 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_start += 2; 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; + access_mode = wanted_access == ACCESS_UPDATE ? ACCESS_READ : wanted_access; + + read_full_records = read_full_records_option; - if (multi_volume_option && verify_option) - FATAL_ERROR ((0, 0, _("Cannot verify multi-volume archives"))); + records_read = 0; if (use_compress_program_option) { - if (multi_volume_option) - FATAL_ERROR ((0, 0, _("Cannot use multi-volume compressed archives"))); - if (verify_option) - FATAL_ERROR ((0, 0, _("Cannot verify compressed archives"))); - - switch (access) + switch (wanted_access) { case ACCESS_READ: - child_open_for_uncompress (); + 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_open_for_compress (); + child_pid = sys_child_open_for_compress (); break; case ACCESS_UPDATE: - FATAL_ERROR ((0, 0, _("Cannot update compressed archives"))); + abort (); /* Should not happen */ break; } - if (access == ACCESS_WRITE && strcmp (archive_name_array[0], "-") == 0) + if (wanted_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 */ + read_full_records = true; /* could be a pipe, be safe */ if (verify_option) FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive"))); - switch (access) + switch (wanted_access) { case ACCESS_READ: - archive = STDIN_FILENO; + { + 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: @@ -770,7 +450,7 @@ open_archive (enum access_mode access) case ACCESS_UPDATE: archive = STDIN_FILENO; stdlis = stderr; - write_archive_to_stdout = 1; + write_archive_to_stdout = true; break; } } @@ -778,11 +458,10 @@ open_archive (enum access_mode access) archive = rmtopen (archive_name_array[0], O_RDWR | O_CREAT | O_BINARY, MODE_RW, rsh_command_option); else - switch (access) + switch (wanted_access) { case ACCESS_READ: - archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY, - MODE_RW, rsh_command_option); + archive = open_compressed_archive (); break; case ACCESS_WRITE: @@ -802,50 +481,27 @@ open_archive (enum access_mode access) } if (archive < 0 - || (! _isrmt (archive) && fstat (archive, &archive_stat) < 0)) + || (! _isrmt (archive) && !sys_get_archive_stat ())) { int saved_errno = errno; if (backed_up_flag) undo_last_backup (); - FATAL_ERROR ((0, saved_errno, _("Cannot open %s"), - archive_name_array[0])); + errno = saved_errno; + open_fatal (archive_name_array[0]); } -#if !MSDOS + sys_detect_dev_null_output (); + sys_save_archive_dev_ino (); + SET_BINARY_MODE (archive); - /* 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) - && stat (dev_null, &dev_null_stat) == 0 - && S_ISCHR (archive_stat.st_mode) - && archive_stat.st_rdev == dev_null_stat.st_rdev)); - } - - 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; - -#endif /* not MSDOS */ - -#if MSDOS - setmode (archive, O_BINARY); -#endif - - switch (access) + switch (wanted_access) { - case ACCESS_READ: case ACCESS_UPDATE: + records_written = 0; record_end = record_start; /* set up for 1st record = # 0 */ + + case ACCESS_READ: find_next_block (); /* read it in, check for EOF */ if (volume_label_option) @@ -853,41 +509,40 @@ open_archive (enum access_mode access) union block *label = find_next_block (); if (!label) - FATAL_ERROR ((0, 0, _("Archive not labelled to match `%s'"), - volume_label_option)); + 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'"), - label->header.name, volume_label_option)); + FATAL_ERROR ((0, 0, _("Volume %s does not match %s"), + quote_n (0, label->header.name), + quote_n (1, volume_label_option))); } break; case ACCESS_WRITE: + records_written = 0; if (volume_label_option) { - memset ((void *) record_start, 0, BLOCKSIZE); + memset (record_start, 0, BLOCKSIZE); if (multi_volume_option) sprintf (record_start->header.name, "%s Volume 1", volume_label_option); else strcpy (record_start->header.name, volume_label_option); - assign_string (¤t_file_name, record_start->header.name); + 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); record_start->header.typeflag = GNUTYPE_VOLHDR; - TIME_TO_OCT (time (0), record_start->header.mtime); - finish_header (record_start); -#if 0 - current_block++; -#endif + 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. | -`--------------------------------------*/ - +/* Perform a write to flush the buffer. */ void flush_write (void) { @@ -895,51 +550,48 @@ flush_write (void) 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 (!zerop_tarlong (tape_length_option) - && !lessp_tarlong (bytes_written, tape_length_option)) + if (tape_length_option && tape_length_option <= bytes_written) { - errno = ENOSPC; /* FIXME: errno should be read-only */ + errno = ENOSPC; status = 0; } else if (dev_null_output) status = record_size; else - status = write_archive_buffer (); + status = sys_write_archive_buffer (); if (status != record_size && !multi_volume_option) - write_error (status); - else if (totals_option) - add_to_tarlong (total_written, record_size); + archive_write_error (status); if (status > 0) - add_to_tarlong (bytes_written, status); + { + records_written++; + bytes_written += status; + } if (status == record_size) { if (multi_volume_option) { - char *cursor; - - if (!save_name) + if (save_name) { - real_s_name[0] = '\0'; + assign_string (&real_s_name, + safer_name_suffix (save_name, false, + absolute_names_option)); + real_s_totsize = save_totsize; + real_s_sizeleft = save_sizeleft; + } + else + { + assign_string (&real_s_name, 0); real_s_totsize = 0; real_s_sizeleft = 0; - return; } - - cursor = save_name; -#if MSDOS - if (cursor[1] == ':') - cursor += 2; -#endif - while (*cursor == '/') - cursor++; - - strcpy (real_s_name, cursor); - real_s_totsize = save_totsize; - real_s_sizeleft = save_sizeleft; } return; } @@ -948,21 +600,23 @@ flush_write (void) /* ENXIO is for the UNIX PC. */ if (status < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO) - write_error (status); + archive_write_error (status); /* If error indicates a short write, we just move to the next tape. */ if (!new_volume (ACCESS_WRITE)) return; - clear_tarlong (bytes_written); + if (totals_option) + prev_written += bytes_written; + bytes_written = 0; - if (volume_label_option && real_s_name[0]) + if (volume_label_option && real_s_name) { copy_back = 2; record_start -= 2; } - else if (volume_label_option || real_s_name[0]) + else if (volume_label_option || real_s_name) { copy_back = 1; record_start--; @@ -972,71 +626,71 @@ flush_write (void) if (volume_label_option) { - memset ((void *) record_start, 0, BLOCKSIZE); - sprintf (record_start->header.name, "%s Volume %d", volume_label_option, volno); - TIME_TO_OCT (time (0), record_start->header.mtime); + 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 (record_start); + finish_header (¤t_stat_info, record_start, -1); } - if (real_s_name[0]) + if (real_s_name) { int tmp; if (volume_label_option) record_start++; - memset ((void *) record_start, 0, BLOCKSIZE); + 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. */ - strcpy (record_start->header.name, real_s_name); + strncpy (record_start->header.name, real_s_name, NAME_FIELD_SIZE); record_start->header.typeflag = GNUTYPE_MULTIVOL; - OFF_TO_OCT (real_s_sizeleft, record_start->header.size); - OFF_TO_OCT (real_s_totsize - real_s_sizeleft, - record_start->oldgnu_header.offset); + + 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); + finish_header (¤t_stat_info, record_start, -1); verbose_option = tmp; if (volume_label_option) record_start--; } - status = write_archive_buffer (); + status = sys_write_archive_buffer (); if (status != record_size) - write_error (status); - else if (totals_option) - add_to_tarlong (total_written, record_size); + archive_write_error (status); + + bytes_written += status; - add_to_tarlong (bytes_written, record_size); if (copy_back) { record_start += copy_back; - memcpy ((void *) current_block, - (void *) (record_start + blocking_factor - copy_back), - (size_t) (copy_back * BLOCKSIZE)); + 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) - real_s_name[0] = '\0'; + assign_string (&real_s_name, 0); else { - char *cursor = save_name; - -#if MSDOS - if (cursor[1] == ':') - cursor += 2; -#endif - while (*cursor == '/') - cursor++; - - strcpy (real_s_name, cursor); + assign_string (&real_s_name, + safer_name_suffix (save_name, false, + absolute_names_option)); real_s_sizeleft = save_sizeleft; real_s_totsize = save_totsize; } @@ -1044,40 +698,30 @@ flush_write (void) } } -/*---------------------------------------------------------------------. -| 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) +/* 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) { - int saved_errno = errno; - /* It might be useful to know how much was written before the error - occured. Beware that mere printing maybe change errno value. */ + occurred. */ if (totals_option) - print_total_written (); + { + int e = errno; + print_total_written (); + errno = e; + } - 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)); + write_fatal_details (*archive_name_cursor, status, record_size); } -/*-------------------------------------------------------------------. -| Handle read errors on the archive. If the read should be retried, | -| returns to the caller. | -`-------------------------------------------------------------------*/ - -static void -read_error (void) +/* Handle read errors on the archive. If the read should be retried, + return to the caller. */ +void +archive_read_error (void) { - WARN ((0, errno, _("Read error on %s"), *archive_name_cursor)); + read_error (*archive_name_cursor); if (record_start_block == 0) FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now"))); @@ -1090,18 +734,71 @@ read_error (void) return; } -/*-------------------------------------. -| Perform a read to flush the buffer. | -`-------------------------------------*/ +static void +short_read (size_t status) +{ + size_t left; /* bytes left */ + char *more; /* pointer to next byte to read */ + + more = record_start->buffer + status; + left = record_size - status; + + while (left % BLOCKSIZE != 0 + || (left && status && read_full_records)) + { + 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; + } + + /* 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) + { + unsigned long rsize = (record_size - left) / BLOCKSIZE; + WARN ((0, 0, + ngettext ("Record size = %lu block", + "Record size = %lu blocks", + rsize), + rsize)); + } + + record_end = record_start + (record_size - left) / BLOCKSIZE; + records_read++; +} + +/* Perform a read to flush the buffer. */ void flush_read (void) { - ssize_t status; /* result from system call */ - size_t left; /* bytes left */ - char *more; /* pointer to next byte to read */ + 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 @@ -1111,43 +808,46 @@ flush_read (void) if (write_archive_to_stdout && record_start_block != 0) { - status = write_archive_buffer (); + archive = STDOUT_FILENO; + status = sys_write_archive_buffer (); + archive = STDIN_FILENO; if (status != record_size) - write_error (status); + archive_write_error (status); } if (multi_volume_option) { if (save_name) { - char *cursor = save_name; - -#if MSDOS - if (cursor[1] == ':') - cursor += 2; -#endif - while (*cursor == '/') - cursor++; - - strcpy (real_s_name, cursor); + 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: + error_loop: status = rmtread (archive, record_start->buffer, record_size); if (status == record_size) - return; + { + 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 < 0 && errno == ENOSPC) - || (status > 0 && !read_full_records_option)) + || (status == SAFE_READ_ERROR && errno == ENOSPC)) && multi_volume_option) { union block *cursor; @@ -1168,15 +868,12 @@ error_loop: break; } - vol_error: - status = rmtread (archive, record_start->buffer, record_size); - if (status < 0) - { - read_error (); - goto vol_error; - } + while ((status = rmtread (archive, record_start->buffer, record_size)) + == SAFE_READ_ERROR) + archive_read_error (); + if (status != record_size) - goto short_read; + short_read (status); cursor = record_start; @@ -1186,42 +883,43 @@ error_loop: { if (!check_label_pattern (cursor)) { - WARN ((0, 0, _("Volume `%s' does not match `%s'"), - cursor->header.name, volume_label_option)); + 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; } } if (verbose_option) - fprintf (stdlis, _("Reading %s\n"), cursor->header.name); + 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) { uintmax_t s1, s2; if (cursor->header.typeflag != GNUTYPE_MULTIVOL - || strcmp (cursor->header.name, real_s_name)) + || strncmp (cursor->header.name, real_s_name, NAME_FIELD_SIZE)) { WARN ((0, 0, _("%s is not continued on this volume"), - real_s_name)); + quote (real_s_name))); volno--; global_volno--; goto try_volume; } - s1 = UINTMAX_FROM_OCT (cursor->header.size); - s2 = UINTMAX_FROM_OCT (cursor->oldgnu_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) { 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, + quote (cursor->header.name), STRINGIFY_BIGINT (save_totsize, totsizebuf), STRINGIFY_BIGINT (s1, s1buf), STRINGIFY_BIGINT (s2, s2buf))); @@ -1230,7 +928,7 @@ error_loop: goto try_volume; } if (real_s_totsize - real_s_sizeleft - != OFF_FROM_OCT (cursor->oldgnu_header.offset)) + != OFF_FROM_HEADER (cursor->oldgnu_header.offset)) { WARN ((0, 0, _("This volume is out of sequence"))); volno--; @@ -1240,63 +938,19 @@ error_loop: cursor++; } current_block = cursor; + records_read++; return; } - else if (status < 0) + else if (status == SAFE_READ_ERROR) { - read_error (); + archive_read_error (); goto error_loop; /* try again */ } -short_read: - more = record_start->buffer + status; - left = record_size - status; - -again: - if (left % BLOCKSIZE == 0) - { - /* FIXME: for size=0, multi-volume support. On the first record, warn - about the problem. */ - - if (!read_full_records_option && verbose_option - && record_start_block == 0 && status > 0) - WARN ((0, 0, _("Record size = %lu blocks"), - (unsigned long) (status / BLOCKSIZE))); - - record_end = record_start + (record_size - left) / BLOCKSIZE; - - return; - } - if (read_full_records_option) - { - /* User warned us about this. Fix up. */ - - if (left > 0) - { - error2loop: - status = rmtread (archive, more, left); - if (status < 0) - { - read_error (); - goto error2loop; /* try again */ - } - if (status == 0) - FATAL_ERROR ((0, 0, _("Archive %s EOF not on block boundary"), - *archive_name_cursor)); - left -= status; - more += status; - goto again; - } - } - else - FATAL_ERROR ((0, 0, _("Only read %lu bytes from archive %s"), - (unsigned long) status, *archive_name_cursor)); + short_read (status); } -/*-----------------------------------------------. -| Flush the current buffer to/from the archive. | -`-----------------------------------------------*/ - +/* Flush the current buffer to/from the archive. */ void flush_archive (void) { @@ -1307,20 +961,8 @@ flush_archive (void) if (access_mode == ACCESS_READ && time_to_start_writing) { access_mode = ACCESS_WRITE; - time_to_start_writing = 0; - - if (file_to_switch_to >= 0) - { - int status = rmtclose (archive); - - if (status < 0) - WARN ((0, errno, _("WARNING: Cannot close %s (%d, %d)"), - *archive_name_cursor, archive, status)); - - archive = file_to_switch_to; - } - else - backspace_output (); + time_to_start_writing = false; + backspace_output (); } switch (access_mode) @@ -1338,12 +980,9 @@ flush_archive (void) } } -/*-------------------------------------------------------------------------. -| 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! | -`-------------------------------------------------------------------------*/ - +/* 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) { @@ -1366,124 +1005,87 @@ backspace_output (void) /* 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, _("\ -Could not backspace archive file; it may be unreadable without -i"))); + 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, - (size_t) (output_start - record_start->buffer)); + output_start - record_start->buffer); } } } -/*-------------------------. -| Close the archive file. | -`-------------------------*/ - -void -close_archive (void) +off_t +seek_archive (off_t size) { - if (time_to_start_writing || access_mode == ACCESS_WRITE) - flush_archive (); - -#if !MSDOS + off_t start = current_block_ordinal (); + off_t offset; + off_t nrec, nblk; + off_t skipped = (blocking_factor - (current_block - record_start)); - /* 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. */ + size -= skipped * BLOCKSIZE; - if (access_mode == ACCESS_READ - && ! _isrmt (archive) - && S_ISFIFO (archive_stat.st_mode)) - while (rmtread (archive, record_start->buffer, record_size) > 0) - continue; -#endif + if (size < record_size) + return 0; + /* FIXME: flush? */ - if (! _isrmt (archive) && subcommand_option == DELETE_SUBCOMMAND) - { -#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)); - } - if (verify_option) - verify_volume (); + /* Compute number of records to skip */ + nrec = size / record_size; + offset = rmtlseek (archive, nrec * record_size, SEEK_CUR); + if (offset < 0) + return offset; - { - int status = rmtclose (archive); + if (offset % record_size) + FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary"))); - if (status < 0) - WARN ((0, errno, _("WARNING: Cannot close %s (%d, %d)"), - *archive_name_cursor, archive, status)); - } + /* Convert to number of records */ + offset /= BLOCKSIZE; + /* Compute number of skipped blocks */ + nblk = offset - start; -#if !MSDOS + /* Update buffering info */ + records_read += nblk / blocking_factor; + record_start_block = offset - blocking_factor; + current_block = record_end; - if (child_pid) - { - WAIT_T wait_status; - pid_t child; + return nblk; +} - /* Loop waiting for the right child to die, or for no more kids. */ +/* Close the archive file. */ +void +close_archive (void) +{ + if (time_to_start_writing || access_mode == ACCESS_WRITE) + flush_archive (); - while ((child = wait (&wait_status), child != child_pid) - && child != -1) - continue; + sys_drain_input_pipe (); - if (child != -1) - { - if (WIFSIGNALED (wait_status) -#if 0 - && !WIFSTOPPED (wait_status) -#endif - ) - { - /* SIGPIPE is OK, everything else is a problem. */ + compute_duration (); + if (verify_option) + verify_volume (); - if (WTERMSIG (wait_status) != SIGPIPE) - ERROR ((0, 0, _("Child died with signal %d%s"), - WTERMSIG (wait_status), - WCOREDUMP (wait_status) ? _(" (core dumped)") : "")); - } - else - { - /* Child voluntarily terminated -- but why? /bin/sh returns - SIGPIPE + 128 if its child, then do nothing. */ + if (rmtclose (archive) != 0) + close_warn (*archive_name_cursor); - if (WEXITSTATUS (wait_status) != (SIGPIPE + 128) - && WEXITSTATUS (wait_status)) - ERROR ((0, 0, _("Child returned status %d"), - WEXITSTATUS (wait_status))); - } - } - } -#endif /* !MSDOS */ + sys_wait_for_child (child_pid); - if (current_file_name) - free (current_file_name); - if (current_link_name) - free (current_link_name); + tar_stat_destroy (¤t_stat_info); if (save_name) free (save_name); - free (multi_volume_option ? record_start - 2 : record_start); + if (real_s_name) + free (real_s_name); + free (record_buffer); } -/*------------------------------------------------. -| Called to initialize the global volume number. | -`------------------------------------------------*/ - +/* Called to initialize the global volume number. */ void init_volume_number (void) { @@ -1491,18 +1093,20 @@ init_volume_number (void) if (file) { - fscanf (file, "%d", &global_volno); - if (fclose (file) == EOF) - ERROR ((0, errno, "%s", volno_file_option)); + if (fscanf (file, "%d", &global_volno) != 1 + || global_volno < 0) + FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"), + quotearg_colon (volno_file_option))); + if (ferror (file)) + read_error (volno_file_option); + if (fclose (file) != 0) + close_error (volno_file_option); } else if (errno != ENOENT) - ERROR ((0, errno, "%s", volno_file_option)); + open_error (volno_file_option); } -/*-------------------------------------------------------. -| Called to write out the closing global volume number. | -`-------------------------------------------------------*/ - +/* Called to write out the closing global volume number. */ void closeout_volume_number (void) { @@ -1511,40 +1115,39 @@ closeout_volume_number (void) if (file) { fprintf (file, "%d\n", global_volno); - if (fclose (file) == EOF) - ERROR ((0, errno, "%s", volno_file_option)); + if (ferror (file)) + write_error (volno_file_option); + if (fclose (file) != 0) + close_error (volno_file_option); } else - ERROR ((0, errno, "%s", volno_file_option)); + open_error (volno_file_option); } -/*-----------------------------------------------------------------------. -| We've hit the end of the old volume. Close it and open the next one. | -| Return nonzero on success. | -`-----------------------------------------------------------------------*/ - -static int -new_volume (enum access_mode access) +/* 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 = NULL; - static int looped = 0; - - int status; + 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 0; + return false; if (verify_option) verify_volume (); - if (status = rmtclose (archive), status < 0) - WARN ((0, errno, _("WARNING: Cannot close %s (%d, %d)"), - *archive_name_cursor, archive, status)); + if (rmtclose (archive) != 0) + close_warn (*archive_name_cursor); 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) @@ -1553,7 +1156,7 @@ new_volume (enum access_mode access) looped = 1; } -tryagain: + tryagain: if (looped) { /* We have to prompt from now on. */ @@ -1562,7 +1165,9 @@ tryagain: { if (volno_file_option) closeout_volume_number (); - system (info_script_option); + if (system (info_script_option) != 0) + FATAL_ERROR ((0, 0, _("%s command failed"), + quote (info_script_option))); } else while (1) @@ -1572,19 +1177,19 @@ tryagain: fputc ('\007', stderr); fprintf (stderr, _("Prepare volume #%d for %s and hit return: "), - global_volno, *archive_name_cursor); + global_volno, quote (*archive_name_cursor)); fflush (stderr); - if (fgets (input_buffer, sizeof (input_buffer), read_file) == 0) + if (fgets (input_buffer, sizeof input_buffer, read_file) == 0) { - fprintf (stderr, _("EOF where user reply was expected")); + 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"))); - exit (TAREXIT_FAILURE); + fatal_exit (); } if (input_buffer[0] == '\n' || input_buffer[0] == 'y' @@ -1595,6 +1200,7 @@ tryagain: { 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\ @@ -1606,14 +1212,14 @@ tryagain: case 'q': /* Quit. */ - fprintf (stdlis, _("No new volume; exiting.\n")); + 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"))); - exit (TAREXIT_FAILURE); + fatal_exit (); case 'n': /* Get new file name. */ @@ -1622,11 +1228,13 @@ tryagain: char *name = &input_buffer[1]; char *cursor; - while (*name == ' ' || *name == '\t') - name++; - cursor = name; - while (*cursor && *cursor != '\n') - cursor++; + for (name = input_buffer + 1; + *name == ' ' || *name == '\t'; + name++) + ; + + for (cursor = name; *cursor && *cursor != '\n'; cursor++) + ; *cursor = '\0'; /* FIXME: the following allocation is never reclaimed. */ @@ -1635,49 +1243,22 @@ tryagain: break; case '!': -#if MSDOS - spawnl (P_WAIT, getenv ("COMSPEC"), "-", 0); -#else /* not MSDOS */ - switch (fork ()) - { - case -1: - WARN ((0, errno, _("Cannot fork!"))); - break; - - case 0: - { - const char *shell = getenv ("SHELL"); - - if (shell == NULL) - shell = "/bin/sh"; - execlp (shell, "-sh", "-i", 0); - FATAL_ERROR ((0, errno, _("Cannot exec a shell %s"), - shell)); - } - - default: - { - WAIT_T wait_status; - - wait (&wait_status); - } - break; - } - - /* FIXME: I'm not sure if that's all that has to be done - here. (jk) */ - -#endif /* not MSDOS */ + sys_spawn_shell (); break; } } } - if (verify_option) + 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 (access) + switch (mode) { case ACCESS_READ: archive = rmtopen (*archive_name_cursor, O_RDONLY, MODE_RW, @@ -1699,15 +1280,13 @@ tryagain: if (archive < 0) { - WARN ((0, errno, _("Cannot open %s"), *archive_name_cursor)); - if (!verify_option && access == ACCESS_WRITE && backup_option) + open_warn (*archive_name_cursor); + if (!verify_option && mode == ACCESS_WRITE && backup_option) undo_last_backup (); goto tryagain; } -#if MSDOS - setmode (archive, O_BINARY); -#endif + SET_BINARY_MODE (archive); - return 1; + return true; }