1 /* Buffer management for tar.
3 Copyright 1988, 1992-1994, 1996-1997, 1999-2010, 2013-2014 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 (tar_checksum (record_start, true) == HEADER_SUCCESS)
395 /* Probably a valid header */
398 for (p = magic + 2; p < magic + NMAGIC; p++)
399 if (memcmp (record_start->buffer, p->magic, p->length) == 0)
405 /* Guess if the archive is seekable. */
407 guess_seekable_archive (void)
411 if (subcommand_option == DELETE_SUBCOMMAND)
413 /* The current code in delete.c is based on the assumption that
414 skip_member() reads all data from the archive. So, we should
415 make sure it won't use seeks. On the other hand, the same code
416 depends on the ability to backspace a record in the archive,
417 so setting seekable_archive to false is technically incorrect.
418 However, it is tested only in skip_member(), so it's not a
420 seekable_archive = false;
423 if (seek_option != -1)
425 seekable_archive = !!seek_option;
429 if (!multi_volume_option && !use_compress_program_option
430 && fstat (archive, &st) == 0)
431 seekable_archive = S_ISREG (st.st_mode);
433 seekable_archive = false;
436 /* Open an archive named archive_name_array[0]. Detect if it is
437 a compressed archive of known type and use corresponding decompression
440 open_compressed_archive (void)
442 archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY,
443 MODE_RW, rsh_command_option);
447 if (!multi_volume_option)
449 if (!use_compress_program_option)
452 enum compress_type type = check_compressed_archive (&shortfile);
458 ERROR ((0, 0, _("This does not look like a tar archive")));
463 ERROR ((0, 0, _("This does not look like a tar archive")));
464 set_compression_program_by_suffix (archive_name_array[0], NULL);
465 if (!use_compress_program_option)
470 archive_compression_type = type;
475 /* FD is not needed any more */
478 hit_eof = false; /* It might have been set by find_next_block in
479 check_compressed_archive */
481 /* Open compressed archive */
482 child_pid = sys_child_open_for_uncompress ();
483 read_full_records = true;
487 record_end = record_start; /* set up for 1st record = # 0 */
493 print_stats (FILE *fp, const char *text, tarlong numbytes)
495 char abbr[LONGEST_HUMAN_READABLE + 1];
496 char rate[LONGEST_HUMAN_READABLE + 1];
499 int human_opts = human_autoscale | human_base_1024 | human_SI | human_B;
502 n += fprintf (fp, "%s: ", gettext (text));
503 return n + fprintf (fp, TARLONG_FORMAT " (%s, %s/s)",
505 human_readable (numbytes, abbr, human_opts, 1, 1),
506 (0 < duration && numbytes / duration < (uintmax_t) -1
507 ? human_readable (numbytes / duration, rate, human_opts, 1, 1)
511 /* Format totals to file FP. FORMATS is an array of strings to output
512 before each data item (bytes read, written, deleted, in that order).
513 EOR is a delimiter to output after each item (used only if deleting
514 from the archive), EOL is a delimiter to add at the end of the output
517 format_total_stats (FILE *fp, const char **formats, int eor, int eol)
521 switch (subcommand_option)
523 case CREATE_SUBCOMMAND:
525 case UPDATE_SUBCOMMAND:
526 case APPEND_SUBCOMMAND:
527 n = print_stats (fp, formats[TF_WRITE],
528 prev_written + bytes_written);
531 case DELETE_SUBCOMMAND:
533 char buf[UINTMAX_STRSIZE_BOUND];
534 n = print_stats (fp, formats[TF_READ],
535 records_read * record_size);
540 n += print_stats (fp, formats[TF_WRITE],
541 prev_written + bytes_written);
546 if (formats[TF_DELETED] && formats[TF_DELETED][0])
547 n += fprintf (fp, "%s: ", gettext (formats[TF_DELETED]));
548 n += fprintf (fp, "%s",
549 STRINGIFY_BIGINT ((records_read - records_skipped)
551 - (prev_written + bytes_written), buf));
555 case EXTRACT_SUBCOMMAND:
556 case LIST_SUBCOMMAND:
557 case DIFF_SUBCOMMAND:
558 n = print_stats (fp, _(formats[TF_READ]),
559 records_read * record_size);
573 const char *default_total_format[] = {
574 N_("Total bytes read"),
575 /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */
576 N_("Total bytes written"),
577 N_("Total bytes deleted")
581 print_total_stats (void)
583 format_total_stats (stderr, default_total_format, '\n', '\n');
586 /* Compute and return the block ordinal at current_block. */
588 current_block_ordinal (void)
590 return record_start_block + (current_block - record_start);
593 /* If the EOF flag is set, reset it, as well as current_block, etc. */
600 current_block = record_start;
601 record_end = record_start + blocking_factor;
602 access_mode = ACCESS_WRITE;
606 /* Return the location of the next available input or output block.
607 Return zero for EOF. Once we have returned zero, we just keep returning
608 it, to avoid accidentally going on to the next file on the tape. */
610 find_next_block (void)
612 if (current_block == record_end)
617 if (current_block == record_end)
623 return current_block;
626 /* Indicate that we have used all blocks up thru BLOCK. */
628 set_next_block_after (union block *block)
630 while (block >= current_block)
633 /* Do *not* flush the archive here. If we do, the same argument to
634 set_next_block_after could mean the next block (if the input record
635 is exactly one block long), which is not what is intended. */
637 if (current_block > record_end)
641 /* Return the number of bytes comprising the space between POINTER
642 through the end of the current buffer of blocks. This space is
643 available for filling with data, or taking data from. POINTER is
644 usually (but not always) the result of previous find_next_block call. */
646 available_space_after (union block *pointer)
648 return record_end->buffer - pointer->buffer;
651 /* Close file having descriptor FD, and abort if close unsuccessful. */
656 close_error (_("(pipe)"));
662 if (! record_buffer_aligned[record_index])
663 record_buffer_aligned[record_index] =
664 page_aligned_alloc (&record_buffer[record_index], record_size);
666 record_start = record_buffer_aligned[record_index];
667 current_block = record_start;
668 record_end = record_start + blocking_factor;
672 check_tty (enum access_mode mode)
674 /* Refuse to read archive from and write it to a tty. */
675 if (strcmp (archive_name_array[0], "-") == 0
676 && isatty (mode == ACCESS_READ ? STDIN_FILENO : STDOUT_FILENO))
680 ? _("Refusing to read archive contents from terminal "
681 "(missing -f option?)")
682 : _("Refusing to write archive contents to terminal "
683 "(missing -f option?)")));
687 /* Open an archive file. The argument specifies whether we are
688 reading or writing, or both. */
690 _open_archive (enum access_mode wanted_access)
692 int backed_up_flag = 0;
694 if (record_size == 0)
695 FATAL_ERROR ((0, 0, _("Invalid value for record_size")));
697 if (archive_names == 0)
698 FATAL_ERROR ((0, 0, _("No archive name given")));
700 tar_stat_destroy (¤t_stat_info);
705 /* When updating the archive, we start with reading. */
706 access_mode = wanted_access == ACCESS_UPDATE ? ACCESS_READ : wanted_access;
707 check_tty (access_mode);
709 read_full_records = read_full_records_option;
713 if (use_compress_program_option)
715 switch (wanted_access)
718 child_pid = sys_child_open_for_uncompress ();
719 read_full_records = true;
720 record_end = record_start; /* set up for 1st record = # 0 */
724 child_pid = sys_child_open_for_compress ();
728 abort (); /* Should not happen */
733 && wanted_access == ACCESS_WRITE
734 && strcmp (archive_name_array[0], "-") == 0)
737 else if (strcmp (archive_name_array[0], "-") == 0)
739 read_full_records = true; /* could be a pipe, be safe */
741 FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
743 switch (wanted_access)
748 enum compress_type type;
750 archive = STDIN_FILENO;
751 type = check_compressed_archive (&shortfile);
752 if (type != ct_tar && type != ct_none)
754 _("Archive is compressed. Use %s option"),
755 compress_option (type)));
757 ERROR ((0, 0, _("This does not look like a tar archive")));
762 archive = STDOUT_FILENO;
763 if (!index_file_name)
768 archive = STDIN_FILENO;
769 write_archive_to_stdout = true;
770 record_end = record_start; /* set up for 1st record = # 0 */
771 if (!index_file_name)
777 switch (wanted_access)
780 archive = open_compressed_archive ();
782 guess_seekable_archive ();
788 maybe_backup_file (archive_name_array[0], 1);
792 archive = rmtopen (archive_name_array[0], O_RDWR | O_CREAT | O_BINARY,
793 MODE_RW, rsh_command_option);
795 archive = rmtcreat (archive_name_array[0], MODE_RW,
800 archive = rmtopen (archive_name_array[0],
801 O_RDWR | O_CREAT | O_BINARY,
802 MODE_RW, rsh_command_option);
804 switch (check_compressed_archive (NULL))
812 _("Cannot update compressed archives")));
818 || (! _isrmt (archive) && !sys_get_archive_stat ()))
820 int saved_errno = errno;
825 open_fatal (archive_name_array[0]);
828 sys_detect_dev_null_output ();
829 sys_save_archive_dev_ino ();
830 SET_BINARY_MODE (archive);
832 switch (wanted_access)
835 find_next_block (); /* read it in, check for EOF */
845 /* Perform a write to flush the buffer. */
851 checkpoint_run (true);
852 if (tape_length_option && tape_length_option <= bytes_written)
857 else if (dev_null_output)
858 status = record_size;
860 status = sys_write_archive_buffer ();
862 if (status && multi_volume_option && !inhibit_map)
864 struct bufmap *map = bufmap_locate (status);
867 size_t delta = status - map->start * BLOCKSIZE;
868 if (delta > map->sizeleft)
869 delta = map->sizeleft;
870 map->sizeleft -= delta;
871 if (map->sizeleft == 0)
873 bufmap_reset (map, map ? (- map->start) : 0);
879 /* Handle write errors on the archive. Write errors are always fatal.
880 Hitting the end of a volume does not cause a write error unless the
881 write was the first record of the volume. */
883 archive_write_error (ssize_t status)
885 /* It might be useful to know how much was written before the error
890 print_total_stats ();
894 write_fatal_details (*archive_name_cursor, status, record_size);
897 /* Handle read errors on the archive. If the read should be retried,
898 return to the caller. */
900 archive_read_error (void)
902 read_error (*archive_name_cursor);
904 if (record_start_block == 0)
905 FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
907 /* Read error in mid archive. We retry up to READ_ERROR_MAX times and
908 then give up on reading the archive. */
910 if (read_error_count++ > READ_ERROR_MAX)
911 FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
916 archive_is_dev (void)
920 if (fstat (archive, &st))
922 stat_diag (*archive_name_cursor);
925 return S_ISBLK (st.st_mode) || S_ISCHR (st.st_mode);
929 short_read (size_t status)
931 size_t left; /* bytes left */
932 char *more; /* pointer to next byte to read */
934 more = record_start->buffer + status;
935 left = record_size - status;
937 if (left && left % BLOCKSIZE == 0
938 && (warning_option & WARN_RECORD_SIZE)
939 && record_start_block == 0 && status != 0
940 && archive_is_dev ())
942 unsigned long rsize = status / BLOCKSIZE;
944 ngettext ("Record size = %lu block",
945 "Record size = %lu blocks",
950 while (left % BLOCKSIZE != 0
951 || (left && status && read_full_records))
954 while ((status = rmtread (archive, more, left)) == SAFE_READ_ERROR)
955 archive_read_error ();
960 if (! read_full_records)
962 unsigned long rest = record_size - left;
965 ngettext ("Unaligned block (%lu byte) in archive",
966 "Unaligned block (%lu bytes) in archive",
975 record_end = record_start + (record_size - left) / BLOCKSIZE;
979 /* Flush the current buffer to/from the archive. */
983 size_t buffer_level = current_block->buffer - record_start->buffer;
984 record_start_block += record_end - record_start;
985 current_block = record_start;
986 record_end = record_start + blocking_factor;
988 if (access_mode == ACCESS_READ && time_to_start_writing)
990 access_mode = ACCESS_WRITE;
991 time_to_start_writing = false;
1002 flush_write_ptr (buffer_level);
1010 /* Backspace the archive descriptor by one record worth. If it's a
1011 tape, MTIOCTOP will work. If it's something else, try to seek on
1012 it. If we can't seek, we lose! */
1014 backspace_output (void)
1018 struct mtop operation;
1020 operation.mt_op = MTBSR;
1021 operation.mt_count = 1;
1022 if (rmtioctl (archive, MTIOCTOP, (char *) &operation) >= 0)
1024 if (errno == EIO && rmtioctl (archive, MTIOCTOP, (char *) &operation) >= 0)
1030 off_t position = rmtlseek (archive, (off_t) 0, SEEK_CUR);
1032 /* Seek back to the beginning of this record and start writing there. */
1034 position -= record_size;
1037 if (rmtlseek (archive, position, SEEK_SET) != position)
1039 /* Lseek failed. Try a different method. */
1042 _("Cannot backspace archive file; it may be unreadable without -i")));
1044 /* Replace the first part of the record with NULs. */
1046 if (record_start->buffer != output_start)
1047 memset (record_start->buffer, 0,
1048 output_start - record_start->buffer);
1054 seek_archive (off_t size)
1056 off_t start = current_block_ordinal ();
1059 off_t skipped = (blocking_factor - (current_block - record_start))
1062 if (size <= skipped)
1065 /* Compute number of records to skip */
1066 nrec = (size - skipped) / record_size;
1069 offset = rmtlseek (archive, nrec * record_size, SEEK_CUR);
1073 if (offset % record_size)
1074 FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary")));
1076 /* Convert to number of records */
1077 offset /= BLOCKSIZE;
1078 /* Compute number of skipped blocks */
1079 nblk = offset - start;
1081 /* Update buffering info */
1082 records_read += nblk / blocking_factor;
1083 record_start_block = offset - blocking_factor;
1084 current_block = record_end;
1089 /* Close the archive file. */
1091 close_archive (void)
1093 if (time_to_start_writing || access_mode == ACCESS_WRITE)
1096 if (current_block > record_start)
1100 compute_duration ();
1104 if (rmtclose (archive) != 0)
1105 close_error (*archive_name_cursor);
1107 sys_wait_for_child (child_pid, hit_eof);
1109 tar_stat_destroy (¤t_stat_info);
1110 free (record_buffer[0]);
1111 free (record_buffer[1]);
1115 /* Called to initialize the global volume number. */
1117 init_volume_number (void)
1119 FILE *file = fopen (volno_file_option, "r");
1123 if (fscanf (file, "%d", &global_volno) != 1
1124 || global_volno < 0)
1125 FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"),
1126 quotearg_colon (volno_file_option)));
1128 read_error (volno_file_option);
1129 if (fclose (file) != 0)
1130 close_error (volno_file_option);
1132 else if (errno != ENOENT)
1133 open_error (volno_file_option);
1136 /* Called to write out the closing global volume number. */
1138 closeout_volume_number (void)
1140 FILE *file = fopen (volno_file_option, "w");
1144 fprintf (file, "%d\n", global_volno);
1146 write_error (volno_file_option);
1147 if (fclose (file) != 0)
1148 close_error (volno_file_option);
1151 open_error (volno_file_option);
1156 increase_volume_number (void)
1159 if (global_volno < 0)
1160 FATAL_ERROR ((0, 0, _("Volume number overflow")));
1165 change_tape_menu (FILE *read_file)
1167 char *input_buffer = NULL;
1173 fputc ('\007', stderr);
1175 _("Prepare volume #%d for %s and hit return: "),
1176 global_volno + 1, quote (*archive_name_cursor));
1179 if (getline (&input_buffer, &size, read_file) <= 0)
1181 WARN ((0, 0, _("EOF where user reply was expected")));
1183 if (subcommand_option != EXTRACT_SUBCOMMAND
1184 && subcommand_option != LIST_SUBCOMMAND
1185 && subcommand_option != DIFF_SUBCOMMAND)
1186 WARN ((0, 0, _("WARNING: Archive is incomplete")));
1191 if (input_buffer[0] == '\n'
1192 || input_buffer[0] == 'y'
1193 || input_buffer[0] == 'Y')
1196 switch (input_buffer[0])
1200 fprintf (stderr, _("\
1201 n name Give a new file name for the next (and subsequent) volume(s)\n\
1203 y or newline Continue operation\n"));
1204 if (!restrict_option)
1205 fprintf (stderr, _(" ! Spawn a subshell\n"));
1206 fprintf (stderr, _(" ? Print this list\n"));
1213 WARN ((0, 0, _("No new volume; exiting.\n")));
1215 if (subcommand_option != EXTRACT_SUBCOMMAND
1216 && subcommand_option != LIST_SUBCOMMAND
1217 && subcommand_option != DIFF_SUBCOMMAND)
1218 WARN ((0, 0, _("WARNING: Archive is incomplete")));
1223 /* Get new file name. */
1229 for (name = input_buffer + 1;
1230 *name == ' ' || *name == '\t';
1234 for (cursor = name; *cursor && *cursor != '\n'; cursor++)
1240 /* FIXME: the following allocation is never reclaimed. */
1241 *archive_name_cursor = xstrdup (name);
1245 fprintf (stderr, "%s",
1246 _("File name not specified. Try again.\n"));
1251 if (!restrict_option)
1259 fprintf (stderr, _("Invalid input. Type ? for help.\n"));
1262 free (input_buffer);
1265 /* We've hit the end of the old volume. Close it and open the next one.
1266 Return nonzero on success.
1269 new_volume (enum access_mode mode)
1271 static FILE *read_file;
1275 if (!read_file && !info_script_option)
1276 /* FIXME: if fopen is used, it will never be closed. */
1277 read_file = archive == STDIN_FILENO ? fopen (TTY_NAME, "r") : stdin;
1284 assign_string (&volume_label, NULL);
1285 assign_string (&continued_file_name, NULL);
1286 continued_file_size = continued_file_offset = 0;
1287 current_block = record_start;
1289 if (rmtclose (archive) != 0)
1290 close_error (*archive_name_cursor);
1292 archive_name_cursor++;
1293 if (archive_name_cursor == archive_name_array + archive_names)
1295 archive_name_cursor = archive_name_array;
1303 /* We have to prompt from now on. */
1305 if (info_script_option)
1307 if (volno_file_option)
1308 closeout_volume_number ();
1309 if (sys_exec_info_script (archive_name_cursor, global_volno+1))
1310 FATAL_ERROR ((0, 0, _("%s command failed"),
1311 quote (info_script_option)));
1314 change_tape_menu (read_file);
1317 if (strcmp (archive_name_cursor[0], "-") == 0)
1319 read_full_records = true;
1320 archive = STDIN_FILENO;
1322 else if (verify_option)
1323 archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW,
1324 rsh_command_option);
1329 archive = rmtopen (*archive_name_cursor, O_RDONLY, MODE_RW,
1330 rsh_command_option);
1331 guess_seekable_archive ();
1336 maybe_backup_file (*archive_name_cursor, 1);
1337 archive = rmtcreat (*archive_name_cursor, MODE_RW,
1338 rsh_command_option);
1342 archive = rmtopen (*archive_name_cursor, O_RDWR | O_CREAT, MODE_RW,
1343 rsh_command_option);
1349 open_warn (*archive_name_cursor);
1350 if (!verify_option && mode == ACCESS_WRITE && backup_option)
1351 undo_last_backup ();
1356 SET_BINARY_MODE (archive);
1362 read_header0 (struct tar_stat_info *info)
1364 enum read_header rc;
1366 tar_stat_init (info);
1367 rc = read_header (¤t_header, info, read_header_auto);
1368 if (rc == HEADER_SUCCESS)
1370 set_next_block_after (current_header);
1373 ERROR ((0, 0, _("This does not look like a tar archive")));
1378 try_new_volume (void)
1381 union block *header;
1382 enum access_mode acc;
1384 switch (subcommand_option)
1386 case APPEND_SUBCOMMAND:
1387 case CAT_SUBCOMMAND:
1388 case UPDATE_SUBCOMMAND:
1389 acc = ACCESS_UPDATE;
1397 if (!new_volume (acc))
1400 while ((status = rmtread (archive, record_start->buffer, record_size))
1402 archive_read_error ();
1404 if (status != record_size)
1405 short_read (status);
1407 header = find_next_block ();
1411 switch (header->header.typeflag)
1415 tar_stat_init (&dummy);
1416 if (read_header (&header, &dummy, read_header_x_global)
1417 != HEADER_SUCCESS_EXTENDED)
1419 ERROR ((0, 0, _("This does not look like a tar archive")));
1423 xheader_decode (&dummy); /* decodes values from the global header */
1424 tar_stat_destroy (&dummy);
1426 /* The initial global header must be immediately followed by
1427 an extended PAX header for the first member in this volume.
1428 However, in some cases tar may split volumes in the middle
1429 of a PAX header. This is incorrect, and should be fixed
1430 in the future versions. In the meantime we must be
1431 prepared to correctly list and extract such archives.
1433 If this happens, the following call to read_header returns
1434 HEADER_FAILURE, which is ignored.
1436 See also tests/multiv07.at */
1438 switch (read_header (&header, &dummy, read_header_auto))
1440 case HEADER_SUCCESS:
1441 set_next_block_after (header);
1444 case HEADER_FAILURE:
1448 ERROR ((0, 0, _("This does not look like a tar archive")));
1454 case GNUTYPE_VOLHDR:
1455 if (!read_header0 (&dummy))
1457 tar_stat_destroy (&dummy);
1458 assign_string (&volume_label, current_header->header.name);
1459 set_next_block_after (header);
1460 header = find_next_block ();
1461 if (header->header.typeflag != GNUTYPE_MULTIVOL)
1465 case GNUTYPE_MULTIVOL:
1466 if (!read_header0 (&dummy))
1468 tar_stat_destroy (&dummy);
1469 assign_string (&continued_file_name, current_header->header.name);
1470 continued_file_size =
1471 UINTMAX_FROM_HEADER (current_header->header.size);
1472 continued_file_offset =
1473 UINTMAX_FROM_HEADER (current_header->oldgnu_header.offset);
1483 if (!continued_file_name
1484 || strcmp (continued_file_name, bufmap_head->file_name))
1486 if ((archive_format == GNU_FORMAT || archive_format == OLDGNU_FORMAT)
1487 && strlen (bufmap_head->file_name) >= NAME_FIELD_SIZE
1488 && strncmp (continued_file_name, bufmap_head->file_name,
1489 NAME_FIELD_SIZE) == 0)
1491 _("%s is possibly continued on this volume: header contains truncated name"),
1492 quote (bufmap_head->file_name)));
1495 WARN ((0, 0, _("%s is not continued on this volume"),
1496 quote (bufmap_head->file_name)));
1501 s = continued_file_size + continued_file_offset;
1503 if (bufmap_head->sizetotal != s || s < continued_file_offset)
1505 char totsizebuf[UINTMAX_STRSIZE_BOUND];
1506 char s1buf[UINTMAX_STRSIZE_BOUND];
1507 char s2buf[UINTMAX_STRSIZE_BOUND];
1509 WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
1510 quote (continued_file_name),
1511 STRINGIFY_BIGINT (bufmap_head->sizetotal, totsizebuf),
1512 STRINGIFY_BIGINT (continued_file_size, s1buf),
1513 STRINGIFY_BIGINT (continued_file_offset, s2buf)));
1517 if (bufmap_head->sizetotal - bufmap_head->sizeleft !=
1518 continued_file_offset)
1520 char totsizebuf[UINTMAX_STRSIZE_BOUND];
1521 char s1buf[UINTMAX_STRSIZE_BOUND];
1522 char s2buf[UINTMAX_STRSIZE_BOUND];
1524 WARN ((0, 0, _("This volume is out of sequence (%s - %s != %s)"),
1525 STRINGIFY_BIGINT (bufmap_head->sizetotal, totsizebuf),
1526 STRINGIFY_BIGINT (bufmap_head->sizeleft, s1buf),
1527 STRINGIFY_BIGINT (continued_file_offset, s2buf)));
1533 increase_volume_number ();
1538 #define VOLUME_TEXT " Volume "
1539 #define VOLUME_TEXT_LEN (sizeof VOLUME_TEXT - 1)
1542 drop_volume_label_suffix (const char *label)
1545 size_t len = strlen (label);
1550 for (p = label + len - 1; p > label && isdigit ((unsigned char) *p); p--)
1552 if (p > label && p - (VOLUME_TEXT_LEN - 1) > label)
1554 p -= VOLUME_TEXT_LEN - 1;
1555 if (memcmp (p, VOLUME_TEXT, VOLUME_TEXT_LEN) == 0)
1557 char *s = xmalloc ((len = p - label) + 1);
1558 memcpy (s, label, len);
1567 /* Check LABEL against the volume label, seen as a globbing
1568 pattern. Return true if the pattern matches. In case of failure,
1569 retry matching a volume sequence number before giving up in
1570 multi-volume mode. */
1572 check_label_pattern (const char *label)
1575 bool result = false;
1577 if (fnmatch (volume_label_option, label, 0) == 0)
1580 if (!multi_volume_option)
1583 string = drop_volume_label_suffix (label);
1586 result = fnmatch (string, volume_label_option, 0) == 0;
1592 /* Check if the next block contains a volume label and if this matches
1593 the one given in the command line */
1595 match_volume_label (void)
1599 union block *label = find_next_block ();
1602 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1603 quote (volume_label_option)));
1604 if (label->header.typeflag == GNUTYPE_VOLHDR)
1606 if (memchr (label->header.name, '\0', sizeof label->header.name))
1607 assign_string (&volume_label, label->header.name);
1610 volume_label = xmalloc (sizeof (label->header.name) + 1);
1611 memcpy (volume_label, label->header.name,
1612 sizeof (label->header.name));
1613 volume_label[sizeof (label->header.name)] = 0;
1616 else if (label->header.typeflag == XGLTYPE)
1618 struct tar_stat_info st;
1619 tar_stat_init (&st);
1620 xheader_read (&st.xhdr, label,
1621 OFF_FROM_HEADER (label->header.size));
1622 xheader_decode (&st);
1623 tar_stat_destroy (&st);
1628 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1629 quote (volume_label_option)));
1631 if (!check_label_pattern (volume_label))
1632 FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
1633 quote_n (0, volume_label),
1634 quote_n (1, volume_label_option)));
1637 /* Mark the archive with volume label STR. */
1639 _write_volume_label (const char *str)
1641 if (archive_format == POSIX_FORMAT)
1642 xheader_store ("GNU.volume.label", &dummy, str);
1645 union block *label = find_next_block ();
1647 memset (label, 0, BLOCKSIZE);
1649 strcpy (label->header.name, str);
1650 assign_string (¤t_stat_info.file_name,
1651 label->header.name);
1652 current_stat_info.had_trailing_slash =
1653 strip_trailing_slashes (current_stat_info.file_name);
1655 label->header.typeflag = GNUTYPE_VOLHDR;
1656 TIME_TO_CHARS (start_time.tv_sec, label->header.mtime);
1657 finish_header (¤t_stat_info, label, -1);
1658 set_next_block_after (label);
1662 #define VOL_SUFFIX "Volume"
1664 /* Add a volume label to a part of multi-volume archive */
1666 add_volume_label (void)
1668 char buf[UINTMAX_STRSIZE_BOUND];
1669 char *p = STRINGIFY_BIGINT (volno, buf);
1670 char *s = xmalloc (strlen (volume_label_option) + sizeof VOL_SUFFIX
1672 sprintf (s, "%s %s %s", volume_label_option, VOL_SUFFIX, p);
1673 _write_volume_label (s);
1678 add_chunk_header (struct bufmap *map)
1680 if (archive_format == POSIX_FORMAT)
1682 off_t block_ordinal;
1684 struct tar_stat_info st;
1686 memset (&st, 0, sizeof st);
1687 st.orig_file_name = st.file_name = map->file_name;
1688 st.stat.st_mode = S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH;
1689 st.stat.st_uid = getuid ();
1690 st.stat.st_gid = getgid ();
1691 st.orig_file_name = xheader_format_name (&st,
1692 "%d/GNUFileParts.%p/%f.%n",
1694 st.file_name = st.orig_file_name;
1695 st.archive_file_size = st.stat.st_size = map->sizeleft;
1697 block_ordinal = current_block_ordinal ();
1698 blk = start_header (&st);
1700 abort (); /* FIXME */
1701 finish_header (&st, blk, block_ordinal);
1702 free (st.orig_file_name);
1707 /* Add a volume label to the current archive */
1709 write_volume_label (void)
1711 if (multi_volume_option)
1712 add_volume_label ();
1714 _write_volume_label (volume_label_option);
1717 /* Write GNU multi-volume header */
1719 gnu_add_multi_volume_header (struct bufmap *map)
1722 union block *block = find_next_block ();
1724 if (strlen (map->file_name) > NAME_FIELD_SIZE)
1726 _("%s: file name too long to be stored in a GNU multivolume header, truncated"),
1727 quotearg_colon (map->file_name)));
1729 memset (block, 0, BLOCKSIZE);
1731 strncpy (block->header.name, map->file_name, NAME_FIELD_SIZE);
1732 block->header.typeflag = GNUTYPE_MULTIVOL;
1734 OFF_TO_CHARS (map->sizeleft, block->header.size);
1735 OFF_TO_CHARS (map->sizetotal - map->sizeleft,
1736 block->oldgnu_header.offset);
1738 tmp = verbose_option;
1740 finish_header (¤t_stat_info, block, -1);
1741 verbose_option = tmp;
1742 set_next_block_after (block);
1745 /* Add a multi volume header to the current archive. The exact header format
1746 depends on the archive format. */
1748 add_multi_volume_header (struct bufmap *map)
1750 if (archive_format == POSIX_FORMAT)
1752 off_t d = map->sizetotal - map->sizeleft;
1753 xheader_store ("GNU.volume.filename", &dummy, map->file_name);
1754 xheader_store ("GNU.volume.size", &dummy, &map->sizeleft);
1755 xheader_store ("GNU.volume.offset", &dummy, &d);
1758 gnu_add_multi_volume_header (map);
1762 /* Low-level flush functions */
1764 /* Simple flush read (no multi-volume or label extensions) */
1766 simple_flush_read (void)
1768 size_t status; /* result from system call */
1770 checkpoint_run (false);
1772 /* Clear the count of errors. This only applies to a single call to
1775 read_error_count = 0; /* clear error count */
1777 if (write_archive_to_stdout && record_start_block != 0)
1779 archive = STDOUT_FILENO;
1780 status = sys_write_archive_buffer ();
1781 archive = STDIN_FILENO;
1782 if (status != record_size)
1783 archive_write_error (status);
1788 status = rmtread (archive, record_start->buffer, record_size);
1789 if (status == record_size)
1794 if (status == SAFE_READ_ERROR)
1796 archive_read_error ();
1797 continue; /* try again */
1801 short_read (status);
1804 /* Simple flush write (no multi-volume or label extensions) */
1806 simple_flush_write (size_t level __attribute__((unused)))
1810 status = _flush_write ();
1811 if (status != record_size)
1812 archive_write_error (status);
1816 bytes_written += status;
1821 /* GNU flush functions. These support multi-volume and archive labels in
1822 GNU and PAX archive formats. */
1825 _gnu_flush_read (void)
1827 size_t status; /* result from system call */
1829 checkpoint_run (false);
1831 /* Clear the count of errors. This only applies to a single call to
1834 read_error_count = 0; /* clear error count */
1836 if (write_archive_to_stdout && record_start_block != 0)
1838 archive = STDOUT_FILENO;
1839 status = sys_write_archive_buffer ();
1840 archive = STDIN_FILENO;
1841 if (status != record_size)
1842 archive_write_error (status);
1847 status = rmtread (archive, record_start->buffer, record_size);
1848 if (status == record_size)
1854 /* The condition below used to include
1855 || (status > 0 && !read_full_records)
1856 This is incorrect since even if new_volume() succeeds, the
1857 subsequent call to rmtread will overwrite the chunk of data
1858 already read in the buffer, so the processing will fail */
1860 || (status == SAFE_READ_ERROR && errno == ENOSPC))
1861 && multi_volume_option)
1863 while (!try_new_volume ())
1865 if (current_block == record_end)
1866 /* Necessary for blocking_factor == 1 */
1870 else if (status == SAFE_READ_ERROR)
1872 archive_read_error ();
1877 short_read (status);
1881 gnu_flush_read (void)
1883 flush_read_ptr = simple_flush_read; /* Avoid recursion */
1885 flush_read_ptr = gnu_flush_read;
1889 _gnu_flush_write (size_t buffer_level)
1892 union block *header;
1898 status = _flush_write ();
1899 if (status != record_size && !multi_volume_option)
1900 archive_write_error (status);
1905 bytes_written += status;
1908 if (status == record_size)
1913 map = bufmap_locate (status);
1915 if (status % BLOCKSIZE)
1917 ERROR ((0, 0, _("write did not end on a block boundary")));
1918 archive_write_error (status);
1921 /* In multi-volume mode. */
1922 /* ENXIO is for the UNIX PC. */
1923 if (status < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO)
1924 archive_write_error (status);
1926 if (!new_volume (ACCESS_WRITE))
1929 tar_stat_destroy (&dummy);
1931 increase_volume_number ();
1932 prev_written += bytes_written;
1935 copy_ptr = record_start->buffer + status;
1936 copy_size = buffer_level - status;
1938 /* Switch to the next buffer */
1939 record_index = !record_index;
1944 if (volume_label_option)
1945 add_volume_label ();
1948 add_multi_volume_header (map);
1950 write_extended (true, &dummy, find_next_block ());
1951 tar_stat_destroy (&dummy);
1954 add_chunk_header (map);
1955 header = find_next_block ();
1956 bufmap_reset (map, header - record_start);
1957 bufsize = available_space_after (header);
1959 while (bufsize < copy_size)
1961 memcpy (header->buffer, copy_ptr, bufsize);
1962 copy_ptr += bufsize;
1963 copy_size -= bufsize;
1964 set_next_block_after (header + (bufsize - 1) / BLOCKSIZE);
1965 header = find_next_block ();
1966 bufsize = available_space_after (header);
1968 memcpy (header->buffer, copy_ptr, copy_size);
1969 memset (header->buffer + copy_size, 0, bufsize - copy_size);
1970 set_next_block_after (header + (copy_size - 1) / BLOCKSIZE);
1975 gnu_flush_write (size_t buffer_level)
1977 flush_write_ptr = simple_flush_write; /* Avoid recursion */
1978 _gnu_flush_write (buffer_level);
1979 flush_write_ptr = gnu_flush_write;
1991 flush_write_ptr (record_size);
1995 open_archive (enum access_mode wanted_access)
1997 flush_read_ptr = gnu_flush_read;
1998 flush_write_ptr = gnu_flush_write;
2000 _open_archive (wanted_access);
2001 switch (wanted_access)
2005 if (volume_label_option)
2006 match_volume_label ();
2010 records_written = 0;
2011 if (volume_label_option)
2012 write_volume_label ();
2015 set_volume_start_time ();