Home | History | Annotate | Line # | Download | only in pax
ar_io.c revision 1.39.2.1.2.1
      1 /*	$NetBSD: ar_io.c,v 1.39.2.1.2.1 2005/07/23 17:32:16 snj Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1992 Keith Muller.
      5  * Copyright (c) 1992, 1993
      6  *	The Regents of the University of California.  All rights reserved.
      7  *
      8  * This code is derived from software contributed to Berkeley by
      9  * Keith Muller of the University of California, San Diego.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions and the following disclaimer.
     16  * 2. Redistributions in binary form must reproduce the above copyright
     17  *    notice, this list of conditions and the following disclaimer in the
     18  *    documentation and/or other materials provided with the distribution.
     19  * 3. Neither the name of the University nor the names of its contributors
     20  *    may be used to endorse or promote products derived from this software
     21  *    without specific prior written permission.
     22  *
     23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33  * SUCH DAMAGE.
     34  */
     35 
     36 #if HAVE_NBTOOL_CONFIG_H
     37 #include "nbtool_config.h"
     38 #endif
     39 
     40 #include <sys/cdefs.h>
     41 #if !defined(lint)
     42 #if 0
     43 static char sccsid[] = "@(#)ar_io.c	8.2 (Berkeley) 4/18/94";
     44 #else
     45 __RCSID("$NetBSD: ar_io.c,v 1.39.2.1.2.1 2005/07/23 17:32:16 snj Exp $");
     46 #endif
     47 #endif /* not lint */
     48 
     49 #include <sys/types.h>
     50 #include <sys/param.h>
     51 #include <sys/time.h>
     52 #include <sys/stat.h>
     53 #include <sys/ioctl.h>
     54 #ifdef HAVE_MTIO_H
     55 #include <sys/mtio.h>
     56 #endif
     57 #include <sys/wait.h>
     58 #include <signal.h>
     59 #include <string.h>
     60 #include <fcntl.h>
     61 #include <unistd.h>
     62 #include <stdio.h>
     63 #include <ctype.h>
     64 #include <errno.h>
     65 #include <stdlib.h>
     66 #ifdef SUPPORT_RMT
     67 #define __RMTLIB_PRIVATE
     68 #include <rmt.h>
     69 #endif /* SUPPORT_RMT */
     70 #include "pax.h"
     71 #include "options.h"
     72 #include "extern.h"
     73 
     74 /*
     75  * Routines which deal directly with the archive I/O device/file.
     76  */
     77 
     78 #define DMOD		0666		/* default mode of created archives */
     79 #define EXT_MODE	O_RDONLY	/* open mode for list/extract */
     80 #define AR_MODE		(O_WRONLY | O_CREAT | O_TRUNC)	/* mode for archive */
     81 #define APP_MODE	O_RDWR		/* mode for append */
     82 static char STDO[] =	"<STDOUT>";	/* pseudo name for stdout */
     83 static char STDN[] =	"<STDIN>";	/* pseudo name for stdin */
     84 static char NONE[] =	"<NONE>";	/* pseudo name for none */
     85 static int arfd = -1;			/* archive file descriptor */
     86 static int artyp = ISREG;		/* archive type: file/FIFO/tape */
     87 static int arvol = 1;			/* archive volume number */
     88 static int lstrval = -1;		/* return value from last i/o */
     89 static int io_ok;			/* i/o worked on volume after resync */
     90 static int did_io;			/* did i/o ever occur on volume? */
     91 static int done;			/* set via tty termination */
     92 static struct stat arsb;		/* stat of archive device at open */
     93 static int invld_rec;			/* tape has out of spec record size */
     94 static int wr_trail = 1;		/* trailer was rewritten in append */
     95 static int can_unlnk = 0;		/* do we unlink null archives?  */
     96 const char *arcname;			/* printable name of archive */
     97 const char *gzip_program;		/* name of gzip program */
     98 static pid_t zpid = -1;			/* pid of child process */
     99 time_t starttime;			/* time the run started */
    100 int force_one_volume;			/* 1 if we ignore volume changes */
    101 
    102 #ifdef HAVE_MTIO_H
    103 static int get_phys(void);
    104 #endif
    105 extern sigset_t s_mask;
    106 static void ar_start_gzip(int, const char *, int);
    107 static const char *timefmt(char *, size_t, off_t, time_t, const char *);
    108 static const char *sizefmt(char *, size_t, off_t);
    109 
    110 #ifdef SUPPORT_RMT
    111 #ifdef SYS_NO_RESTART
    112 static int rmtread_with_restart(int, void *, int);
    113 static int rmtwrite_with_restart(int, void *, int);
    114 #else
    115 #define rmtread_with_restart(a, b, c) rmtread((a), (b), (c))
    116 #define rmtwrite_with_restart(a, b, c) rmtwrite((a), (b), (c))
    117 #endif
    118 #endif /* SUPPORT_RMT */
    119 
    120 /*
    121  * ar_open()
    122  *	Opens the next archive volume. Determines the type of the device and
    123  *	sets up block sizes as required by the archive device and the format.
    124  *	Note: we may be called with name == NULL on the first open only.
    125  * Return:
    126  *	-1 on failure, 0 otherwise
    127  */
    128 
    129 int
    130 ar_open(const char *name)
    131 {
    132 #ifdef HAVE_MTIO_H
    133 	struct mtget mb;
    134 #endif
    135 
    136 	if (arfd != -1)
    137 		(void)close(arfd);
    138 	arfd = -1;
    139 	can_unlnk = did_io = io_ok = invld_rec = 0;
    140 	artyp = ISREG;
    141 	flcnt = 0;
    142 
    143 #ifdef SUPPORT_RMT
    144 	if (name && strchr(name, ':') != NULL && !forcelocal) {
    145 		artyp = ISRMT;
    146 		if ((arfd = rmtopen(name, O_RDWR, DMOD)) == -1) {
    147 			syswarn(0, errno, "Failed open on %s", name);
    148 			return -1;
    149 		}
    150 		blksz = rdblksz = 8192;
    151 		lstrval = 1;
    152 		return 0;
    153 	}
    154 #endif /* SUPPORT_RMT */
    155 
    156 	/*
    157 	 * open based on overall operation mode
    158 	 */
    159 	switch (act) {
    160 	case LIST:
    161 	case EXTRACT:
    162 		if (name == NULL) {
    163 			arfd = STDIN_FILENO;
    164 			arcname = STDN;
    165 		} else if ((arfd = open(name, EXT_MODE, DMOD)) < 0)
    166 			syswarn(0, errno, "Failed open to read on %s", name);
    167 		if (arfd != -1 && gzip_program != NULL)
    168 			ar_start_gzip(arfd, gzip_program, 0);
    169 		break;
    170 	case ARCHIVE:
    171 		if (name == NULL) {
    172 			arfd = STDOUT_FILENO;
    173 			arcname = STDO;
    174 		} else if ((arfd = open(name, AR_MODE, DMOD)) < 0)
    175 			syswarn(0, errno, "Failed open to write on %s", name);
    176 		else
    177 			can_unlnk = 1;
    178 		if (arfd != -1 && gzip_program != NULL)
    179 			ar_start_gzip(arfd, gzip_program, 1);
    180 		break;
    181 	case APPND:
    182 		if (name == NULL) {
    183 			arfd = STDOUT_FILENO;
    184 			arcname = STDO;
    185 		} else if ((arfd = open(name, APP_MODE, DMOD)) < 0)
    186 			syswarn(0, errno, "Failed open to read/write on %s",
    187 				name);
    188 		break;
    189 	case COPY:
    190 		/*
    191 		 * arfd not used in COPY mode
    192 		 */
    193 		arcname = NONE;
    194 		lstrval = 1;
    195 		return(0);
    196 	}
    197 	if (arfd < 0)
    198 		return(-1);
    199 
    200 	if (chdname != NULL)
    201 		if (dochdir(chdname) == -1)
    202 			return(-1);
    203 	/*
    204 	 * set up is based on device type
    205 	 */
    206 	if (fstat(arfd, &arsb) < 0) {
    207 		syswarn(0, errno, "Failed stat on %s", arcname);
    208 		(void)close(arfd);
    209 		arfd = -1;
    210 		can_unlnk = 0;
    211 		return(-1);
    212 	}
    213 	if (S_ISDIR(arsb.st_mode)) {
    214 		tty_warn(0, "Cannot write an archive on top of a directory %s",
    215 		    arcname);
    216 		(void)close(arfd);
    217 		arfd = -1;
    218 		can_unlnk = 0;
    219 		return(-1);
    220 	}
    221 
    222 	if (S_ISCHR(arsb.st_mode)) {
    223 #ifdef HAVE_MTIO_H
    224 		artyp = ioctl(arfd, MTIOCGET, &mb) ? ISCHR : ISTAPE;
    225 #else
    226 		tty_warn(1, "System does not have tape support");
    227 		artyp = ISREG;
    228 #endif
    229 	} else if (S_ISBLK(arsb.st_mode))
    230 		artyp = ISBLK;
    231 	else if ((lseek(arfd, (off_t)0L, SEEK_CUR) == -1) && (errno == ESPIPE))
    232 		artyp = ISPIPE;
    233 	else
    234 		artyp = ISREG;
    235 
    236 	/*
    237 	 * Special handling for empty files.
    238 	 */
    239 	if (artyp == ISREG && arsb.st_size == 0) {
    240 		switch (act) {
    241 		case LIST:
    242 		case EXTRACT:
    243 			return -1;
    244 		case APPND:
    245 			act = -ARCHIVE;
    246 			return -1;
    247 		case ARCHIVE:
    248 			break;
    249 		}
    250 	}
    251 
    252 	/*
    253 	 * make sure we beyond any doubt that we only can unlink regular files
    254 	 * we created
    255 	 */
    256 	if (artyp != ISREG)
    257 		can_unlnk = 0;
    258 
    259 	/*
    260 	 * if we are writing, we are done
    261 	 */
    262 	if (act == ARCHIVE) {
    263 		blksz = rdblksz = wrblksz;
    264 		lstrval = 1;
    265 		return(0);
    266 	}
    267 
    268 	/*
    269 	 * set default blksz on read. APPNDs writes rdblksz on the last volume
    270 	 * On all new archive volumes, we shift to wrblksz (if the user
    271 	 * specified one, otherwize we will continue to use rdblksz). We
    272 	 * must set blocksize based on what kind of device the archive is
    273 	 * stored.
    274 	 */
    275 	switch(artyp) {
    276 	case ISTAPE:
    277 		/*
    278 		 * Tape drives come in at least two flavors. Those that support
    279 		 * variable sized records and those that have fixed sized
    280 		 * records. They must be treated differently. For tape drives
    281 		 * that support variable sized records, we must make large
    282 		 * reads to make sure we get the entire record, otherwise we
    283 		 * will just get the first part of the record (up to size we
    284 		 * asked). Tapes with fixed sized records may or may not return
    285 		 * multiple records in a single read. We really do not care
    286 		 * what the physical record size is UNLESS we are going to
    287 		 * append. (We will need the physical block size to rewrite
    288 		 * the trailer). Only when we are appending do we go to the
    289 		 * effort to figure out the true PHYSICAL record size.
    290 		 */
    291 		blksz = rdblksz = MAXBLK;
    292 		break;
    293 	case ISPIPE:
    294 	case ISBLK:
    295 	case ISCHR:
    296 		/*
    297 		 * Blocksize is not a major issue with these devices (but must
    298 		 * be kept a multiple of 512). If the user specified a write
    299 		 * block size, we use that to read. Under append, we must
    300 		 * always keep blksz == rdblksz. Otherwise we go ahead and use
    301 		 * the device optimal blocksize as (and if) returned by stat
    302 		 * and if it is within pax specs.
    303 		 */
    304 		if ((act == APPND) && wrblksz) {
    305 			blksz = rdblksz = wrblksz;
    306 			break;
    307 		}
    308 
    309 		if ((arsb.st_blksize > 0) && (arsb.st_blksize < MAXBLK) &&
    310 		    ((arsb.st_blksize % BLKMULT) == 0))
    311 			rdblksz = arsb.st_blksize;
    312 		else
    313 			rdblksz = DEVBLK;
    314 		/*
    315 		 * For performance go for large reads when we can without harm
    316 		 */
    317 		if ((act == APPND) || (artyp == ISCHR))
    318 			blksz = rdblksz;
    319 		else
    320 			blksz = MAXBLK;
    321 		break;
    322 	case ISREG:
    323 		/*
    324 		 * if the user specified wrblksz works, use it. Under appends
    325 		 * we must always keep blksz == rdblksz
    326 		 */
    327 		if ((act == APPND) && wrblksz && ((arsb.st_size%wrblksz)==0)){
    328 			blksz = rdblksz = wrblksz;
    329 			break;
    330 		}
    331 		/*
    332 		 * See if we can find the blocking factor from the file size
    333 		 */
    334 		for (rdblksz = MAXBLK; rdblksz > 0; rdblksz -= BLKMULT)
    335 			if ((arsb.st_size % rdblksz) == 0)
    336 				break;
    337 		/*
    338 		 * When we cannot find a match, we may have a flawed archive.
    339 		 */
    340 		if (rdblksz <= 0)
    341 			rdblksz = FILEBLK;
    342 		/*
    343 		 * for performance go for large reads when we can
    344 		 */
    345 		if (act == APPND)
    346 			blksz = rdblksz;
    347 		else
    348 			blksz = MAXBLK;
    349 		break;
    350 	default:
    351 		/*
    352 		 * should never happen, worst case, slow...
    353 		 */
    354 		blksz = rdblksz = BLKMULT;
    355 		break;
    356 	}
    357 	lstrval = 1;
    358 	return(0);
    359 }
    360 
    361 /*
    362  * ar_close()
    363  *	closes archive device, increments volume number, and prints i/o summary
    364  */
    365 void
    366 ar_close(void)
    367 {
    368 	int status;
    369 
    370 	if (arfd < 0) {
    371 		did_io = io_ok = flcnt = 0;
    372 		return;
    373 	}
    374 
    375 
    376 	/*
    377 	 * Close archive file. This may take a LONG while on tapes (we may be
    378 	 * forced to wait for the rewind to complete) so tell the user what is
    379 	 * going on (this avoids the user hitting control-c thinking pax is
    380 	 * broken).
    381 	 */
    382 	if (vflag && (artyp == ISTAPE)) {
    383 		if (vfpart)
    384 			(void)putc('\n', listf);
    385 		(void)fprintf(listf,
    386 			"%s: Waiting for tape drive close to complete...",
    387 			argv0);
    388 		(void)fflush(listf);
    389 	}
    390 
    391 	/*
    392 	 * if nothing was written to the archive (and we created it), we remove
    393 	 * it
    394 	 */
    395 	if (can_unlnk && (fstat(arfd, &arsb) == 0) && (S_ISREG(arsb.st_mode)) &&
    396 	    (arsb.st_size == 0)) {
    397 		(void)unlink(arcname);
    398 		can_unlnk = 0;
    399 	}
    400 
    401 	/*
    402 	 * for a quick extract/list, pax frequently exits before the child
    403 	 * process is done
    404 	 */
    405 	if ((act == LIST || act == EXTRACT) && nflag && zpid > 0)
    406 		kill(zpid, SIGINT);
    407 
    408 #ifdef SUPPORT_RMT
    409 	if (artyp == ISRMT)
    410 		(void)rmtclose(arfd);
    411 	else
    412 #endif /* SUPPORT_RMT */
    413 		(void)close(arfd);
    414 
    415 	/* Do not exit before child to ensure data integrity */
    416 	if (zpid > 0)
    417 		waitpid(zpid, &status, 0);
    418 
    419 	if (vflag && (artyp == ISTAPE)) {
    420 		(void)fputs("done.\n", listf);
    421 		vfpart = 0;
    422 		(void)fflush(listf);
    423 	}
    424 	arfd = -1;
    425 
    426 	if (!io_ok && !did_io) {
    427 		flcnt = 0;
    428 		return;
    429 	}
    430 	did_io = io_ok = 0;
    431 
    432 	/*
    433 	 * The volume number is only increased when the last device has data
    434 	 * and we have already determined the archive format.
    435 	 */
    436 	if (frmt != NULL)
    437 		++arvol;
    438 
    439 	if (!vflag) {
    440 		flcnt = 0;
    441 		return;
    442 	}
    443 
    444 	/*
    445 	 * Print out a summary of I/O for this archive volume.
    446 	 */
    447 	if (vfpart) {
    448 		(void)putc('\n', listf);
    449 		vfpart = 0;
    450 	}
    451 	/*
    452 	 * If we have not determined the format yet, we just say how many bytes
    453 	 * we have skipped over looking for a header to id. there is no way we
    454 	 * could have written anything yet.
    455 	 */
    456 	if (frmt == NULL) {
    457 		(void)fprintf(listf, "%s: unknown format, " OFFT_F
    458 		    " bytes skipped.\n", argv0, rdcnt);
    459 		(void)fflush(listf);
    460 		flcnt = 0;
    461 		return;
    462 	}
    463 
    464 	if (strcmp(NM_CPIO, argv0) == 0) {
    465 		(void)fprintf(listf, OFFT_F " blocks\n",
    466 		    (rdcnt ? rdcnt : wrcnt) / 5120);
    467 	}
    468 
    469 	ar_summary(0);
    470 
    471 	(void)fflush(listf);
    472 	flcnt = 0;
    473 }
    474 
    475 /*
    476  * ar_drain()
    477  *	drain any archive format independent padding from an archive read
    478  *	from a socket or a pipe. This is to prevent the process on the
    479  *	other side of the pipe from getting a SIGPIPE (pax will stop
    480  *	reading an archive once a format dependent trailer is detected).
    481  */
    482 void
    483 ar_drain(void)
    484 {
    485 	int res;
    486 	char drbuf[MAXBLK];
    487 
    488 	/*
    489 	 * we only drain from a pipe/socket. Other devices can be closed
    490 	 * without reading up to end of file. We sure hope that pipe is closed
    491 	 * on the other side so we will get an EOF.
    492 	 */
    493 	if ((artyp != ISPIPE) || (lstrval <= 0))
    494 		return;
    495 
    496 	/*
    497 	 * keep reading until pipe is drained
    498 	 */
    499 #ifdef SUPPORT_RMT
    500 	if (artyp == ISRMT) {
    501 		while ((res = rmtread_with_restart(arfd,
    502 						   drbuf, sizeof(drbuf))) > 0)
    503 			continue;
    504 	} else {
    505 #endif /* SUPPORT_RMT */
    506 		while ((res = read_with_restart(arfd,
    507 						drbuf, sizeof(drbuf))) > 0)
    508 			continue;
    509 #ifdef SUPPORT_RMT
    510 	}
    511 #endif /* SUPPORT_RMT */
    512 	lstrval = res;
    513 }
    514 
    515 /*
    516  * ar_set_wr()
    517  *	Set up device right before switching from read to write in an append.
    518  *	device dependent code (if required) to do this should be added here.
    519  *	For all archive devices we are already positioned at the place we want
    520  *	to start writing when this routine is called.
    521  * Return:
    522  *	0 if all ready to write, -1 otherwise
    523  */
    524 
    525 int
    526 ar_set_wr(void)
    527 {
    528 	off_t cpos;
    529 
    530 	/*
    531 	 * we must make sure the trailer is rewritten on append, ar_next()
    532 	 * will stop us if the archive containing the trailer was not written
    533 	 */
    534 	wr_trail = 0;
    535 
    536 	/*
    537 	 * Add any device dependent code as required here
    538 	 */
    539 	if (artyp != ISREG)
    540 		return(0);
    541 	/*
    542 	 * Ok we have an archive in a regular file. If we were rewriting a
    543 	 * file, we must get rid of all the stuff after the current offset
    544 	 * (it was not written by pax).
    545 	 */
    546 	if (((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0) ||
    547 	    (ftruncate(arfd, cpos) < 0)) {
    548 		syswarn(1, errno, "Unable to truncate archive file");
    549 		return(-1);
    550 	}
    551 	return(0);
    552 }
    553 
    554 /*
    555  * ar_app_ok()
    556  *	check if the last volume in the archive allows appends. We cannot check
    557  *	this until we are ready to write since there is no spec that says all
    558  *	volumes in a single archive have to be of the same type...
    559  * Return:
    560  *	0 if we can append, -1 otherwise.
    561  */
    562 
    563 int
    564 ar_app_ok(void)
    565 {
    566 	if (artyp == ISPIPE) {
    567 		tty_warn(1,
    568 		    "Cannot append to an archive obtained from a pipe.");
    569 		return(-1);
    570 	}
    571 
    572 	if (!invld_rec)
    573 		return(0);
    574 	tty_warn(1,
    575 	    "Cannot append, device record size %d does not support %s spec",
    576 	    rdblksz, argv0);
    577 	return(-1);
    578 }
    579 
    580 #ifdef SYS_NO_RESTART
    581 /*
    582  * read_with_restart()
    583  *	Equivalent to read() but does retry on signals.
    584  *	This function is not needed on 4.2BSD and later.
    585  * Return:
    586  *	Number of bytes written.  -1 indicates an error.
    587  */
    588 
    589 int
    590 read_with_restart(int fd, void *buf, int bsz)
    591 {
    592 	int r;
    593 
    594 	while (((r = read(fd, buf, bsz)) < 0) && errno == EINTR)
    595 		continue;
    596 
    597 	return(r);
    598 }
    599 
    600 /*
    601  * rmtread_with_restart()
    602  *	Equivalent to rmtread() but does retry on signals.
    603  *	This function is not needed on 4.2BSD and later.
    604  * Return:
    605  *	Number of bytes written.  -1 indicates an error.
    606  */
    607 static int
    608 rmtread_with_restart(int fd, void *buf, int bsz)
    609 {
    610 	int r;
    611 
    612 	while (((r = rmtread(fd, buf, bsz)) < 0) && errno == EINTR)
    613 		continue;
    614 
    615 	return(r);
    616 }
    617 #endif
    618 
    619 /*
    620  * xread()
    621  *	Equivalent to read() but does retry on partial read, which may occur
    622  *	on signals.
    623  * Return:
    624  *	Number of bytes read.  0 for end of file, -1 for an error.
    625  */
    626 
    627 int
    628 xread(int fd, void *buf, int bsz)
    629 {
    630 	char *b = buf;
    631 	int nread = 0;
    632 	int r;
    633 
    634 	do {
    635 #ifdef SUPPORT_RMT
    636 		if ((r = rmtread_with_restart(fd, b, bsz)) <= 0)
    637 			break;
    638 #else
    639 		if ((r = read_with_restart(fd, b, bsz)) <= 0)
    640 			break;
    641 #endif /* SUPPORT_RMT */
    642 		b += r;
    643 		bsz -= r;
    644 		nread += r;
    645 	} while (bsz > 0);
    646 
    647 	return(nread ? nread : r);
    648 }
    649 
    650 #ifdef SYS_NO_RESTART
    651 /*
    652  * write_with_restart()
    653  *	Equivalent to write() but does retry on signals.
    654  *	This function is not needed on 4.2BSD and later.
    655  * Return:
    656  *	Number of bytes written.  -1 indicates an error.
    657  */
    658 
    659 int
    660 write_with_restart(int fd, void *buf, int bsz)
    661 {
    662 	int r;
    663 
    664 	while (((r = write(fd, buf, bsz)) < 0) && errno == EINTR)
    665 		;
    666 
    667 	return(r);
    668 }
    669 
    670 /*
    671  * rmtwrite_with_restart()
    672  *	Equivalent to write() but does retry on signals.
    673  *	This function is not needed on 4.2BSD and later.
    674  * Return:
    675  *	Number of bytes written.  -1 indicates an error.
    676  */
    677 
    678 static int
    679 rmtwrite_with_restart(int fd, void *buf, int bsz)
    680 {
    681 	int r;
    682 
    683 	while (((r = rmtwrite(fd, buf, bsz)) < 0) && errno == EINTR)
    684 		;
    685 
    686 	return(r);
    687 }
    688 #endif
    689 
    690 /*
    691  * xwrite()
    692  *	Equivalent to write() but does retry on partial write, which may occur
    693  *	on signals.
    694  * Return:
    695  *	Number of bytes written.  -1 indicates an error.
    696  */
    697 
    698 int
    699 xwrite(int fd, void *buf, int bsz)
    700 {
    701 	char *b = buf;
    702 	int written = 0;
    703 	int r;
    704 
    705 	do {
    706 #ifdef SUPPORT_RMT
    707 		if ((r = rmtwrite_with_restart(fd, b, bsz)) <= 0)
    708 			break;
    709 #else
    710 		if ((r = write_with_restart(fd, b, bsz)) <= 0)
    711 			break;
    712 #endif /* SUPPORT_RMT */
    713 		b += r;
    714 		bsz -= r;
    715 		written += r;
    716 	} while (bsz > 0);
    717 
    718 	return(written ? written : r);
    719 }
    720 
    721 /*
    722  * ar_read()
    723  *	read up to a specified number of bytes from the archive into the
    724  *	supplied buffer. When dealing with tapes we may not always be able to
    725  *	read what we want.
    726  * Return:
    727  *	Number of bytes in buffer. 0 for end of file, -1 for a read error.
    728  */
    729 
    730 int
    731 ar_read(char *buf, int cnt)
    732 {
    733 	int res = 0;
    734 
    735 	/*
    736 	 * if last i/o was in error, no more reads until reset or new volume
    737 	 */
    738 	if (lstrval <= 0)
    739 		return(lstrval);
    740 
    741 	/*
    742 	 * how we read must be based on device type
    743 	 */
    744 	switch (artyp) {
    745 #ifdef SUPPORT_RMT
    746 	case ISRMT:
    747 		if ((res = rmtread_with_restart(arfd, buf, cnt)) > 0) {
    748 			io_ok = 1;
    749 			return res;
    750 		}
    751 		break;
    752 #endif /* SUPPORT_RMT */
    753 	case ISTAPE:
    754 		if ((res = read_with_restart(arfd, buf, cnt)) > 0) {
    755 			/*
    756 			 * CAUTION: tape systems may not always return the same
    757 			 * sized records so we leave blksz == MAXBLK. The
    758 			 * physical record size that a tape drive supports is
    759 			 * very hard to determine in a uniform and portable
    760 			 * manner.
    761 			 */
    762 			io_ok = 1;
    763 			if (res != rdblksz) {
    764 				/*
    765 				 * Record size changed. If this happens on
    766 				 * any record after the first, we probably have
    767 				 * a tape drive which has a fixed record size
    768 				 * (we are getting multiple records in a single
    769 				 * read). Watch out for record blocking that
    770 				 * violates pax spec (must be a multiple of
    771 				 * BLKMULT).
    772 				 */
    773 				rdblksz = res;
    774 				if (rdblksz % BLKMULT)
    775 					invld_rec = 1;
    776 			}
    777 			return(res);
    778 		}
    779 		break;
    780 	case ISREG:
    781 	case ISBLK:
    782 	case ISCHR:
    783 	case ISPIPE:
    784 	default:
    785 		/*
    786 		 * Files are so easy to deal with. These other things cannot
    787 		 * be trusted at all. So when we are dealing with character
    788 		 * devices and pipes we just take what they have ready for us
    789 		 * and return. Trying to do anything else with them runs the
    790 		 * risk of failure.
    791 		 */
    792 		if ((res = read_with_restart(arfd, buf, cnt)) > 0) {
    793 			io_ok = 1;
    794 			return(res);
    795 		}
    796 		break;
    797 	}
    798 
    799 	/*
    800 	 * We are in trouble at this point, something is broken...
    801 	 */
    802 	lstrval = res;
    803 	if (res < 0)
    804 		syswarn(1, errno, "Failed read on archive volume %d", arvol);
    805 	else
    806 		tty_warn(0, "End of archive volume %d reached", arvol);
    807 	return(res);
    808 }
    809 
    810 /*
    811  * ar_write()
    812  *	Write a specified number of bytes in supplied buffer to the archive
    813  *	device so it appears as a single "block". Deals with errors and tries
    814  *	to recover when faced with short writes.
    815  * Return:
    816  *	Number of bytes written. 0 indicates end of volume reached and with no
    817  *	flaws (as best that can be detected). A -1 indicates an unrecoverable
    818  *	error in the archive occurred.
    819  */
    820 
    821 int
    822 ar_write(char *buf, int bsz)
    823 {
    824 	int res;
    825 	off_t cpos;
    826 
    827 	/*
    828 	 * do not allow pax to create a "bad" archive. Once a write fails on
    829 	 * an archive volume prevent further writes to it.
    830 	 */
    831 	if (lstrval <= 0)
    832 		return(lstrval);
    833 
    834 	if ((res = xwrite(arfd, buf, bsz)) == bsz) {
    835 		wr_trail = 1;
    836 		io_ok = 1;
    837 		return(bsz);
    838 	}
    839 	/*
    840 	 * write broke, see what we can do with it. We try to send any partial
    841 	 * writes that may violate pax spec to the next archive volume.
    842 	 */
    843 	if (res < 0)
    844 		lstrval = res;
    845 	else
    846 		lstrval = 0;
    847 
    848 	switch (artyp) {
    849 	case ISREG:
    850 		if ((res > 0) && (res % BLKMULT)) {
    851 			/*
    852 			 * try to fix up partial writes which are not BLKMULT
    853 			 * in size by forcing the runt record to next archive
    854 			 * volume
    855 			 */
    856 			if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0)
    857 				break;
    858 			cpos -= (off_t)res;
    859 			if (ftruncate(arfd, cpos) < 0)
    860 				break;
    861 			res = lstrval = 0;
    862 			break;
    863 		}
    864 		if (res >= 0)
    865 			break;
    866 		/*
    867 		 * if file is out of space, handle it like a return of 0
    868 		 */
    869 		if ((errno == ENOSPC) || (errno == EFBIG))
    870 			res = lstrval = 0;
    871 #ifdef EDQUOT
    872 		if (errno == EDQUOT)
    873 			res = lstrval = 0;
    874 #endif
    875 		break;
    876 	case ISTAPE:
    877 	case ISCHR:
    878 	case ISBLK:
    879 #ifdef SUPPORT_RMT
    880 	case ISRMT:
    881 #endif /* SUPPORT_RMT */
    882 		if (res >= 0)
    883 			break;
    884 		if (errno == EACCES) {
    885 			tty_warn(0,
    886 			    "Write failed, archive is write protected.");
    887 			res = lstrval = 0;
    888 			return(0);
    889 		}
    890 		/*
    891 		 * see if we reached the end of media, if so force a change to
    892 		 * the next volume
    893 		 */
    894 		if ((errno == ENOSPC) || (errno == EIO) || (errno == ENXIO))
    895 			res = lstrval = 0;
    896 		break;
    897 	case ISPIPE:
    898 	default:
    899 		/*
    900 		 * we cannot fix errors to these devices
    901 		 */
    902 		break;
    903 	}
    904 
    905 	/*
    906 	 * Better tell the user the bad news...
    907 	 * if this is a block aligned archive format, we may have a bad archive
    908 	 * if the format wants the header to start at a BLKMULT boundary. While
    909 	 * we can deal with the mis-aligned data, it violates spec and other
    910 	 * archive readers will likely fail. if the format is not block
    911 	 * aligned, the user may be lucky (and the archive is ok).
    912 	 */
    913 	if (res >= 0) {
    914 		if (res > 0)
    915 			wr_trail = 1;
    916 		io_ok = 1;
    917 	}
    918 
    919 	/*
    920 	 * If we were trying to rewrite the trailer and it didn't work, we
    921 	 * must quit right away.
    922 	 */
    923 	if (!wr_trail && (res <= 0)) {
    924 		tty_warn(1,
    925 		    "Unable to append, trailer re-write failed. Quitting.");
    926 		return(res);
    927 	}
    928 
    929 	if (res == 0)
    930 		tty_warn(0, "End of archive volume %d reached", arvol);
    931 	else if (res < 0)
    932 		syswarn(1, errno, "Failed write to archive volume: %d", arvol);
    933 	else if (!frmt->blkalgn || ((res % frmt->blkalgn) == 0))
    934 		tty_warn(0,
    935 		    "WARNING: partial archive write. Archive MAY BE FLAWED");
    936 	else
    937 		tty_warn(1,"WARNING: partial archive write. Archive IS FLAWED");
    938 	return(res);
    939 }
    940 
    941 /*
    942  * ar_rdsync()
    943  *	Try to move past a bad spot on a flawed archive as needed to continue
    944  *	I/O. Clears error flags to allow I/O to continue.
    945  * Return:
    946  *	0 when ok to try i/o again, -1 otherwise.
    947  */
    948 
    949 int
    950 ar_rdsync(void)
    951 {
    952 	long fsbz;
    953 	off_t cpos;
    954 	off_t mpos;
    955 #ifdef HAVE_MTIO_H
    956 	struct mtop mb;
    957 #endif
    958 
    959 	/*
    960 	 * Fail resync attempts at user request (done) or if this is going to be
    961 	 * an update/append to a existing archive. if last i/o hit media end,
    962 	 * we need to go to the next volume not try a resync
    963 	 */
    964 	if ((done > 0) || (lstrval == 0))
    965 		return(-1);
    966 
    967 	if ((act == APPND) || (act == ARCHIVE)) {
    968 		tty_warn(1, "Cannot allow updates to an archive with flaws.");
    969 		return(-1);
    970 	}
    971 	if (io_ok)
    972 		did_io = 1;
    973 
    974 	switch(artyp) {
    975 #ifdef SUPPORT_RMT
    976 	case ISRMT:
    977 #endif /* SUPPORT_RMT */
    978 	case ISTAPE:
    979 #ifdef HAVE_MTIO_H
    980 		/*
    981 		 * if the last i/o was a successful data transfer, we assume
    982 		 * the fault is just a bad record on the tape that we are now
    983 		 * past. If we did not get any data since the last resync try
    984 		 * to move the tape forward one PHYSICAL record past any
    985 		 * damaged tape section. Some tape drives are stubborn and need
    986 		 * to be pushed.
    987 		 */
    988 		if (io_ok) {
    989 			io_ok = 0;
    990 			lstrval = 1;
    991 			break;
    992 		}
    993 		mb.mt_op = MTFSR;
    994 		mb.mt_count = 1;
    995 #ifdef SUPPORT_RMT
    996 		if (artyp == ISRMT) {
    997 			if (rmtioctl(arfd, MTIOCTOP, &mb) < 0)
    998 				break;
    999 		} else {
   1000 #endif /* SUPPORT_RMT */
   1001 			if (ioctl(arfd, MTIOCTOP, &mb) < 0)
   1002 				break;
   1003 #ifdef SUPPORT_RMT
   1004 		}
   1005 #endif /* SUPPORT_RMT */
   1006 		lstrval = 1;
   1007 #else
   1008 		tty_warn(1, "System does not have tape support");
   1009 #endif
   1010 		break;
   1011 	case ISREG:
   1012 	case ISCHR:
   1013 	case ISBLK:
   1014 		/*
   1015 		 * try to step over the bad part of the device.
   1016 		 */
   1017 		io_ok = 0;
   1018 		if (((fsbz = arsb.st_blksize) <= 0) || (artyp != ISREG))
   1019 			fsbz = BLKMULT;
   1020 		if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0)
   1021 			break;
   1022 		mpos = fsbz - (cpos % (off_t)fsbz);
   1023 		if (lseek(arfd, mpos, SEEK_CUR) < 0)
   1024 			break;
   1025 		lstrval = 1;
   1026 		break;
   1027 	case ISPIPE:
   1028 	default:
   1029 		/*
   1030 		 * cannot recover on these archive device types
   1031 		 */
   1032 		io_ok = 0;
   1033 		break;
   1034 	}
   1035 	if (lstrval <= 0) {
   1036 		tty_warn(1, "Unable to recover from an archive read failure.");
   1037 		return(-1);
   1038 	}
   1039 	tty_warn(0, "Attempting to recover from an archive read failure.");
   1040 	return(0);
   1041 }
   1042 
   1043 /*
   1044  * ar_fow()
   1045  *	Move the I/O position within the archive forward the specified number of
   1046  *	bytes as supported by the device. If we cannot move the requested
   1047  *	number of bytes, return the actual number of bytes moved in skipped.
   1048  * Return:
   1049  *	0 if moved the requested distance, -1 on complete failure, 1 on
   1050  *	partial move (the amount moved is in skipped)
   1051  */
   1052 
   1053 int
   1054 ar_fow(off_t sksz, off_t *skipped)
   1055 {
   1056 	off_t cpos;
   1057 	off_t mpos;
   1058 
   1059 	*skipped = 0;
   1060 	if (sksz <= 0)
   1061 		return(0);
   1062 
   1063 	/*
   1064 	 * we cannot move forward at EOF or error
   1065 	 */
   1066 	if (lstrval <= 0)
   1067 		return(lstrval);
   1068 
   1069 	/*
   1070 	 * Safer to read forward on devices where it is hard to find the end of
   1071 	 * the media without reading to it. With tapes we cannot be sure of the
   1072 	 * number of physical blocks to skip (we do not know physical block
   1073 	 * size at this point), so we must only read forward on tapes!
   1074 	 */
   1075 	if (artyp == ISTAPE || artyp == ISPIPE
   1076 #ifdef SUPPORT_RMT
   1077 	    || artyp == ISRMT
   1078 #endif /* SUPPORT_RMT */
   1079 	    )
   1080 		return(0);
   1081 
   1082 	/*
   1083 	 * figure out where we are in the archive
   1084 	 */
   1085 	if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) >= 0) {
   1086 		/*
   1087 		 * we can be asked to move farther than there are bytes in this
   1088 		 * volume, if so, just go to file end and let normal buf_fill()
   1089 		 * deal with the end of file (it will go to next volume by
   1090 		 * itself)
   1091 		 */
   1092 		mpos = cpos + sksz;
   1093 		if (artyp == ISREG && mpos > arsb.st_size)
   1094 			mpos = arsb.st_size;
   1095 		if ((mpos = lseek(arfd, mpos, SEEK_SET)) >= 0) {
   1096 			*skipped = mpos - cpos;
   1097 			return(0);
   1098 		}
   1099 	} else {
   1100 		if (artyp != ISREG)
   1101 			return(0);		/* non-seekable device */
   1102 	}
   1103 	syswarn(1, errno, "Forward positioning operation on archive failed");
   1104 	lstrval = -1;
   1105 	return(-1);
   1106 }
   1107 
   1108 /*
   1109  * ar_rev()
   1110  *	move the i/o position within the archive backwards the specified byte
   1111  *	count as supported by the device. With tapes drives we RESET rdblksz to
   1112  *	the PHYSICAL blocksize.
   1113  *	NOTE: We should only be called to move backwards so we can rewrite the
   1114  *	last records (the trailer) of an archive (APPEND).
   1115  * Return:
   1116  *	0 if moved the requested distance, -1 on complete failure
   1117  */
   1118 
   1119 int
   1120 ar_rev(off_t sksz)
   1121 {
   1122 	off_t cpos;
   1123 #ifdef HAVE_MTIO_H
   1124 	int phyblk;
   1125 	struct mtop mb;
   1126 #endif
   1127 
   1128 	/*
   1129 	 * make sure we do not have try to reverse on a flawed archive
   1130 	 */
   1131 	if (lstrval < 0)
   1132 		return(lstrval);
   1133 
   1134 	switch(artyp) {
   1135 	case ISPIPE:
   1136 		if (sksz <= 0)
   1137 			break;
   1138 		/*
   1139 		 * cannot go backwards on these critters
   1140 		 */
   1141 		tty_warn(1, "Reverse positioning on pipes is not supported.");
   1142 		lstrval = -1;
   1143 		return(-1);
   1144 	case ISREG:
   1145 	case ISBLK:
   1146 	case ISCHR:
   1147 	default:
   1148 		if (sksz <= 0)
   1149 			break;
   1150 
   1151 		/*
   1152 		 * For things other than files, backwards movement has a very
   1153 		 * high probability of failure as we really do not know the
   1154 		 * true attributes of the device we are talking to (the device
   1155 		 * may not even have the ability to lseek() in any direction).
   1156 		 * First we figure out where we are in the archive.
   1157 		 */
   1158 		if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0) {
   1159 			syswarn(1, errno,
   1160 			   "Unable to obtain current archive byte offset");
   1161 			lstrval = -1;
   1162 			return(-1);
   1163 		}
   1164 
   1165 		/*
   1166 		 * we may try to go backwards past the start when the archive
   1167 		 * is only a single record. If this happens and we are on a
   1168 		 * multi-volume archive, we need to go to the end of the
   1169 		 * previous volume and continue our movement backwards from
   1170 		 * there.
   1171 		 */
   1172 		if ((cpos -= sksz) < (off_t)0L) {
   1173 			if (arvol > 1) {
   1174 				/*
   1175 				 * this should never happen
   1176 				 */
   1177 				tty_warn(1,
   1178 				    "Reverse position on previous volume.");
   1179 				lstrval = -1;
   1180 				return(-1);
   1181 			}
   1182 			cpos = (off_t)0L;
   1183 		}
   1184 		if (lseek(arfd, cpos, SEEK_SET) < 0) {
   1185 			syswarn(1, errno, "Unable to seek archive backwards");
   1186 			lstrval = -1;
   1187 			return(-1);
   1188 		}
   1189 		break;
   1190 	case ISTAPE:
   1191 #ifdef SUPPORT_RMT
   1192 	case ISRMT:
   1193 #endif /* SUPPORT_RMT */
   1194 #ifdef HAVE_MTIO_H
   1195 		/*
   1196 		 * Calculate and move the proper number of PHYSICAL tape
   1197 		 * blocks. If the sksz is not an even multiple of the physical
   1198 		 * tape size, we cannot do the move (this should never happen).
   1199 		 * (We also cannot handle trailers spread over two vols).
   1200 		 * get_phys() also makes sure we are in front of the filemark.
   1201 		 */
   1202 		if ((phyblk = get_phys()) <= 0) {
   1203 			lstrval = -1;
   1204 			return(-1);
   1205 		}
   1206 
   1207 		/*
   1208 		 * make sure future tape reads only go by physical tape block
   1209 		 * size (set rdblksz to the real size).
   1210 		 */
   1211 		rdblksz = phyblk;
   1212 
   1213 		/*
   1214 		 * if no movement is required, just return (we must be after
   1215 		 * get_phys() so the physical blocksize is properly set)
   1216 		 */
   1217 		if (sksz <= 0)
   1218 			break;
   1219 
   1220 		/*
   1221 		 * ok we have to move. Make sure the tape drive can do it.
   1222 		 */
   1223 		if (sksz % phyblk) {
   1224 			tty_warn(1,
   1225 			    "Tape drive unable to backspace requested amount");
   1226 			lstrval = -1;
   1227 			return(-1);
   1228 		}
   1229 
   1230 		/*
   1231 		 * move backwards the requested number of bytes
   1232 		 */
   1233 		mb.mt_op = MTBSR;
   1234 		mb.mt_count = sksz/phyblk;
   1235 		if (
   1236 #ifdef SUPPORT_RMT
   1237 		    rmtioctl(arfd, MTIOCTOP, &mb)
   1238 #else
   1239 		    ioctl(arfd, MTIOCTOP, &mb)
   1240 #endif /* SUPPORT_RMT */
   1241 		    < 0) {
   1242 			syswarn(1, errno, "Unable to backspace tape %ld blocks.",
   1243 			    (long) mb.mt_count);
   1244 			lstrval = -1;
   1245 			return(-1);
   1246 		}
   1247 #else
   1248 		tty_warn(1, "System does not have tape support");
   1249 #endif
   1250 		break;
   1251 	}
   1252 	lstrval = 1;
   1253 	return(0);
   1254 }
   1255 
   1256 #ifdef HAVE_MTIO_H
   1257 /*
   1258  * get_phys()
   1259  *	Determine the physical block size on a tape drive. We need the physical
   1260  *	block size so we know how many bytes we skip over when we move with
   1261  *	mtio commands. We also make sure we are BEFORE THE TAPE FILEMARK when
   1262  *	return.
   1263  *	This is one really SLOW routine...
   1264  * Return:
   1265  *	physical block size if ok (ok > 0), -1 otherwise
   1266  */
   1267 
   1268 static int
   1269 get_phys(void)
   1270 {
   1271 	int padsz = 0;
   1272 	int res;
   1273 	int phyblk;
   1274 	struct mtop mb;
   1275 	char scbuf[MAXBLK];
   1276 
   1277 	/*
   1278 	 * move to the file mark, and then back up one record and read it.
   1279 	 * this should tell us the physical record size the tape is using.
   1280 	 */
   1281 	if (lstrval == 1) {
   1282 		/*
   1283 		 * we know we are at file mark when we get back a 0 from
   1284 		 * read()
   1285 		 */
   1286 #ifdef SUPPORT_RMT
   1287 		while ((res = rmtread_with_restart(arfd,
   1288 						   scbuf, sizeof(scbuf))) > 0)
   1289 #else
   1290 		while ((res = read_with_restart(arfd,
   1291 						scbuf, sizeof(scbuf))) > 0)
   1292 #endif /* SUPPORT_RMT */
   1293 			padsz += res;
   1294 		if (res < 0) {
   1295 			syswarn(1, errno, "Unable to locate tape filemark.");
   1296 			return(-1);
   1297 		}
   1298 	}
   1299 
   1300 	/*
   1301 	 * move backwards over the file mark so we are at the end of the
   1302 	 * last record.
   1303 	 */
   1304 	mb.mt_op = MTBSF;
   1305 	mb.mt_count = 1;
   1306 	if (
   1307 #ifdef SUPPORT_RMT
   1308 	    rmtioctl(arfd, MTIOCTOP, &mb)
   1309 #else
   1310 	    ioctl(arfd, MTIOCTOP, &mb)
   1311 #endif /* SUPPORT_RMT */
   1312 	    < 0) {
   1313 		syswarn(1, errno, "Unable to backspace over tape filemark.");
   1314 		return(-1);
   1315 	}
   1316 
   1317 	/*
   1318 	 * move backwards so we are in front of the last record and read it to
   1319 	 * get physical tape blocksize.
   1320 	 */
   1321 	mb.mt_op = MTBSR;
   1322 	mb.mt_count = 1;
   1323 	if (
   1324 #ifdef SUPPORT_RMT
   1325 	    rmtioctl(arfd, MTIOCTOP, &mb)
   1326 #else
   1327 	    ioctl(arfd, MTIOCTOP, &mb)
   1328 #endif /* SUPPORT_RMT */
   1329 	    < 0) {
   1330 		syswarn(1, errno, "Unable to backspace over last tape block.");
   1331 		return(-1);
   1332 	}
   1333 	if ((phyblk =
   1334 #ifdef SUPPORT_RMT
   1335 	     rmtread_with_restart(arfd, scbuf, sizeof(scbuf))
   1336 #else
   1337 	     read_with_restart(arfd, scbuf, sizeof(scbuf))
   1338 #endif /* SUPPORT_RMT */
   1339 	    ) <= 0) {
   1340 		syswarn(1, errno, "Cannot determine archive tape blocksize.");
   1341 		return(-1);
   1342 	}
   1343 
   1344 	/*
   1345 	 * read forward to the file mark, then back up in front of the filemark
   1346 	 * (this is a bit paranoid, but should be safe to do).
   1347 	 */
   1348 	while ((res =
   1349 #ifdef SUPPORT_RMT
   1350 		rmtread_with_restart(arfd, scbuf, sizeof(scbuf))
   1351 #else
   1352 		read_with_restart(arfd, scbuf, sizeof(scbuf))
   1353 #endif /* SUPPORT_RMT */
   1354 	       ) > 0)
   1355 		;
   1356 	if (res < 0) {
   1357 		syswarn(1, errno, "Unable to locate tape filemark.");
   1358 		return(-1);
   1359 	}
   1360 	mb.mt_op = MTBSF;
   1361 	mb.mt_count = 1;
   1362 	if (
   1363 #ifdef SUPPORT_RMT
   1364 	    rmtioctl(arfd, MTIOCTOP, &mb)
   1365 #else
   1366 	    ioctl(arfd, MTIOCTOP, &mb)
   1367 #endif /* SUPPORT_RMT */
   1368 	    < 0) {
   1369 		syswarn(1, errno, "Unable to backspace over tape filemark.");
   1370 		return(-1);
   1371 	}
   1372 
   1373 	/*
   1374 	 * set lstrval so we know that the filemark has not been seen
   1375 	 */
   1376 	lstrval = 1;
   1377 
   1378 	/*
   1379 	 * return if there was no padding
   1380 	 */
   1381 	if (padsz == 0)
   1382 		return(phyblk);
   1383 
   1384 	/*
   1385 	 * make sure we can move backwards over the padding. (this should
   1386 	 * never fail).
   1387 	 */
   1388 	if (padsz % phyblk) {
   1389 		tty_warn(1, "Tape drive unable to backspace requested amount");
   1390 		return(-1);
   1391 	}
   1392 
   1393 	/*
   1394 	 * move backwards over the padding so the head is where it was when
   1395 	 * we were first called (if required).
   1396 	 */
   1397 	mb.mt_op = MTBSR;
   1398 	mb.mt_count = padsz/phyblk;
   1399 	if (
   1400 #ifdef SUPPORT_RMT
   1401 	    rmtioctl(arfd, MTIOCTOP, &mb)
   1402 #else
   1403 	    ioctl(arfd, MTIOCTOP, &mb)
   1404 #endif /* SUPPORT_RMT */
   1405 	    < 0) {
   1406 		syswarn(1, errno,
   1407 		    "Unable to backspace tape over %ld pad blocks",
   1408 		    (long)mb.mt_count);
   1409 		return(-1);
   1410 	}
   1411 	return(phyblk);
   1412 }
   1413 #endif
   1414 
   1415 /*
   1416  * ar_next()
   1417  *	prompts the user for the next volume in this archive. For some devices
   1418  *	we may allow the media to be changed. Otherwise a new archive is
   1419  *	prompted for. By pax spec, if there is no controlling tty or an eof is
   1420  *	read on tty input, we must quit pax.
   1421  * Return:
   1422  *	0 when ready to continue, -1 when all done
   1423  */
   1424 
   1425 int
   1426 ar_next(void)
   1427 {
   1428 	char buf[PAXPATHLEN+2];
   1429 	static char *arcfree = NULL;
   1430 	sigset_t o_mask;
   1431 
   1432 	/*
   1433 	 * WE MUST CLOSE THE DEVICE. A lot of devices must see last close, (so
   1434 	 * things like writing EOF etc will be done) (Watch out ar_close() can
   1435 	 * also be called via a signal handler, so we must prevent a race.
   1436 	 */
   1437 	if (sigprocmask(SIG_BLOCK, &s_mask, &o_mask) < 0)
   1438 		syswarn(0, errno, "Unable to set signal mask");
   1439 	ar_close();
   1440 	if (sigprocmask(SIG_SETMASK, &o_mask, (sigset_t *)NULL) < 0)
   1441 		syswarn(0, errno, "Unable to restore signal mask");
   1442 
   1443 	if (done || !wr_trail || force_one_volume)
   1444 		return(-1);
   1445 
   1446 	if (!is_gnutar)
   1447 		tty_prnt("\nATTENTION! %s archive volume change required.\n",
   1448 		    argv0);
   1449 
   1450 	/*
   1451 	 * if i/o is on stdin or stdout, we cannot reopen it (we do not know
   1452 	 * the name), the user will be forced to type it in.
   1453 	 */
   1454 	if (strcmp(arcname, STDO) && strcmp(arcname, STDN) && (artyp != ISREG)
   1455 	    && (artyp != ISPIPE)) {
   1456 		if (artyp == ISTAPE
   1457 #ifdef SUPPORT_RMT
   1458 		    || artyp == ISRMT
   1459 #endif /* SUPPORT_RMT */
   1460 		    ) {
   1461 			tty_prnt("%s ready for archive tape volume: %d\n",
   1462 				arcname, arvol);
   1463 			tty_prnt("Load the NEXT TAPE on the tape drive");
   1464 		} else {
   1465 			tty_prnt("%s ready for archive volume: %d\n",
   1466 				arcname, arvol);
   1467 			tty_prnt("Load the NEXT STORAGE MEDIA (if required)");
   1468 		}
   1469 
   1470 		if ((act == ARCHIVE) || (act == APPND))
   1471 			tty_prnt(" and make sure it is WRITE ENABLED.\n");
   1472 		else
   1473 			tty_prnt("\n");
   1474 
   1475 		for(;;) {
   1476 			tty_prnt("Type \"y\" to continue, \".\" to quit %s,",
   1477 				argv0);
   1478 			tty_prnt(" or \"s\" to switch to new device.\nIf you");
   1479 			tty_prnt(" cannot change storage media, type \"s\"\n");
   1480 			tty_prnt("Is the device ready and online? > ");
   1481 
   1482 			if ((tty_read(buf,sizeof(buf))<0) || !strcmp(buf,".")){
   1483 				done = 1;
   1484 				lstrval = -1;
   1485 				tty_prnt("Quitting %s!\n", argv0);
   1486 				vfpart = 0;
   1487 				return(-1);
   1488 			}
   1489 
   1490 			if ((buf[0] == '\0') || (buf[1] != '\0')) {
   1491 				tty_prnt("%s unknown command, try again\n",buf);
   1492 				continue;
   1493 			}
   1494 
   1495 			switch (buf[0]) {
   1496 			case 'y':
   1497 			case 'Y':
   1498 				/*
   1499 				 * we are to continue with the same device
   1500 				 */
   1501 				if (ar_open(arcname) >= 0)
   1502 					return(0);
   1503 				tty_prnt("Cannot re-open %s, try again\n",
   1504 					arcname);
   1505 				continue;
   1506 			case 's':
   1507 			case 'S':
   1508 				/*
   1509 				 * user wants to open a different device
   1510 				 */
   1511 				tty_prnt("Switching to a different archive\n");
   1512 				break;
   1513 			default:
   1514 				tty_prnt("%s unknown command, try again\n",buf);
   1515 				continue;
   1516 			}
   1517 			break;
   1518 		}
   1519 	} else {
   1520 		if (is_gnutar) {
   1521 			tty_warn(1, "Unexpected EOF on archive file");
   1522 			return -1;
   1523 		}
   1524 		tty_prnt("Ready for archive volume: %d\n", arvol);
   1525 	}
   1526 
   1527 	/*
   1528 	 * have to go to a different archive
   1529 	 */
   1530 	for (;;) {
   1531 		tty_prnt("Input archive name or \".\" to quit %s.\n", argv0);
   1532 		tty_prnt("Archive name > ");
   1533 
   1534 		if ((tty_read(buf, sizeof(buf)) < 0) || !strcmp(buf, ".")) {
   1535 			done = 1;
   1536 			lstrval = -1;
   1537 			tty_prnt("Quitting %s!\n", argv0);
   1538 			vfpart = 0;
   1539 			return(-1);
   1540 		}
   1541 		if (buf[0] == '\0') {
   1542 			tty_prnt("Empty file name, try again\n");
   1543 			continue;
   1544 		}
   1545 		if (!strcmp(buf, "..")) {
   1546 			tty_prnt("Illegal file name: .. try again\n");
   1547 			continue;
   1548 		}
   1549 		if (strlen(buf) > PAXPATHLEN) {
   1550 			tty_prnt("File name too long, try again\n");
   1551 			continue;
   1552 		}
   1553 
   1554 		/*
   1555 		 * try to open new archive
   1556 		 */
   1557 		if (ar_open(buf) >= 0) {
   1558 			if (arcfree) {
   1559 				(void)free(arcfree);
   1560 				arcfree = NULL;
   1561 			}
   1562 			if ((arcfree = strdup(buf)) == NULL) {
   1563 				done = 1;
   1564 				lstrval = -1;
   1565 				tty_warn(0, "Cannot save archive name.");
   1566 				return(-1);
   1567 			}
   1568 			arcname = arcfree;
   1569 			break;
   1570 		}
   1571 		tty_prnt("Cannot open %s, try again\n", buf);
   1572 		continue;
   1573 	}
   1574 	return(0);
   1575 }
   1576 
   1577 /*
   1578  * ar_start_gzip()
   1579  * starts the compression/decompression process as a child, using magic
   1580  * to keep the fd the same in the calling function (parent). possible
   1581  * programs are GZIP_CMD, BZIP2_CMD, and COMPRESS_CMD.
   1582  */
   1583 void
   1584 ar_start_gzip(int fd, const char *gzp, int wr)
   1585 {
   1586 	int fds[2];
   1587 	const char *gzip_flags;
   1588 
   1589 	if (pipe(fds) < 0)
   1590 		err(1, "could not pipe");
   1591 	zpid = fork();
   1592 	if (zpid < 0)
   1593 		err(1, "could not fork");
   1594 
   1595 	/* parent */
   1596 	if (zpid) {
   1597 		if (wr)
   1598 			dup2(fds[1], fd);
   1599 		else
   1600 			dup2(fds[0], fd);
   1601 		close(fds[0]);
   1602 		close(fds[1]);
   1603 	} else {
   1604 		if (wr) {
   1605 			dup2(fds[0], STDIN_FILENO);
   1606 			dup2(fd, STDOUT_FILENO);
   1607 			gzip_flags = "-c";
   1608 		} else {
   1609 			dup2(fds[1], STDOUT_FILENO);
   1610 			dup2(fd, STDIN_FILENO);
   1611 			gzip_flags = "-dc";
   1612 		}
   1613 		close(fds[0]);
   1614 		close(fds[1]);
   1615 		if (execlp(gzp, gzp, gzip_flags, NULL) < 0)
   1616 			err(1, "could not exec");
   1617 		/* NOTREACHED */
   1618 	}
   1619 }
   1620 
   1621 static const char *
   1622 timefmt(buf, size, sz, tm, unitstr)
   1623 	char *buf;
   1624 	size_t size;
   1625 	off_t sz;
   1626 	time_t tm;
   1627 	const char *unitstr;
   1628 {
   1629 	(void)snprintf(buf, size, "%lu secs (" OFFT_F " %s/sec)",
   1630 	    (unsigned long)tm, (OFFT_T)(sz / tm), unitstr);
   1631 	return buf;
   1632 }
   1633 
   1634 static const char *
   1635 sizefmt(buf, size, sz)
   1636 	char *buf;
   1637 	size_t size;
   1638 	off_t sz;
   1639 {
   1640 	(void)snprintf(buf, size, OFFT_F " bytes", (OFFT_T)sz);
   1641 	return buf;
   1642 }
   1643 
   1644 void
   1645 ar_summary(int n)
   1646 {
   1647 	time_t secs;
   1648 	int len;
   1649 	char buf[MAXPATHLEN];
   1650 	char tbuf[MAXPATHLEN/4];
   1651 	char s1buf[MAXPATHLEN/8];
   1652 	char s2buf[MAXPATHLEN/8];
   1653 	FILE *outf;
   1654 
   1655 	if (act == LIST)
   1656 		outf = stdout;
   1657 	else
   1658 		outf = stderr;
   1659 
   1660 	/*
   1661 	 * If we are called from a signal (n != 0), use snprintf(3) so that we
   1662 	 * don't reenter stdio(3).
   1663 	 */
   1664 	(void)time(&secs);
   1665 	if ((secs -= starttime) == 0)
   1666 		secs = 1;
   1667 
   1668 	/*
   1669 	 * If we have not determined the format yet, we just say how many bytes
   1670 	 * we have skipped over looking for a header to id. there is no way we
   1671 	 * could have written anything yet.
   1672 	 */
   1673 	if (frmt == NULL && act != COPY) {
   1674 		len = snprintf(buf, sizeof(buf),
   1675 		    "unknown format, %s skipped in %s\n",
   1676 		    sizefmt(s1buf, sizeof(s1buf), rdcnt),
   1677 		    timefmt(tbuf, sizeof(tbuf), rdcnt, secs, "bytes"));
   1678 		if (n == 0)
   1679 			(void)fprintf(outf, "%s: %s", argv0, buf);
   1680 		else
   1681 			(void)write(STDERR_FILENO, buf, len);
   1682 		return;
   1683 	}
   1684 
   1685 
   1686 	if (n != 0) {
   1687 		len = snprintf(buf, sizeof(buf), "Working on `%s' (%s)\n",
   1688 		    archd.name, sizefmt(s1buf, sizeof(s1buf), archd.sb.st_size));
   1689 		(void)write(STDERR_FILENO, buf, len);
   1690 	}
   1691 
   1692 
   1693 	if (act == COPY) {
   1694 		len = snprintf(buf, sizeof(buf),
   1695 		    "%lu files in %s\n",
   1696 		    (unsigned long)flcnt,
   1697 		    timefmt(tbuf, sizeof(tbuf), flcnt, secs, "files"));
   1698 	} else {
   1699 		len = snprintf(buf, sizeof(buf),
   1700 		    "%s vol %d, %lu files, %s read, %s written in %s\n",
   1701 		    frmt->name, arvol-1, (unsigned long)flcnt,
   1702 		    sizefmt(s1buf, sizeof(s1buf), rdcnt),
   1703 		    sizefmt(s2buf, sizeof(s2buf), wrcnt),
   1704 		    timefmt(tbuf, sizeof(tbuf), rdcnt + wrcnt, secs, "bytes"));
   1705 	}
   1706 	if (n == 0)
   1707 		(void)fprintf(outf, "%s: %s", argv0, buf);
   1708 	else
   1709 		(void)write(STDERR_FILENO, buf, strlen(buf));
   1710 }
   1711 
   1712 /*
   1713  * ar_dochdir(name)
   1714  *	change directory to name, and remember where we came from and
   1715  *	where we change to (for ar_open).
   1716  *
   1717  *	Maybe we could try to be smart and only do the actual chdir
   1718  *	when necessary to write a file read from the archive, but this
   1719  *	is not easy to get right given the pax code structure.
   1720  *
   1721  *	Be sure to not leak descriptors!
   1722  *
   1723  *	We are called N * M times when extracting, and N times when
   1724  *	writing archives, where
   1725  *	N:	number of -C options
   1726  *	M:	number of files in archive
   1727  *
   1728  * Returns 0 if all went well, else -1.
   1729  */
   1730 
   1731 int
   1732 ar_dochdir(const char *name)
   1733 {
   1734 	/* First fdochdir() back... */
   1735 	if (fdochdir(cwdfd) == -1)
   1736 		return -1;
   1737 	if (dochdir(name) == -1)
   1738 		return -1;
   1739 	return 0;
   1740 }
   1741