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 /* Refuse to read archive from a tty.
693 Do not fail if the tar's output goes directly to tty because such
694 behavior would go against GNU Coding Standards:
695 http://lists.gnu.org/archive/html/bug-tar/2014-03/msg00042.html */
696 if (strcmp (archive_name_array
[0], "-") == 0
697 && wanted_access
== ACCESS_READ
&& isatty (STDIN_FILENO
))
699 _("Refusing to read archive contents from terminal "
700 "(missing -f option?)")));
702 read_full_records
= read_full_records_option
;
706 if (use_compress_program_option
)
708 switch (wanted_access
)
711 child_pid
= sys_child_open_for_uncompress ();
712 read_full_records
= true;
713 record_end
= record_start
; /* set up for 1st record = # 0 */
717 child_pid
= sys_child_open_for_compress ();
721 abort (); /* Should not happen */
726 && wanted_access
== ACCESS_WRITE
727 && strcmp (archive_name_array
[0], "-") == 0)
730 else if (strcmp (archive_name_array
[0], "-") == 0)
732 read_full_records
= true; /* could be a pipe, be safe */
734 FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
736 switch (wanted_access
)
741 enum compress_type type
;
743 archive
= STDIN_FILENO
;
744 type
= check_compressed_archive (&shortfile
);
745 if (type
!= ct_tar
&& type
!= ct_none
)
747 _("Archive is compressed. Use %s option"),
748 compress_option (type
)));
750 ERROR ((0, 0, _("This does not look like a tar archive")));
755 archive
= STDOUT_FILENO
;
756 if (!index_file_name
)
761 archive
= STDIN_FILENO
;
762 write_archive_to_stdout
= true;
763 record_end
= record_start
; /* set up for 1st record = # 0 */
764 if (!index_file_name
)
770 switch (wanted_access
)
773 archive
= open_compressed_archive ();
775 guess_seekable_archive ();
781 maybe_backup_file (archive_name_array
[0], 1);
785 archive
= rmtopen (archive_name_array
[0], O_RDWR
| O_CREAT
| O_BINARY
,
786 MODE_RW
, rsh_command_option
);
788 archive
= rmtcreat (archive_name_array
[0], MODE_RW
,
793 archive
= rmtopen (archive_name_array
[0],
794 O_RDWR
| O_CREAT
| O_BINARY
,
795 MODE_RW
, rsh_command_option
);
797 switch (check_compressed_archive (NULL
))
805 _("Cannot update compressed archives")));
811 || (! _isrmt (archive
) && !sys_get_archive_stat ()))
813 int saved_errno
= errno
;
818 open_fatal (archive_name_array
[0]);
821 sys_detect_dev_null_output ();
822 sys_save_archive_dev_ino ();
823 SET_BINARY_MODE (archive
);
825 switch (wanted_access
)
828 find_next_block (); /* read it in, check for EOF */
838 /* Perform a write to flush the buffer. */
844 checkpoint_run (true);
845 if (tape_length_option
&& tape_length_option
<= bytes_written
)
850 else if (dev_null_output
)
851 status
= record_size
;
853 status
= sys_write_archive_buffer ();
855 if (status
&& multi_volume_option
&& !inhibit_map
)
857 struct bufmap
*map
= bufmap_locate (status
);
860 size_t delta
= status
- map
->start
* BLOCKSIZE
;
861 if (delta
> map
->sizeleft
)
862 delta
= map
->sizeleft
;
863 map
->sizeleft
-= delta
;
864 if (map
->sizeleft
== 0)
866 bufmap_reset (map
, map
? (- map
->start
) : 0);
872 /* Handle write errors on the archive. Write errors are always fatal.
873 Hitting the end of a volume does not cause a write error unless the
874 write was the first record of the volume. */
876 archive_write_error (ssize_t status
)
878 /* It might be useful to know how much was written before the error
883 print_total_stats ();
887 write_fatal_details (*archive_name_cursor
, status
, record_size
);
890 /* Handle read errors on the archive. If the read should be retried,
891 return to the caller. */
893 archive_read_error (void)
895 read_error (*archive_name_cursor
);
897 if (record_start_block
== 0)
898 FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
900 /* Read error in mid archive. We retry up to READ_ERROR_MAX times and
901 then give up on reading the archive. */
903 if (read_error_count
++ > READ_ERROR_MAX
)
904 FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
909 archive_is_dev (void)
913 if (fstat (archive
, &st
))
915 stat_diag (*archive_name_cursor
);
918 return S_ISBLK (st
.st_mode
) || S_ISCHR (st
.st_mode
);
922 short_read (size_t status
)
924 size_t left
; /* bytes left */
925 char *more
; /* pointer to next byte to read */
927 more
= record_start
->buffer
+ status
;
928 left
= record_size
- status
;
930 if (left
&& left
% BLOCKSIZE
== 0
931 && (warning_option
& WARN_RECORD_SIZE
)
932 && record_start_block
== 0 && status
!= 0
933 && archive_is_dev ())
935 unsigned long rsize
= status
/ BLOCKSIZE
;
937 ngettext ("Record size = %lu block",
938 "Record size = %lu blocks",
943 while (left
% BLOCKSIZE
!= 0
944 || (left
&& status
&& read_full_records
))
947 while ((status
= rmtread (archive
, more
, left
)) == SAFE_READ_ERROR
)
948 archive_read_error ();
953 if (! read_full_records
)
955 unsigned long rest
= record_size
- left
;
958 ngettext ("Unaligned block (%lu byte) in archive",
959 "Unaligned block (%lu bytes) in archive",
968 record_end
= record_start
+ (record_size
- left
) / BLOCKSIZE
;
972 /* Flush the current buffer to/from the archive. */
976 size_t buffer_level
= current_block
->buffer
- record_start
->buffer
;
977 record_start_block
+= record_end
- record_start
;
978 current_block
= record_start
;
979 record_end
= record_start
+ blocking_factor
;
981 if (access_mode
== ACCESS_READ
&& time_to_start_writing
)
983 access_mode
= ACCESS_WRITE
;
984 time_to_start_writing
= false;
995 flush_write_ptr (buffer_level
);
1003 /* Backspace the archive descriptor by one record worth. If it's a
1004 tape, MTIOCTOP will work. If it's something else, try to seek on
1005 it. If we can't seek, we lose! */
1007 backspace_output (void)
1011 struct mtop operation
;
1013 operation
.mt_op
= MTBSR
;
1014 operation
.mt_count
= 1;
1015 if (rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
1017 if (errno
== EIO
&& rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
1023 off_t position
= rmtlseek (archive
, (off_t
) 0, SEEK_CUR
);
1025 /* Seek back to the beginning of this record and start writing there. */
1027 position
-= record_size
;
1030 if (rmtlseek (archive
, position
, SEEK_SET
) != position
)
1032 /* Lseek failed. Try a different method. */
1035 _("Cannot backspace archive file; it may be unreadable without -i")));
1037 /* Replace the first part of the record with NULs. */
1039 if (record_start
->buffer
!= output_start
)
1040 memset (record_start
->buffer
, 0,
1041 output_start
- record_start
->buffer
);
1047 seek_archive (off_t size
)
1049 off_t start
= current_block_ordinal ();
1052 off_t skipped
= (blocking_factor
- (current_block
- record_start
))
1055 if (size
<= skipped
)
1058 /* Compute number of records to skip */
1059 nrec
= (size
- skipped
) / record_size
;
1062 offset
= rmtlseek (archive
, nrec
* record_size
, SEEK_CUR
);
1066 if (offset
% record_size
)
1067 FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary")));
1069 /* Convert to number of records */
1070 offset
/= BLOCKSIZE
;
1071 /* Compute number of skipped blocks */
1072 nblk
= offset
- start
;
1074 /* Update buffering info */
1075 records_read
+= nblk
/ blocking_factor
;
1076 record_start_block
= offset
- blocking_factor
;
1077 current_block
= record_end
;
1082 /* Close the archive file. */
1084 close_archive (void)
1086 if (time_to_start_writing
|| access_mode
== ACCESS_WRITE
)
1089 if (current_block
> record_start
)
1093 compute_duration ();
1097 if (rmtclose (archive
) != 0)
1098 close_error (*archive_name_cursor
);
1100 sys_wait_for_child (child_pid
, hit_eof
);
1102 tar_stat_destroy (¤t_stat_info
);
1103 free (record_buffer
[0]);
1104 free (record_buffer
[1]);
1108 /* Called to initialize the global volume number. */
1110 init_volume_number (void)
1112 FILE *file
= fopen (volno_file_option
, "r");
1116 if (fscanf (file
, "%d", &global_volno
) != 1
1117 || global_volno
< 0)
1118 FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"),
1119 quotearg_colon (volno_file_option
)));
1121 read_error (volno_file_option
);
1122 if (fclose (file
) != 0)
1123 close_error (volno_file_option
);
1125 else if (errno
!= ENOENT
)
1126 open_error (volno_file_option
);
1129 /* Called to write out the closing global volume number. */
1131 closeout_volume_number (void)
1133 FILE *file
= fopen (volno_file_option
, "w");
1137 fprintf (file
, "%d\n", global_volno
);
1139 write_error (volno_file_option
);
1140 if (fclose (file
) != 0)
1141 close_error (volno_file_option
);
1144 open_error (volno_file_option
);
1149 increase_volume_number (void)
1152 if (global_volno
< 0)
1153 FATAL_ERROR ((0, 0, _("Volume number overflow")));
1158 change_tape_menu (FILE *read_file
)
1160 char *input_buffer
= NULL
;
1166 fputc ('\007', stderr
);
1168 _("Prepare volume #%d for %s and hit return: "),
1169 global_volno
+ 1, quote (*archive_name_cursor
));
1172 if (getline (&input_buffer
, &size
, read_file
) <= 0)
1174 WARN ((0, 0, _("EOF where user reply was expected")));
1176 if (subcommand_option
!= EXTRACT_SUBCOMMAND
1177 && subcommand_option
!= LIST_SUBCOMMAND
1178 && subcommand_option
!= DIFF_SUBCOMMAND
)
1179 WARN ((0, 0, _("WARNING: Archive is incomplete")));
1184 if (input_buffer
[0] == '\n'
1185 || input_buffer
[0] == 'y'
1186 || input_buffer
[0] == 'Y')
1189 switch (input_buffer
[0])
1193 fprintf (stderr
, _("\
1194 n name Give a new file name for the next (and subsequent) volume(s)\n\
1196 y or newline Continue operation\n"));
1197 if (!restrict_option
)
1198 fprintf (stderr
, _(" ! Spawn a subshell\n"));
1199 fprintf (stderr
, _(" ? Print this list\n"));
1206 WARN ((0, 0, _("No new volume; exiting.\n")));
1208 if (subcommand_option
!= EXTRACT_SUBCOMMAND
1209 && subcommand_option
!= LIST_SUBCOMMAND
1210 && subcommand_option
!= DIFF_SUBCOMMAND
)
1211 WARN ((0, 0, _("WARNING: Archive is incomplete")));
1216 /* Get new file name. */
1222 for (name
= input_buffer
+ 1;
1223 *name
== ' ' || *name
== '\t';
1227 for (cursor
= name
; *cursor
&& *cursor
!= '\n'; cursor
++)
1233 /* FIXME: the following allocation is never reclaimed. */
1234 *archive_name_cursor
= xstrdup (name
);
1238 fprintf (stderr
, "%s",
1239 _("File name not specified. Try again.\n"));
1244 if (!restrict_option
)
1252 fprintf (stderr
, _("Invalid input. Type ? for help.\n"));
1255 free (input_buffer
);
1258 /* We've hit the end of the old volume. Close it and open the next one.
1259 Return nonzero on success.
1262 new_volume (enum access_mode mode
)
1264 static FILE *read_file
;
1268 if (!read_file
&& !info_script_option
)
1269 /* FIXME: if fopen is used, it will never be closed. */
1270 read_file
= archive
== STDIN_FILENO
? fopen (TTY_NAME
, "r") : stdin
;
1277 assign_string (&volume_label
, NULL
);
1278 assign_string (&continued_file_name
, NULL
);
1279 continued_file_size
= continued_file_offset
= 0;
1280 current_block
= record_start
;
1282 if (rmtclose (archive
) != 0)
1283 close_error (*archive_name_cursor
);
1285 archive_name_cursor
++;
1286 if (archive_name_cursor
== archive_name_array
+ archive_names
)
1288 archive_name_cursor
= archive_name_array
;
1296 /* We have to prompt from now on. */
1298 if (info_script_option
)
1300 if (volno_file_option
)
1301 closeout_volume_number ();
1302 if (sys_exec_info_script (archive_name_cursor
, global_volno
+1))
1303 FATAL_ERROR ((0, 0, _("%s command failed"),
1304 quote (info_script_option
)));
1307 change_tape_menu (read_file
);
1310 if (strcmp (archive_name_cursor
[0], "-") == 0)
1312 read_full_records
= true;
1313 archive
= STDIN_FILENO
;
1315 else if (verify_option
)
1316 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1317 rsh_command_option
);
1322 archive
= rmtopen (*archive_name_cursor
, O_RDONLY
, MODE_RW
,
1323 rsh_command_option
);
1324 guess_seekable_archive ();
1329 maybe_backup_file (*archive_name_cursor
, 1);
1330 archive
= rmtcreat (*archive_name_cursor
, MODE_RW
,
1331 rsh_command_option
);
1335 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1336 rsh_command_option
);
1342 open_warn (*archive_name_cursor
);
1343 if (!verify_option
&& mode
== ACCESS_WRITE
&& backup_option
)
1344 undo_last_backup ();
1349 SET_BINARY_MODE (archive
);
1355 read_header0 (struct tar_stat_info
*info
)
1357 enum read_header rc
;
1359 tar_stat_init (info
);
1360 rc
= read_header (¤t_header
, info
, read_header_auto
);
1361 if (rc
== HEADER_SUCCESS
)
1363 set_next_block_after (current_header
);
1366 ERROR ((0, 0, _("This does not look like a tar archive")));
1371 try_new_volume (void)
1374 union block
*header
;
1375 enum access_mode acc
;
1377 switch (subcommand_option
)
1379 case APPEND_SUBCOMMAND
:
1380 case CAT_SUBCOMMAND
:
1381 case UPDATE_SUBCOMMAND
:
1382 acc
= ACCESS_UPDATE
;
1390 if (!new_volume (acc
))
1393 while ((status
= rmtread (archive
, record_start
->buffer
, record_size
))
1395 archive_read_error ();
1397 if (status
!= record_size
)
1398 short_read (status
);
1400 header
= find_next_block ();
1404 switch (header
->header
.typeflag
)
1408 tar_stat_init (&dummy
);
1409 if (read_header (&header
, &dummy
, read_header_x_global
)
1410 != HEADER_SUCCESS_EXTENDED
)
1412 ERROR ((0, 0, _("This does not look like a tar archive")));
1416 xheader_decode (&dummy
); /* decodes values from the global header */
1417 tar_stat_destroy (&dummy
);
1419 /* The initial global header must be immediately followed by
1420 an extended PAX header for the first member in this volume.
1421 However, in some cases tar may split volumes in the middle
1422 of a PAX header. This is incorrect, and should be fixed
1423 in the future versions. In the meantime we must be
1424 prepared to correctly list and extract such archives.
1426 If this happens, the following call to read_header returns
1427 HEADER_FAILURE, which is ignored.
1429 See also tests/multiv07.at */
1431 switch (read_header (&header
, &dummy
, read_header_auto
))
1433 case HEADER_SUCCESS
:
1434 set_next_block_after (header
);
1437 case HEADER_FAILURE
:
1441 ERROR ((0, 0, _("This does not look like a tar archive")));
1447 case GNUTYPE_VOLHDR
:
1448 if (!read_header0 (&dummy
))
1450 tar_stat_destroy (&dummy
);
1451 assign_string (&volume_label
, current_header
->header
.name
);
1452 set_next_block_after (header
);
1453 header
= find_next_block ();
1454 if (header
->header
.typeflag
!= GNUTYPE_MULTIVOL
)
1458 case GNUTYPE_MULTIVOL
:
1459 if (!read_header0 (&dummy
))
1461 tar_stat_destroy (&dummy
);
1462 assign_string (&continued_file_name
, current_header
->header
.name
);
1463 continued_file_size
=
1464 UINTMAX_FROM_HEADER (current_header
->header
.size
);
1465 continued_file_offset
=
1466 UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
);
1476 if (!continued_file_name
1477 || strcmp (continued_file_name
, bufmap_head
->file_name
))
1479 if ((archive_format
== GNU_FORMAT
|| archive_format
== OLDGNU_FORMAT
)
1480 && strlen (bufmap_head
->file_name
) >= NAME_FIELD_SIZE
1481 && strncmp (continued_file_name
, bufmap_head
->file_name
,
1482 NAME_FIELD_SIZE
) == 0)
1484 _("%s is possibly continued on this volume: header contains truncated name"),
1485 quote (bufmap_head
->file_name
)));
1488 WARN ((0, 0, _("%s is not continued on this volume"),
1489 quote (bufmap_head
->file_name
)));
1494 s
= continued_file_size
+ continued_file_offset
;
1496 if (bufmap_head
->sizetotal
!= s
|| s
< continued_file_offset
)
1498 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1499 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1500 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1502 WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
1503 quote (continued_file_name
),
1504 STRINGIFY_BIGINT (bufmap_head
->sizetotal
, totsizebuf
),
1505 STRINGIFY_BIGINT (continued_file_size
, s1buf
),
1506 STRINGIFY_BIGINT (continued_file_offset
, s2buf
)));
1510 if (bufmap_head
->sizetotal
- bufmap_head
->sizeleft
!=
1511 continued_file_offset
)
1513 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1514 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1515 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1517 WARN ((0, 0, _("This volume is out of sequence (%s - %s != %s)"),
1518 STRINGIFY_BIGINT (bufmap_head
->sizetotal
, totsizebuf
),
1519 STRINGIFY_BIGINT (bufmap_head
->sizeleft
, s1buf
),
1520 STRINGIFY_BIGINT (continued_file_offset
, s2buf
)));
1526 increase_volume_number ();
1531 #define VOLUME_TEXT " Volume "
1532 #define VOLUME_TEXT_LEN (sizeof VOLUME_TEXT - 1)
1535 drop_volume_label_suffix (const char *label
)
1538 size_t len
= strlen (label
);
1543 for (p
= label
+ len
- 1; p
> label
&& isdigit ((unsigned char) *p
); p
--)
1545 if (p
> label
&& p
- (VOLUME_TEXT_LEN
- 1) > label
)
1547 p
-= VOLUME_TEXT_LEN
- 1;
1548 if (memcmp (p
, VOLUME_TEXT
, VOLUME_TEXT_LEN
) == 0)
1550 char *s
= xmalloc ((len
= p
- label
) + 1);
1551 memcpy (s
, label
, len
);
1560 /* Check LABEL against the volume label, seen as a globbing
1561 pattern. Return true if the pattern matches. In case of failure,
1562 retry matching a volume sequence number before giving up in
1563 multi-volume mode. */
1565 check_label_pattern (const char *label
)
1568 bool result
= false;
1570 if (fnmatch (volume_label_option
, label
, 0) == 0)
1573 if (!multi_volume_option
)
1576 string
= drop_volume_label_suffix (label
);
1579 result
= fnmatch (string
, volume_label_option
, 0) == 0;
1585 /* Check if the next block contains a volume label and if this matches
1586 the one given in the command line */
1588 match_volume_label (void)
1592 union block
*label
= find_next_block ();
1595 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1596 quote (volume_label_option
)));
1597 if (label
->header
.typeflag
== GNUTYPE_VOLHDR
)
1599 if (memchr (label
->header
.name
, '\0', sizeof label
->header
.name
))
1600 assign_string (&volume_label
, label
->header
.name
);
1603 volume_label
= xmalloc (sizeof (label
->header
.name
) + 1);
1604 memcpy (volume_label
, label
->header
.name
,
1605 sizeof (label
->header
.name
));
1606 volume_label
[sizeof (label
->header
.name
)] = 0;
1609 else if (label
->header
.typeflag
== XGLTYPE
)
1611 struct tar_stat_info st
;
1612 tar_stat_init (&st
);
1613 xheader_read (&st
.xhdr
, label
,
1614 OFF_FROM_HEADER (label
->header
.size
));
1615 xheader_decode (&st
);
1616 tar_stat_destroy (&st
);
1621 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1622 quote (volume_label_option
)));
1624 if (!check_label_pattern (volume_label
))
1625 FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
1626 quote_n (0, volume_label
),
1627 quote_n (1, volume_label_option
)));
1630 /* Mark the archive with volume label STR. */
1632 _write_volume_label (const char *str
)
1634 if (archive_format
== POSIX_FORMAT
)
1635 xheader_store ("GNU.volume.label", &dummy
, str
);
1638 union block
*label
= find_next_block ();
1640 memset (label
, 0, BLOCKSIZE
);
1642 strcpy (label
->header
.name
, str
);
1643 assign_string (¤t_stat_info
.file_name
,
1644 label
->header
.name
);
1645 current_stat_info
.had_trailing_slash
=
1646 strip_trailing_slashes (current_stat_info
.file_name
);
1648 label
->header
.typeflag
= GNUTYPE_VOLHDR
;
1649 TIME_TO_CHARS (start_time
.tv_sec
, label
->header
.mtime
);
1650 finish_header (¤t_stat_info
, label
, -1);
1651 set_next_block_after (label
);
1655 #define VOL_SUFFIX "Volume"
1657 /* Add a volume label to a part of multi-volume archive */
1659 add_volume_label (void)
1661 char buf
[UINTMAX_STRSIZE_BOUND
];
1662 char *p
= STRINGIFY_BIGINT (volno
, buf
);
1663 char *s
= xmalloc (strlen (volume_label_option
) + sizeof VOL_SUFFIX
1665 sprintf (s
, "%s %s %s", volume_label_option
, VOL_SUFFIX
, p
);
1666 _write_volume_label (s
);
1671 add_chunk_header (struct bufmap
*map
)
1673 if (archive_format
== POSIX_FORMAT
)
1675 off_t block_ordinal
;
1677 struct tar_stat_info st
;
1679 memset (&st
, 0, sizeof st
);
1680 st
.orig_file_name
= st
.file_name
= map
->file_name
;
1681 st
.stat
.st_mode
= S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
;
1682 st
.stat
.st_uid
= getuid ();
1683 st
.stat
.st_gid
= getgid ();
1684 st
.orig_file_name
= xheader_format_name (&st
,
1685 "%d/GNUFileParts.%p/%f.%n",
1687 st
.file_name
= st
.orig_file_name
;
1688 st
.archive_file_size
= st
.stat
.st_size
= map
->sizeleft
;
1690 block_ordinal
= current_block_ordinal ();
1691 blk
= start_header (&st
);
1693 abort (); /* FIXME */
1694 finish_header (&st
, blk
, block_ordinal
);
1695 free (st
.orig_file_name
);
1700 /* Add a volume label to the current archive */
1702 write_volume_label (void)
1704 if (multi_volume_option
)
1705 add_volume_label ();
1707 _write_volume_label (volume_label_option
);
1710 /* Write GNU multi-volume header */
1712 gnu_add_multi_volume_header (struct bufmap
*map
)
1715 union block
*block
= find_next_block ();
1717 if (strlen (map
->file_name
) > NAME_FIELD_SIZE
)
1719 _("%s: file name too long to be stored in a GNU multivolume header, truncated"),
1720 quotearg_colon (map
->file_name
)));
1722 memset (block
, 0, BLOCKSIZE
);
1724 strncpy (block
->header
.name
, map
->file_name
, NAME_FIELD_SIZE
);
1725 block
->header
.typeflag
= GNUTYPE_MULTIVOL
;
1727 OFF_TO_CHARS (map
->sizeleft
, block
->header
.size
);
1728 OFF_TO_CHARS (map
->sizetotal
- map
->sizeleft
,
1729 block
->oldgnu_header
.offset
);
1731 tmp
= verbose_option
;
1733 finish_header (¤t_stat_info
, block
, -1);
1734 verbose_option
= tmp
;
1735 set_next_block_after (block
);
1738 /* Add a multi volume header to the current archive. The exact header format
1739 depends on the archive format. */
1741 add_multi_volume_header (struct bufmap
*map
)
1743 if (archive_format
== POSIX_FORMAT
)
1745 off_t d
= map
->sizetotal
- map
->sizeleft
;
1746 xheader_store ("GNU.volume.filename", &dummy
, map
->file_name
);
1747 xheader_store ("GNU.volume.size", &dummy
, &map
->sizeleft
);
1748 xheader_store ("GNU.volume.offset", &dummy
, &d
);
1751 gnu_add_multi_volume_header (map
);
1755 /* Low-level flush functions */
1757 /* Simple flush read (no multi-volume or label extensions) */
1759 simple_flush_read (void)
1761 size_t status
; /* result from system call */
1763 checkpoint_run (false);
1765 /* Clear the count of errors. This only applies to a single call to
1768 read_error_count
= 0; /* clear error count */
1770 if (write_archive_to_stdout
&& record_start_block
!= 0)
1772 archive
= STDOUT_FILENO
;
1773 status
= sys_write_archive_buffer ();
1774 archive
= STDIN_FILENO
;
1775 if (status
!= record_size
)
1776 archive_write_error (status
);
1781 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1782 if (status
== record_size
)
1787 if (status
== SAFE_READ_ERROR
)
1789 archive_read_error ();
1790 continue; /* try again */
1794 short_read (status
);
1797 /* Simple flush write (no multi-volume or label extensions) */
1799 simple_flush_write (size_t level
__attribute__((unused
)))
1803 status
= _flush_write ();
1804 if (status
!= record_size
)
1805 archive_write_error (status
);
1809 bytes_written
+= status
;
1814 /* GNU flush functions. These support multi-volume and archive labels in
1815 GNU and PAX archive formats. */
1818 _gnu_flush_read (void)
1820 size_t status
; /* result from system call */
1822 checkpoint_run (false);
1824 /* Clear the count of errors. This only applies to a single call to
1827 read_error_count
= 0; /* clear error count */
1829 if (write_archive_to_stdout
&& record_start_block
!= 0)
1831 archive
= STDOUT_FILENO
;
1832 status
= sys_write_archive_buffer ();
1833 archive
= STDIN_FILENO
;
1834 if (status
!= record_size
)
1835 archive_write_error (status
);
1840 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1841 if (status
== record_size
)
1847 /* The condition below used to include
1848 || (status > 0 && !read_full_records)
1849 This is incorrect since even if new_volume() succeeds, the
1850 subsequent call to rmtread will overwrite the chunk of data
1851 already read in the buffer, so the processing will fail */
1853 || (status
== SAFE_READ_ERROR
&& errno
== ENOSPC
))
1854 && multi_volume_option
)
1856 while (!try_new_volume ())
1858 if (current_block
== record_end
)
1859 /* Necessary for blocking_factor == 1 */
1863 else if (status
== SAFE_READ_ERROR
)
1865 archive_read_error ();
1870 short_read (status
);
1874 gnu_flush_read (void)
1876 flush_read_ptr
= simple_flush_read
; /* Avoid recursion */
1878 flush_read_ptr
= gnu_flush_read
;
1882 _gnu_flush_write (size_t buffer_level
)
1885 union block
*header
;
1891 status
= _flush_write ();
1892 if (status
!= record_size
&& !multi_volume_option
)
1893 archive_write_error (status
);
1898 bytes_written
+= status
;
1901 if (status
== record_size
)
1906 map
= bufmap_locate (status
);
1908 if (status
% BLOCKSIZE
)
1910 ERROR ((0, 0, _("write did not end on a block boundary")));
1911 archive_write_error (status
);
1914 /* In multi-volume mode. */
1915 /* ENXIO is for the UNIX PC. */
1916 if (status
< 0 && errno
!= ENOSPC
&& errno
!= EIO
&& errno
!= ENXIO
)
1917 archive_write_error (status
);
1919 if (!new_volume (ACCESS_WRITE
))
1922 tar_stat_destroy (&dummy
);
1924 increase_volume_number ();
1925 prev_written
+= bytes_written
;
1928 copy_ptr
= record_start
->buffer
+ status
;
1929 copy_size
= buffer_level
- status
;
1931 /* Switch to the next buffer */
1932 record_index
= !record_index
;
1937 if (volume_label_option
)
1938 add_volume_label ();
1941 add_multi_volume_header (map
);
1943 write_extended (true, &dummy
, find_next_block ());
1944 tar_stat_destroy (&dummy
);
1947 add_chunk_header (map
);
1948 header
= find_next_block ();
1949 bufmap_reset (map
, header
- record_start
);
1950 bufsize
= available_space_after (header
);
1952 while (bufsize
< copy_size
)
1954 memcpy (header
->buffer
, copy_ptr
, bufsize
);
1955 copy_ptr
+= bufsize
;
1956 copy_size
-= bufsize
;
1957 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
1958 header
= find_next_block ();
1959 bufsize
= available_space_after (header
);
1961 memcpy (header
->buffer
, copy_ptr
, copy_size
);
1962 memset (header
->buffer
+ copy_size
, 0, bufsize
- copy_size
);
1963 set_next_block_after (header
+ (copy_size
- 1) / BLOCKSIZE
);
1968 gnu_flush_write (size_t buffer_level
)
1970 flush_write_ptr
= simple_flush_write
; /* Avoid recursion */
1971 _gnu_flush_write (buffer_level
);
1972 flush_write_ptr
= gnu_flush_write
;
1984 flush_write_ptr (record_size
);
1988 open_archive (enum access_mode wanted_access
)
1990 flush_read_ptr
= gnu_flush_read
;
1991 flush_write_ptr
= gnu_flush_write
;
1993 _open_archive (wanted_access
);
1994 switch (wanted_access
)
1998 if (volume_label_option
)
1999 match_volume_label ();
2003 records_written
= 0;
2004 if (volume_label_option
)
2005 write_volume_label ();
2008 set_volume_start_time ();