1 /* Buffer management for tar.
3 Copyright 1988, 1992-1994, 1996-1997, 1999-2010, 2013 Free Software
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 bytes
[sizeof (tarlong
) * CHAR_BIT
];
496 char abbr
[LONGEST_HUMAN_READABLE
+ 1];
497 char rate
[LONGEST_HUMAN_READABLE
+ 1];
499 int human_opts
= human_autoscale
| human_base_1024
| human_SI
| human_B
;
501 sprintf (bytes
, TARLONG_FORMAT
, numbytes
);
503 return fprintf (fp
, "%s: %s (%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 n
+= fprintf (fp
, "%s: %s",
547 _(formats
[TF_DELETED
]),
548 STRINGIFY_BIGINT ((records_read
- records_skipped
)
550 - (prev_written
+ bytes_written
), buf
));
554 case EXTRACT_SUBCOMMAND
:
555 case LIST_SUBCOMMAND
:
556 case DIFF_SUBCOMMAND
:
557 n
= print_stats (fp
, _(formats
[TF_READ
]),
558 records_read
* record_size
);
572 const char *default_total_format
[] = {
573 N_("Total bytes read"),
574 /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */
575 N_("Total bytes written"),
576 N_("Total bytes deleted")
580 print_total_stats (void)
582 format_total_stats (stderr
, default_total_format
, '\n', '\n');
585 /* Compute and return the block ordinal at current_block. */
587 current_block_ordinal (void)
589 return record_start_block
+ (current_block
- record_start
);
592 /* If the EOF flag is set, reset it, as well as current_block, etc. */
599 current_block
= record_start
;
600 record_end
= record_start
+ blocking_factor
;
601 access_mode
= ACCESS_WRITE
;
605 /* Return the location of the next available input or output block.
606 Return zero for EOF. Once we have returned zero, we just keep returning
607 it, to avoid accidentally going on to the next file on the tape. */
609 find_next_block (void)
611 if (current_block
== record_end
)
616 if (current_block
== record_end
)
622 return current_block
;
625 /* Indicate that we have used all blocks up thru BLOCK. */
627 set_next_block_after (union block
*block
)
629 while (block
>= current_block
)
632 /* Do *not* flush the archive here. If we do, the same argument to
633 set_next_block_after could mean the next block (if the input record
634 is exactly one block long), which is not what is intended. */
636 if (current_block
> record_end
)
640 /* Return the number of bytes comprising the space between POINTER
641 through the end of the current buffer of blocks. This space is
642 available for filling with data, or taking data from. POINTER is
643 usually (but not always) the result of previous find_next_block call. */
645 available_space_after (union block
*pointer
)
647 return record_end
->buffer
- pointer
->buffer
;
650 /* Close file having descriptor FD, and abort if close unsuccessful. */
655 close_error (_("(pipe)"));
661 if (! record_buffer_aligned
[record_index
])
662 record_buffer_aligned
[record_index
] =
663 page_aligned_alloc (&record_buffer
[record_index
], record_size
);
665 record_start
= record_buffer_aligned
[record_index
];
666 current_block
= record_start
;
667 record_end
= record_start
+ blocking_factor
;
670 /* Open an archive file. The argument specifies whether we are
671 reading or writing, or both. */
673 _open_archive (enum access_mode wanted_access
)
675 int backed_up_flag
= 0;
677 if (record_size
== 0)
678 FATAL_ERROR ((0, 0, _("Invalid value for record_size")));
680 if (archive_names
== 0)
681 FATAL_ERROR ((0, 0, _("No archive name given")));
683 tar_stat_destroy (¤t_stat_info
);
688 /* When updating the archive, we start with reading. */
689 access_mode
= wanted_access
== ACCESS_UPDATE
? ACCESS_READ
: wanted_access
;
691 read_full_records
= read_full_records_option
;
695 if (use_compress_program_option
)
697 switch (wanted_access
)
700 child_pid
= sys_child_open_for_uncompress ();
701 read_full_records
= true;
702 record_end
= record_start
; /* set up for 1st record = # 0 */
706 child_pid
= sys_child_open_for_compress ();
710 abort (); /* Should not happen */
715 && wanted_access
== ACCESS_WRITE
716 && strcmp (archive_name_array
[0], "-") == 0)
719 else if (strcmp (archive_name_array
[0], "-") == 0)
721 read_full_records
= true; /* could be a pipe, be safe */
723 FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
725 switch (wanted_access
)
730 enum compress_type type
;
732 archive
= STDIN_FILENO
;
734 type
= check_compressed_archive (&shortfile
);
735 if (type
!= ct_tar
&& type
!= ct_none
)
737 _("Archive is compressed. Use %s option"),
738 compress_option (type
)));
740 ERROR ((0, 0, _("This does not look like a tar archive")));
745 archive
= STDOUT_FILENO
;
746 if (!index_file_name
)
751 archive
= STDIN_FILENO
;
752 write_archive_to_stdout
= true;
753 record_end
= record_start
; /* set up for 1st record = # 0 */
754 if (!index_file_name
)
760 switch (wanted_access
)
763 archive
= open_compressed_archive ();
765 guess_seekable_archive ();
771 maybe_backup_file (archive_name_array
[0], 1);
775 archive
= rmtopen (archive_name_array
[0], O_RDWR
| O_CREAT
| O_BINARY
,
776 MODE_RW
, rsh_command_option
);
778 archive
= rmtcreat (archive_name_array
[0], MODE_RW
,
783 archive
= rmtopen (archive_name_array
[0],
784 O_RDWR
| O_CREAT
| O_BINARY
,
785 MODE_RW
, rsh_command_option
);
787 switch (check_compressed_archive (NULL
))
795 _("Cannot update compressed archives")));
801 || (! _isrmt (archive
) && !sys_get_archive_stat ()))
803 int saved_errno
= errno
;
808 open_fatal (archive_name_array
[0]);
811 sys_detect_dev_null_output ();
812 sys_save_archive_dev_ino ();
813 SET_BINARY_MODE (archive
);
815 switch (wanted_access
)
818 find_next_block (); /* read it in, check for EOF */
828 /* Perform a write to flush the buffer. */
834 checkpoint_run (true);
835 if (tape_length_option
&& tape_length_option
<= bytes_written
)
840 else if (dev_null_output
)
841 status
= record_size
;
843 status
= sys_write_archive_buffer ();
845 if (status
&& multi_volume_option
&& !inhibit_map
)
847 struct bufmap
*map
= bufmap_locate (status
);
850 size_t delta
= status
- map
->start
* BLOCKSIZE
;
851 if (delta
> map
->sizeleft
)
852 delta
= map
->sizeleft
;
853 map
->sizeleft
-= delta
;
854 if (map
->sizeleft
== 0)
856 bufmap_reset (map
, map
? (- map
->start
) : 0);
862 /* Handle write errors on the archive. Write errors are always fatal.
863 Hitting the end of a volume does not cause a write error unless the
864 write was the first record of the volume. */
866 archive_write_error (ssize_t status
)
868 /* It might be useful to know how much was written before the error
873 print_total_stats ();
877 write_fatal_details (*archive_name_cursor
, status
, record_size
);
880 /* Handle read errors on the archive. If the read should be retried,
881 return to the caller. */
883 archive_read_error (void)
885 read_error (*archive_name_cursor
);
887 if (record_start_block
== 0)
888 FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
890 /* Read error in mid archive. We retry up to READ_ERROR_MAX times and
891 then give up on reading the archive. */
893 if (read_error_count
++ > READ_ERROR_MAX
)
894 FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
899 archive_is_dev (void)
903 if (fstat (archive
, &st
))
905 stat_diag (*archive_name_cursor
);
908 return S_ISBLK (st
.st_mode
) || S_ISCHR (st
.st_mode
);
912 short_read (size_t status
)
914 size_t left
; /* bytes left */
915 char *more
; /* pointer to next byte to read */
917 more
= record_start
->buffer
+ status
;
918 left
= record_size
- status
;
920 if (left
&& left
% BLOCKSIZE
== 0
921 && (warning_option
& WARN_RECORD_SIZE
)
922 && record_start_block
== 0 && status
!= 0
923 && archive_is_dev ())
925 unsigned long rsize
= status
/ BLOCKSIZE
;
927 ngettext ("Record size = %lu block",
928 "Record size = %lu blocks",
933 while (left
% BLOCKSIZE
!= 0
934 || (left
&& status
&& read_full_records
))
937 while ((status
= rmtread (archive
, more
, left
)) == SAFE_READ_ERROR
)
938 archive_read_error ();
943 if (! read_full_records
)
945 unsigned long rest
= record_size
- left
;
948 ngettext ("Unaligned block (%lu byte) in archive",
949 "Unaligned block (%lu bytes) in archive",
958 record_end
= record_start
+ (record_size
- left
) / BLOCKSIZE
;
962 /* Flush the current buffer to/from the archive. */
966 size_t buffer_level
= current_block
->buffer
- record_start
->buffer
;
967 record_start_block
+= record_end
- record_start
;
968 current_block
= record_start
;
969 record_end
= record_start
+ blocking_factor
;
971 if (access_mode
== ACCESS_READ
&& time_to_start_writing
)
973 access_mode
= ACCESS_WRITE
;
974 time_to_start_writing
= false;
985 flush_write_ptr (buffer_level
);
993 /* Backspace the archive descriptor by one record worth. If it's a
994 tape, MTIOCTOP will work. If it's something else, try to seek on
995 it. If we can't seek, we lose! */
997 backspace_output (void)
1001 struct mtop operation
;
1003 operation
.mt_op
= MTBSR
;
1004 operation
.mt_count
= 1;
1005 if (rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
1007 if (errno
== EIO
&& rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
1013 off_t position
= rmtlseek (archive
, (off_t
) 0, SEEK_CUR
);
1015 /* Seek back to the beginning of this record and start writing there. */
1017 position
-= record_size
;
1020 if (rmtlseek (archive
, position
, SEEK_SET
) != position
)
1022 /* Lseek failed. Try a different method. */
1025 _("Cannot backspace archive file; it may be unreadable without -i")));
1027 /* Replace the first part of the record with NULs. */
1029 if (record_start
->buffer
!= output_start
)
1030 memset (record_start
->buffer
, 0,
1031 output_start
- record_start
->buffer
);
1037 seek_archive (off_t size
)
1039 off_t start
= current_block_ordinal ();
1042 off_t skipped
= (blocking_factor
- (current_block
- record_start
))
1045 if (size
<= skipped
)
1048 /* Compute number of records to skip */
1049 nrec
= (size
- skipped
) / record_size
;
1052 offset
= rmtlseek (archive
, nrec
* record_size
, SEEK_CUR
);
1056 if (offset
% record_size
)
1057 FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary")));
1059 /* Convert to number of records */
1060 offset
/= BLOCKSIZE
;
1061 /* Compute number of skipped blocks */
1062 nblk
= offset
- start
;
1064 /* Update buffering info */
1065 records_read
+= nblk
/ blocking_factor
;
1066 record_start_block
= offset
- blocking_factor
;
1067 current_block
= record_end
;
1072 /* Close the archive file. */
1074 close_archive (void)
1076 if (time_to_start_writing
|| access_mode
== ACCESS_WRITE
)
1079 if (current_block
> record_start
)
1083 compute_duration ();
1087 if (rmtclose (archive
) != 0)
1088 close_error (*archive_name_cursor
);
1090 sys_wait_for_child (child_pid
, hit_eof
);
1092 tar_stat_destroy (¤t_stat_info
);
1093 free (record_buffer
[0]);
1094 free (record_buffer
[1]);
1098 /* Called to initialize the global volume number. */
1100 init_volume_number (void)
1102 FILE *file
= fopen (volno_file_option
, "r");
1106 if (fscanf (file
, "%d", &global_volno
) != 1
1107 || global_volno
< 0)
1108 FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"),
1109 quotearg_colon (volno_file_option
)));
1111 read_error (volno_file_option
);
1112 if (fclose (file
) != 0)
1113 close_error (volno_file_option
);
1115 else if (errno
!= ENOENT
)
1116 open_error (volno_file_option
);
1119 /* Called to write out the closing global volume number. */
1121 closeout_volume_number (void)
1123 FILE *file
= fopen (volno_file_option
, "w");
1127 fprintf (file
, "%d\n", global_volno
);
1129 write_error (volno_file_option
);
1130 if (fclose (file
) != 0)
1131 close_error (volno_file_option
);
1134 open_error (volno_file_option
);
1139 increase_volume_number (void)
1142 if (global_volno
< 0)
1143 FATAL_ERROR ((0, 0, _("Volume number overflow")));
1148 change_tape_menu (FILE *read_file
)
1150 char *input_buffer
= NULL
;
1156 fputc ('\007', stderr
);
1158 _("Prepare volume #%d for %s and hit return: "),
1159 global_volno
+ 1, quote (*archive_name_cursor
));
1162 if (getline (&input_buffer
, &size
, read_file
) <= 0)
1164 WARN ((0, 0, _("EOF where user reply was expected")));
1166 if (subcommand_option
!= EXTRACT_SUBCOMMAND
1167 && subcommand_option
!= LIST_SUBCOMMAND
1168 && subcommand_option
!= DIFF_SUBCOMMAND
)
1169 WARN ((0, 0, _("WARNING: Archive is incomplete")));
1174 if (input_buffer
[0] == '\n'
1175 || input_buffer
[0] == 'y'
1176 || input_buffer
[0] == 'Y')
1179 switch (input_buffer
[0])
1183 fprintf (stderr
, _("\
1184 n name Give a new file name for the next (and subsequent) volume(s)\n\
1186 y or newline Continue operation\n"));
1187 if (!restrict_option
)
1188 fprintf (stderr
, _(" ! Spawn a subshell\n"));
1189 fprintf (stderr
, _(" ? Print this list\n"));
1196 WARN ((0, 0, _("No new volume; exiting.\n")));
1198 if (subcommand_option
!= EXTRACT_SUBCOMMAND
1199 && subcommand_option
!= LIST_SUBCOMMAND
1200 && subcommand_option
!= DIFF_SUBCOMMAND
)
1201 WARN ((0, 0, _("WARNING: Archive is incomplete")));
1206 /* Get new file name. */
1212 for (name
= input_buffer
+ 1;
1213 *name
== ' ' || *name
== '\t';
1217 for (cursor
= name
; *cursor
&& *cursor
!= '\n'; cursor
++)
1223 /* FIXME: the following allocation is never reclaimed. */
1224 *archive_name_cursor
= xstrdup (name
);
1228 fprintf (stderr
, "%s",
1229 _("File name not specified. Try again.\n"));
1234 if (!restrict_option
)
1242 fprintf (stderr
, _("Invalid input. Type ? for help.\n"));
1245 free (input_buffer
);
1248 /* We've hit the end of the old volume. Close it and open the next one.
1249 Return nonzero on success.
1252 new_volume (enum access_mode mode
)
1254 static FILE *read_file
;
1258 if (!read_file
&& !info_script_option
)
1259 /* FIXME: if fopen is used, it will never be closed. */
1260 read_file
= archive
== STDIN_FILENO
? fopen (TTY_NAME
, "r") : stdin
;
1267 assign_string (&volume_label
, NULL
);
1268 assign_string (&continued_file_name
, NULL
);
1269 continued_file_size
= continued_file_offset
= 0;
1270 current_block
= record_start
;
1272 if (rmtclose (archive
) != 0)
1273 close_error (*archive_name_cursor
);
1275 archive_name_cursor
++;
1276 if (archive_name_cursor
== archive_name_array
+ archive_names
)
1278 archive_name_cursor
= archive_name_array
;
1286 /* We have to prompt from now on. */
1288 if (info_script_option
)
1290 if (volno_file_option
)
1291 closeout_volume_number ();
1292 if (sys_exec_info_script (archive_name_cursor
, global_volno
+1))
1293 FATAL_ERROR ((0, 0, _("%s command failed"),
1294 quote (info_script_option
)));
1297 change_tape_menu (read_file
);
1300 if (strcmp (archive_name_cursor
[0], "-") == 0)
1302 read_full_records
= true;
1303 archive
= STDIN_FILENO
;
1305 else if (verify_option
)
1306 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1307 rsh_command_option
);
1312 archive
= rmtopen (*archive_name_cursor
, O_RDONLY
, MODE_RW
,
1313 rsh_command_option
);
1314 guess_seekable_archive ();
1319 maybe_backup_file (*archive_name_cursor
, 1);
1320 archive
= rmtcreat (*archive_name_cursor
, MODE_RW
,
1321 rsh_command_option
);
1325 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1326 rsh_command_option
);
1332 open_warn (*archive_name_cursor
);
1333 if (!verify_option
&& mode
== ACCESS_WRITE
&& backup_option
)
1334 undo_last_backup ();
1339 SET_BINARY_MODE (archive
);
1345 read_header0 (struct tar_stat_info
*info
)
1347 enum read_header rc
;
1349 tar_stat_init (info
);
1350 rc
= read_header (¤t_header
, info
, read_header_auto
);
1351 if (rc
== HEADER_SUCCESS
)
1353 set_next_block_after (current_header
);
1356 ERROR ((0, 0, _("This does not look like a tar archive")));
1361 try_new_volume (void)
1364 union block
*header
;
1365 enum access_mode acc
;
1367 switch (subcommand_option
)
1369 case APPEND_SUBCOMMAND
:
1370 case CAT_SUBCOMMAND
:
1371 case UPDATE_SUBCOMMAND
:
1372 acc
= ACCESS_UPDATE
;
1380 if (!new_volume (acc
))
1383 while ((status
= rmtread (archive
, record_start
->buffer
, record_size
))
1385 archive_read_error ();
1387 if (status
!= record_size
)
1388 short_read (status
);
1390 header
= find_next_block ();
1394 switch (header
->header
.typeflag
)
1398 tar_stat_init (&dummy
);
1399 if (read_header (&header
, &dummy
, read_header_x_global
)
1400 != HEADER_SUCCESS_EXTENDED
)
1402 ERROR ((0, 0, _("This does not look like a tar archive")));
1406 xheader_decode (&dummy
); /* decodes values from the global header */
1407 tar_stat_destroy (&dummy
);
1409 /* The initial global header must be immediately followed by
1410 an extended PAX header for the first member in this volume.
1411 However, in some cases tar may split volumes in the middle
1412 of a PAX header. This is incorrect, and should be fixed
1413 in the future versions. In the meantime we must be
1414 prepared to correctly list and extract such archives.
1416 If this happens, the following call to read_header returns
1417 HEADER_FAILURE, which is ignored.
1419 See also tests/multiv07.at */
1421 switch (read_header (&header
, &dummy
, read_header_auto
))
1423 case HEADER_SUCCESS
:
1424 set_next_block_after (header
);
1427 case HEADER_FAILURE
:
1431 ERROR ((0, 0, _("This does not look like a tar archive")));
1437 case GNUTYPE_VOLHDR
:
1438 if (!read_header0 (&dummy
))
1440 tar_stat_destroy (&dummy
);
1441 assign_string (&volume_label
, current_header
->header
.name
);
1442 set_next_block_after (header
);
1443 header
= find_next_block ();
1444 if (header
->header
.typeflag
!= GNUTYPE_MULTIVOL
)
1448 case GNUTYPE_MULTIVOL
:
1449 if (!read_header0 (&dummy
))
1451 tar_stat_destroy (&dummy
);
1452 assign_string (&continued_file_name
, current_header
->header
.name
);
1453 continued_file_size
=
1454 UINTMAX_FROM_HEADER (current_header
->header
.size
);
1455 continued_file_offset
=
1456 UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
);
1466 if (!continued_file_name
1467 || strcmp (continued_file_name
, bufmap_head
->file_name
))
1469 if ((archive_format
== GNU_FORMAT
|| archive_format
== OLDGNU_FORMAT
)
1470 && strlen (bufmap_head
->file_name
) >= NAME_FIELD_SIZE
1471 && strncmp (continued_file_name
, bufmap_head
->file_name
,
1472 NAME_FIELD_SIZE
) == 0)
1474 _("%s is possibly continued on this volume: header contains truncated name"),
1475 quote (bufmap_head
->file_name
)));
1478 WARN ((0, 0, _("%s is not continued on this volume"),
1479 quote (bufmap_head
->file_name
)));
1484 s
= continued_file_size
+ continued_file_offset
;
1486 if (bufmap_head
->sizetotal
!= s
|| s
< continued_file_offset
)
1488 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1489 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1490 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1492 WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
1493 quote (continued_file_name
),
1494 STRINGIFY_BIGINT (bufmap_head
->sizetotal
, totsizebuf
),
1495 STRINGIFY_BIGINT (continued_file_size
, s1buf
),
1496 STRINGIFY_BIGINT (continued_file_offset
, s2buf
)));
1500 if (bufmap_head
->sizetotal
- bufmap_head
->sizeleft
!=
1501 continued_file_offset
)
1503 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1504 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1505 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1507 WARN ((0, 0, _("This volume is out of sequence (%s - %s != %s)"),
1508 STRINGIFY_BIGINT (bufmap_head
->sizetotal
, totsizebuf
),
1509 STRINGIFY_BIGINT (bufmap_head
->sizeleft
, s1buf
),
1510 STRINGIFY_BIGINT (continued_file_offset
, s2buf
)));
1516 increase_volume_number ();
1521 #define VOLUME_TEXT " Volume "
1522 #define VOLUME_TEXT_LEN (sizeof VOLUME_TEXT - 1)
1525 drop_volume_label_suffix (const char *label
)
1528 size_t len
= strlen (label
);
1533 for (p
= label
+ len
- 1; p
> label
&& isdigit ((unsigned char) *p
); p
--)
1535 if (p
> label
&& p
- (VOLUME_TEXT_LEN
- 1) > label
)
1537 p
-= VOLUME_TEXT_LEN
- 1;
1538 if (memcmp (p
, VOLUME_TEXT
, VOLUME_TEXT_LEN
) == 0)
1540 char *s
= xmalloc ((len
= p
- label
) + 1);
1541 memcpy (s
, label
, len
);
1550 /* Check LABEL against the volume label, seen as a globbing
1551 pattern. Return true if the pattern matches. In case of failure,
1552 retry matching a volume sequence number before giving up in
1553 multi-volume mode. */
1555 check_label_pattern (const char *label
)
1558 bool result
= false;
1560 if (fnmatch (volume_label_option
, label
, 0) == 0)
1563 if (!multi_volume_option
)
1566 string
= drop_volume_label_suffix (label
);
1569 result
= fnmatch (string
, volume_label_option
, 0) == 0;
1575 /* Check if the next block contains a volume label and if this matches
1576 the one given in the command line */
1578 match_volume_label (void)
1582 union block
*label
= find_next_block ();
1585 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1586 quote (volume_label_option
)));
1587 if (label
->header
.typeflag
== GNUTYPE_VOLHDR
)
1589 if (memchr (label
->header
.name
, '\0', sizeof label
->header
.name
))
1590 assign_string (&volume_label
, label
->header
.name
);
1593 volume_label
= xmalloc (sizeof (label
->header
.name
) + 1);
1594 memcpy (volume_label
, label
->header
.name
,
1595 sizeof (label
->header
.name
));
1596 volume_label
[sizeof (label
->header
.name
)] = 0;
1599 else if (label
->header
.typeflag
== XGLTYPE
)
1601 struct tar_stat_info st
;
1602 tar_stat_init (&st
);
1603 xheader_read (&st
.xhdr
, label
,
1604 OFF_FROM_HEADER (label
->header
.size
));
1605 xheader_decode (&st
);
1606 tar_stat_destroy (&st
);
1611 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1612 quote (volume_label_option
)));
1614 if (!check_label_pattern (volume_label
))
1615 FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
1616 quote_n (0, volume_label
),
1617 quote_n (1, volume_label_option
)));
1620 /* Mark the archive with volume label STR. */
1622 _write_volume_label (const char *str
)
1624 if (archive_format
== POSIX_FORMAT
)
1625 xheader_store ("GNU.volume.label", &dummy
, str
);
1628 union block
*label
= find_next_block ();
1630 memset (label
, 0, BLOCKSIZE
);
1632 strcpy (label
->header
.name
, str
);
1633 assign_string (¤t_stat_info
.file_name
,
1634 label
->header
.name
);
1635 current_stat_info
.had_trailing_slash
=
1636 strip_trailing_slashes (current_stat_info
.file_name
);
1638 label
->header
.typeflag
= GNUTYPE_VOLHDR
;
1639 TIME_TO_CHARS (start_time
.tv_sec
, label
->header
.mtime
);
1640 finish_header (¤t_stat_info
, label
, -1);
1641 set_next_block_after (label
);
1645 #define VOL_SUFFIX "Volume"
1647 /* Add a volume label to a part of multi-volume archive */
1649 add_volume_label (void)
1651 char buf
[UINTMAX_STRSIZE_BOUND
];
1652 char *p
= STRINGIFY_BIGINT (volno
, buf
);
1653 char *s
= xmalloc (strlen (volume_label_option
) + sizeof VOL_SUFFIX
1655 sprintf (s
, "%s %s %s", volume_label_option
, VOL_SUFFIX
, p
);
1656 _write_volume_label (s
);
1661 add_chunk_header (struct bufmap
*map
)
1663 if (archive_format
== POSIX_FORMAT
)
1665 off_t block_ordinal
;
1667 struct tar_stat_info st
;
1669 memset (&st
, 0, sizeof st
);
1670 st
.orig_file_name
= st
.file_name
= map
->file_name
;
1671 st
.stat
.st_mode
= S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
;
1672 st
.stat
.st_uid
= getuid ();
1673 st
.stat
.st_gid
= getgid ();
1674 st
.orig_file_name
= xheader_format_name (&st
,
1675 "%d/GNUFileParts.%p/%f.%n",
1677 st
.file_name
= st
.orig_file_name
;
1678 st
.archive_file_size
= st
.stat
.st_size
= map
->sizeleft
;
1680 block_ordinal
= current_block_ordinal ();
1681 blk
= start_header (&st
);
1683 abort (); /* FIXME */
1684 finish_header (&st
, blk
, block_ordinal
);
1685 free (st
.orig_file_name
);
1690 /* Add a volume label to the current archive */
1692 write_volume_label (void)
1694 if (multi_volume_option
)
1695 add_volume_label ();
1697 _write_volume_label (volume_label_option
);
1700 /* Write GNU multi-volume header */
1702 gnu_add_multi_volume_header (struct bufmap
*map
)
1705 union block
*block
= find_next_block ();
1707 if (strlen (map
->file_name
) > NAME_FIELD_SIZE
)
1709 _("%s: file name too long to be stored in a GNU multivolume header, truncated"),
1710 quotearg_colon (map
->file_name
)));
1712 memset (block
, 0, BLOCKSIZE
);
1714 strncpy (block
->header
.name
, map
->file_name
, NAME_FIELD_SIZE
);
1715 block
->header
.typeflag
= GNUTYPE_MULTIVOL
;
1717 OFF_TO_CHARS (map
->sizeleft
, block
->header
.size
);
1718 OFF_TO_CHARS (map
->sizetotal
- map
->sizeleft
,
1719 block
->oldgnu_header
.offset
);
1721 tmp
= verbose_option
;
1723 finish_header (¤t_stat_info
, block
, -1);
1724 verbose_option
= tmp
;
1725 set_next_block_after (block
);
1728 /* Add a multi volume header to the current archive. The exact header format
1729 depends on the archive format. */
1731 add_multi_volume_header (struct bufmap
*map
)
1733 if (archive_format
== POSIX_FORMAT
)
1735 off_t d
= map
->sizetotal
- map
->sizeleft
;
1736 xheader_store ("GNU.volume.filename", &dummy
, map
->file_name
);
1737 xheader_store ("GNU.volume.size", &dummy
, &map
->sizeleft
);
1738 xheader_store ("GNU.volume.offset", &dummy
, &d
);
1741 gnu_add_multi_volume_header (map
);
1745 /* Low-level flush functions */
1747 /* Simple flush read (no multi-volume or label extensions) */
1749 simple_flush_read (void)
1751 size_t status
; /* result from system call */
1753 checkpoint_run (false);
1755 /* Clear the count of errors. This only applies to a single call to
1758 read_error_count
= 0; /* clear error count */
1760 if (write_archive_to_stdout
&& record_start_block
!= 0)
1762 archive
= STDOUT_FILENO
;
1763 status
= sys_write_archive_buffer ();
1764 archive
= STDIN_FILENO
;
1765 if (status
!= record_size
)
1766 archive_write_error (status
);
1771 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1772 if (status
== record_size
)
1777 if (status
== SAFE_READ_ERROR
)
1779 archive_read_error ();
1780 continue; /* try again */
1784 short_read (status
);
1787 /* Simple flush write (no multi-volume or label extensions) */
1789 simple_flush_write (size_t level
__attribute__((unused
)))
1793 status
= _flush_write ();
1794 if (status
!= record_size
)
1795 archive_write_error (status
);
1799 bytes_written
+= status
;
1804 /* GNU flush functions. These support multi-volume and archive labels in
1805 GNU and PAX archive formats. */
1808 _gnu_flush_read (void)
1810 size_t status
; /* result from system call */
1812 checkpoint_run (false);
1814 /* Clear the count of errors. This only applies to a single call to
1817 read_error_count
= 0; /* clear error count */
1819 if (write_archive_to_stdout
&& record_start_block
!= 0)
1821 archive
= STDOUT_FILENO
;
1822 status
= sys_write_archive_buffer ();
1823 archive
= STDIN_FILENO
;
1824 if (status
!= record_size
)
1825 archive_write_error (status
);
1830 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1831 if (status
== record_size
)
1837 /* The condition below used to include
1838 || (status > 0 && !read_full_records)
1839 This is incorrect since even if new_volume() succeeds, the
1840 subsequent call to rmtread will overwrite the chunk of data
1841 already read in the buffer, so the processing will fail */
1843 || (status
== SAFE_READ_ERROR
&& errno
== ENOSPC
))
1844 && multi_volume_option
)
1846 while (!try_new_volume ())
1848 if (current_block
== record_end
)
1849 /* Necessary for blocking_factor == 1 */
1853 else if (status
== SAFE_READ_ERROR
)
1855 archive_read_error ();
1860 short_read (status
);
1864 gnu_flush_read (void)
1866 flush_read_ptr
= simple_flush_read
; /* Avoid recursion */
1868 flush_read_ptr
= gnu_flush_read
;
1872 _gnu_flush_write (size_t buffer_level
)
1875 union block
*header
;
1881 status
= _flush_write ();
1882 if (status
!= record_size
&& !multi_volume_option
)
1883 archive_write_error (status
);
1888 bytes_written
+= status
;
1891 if (status
== record_size
)
1896 map
= bufmap_locate (status
);
1898 if (status
% BLOCKSIZE
)
1900 ERROR ((0, 0, _("write did not end on a block boundary")));
1901 archive_write_error (status
);
1904 /* In multi-volume mode. */
1905 /* ENXIO is for the UNIX PC. */
1906 if (status
< 0 && errno
!= ENOSPC
&& errno
!= EIO
&& errno
!= ENXIO
)
1907 archive_write_error (status
);
1909 if (!new_volume (ACCESS_WRITE
))
1912 tar_stat_destroy (&dummy
);
1914 increase_volume_number ();
1915 prev_written
+= bytes_written
;
1918 copy_ptr
= record_start
->buffer
+ status
;
1919 copy_size
= buffer_level
- status
;
1921 /* Switch to the next buffer */
1922 record_index
= !record_index
;
1927 if (volume_label_option
)
1928 add_volume_label ();
1931 add_multi_volume_header (map
);
1933 write_extended (true, &dummy
, find_next_block ());
1934 tar_stat_destroy (&dummy
);
1937 add_chunk_header (map
);
1938 header
= find_next_block ();
1939 bufmap_reset (map
, header
- record_start
);
1940 bufsize
= available_space_after (header
);
1942 while (bufsize
< copy_size
)
1944 memcpy (header
->buffer
, copy_ptr
, bufsize
);
1945 copy_ptr
+= bufsize
;
1946 copy_size
-= bufsize
;
1947 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
1948 header
= find_next_block ();
1949 bufsize
= available_space_after (header
);
1951 memcpy (header
->buffer
, copy_ptr
, copy_size
);
1952 memset (header
->buffer
+ copy_size
, 0, bufsize
- copy_size
);
1953 set_next_block_after (header
+ (copy_size
- 1) / BLOCKSIZE
);
1958 gnu_flush_write (size_t buffer_level
)
1960 flush_write_ptr
= simple_flush_write
; /* Avoid recursion */
1961 _gnu_flush_write (buffer_level
);
1962 flush_write_ptr
= gnu_flush_write
;
1974 flush_write_ptr (record_size
);
1978 open_archive (enum access_mode wanted_access
)
1980 flush_read_ptr
= gnu_flush_read
;
1981 flush_write_ptr
= gnu_flush_write
;
1983 _open_archive (wanted_access
);
1984 switch (wanted_access
)
1988 if (volume_label_option
)
1989 match_volume_label ();
1993 records_written
= 0;
1994 if (volume_label_option
)
1995 write_volume_label ();
1998 set_volume_start_time ();