GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: bin/pax/ar_io.c Lines: 141 461 30.6 %
Date: 2017-11-13 Branches: 87 322 27.0 %

Line Branch Exec Source
1
/*	$OpenBSD: ar_io.c,v 1.62 2017/03/11 12:55:47 tb Exp $	*/
2
/*	$NetBSD: ar_io.c,v 1.5 1996/03/26 23:54:13 mrg Exp $	*/
3
4
/*-
5
 * Copyright (c) 1992 Keith Muller.
6
 * Copyright (c) 1992, 1993
7
 *	The Regents of the University of California.  All rights reserved.
8
 *
9
 * This code is derived from software contributed to Berkeley by
10
 * Keith Muller of the University of California, San Diego.
11
 *
12
 * Redistribution and use in source and binary forms, with or without
13
 * modification, are permitted provided that the following conditions
14
 * are met:
15
 * 1. Redistributions of source code must retain the above copyright
16
 *    notice, this list of conditions and the following disclaimer.
17
 * 2. Redistributions in binary form must reproduce the above copyright
18
 *    notice, this list of conditions and the following disclaimer in the
19
 *    documentation and/or other materials provided with the distribution.
20
 * 3. Neither the name of the University nor the names of its contributors
21
 *    may be used to endorse or promote products derived from this software
22
 *    without specific prior written permission.
23
 *
24
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34
 * SUCH DAMAGE.
35
 */
36
37
#include <sys/types.h>
38
#include <sys/stat.h>
39
#include <sys/ioctl.h>
40
#include <sys/mtio.h>
41
#include <sys/wait.h>
42
#include <err.h>
43
#include <errno.h>
44
#include <fcntl.h>
45
#include <signal.h>
46
#include <stdio.h>
47
#include <stdlib.h>
48
#include <string.h>
49
#include <unistd.h>
50
51
#include "pax.h"
52
#include "extern.h"
53
54
/*
55
 * Routines which deal directly with the archive I/O device/file.
56
 */
57
58
#define DMOD		0666		/* default mode of created archives */
59
#define EXT_MODE	O_RDONLY	/* open mode for list/extract */
60
#define AR_MODE		(O_WRONLY | O_CREAT | O_TRUNC)	/* mode for archive */
61
#define APP_MODE	O_RDWR		/* mode for append */
62
#define STDO		"<STDOUT>"	/* pseudo name for stdout */
63
#define STDN		"<STDIN>"	/* pseudo name for stdin */
64
static int arfd = -1;			/* archive file descriptor */
65
static int artyp = ISREG;		/* archive type: file/FIFO/tape */
66
static int arvol = 1;			/* archive volume number */
67
static int lstrval = -1;		/* return value from last i/o */
68
static int io_ok;			/* i/o worked on volume after resync */
69
static int did_io;			/* did i/o ever occur on volume? */
70
static int done;			/* set via tty termination */
71
static struct stat arsb;		/* stat of archive device at open */
72
static int invld_rec;			/* tape has out of spec record size */
73
static int wr_trail = 1;		/* trailer was rewritten in append */
74
static int can_unlnk = 0;		/* do we unlink null archives?  */
75
const char *arcname;			/* printable name of archive */
76
const char *gzip_program;		/* name of gzip program */
77
static pid_t zpid = -1;			/* pid of child process */
78
int force_one_volume;			/* 1 if we ignore volume changes */
79
80
static int get_phys(void);
81
extern sigset_t s_mask;
82
static void ar_start_gzip(int, const char *, int);
83
84
/*
85
 * ar_open()
86
 *	Opens the next archive volume. Determines the type of the device and
87
 *	sets up block sizes as required by the archive device and the format.
88
 *	Note: we may be called with name == NULL on the first open only.
89
 * Return:
90
 *	-1 on failure, 0 otherwise
91
 */
92
93
int
94
ar_open(const char *name)
95
{
96
200
	struct mtget mb;
97
98
100
	if (arfd != -1)
99
		(void)close(arfd);
100
200
	arfd = -1;
101
200
	can_unlnk = did_io = io_ok = invld_rec = 0;
102
200
	artyp = ISREG;
103
200
	flcnt = 0;
104
105
	/*
106
	 * open based on overall operation mode
107
	 */
108

200
	switch (act) {
109
	case LIST:
110
	case EXTRACT:
111
60
		if (name == NULL) {
112
24
			arfd = STDIN_FILENO;
113
24
			arcname = STDN;
114
60
		} else if ((arfd = open(name, EXT_MODE, DMOD)) < 0)
115
			syswarn(1, errno, "Failed open to read on %s", name);
116
60
		if (arfd != -1 && gzip_program != NULL)
117
18
			ar_start_gzip(arfd, gzip_program, 0);
118
		break;
119
	case ARCHIVE:
120
22
		if (name == NULL) {
121
12
			arfd = STDOUT_FILENO;
122
12
			arcname = STDO;
123
22
		} else if ((arfd = open(name, AR_MODE, DMOD)) < 0)
124
			syswarn(1, errno, "Failed open to write on %s", name);
125
		else
126
10
			can_unlnk = 1;
127
22
		if (arfd != -1 && gzip_program != NULL)
128
4
			ar_start_gzip(arfd, gzip_program, 1);
129
		break;
130
	case APPND:
131
18
		if (name == NULL) {
132
			arfd = STDOUT_FILENO;
133
			arcname = STDO;
134
18
		} else if ((arfd = open(name, APP_MODE, DMOD)) < 0)
135
			syswarn(1, errno, "Failed open to read/write on %s",
136
				name);
137
		break;
138
	case COPY:
139
		/*
140
		 * arfd not used in COPY mode
141
		 */
142
		arcname = "<NONE>";
143
		lstrval = 1;
144
		return(0);
145
	}
146
100
	if (arfd < 0)
147
		return(-1);
148
149
100
	if (chdname != NULL)
150
		if (chdir(chdname) != 0) {
151
			syswarn(1, errno, "Failed chdir to %s", chdname);
152
			return(-1);
153
		}
154
	/*
155
	 * set up is based on device type
156
	 */
157
100
	if (fstat(arfd, &arsb) < 0) {
158
		syswarn(1, errno, "Failed stat on %s", arcname);
159
		(void)close(arfd);
160
		arfd = -1;
161
		can_unlnk = 0;
162
		return(-1);
163
	}
164
100
	if (S_ISDIR(arsb.st_mode)) {
165
		paxwarn(0, "Cannot write an archive on top of a directory %s",
166
		    arcname);
167
		(void)close(arfd);
168
		arfd = -1;
169
		can_unlnk = 0;
170
		return(-1);
171
	}
172
173
100
	if (S_ISCHR(arsb.st_mode))
174
1
		artyp = ioctl(arfd, MTIOCGET, &mb) ? ISCHR : ISTAPE;
175
99
	else if (S_ISBLK(arsb.st_mode))
176
		artyp = ISBLK;
177
138
	else if ((lseek(arfd, 0, SEEK_CUR) == -1) && (errno == ESPIPE))
178
		artyp = ISPIPE;
179
	else
180
		artyp = ISREG;
181
182
	/*
183
	 * make sure beyond any doubt that we can unlink only regular files
184
	 * we created
185
	 */
186
100
	if (artyp != ISREG)
187
40
		can_unlnk = 0;
188
	/*
189
	 * if we are writing, we are done
190
	 */
191
100
	if (act == ARCHIVE) {
192
22
		blksz = rdblksz = wrblksz;
193
22
		lstrval = 1;
194
22
		return(0);
195
	}
196
197
	/*
198
	 * set default blksz on read. APPNDs writes rdblksz on the last volume
199
	 * On all new archive volumes, we shift to wrblksz (if the user
200
	 * specified one, otherwise we will continue to use rdblksz). We
201
	 * must set blocksize based on what kind of device the archive is
202
	 * stored.
203
	 */
204

78
	switch (artyp) {
205
	case ISTAPE:
206
		/*
207
		 * Tape drives come in at least two flavors. Those that support
208
		 * variable sized records and those that have fixed sized
209
		 * records. They must be treated differently. For tape drives
210
		 * that support variable sized records, we must make large
211
		 * reads to make sure we get the entire record, otherwise we
212
		 * will just get the first part of the record (up to size we
213
		 * asked). Tapes with fixed sized records may or may not return
214
		 * multiple records in a single read. We really do not care
215
		 * what the physical record size is UNLESS we are going to
216
		 * append. (We will need the physical block size to rewrite
217
		 * the trailer). Only when we are appending do we go to the
218
		 * effort to figure out the true PHYSICAL record size.
219
		 */
220
		blksz = rdblksz = MAXBLK;
221
		break;
222
	case ISPIPE:
223
	case ISBLK:
224
	case ISCHR:
225
		/*
226
		 * Blocksize is not a major issue with these devices (but must
227
		 * be kept a multiple of 512). If the user specified a write
228
		 * block size, we use that to read. Under append, we must
229
		 * always keep blksz == rdblksz. Otherwise we go ahead and use
230
		 * the device optimal blocksize as (and if) returned by stat
231
		 * and if it is within pax specs.
232
		 */
233
24
		if ((act == APPND) && wrblksz) {
234
			blksz = rdblksz = wrblksz;
235
			break;
236
		}
237
238
48
		if ((arsb.st_blksize > 0) && (arsb.st_blksize < MAXBLK) &&
239
24
		    ((arsb.st_blksize % BLKMULT) == 0))
240
			rdblksz = arsb.st_blksize;
241
		else
242
			rdblksz = DEVBLK;
243
		/*
244
		 * For performance go for large reads when we can without harm
245
		 */
246
24
		if ((act == APPND) || (artyp == ISCHR))
247
			blksz = rdblksz;
248
		else
249
			blksz = MAXBLK;
250
24
		break;
251
	case ISREG:
252
		/*
253
		 * if the user specified wrblksz works, use it. Under appends
254
		 * we must always keep blksz == rdblksz
255
		 */
256

54
		if ((act == APPND) && wrblksz && ((arsb.st_size%wrblksz)==0)){
257
			blksz = rdblksz = wrblksz;
258
			break;
259
		}
260
		/*
261
		 * See if we can find the blocking factor from the file size
262
		 */
263
11772
		for (rdblksz = MAXBLK; rdblksz > 0; rdblksz -= BLKMULT)
264
5886
			if ((arsb.st_size % rdblksz) == 0)
265
				break;
266
		/*
267
		 * When we cannot find a match, we may have a flawed archive.
268
		 */
269
54
		if (rdblksz <= 0)
270
			rdblksz = FILEBLK;
271
		/*
272
		 * for performance go for large reads when we can
273
		 */
274
108
		if (act == APPND)
275
54
			blksz = rdblksz;
276
		else
277
			blksz = MAXBLK;
278
54
		break;
279
	default:
280
		/*
281
		 * should never happen, worst case, slow...
282
		 */
283
		blksz = rdblksz = BLKMULT;
284
		break;
285
	}
286
78
	lstrval = 1;
287
78
	return(0);
288
100
}
289
290
/*
291
 * ar_close(int int_sig)
292
 *	closes archive device, increments volume number, and prints i/o summary
293
 *	If in_sig is set we're in a signal handler and can't flush stdio.
294
 */
295
void
296
ar_close(int in_sig)
297
{
298
200
	int status;
299
300
100
	if (arfd < 0) {
301
6
		did_io = io_ok = flcnt = 0;
302
6
		return;
303
	}
304
94
	if (!in_sig)
305
94
		fflush(listf);
306
307
	/*
308
	 * Close archive file. This may take a LONG while on tapes (we may be
309
	 * forced to wait for the rewind to complete) so tell the user what is
310
	 * going on (this avoids the user hitting control-c thinking pax is
311
	 * broken).
312
	 */
313
94
	if (vflag && (artyp == ISTAPE)) {
314
		(void)dprintf(listfd,
315
		    "%s%s: Waiting for tape drive close to complete...",
316
		    vfpart ? "\n" : "", argv0);
317
	}
318
319
	/*
320
	 * if nothing was written to the archive (and we created it), we remove
321
	 * it
322
	 */
323

112
	if (can_unlnk && (fstat(arfd, &arsb) == 0) && (S_ISREG(arsb.st_mode)) &&
324
6
	    (arsb.st_size == 0)) {
325
		(void)unlink(arcname);
326
		can_unlnk = 0;
327
	}
328
329
	/*
330
	 * for a quick extract/list, pax frequently exits before the child
331
	 * process is done
332
	 */
333
94
	if ((act == LIST || act == EXTRACT) && nflag && zpid > 0) {
334
		kill(zpid, SIGINT);
335
		zpid = -1;
336
	}
337
338
94
	(void)close(arfd);
339
340
	/* Do not exit before child to ensure data integrity */
341
94
	if (zpid > 0) {
342
22
		waitpid(zpid, &status, 0);
343

44
		if (!WIFEXITED(status) || WEXITSTATUS(status))
344
			exit_val = 1;
345
	}
346
347
348
94
	if (vflag && (artyp == ISTAPE)) {
349
		(void)write(listfd, "done.\n", sizeof("done.\n")-1);
350
		vfpart = 0;
351
	}
352
94
	arfd = -1;
353
354
94
	if (!io_ok && !did_io) {
355
		flcnt = 0;
356
		return;
357
	}
358
94
	did_io = io_ok = 0;
359
360
	/*
361
	 * The volume number is only increased when the last device has data
362
	 * and we have already determined the archive format.
363
	 */
364
94
	if (frmt != NULL)
365
94
		++arvol;
366
367
94
	if (!vflag) {
368
94
		flcnt = 0;
369
94
		return;
370
	}
371
372
	/*
373
	 * Print out a summary of I/O for this archive volume.
374
	 */
375
	if (vfpart) {
376
		(void)write(listfd, "\n", 1);
377
		vfpart = 0;
378
	}
379
380
	/*
381
	 * If we have not determined the format yet, we just say how many bytes
382
	 * we have skipped over looking for a header to id. there is no way we
383
	 * could have written anything yet.
384
	 */
385
	if (frmt == NULL) {
386
		(void)dprintf(listfd,
387
		    "%s: unknown format, %llu bytes skipped.\n", argv0, rdcnt);
388
		flcnt = 0;
389
		return;
390
	}
391
392
	if (op_mode == OP_PAX)
393
		(void)dprintf(listfd, "%s: %s vol %d, %lu files,"
394
		    " %llu bytes read, %llu bytes written.\n",
395
		    argv0, frmt->name, arvol-1, flcnt, rdcnt, wrcnt);
396
#ifndef NOCPIO
397
	else if (op_mode == OP_CPIO)
398
		(void)dprintf(listfd, "%llu blocks\n",
399
		    (rdcnt ? rdcnt : wrcnt) / 5120);
400
#endif /* !NOCPIO */
401
	flcnt = 0;
402
100
}
403
404
/*
405
 * ar_drain()
406
 *	drain any archive format independent padding from an archive read
407
 *	from a socket or a pipe. This is to prevent the process on the
408
 *	other side of the pipe from getting a SIGPIPE (pax will stop
409
 *	reading an archive once a format dependent trailer is detected).
410
 */
411
void
412
ar_drain(void)
413
{
414
	int res;
415
144
	char drbuf[MAXBLK];
416
417
	/*
418
	 * we only drain from a pipe/socket. Other devices can be closed
419
	 * without reading up to end of file. We sure hope that pipe is closed
420
	 * on the other side so we will get an EOF.
421
	 */
422
72
	if ((artyp != ISPIPE) || (lstrval <= 0))
423
48
		return;
424
425
	/*
426
	 * keep reading until pipe is drained
427
	 */
428
48
	while ((res = read(arfd, drbuf, sizeof(drbuf))) > 0)
429
		continue;
430
24
	lstrval = res;
431
96
}
432
433
/*
434
 * ar_set_wr()
435
 *	Set up device right before switching from read to write in an append.
436
 *	device dependent code (if required) to do this should be added here.
437
 *	For all archive devices we are already positioned at the place we want
438
 *	to start writing when this routine is called.
439
 * Return:
440
 *	0 if all ready to write, -1 otherwise
441
 */
442
443
int
444
ar_set_wr(void)
445
{
446
	off_t cpos;
447
448
	/*
449
	 * we must make sure the trailer is rewritten on append, ar_next()
450
	 * will stop us if the archive containing the trailer was not written
451
	 */
452
36
	wr_trail = 0;
453
454
	/*
455
	 * Add any device dependent code as required here
456
	 */
457
18
	if (artyp != ISREG)
458
		return(0);
459
	/*
460
	 * Ok we have an archive in a regular file. If we were rewriting a
461
	 * file, we must get rid of all the stuff after the current offset
462
	 * (it was not written by pax).
463
	 */
464

36
	if (((cpos = lseek(arfd, 0, SEEK_CUR)) < 0) ||
465
18
	    (ftruncate(arfd, cpos) < 0)) {
466
		syswarn(1, errno, "Unable to truncate archive file");
467
		return(-1);
468
	}
469
18
	return(0);
470
18
}
471
472
/*
473
 * ar_app_ok()
474
 *	check if the last volume in the archive allows appends. We cannot check
475
 *	this until we are ready to write since there is no spec that says all
476
 *	volumes in a single archive have to be of the same type...
477
 * Return:
478
 *	0 if we can append, -1 otherwise.
479
 */
480
481
int
482
ar_app_ok(void)
483
{
484
36
	if (artyp == ISPIPE) {
485
		paxwarn(1, "Cannot append to an archive obtained from a pipe.");
486
		return(-1);
487
	}
488
489
18
	if (!invld_rec)
490
18
		return(0);
491
	paxwarn(1,"Cannot append, device record size %d does not support %s spec",
492
		rdblksz, argv0);
493
	return(-1);
494
18
}
495
496
/*
497
 * ar_read()
498
 *	read up to a specified number of bytes from the archive into the
499
 *	supplied buffer. When dealing with tapes we may not always be able to
500
 *	read what we want.
501
 * Return:
502
 *	Number of bytes in buffer. 0 for end of file, -1 for a read error.
503
 */
504
505
int
506
ar_read(char *buf, int cnt)
507
{
508
	int res = 0;
509
510
	/*
511
	 * if last i/o was in error, no more reads until reset or new volume
512
	 */
513
216
	if (lstrval <= 0)
514
		return(lstrval);
515
516
	/*
517
	 * how we read must be based on device type
518
	 */
519
216
	switch (artyp) {
520
	case ISTAPE:
521
108
		if ((res = read(arfd, buf, cnt)) > 0) {
522
			/*
523
			 * CAUTION: tape systems may not always return the same
524
			 * sized records so we leave blksz == MAXBLK. The
525
			 * physical record size that a tape drive supports is
526
			 * very hard to determine in a uniform and portable
527
			 * manner.
528
			 */
529
			io_ok = 1;
530
			if (res != rdblksz) {
531
				/*
532
				 * Record size changed. If this happens on
533
				 * any record after the first, we probably have
534
				 * a tape drive which has a fixed record size
535
				 * (we are getting multiple records in a single
536
				 * read). Watch out for record blocking that
537
				 * violates pax spec (must be a multiple of
538
				 * BLKMULT).
539
				 */
540
				rdblksz = res;
541
				if (rdblksz % BLKMULT)
542
					invld_rec = 1;
543
			}
544
			return(res);
545
		}
546
		break;
547
	case ISREG:
548
	case ISBLK:
549
	case ISCHR:
550
	case ISPIPE:
551
	default:
552
		/*
553
		 * Files are so easy to deal with. These other things cannot
554
		 * be trusted at all. So when we are dealing with character
555
		 * devices and pipes we just take what they have ready for us
556
		 * and return. Trying to do anything else with them runs the
557
		 * risk of failure.
558
		 */
559
108
		if ((res = read(arfd, buf, cnt)) > 0) {
560
102
			io_ok = 1;
561
102
			return(res);
562
		}
563
		break;
564
	}
565
566
	/*
567
	 * We are in trouble at this point, something is broken...
568
	 */
569
6
	lstrval = res;
570
6
	if (res < 0)
571
		syswarn(1, errno, "Failed read on archive volume %d", arvol);
572
	else
573
6
		paxwarn(0, "End of archive volume %d reached", arvol);
574
6
	return(res);
575
108
}
576
577
/*
578
 * ar_write()
579
 *	Write a specified number of bytes in supplied buffer to the archive
580
 *	device so it appears as a single "block". Deals with errors and tries
581
 *	to recover when faced with short writes.
582
 * Return:
583
 *	Number of bytes written. 0 indicates end of volume reached and with no
584
 *	flaws (as best that can be detected). A -1 indicates an unrecoverable
585
 *	error in the archive occurred.
586
 */
587
588
int
589
ar_write(char *buf, int bsz)
590
{
591
	int res;
592
	off_t cpos;
593
594
	/*
595
	 * do not allow pax to create a "bad" archive. Once a write fails on
596
	 * an archive volume prevent further writes to it.
597
	 */
598
78
	if (lstrval <= 0)
599
		return(lstrval);
600
601
39
	if ((res = write(arfd, buf, bsz)) == bsz) {
602
39
		wr_trail = 1;
603
39
		io_ok = 1;
604
39
		return(bsz);
605
	}
606
	/*
607
	 * write broke, see what we can do with it. We try to send any partial
608
	 * writes that may violate pax spec to the next archive volume.
609
	 */
610
	if (res < 0)
611
		lstrval = res;
612
	else
613
		lstrval = 0;
614
615
	switch (artyp) {
616
	case ISREG:
617
		if ((res > 0) && (res % BLKMULT)) {
618
			/*
619
			 * try to fix up partial writes which are not BLKMULT
620
			 * in size by forcing the runt record to next archive
621
			 * volume
622
			 */
623
			if ((cpos = lseek(arfd, 0, SEEK_CUR)) < 0)
624
				break;
625
			cpos -= res;
626
			if (ftruncate(arfd, cpos) < 0)
627
				break;
628
			res = lstrval = 0;
629
			break;
630
		}
631
		if (res >= 0)
632
			break;
633
		/*
634
		 * if file is out of space, handle it like a return of 0
635
		 */
636
		if ((errno == ENOSPC) || (errno == EFBIG) || (errno == EDQUOT))
637
			res = lstrval = 0;
638
		break;
639
	case ISTAPE:
640
	case ISCHR:
641
	case ISBLK:
642
		if (res >= 0)
643
			break;
644
		if (errno == EACCES) {
645
			paxwarn(0, "Write failed, archive is write protected.");
646
			res = lstrval = 0;
647
			return(0);
648
		}
649
		/*
650
		 * see if we reached the end of media, if so force a change to
651
		 * the next volume
652
		 */
653
		if ((errno == ENOSPC) || (errno == EIO) || (errno == ENXIO))
654
			res = lstrval = 0;
655
		break;
656
	case ISPIPE:
657
	default:
658
		/*
659
		 * we cannot fix errors to these devices
660
		 */
661
		break;
662
	}
663
664
	/*
665
	 * Better tell the user the bad news...
666
	 * if this is a block aligned archive format, we may have a bad archive
667
	 * if the format wants the header to start at a BLKMULT boundary. While
668
	 * we can deal with the mis-aligned data, it violates spec and other
669
	 * archive readers will likely fail. if the format is not block
670
	 * aligned, the user may be lucky (and the archive is ok).
671
	 */
672
	if (res >= 0) {
673
		if (res > 0)
674
			wr_trail = 1;
675
		io_ok = 1;
676
	}
677
678
	/*
679
	 * If we were trying to rewrite the trailer and it didn't work, we
680
	 * must quit right away.
681
	 */
682
	if (!wr_trail && (res <= 0)) {
683
		paxwarn(1,"Unable to append, trailer re-write failed. Quitting.");
684
		return(res);
685
	}
686
687
	if (res == 0)
688
		paxwarn(0, "End of archive volume %d reached", arvol);
689
	else if (res < 0)
690
		syswarn(1, errno, "Failed write to archive volume: %d", arvol);
691
	else if (!frmt->blkalgn || ((res % frmt->blkalgn) == 0))
692
		paxwarn(0,"WARNING: partial archive write. Archive MAY BE FLAWED");
693
	else
694
		paxwarn(1,"WARNING: partial archive write. Archive IS FLAWED");
695
	return(res);
696
39
}
697
698
/*
699
 * ar_rdsync()
700
 *	Try to move past a bad spot on a flawed archive as needed to continue
701
 *	I/O. Clears error flags to allow I/O to continue.
702
 * Return:
703
 *	0 when ok to try i/o again, -1 otherwise.
704
 */
705
706
int
707
ar_rdsync(void)
708
{
709
	long fsbz;
710
	off_t cpos;
711
	off_t mpos;
712
	struct mtop mb;
713
714
	/*
715
	 * Fail resync attempts at user request (done) or if this is going to be
716
	 * an update/append to a existing archive. if last i/o hit media end,
717
	 * we need to go to the next volume not try a resync
718
	 */
719
	if ((done > 0) || (lstrval == 0))
720
		return(-1);
721
722
	if ((act == APPND) || (act == ARCHIVE)) {
723
		paxwarn(1, "Cannot allow updates to an archive with flaws.");
724
		return(-1);
725
	}
726
	if (io_ok)
727
		did_io = 1;
728
729
	switch (artyp) {
730
	case ISTAPE:
731
		/*
732
		 * if the last i/o was a successful data transfer, we assume
733
		 * the fault is just a bad record on the tape that we are now
734
		 * past. If we did not get any data since the last resync try
735
		 * to move the tape forward one PHYSICAL record past any
736
		 * damaged tape section. Some tape drives are stubborn and need
737
		 * to be pushed.
738
		 */
739
		if (io_ok) {
740
			io_ok = 0;
741
			lstrval = 1;
742
			break;
743
		}
744
		mb.mt_op = MTFSR;
745
		mb.mt_count = 1;
746
		if (ioctl(arfd, MTIOCTOP, &mb) < 0)
747
			break;
748
		lstrval = 1;
749
		break;
750
	case ISREG:
751
	case ISCHR:
752
	case ISBLK:
753
		/*
754
		 * try to step over the bad part of the device.
755
		 */
756
		io_ok = 0;
757
		if (((fsbz = arsb.st_blksize) <= 0) || (artyp != ISREG))
758
			fsbz = BLKMULT;
759
		if ((cpos = lseek(arfd, 0, SEEK_CUR)) < 0)
760
			break;
761
		mpos = fsbz - (cpos % fsbz);
762
		if (lseek(arfd, mpos, SEEK_CUR) < 0)
763
			break;
764
		lstrval = 1;
765
		break;
766
	case ISPIPE:
767
	default:
768
		/*
769
		 * cannot recover on these archive device types
770
		 */
771
		io_ok = 0;
772
		break;
773
	}
774
	if (lstrval <= 0) {
775
		paxwarn(1, "Unable to recover from an archive read failure.");
776
		return(-1);
777
	}
778
	paxwarn(0, "Attempting to recover from an archive read failure.");
779
	return(0);
780
}
781
782
/*
783
 * ar_fow()
784
 *	Move the I/O position within the archive forward the specified number of
785
 *	bytes as supported by the device. If we cannot move the requested
786
 *	number of bytes, return the actual number of bytes moved in skipped.
787
 * Return:
788
 *	0 if moved the requested distance, -1 on complete failure, 1 on
789
 *	partial move (the amount moved is in skipped)
790
 */
791
792
int
793
ar_fow(off_t sksz, off_t *skipped)
794
{
795
	off_t cpos;
796
	off_t mpos;
797
798
	*skipped = 0;
799
	if (sksz <= 0)
800
		return(0);
801
802
	/*
803
	 * we cannot move forward at EOF or error
804
	 */
805
	if (lstrval <= 0)
806
		return(lstrval);
807
808
	/*
809
	 * Safer to read forward on devices where it is hard to find the end of
810
	 * the media without reading to it. With tapes we cannot be sure of the
811
	 * number of physical blocks to skip (we do not know physical block
812
	 * size at this point), so we must only read forward on tapes!
813
	 */
814
	if (artyp != ISREG)
815
		return(0);
816
817
	/*
818
	 * figure out where we are in the archive
819
	 */
820
	if ((cpos = lseek(arfd, 0, SEEK_CUR)) >= 0) {
821
		/*
822
		 * we can be asked to move farther than there are bytes in this
823
		 * volume, if so, just go to file end and let normal buf_fill()
824
		 * deal with the end of file (it will go to next volume by
825
		 * itself)
826
		 */
827
		if ((mpos = cpos + sksz) > arsb.st_size) {
828
			*skipped = arsb.st_size - cpos;
829
			mpos = arsb.st_size;
830
		} else
831
			*skipped = sksz;
832
		if (lseek(arfd, mpos, SEEK_SET) >= 0)
833
			return(0);
834
	}
835
	syswarn(1, errno, "Forward positioning operation on archive failed");
836
	lstrval = -1;
837
	return(-1);
838
}
839
840
/*
841
 * ar_rev()
842
 *	move the i/o position within the archive backwards the specified byte
843
 *	count as supported by the device. With tapes drives we RESET rdblksz to
844
 *	the PHYSICAL blocksize.
845
 *	NOTE: We should only be called to move backwards so we can rewrite the
846
 *	last records (the trailer) of an archive (APPEND).
847
 * Return:
848
 *	0 if moved the requested distance, -1 on complete failure
849
 */
850
851
int
852
ar_rev(off_t sksz)
853
{
854
	off_t cpos;
855
72
	struct mtop mb;
856
	int phyblk;
857
858
	/*
859
	 * make sure we do not have try to reverse on a flawed archive
860
	 */
861
36
	if (lstrval < 0)
862
		return(lstrval);
863
864
36
	switch (artyp) {
865
	case ISPIPE:
866
		if (sksz <= 0)
867
			break;
868
		/*
869
		 * cannot go backwards on these critters
870
		 */
871
		paxwarn(1, "Reverse positioning on pipes is not supported.");
872
		lstrval = -1;
873
		return(-1);
874
	case ISREG:
875
	case ISBLK:
876
	case ISCHR:
877
	default:
878
36
		if (sksz <= 0)
879
			break;
880
881
		/*
882
		 * For things other than files, backwards movement has a very
883
		 * high probability of failure as we really do not know the
884
		 * true attributes of the device we are talking to (the device
885
		 * may not even have the ability to lseek() in any direction).
886
		 * First we figure out where we are in the archive.
887
		 */
888
36
		if ((cpos = lseek(arfd, 0, SEEK_CUR)) < 0) {
889
			syswarn(1, errno,
890
			   "Unable to obtain current archive byte offset");
891
			lstrval = -1;
892
			return(-1);
893
		}
894
895
		/*
896
		 * we may try to go backwards past the start when the archive
897
		 * is only a single record. If this happens and we are on a
898
		 * multi-volume archive, we need to go to the end of the
899
		 * previous volume and continue our movement backwards from
900
		 * there.
901
		 */
902
36
		if ((cpos -= sksz) < 0) {
903
			if (arvol > 1) {
904
				/*
905
				 * this should never happen
906
				 */
907
				paxwarn(1,"Reverse position on previous volume.");
908
				lstrval = -1;
909
				return(-1);
910
			}
911
			cpos = 0;
912
		}
913
36
		if (lseek(arfd, cpos, SEEK_SET) < 0) {
914
			syswarn(1, errno, "Unable to seek archive backwards");
915
			lstrval = -1;
916
			return(-1);
917
		}
918
		break;
919
	case ISTAPE:
920
		/*
921
		 * Calculate and move the proper number of PHYSICAL tape
922
		 * blocks. If the sksz is not an even multiple of the physical
923
		 * tape size, we cannot do the move (this should never happen).
924
		 * (We also cannot handle trailers spread over two vols.)
925
		 * get_phys() also makes sure we are in front of the filemark.
926
		 */
927
		if ((phyblk = get_phys()) <= 0) {
928
			lstrval = -1;
929
			return(-1);
930
		}
931
932
		/*
933
		 * make sure future tape reads only go by physical tape block
934
		 * size (set rdblksz to the real size).
935
		 */
936
		rdblksz = phyblk;
937
938
		/*
939
		 * if no movement is required, just return (we must be after
940
		 * get_phys() so the physical blocksize is properly set)
941
		 */
942
		if (sksz <= 0)
943
			break;
944
945
		/*
946
		 * ok we have to move. Make sure the tape drive can do it.
947
		 */
948
		if (sksz % phyblk) {
949
			paxwarn(1,
950
			    "Tape drive unable to backspace requested amount");
951
			lstrval = -1;
952
			return(-1);
953
		}
954
955
		/*
956
		 * move backwards the requested number of bytes
957
		 */
958
		mb.mt_op = MTBSR;
959
		mb.mt_count = sksz/phyblk;
960
		if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
961
			syswarn(1,errno, "Unable to backspace tape %d blocks.",
962
			    mb.mt_count);
963
			lstrval = -1;
964
			return(-1);
965
		}
966
		break;
967
	}
968
36
	lstrval = 1;
969
36
	return(0);
970
36
}
971
972
/*
973
 * get_phys()
974
 *	Determine the physical block size on a tape drive. We need the physical
975
 *	block size so we know how many bytes we skip over when we move with
976
 *	mtio commands. We also make sure we are BEFORE THE TAPE FILEMARK when
977
 *	return.
978
 *	This is one really SLOW routine...
979
 * Return:
980
 *	physical block size if ok (ok > 0), -1 otherwise
981
 */
982
983
static int
984
get_phys(void)
985
{
986
	int padsz = 0;
987
	int res;
988
	int phyblk;
989
	struct mtop mb;
990
	char scbuf[MAXBLK];
991
992
	/*
993
	 * move to the file mark, and then back up one record and read it.
994
	 * this should tell us the physical record size the tape is using.
995
	 */
996
	if (lstrval == 1) {
997
		/*
998
		 * we know we are at file mark when we get back a 0 from
999
		 * read()
1000
		 */
1001
		while ((res = read(arfd, scbuf, sizeof(scbuf))) > 0)
1002
			padsz += res;
1003
		if (res < 0) {
1004
			syswarn(1, errno, "Unable to locate tape filemark.");
1005
			return(-1);
1006
		}
1007
	}
1008
1009
	/*
1010
	 * move backwards over the file mark so we are at the end of the
1011
	 * last record.
1012
	 */
1013
	mb.mt_op = MTBSF;
1014
	mb.mt_count = 1;
1015
	if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
1016
		syswarn(1, errno, "Unable to backspace over tape filemark.");
1017
		return(-1);
1018
	}
1019
1020
	/*
1021
	 * move backwards so we are in front of the last record and read it to
1022
	 * get physical tape blocksize.
1023
	 */
1024
	mb.mt_op = MTBSR;
1025
	mb.mt_count = 1;
1026
	if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
1027
		syswarn(1, errno, "Unable to backspace over last tape block.");
1028
		return(-1);
1029
	}
1030
	if ((phyblk = read(arfd, scbuf, sizeof(scbuf))) <= 0) {
1031
		syswarn(1, errno, "Cannot determine archive tape blocksize.");
1032
		return(-1);
1033
	}
1034
1035
	/*
1036
	 * read forward to the file mark, then back up in front of the filemark
1037
	 * (this is a bit paranoid, but should be safe to do).
1038
	 */
1039
	while ((res = read(arfd, scbuf, sizeof(scbuf))) > 0)
1040
		continue;
1041
	if (res < 0) {
1042
		syswarn(1, errno, "Unable to locate tape filemark.");
1043
		return(-1);
1044
	}
1045
	mb.mt_op = MTBSF;
1046
	mb.mt_count = 1;
1047
	if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
1048
		syswarn(1, errno, "Unable to backspace over tape filemark.");
1049
		return(-1);
1050
	}
1051
1052
	/*
1053
	 * set lstrval so we know that the filemark has not been seen
1054
	 */
1055
	lstrval = 1;
1056
1057
	/*
1058
	 * return if there was no padding
1059
	 */
1060
	if (padsz == 0)
1061
		return(phyblk);
1062
1063
	/*
1064
	 * make sure we can move backwards over the padding. (this should
1065
	 * never fail).
1066
	 */
1067
	if (padsz % phyblk) {
1068
		paxwarn(1, "Tape drive unable to backspace requested amount");
1069
		return(-1);
1070
	}
1071
1072
	/*
1073
	 * move backwards over the padding so the head is where it was when
1074
	 * we were first called (if required).
1075
	 */
1076
	mb.mt_op = MTBSR;
1077
	mb.mt_count = padsz/phyblk;
1078
	if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
1079
		syswarn(1,errno,"Unable to backspace tape over %d pad blocks",
1080
		    mb.mt_count);
1081
		return(-1);
1082
	}
1083
	return(phyblk);
1084
}
1085
1086
/*
1087
 * ar_next()
1088
 *	prompts the user for the next volume in this archive. For some devices
1089
 *	we may allow the media to be changed. Otherwise a new archive is
1090
 *	prompted for. By pax spec, if there is no controlling tty or an eof is
1091
 *	read on tty input, we must quit pax.
1092
 * Return:
1093
 *	0 when ready to continue, -1 when all done
1094
 */
1095
1096
int
1097
ar_next(void)
1098
{
1099
12
	char buf[PAXPATHLEN+2];
1100
	static int freeit = 0;
1101
6
	sigset_t o_mask;
1102
1103
	/*
1104
	 * WE MUST CLOSE THE DEVICE. A lot of devices must see last close, (so
1105
	 * things like writing EOF etc will be done) (Watch out ar_close() can
1106
	 * also be called via a signal handler, so we must prevent a race.
1107
	 */
1108
6
	if (sigprocmask(SIG_BLOCK, &s_mask, &o_mask) < 0)
1109
		syswarn(0, errno, "Unable to set signal mask");
1110
6
	ar_close(0);
1111
6
	if (sigprocmask(SIG_SETMASK, &o_mask, NULL) < 0)
1112
		syswarn(0, errno, "Unable to restore signal mask");
1113
1114
6
	if (done || !wr_trail || force_one_volume || op_mode == OP_TAR)
1115
6
		return(-1);
1116
1117
	tty_prnt("\nATTENTION! %s archive volume change required.\n", argv0);
1118
1119
	/*
1120
	 * if i/o is on stdin or stdout, we cannot reopen it (we do not know
1121
	 * the name), the user will be forced to type it in.
1122
	 */
1123
	if (strcmp(arcname, STDO) && strcmp(arcname, STDN) && (artyp != ISREG)
1124
	    && (artyp != ISPIPE)) {
1125
		if (artyp == ISTAPE) {
1126
			tty_prnt("%s ready for archive tape volume: %d\n",
1127
				arcname, arvol);
1128
			tty_prnt("Load the NEXT TAPE on the tape drive");
1129
		} else {
1130
			tty_prnt("%s ready for archive volume: %d\n",
1131
				arcname, arvol);
1132
			tty_prnt("Load the NEXT STORAGE MEDIA (if required)");
1133
		}
1134
1135
		if ((act == ARCHIVE) || (act == APPND))
1136
			tty_prnt(" and make sure it is WRITE ENABLED.\n");
1137
		else
1138
			tty_prnt("\n");
1139
1140
		for (;;) {
1141
			tty_prnt("Type \"y\" to continue, \".\" to quit %s,",
1142
				argv0);
1143
			tty_prnt(" or \"s\" to switch to new device.\nIf you");
1144
			tty_prnt(" cannot change storage media, type \"s\"\n");
1145
			tty_prnt("Is the device ready and online? > ");
1146
1147
			if ((tty_read(buf,sizeof(buf))<0) || !strcmp(buf,".")){
1148
				done = 1;
1149
				lstrval = -1;
1150
				tty_prnt("Quitting %s!\n", argv0);
1151
				vfpart = 0;
1152
				return(-1);
1153
			}
1154
1155
			if ((buf[0] == '\0') || (buf[1] != '\0')) {
1156
				tty_prnt("%s unknown command, try again\n",buf);
1157
				continue;
1158
			}
1159
1160
			switch (buf[0]) {
1161
			case 'y':
1162
			case 'Y':
1163
				/*
1164
				 * we are to continue with the same device
1165
				 */
1166
				if (ar_open(arcname) >= 0)
1167
					return(0);
1168
				tty_prnt("Cannot re-open %s, try again\n",
1169
					arcname);
1170
				continue;
1171
			case 's':
1172
			case 'S':
1173
				/*
1174
				 * user wants to open a different device
1175
				 */
1176
				tty_prnt("Switching to a different archive\n");
1177
				break;
1178
			default:
1179
				tty_prnt("%s unknown command, try again\n",buf);
1180
				continue;
1181
			}
1182
			break;
1183
		}
1184
	} else
1185
		tty_prnt("Ready for archive volume: %d\n", arvol);
1186
1187
	/*
1188
	 * have to go to a different archive
1189
	 */
1190
	for (;;) {
1191
		tty_prnt("Input archive name or \".\" to quit %s.\n", argv0);
1192
		tty_prnt("Archive name > ");
1193
1194
		if ((tty_read(buf, sizeof(buf)) < 0) || !strcmp(buf, ".")) {
1195
			done = 1;
1196
			lstrval = -1;
1197
			tty_prnt("Quitting %s!\n", argv0);
1198
			vfpart = 0;
1199
			return(-1);
1200
		}
1201
		if (buf[0] == '\0') {
1202
			tty_prnt("Empty file name, try again\n");
1203
			continue;
1204
		}
1205
		if (!strcmp(buf, "..")) {
1206
			tty_prnt("Illegal file name: .. try again\n");
1207
			continue;
1208
		}
1209
		if (strlen(buf) > PAXPATHLEN) {
1210
			tty_prnt("File name too long, try again\n");
1211
			continue;
1212
		}
1213
1214
		/*
1215
		 * try to open new archive
1216
		 */
1217
		if (ar_open(buf) >= 0) {
1218
			if (freeit) {
1219
				free((char *)arcname);
1220
				freeit = 0;
1221
			}
1222
			if ((arcname = strdup(buf)) == NULL) {
1223
				done = 1;
1224
				lstrval = -1;
1225
				paxwarn(0, "Cannot save archive name.");
1226
				return(-1);
1227
			}
1228
			freeit = 1;
1229
			break;
1230
		}
1231
		tty_prnt("Cannot open %s, try again\n", buf);
1232
		continue;
1233
	}
1234
	return(0);
1235
6
}
1236
1237
/*
1238
 * ar_start_gzip()
1239
 * starts the gzip compression/decompression process as a child, using magic
1240
 * to keep the fd the same in the calling function (parent).
1241
 */
1242
void
1243
ar_start_gzip(int fd, const char *path, int wr)
1244
{
1245
44
	int fds[2];
1246
	const char *gzip_flags;
1247
1248
22
	if (pipe(fds) < 0)
1249
		err(1, "could not pipe");
1250
22
	zpid = fork();
1251
22
	if (zpid < 0)
1252
		err(1, "could not fork");
1253
1254
	/* parent */
1255
22
	if (zpid) {
1256
22
		if (wr)
1257
4
			dup2(fds[1], fd);
1258
		else
1259
18
			dup2(fds[0], fd);
1260
22
		close(fds[0]);
1261
22
		close(fds[1]);
1262
1263

22
		if (pmode == 0 || (act != EXTRACT && act != COPY)) {
1264
44
		    if (pledge("stdio rpath wpath cpath fattr dpath getpw proc tape flock rpath cpath wpath",
1265
22
			NULL) == -1)
1266
				err(1, "pledge");
1267
		}
1268
	} else {
1269
		if (wr) {
1270
			dup2(fds[0], STDIN_FILENO);
1271
			dup2(fd, STDOUT_FILENO);
1272
			gzip_flags = "-c";
1273
		} else {
1274
			dup2(fds[1], STDOUT_FILENO);
1275
			dup2(fd, STDIN_FILENO);
1276
			gzip_flags = "-dc";
1277
		}
1278
		close(fds[0]);
1279
		close(fds[1]);
1280
1281
		/* System compressors are more likely to use pledge(2) */
1282
		putenv("PATH=/usr/bin:/usr/local/bin");
1283
1284
		if (execlp(path, path, gzip_flags, (char *)NULL) < 0)
1285
			err(1, "could not exec %s", path);
1286
		/* NOTREACHED */
1287
	}
1288
22
}