1 /* Buffer management for tar.
3 Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003, 2004, 2005, 2006 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 2, 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>
36 /* Number of retries before giving up on read. */
37 #define READ_ERROR_MAX 10
39 /* Globbing pattern to append to volume label if initial match failed. */
40 #define VOLUME_LABEL_APPEND " Volume [1-9]*"
44 static tarlong prev_written
; /* bytes written on previous volumes */
45 static tarlong bytes_written
; /* bytes written on this volume */
46 static void *record_buffer
[2]; /* allocated memory */
47 union block
*record_buffer_aligned
[2];
48 static int record_index
;
50 /* FIXME: The following variables should ideally be static to this
51 module. However, this cannot be done yet. The cleanup continues! */
53 union block
*record_start
; /* start of record of archive */
54 union block
*record_end
; /* last+1 block of archive record */
55 union block
*current_block
; /* current block of archive */
56 enum access_mode access_mode
; /* how do we handle the archive */
57 off_t records_read
; /* number of records read from this archive */
58 off_t records_written
; /* likewise, for records written */
60 static off_t record_start_block
; /* block ordinal at record_start */
62 /* Where we write list messages (not errors, not interactions) to. */
65 static void backspace_output (void);
67 /* PID of child program, if compress_option or remote archive access. */
68 static pid_t child_pid
;
70 /* Error recovery stuff */
71 static int read_error_count
;
73 /* Have we hit EOF yet? */
76 /* Checkpointing counter */
77 static int checkpoint
;
79 static bool read_full_records
= false;
81 /* We're reading, but we just read the last block and it's time to update.
84 As least EXTERN like this one as possible. (?? --gray)
85 FIXME: Either eliminate it or move it to common.h.
87 extern bool time_to_start_writing
;
89 bool write_archive_to_stdout
;
91 void (*flush_write_ptr
) (size_t);
92 void (*flush_read_ptr
) (void);
96 char *continued_file_name
;
97 uintmax_t continued_file_size
;
98 uintmax_t continued_file_offset
;
101 static int volno
= 1; /* which volume of a multi-volume tape we're
103 static int global_volno
= 1; /* volume number to print in external
106 bool write_archive_to_stdout
;
108 /* Used by flush_read and flush_write to store the real info about saved
110 static char *real_s_name
;
111 static off_t real_s_totsize
;
112 static off_t real_s_sizeleft
;
115 /* Multi-volume tracking support */
116 static char *save_name
; /* name of the file we are currently writing */
117 static off_t save_totsize
; /* total size of file we are writing, only
118 valid if save_name is nonzero */
119 static off_t save_sizeleft
; /* where we are in the file we are writing,
120 only valid if save_name is nonzero */
123 mv_begin (struct tar_stat_info
*st
)
125 if (multi_volume_option
)
127 assign_string (&save_name
, st
->orig_file_name
);
128 save_totsize
= save_sizeleft
= st
->stat
.st_size
;
135 if (multi_volume_option
)
136 assign_string (&save_name
, 0);
140 mv_total_size (off_t size
)
146 mv_size_left (off_t size
)
148 save_sizeleft
= size
;
155 clear_read_error_count (void)
157 read_error_count
= 0;
161 /* Time-related functions */
168 gettime (&start_time
);
176 duration
+= ((now
.tv_sec
- start_time
.tv_sec
)
177 + (now
.tv_nsec
- start_time
.tv_nsec
) / 1e9
);
182 /* Compression detection */
193 enum compress_type type
;
200 static struct zip_magic
const magic
[] = {
202 { ct_compress
, 2, "\037\235", "compress", "-Z" },
203 { ct_gzip
, 2, "\037\213", "gzip", "-z" },
204 { ct_bzip2
, 3, "BZh", "bzip2", "-j" },
207 #define NMAGIC (sizeof(magic)/sizeof(magic[0]))
209 #define compress_option(t) magic[t].option
210 #define compress_program(t) magic[t].program
212 /* Check if the file ARCHIVE is a compressed archive. */
214 check_compressed_archive ()
216 struct zip_magic
const *p
;
219 /* Prepare global data needed for find_next_block: */
220 record_end
= record_start
; /* set up for 1st record = # 0 */
221 sfr
= read_full_records
;
222 read_full_records
= true; /* Suppress fatal error on reading a partial
226 /* Restore global values */
227 read_full_records
= sfr
;
229 if (tar_checksum (record_start
, true) == HEADER_SUCCESS
)
230 /* Probably a valid header */
233 for (p
= magic
+ 1; p
< magic
+ NMAGIC
; p
++)
234 if (memcmp (record_start
->buffer
, p
->magic
, p
->length
) == 0)
240 /* Open an archive named archive_name_array[0]. Detect if it is
241 a compressed archive of known type and use corresponding decompression
244 open_compressed_archive ()
246 archive
= rmtopen (archive_name_array
[0], O_RDONLY
| O_BINARY
,
247 MODE_RW
, rsh_command_option
);
251 if (!multi_volume_option
)
253 enum compress_type type
= check_compressed_archive ();
258 /* FD is not needed any more */
261 hit_eof
= false; /* It might have been set by find_next_block in
262 check_compressed_archive */
264 /* Open compressed archive */
265 use_compress_program_option
= compress_program (type
);
266 child_pid
= sys_child_open_for_uncompress ();
267 read_full_records
= true;
271 record_end
= record_start
; /* set up for 1st record = # 0 */
278 print_total_written (void)
280 tarlong written
= prev_written
+ bytes_written
;
281 char bytes
[sizeof (tarlong
) * CHAR_BIT
];
282 char abbr
[LONGEST_HUMAN_READABLE
+ 1];
283 char rate
[LONGEST_HUMAN_READABLE
+ 1];
285 int human_opts
= human_autoscale
| human_base_1024
| human_SI
| human_B
;
287 sprintf (bytes
, TARLONG_FORMAT
, written
);
289 /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */
290 fprintf (stderr
, _("Total bytes written: %s (%s, %s/s)\n"), bytes
,
291 human_readable (written
, abbr
, human_opts
, 1, 1),
292 (0 < duration
&& written
/ duration
< (uintmax_t) -1
293 ? human_readable (written
/ duration
, rate
, human_opts
, 1, 1)
297 /* Compute and return the block ordinal at current_block. */
299 current_block_ordinal (void)
301 return record_start_block
+ (current_block
- record_start
);
304 /* If the EOF flag is set, reset it, as well as current_block, etc. */
311 current_block
= record_start
;
312 record_end
= record_start
+ blocking_factor
;
313 access_mode
= ACCESS_WRITE
;
317 /* Return the location of the next available input or output block.
318 Return zero for EOF. Once we have returned zero, we just keep returning
319 it, to avoid accidentally going on to the next file on the tape. */
321 find_next_block (void)
323 if (current_block
== record_end
)
328 if (current_block
== record_end
)
334 return current_block
;
337 /* Indicate that we have used all blocks up thru BLOCK. */
339 set_next_block_after (union block
*block
)
341 while (block
>= current_block
)
344 /* Do *not* flush the archive here. If we do, the same argument to
345 set_next_block_after could mean the next block (if the input record
346 is exactly one block long), which is not what is intended. */
348 if (current_block
> record_end
)
352 /* Return the number of bytes comprising the space between POINTER
353 through the end of the current buffer of blocks. This space is
354 available for filling with data, or taking data from. POINTER is
355 usually (but not always) the result of previous find_next_block call. */
357 available_space_after (union block
*pointer
)
359 return record_end
->buffer
- pointer
->buffer
;
362 /* Close file having descriptor FD, and abort if close unsuccessful. */
367 close_error (_("(pipe)"));
373 if (! record_buffer_aligned
[record_index
])
374 record_buffer_aligned
[record_index
] =
375 page_aligned_alloc (&record_buffer
[record_index
], record_size
);
377 record_start
= record_buffer_aligned
[record_index
];
378 current_block
= record_start
;
379 record_end
= record_start
+ blocking_factor
;
382 /* Open an archive file. The argument specifies whether we are
383 reading or writing, or both. */
385 _open_archive (enum access_mode wanted_access
)
387 int backed_up_flag
= 0;
391 stdlis
= freopen (index_file_name
, "w", stdout
);
393 open_error (index_file_name
);
394 close_stdout_set_file_name (index_file_name
);
397 stdlis
= to_stdout_option
? stderr
: stdout
;
399 if (record_size
== 0)
400 FATAL_ERROR ((0, 0, _("Invalid value for record_size")));
402 if (archive_names
== 0)
403 FATAL_ERROR ((0, 0, _("No archive name given")));
405 tar_stat_destroy (¤t_stat_info
);
412 /* When updating the archive, we start with reading. */
413 access_mode
= wanted_access
== ACCESS_UPDATE
? ACCESS_READ
: wanted_access
;
415 read_full_records
= read_full_records_option
;
419 if (use_compress_program_option
)
421 switch (wanted_access
)
424 child_pid
= sys_child_open_for_uncompress ();
425 read_full_records
= true;
426 record_end
= record_start
; /* set up for 1st record = # 0 */
430 child_pid
= sys_child_open_for_compress ();
434 abort (); /* Should not happen */
438 if (wanted_access
== ACCESS_WRITE
439 && strcmp (archive_name_array
[0], "-") == 0)
442 else if (strcmp (archive_name_array
[0], "-") == 0)
444 read_full_records
= true; /* could be a pipe, be safe */
446 FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
448 switch (wanted_access
)
452 enum compress_type type
;
454 archive
= STDIN_FILENO
;
456 type
= check_compressed_archive ();
459 _("Archive is compressed. Use %s option"),
460 compress_option (type
)));
465 archive
= STDOUT_FILENO
;
470 archive
= STDIN_FILENO
;
472 write_archive_to_stdout
= true;
476 else if (verify_option
)
477 archive
= rmtopen (archive_name_array
[0], O_RDWR
| O_CREAT
| O_BINARY
,
478 MODE_RW
, rsh_command_option
);
480 switch (wanted_access
)
483 archive
= open_compressed_archive ();
489 maybe_backup_file (archive_name_array
[0], 1);
492 archive
= rmtcreat (archive_name_array
[0], MODE_RW
,
497 archive
= rmtopen (archive_name_array
[0], O_RDWR
| O_CREAT
| O_BINARY
,
498 MODE_RW
, rsh_command_option
);
503 || (! _isrmt (archive
) && !sys_get_archive_stat ()))
505 int saved_errno
= errno
;
510 open_fatal (archive_name_array
[0]);
513 sys_detect_dev_null_output ();
514 sys_save_archive_dev_ino ();
515 SET_BINARY_MODE (archive
);
517 switch (wanted_access
)
521 record_end
= record_start
; /* set up for 1st record = # 0 */
524 find_next_block (); /* read it in, check for EOF */
533 /* Perform a write to flush the buffer. */
539 if (checkpoint_option
&& !(++checkpoint
% 10))
540 /* TRANSLATORS: This is a ``checkpoint of write operation'',
541 *not* ``Writing a checkpoint''.
542 E.g. in Spanish ``Punto de comprobaci@'on de escritura'',
543 *not* ``Escribiendo un punto de comprobaci@'on'' */
544 WARN ((0, 0, _("Write checkpoint %d"), checkpoint
));
546 if (tape_length_option
&& tape_length_option
<= bytes_written
)
551 else if (dev_null_output
)
552 status
= record_size
;
554 status
= sys_write_archive_buffer ();
559 /* Handle write errors on the archive. Write errors are always fatal.
560 Hitting the end of a volume does not cause a write error unless the
561 write was the first record of the volume. */
563 archive_write_error (ssize_t status
)
565 /* It might be useful to know how much was written before the error
570 print_total_written ();
574 write_fatal_details (*archive_name_cursor
, status
, record_size
);
577 /* Handle read errors on the archive. If the read should be retried,
578 return to the caller. */
580 archive_read_error (void)
582 read_error (*archive_name_cursor
);
584 if (record_start_block
== 0)
585 FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
587 /* Read error in mid archive. We retry up to READ_ERROR_MAX times and
588 then give up on reading the archive. */
590 if (read_error_count
++ > READ_ERROR_MAX
)
591 FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
596 short_read (size_t status
)
598 size_t left
; /* bytes left */
599 char *more
; /* pointer to next byte to read */
601 more
= record_start
->buffer
+ status
;
602 left
= record_size
- status
;
604 while (left
% BLOCKSIZE
!= 0
605 || (left
&& status
&& read_full_records
))
608 while ((status
= rmtread (archive
, more
, left
)) == SAFE_READ_ERROR
)
609 archive_read_error ();
614 if (! read_full_records
)
616 unsigned long rest
= record_size
- left
;
619 ngettext ("Unaligned block (%lu byte) in archive",
620 "Unaligned block (%lu bytes) in archive",
625 /* User warned us about this. Fix up. */
631 /* FIXME: for size=0, multi-volume support. On the first record, warn
632 about the problem. */
634 if (!read_full_records
&& verbose_option
> 1
635 && record_start_block
== 0 && status
!= 0)
637 unsigned long rsize
= (record_size
- left
) / BLOCKSIZE
;
639 ngettext ("Record size = %lu block",
640 "Record size = %lu blocks",
645 record_end
= record_start
+ (record_size
- left
) / BLOCKSIZE
;
649 /* Perform a read to flush the buffer. */
653 size_t status
; /* result from system call */
655 if (checkpoint_option
&& !(++checkpoint
% 10))
656 /* TRANSLATORS: This is a ``checkpoint of read operation'',
657 *not* ``Reading a checkpoint''.
658 E.g. in Spanish ``Punto de comprobaci@'on de lectura'',
659 *not* ``Leyendo un punto de comprobaci@'on'' */
660 WARN ((0, 0, _("Read checkpoint %d"), checkpoint
));
662 /* Clear the count of errors. This only applies to a single call to
665 read_error_count
= 0; /* clear error count */
667 if (write_archive_to_stdout
&& record_start_block
!= 0)
669 archive
= STDOUT_FILENO
;
670 status
= sys_write_archive_buffer ();
671 archive
= STDIN_FILENO
;
672 if (status
!= record_size
)
673 archive_write_error (status
);
676 status
= rmtread (archive
, record_start
->buffer
, record_size
);
677 if (status
== record_size
)
682 /* Flush the current buffer to/from the archive. */
686 size_t buffer_level
= current_block
->buffer
- record_start
->buffer
;
687 record_start_block
+= record_end
- record_start
;
688 current_block
= record_start
;
689 record_end
= record_start
+ blocking_factor
;
691 if (access_mode
== ACCESS_READ
&& time_to_start_writing
)
693 access_mode
= ACCESS_WRITE
;
694 time_to_start_writing
= false;
705 flush_write_ptr (buffer_level
);
713 /* Backspace the archive descriptor by one record worth. If it's a
714 tape, MTIOCTOP will work. If it's something else, try to seek on
715 it. If we can't seek, we lose! */
717 backspace_output (void)
721 struct mtop operation
;
723 operation
.mt_op
= MTBSR
;
724 operation
.mt_count
= 1;
725 if (rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
727 if (errno
== EIO
&& rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
733 off_t position
= rmtlseek (archive
, (off_t
) 0, SEEK_CUR
);
735 /* Seek back to the beginning of this record and start writing there. */
737 position
-= record_size
;
740 if (rmtlseek (archive
, position
, SEEK_SET
) != position
)
742 /* Lseek failed. Try a different method. */
745 _("Cannot backspace archive file; it may be unreadable without -i")));
747 /* Replace the first part of the record with NULs. */
749 if (record_start
->buffer
!= output_start
)
750 memset (record_start
->buffer
, 0,
751 output_start
- record_start
->buffer
);
757 seek_archive (off_t size
)
759 off_t start
= current_block_ordinal ();
762 off_t skipped
= (blocking_factor
- (current_block
- record_start
));
764 size
-= skipped
* BLOCKSIZE
;
766 if (size
< record_size
)
770 /* Compute number of records to skip */
771 nrec
= size
/ record_size
;
772 offset
= rmtlseek (archive
, nrec
* record_size
, SEEK_CUR
);
776 if (offset
% record_size
)
777 FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary")));
779 /* Convert to number of records */
781 /* Compute number of skipped blocks */
782 nblk
= offset
- start
;
784 /* Update buffering info */
785 records_read
+= nblk
/ blocking_factor
;
786 record_start_block
= offset
- blocking_factor
;
787 current_block
= record_end
;
792 /* Close the archive file. */
796 if (time_to_start_writing
|| access_mode
== ACCESS_WRITE
)
799 if (current_block
> record_start
)
803 sys_drain_input_pipe ();
809 if (rmtclose (archive
) != 0)
810 close_warn (*archive_name_cursor
);
812 sys_wait_for_child (child_pid
);
814 tar_stat_destroy (¤t_stat_info
);
819 free (record_buffer
[0]);
820 free (record_buffer
[1]);
823 /* Called to initialize the global volume number. */
825 init_volume_number (void)
827 FILE *file
= fopen (volno_file_option
, "r");
831 if (fscanf (file
, "%d", &global_volno
) != 1
833 FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"),
834 quotearg_colon (volno_file_option
)));
836 read_error (volno_file_option
);
837 if (fclose (file
) != 0)
838 close_error (volno_file_option
);
840 else if (errno
!= ENOENT
)
841 open_error (volno_file_option
);
844 /* Called to write out the closing global volume number. */
846 closeout_volume_number (void)
848 FILE *file
= fopen (volno_file_option
, "w");
852 fprintf (file
, "%d\n", global_volno
);
854 write_error (volno_file_option
);
855 if (fclose (file
) != 0)
856 close_error (volno_file_option
);
859 open_error (volno_file_option
);
864 increase_volume_number ()
867 if (global_volno
< 0)
868 FATAL_ERROR ((0, 0, _("Volume number overflow")));
873 change_tape_menu (FILE *read_file
)
875 char *input_buffer
= NULL
;
881 fputc ('\007', stderr
);
883 _("Prepare volume #%d for %s and hit return: "),
884 global_volno
+ 1, quote (*archive_name_cursor
));
887 if (getline (&input_buffer
, &size
, read_file
) <= 0)
889 WARN ((0, 0, _("EOF where user reply was expected")));
891 if (subcommand_option
!= EXTRACT_SUBCOMMAND
892 && subcommand_option
!= LIST_SUBCOMMAND
893 && subcommand_option
!= DIFF_SUBCOMMAND
)
894 WARN ((0, 0, _("WARNING: Archive is incomplete")));
899 if (input_buffer
[0] == '\n'
900 || input_buffer
[0] == 'y'
901 || input_buffer
[0] == 'Y')
904 switch (input_buffer
[0])
908 fprintf (stderr
, _("\
909 n name Give a new file name for the next (and subsequent) volume(s)\n\
911 y or newline Continue operation\n"));
912 if (!restrict_option
)
913 fprintf (stderr
, _(" ! Spawn a subshell\n"));
914 fprintf (stderr
, _(" ? Print this list\n"));
921 WARN ((0, 0, _("No new volume; exiting.\n")));
923 if (subcommand_option
!= EXTRACT_SUBCOMMAND
924 && subcommand_option
!= LIST_SUBCOMMAND
925 && subcommand_option
!= DIFF_SUBCOMMAND
)
926 WARN ((0, 0, _("WARNING: Archive is incomplete")));
931 /* Get new file name. */
937 for (name
= input_buffer
+ 1;
938 *name
== ' ' || *name
== '\t';
942 for (cursor
= name
; *cursor
&& *cursor
!= '\n'; cursor
++)
948 /* FIXME: the following allocation is never reclaimed. */
949 *archive_name_cursor
= xstrdup (name
);
953 fprintf (stderr
, "%s",
954 _("File name not specified. Try again.\n"));
959 if (!restrict_option
)
967 fprintf (stderr
, _("Invalid input. Type ? for help.\n"));
973 /* We've hit the end of the old volume. Close it and open the next one.
974 Return nonzero on success.
977 new_volume (enum access_mode mode
)
979 static FILE *read_file
;
983 if (!read_file
&& !info_script_option
)
984 /* FIXME: if fopen is used, it will never be closed. */
985 read_file
= archive
== STDIN_FILENO
? fopen (TTY_NAME
, "r") : stdin
;
992 assign_string (&volume_label
, NULL
);
993 assign_string (&continued_file_name
, NULL
);
994 continued_file_size
= continued_file_offset
= 0;
996 if (rmtclose (archive
) != 0)
997 close_warn (*archive_name_cursor
);
999 archive_name_cursor
++;
1000 if (archive_name_cursor
== archive_name_array
+ archive_names
)
1002 archive_name_cursor
= archive_name_array
;
1010 /* We have to prompt from now on. */
1012 if (info_script_option
)
1014 if (volno_file_option
)
1015 closeout_volume_number ();
1016 if (sys_exec_info_script (archive_name_cursor
, global_volno
+1))
1017 FATAL_ERROR ((0, 0, _("%s command failed"),
1018 quote (info_script_option
)));
1021 change_tape_menu (read_file
);
1024 if (strcmp (archive_name_cursor
[0], "-") == 0)
1026 read_full_records
= true;
1027 archive
= STDIN_FILENO
;
1029 else if (verify_option
)
1030 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1031 rsh_command_option
);
1036 archive
= rmtopen (*archive_name_cursor
, O_RDONLY
, MODE_RW
,
1037 rsh_command_option
);
1042 maybe_backup_file (*archive_name_cursor
, 1);
1043 archive
= rmtcreat (*archive_name_cursor
, MODE_RW
,
1044 rsh_command_option
);
1048 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1049 rsh_command_option
);
1055 open_warn (*archive_name_cursor
);
1056 if (!verify_option
&& mode
== ACCESS_WRITE
&& backup_option
)
1057 undo_last_backup ();
1062 SET_BINARY_MODE (archive
);
1068 read_header0 (struct tar_stat_info
*info
)
1070 enum read_header rc
;
1072 tar_stat_init (info
);
1073 rc
= read_header_primitive (false, info
);
1074 if (rc
== HEADER_SUCCESS
)
1076 set_next_block_after (current_header
);
1079 ERROR ((0, 0, _("This does not look like a tar archive")));
1087 union block
*header
;
1088 struct tar_stat_info dummy
;
1090 switch (subcommand_option
)
1092 case APPEND_SUBCOMMAND
:
1093 case CAT_SUBCOMMAND
:
1094 case UPDATE_SUBCOMMAND
:
1095 if (!new_volume (ACCESS_UPDATE
))
1100 if (!new_volume (ACCESS_READ
))
1105 while ((status
= rmtread (archive
, record_start
->buffer
, record_size
))
1107 archive_read_error ();
1109 if (status
!= record_size
)
1110 short_read (status
);
1112 header
= find_next_block ();
1116 switch (header
->header
.typeflag
)
1120 if (!read_header0 (&dummy
))
1122 xheader_decode (&dummy
); /* decodes values from the global header */
1123 tar_stat_destroy (&dummy
);
1126 /* We have read the extended header of the first member in
1127 this volume. Put it back, so next read_header works as
1129 current_block
= record_start
;
1134 case GNUTYPE_VOLHDR
:
1135 if (!read_header0 (&dummy
))
1137 tar_stat_destroy (&dummy
);
1138 assign_string (&volume_label
, current_header
->header
.name
);
1139 set_next_block_after (header
);
1140 header
= find_next_block ();
1141 if (header
->header
.typeflag
!= GNUTYPE_MULTIVOL
)
1145 case GNUTYPE_MULTIVOL
:
1146 if (!read_header0 (&dummy
))
1148 tar_stat_destroy (&dummy
);
1149 assign_string (&continued_file_name
, current_header
->header
.name
);
1150 continued_file_size
=
1151 UINTMAX_FROM_HEADER (current_header
->header
.size
);
1152 continued_file_offset
=
1153 UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
);
1163 if (!continued_file_name
1164 || strcmp (continued_file_name
, real_s_name
))
1166 if ((archive_format
== GNU_FORMAT
|| archive_format
== OLDGNU_FORMAT
)
1167 && strlen (real_s_name
) >= NAME_FIELD_SIZE
1168 && strncmp (continued_file_name
, real_s_name
,
1169 NAME_FIELD_SIZE
) == 0)
1171 _("%s is possibly continued on this volume: header contains truncated name"),
1172 quote (real_s_name
)));
1175 WARN ((0, 0, _("%s is not continued on this volume"),
1176 quote (real_s_name
)));
1181 s
= continued_file_size
+ continued_file_offset
;
1183 if (real_s_totsize
!= s
|| s
< continued_file_offset
)
1185 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1186 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1187 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1189 WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
1190 quote (continued_file_name
),
1191 STRINGIFY_BIGINT (save_totsize
, totsizebuf
),
1192 STRINGIFY_BIGINT (continued_file_size
, s1buf
),
1193 STRINGIFY_BIGINT (continued_file_offset
, s2buf
)));
1197 if (real_s_totsize
- real_s_sizeleft
!= continued_file_offset
)
1199 WARN ((0, 0, _("This volume is out of sequence")));
1204 increase_volume_number ();
1209 /* Check the LABEL block against the volume label, seen as a globbing
1210 pattern. Return true if the pattern matches. In case of failure,
1211 retry matching a volume sequence number before giving up in
1212 multi-volume mode. */
1214 check_label_pattern (union block
*label
)
1219 if (! memchr (label
->header
.name
, '\0', sizeof label
->header
.name
))
1222 if (fnmatch (volume_label_option
, label
->header
.name
, 0) == 0)
1225 if (!multi_volume_option
)
1228 string
= xmalloc (strlen (volume_label_option
)
1229 + sizeof VOLUME_LABEL_APPEND
+ 1);
1230 strcpy (string
, volume_label_option
);
1231 strcat (string
, VOLUME_LABEL_APPEND
);
1232 result
= fnmatch (string
, label
->header
.name
, 0) == 0;
1237 /* Check if the next block contains a volume label and if this matches
1238 the one given in the command line */
1240 match_volume_label (void)
1242 union block
*label
= find_next_block ();
1245 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1246 quote (volume_label_option
)));
1247 if (!check_label_pattern (label
))
1248 FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
1249 quote_n (0, label
->header
.name
),
1250 quote_n (1, volume_label_option
)));
1253 /* Mark the archive with volume label STR. */
1255 _write_volume_label (const char *str
)
1257 if (archive_format
== POSIX_FORMAT
)
1258 xheader_store ("GNU.volume.label", NULL
, str
);
1261 union block
*label
= find_next_block ();
1263 memset (label
, 0, BLOCKSIZE
);
1265 strcpy (label
->header
.name
, volume_label_option
);
1266 assign_string (¤t_stat_info
.file_name
,
1267 label
->header
.name
);
1268 current_stat_info
.had_trailing_slash
=
1269 strip_trailing_slashes (current_stat_info
.file_name
);
1271 label
->header
.typeflag
= GNUTYPE_VOLHDR
;
1272 TIME_TO_CHARS (start_time
.tv_sec
, label
->header
.mtime
);
1273 finish_header (¤t_stat_info
, label
, -1);
1274 set_next_block_after (label
);
1278 #define VOL_SUFFIX "Volume"
1280 /* Add a volume label to a part of multi-volume archive */
1282 add_volume_label (void)
1284 char buf
[UINTMAX_STRSIZE_BOUND
];
1285 char *p
= STRINGIFY_BIGINT (volno
, buf
);
1286 char *s
= xmalloc (strlen (volume_label_option
) + sizeof VOL_SUFFIX
1288 sprintf (s
, "%s %s %s", volume_label_option
, VOL_SUFFIX
, p
);
1289 _write_volume_label (s
);
1296 if (archive_format
== POSIX_FORMAT
)
1298 off_t block_ordinal
;
1300 struct tar_stat_info st
;
1301 static size_t real_s_part_no
; /* FIXME */
1304 memset (&st
, 0, sizeof st
);
1305 st
.orig_file_name
= st
.file_name
= real_s_name
;
1306 st
.stat
.st_mode
= S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
;
1307 st
.stat
.st_uid
= getuid ();
1308 st
.stat
.st_gid
= getgid ();
1309 st
.orig_file_name
= xheader_format_name (&st
,
1310 "%d/GNUFileParts.%p/%f.%n",
1312 st
.file_name
= st
.orig_file_name
;
1313 st
.archive_file_size
= st
.stat
.st_size
= real_s_sizeleft
;
1315 block_ordinal
= current_block_ordinal ();
1316 blk
= start_header (&st
);
1318 abort (); /* FIXME */
1319 finish_header (&st
, blk
, block_ordinal
);
1320 free (st
.orig_file_name
);
1325 /* Add a volume label to the current archive */
1327 write_volume_label (void)
1329 if (multi_volume_option
)
1330 add_volume_label ();
1332 _write_volume_label (volume_label_option
);
1335 /* Write GNU multi-volume header */
1337 gnu_add_multi_volume_header (void)
1340 union block
*block
= find_next_block ();
1342 if (strlen (real_s_name
) > NAME_FIELD_SIZE
)
1344 _("%s: file name too long to be stored in a GNU multivolume header, truncated"),
1345 quotearg_colon (real_s_name
)));
1347 memset (block
, 0, BLOCKSIZE
);
1349 /* FIXME: Michael P Urban writes: [a long name file] is being written
1350 when a new volume rolls around [...] Looks like the wrong value is
1351 being preserved in real_s_name, though. */
1353 strncpy (block
->header
.name
, real_s_name
, NAME_FIELD_SIZE
);
1354 block
->header
.typeflag
= GNUTYPE_MULTIVOL
;
1356 OFF_TO_CHARS (real_s_sizeleft
, block
->header
.size
);
1357 OFF_TO_CHARS (real_s_totsize
- real_s_sizeleft
,
1358 block
->oldgnu_header
.offset
);
1360 tmp
= verbose_option
;
1362 finish_header (¤t_stat_info
, block
, -1);
1363 verbose_option
= tmp
;
1364 set_next_block_after (block
);
1367 /* Add a multi volume header to the current archive. The exact header format
1368 depends on the archive format. */
1370 add_multi_volume_header (void)
1372 if (archive_format
== POSIX_FORMAT
)
1374 off_t d
= real_s_totsize
- real_s_sizeleft
;
1375 xheader_store ("GNU.volume.filename", NULL
, real_s_name
);
1376 xheader_store ("GNU.volume.size", NULL
, &real_s_sizeleft
);
1377 xheader_store ("GNU.volume.offset", NULL
, &d
);
1380 gnu_add_multi_volume_header ();
1383 /* Synchronize multi-volume globals */
1385 multi_volume_sync ()
1387 if (multi_volume_option
)
1391 assign_string (&real_s_name
,
1392 safer_name_suffix (save_name
, false,
1393 absolute_names_option
));
1394 real_s_totsize
= save_totsize
;
1395 real_s_sizeleft
= save_sizeleft
;
1399 assign_string (&real_s_name
, 0);
1401 real_s_sizeleft
= 0;
1407 /* Low-level flush functions */
1409 /* Simple flush read (no multi-volume or label extensions) */
1411 simple_flush_read (void)
1413 size_t status
; /* result from system call */
1415 if (checkpoint_option
&& !(++checkpoint
% 10))
1416 /* TRANSLATORS: This is a ``checkpoint of read operation'',
1417 *not* ``Reading a checkpoint''.
1418 E.g. in Spanish ``Punto de comprobaci@'on de lectura'',
1419 *not* ``Leyendo un punto de comprobaci@'on'' */
1420 WARN ((0, 0, _("Read checkpoint %d"), checkpoint
));
1422 /* Clear the count of errors. This only applies to a single call to
1425 read_error_count
= 0; /* clear error count */
1427 if (write_archive_to_stdout
&& record_start_block
!= 0)
1429 archive
= STDOUT_FILENO
;
1430 status
= sys_write_archive_buffer ();
1431 archive
= STDIN_FILENO
;
1432 if (status
!= record_size
)
1433 archive_write_error (status
);
1438 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1439 if (status
== record_size
)
1444 if (status
== SAFE_READ_ERROR
)
1446 archive_read_error ();
1447 continue; /* try again */
1451 short_read (status
);
1454 /* Simple flush write (no multi-volume or label extensions) */
1456 simple_flush_write (size_t level
__attribute__((unused
)))
1460 status
= _flush_write ();
1461 if (status
!= record_size
)
1462 archive_write_error (status
);
1466 bytes_written
+= status
;
1471 /* GNU flush functions. These support multi-volume and archive labels in
1472 GNU and PAX archive formats. */
1475 _gnu_flush_read (void)
1477 size_t status
; /* result from system call */
1479 if (checkpoint_option
&& !(++checkpoint
% 10))
1480 /* TRANSLATORS: This is a ``checkpoint of read operation'',
1481 *not* ``Reading a checkpoint''.
1482 E.g. in Spanish ``Punto de comprobaci@'on de lectura'',
1483 *not* ``Leyendo un punto de comprobaci@'on'' */
1484 WARN ((0, 0, _("Read checkpoint %d"), checkpoint
));
1486 /* Clear the count of errors. This only applies to a single call to
1489 read_error_count
= 0; /* clear error count */
1491 if (write_archive_to_stdout
&& record_start_block
!= 0)
1493 archive
= STDOUT_FILENO
;
1494 status
= sys_write_archive_buffer ();
1495 archive
= STDIN_FILENO
;
1496 if (status
!= record_size
)
1497 archive_write_error (status
);
1500 multi_volume_sync ();
1504 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1505 if (status
== record_size
)
1511 /* The condition below used to include
1512 || (status > 0 && !read_full_records)
1513 This is incorrect since even if new_volume() succeeds, the
1514 subsequent call to rmtread will overwrite the chunk of data
1515 already read in the buffer, so the processing will fail */
1517 || (status
== SAFE_READ_ERROR
&& errno
== ENOSPC
))
1518 && multi_volume_option
)
1520 while (!try_new_volume ())
1524 else if (status
== SAFE_READ_ERROR
)
1526 archive_read_error ();
1531 short_read (status
);
1535 gnu_flush_read (void)
1537 flush_read_ptr
= simple_flush_read
; /* Avoid recursion */
1539 flush_read_ptr
= gnu_flush_read
;
1543 _gnu_flush_write (size_t buffer_level
)
1546 union block
*header
;
1551 status
= _flush_write ();
1552 if (status
!= record_size
&& !multi_volume_option
)
1553 archive_write_error (status
);
1557 bytes_written
+= status
;
1560 if (status
== record_size
)
1562 multi_volume_sync ();
1566 /* In multi-volume mode. */
1567 /* ENXIO is for the UNIX PC. */
1568 if (status
< 0 && errno
!= ENOSPC
&& errno
!= EIO
&& errno
!= ENXIO
)
1569 archive_write_error (status
);
1571 if (!new_volume (ACCESS_WRITE
))
1574 xheader_destroy (&extended_header
);
1576 increase_volume_number ();
1578 prev_written
+= bytes_written
;
1581 copy_ptr
= record_start
->buffer
+ status
;
1582 copy_size
= buffer_level
- status
;
1583 /* Switch to the next buffer */
1584 record_index
= !record_index
;
1587 if (volume_label_option
)
1588 add_volume_label ();
1591 add_multi_volume_header ();
1593 write_extended (true, NULL
, find_next_block ());
1595 add_chunk_header ();
1596 header
= find_next_block ();
1597 bufsize
= available_space_after (header
);
1598 while (bufsize
< copy_size
)
1600 memcpy (header
->buffer
, copy_ptr
, bufsize
);
1601 copy_ptr
+= bufsize
;
1602 copy_size
-= bufsize
;
1603 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
1604 header
= find_next_block ();
1605 bufsize
= available_space_after (header
);
1607 memcpy (header
->buffer
, copy_ptr
, copy_size
);
1608 memset (header
->buffer
+ copy_size
, 0, bufsize
- copy_size
);
1609 set_next_block_after (header
+ (copy_size
- 1) / BLOCKSIZE
);
1614 gnu_flush_write (size_t buffer_level
)
1616 flush_write_ptr
= simple_flush_write
; /* Avoid recursion */
1617 _gnu_flush_write (buffer_level
);
1618 flush_write_ptr
= gnu_flush_write
;
1630 flush_write_ptr (record_size
);
1634 open_archive (enum access_mode wanted_access
)
1636 flush_read_ptr
= gnu_flush_read
;
1637 flush_write_ptr
= gnu_flush_write
;
1639 _open_archive (wanted_access
);
1640 switch (wanted_access
)
1643 if (volume_label_option
)
1644 match_volume_label ();
1648 records_written
= 0;
1649 if (volume_label_option
)
1650 write_volume_label ();