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
;
671 /* Open an archive file. The argument specifies whether we are
672 reading or writing, or both. */
674 _open_archive (enum access_mode wanted_access
)
676 int backed_up_flag
= 0;
678 if (record_size
== 0)
679 FATAL_ERROR ((0, 0, _("Invalid value for record_size")));
681 if (archive_names
== 0)
682 FATAL_ERROR ((0, 0, _("No archive name given")));
684 tar_stat_destroy (¤t_stat_info
);
689 /* When updating the archive, we start with reading. */
690 access_mode
= wanted_access
== ACCESS_UPDATE
? ACCESS_READ
: wanted_access
;
692 read_full_records
= read_full_records_option
;
696 if (use_compress_program_option
)
698 switch (wanted_access
)
701 child_pid
= sys_child_open_for_uncompress ();
702 read_full_records
= true;
703 record_end
= record_start
; /* set up for 1st record = # 0 */
707 child_pid
= sys_child_open_for_compress ();
711 abort (); /* Should not happen */
716 && wanted_access
== ACCESS_WRITE
717 && strcmp (archive_name_array
[0], "-") == 0)
720 else if (strcmp (archive_name_array
[0], "-") == 0)
722 read_full_records
= true; /* could be a pipe, be safe */
724 FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
726 switch (wanted_access
)
731 enum compress_type type
;
733 archive
= STDIN_FILENO
;
735 type
= check_compressed_archive (&shortfile
);
736 if (type
!= ct_tar
&& type
!= ct_none
)
738 _("Archive is compressed. Use %s option"),
739 compress_option (type
)));
741 ERROR ((0, 0, _("This does not look like a tar archive")));
746 archive
= STDOUT_FILENO
;
747 if (!index_file_name
)
752 archive
= STDIN_FILENO
;
753 write_archive_to_stdout
= true;
754 record_end
= record_start
; /* set up for 1st record = # 0 */
755 if (!index_file_name
)
761 switch (wanted_access
)
764 archive
= open_compressed_archive ();
766 guess_seekable_archive ();
772 maybe_backup_file (archive_name_array
[0], 1);
776 archive
= rmtopen (archive_name_array
[0], O_RDWR
| O_CREAT
| O_BINARY
,
777 MODE_RW
, rsh_command_option
);
779 archive
= rmtcreat (archive_name_array
[0], MODE_RW
,
784 archive
= rmtopen (archive_name_array
[0],
785 O_RDWR
| O_CREAT
| O_BINARY
,
786 MODE_RW
, rsh_command_option
);
788 switch (check_compressed_archive (NULL
))
796 _("Cannot update compressed archives")));
802 || (! _isrmt (archive
) && !sys_get_archive_stat ()))
804 int saved_errno
= errno
;
809 open_fatal (archive_name_array
[0]);
812 sys_detect_dev_null_output ();
813 sys_save_archive_dev_ino ();
814 SET_BINARY_MODE (archive
);
816 switch (wanted_access
)
819 find_next_block (); /* read it in, check for EOF */
829 /* Perform a write to flush the buffer. */
835 checkpoint_run (true);
836 if (tape_length_option
&& tape_length_option
<= bytes_written
)
841 else if (dev_null_output
)
842 status
= record_size
;
844 status
= sys_write_archive_buffer ();
846 if (status
&& multi_volume_option
&& !inhibit_map
)
848 struct bufmap
*map
= bufmap_locate (status
);
851 size_t delta
= status
- map
->start
* BLOCKSIZE
;
852 if (delta
> map
->sizeleft
)
853 delta
= map
->sizeleft
;
854 map
->sizeleft
-= delta
;
855 if (map
->sizeleft
== 0)
857 bufmap_reset (map
, map
? (- map
->start
) : 0);
863 /* Handle write errors on the archive. Write errors are always fatal.
864 Hitting the end of a volume does not cause a write error unless the
865 write was the first record of the volume. */
867 archive_write_error (ssize_t status
)
869 /* It might be useful to know how much was written before the error
874 print_total_stats ();
878 write_fatal_details (*archive_name_cursor
, status
, record_size
);
881 /* Handle read errors on the archive. If the read should be retried,
882 return to the caller. */
884 archive_read_error (void)
886 read_error (*archive_name_cursor
);
888 if (record_start_block
== 0)
889 FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
891 /* Read error in mid archive. We retry up to READ_ERROR_MAX times and
892 then give up on reading the archive. */
894 if (read_error_count
++ > READ_ERROR_MAX
)
895 FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
900 archive_is_dev (void)
904 if (fstat (archive
, &st
))
906 stat_diag (*archive_name_cursor
);
909 return S_ISBLK (st
.st_mode
) || S_ISCHR (st
.st_mode
);
913 short_read (size_t status
)
915 size_t left
; /* bytes left */
916 char *more
; /* pointer to next byte to read */
918 more
= record_start
->buffer
+ status
;
919 left
= record_size
- status
;
921 if (left
&& left
% BLOCKSIZE
== 0
922 && (warning_option
& WARN_RECORD_SIZE
)
923 && record_start_block
== 0 && status
!= 0
924 && archive_is_dev ())
926 unsigned long rsize
= status
/ BLOCKSIZE
;
928 ngettext ("Record size = %lu block",
929 "Record size = %lu blocks",
934 while (left
% BLOCKSIZE
!= 0
935 || (left
&& status
&& read_full_records
))
938 while ((status
= rmtread (archive
, more
, left
)) == SAFE_READ_ERROR
)
939 archive_read_error ();
944 if (! read_full_records
)
946 unsigned long rest
= record_size
- left
;
949 ngettext ("Unaligned block (%lu byte) in archive",
950 "Unaligned block (%lu bytes) in archive",
959 record_end
= record_start
+ (record_size
- left
) / BLOCKSIZE
;
963 /* Flush the current buffer to/from the archive. */
967 size_t buffer_level
= current_block
->buffer
- record_start
->buffer
;
968 record_start_block
+= record_end
- record_start
;
969 current_block
= record_start
;
970 record_end
= record_start
+ blocking_factor
;
972 if (access_mode
== ACCESS_READ
&& time_to_start_writing
)
974 access_mode
= ACCESS_WRITE
;
975 time_to_start_writing
= false;
986 flush_write_ptr (buffer_level
);
994 /* Backspace the archive descriptor by one record worth. If it's a
995 tape, MTIOCTOP will work. If it's something else, try to seek on
996 it. If we can't seek, we lose! */
998 backspace_output (void)
1002 struct mtop operation
;
1004 operation
.mt_op
= MTBSR
;
1005 operation
.mt_count
= 1;
1006 if (rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
1008 if (errno
== EIO
&& rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
1014 off_t position
= rmtlseek (archive
, (off_t
) 0, SEEK_CUR
);
1016 /* Seek back to the beginning of this record and start writing there. */
1018 position
-= record_size
;
1021 if (rmtlseek (archive
, position
, SEEK_SET
) != position
)
1023 /* Lseek failed. Try a different method. */
1026 _("Cannot backspace archive file; it may be unreadable without -i")));
1028 /* Replace the first part of the record with NULs. */
1030 if (record_start
->buffer
!= output_start
)
1031 memset (record_start
->buffer
, 0,
1032 output_start
- record_start
->buffer
);
1038 seek_archive (off_t size
)
1040 off_t start
= current_block_ordinal ();
1043 off_t skipped
= (blocking_factor
- (current_block
- record_start
))
1046 if (size
<= skipped
)
1049 /* Compute number of records to skip */
1050 nrec
= (size
- skipped
) / record_size
;
1053 offset
= rmtlseek (archive
, nrec
* record_size
, SEEK_CUR
);
1057 if (offset
% record_size
)
1058 FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary")));
1060 /* Convert to number of records */
1061 offset
/= BLOCKSIZE
;
1062 /* Compute number of skipped blocks */
1063 nblk
= offset
- start
;
1065 /* Update buffering info */
1066 records_read
+= nblk
/ blocking_factor
;
1067 record_start_block
= offset
- blocking_factor
;
1068 current_block
= record_end
;
1073 /* Close the archive file. */
1075 close_archive (void)
1077 if (time_to_start_writing
|| access_mode
== ACCESS_WRITE
)
1080 if (current_block
> record_start
)
1084 compute_duration ();
1088 if (rmtclose (archive
) != 0)
1089 close_error (*archive_name_cursor
);
1091 sys_wait_for_child (child_pid
, hit_eof
);
1093 tar_stat_destroy (¤t_stat_info
);
1094 free (record_buffer
[0]);
1095 free (record_buffer
[1]);
1099 /* Called to initialize the global volume number. */
1101 init_volume_number (void)
1103 FILE *file
= fopen (volno_file_option
, "r");
1107 if (fscanf (file
, "%d", &global_volno
) != 1
1108 || global_volno
< 0)
1109 FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"),
1110 quotearg_colon (volno_file_option
)));
1112 read_error (volno_file_option
);
1113 if (fclose (file
) != 0)
1114 close_error (volno_file_option
);
1116 else if (errno
!= ENOENT
)
1117 open_error (volno_file_option
);
1120 /* Called to write out the closing global volume number. */
1122 closeout_volume_number (void)
1124 FILE *file
= fopen (volno_file_option
, "w");
1128 fprintf (file
, "%d\n", global_volno
);
1130 write_error (volno_file_option
);
1131 if (fclose (file
) != 0)
1132 close_error (volno_file_option
);
1135 open_error (volno_file_option
);
1140 increase_volume_number (void)
1143 if (global_volno
< 0)
1144 FATAL_ERROR ((0, 0, _("Volume number overflow")));
1149 change_tape_menu (FILE *read_file
)
1151 char *input_buffer
= NULL
;
1157 fputc ('\007', stderr
);
1159 _("Prepare volume #%d for %s and hit return: "),
1160 global_volno
+ 1, quote (*archive_name_cursor
));
1163 if (getline (&input_buffer
, &size
, read_file
) <= 0)
1165 WARN ((0, 0, _("EOF where user reply was expected")));
1167 if (subcommand_option
!= EXTRACT_SUBCOMMAND
1168 && subcommand_option
!= LIST_SUBCOMMAND
1169 && subcommand_option
!= DIFF_SUBCOMMAND
)
1170 WARN ((0, 0, _("WARNING: Archive is incomplete")));
1175 if (input_buffer
[0] == '\n'
1176 || input_buffer
[0] == 'y'
1177 || input_buffer
[0] == 'Y')
1180 switch (input_buffer
[0])
1184 fprintf (stderr
, _("\
1185 n name Give a new file name for the next (and subsequent) volume(s)\n\
1187 y or newline Continue operation\n"));
1188 if (!restrict_option
)
1189 fprintf (stderr
, _(" ! Spawn a subshell\n"));
1190 fprintf (stderr
, _(" ? Print this list\n"));
1197 WARN ((0, 0, _("No new volume; exiting.\n")));
1199 if (subcommand_option
!= EXTRACT_SUBCOMMAND
1200 && subcommand_option
!= LIST_SUBCOMMAND
1201 && subcommand_option
!= DIFF_SUBCOMMAND
)
1202 WARN ((0, 0, _("WARNING: Archive is incomplete")));
1207 /* Get new file name. */
1213 for (name
= input_buffer
+ 1;
1214 *name
== ' ' || *name
== '\t';
1218 for (cursor
= name
; *cursor
&& *cursor
!= '\n'; cursor
++)
1224 /* FIXME: the following allocation is never reclaimed. */
1225 *archive_name_cursor
= xstrdup (name
);
1229 fprintf (stderr
, "%s",
1230 _("File name not specified. Try again.\n"));
1235 if (!restrict_option
)
1243 fprintf (stderr
, _("Invalid input. Type ? for help.\n"));
1246 free (input_buffer
);
1249 /* We've hit the end of the old volume. Close it and open the next one.
1250 Return nonzero on success.
1253 new_volume (enum access_mode mode
)
1255 static FILE *read_file
;
1259 if (!read_file
&& !info_script_option
)
1260 /* FIXME: if fopen is used, it will never be closed. */
1261 read_file
= archive
== STDIN_FILENO
? fopen (TTY_NAME
, "r") : stdin
;
1268 assign_string (&volume_label
, NULL
);
1269 assign_string (&continued_file_name
, NULL
);
1270 continued_file_size
= continued_file_offset
= 0;
1271 current_block
= record_start
;
1273 if (rmtclose (archive
) != 0)
1274 close_error (*archive_name_cursor
);
1276 archive_name_cursor
++;
1277 if (archive_name_cursor
== archive_name_array
+ archive_names
)
1279 archive_name_cursor
= archive_name_array
;
1287 /* We have to prompt from now on. */
1289 if (info_script_option
)
1291 if (volno_file_option
)
1292 closeout_volume_number ();
1293 if (sys_exec_info_script (archive_name_cursor
, global_volno
+1))
1294 FATAL_ERROR ((0, 0, _("%s command failed"),
1295 quote (info_script_option
)));
1298 change_tape_menu (read_file
);
1301 if (strcmp (archive_name_cursor
[0], "-") == 0)
1303 read_full_records
= true;
1304 archive
= STDIN_FILENO
;
1306 else if (verify_option
)
1307 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1308 rsh_command_option
);
1313 archive
= rmtopen (*archive_name_cursor
, O_RDONLY
, MODE_RW
,
1314 rsh_command_option
);
1315 guess_seekable_archive ();
1320 maybe_backup_file (*archive_name_cursor
, 1);
1321 archive
= rmtcreat (*archive_name_cursor
, MODE_RW
,
1322 rsh_command_option
);
1326 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1327 rsh_command_option
);
1333 open_warn (*archive_name_cursor
);
1334 if (!verify_option
&& mode
== ACCESS_WRITE
&& backup_option
)
1335 undo_last_backup ();
1340 SET_BINARY_MODE (archive
);
1346 read_header0 (struct tar_stat_info
*info
)
1348 enum read_header rc
;
1350 tar_stat_init (info
);
1351 rc
= read_header (¤t_header
, info
, read_header_auto
);
1352 if (rc
== HEADER_SUCCESS
)
1354 set_next_block_after (current_header
);
1357 ERROR ((0, 0, _("This does not look like a tar archive")));
1362 try_new_volume (void)
1365 union block
*header
;
1366 enum access_mode acc
;
1368 switch (subcommand_option
)
1370 case APPEND_SUBCOMMAND
:
1371 case CAT_SUBCOMMAND
:
1372 case UPDATE_SUBCOMMAND
:
1373 acc
= ACCESS_UPDATE
;
1381 if (!new_volume (acc
))
1384 while ((status
= rmtread (archive
, record_start
->buffer
, record_size
))
1386 archive_read_error ();
1388 if (status
!= record_size
)
1389 short_read (status
);
1391 header
= find_next_block ();
1395 switch (header
->header
.typeflag
)
1399 tar_stat_init (&dummy
);
1400 if (read_header (&header
, &dummy
, read_header_x_global
)
1401 != HEADER_SUCCESS_EXTENDED
)
1403 ERROR ((0, 0, _("This does not look like a tar archive")));
1407 xheader_decode (&dummy
); /* decodes values from the global header */
1408 tar_stat_destroy (&dummy
);
1410 /* The initial global header must be immediately followed by
1411 an extended PAX header for the first member in this volume.
1412 However, in some cases tar may split volumes in the middle
1413 of a PAX header. This is incorrect, and should be fixed
1414 in the future versions. In the meantime we must be
1415 prepared to correctly list and extract such archives.
1417 If this happens, the following call to read_header returns
1418 HEADER_FAILURE, which is ignored.
1420 See also tests/multiv07.at */
1422 switch (read_header (&header
, &dummy
, read_header_auto
))
1424 case HEADER_SUCCESS
:
1425 set_next_block_after (header
);
1428 case HEADER_FAILURE
:
1432 ERROR ((0, 0, _("This does not look like a tar archive")));
1438 case GNUTYPE_VOLHDR
:
1439 if (!read_header0 (&dummy
))
1441 tar_stat_destroy (&dummy
);
1442 assign_string (&volume_label
, current_header
->header
.name
);
1443 set_next_block_after (header
);
1444 header
= find_next_block ();
1445 if (header
->header
.typeflag
!= GNUTYPE_MULTIVOL
)
1449 case GNUTYPE_MULTIVOL
:
1450 if (!read_header0 (&dummy
))
1452 tar_stat_destroy (&dummy
);
1453 assign_string (&continued_file_name
, current_header
->header
.name
);
1454 continued_file_size
=
1455 UINTMAX_FROM_HEADER (current_header
->header
.size
);
1456 continued_file_offset
=
1457 UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
);
1467 if (!continued_file_name
1468 || strcmp (continued_file_name
, bufmap_head
->file_name
))
1470 if ((archive_format
== GNU_FORMAT
|| archive_format
== OLDGNU_FORMAT
)
1471 && strlen (bufmap_head
->file_name
) >= NAME_FIELD_SIZE
1472 && strncmp (continued_file_name
, bufmap_head
->file_name
,
1473 NAME_FIELD_SIZE
) == 0)
1475 _("%s is possibly continued on this volume: header contains truncated name"),
1476 quote (bufmap_head
->file_name
)));
1479 WARN ((0, 0, _("%s is not continued on this volume"),
1480 quote (bufmap_head
->file_name
)));
1485 s
= continued_file_size
+ continued_file_offset
;
1487 if (bufmap_head
->sizetotal
!= s
|| s
< continued_file_offset
)
1489 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1490 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1491 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1493 WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
1494 quote (continued_file_name
),
1495 STRINGIFY_BIGINT (bufmap_head
->sizetotal
, totsizebuf
),
1496 STRINGIFY_BIGINT (continued_file_size
, s1buf
),
1497 STRINGIFY_BIGINT (continued_file_offset
, s2buf
)));
1501 if (bufmap_head
->sizetotal
- bufmap_head
->sizeleft
!=
1502 continued_file_offset
)
1504 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1505 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1506 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1508 WARN ((0, 0, _("This volume is out of sequence (%s - %s != %s)"),
1509 STRINGIFY_BIGINT (bufmap_head
->sizetotal
, totsizebuf
),
1510 STRINGIFY_BIGINT (bufmap_head
->sizeleft
, s1buf
),
1511 STRINGIFY_BIGINT (continued_file_offset
, s2buf
)));
1517 increase_volume_number ();
1522 #define VOLUME_TEXT " Volume "
1523 #define VOLUME_TEXT_LEN (sizeof VOLUME_TEXT - 1)
1526 drop_volume_label_suffix (const char *label
)
1529 size_t len
= strlen (label
);
1534 for (p
= label
+ len
- 1; p
> label
&& isdigit ((unsigned char) *p
); p
--)
1536 if (p
> label
&& p
- (VOLUME_TEXT_LEN
- 1) > label
)
1538 p
-= VOLUME_TEXT_LEN
- 1;
1539 if (memcmp (p
, VOLUME_TEXT
, VOLUME_TEXT_LEN
) == 0)
1541 char *s
= xmalloc ((len
= p
- label
) + 1);
1542 memcpy (s
, label
, len
);
1551 /* Check LABEL against the volume label, seen as a globbing
1552 pattern. Return true if the pattern matches. In case of failure,
1553 retry matching a volume sequence number before giving up in
1554 multi-volume mode. */
1556 check_label_pattern (const char *label
)
1559 bool result
= false;
1561 if (fnmatch (volume_label_option
, label
, 0) == 0)
1564 if (!multi_volume_option
)
1567 string
= drop_volume_label_suffix (label
);
1570 result
= fnmatch (string
, volume_label_option
, 0) == 0;
1576 /* Check if the next block contains a volume label and if this matches
1577 the one given in the command line */
1579 match_volume_label (void)
1583 union block
*label
= find_next_block ();
1586 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1587 quote (volume_label_option
)));
1588 if (label
->header
.typeflag
== GNUTYPE_VOLHDR
)
1590 if (memchr (label
->header
.name
, '\0', sizeof label
->header
.name
))
1591 assign_string (&volume_label
, label
->header
.name
);
1594 volume_label
= xmalloc (sizeof (label
->header
.name
) + 1);
1595 memcpy (volume_label
, label
->header
.name
,
1596 sizeof (label
->header
.name
));
1597 volume_label
[sizeof (label
->header
.name
)] = 0;
1600 else if (label
->header
.typeflag
== XGLTYPE
)
1602 struct tar_stat_info st
;
1603 tar_stat_init (&st
);
1604 xheader_read (&st
.xhdr
, label
,
1605 OFF_FROM_HEADER (label
->header
.size
));
1606 xheader_decode (&st
);
1607 tar_stat_destroy (&st
);
1612 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1613 quote (volume_label_option
)));
1615 if (!check_label_pattern (volume_label
))
1616 FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
1617 quote_n (0, volume_label
),
1618 quote_n (1, volume_label_option
)));
1621 /* Mark the archive with volume label STR. */
1623 _write_volume_label (const char *str
)
1625 if (archive_format
== POSIX_FORMAT
)
1626 xheader_store ("GNU.volume.label", &dummy
, str
);
1629 union block
*label
= find_next_block ();
1631 memset (label
, 0, BLOCKSIZE
);
1633 strcpy (label
->header
.name
, str
);
1634 assign_string (¤t_stat_info
.file_name
,
1635 label
->header
.name
);
1636 current_stat_info
.had_trailing_slash
=
1637 strip_trailing_slashes (current_stat_info
.file_name
);
1639 label
->header
.typeflag
= GNUTYPE_VOLHDR
;
1640 TIME_TO_CHARS (start_time
.tv_sec
, label
->header
.mtime
);
1641 finish_header (¤t_stat_info
, label
, -1);
1642 set_next_block_after (label
);
1646 #define VOL_SUFFIX "Volume"
1648 /* Add a volume label to a part of multi-volume archive */
1650 add_volume_label (void)
1652 char buf
[UINTMAX_STRSIZE_BOUND
];
1653 char *p
= STRINGIFY_BIGINT (volno
, buf
);
1654 char *s
= xmalloc (strlen (volume_label_option
) + sizeof VOL_SUFFIX
1656 sprintf (s
, "%s %s %s", volume_label_option
, VOL_SUFFIX
, p
);
1657 _write_volume_label (s
);
1662 add_chunk_header (struct bufmap
*map
)
1664 if (archive_format
== POSIX_FORMAT
)
1666 off_t block_ordinal
;
1668 struct tar_stat_info st
;
1670 memset (&st
, 0, sizeof st
);
1671 st
.orig_file_name
= st
.file_name
= map
->file_name
;
1672 st
.stat
.st_mode
= S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
;
1673 st
.stat
.st_uid
= getuid ();
1674 st
.stat
.st_gid
= getgid ();
1675 st
.orig_file_name
= xheader_format_name (&st
,
1676 "%d/GNUFileParts.%p/%f.%n",
1678 st
.file_name
= st
.orig_file_name
;
1679 st
.archive_file_size
= st
.stat
.st_size
= map
->sizeleft
;
1681 block_ordinal
= current_block_ordinal ();
1682 blk
= start_header (&st
);
1684 abort (); /* FIXME */
1685 finish_header (&st
, blk
, block_ordinal
);
1686 free (st
.orig_file_name
);
1691 /* Add a volume label to the current archive */
1693 write_volume_label (void)
1695 if (multi_volume_option
)
1696 add_volume_label ();
1698 _write_volume_label (volume_label_option
);
1701 /* Write GNU multi-volume header */
1703 gnu_add_multi_volume_header (struct bufmap
*map
)
1706 union block
*block
= find_next_block ();
1708 if (strlen (map
->file_name
) > NAME_FIELD_SIZE
)
1710 _("%s: file name too long to be stored in a GNU multivolume header, truncated"),
1711 quotearg_colon (map
->file_name
)));
1713 memset (block
, 0, BLOCKSIZE
);
1715 strncpy (block
->header
.name
, map
->file_name
, NAME_FIELD_SIZE
);
1716 block
->header
.typeflag
= GNUTYPE_MULTIVOL
;
1718 OFF_TO_CHARS (map
->sizeleft
, block
->header
.size
);
1719 OFF_TO_CHARS (map
->sizetotal
- map
->sizeleft
,
1720 block
->oldgnu_header
.offset
);
1722 tmp
= verbose_option
;
1724 finish_header (¤t_stat_info
, block
, -1);
1725 verbose_option
= tmp
;
1726 set_next_block_after (block
);
1729 /* Add a multi volume header to the current archive. The exact header format
1730 depends on the archive format. */
1732 add_multi_volume_header (struct bufmap
*map
)
1734 if (archive_format
== POSIX_FORMAT
)
1736 off_t d
= map
->sizetotal
- map
->sizeleft
;
1737 xheader_store ("GNU.volume.filename", &dummy
, map
->file_name
);
1738 xheader_store ("GNU.volume.size", &dummy
, &map
->sizeleft
);
1739 xheader_store ("GNU.volume.offset", &dummy
, &d
);
1742 gnu_add_multi_volume_header (map
);
1746 /* Low-level flush functions */
1748 /* Simple flush read (no multi-volume or label extensions) */
1750 simple_flush_read (void)
1752 size_t status
; /* result from system call */
1754 checkpoint_run (false);
1756 /* Clear the count of errors. This only applies to a single call to
1759 read_error_count
= 0; /* clear error count */
1761 if (write_archive_to_stdout
&& record_start_block
!= 0)
1763 archive
= STDOUT_FILENO
;
1764 status
= sys_write_archive_buffer ();
1765 archive
= STDIN_FILENO
;
1766 if (status
!= record_size
)
1767 archive_write_error (status
);
1772 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1773 if (status
== record_size
)
1778 if (status
== SAFE_READ_ERROR
)
1780 archive_read_error ();
1781 continue; /* try again */
1785 short_read (status
);
1788 /* Simple flush write (no multi-volume or label extensions) */
1790 simple_flush_write (size_t level
__attribute__((unused
)))
1794 status
= _flush_write ();
1795 if (status
!= record_size
)
1796 archive_write_error (status
);
1800 bytes_written
+= status
;
1805 /* GNU flush functions. These support multi-volume and archive labels in
1806 GNU and PAX archive formats. */
1809 _gnu_flush_read (void)
1811 size_t status
; /* result from system call */
1813 checkpoint_run (false);
1815 /* Clear the count of errors. This only applies to a single call to
1818 read_error_count
= 0; /* clear error count */
1820 if (write_archive_to_stdout
&& record_start_block
!= 0)
1822 archive
= STDOUT_FILENO
;
1823 status
= sys_write_archive_buffer ();
1824 archive
= STDIN_FILENO
;
1825 if (status
!= record_size
)
1826 archive_write_error (status
);
1831 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1832 if (status
== record_size
)
1838 /* The condition below used to include
1839 || (status > 0 && !read_full_records)
1840 This is incorrect since even if new_volume() succeeds, the
1841 subsequent call to rmtread will overwrite the chunk of data
1842 already read in the buffer, so the processing will fail */
1844 || (status
== SAFE_READ_ERROR
&& errno
== ENOSPC
))
1845 && multi_volume_option
)
1847 while (!try_new_volume ())
1849 if (current_block
== record_end
)
1850 /* Necessary for blocking_factor == 1 */
1854 else if (status
== SAFE_READ_ERROR
)
1856 archive_read_error ();
1861 short_read (status
);
1865 gnu_flush_read (void)
1867 flush_read_ptr
= simple_flush_read
; /* Avoid recursion */
1869 flush_read_ptr
= gnu_flush_read
;
1873 _gnu_flush_write (size_t buffer_level
)
1876 union block
*header
;
1882 status
= _flush_write ();
1883 if (status
!= record_size
&& !multi_volume_option
)
1884 archive_write_error (status
);
1889 bytes_written
+= status
;
1892 if (status
== record_size
)
1897 map
= bufmap_locate (status
);
1899 if (status
% BLOCKSIZE
)
1901 ERROR ((0, 0, _("write did not end on a block boundary")));
1902 archive_write_error (status
);
1905 /* In multi-volume mode. */
1906 /* ENXIO is for the UNIX PC. */
1907 if (status
< 0 && errno
!= ENOSPC
&& errno
!= EIO
&& errno
!= ENXIO
)
1908 archive_write_error (status
);
1910 if (!new_volume (ACCESS_WRITE
))
1913 tar_stat_destroy (&dummy
);
1915 increase_volume_number ();
1916 prev_written
+= bytes_written
;
1919 copy_ptr
= record_start
->buffer
+ status
;
1920 copy_size
= buffer_level
- status
;
1922 /* Switch to the next buffer */
1923 record_index
= !record_index
;
1928 if (volume_label_option
)
1929 add_volume_label ();
1932 add_multi_volume_header (map
);
1934 write_extended (true, &dummy
, find_next_block ());
1935 tar_stat_destroy (&dummy
);
1938 add_chunk_header (map
);
1939 header
= find_next_block ();
1940 bufmap_reset (map
, header
- record_start
);
1941 bufsize
= available_space_after (header
);
1943 while (bufsize
< copy_size
)
1945 memcpy (header
->buffer
, copy_ptr
, bufsize
);
1946 copy_ptr
+= bufsize
;
1947 copy_size
-= bufsize
;
1948 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
1949 header
= find_next_block ();
1950 bufsize
= available_space_after (header
);
1952 memcpy (header
->buffer
, copy_ptr
, copy_size
);
1953 memset (header
->buffer
+ copy_size
, 0, bufsize
- copy_size
);
1954 set_next_block_after (header
+ (copy_size
- 1) / BLOCKSIZE
);
1959 gnu_flush_write (size_t buffer_level
)
1961 flush_write_ptr
= simple_flush_write
; /* Avoid recursion */
1962 _gnu_flush_write (buffer_level
);
1963 flush_write_ptr
= gnu_flush_write
;
1975 flush_write_ptr (record_size
);
1979 open_archive (enum access_mode wanted_access
)
1981 flush_read_ptr
= gnu_flush_read
;
1982 flush_write_ptr
= gnu_flush_write
;
1984 _open_archive (wanted_access
);
1985 switch (wanted_access
)
1989 if (volume_label_option
)
1990 match_volume_label ();
1994 records_written
= 0;
1995 if (volume_label_option
)
1996 write_volume_label ();
1999 set_volume_start_time ();