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_error (*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_error (*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 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1228 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1229 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1231 WARN ((0, 0, _("This volume is out of sequence (%s - %s != %s)"),
1232 STRINGIFY_BIGINT (real_s_totsize
, totsizebuf
),
1233 STRINGIFY_BIGINT (real_s_sizeleft
, s1buf
),
1234 STRINGIFY_BIGINT (continued_file_offset
, s2buf
)));
1240 increase_volume_number ();
1245 /* Check the LABEL block against the volume label, seen as a globbing
1246 pattern. Return true if the pattern matches. In case of failure,
1247 retry matching a volume sequence number before giving up in
1248 multi-volume mode. */
1250 check_label_pattern (union block
*label
)
1255 if (! memchr (label
->header
.name
, '\0', sizeof label
->header
.name
))
1258 if (fnmatch (volume_label_option
, label
->header
.name
, 0) == 0)
1261 if (!multi_volume_option
)
1264 string
= xmalloc (strlen (volume_label_option
)
1265 + sizeof VOLUME_LABEL_APPEND
+ 1);
1266 strcpy (string
, volume_label_option
);
1267 strcat (string
, VOLUME_LABEL_APPEND
);
1268 result
= fnmatch (string
, label
->header
.name
, 0) == 0;
1273 /* Check if the next block contains a volume label and if this matches
1274 the one given in the command line */
1276 match_volume_label (void)
1278 union block
*label
= find_next_block ();
1281 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1282 quote (volume_label_option
)));
1283 if (!check_label_pattern (label
))
1284 FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
1285 quote_n (0, label
->header
.name
),
1286 quote_n (1, volume_label_option
)));
1289 /* Mark the archive with volume label STR. */
1291 _write_volume_label (const char *str
)
1293 if (archive_format
== POSIX_FORMAT
)
1294 xheader_store ("GNU.volume.label", &dummy
, str
);
1297 union block
*label
= find_next_block ();
1299 memset (label
, 0, BLOCKSIZE
);
1301 strcpy (label
->header
.name
, volume_label_option
);
1302 assign_string (¤t_stat_info
.file_name
,
1303 label
->header
.name
);
1304 current_stat_info
.had_trailing_slash
=
1305 strip_trailing_slashes (current_stat_info
.file_name
);
1307 label
->header
.typeflag
= GNUTYPE_VOLHDR
;
1308 TIME_TO_CHARS (start_time
.tv_sec
, label
->header
.mtime
);
1309 finish_header (¤t_stat_info
, label
, -1);
1310 set_next_block_after (label
);
1314 #define VOL_SUFFIX "Volume"
1316 /* Add a volume label to a part of multi-volume archive */
1318 add_volume_label (void)
1320 char buf
[UINTMAX_STRSIZE_BOUND
];
1321 char *p
= STRINGIFY_BIGINT (volno
, buf
);
1322 char *s
= xmalloc (strlen (volume_label_option
) + sizeof VOL_SUFFIX
1324 sprintf (s
, "%s %s %s", volume_label_option
, VOL_SUFFIX
, p
);
1325 _write_volume_label (s
);
1332 if (archive_format
== POSIX_FORMAT
)
1334 off_t block_ordinal
;
1336 struct tar_stat_info st
;
1337 static size_t real_s_part_no
; /* FIXME */
1340 memset (&st
, 0, sizeof st
);
1341 st
.orig_file_name
= st
.file_name
= real_s_name
;
1342 st
.stat
.st_mode
= S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
;
1343 st
.stat
.st_uid
= getuid ();
1344 st
.stat
.st_gid
= getgid ();
1345 st
.orig_file_name
= xheader_format_name (&st
,
1346 "%d/GNUFileParts.%p/%f.%n",
1348 st
.file_name
= st
.orig_file_name
;
1349 st
.archive_file_size
= st
.stat
.st_size
= real_s_sizeleft
;
1351 block_ordinal
= current_block_ordinal ();
1352 blk
= start_header (&st
);
1354 abort (); /* FIXME */
1355 finish_header (&st
, blk
, block_ordinal
);
1356 free (st
.orig_file_name
);
1361 /* Add a volume label to the current archive */
1363 write_volume_label (void)
1365 if (multi_volume_option
)
1366 add_volume_label ();
1368 _write_volume_label (volume_label_option
);
1371 /* Write GNU multi-volume header */
1373 gnu_add_multi_volume_header (void)
1376 union block
*block
= find_next_block ();
1378 if (strlen (real_s_name
) > NAME_FIELD_SIZE
)
1380 _("%s: file name too long to be stored in a GNU multivolume header, truncated"),
1381 quotearg_colon (real_s_name
)));
1383 memset (block
, 0, BLOCKSIZE
);
1385 /* FIXME: Michael P Urban writes: [a long name file] is being written
1386 when a new volume rolls around [...] Looks like the wrong value is
1387 being preserved in real_s_name, though. */
1389 strncpy (block
->header
.name
, real_s_name
, NAME_FIELD_SIZE
);
1390 block
->header
.typeflag
= GNUTYPE_MULTIVOL
;
1392 OFF_TO_CHARS (real_s_sizeleft
, block
->header
.size
);
1393 OFF_TO_CHARS (real_s_totsize
- real_s_sizeleft
,
1394 block
->oldgnu_header
.offset
);
1396 tmp
= verbose_option
;
1398 finish_header (¤t_stat_info
, block
, -1);
1399 verbose_option
= tmp
;
1400 set_next_block_after (block
);
1403 /* Add a multi volume header to the current archive. The exact header format
1404 depends on the archive format. */
1406 add_multi_volume_header (void)
1408 if (archive_format
== POSIX_FORMAT
)
1410 off_t d
= real_s_totsize
- real_s_sizeleft
;
1411 xheader_store ("GNU.volume.filename", &dummy
, real_s_name
);
1412 xheader_store ("GNU.volume.size", &dummy
, &real_s_sizeleft
);
1413 xheader_store ("GNU.volume.offset", &dummy
, &d
);
1416 gnu_add_multi_volume_header ();
1419 /* Synchronize multi-volume globals */
1421 multi_volume_sync ()
1423 if (multi_volume_option
)
1427 assign_string (&real_s_name
,
1428 safer_name_suffix (save_name
, false,
1429 absolute_names_option
));
1430 real_s_totsize
= save_totsize
;
1431 real_s_sizeleft
= save_sizeleft
;
1435 assign_string (&real_s_name
, 0);
1437 real_s_sizeleft
= 0;
1443 /* Low-level flush functions */
1445 /* Simple flush read (no multi-volume or label extensions) */
1447 simple_flush_read (void)
1449 size_t status
; /* result from system call */
1451 checkpoint_run (false);
1453 /* Clear the count of errors. This only applies to a single call to
1456 read_error_count
= 0; /* clear error count */
1458 if (write_archive_to_stdout
&& record_start_block
!= 0)
1460 archive
= STDOUT_FILENO
;
1461 status
= sys_write_archive_buffer ();
1462 archive
= STDIN_FILENO
;
1463 if (status
!= record_size
)
1464 archive_write_error (status
);
1469 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1470 if (status
== record_size
)
1475 if (status
== SAFE_READ_ERROR
)
1477 archive_read_error ();
1478 continue; /* try again */
1482 short_read (status
);
1485 /* Simple flush write (no multi-volume or label extensions) */
1487 simple_flush_write (size_t level
__attribute__((unused
)))
1491 status
= _flush_write ();
1492 if (status
!= record_size
)
1493 archive_write_error (status
);
1497 bytes_written
+= status
;
1502 /* GNU flush functions. These support multi-volume and archive labels in
1503 GNU and PAX archive formats. */
1506 _gnu_flush_read (void)
1508 size_t status
; /* result from system call */
1510 checkpoint_run (false);
1512 /* Clear the count of errors. This only applies to a single call to
1515 read_error_count
= 0; /* clear error count */
1517 if (write_archive_to_stdout
&& record_start_block
!= 0)
1519 archive
= STDOUT_FILENO
;
1520 status
= sys_write_archive_buffer ();
1521 archive
= STDIN_FILENO
;
1522 if (status
!= record_size
)
1523 archive_write_error (status
);
1526 multi_volume_sync ();
1530 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1531 if (status
== record_size
)
1537 /* The condition below used to include
1538 || (status > 0 && !read_full_records)
1539 This is incorrect since even if new_volume() succeeds, the
1540 subsequent call to rmtread will overwrite the chunk of data
1541 already read in the buffer, so the processing will fail */
1543 || (status
== SAFE_READ_ERROR
&& errno
== ENOSPC
))
1544 && multi_volume_option
)
1546 while (!try_new_volume ())
1550 else if (status
== SAFE_READ_ERROR
)
1552 archive_read_error ();
1557 short_read (status
);
1561 gnu_flush_read (void)
1563 flush_read_ptr
= simple_flush_read
; /* Avoid recursion */
1565 flush_read_ptr
= gnu_flush_read
;
1569 _gnu_flush_write (size_t buffer_level
)
1572 union block
*header
;
1577 status
= _flush_write ();
1578 if (status
!= record_size
&& !multi_volume_option
)
1579 archive_write_error (status
);
1583 bytes_written
+= status
;
1586 if (status
== record_size
)
1588 multi_volume_sync ();
1592 if (status
% BLOCKSIZE
)
1594 ERROR ((0, 0, _("write did not end on a block boundary")));
1595 archive_write_error (status
);
1598 /* In multi-volume mode. */
1599 /* ENXIO is for the UNIX PC. */
1600 if (status
< 0 && errno
!= ENOSPC
&& errno
!= EIO
&& errno
!= ENXIO
)
1601 archive_write_error (status
);
1603 real_s_sizeleft
-= status
;
1604 if (!new_volume (ACCESS_WRITE
))
1607 tar_stat_destroy (&dummy
);
1609 increase_volume_number ();
1610 prev_written
+= bytes_written
;
1613 copy_ptr
= record_start
->buffer
+ status
;
1614 copy_size
= buffer_level
- status
;
1616 /* Switch to the next buffer */
1617 record_index
= !record_index
;
1620 if (volume_label_option
)
1621 add_volume_label ();
1624 add_multi_volume_header ();
1626 write_extended (true, &dummy
, find_next_block ());
1627 tar_stat_destroy (&dummy
);
1630 add_chunk_header ();
1631 header
= find_next_block ();
1632 bufsize
= available_space_after (header
);
1633 while (bufsize
< copy_size
)
1635 memcpy (header
->buffer
, copy_ptr
, bufsize
);
1636 copy_ptr
+= bufsize
;
1637 copy_size
-= bufsize
;
1638 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
1639 header
= find_next_block ();
1640 bufsize
= available_space_after (header
);
1642 memcpy (header
->buffer
, copy_ptr
, copy_size
);
1643 memset (header
->buffer
+ copy_size
, 0, bufsize
- copy_size
);
1644 set_next_block_after (header
+ (copy_size
- 1) / BLOCKSIZE
);
1649 gnu_flush_write (size_t buffer_level
)
1651 flush_write_ptr
= simple_flush_write
; /* Avoid recursion */
1652 _gnu_flush_write (buffer_level
);
1653 flush_write_ptr
= gnu_flush_write
;
1665 flush_write_ptr (record_size
);
1669 open_archive (enum access_mode wanted_access
)
1671 flush_read_ptr
= gnu_flush_read
;
1672 flush_write_ptr
= gnu_flush_write
;
1674 _open_archive (wanted_access
);
1675 switch (wanted_access
)
1678 if (volume_label_option
)
1679 match_volume_label ();
1683 records_written
= 0;
1684 if (volume_label_option
)
1685 write_volume_label ();
1691 set_volume_start_time ();