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