1 /* $OpenBSD: ar_io.c,v 1.36 2004/06/20 16:22:08 niklas Exp $ */
2 /* $NetBSD: ar_io.c,v 1.5 1996/03/26 23:54:13 mrg Exp $ */
5 * Copyright (c) 1992 Keith Muller.
6 * Copyright (c) 1992, 1993
7 * The Regents of the University of California. All rights reserved.
9 * This code is derived from software contributed to Berkeley by
10 * Keith Muller of the University of California, San Diego.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
39 static const char sccsid
[] = "@(#)ar_io.c 8.2 (Berkeley) 4/18/94";
41 static const char rcsid
[] __attribute__((__unused__
)) = "$OpenBSD: ar_io.c,v 1.36 2004/06/20 16:22:08 niklas Exp $";
45 #include <sys/types.h>
48 #include <sys/ioctl.h>
50 #include <sys/param.h>
65 * Routines which deal directly with the archive I/O device/file.
68 #define DMOD 0666 /* default mode of created archives */
69 #define EXT_MODE O_RDONLY /* open mode for list/extract */
70 #define AR_MODE (O_WRONLY | O_CREAT | O_TRUNC) /* mode for archive */
71 #define APP_MODE O_RDWR /* mode for append */
72 #define STDO "<STDOUT>" /* pseudo name for stdout */
73 #define STDN "<STDIN>" /* pseudo name for stdin */
74 static int arfd
= -1; /* archive file descriptor */
75 static int artyp
= ISREG
; /* archive type: file/FIFO/tape */
76 static int arvol
= 1; /* archive volume number */
77 static int lstrval
= -1; /* return value from last i/o */
78 static int io_ok
; /* i/o worked on volume after resync */
79 static int did_io
; /* did i/o ever occur on volume? */
80 static int done
; /* set via tty termination */
81 static struct stat arsb
; /* stat of archive device at open */
82 static int invld_rec
; /* tape has out of spec record size */
83 static int wr_trail
= 1; /* trailer was rewritten in append */
84 static int can_unlnk
= 0; /* do we unlink null archives? */
85 const char *arcname
; /* printable name of archive */
86 const char *gzip_program
; /* name of gzip program */
87 static pid_t zpid
= -1; /* pid of child process */
88 int force_one_volume
; /* 1 if we ignore volume changes */
90 static int get_phys(void);
91 extern sigset_t s_mask
;
92 static void ar_start_gzip(int, const char *, int);
96 * Opens the next archive volume. Determines the type of the device and
97 * sets up block sizes as required by the archive device and the format.
98 * Note: we may be called with name == NULL on the first open only.
100 * -1 on failure, 0 otherwise
104 ar_open(const char *name
)
111 can_unlnk
= did_io
= io_ok
= invld_rec
= 0;
116 * open based on overall operation mode
124 } else if ((arfd
= open(name
, EXT_MODE
, DMOD
)) < 0)
125 syswarn(1, errno
, "Failed open to read on %s", name
);
126 if (arfd
!= -1 && gzip_program
!= NULL
)
127 ar_start_gzip(arfd
, gzip_program
, 0);
131 arfd
= STDOUT_FILENO
;
133 } else if ((arfd
= open(name
, AR_MODE
, DMOD
)) < 0)
134 syswarn(1, errno
, "Failed open to write on %s", name
);
137 if (arfd
!= -1 && gzip_program
!= NULL
)
138 ar_start_gzip(arfd
, gzip_program
, 1);
142 arfd
= STDOUT_FILENO
;
144 } else if ((arfd
= open(name
, APP_MODE
, DMOD
)) < 0)
145 syswarn(1, errno
, "Failed open to read/write on %s",
150 * arfd not used in COPY mode
160 if (chdir(chdname
) != 0) {
161 syswarn(1, errno
, "Failed chdir to %s", chdname
);
165 * set up is based on device type
167 if (fstat(arfd
, &arsb
) < 0) {
168 syswarn(0, errno
, "Failed stat on %s", arcname
);
174 if (S_ISDIR(arsb
.st_mode
)) {
175 paxwarn(0, "Cannot write an archive on top of a directory %s",
183 if (S_ISCHR(arsb
.st_mode
))
184 artyp
= ioctl(arfd
, MTIOCGET
, &mb
) ? ISCHR
: ISTAPE
;
185 else if (S_ISBLK(arsb
.st_mode
))
187 else if ((lseek(arfd
, (off_t
)0L, SEEK_CUR
) == -1) && (errno
== ESPIPE
))
193 * make sure we beyond any doubt that we only can unlink regular files
199 * if we are writing, we are done
201 if (act
== ARCHIVE
) {
202 blksz
= rdblksz
= wrblksz
;
208 * set default blksz on read. APPNDs writes rdblksz on the last volume
209 * On all new archive volumes, we shift to wrblksz (if the user
210 * specified one, otherwise we will continue to use rdblksz). We
211 * must set blocksize based on what kind of device the archive is
217 * Tape drives come in at least two flavors. Those that support
218 * variable sized records and those that have fixed sized
219 * records. They must be treated differently. For tape drives
220 * that support variable sized records, we must make large
221 * reads to make sure we get the entire record, otherwise we
222 * will just get the first part of the record (up to size we
223 * asked). Tapes with fixed sized records may or may not return
224 * multiple records in a single read. We really do not care
225 * what the physical record size is UNLESS we are going to
226 * append. (We will need the physical block size to rewrite
227 * the trailer). Only when we are appending do we go to the
228 * effort to figure out the true PHYSICAL record size.
230 blksz
= rdblksz
= MAXBLK
;
236 * Blocksize is not a major issue with these devices (but must
237 * be kept a multiple of 512). If the user specified a write
238 * block size, we use that to read. Under append, we must
239 * always keep blksz == rdblksz. Otherwise we go ahead and use
240 * the device optimal blocksize as (and if) returned by stat
241 * and if it is within pax specs.
243 if ((act
== APPND
) && wrblksz
) {
244 blksz
= rdblksz
= wrblksz
;
248 if ((arsb
.st_blksize
> 0) && (arsb
.st_blksize
< MAXBLK
) &&
249 ((arsb
.st_blksize
% BLKMULT
) == 0))
250 rdblksz
= arsb
.st_blksize
;
254 * For performance go for large reads when we can without harm
256 if ((act
== APPND
) || (artyp
== ISCHR
))
263 * if the user specified wrblksz works, use it. Under appends
264 * we must always keep blksz == rdblksz
266 if ((act
== APPND
) && wrblksz
&& ((arsb
.st_size
%wrblksz
)==0)){
267 blksz
= rdblksz
= wrblksz
;
271 * See if we can find the blocking factor from the file size
273 for (rdblksz
= MAXBLK
; rdblksz
> 0; rdblksz
-= BLKMULT
)
274 if ((arsb
.st_size
% rdblksz
) == 0)
277 * When we cannot find a match, we may have a flawed archive.
282 * for performance go for large reads when we can
291 * should never happen, worst case, slow...
293 blksz
= rdblksz
= BLKMULT
;
302 * closes archive device, increments volume number, and prints i/o summary
310 did_io
= io_ok
= flcnt
= 0;
315 * Close archive file. This may take a LONG while on tapes (we may be
316 * forced to wait for the rewind to complete) so tell the user what is
317 * going on (this avoids the user hitting control-c thinking pax is
320 if (vflag
&& (artyp
== ISTAPE
)) {
322 (void)putc('\n', listf
);
324 "%s: Waiting for tape drive close to complete...",
330 * if nothing was written to the archive (and we created it), we remove
333 if (can_unlnk
&& (fstat(arfd
, &arsb
) == 0) && (S_ISREG(arsb
.st_mode
)) &&
334 (arsb
.st_size
== 0)) {
335 (void)unlink(arcname
);
340 * for a quick extract/list, pax frequently exits before the child
343 if ((act
== LIST
|| act
== EXTRACT
) && nflag
&& zpid
> 0)
348 /* Do not exit before child to ensure data integrity */
350 waitpid(zpid
, &status
, 0);
352 if (vflag
&& (artyp
== ISTAPE
)) {
353 (void)fputs("done.\n", listf
);
359 if (!io_ok
&& !did_io
) {
366 * The volume number is only increased when the last device has data
367 * and we have already determined the archive format.
378 * Print out a summary of I/O for this archive volume.
381 (void)putc('\n', listf
);
386 * If we have not determined the format yet, we just say how many bytes
387 * we have skipped over looking for a header to id. there is no way we
388 * could have written anything yet.
392 (void)fprintf(listf
, "%s: unknown format, %lu bytes skipped.\n",
394 (void)fprintf(listf
, "%s: unknown format, %qu bytes skipped.\n",
402 if (strcmp(NM_CPIO
, argv0
) == 0)
403 (void)fprintf(listf
, "%qu blocks\n", (rdcnt ? rdcnt
: wrcnt
) / 5120);
404 else if (strcmp(NM_TAR
, argv0
) != 0 && strcmp(NM_PAX
, argv0
) != 0)
407 "%s: %s vol %d, %lu files, %lu bytes read, %lu bytes written.\n",
409 "%s: %s vol %d, %lu files, %qu bytes read, %qu bytes written.\n",
411 argv0
, frmt
->name
, arvol
-1, flcnt
, rdcnt
, wrcnt
);
418 * drain any archive format independent padding from an archive read
419 * from a socket or a pipe. This is to prevent the process on the
420 * other side of the pipe from getting a SIGPIPE (pax will stop
421 * reading an archive once a format dependent trailer is detected).
430 * we only drain from a pipe/socket. Other devices can be closed
431 * without reading up to end of file. We sure hope that pipe is closed
432 * on the other side so we will get an EOF.
434 if ((artyp
!= ISPIPE
) || (lstrval
<= 0))
438 * keep reading until pipe is drained
440 while ((res
= read(arfd
, drbuf
, sizeof(drbuf
))) > 0)
447 * Set up device right before switching from read to write in an append.
448 * device dependent code (if required) to do this should be added here.
449 * For all archive devices we are already positioned at the place we want
450 * to start writing when this routine is called.
452 * 0 if all ready to write, -1 otherwise
461 * we must make sure the trailer is rewritten on append, ar_next()
462 * will stop us if the archive containing the trailer was not written
467 * Add any device dependent code as required here
472 * Ok we have an archive in a regular file. If we were rewriting a
473 * file, we must get rid of all the stuff after the current offset
474 * (it was not written by pax).
476 if (((cpos
= lseek(arfd
, (off_t
)0L, SEEK_CUR
)) < 0) ||
477 (ftruncate(arfd
, cpos
) < 0)) {
478 syswarn(1, errno
, "Unable to truncate archive file");
486 * check if the last volume in the archive allows appends. We cannot check
487 * this until we are ready to write since there is no spec that says all
488 * volumes in a single archive have to be of the same type...
490 * 0 if we can append, -1 otherwise.
496 if (artyp
== ISPIPE
) {
497 paxwarn(1, "Cannot append to an archive obtained from a pipe.");
503 paxwarn(1,"Cannot append, device record size %d does not support %s spec",
510 * read up to a specified number of bytes from the archive into the
511 * supplied buffer. When dealing with tapes we may not always be able to
514 * Number of bytes in buffer. 0 for end of file, -1 for a read error.
518 ar_read(char *buf
, int cnt
)
523 * if last i/o was in error, no more reads until reset or new volume
529 * how we read must be based on device type
533 if ((res
= read(arfd
, buf
, cnt
)) > 0) {
535 * CAUTION: tape systems may not always return the same
536 * sized records so we leave blksz == MAXBLK. The
537 * physical record size that a tape drive supports is
538 * very hard to determine in a uniform and portable
542 if (res
!= rdblksz
) {
544 * Record size changed. If this happens on
545 * any record after the first, we probably have
546 * a tape drive which has a fixed record size
547 * (we are getting multiple records in a single
548 * read). Watch out for record blocking that
549 * violates pax spec (must be a multiple of
553 if (rdblksz
% BLKMULT
)
565 * Files are so easy to deal with. These other things cannot
566 * be trusted at all. So when we are dealing with character
567 * devices and pipes we just take what they have ready for us
568 * and return. Trying to do anything else with them runs the
571 if ((res
= read(arfd
, buf
, cnt
)) > 0) {
579 * We are in trouble at this point, something is broken...
583 syswarn(1, errno
, "Failed read on archive volume %d", arvol
);
585 paxwarn(0, "End of archive volume %d reached", arvol
);
591 * Write a specified number of bytes in supplied buffer to the archive
592 * device so it appears as a single "block". Deals with errors and tries
593 * to recover when faced with short writes.
595 * Number of bytes written. 0 indicates end of volume reached and with no
596 * flaws (as best that can be detected). A -1 indicates an unrecoverable
597 * error in the archive occurred.
601 ar_write(char *buf
, int bsz
)
607 * do not allow pax to create a "bad" archive. Once a write fails on
608 * an archive volume prevent further writes to it.
613 if ((res
= write(arfd
, buf
, bsz
)) == bsz
) {
617 } else if (res
< 0 && artyp
== ISPIPE
&& errno
== EPIPE
) { /* ignore it */
621 arfd
= open("/dev/null", AR_MODE
, DMOD
);
627 * write broke, see what we can do with it. We try to send any partial
628 * writes that may violate pax spec to the next archive volume.
637 if ((res
> 0) && (res
% BLKMULT
)) {
639 * try to fix up partial writes which are not BLKMULT
640 * in size by forcing the runt record to next archive
643 if ((cpos
= lseek(arfd
, (off_t
)0L, SEEK_CUR
)) < 0)
646 if (ftruncate(arfd
, cpos
) < 0)
654 * if file is out of space, handle it like a return of 0
656 if ((errno
== ENOSPC
) || (errno
== EFBIG
) || (errno
== EDQUOT
))
664 if (errno
== EACCES
) {
665 paxwarn(0, "Write failed, archive is write protected.");
670 * see if we reached the end of media, if so force a change to
673 if ((errno
== ENOSPC
) || (errno
== EIO
) || (errno
== ENXIO
))
679 * we cannot fix errors to these devices
685 * Better tell the user the bad news...
686 * if this is a block aligned archive format, we may have a bad archive
687 * if the format wants the header to start at a BLKMULT boundary.. While
688 * we can deal with the mis-aligned data, it violates spec and other
689 * archive readers will likely fail. if the format is not block
690 * aligned, the user may be lucky (and the archive is ok).
699 * If we were trying to rewrite the trailer and it didn't work, we
700 * must quit right away.
702 if (!wr_trail
&& (res
<= 0)) {
703 paxwarn(1,"Unable to append, trailer re-write failed. Quitting.");
708 paxwarn(0, "End of archive volume %d reached", arvol
);
710 syswarn(1, errno
, "Failed write to archive volume: %d", arvol
);
711 else if (!frmt
->blkalgn
|| ((res
% frmt
->blkalgn
) == 0))
712 paxwarn(0,"WARNING: partial archive write. Archive MAY BE FLAWED");
714 paxwarn(1,"WARNING: partial archive write. Archive IS FLAWED");
720 * Try to move past a bad spot on a flawed archive as needed to continue
721 * I/O. Clears error flags to allow I/O to continue.
723 * 0 when ok to try i/o again, -1 otherwise.
735 * Fail resync attempts at user request (done) or if this is going to be
736 * an update/append to a existing archive. if last i/o hit media end,
737 * we need to go to the next volume not try a resync
739 if ((done
> 0) || (lstrval
== 0))
742 if ((act
== APPND
) || (act
== ARCHIVE
)) {
743 paxwarn(1, "Cannot allow updates to an archive with flaws.");
752 * if the last i/o was a successful data transfer, we assume
753 * the fault is just a bad record on the tape that we are now
754 * past. If we did not get any data since the last resync try
755 * to move the tape forward one PHYSICAL record past any
756 * damaged tape section. Some tape drives are stubborn and need
766 if (ioctl(arfd
, MTIOCTOP
, &mb
) < 0)
774 * try to step over the bad part of the device.
777 if (((fsbz
= arsb
.st_blksize
) <= 0) || (artyp
!= ISREG
))
779 if ((cpos
= lseek(arfd
, (off_t
)0L, SEEK_CUR
)) < 0)
781 mpos
= fsbz
- (cpos
% (off_t
)fsbz
);
782 if (lseek(arfd
, mpos
, SEEK_CUR
) < 0)
789 * cannot recover on these archive device types
795 paxwarn(1, "Unable to recover from an archive read failure.");
798 paxwarn(0, "Attempting to recover from an archive read failure.");
804 * Move the I/O position within the archive forward the specified number of
805 * bytes as supported by the device. If we cannot move the requested
806 * number of bytes, return the actual number of bytes moved in skipped.
808 * 0 if moved the requested distance, -1 on complete failure, 1 on
809 * partial move (the amount moved is in skipped)
813 ar_fow(off_t sksz
, off_t
*skipped
)
823 * we cannot move forward at EOF or error
829 * Safer to read forward on devices where it is hard to find the end of
830 * the media without reading to it. With tapes we cannot be sure of the
831 * number of physical blocks to skip (we do not know physical block
832 * size at this point), so we must only read forward on tapes!
838 * figure out where we are in the archive
840 if ((cpos
= lseek(arfd
, (off_t
)0L, SEEK_CUR
)) >= 0) {
842 * we can be asked to move farther than there are bytes in this
843 * volume, if so, just go to file end and let normal buf_fill()
844 * deal with the end of file (it will go to next volume by
847 if ((mpos
= cpos
+ sksz
) > arsb
.st_size
) {
848 *skipped
= arsb
.st_size
- cpos
;
852 if (lseek(arfd
, mpos
, SEEK_SET
) >= 0)
855 syswarn(1, errno
, "Forward positioning operation on archive failed");
862 * move the i/o position within the archive backwards the specified byte
863 * count as supported by the device. With tapes drives we RESET rdblksz to
864 * the PHYSICAL blocksize.
865 * NOTE: We should only be called to move backwards so we can rewrite the
866 * last records (the trailer) of an archive (APPEND).
868 * 0 if moved the requested distance, -1 on complete failure
879 * make sure we do not have try to reverse on a flawed archive
889 * cannot go backwards on these critters
891 paxwarn(1, "Reverse positioning on pipes is not supported.");
902 * For things other than files, backwards movement has a very
903 * high probability of failure as we really do not know the
904 * true attributes of the device we are talking to (the device
905 * may not even have the ability to lseek() in any direction).
906 * First we figure out where we are in the archive.
908 if ((cpos
= lseek(arfd
, (off_t
)0L, SEEK_CUR
)) < 0) {
910 "Unable to obtain current archive byte offset");
916 * we may try to go backwards past the start when the archive
917 * is only a single record. If this happens and we are on a
918 * multi-volume archive, we need to go to the end of the
919 * previous volume and continue our movement backwards from
922 if ((cpos
-= sksz
) < (off_t
)0L) {
925 * this should never happen
927 paxwarn(1,"Reverse position on previous volume.");
933 if (lseek(arfd
, cpos
, SEEK_SET
) < 0) {
934 syswarn(1, errno
, "Unable to seek archive backwards");
941 * Calculate and move the proper number of PHYSICAL tape
942 * blocks. If the sksz is not an even multiple of the physical
943 * tape size, we cannot do the move (this should never happen).
944 * (We also cannot handle trailers spread over two vols.)
945 * get_phys() also makes sure we are in front of the filemark.
947 if ((phyblk
= get_phys()) <= 0) {
953 * make sure future tape reads only go by physical tape block
954 * size (set rdblksz to the real size).
959 * if no movement is required, just return (we must be after
960 * get_phys() so the physical blocksize is properly set)
966 * ok we have to move. Make sure the tape drive can do it.
970 "Tape drive unable to backspace requested amount");
976 * move backwards the requested number of bytes
979 mb
.mt_count
= sksz
/phyblk
;
980 if (ioctl(arfd
, MTIOCTOP
, &mb
) < 0) {
981 syswarn(1,errno
, "Unable to backspace tape %d blocks.",
994 * Determine the physical block size on a tape drive. We need the physical
995 * block size so we know how many bytes we skip over when we move with
996 * mtio commands. We also make sure we are BEFORE THE TAPE FILEMARK when
998 * This is one really SLOW routine...
1000 * physical block size if ok (ok > 0), -1 otherwise
1013 * move to the file mark, and then back up one record and read it.
1014 * this should tell us the physical record size the tape is using.
1018 * we know we are at file mark when we get back a 0 from
1021 while ((res
= read(arfd
, scbuf
, sizeof(scbuf
))) > 0)
1024 syswarn(1, errno
, "Unable to locate tape filemark.");
1030 * move backwards over the file mark so we are at the end of the
1035 if (ioctl(arfd
, MTIOCTOP
, &mb
) < 0) {
1036 syswarn(1, errno
, "Unable to backspace over tape filemark.");
1041 * move backwards so we are in front of the last record and read it to
1042 * get physical tape blocksize.
1046 if (ioctl(arfd
, MTIOCTOP
, &mb
) < 0) {
1047 syswarn(1, errno
, "Unable to backspace over last tape block.");
1050 if ((phyblk
= read(arfd
, scbuf
, sizeof(scbuf
))) <= 0) {
1051 syswarn(1, errno
, "Cannot determine archive tape blocksize.");
1056 * read forward to the file mark, then back up in front of the filemark
1057 * (this is a bit paranoid, but should be safe to do).
1059 while ((res
= read(arfd
, scbuf
, sizeof(scbuf
))) > 0)
1062 syswarn(1, errno
, "Unable to locate tape filemark.");
1067 if (ioctl(arfd
, MTIOCTOP
, &mb
) < 0) {
1068 syswarn(1, errno
, "Unable to backspace over tape filemark.");
1073 * set lstrval so we know that the filemark has not been seen
1078 * return if there was no padding
1084 * make sure we can move backwards over the padding. (this should
1087 if (padsz
% phyblk
) {
1088 paxwarn(1, "Tape drive unable to backspace requested amount");
1093 * move backwards over the padding so the head is where it was when
1094 * we were first called (if required).
1097 mb
.mt_count
= padsz
/phyblk
;
1098 if (ioctl(arfd
, MTIOCTOP
, &mb
) < 0) {
1099 syswarn(1,errno
,"Unable to backspace tape over %d pad blocks",
1108 * prompts the user for the next volume in this archive. For some devices
1109 * we may allow the media to be changed. Otherwise a new archive is
1110 * prompted for. By pax spec, if there is no controlling tty or an eof is
1111 * read on tty input, we must quit pax.
1113 * 0 when ready to continue, -1 when all done
1119 char buf
[PAXPATHLEN
+2];
1120 static int freeit
= 0;
1124 * WE MUST CLOSE THE DEVICE. A lot of devices must see last close, (so
1125 * things like writing EOF etc will be done) (Watch out ar_close() can
1126 * also be called via a signal handler, so we must prevent a race.
1128 if (sigprocmask(SIG_BLOCK
, &s_mask
, &o_mask
) < 0)
1129 syswarn(0, errno
, "Unable to set signal mask");
1131 if (sigprocmask(SIG_SETMASK
, &o_mask
, NULL
) < 0)
1132 syswarn(0, errno
, "Unable to restore signal mask");
1134 /* Don't query for new volume if format is unknown */
1135 if (frmt
== NULL
|| done
|| !wr_trail
|| force_one_volume
|| strcmp(NM_TAR
, argv0
) == 0 ||
1136 strcmp(NM_PAX
, argv0
) == 0)
1139 tty_prnt("\nATTENTION! %s archive volume change required.\n", argv0
);
1142 * if i/o is on stdin or stdout, we cannot reopen it (we do not know
1143 * the name), the user will be forced to type it in.
1145 if (strcmp(arcname
, STDO
) && strcmp(arcname
, STDN
) && (artyp
!= ISREG
)
1146 && (artyp
!= ISPIPE
)) {
1147 if (artyp
== ISTAPE
) {
1148 tty_prnt("%s ready for archive tape volume: %d\n",
1150 tty_prnt("Load the NEXT TAPE on the tape drive");
1152 tty_prnt("%s ready for archive volume: %d\n",
1154 tty_prnt("Load the NEXT STORAGE MEDIA (if required)");
1157 if ((act
== ARCHIVE
) || (act
== APPND
))
1158 tty_prnt(" and make sure it is WRITE ENABLED.\n");
1163 tty_prnt("Type \"y\" to continue, \".\" to quit %s,",
1165 tty_prnt(" or \"s\" to switch to new device.\nIf you");
1166 tty_prnt(" cannot change storage media, type \"s\"\n");
1167 tty_prnt("Is the device ready and online? > ");
1169 if ((tty_read(buf
,sizeof(buf
))<0) || !strcmp(buf
,".")){
1172 tty_prnt("Quitting %s!\n", argv0
);
1177 if ((buf
[0] == '\0') || (buf
[1] != '\0')) {
1178 tty_prnt("%s unknown command, try again\n",buf
);
1186 * we are to continue with the same device
1188 if (ar_open(arcname
) >= 0)
1190 tty_prnt("Cannot re-open %s, try again\n",
1196 * user wants to open a different device
1198 tty_prnt("Switching to a different archive\n");
1201 tty_prnt("%s unknown command, try again\n",buf
);
1207 tty_prnt("Ready for archive volume: %d\n", arvol
);
1210 * have to go to a different archive
1213 tty_prnt("Input archive name or \".\" to quit %s.\n", argv0
);
1214 tty_prnt("Archive name > ");
1216 if ((tty_read(buf
, sizeof(buf
)) < 0) || !strcmp(buf
, ".")) {
1219 tty_prnt("Quitting %s!\n", argv0
);
1223 if (buf
[0] == '\0') {
1224 tty_prnt("Empty file name, try again\n");
1227 if (!strcmp(buf
, "..")) {
1228 tty_prnt("Illegal file name: .. try again\n");
1231 if (strlen(buf
) > PAXPATHLEN
) {
1232 tty_prnt("File name too long, try again\n");
1237 * try to open new archive
1239 if (ar_open(buf
) >= 0) {
1241 (void)free((char *)arcname
);
1244 if ((arcname
= strdup(buf
)) == NULL
) {
1247 paxwarn(0, "Cannot save archive name.");
1253 tty_prnt("Cannot open %s, try again\n", buf
);
1261 * starts the gzip compression/decompression process as a child, using magic
1262 * to keep the fd the same in the calling function (parent).
1265 ar_start_gzip(int fd
, const char *gzip_program
, int wr
)
1268 const char *gzip_flags
= NULL
;
1271 err(1, "could not pipe");
1274 err(1, "could not fork");
1286 dup2(fds
[0], STDIN_FILENO
);
1287 dup2(fd
, STDOUT_FILENO
);
1290 dup2(fds
[1], STDOUT_FILENO
);
1291 dup2(fd
, STDIN_FILENO
);
1296 if (execlp(gzip_program
, gzip_program
, gzip_flags
, (char *)NULL
) < 0)
1297 err(1, "could not exec");