1 /* Buffer management for tar.
3 Copyright 1988, 1992-1994, 1996-1997, 1999-2010, 2013-2014, 2016 Free
4 Software Foundation, Inc.
6 This file is part of GNU tar.
8 GNU tar is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 GNU tar is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 Written by John Gilmore, on 1985-08-25. */
24 #include <system-ioctl.h>
36 /* Number of retries before giving up on read. */
37 #define READ_ERROR_MAX 10
41 static tarlong prev_written; /* bytes written on previous volumes */
42 static tarlong bytes_written; /* bytes written on this volume */
43 static void *record_buffer[2]; /* allocated memory */
44 static union block *record_buffer_aligned[2];
45 static int record_index;
47 /* FIXME: The following variables should ideally be static to this
48 module. However, this cannot be done yet. The cleanup continues! */
50 union block *record_start; /* start of record of archive */
51 union block *record_end; /* last+1 block of archive record */
52 union block *current_block; /* current block of archive */
53 enum access_mode access_mode; /* how do we handle the archive */
54 off_t records_read; /* number of records read from this archive */
55 off_t records_written; /* likewise, for records written */
56 extern off_t records_skipped; /* number of records skipped at the start
57 of the archive, defined in delete.c */
59 static off_t record_start_block; /* block ordinal at record_start */
61 /* Where we write list messages (not errors, not interactions) to. */
64 static void backspace_output (void);
66 /* PID of child program, if compress_option or remote archive access. */
67 static pid_t child_pid;
69 /* Error recovery stuff */
70 static int read_error_count;
72 /* Have we hit EOF yet? */
75 static bool read_full_records = false;
77 /* We're reading, but we just read the last block and it's time to update.
80 FIXME: Either eliminate it or move it to common.h.
82 extern bool time_to_start_writing;
84 bool write_archive_to_stdout;
86 static void (*flush_write_ptr) (size_t);
87 static void (*flush_read_ptr) (void);
91 char *continued_file_name;
92 uintmax_t continued_file_size;
93 uintmax_t continued_file_offset;
96 static int volno = 1; /* which volume of a multi-volume tape we're
98 static int global_volno = 1; /* volume number to print in external
101 bool write_archive_to_stdout;
104 /* Multi-volume tracking support */
106 /* When creating a multi-volume archive, each 'bufmap' represents
107 a member stored (perhaps partly) in the current record buffer.
108 After flushing the record to the output media, all bufmaps that
109 represent fully written members are removed from the list, then
110 the sizeleft and start numbers in the remaining bufmaps are updated.
112 When reading from a multi-volume archive, the list degrades to a
113 single element, which keeps information about the member currently
119 struct bufmap *next; /* Pointer to the next map entry */
120 size_t start; /* Offset of the first data block */
121 char *file_name; /* Name of the stored file */
122 off_t sizetotal; /* Size of the stored file */
123 off_t sizeleft; /* Size left to read/write */
125 static struct bufmap *bufmap_head, *bufmap_tail;
127 /* This variable, when set, inhibits updating the bufmap chain after
128 a write. This is necessary when writing extended POSIX headers. */
129 static int inhibit_map;
132 mv_begin_write (const char *file_name, off_t totsize, off_t sizeleft)
134 if (multi_volume_option)
136 struct bufmap *bp = xmalloc (sizeof bp[0]);
138 bufmap_tail->next = bp;
144 bp->start = current_block - record_start;
145 bp->file_name = xstrdup (file_name);
146 bp->sizetotal = totsize;
147 bp->sizeleft = sizeleft;
151 static struct bufmap *
152 bufmap_locate (size_t off)
156 for (map = bufmap_head; map; map = map->next)
159 || off < map->next->start * BLOCKSIZE)
166 bufmap_free (struct bufmap *mark)
169 for (map = bufmap_head; map && map != mark; )
171 struct bufmap *next = map->next;
172 free (map->file_name);
178 bufmap_tail = bufmap_head;
182 bufmap_reset (struct bufmap *map, ssize_t fixup)
187 for (; map; map = map->next)
193 static struct tar_stat_info dummy;
196 buffer_write_global_xheader (void)
198 xheader_write_global (&dummy.xhdr);
202 mv_begin_read (struct tar_stat_info *st)
204 mv_begin_write (st->orig_file_name, st->stat.st_size, st->stat.st_size);
210 if (multi_volume_option)
215 mv_size_left (off_t size)
218 bufmap_head->sizeleft = size;
225 clear_read_error_count (void)
227 read_error_count = 0;
231 /* Time-related functions */
233 static double duration;
236 set_start_time (void)
238 gettime (&start_time);
239 volume_start_time = start_time;
240 last_stat_time = start_time;
244 set_volume_start_time (void)
246 gettime (&volume_start_time);
247 last_stat_time = volume_start_time;
251 compute_duration (void)
255 duration += ((now.tv_sec - last_stat_time.tv_sec)
256 + (now.tv_nsec - last_stat_time.tv_nsec) / 1e9);
257 gettime (&last_stat_time);
262 /* Compression detection */
265 ct_none, /* Unknown compression type */
266 ct_tar, /* Plain tar file */
276 static enum compress_type archive_compression_type = ct_none;
280 enum compress_type type;
287 enum compress_type type;
292 static struct zip_magic const magic[] = {
295 { ct_compress, 2, "\037\235" },
296 { ct_gzip, 2, "\037\213" },
297 { ct_bzip2, 3, "BZh" },
298 { ct_lzip, 4, "LZIP" },
299 { ct_lzma, 6, "\xFFLZMA" },
300 { ct_lzop, 4, "\211LZO" },
301 { ct_xz, 6, "\xFD" "7zXZ" },
304 #define NMAGIC (sizeof(magic)/sizeof(magic[0]))
306 static struct zip_program zip_program[] = {
307 { ct_compress, COMPRESS_PROGRAM, "-Z" },
308 { ct_compress, GZIP_PROGRAM, "-z" },
309 { ct_gzip, GZIP_PROGRAM, "-z" },
310 { ct_bzip2, BZIP2_PROGRAM, "-j" },
311 { ct_bzip2, "lbzip2", "-j" },
312 { ct_lzip, LZIP_PROGRAM, "--lzip" },
313 { ct_lzma, LZMA_PROGRAM, "--lzma" },
314 { ct_lzma, XZ_PROGRAM, "-J" },
315 { ct_lzop, LZOP_PROGRAM, "--lzop" },
316 { ct_xz, XZ_PROGRAM, "-J" },
320 static struct zip_program const *
321 find_zip_program (enum compress_type type, int *pstate)
325 for (i = *pstate; zip_program[i].type != ct_none; i++)
327 if (zip_program[i].type == type)
330 return zip_program + i;
338 first_decompress_program (int *pstate)
340 struct zip_program const *zp;
342 if (use_compress_program_option)
343 return use_compress_program_option;
345 if (archive_compression_type == ct_none)
349 zp = find_zip_program (archive_compression_type, pstate);
350 return zp ? zp->program : NULL;
354 next_decompress_program (int *pstate)
356 struct zip_program const *zp;
358 if (use_compress_program_option)
360 zp = find_zip_program (archive_compression_type, pstate);
361 return zp ? zp->program : NULL;
365 compress_option (enum compress_type type)
367 struct zip_program const *zp;
369 zp = find_zip_program (type, &i);
370 return zp ? zp->option : NULL;
373 /* Check if the file ARCHIVE is a compressed archive. */
374 static enum compress_type
375 check_compressed_archive (bool *pshort)
377 struct zip_magic const *p;
384 /* Prepare global data needed for find_next_block: */
385 record_end = record_start; /* set up for 1st record = # 0 */
386 sfr = read_full_records;
387 read_full_records = true; /* Suppress fatal error on reading a partial
389 *pshort = find_next_block () == 0;
391 /* Restore global values */
392 read_full_records = sfr;
394 if ((strcmp (record_start->header.magic, TMAGIC) == 0 ||
395 strcmp (record_start->buffer + offsetof (struct posix_header, magic),
396 OLDGNU_MAGIC) == 0) &&
397 tar_checksum (record_start, true) == HEADER_SUCCESS)
398 /* Probably a valid header */
401 for (p = magic + 2; p < magic + NMAGIC; p++)
402 if (memcmp (record_start->buffer, p->magic, p->length) == 0)
408 /* Guess if the archive is seekable. */
410 guess_seekable_archive (void)
414 if (subcommand_option == DELETE_SUBCOMMAND)
416 /* The current code in delete.c is based on the assumption that
417 skip_member() reads all data from the archive. So, we should
418 make sure it won't use seeks. On the other hand, the same code
419 depends on the ability to backspace a record in the archive,
420 so setting seekable_archive to false is technically incorrect.
421 However, it is tested only in skip_member(), so it's not a
423 seekable_archive = false;
426 if (seek_option != -1)
428 seekable_archive = !!seek_option;
432 if (!multi_volume_option && !use_compress_program_option
433 && fstat (archive, &st) == 0)
434 seekable_archive = S_ISREG (st.st_mode);
436 seekable_archive = false;
439 /* Open an archive named archive_name_array[0]. Detect if it is
440 a compressed archive of known type and use corresponding decompression
443 open_compressed_archive (void)
445 archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY,
446 MODE_RW, rsh_command_option);
450 if (!multi_volume_option)
452 if (!use_compress_program_option)
455 enum compress_type type = check_compressed_archive (&shortfile);
461 ERROR ((0, 0, _("This does not look like a tar archive")));
466 ERROR ((0, 0, _("This does not look like a tar archive")));
467 set_compression_program_by_suffix (archive_name_array[0], NULL);
468 if (!use_compress_program_option)
473 archive_compression_type = type;
478 /* FD is not needed any more */
481 hit_eof = false; /* It might have been set by find_next_block in
482 check_compressed_archive */
484 /* Open compressed archive */
485 child_pid = sys_child_open_for_uncompress ();
486 read_full_records = true;
490 record_end = record_start; /* set up for 1st record = # 0 */
496 print_stats (FILE *fp, const char *text, tarlong numbytes)
498 char abbr[LONGEST_HUMAN_READABLE + 1];
499 char rate[LONGEST_HUMAN_READABLE + 1];
502 int human_opts = human_autoscale | human_base_1024 | human_SI | human_B;
505 n += fprintf (fp, "%s: ", gettext (text));
506 return n + fprintf (fp, TARLONG_FORMAT " (%s, %s/s)",
508 human_readable (numbytes, abbr, human_opts, 1, 1),
509 (0 < duration && numbytes / duration < (uintmax_t) -1
510 ? human_readable (numbytes / duration, rate, human_opts, 1, 1)
514 /* Format totals to file FP. FORMATS is an array of strings to output
515 before each data item (bytes read, written, deleted, in that order).
516 EOR is a delimiter to output after each item (used only if deleting
517 from the archive), EOL is a delimiter to add at the end of the output
520 format_total_stats (FILE *fp, char const *const *formats, int eor, int eol)
524 switch (subcommand_option)
526 case CREATE_SUBCOMMAND:
528 case UPDATE_SUBCOMMAND:
529 case APPEND_SUBCOMMAND:
530 n = print_stats (fp, formats[TF_WRITE],
531 prev_written + bytes_written);
534 case DELETE_SUBCOMMAND:
536 char buf[UINTMAX_STRSIZE_BOUND];
537 n = print_stats (fp, formats[TF_READ],
538 records_read * record_size);
543 n += print_stats (fp, formats[TF_WRITE],
544 prev_written + bytes_written);
549 if (formats[TF_DELETED] && formats[TF_DELETED][0])
550 n += fprintf (fp, "%s: ", gettext (formats[TF_DELETED]));
551 n += fprintf (fp, "%s",
552 STRINGIFY_BIGINT ((records_read - records_skipped)
554 - (prev_written + bytes_written), buf));
558 case EXTRACT_SUBCOMMAND:
559 case LIST_SUBCOMMAND:
560 case DIFF_SUBCOMMAND:
561 n = print_stats (fp, _(formats[TF_READ]),
562 records_read * record_size);
576 static char const *const default_total_format[] = {
577 N_("Total bytes read"),
578 /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */
579 N_("Total bytes written"),
580 N_("Total bytes deleted")
584 print_total_stats (void)
586 format_total_stats (stderr, default_total_format, '\n', '\n');
589 /* Compute and return the block ordinal at current_block. */
591 current_block_ordinal (void)
593 return record_start_block + (current_block - record_start);
596 /* If the EOF flag is set, reset it, as well as current_block, etc. */
603 current_block = record_start;
604 record_end = record_start + blocking_factor;
605 access_mode = ACCESS_WRITE;
609 /* Return the location of the next available input or output block.
610 Return zero for EOF. Once we have returned zero, we just keep returning
611 it, to avoid accidentally going on to the next file on the tape. */
613 find_next_block (void)
615 if (current_block == record_end)
620 if (current_block == record_end)
626 return current_block;
629 /* Indicate that we have used all blocks up thru BLOCK. */
631 set_next_block_after (union block *block)
633 while (block >= current_block)
636 /* Do *not* flush the archive here. If we do, the same argument to
637 set_next_block_after could mean the next block (if the input record
638 is exactly one block long), which is not what is intended. */
640 if (current_block > record_end)
644 /* Return the number of bytes comprising the space between POINTER
645 through the end of the current buffer of blocks. This space is
646 available for filling with data, or taking data from. POINTER is
647 usually (but not always) the result of previous find_next_block call. */
649 available_space_after (union block *pointer)
651 return record_end->buffer - pointer->buffer;
654 /* Close file having descriptor FD, and abort if close unsuccessful. */
659 close_error (_("(pipe)"));
665 if (! record_buffer_aligned[record_index])
666 record_buffer_aligned[record_index] =
667 page_aligned_alloc (&record_buffer[record_index], record_size);
669 record_start = record_buffer_aligned[record_index];
670 current_block = record_start;
671 record_end = record_start + blocking_factor;
675 check_tty (enum access_mode mode)
677 /* Refuse to read archive from and write it to a tty. */
678 if (strcmp (archive_name_array[0], "-") == 0
679 && isatty (mode == ACCESS_READ ? STDIN_FILENO : STDOUT_FILENO))
683 ? _("Refusing to read archive contents from terminal "
684 "(missing -f option?)")
685 : _("Refusing to write archive contents to terminal "
686 "(missing -f option?)")));
690 /* Open an archive file. The argument specifies whether we are
691 reading or writing, or both. */
693 _open_archive (enum access_mode wanted_access)
695 int backed_up_flag = 0;
697 if (record_size == 0)
698 FATAL_ERROR ((0, 0, _("Invalid value for record_size")));
700 if (archive_names == 0)
701 FATAL_ERROR ((0, 0, _("No archive name given")));
703 tar_stat_destroy (¤t_stat_info);
708 /* When updating the archive, we start with reading. */
709 access_mode = wanted_access == ACCESS_UPDATE ? ACCESS_READ : wanted_access;
710 check_tty (access_mode);
712 read_full_records = read_full_records_option;
716 if (use_compress_program_option)
718 switch (wanted_access)
721 child_pid = sys_child_open_for_uncompress ();
722 read_full_records = true;
723 record_end = record_start; /* set up for 1st record = # 0 */
727 child_pid = sys_child_open_for_compress ();
731 abort (); /* Should not happen */
736 && wanted_access == ACCESS_WRITE
737 && strcmp (archive_name_array[0], "-") == 0)
740 else if (strcmp (archive_name_array[0], "-") == 0)
742 read_full_records = true; /* could be a pipe, be safe */
744 FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
746 switch (wanted_access)
751 enum compress_type type;
753 archive = STDIN_FILENO;
754 type = check_compressed_archive (&shortfile);
755 if (type != ct_tar && type != ct_none)
757 _("Archive is compressed. Use %s option"),
758 compress_option (type)));
760 ERROR ((0, 0, _("This does not look like a tar archive")));
765 archive = STDOUT_FILENO;
766 if (!index_file_name)
771 archive = STDIN_FILENO;
772 write_archive_to_stdout = true;
773 record_end = record_start; /* set up for 1st record = # 0 */
774 if (!index_file_name)
780 switch (wanted_access)
783 archive = open_compressed_archive ();
785 guess_seekable_archive ();
791 maybe_backup_file (archive_name_array[0], 1);
795 archive = rmtopen (archive_name_array[0], O_RDWR | O_CREAT | O_BINARY,
796 MODE_RW, rsh_command_option);
798 archive = rmtcreat (archive_name_array[0], MODE_RW,
803 archive = rmtopen (archive_name_array[0],
804 O_RDWR | O_CREAT | O_BINARY,
805 MODE_RW, rsh_command_option);
807 switch (check_compressed_archive (NULL))
815 _("Cannot update compressed archives")));
821 || (! _isrmt (archive) && !sys_get_archive_stat ()))
823 int saved_errno = errno;
828 open_fatal (archive_name_array[0]);
831 sys_detect_dev_null_output ();
832 sys_save_archive_dev_ino ();
833 SET_BINARY_MODE (archive);
835 switch (wanted_access)
838 find_next_block (); /* read it in, check for EOF */
848 /* Perform a write to flush the buffer. */
854 checkpoint_run (true);
855 if (tape_length_option && tape_length_option <= bytes_written)
860 else if (dev_null_output)
861 status = record_size;
863 status = sys_write_archive_buffer ();
865 if (status && multi_volume_option && !inhibit_map)
867 struct bufmap *map = bufmap_locate (status);
870 size_t delta = status - map->start * BLOCKSIZE;
871 if (delta > map->sizeleft)
872 delta = map->sizeleft;
873 map->sizeleft -= delta;
874 if (map->sizeleft == 0)
876 bufmap_reset (map, map ? (- map->start) : 0);
882 /* Handle write errors on the archive. Write errors are always fatal.
883 Hitting the end of a volume does not cause a write error unless the
884 write was the first record of the volume. */
886 archive_write_error (ssize_t status)
888 /* It might be useful to know how much was written before the error
893 print_total_stats ();
897 write_fatal_details (*archive_name_cursor, status, record_size);
900 /* Handle read errors on the archive. If the read should be retried,
901 return to the caller. */
903 archive_read_error (void)
905 read_error (*archive_name_cursor);
907 if (record_start_block == 0)
908 FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
910 /* Read error in mid archive. We retry up to READ_ERROR_MAX times and
911 then give up on reading the archive. */
913 if (read_error_count++ > READ_ERROR_MAX)
914 FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
919 archive_is_dev (void)
923 if (fstat (archive, &st))
925 stat_diag (*archive_name_cursor);
928 return S_ISBLK (st.st_mode) || S_ISCHR (st.st_mode);
932 short_read (size_t status)
934 size_t left; /* bytes left */
935 char *more; /* pointer to next byte to read */
937 more = record_start->buffer + status;
938 left = record_size - status;
940 if (left && left % BLOCKSIZE == 0
941 && (warning_option & WARN_RECORD_SIZE)
942 && record_start_block == 0 && status != 0
943 && archive_is_dev ())
945 unsigned long rsize = status / BLOCKSIZE;
947 ngettext ("Record size = %lu block",
948 "Record size = %lu blocks",
953 while (left % BLOCKSIZE != 0
954 || (left && status && read_full_records))
957 while ((status = rmtread (archive, more, left)) == SAFE_READ_ERROR)
958 archive_read_error ();
963 if (! read_full_records)
965 unsigned long rest = record_size - left;
968 ngettext ("Unaligned block (%lu byte) in archive",
969 "Unaligned block (%lu bytes) in archive",
978 record_end = record_start + (record_size - left) / BLOCKSIZE;
982 /* Flush the current buffer to/from the archive. */
988 if (access_mode == ACCESS_READ && time_to_start_writing)
990 access_mode = ACCESS_WRITE;
991 time_to_start_writing = false;
993 if (record_end - record_start < blocking_factor)
995 memset (record_end, 0,
996 (blocking_factor - (record_end - record_start))
998 record_end = record_start + blocking_factor;
1003 buffer_level = current_block->buffer - record_start->buffer;
1004 record_start_block += record_end - record_start;
1005 current_block = record_start;
1006 record_end = record_start + blocking_factor;
1008 switch (access_mode)
1015 flush_write_ptr (buffer_level);
1023 /* Backspace the archive descriptor by one record worth. If it's a
1024 tape, MTIOCTOP will work. If it's something else, try to seek on
1025 it. If we can't seek, we lose! */
1027 backspace_output (void)
1031 struct mtop operation;
1033 operation.mt_op = MTBSR;
1034 operation.mt_count = 1;
1035 if (rmtioctl (archive, MTIOCTOP, (char *) &operation) >= 0)
1037 if (errno == EIO && rmtioctl (archive, MTIOCTOP, (char *) &operation) >= 0)
1043 off_t position = rmtlseek (archive, (off_t) 0, SEEK_CUR);
1045 /* Seek back to the beginning of this record and start writing there. */
1047 position -= record_end->buffer - record_start->buffer;
1050 if (rmtlseek (archive, position, SEEK_SET) != position)
1052 /* Lseek failed. Try a different method. */
1055 _("Cannot backspace archive file; it may be unreadable without -i")));
1057 /* Replace the first part of the record with NULs. */
1059 if (record_start->buffer != output_start)
1060 memset (record_start->buffer, 0,
1061 output_start - record_start->buffer);
1067 seek_archive (off_t size)
1069 off_t start = current_block_ordinal ();
1072 off_t skipped = (blocking_factor - (current_block - record_start))
1075 if (size <= skipped)
1078 /* Compute number of records to skip */
1079 nrec = (size - skipped) / record_size;
1082 offset = rmtlseek (archive, nrec * record_size, SEEK_CUR);
1086 if (offset % record_size)
1087 FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary")));
1089 /* Convert to number of records */
1090 offset /= BLOCKSIZE;
1091 /* Compute number of skipped blocks */
1092 nblk = offset - start;
1094 /* Update buffering info */
1095 records_read += nblk / blocking_factor;
1096 record_start_block = offset - blocking_factor;
1097 current_block = record_end;
1102 /* Close the archive file. */
1104 close_archive (void)
1106 if (time_to_start_writing || access_mode == ACCESS_WRITE)
1109 if (current_block > record_start)
1113 compute_duration ();
1117 if (rmtclose (archive) != 0)
1118 close_error (*archive_name_cursor);
1120 sys_wait_for_child (child_pid, hit_eof);
1122 tar_stat_destroy (¤t_stat_info);
1123 free (record_buffer[0]);
1124 free (record_buffer[1]);
1129 write_fatal_details (char const *name, ssize_t status, size_t size)
1131 write_error_details (name, status, size);
1132 if (rmtclose (archive) != 0)
1133 close_error (*archive_name_cursor);
1134 sys_wait_for_child (child_pid, false);
1138 /* Called to initialize the global volume number. */
1140 init_volume_number (void)
1142 FILE *file = fopen (volno_file_option, "r");
1146 if (fscanf (file, "%d", &global_volno) != 1
1147 || global_volno < 0)
1148 FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"),
1149 quotearg_colon (volno_file_option)));
1151 read_error (volno_file_option);
1152 if (fclose (file) != 0)
1153 close_error (volno_file_option);
1155 else if (errno != ENOENT)
1156 open_error (volno_file_option);
1159 /* Called to write out the closing global volume number. */
1161 closeout_volume_number (void)
1163 FILE *file = fopen (volno_file_option, "w");
1167 fprintf (file, "%d\n", global_volno);
1169 write_error (volno_file_option);
1170 if (fclose (file) != 0)
1171 close_error (volno_file_option);
1174 open_error (volno_file_option);
1179 increase_volume_number (void)
1182 if (global_volno < 0)
1183 FATAL_ERROR ((0, 0, _("Volume number overflow")));
1188 change_tape_menu (FILE *read_file)
1190 char *input_buffer = NULL;
1196 fputc ('\007', stderr);
1198 _("Prepare volume #%d for %s and hit return: "),
1199 global_volno + 1, quote (*archive_name_cursor));
1202 if (getline (&input_buffer, &size, read_file) <= 0)
1204 WARN ((0, 0, _("EOF where user reply was expected")));
1206 if (subcommand_option != EXTRACT_SUBCOMMAND
1207 && subcommand_option != LIST_SUBCOMMAND
1208 && subcommand_option != DIFF_SUBCOMMAND)
1209 WARN ((0, 0, _("WARNING: Archive is incomplete")));
1214 if (input_buffer[0] == '\n'
1215 || input_buffer[0] == 'y'
1216 || input_buffer[0] == 'Y')
1219 switch (input_buffer[0])
1223 fprintf (stderr, _("\
1224 n name Give a new file name for the next (and subsequent) volume(s)\n\
1226 y or newline Continue operation\n"));
1227 if (!restrict_option)
1228 fprintf (stderr, _(" ! Spawn a subshell\n"));
1229 fprintf (stderr, _(" ? Print this list\n"));
1236 WARN ((0, 0, _("No new volume; exiting.\n")));
1238 if (subcommand_option != EXTRACT_SUBCOMMAND
1239 && subcommand_option != LIST_SUBCOMMAND
1240 && subcommand_option != DIFF_SUBCOMMAND)
1241 WARN ((0, 0, _("WARNING: Archive is incomplete")));
1246 /* Get new file name. */
1252 for (name = input_buffer + 1;
1253 *name == ' ' || *name == '\t';
1257 for (cursor = name; *cursor && *cursor != '\n'; cursor++)
1263 /* FIXME: the following allocation is never reclaimed. */
1264 *archive_name_cursor = xstrdup (name);
1268 fprintf (stderr, "%s",
1269 _("File name not specified. Try again.\n"));
1274 if (!restrict_option)
1282 fprintf (stderr, _("Invalid input. Type ? for help.\n"));
1285 free (input_buffer);
1288 /* We've hit the end of the old volume. Close it and open the next one.
1289 Return nonzero on success.
1292 new_volume (enum access_mode mode)
1294 static FILE *read_file;
1298 if (!read_file && !info_script_option)
1299 /* FIXME: if fopen is used, it will never be closed. */
1300 read_file = archive == STDIN_FILENO ? fopen (TTY_NAME, "r") : stdin;
1307 assign_string (&volume_label, NULL);
1308 assign_string (&continued_file_name, NULL);
1309 continued_file_size = continued_file_offset = 0;
1310 current_block = record_start;
1312 if (rmtclose (archive) != 0)
1313 close_error (*archive_name_cursor);
1315 archive_name_cursor++;
1316 if (archive_name_cursor == archive_name_array + archive_names)
1318 archive_name_cursor = archive_name_array;
1326 /* We have to prompt from now on. */
1328 if (info_script_option)
1330 if (volno_file_option)
1331 closeout_volume_number ();
1332 if (sys_exec_info_script (archive_name_cursor, global_volno+1))
1333 FATAL_ERROR ((0, 0, _("%s command failed"),
1334 quote (info_script_option)));
1337 change_tape_menu (read_file);
1340 if (strcmp (archive_name_cursor[0], "-") == 0)
1342 read_full_records = true;
1343 archive = STDIN_FILENO;
1345 else if (verify_option)
1346 archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW,
1347 rsh_command_option);
1352 archive = rmtopen (*archive_name_cursor, O_RDONLY, MODE_RW,
1353 rsh_command_option);
1354 guess_seekable_archive ();
1359 maybe_backup_file (*archive_name_cursor, 1);
1360 archive = rmtcreat (*archive_name_cursor, MODE_RW,
1361 rsh_command_option);
1365 archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW,
1366 rsh_command_option);
1372 open_warn (*archive_name_cursor);
1373 if (!verify_option && mode == ACCESS_WRITE && backup_option)
1374 undo_last_backup ();
1379 SET_BINARY_MODE (archive);
1385 read_header0 (struct tar_stat_info *info)
1387 enum read_header rc;
1389 tar_stat_init (info);
1390 rc = read_header (¤t_header, info, read_header_auto);
1391 if (rc == HEADER_SUCCESS)
1393 set_next_block_after (current_header);
1396 ERROR ((0, 0, _("This does not look like a tar archive")));
1401 try_new_volume (void)
1404 union block *header;
1405 enum access_mode acc;
1407 switch (subcommand_option)
1409 case APPEND_SUBCOMMAND:
1410 case CAT_SUBCOMMAND:
1411 case UPDATE_SUBCOMMAND:
1412 acc = ACCESS_UPDATE;
1420 if (!new_volume (acc))
1423 while ((status = rmtread (archive, record_start->buffer, record_size))
1425 archive_read_error ();
1427 if (status != record_size)
1428 short_read (status);
1430 header = find_next_block ();
1433 WARN ((0, 0, _("This does not look like a tar archive")));
1437 switch (header->header.typeflag)
1441 tar_stat_init (&dummy);
1442 if (read_header (&header, &dummy, read_header_x_global)
1443 != HEADER_SUCCESS_EXTENDED)
1445 WARN ((0, 0, _("This does not look like a tar archive")));
1449 xheader_decode (&dummy); /* decodes values from the global header */
1450 tar_stat_destroy (&dummy);
1452 /* The initial global header must be immediately followed by
1453 an extended PAX header for the first member in this volume.
1454 However, in some cases tar may split volumes in the middle
1455 of a PAX header. This is incorrect, and should be fixed
1456 in the future versions. In the meantime we must be
1457 prepared to correctly list and extract such archives.
1459 If this happens, the following call to read_header returns
1460 HEADER_FAILURE, which is ignored.
1462 See also tests/multiv07.at */
1464 switch (read_header (&header, &dummy, read_header_auto))
1466 case HEADER_SUCCESS:
1467 set_next_block_after (header);
1470 case HEADER_FAILURE:
1474 WARN ((0, 0, _("This does not look like a tar archive")));
1480 case GNUTYPE_VOLHDR:
1481 if (!read_header0 (&dummy))
1483 tar_stat_destroy (&dummy);
1484 assign_string (&volume_label, current_header->header.name);
1485 set_next_block_after (header);
1486 header = find_next_block ();
1487 if (header->header.typeflag != GNUTYPE_MULTIVOL)
1491 case GNUTYPE_MULTIVOL:
1492 if (!read_header0 (&dummy))
1494 tar_stat_destroy (&dummy);
1495 assign_string (&continued_file_name, current_header->header.name);
1496 continued_file_size =
1497 UINTMAX_FROM_HEADER (current_header->header.size);
1498 continued_file_offset =
1499 UINTMAX_FROM_HEADER (current_header->oldgnu_header.offset);
1509 if (!continued_file_name)
1511 WARN ((0, 0, _("%s is not continued on this volume"),
1512 quote (bufmap_head->file_name)));
1516 if (strcmp (continued_file_name, bufmap_head->file_name))
1518 if ((archive_format == GNU_FORMAT || archive_format == OLDGNU_FORMAT)
1519 && strlen (bufmap_head->file_name) >= NAME_FIELD_SIZE
1520 && strncmp (continued_file_name, bufmap_head->file_name,
1521 NAME_FIELD_SIZE) == 0)
1523 _("%s is possibly continued on this volume: header contains truncated name"),
1524 quote (bufmap_head->file_name)));
1527 WARN ((0, 0, _("%s is not continued on this volume"),
1528 quote (bufmap_head->file_name)));
1533 s = continued_file_size + continued_file_offset;
1535 if (bufmap_head->sizetotal != s || s < continued_file_offset)
1537 char totsizebuf[UINTMAX_STRSIZE_BOUND];
1538 char s1buf[UINTMAX_STRSIZE_BOUND];
1539 char s2buf[UINTMAX_STRSIZE_BOUND];
1541 WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
1542 quote (continued_file_name),
1543 STRINGIFY_BIGINT (bufmap_head->sizetotal, totsizebuf),
1544 STRINGIFY_BIGINT (continued_file_size, s1buf),
1545 STRINGIFY_BIGINT (continued_file_offset, s2buf)));
1549 if (bufmap_head->sizetotal - bufmap_head->sizeleft !=
1550 continued_file_offset)
1552 char totsizebuf[UINTMAX_STRSIZE_BOUND];
1553 char s1buf[UINTMAX_STRSIZE_BOUND];
1554 char s2buf[UINTMAX_STRSIZE_BOUND];
1556 WARN ((0, 0, _("This volume is out of sequence (%s - %s != %s)"),
1557 STRINGIFY_BIGINT (bufmap_head->sizetotal, totsizebuf),
1558 STRINGIFY_BIGINT (bufmap_head->sizeleft, s1buf),
1559 STRINGIFY_BIGINT (continued_file_offset, s2buf)));
1565 increase_volume_number ();
1570 #define VOLUME_TEXT " Volume "
1571 #define VOLUME_TEXT_LEN (sizeof VOLUME_TEXT - 1)
1574 drop_volume_label_suffix (const char *label)
1577 size_t len = strlen (label);
1582 for (p = label + len - 1; p > label && isdigit ((unsigned char) *p); p--)
1584 if (p > label && p - (VOLUME_TEXT_LEN - 1) > label)
1586 p -= VOLUME_TEXT_LEN - 1;
1587 if (memcmp (p, VOLUME_TEXT, VOLUME_TEXT_LEN) == 0)
1589 char *s = xmalloc ((len = p - label) + 1);
1590 memcpy (s, label, len);
1599 /* Check LABEL against the volume label, seen as a globbing
1600 pattern. Return true if the pattern matches. In case of failure,
1601 retry matching a volume sequence number before giving up in
1602 multi-volume mode. */
1604 check_label_pattern (const char *label)
1607 bool result = false;
1609 if (fnmatch (volume_label_option, label, 0) == 0)
1612 if (!multi_volume_option)
1615 string = drop_volume_label_suffix (label);
1618 result = fnmatch (string, volume_label_option, 0) == 0;
1624 /* Check if the next block contains a volume label and if this matches
1625 the one given in the command line */
1627 match_volume_label (void)
1631 union block *label = find_next_block ();
1634 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1635 quote (volume_label_option)));
1636 if (label->header.typeflag == GNUTYPE_VOLHDR)
1638 if (memchr (label->header.name, '\0', sizeof label->header.name))
1639 assign_string (&volume_label, label->header.name);
1642 volume_label = xmalloc (sizeof (label->header.name) + 1);
1643 memcpy (volume_label, label->header.name,
1644 sizeof (label->header.name));
1645 volume_label[sizeof (label->header.name)] = 0;
1648 else if (label->header.typeflag == XGLTYPE)
1650 struct tar_stat_info st;
1651 tar_stat_init (&st);
1652 xheader_read (&st.xhdr, label,
1653 OFF_FROM_HEADER (label->header.size));
1654 xheader_decode (&st);
1655 tar_stat_destroy (&st);
1660 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1661 quote (volume_label_option)));
1663 if (!check_label_pattern (volume_label))
1664 FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
1665 quote_n (0, volume_label),
1666 quote_n (1, volume_label_option)));
1669 /* Mark the archive with volume label STR. */
1671 _write_volume_label (const char *str)
1673 if (archive_format == POSIX_FORMAT)
1674 xheader_store ("GNU.volume.label", &dummy, str);
1677 union block *label = find_next_block ();
1679 memset (label, 0, BLOCKSIZE);
1681 strcpy (label->header.name, str);
1682 assign_string (¤t_stat_info.file_name,
1683 label->header.name);
1684 current_stat_info.had_trailing_slash =
1685 strip_trailing_slashes (current_stat_info.file_name);
1687 label->header.typeflag = GNUTYPE_VOLHDR;
1688 TIME_TO_CHARS (start_time.tv_sec, label->header.mtime);
1689 finish_header (¤t_stat_info, label, -1);
1690 set_next_block_after (label);
1694 #define VOL_SUFFIX "Volume"
1696 /* Add a volume label to a part of multi-volume archive */
1698 add_volume_label (void)
1700 char buf[UINTMAX_STRSIZE_BOUND];
1701 char *p = STRINGIFY_BIGINT (volno, buf);
1702 char *s = xmalloc (strlen (volume_label_option) + sizeof VOL_SUFFIX
1704 sprintf (s, "%s %s %s", volume_label_option, VOL_SUFFIX, p);
1705 _write_volume_label (s);
1710 add_chunk_header (struct bufmap *map)
1712 if (archive_format == POSIX_FORMAT)
1714 off_t block_ordinal;
1716 struct tar_stat_info st;
1718 memset (&st, 0, sizeof st);
1719 st.orig_file_name = st.file_name = map->file_name;
1720 st.stat.st_mode = S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH;
1721 st.stat.st_uid = getuid ();
1722 st.stat.st_gid = getgid ();
1723 st.orig_file_name = xheader_format_name (&st,
1724 "%d/GNUFileParts.%p/%f.%n",
1726 st.file_name = st.orig_file_name;
1727 st.archive_file_size = st.stat.st_size = map->sizeleft;
1729 block_ordinal = current_block_ordinal ();
1730 blk = start_header (&st);
1732 abort (); /* FIXME */
1733 finish_header (&st, blk, block_ordinal);
1734 free (st.orig_file_name);
1739 /* Add a volume label to the current archive */
1741 write_volume_label (void)
1743 if (multi_volume_option)
1744 add_volume_label ();
1746 _write_volume_label (volume_label_option);
1749 /* Write GNU multi-volume header */
1751 gnu_add_multi_volume_header (struct bufmap *map)
1754 union block *block = find_next_block ();
1756 if (strlen (map->file_name) > NAME_FIELD_SIZE)
1758 _("%s: file name too long to be stored in a GNU multivolume header, truncated"),
1759 quotearg_colon (map->file_name)));
1761 memset (block, 0, BLOCKSIZE);
1763 strncpy (block->header.name, map->file_name, NAME_FIELD_SIZE);
1764 block->header.typeflag = GNUTYPE_MULTIVOL;
1766 OFF_TO_CHARS (map->sizeleft, block->header.size);
1767 OFF_TO_CHARS (map->sizetotal - map->sizeleft,
1768 block->oldgnu_header.offset);
1770 tmp = verbose_option;
1772 finish_header (¤t_stat_info, block, -1);
1773 verbose_option = tmp;
1774 set_next_block_after (block);
1777 /* Add a multi volume header to the current archive. The exact header format
1778 depends on the archive format. */
1780 add_multi_volume_header (struct bufmap *map)
1782 if (archive_format == POSIX_FORMAT)
1784 off_t d = map->sizetotal - map->sizeleft;
1785 xheader_store ("GNU.volume.filename", &dummy, map->file_name);
1786 xheader_store ("GNU.volume.size", &dummy, &map->sizeleft);
1787 xheader_store ("GNU.volume.offset", &dummy, &d);
1790 gnu_add_multi_volume_header (map);
1794 /* Low-level flush functions */
1796 /* Simple flush read (no multi-volume or label extensions) */
1798 simple_flush_read (void)
1800 size_t status; /* result from system call */
1802 checkpoint_run (false);
1804 /* Clear the count of errors. This only applies to a single call to
1807 read_error_count = 0; /* clear error count */
1809 if (write_archive_to_stdout && record_start_block != 0)
1811 archive = STDOUT_FILENO;
1812 status = sys_write_archive_buffer ();
1813 archive = STDIN_FILENO;
1814 if (status != record_size)
1815 archive_write_error (status);
1820 status = rmtread (archive, record_start->buffer, record_size);
1821 if (status == record_size)
1826 if (status == SAFE_READ_ERROR)
1828 archive_read_error ();
1829 continue; /* try again */
1833 short_read (status);
1836 /* Simple flush write (no multi-volume or label extensions) */
1838 simple_flush_write (size_t level __attribute__((unused)))
1842 status = _flush_write ();
1843 if (status != record_size)
1844 archive_write_error (status);
1848 bytes_written += status;
1853 /* GNU flush functions. These support multi-volume and archive labels in
1854 GNU and PAX archive formats. */
1857 _gnu_flush_read (void)
1859 size_t status; /* result from system call */
1861 checkpoint_run (false);
1863 /* Clear the count of errors. This only applies to a single call to
1866 read_error_count = 0; /* clear error count */
1868 if (write_archive_to_stdout && record_start_block != 0)
1870 archive = STDOUT_FILENO;
1871 status = sys_write_archive_buffer ();
1872 archive = STDIN_FILENO;
1873 if (status != record_size)
1874 archive_write_error (status);
1879 status = rmtread (archive, record_start->buffer, record_size);
1880 if (status == record_size)
1886 /* The condition below used to include
1887 || (status > 0 && !read_full_records)
1888 This is incorrect since even if new_volume() succeeds, the
1889 subsequent call to rmtread will overwrite the chunk of data
1890 already read in the buffer, so the processing will fail */
1892 || (status == SAFE_READ_ERROR && errno == ENOSPC))
1893 && multi_volume_option)
1895 while (!try_new_volume ())
1897 if (current_block == record_end)
1898 /* Necessary for blocking_factor == 1 */
1902 else if (status == SAFE_READ_ERROR)
1904 archive_read_error ();
1909 short_read (status);
1913 gnu_flush_read (void)
1915 flush_read_ptr = simple_flush_read; /* Avoid recursion */
1917 flush_read_ptr = gnu_flush_read;
1921 _gnu_flush_write (size_t buffer_level)
1924 union block *header;
1930 status = _flush_write ();
1931 if (status != record_size && !multi_volume_option)
1932 archive_write_error (status);
1937 bytes_written += status;
1940 if (status == record_size)
1945 map = bufmap_locate (status);
1947 if (status % BLOCKSIZE)
1949 ERROR ((0, 0, _("write did not end on a block boundary")));
1950 archive_write_error (status);
1953 /* In multi-volume mode. */
1954 /* ENXIO is for the UNIX PC. */
1955 if (status < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO)
1956 archive_write_error (status);
1958 if (!new_volume (ACCESS_WRITE))
1961 tar_stat_destroy (&dummy);
1963 increase_volume_number ();
1964 prev_written += bytes_written;
1967 copy_ptr = record_start->buffer + status;
1968 copy_size = buffer_level - status;
1970 /* Switch to the next buffer */
1971 record_index = !record_index;
1976 if (volume_label_option)
1977 add_volume_label ();
1980 add_multi_volume_header (map);
1982 write_extended (true, &dummy, find_next_block ());
1983 tar_stat_destroy (&dummy);
1986 add_chunk_header (map);
1987 header = find_next_block ();
1988 bufmap_reset (map, header - record_start);
1989 bufsize = available_space_after (header);
1991 while (bufsize < copy_size)
1993 memcpy (header->buffer, copy_ptr, bufsize);
1994 copy_ptr += bufsize;
1995 copy_size -= bufsize;
1996 set_next_block_after (header + (bufsize - 1) / BLOCKSIZE);
1997 header = find_next_block ();
1998 bufsize = available_space_after (header);
2000 memcpy (header->buffer, copy_ptr, copy_size);
2001 memset (header->buffer + copy_size, 0, bufsize - copy_size);
2002 set_next_block_after (header + (copy_size - 1) / BLOCKSIZE);
2007 gnu_flush_write (size_t buffer_level)
2009 flush_write_ptr = simple_flush_write; /* Avoid recursion */
2010 _gnu_flush_write (buffer_level);
2011 flush_write_ptr = gnu_flush_write;
2023 flush_write_ptr (record_size);
2027 open_archive (enum access_mode wanted_access)
2029 flush_read_ptr = gnu_flush_read;
2030 flush_write_ptr = gnu_flush_write;
2032 _open_archive (wanted_access);
2033 switch (wanted_access)
2037 if (volume_label_option)
2038 match_volume_label ();
2042 records_written = 0;
2043 if (volume_label_option)
2044 write_volume_label ();
2047 set_volume_start_time ();