Dogcows Code - chaz/tar/blob - src/buffer.c

   1 /* Buffer management for tar.
   2
   3    Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
   4    2003, 2004, 2005, 2006 Free Software Foundation, Inc.
   5
   6    Written by John Gilmore, on 1985-08-25.
   7
   8    This program is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by the
  10    Free Software Foundation; either version 2, or (at your option) any later
  11    version.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
  16    Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License along
  19    with this program; if not, write to the Free Software Foundation, Inc.,
  20    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  21
  22 #include <system.h>
  23 #include <system-ioctl.h>
  24
  25 #include <signal.h>
  26
  27 #include <closeout.h>
  28 #include <fnmatch.h>
  29 #include <getline.h>
  30 #include <human.h>
  31 #include <quotearg.h>
  32
  33 #include "common.h"
  34 #include <rmt.h>
  35
  36 /* Number of retries before giving up on read.  */
  37 #define READ_ERROR_MAX 10
  38
  39 /* Globbing pattern to append to volume label if initial match failed.  */
  40 #define VOLUME_LABEL_APPEND " Volume [1-9]*"
  41
  42 /* Variables.  */
  43
  44 static tarlong prev_written;    /* bytes written on previous volumes */
  45 static tarlong bytes_written;   /* bytes written on this volume */
  46 static void *record_buffer[2];  /* allocated memory */
  47 union block *record_buffer_aligned[2];
  48 static int record_index;
  49
  50 /* FIXME: The following variables should ideally be static to this
  51    module.  However, this cannot be done yet.  The cleanup continues!  */
  52
  53 union block *record_start;      /* start of record of archive */
  54 union block *record_end;        /* last+1 block of archive record */
  55 union block *current_block;     /* current block of archive */
  56 enum access_mode access_mode;   /* how do we handle the archive */
  57 off_t records_read;             /* number of records read from this archive */
  58 off_t records_written;          /* likewise, for records written */
  59
  60 static off_t record_start_block; /* block ordinal at record_start */
  61
  62 /* Where we write list messages (not errors, not interactions) to.  */
  63 FILE *stdlis;
  64
  65 static void backspace_output (void);
  66
  67 /* PID of child program, if compress_option or remote archive access.  */
  68 static pid_t child_pid;
  69
  70 /* Error recovery stuff  */
  71 static int read_error_count;
  72
  73 /* Have we hit EOF yet?  */
  74 static bool hit_eof;
  75
  76 /* Checkpointing counter */
  77 static int checkpoint;
  78
  79 static bool read_full_records = false;
  80
  81 /* We're reading, but we just read the last block and it's time to update.
  82    Declared in update.c
  83
  84    As least EXTERN like this one as possible. (?? --gray)
  85    FIXME: Either eliminate it or move it to common.h.
  86 */
  87 extern bool time_to_start_writing;
  88
  89 bool write_archive_to_stdout;
  90
  91 void (*flush_write_ptr) (size_t);
  92 void (*flush_read_ptr) (void);
  93
  94 \f
  95 char *volume_label;
  96 char *continued_file_name;
  97 uintmax_t continued_file_size;
  98 uintmax_t continued_file_offset;
  99
 100 \f
 101 static int volno = 1;           /* which volume of a multi-volume tape we're
 102                                    on */
 103 static int global_volno = 1;    /* volume number to print in external
 104                                    messages */
 105
 106 bool write_archive_to_stdout;
 107
 108 /* Used by flush_read and flush_write to store the real info about saved
 109    names.  */
 110 static char *real_s_name;
 111 static off_t real_s_totsize;
 112 static off_t real_s_sizeleft;
 113
 114 \f
 115 /* Multi-volume tracking support */
 116 static char *save_name;         /* name of the file we are currently writing */
 117 static off_t save_totsize;      /* total size of file we are writing, only
 118                                    valid if save_name is nonzero */
 119 static off_t save_sizeleft;     /* where we are in the file we are writing,
 120                                    only valid if save_name is nonzero */
 121
 122 void
 123 mv_begin (struct tar_stat_info *st)
 124 {
 125   if (multi_volume_option)
 126     {
 127       assign_string (&save_name,  st->orig_file_name);
 128       save_totsize = save_sizeleft = st->stat.st_size;
 129     }
 130 }
 131
 132 void
 133 mv_end ()
 134 {
 135   if (multi_volume_option)
 136     assign_string (&save_name, 0);
 137 }
 138
 139 void
 140 mv_total_size (off_t size)
 141 {
 142   save_totsize = size;
 143 }
 144
 145 void
 146 mv_size_left (off_t size)
 147 {
 148   save_sizeleft = size;
 149 }
 150
 151 \f
 152 /* Functions.  */
 153
 154 void
 155 clear_read_error_count (void)
 156 {
 157   read_error_count = 0;
 158 }
 159
 160 \f
 161 /* Time-related functions */
 162
 163 double duration;
 164
 165 void
 166 set_start_time ()
 167 {
 168   gettime (&start_time);
 169 }
 170
 171 void
 172 compute_duration ()
 173 {
 174   struct timespec now;
 175   gettime (&now);
 176   duration += ((now.tv_sec - start_time.tv_sec)
 177                + (now.tv_nsec - start_time.tv_nsec) / 1e9);
 178   set_start_time ();
 179 }
 180
 181 \f
 182 /* Compression detection */
 183
 184 enum compress_type {
 185   ct_none,
 186   ct_compress,
 187   ct_gzip,
 188   ct_bzip2
 189 };
 190
 191 struct zip_magic
 192 {
 193   enum compress_type type;
 194   size_t length;
 195   char *magic;
 196   char *program;
 197   char *option;
 198 };
 199
 200 static struct zip_magic const magic[] = {
 201   { ct_none, },
 202   { ct_compress, 2, "\037\235", "compress", "-Z" },
 203   { ct_gzip,     2, "\037\213", "gzip", "-z"  },
 204   { ct_bzip2,    3, "BZh",      "bzip2", "-j" },
 205 };
 206
 207 #define NMAGIC (sizeof(magic)/sizeof(magic[0]))
 208
 209 #define compress_option(t) magic[t].option
 210 #define compress_program(t) magic[t].program
 211
 212 /* Check if the file ARCHIVE is a compressed archive. */
 213 enum compress_type
 214 check_compressed_archive ()
 215 {
 216   struct zip_magic const *p;
 217   bool sfr;
 218
 219   /* Prepare global data needed for find_next_block: */
 220   record_end = record_start; /* set up for 1st record = # 0 */
 221   sfr = read_full_records;
 222   read_full_records = true; /* Suppress fatal error on reading a partial
 223                                record */
 224   find_next_block ();
 225
 226   /* Restore global values */
 227   read_full_records = sfr;
 228
 229   if (tar_checksum (record_start, true) == HEADER_SUCCESS)
 230     /* Probably a valid header */
 231     return ct_none;
 232
 233   for (p = magic + 1; p < magic + NMAGIC; p++)
 234     if (memcmp (record_start->buffer, p->magic, p->length) == 0)
 235       return p->type;
 236
 237   return ct_none;
 238 }
 239
 240 /* Open an archive named archive_name_array[0]. Detect if it is
 241    a compressed archive of known type and use corresponding decompression
 242    program if so */
 243 int
 244 open_compressed_archive ()
 245 {
 246   archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY,
 247                      MODE_RW, rsh_command_option);
 248   if (archive == -1)
 249     return archive;
 250
 251   if (!multi_volume_option)
 252     {
 253       enum compress_type type = check_compressed_archive ();
 254
 255       if (type == ct_none)
 256         return archive;
 257
 258       /* FD is not needed any more */
 259       rmtclose (archive);
 260
 261       hit_eof = false; /* It might have been set by find_next_block in
 262                           check_compressed_archive */
 263
 264       /* Open compressed archive */
 265       use_compress_program_option = compress_program (type);
 266       child_pid = sys_child_open_for_uncompress ();
 267       read_full_records = true;
 268     }
 269
 270   records_read = 0;
 271   record_end = record_start; /* set up for 1st record = # 0 */
 272
 273   return archive;
 274 }
 275 \f
 276
 277 void
 278 print_total_written (void)
 279 {
 280   tarlong written = prev_written + bytes_written;
 281   char bytes[sizeof (tarlong) * CHAR_BIT];
 282   char abbr[LONGEST_HUMAN_READABLE + 1];
 283   char rate[LONGEST_HUMAN_READABLE + 1];
 284
 285   int human_opts = human_autoscale | human_base_1024 | human_SI | human_B;
 286
 287   sprintf (bytes, TARLONG_FORMAT, written);
 288
 289   /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*".  */
 290   fprintf (stderr, _("Total bytes written: %s (%s, %s/s)\n"), bytes,
 291            human_readable (written, abbr, human_opts, 1, 1),
 292            (0 < duration && written / duration < (uintmax_t) -1
 293             ? human_readable (written / duration, rate, human_opts, 1, 1)
 294             : "?"));
 295 }
 296
 297 /* Compute and return the block ordinal at current_block.  */
 298 off_t
 299 current_block_ordinal (void)
 300 {
 301   return record_start_block + (current_block - record_start);
 302 }
 303
 304 /* If the EOF flag is set, reset it, as well as current_block, etc.  */
 305 void
 306 reset_eof (void)
 307 {
 308   if (hit_eof)
 309     {
 310       hit_eof = false;
 311       current_block = record_start;
 312       record_end = record_start + blocking_factor;
 313       access_mode = ACCESS_WRITE;
 314     }
 315 }
 316
 317 /* Return the location of the next available input or output block.
 318    Return zero for EOF.  Once we have returned zero, we just keep returning
 319    it, to avoid accidentally going on to the next file on the tape.  */
 320 union block *
 321 find_next_block (void)
 322 {
 323   if (current_block == record_end)
 324     {
 325       if (hit_eof)
 326         return 0;
 327       flush_archive ();
 328       if (current_block == record_end)
 329         {
 330           hit_eof = true;
 331           return 0;
 332         }
 333     }
 334   return current_block;
 335 }
 336
 337 /* Indicate that we have used all blocks up thru BLOCK. */
 338 void
 339 set_next_block_after (union block *block)
 340 {
 341   while (block >= current_block)
 342     current_block++;
 343
 344   /* Do *not* flush the archive here.  If we do, the same argument to
 345      set_next_block_after could mean the next block (if the input record
 346      is exactly one block long), which is not what is intended.  */
 347
 348   if (current_block > record_end)
 349     abort ();
 350 }
 351
 352 /* Return the number of bytes comprising the space between POINTER
 353    through the end of the current buffer of blocks.  This space is
 354    available for filling with data, or taking data from.  POINTER is
 355    usually (but not always) the result of previous find_next_block call.  */
 356 size_t
 357 available_space_after (union block *pointer)
 358 {
 359   return record_end->buffer - pointer->buffer;
 360 }
 361
 362 /* Close file having descriptor FD, and abort if close unsuccessful.  */
 363 void
 364 xclose (int fd)
 365 {
 366   if (close (fd) != 0)
 367     close_error (_("(pipe)"));
 368 }
 369
 370 static void
 371 init_buffer ()
 372 {
 373   if (! record_buffer_aligned[record_index])
 374     record_buffer_aligned[record_index] =
 375       page_aligned_alloc (&record_buffer[record_index], record_size);
 376
 377   record_start = record_buffer_aligned[record_index];
 378   current_block = record_start;
 379   record_end = record_start + blocking_factor;
 380 }
 381
 382 /* Open an archive file.  The argument specifies whether we are
 383    reading or writing, or both.  */
 384 static void
 385 _open_archive (enum access_mode wanted_access)
 386 {
 387   int backed_up_flag = 0;
 388
 389   if (index_file_name)
 390     {
 391       stdlis = freopen (index_file_name, "w", stdout);
 392       if (! stdlis)
 393         open_error (index_file_name);
 394       close_stdout_set_file_name (index_file_name);
 395     }
 396   else
 397     stdlis = to_stdout_option ? stderr : stdout;
 398
 399   if (record_size == 0)
 400     FATAL_ERROR ((0, 0, _("Invalid value for record_size")));
 401
 402   if (archive_names == 0)
 403     FATAL_ERROR ((0, 0, _("No archive name given")));
 404
 405   tar_stat_destroy (&current_stat_info);
 406   save_name = 0;
 407   real_s_name = 0;
 408
 409   record_index = 0;
 410   init_buffer ();
 411
 412   /* When updating the archive, we start with reading.  */
 413   access_mode = wanted_access == ACCESS_UPDATE ? ACCESS_READ : wanted_access;
 414
 415   read_full_records = read_full_records_option;
 416
 417   records_read = 0;
 418
 419   if (use_compress_program_option)
 420     {
 421       switch (wanted_access)
 422         {
 423         case ACCESS_READ:
 424           child_pid = sys_child_open_for_uncompress ();
 425           read_full_records = true;
 426           record_end = record_start; /* set up for 1st record = # 0 */
 427           break;
 428
 429         case ACCESS_WRITE:
 430           child_pid = sys_child_open_for_compress ();
 431           break;
 432
 433         case ACCESS_UPDATE:
 434           abort (); /* Should not happen */
 435           break;
 436         }
 437
 438       if (wanted_access == ACCESS_WRITE
 439           && strcmp (archive_name_array[0], "-") == 0)
 440         stdlis = stderr;
 441     }
 442   else if (strcmp (archive_name_array[0], "-") == 0)
 443     {
 444       read_full_records = true; /* could be a pipe, be safe */
 445       if (verify_option)
 446         FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
 447
 448       switch (wanted_access)
 449         {
 450         case ACCESS_READ:
 451           {
 452             enum compress_type type;
 453
 454             archive = STDIN_FILENO;
 455
 456             type = check_compressed_archive ();
 457             if (type != ct_none)
 458               FATAL_ERROR ((0, 0,
 459                             _("Archive is compressed. Use %s option"),
 460                             compress_option (type)));
 461           }
 462           break;
 463
 464         case ACCESS_WRITE:
 465           archive = STDOUT_FILENO;
 466           stdlis = stderr;
 467           break;
 468
 469         case ACCESS_UPDATE:
 470           archive = STDIN_FILENO;
 471           stdlis = stderr;
 472           write_archive_to_stdout = true;
 473           break;
 474         }
 475     }
 476   else if (verify_option)
 477     archive = rmtopen (archive_name_array[0], O_RDWR | O_CREAT | O_BINARY,
 478                        MODE_RW, rsh_command_option);
 479   else
 480     switch (wanted_access)
 481       {
 482       case ACCESS_READ:
 483         archive = open_compressed_archive ();
 484         break;
 485
 486       case ACCESS_WRITE:
 487         if (backup_option)
 488           {
 489             maybe_backup_file (archive_name_array[0], 1);
 490             backed_up_flag = 1;
 491           }
 492         archive = rmtcreat (archive_name_array[0], MODE_RW,
 493                             rsh_command_option);
 494         break;
 495
 496       case ACCESS_UPDATE:
 497         archive = rmtopen (archive_name_array[0], O_RDWR | O_CREAT | O_BINARY,
 498                            MODE_RW, rsh_command_option);
 499         break;
 500       }
 501
 502   if (archive < 0
 503       || (! _isrmt (archive) && !sys_get_archive_stat ()))
 504     {
 505       int saved_errno = errno;
 506
 507       if (backed_up_flag)
 508         undo_last_backup ();
 509       errno = saved_errno;
 510       open_fatal (archive_name_array[0]);
 511     }
 512
 513   sys_detect_dev_null_output ();
 514   sys_save_archive_dev_ino ();
 515   SET_BINARY_MODE (archive);
 516
 517   switch (wanted_access)
 518     {
 519     case ACCESS_UPDATE:
 520       records_written = 0;
 521       record_end = record_start; /* set up for 1st record = # 0 */
 522
 523     case ACCESS_READ:
 524       find_next_block ();       /* read it in, check for EOF */
 525       break;
 526
 527     case ACCESS_WRITE:
 528       records_written = 0;
 529       break;
 530     }
 531 }
 532
 533 /* Perform a write to flush the buffer.  */
 534 ssize_t
 535 _flush_write (void)
 536 {
 537   ssize_t status;
 538
 539   if (checkpoint_option && !(++checkpoint % 10))
 540     /* TRANSLATORS: This is a ``checkpoint of write operation'',
 541        *not* ``Writing a checkpoint''.
 542        E.g. in Spanish ``Punto de comprobaci@'on de escritura'',
 543        *not* ``Escribiendo un punto de comprobaci@'on'' */
 544     WARN ((0, 0, _("Write checkpoint %d"), checkpoint));
 545
 546   if (tape_length_option && tape_length_option <= bytes_written)
 547     {
 548       errno = ENOSPC;
 549       status = 0;
 550     }
 551   else if (dev_null_output)
 552     status = record_size;
 553   else
 554     status = sys_write_archive_buffer ();
 555
 556   return status;
 557 }
 558
 559 /* Handle write errors on the archive.  Write errors are always fatal.
 560    Hitting the end of a volume does not cause a write error unless the
 561    write was the first record of the volume.  */
 562 void
 563 archive_write_error (ssize_t status)
 564 {
 565   /* It might be useful to know how much was written before the error
 566      occurred.  */
 567   if (totals_option)
 568     {
 569       int e = errno;
 570       print_total_written ();
 571       errno = e;
 572     }
 573
 574   write_fatal_details (*archive_name_cursor, status, record_size);
 575 }
 576
 577 /* Handle read errors on the archive.  If the read should be retried,
 578    return to the caller.  */
 579 void
 580 archive_read_error (void)
 581 {
 582   read_error (*archive_name_cursor);
 583
 584   if (record_start_block == 0)
 585     FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
 586
 587   /* Read error in mid archive.  We retry up to READ_ERROR_MAX times and
 588      then give up on reading the archive.  */
 589
 590   if (read_error_count++ > READ_ERROR_MAX)
 591     FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
 592   return;
 593 }
 594
 595 static void
 596 short_read (size_t status)
 597 {
 598   size_t left;                  /* bytes left */
 599   char *more;                   /* pointer to next byte to read */
 600
 601   more = record_start->buffer + status;
 602   left = record_size - status;
 603
 604   while (left % BLOCKSIZE != 0
 605          || (left && status && read_full_records))
 606     {
 607       if (status)
 608         while ((status = rmtread (archive, more, left)) == SAFE_READ_ERROR)
 609           archive_read_error ();
 610
 611       if (status == 0)
 612         break;
 613
 614       if (! read_full_records)
 615         {
 616           unsigned long rest = record_size - left;
 617
 618           FATAL_ERROR ((0, 0,
 619                         ngettext ("Unaligned block (%lu byte) in archive",
 620                                   "Unaligned block (%lu bytes) in archive",
 621                                   rest),
 622                         rest));
 623         }
 624
 625       /* User warned us about this.  Fix up.  */
 626
 627       left -= status;
 628       more += status;
 629     }
 630
 631   /* FIXME: for size=0, multi-volume support.  On the first record, warn
 632      about the problem.  */
 633
 634   if (!read_full_records && verbose_option > 1
 635       && record_start_block == 0 && status != 0)
 636     {
 637       unsigned long rsize = (record_size - left) / BLOCKSIZE;
 638       WARN ((0, 0,
 639              ngettext ("Record size = %lu block",
 640                        "Record size = %lu blocks",
 641                        rsize),
 642              rsize));
 643     }
 644
 645   record_end = record_start + (record_size - left) / BLOCKSIZE;
 646   records_read++;
 647 }
 648
 649 /* Perform a read to flush the buffer.  */
 650 size_t
 651 _flush_read (void)
 652 {
 653   size_t status;                /* result from system call */
 654
 655   if (checkpoint_option && !(++checkpoint % 10))
 656     /* TRANSLATORS: This is a ``checkpoint of read operation'',
 657        *not* ``Reading a checkpoint''.
 658        E.g. in Spanish ``Punto de comprobaci@'on de lectura'',
 659        *not* ``Leyendo un punto de comprobaci@'on'' */
 660     WARN ((0, 0, _("Read checkpoint %d"), checkpoint));
 661
 662   /* Clear the count of errors.  This only applies to a single call to
 663      flush_read.  */
 664
 665   read_error_count = 0;         /* clear error count */
 666
 667   if (write_archive_to_stdout && record_start_block != 0)
 668     {
 669       archive = STDOUT_FILENO;
 670       status = sys_write_archive_buffer ();
 671       archive = STDIN_FILENO;
 672       if (status != record_size)
 673         archive_write_error (status);
 674     }
 675
 676   status = rmtread (archive, record_start->buffer, record_size);
 677   if (status == record_size)
 678     records_read++;
 679   return status;
 680 }
 681
 682 /*  Flush the current buffer to/from the archive.  */
 683 void
 684 flush_archive (void)
 685 {
 686   size_t buffer_level = current_block->buffer - record_start->buffer;
 687   record_start_block += record_end - record_start;
 688   current_block = record_start;
 689   record_end = record_start + blocking_factor;
 690
 691   if (access_mode == ACCESS_READ && time_to_start_writing)
 692     {
 693       access_mode = ACCESS_WRITE;
 694       time_to_start_writing = false;
 695       backspace_output ();
 696     }
 697
 698   switch (access_mode)
 699     {
 700     case ACCESS_READ:
 701       flush_read ();
 702       break;
 703
 704     case ACCESS_WRITE:
 705       flush_write_ptr (buffer_level);
 706       break;
 707
 708     case ACCESS_UPDATE:
 709       abort ();
 710     }
 711 }
 712
 713 /* Backspace the archive descriptor by one record worth.  If it's a
 714    tape, MTIOCTOP will work.  If it's something else, try to seek on
 715    it.  If we can't seek, we lose!  */
 716 static void
 717 backspace_output (void)
 718 {
 719 #ifdef MTIOCTOP
 720   {
 721     struct mtop operation;
 722
 723     operation.mt_op = MTBSR;
 724     operation.mt_count = 1;
 725     if (rmtioctl (archive, MTIOCTOP, (char *) &operation) >= 0)
 726       return;
 727     if (errno == EIO && rmtioctl (archive, MTIOCTOP, (char *) &operation) >= 0)
 728       return;
 729   }
 730 #endif
 731
 732   {
 733     off_t position = rmtlseek (archive, (off_t) 0, SEEK_CUR);
 734
 735     /* Seek back to the beginning of this record and start writing there.  */
 736
 737     position -= record_size;
 738     if (position < 0)
 739       position = 0;
 740     if (rmtlseek (archive, position, SEEK_SET) != position)
 741       {
 742         /* Lseek failed.  Try a different method.  */
 743
 744         WARN ((0, 0,
 745                _("Cannot backspace archive file; it may be unreadable without -i")));
 746
 747         /* Replace the first part of the record with NULs.  */
 748
 749         if (record_start->buffer != output_start)
 750           memset (record_start->buffer, 0,
 751                   output_start - record_start->buffer);
 752       }
 753   }
 754 }
 755
 756 off_t
 757 seek_archive (off_t size)
 758 {
 759   off_t start = current_block_ordinal ();
 760   off_t offset;
 761   off_t nrec, nblk;
 762   off_t skipped = (blocking_factor - (current_block - record_start));
 763
 764   size -= skipped * BLOCKSIZE;
 765
 766   if (size < record_size)
 767     return 0;
 768   /* FIXME: flush? */
 769
 770   /* Compute number of records to skip */
 771   nrec = size / record_size;
 772   offset = rmtlseek (archive, nrec * record_size, SEEK_CUR);
 773   if (offset < 0)
 774     return offset;
 775
 776   if (offset % record_size)
 777     FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary")));
 778
 779   /* Convert to number of records */
 780   offset /= BLOCKSIZE;
 781   /* Compute number of skipped blocks */
 782   nblk = offset - start;
 783
 784   /* Update buffering info */
 785   records_read += nblk / blocking_factor;
 786   record_start_block = offset - blocking_factor;
 787   current_block = record_end;
 788
 789   return nblk;
 790 }
 791
 792 /* Close the archive file.  */
 793 void
 794 close_archive (void)
 795 {
 796   if (time_to_start_writing || access_mode == ACCESS_WRITE)
 797     {
 798       flush_archive ();
 799       if (current_block > record_start)
 800         flush_archive ();
 801     }
 802
 803   sys_drain_input_pipe ();
 804
 805   compute_duration ();
 806   if (verify_option)
 807     verify_volume ();
 808
 809   if (rmtclose (archive) != 0)
 810     close_warn (*archive_name_cursor);
 811
 812   sys_wait_for_child (child_pid);
 813
 814   tar_stat_destroy (&current_stat_info);
 815   if (save_name)
 816     free (save_name);
 817   if (real_s_name)
 818     free (real_s_name);
 819   free (record_buffer[0]);
 820   free (record_buffer[1]);
 821 }
 822
 823 /* Called to initialize the global volume number.  */
 824 void
 825 init_volume_number (void)
 826 {
 827   FILE *file = fopen (volno_file_option, "r");
 828
 829   if (file)
 830     {
 831       if (fscanf (file, "%d", &global_volno) != 1
 832           || global_volno < 0)
 833         FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"),
 834                       quotearg_colon (volno_file_option)));
 835       if (ferror (file))
 836         read_error (volno_file_option);
 837       if (fclose (file) != 0)
 838         close_error (volno_file_option);
 839     }
 840   else if (errno != ENOENT)
 841     open_error (volno_file_option);
 842 }
 843
 844 /* Called to write out the closing global volume number.  */
 845 void
 846 closeout_volume_number (void)
 847 {
 848   FILE *file = fopen (volno_file_option, "w");
 849
 850   if (file)
 851     {
 852       fprintf (file, "%d\n", global_volno);
 853       if (ferror (file))
 854         write_error (volno_file_option);
 855       if (fclose (file) != 0)
 856         close_error (volno_file_option);
 857     }
 858   else
 859     open_error (volno_file_option);
 860 }
 861
 862 \f
 863 static void
 864 increase_volume_number ()
 865 {
 866   global_volno++;
 867   if (global_volno < 0)
 868     FATAL_ERROR ((0, 0, _("Volume number overflow")));
 869   volno++;
 870 }
 871
 872 void
 873 change_tape_menu (FILE *read_file)
 874 {
 875   char *input_buffer = NULL;
 876   size_t size = 0;
 877
 878   while (1)
 879     {
 880       fputc ('\007', stderr);
 881       fprintf (stderr,
 882                _("Prepare volume #%d for %s and hit return: "),
 883                global_volno + 1, quote (*archive_name_cursor));
 884       fflush (stderr);
 885
 886       if (getline (&input_buffer, &size, read_file) <= 0)
 887         {
 888           WARN ((0, 0, _("EOF where user reply was expected")));
 889
 890           if (subcommand_option != EXTRACT_SUBCOMMAND
 891               && subcommand_option != LIST_SUBCOMMAND
 892               && subcommand_option != DIFF_SUBCOMMAND)
 893             WARN ((0, 0, _("WARNING: Archive is incomplete")));
 894
 895           fatal_exit ();
 896         }
 897
 898       if (input_buffer[0] == '\n'
 899           || input_buffer[0] == 'y'
 900           || input_buffer[0] == 'Y')
 901         break;
 902
 903       switch (input_buffer[0])
 904         {
 905         case '?':
 906           {
 907             fprintf (stderr, _("\
 908  n [name]      Give a new file name for the next (and subsequent) volume(s)\n\
 909  q             Abort tar\n\
 910  y or newline  Continue operation\n"));
 911             if (!restrict_option)
 912               fprintf (stderr, _(" !             Spawn a subshell\n"));
 913             fprintf (stderr, _(" ?             Print this list\n"));
 914           }
 915           break;
 916
 917         case 'q':
 918           /* Quit.  */
 919
 920           WARN ((0, 0, _("No new volume; exiting.\n")));
 921
 922           if (subcommand_option != EXTRACT_SUBCOMMAND
 923               && subcommand_option != LIST_SUBCOMMAND
 924               && subcommand_option != DIFF_SUBCOMMAND)
 925             WARN ((0, 0, _("WARNING: Archive is incomplete")));
 926
 927           fatal_exit ();
 928
 929         case 'n':
 930           /* Get new file name.  */
 931
 932           {
 933             char *name;
 934             char *cursor;
 935
 936             for (name = input_buffer + 1;
 937                  *name == ' ' || *name == '\t';
 938                  name++)
 939               ;
 940
 941             for (cursor = name; *cursor && *cursor != '\n'; cursor++)
 942               ;
 943             *cursor = '\0';
 944
 945             /* FIXME: the following allocation is never reclaimed.  */
 946             *archive_name_cursor = xstrdup (name);
 947           }
 948           break;
 949
 950         case '!':
 951           if (!restrict_option)
 952             {
 953               sys_spawn_shell ();
 954               break;
 955             }
 956           /* FALL THROUGH */
 957
 958         default:
 959           fprintf (stderr, _("Invalid input. Type ? for help.\n"));
 960         }
 961     }
 962   free (input_buffer);
 963 }
 964
 965 /* We've hit the end of the old volume.  Close it and open the next one.
 966    Return nonzero on success.
 967 */
 968 static bool
 969 new_volume (enum access_mode mode)
 970 {
 971   static FILE *read_file;
 972   static int looped;
 973   int prompt;
 974
 975   if (!read_file && !info_script_option)
 976     /* FIXME: if fopen is used, it will never be closed.  */
 977     read_file = archive == STDIN_FILENO ? fopen (TTY_NAME, "r") : stdin;
 978
 979   if (now_verifying)
 980     return false;
 981   if (verify_option)
 982     verify_volume ();
 983
 984   assign_string (&volume_label, NULL);
 985   assign_string (&continued_file_name, NULL);
 986   continued_file_size = continued_file_offset = 0;
 987
 988   if (rmtclose (archive) != 0)
 989     close_warn (*archive_name_cursor);
 990
 991   archive_name_cursor++;
 992   if (archive_name_cursor == archive_name_array + archive_names)
 993     {
 994       archive_name_cursor = archive_name_array;
 995       looped = 1;
 996     }
 997   prompt = looped;
 998
 999  tryagain:
1000   if (prompt)
1001     {
1002       /* We have to prompt from now on.  */
1003
1004       if (info_script_option)
1005         {
1006           if (volno_file_option)
1007             closeout_volume_number ();
1008           if (sys_exec_info_script (archive_name_cursor, global_volno+1))
1009             FATAL_ERROR ((0, 0, _("%s command failed"),
1010                           quote (info_script_option)));
1011         }
1012       else
1013         change_tape_menu (read_file);
1014     }
1015
1016   if (strcmp (archive_name_cursor[0], "-") == 0)
1017     {
1018       read_full_records = true;
1019       archive = STDIN_FILENO;
1020     }
1021   else if (verify_option)
1022     archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW,
1023                        rsh_command_option);
1024   else
1025     switch (mode)
1026       {
1027       case ACCESS_READ:
1028         archive = rmtopen (*archive_name_cursor, O_RDONLY, MODE_RW,
1029                            rsh_command_option);
1030         break;
1031
1032       case ACCESS_WRITE:
1033         if (backup_option)
1034           maybe_backup_file (*archive_name_cursor, 1);
1035         archive = rmtcreat (*archive_name_cursor, MODE_RW,
1036                             rsh_command_option);
1037         break;
1038
1039       case ACCESS_UPDATE:
1040         archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW,
1041                            rsh_command_option);
1042         break;
1043       }
1044
1045   if (archive < 0)
1046     {
1047       open_warn (*archive_name_cursor);
1048       if (!verify_option && mode == ACCESS_WRITE && backup_option)
1049         undo_last_backup ();
1050       prompt = 1;
1051       goto tryagain;
1052     }
1053
1054   SET_BINARY_MODE (archive);
1055
1056   return true;
1057 }
1058
1059 static bool
1060 read_header0 ()
1061 {
1062   enum read_header rc = read_header (false);
1063
1064   if (rc == HEADER_SUCCESS)
1065     {
1066       set_next_block_after (current_header);
1067       return true;
1068     }
1069   ERROR ((0, 0, _("This does not look like a tar archive")));
1070   return false;
1071 }
1072
1073 bool
1074 try_new_volume ()
1075 {
1076   size_t status;
1077   union block *header;
1078
1079   switch (subcommand_option)
1080     {
1081     case APPEND_SUBCOMMAND:
1082     case CAT_SUBCOMMAND:
1083     case UPDATE_SUBCOMMAND:
1084       if (!new_volume (ACCESS_UPDATE))
1085         return true;
1086       break;
1087
1088     default:
1089       if (!new_volume (ACCESS_READ))
1090         return true;
1091       break;
1092     }
1093
1094   while ((status = rmtread (archive, record_start->buffer, record_size))
1095          == SAFE_READ_ERROR)
1096     archive_read_error ();
1097
1098   if (status != record_size)
1099     short_read (status);
1100
1101   header = find_next_block ();
1102   if (!header)
1103     return false;
1104   switch (header->header.typeflag)
1105     {
1106     case XGLTYPE:
1107       {
1108         struct tar_stat_info dummy;
1109         if (!read_header0 ())
1110           return false;
1111         tar_stat_init (&dummy);
1112         xheader_decode (&dummy); /* decodes values from the global header */
1113         tar_stat_destroy (&dummy);
1114         if (!real_s_name)
1115           {
1116             /* We have read the extended header of the first member in
1117                this volume. Put it back, so next read_header works as
1118                expected. */
1119             current_block = record_start;
1120           }
1121         break;
1122       }
1123
1124     case GNUTYPE_VOLHDR:
1125       if (!read_header0 ())
1126         return false;
1127       assign_string (&volume_label, current_header->header.name);
1128       set_next_block_after (header);
1129       header = find_next_block ();
1130       if (header->header.typeflag != GNUTYPE_MULTIVOL)
1131         break;
1132       /* FALL THROUGH */
1133
1134     case GNUTYPE_MULTIVOL:
1135       if (!read_header0 ())
1136         return false;
1137       assign_string (&continued_file_name, current_header->header.name);
1138       continued_file_size =
1139         UINTMAX_FROM_HEADER (current_header->header.size);
1140       continued_file_offset =
1141         UINTMAX_FROM_HEADER (current_header->oldgnu_header.offset);
1142       break;
1143
1144     default:
1145       break;
1146     }
1147
1148   if (real_s_name)
1149     {
1150       uintmax_t s;
1151       if (!continued_file_name
1152           || strcmp (continued_file_name, real_s_name))
1153         {
1154           if ((archive_format == GNU_FORMAT || archive_format == OLDGNU_FORMAT)
1155               && strlen (real_s_name) >= NAME_FIELD_SIZE
1156               && strncmp (continued_file_name, real_s_name,
1157                           NAME_FIELD_SIZE) == 0)
1158             WARN ((0, 0,
1159  _("%s is possibly continued on this volume: header contains truncated name"),
1160                    quote (real_s_name)));
1161           else
1162             {
1163               WARN ((0, 0, _("%s is not continued on this volume"),
1164                      quote (real_s_name)));
1165               return false;
1166             }
1167         }
1168
1169       s = continued_file_size + continued_file_offset;
1170
1171       if (real_s_totsize != s || s < continued_file_offset)
1172         {
1173           char totsizebuf[UINTMAX_STRSIZE_BOUND];
1174           char s1buf[UINTMAX_STRSIZE_BOUND];
1175           char s2buf[UINTMAX_STRSIZE_BOUND];
1176
1177           WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
1178                  quote (continued_file_name),
1179                  STRINGIFY_BIGINT (save_totsize, totsizebuf),
1180                  STRINGIFY_BIGINT (continued_file_size, s1buf),
1181                  STRINGIFY_BIGINT (continued_file_offset, s2buf)));
1182           return false;
1183         }
1184
1185       if (real_s_totsize - real_s_sizeleft != continued_file_offset)
1186         {
1187           WARN ((0, 0, _("This volume is out of sequence")));
1188           return false;
1189         }
1190     }
1191
1192   increase_volume_number ();
1193   return true;
1194 }
1195
1196 \f
1197 /* Check the LABEL block against the volume label, seen as a globbing
1198    pattern.  Return true if the pattern matches.  In case of failure,
1199    retry matching a volume sequence number before giving up in
1200    multi-volume mode.  */
1201 static bool
1202 check_label_pattern (union block *label)
1203 {
1204   char *string;
1205   bool result;
1206
1207   if (! memchr (label->header.name, '\0', sizeof label->header.name))
1208     return false;
1209
1210   if (fnmatch (volume_label_option, label->header.name, 0) == 0)
1211     return true;
1212
1213   if (!multi_volume_option)
1214     return false;
1215
1216   string = xmalloc (strlen (volume_label_option)
1217                     + sizeof VOLUME_LABEL_APPEND + 1);
1218   strcpy (string, volume_label_option);
1219   strcat (string, VOLUME_LABEL_APPEND);
1220   result = fnmatch (string, label->header.name, 0) == 0;
1221   free (string);
1222   return result;
1223 }
1224
1225 /* Check if the next block contains a volume label and if this matches
1226    the one given in the command line */
1227 static void
1228 match_volume_label (void)
1229 {
1230   union block *label = find_next_block ();
1231
1232   if (!label)
1233     FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1234                   quote (volume_label_option)));
1235   if (!check_label_pattern (label))
1236     FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
1237                   quote_n (0, label->header.name),
1238                   quote_n (1, volume_label_option)));
1239 }
1240
1241 /* Mark the archive with volume label STR. */
1242 static void
1243 _write_volume_label (const char *str)
1244 {
1245   if (archive_format == POSIX_FORMAT)
1246     xheader_store ("GNU.volume.label", NULL, str);
1247   else
1248     {
1249       union block *label = find_next_block ();
1250
1251       memset (label, 0, BLOCKSIZE);
1252
1253       strcpy (label->header.name, volume_label_option);
1254       assign_string (&current_stat_info.file_name,
1255                      label->header.name);
1256       current_stat_info.had_trailing_slash =
1257         strip_trailing_slashes (current_stat_info.file_name);
1258
1259       label->header.typeflag = GNUTYPE_VOLHDR;
1260       TIME_TO_CHARS (start_time.tv_sec, label->header.mtime);
1261       finish_header (&current_stat_info, label, -1);
1262       set_next_block_after (label);
1263     }
1264 }
1265
1266 #define VOL_SUFFIX "Volume"
1267
1268 /* Add a volume label to a part of multi-volume archive */
1269 static void
1270 add_volume_label (void)
1271 {
1272   char buf[UINTMAX_STRSIZE_BOUND];
1273   char *p = STRINGIFY_BIGINT (volno, buf);
1274   char *s = xmalloc (strlen (volume_label_option) + sizeof VOL_SUFFIX
1275                      + strlen (p) + 2);
1276   sprintf (s, "%s %s %s", volume_label_option, VOL_SUFFIX, p);
1277   _write_volume_label (s);
1278   free (s);
1279 }
1280
1281 static void
1282 add_chunk_header ()
1283 {
1284   if (archive_format == POSIX_FORMAT)
1285     {
1286       off_t block_ordinal;
1287       union block *blk;
1288       struct tar_stat_info st;
1289       static size_t real_s_part_no; /* FIXME */
1290
1291       real_s_part_no++;
1292       memset (&st, 0, sizeof st);
1293       st.orig_file_name = st.file_name = real_s_name;
1294       st.stat.st_mode = S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH;
1295       st.stat.st_uid = getuid ();
1296       st.stat.st_gid = getgid ();
1297       st.orig_file_name = xheader_format_name (&st,
1298                                                "%d/GNUFileParts.%p/%f.%n",
1299                                                real_s_part_no);
1300       st.file_name = st.orig_file_name;
1301       st.archive_file_size = st.stat.st_size = real_s_sizeleft;
1302
1303       block_ordinal = current_block_ordinal ();
1304       blk = start_header (&st);
1305       if (!blk)
1306         abort (); /* FIXME */
1307       finish_header (&st, blk, block_ordinal);
1308       free (st.orig_file_name);
1309     }
1310 }
1311
1312
1313 /* Add a volume label to the current archive */
1314 static void
1315 write_volume_label (void)
1316 {
1317   if (multi_volume_option)
1318     add_volume_label ();
1319   else
1320     _write_volume_label (volume_label_option);
1321 }
1322
1323 /* Write GNU multi-volume header */
1324 static void
1325 gnu_add_multi_volume_header (void)
1326 {
1327   int tmp;
1328   union block *block = find_next_block ();
1329
1330   if (strlen (real_s_name) > NAME_FIELD_SIZE)
1331     WARN ((0, 0,
1332            _("%s: file name too long to be stored in a GNU multivolume header, truncated"),
1333            quotearg_colon (real_s_name)));
1334
1335   memset (block, 0, BLOCKSIZE);
1336
1337   /* FIXME: Michael P Urban writes: [a long name file] is being written
1338      when a new volume rolls around [...]  Looks like the wrong value is
1339      being preserved in real_s_name, though.  */
1340
1341   strncpy (block->header.name, real_s_name, NAME_FIELD_SIZE);
1342   block->header.typeflag = GNUTYPE_MULTIVOL;
1343
1344   OFF_TO_CHARS (real_s_sizeleft, block->header.size);
1345   OFF_TO_CHARS (real_s_totsize - real_s_sizeleft,
1346                 block->oldgnu_header.offset);
1347
1348   tmp = verbose_option;
1349   verbose_option = 0;
1350   finish_header (&current_stat_info, block, -1);
1351   verbose_option = tmp;
1352   set_next_block_after (block);
1353 }
1354
1355 /* Add a multi volume header to the current archive. The exact header format
1356    depends on the archive format. */
1357 static void
1358 add_multi_volume_header (void)
1359 {
1360   if (archive_format == POSIX_FORMAT)
1361     {
1362       off_t d = real_s_totsize - real_s_sizeleft;
1363       xheader_store ("GNU.volume.filename", NULL, real_s_name);
1364       xheader_store ("GNU.volume.size", NULL, &real_s_sizeleft);
1365       xheader_store ("GNU.volume.offset", NULL, &d);
1366     }
1367   else
1368     gnu_add_multi_volume_header ();
1369 }
1370
1371 /* Synchronize multi-volume globals */
1372 static void
1373 multi_volume_sync ()
1374 {
1375   if (multi_volume_option)
1376     {
1377       if (save_name)
1378         {
1379           assign_string (&real_s_name,
1380                          safer_name_suffix (save_name, false,
1381                                             absolute_names_option));
1382           real_s_totsize = save_totsize;
1383           real_s_sizeleft = save_sizeleft;
1384         }
1385       else
1386         {
1387           assign_string (&real_s_name, 0);
1388           real_s_totsize = 0;
1389           real_s_sizeleft = 0;
1390         }
1391     }
1392 }
1393
1394 \f
1395 /* Low-level flush functions */
1396
1397 /* Simple flush read (no multi-volume or label extensions) */
1398 static void
1399 simple_flush_read (void)
1400 {
1401   size_t status;                /* result from system call */
1402
1403   if (checkpoint_option && !(++checkpoint % 10))
1404     /* TRANSLATORS: This is a ``checkpoint of read operation'',
1405        *not* ``Reading a checkpoint''.
1406        E.g. in Spanish ``Punto de comprobaci@'on de lectura'',
1407        *not* ``Leyendo un punto de comprobaci@'on'' */
1408     WARN ((0, 0, _("Read checkpoint %d"), checkpoint));
1409
1410   /* Clear the count of errors.  This only applies to a single call to
1411      flush_read.  */
1412
1413   read_error_count = 0;         /* clear error count */
1414
1415   if (write_archive_to_stdout && record_start_block != 0)
1416     {
1417       archive = STDOUT_FILENO;
1418       status = sys_write_archive_buffer ();
1419       archive = STDIN_FILENO;
1420       if (status != record_size)
1421         archive_write_error (status);
1422     }
1423
1424   for (;;)
1425     {
1426       status = rmtread (archive, record_start->buffer, record_size);
1427       if (status == record_size)
1428         {
1429           records_read++;
1430           return;
1431         }
1432       if (status == SAFE_READ_ERROR)
1433         {
1434           archive_read_error ();
1435           continue;             /* try again */
1436         }
1437       break;
1438     }
1439   short_read (status);
1440 }
1441
1442 /* Simple flush write (no multi-volume or label extensions) */
1443 static void
1444 simple_flush_write (size_t level __attribute__((unused)))
1445 {
1446   ssize_t status;
1447
1448   status = _flush_write ();
1449   if (status != record_size)
1450     archive_write_error (status);
1451   else
1452     {
1453       records_written++;
1454       bytes_written += status;
1455     }
1456 }
1457
1458 \f
1459 /* GNU flush functions. These support multi-volume and archive labels in
1460    GNU and PAX archive formats. */
1461
1462 static void
1463 _gnu_flush_read (void)
1464 {
1465   size_t status;                /* result from system call */
1466
1467   if (checkpoint_option && !(++checkpoint % 10))
1468     /* TRANSLATORS: This is a ``checkpoint of read operation'',
1469        *not* ``Reading a checkpoint''.
1470        E.g. in Spanish ``Punto de comprobaci@'on de lectura'',
1471        *not* ``Leyendo un punto de comprobaci@'on'' */
1472     WARN ((0, 0, _("Read checkpoint %d"), checkpoint));
1473
1474   /* Clear the count of errors.  This only applies to a single call to
1475      flush_read.  */
1476
1477   read_error_count = 0;         /* clear error count */
1478
1479   if (write_archive_to_stdout && record_start_block != 0)
1480     {
1481       archive = STDOUT_FILENO;
1482       status = sys_write_archive_buffer ();
1483       archive = STDIN_FILENO;
1484       if (status != record_size)
1485         archive_write_error (status);
1486     }
1487
1488   multi_volume_sync ();
1489
1490   for (;;)
1491     {
1492       status = rmtread (archive, record_start->buffer, record_size);
1493       if (status == record_size)
1494         {
1495           records_read++;
1496           return;
1497         }
1498
1499       /* The condition below used to include
1500               || (status > 0 && !read_full_records)
1501          This is incorrect since even if new_volume() succeeds, the
1502          subsequent call to rmtread will overwrite the chunk of data
1503          already read in the buffer, so the processing will fail */
1504       if ((status == 0
1505            || (status == SAFE_READ_ERROR && errno == ENOSPC))
1506           && multi_volume_option)
1507         {
1508           while (!try_new_volume ())
1509             ;
1510           return;
1511         }
1512       else if (status == SAFE_READ_ERROR)
1513         {
1514           archive_read_error ();
1515           continue;
1516         }
1517       break;
1518     }
1519   short_read (status);
1520 }
1521
1522 static void
1523 gnu_flush_read (void)
1524 {
1525   flush_read_ptr = simple_flush_read; /* Avoid recursion */
1526   _gnu_flush_read ();
1527   flush_read_ptr = gnu_flush_read;
1528 }
1529
1530 static void
1531 _gnu_flush_write (size_t buffer_level)
1532 {
1533   ssize_t status;
1534   union block *header;
1535   char *copy_ptr;
1536   size_t copy_size;
1537   size_t bufsize;
1538
1539   status = _flush_write ();
1540   if (status != record_size && !multi_volume_option)
1541     archive_write_error (status);
1542   else
1543     {
1544       records_written++;
1545       bytes_written += status;
1546     }
1547
1548   if (status == record_size)
1549     {
1550       multi_volume_sync ();
1551       return;
1552     }
1553
1554   /* In multi-volume mode. */
1555   /* ENXIO is for the UNIX PC.  */
1556   if (status < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO)
1557     archive_write_error (status);
1558
1559   if (!new_volume (ACCESS_WRITE))
1560     return;
1561
1562   xheader_destroy (&extended_header);
1563
1564   increase_volume_number ();
1565   if (totals_option)
1566     prev_written += bytes_written;
1567   bytes_written = 0;
1568
1569   copy_ptr = record_start->buffer + status;
1570   copy_size = buffer_level - status;
1571   /* Switch to the next buffer */
1572   record_index = !record_index;
1573   init_buffer ();
1574
1575   if (volume_label_option)
1576     add_volume_label ();
1577
1578   if (real_s_name)
1579     add_multi_volume_header ();
1580
1581   write_extended (true, NULL, find_next_block ());
1582   if (real_s_name)
1583     add_chunk_header ();
1584   header = find_next_block ();
1585   bufsize = available_space_after (header);
1586   while (bufsize < copy_size)
1587     {
1588       memcpy (header->buffer, copy_ptr, bufsize);
1589       copy_ptr += bufsize;
1590       copy_size -= bufsize;
1591       set_next_block_after (header + (bufsize - 1) / BLOCKSIZE);
1592       header = find_next_block ();
1593       bufsize = available_space_after (header);
1594     }
1595   memcpy (header->buffer, copy_ptr, copy_size);
1596   memset (header->buffer + copy_size, 0, bufsize - copy_size);
1597   set_next_block_after (header + (copy_size - 1) / BLOCKSIZE);
1598   find_next_block ();
1599 }
1600
1601 static void
1602 gnu_flush_write (size_t buffer_level)
1603 {
1604   flush_write_ptr = simple_flush_write; /* Avoid recursion */
1605   _gnu_flush_write (buffer_level);
1606   flush_write_ptr = gnu_flush_write;
1607 }
1608
1609 void
1610 flush_read ()
1611 {
1612   flush_read_ptr ();
1613 }
1614
1615 void
1616 flush_write ()
1617 {
1618   flush_write_ptr (record_size);
1619 }
1620
1621 void
1622 open_archive (enum access_mode wanted_access)
1623 {
1624   flush_read_ptr = gnu_flush_read;
1625   flush_write_ptr = gnu_flush_write;
1626
1627   _open_archive (wanted_access);
1628   switch (wanted_access)
1629     {
1630     case ACCESS_READ:
1631       if (volume_label_option)
1632         match_volume_label ();
1633       break;
1634
1635     case ACCESS_WRITE:
1636       records_written = 0;
1637       if (volume_label_option)
1638         write_volume_label ();
1639       break;
1640
1641     default:
1642       break;
1643     }
1644 }