1 /* Buffer management for tar.
3 Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003, 2004, 2005, 2006, 2007, 2008 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 */
201 ct_tar
, /* Plain tar file */
202 ct_none
, /* Unknown compression type */
212 enum compress_type type
;
219 static struct zip_magic
const magic
[] = {
222 { ct_compress
, 2, "\037\235", "compress", "-Z" },
223 { ct_gzip
, 2, "\037\213", "gzip", "-z" },
224 { ct_bzip2
, 3, "BZh", "bzip2", "-j" },
225 { ct_lzma
, 6, "\xFFLZMA", "lzma", "-J" }, /* FIXME: ???? */
226 { ct_lzop
, 4, "\211LZO", "lzop", "--lzop" },
229 #define NMAGIC (sizeof(magic)/sizeof(magic[0]))
231 #define compress_option(t) magic[t].option
232 #define compress_program(t) magic[t].program
234 /* Check if the file ARCHIVE is a compressed archive. */
236 check_compressed_archive (bool *pshort
)
238 struct zip_magic
const *p
;
245 /* Prepare global data needed for find_next_block: */
246 record_end
= record_start
; /* set up for 1st record = # 0 */
247 sfr
= read_full_records
;
248 read_full_records
= true; /* Suppress fatal error on reading a partial
250 *pshort
= find_next_block () == 0;
252 /* Restore global values */
253 read_full_records
= sfr
;
255 if (tar_checksum (record_start
, true) == HEADER_SUCCESS
)
256 /* Probably a valid header */
259 for (p
= magic
+ 2; p
< magic
+ NMAGIC
; p
++)
260 if (memcmp (record_start
->buffer
, p
->magic
, p
->length
) == 0)
266 /* Open an archive named archive_name_array[0]. Detect if it is
267 a compressed archive of known type and use corresponding decompression
270 open_compressed_archive ()
272 archive
= rmtopen (archive_name_array
[0], O_RDONLY
| O_BINARY
,
273 MODE_RW
, rsh_command_option
);
277 if (!multi_volume_option
)
279 if (!use_compress_program_option
)
282 enum compress_type type
= check_compressed_archive (&shortfile
);
288 ERROR ((0, 0, _("This does not look like a tar archive")));
293 ERROR ((0, 0, _("This does not look like a tar archive")));
294 set_comression_program_by_suffix (archive_name_array
[0], NULL
);
295 if (!use_compress_program_option
)
300 use_compress_program_option
= compress_program (type
);
305 /* FD is not needed any more */
308 hit_eof
= false; /* It might have been set by find_next_block in
309 check_compressed_archive */
311 /* Open compressed archive */
312 child_pid
= sys_child_open_for_uncompress ();
313 read_full_records
= true;
317 record_end
= record_start
; /* set up for 1st record = # 0 */
324 print_stats (FILE *fp
, const char *text
, tarlong numbytes
)
326 char bytes
[sizeof (tarlong
) * CHAR_BIT
];
327 char abbr
[LONGEST_HUMAN_READABLE
+ 1];
328 char rate
[LONGEST_HUMAN_READABLE
+ 1];
330 int human_opts
= human_autoscale
| human_base_1024
| human_SI
| human_B
;
332 sprintf (bytes
, TARLONG_FORMAT
, numbytes
);
334 fprintf (fp
, "%s: %s (%s, %s/s)\n",
336 human_readable (numbytes
, abbr
, human_opts
, 1, 1),
337 (0 < duration
&& numbytes
/ duration
< (uintmax_t) -1
338 ? human_readable (numbytes
/ duration
, rate
, human_opts
, 1, 1)
345 switch (subcommand_option
)
347 case CREATE_SUBCOMMAND
:
349 case UPDATE_SUBCOMMAND
:
350 case APPEND_SUBCOMMAND
:
351 /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */
352 print_stats (stderr
, _("Total bytes written"),
353 prev_written
+ bytes_written
);
356 case DELETE_SUBCOMMAND
:
358 char buf
[UINTMAX_STRSIZE_BOUND
];
359 print_stats (stderr
, _("Total bytes read"),
360 records_read
* record_size
);
361 print_stats (stderr
, _("Total bytes written"),
362 prev_written
+ bytes_written
);
363 fprintf (stderr
, _("Total bytes deleted: %s\n"),
364 STRINGIFY_BIGINT ((records_read
- records_skipped
)
366 - (prev_written
+ bytes_written
), buf
));
370 case EXTRACT_SUBCOMMAND
:
371 case LIST_SUBCOMMAND
:
372 case DIFF_SUBCOMMAND
:
373 print_stats (stderr
, _("Total bytes read"),
374 records_read
* record_size
);
382 /* Compute and return the block ordinal at current_block. */
384 current_block_ordinal (void)
386 return record_start_block
+ (current_block
- record_start
);
389 /* If the EOF flag is set, reset it, as well as current_block, etc. */
396 current_block
= record_start
;
397 record_end
= record_start
+ blocking_factor
;
398 access_mode
= ACCESS_WRITE
;
402 /* Return the location of the next available input or output block.
403 Return zero for EOF. Once we have returned zero, we just keep returning
404 it, to avoid accidentally going on to the next file on the tape. */
406 find_next_block (void)
408 if (current_block
== record_end
)
413 if (current_block
== record_end
)
419 return current_block
;
422 /* Indicate that we have used all blocks up thru BLOCK. */
424 set_next_block_after (union block
*block
)
426 while (block
>= current_block
)
429 /* Do *not* flush the archive here. If we do, the same argument to
430 set_next_block_after could mean the next block (if the input record
431 is exactly one block long), which is not what is intended. */
433 if (current_block
> record_end
)
437 /* Return the number of bytes comprising the space between POINTER
438 through the end of the current buffer of blocks. This space is
439 available for filling with data, or taking data from. POINTER is
440 usually (but not always) the result of previous find_next_block call. */
442 available_space_after (union block
*pointer
)
444 return record_end
->buffer
- pointer
->buffer
;
447 /* Close file having descriptor FD, and abort if close unsuccessful. */
452 close_error (_("(pipe)"));
458 if (! record_buffer_aligned
[record_index
])
459 record_buffer_aligned
[record_index
] =
460 page_aligned_alloc (&record_buffer
[record_index
], record_size
);
462 record_start
= record_buffer_aligned
[record_index
];
463 current_block
= record_start
;
464 record_end
= record_start
+ blocking_factor
;
467 /* Open an archive file. The argument specifies whether we are
468 reading or writing, or both. */
470 _open_archive (enum access_mode wanted_access
)
472 int backed_up_flag
= 0;
474 if (record_size
== 0)
475 FATAL_ERROR ((0, 0, _("Invalid value for record_size")));
477 if (archive_names
== 0)
478 FATAL_ERROR ((0, 0, _("No archive name given")));
480 tar_stat_destroy (¤t_stat_info
);
487 /* When updating the archive, we start with reading. */
488 access_mode
= wanted_access
== ACCESS_UPDATE
? ACCESS_READ
: wanted_access
;
490 read_full_records
= read_full_records_option
;
494 if (use_compress_program_option
)
496 switch (wanted_access
)
499 child_pid
= sys_child_open_for_uncompress ();
500 read_full_records
= true;
501 record_end
= record_start
; /* set up for 1st record = # 0 */
505 child_pid
= sys_child_open_for_compress ();
509 abort (); /* Should not happen */
514 && wanted_access
== ACCESS_WRITE
515 && strcmp (archive_name_array
[0], "-") == 0)
518 else if (strcmp (archive_name_array
[0], "-") == 0)
520 read_full_records
= true; /* could be a pipe, be safe */
522 FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
524 switch (wanted_access
)
529 enum compress_type type
;
531 archive
= STDIN_FILENO
;
533 type
= check_compressed_archive (&shortfile
);
534 if (type
!= ct_tar
&& type
!= ct_none
)
536 _("Archive is compressed. Use %s option"),
537 compress_option (type
)));
539 ERROR ((0, 0, _("This does not look like a tar archive")));
544 archive
= STDOUT_FILENO
;
545 if (!index_file_name
)
550 archive
= STDIN_FILENO
;
551 write_archive_to_stdout
= true;
552 record_end
= record_start
; /* set up for 1st record = # 0 */
553 if (!index_file_name
)
558 else if (verify_option
)
559 archive
= rmtopen (archive_name_array
[0], O_RDWR
| O_CREAT
| O_BINARY
,
560 MODE_RW
, rsh_command_option
);
562 switch (wanted_access
)
565 archive
= open_compressed_archive ();
571 maybe_backup_file (archive_name_array
[0], 1);
574 archive
= rmtcreat (archive_name_array
[0], MODE_RW
,
579 archive
= rmtopen (archive_name_array
[0],
580 O_RDWR
| O_CREAT
| O_BINARY
,
581 MODE_RW
, rsh_command_option
);
583 switch (check_compressed_archive (NULL
))
591 _("Cannot update compressed archives")));
597 || (! _isrmt (archive
) && !sys_get_archive_stat ()))
599 int saved_errno
= errno
;
604 open_fatal (archive_name_array
[0]);
607 sys_detect_dev_null_output ();
608 sys_save_archive_dev_ino ();
609 SET_BINARY_MODE (archive
);
611 switch (wanted_access
)
614 find_next_block (); /* read it in, check for EOF */
624 /* Perform a write to flush the buffer. */
630 checkpoint_run (true);
631 if (tape_length_option
&& tape_length_option
<= bytes_written
)
636 else if (dev_null_output
)
637 status
= record_size
;
639 status
= sys_write_archive_buffer ();
644 /* Handle write errors on the archive. Write errors are always fatal.
645 Hitting the end of a volume does not cause a write error unless the
646 write was the first record of the volume. */
648 archive_write_error (ssize_t status
)
650 /* It might be useful to know how much was written before the error
655 print_total_stats ();
659 write_fatal_details (*archive_name_cursor
, status
, record_size
);
662 /* Handle read errors on the archive. If the read should be retried,
663 return to the caller. */
665 archive_read_error (void)
667 read_error (*archive_name_cursor
);
669 if (record_start_block
== 0)
670 FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
672 /* Read error in mid archive. We retry up to READ_ERROR_MAX times and
673 then give up on reading the archive. */
675 if (read_error_count
++ > READ_ERROR_MAX
)
676 FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
681 short_read (size_t status
)
683 size_t left
; /* bytes left */
684 char *more
; /* pointer to next byte to read */
686 more
= record_start
->buffer
+ status
;
687 left
= record_size
- status
;
689 if (left
&& left
% BLOCKSIZE
== 0
691 && record_start_block
== 0 && status
!= 0)
693 unsigned long rsize
= status
/ BLOCKSIZE
;
695 ngettext ("Record size = %lu block",
696 "Record size = %lu blocks",
701 while (left
% BLOCKSIZE
!= 0
702 || (left
&& status
&& read_full_records
))
705 while ((status
= rmtread (archive
, more
, left
)) == SAFE_READ_ERROR
)
706 archive_read_error ();
711 if (! read_full_records
)
713 unsigned long rest
= record_size
- left
;
716 ngettext ("Unaligned block (%lu byte) in archive",
717 "Unaligned block (%lu bytes) in archive",
726 record_end
= record_start
+ (record_size
- left
) / BLOCKSIZE
;
730 /* Flush the current buffer to/from the archive. */
734 size_t buffer_level
= current_block
->buffer
- record_start
->buffer
;
735 record_start_block
+= record_end
- record_start
;
736 current_block
= record_start
;
737 record_end
= record_start
+ blocking_factor
;
739 if (access_mode
== ACCESS_READ
&& time_to_start_writing
)
741 access_mode
= ACCESS_WRITE
;
742 time_to_start_writing
= false;
753 flush_write_ptr (buffer_level
);
761 /* Backspace the archive descriptor by one record worth. If it's a
762 tape, MTIOCTOP will work. If it's something else, try to seek on
763 it. If we can't seek, we lose! */
765 backspace_output (void)
769 struct mtop operation
;
771 operation
.mt_op
= MTBSR
;
772 operation
.mt_count
= 1;
773 if (rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
775 if (errno
== EIO
&& rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
781 off_t position
= rmtlseek (archive
, (off_t
) 0, SEEK_CUR
);
783 /* Seek back to the beginning of this record and start writing there. */
785 position
-= record_size
;
788 if (rmtlseek (archive
, position
, SEEK_SET
) != position
)
790 /* Lseek failed. Try a different method. */
793 _("Cannot backspace archive file; it may be unreadable without -i")));
795 /* Replace the first part of the record with NULs. */
797 if (record_start
->buffer
!= output_start
)
798 memset (record_start
->buffer
, 0,
799 output_start
- record_start
->buffer
);
805 seek_archive (off_t size
)
807 off_t start
= current_block_ordinal ();
810 off_t skipped
= (blocking_factor
- (current_block
- record_start
));
812 size
-= skipped
* BLOCKSIZE
;
814 if (size
< record_size
)
818 /* Compute number of records to skip */
819 nrec
= size
/ record_size
;
820 offset
= rmtlseek (archive
, nrec
* record_size
, SEEK_CUR
);
824 if (offset
% record_size
)
825 FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary")));
827 /* Convert to number of records */
829 /* Compute number of skipped blocks */
830 nblk
= offset
- start
;
832 /* Update buffering info */
833 records_read
+= nblk
/ blocking_factor
;
834 record_start_block
= offset
- blocking_factor
;
835 current_block
= record_end
;
840 /* Close the archive file. */
844 if (time_to_start_writing
|| access_mode
== ACCESS_WRITE
)
847 if (current_block
> record_start
)
851 sys_drain_input_pipe ();
857 if (rmtclose (archive
) != 0)
858 close_error (*archive_name_cursor
);
860 sys_wait_for_child (child_pid
);
862 tar_stat_destroy (¤t_stat_info
);
867 free (record_buffer
[0]);
868 free (record_buffer
[1]);
871 /* Called to initialize the global volume number. */
873 init_volume_number (void)
875 FILE *file
= fopen (volno_file_option
, "r");
879 if (fscanf (file
, "%d", &global_volno
) != 1
881 FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"),
882 quotearg_colon (volno_file_option
)));
884 read_error (volno_file_option
);
885 if (fclose (file
) != 0)
886 close_error (volno_file_option
);
888 else if (errno
!= ENOENT
)
889 open_error (volno_file_option
);
892 /* Called to write out the closing global volume number. */
894 closeout_volume_number (void)
896 FILE *file
= fopen (volno_file_option
, "w");
900 fprintf (file
, "%d\n", global_volno
);
902 write_error (volno_file_option
);
903 if (fclose (file
) != 0)
904 close_error (volno_file_option
);
907 open_error (volno_file_option
);
912 increase_volume_number ()
915 if (global_volno
< 0)
916 FATAL_ERROR ((0, 0, _("Volume number overflow")));
921 change_tape_menu (FILE *read_file
)
923 char *input_buffer
= NULL
;
929 fputc ('\007', stderr
);
931 _("Prepare volume #%d for %s and hit return: "),
932 global_volno
+ 1, quote (*archive_name_cursor
));
935 if (getline (&input_buffer
, &size
, read_file
) <= 0)
937 WARN ((0, 0, _("EOF where user reply was expected")));
939 if (subcommand_option
!= EXTRACT_SUBCOMMAND
940 && subcommand_option
!= LIST_SUBCOMMAND
941 && subcommand_option
!= DIFF_SUBCOMMAND
)
942 WARN ((0, 0, _("WARNING: Archive is incomplete")));
947 if (input_buffer
[0] == '\n'
948 || input_buffer
[0] == 'y'
949 || input_buffer
[0] == 'Y')
952 switch (input_buffer
[0])
956 fprintf (stderr
, _("\
957 n name Give a new file name for the next (and subsequent) volume(s)\n\
959 y or newline Continue operation\n"));
960 if (!restrict_option
)
961 fprintf (stderr
, _(" ! Spawn a subshell\n"));
962 fprintf (stderr
, _(" ? Print this list\n"));
969 WARN ((0, 0, _("No new volume; exiting.\n")));
971 if (subcommand_option
!= EXTRACT_SUBCOMMAND
972 && subcommand_option
!= LIST_SUBCOMMAND
973 && subcommand_option
!= DIFF_SUBCOMMAND
)
974 WARN ((0, 0, _("WARNING: Archive is incomplete")));
979 /* Get new file name. */
985 for (name
= input_buffer
+ 1;
986 *name
== ' ' || *name
== '\t';
990 for (cursor
= name
; *cursor
&& *cursor
!= '\n'; cursor
++)
996 /* FIXME: the following allocation is never reclaimed. */
997 *archive_name_cursor
= xstrdup (name
);
1001 fprintf (stderr
, "%s",
1002 _("File name not specified. Try again.\n"));
1007 if (!restrict_option
)
1015 fprintf (stderr
, _("Invalid input. Type ? for help.\n"));
1018 free (input_buffer
);
1021 /* We've hit the end of the old volume. Close it and open the next one.
1022 Return nonzero on success.
1025 new_volume (enum access_mode mode
)
1027 static FILE *read_file
;
1031 if (!read_file
&& !info_script_option
)
1032 /* FIXME: if fopen is used, it will never be closed. */
1033 read_file
= archive
== STDIN_FILENO
? fopen (TTY_NAME
, "r") : stdin
;
1040 assign_string (&volume_label
, NULL
);
1041 assign_string (&continued_file_name
, NULL
);
1042 continued_file_size
= continued_file_offset
= 0;
1043 current_block
= record_start
;
1045 if (rmtclose (archive
) != 0)
1046 close_error (*archive_name_cursor
);
1048 archive_name_cursor
++;
1049 if (archive_name_cursor
== archive_name_array
+ archive_names
)
1051 archive_name_cursor
= archive_name_array
;
1059 /* We have to prompt from now on. */
1061 if (info_script_option
)
1063 if (volno_file_option
)
1064 closeout_volume_number ();
1065 if (sys_exec_info_script (archive_name_cursor
, global_volno
+1))
1066 FATAL_ERROR ((0, 0, _("%s command failed"),
1067 quote (info_script_option
)));
1070 change_tape_menu (read_file
);
1073 if (strcmp (archive_name_cursor
[0], "-") == 0)
1075 read_full_records
= true;
1076 archive
= STDIN_FILENO
;
1078 else if (verify_option
)
1079 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1080 rsh_command_option
);
1085 archive
= rmtopen (*archive_name_cursor
, O_RDONLY
, MODE_RW
,
1086 rsh_command_option
);
1091 maybe_backup_file (*archive_name_cursor
, 1);
1092 archive
= rmtcreat (*archive_name_cursor
, MODE_RW
,
1093 rsh_command_option
);
1097 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1098 rsh_command_option
);
1104 open_warn (*archive_name_cursor
);
1105 if (!verify_option
&& mode
== ACCESS_WRITE
&& backup_option
)
1106 undo_last_backup ();
1111 SET_BINARY_MODE (archive
);
1117 read_header0 (struct tar_stat_info
*info
)
1119 enum read_header rc
;
1121 tar_stat_init (info
);
1122 rc
= read_header_primitive (false, info
);
1123 if (rc
== HEADER_SUCCESS
)
1125 set_next_block_after (current_header
);
1128 ERROR ((0, 0, _("This does not look like a tar archive")));
1136 union block
*header
;
1137 enum access_mode acc
;
1139 switch (subcommand_option
)
1141 case APPEND_SUBCOMMAND
:
1142 case CAT_SUBCOMMAND
:
1143 case UPDATE_SUBCOMMAND
:
1144 acc
= ACCESS_UPDATE
;
1152 if (!new_volume (acc
))
1155 while ((status
= rmtread (archive
, record_start
->buffer
, record_size
))
1157 archive_read_error ();
1159 if (status
!= record_size
)
1160 short_read (status
);
1162 header
= find_next_block ();
1166 switch (header
->header
.typeflag
)
1170 if (!read_header0 (&dummy
))
1172 xheader_decode (&dummy
); /* decodes values from the global header */
1173 tar_stat_destroy (&dummy
);
1176 /* We have read the extended header of the first member in
1177 this volume. Put it back, so next read_header works as
1179 current_block
= record_start
;
1184 case GNUTYPE_VOLHDR
:
1185 if (!read_header0 (&dummy
))
1187 tar_stat_destroy (&dummy
);
1188 assign_string (&volume_label
, current_header
->header
.name
);
1189 set_next_block_after (header
);
1190 header
= find_next_block ();
1191 if (header
->header
.typeflag
!= GNUTYPE_MULTIVOL
)
1195 case GNUTYPE_MULTIVOL
:
1196 if (!read_header0 (&dummy
))
1198 tar_stat_destroy (&dummy
);
1199 assign_string (&continued_file_name
, current_header
->header
.name
);
1200 continued_file_size
=
1201 UINTMAX_FROM_HEADER (current_header
->header
.size
);
1202 continued_file_offset
=
1203 UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
);
1213 if (!continued_file_name
1214 || strcmp (continued_file_name
, real_s_name
))
1216 if ((archive_format
== GNU_FORMAT
|| archive_format
== OLDGNU_FORMAT
)
1217 && strlen (real_s_name
) >= NAME_FIELD_SIZE
1218 && strncmp (continued_file_name
, real_s_name
,
1219 NAME_FIELD_SIZE
) == 0)
1221 _("%s is possibly continued on this volume: header contains truncated name"),
1222 quote (real_s_name
)));
1225 WARN ((0, 0, _("%s is not continued on this volume"),
1226 quote (real_s_name
)));
1231 s
= continued_file_size
+ continued_file_offset
;
1233 if (real_s_totsize
!= s
|| s
< continued_file_offset
)
1235 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1236 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1237 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1239 WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
1240 quote (continued_file_name
),
1241 STRINGIFY_BIGINT (save_totsize
, totsizebuf
),
1242 STRINGIFY_BIGINT (continued_file_size
, s1buf
),
1243 STRINGIFY_BIGINT (continued_file_offset
, s2buf
)));
1247 if (real_s_totsize
- real_s_sizeleft
!= continued_file_offset
)
1249 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1250 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1251 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1253 WARN ((0, 0, _("This volume is out of sequence (%s - %s != %s)"),
1254 STRINGIFY_BIGINT (real_s_totsize
, totsizebuf
),
1255 STRINGIFY_BIGINT (real_s_sizeleft
, s1buf
),
1256 STRINGIFY_BIGINT (continued_file_offset
, s2buf
)));
1262 increase_volume_number ();
1267 /* Check the LABEL block against the volume label, seen as a globbing
1268 pattern. Return true if the pattern matches. In case of failure,
1269 retry matching a volume sequence number before giving up in
1270 multi-volume mode. */
1272 check_label_pattern (union block
*label
)
1277 if (! memchr (label
->header
.name
, '\0', sizeof label
->header
.name
))
1280 if (fnmatch (volume_label_option
, label
->header
.name
, 0) == 0)
1283 if (!multi_volume_option
)
1286 string
= xmalloc (strlen (volume_label_option
)
1287 + sizeof VOLUME_LABEL_APPEND
+ 1);
1288 strcpy (string
, volume_label_option
);
1289 strcat (string
, VOLUME_LABEL_APPEND
);
1290 result
= fnmatch (string
, label
->header
.name
, 0) == 0;
1295 /* Check if the next block contains a volume label and if this matches
1296 the one given in the command line */
1298 match_volume_label (void)
1300 union block
*label
= find_next_block ();
1303 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1304 quote (volume_label_option
)));
1305 if (!check_label_pattern (label
))
1306 FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
1307 quote_n (0, label
->header
.name
),
1308 quote_n (1, volume_label_option
)));
1311 /* Mark the archive with volume label STR. */
1313 _write_volume_label (const char *str
)
1315 if (archive_format
== POSIX_FORMAT
)
1316 xheader_store ("GNU.volume.label", &dummy
, str
);
1319 union block
*label
= find_next_block ();
1321 memset (label
, 0, BLOCKSIZE
);
1323 strcpy (label
->header
.name
, volume_label_option
);
1324 assign_string (¤t_stat_info
.file_name
,
1325 label
->header
.name
);
1326 current_stat_info
.had_trailing_slash
=
1327 strip_trailing_slashes (current_stat_info
.file_name
);
1329 label
->header
.typeflag
= GNUTYPE_VOLHDR
;
1330 TIME_TO_CHARS (start_time
.tv_sec
, label
->header
.mtime
);
1331 finish_header (¤t_stat_info
, label
, -1);
1332 set_next_block_after (label
);
1336 #define VOL_SUFFIX "Volume"
1338 /* Add a volume label to a part of multi-volume archive */
1340 add_volume_label (void)
1342 char buf
[UINTMAX_STRSIZE_BOUND
];
1343 char *p
= STRINGIFY_BIGINT (volno
, buf
);
1344 char *s
= xmalloc (strlen (volume_label_option
) + sizeof VOL_SUFFIX
1346 sprintf (s
, "%s %s %s", volume_label_option
, VOL_SUFFIX
, p
);
1347 _write_volume_label (s
);
1354 if (archive_format
== POSIX_FORMAT
)
1356 off_t block_ordinal
;
1358 struct tar_stat_info st
;
1359 static size_t real_s_part_no
; /* FIXME */
1362 memset (&st
, 0, sizeof st
);
1363 st
.orig_file_name
= st
.file_name
= real_s_name
;
1364 st
.stat
.st_mode
= S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
;
1365 st
.stat
.st_uid
= getuid ();
1366 st
.stat
.st_gid
= getgid ();
1367 st
.orig_file_name
= xheader_format_name (&st
,
1368 "%d/GNUFileParts.%p/%f.%n",
1370 st
.file_name
= st
.orig_file_name
;
1371 st
.archive_file_size
= st
.stat
.st_size
= real_s_sizeleft
;
1373 block_ordinal
= current_block_ordinal ();
1374 blk
= start_header (&st
);
1376 abort (); /* FIXME */
1377 finish_header (&st
, blk
, block_ordinal
);
1378 free (st
.orig_file_name
);
1383 /* Add a volume label to the current archive */
1385 write_volume_label (void)
1387 if (multi_volume_option
)
1388 add_volume_label ();
1390 _write_volume_label (volume_label_option
);
1393 /* Write GNU multi-volume header */
1395 gnu_add_multi_volume_header (void)
1398 union block
*block
= find_next_block ();
1400 if (strlen (real_s_name
) > NAME_FIELD_SIZE
)
1402 _("%s: file name too long to be stored in a GNU multivolume header, truncated"),
1403 quotearg_colon (real_s_name
)));
1405 memset (block
, 0, BLOCKSIZE
);
1407 /* FIXME: Michael P Urban writes: [a long name file] is being written
1408 when a new volume rolls around [...] Looks like the wrong value is
1409 being preserved in real_s_name, though. */
1411 strncpy (block
->header
.name
, real_s_name
, NAME_FIELD_SIZE
);
1412 block
->header
.typeflag
= GNUTYPE_MULTIVOL
;
1414 OFF_TO_CHARS (real_s_sizeleft
, block
->header
.size
);
1415 OFF_TO_CHARS (real_s_totsize
- real_s_sizeleft
,
1416 block
->oldgnu_header
.offset
);
1418 tmp
= verbose_option
;
1420 finish_header (¤t_stat_info
, block
, -1);
1421 verbose_option
= tmp
;
1422 set_next_block_after (block
);
1425 /* Add a multi volume header to the current archive. The exact header format
1426 depends on the archive format. */
1428 add_multi_volume_header (void)
1430 if (archive_format
== POSIX_FORMAT
)
1432 off_t d
= real_s_totsize
- real_s_sizeleft
;
1433 xheader_store ("GNU.volume.filename", &dummy
, real_s_name
);
1434 xheader_store ("GNU.volume.size", &dummy
, &real_s_sizeleft
);
1435 xheader_store ("GNU.volume.offset", &dummy
, &d
);
1438 gnu_add_multi_volume_header ();
1441 /* Synchronize multi-volume globals */
1443 multi_volume_sync ()
1445 if (multi_volume_option
)
1449 assign_string (&real_s_name
,
1450 safer_name_suffix (save_name
, false,
1451 absolute_names_option
));
1452 real_s_totsize
= save_totsize
;
1453 real_s_sizeleft
= save_sizeleft
;
1457 assign_string (&real_s_name
, 0);
1459 real_s_sizeleft
= 0;
1465 /* Low-level flush functions */
1467 /* Simple flush read (no multi-volume or label extensions) */
1469 simple_flush_read (void)
1471 size_t status
; /* result from system call */
1473 checkpoint_run (false);
1475 /* Clear the count of errors. This only applies to a single call to
1478 read_error_count
= 0; /* clear error count */
1480 if (write_archive_to_stdout
&& record_start_block
!= 0)
1482 archive
= STDOUT_FILENO
;
1483 status
= sys_write_archive_buffer ();
1484 archive
= STDIN_FILENO
;
1485 if (status
!= record_size
)
1486 archive_write_error (status
);
1491 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1492 if (status
== record_size
)
1497 if (status
== SAFE_READ_ERROR
)
1499 archive_read_error ();
1500 continue; /* try again */
1504 short_read (status
);
1507 /* Simple flush write (no multi-volume or label extensions) */
1509 simple_flush_write (size_t level
__attribute__((unused
)))
1513 status
= _flush_write ();
1514 if (status
!= record_size
)
1515 archive_write_error (status
);
1519 bytes_written
+= status
;
1524 /* GNU flush functions. These support multi-volume and archive labels in
1525 GNU and PAX archive formats. */
1528 _gnu_flush_read (void)
1530 size_t status
; /* result from system call */
1532 checkpoint_run (false);
1534 /* Clear the count of errors. This only applies to a single call to
1537 read_error_count
= 0; /* clear error count */
1539 if (write_archive_to_stdout
&& record_start_block
!= 0)
1541 archive
= STDOUT_FILENO
;
1542 status
= sys_write_archive_buffer ();
1543 archive
= STDIN_FILENO
;
1544 if (status
!= record_size
)
1545 archive_write_error (status
);
1548 multi_volume_sync ();
1552 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1553 if (status
== record_size
)
1559 /* The condition below used to include
1560 || (status > 0 && !read_full_records)
1561 This is incorrect since even if new_volume() succeeds, the
1562 subsequent call to rmtread will overwrite the chunk of data
1563 already read in the buffer, so the processing will fail */
1565 || (status
== SAFE_READ_ERROR
&& errno
== ENOSPC
))
1566 && multi_volume_option
)
1568 while (!try_new_volume ())
1570 if (current_block
== record_end
)
1571 /* Necessary for blocking_factor == 1 */
1575 else if (status
== SAFE_READ_ERROR
)
1577 archive_read_error ();
1582 short_read (status
);
1586 gnu_flush_read (void)
1588 flush_read_ptr
= simple_flush_read
; /* Avoid recursion */
1590 flush_read_ptr
= gnu_flush_read
;
1594 _gnu_flush_write (size_t buffer_level
)
1597 union block
*header
;
1603 status
= _flush_write ();
1604 if (status
!= record_size
&& !multi_volume_option
)
1605 archive_write_error (status
);
1610 bytes_written
+= status
;
1613 if (status
== record_size
)
1615 multi_volume_sync ();
1619 if (status
% BLOCKSIZE
)
1621 ERROR ((0, 0, _("write did not end on a block boundary")));
1622 archive_write_error (status
);
1625 /* In multi-volume mode. */
1626 /* ENXIO is for the UNIX PC. */
1627 if (status
< 0 && errno
!= ENOSPC
&& errno
!= EIO
&& errno
!= ENXIO
)
1628 archive_write_error (status
);
1630 real_s_sizeleft
-= status
;
1631 if (!new_volume (ACCESS_WRITE
))
1634 tar_stat_destroy (&dummy
);
1636 increase_volume_number ();
1637 prev_written
+= bytes_written
;
1640 copy_ptr
= record_start
->buffer
+ status
;
1641 copy_size
= buffer_level
- status
;
1643 /* Switch to the next buffer */
1644 record_index
= !record_index
;
1647 if (volume_label_option
)
1648 add_volume_label ();
1651 add_multi_volume_header ();
1653 write_extended (true, &dummy
, find_next_block ());
1654 tar_stat_destroy (&dummy
);
1657 add_chunk_header ();
1658 wrt
= bytes_written
;
1659 header
= find_next_block ();
1660 bufsize
= available_space_after (header
);
1661 while (bufsize
< copy_size
)
1663 memcpy (header
->buffer
, copy_ptr
, bufsize
);
1664 copy_ptr
+= bufsize
;
1665 copy_size
-= bufsize
;
1666 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
1667 header
= find_next_block ();
1668 bufsize
= available_space_after (header
);
1670 memcpy (header
->buffer
, copy_ptr
, copy_size
);
1671 memset (header
->buffer
+ copy_size
, 0, bufsize
- copy_size
);
1672 set_next_block_after (header
+ (copy_size
- 1) / BLOCKSIZE
);
1673 if (multi_volume_option
&& wrt
< bytes_written
)
1675 /* The value of bytes_written has changed while moving data;
1676 that means that flush_archive was executed at least once in
1677 between, and, as a consequence, copy_size bytes were not written
1678 to disk. We need to update sizeleft variables to compensate for
1680 save_sizeleft
+= copy_size
;
1681 multi_volume_sync ();
1687 gnu_flush_write (size_t buffer_level
)
1689 flush_write_ptr
= simple_flush_write
; /* Avoid recursion */
1690 _gnu_flush_write (buffer_level
);
1691 flush_write_ptr
= gnu_flush_write
;
1703 flush_write_ptr (record_size
);
1707 open_archive (enum access_mode wanted_access
)
1709 flush_read_ptr
= gnu_flush_read
;
1710 flush_write_ptr
= gnu_flush_write
;
1712 _open_archive (wanted_access
);
1713 switch (wanted_access
)
1716 if (volume_label_option
)
1717 match_volume_label ();
1721 records_written
= 0;
1722 if (volume_label_option
)
1723 write_volume_label ();
1729 set_volume_start_time ();