1 /* Buffer management for tar.
3 Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
6 Written by John Gilmore, on 1985-08-25.
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 3, or (at your option) any later
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
16 Public License for more details.
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
23 #include <system-ioctl.h>
35 /* Number of retries before giving up on read. */
36 #define READ_ERROR_MAX 10
38 /* Globbing pattern to append to volume label if initial match failed. */
39 #define VOLUME_LABEL_APPEND " Volume [1-9]*"
43 static tarlong prev_written
; /* bytes written on previous volumes */
44 static tarlong bytes_written
; /* bytes written on this volume */
45 static void *record_buffer
[2]; /* allocated memory */
46 union block
*record_buffer_aligned
[2];
47 static int record_index
;
49 /* FIXME: The following variables should ideally be static to this
50 module. However, this cannot be done yet. The cleanup continues! */
52 union block
*record_start
; /* start of record of archive */
53 union block
*record_end
; /* last+1 block of archive record */
54 union block
*current_block
; /* current block of archive */
55 enum access_mode access_mode
; /* how do we handle the archive */
56 off_t records_read
; /* number of records read from this archive */
57 off_t records_written
; /* likewise, for records written */
58 extern off_t records_skipped
; /* number of records skipped at the start
59 of the archive, defined in delete.c */
61 static off_t record_start_block
; /* block ordinal at record_start */
63 /* Where we write list messages (not errors, not interactions) to. */
66 static void backspace_output (void);
68 /* PID of child program, if compress_option or remote archive access. */
69 static pid_t child_pid
;
71 /* Error recovery stuff */
72 static int read_error_count
;
74 /* Have we hit EOF yet? */
77 static bool read_full_records
= false;
79 /* We're reading, but we just read the last block and it's time to update.
82 As least EXTERN like this one as possible. (?? --gray)
83 FIXME: Either eliminate it or move it to common.h.
85 extern bool time_to_start_writing
;
87 bool write_archive_to_stdout
;
89 void (*flush_write_ptr
) (size_t);
90 void (*flush_read_ptr
) (void);
94 char *continued_file_name
;
95 uintmax_t continued_file_size
;
96 uintmax_t continued_file_offset
;
99 static int volno
= 1; /* which volume of a multi-volume tape we're
101 static int global_volno
= 1; /* volume number to print in external
104 bool write_archive_to_stdout
;
106 /* Used by flush_read and flush_write to store the real info about saved
108 static char *real_s_name
;
109 static off_t real_s_totsize
;
110 static off_t real_s_sizeleft
;
113 /* Multi-volume tracking support */
114 static char *save_name
; /* name of the file we are currently writing */
115 static off_t save_totsize
; /* total size of file we are writing, only
116 valid if save_name is nonzero */
117 static off_t save_sizeleft
; /* where we are in the file we are writing,
118 only valid if save_name is nonzero */
121 static struct tar_stat_info dummy
;
124 buffer_write_global_xheader ()
126 xheader_write_global (&dummy
.xhdr
);
130 mv_begin (struct tar_stat_info
*st
)
132 if (multi_volume_option
)
134 assign_string (&save_name
, st
->orig_file_name
);
135 save_totsize
= save_sizeleft
= st
->stat
.st_size
;
142 if (multi_volume_option
)
143 assign_string (&save_name
, 0);
147 mv_total_size (off_t size
)
153 mv_size_left (off_t size
)
155 save_sizeleft
= size
;
162 clear_read_error_count (void)
164 read_error_count
= 0;
168 /* Time-related functions */
175 gettime (&start_time
);
176 volume_start_time
= start_time
;
177 last_stat_time
= start_time
;
181 set_volume_start_time ()
183 gettime (&volume_start_time
);
184 last_stat_time
= volume_start_time
;
192 duration
+= ((now
.tv_sec
- last_stat_time
.tv_sec
)
193 + (now
.tv_nsec
- last_stat_time
.tv_nsec
) / 1e9
);
194 gettime (&last_stat_time
);
198 /* Compression detection */
210 enum compress_type type
;
217 static struct zip_magic
const magic
[] = {
219 { ct_compress
, 2, "\037\235", "compress", "-Z" },
220 { ct_gzip
, 2, "\037\213", "gzip", "-z" },
221 { ct_bzip2
, 3, "BZh", "bzip2", "-j" },
222 { ct_lzma
, 6, "\xFFLZMA", "lzma", "--lzma" }, /* FIXME: ???? */
225 #define NMAGIC (sizeof(magic)/sizeof(magic[0]))
227 #define compress_option(t) magic[t].option
228 #define compress_program(t) magic[t].program
230 /* Check if the file ARCHIVE is a compressed archive. */
232 check_compressed_archive (bool *pshort
)
234 struct zip_magic
const *p
;
241 /* Prepare global data needed for find_next_block: */
242 record_end
= record_start
; /* set up for 1st record = # 0 */
243 sfr
= read_full_records
;
244 read_full_records
= true; /* Suppress fatal error on reading a partial
246 *pshort
= find_next_block () == 0;
248 /* Restore global values */
249 read_full_records
= sfr
;
251 if (tar_checksum (record_start
, true) == HEADER_SUCCESS
)
252 /* Probably a valid header */
255 for (p
= magic
+ 1; p
< magic
+ NMAGIC
; p
++)
256 if (memcmp (record_start
->buffer
, p
->magic
, p
->length
) == 0)
262 /* Open an archive named archive_name_array[0]. Detect if it is
263 a compressed archive of known type and use corresponding decompression
266 open_compressed_archive ()
268 archive
= rmtopen (archive_name_array
[0], O_RDONLY
| O_BINARY
,
269 MODE_RW
, rsh_command_option
);
273 if (!multi_volume_option
)
276 enum compress_type type
= check_compressed_archive (&shortfile
);
281 ERROR ((0, 0, _("This does not look like a tar archive")));
285 /* FD is not needed any more */
288 hit_eof
= false; /* It might have been set by find_next_block in
289 check_compressed_archive */
291 /* Open compressed archive */
292 use_compress_program_option
= compress_program (type
);
293 child_pid
= sys_child_open_for_uncompress ();
294 read_full_records
= true;
298 record_end
= record_start
; /* set up for 1st record = # 0 */
305 print_stats (FILE *fp
, const char *text
, tarlong numbytes
)
307 char bytes
[sizeof (tarlong
) * CHAR_BIT
];
308 char abbr
[LONGEST_HUMAN_READABLE
+ 1];
309 char rate
[LONGEST_HUMAN_READABLE
+ 1];
311 int human_opts
= human_autoscale
| human_base_1024
| human_SI
| human_B
;
313 sprintf (bytes
, TARLONG_FORMAT
, numbytes
);
315 fprintf (fp
, "%s: %s (%s, %s/s)\n",
317 human_readable (numbytes
, abbr
, human_opts
, 1, 1),
318 (0 < duration
&& numbytes
/ duration
< (uintmax_t) -1
319 ? human_readable (numbytes
/ duration
, rate
, human_opts
, 1, 1)
326 switch (subcommand_option
)
328 case CREATE_SUBCOMMAND
:
330 case UPDATE_SUBCOMMAND
:
331 case APPEND_SUBCOMMAND
:
332 /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */
333 print_stats (stderr
, _("Total bytes written"),
334 prev_written
+ bytes_written
);
337 case DELETE_SUBCOMMAND
:
339 char buf
[UINTMAX_STRSIZE_BOUND
];
340 print_stats (stderr
, _("Total bytes read"),
341 records_read
* record_size
);
342 print_stats (stderr
, _("Total bytes written"),
343 prev_written
+ bytes_written
);
344 fprintf (stderr
, _("Total bytes deleted: %s\n"),
345 STRINGIFY_BIGINT ((records_read
- records_skipped
)
347 - (prev_written
+ bytes_written
), buf
));
351 case EXTRACT_SUBCOMMAND
:
352 case LIST_SUBCOMMAND
:
353 case DIFF_SUBCOMMAND
:
354 print_stats (stderr
, _("Total bytes read"),
355 records_read
* record_size
);
363 /* Compute and return the block ordinal at current_block. */
365 current_block_ordinal (void)
367 return record_start_block
+ (current_block
- record_start
);
370 /* If the EOF flag is set, reset it, as well as current_block, etc. */
377 current_block
= record_start
;
378 record_end
= record_start
+ blocking_factor
;
379 access_mode
= ACCESS_WRITE
;
383 /* Return the location of the next available input or output block.
384 Return zero for EOF. Once we have returned zero, we just keep returning
385 it, to avoid accidentally going on to the next file on the tape. */
387 find_next_block (void)
389 if (current_block
== record_end
)
394 if (current_block
== record_end
)
400 return current_block
;
403 /* Indicate that we have used all blocks up thru BLOCK. */
405 set_next_block_after (union block
*block
)
407 while (block
>= current_block
)
410 /* Do *not* flush the archive here. If we do, the same argument to
411 set_next_block_after could mean the next block (if the input record
412 is exactly one block long), which is not what is intended. */
414 if (current_block
> record_end
)
418 /* Return the number of bytes comprising the space between POINTER
419 through the end of the current buffer of blocks. This space is
420 available for filling with data, or taking data from. POINTER is
421 usually (but not always) the result of previous find_next_block call. */
423 available_space_after (union block
*pointer
)
425 return record_end
->buffer
- pointer
->buffer
;
428 /* Close file having descriptor FD, and abort if close unsuccessful. */
433 close_error (_("(pipe)"));
439 if (! record_buffer_aligned
[record_index
])
440 record_buffer_aligned
[record_index
] =
441 page_aligned_alloc (&record_buffer
[record_index
], record_size
);
443 record_start
= record_buffer_aligned
[record_index
];
444 current_block
= record_start
;
445 record_end
= record_start
+ blocking_factor
;
448 /* Open an archive file. The argument specifies whether we are
449 reading or writing, or both. */
451 _open_archive (enum access_mode wanted_access
)
453 int backed_up_flag
= 0;
455 if (record_size
== 0)
456 FATAL_ERROR ((0, 0, _("Invalid value for record_size")));
458 if (archive_names
== 0)
459 FATAL_ERROR ((0, 0, _("No archive name given")));
461 tar_stat_destroy (¤t_stat_info
);
468 /* When updating the archive, we start with reading. */
469 access_mode
= wanted_access
== ACCESS_UPDATE
? ACCESS_READ
: wanted_access
;
471 read_full_records
= read_full_records_option
;
475 if (use_compress_program_option
)
477 switch (wanted_access
)
480 child_pid
= sys_child_open_for_uncompress ();
481 read_full_records
= true;
482 record_end
= record_start
; /* set up for 1st record = # 0 */
486 child_pid
= sys_child_open_for_compress ();
490 abort (); /* Should not happen */
495 && wanted_access
== ACCESS_WRITE
496 && strcmp (archive_name_array
[0], "-") == 0)
499 else if (strcmp (archive_name_array
[0], "-") == 0)
501 read_full_records
= true; /* could be a pipe, be safe */
503 FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
505 switch (wanted_access
)
510 enum compress_type type
;
512 archive
= STDIN_FILENO
;
514 type
= check_compressed_archive (&shortfile
);
517 _("Archive is compressed. Use %s option"),
518 compress_option (type
)));
520 ERROR ((0, 0, _("This does not look like a tar archive")));
525 archive
= STDOUT_FILENO
;
526 if (!index_file_name
)
531 archive
= STDIN_FILENO
;
532 write_archive_to_stdout
= true;
533 record_end
= record_start
; /* set up for 1st record = # 0 */
534 if (!index_file_name
)
539 else if (verify_option
)
540 archive
= rmtopen (archive_name_array
[0], O_RDWR
| O_CREAT
| O_BINARY
,
541 MODE_RW
, rsh_command_option
);
543 switch (wanted_access
)
546 archive
= open_compressed_archive ();
552 maybe_backup_file (archive_name_array
[0], 1);
555 archive
= rmtcreat (archive_name_array
[0], MODE_RW
,
560 archive
= rmtopen (archive_name_array
[0],
561 O_RDWR
| O_CREAT
| O_BINARY
,
562 MODE_RW
, rsh_command_option
);
564 if (check_compressed_archive (NULL
) != ct_none
)
566 _("Cannot update compressed archives")));
571 || (! _isrmt (archive
) && !sys_get_archive_stat ()))
573 int saved_errno
= errno
;
578 open_fatal (archive_name_array
[0]);
581 sys_detect_dev_null_output ();
582 sys_save_archive_dev_ino ();
583 SET_BINARY_MODE (archive
);
585 switch (wanted_access
)
588 find_next_block (); /* read it in, check for EOF */
598 /* Perform a write to flush the buffer. */
604 checkpoint_run (true);
605 if (tape_length_option
&& tape_length_option
<= bytes_written
)
610 else if (dev_null_output
)
611 status
= record_size
;
613 status
= sys_write_archive_buffer ();
618 /* Handle write errors on the archive. Write errors are always fatal.
619 Hitting the end of a volume does not cause a write error unless the
620 write was the first record of the volume. */
622 archive_write_error (ssize_t status
)
624 /* It might be useful to know how much was written before the error
629 print_total_stats ();
633 write_fatal_details (*archive_name_cursor
, status
, record_size
);
636 /* Handle read errors on the archive. If the read should be retried,
637 return to the caller. */
639 archive_read_error (void)
641 read_error (*archive_name_cursor
);
643 if (record_start_block
== 0)
644 FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
646 /* Read error in mid archive. We retry up to READ_ERROR_MAX times and
647 then give up on reading the archive. */
649 if (read_error_count
++ > READ_ERROR_MAX
)
650 FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
655 short_read (size_t status
)
657 size_t left
; /* bytes left */
658 char *more
; /* pointer to next byte to read */
660 more
= record_start
->buffer
+ status
;
661 left
= record_size
- status
;
663 while (left
% BLOCKSIZE
!= 0
664 || (left
&& status
&& read_full_records
))
667 while ((status
= rmtread (archive
, more
, left
)) == SAFE_READ_ERROR
)
668 archive_read_error ();
673 if (! read_full_records
)
675 unsigned long rest
= record_size
- left
;
678 ngettext ("Unaligned block (%lu byte) in archive",
679 "Unaligned block (%lu bytes) in archive",
684 /* User warned us about this. Fix up. */
690 /* FIXME: for size=0, multi-volume support. On the first record, warn
691 about the problem. */
693 if (!read_full_records
&& verbose_option
> 1
694 && record_start_block
== 0 && status
!= 0)
696 unsigned long rsize
= (record_size
- left
) / BLOCKSIZE
;
698 ngettext ("Record size = %lu block",
699 "Record size = %lu blocks",
704 record_end
= record_start
+ (record_size
- left
) / BLOCKSIZE
;
708 /* Flush the current buffer to/from the archive. */
712 size_t buffer_level
= current_block
->buffer
- record_start
->buffer
;
713 record_start_block
+= record_end
- record_start
;
714 current_block
= record_start
;
715 record_end
= record_start
+ blocking_factor
;
717 if (access_mode
== ACCESS_READ
&& time_to_start_writing
)
719 access_mode
= ACCESS_WRITE
;
720 time_to_start_writing
= false;
731 flush_write_ptr (buffer_level
);
739 /* Backspace the archive descriptor by one record worth. If it's a
740 tape, MTIOCTOP will work. If it's something else, try to seek on
741 it. If we can't seek, we lose! */
743 backspace_output (void)
747 struct mtop operation
;
749 operation
.mt_op
= MTBSR
;
750 operation
.mt_count
= 1;
751 if (rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
753 if (errno
== EIO
&& rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
759 off_t position
= rmtlseek (archive
, (off_t
) 0, SEEK_CUR
);
761 /* Seek back to the beginning of this record and start writing there. */
763 position
-= record_size
;
766 if (rmtlseek (archive
, position
, SEEK_SET
) != position
)
768 /* Lseek failed. Try a different method. */
771 _("Cannot backspace archive file; it may be unreadable without -i")));
773 /* Replace the first part of the record with NULs. */
775 if (record_start
->buffer
!= output_start
)
776 memset (record_start
->buffer
, 0,
777 output_start
- record_start
->buffer
);
783 seek_archive (off_t size
)
785 off_t start
= current_block_ordinal ();
788 off_t skipped
= (blocking_factor
- (current_block
- record_start
));
790 size
-= skipped
* BLOCKSIZE
;
792 if (size
< record_size
)
796 /* Compute number of records to skip */
797 nrec
= size
/ record_size
;
798 offset
= rmtlseek (archive
, nrec
* record_size
, SEEK_CUR
);
802 if (offset
% record_size
)
803 FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary")));
805 /* Convert to number of records */
807 /* Compute number of skipped blocks */
808 nblk
= offset
- start
;
810 /* Update buffering info */
811 records_read
+= nblk
/ blocking_factor
;
812 record_start_block
= offset
- blocking_factor
;
813 current_block
= record_end
;
818 /* Close the archive file. */
822 if (time_to_start_writing
|| access_mode
== ACCESS_WRITE
)
825 if (current_block
> record_start
)
829 sys_drain_input_pipe ();
835 if (rmtclose (archive
) != 0)
836 close_warn (*archive_name_cursor
);
838 sys_wait_for_child (child_pid
);
840 tar_stat_destroy (¤t_stat_info
);
845 free (record_buffer
[0]);
846 free (record_buffer
[1]);
849 /* Called to initialize the global volume number. */
851 init_volume_number (void)
853 FILE *file
= fopen (volno_file_option
, "r");
857 if (fscanf (file
, "%d", &global_volno
) != 1
859 FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"),
860 quotearg_colon (volno_file_option
)));
862 read_error (volno_file_option
);
863 if (fclose (file
) != 0)
864 close_error (volno_file_option
);
866 else if (errno
!= ENOENT
)
867 open_error (volno_file_option
);
870 /* Called to write out the closing global volume number. */
872 closeout_volume_number (void)
874 FILE *file
= fopen (volno_file_option
, "w");
878 fprintf (file
, "%d\n", global_volno
);
880 write_error (volno_file_option
);
881 if (fclose (file
) != 0)
882 close_error (volno_file_option
);
885 open_error (volno_file_option
);
890 increase_volume_number ()
893 if (global_volno
< 0)
894 FATAL_ERROR ((0, 0, _("Volume number overflow")));
899 change_tape_menu (FILE *read_file
)
901 char *input_buffer
= NULL
;
907 fputc ('\007', stderr
);
909 _("Prepare volume #%d for %s and hit return: "),
910 global_volno
+ 1, quote (*archive_name_cursor
));
913 if (getline (&input_buffer
, &size
, read_file
) <= 0)
915 WARN ((0, 0, _("EOF where user reply was expected")));
917 if (subcommand_option
!= EXTRACT_SUBCOMMAND
918 && subcommand_option
!= LIST_SUBCOMMAND
919 && subcommand_option
!= DIFF_SUBCOMMAND
)
920 WARN ((0, 0, _("WARNING: Archive is incomplete")));
925 if (input_buffer
[0] == '\n'
926 || input_buffer
[0] == 'y'
927 || input_buffer
[0] == 'Y')
930 switch (input_buffer
[0])
934 fprintf (stderr
, _("\
935 n name Give a new file name for the next (and subsequent) volume(s)\n\
937 y or newline Continue operation\n"));
938 if (!restrict_option
)
939 fprintf (stderr
, _(" ! Spawn a subshell\n"));
940 fprintf (stderr
, _(" ? Print this list\n"));
947 WARN ((0, 0, _("No new volume; exiting.\n")));
949 if (subcommand_option
!= EXTRACT_SUBCOMMAND
950 && subcommand_option
!= LIST_SUBCOMMAND
951 && subcommand_option
!= DIFF_SUBCOMMAND
)
952 WARN ((0, 0, _("WARNING: Archive is incomplete")));
957 /* Get new file name. */
963 for (name
= input_buffer
+ 1;
964 *name
== ' ' || *name
== '\t';
968 for (cursor
= name
; *cursor
&& *cursor
!= '\n'; cursor
++)
974 /* FIXME: the following allocation is never reclaimed. */
975 *archive_name_cursor
= xstrdup (name
);
979 fprintf (stderr
, "%s",
980 _("File name not specified. Try again.\n"));
985 if (!restrict_option
)
993 fprintf (stderr
, _("Invalid input. Type ? for help.\n"));
999 /* We've hit the end of the old volume. Close it and open the next one.
1000 Return nonzero on success.
1003 new_volume (enum access_mode mode
)
1005 static FILE *read_file
;
1009 if (!read_file
&& !info_script_option
)
1010 /* FIXME: if fopen is used, it will never be closed. */
1011 read_file
= archive
== STDIN_FILENO
? fopen (TTY_NAME
, "r") : stdin
;
1018 assign_string (&volume_label
, NULL
);
1019 assign_string (&continued_file_name
, NULL
);
1020 continued_file_size
= continued_file_offset
= 0;
1021 current_block
= record_start
;
1023 if (rmtclose (archive
) != 0)
1024 close_warn (*archive_name_cursor
);
1026 archive_name_cursor
++;
1027 if (archive_name_cursor
== archive_name_array
+ archive_names
)
1029 archive_name_cursor
= archive_name_array
;
1037 /* We have to prompt from now on. */
1039 if (info_script_option
)
1041 if (volno_file_option
)
1042 closeout_volume_number ();
1043 if (sys_exec_info_script (archive_name_cursor
, global_volno
+1))
1044 FATAL_ERROR ((0, 0, _("%s command failed"),
1045 quote (info_script_option
)));
1048 change_tape_menu (read_file
);
1051 if (strcmp (archive_name_cursor
[0], "-") == 0)
1053 read_full_records
= true;
1054 archive
= STDIN_FILENO
;
1056 else if (verify_option
)
1057 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1058 rsh_command_option
);
1063 archive
= rmtopen (*archive_name_cursor
, O_RDONLY
, MODE_RW
,
1064 rsh_command_option
);
1069 maybe_backup_file (*archive_name_cursor
, 1);
1070 archive
= rmtcreat (*archive_name_cursor
, MODE_RW
,
1071 rsh_command_option
);
1075 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1076 rsh_command_option
);
1082 open_warn (*archive_name_cursor
);
1083 if (!verify_option
&& mode
== ACCESS_WRITE
&& backup_option
)
1084 undo_last_backup ();
1089 SET_BINARY_MODE (archive
);
1095 read_header0 (struct tar_stat_info
*info
)
1097 enum read_header rc
;
1099 tar_stat_init (info
);
1100 rc
= read_header_primitive (false, info
);
1101 if (rc
== HEADER_SUCCESS
)
1103 set_next_block_after (current_header
);
1106 ERROR ((0, 0, _("This does not look like a tar archive")));
1114 union block
*header
;
1115 enum access_mode acc
;
1117 switch (subcommand_option
)
1119 case APPEND_SUBCOMMAND
:
1120 case CAT_SUBCOMMAND
:
1121 case UPDATE_SUBCOMMAND
:
1122 acc
= ACCESS_UPDATE
;
1130 if (!new_volume (acc
))
1133 while ((status
= rmtread (archive
, record_start
->buffer
, record_size
))
1135 archive_read_error ();
1137 if (status
!= record_size
)
1138 short_read (status
);
1140 header
= find_next_block ();
1144 switch (header
->header
.typeflag
)
1148 if (!read_header0 (&dummy
))
1150 xheader_decode (&dummy
); /* decodes values from the global header */
1151 tar_stat_destroy (&dummy
);
1154 /* We have read the extended header of the first member in
1155 this volume. Put it back, so next read_header works as
1157 current_block
= record_start
;
1162 case GNUTYPE_VOLHDR
:
1163 if (!read_header0 (&dummy
))
1165 tar_stat_destroy (&dummy
);
1166 assign_string (&volume_label
, current_header
->header
.name
);
1167 set_next_block_after (header
);
1168 header
= find_next_block ();
1169 if (header
->header
.typeflag
!= GNUTYPE_MULTIVOL
)
1173 case GNUTYPE_MULTIVOL
:
1174 if (!read_header0 (&dummy
))
1176 tar_stat_destroy (&dummy
);
1177 assign_string (&continued_file_name
, current_header
->header
.name
);
1178 continued_file_size
=
1179 UINTMAX_FROM_HEADER (current_header
->header
.size
);
1180 continued_file_offset
=
1181 UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
);
1191 if (!continued_file_name
1192 || strcmp (continued_file_name
, real_s_name
))
1194 if ((archive_format
== GNU_FORMAT
|| archive_format
== OLDGNU_FORMAT
)
1195 && strlen (real_s_name
) >= NAME_FIELD_SIZE
1196 && strncmp (continued_file_name
, real_s_name
,
1197 NAME_FIELD_SIZE
) == 0)
1199 _("%s is possibly continued on this volume: header contains truncated name"),
1200 quote (real_s_name
)));
1203 WARN ((0, 0, _("%s is not continued on this volume"),
1204 quote (real_s_name
)));
1209 s
= continued_file_size
+ continued_file_offset
;
1211 if (real_s_totsize
!= s
|| s
< continued_file_offset
)
1213 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1214 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1215 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1217 WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
1218 quote (continued_file_name
),
1219 STRINGIFY_BIGINT (save_totsize
, totsizebuf
),
1220 STRINGIFY_BIGINT (continued_file_size
, s1buf
),
1221 STRINGIFY_BIGINT (continued_file_offset
, s2buf
)));
1225 if (real_s_totsize
- real_s_sizeleft
!= continued_file_offset
)
1227 WARN ((0, 0, _("This volume is out of sequence")));
1232 increase_volume_number ();
1237 /* Check the LABEL block against the volume label, seen as a globbing
1238 pattern. Return true if the pattern matches. In case of failure,
1239 retry matching a volume sequence number before giving up in
1240 multi-volume mode. */
1242 check_label_pattern (union block
*label
)
1247 if (! memchr (label
->header
.name
, '\0', sizeof label
->header
.name
))
1250 if (fnmatch (volume_label_option
, label
->header
.name
, 0) == 0)
1253 if (!multi_volume_option
)
1256 string
= xmalloc (strlen (volume_label_option
)
1257 + sizeof VOLUME_LABEL_APPEND
+ 1);
1258 strcpy (string
, volume_label_option
);
1259 strcat (string
, VOLUME_LABEL_APPEND
);
1260 result
= fnmatch (string
, label
->header
.name
, 0) == 0;
1265 /* Check if the next block contains a volume label and if this matches
1266 the one given in the command line */
1268 match_volume_label (void)
1270 union block
*label
= find_next_block ();
1273 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1274 quote (volume_label_option
)));
1275 if (!check_label_pattern (label
))
1276 FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
1277 quote_n (0, label
->header
.name
),
1278 quote_n (1, volume_label_option
)));
1281 /* Mark the archive with volume label STR. */
1283 _write_volume_label (const char *str
)
1285 if (archive_format
== POSIX_FORMAT
)
1286 xheader_store ("GNU.volume.label", &dummy
, str
);
1289 union block
*label
= find_next_block ();
1291 memset (label
, 0, BLOCKSIZE
);
1293 strcpy (label
->header
.name
, volume_label_option
);
1294 assign_string (¤t_stat_info
.file_name
,
1295 label
->header
.name
);
1296 current_stat_info
.had_trailing_slash
=
1297 strip_trailing_slashes (current_stat_info
.file_name
);
1299 label
->header
.typeflag
= GNUTYPE_VOLHDR
;
1300 TIME_TO_CHARS (start_time
.tv_sec
, label
->header
.mtime
);
1301 finish_header (¤t_stat_info
, label
, -1);
1302 set_next_block_after (label
);
1306 #define VOL_SUFFIX "Volume"
1308 /* Add a volume label to a part of multi-volume archive */
1310 add_volume_label (void)
1312 char buf
[UINTMAX_STRSIZE_BOUND
];
1313 char *p
= STRINGIFY_BIGINT (volno
, buf
);
1314 char *s
= xmalloc (strlen (volume_label_option
) + sizeof VOL_SUFFIX
1316 sprintf (s
, "%s %s %s", volume_label_option
, VOL_SUFFIX
, p
);
1317 _write_volume_label (s
);
1324 if (archive_format
== POSIX_FORMAT
)
1326 off_t block_ordinal
;
1328 struct tar_stat_info st
;
1329 static size_t real_s_part_no
; /* FIXME */
1332 memset (&st
, 0, sizeof st
);
1333 st
.orig_file_name
= st
.file_name
= real_s_name
;
1334 st
.stat
.st_mode
= S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
;
1335 st
.stat
.st_uid
= getuid ();
1336 st
.stat
.st_gid
= getgid ();
1337 st
.orig_file_name
= xheader_format_name (&st
,
1338 "%d/GNUFileParts.%p/%f.%n",
1340 st
.file_name
= st
.orig_file_name
;
1341 st
.archive_file_size
= st
.stat
.st_size
= real_s_sizeleft
;
1343 block_ordinal
= current_block_ordinal ();
1344 blk
= start_header (&st
);
1346 abort (); /* FIXME */
1347 finish_header (&st
, blk
, block_ordinal
);
1348 free (st
.orig_file_name
);
1353 /* Add a volume label to the current archive */
1355 write_volume_label (void)
1357 if (multi_volume_option
)
1358 add_volume_label ();
1360 _write_volume_label (volume_label_option
);
1363 /* Write GNU multi-volume header */
1365 gnu_add_multi_volume_header (void)
1368 union block
*block
= find_next_block ();
1370 if (strlen (real_s_name
) > NAME_FIELD_SIZE
)
1372 _("%s: file name too long to be stored in a GNU multivolume header, truncated"),
1373 quotearg_colon (real_s_name
)));
1375 memset (block
, 0, BLOCKSIZE
);
1377 /* FIXME: Michael P Urban writes: [a long name file] is being written
1378 when a new volume rolls around [...] Looks like the wrong value is
1379 being preserved in real_s_name, though. */
1381 strncpy (block
->header
.name
, real_s_name
, NAME_FIELD_SIZE
);
1382 block
->header
.typeflag
= GNUTYPE_MULTIVOL
;
1384 OFF_TO_CHARS (real_s_sizeleft
, block
->header
.size
);
1385 OFF_TO_CHARS (real_s_totsize
- real_s_sizeleft
,
1386 block
->oldgnu_header
.offset
);
1388 tmp
= verbose_option
;
1390 finish_header (¤t_stat_info
, block
, -1);
1391 verbose_option
= tmp
;
1392 set_next_block_after (block
);
1395 /* Add a multi volume header to the current archive. The exact header format
1396 depends on the archive format. */
1398 add_multi_volume_header (void)
1400 if (archive_format
== POSIX_FORMAT
)
1402 off_t d
= real_s_totsize
- real_s_sizeleft
;
1403 xheader_store ("GNU.volume.filename", &dummy
, real_s_name
);
1404 xheader_store ("GNU.volume.size", &dummy
, &real_s_sizeleft
);
1405 xheader_store ("GNU.volume.offset", &dummy
, &d
);
1408 gnu_add_multi_volume_header ();
1411 /* Synchronize multi-volume globals */
1413 multi_volume_sync ()
1415 if (multi_volume_option
)
1419 assign_string (&real_s_name
,
1420 safer_name_suffix (save_name
, false,
1421 absolute_names_option
));
1422 real_s_totsize
= save_totsize
;
1423 real_s_sizeleft
= save_sizeleft
;
1427 assign_string (&real_s_name
, 0);
1429 real_s_sizeleft
= 0;
1435 /* Low-level flush functions */
1437 /* Simple flush read (no multi-volume or label extensions) */
1439 simple_flush_read (void)
1441 size_t status
; /* result from system call */
1443 checkpoint_run (false);
1445 /* Clear the count of errors. This only applies to a single call to
1448 read_error_count
= 0; /* clear error count */
1450 if (write_archive_to_stdout
&& record_start_block
!= 0)
1452 archive
= STDOUT_FILENO
;
1453 status
= sys_write_archive_buffer ();
1454 archive
= STDIN_FILENO
;
1455 if (status
!= record_size
)
1456 archive_write_error (status
);
1461 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1462 if (status
== record_size
)
1467 if (status
== SAFE_READ_ERROR
)
1469 archive_read_error ();
1470 continue; /* try again */
1474 short_read (status
);
1477 /* Simple flush write (no multi-volume or label extensions) */
1479 simple_flush_write (size_t level
__attribute__((unused
)))
1483 status
= _flush_write ();
1484 if (status
!= record_size
)
1485 archive_write_error (status
);
1489 bytes_written
+= status
;
1494 /* GNU flush functions. These support multi-volume and archive labels in
1495 GNU and PAX archive formats. */
1498 _gnu_flush_read (void)
1500 size_t status
; /* result from system call */
1502 checkpoint_run (false);
1504 /* Clear the count of errors. This only applies to a single call to
1507 read_error_count
= 0; /* clear error count */
1509 if (write_archive_to_stdout
&& record_start_block
!= 0)
1511 archive
= STDOUT_FILENO
;
1512 status
= sys_write_archive_buffer ();
1513 archive
= STDIN_FILENO
;
1514 if (status
!= record_size
)
1515 archive_write_error (status
);
1518 multi_volume_sync ();
1522 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1523 if (status
== record_size
)
1529 /* The condition below used to include
1530 || (status > 0 && !read_full_records)
1531 This is incorrect since even if new_volume() succeeds, the
1532 subsequent call to rmtread will overwrite the chunk of data
1533 already read in the buffer, so the processing will fail */
1535 || (status
== SAFE_READ_ERROR
&& errno
== ENOSPC
))
1536 && multi_volume_option
)
1538 while (!try_new_volume ())
1542 else if (status
== SAFE_READ_ERROR
)
1544 archive_read_error ();
1549 short_read (status
);
1553 gnu_flush_read (void)
1555 flush_read_ptr
= simple_flush_read
; /* Avoid recursion */
1557 flush_read_ptr
= gnu_flush_read
;
1561 _gnu_flush_write (size_t buffer_level
)
1564 union block
*header
;
1569 status
= _flush_write ();
1570 if (status
!= record_size
&& !multi_volume_option
)
1571 archive_write_error (status
);
1575 bytes_written
+= status
;
1578 if (status
== record_size
)
1580 multi_volume_sync ();
1584 /* In multi-volume mode. */
1585 /* ENXIO is for the UNIX PC. */
1586 if (status
< 0 && errno
!= ENOSPC
&& errno
!= EIO
&& errno
!= ENXIO
)
1587 archive_write_error (status
);
1589 if (!new_volume (ACCESS_WRITE
))
1592 tar_stat_destroy (&dummy
);
1594 increase_volume_number ();
1595 prev_written
+= bytes_written
;
1598 copy_ptr
= record_start
->buffer
+ status
;
1599 copy_size
= buffer_level
- status
;
1600 /* Switch to the next buffer */
1601 record_index
= !record_index
;
1604 if (volume_label_option
)
1605 add_volume_label ();
1608 add_multi_volume_header ();
1610 write_extended (true, &dummy
, find_next_block ());
1611 tar_stat_destroy (&dummy
);
1614 add_chunk_header ();
1615 header
= find_next_block ();
1616 bufsize
= available_space_after (header
);
1617 while (bufsize
< copy_size
)
1619 memcpy (header
->buffer
, copy_ptr
, bufsize
);
1620 copy_ptr
+= bufsize
;
1621 copy_size
-= bufsize
;
1622 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
1623 header
= find_next_block ();
1624 bufsize
= available_space_after (header
);
1626 memcpy (header
->buffer
, copy_ptr
, copy_size
);
1627 memset (header
->buffer
+ copy_size
, 0, bufsize
- copy_size
);
1628 set_next_block_after (header
+ (copy_size
- 1) / BLOCKSIZE
);
1633 gnu_flush_write (size_t buffer_level
)
1635 flush_write_ptr
= simple_flush_write
; /* Avoid recursion */
1636 _gnu_flush_write (buffer_level
);
1637 flush_write_ptr
= gnu_flush_write
;
1649 flush_write_ptr (record_size
);
1653 open_archive (enum access_mode wanted_access
)
1655 flush_read_ptr
= gnu_flush_read
;
1656 flush_write_ptr
= gnu_flush_write
;
1658 _open_archive (wanted_access
);
1659 switch (wanted_access
)
1662 if (volume_label_option
)
1663 match_volume_label ();
1667 records_written
= 0;
1668 if (volume_label_option
)
1669 write_volume_label ();
1675 set_volume_start_time ();