1 /* $OpenBSD: ar_io.c,v 1.64 2023/11/09 18:54:15 kn 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 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)) == -1) 115 syswarn(1, 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)) == -1) 124 syswarn(1, 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)) == -1) 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 if (arfd < 0) 147 return(-1); 148 149 if (chdname != NULL) 150 if (chdir(chdname) == -1) { 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) == -1) { 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 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, 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 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(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 int status; 299 300 if (arfd < 0) { 301 did_io = io_ok = flcnt = 0; 302 return; 303 } 304 if (!in_sig) 305 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 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 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 zpid = -1; 336 } 337 338 (void)close(arfd); 339 340 /* Do not exit before child to ensure data integrity */ 341 if (zpid > 0) { 342 waitpid(zpid, &status, 0); 343 if (!WIFEXITED(status) || WEXITSTATUS(status)) 344 exit_val = 1; 345 } 346 347 348 if (vflag && (artyp == ISTAPE)) { 349 (void)write(listfd, "done.\n", sizeof("done.\n")-1); 350 vfpart = 0; 351 } 352 arfd = -1; 353 354 if (!io_ok && !did_io) { 355 flcnt = 0; 356 return; 357 } 358 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 if (frmt != NULL) 365 ++arvol; 366 367 if (!vflag) { 368 flcnt = 0; 369 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 } 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 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 if ((artyp != ISPIPE) || (lstrval <= 0)) 423 return; 424 425 /* 426 * keep reading until pipe is drained 427 */ 428 while ((res = read(arfd, drbuf, sizeof(drbuf))) > 0) 429 continue; 430 lstrval = res; 431 } 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 wr_trail = 0; 453 454 /* 455 * Add any device dependent code as required here 456 */ 457 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 if (((cpos = lseek(arfd, 0, SEEK_CUR)) < 0) || 465 (ftruncate(arfd, cpos) == -1)) { 466 syswarn(1, errno, "Unable to truncate archive file"); 467 return(-1); 468 } 469 return(0); 470 } 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 if (artyp == ISPIPE) { 485 paxwarn(1, "Cannot append to an archive obtained from a pipe."); 486 return(-1); 487 } 488 489 if (!invld_rec) 490 return(0); 491 paxwarn(1,"Cannot append, device record size %d does not support %s spec", 492 rdblksz, argv0); 493 return(-1); 494 } 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 if (lstrval <= 0) 514 return(lstrval); 515 516 /* 517 * how we read must be based on device type 518 */ 519 switch (artyp) { 520 case ISTAPE: 521 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 if ((res = read(arfd, buf, cnt)) > 0) { 560 io_ok = 1; 561 return(res); 562 } 563 break; 564 } 565 566 /* 567 * We are in trouble at this point, something is broken... 568 */ 569 lstrval = res; 570 if (res < 0) 571 syswarn(1, errno, "Failed read on archive volume %d", arvol); 572 else 573 paxwarn(0, "End of archive volume %d reached", arvol); 574 return(res); 575 } 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 ssize_t 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 if (lstrval <= 0) 599 return(lstrval); 600 601 if ((res = write(arfd, buf, bsz)) == bsz) { 602 wr_trail = 1; 603 io_ok = 1; 604 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 == -1) 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)) == -1) 624 break; 625 cpos -= res; 626 if (ftruncate(arfd, cpos) == -1) 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 } 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) == -1) 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)) == -1) 760 break; 761 mpos = fsbz - (cpos % fsbz); 762 if (lseek(arfd, mpos, SEEK_CUR) == -1) 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 struct mtop mb; 856 int phyblk; 857 858 /* 859 * make sure we do not have try to reverse on a flawed archive 860 */ 861 if (lstrval < 0) 862 return(lstrval); 863 864 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 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 if ((cpos = lseek(arfd, 0, SEEK_CUR)) == -1) { 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 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 if (lseek(arfd, cpos, SEEK_SET) == -1) { 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) == -1) { 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 lstrval = 1; 969 return(0); 970 } 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 == -1) { 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) == -1) { 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) == -1) { 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 == -1) { 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) == -1) { 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) == -1) { 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 char buf[PAXPATHLEN+2]; 1100 static int freeit = 0; 1101 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 if (sigprocmask(SIG_BLOCK, &s_mask, &o_mask) == -1) 1109 syswarn(0, errno, "Unable to set signal mask"); 1110 ar_close(0); 1111 if (sigprocmask(SIG_SETMASK, &o_mask, NULL) == -1) 1112 syswarn(0, errno, "Unable to restore signal mask"); 1113 1114 if (done || !wr_trail || force_one_volume || op_mode == OP_TAR) 1115 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 } 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 int fds[2]; 1246 const char *gzip_flags; 1247 1248 if (pipe(fds) == -1) 1249 err(1, "could not pipe"); 1250 zpid = fork(); 1251 if (zpid == -1) 1252 err(1, "could not fork"); 1253 1254 /* parent */ 1255 if (zpid) { 1256 if (wr) 1257 dup2(fds[1], fd); 1258 else 1259 dup2(fds[0], fd); 1260 close(fds[0]); 1261 close(fds[1]); 1262 1263 if (pmode == 0 || (act != EXTRACT && act != COPY)) { 1264 if (act == LIST) { 1265 if (pledge("stdio rpath getpw proc tape", 1266 NULL) == -1) 1267 err(1, "pledge"); 1268 /* can not gzip while appending */ 1269 } else { 1270 if (pledge("stdio rpath wpath cpath fattr dpath getpw proc tape", 1271 NULL) == -1) 1272 err(1, "pledge"); 1273 } 1274 } 1275 } else { 1276 if (wr) { 1277 dup2(fds[0], STDIN_FILENO); 1278 dup2(fd, STDOUT_FILENO); 1279 gzip_flags = "-c"; 1280 } else { 1281 dup2(fds[1], STDOUT_FILENO); 1282 dup2(fd, STDIN_FILENO); 1283 gzip_flags = "-dc"; 1284 } 1285 close(fds[0]); 1286 close(fds[1]); 1287 1288 /* System compressors are more likely to use pledge(2) */ 1289 putenv("PATH=/usr/bin:/usr/local/bin"); 1290 1291 if (execlp(path, path, gzip_flags, (char *)NULL) == -1) 1292 err(1, "could not exec %s", path); 1293 /* NOTREACHED */ 1294 } 1295 } 1296