1 /* Buffer management for tar.
3 Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003 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 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
31 # include <sys/inode.h>
41 #define PREAD 0 /* read file descriptor from pipe() */
42 #define PWRITE 1 /* write file descriptor from pipe() */
44 /* Number of retries before giving up on read. */
45 #define READ_ERROR_MAX 10
47 /* Globbing pattern to append to volume label if initial match failed. */
48 #define VOLUME_LABEL_APPEND " Volume [1-9]*"
52 static tarlong prev_written
; /* bytes written on previous volumes */
53 static tarlong bytes_written
; /* bytes written on this volume */
55 /* FIXME: The following variables should ideally be static to this
56 module. However, this cannot be done yet. The cleanup continues! */
58 union block
*record_start
; /* start of record of archive */
59 union block
*record_end
; /* last+1 block of archive record */
60 union block
*current_block
; /* current block of archive */
61 enum access_mode access_mode
; /* how do we handle the archive */
62 off_t records_read
; /* number of records read from this archive */
63 off_t records_written
; /* likewise, for records written */
65 static struct stat archive_stat
; /* stat block for archive file */
67 static off_t record_start_block
; /* block ordinal at record_start */
69 /* Where we write list messages (not errors, not interactions) to. */
72 static void backspace_output (void);
73 static int new_volume (enum access_mode
);
74 static void archive_write_error (ssize_t
) __attribute__ ((noreturn
));
75 static void archive_read_error (void);
78 /* Obnoxious test to see if dimwit is trying to dump the archive. */
83 /* PID of child program, if compress_option or remote archive access. */
84 static pid_t child_pid
;
86 /* Error recovery stuff */
87 static int read_error_count
;
89 /* Have we hit EOF yet? */
92 /* Checkpointing counter */
93 static int checkpoint
;
95 /* We're reading, but we just read the last block and its time to update. */
96 /* As least EXTERN like this one as possible. FIXME! */
97 extern int time_to_start_writing
;
99 int file_to_switch_to
= -1; /* if remote update, close archive, and use
100 this descriptor to write to */
102 static int volno
= 1; /* which volume of a multi-volume tape we're
104 static int global_volno
= 1; /* volume number to print in external
107 /* The pointer save_name, which is set in function dump_file() of module
108 create.c, points to the original long filename instead of the new,
109 shorter mangled name that is set in start_header() of module create.c.
110 The pointer save_name is only used in multi-volume mode when the file
111 being processed is non-sparse; if a file is split between volumes, the
112 save_name is used in generating the LF_MULTIVOL record on the second
113 volume. (From Pierce Cantrell, 1991-08-13.) */
115 char *save_name
; /* name of the file we are currently writing */
116 off_t save_totsize
; /* total size of file we are writing, only
117 valid if save_name is nonzero */
118 off_t save_sizeleft
; /* where we are in the file we are writing,
119 only valid if save_name is nonzero */
121 bool write_archive_to_stdout
;
123 /* Used by flush_read and flush_write to store the real info about saved
125 static char *real_s_name
;
126 static off_t real_s_totsize
;
127 static off_t real_s_sizeleft
;
132 print_total_written (void)
134 tarlong written
= prev_written
+ bytes_written
;
135 char bytes
[sizeof (tarlong
) * CHAR_BIT
];
136 char abbr
[LONGEST_HUMAN_READABLE
+ 1];
137 char rate
[LONGEST_HUMAN_READABLE
+ 1];
139 int human_opts
= human_autoscale
| human_base_1024
| human_SI
| human_B
;
141 #if HAVE_CLOCK_GETTIME
143 if (clock_gettime (CLOCK_REALTIME
, &now
) == 0)
144 seconds
= ((now
.tv_sec
- start_timespec
.tv_sec
)
145 + (now
.tv_nsec
- start_timespec
.tv_nsec
) / 1e9
);
148 seconds
= time (0) - start_time
;
150 sprintf (bytes
, TARLONG_FORMAT
, written
);
152 /* Amanda 2.4.1p1 looks for "Total bytes written: [0-9][0-9]*". */
153 fprintf (stderr
, _("Total bytes written: %s (%s, %s/s)\n"), bytes
,
154 human_readable (written
, abbr
, human_opts
, 1, 1),
155 (0 < seconds
&& written
/ seconds
< (uintmax_t) -1
156 ? human_readable (written
/ seconds
, rate
, human_opts
, 1, 1)
160 /* Compute and return the block ordinal at current_block. */
162 current_block_ordinal (void)
164 return record_start_block
+ (current_block
- record_start
);
167 /* If the EOF flag is set, reset it, as well as current_block, etc. */
174 current_block
= record_start
;
175 record_end
= record_start
+ blocking_factor
;
176 access_mode
= ACCESS_WRITE
;
180 /* Return the location of the next available input or output block.
181 Return zero for EOF. Once we have returned zero, we just keep returning
182 it, to avoid accidentally going on to the next file on the tape. */
184 find_next_block (void)
186 if (current_block
== record_end
)
191 if (current_block
== record_end
)
197 return current_block
;
200 /* Indicate that we have used all blocks up thru BLOCK.
201 FIXME: should the arg have an off-by-1? */
203 set_next_block_after (union block
*block
)
205 while (block
>= current_block
)
208 /* Do *not* flush the archive here. If we do, the same argument to
209 set_next_block_after could mean the next block (if the input record
210 is exactly one block long), which is not what is intended. */
212 if (current_block
> record_end
)
216 /* Return the number of bytes comprising the space between POINTER
217 through the end of the current buffer of blocks. This space is
218 available for filling with data, or taking data from. POINTER is
219 usually (but not always) the result previous find_next_block call. */
221 available_space_after (union block
*pointer
)
223 return record_end
->buffer
- pointer
->buffer
;
226 /* Close file having descriptor FD, and abort if close unsuccessful. */
231 close_error (_("(pipe)"));
234 /* Duplicate file descriptor FROM into becoming INTO.
235 INTO is closed first and has to be the next available slot. */
237 xdup2 (int from
, int into
)
241 int status
= close (into
);
243 if (status
!= 0 && errno
!= EBADF
)
246 FATAL_ERROR ((0, e
, _("Cannot close")));
254 FATAL_ERROR ((0, e
, _("Cannot dup")));
264 /* Set ARCHIVE for writing, then compressing an archive. */
266 child_open_for_compress (void)
268 FATAL_ERROR ((0, 0, _("Cannot use compressed or remote archives")));
271 /* Set ARCHIVE for uncompressing, then reading an archive. */
273 child_open_for_uncompress (void)
275 FATAL_ERROR ((0, 0, _("Cannot use compressed or remote archives")));
278 #else /* not MSDOS */
280 /* Return nonzero if NAME is the name of a regular file, or if the file
281 does not exist (so it would be created as a regular file). */
283 is_regular_file (const char *name
)
287 if (stat (name
, &stbuf
) == 0)
288 return S_ISREG (stbuf
.st_mode
);
290 return errno
== ENOENT
;
294 write_archive_buffer (void)
299 while (0 <= (status
= rmtwrite (archive
, record_start
->buffer
+ written
,
300 record_size
- written
)))
303 if (written
== record_size
305 || ! (S_ISFIFO (archive_stat
.st_mode
)
306 || S_ISSOCK (archive_stat
.st_mode
)))
310 return written
? written
: status
;
313 /* Set ARCHIVE for writing, then compressing an archive. */
315 child_open_for_compress (void)
319 pid_t grandchild_pid
;
323 child_pid
= xfork ();
327 /* The parent tar is still here! Just clean up. */
329 archive
= parent_pipe
[PWRITE
];
330 xclose (parent_pipe
[PREAD
]);
334 /* The new born child tar is here! */
336 program_name
= _("tar (child)");
338 xdup2 (parent_pipe
[PREAD
], STDIN_FILENO
);
339 xclose (parent_pipe
[PWRITE
]);
341 /* Check if we need a grandchild tar. This happens only if either:
342 a) we are writing stdout: to force reblocking;
343 b) the file is to be accessed by rmt: compressor doesn't know how;
344 c) the file is not a plain file. */
346 if (strcmp (archive_name_array
[0], "-") != 0
347 && !_remdev (archive_name_array
[0])
348 && is_regular_file (archive_name_array
[0]))
351 maybe_backup_file (archive_name_array
[0], 1);
353 /* We don't need a grandchild tar. Open the archive and launch the
356 archive
= creat (archive_name_array
[0], MODE_RW
);
359 int saved_errno
= errno
;
364 open_fatal (archive_name_array
[0]);
366 xdup2 (archive
, STDOUT_FILENO
);
367 execlp (use_compress_program_option
, use_compress_program_option
,
369 exec_fatal (use_compress_program_option
);
372 /* We do need a grandchild tar. */
375 grandchild_pid
= xfork ();
377 if (grandchild_pid
== 0)
379 /* The newborn grandchild tar is here! Launch the compressor. */
381 program_name
= _("tar (grandchild)");
383 xdup2 (child_pipe
[PWRITE
], STDOUT_FILENO
);
384 xclose (child_pipe
[PREAD
]);
385 execlp (use_compress_program_option
, use_compress_program_option
,
387 exec_fatal (use_compress_program_option
);
390 /* The child tar is still here! */
392 /* Prepare for reblocking the data from the compressor into the archive. */
394 xdup2 (child_pipe
[PREAD
], STDIN_FILENO
);
395 xclose (child_pipe
[PWRITE
]);
397 if (strcmp (archive_name_array
[0], "-") == 0)
398 archive
= STDOUT_FILENO
;
401 archive
= rmtcreat (archive_name_array
[0], MODE_RW
, rsh_command_option
);
403 open_fatal (archive_name_array
[0]);
406 /* Let's read out of the stdin pipe and write an archive. */
414 /* Assemble a record. */
416 for (length
= 0, cursor
= record_start
->buffer
;
417 length
< record_size
;
418 length
+= status
, cursor
+= status
)
420 size_t size
= record_size
- length
;
422 status
= safe_read (STDIN_FILENO
, cursor
, size
);
428 read_fatal (use_compress_program_option
);
430 /* Copy the record. */
434 /* We hit the end of the file. Write last record at
435 full length, as the only role of the grandchild is
436 doing proper reblocking. */
440 memset (record_start
->buffer
+ length
, 0, record_size
- length
);
441 status
= write_archive_buffer ();
442 if (status
!= record_size
)
443 archive_write_error (status
);
446 /* There is nothing else to read, break out. */
450 status
= write_archive_buffer ();
451 if (status
!= record_size
)
452 archive_write_error (status
);
459 /* Propagate any failure of the grandchild back to the parent. */
461 while (waitpid (grandchild_pid
, &wait_status
, 0) == -1)
464 waitpid_error (use_compress_program_option
);
468 if (WIFSIGNALED (wait_status
))
470 kill (child_pid
, WTERMSIG (wait_status
));
471 exit_status
= TAREXIT_FAILURE
;
473 else if (WEXITSTATUS (wait_status
) != 0)
474 exit_status
= WEXITSTATUS (wait_status
);
479 /* Set ARCHIVE for uncompressing, then reading an archive. */
481 child_open_for_uncompress (void)
485 pid_t grandchild_pid
;
489 child_pid
= xfork ();
493 /* The parent tar is still here! Just clean up. */
495 read_full_records_option
= 1;
496 archive
= parent_pipe
[PREAD
];
497 xclose (parent_pipe
[PWRITE
]);
501 /* The newborn child tar is here! */
503 program_name
= _("tar (child)");
505 xdup2 (parent_pipe
[PWRITE
], STDOUT_FILENO
);
506 xclose (parent_pipe
[PREAD
]);
508 /* Check if we need a grandchild tar. This happens only if either:
509 a) we're reading stdin: to force unblocking;
510 b) the file is to be accessed by rmt: compressor doesn't know how;
511 c) the file is not a plain file. */
513 if (strcmp (archive_name_array
[0], "-") != 0
514 && !_remdev (archive_name_array
[0])
515 && is_regular_file (archive_name_array
[0]))
517 /* We don't need a grandchild tar. Open the archive and lauch the
520 archive
= open (archive_name_array
[0], O_RDONLY
| O_BINARY
, MODE_RW
);
522 open_fatal (archive_name_array
[0]);
523 xdup2 (archive
, STDIN_FILENO
);
524 execlp (use_compress_program_option
, use_compress_program_option
,
526 exec_fatal (use_compress_program_option
);
529 /* We do need a grandchild tar. */
532 grandchild_pid
= xfork ();
534 if (grandchild_pid
== 0)
536 /* The newborn grandchild tar is here! Launch the uncompressor. */
538 program_name
= _("tar (grandchild)");
540 xdup2 (child_pipe
[PREAD
], STDIN_FILENO
);
541 xclose (child_pipe
[PWRITE
]);
542 execlp (use_compress_program_option
, use_compress_program_option
,
544 exec_fatal (use_compress_program_option
);
547 /* The child tar is still here! */
549 /* Prepare for unblocking the data from the archive into the
552 xdup2 (child_pipe
[PWRITE
], STDOUT_FILENO
);
553 xclose (child_pipe
[PREAD
]);
555 if (strcmp (archive_name_array
[0], "-") == 0)
556 archive
= STDIN_FILENO
;
558 archive
= rmtopen (archive_name_array
[0], O_RDONLY
| O_BINARY
,
559 MODE_RW
, rsh_command_option
);
561 open_fatal (archive_name_array
[0]);
563 /* Let's read the archive and pipe it into stdout. */
572 read_error_count
= 0;
575 status
= rmtread (archive
, record_start
->buffer
, record_size
);
578 archive_read_error ();
583 cursor
= record_start
->buffer
;
587 count
= maximum
< BLOCKSIZE
? maximum
: BLOCKSIZE
;
588 if (full_write (STDOUT_FILENO
, cursor
, count
) != count
)
589 write_error (use_compress_program_option
);
595 xclose (STDOUT_FILENO
);
600 /* Propagate any failure of the grandchild back to the parent. */
602 while (waitpid (grandchild_pid
, &wait_status
, 0) == -1)
605 waitpid_error (use_compress_program_option
);
609 if (WIFSIGNALED (wait_status
))
611 kill (child_pid
, WTERMSIG (wait_status
));
612 exit_status
= TAREXIT_FAILURE
;
614 else if (WEXITSTATUS (wait_status
) != 0)
615 exit_status
= WEXITSTATUS (wait_status
);
620 #endif /* not MSDOS */
622 /* Check the LABEL block against the volume label, seen as a globbing
623 pattern. Return true if the pattern matches. In case of failure,
624 retry matching a volume sequence number before giving up in
625 multi-volume mode. */
627 check_label_pattern (union block
*label
)
632 if (! memchr (label
->header
.name
, '\0', sizeof label
->header
.name
))
635 if (fnmatch (volume_label_option
, label
->header
.name
, 0) == 0)
638 if (!multi_volume_option
)
641 string
= xmalloc (strlen (volume_label_option
)
642 + sizeof VOLUME_LABEL_APPEND
+ 1);
643 strcpy (string
, volume_label_option
);
644 strcat (string
, VOLUME_LABEL_APPEND
);
645 result
= fnmatch (string
, label
->header
.name
, 0) == 0;
650 /* Open an archive file. The argument specifies whether we are
651 reading or writing, or both. */
653 open_archive (enum access_mode wanted_access
)
655 int backed_up_flag
= 0;
659 stdlis
= fopen (index_file_name
, "w");
661 open_error (index_file_name
);
664 stdlis
= to_stdout_option
? stderr
: stdout
;
666 if (record_size
== 0)
667 FATAL_ERROR ((0, 0, _("Invalid value for record_size")));
669 if (archive_names
== 0)
670 FATAL_ERROR ((0, 0, _("No archive name given")));
672 current_file_name
= 0;
673 current_link_name
= 0;
677 if (multi_volume_option
)
680 FATAL_ERROR ((0, 0, _("Cannot verify multi-volume archives")));
681 record_start
= valloc (record_size
+ (2 * BLOCKSIZE
));
686 record_start
= valloc (record_size
);
688 FATAL_ERROR ((0, 0, _("Cannot allocate memory for blocking factor %d"),
691 current_block
= record_start
;
692 record_end
= record_start
+ blocking_factor
;
693 /* When updating the archive, we start with reading. */
694 access_mode
= wanted_access
== ACCESS_UPDATE
? ACCESS_READ
: wanted_access
;
696 if (use_compress_program_option
)
698 if (multi_volume_option
)
699 FATAL_ERROR ((0, 0, _("Cannot use multi-volume compressed archives")));
701 FATAL_ERROR ((0, 0, _("Cannot verify compressed archives")));
703 switch (wanted_access
)
706 child_open_for_uncompress ();
710 child_open_for_compress ();
714 FATAL_ERROR ((0, 0, _("Cannot update compressed archives")));
718 if (wanted_access
== ACCESS_WRITE
719 && strcmp (archive_name_array
[0], "-") == 0)
722 else if (strcmp (archive_name_array
[0], "-") == 0)
724 read_full_records_option
= 1; /* could be a pipe, be safe */
726 FATAL_ERROR ((0, 0, _("Cannot verify stdin/stdout archive")));
728 switch (wanted_access
)
731 archive
= STDIN_FILENO
;
735 archive
= STDOUT_FILENO
;
740 archive
= STDIN_FILENO
;
742 write_archive_to_stdout
= 1;
746 else if (verify_option
)
747 archive
= rmtopen (archive_name_array
[0], O_RDWR
| O_CREAT
| O_BINARY
,
748 MODE_RW
, rsh_command_option
);
750 switch (wanted_access
)
753 archive
= rmtopen (archive_name_array
[0], O_RDONLY
| O_BINARY
,
754 MODE_RW
, rsh_command_option
);
760 maybe_backup_file (archive_name_array
[0], 1);
763 archive
= rmtcreat (archive_name_array
[0], MODE_RW
,
768 archive
= rmtopen (archive_name_array
[0], O_RDWR
| O_CREAT
| O_BINARY
,
769 MODE_RW
, rsh_command_option
);
774 || (! _isrmt (archive
) && fstat (archive
, &archive_stat
) < 0))
776 int saved_errno
= errno
;
781 open_fatal (archive_name_array
[0]);
786 /* Detect if outputting to "/dev/null". */
788 static char const dev_null
[] = "/dev/null";
789 struct stat dev_null_stat
;
792 (strcmp (archive_name_array
[0], dev_null
) == 0
793 || (! _isrmt (archive
)
794 && S_ISCHR (archive_stat
.st_mode
)
795 && stat (dev_null
, &dev_null_stat
) == 0
796 && archive_stat
.st_dev
== dev_null_stat
.st_dev
797 && archive_stat
.st_ino
== dev_null_stat
.st_ino
));
800 if (!_isrmt (archive
) && S_ISREG (archive_stat
.st_mode
))
802 ar_dev
= archive_stat
.st_dev
;
803 ar_ino
= archive_stat
.st_ino
;
808 #endif /* not MSDOS */
811 setmode (archive
, O_BINARY
);
814 switch (wanted_access
)
820 record_end
= record_start
; /* set up for 1st record = # 0 */
821 find_next_block (); /* read it in, check for EOF */
823 if (volume_label_option
)
825 union block
*label
= find_next_block ();
828 FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"),
829 quote (volume_label_option
)));
830 if (!check_label_pattern (label
))
831 FATAL_ERROR ((0, 0, _("Volume %s does not match %s"),
832 quote_n (0, label
->header
.name
),
833 quote_n (1, volume_label_option
)));
839 if (volume_label_option
)
841 memset (record_start
, 0, BLOCKSIZE
);
842 if (multi_volume_option
)
843 sprintf (record_start
->header
.name
, "%s Volume 1",
844 volume_label_option
);
846 strcpy (record_start
->header
.name
, volume_label_option
);
848 assign_string (¤t_file_name
, record_start
->header
.name
);
849 current_trailing_slash
= strip_trailing_slashes (current_file_name
);
851 record_start
->header
.typeflag
= GNUTYPE_VOLHDR
;
852 TIME_TO_CHARS (start_time
, record_start
->header
.mtime
);
853 finish_header (record_start
, -1);
862 /* Perform a write to flush the buffer. */
869 if (checkpoint_option
&& !(++checkpoint
% 10))
870 WARN ((0, 0, _("Write checkpoint %d"), checkpoint
));
872 if (tape_length_option
&& tape_length_option
<= bytes_written
)
877 else if (dev_null_output
)
878 status
= record_size
;
880 status
= write_archive_buffer ();
881 if (status
!= record_size
&& !multi_volume_option
)
882 archive_write_error (status
);
887 bytes_written
+= status
;
890 if (status
== record_size
)
892 if (multi_volume_option
)
896 assign_string (&real_s_name
, safer_name_suffix (save_name
, 0));
897 real_s_totsize
= save_totsize
;
898 real_s_sizeleft
= save_sizeleft
;
902 assign_string (&real_s_name
, 0);
910 /* We're multivol. Panic if we didn't get the right kind of response. */
912 /* ENXIO is for the UNIX PC. */
913 if (status
< 0 && errno
!= ENOSPC
&& errno
!= EIO
&& errno
!= ENXIO
)
914 archive_write_error (status
);
916 /* If error indicates a short write, we just move to the next tape. */
918 if (!new_volume (ACCESS_WRITE
))
922 prev_written
+= bytes_written
;
925 if (volume_label_option
&& real_s_name
)
930 else if (volume_label_option
|| real_s_name
)
938 if (volume_label_option
)
940 memset (record_start
, 0, BLOCKSIZE
);
941 sprintf (record_start
->header
.name
, "%s Volume %d",
942 volume_label_option
, volno
);
943 TIME_TO_CHARS (start_time
, record_start
->header
.mtime
);
944 record_start
->header
.typeflag
= GNUTYPE_VOLHDR
;
945 finish_header (record_start
, -1);
952 if (volume_label_option
)
955 memset (record_start
, 0, BLOCKSIZE
);
957 /* FIXME: Michael P Urban writes: [a long name file] is being written
958 when a new volume rolls around [...] Looks like the wrong value is
959 being preserved in real_s_name, though. */
961 strcpy (record_start
->header
.name
, real_s_name
);
962 record_start
->header
.typeflag
= GNUTYPE_MULTIVOL
;
963 OFF_TO_CHARS (real_s_sizeleft
, record_start
->header
.size
);
964 OFF_TO_CHARS (real_s_totsize
- real_s_sizeleft
,
965 record_start
->oldgnu_header
.offset
);
966 tmp
= verbose_option
;
968 finish_header (record_start
, -1);
969 verbose_option
= tmp
;
971 if (volume_label_option
)
975 status
= write_archive_buffer ();
976 if (status
!= record_size
)
977 archive_write_error (status
);
979 bytes_written
+= status
;
983 record_start
+= copy_back
;
984 memcpy (current_block
,
985 record_start
+ blocking_factor
- copy_back
,
986 copy_back
* BLOCKSIZE
);
987 current_block
+= copy_back
;
989 if (real_s_sizeleft
>= copy_back
* BLOCKSIZE
)
990 real_s_sizeleft
-= copy_back
* BLOCKSIZE
;
991 else if ((real_s_sizeleft
+ BLOCKSIZE
- 1) / BLOCKSIZE
<= copy_back
)
992 assign_string (&real_s_name
, 0);
995 assign_string (&real_s_name
, safer_name_suffix (save_name
, 0));
996 real_s_sizeleft
= save_sizeleft
;
997 real_s_totsize
= save_totsize
;
1003 /* Handle write errors on the archive. Write errors are always fatal.
1004 Hitting the end of a volume does not cause a write error unless the
1005 write was the first record of the volume. */
1007 archive_write_error (ssize_t status
)
1009 /* It might be useful to know how much was written before the error
1014 print_total_written ();
1018 write_fatal_details (*archive_name_cursor
, status
, record_size
);
1021 /* Handle read errors on the archive. If the read should be retried,
1022 return to the caller. */
1024 archive_read_error (void)
1026 read_error (*archive_name_cursor
);
1028 if (record_start_block
== 0)
1029 FATAL_ERROR ((0, 0, _("At beginning of tape, quitting now")));
1031 /* Read error in mid archive. We retry up to READ_ERROR_MAX times and
1032 then give up on reading the archive. */
1034 if (read_error_count
++ > READ_ERROR_MAX
)
1035 FATAL_ERROR ((0, 0, _("Too many errors, quitting")));
1040 short_read (ssize_t status
)
1042 size_t left
; /* bytes left */
1043 char *more
; /* pointer to next byte to read */
1045 more
= record_start
->buffer
+ status
;
1046 left
= record_size
- status
;
1048 while (left
% BLOCKSIZE
!= 0
1049 || (left
&& status
&& read_full_records_option
))
1052 while ((status
= rmtread (archive
, more
, left
)) < 0)
1053 archive_read_error ();
1058 if (! read_full_records_option
)
1059 FATAL_ERROR ((0, 0, _("Unaligned block (%lu bytes) in archive"),
1060 (unsigned long) (record_size
- left
)));
1062 /* User warned us about this. Fix up. */
1068 /* FIXME: for size=0, multi-volume support. On the first record, warn
1069 about the problem. */
1071 if (!read_full_records_option
&& verbose_option
1072 && record_start_block
== 0 && status
> 0)
1073 WARN ((0, 0, _("Record size = %lu blocks"),
1074 (unsigned long) ((record_size
- left
) / BLOCKSIZE
)));
1076 record_end
= record_start
+ (record_size
- left
) / BLOCKSIZE
;
1080 /* Perform a read to flush the buffer. */
1084 ssize_t status
; /* result from system call */
1086 if (checkpoint_option
&& !(++checkpoint
% 10))
1087 WARN ((0, 0, _("Read checkpoint %d"), checkpoint
));
1089 /* Clear the count of errors. This only applies to a single call to
1092 read_error_count
= 0; /* clear error count */
1094 if (write_archive_to_stdout
&& record_start_block
!= 0)
1096 archive
= STDOUT_FILENO
;
1097 status
= write_archive_buffer ();
1098 archive
= STDIN_FILENO
;
1099 if (status
!= record_size
)
1100 archive_write_error (status
);
1102 if (multi_volume_option
)
1106 assign_string (&real_s_name
, safer_name_suffix (save_name
, 0));
1107 real_s_sizeleft
= save_sizeleft
;
1108 real_s_totsize
= save_totsize
;
1112 assign_string (&real_s_name
, 0);
1114 real_s_sizeleft
= 0;
1119 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1120 if (status
== record_size
)
1127 || (status
< 0 && errno
== ENOSPC
)
1128 || (status
> 0 && !read_full_records_option
))
1129 && multi_volume_option
)
1131 union block
*cursor
;
1134 switch (subcommand_option
)
1136 case APPEND_SUBCOMMAND
:
1137 case CAT_SUBCOMMAND
:
1138 case UPDATE_SUBCOMMAND
:
1139 if (!new_volume (ACCESS_UPDATE
))
1144 if (!new_volume (ACCESS_READ
))
1150 status
= rmtread (archive
, record_start
->buffer
, record_size
);
1153 archive_read_error ();
1156 if (status
!= record_size
)
1157 short_read (status
);
1159 cursor
= record_start
;
1161 if (cursor
->header
.typeflag
== GNUTYPE_VOLHDR
)
1163 if (volume_label_option
)
1165 if (!check_label_pattern (cursor
))
1167 WARN ((0, 0, _("Volume %s does not match %s"),
1168 quote_n (0, cursor
->header
.name
),
1169 quote_n (1, volume_label_option
)));
1176 fprintf (stdlis
, _("Reading %s\n"), quote (cursor
->header
.name
));
1179 else if (volume_label_option
)
1180 WARN ((0, 0, _("WARNING: No volume header")));
1185 if (cursor
->header
.typeflag
!= GNUTYPE_MULTIVOL
1186 || strcmp (cursor
->header
.name
, real_s_name
))
1188 WARN ((0, 0, _("%s is not continued on this volume"),
1189 quote (real_s_name
)));
1194 s1
= UINTMAX_FROM_HEADER (cursor
->header
.size
);
1195 s2
= UINTMAX_FROM_HEADER (cursor
->oldgnu_header
.offset
);
1196 if (real_s_totsize
!= s1
+ s2
|| s1
+ s2
< s2
)
1198 char totsizebuf
[UINTMAX_STRSIZE_BOUND
];
1199 char s1buf
[UINTMAX_STRSIZE_BOUND
];
1200 char s2buf
[UINTMAX_STRSIZE_BOUND
];
1202 WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"),
1203 quote (cursor
->header
.name
),
1204 STRINGIFY_BIGINT (save_totsize
, totsizebuf
),
1205 STRINGIFY_BIGINT (s1
, s1buf
),
1206 STRINGIFY_BIGINT (s2
, s2buf
)));
1211 if (real_s_totsize
- real_s_sizeleft
1212 != OFF_FROM_HEADER (cursor
->oldgnu_header
.offset
))
1214 WARN ((0, 0, _("This volume is out of sequence")));
1221 current_block
= cursor
;
1225 else if (status
< 0)
1227 archive_read_error ();
1228 goto error_loop
; /* try again */
1231 short_read (status
);
1234 /* Flush the current buffer to/from the archive. */
1236 flush_archive (void)
1238 record_start_block
+= record_end
- record_start
;
1239 current_block
= record_start
;
1240 record_end
= record_start
+ blocking_factor
;
1242 if (access_mode
== ACCESS_READ
&& time_to_start_writing
)
1244 access_mode
= ACCESS_WRITE
;
1245 time_to_start_writing
= 0;
1247 if (file_to_switch_to
>= 0)
1249 if (rmtclose (archive
) != 0)
1250 close_warn (*archive_name_cursor
);
1252 archive
= file_to_switch_to
;
1255 backspace_output ();
1258 switch (access_mode
)
1273 /* Backspace the archive descriptor by one record worth. If it's a
1274 tape, MTIOCTOP will work. If it's something else, try to seek on
1275 it. If we can't seek, we lose! */
1277 backspace_output (void)
1281 struct mtop operation
;
1283 operation
.mt_op
= MTBSR
;
1284 operation
.mt_count
= 1;
1285 if (rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
1287 if (errno
== EIO
&& rmtioctl (archive
, MTIOCTOP
, (char *) &operation
) >= 0)
1293 off_t position
= rmtlseek (archive
, (off_t
) 0, SEEK_CUR
);
1295 /* Seek back to the beginning of this record and start writing there. */
1297 position
-= record_size
;
1300 if (rmtlseek (archive
, position
, SEEK_SET
) != position
)
1302 /* Lseek failed. Try a different method. */
1305 _("Cannot backspace archive file; it may be unreadable without -i")));
1307 /* Replace the first part of the record with NULs. */
1309 if (record_start
->buffer
!= output_start
)
1310 memset (record_start
->buffer
, 0,
1311 output_start
- record_start
->buffer
);
1316 /* Close the archive file. */
1318 close_archive (void)
1320 if (time_to_start_writing
|| access_mode
== ACCESS_WRITE
)
1325 /* Manage to fully drain a pipe we might be reading, so to not break it on
1326 the producer after the EOF block. FIXME: one of these days, GNU tar
1327 might become clever enough to just stop working, once there is no more
1328 work to do, we might have to revise this area in such time. */
1330 if (access_mode
== ACCESS_READ
1331 && ! _isrmt (archive
)
1332 && (S_ISFIFO (archive_stat
.st_mode
) || S_ISSOCK (archive_stat
.st_mode
)))
1333 while (rmtread (archive
, record_start
->buffer
, record_size
) > 0)
1340 if (rmtclose (archive
) != 0)
1341 close_warn (*archive_name_cursor
);
1349 while (waitpid (child_pid
, &wait_status
, 0) == -1)
1352 waitpid_error (use_compress_program_option
);
1356 if (WIFSIGNALED (wait_status
))
1357 ERROR ((0, 0, _("Child died with signal %d"),
1358 WTERMSIG (wait_status
)));
1359 else if (WEXITSTATUS (wait_status
) != 0)
1360 ERROR ((0, 0, _("Child returned status %d"),
1361 WEXITSTATUS (wait_status
)));
1365 if (current_file_name
)
1366 free (current_file_name
);
1367 if (current_link_name
)
1368 free (current_link_name
);
1373 free (multi_volume_option
? record_start
- 2 : record_start
);
1376 /* Called to initialize the global volume number. */
1378 init_volume_number (void)
1380 FILE *file
= fopen (volno_file_option
, "r");
1384 if (fscanf (file
, "%d", &global_volno
) != 1
1385 || global_volno
< 0)
1386 FATAL_ERROR ((0, 0, _("%s: contains invalid volume number"),
1387 quotearg_colon (volno_file_option
)));
1389 read_error (volno_file_option
);
1390 if (fclose (file
) != 0)
1391 close_error (volno_file_option
);
1393 else if (errno
!= ENOENT
)
1394 open_error (volno_file_option
);
1397 /* Called to write out the closing global volume number. */
1399 closeout_volume_number (void)
1401 FILE *file
= fopen (volno_file_option
, "w");
1405 fprintf (file
, "%d\n", global_volno
);
1407 write_error (volno_file_option
);
1408 if (fclose (file
) != 0)
1409 close_error (volno_file_option
);
1412 open_error (volno_file_option
);
1415 /* We've hit the end of the old volume. Close it and open the next one.
1416 Return nonzero on success. */
1418 new_volume (enum access_mode access
)
1420 static FILE *read_file
;
1423 if (!read_file
&& !info_script_option
)
1424 /* FIXME: if fopen is used, it will never be closed. */
1425 read_file
= archive
== STDIN_FILENO
? fopen (TTY_NAME
, "r") : stdin
;
1432 if (rmtclose (archive
) != 0)
1433 close_warn (*archive_name_cursor
);
1436 if (global_volno
< 0)
1437 FATAL_ERROR ((0, 0, _("Volume number overflow")));
1439 archive_name_cursor
++;
1440 if (archive_name_cursor
== archive_name_array
+ archive_names
)
1442 archive_name_cursor
= archive_name_array
;
1449 /* We have to prompt from now on. */
1451 if (info_script_option
)
1453 if (volno_file_option
)
1454 closeout_volume_number ();
1455 if (system (info_script_option
) != 0)
1456 FATAL_ERROR ((0, 0, _("`%s' command failed"), info_script_option
));
1461 char input_buffer
[80];
1463 fputc ('\007', stderr
);
1465 _("Prepare volume #%d for %s and hit return: "),
1466 global_volno
, quote (*archive_name_cursor
));
1469 if (fgets (input_buffer
, sizeof input_buffer
, read_file
) == 0)
1471 WARN ((0, 0, _("EOF where user reply was expected")));
1473 if (subcommand_option
!= EXTRACT_SUBCOMMAND
1474 && subcommand_option
!= LIST_SUBCOMMAND
1475 && subcommand_option
!= DIFF_SUBCOMMAND
)
1476 WARN ((0, 0, _("WARNING: Archive is incomplete")));
1480 if (input_buffer
[0] == '\n'
1481 || input_buffer
[0] == 'y'
1482 || input_buffer
[0] == 'Y')
1485 switch (input_buffer
[0])
1489 fprintf (stderr
, _("\
1490 n [name] Give a new file name for the next (and subsequent) volume(s)\n\
1492 ! Spawn a subshell\n\
1493 ? Print this list\n"));
1500 WARN ((0, 0, _("No new volume; exiting.\n")));
1502 if (subcommand_option
!= EXTRACT_SUBCOMMAND
1503 && subcommand_option
!= LIST_SUBCOMMAND
1504 && subcommand_option
!= DIFF_SUBCOMMAND
)
1505 WARN ((0, 0, _("WARNING: Archive is incomplete")));
1510 /* Get new file name. */
1513 char *name
= &input_buffer
[1];
1516 while (*name
== ' ' || *name
== '\t')
1519 while (*cursor
&& *cursor
!= '\n')
1523 /* FIXME: the following allocation is never reclaimed. */
1524 *archive_name_cursor
= xstrdup (name
);
1530 spawnl (P_WAIT
, getenv ("COMSPEC"), "-", 0);
1531 #else /* not MSDOS */
1534 const char *shell
= getenv ("SHELL");
1540 execlp (shell
, "-sh", "-i", 0);
1546 while (waitpid (child
, &wait_status
, 0) == -1)
1549 waitpid_error (shell
);
1554 #endif /* not MSDOS */
1560 if (strcmp (archive_name_cursor
[0], "-") == 0)
1562 read_full_records_option
= true;
1563 archive
= STDIN_FILENO
;
1565 else if (verify_option
)
1566 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1567 rsh_command_option
);
1572 archive
= rmtopen (*archive_name_cursor
, O_RDONLY
, MODE_RW
,
1573 rsh_command_option
);
1578 maybe_backup_file (*archive_name_cursor
, 1);
1579 archive
= rmtcreat (*archive_name_cursor
, MODE_RW
,
1580 rsh_command_option
);
1584 archive
= rmtopen (*archive_name_cursor
, O_RDWR
| O_CREAT
, MODE_RW
,
1585 rsh_command_option
);
1591 open_warn (*archive_name_cursor
);
1592 if (!verify_option
&& access
== ACCESS_WRITE
&& backup_option
)
1593 undo_last_backup ();
1598 setmode (archive
, O_BINARY
);