X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fbuffer.c;h=d29ccccef279350575905ec718a9326e32888264;hb=0e041a7bfe4655f4b2ffe4ce3f5ebe942a0151f0;hp=4ff57af73d69bf227bfdc3de8cb64f856c06c154;hpb=7f91a90a9c09ef660d5c7f13a26f0bb8921c9141;p=chaz%2Ftar diff --git a/src/buffer.c b/src/buffer.c index 4ff57af..d29cccc 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -1,871 +1,1000 @@ /* 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 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001 Free + Software Foundation, Inc. -#ifdef BSD42 -#include -#else -#ifndef V7 -#include -#endif -#endif + Written by John Gilmore, on 1985-08-25. + + This program is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by the + Free Software Foundation; either version 2, or (at your option) any later + version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General + Public License for more details. -#ifdef __MSDOS__ -#include + 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. */ + +#include "system.h" + +#include + +#if MSDOS +# include #endif -#ifdef XENIX -#include +#if XENIX +# include #endif -#include "tar.h" -#include "port.h" +#include +#include +#include + +#include "common.h" #include "rmt.h" -#include "regex.h" -/* 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; +#define PREAD 0 /* read file descriptor from pipe() */ +#define PWRITE 1 /* write file descriptor from pipe() */ + +/* Number of retries before giving up on read. */ +#define READ_ERROR_MAX 10 + +/* Globbing pattern to append to volume label if initial match failed. */ +#define VOLUME_LABEL_APPEND " Volume [1-9]*" + +/* Variables. */ -#define STDIN 0 /* Standard input file descriptor */ -#define STDOUT 1 /* Standard output file descriptor */ +static tarlong prev_written; /* bytes written on previous volumes */ +static tarlong bytes_written; /* bytes written on this volume */ -#define PREAD 0 /* Read file descriptor from pipe() */ -#define PWRITE 1 /* Write file descriptor from pipe() */ +/* FIXME: The following variables should ideally be static to this + module. However, this cannot be done yet. The cleanup continues! */ -#define MAGIC_STAT 105 /* Magic status returned by child, if - it can't exec. We hope compress/sh - never return this status! */ +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 */ -void *valloc (); +static struct stat archive_stat; /* stat block for archive file */ -void writeerror (); -void readerror (); +static off_t record_start_block; /* block ordinal at record_start */ -void ck_pipe (); -void ck_close (); +/* Where we write list messages (not errors, not interactions) to. Stdout + unless we're writing a pipe, in which case stderr. */ +FILE *stdlis; -int backspace_output (); -extern void finish_header (); -void flush_archive (); -int isfile (); -int new_volume (); -void verify_volume (); -extern void to_oct (); +static void backspace_output PARAMS ((void)); +static int new_volume PARAMS ((enum access_mode)); +static void archive_write_error PARAMS ((ssize_t)) __attribute__ ((noreturn)); +static void archive_read_error PARAMS ((void)); -#ifndef __MSDOS__ -/* Obnoxious test to see if dimwit is trying to dump the archive */ +#if !MSDOS +/* Obnoxious test to see if dimwit is trying to dump the archive. */ dev_t ar_dev; ino_t ar_ino; #endif -/* - * 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? - */ +/* PID of child program, if compress_option or remote archive access. */ +static pid_t child_pid; + +/* Error recovery stuff */ +static int read_error_count; + +/* Have we hit EOF yet? */ static int hit_eof; /* Checkpointing counter */ static int checkpoint; -/* 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 +/* We're reading, but we just read the last block and its time to update. */ +/* As least EXTERN like this one as possible. FIXME! */ +extern int time_to_start_writing; + +int file_to_switch_to = -1; /* if remote update, close archive, and use this descriptor to write to */ -static int volno = 1; /* JF which volume of a multi-volume tape - we're on */ -static int global_volno = 1; /* Volume number to print in external messages. */ +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. */ -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 */ +void +print_total_written (void) +{ + tarlong written = prev_written + bytes_written; + char bytes[sizeof (tarlong) * CHAR_BIT]; + char abbr[LONGEST_HUMAN_READABLE + 1]; + char rate[LONGEST_HUMAN_READABLE + 1]; + double seconds; + +#if HAVE_CLOCK_GETTIME + struct timespec now; + if (clock_gettime (CLOCK_REALTIME, &now) == 0) + seconds = ((now.tv_sec - start_timespec.tv_sec) + + (now.tv_nsec - start_timespec.tv_nsec) / 1e9); + else +#endif + seconds = time (0) - start_time; -int write_archive_to_stdout; + sprintf (bytes, TARLONG_FORMAT, written); -/* 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; + /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */ + fprintf (stderr, _("Total bytes written: %s (%sB, %sB/s)\n"), bytes, + human_readable ((uintmax_t) written, abbr, 1, -1024), + (0 < seconds && written / seconds < (uintmax_t) -1 + ? human_readable ((uintmax_t) (written / seconds), rate, 1, -1024) + : "?")); +} -/* Reset the EOF flag (if set), and re-set ar_record, etc */ +/* 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. */ void -reset_eof () +reset_eof (void) { if (hit_eof) { hit_eof = 0; - ar_record = ar_block; - ar_last = ar_block + blocking; - ar_reading = 0; + current_block = record_start; + record_end = record_start + blocking_factor; + access_mode = ACCESS_WRITE; } } -/* - * 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 () +/* 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 (ar_record == ar_last) + if (current_block == record_end) { if (hit_eof) - return (union record *) NULL; /* EOF */ + return 0; flush_archive (); - if (ar_record == ar_last) + if (current_block == record_end) { - hit_eof++; - return (union record *) NULL; /* EOF */ + hit_eof = 1; + return 0; } } - return ar_record; + return current_block; } - -/* - * Indicate that we have used all records up thru the argument. - * (should the arg have an off-by-1? XXX FIXME) - */ +/* Indicate that we have used all blocks up thru BLOCK. + FIXME: should the arg have an off-by-1? */ void -userec (rec) - union record *rec; +set_next_block_after (union block *block) { - 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) + while (block >= current_block) + current_block++; + + /* Do *not* flush the archive here. If we do, the same argument to + set_next_block_after could mean the next block (if the input record + is exactly one block long), which is not what is intended. */ + + if (current_block > record_end) abort (); } - -/* - * 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 () +/* Return the number of bytes comprising the space between POINTER + through the end of the current buffer of blocks. This space is + available for filling with data, or taking data from. POINTER is + usually (but not always) the result previous find_next_block call. */ +size_t +available_space_after (union block *pointer) { - return ar_last; + return record_end->buffer - pointer->buffer; } - -/* - * 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; +/* Close file having descriptor FD, and abort if close unsuccessful. */ +static void +xclose (int fd) { - int err; + if (close (fd) != 0) + close_error (_("(pipe)")); +} - if (from != to) +/* Duplicate file descriptor FROM into becoming INTO. + INTO is closed first and has to be the next available slot. */ +static void +xdup2 (int from, int into) +{ + if (from != into) { - err = close (to); - if (err < 0 && errno != EBADF) + int status = close (into); + + if (status != 0 && errno != EBADF) { - msg_perror ("Cannot close descriptor %d", to); - exit (EX_SYSTEM); + int e = errno; + FATAL_ERROR ((0, e, _("Cannot close"))); } - err = dup (from); - if (err != to) + status = dup (from); + if (status != into) { - msg_perror ("cannot dup %s", msg); - exit (EX_SYSTEM); + if (status < 0) + { + int e = errno; + FATAL_ERROR ((0, e, _("Cannot dup"))); + } + abort (); } - ck_close (from); + xclose (from); } } -#ifdef __MSDOS__ -void -child_open () +#if MSDOS + +/* Set ARCHIVE for writing, then compressing an archive. */ +static void +child_open_for_compress (void) { - fprintf (stderr, "MS-DOS %s can't use compressed or remote archives\n", tar); - exit (EX_ARGSBAD); + FATAL_ERROR ((0, 0, _("Cannot use compressed or remote archives"))); } -#else -void -child_open () +/* Set ARCHIVE for uncompressing, then reading an archive. */ +static void +child_open_for_uncompress (void) { - int pipe[2]; - int err = 0; + FATAL_ERROR ((0, 0, _("Cannot use compressed or remote archives"))); +} + +#else /* not MSDOS */ - int kidpipe[2]; - int kidchildpid; +/* 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; -#define READ 0 -#define WRITE 1 + if (stat (name, &stbuf) == 0) + return S_ISREG (stbuf.st_mode); + else + return errno == ENOENT; +} - ck_pipe (pipe); +static ssize_t +write_archive_buffer (void) +{ + ssize_t status; + ssize_t written = 0; - childpid = fork (); - if (childpid < 0) + while (0 <= (status = rmtwrite (archive, record_start->buffer + written, + record_size - written))) { - msg_perror ("cannot fork"); - exit (EX_SYSTEM); + written += status; + if (written == record_size + || _isrmt (archive) || ! S_ISFIFO (archive_stat.st_mode)) + break; } - if (childpid > 0) + + return written ? written : status; +} + +/* Set ARCHIVE for writing, then compressing an archive. */ +static void +child_open_for_compress (void) +{ + int parent_pipe[2]; + int child_pipe[2]; + pid_t grandchild_pid; + int wait_status; + + xpipe (parent_pipe); + child_pid = xfork (); + + if (child_pid > 0) { - /* We're the parent. Clean up and be happy */ - /* This, at least, is easy */ + /* The parent tar is still here! Just clean up. */ - if (ar_reading) - { - f_reblock++; - archive = pipe[READ]; - ck_close (pipe[WRITE]); - } - else + 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); + 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) { - archive = pipe[WRITE]; - ck_close (pipe[READ]); + int saved_errno = errno; + + if (backup_option) + undo_last_backup (); + errno = saved_errno; + open_fatal (archive_name_array[0]); } - return; + xdup2 (archive, STDOUT_FILENO); + execlp (use_compress_program_option, use_compress_program_option, + (char *) 0); + exec_fatal (use_compress_program_option); } - /* We're the kid */ - if (ar_reading) + /* We do need a grandchild tar. */ + + xpipe (child_pipe); + grandchild_pid = xfork (); + + if (grandchild_pid == 0) { - dupto (pipe[WRITE], STDOUT, "(child) pipe to stdout"); - ck_close (pipe[READ]); + /* The newborn grandchild tar is here! Launch the compressor. */ + + program_name = _("tar (grandchild)"); + + xdup2 (child_pipe[PWRITE], STDOUT_FILENO); + xclose (child_pipe[PREAD]); + execlp (use_compress_program_option, use_compress_program_option, + (char *) 0); + exec_fatal (use_compress_program_option); } + + /* The child tar is still here! */ + + /* Prepare for reblocking the data from the compressor into the archive. */ + + xdup2 (child_pipe[PREAD], STDIN_FILENO); + xclose (child_pipe[PWRITE]); + + if (strcmp (archive_name_array[0], "-") == 0) + archive = STDOUT_FILENO; else { - dupto (pipe[READ], STDIN, "(child) pipe to stdin"); - ck_close (pipe[WRITE]); + archive = rmtcreat (archive_name_array[0], MODE_RW, rsh_command_option); + if (archive < 0) + open_fatal (archive_name_array[0]); } - /* 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 + /* Let's read out of the stdin pipe and write an archive. */ + + while (1) { - /* We don't need a child tar. Open the archive */ - if (ar_reading) + 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) { - 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); */ + size_t size = record_size - length; + + if (size < BLOCKSIZE) + size = BLOCKSIZE; + status = safe_read (STDIN_FILENO, cursor, size); + if (status <= 0) + break; } - else + + if (status < 0) + read_fatal (use_compress_program_option); + + /* Copy the record. */ + + if (status == 0) { - archive = creat (ar_files[0], 0666); - if (archive < 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) { - msg_perror ("can't open archive %s", ar_files[0]); - exit (EX_BADARCH); + memset (record_start->buffer + length, 0, record_size - length); + status = write_archive_buffer (); + if (status != record_size) + archive_write_error (status); } - dupto (archive, STDOUT, "archive to stdout"); - /* close(archive); */ + + /* There is nothing else to read, break out. */ + break; } + + status = write_archive_buffer (); + if (status != record_size) + archive_write_error (status); + } + +#if 0 + close_archive (); +#endif + + /* Propagate any failure of the grandchild back to the parent. */ + + while (waitpid (grandchild_pid, &wait_status, 0) == -1) + if (errno != EINTR) + { + waitpid_error (use_compress_program_option); + break; + } + + if (WIFSIGNALED (wait_status)) + { + kill (child_pid, WTERMSIG (wait_status)); + exit_status = TAREXIT_FAILURE; + } + else if (WEXITSTATUS (wait_status) != 0) + exit_status = WEXITSTATUS (wait_status); + + exit (exit_status); +} + +/* Set ARCHIVE for uncompressing, then reading an archive. */ +static void +child_open_for_uncompress (void) +{ + int parent_pipe[2]; + int child_pipe[2]; + pid_t grandchild_pid; + int wait_status; + + xpipe (parent_pipe); + child_pid = xfork (); + + 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 newborn child tar is here! */ + + program_name = _("tar (child)"); + + xdup2 (parent_pipe[PWRITE], STDOUT_FILENO); + 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) + open_fatal (archive_name_array[0]); + xdup2 (archive, STDIN_FILENO); + execlp (use_compress_program_option, use_compress_program_option, + "-d", (char *) 0); + exec_fatal (use_compress_program_option); + } + + /* We do need a grandchild tar. */ + + xpipe (child_pipe); + grandchild_pid = xfork (); + + if (grandchild_pid == 0) + { + /* The newborn grandchild tar is here! Launch the uncompressor. */ + + program_name = _("tar (grandchild)"); + + xdup2 (child_pipe[PREAD], STDIN_FILENO); + xclose (child_pipe[PWRITE]); + execlp (use_compress_program_option, use_compress_program_option, + "-d", (char *) 0); + exec_fatal (use_compress_program_option); + } + + /* The child tar is still here! */ + + /* Prepare for unblocking the data from the archive into the + uncompressor. */ + + xdup2 (child_pipe[PWRITE], STDOUT_FILENO); + xclose (child_pipe[PREAD]); + + if (strcmp (archive_name_array[0], "-") == 0) + archive = STDIN_FILENO; else + archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY, + MODE_RW, rsh_command_option); + if (archive < 0) + open_fatal (archive_name_array[0]); + + /* Let's read the archive and pipe it into stdout. */ + + while (1) { - /* We need a child tar */ - ck_pipe (kidpipe); + char *cursor; + size_t maximum; + size_t count; + ssize_t status; - kidchildpid = fork (); - if (kidchildpid < 0) - { - msg_perror ("child can't fork"); - exit (EX_SYSTEM); - } + read_error_count = 0; - if (kidchildpid > 0) + error_loop: + status = rmtread (archive, record_start->buffer, record_size); + if (status < 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]); */ + archive_read_error (); + goto error_loop; } - else + if (status == 0) + break; + cursor = record_start->buffer; + maximum = status; + while (maximum) { - /* 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]); - } - - 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); - - if (archive < 0) - { - msg_perror ("can't open archive %s", ar_files[0]); - exit (EX_BADARCH); - } + count = maximum < BLOCKSIZE ? maximum : BLOCKSIZE; + if (full_write (STDOUT_FILENO, cursor, count) != count) + write_error (use_compress_program_option); + cursor += count; + maximum -= count; + } + } - if (ar_reading) - { - for (;;) - { - char *ptr; - int max, count; + xclose (STDOUT_FILENO); +#if 0 + close_archive (); +#endif - 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; + /* Propagate any failure of the grandchild back to the parent. */ - 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); - } - } + while (waitpid (grandchild_pid, &wait_status, 0) == -1) + if (errno != EINTR) + { + waitpid_error (use_compress_program_option); + break; + } - /* close_archive(); */ - exit (0); - } + if (WIFSIGNALED (wait_status)) + { + kill (child_pid, WTERMSIG (wait_status)); + exit_status = TAREXIT_FAILURE; } - /* 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); + else if (WEXITSTATUS (wait_status) != 0) + exit_status = WEXITSTATUS (wait_status); + + exit (exit_status); } +#endif /* not MSDOS */ -/* 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 int +check_label_pattern (union block *label) { - struct stat stbuf; + char *string; + int result; - if (stat (p, &stbuf) < 0) - return 1; - if (S_ISREG (stbuf.st_mode)) + if (! memchr (label->header.name, '\0', sizeof label->header.name)) + return 0; + + if (fnmatch (volume_label_option, label->header.name, 0) == 0) return 1; - return 0; -} -#endif + if (!multi_volume_option) + return 0; -/* - * 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) - { - msg ("invalid value for blocksize"); - exit (EX_ARGSBAD); - } + 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"))); + + if (archive_names == 0) + FATAL_ERROR ((0, 0, _("No archive name given"))); - /*NOSTRICT*/ - if (f_multivol) + current_file_name = 0; + current_link_name = 0; + save_name = 0; + real_s_name = 0; + + if (multi_volume_option) { - ar_block = (union record *) valloc ((unsigned) (blocksize + (2 * RECORDSIZE))); - if (ar_block) - ar_block += 2; + if (verify_option) + FATAL_ERROR ((0, 0, _("Cannot verify multi-volume archives"))); + record_start = valloc (record_size + (2 * BLOCKSIZE)); + if (record_start) + record_start += 2; } else - ar_block = (union record *) valloc ((unsigned) blocksize); - if (!ar_block) - { - msg ("could not allocate memory for blocking factor %d", - blocking); - exit (EX_ARGSBAD); - } + record_start = valloc (record_size); + if (!record_start) + FATAL_ERROR ((0, 0, _("Cannot allocate memory for blocking factor %d"), + blocking_factor)); - ar_record = ar_block; - ar_last = ar_block + blocking; - ar_reading = reading; + current_block = record_start; + record_end = record_start + blocking_factor; + /* When updating the archive, we start with reading. */ + access_mode = wanted_access == ACCESS_UPDATE ? ACCESS_READ : wanted_access; - if (f_multivol && f_verify) + if (use_compress_program_option) { - msg ("cannot verify multi-volume archives"); - exit (EX_ARGSBAD); - } + if (multi_volume_option) + FATAL_ERROR ((0, 0, _("Cannot use multi-volume compressed archives"))); + if (verify_option) + FATAL_ERROR ((0, 0, _("Cannot verify compressed archives"))); - if (f_compress) - { - 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_open_for_uncompress (); + break; + + case ACCESS_WRITE: + child_open_for_compress (); + break; + + case ACCESS_UPDATE: + FATAL_ERROR ((0, 0, _("Cannot update compressed archives"))); + 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_option = 1; /* 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: + archive = STDIN_FILENO; + break; + + case ACCESS_WRITE: + archive = STDOUT_FILENO; + stdlis = stderr; + break; + + case ACCESS_UPDATE: + archive = STDIN_FILENO; + stdlis = stderr; + write_archive_to_stdout = 1; + break; } } - else if (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 = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY, + MODE_RW, rsh_command_option); + 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) && fstat (archive, &archive_stat) < 0)) { - archive = rmtcreat (ar_files[0], 0666); + int saved_errno = errno; + + if (backed_up_flag) + undo_last_backup (); + errno = saved_errno; + open_fatal (archive_name_array[0]); } - if (archive < 0) + +#if !MSDOS + + /* Detect if outputting to "/dev/null". */ + { + static char const dev_null[] = "/dev/null"; + struct stat dev_null_stat; + + dev_null_output = + (strcmp (archive_name_array[0], dev_null) == 0 + || (! _isrmt (archive) + && S_ISCHR (archive_stat.st_mode) + && stat (dev_null, &dev_null_stat) == 0 + && archive_stat.st_dev == dev_null_stat.st_dev + && archive_stat.st_ino == dev_null_stat.st_ino)); + } + + if (!_isrmt (archive) && S_ISREG (archive_stat.st_mode)) { - msg_perror ("can't open %s", ar_files[0]); - exit (EX_BADARCH); + ar_dev = archive_stat.st_dev; + ar_ino = archive_stat.st_ino; } -#ifndef __MSDOS__ - if (!_isrmt (archive)) - { - struct stat tmp_stat; + else + ar_dev = 0; - fstat (archive, &tmp_stat); - if (S_ISREG (tmp_stat.st_mode)) - { - ar_dev = tmp_stat.st_dev; - ar_ino = tmp_stat.st_ino; - } - } -#endif +#endif /* not MSDOS */ -#ifdef __MSDOS__ +#if MSDOS setmode (archive, O_BINARY); #endif - if (reading) + switch (wanted_access) { - ar_last = ar_block; /* Set up for 1st block = # 0 */ - (void) findrec (); /* Read it in, check for EOF */ - - if (f_volhdr) + case ACCESS_UPDATE: + records_written = 0; + case ACCESS_READ: + records_read = 0; + record_end = record_start; /* set up for 1st record = # 0 */ + find_next_block (); /* read it in, check for EOF */ + + if (volume_label_option) { - union record *head; -#if 0 - char *ptr; + 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))); + } + break; - if (f_multivol) - { - ptr = malloc (strlen (f_volhdr) + 20); - sprintf (ptr, "%s Volume %d", f_volhdr, 1); - } + 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 - 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); - } + strcpy (record_start->header.name, volume_label_option); + + assign_string (¤t_file_name, record_start->header.name); + + record_start->header.typeflag = GNUTYPE_VOLHDR; + TIME_TO_CHARS (start_time, record_start->header.mtime); + finish_header (record_start); #if 0 - if (strcmp (ptr, head->header.name)) - { - msg ("Volume mismatch! %s!=%s", ptr, head->header.name); - exit (EX_BADVOL); - } - if (ptr != f_volhdr) - free (ptr); + current_block++; #endif } - } - 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; } } - -/* - * 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. - */ +/* Perform a write to flush the buffer. */ void -saverec (pointer) - union record **pointer; +flush_write (void) { - long offset; - - save_rec = pointer; - offset = ar_record - ar_block; - saved_recno = baserec + offset; -} - -/* - * Perform a write to flush the buffer. - */ - -/*send_buffer_to_file(); - if(new_volume) { - deal_with_new_volume_stuff(); - send_buffer_to_file(); - } - */ - -void -fl_write () -{ - int err; int copy_back; - static long bytes_written = 0; + ssize_t status; + + if (checkpoint_option && !(++checkpoint % 10)) + 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 = 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) { + char *cursor; + if (!save_name) { - 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); + cursor = save_name + FILESYSTEM_PREFIX_LEN (save_name); + while (ISSLASH (*cursor)) + cursor++; + + assign_string (&real_s_name, cursor); 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. */ - /* If error indicates a short write, we just move to the next tape. */ + /* ENXIO is for the UNIX PC. */ + if (status < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO) + archive_write_error (status); - if (new_volume (0) < 0) + /* If error indicates a short write, we just move to the next tape. */ + + 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, record_start->header.mtime); + record_start->header.typeflag = GNUTYPE_VOLHDR; + finish_header (record_start); } - 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++; + + 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); + record_start->header.typeflag = GNUTYPE_MULTIVOL; + OFF_TO_CHARS (real_s_sizeleft, record_start->header.size); + OFF_TO_CHARS (real_s_totsize - real_s_sizeleft, + record_start->oldgnu_header.offset); + tmp = verbose_option; + verbose_option = 0; + finish_header (record_start); + verbose_option = tmp; + + if (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 = 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++; + char *cursor = save_name + FILESYSTEM_PREFIX_LEN (save_name); + + while (ISSLASH (*cursor)) + cursor++; - strcpy (real_s_name, save_name); + assign_string (&real_s_name, cursor); real_s_sizeleft = save_sizeleft; real_s_totsize = save_totsize; } @@ -873,707 +1002,602 @@ 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 */ - -void -writeerror (err) - int err; +/* Handle write errors on the archive. Write errors are always fatal. + Hitting the end of a volume does not cause a write error unless the + write was the first record of the volume. */ +static void +archive_write_error (ssize_t status) { - 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. - */ -void -readerror () +/* Handle read errors on the archive. If the read should be retried, + return to the caller. */ +static void +archive_read_error (void) { -# define READ_ERROR_MAX 10 + read_error (*archive_name_cursor); - read_error_flag++; /* Tell callers */ + if (record_start_block == 0) + FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now"))); - msg_perror ("read error on %s", ar_files[cur_ar_file]); + /* Read error in mid archive. We retry up to READ_ERROR_MAX times and + then give up on reading the archive. */ - if (baserec == 0) - { - /* First block of tape. Probably stupidity error */ - exit (EX_BADARCH); - } - - /* - * 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) - { - msg ("Too many errors, quitting."); - exit (EX_BADARCH); - } + if (read_error_count++ > READ_ERROR_MAX) + FATAL_ERROR ((0, 0, _("Too many errors, quitting"))); return; } - -/* - * 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) + ssize_t status; /* result from system call */ + size_t left; /* bytes left */ + char *more; /* pointer to next byte to read */ + + if (checkpoint_option && !(++checkpoint % 10)) + 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 = 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++; + char *cursor = save_name + FILESYSTEM_PREFIX_LEN (save_name); - strcpy (real_s_name, save_name); - save_name = real_s_name; - } - real_s_totsize = save_totsize; - real_s_sizeleft = save_sizeleft; + while (ISSLASH (*cursor)) + cursor++; + assign_string (&real_s_name, cursor); + 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; + } - if ((err == 0 || (err < 0 && errno == ENOSPC) || (err > 0 && !f_reblock)) && f_multivol) + if ((status == 0 + || (status < 0 && errno == ENOSPC) + || (status > 0 && !read_full_records_option)) + && 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; + switch (subcommand_option) + { + case APPEND_SUBCOMMAND: + case CAT_SUBCOMMAND: + case UPDATE_SUBCOMMAND: + if (!new_volume (ACCESS_UPDATE)) + return; + break; + + default: + if (!new_volume (ACCESS_READ)) + return; + break; + } + vol_error: - err = rmtread (archive, ar_block->charptr, (int) blocksize); - if (err < 0) + status = rmtread (archive, record_start->buffer, record_size); + if (status < 0) { - readerror (); + archive_read_error (); goto vol_error; } - if (err != blocksize) + if (status != record_size) goto short_read; - head = ar_block; + cursor = record_start; - if (head->header.linkflag == LF_VOLHDR) + if (cursor->header.typeflag == GNUTYPE_VOLHDR) { - if (f_volhdr) + if (volume_label_option) { -#if 0 - char *ptr; - - 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; - } - -#if 0 - if (strcmp (ptr, head->header.name)) + 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 + || strcmp (cursor->header.name, real_s_name)) { - 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 < 0) { - 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: + more = record_start->buffer + status; + left = record_size - status; -again: - if (0 == (((unsigned) left) % RECORDSIZE)) + while (left % BLOCKSIZE != 0 + || (left && status && read_full_records_option)) { - /* 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) - { - /* - * User warned us about this. Fix up. - */ - if (left > 0) + if (status) + while ((status = rmtread (archive, more, left)) < 0) + archive_read_error (); + + if (status == 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; + if (left % BLOCKSIZE != 0) + ERROR ((0, 0, _("%d garbage bytes ignored at end of archive"), + (int) ((record_size - left) % BLOCKSIZE))); + break; } + + if (! read_full_records_option) + FATAL_ERROR ((0, 0, _("Unaligned block (%lu bytes) in archive"), + (unsigned long) (record_size - left))); + + /* User warned us about this. Fix up. */ + + left -= status; + more += status; } - else - { - msg ("only read %d bytes from archive %s", err, ar_files[cur_ar_file]); - exit (EX_BADARCH); - } -} + /* 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) ((record_size - left) / BLOCKSIZE))); + + record_end = record_start + (record_size - left) / BLOCKSIZE; + records_read++; +} -/* - * Flush the current buffer to/from the archive. - */ +/* Flush the current buffer to/from the archive. */ void -flush_archive () +flush_archive (void) { - int c; + record_start_block += record_end - record_start; + current_block = record_start; + record_end = record_start + blocking_factor; - 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 */ - - if (ar_reading) + if (access_mode == ACCESS_READ && time_to_start_writing) { - if (time_to_start_writing) - { - time_to_start_writing = 0; - ar_reading = 0; + access_mode = ACCESS_WRITE; + time_to_start_writing = 0; - 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); + if (file_to_switch_to >= 0) + { + if (rmtclose (archive) != 0) + close_warn (*archive_name_cursor); - archive = file_to_switch_to; - } - else - (void) backspace_output (); - fl_write (); + archive = file_to_switch_to; } else - fl_read (); + backspace_output (); } - else + + switch (access_mode) { - fl_write (); + case ACCESS_READ: + flush_read (); + break; + + case ACCESS_WRITE: + flush_write (); + break; + + case ACCESS_UPDATE: + abort (); } } -/* 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 () +/* 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) { - long cur; - /* int er; */ - extern char *output_start; - #ifdef MTIOCTOP - struct mtop t; + { + struct mtop operation; - 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; + 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 - cur = rmtlseek (archive, 0L, 1); - cur -= blocksize; - /* Seek back to the beginning of this block and - start writing there. */ + { + off_t position = rmtlseek (archive, (off_t) 0, SEEK_CUR); - if (rmtlseek (archive, cur, 0) != cur) - { - /* 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; - } - return 3; -} + /* 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"))); -/* - * Close the archive file. - */ + /* 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); + } + } +} + +/* Close the archive file. */ void -close_archive () +close_archive (void) { - int child; - int status; - int c; - - if (time_to_start_writing || !ar_reading) + if (time_to_start_writing || access_mode == ACCESS_WRITE) flush_archive (); - if (cmd_mode == CMD_DELETE) - { - off_t pos; - pos = rmtlseek (archive, 0L, 1); -#ifndef __MSDOS__ - (void) ftruncate (archive, pos); -#else - (void) rmtwrite (archive, "", 0); +#if !MSDOS + + /* Manage to fully drain a pipe we might be reading, so to not break it on + the producer after the EOF block. FIXME: one of these days, GNU tar + might become clever enough to just stop working, once there is no more + work to do, we might have to revise this area in such time. */ + + if (access_mode == ACCESS_READ + && ! _isrmt (archive) + && S_ISFIFO (archive_stat.st_mode)) + while (rmtread (archive, record_start->buffer, record_size) > 0) + continue; #endif - } - if (f_verify) + + 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) +#if !MSDOS + + if (child_pid) { - /* - * Loop waiting for the right child to die, or for - * no more kids. - */ - while (((child = wait (&status)) != childpid) && child != -1) - ; - - if (child != -1) - { - if (WIFSIGNALED (status)) - { - /* 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)" : ""); - } - else - { - /* 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. - */ - /* Do nothing. */ - } - else if (WEXITSTATUS (status)) - msg ("child returned status %d", - WEXITSTATUS (status)); - } - } - } -#endif /* __MSDOS__ */ -} + int wait_status; + while (waitpid (child_pid, &wait_status, 0) == -1) + if (errno != EINTR) + { + waitpid_error (use_compress_program_option); + break; + } -#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, ""); - } + if (WIFSIGNALED (wait_status)) + ERROR ((0, 0, _("Child died with signal %d"), + WTERMSIG (wait_status))); + else if (WEXITSTATUS (wait_status) != 0) + ERROR ((0, 0, _("Child returned status %d"), + WEXITSTATUS (wait_status))); } - else if (prefix) - { - fputs (prefix, stream); - fputs (": ", stream); - } - errno = save_e; +#endif /* !MSDOS */ + + if (current_file_name) + free (current_file_name); + if (current_link_name) + free (current_link_name); + if (save_name) + free (save_name); + if (real_s_name) + free (real_s_name); + free (multi_volume_option ? record_start - 2 : record_start); } -#endif - -/* Called to initialize the global volume number. */ +/* Called to initialize the global volume number. */ void -init_volume_number () +init_volume_number (void) { - FILE *vf; + FILE *file = fopen (volno_file_option, "r"); - vf = fopen (f_volno_file, "r"); - if (!vf && errno != ENOENT) - msg_perror ("%s", f_volno_file); - - if (vf) + if (file) { - fscanf (vf, "%d", &global_volno); - fclose (vf); + if (fscanf (file, "%d", &global_volno) != 1 + || global_volno < 0) + FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"), + quotearg_colon (volno_file_option))); + if (ferror (file)) + read_error (volno_file_option); + if (fclose (file) != 0) + close_error (volno_file_option); } + else if (errno != ENOENT) + open_error (volno_file_option); } -/* Called to write out the closing global volume number. */ +/* Called to write out the closing global volume number. */ void -closeout_volume_number () +closeout_volume_number (void) { - FILE *vf; + FILE *file = fopen (volno_file_option, "w"); - vf = fopen (f_volno_file, "w"); - if (!vf) - msg_perror ("%s", f_volno_file); - else + if (file) { - fprintf (vf, "%d\n", global_volno); - fclose (vf); + fprintf (file, "%d\n", global_volno); + if (ferror (file)) + write_error (volno_file_option); + if (fclose (file) != 0) + close_error (volno_file_option); } + else + open_error (volno_file_option); } -/* 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; +/* 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) { - int c; - char inbuf[80]; - char *p; - static FILE *read_file = 0; - extern int now_verifying; - extern char TTY_NAME[]; - static int looped = 0; + static FILE *read_file; + static int looped; - if (!read_file && !f_run_script_at_end) - read_file = (archive == 0) ? fopen (TTY_NAME, "r") : stdin; + 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 -1; - if (f_verify) + return 0; + 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); global_volno++; + if (global_volno < 0) + FATAL_ERROR ((0, 0, _("Volume number overflow"))); volno++; - cur_ar_file++; - if (cur_ar_file == n_ar_files) + archive_name_cursor++; + if (archive_name_cursor == archive_name_array + archive_names) { - cur_ar_file = 0; + archive_name_cursor = archive_name_array; looped = 1; } -tryagain: + tryagain: if (looped) { - /* We have to prompt from now on. */ - if (f_run_script_at_end) - system (info_script); + /* 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"), info_script_option)); + } else - for (;;) + while (1) { - 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) + 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) { - 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); + WARN ((0, 0, _("EOF where user reply was expected"))); + + if (subcommand_option != EXTRACT_SUBCOMMAND + && subcommand_option != LIST_SUBCOMMAND + && subcommand_option != DIFF_SUBCOMMAND) + WARN ((0, 0, _("WARNING: Archive is incomplete"))); + + fatal_exit (); } - if (inbuf[0] == '\n' || inbuf[0] == 'y' || inbuf[0] == 'Y') + if (input_buffer[0] == '\n' + || input_buffer[0] == 'y' + || input_buffer[0] == 'Y') break; - switch (inbuf[0]) + switch (input_buffer[0]) { case '?': { - fprintf (msg_file, "\ - n [name] Give a new filename for the next (and subsequent) volume(s)\n\ + 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"); + ? 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 'q': + /* Quit. */ + + WARN ((0, 0, _("No new volume; exiting.\n"))); + + if (subcommand_option != EXTRACT_SUBCOMMAND + && subcommand_option != LIST_SUBCOMMAND + && subcommand_option != DIFF_SUBCOMMAND) + WARN ((0, 0, _("WARNING: Archive is incomplete"))); + + fatal_exit (); + + case 'n': + /* Get new file name. */ - 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; + char *name = &input_buffer[1]; + char *cursor; + + while (*name == ' ' || *name == '\t') + name++; + cursor = name; + while (*cursor && *cursor != '\n') + cursor++; + *cursor = '\0'; + + /* FIXME: the following allocation is never reclaimed. */ + *archive_name_cursor = xstrdup (name); } break; case '!': -#ifdef __MSDOS__ +#if 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 +#else /* not MSDOS */ + { + pid_t child; + const char *shell = getenv ("SHELL"); + if (! shell) + shell = "/bin/sh"; + child = xfork (); + if (child == 0) + { + execlp (shell, "-sh", "-i", 0); + exec_fatal (shell); + } + else + { + int wait_status; + while (waitpid (child, &wait_status, 0) == -1) + if (errno != EINTR) + { + waitpid_error (shell); + break; + } + } + } +#endif /* not MSDOS */ break; } } } - - if (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); + if (verify_option) + archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW, + rsh_command_option); else - archive = -1; + switch (access) + { + 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; + } if (archive < 0) { - msg_perror ("can't open %s", ar_files[cur_ar_file]); + open_warn (*archive_name_cursor); + if (!verify_option && access == ACCESS_WRITE && backup_option) + undo_last_backup (); goto tryagain; } -#ifdef __MSDOS__ + +#if 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; -} - -/* 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; - - 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 1; }