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 unsigned 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 */
534 do_checkpoint (bool write
)
536 if (checkpoint_option
&& !(++checkpoint
% checkpoint_option
))
538 switch (checkpoint_style
)
545 case checkpoint_text
:
547 /* TRANSLATORS: This is a ``checkpoint of write operation'',
548 *not* ``Writing a checkpoint''.
549 E.g. in Spanish ``Punto de comprobaci@'on de escritura'',
550 *not* ``Escribiendo un punto de comprobaci@'on'' */
551 WARN ((0, 0, _("Write checkpoint %u"), checkpoint
));
553 /* TRANSLATORS: This is a ``checkpoint of read operation'',
554 *not* ``Reading a checkpoint''.
555 E.g. in Spanish ``Punto de comprobaci@'on de lectura'',
556 *not* ``Leyendo un punto de comprobaci@'on'' */
557 WARN ((0, 0, _("Read checkpoint %u"), checkpoint
));
563 /* Perform a write to flush the buffer. */
569 do_checkpoint (true);
570 if (tape_length_option
&& tape_length_option
<= bytes_written
)
575 else if (dev_null_output
)
576 status
= record_size
;
578 status
= sys_write_archive_buffer ();
583 /* Handle write errors on the archive. Write errors are always fatal.
584 Hitting the end of a volume does not cause a write error unless the
585 write was the first record of the volume. */
587 archive_write_error (ssize_t status
)
589 /* It might be useful to know how much was written before the error
594 print_total_written ();
598 write_fatal_details (*archive_name_cursor
, status
, record_size
);
601 /* Handle read errors on the archive. If the read should be retried,
602 return to the caller. */
604 archive_read_error (void)
606 read_error (*archive_name_cursor
);
608 if (record_start_block
== 0)
609 FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
611 /* Read error in mid archive. We retry up to READ_ERROR_MAX times and
612 then give up on reading the archive. */
614 if (read_error_count
++ > READ_ERROR_MAX
)
615 FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
620 short_read (size_t status
)
622 size_t left
; /* bytes left */
623 char *more
; /* pointer to next byte to read */
625 more
= record_start
->buffer
+ status
;
626 left
= record_size
- status
;
628 while (left
% BLOCKSIZE
!= 0
629 || (left
&& status
&& read_full_records
))
632 while ((status
= rmtread (archive
, more
, left
)) == SAFE_READ_ERROR
)
633 archive_read_error ();
638 if (! read_full_records
)
640 unsigned long rest
= record_size
- left
;
643 ngettext ("Unaligned block (%lu byte) in archive",
644 "Unaligned block (%lu bytes) in archive",
649 /* User warned us about this. Fix up. */
655 /* FIXME: for size=0, multi-volume support. On the first record, warn
656 about the problem. */
658 if (!read_full_records
&& verbose_option
> 1
659 && record_start_block
== 0 && status
!= 0)
661 unsigned long rsize
= (record_size
- left
) / BLOCKSIZE
;
663 ngettext ("Record size = %lu block",
664 "Record size = %lu blocks",
669 record_end
= record_start
+ (record_size
- left
) / BLOCKSIZE
;
673 /* Flush the current buffer to/from the archive. */
677 size_t buffer_level
= current_block
->buffer
- record_start
->buffer
;
678 record_start_block
+= record_end
- record_start
;
679 current_block
= record_start
;
680 record_end
= record_start
+ blocking_factor
;
682 if (access_mode
== ACCESS_READ
&& time_to_start_writing
)
684 access_mode
= ACCESS_WRITE
;
685 time_to_start_writing
= false;
696 flush_write_ptr (buffer_level
);
704 /* Backspace the archive descriptor by one record worth. If it's a
705 tape, MTIOCTOP will work. If it's something else, try to seek on
706 it. If we can't seek, we lose! */
708 backspace_output (void)
712 struct mtop operation
;
714 operation
.mt_op
= MTBSR
;
715 operation
.mt_count
= 1;
716 if (rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
718 if (errno
== EIO
&& rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
724 off_t position
= rmtlseek (archive
, (off_t
) 0, SEEK_CUR
);
726 /* Seek back to the beginning of this record and start writing there. */
728 position
-= record_size
;
731 if (rmtlseek (archive
, position
, SEEK_SET
) != position
)
733 /* Lseek failed. Try a different method. */
736 _("Cannot backspace archive file; it may be unreadable without -i")));
738 /* Replace the first part of the record with NULs. */
740 if (record_start
->buffer
!= output_start
)
741 memset (record_start
->buffer
, 0,
742 output_start
- record_start
->buffer
);
748 seek_archive (off_t size
)
750 off_t start
= current_block_ordinal ();
753 off_t skipped
= (blocking_factor
- (current_block
- record_start
));
755 size
-= skipped
* BLOCKSIZE
;
757 if (size
< record_size
)
761 /* Compute number of records to skip */
762 nrec
= size
/ record_size
;
763 offset
= rmtlseek (archive
, nrec
* record_size
, SEEK_CUR
);
767 if (offset
% record_size
)
768 FATAL_ERROR ((0, 0, _("rmtlseek not stopped at a record boundary")));
770 /* Convert to number of records */
772 /* Compute number of skipped blocks */
773 nblk
= offset
- start
;
775 /* Update buffering info */
776 records_read
+= nblk
/ blocking_factor
;
777 record_start_block
= offset
- blocking_factor
;
778 current_block
= record_end
;
783 /* Close the archive file. */
787 if (time_to_start_writing
|| access_mode
== ACCESS_WRITE
)
790 if (current_block
> record_start
)
794 sys_drain_input_pipe ();
800 if (rmtclose (archive
) != 0)
801 close_warn (*archive_name_cursor
);
803 sys_wait_for_child (child_pid
);
805 tar_stat_destroy (¤t_stat_info
);
810 free (record_buffer
[0]);
811 free (record_buffer
[1]);
814 /* Called to initialize the global volume number. */
816 init_volume_number (void)
818 FILE *file
= fopen (volno_file_option
, "r");
822 if (fscanf (file
, "%d", &global_volno
) != 1
824 FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"),
825 quotearg_colon (volno_file_option
)));
827 read_error (volno_file_option
);
828 if (fclose (file
) != 0)
829 close_error (volno_file_option
);
831 else if (errno
!= ENOENT
)
832 open_error (volno_file_option
);
835 /* Called to write out the closing global volume number. */
837 closeout_volume_number (void)
839 FILE *file
= fopen (volno_file_option
, "w");
843 fprintf (file
, "%d\n", global_volno
);
845 write_error (volno_file_option
);
846 if (fclose (file
) != 0)
847 close_error (volno_file_option
);
850 open_error (volno_file_option
);
855 increase_volume_number ()
858 if (global_volno
< 0)
859 FATAL_ERROR ((0, 0, _("Volume number overflow")));
864 change_tape_menu (FILE *read_file
)
866 char *input_buffer
= NULL
;
872 fputc ('\007', stderr
);
874 _("Prepare volume #%d for %s and hit return: "),
875 global_volno
+ 1, quote (*archive_name_cursor
));
878 if (getline (&input_buffer
, &size
, read_file
) <= 0)
880 WARN ((0, 0, _("EOF where user reply was expected")));
882 if (subcommand_option
!= EXTRACT_SUBCOMMAND
883 && subcommand_option
!= LIST_SUBCOMMAND
884 && subcommand_option
!= DIFF_SUBCOMMAND
)
885 WARN ((0, 0, _("WARNING: Archive is incomplete")));
890 if (input_buffer
[0] == '\n'
891 || input_buffer
[0] == 'y'
892 || input_buffer
[0] == 'Y')
895 switch (input_buffer
[0])
899 fprintf (stderr
, _("\
900 n name Give a new file name for the next (and subsequent) volume(s)\n\
902 y or newline Continue operation\n"));
903 if (!restrict_option
)
904 fprintf (stderr
, _(" ! Spawn a subshell\n"));
905 fprintf (stderr
, _(" ? Print this list\n"));
912 WARN ((0, 0, _("No new volume; exiting.\n")));
914 if (subcommand_option
!= EXTRACT_SUBCOMMAND
915 && subcommand_option
!= LIST_SUBCOMMAND
916 && subcommand_option
!= DIFF_SUBCOMMAND
)
917 WARN ((0, 0, _("WARNING: Archive is incomplete")));
922 /* Get new file name. */
928 for (name
= input_buffer
+ 1;
929 *name
== ' ' || *name
== '\t';
933 for (cursor
= name
; *cursor
&& *cursor
!= '\n'; cursor
++)
939 /* FIXME: the following allocation is never reclaimed. */
940 *archive_name_cursor
= xstrdup (name
);
944 fprintf (stderr
, "%s",
945 _("File name not specified. Try again.\n"));
950 if (!restrict_option
)
958 fprintf (stderr
, _("Invalid input. Type ? for help.\n"));
964 /* We've hit the end of the old volume. Close it and open the next one.
965 Return nonzero on success.
968 new_volume (enum access_mode mode
)
970 static FILE *read_file
;
974 if (!read_file
&& !info_script_option
)
975 /* FIXME: if fopen is used, it will never be closed. */
976 read_file
= archive
== STDIN_FILENO
? fopen (TTY_NAME
, "r") : stdin
;
983 assign_string (&volume_label
, NULL
);
984 assign_string (&continued_file_name
, NULL
);
985 continued_file_size
= continued_file_offset
= 0;
987 if (rmtclose (archive
) != 0)
988 close_warn (*archive_name_cursor
);
990 archive_name_cursor
++;
991 if (archive_name_cursor
== archive_name_array
+ archive_names
)
993 archive_name_cursor
= archive_name_array
;
1001 /* We have to prompt from now on. */
1003 if (info_script_option
)
1005 if (volno_file_option
)
1006 closeout_volume_number ();
1007 if (sys_exec_info_script (archive_name_cursor
, global_volno
+1))
1008 FATAL_ERROR ((0, 0, _("%s command failed"),
1009 quote (info_script_option
)));
1012 change_tape_menu (read_file
);
1015 if (strcmp (archive_name_cursor
[0], "-") == 0)
1017 read_full_records
= true;
1018 archive
= STDIN_FILENO
;
1020 else if (verify_option
)
1021 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1022 rsh_command_option
);
1027 archive
= rmtopen (*archive_name_cursor
, O_RDONLY
, MODE_RW
,
1028 rsh_command_option
);
1033 maybe_backup_file (*archive_name_cursor
, 1);
1034 archive
= rmtcreat (*archive_name_cursor
, MODE_RW
,
1035 rsh_command_option
);
1039 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1040 rsh_command_option
);
1046 open_warn (*archive_name_cursor
);
1047 if (!verify_option
&& mode
== ACCESS_WRITE
&& backup_option
)
1048 undo_last_backup ();
1053 SET_BINARY_MODE (archive
);
1059 read_header0 (struct tar_stat_info
*info
)
1061 enum read_header rc
;
1063 tar_stat_init (info
);
1064 rc
= read_header_primitive (false, info
);
1065 if (rc
== HEADER_SUCCESS
)
1067 set_next_block_after (current_header
);
1070 ERROR ((0, 0, _("This does not look like a tar archive")));
1078 union block
*header
;
1079 struct tar_stat_info dummy
;
1081 switch (subcommand_option
)
1083 case APPEND_SUBCOMMAND
:
1084 case CAT_SUBCOMMAND
:
1085 case UPDATE_SUBCOMMAND
:
1086 if (!new_volume (ACCESS_UPDATE
))
1091 if (!new_volume (ACCESS_READ
))
1096 while ((status
= rmtread (archive
, record_start
->buffer
, record_size
))
1098 archive_read_error ();
1100 if (status
!= record_size
)
1101 short_read (status
);
1103 header
= find_next_block ();
1107 switch (header
->header
.typeflag
)
1111 if (!read_header0 (&dummy
))
1113 xheader_decode (&dummy
); /* decodes values from the global header */
1114 tar_stat_destroy (&dummy
);
1117 /* We have read the extended header of the first member in
1118 this volume. Put it back, so next read_header works as
1120 current_block
= record_start
;
1125 case GNUTYPE_VOLHDR
:
1126 if (!read_header0 (&dummy
))
1128 tar_stat_destroy (&dummy
);
1129 assign_string (&volume_label
, current_header
->header
.name
);
1130 set_next_block_after (header
);
1131 header
= find_next_block ();
1132 if (header
->header
.typeflag
!= GNUTYPE_MULTIVOL
)
1136 case GNUTYPE_MULTIVOL
:
1137 if (!read_header0 (&dummy
))
1139 tar_stat_destroy (&dummy
);
1140 assign_string (&continued_file_name
, current_header
->header
.name
);
1141 continued_file_size
=
1142 UINTMAX_FROM_HEADER (current_header
->header
.size
);
1143 continued_file_offset
=
1144 UINTMAX_FROM_HEADER (current_header
->oldgnu_header
.offset
);
1154 if (!continued_file_name
1155 || strcmp (continued_file_name
, real_s_name
))
1157 if ((archive_format
== GNU_FORMAT
|| archive_format
== OLDGNU_FORMAT
)
1158 && strlen (real_s_name
) >= NAME_FIELD_SIZE
1159 && strncmp (continued_file_name
, real_s_name
,
1160 NAME_FIELD_SIZE
) == 0)
1162 _("%s is possibly continued on this volume: header contains truncated name"),
1163 quote (real_s_name
)));
1166 WARN ((0, 0, _("%s is not continued on this volume"),
1167 quote (real_s_name
)));
1172 s
= continued_file_size
+ continued_file_offset
;
1174 if (real_s_totsize
!= s
|| s
< continued_file_offset
)
1176 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1177 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1178 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1180 WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
1181 quote (continued_file_name
),
1182 STRINGIFY_BIGINT (save_totsize
, totsizebuf
),
1183 STRINGIFY_BIGINT (continued_file_size
, s1buf
),
1184 STRINGIFY_BIGINT (continued_file_offset
, s2buf
)));
1188 if (real_s_totsize
- real_s_sizeleft
!= continued_file_offset
)
1190 WARN ((0, 0, _("This volume is out of sequence")));
1195 increase_volume_number ();
1200 /* Check the LABEL block against the volume label, seen as a globbing
1201 pattern. Return true if the pattern matches. In case of failure,
1202 retry matching a volume sequence number before giving up in
1203 multi-volume mode. */
1205 check_label_pattern (union block
*label
)
1210 if (! memchr (label
->header
.name
, '\0', sizeof label
->header
.name
))
1213 if (fnmatch (volume_label_option
, label
->header
.name
, 0) == 0)
1216 if (!multi_volume_option
)
1219 string
= xmalloc (strlen (volume_label_option
)
1220 + sizeof VOLUME_LABEL_APPEND
+ 1);
1221 strcpy (string
, volume_label_option
);
1222 strcat (string
, VOLUME_LABEL_APPEND
);
1223 result
= fnmatch (string
, label
->header
.name
, 0) == 0;
1228 /* Check if the next block contains a volume label and if this matches
1229 the one given in the command line */
1231 match_volume_label (void)
1233 union block
*label
= find_next_block ();
1236 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
1237 quote (volume_label_option
)));
1238 if (!check_label_pattern (label
))
1239 FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
1240 quote_n (0, label
->header
.name
),
1241 quote_n (1, volume_label_option
)));
1244 /* Mark the archive with volume label STR. */
1246 _write_volume_label (const char *str
)
1248 if (archive_format
== POSIX_FORMAT
)
1249 xheader_store ("GNU.volume.label", NULL
, str
);
1252 union block
*label
= find_next_block ();
1254 memset (label
, 0, BLOCKSIZE
);
1256 strcpy (label
->header
.name
, volume_label_option
);
1257 assign_string (¤t_stat_info
.file_name
,
1258 label
->header
.name
);
1259 current_stat_info
.had_trailing_slash
=
1260 strip_trailing_slashes (current_stat_info
.file_name
);
1262 label
->header
.typeflag
= GNUTYPE_VOLHDR
;
1263 TIME_TO_CHARS (start_time
.tv_sec
, label
->header
.mtime
);
1264 finish_header (¤t_stat_info
, label
, -1);
1265 set_next_block_after (label
);
1269 #define VOL_SUFFIX "Volume"
1271 /* Add a volume label to a part of multi-volume archive */
1273 add_volume_label (void)
1275 char buf
[UINTMAX_STRSIZE_BOUND
];
1276 char *p
= STRINGIFY_BIGINT (volno
, buf
);
1277 char *s
= xmalloc (strlen (volume_label_option
) + sizeof VOL_SUFFIX
1279 sprintf (s
, "%s %s %s", volume_label_option
, VOL_SUFFIX
, p
);
1280 _write_volume_label (s
);
1287 if (archive_format
== POSIX_FORMAT
)
1289 off_t block_ordinal
;
1291 struct tar_stat_info st
;
1292 static size_t real_s_part_no
; /* FIXME */
1295 memset (&st
, 0, sizeof st
);
1296 st
.orig_file_name
= st
.file_name
= real_s_name
;
1297 st
.stat
.st_mode
= S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
;
1298 st
.stat
.st_uid
= getuid ();
1299 st
.stat
.st_gid
= getgid ();
1300 st
.orig_file_name
= xheader_format_name (&st
,
1301 "%d/GNUFileParts.%p/%f.%n",
1303 st
.file_name
= st
.orig_file_name
;
1304 st
.archive_file_size
= st
.stat
.st_size
= real_s_sizeleft
;
1306 block_ordinal
= current_block_ordinal ();
1307 blk
= start_header (&st
);
1309 abort (); /* FIXME */
1310 finish_header (&st
, blk
, block_ordinal
);
1311 free (st
.orig_file_name
);
1316 /* Add a volume label to the current archive */
1318 write_volume_label (void)
1320 if (multi_volume_option
)
1321 add_volume_label ();
1323 _write_volume_label (volume_label_option
);
1326 /* Write GNU multi-volume header */
1328 gnu_add_multi_volume_header (void)
1331 union block
*block
= find_next_block ();
1333 if (strlen (real_s_name
) > NAME_FIELD_SIZE
)
1335 _("%s: file name too long to be stored in a GNU multivolume header, truncated"),
1336 quotearg_colon (real_s_name
)));
1338 memset (block
, 0, BLOCKSIZE
);
1340 /* FIXME: Michael P Urban writes: [a long name file] is being written
1341 when a new volume rolls around [...] Looks like the wrong value is
1342 being preserved in real_s_name, though. */
1344 strncpy (block
->header
.name
, real_s_name
, NAME_FIELD_SIZE
);
1345 block
->header
.typeflag
= GNUTYPE_MULTIVOL
;
1347 OFF_TO_CHARS (real_s_sizeleft
, block
->header
.size
);
1348 OFF_TO_CHARS (real_s_totsize
- real_s_sizeleft
,
1349 block
->oldgnu_header
.offset
);
1351 tmp
= verbose_option
;
1353 finish_header (¤t_stat_info
, block
, -1);
1354 verbose_option
= tmp
;
1355 set_next_block_after (block
);
1358 /* Add a multi volume header to the current archive. The exact header format
1359 depends on the archive format. */
1361 add_multi_volume_header (void)
1363 if (archive_format
== POSIX_FORMAT
)
1365 off_t d
= real_s_totsize
- real_s_sizeleft
;
1366 xheader_store ("GNU.volume.filename", NULL
, real_s_name
);
1367 xheader_store ("GNU.volume.size", NULL
, &real_s_sizeleft
);
1368 xheader_store ("GNU.volume.offset", NULL
, &d
);
1371 gnu_add_multi_volume_header ();
1374 /* Synchronize multi-volume globals */
1376 multi_volume_sync ()
1378 if (multi_volume_option
)
1382 assign_string (&real_s_name
,
1383 safer_name_suffix (save_name
, false,
1384 absolute_names_option
));
1385 real_s_totsize
= save_totsize
;
1386 real_s_sizeleft
= save_sizeleft
;
1390 assign_string (&real_s_name
, 0);
1392 real_s_sizeleft
= 0;
1398 /* Low-level flush functions */
1400 /* Simple flush read (no multi-volume or label extensions) */
1402 simple_flush_read (void)
1404 size_t status
; /* result from system call */
1406 do_checkpoint (false);
1408 /* Clear the count of errors. This only applies to a single call to
1411 read_error_count
= 0; /* clear error count */
1413 if (write_archive_to_stdout
&& record_start_block
!= 0)
1415 archive
= STDOUT_FILENO
;
1416 status
= sys_write_archive_buffer ();
1417 archive
= STDIN_FILENO
;
1418 if (status
!= record_size
)
1419 archive_write_error (status
);
1424 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1425 if (status
== record_size
)
1430 if (status
== SAFE_READ_ERROR
)
1432 archive_read_error ();
1433 continue; /* try again */
1437 short_read (status
);
1440 /* Simple flush write (no multi-volume or label extensions) */
1442 simple_flush_write (size_t level
__attribute__((unused
)))
1446 status
= _flush_write ();
1447 if (status
!= record_size
)
1448 archive_write_error (status
);
1452 bytes_written
+= status
;
1457 /* GNU flush functions. These support multi-volume and archive labels in
1458 GNU and PAX archive formats. */
1461 _gnu_flush_read (void)
1463 size_t status
; /* result from system call */
1465 do_checkpoint (false);
1467 /* Clear the count of errors. This only applies to a single call to
1470 read_error_count
= 0; /* clear error count */
1472 if (write_archive_to_stdout
&& record_start_block
!= 0)
1474 archive
= STDOUT_FILENO
;
1475 status
= sys_write_archive_buffer ();
1476 archive
= STDIN_FILENO
;
1477 if (status
!= record_size
)
1478 archive_write_error (status
);
1481 multi_volume_sync ();
1485 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1486 if (status
== record_size
)
1492 /* The condition below used to include
1493 || (status > 0 && !read_full_records)
1494 This is incorrect since even if new_volume() succeeds, the
1495 subsequent call to rmtread will overwrite the chunk of data
1496 already read in the buffer, so the processing will fail */
1498 || (status
== SAFE_READ_ERROR
&& errno
== ENOSPC
))
1499 && multi_volume_option
)
1501 while (!try_new_volume ())
1505 else if (status
== SAFE_READ_ERROR
)
1507 archive_read_error ();
1512 short_read (status
);
1516 gnu_flush_read (void)
1518 flush_read_ptr
= simple_flush_read
; /* Avoid recursion */
1520 flush_read_ptr
= gnu_flush_read
;
1524 _gnu_flush_write (size_t buffer_level
)
1527 union block
*header
;
1532 status
= _flush_write ();
1533 if (status
!= record_size
&& !multi_volume_option
)
1534 archive_write_error (status
);
1538 bytes_written
+= status
;
1541 if (status
== record_size
)
1543 multi_volume_sync ();
1547 /* In multi-volume mode. */
1548 /* ENXIO is for the UNIX PC. */
1549 if (status
< 0 && errno
!= ENOSPC
&& errno
!= EIO
&& errno
!= ENXIO
)
1550 archive_write_error (status
);
1552 if (!new_volume (ACCESS_WRITE
))
1555 xheader_destroy (&extended_header
);
1557 increase_volume_number ();
1559 prev_written
+= bytes_written
;
1562 copy_ptr
= record_start
->buffer
+ status
;
1563 copy_size
= buffer_level
- status
;
1564 /* Switch to the next buffer */
1565 record_index
= !record_index
;
1568 if (volume_label_option
)
1569 add_volume_label ();
1572 add_multi_volume_header ();
1574 write_extended (true, NULL
, find_next_block ());
1576 add_chunk_header ();
1577 header
= find_next_block ();
1578 bufsize
= available_space_after (header
);
1579 while (bufsize
< copy_size
)
1581 memcpy (header
->buffer
, copy_ptr
, bufsize
);
1582 copy_ptr
+= bufsize
;
1583 copy_size
-= bufsize
;
1584 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
1585 header
= find_next_block ();
1586 bufsize
= available_space_after (header
);
1588 memcpy (header
->buffer
, copy_ptr
, copy_size
);
1589 memset (header
->buffer
+ copy_size
, 0, bufsize
- copy_size
);
1590 set_next_block_after (header
+ (copy_size
- 1) / BLOCKSIZE
);
1595 gnu_flush_write (size_t buffer_level
)
1597 flush_write_ptr
= simple_flush_write
; /* Avoid recursion */
1598 _gnu_flush_write (buffer_level
);
1599 flush_write_ptr
= gnu_flush_write
;
1611 flush_write_ptr (record_size
);
1615 open_archive (enum access_mode wanted_access
)
1617 flush_read_ptr
= gnu_flush_read
;
1618 flush_write_ptr
= gnu_flush_write
;
1620 _open_archive (wanted_access
);
1621 switch (wanted_access
)
1624 if (volume_label_option
)
1625 match_volume_label ();
1629 records_written
= 0;
1630 if (volume_label_option
)
1631 write_volume_label ();