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", "-a" }, /* 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 ()
234 struct zip_magic
const *p
;
236 bool short_file
= false;
238 /* Prepare global data needed for find_next_block: */
239 record_end
= record_start
; /* set up for 1st record = # 0 */
240 sfr
= read_full_records
;
241 read_full_records
= true; /* Suppress fatal error on reading a partial
243 if (find_next_block () == 0)
246 /* Restore global values */
247 read_full_records
= sfr
;
249 if (tar_checksum (record_start
, true) == HEADER_SUCCESS
)
250 /* Probably a valid header */
253 for (p
= magic
+ 1; p
< magic
+ NMAGIC
; p
++)
254 if (memcmp (record_start
->buffer
, p
->magic
, p
->length
) == 0)
258 ERROR ((0, 0, _("This does not look like a tar archive")));
263 /* Open an archive named archive_name_array[0]. Detect if it is
264 a compressed archive of known type and use corresponding decompression
267 open_compressed_archive ()
269 archive
= rmtopen (archive_name_array
[0], O_RDONLY
| O_BINARY
,
270 MODE_RW
, rsh_command_option
);
274 if (!multi_volume_option
)
276 enum compress_type type
= check_compressed_archive ();
281 /* FD is not needed any more */
284 hit_eof
= false; /* It might have been set by find_next_block in
285 check_compressed_archive */
287 /* Open compressed archive */
288 use_compress_program_option
= compress_program (type
);
289 child_pid
= sys_child_open_for_uncompress ();
290 read_full_records
= true;
294 record_end
= record_start
; /* set up for 1st record = # 0 */
301 print_stats (FILE *fp
, const char *text
, tarlong numbytes
)
303 char bytes
[sizeof (tarlong
) * CHAR_BIT
];
304 char abbr
[LONGEST_HUMAN_READABLE
+ 1];
305 char rate
[LONGEST_HUMAN_READABLE
+ 1];
307 int human_opts
= human_autoscale
| human_base_1024
| human_SI
| human_B
;
309 sprintf (bytes
, TARLONG_FORMAT
, numbytes
);
311 fprintf (fp
, "%s: %s (%s, %s/s)\n",
313 human_readable (numbytes
, abbr
, human_opts
, 1, 1),
314 (0 < duration
&& numbytes
/ duration
< (uintmax_t) -1
315 ? human_readable (numbytes
/ duration
, rate
, human_opts
, 1, 1)
322 switch (subcommand_option
)
324 case CREATE_SUBCOMMAND
:
326 case UPDATE_SUBCOMMAND
:
327 case APPEND_SUBCOMMAND
:
328 /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */
329 print_stats (stderr
, _("Total bytes written"),
330 prev_written
+ bytes_written
);
333 case DELETE_SUBCOMMAND
:
335 char buf
[UINTMAX_STRSIZE_BOUND
];
336 print_stats (stderr
, _("Total bytes read"),
337 records_read
* record_size
);
338 print_stats (stderr
, _("Total bytes written"),
339 prev_written
+ bytes_written
);
340 fprintf (stderr
, _("Total bytes deleted: %s\n"),
341 STRINGIFY_BIGINT ((records_read
- records_skipped
)
343 - (prev_written
+ bytes_written
), buf
));
347 case EXTRACT_SUBCOMMAND
:
348 case LIST_SUBCOMMAND
:
349 case DIFF_SUBCOMMAND
:
350 print_stats (stderr
, _("Total bytes read"),
351 records_read
* record_size
);
359 /* Compute and return the block ordinal at current_block. */
361 current_block_ordinal (void)
363 return record_start_block
+ (current_block
- record_start
);
366 /* If the EOF flag is set, reset it, as well as current_block, etc. */
373 current_block
= record_start
;
374 record_end
= record_start
+ blocking_factor
;
375 access_mode
= ACCESS_WRITE
;
379 /* Return the location of the next available input or output block.
380 Return zero for EOF. Once we have returned zero, we just keep returning
381 it, to avoid accidentally going on to the next file on the tape. */
383 find_next_block (void)
385 if (current_block
== record_end
)
390 if (current_block
== record_end
)
396 return current_block
;
399 /* Indicate that we have used all blocks up thru BLOCK. */
401 set_next_block_after (union block
*block
)
403 while (block
>= current_block
)
406 /* Do *not* flush the archive here. If we do, the same argument to
407 set_next_block_after could mean the next block (if the input record
408 is exactly one block long), which is not what is intended. */
410 if (current_block
> record_end
)
414 /* Return the number of bytes comprising the space between POINTER
415 through the end of the current buffer of blocks. This space is
416 available for filling with data, or taking data from. POINTER is
417 usually (but not always) the result of previous find_next_block call. */
419 available_space_after (union block
*pointer
)
421 return record_end
->buffer
- pointer
->buffer
;
424 /* Close file having descriptor FD, and abort if close unsuccessful. */
429 close_error (_("(pipe)"));
435 if (! record_buffer_aligned
[record_index
])
436 record_buffer_aligned
[record_index
] =
437 page_aligned_alloc (&record_buffer
[record_index
], record_size
);
439 record_start
= record_buffer_aligned
[record_index
];
440 current_block
= record_start
;
441 record_end
= record_start
+ blocking_factor
;
444 /* Open an archive file. The argument specifies whether we are
445 reading or writing, or both. */
447 _open_archive (enum access_mode wanted_access
)
449 int backed_up_flag
= 0;
451 if (record_size
== 0)
452 FATAL_ERROR ((0, 0, _("Invalid value for record_size")));
454 if (archive_names
== 0)
455 FATAL_ERROR ((0, 0, _("No archive name given")));
457 tar_stat_destroy (¤t_stat_info
);
464 /* When updating the archive, we start with reading. */
465 access_mode
= wanted_access
== ACCESS_UPDATE
? ACCESS_READ
: wanted_access
;
467 read_full_records
= read_full_records_option
;
471 if (use_compress_program_option
)
473 switch (wanted_access
)
476 child_pid
= sys_child_open_for_uncompress ();
477 read_full_records
= true;
478 record_end
= record_start
; /* set up for 1st record = # 0 */
482 child_pid
= sys_child_open_for_compress ();
486 abort (); /* Should not happen */
491 && wanted_access
== ACCESS_WRITE
492 && strcmp (archive_name_array
[0], "-") == 0)
495 else if (strcmp (archive_name_array
[0], "-") == 0)
497 read_full_records
= true; /* could be a pipe, be safe */
499 FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
501 switch (wanted_access
)
505 enum compress_type type
;
507 archive
= STDIN_FILENO
;
509 type
= check_compressed_archive ();
512 _("Archive is compressed. Use %s option"),
513 compress_option (type
)));
518 archive
= STDOUT_FILENO
;
519 if (!index_file_name
)
524 archive
= STDIN_FILENO
;
525 write_archive_to_stdout
= true;
526 record_end
= record_start
; /* set up for 1st record = # 0 */
527 if (!index_file_name
)
532 else if (verify_option
)
533 archive
= rmtopen (archive_name_array
[0], O_RDWR
| O_CREAT
| O_BINARY
,
534 MODE_RW
, rsh_command_option
);
536 switch (wanted_access
)
539 archive
= open_compressed_archive ();
545 maybe_backup_file (archive_name_array
[0], 1);
548 archive
= rmtcreat (archive_name_array
[0], MODE_RW
,
553 archive
= rmtopen (archive_name_array
[0],
554 O_RDWR
| O_CREAT
| O_BINARY
,
555 MODE_RW
, rsh_command_option
);
557 if (check_compressed_archive () != ct_none
)
559 _("Cannot update compressed archives")));
564 || (! _isrmt (archive
) && !sys_get_archive_stat ()))
566 int saved_errno
= errno
;
571 open_fatal (archive_name_array
[0]);
574 sys_detect_dev_null_output ();
575 sys_save_archive_dev_ino ();
576 SET_BINARY_MODE (archive
);
578 switch (wanted_access
)
581 find_next_block (); /* read it in, check for EOF */
591 /* Perform a write to flush the buffer. */
597 checkpoint_run (true);
598 if (tape_length_option
&& tape_length_option
<= bytes_written
)
603 else if (dev_null_output
)
604 status
= record_size
;
606 status
= sys_write_archive_buffer ();
611 /* Handle write errors on the archive. Write errors are always fatal.
612 Hitting the end of a volume does not cause a write error unless the
613 write was the first record of the volume. */
615 archive_write_error (ssize_t status
)
617 /* It might be useful to know how much was written before the error
622 print_total_stats ();
626 write_fatal_details (*archive_name_cursor
, status
, record_size
);
629 /* Handle read errors on the archive. If the read should be retried,
630 return to the caller. */
632 archive_read_error (void)
634 read_error (*archive_name_cursor
);
636 if (record_start_block
== 0)
637 FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
639 /* Read error in mid archive. We retry up to READ_ERROR_MAX times and
640 then give up on reading the archive. */
642 if (read_error_count
++ > READ_ERROR_MAX
)
643 FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
648 short_read (size_t status
)
650 size_t left
; /* bytes left */
651 char *more
; /* pointer to next byte to read */
653 more
= record_start
->buffer
+ status
;
654 left
= record_size
- status
;
656 while (left
% BLOCKSIZE
!= 0
657 || (left
&& status
&& read_full_records
))
660 while ((status
= rmtread (archive
, more
, left
)) == SAFE_READ_ERROR
)
661 archive_read_error ();
666 if (! read_full_records
)
668 unsigned long rest
= record_size
- left
;
671 ngettext ("Unaligned block (%lu byte) in archive",
672 "Unaligned block (%lu bytes) in archive",
677 /* User warned us about this. Fix up. */
683 /* FIXME: for size=0, multi-volume support. On the first record, warn
684 about the problem. */
686 if (!read_full_records
&& verbose_option
> 1
687 && record_start_block
== 0 && status
!= 0)
689 unsigned long rsize
= (record_size
- left
) / BLOCKSIZE
;
691 ngettext ("Record size = %lu block",
692 "Record size = %lu blocks",
697 record_end
= record_start
+ (record_size
- left
) / BLOCKSIZE
;
701 /* Flush the current buffer to/from the archive. */
705 size_t buffer_level
= current_block
->buffer
- record_start
->buffer
;
706 record_start_block
+= record_end
- record_start
;
707 current_block
= record_start
;
708 record_end
= record_start
+ blocking_factor
;
710 if (access_mode
== ACCESS_READ
&& time_to_start_writing
)
712 access_mode
= ACCESS_WRITE
;
713 time_to_start_writing
= false;
724 flush_write_ptr (buffer_level
);
732 /* Backspace the archive descriptor by one record worth. If it's a
733 tape, MTIOCTOP will work. If it's something else, try to seek on
734 it. If we can't seek, we lose! */
736 backspace_output (void)
740 struct mtop operation
;
742 operation
.mt_op
= MTBSR
;
743 operation
.mt_count
= 1;
744 if (rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
746 if (errno
== EIO
&& rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
752 off_t position
= rmtlseek (archive
, (off_t
) 0, SEEK_CUR
);
754 /* Seek back to the beginning of this record and start writing there. */
756 position
-= record_size
;
759 if (rmtlseek (archive
, position
, SEEK_SET
) != position
)
761 /* Lseek failed. Try a different method. */
764 _("Cannot backspace archive file; it may be unreadable without -i")));
766 /* Replace the first part of the record with NULs. */
768 if (record_start
->buffer
!= output_start
)
769 memset (record_start
->buffer
, 0,
770 output_start
- record_start
->buffer
);
776 seek_archive (off_t size
)
778 off_t start
= current_block_ordinal ();
781 off_t skipped
= (blocking_factor
- (current_block
- record_start
));
783 size
-= skipped
* BLOCKSIZE
;
785 if (size
< record_size
)
789 /* Compute number of records to skip */
790 nrec
= size
/ record_size
;
791 offset
= rmtlseek (archive
, nrec
* record_size
, SEEK_CUR
);
795 if (offset
% record_size
)
796 FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary")));
798 /* Convert to number of records */
800 /* Compute number of skipped blocks */
801 nblk
= offset
- start
;
803 /* Update buffering info */
804 records_read
+= nblk
/ blocking_factor
;
805 record_start_block
= offset
- blocking_factor
;
806 current_block
= record_end
;
811 /* Close the archive file. */
815 if (time_to_start_writing
|| access_mode
== ACCESS_WRITE
)
818 if (current_block
> record_start
)
822 sys_drain_input_pipe ();
828 if (rmtclose (archive
) != 0)
829 close_warn (*archive_name_cursor
);
831 sys_wait_for_child (child_pid
);
833 tar_stat_destroy (¤t_stat_info
);
838 free (record_buffer
[0]);
839 free (record_buffer
[1]);
842 /* Called to initialize the global volume number. */
844 init_volume_number (void)
846 FILE *file
= fopen (volno_file_option
, "r");
850 if (fscanf (file
, "%d", &global_volno
) != 1
852 FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"),
853 quotearg_colon (volno_file_option
)));
855 read_error (volno_file_option
);
856 if (fclose (file
) != 0)
857 close_error (volno_file_option
);
859 else if (errno
!= ENOENT
)
860 open_error (volno_file_option
);
863 /* Called to write out the closing global volume number. */
865 closeout_volume_number (void)
867 FILE *file
= fopen (volno_file_option
, "w");
871 fprintf (file
, "%d\n", global_volno
);
873 write_error (volno_file_option
);
874 if (fclose (file
) != 0)
875 close_error (volno_file_option
);
878 open_error (volno_file_option
);
883 increase_volume_number ()
886 if (global_volno
< 0)
887 FATAL_ERROR ((0, 0, _("Volume number overflow")));
892 change_tape_menu (FILE *read_file
)
894 char *input_buffer
= NULL
;
900 fputc ('\007', stderr
);
902 _("Prepare volume #%d for %s and hit return: "),
903 global_volno
+ 1, quote (*archive_name_cursor
));
906 if (getline (&input_buffer
, &size
, read_file
) <= 0)
908 WARN ((0, 0, _("EOF where user reply was expected")));
910 if (subcommand_option
!= EXTRACT_SUBCOMMAND
911 && subcommand_option
!= LIST_SUBCOMMAND
912 && subcommand_option
!= DIFF_SUBCOMMAND
)
913 WARN ((0, 0, _("WARNING: Archive is incomplete")));
918 if (input_buffer
[0] == '\n'
919 || input_buffer
[0] == 'y'
920 || input_buffer
[0] == 'Y')
923 switch (input_buffer
[0])
927 fprintf (stderr
, _("\
928 n name Give a new file name for the next (and subsequent) volume(s)\n\
930 y or newline Continue operation\n"));
931 if (!restrict_option
)
932 fprintf (stderr
, _(" ! Spawn a subshell\n"));
933 fprintf (stderr
, _(" ? Print this list\n"));
940 WARN ((0, 0, _("No new volume; exiting.\n")));
942 if (subcommand_option
!= EXTRACT_SUBCOMMAND
943 && subcommand_option
!= LIST_SUBCOMMAND
944 && subcommand_option
!= DIFF_SUBCOMMAND
)
945 WARN ((0, 0, _("WARNING: Archive is incomplete")));
950 /* Get new file name. */
956 for (name
= input_buffer
+ 1;
957 *name
== ' ' || *name
== '\t';
961 for (cursor
= name
; *cursor
&& *cursor
!= '\n'; cursor
++)
967 /* FIXME: the following allocation is never reclaimed. */
968 *archive_name_cursor
= xstrdup (name
);
972 fprintf (stderr
, "%s",
973 _("File name not specified. Try again.\n"));
978 if (!restrict_option
)
986 fprintf (stderr
, _("Invalid input. Type ? for help.\n"));
992 /* We've hit the end of the old volume. Close it and open the next one.
993 Return nonzero on success.
996 new_volume (enum access_mode mode
)
998 static FILE *read_file
;
1002 if (!read_file
&& !info_script_option
)
1003 /* FIXME: if fopen is used, it will never be closed. */
1004 read_file
= archive
== STDIN_FILENO
? fopen (TTY_NAME
, "r") : stdin
;
1011 assign_string (&volume_label
, NULL
);
1012 assign_string (&continued_file_name
, NULL
);
1013 continued_file_size
= continued_file_offset
= 0;
1014 current_block
= record_start
;
1016 if (rmtclose (archive
) != 0)
1017 close_warn (*archive_name_cursor
);
1019 archive_name_cursor
++;
1020 if (archive_name_cursor
== archive_name_array
+ archive_names
)
1022 archive_name_cursor
= archive_name_array
;
1030 /* We have to prompt from now on. */
1032 if (info_script_option
)
1034 if (volno_file_option
)
1035 closeout_volume_number ();
1036 if (sys_exec_info_script (archive_name_cursor
, global_volno
+1))
1037 FATAL_ERROR ((0, 0, _("%s command failed"),
1038 quote (info_script_option
)));
1041 change_tape_menu (read_file
);
1044 if (strcmp (archive_name_cursor
[0], "-") == 0)
1046 read_full_records
= true;
1047 archive
= STDIN_FILENO
;
1049 else if (verify_option
)
1050 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1051 rsh_command_option
);
1056 archive
= rmtopen (*archive_name_cursor
, O_RDONLY
, MODE_RW
,
1057 rsh_command_option
);
1062 maybe_backup_file (*archive_name_cursor
, 1);
1063 archive
= rmtcreat (*archive_name_cursor
, MODE_RW
,
1064 rsh_command_option
);
1068 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1069 rsh_command_option
);
1075 open_warn (*archive_name_cursor
);
1076 if (!verify_option
&& mode
== ACCESS_WRITE
&& backup_option
)
1077 undo_last_backup ();
1082 SET_BINARY_MODE (archive
);
1088 read_header0 (struct tar_stat_info
*info
)
1090 enum read_header rc
;
1092 tar_stat_init (info
);
1093 rc
= read_header_primitive (false, info
);
1094 if (rc
== HEADER_SUCCESS
)
1096 set_next_block_after (current_header
);
1099 ERROR ((0, 0, _("This does not look like a tar archive")));
1107 union block
*header
;
1108 enum access_mode acc
;
1110 switch (subcommand_option
)
1112 case APPEND_SUBCOMMAND
:
1113 case CAT_SUBCOMMAND
:
1114 case UPDATE_SUBCOMMAND
:
1115 acc
= ACCESS_UPDATE
;
1123 if (!new_volume (acc
))
1126 while ((status
= rmtread (archive
, record_start
->buffer
, record_size
))
1128 archive_read_error ();
1130 if (status
!= record_size
)
1131 short_read (status
);
1133 header
= find_next_block ();
1137 switch (header
->header
.typeflag
)
1141 if (!read_header0 (&dummy
))
1143 xheader_decode (&dummy
); /* decodes values from the global header */
1144 tar_stat_destroy (&dummy
);
1147 /* We have read the extended header of the first member in
1148 this volume. Put it back, so next read_header works as
1150 current_block
= record_start
;
1155 case GNUTYPE_VOLHDR
:
1156 if (!read_header0 (&dummy
))
1158 tar_stat_destroy (&dummy
);
1159 assign_string (&volume_label
, current_header
->header
.name
);
1160 set_next_block_after (header
);
1161 header
= find_next_block ();
1162 if (header
->header
.typeflag
!= GNUTYPE_MULTIVOL
)
1166 case GNUTYPE_MULTIVOL
:
1167 if (!read_header0 (&dummy
))
1169 tar_stat_destroy (&dummy
);
1170 assign_string (&continued_file_name
, current_header
->header
.name
);
1171 continued_file_size
=
1172 UINTMAX_FROM_HEADER (current_header
->header
.size
);
1173 continued_file_offset
=
1174 UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
);
1184 if (!continued_file_name
1185 || strcmp (continued_file_name
, real_s_name
))
1187 if ((archive_format
== GNU_FORMAT
|| archive_format
== OLDGNU_FORMAT
)
1188 && strlen (real_s_name
) >= NAME_FIELD_SIZE
1189 && strncmp (continued_file_name
, real_s_name
,
1190 NAME_FIELD_SIZE
) == 0)
1192 _("%s is possibly continued on this volume: header contains truncated name"),
1193 quote (real_s_name
)));
1196 WARN ((0, 0, _("%s is not continued on this volume"),
1197 quote (real_s_name
)));
1202 s
= continued_file_size
+ continued_file_offset
;
1204 if (real_s_totsize
!= s
|| s
< continued_file_offset
)
1206 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1207 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1208 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1210 WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
1211 quote (continued_file_name
),
1212 STRINGIFY_BIGINT (save_totsize
, totsizebuf
),
1213 STRINGIFY_BIGINT (continued_file_size
, s1buf
),
1214 STRINGIFY_BIGINT (continued_file_offset
, s2buf
)));
1218 if (real_s_totsize
- real_s_sizeleft
!= continued_file_offset
)
1220 WARN ((0, 0, _("This volume is out of sequence")));
1225 increase_volume_number ();
1230 /* Check the LABEL block against the volume label, seen as a globbing
1231 pattern. Return true if the pattern matches. In case of failure,
1232 retry matching a volume sequence number before giving up in
1233 multi-volume mode. */
1235 check_label_pattern (union block
*label
)
1240 if (! memchr (label
->header
.name
, '\0', sizeof label
->header
.name
))
1243 if (fnmatch (volume_label_option
, label
->header
.name
, 0) == 0)
1246 if (!multi_volume_option
)
1249 string
= xmalloc (strlen (volume_label_option
)
1250 + sizeof VOLUME_LABEL_APPEND
+ 1);
1251 strcpy (string
, volume_label_option
);
1252 strcat (string
, VOLUME_LABEL_APPEND
);
1253 result
= fnmatch (string
, label
->header
.name
, 0) == 0;
1258 /* Check if the next block contains a volume label and if this matches
1259 the one given in the command line */
1261 match_volume_label (void)
1263 union block
*label
= find_next_block ();
1266 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1267 quote (volume_label_option
)));
1268 if (!check_label_pattern (label
))
1269 FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
1270 quote_n (0, label
->header
.name
),
1271 quote_n (1, volume_label_option
)));
1274 /* Mark the archive with volume label STR. */
1276 _write_volume_label (const char *str
)
1278 if (archive_format
== POSIX_FORMAT
)
1279 xheader_store ("GNU.volume.label", &dummy
, str
);
1282 union block
*label
= find_next_block ();
1284 memset (label
, 0, BLOCKSIZE
);
1286 strcpy (label
->header
.name
, volume_label_option
);
1287 assign_string (¤t_stat_info
.file_name
,
1288 label
->header
.name
);
1289 current_stat_info
.had_trailing_slash
=
1290 strip_trailing_slashes (current_stat_info
.file_name
);
1292 label
->header
.typeflag
= GNUTYPE_VOLHDR
;
1293 TIME_TO_CHARS (start_time
.tv_sec
, label
->header
.mtime
);
1294 finish_header (¤t_stat_info
, label
, -1);
1295 set_next_block_after (label
);
1299 #define VOL_SUFFIX "Volume"
1301 /* Add a volume label to a part of multi-volume archive */
1303 add_volume_label (void)
1305 char buf
[UINTMAX_STRSIZE_BOUND
];
1306 char *p
= STRINGIFY_BIGINT (volno
, buf
);
1307 char *s
= xmalloc (strlen (volume_label_option
) + sizeof VOL_SUFFIX
1309 sprintf (s
, "%s %s %s", volume_label_option
, VOL_SUFFIX
, p
);
1310 _write_volume_label (s
);
1317 if (archive_format
== POSIX_FORMAT
)
1319 off_t block_ordinal
;
1321 struct tar_stat_info st
;
1322 static size_t real_s_part_no
; /* FIXME */
1325 memset (&st
, 0, sizeof st
);
1326 st
.orig_file_name
= st
.file_name
= real_s_name
;
1327 st
.stat
.st_mode
= S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
;
1328 st
.stat
.st_uid
= getuid ();
1329 st
.stat
.st_gid
= getgid ();
1330 st
.orig_file_name
= xheader_format_name (&st
,
1331 "%d/GNUFileParts.%p/%f.%n",
1333 st
.file_name
= st
.orig_file_name
;
1334 st
.archive_file_size
= st
.stat
.st_size
= real_s_sizeleft
;
1336 block_ordinal
= current_block_ordinal ();
1337 blk
= start_header (&st
);
1339 abort (); /* FIXME */
1340 finish_header (&st
, blk
, block_ordinal
);
1341 free (st
.orig_file_name
);
1346 /* Add a volume label to the current archive */
1348 write_volume_label (void)
1350 if (multi_volume_option
)
1351 add_volume_label ();
1353 _write_volume_label (volume_label_option
);
1356 /* Write GNU multi-volume header */
1358 gnu_add_multi_volume_header (void)
1361 union block
*block
= find_next_block ();
1363 if (strlen (real_s_name
) > NAME_FIELD_SIZE
)
1365 _("%s: file name too long to be stored in a GNU multivolume header, truncated"),
1366 quotearg_colon (real_s_name
)));
1368 memset (block
, 0, BLOCKSIZE
);
1370 /* FIXME: Michael P Urban writes: [a long name file] is being written
1371 when a new volume rolls around [...] Looks like the wrong value is
1372 being preserved in real_s_name, though. */
1374 strncpy (block
->header
.name
, real_s_name
, NAME_FIELD_SIZE
);
1375 block
->header
.typeflag
= GNUTYPE_MULTIVOL
;
1377 OFF_TO_CHARS (real_s_sizeleft
, block
->header
.size
);
1378 OFF_TO_CHARS (real_s_totsize
- real_s_sizeleft
,
1379 block
->oldgnu_header
.offset
);
1381 tmp
= verbose_option
;
1383 finish_header (¤t_stat_info
, block
, -1);
1384 verbose_option
= tmp
;
1385 set_next_block_after (block
);
1388 /* Add a multi volume header to the current archive. The exact header format
1389 depends on the archive format. */
1391 add_multi_volume_header (void)
1393 if (archive_format
== POSIX_FORMAT
)
1395 off_t d
= real_s_totsize
- real_s_sizeleft
;
1396 xheader_store ("GNU.volume.filename", &dummy
, real_s_name
);
1397 xheader_store ("GNU.volume.size", &dummy
, &real_s_sizeleft
);
1398 xheader_store ("GNU.volume.offset", &dummy
, &d
);
1401 gnu_add_multi_volume_header ();
1404 /* Synchronize multi-volume globals */
1406 multi_volume_sync ()
1408 if (multi_volume_option
)
1412 assign_string (&real_s_name
,
1413 safer_name_suffix (save_name
, false,
1414 absolute_names_option
));
1415 real_s_totsize
= save_totsize
;
1416 real_s_sizeleft
= save_sizeleft
;
1420 assign_string (&real_s_name
, 0);
1422 real_s_sizeleft
= 0;
1428 /* Low-level flush functions */
1430 /* Simple flush read (no multi-volume or label extensions) */
1432 simple_flush_read (void)
1434 size_t status
; /* result from system call */
1436 checkpoint_run (false);
1438 /* Clear the count of errors. This only applies to a single call to
1441 read_error_count
= 0; /* clear error count */
1443 if (write_archive_to_stdout
&& record_start_block
!= 0)
1445 archive
= STDOUT_FILENO
;
1446 status
= sys_write_archive_buffer ();
1447 archive
= STDIN_FILENO
;
1448 if (status
!= record_size
)
1449 archive_write_error (status
);
1454 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1455 if (status
== record_size
)
1460 if (status
== SAFE_READ_ERROR
)
1462 archive_read_error ();
1463 continue; /* try again */
1467 short_read (status
);
1470 /* Simple flush write (no multi-volume or label extensions) */
1472 simple_flush_write (size_t level
__attribute__((unused
)))
1476 status
= _flush_write ();
1477 if (status
!= record_size
)
1478 archive_write_error (status
);
1482 bytes_written
+= status
;
1487 /* GNU flush functions. These support multi-volume and archive labels in
1488 GNU and PAX archive formats. */
1491 _gnu_flush_read (void)
1493 size_t status
; /* result from system call */
1495 checkpoint_run (false);
1497 /* Clear the count of errors. This only applies to a single call to
1500 read_error_count
= 0; /* clear error count */
1502 if (write_archive_to_stdout
&& record_start_block
!= 0)
1504 archive
= STDOUT_FILENO
;
1505 status
= sys_write_archive_buffer ();
1506 archive
= STDIN_FILENO
;
1507 if (status
!= record_size
)
1508 archive_write_error (status
);
1511 multi_volume_sync ();
1515 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1516 if (status
== record_size
)
1522 /* The condition below used to include
1523 || (status > 0 && !read_full_records)
1524 This is incorrect since even if new_volume() succeeds, the
1525 subsequent call to rmtread will overwrite the chunk of data
1526 already read in the buffer, so the processing will fail */
1528 || (status
== SAFE_READ_ERROR
&& errno
== ENOSPC
))
1529 && multi_volume_option
)
1531 while (!try_new_volume ())
1535 else if (status
== SAFE_READ_ERROR
)
1537 archive_read_error ();
1542 short_read (status
);
1546 gnu_flush_read (void)
1548 flush_read_ptr
= simple_flush_read
; /* Avoid recursion */
1550 flush_read_ptr
= gnu_flush_read
;
1554 _gnu_flush_write (size_t buffer_level
)
1557 union block
*header
;
1562 status
= _flush_write ();
1563 if (status
!= record_size
&& !multi_volume_option
)
1564 archive_write_error (status
);
1568 bytes_written
+= status
;
1571 if (status
== record_size
)
1573 multi_volume_sync ();
1577 /* In multi-volume mode. */
1578 /* ENXIO is for the UNIX PC. */
1579 if (status
< 0 && errno
!= ENOSPC
&& errno
!= EIO
&& errno
!= ENXIO
)
1580 archive_write_error (status
);
1582 if (!new_volume (ACCESS_WRITE
))
1585 tar_stat_destroy (&dummy
);
1587 increase_volume_number ();
1588 prev_written
+= bytes_written
;
1591 copy_ptr
= record_start
->buffer
+ status
;
1592 copy_size
= buffer_level
- status
;
1593 /* Switch to the next buffer */
1594 record_index
= !record_index
;
1597 if (volume_label_option
)
1598 add_volume_label ();
1601 add_multi_volume_header ();
1603 write_extended (true, &dummy
, find_next_block ());
1604 tar_stat_destroy (&dummy
);
1607 add_chunk_header ();
1608 header
= find_next_block ();
1609 bufsize
= available_space_after (header
);
1610 while (bufsize
< copy_size
)
1612 memcpy (header
->buffer
, copy_ptr
, bufsize
);
1613 copy_ptr
+= bufsize
;
1614 copy_size
-= bufsize
;
1615 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
1616 header
= find_next_block ();
1617 bufsize
= available_space_after (header
);
1619 memcpy (header
->buffer
, copy_ptr
, copy_size
);
1620 memset (header
->buffer
+ copy_size
, 0, bufsize
- copy_size
);
1621 set_next_block_after (header
+ (copy_size
- 1) / BLOCKSIZE
);
1626 gnu_flush_write (size_t buffer_level
)
1628 flush_write_ptr
= simple_flush_write
; /* Avoid recursion */
1629 _gnu_flush_write (buffer_level
);
1630 flush_write_ptr
= gnu_flush_write
;
1642 flush_write_ptr (record_size
);
1646 open_archive (enum access_mode wanted_access
)
1648 flush_read_ptr
= gnu_flush_read
;
1649 flush_write_ptr
= gnu_flush_write
;
1651 _open_archive (wanted_access
);
1652 switch (wanted_access
)
1655 if (volume_label_option
)
1656 match_volume_label ();
1660 records_written
= 0;
1661 if (volume_label_option
)
1662 write_volume_label ();
1668 set_volume_start_time ();