xref: /freebsd/bin/pax/ar_io.c (revision bb15ca603fa442c72dde3f3cb8b46db6970e3950)
1 /*-
2  * Copyright (c) 1992 Keith Muller.
3  * Copyright (c) 1992, 1993
4  *	The Regents of the University of California.  All rights reserved.
5  *
6  * This code is derived from software contributed to Berkeley by
7  * Keith Muller of the University of California, San Diego.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33 
34 #ifndef lint
35 #if 0
36 static char sccsid[] = "@(#)ar_io.c	8.2 (Berkeley) 4/18/94";
37 #endif
38 #endif /* not lint */
39 #include <sys/cdefs.h>
40 __FBSDID("$FreeBSD$");
41 
42 #include <sys/types.h>
43 #include <sys/ioctl.h>
44 #include <sys/mtio.h>
45 #include <sys/stat.h>
46 #include <sys/wait.h>
47 #include <err.h>
48 #include <errno.h>
49 #include <fcntl.h>
50 #include <signal.h>
51 #include <stdint.h>
52 #include <stdio.h>
53 #include <string.h>
54 #include <stdlib.h>
55 #include <unistd.h>
56 #include "pax.h"
57 #include "options.h"
58 #include "extern.h"
59 
60 /*
61  * Routines which deal directly with the archive I/O device/file.
62  */
63 
64 #define DMOD		0666		/* default mode of created archives */
65 #define EXT_MODE	O_RDONLY	/* open mode for list/extract */
66 #define AR_MODE		(O_WRONLY | O_CREAT | O_TRUNC)	/* mode for archive */
67 #define APP_MODE	O_RDWR		/* mode for append */
68 
69 static char none[] = "<NONE>";		/* pseudo name for no file */
70 static char stdo[] = "<STDOUT>";	/* pseudo name for stdout */
71 static char stdn[] = "<STDIN>";		/* pseudo name for stdin */
72 static int arfd = -1;			/* archive file descriptor */
73 static int artyp = ISREG;		/* archive type: file/FIFO/tape */
74 static int arvol = 1;			/* archive volume number */
75 static int lstrval = -1;		/* return value from last i/o */
76 static int io_ok;			/* i/o worked on volume after resync */
77 static int did_io;			/* did i/o ever occur on volume? */
78 static int done;			/* set via tty termination */
79 static struct stat arsb;		/* stat of archive device at open */
80 static int invld_rec;			/* tape has out of spec record size */
81 static int wr_trail = 1;		/* trailer was rewritten in append */
82 static int can_unlnk = 0;		/* do we unlink null archives?  */
83 const char *arcname;		  	/* printable name of archive */
84 const char *gzip_program;		/* name of gzip program */
85 static pid_t zpid = -1;			/* pid of child process */
86 
87 static int get_phys(void);
88 extern sigset_t s_mask;
89 static void ar_start_gzip(int, const char *, int);
90 
91 /*
92  * ar_open()
93  *	Opens the next archive volume. Determines the type of the device and
94  *	sets up block sizes as required by the archive device and the format.
95  *	Note: we may be called with name == NULL on the first open only.
96  * Return:
97  *	-1 on failure, 0 otherwise
98  */
99 
100 int
101 ar_open(const char *name)
102 {
103 	struct mtget mb;
104 
105 	if (arfd != -1)
106 		(void)close(arfd);
107 	arfd = -1;
108 	can_unlnk = did_io = io_ok = invld_rec = 0;
109 	artyp = ISREG;
110 	flcnt = 0;
111 
112 	/*
113 	 * open based on overall operation mode
114 	 */
115 	switch (act) {
116 	case LIST:
117 	case EXTRACT:
118 		if (name == NULL) {
119 			arfd = STDIN_FILENO;
120 			arcname = stdn;
121 		} else if ((arfd = open(name, EXT_MODE, DMOD)) < 0)
122 			syswarn(0, errno, "Failed open to read on %s", name);
123 		if (arfd != -1 && gzip_program != NULL)
124 			ar_start_gzip(arfd, gzip_program, 0);
125 		break;
126 	case ARCHIVE:
127 		if (name == NULL) {
128 			arfd = STDOUT_FILENO;
129 			arcname = stdo;
130 		} else if ((arfd = open(name, AR_MODE, DMOD)) < 0)
131 			syswarn(0, errno, "Failed open to write on %s", name);
132 		else
133 			can_unlnk = 1;
134 		if (arfd != -1 && gzip_program != NULL)
135 			ar_start_gzip(arfd, gzip_program, 1);
136 		break;
137 	case APPND:
138 		if (name == NULL) {
139 			arfd = STDOUT_FILENO;
140 			arcname = stdo;
141 		} else if ((arfd = open(name, APP_MODE, DMOD)) < 0)
142 			syswarn(0, errno, "Failed open to read/write on %s",
143 				name);
144 		break;
145 	case COPY:
146 		/*
147 		 * arfd not used in COPY mode
148 		 */
149 		arcname = none;
150 		lstrval = 1;
151 		return(0);
152 	}
153 	if (arfd < 0)
154 		return(-1);
155 
156 	if (chdname != NULL)
157 		if (chdir(chdname) != 0) {
158 			syswarn(1, errno, "Failed chdir to %s", chdname);
159 			return(-1);
160 		}
161 	/*
162 	 * set up is based on device type
163 	 */
164 	if (fstat(arfd, &arsb) < 0) {
165 		syswarn(0, errno, "Failed stat on %s", arcname);
166 		(void)close(arfd);
167 		arfd = -1;
168 		can_unlnk = 0;
169 		return(-1);
170 	}
171 	if (S_ISDIR(arsb.st_mode)) {
172 		paxwarn(0, "Cannot write an archive on top of a directory %s",
173 		    arcname);
174 		(void)close(arfd);
175 		arfd = -1;
176 		can_unlnk = 0;
177 		return(-1);
178 	}
179 
180 	if (S_ISCHR(arsb.st_mode))
181 		artyp = ioctl(arfd, MTIOCGET, &mb) ? ISCHR : ISTAPE;
182 	else if (S_ISBLK(arsb.st_mode))
183 		artyp = ISBLK;
184 	else if ((lseek(arfd, (off_t)0L, SEEK_CUR) == -1) && (errno == ESPIPE))
185 		artyp = ISPIPE;
186 	else
187 		artyp = ISREG;
188 
189 	/*
190 	 * make sure we beyond any doubt that we only can unlink regular files
191 	 * we created
192 	 */
193 	if (artyp != ISREG)
194 		can_unlnk = 0;
195 	/*
196 	 * if we are writing, we are done
197 	 */
198 	if (act == ARCHIVE) {
199 		blksz = rdblksz = wrblksz;
200 		lstrval = 1;
201 		return(0);
202 	}
203 
204 	/*
205 	 * set default blksz on read. APPNDs writes rdblksz on the last volume
206 	 * On all new archive volumes, we shift to wrblksz (if the user
207 	 * specified one, otherwise we will continue to use rdblksz). We
208 	 * must to set blocksize based on what kind of device the archive is
209 	 * stored.
210 	 */
211 	switch(artyp) {
212 	case ISTAPE:
213 		/*
214 		 * Tape drives come in at least two flavors. Those that support
215 		 * variable sized records and those that have fixed sized
216 		 * records. They must be treated differently. For tape drives
217 		 * that support variable sized records, we must make large
218 		 * reads to make sure we get the entire record, otherwise we
219 		 * will just get the first part of the record (up to size we
220 		 * asked). Tapes with fixed sized records may or may not return
221 		 * multiple records in a single read. We really do not care
222 		 * what the physical record size is UNLESS we are going to
223 		 * append. (We will need the physical block size to rewrite
224 		 * the trailer). Only when we are appending do we go to the
225 		 * effort to figure out the true PHYSICAL record size.
226 		 */
227 		blksz = rdblksz = MAXBLK;
228 		break;
229 	case ISPIPE:
230 	case ISBLK:
231 	case ISCHR:
232 		/*
233 		 * Blocksize is not a major issue with these devices (but must
234 		 * be kept a multiple of 512). If the user specified a write
235 		 * block size, we use that to read. Under append, we must
236 		 * always keep blksz == rdblksz. Otherwise we go ahead and use
237 		 * the device optimal blocksize as (and if) returned by stat
238 		 * and if it is within pax specs.
239 		 */
240 		if ((act == APPND) && wrblksz) {
241 			blksz = rdblksz = wrblksz;
242 			break;
243 		}
244 
245 		if ((arsb.st_blksize > 0) && (arsb.st_blksize < MAXBLK) &&
246 		    ((arsb.st_blksize % BLKMULT) == 0))
247 			rdblksz = arsb.st_blksize;
248 		else
249 			rdblksz = DEVBLK;
250 		/*
251 		 * For performance go for large reads when we can without harm
252 		 */
253 		if ((act == APPND) || (artyp == ISCHR))
254 			blksz = rdblksz;
255 		else
256 			blksz = MAXBLK;
257 		break;
258 	case ISREG:
259 		/*
260 		 * if the user specified wrblksz works, use it. Under appends
261 		 * we must always keep blksz == rdblksz
262 		 */
263 		if ((act == APPND) && wrblksz && ((arsb.st_size%wrblksz)==0)){
264 			blksz = rdblksz = wrblksz;
265 			break;
266 		}
267 		/*
268 		 * See if we can find the blocking factor from the file size
269 		 */
270 		for (rdblksz = MAXBLK; rdblksz > 0; rdblksz -= BLKMULT)
271 			if ((arsb.st_size % rdblksz) == 0)
272 				break;
273 		/*
274 		 * When we cannot find a match, we may have a flawed archive.
275 		 */
276 		if (rdblksz <= 0)
277 			rdblksz = FILEBLK;
278 		/*
279 		 * for performance go for large reads when we can
280 		 */
281 		if (act == APPND)
282 			blksz = rdblksz;
283 		else
284 			blksz = MAXBLK;
285 		break;
286 	default:
287 		/*
288 		 * should never happen, worse case, slow...
289 		 */
290 		blksz = rdblksz = BLKMULT;
291 		break;
292 	}
293 	lstrval = 1;
294 	return(0);
295 }
296 
297 /*
298  * ar_close()
299  *	closes archive device, increments volume number, and prints i/o summary
300  */
301 void
302 ar_close(void)
303 {
304 	int status;
305 
306 	if (arfd < 0) {
307 		did_io = io_ok = flcnt = 0;
308 		return;
309 	}
310 
311 	/*
312 	 * Close archive file. This may take a LONG while on tapes (we may be
313 	 * forced to wait for the rewind to complete) so tell the user what is
314 	 * going on (this avoids the user hitting control-c thinking pax is
315 	 * broken).
316 	 */
317 	if (vflag && (artyp == ISTAPE)) {
318 		if (vfpart)
319 			(void)putc('\n', listf);
320 		(void)fprintf(listf,
321 			"%s: Waiting for tape drive close to complete...",
322 			argv0);
323 		(void)fflush(listf);
324 	}
325 
326 	/*
327 	 * if nothing was written to the archive (and we created it), we remove
328 	 * it
329 	 */
330 	if (can_unlnk && (fstat(arfd, &arsb) == 0) && (S_ISREG(arsb.st_mode)) &&
331 	    (arsb.st_size == 0)) {
332 		(void)unlink(arcname);
333 		can_unlnk = 0;
334 	}
335 
336 	/*
337 	 * for a quick extract/list, pax frequently exits before the child
338 	 * process is done
339 	 */
340 	if ((act == LIST || act == EXTRACT) && nflag && zpid > 0)
341 		kill(zpid, SIGINT);
342 
343 	(void)close(arfd);
344 
345 	/* Do not exit before child to ensure data integrity */
346 	if (zpid > 0)
347 		waitpid(zpid, &status, 0);
348 
349 	if (vflag && (artyp == ISTAPE)) {
350 		(void)fputs("done.\n", listf);
351 		vfpart = 0;
352 		(void)fflush(listf);
353 	}
354 	arfd = -1;
355 
356 	if (!io_ok && !did_io) {
357 		flcnt = 0;
358 		return;
359 	}
360 	did_io = io_ok = 0;
361 
362 	/*
363 	 * The volume number is only increased when the last device has data
364 	 * and we have already determined the archive format.
365 	 */
366 	if (frmt != NULL)
367 		++arvol;
368 
369 	if (!vflag) {
370 		flcnt = 0;
371 		return;
372 	}
373 
374 	/*
375 	 * Print out a summary of I/O for this archive volume.
376 	 */
377 	if (vfpart) {
378 		(void)putc('\n', listf);
379 		vfpart = 0;
380 	}
381 
382 	/*
383 	 * If we have not determined the format yet, we just say how many bytes
384 	 * we have skipped over looking for a header to id. There is no way we
385 	 * could have written anything yet.
386 	 */
387 	if (frmt == NULL) {
388 #	ifdef NET2_STAT
389 		(void)fprintf(listf, "%s: unknown format, %lu bytes skipped.\n",
390 		    argv0, rdcnt);
391 #	else
392 		(void)fprintf(listf, "%s: unknown format, %ju bytes skipped.\n",
393 		    argv0, (uintmax_t)rdcnt);
394 #	endif
395 		(void)fflush(listf);
396 		flcnt = 0;
397 		return;
398 	}
399 
400 	if (strcmp(NM_CPIO, argv0) == 0)
401 		(void)fprintf(listf, "%llu blocks\n",
402 		    (unsigned long long)((rdcnt ? rdcnt : wrcnt) / 5120));
403 	else if (strcmp(NM_TAR, argv0) != 0)
404 		(void)fprintf(listf,
405 #	ifdef NET2_STAT
406 		    "%s: %s vol %d, %lu files, %lu bytes read, %lu bytes written.\n",
407 		    argv0, frmt->name, arvol-1, flcnt, rdcnt, wrcnt);
408 #	else
409 		    "%s: %s vol %d, %ju files, %ju bytes read, %ju bytes written.\n",
410 		    argv0, frmt->name, arvol-1, (uintmax_t)flcnt,
411 		    (uintmax_t)rdcnt, (uintmax_t)wrcnt);
412 #	endif
413 	(void)fflush(listf);
414 	flcnt = 0;
415 }
416 
417 /*
418  * ar_drain()
419  *	drain any archive format independent padding from an archive read
420  *	from a socket or a pipe. This is to prevent the process on the
421  *	other side of the pipe from getting a SIGPIPE (pax will stop
422  *	reading an archive once a format dependent trailer is detected).
423  */
424 void
425 ar_drain(void)
426 {
427 	int res;
428 	char drbuf[MAXBLK];
429 
430 	/*
431 	 * we only drain from a pipe/socket. Other devices can be closed
432 	 * without reading up to end of file. We sure hope that pipe is closed
433 	 * on the other side so we will get an EOF.
434 	 */
435 	if ((artyp != ISPIPE) || (lstrval <= 0))
436 		return;
437 
438 	/*
439 	 * keep reading until pipe is drained
440 	 */
441 	while ((res = read(arfd, drbuf, sizeof(drbuf))) > 0)
442 		;
443 	lstrval = res;
444 }
445 
446 /*
447  * ar_set_wr()
448  *	Set up device right before switching from read to write in an append.
449  *	device dependent code (if required) to do this should be added here.
450  *	For all archive devices we are already positioned at the place we want
451  *	to start writing when this routine is called.
452  * Return:
453  *	0 if all ready to write, -1 otherwise
454  */
455 
456 int
457 ar_set_wr(void)
458 {
459 	off_t cpos;
460 
461 	/*
462 	 * we must make sure the trailer is rewritten on append, ar_next()
463 	 * will stop us if the archive containing the trailer was not written
464 	 */
465 	wr_trail = 0;
466 
467 	/*
468 	 * Add any device dependent code as required here
469 	 */
470 	if (artyp != ISREG)
471 		return(0);
472 	/*
473 	 * Ok we have an archive in a regular file. If we were rewriting a
474 	 * file, we must get rid of all the stuff after the current offset
475 	 * (it was not written by pax).
476 	 */
477 	if (((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0) ||
478 	    (ftruncate(arfd, cpos) < 0)) {
479 		syswarn(1, errno, "Unable to truncate archive file");
480 		return(-1);
481 	}
482 	return(0);
483 }
484 
485 /*
486  * ar_app_ok()
487  *	check if the last volume in the archive allows appends. We cannot check
488  *	this until we are ready to write since there is no spec that says all
489  *	volumes in a single archive have to be of the same type...
490  * Return:
491  *	0 if we can append, -1 otherwise.
492  */
493 
494 int
495 ar_app_ok(void)
496 {
497 	if (artyp == ISPIPE) {
498 		paxwarn(1, "Cannot append to an archive obtained from a pipe.");
499 		return(-1);
500 	}
501 
502 	if (!invld_rec)
503 		return(0);
504 	paxwarn(1,"Cannot append, device record size %d does not support %s spec",
505 		rdblksz, argv0);
506 	return(-1);
507 }
508 
509 /*
510  * ar_read()
511  *	read up to a specified number of bytes from the archive into the
512  *	supplied buffer. When dealing with tapes we may not always be able to
513  *	read what we want.
514  * Return:
515  *	Number of bytes in buffer. 0 for end of file, -1 for a read error.
516  */
517 
518 int
519 ar_read(char *buf, int cnt)
520 {
521 	int res = 0;
522 
523 	/*
524 	 * if last i/o was in error, no more reads until reset or new volume
525 	 */
526 	if (lstrval <= 0)
527 		return(lstrval);
528 
529 	/*
530 	 * how we read must be based on device type
531 	 */
532 	switch (artyp) {
533 	case ISTAPE:
534 		if ((res = read(arfd, buf, cnt)) > 0) {
535 			/*
536 			 * CAUTION: tape systems may not always return the same
537 			 * sized records so we leave blksz == MAXBLK. The
538 			 * physical record size that a tape drive supports is
539 			 * very hard to determine in a uniform and portable
540 			 * manner.
541 			 */
542 			io_ok = 1;
543 			if (res != rdblksz) {
544 				/*
545 				 * Record size changed. If this is happens on
546 				 * any record after the first, we probably have
547 				 * a tape drive which has a fixed record size
548 				 * we are getting multiple records in a single
549 				 * read). Watch out for record blocking that
550 				 * violates pax spec (must be a multiple of
551 				 * BLKMULT).
552 				 */
553 				rdblksz = res;
554 				if (rdblksz % BLKMULT)
555 					invld_rec = 1;
556 			}
557 			return(res);
558 		}
559 		break;
560 	case ISREG:
561 	case ISBLK:
562 	case ISCHR:
563 	case ISPIPE:
564 	default:
565 		/*
566 		 * Files are so easy to deal with. These other things cannot
567 		 * be trusted at all. So when we are dealing with character
568 		 * devices and pipes we just take what they have ready for us
569 		 * and return. Trying to do anything else with them runs the
570 		 * risk of failure.
571 		 */
572 		if ((res = read(arfd, buf, cnt)) > 0) {
573 			io_ok = 1;
574 			return(res);
575 		}
576 		break;
577 	}
578 
579 	/*
580 	 * We are in trouble at this point, something is broken...
581 	 */
582 	lstrval = res;
583 	if (res < 0)
584 		syswarn(1, errno, "Failed read on archive volume %d", arvol);
585 	else
586 		paxwarn(0, "End of archive volume %d reached", arvol);
587 	return(res);
588 }
589 
590 /*
591  * ar_write()
592  *	Write a specified number of bytes in supplied buffer to the archive
593  *	device so it appears as a single "block". Deals with errors and tries
594  *	to recover when faced with short writes.
595  * Return:
596  *	Number of bytes written. 0 indicates end of volume reached and with no
597  *	flaws (as best that can be detected). A -1 indicates an unrecoverable
598  *	error in the archive occurred.
599  */
600 
601 int
602 ar_write(char *buf, int bsz)
603 {
604 	int res;
605 	off_t cpos;
606 
607 	/*
608 	 * do not allow pax to create a "bad" archive. Once a write fails on
609 	 * an archive volume prevent further writes to it.
610 	 */
611 	if (lstrval <= 0)
612 		return(lstrval);
613 
614 	if ((res = write(arfd, buf, bsz)) == bsz) {
615 		wr_trail = 1;
616 		io_ok = 1;
617 		return(bsz);
618 	}
619 	/*
620 	 * write broke, see what we can do with it. We try to send any partial
621 	 * writes that may violate pax spec to the next archive volume.
622 	 */
623 	if (res < 0)
624 		lstrval = res;
625 	else
626 		lstrval = 0;
627 
628 	switch (artyp) {
629 	case ISREG:
630 		if ((res > 0) && (res % BLKMULT)) {
631 			/*
632 		 	 * try to fix up partial writes which are not BLKMULT
633 			 * in size by forcing the runt record to next archive
634 			 * volume
635 		 	 */
636 			if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0)
637 				break;
638 			cpos -= (off_t)res;
639 			if (ftruncate(arfd, cpos) < 0)
640 				break;
641 			res = lstrval = 0;
642 			break;
643 		}
644 		if (res >= 0)
645 			break;
646 		/*
647 		 * if file is out of space, handle it like a return of 0
648 		 */
649 		if ((errno == ENOSPC) || (errno == EFBIG) || (errno == EDQUOT))
650 			res = lstrval = 0;
651 		break;
652 	case ISTAPE:
653 	case ISCHR:
654 	case ISBLK:
655 		if (res >= 0)
656 			break;
657 		if (errno == EACCES) {
658 			paxwarn(0, "Write failed, archive is write protected.");
659 			res = lstrval = 0;
660 			return(0);
661 		}
662 		/*
663 		 * see if we reached the end of media, if so force a change to
664 		 * the next volume
665 		 */
666 		if ((errno == ENOSPC) || (errno == EIO) || (errno == ENXIO))
667 			res = lstrval = 0;
668 		break;
669 	case ISPIPE:
670 	default:
671 		/*
672 		 * we cannot fix errors to these devices
673 		 */
674 		break;
675 	}
676 
677 	/*
678 	 * Better tell the user the bad news...
679 	 * if this is a block aligned archive format, we may have a bad archive
680 	 * if the format wants the header to start at a BLKMULT boundary. While
681 	 * we can deal with the mis-aligned data, it violates spec and other
682 	 * archive readers will likely fail. If the format is not block
683 	 * aligned, the user may be lucky (and the archive is ok).
684 	 */
685 	if (res >= 0) {
686 		if (res > 0)
687 			wr_trail = 1;
688 		io_ok = 1;
689 	}
690 
691 	/*
692 	 * If we were trying to rewrite the trailer and it didn't work, we
693 	 * must quit right away.
694 	 */
695 	if (!wr_trail && (res <= 0)) {
696 		paxwarn(1,"Unable to append, trailer re-write failed. Quitting.");
697 		return(res);
698 	}
699 
700 	if (res == 0)
701 		paxwarn(0, "End of archive volume %d reached", arvol);
702 	else if (res < 0)
703 		syswarn(1, errno, "Failed write to archive volume: %d", arvol);
704 	else if (!frmt->blkalgn || ((res % frmt->blkalgn) == 0))
705 		paxwarn(0,"WARNING: partial archive write. Archive MAY BE FLAWED");
706 	else
707 		paxwarn(1,"WARNING: partial archive write. Archive IS FLAWED");
708 	return(res);
709 }
710 
711 /*
712  * ar_rdsync()
713  *	Try to move past a bad spot on a flawed archive as needed to continue
714  *	I/O. Clears error flags to allow I/O to continue.
715  * Return:
716  *	0 when ok to try i/o again, -1 otherwise.
717  */
718 
719 int
720 ar_rdsync(void)
721 {
722 	long fsbz;
723 	off_t cpos;
724 	off_t mpos;
725 	struct mtop mb;
726 
727 	/*
728 	 * Fail resync attempts at user request (done) or this is going to be
729 	 * an update/append to an existing archive. If last i/o hit media end,
730 	 * we need to go to the next volume not try a resync.
731 	 */
732 	if ((done > 0) || (lstrval == 0))
733 		return(-1);
734 
735 	if ((act == APPND) || (act == ARCHIVE)) {
736 		paxwarn(1, "Cannot allow updates to an archive with flaws.");
737 		return(-1);
738 	}
739 	if (io_ok)
740 		did_io = 1;
741 
742 	switch(artyp) {
743 	case ISTAPE:
744 		/*
745 		 * if the last i/o was a successful data transfer, we assume
746 		 * the fault is just a bad record on the tape that we are now
747 		 * past. If we did not get any data since the last resync try
748 		 * to move the tape forward one PHYSICAL record past any
749 		 * damaged tape section. Some tape drives are stubborn and need
750 		 * to be pushed.
751 		 */
752 		if (io_ok) {
753 			io_ok = 0;
754 			lstrval = 1;
755 			break;
756 		}
757 		mb.mt_op = MTFSR;
758 		mb.mt_count = 1;
759 		if (ioctl(arfd, MTIOCTOP, &mb) < 0)
760 			break;
761 		lstrval = 1;
762 		break;
763 	case ISREG:
764 	case ISCHR:
765 	case ISBLK:
766 		/*
767 		 * try to step over the bad part of the device.
768 		 */
769 		io_ok = 0;
770 		if (((fsbz = arsb.st_blksize) <= 0) || (artyp != ISREG))
771 			fsbz = BLKMULT;
772 		if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0)
773 			break;
774 		mpos = fsbz - (cpos % (off_t)fsbz);
775 		if (lseek(arfd, mpos, SEEK_CUR) < 0)
776 			break;
777 		lstrval = 1;
778 		break;
779 	case ISPIPE:
780 	default:
781 		/*
782 		 * cannot recover on these archive device types
783 		 */
784 		io_ok = 0;
785 		break;
786 	}
787 	if (lstrval <= 0) {
788 		paxwarn(1, "Unable to recover from an archive read failure.");
789 		return(-1);
790 	}
791 	paxwarn(0, "Attempting to recover from an archive read failure.");
792 	return(0);
793 }
794 
795 /*
796  * ar_fow()
797  *	Move the I/O position within the archive forward the specified number of
798  *	bytes as supported by the device. If we cannot move the requested
799  *	number of bytes, return the actual number of bytes moved in skipped.
800  * Return:
801  *	0 if moved the requested distance, -1 on complete failure, 1 on
802  *	partial move (the amount moved is in skipped)
803  */
804 
805 int
806 ar_fow(off_t sksz, off_t *skipped)
807 {
808 	off_t cpos;
809 	off_t mpos;
810 
811 	*skipped = 0;
812 	if (sksz <= 0)
813 		return(0);
814 
815 	/*
816 	 * we cannot move forward at EOF or error
817 	 */
818 	if (lstrval <= 0)
819 		return(lstrval);
820 
821 	/*
822 	 * Safer to read forward on devices where it is hard to find the end of
823 	 * the media without reading to it. With tapes we cannot be sure of the
824 	 * number of physical blocks to skip (we do not know physical block
825 	 * size at this point), so we must only read forward on tapes!
826 	 */
827 	if (artyp != ISREG)
828 		return(0);
829 
830 	/*
831 	 * figure out where we are in the archive
832 	 */
833 	if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) >= 0) {
834 		/*
835 	 	 * we can be asked to move farther than there are bytes in this
836 		 * volume, if so, just go to file end and let normal buf_fill()
837 		 * deal with the end of file (it will go to next volume by
838 		 * itself)
839 	 	 */
840 		if ((mpos = cpos + sksz) > arsb.st_size) {
841 			*skipped = arsb.st_size - cpos;
842 			mpos = arsb.st_size;
843 		} else
844 			*skipped = sksz;
845 		if (lseek(arfd, mpos, SEEK_SET) >= 0)
846 			return(0);
847 	}
848 	syswarn(1, errno, "Forward positioning operation on archive failed");
849 	lstrval = -1;
850 	return(-1);
851 }
852 
853 /*
854  * ar_rev()
855  *	move the i/o position within the archive backwards the specified byte
856  *	count as supported by the device. With tapes drives we RESET rdblksz to
857  *	the PHYSICAL blocksize.
858  *	NOTE: We should only be called to move backwards so we can rewrite the
859  *	last records (the trailer) of an archive (APPEND).
860  * Return:
861  *	0 if moved the requested distance, -1 on complete failure
862  */
863 
864 int
865 ar_rev(off_t sksz)
866 {
867 	off_t cpos;
868 	struct mtop mb;
869 	int phyblk;
870 
871 	/*
872 	 * make sure we do not have try to reverse on a flawed archive
873 	 */
874 	if (lstrval < 0)
875 		return(lstrval);
876 
877 	switch(artyp) {
878 	case ISPIPE:
879 		if (sksz <= 0)
880 			break;
881 		/*
882 		 * cannot go backwards on these critters
883 		 */
884 		paxwarn(1, "Reverse positioning on pipes is not supported.");
885 		lstrval = -1;
886 		return(-1);
887 	case ISREG:
888 	case ISBLK:
889 	case ISCHR:
890 	default:
891 		if (sksz <= 0)
892 			break;
893 
894 		/*
895 		 * For things other than files, backwards movement has a very
896 		 * high probability of failure as we really do not know the
897 		 * true attributes of the device we are talking to (the device
898 		 * may not even have the ability to lseek() in any direction).
899 		 * First we figure out where we are in the archive.
900 		 */
901 		if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0) {
902 			syswarn(1, errno,
903 			   "Unable to obtain current archive byte offset");
904 			lstrval = -1;
905 			return(-1);
906 		}
907 
908 		/*
909 		 * we may try to go backwards past the start when the archive
910 		 * is only a single record. If this happens and we are on a
911 		 * multi volume archive, we need to go to the end of the
912 		 * previous volume and continue our movement backwards from
913 		 * there.
914 		 */
915 		if ((cpos -= sksz) < (off_t)0L) {
916 			if (arvol > 1) {
917 				/*
918 				 * this should never happen
919 				 */
920 				paxwarn(1,"Reverse position on previous volume.");
921 				lstrval = -1;
922 				return(-1);
923 			}
924 			cpos = (off_t)0L;
925 		}
926 		if (lseek(arfd, cpos, SEEK_SET) < 0) {
927 			syswarn(1, errno, "Unable to seek archive backwards");
928 			lstrval = -1;
929 			return(-1);
930 		}
931 		break;
932 	case ISTAPE:
933 		/*
934 	 	 * Calculate and move the proper number of PHYSICAL tape
935 		 * blocks. If the sksz is not an even multiple of the physical
936 		 * tape size, we cannot do the move (this should never happen).
937 		 * (We also cannot handler trailers spread over two vols).
938 		 * get_phys() also makes sure we are in front of the filemark.
939 	 	 */
940 		if ((phyblk = get_phys()) <= 0) {
941 			lstrval = -1;
942 			return(-1);
943 		}
944 
945 		/*
946 		 * make sure future tape reads only go by physical tape block
947 		 * size (set rdblksz to the real size).
948 		 */
949 		rdblksz = phyblk;
950 
951 		/*
952 		 * if no movement is required, just return (we must be after
953 		 * get_phys() so the physical blocksize is properly set)
954 		 */
955 		if (sksz <= 0)
956 			break;
957 
958 		/*
959 		 * ok we have to move. Make sure the tape drive can do it.
960 		 */
961 		if (sksz % phyblk) {
962 			paxwarn(1,
963 			    "Tape drive unable to backspace requested amount");
964 			lstrval = -1;
965 			return(-1);
966 		}
967 
968 		/*
969 		 * move backwards the requested number of bytes
970 		 */
971 		mb.mt_op = MTBSR;
972 		mb.mt_count = sksz/phyblk;
973 		if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
974 			syswarn(1,errno, "Unable to backspace tape %d blocks.",
975 			    mb.mt_count);
976 			lstrval = -1;
977 			return(-1);
978 		}
979 		break;
980 	}
981 	lstrval = 1;
982 	return(0);
983 }
984 
985 /*
986  * get_phys()
987  *	Determine the physical block size on a tape drive. We need the physical
988  *	block size so we know how many bytes we skip over when we move with
989  *	mtio commands. We also make sure we are BEFORE THE TAPE FILEMARK when
990  *	return.
991  *	This is one really SLOW routine...
992  * Return:
993  *	physical block size if ok (ok > 0), -1 otherwise
994  */
995 
996 static int
997 get_phys(void)
998 {
999 	int padsz = 0;
1000 	int res;
1001 	int phyblk;
1002 	struct mtop mb;
1003 	char scbuf[MAXBLK];
1004 
1005 	/*
1006 	 * move to the file mark, and then back up one record and read it.
1007 	 * this should tell us the physical record size the tape is using.
1008 	 */
1009 	if (lstrval == 1) {
1010 		/*
1011 		 * we know we are at file mark when we get back a 0 from
1012 		 * read()
1013 		 */
1014 		while ((res = read(arfd, scbuf, sizeof(scbuf))) > 0)
1015 			padsz += res;
1016 		if (res < 0) {
1017 			syswarn(1, errno, "Unable to locate tape filemark.");
1018 			return(-1);
1019 		}
1020 	}
1021 
1022 	/*
1023 	 * move backwards over the file mark so we are at the end of the
1024 	 * last record.
1025 	 */
1026 	mb.mt_op = MTBSF;
1027 	mb.mt_count = 1;
1028 	if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
1029 		syswarn(1, errno, "Unable to backspace over tape filemark.");
1030 		return(-1);
1031 	}
1032 
1033 	/*
1034 	 * move backwards so we are in front of the last record and read it to
1035 	 * get physical tape blocksize.
1036 	 */
1037 	mb.mt_op = MTBSR;
1038 	mb.mt_count = 1;
1039 	if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
1040 		syswarn(1, errno, "Unable to backspace over last tape block.");
1041 		return(-1);
1042 	}
1043 	if ((phyblk = read(arfd, scbuf, sizeof(scbuf))) <= 0) {
1044 		syswarn(1, errno, "Cannot determine archive tape blocksize.");
1045 		return(-1);
1046 	}
1047 
1048 	/*
1049 	 * read forward to the file mark, then back up in front of the filemark
1050 	 * (this is a bit paranoid, but should be safe to do).
1051 	 */
1052 	while ((res = read(arfd, scbuf, sizeof(scbuf))) > 0)
1053 		;
1054 	if (res < 0) {
1055 		syswarn(1, errno, "Unable to locate tape filemark.");
1056 		return(-1);
1057 	}
1058 	mb.mt_op = MTBSF;
1059 	mb.mt_count = 1;
1060 	if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
1061 		syswarn(1, errno, "Unable to backspace over tape filemark.");
1062 		return(-1);
1063 	}
1064 
1065 	/*
1066 	 * set lstrval so we know that the filemark has not been seen
1067 	 */
1068 	lstrval = 1;
1069 
1070 	/*
1071 	 * return if there was no padding
1072 	 */
1073 	if (padsz == 0)
1074 		return(phyblk);
1075 
1076 	/*
1077 	 * make sure we can move backwards over the padding. (this should
1078 	 * never fail).
1079 	 */
1080 	if (padsz % phyblk) {
1081 		paxwarn(1, "Tape drive unable to backspace requested amount");
1082 		return(-1);
1083 	}
1084 
1085 	/*
1086 	 * move backwards over the padding so the head is where it was when
1087 	 * we were first called (if required).
1088 	 */
1089 	mb.mt_op = MTBSR;
1090 	mb.mt_count = padsz/phyblk;
1091 	if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
1092 		syswarn(1,errno,"Unable to backspace tape over %d pad blocks",
1093 		    mb.mt_count);
1094 		return(-1);
1095 	}
1096 	return(phyblk);
1097 }
1098 
1099 /*
1100  * ar_next()
1101  *	prompts the user for the next volume in this archive. For some devices
1102  *	we may allow the media to be changed. Otherwise a new archive is
1103  *	prompted for. By pax spec, if there is no controlling tty or an eof is
1104  *	read on tty input, we must quit pax.
1105  * Return:
1106  *	0 when ready to continue, -1 when all done
1107  */
1108 
1109 int
1110 ar_next(void)
1111 {
1112 	static char *arcbuf;
1113 	char buf[PAXPATHLEN+2];
1114 	sigset_t o_mask;
1115 
1116 	/*
1117 	 * WE MUST CLOSE THE DEVICE. A lot of devices must see last close, (so
1118 	 * things like writing EOF etc will be done) (Watch out ar_close() can
1119 	 * also be called via a signal handler, so we must prevent a race.
1120 	 */
1121 	if (sigprocmask(SIG_BLOCK, &s_mask, &o_mask) < 0)
1122 		syswarn(0, errno, "Unable to set signal mask");
1123 	ar_close();
1124 	if (sigprocmask(SIG_SETMASK, &o_mask, NULL) < 0)
1125 		syswarn(0, errno, "Unable to restore signal mask");
1126 
1127 	if (done || !wr_trail || strcmp(NM_TAR, argv0) == 0)
1128 		return(-1);
1129 
1130 	tty_prnt("\nATTENTION! %s archive volume change required.\n", argv0);
1131 
1132 	/*
1133 	 * if i/o is on stdin or stdout, we cannot reopen it (we do not know
1134 	 * the name), the user will be forced to type it in.
1135 	 */
1136 	if (strcmp(arcname, stdo) && strcmp(arcname, stdn) && (artyp != ISREG)
1137 	    && (artyp != ISPIPE)) {
1138 		if (artyp == ISTAPE) {
1139 			tty_prnt("%s ready for archive tape volume: %d\n",
1140 				arcname, arvol);
1141 			tty_prnt("Load the NEXT TAPE on the tape drive");
1142 		} else {
1143 			tty_prnt("%s ready for archive volume: %d\n",
1144 				arcname, arvol);
1145 			tty_prnt("Load the NEXT STORAGE MEDIA (if required)");
1146 		}
1147 
1148 		if ((act == ARCHIVE) || (act == APPND))
1149 			tty_prnt(" and make sure it is WRITE ENABLED.\n");
1150 		else
1151 			tty_prnt("\n");
1152 
1153 		for(;;) {
1154 			tty_prnt("Type \"y\" to continue, \".\" to quit %s,",
1155 				argv0);
1156 			tty_prnt(" or \"s\" to switch to new device.\nIf you");
1157 			tty_prnt(" cannot change storage media, type \"s\"\n");
1158 			tty_prnt("Is the device ready and online? > ");
1159 
1160 			if ((tty_read(buf,sizeof(buf))<0) || !strcmp(buf,".")){
1161 				done = 1;
1162 				lstrval = -1;
1163 				tty_prnt("Quitting %s!\n", argv0);
1164 				vfpart = 0;
1165 				return(-1);
1166 			}
1167 
1168 			if ((buf[0] == '\0') || (buf[1] != '\0')) {
1169 				tty_prnt("%s unknown command, try again\n",buf);
1170 				continue;
1171 			}
1172 
1173 			switch (buf[0]) {
1174 			case 'y':
1175 			case 'Y':
1176 				/*
1177 				 * we are to continue with the same device
1178 				 */
1179 				if (ar_open(arcname) >= 0)
1180 					return(0);
1181 				tty_prnt("Cannot re-open %s, try again\n",
1182 					arcname);
1183 				continue;
1184 			case 's':
1185 			case 'S':
1186 				/*
1187 				 * user wants to open a different device
1188 				 */
1189 				tty_prnt("Switching to a different archive\n");
1190 				break;
1191 			default:
1192 				tty_prnt("%s unknown command, try again\n",buf);
1193 				continue;
1194 			}
1195 			break;
1196 		}
1197 	} else
1198 		tty_prnt("Ready for archive volume: %d\n", arvol);
1199 
1200 	/*
1201 	 * have to go to a different archive
1202 	 */
1203 	for (;;) {
1204 		tty_prnt("Input archive name or \".\" to quit %s.\n", argv0);
1205 		tty_prnt("Archive name > ");
1206 
1207 		if ((tty_read(buf, sizeof(buf)) < 0) || !strcmp(buf, ".")) {
1208 			done = 1;
1209 			lstrval = -1;
1210 			tty_prnt("Quitting %s!\n", argv0);
1211 			vfpart = 0;
1212 			return(-1);
1213 		}
1214 		if (buf[0] == '\0') {
1215 			tty_prnt("Empty file name, try again\n");
1216 			continue;
1217 		}
1218 		if (!strcmp(buf, "..")) {
1219 			tty_prnt("Illegal file name: .. try again\n");
1220 			continue;
1221 		}
1222 		if (strlen(buf) > PAXPATHLEN) {
1223 			tty_prnt("File name too long, try again\n");
1224 			continue;
1225 		}
1226 
1227 		/*
1228 		 * try to open new archive
1229 		 */
1230 		if (ar_open(buf) >= 0) {
1231 			free(arcbuf);
1232 			if ((arcbuf = strdup(buf)) == NULL) {
1233 				done = 1;
1234 				lstrval = -1;
1235 				paxwarn(0, "Cannot save archive name.");
1236 				return(-1);
1237 			}
1238 			arcname = arcbuf;
1239 			break;
1240 		}
1241 		tty_prnt("Cannot open %s, try again\n", buf);
1242 		continue;
1243 	}
1244 	return(0);
1245 }
1246 
1247 /*
1248  * ar_start_gzip()
1249  * starts the gzip compression/decompression process as a child, using magic
1250  * to keep the fd the same in the calling function (parent).
1251  */
1252 void
1253 ar_start_gzip(int fd, const char *gzip_prog, int wr)
1254 {
1255 	int fds[2];
1256 	const char *gzip_flags;
1257 
1258 	if (pipe(fds) < 0)
1259 		err(1, "could not pipe");
1260 	zpid = fork();
1261 	if (zpid < 0)
1262 		err(1, "could not fork");
1263 
1264 	/* parent */
1265 	if (zpid) {
1266 		if (wr)
1267 			dup2(fds[1], fd);
1268 		else
1269 			dup2(fds[0], fd);
1270 		close(fds[0]);
1271 		close(fds[1]);
1272 	} else {
1273 		if (wr) {
1274 			dup2(fds[0], STDIN_FILENO);
1275 			dup2(fd, STDOUT_FILENO);
1276 			gzip_flags = "-c";
1277 		} else {
1278 			dup2(fds[1], STDOUT_FILENO);
1279 			dup2(fd, STDIN_FILENO);
1280 			gzip_flags = "-dc";
1281 		}
1282 		close(fds[0]);
1283 		close(fds[1]);
1284 		if (execlp(gzip_prog, gzip_prog, gzip_flags,
1285 		    (char *)NULL) < 0)
1286 			err(1, "could not exec");
1287 		/* NOTREACHED */
1288 	}
1289 }
1290