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