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