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. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed by the University of 20 * California, Berkeley and its contributors. 21 * 4. Neither the name of the University nor the names of its contributors 22 * may be used to endorse or promote products derived from this software 23 * without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 35 * SUCH DAMAGE. 36 * 37 * @(#)ar_io.c 8.2 (Berkeley) 4/18/94 38 * $FreeBSD: src/bin/pax/ar_io.c,v 1.12.2.1 2001/08/01 05:03:11 obrien Exp $ 39 * $DragonFly: src/bin/pax/ar_io.c,v 1.11 2006/09/27 21:58:08 pavalos Exp $ 40 */ 41 42 #include <sys/types.h> 43 #include <sys/ioctl.h> 44 #include <sys/mtio.h> 45 #include <sys/stat.h> 46 #include <sys/wait.h> 47 #include <err.h> 48 #include <errno.h> 49 #include <fcntl.h> 50 #include <signal.h> 51 #include <stdio.h> 52 #include <string.h> 53 #include <stdlib.h> 54 #include <unistd.h> 55 #include "pax.h" 56 #include "options.h" 57 #include "extern.h" 58 59 /* 60 * Routines which deal directly with the archive I/O device/file. 61 */ 62 63 #define DMOD 0666 /* default mode of created archives */ 64 #define EXT_MODE O_RDONLY /* open mode for list/extract */ 65 #define AR_MODE (O_WRONLY | O_CREAT | O_TRUNC) /* mode for archive */ 66 #define APP_MODE O_RDWR /* mode for append */ 67 #define STDO "<STDOUT>" /* pseudo name for stdout */ 68 #define STDN "<STDIN>" /* pseudo name for stdin */ 69 static int arfd = -1; /* archive file descriptor */ 70 static int artyp = ISREG; /* archive type: file/FIFO/tape */ 71 static int arvol = 1; /* archive volume number */ 72 static int lstrval = -1; /* return value from last i/o */ 73 static int io_ok; /* i/o worked on volume after resync */ 74 static int did_io; /* did i/o ever occur on volume? */ 75 static int done; /* set via tty termination */ 76 static struct stat arsb; /* stat of archive device at open */ 77 static int invld_rec; /* tape has out of spec record size */ 78 static int wr_trail = 1; /* trailer was rewritten in append */ 79 static int can_unlnk = 0; /* do we unlink null archives? */ 80 char *arcname; /* printable name of archive */ 81 const char *gzip_program; /* name of gzip program */ 82 static pid_t zpid = -1; /* pid of child process */ 83 84 static int get_phys (void); 85 extern sigset_t s_mask; 86 static void ar_start_gzip (int, const char *, int); 87 88 /* 89 * ar_open() 90 * Opens the next archive volume. Determines the type of the device and 91 * sets up block sizes as required by the archive device and the format. 92 * Note: we may be called with name == NULL on the first open only. 93 * Return: 94 * -1 on failure, 0 otherwise 95 */ 96 97 int 98 ar_open(char *name) 99 { 100 struct mtget mb; 101 102 if (arfd != -1) 103 close(arfd); 104 arfd = -1; 105 can_unlnk = did_io = io_ok = invld_rec = 0; 106 artyp = ISREG; 107 flcnt = 0; 108 109 /* 110 * open based on overall operation mode 111 */ 112 switch (act) { 113 case LIST: 114 case EXTRACT: 115 if (name == NULL) { 116 arfd = STDIN_FILENO; 117 arcname = STDN; 118 } else if ((arfd = open(name, EXT_MODE, DMOD)) < 0) 119 syswarn(0, errno, "Failed open to read on %s", name); 120 if (arfd != -1 && gzip_program != NULL) 121 ar_start_gzip(arfd, gzip_program, 0); 122 break; 123 case ARCHIVE: 124 if (name == NULL) { 125 arfd = STDOUT_FILENO; 126 arcname = STDO; 127 } else if ((arfd = open(name, AR_MODE, DMOD)) < 0) 128 syswarn(0, errno, "Failed open to write on %s", name); 129 else 130 can_unlnk = 1; 131 if (arfd != -1 && gzip_program != NULL) 132 ar_start_gzip(arfd, gzip_program, 1); 133 break; 134 case APPND: 135 if (name == NULL) { 136 arfd = STDOUT_FILENO; 137 arcname = STDO; 138 } else if ((arfd = open(name, APP_MODE, DMOD)) < 0) 139 syswarn(0, errno, "Failed open to read/write on %s", 140 name); 141 break; 142 case COPY: 143 /* 144 * arfd not used in COPY mode 145 */ 146 arcname = "<NONE>"; 147 lstrval = 1; 148 return(0); 149 } 150 if (arfd < 0) 151 return(-1); 152 153 if (chdname != NULL) { 154 if (chdir(chdname) != 0) { 155 syswarn(1, errno, "Failed chdir to %s", chdname); 156 return(-1); 157 } 158 } 159 /* 160 * set up is based on device type 161 */ 162 if (fstat(arfd, &arsb) < 0) { 163 syswarn(0, errno, "Failed stat on %s", arcname); 164 close(arfd); 165 arfd = -1; 166 can_unlnk = 0; 167 return(-1); 168 } 169 if (S_ISDIR(arsb.st_mode)) { 170 paxwarn(0, "Cannot write an archive on top of a directory %s", 171 arcname); 172 close(arfd); 173 arfd = -1; 174 can_unlnk = 0; 175 return(-1); 176 } 177 178 if (S_ISCHR(arsb.st_mode)) 179 artyp = ioctl(arfd, MTIOCGET, &mb) ? ISCHR : ISTAPE; 180 else if (S_ISBLK(arsb.st_mode)) 181 artyp = ISBLK; 182 else if ((lseek(arfd, (off_t)0L, SEEK_CUR) == -1) && (errno == ESPIPE)) 183 artyp = ISPIPE; 184 else 185 artyp = ISREG; 186 187 /* 188 * make sure we beyond any doubt that we only can unlink regular files 189 * we created 190 */ 191 if (artyp != ISREG) 192 can_unlnk = 0; 193 /* 194 * if we are writing, we are done 195 */ 196 if (act == ARCHIVE) { 197 blksz = rdblksz = wrblksz; 198 lstrval = 1; 199 return(0); 200 } 201 202 /* 203 * set default blksz on read. APPNDs writes rdblksz on the last volume 204 * On all new archive volumes, we shift to wrblksz (if the user 205 * specified one, otherwise we will continue to use rdblksz). We 206 * must set blocksize based on what kind of device the archive is 207 * stored. 208 */ 209 switch(artyp) { 210 case ISTAPE: 211 /* 212 * Tape drives come in at least two flavors. Those that support 213 * variable sized records and those that have fixed sized 214 * records. They must be treated differently. For tape drives 215 * that support variable sized records, we must make large 216 * reads to make sure we get the entire record, otherwise we 217 * will just get the first part of the record (up to size we 218 * asked). Tapes with fixed sized records may or may not return 219 * multiple records in a single read. We really do not care 220 * what the physical record size is UNLESS we are going to 221 * append. (We will need the physical block size to rewrite 222 * the trailer). Only when we are appending do we go to the 223 * effort to figure out the true PHYSICAL record size. 224 */ 225 blksz = rdblksz = MAXBLK; 226 break; 227 case ISPIPE: 228 case ISBLK: 229 case ISCHR: 230 /* 231 * Blocksize is not a major issue with these devices (but must 232 * be kept a multiple of 512). If the user specified a write 233 * block size, we use that to read. Under append, we must 234 * always keep blksz == rdblksz. Otherwise we go ahead and use 235 * the device optimal blocksize as (and if) returned by stat 236 * and if it is within pax specs. 237 */ 238 if ((act == APPND) && wrblksz) { 239 blksz = rdblksz = wrblksz; 240 break; 241 } 242 243 if ((arsb.st_blksize > 0) && (arsb.st_blksize < MAXBLK) && 244 ((arsb.st_blksize % BLKMULT) == 0)) 245 rdblksz = arsb.st_blksize; 246 else 247 rdblksz = DEVBLK; 248 /* 249 * For performance go for large reads when we can without harm 250 */ 251 if ((act == APPND) || (artyp == ISCHR)) 252 blksz = rdblksz; 253 else 254 blksz = MAXBLK; 255 break; 256 case ISREG: 257 /* 258 * if the user specified wrblksz works, use it. Under appends 259 * we must always keep blksz == rdblksz 260 */ 261 if ((act == APPND) && wrblksz && ((arsb.st_size%wrblksz)==0)){ 262 blksz = rdblksz = wrblksz; 263 break; 264 } 265 /* 266 * See if we can find the blocking factor from the file size 267 */ 268 for (rdblksz = MAXBLK; rdblksz > 0; rdblksz -= BLKMULT) 269 if ((arsb.st_size % rdblksz) == 0) 270 break; 271 /* 272 * When we cannot find a match, we may have a flawed archive. 273 */ 274 if (rdblksz <= 0) 275 rdblksz = FILEBLK; 276 /* 277 * for performance go for large reads when we can 278 */ 279 if (act == APPND) 280 blksz = rdblksz; 281 else 282 blksz = MAXBLK; 283 break; 284 default: 285 /* 286 * should never happen, worst case, slow... 287 */ 288 blksz = rdblksz = BLKMULT; 289 break; 290 } 291 lstrval = 1; 292 return(0); 293 } 294 295 /* 296 * ar_close() 297 * closes archive device, increments volume number, and prints i/o summary 298 */ 299 void 300 ar_close(void) 301 { 302 int status; 303 304 if (arfd < 0) { 305 did_io = io_ok = flcnt = 0; 306 return; 307 } 308 309 /* 310 * Close archive file. This may take a LONG while on tapes (we may be 311 * forced to wait for the rewind to complete) so tell the user what is 312 * going on (this avoids the user hitting control-c thinking pax is 313 * broken). 314 */ 315 if (vflag && (artyp == ISTAPE)) { 316 if (vfpart) 317 putc('\n', listf); 318 fprintf(listf, 319 "%s: Waiting for tape drive close to complete...", 320 argv0); 321 fflush(listf); 322 } 323 324 /* 325 * if nothing was written to the archive (and we created it), we remove 326 * it 327 */ 328 if (can_unlnk && (fstat(arfd, &arsb) == 0) && (S_ISREG(arsb.st_mode)) && 329 (arsb.st_size == 0)) { 330 unlink(arcname); 331 can_unlnk = 0; 332 } 333 334 /* 335 * for a quick extract/list, pax frequently exits before the child 336 * process is done 337 */ 338 if ((act == LIST || act == EXTRACT) && nflag && zpid > 0) 339 kill(zpid, SIGINT); 340 341 close(arfd); 342 343 /* Do not exit before child to ensure data integrity */ 344 if (zpid > 0) 345 waitpid(zpid, &status, 0); 346 347 if (vflag && (artyp == ISTAPE)) { 348 fputs("done.\n", listf); 349 vfpart = 0; 350 fflush(listf); 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 putc('\n', listf); 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 fprintf(listf, "%s: unknown format, %jd bytes skipped.\n", 387 argv0, (intmax_t)rdcnt); 388 fflush(listf); 389 flcnt = 0; 390 return; 391 } 392 393 if (strcmp(NM_CPIO, argv0) == 0) 394 fprintf(listf, "%jdu blocks\n", (intmax_t)((rdcnt ? rdcnt : wrcnt) / 5120)); 395 else if (strcmp(NM_TAR, argv0) != 0) 396 fprintf(listf, 397 "%s: %s vol %d, %lu files, %jd bytes read, %jd bytes written.\n", 398 argv0, frmt->name, arvol-1, flcnt, 399 (intmax_t)rdcnt, (intmax_t)wrcnt); 400 fflush(listf); 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 ; 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, (off_t)0L, SEEK_CUR)) < 0) || 465 (ftruncate(arfd, cpos) < 0)) { 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 int res; 592 off_t cpos; 593 594 /* 595 * do not allow pax to create a "bad" archive. Once a write fails on 596 * an archive volume prevent further writes to it. 597 */ 598 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 < 0) 611 lstrval = res; 612 else 613 lstrval = 0; 614 615 switch (artyp) { 616 case ISREG: 617 if ((res > 0) && (res % BLKMULT)) { 618 /* 619 * try to fix up partial writes which are not BLKMULT 620 * in size by forcing the runt record to next archive 621 * volume 622 */ 623 if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0) 624 break; 625 cpos -= (off_t)res; 626 if (ftruncate(arfd, cpos) < 0) 627 break; 628 res = lstrval = 0; 629 break; 630 } 631 if (res >= 0) 632 break; 633 /* 634 * if file is out of space, handle it like a return of 0 635 */ 636 if ((errno == ENOSPC) || (errno == EFBIG) || (errno == EDQUOT)) 637 res = lstrval = 0; 638 break; 639 case ISTAPE: 640 case ISCHR: 641 case ISBLK: 642 if (res >= 0) 643 break; 644 if (errno == EACCES) { 645 paxwarn(0, "Write failed, archive is write protected."); 646 res = lstrval = 0; 647 return(0); 648 } 649 /* 650 * see if we reached the end of media, if so force a change to 651 * the next volume 652 */ 653 if ((errno == ENOSPC) || (errno == EIO) || (errno == ENXIO)) 654 res = lstrval = 0; 655 break; 656 case ISPIPE: 657 default: 658 /* 659 * we cannot fix errors to these devices 660 */ 661 break; 662 } 663 664 /* 665 * Better tell the user the bad news... 666 * if this is a block aligned archive format, we may have a bad archive 667 * if the format wants the header to start at a BLKMULT boundary. While 668 * we can deal with the mis-aligned data, it violates spec and other 669 * archive readers will likely fail. if the format is not block 670 * aligned, the user may be lucky (and the archive is ok). 671 */ 672 if (res >= 0) { 673 if (res > 0) 674 wr_trail = 1; 675 io_ok = 1; 676 } 677 678 /* 679 * If we were trying to rewrite the trailer and it didn't work, we 680 * must quit right away. 681 */ 682 if (!wr_trail && (res <= 0)) { 683 paxwarn(1,"Unable to append, trailer re-write failed. Quitting."); 684 return(res); 685 } 686 687 if (res == 0) 688 paxwarn(0, "End of archive volume %d reached", arvol); 689 else if (res < 0) 690 syswarn(1, errno, "Failed write to archive volume: %d", arvol); 691 else if (!frmt->blkalgn || ((res % frmt->blkalgn) == 0)) 692 paxwarn(0,"WARNING: partial archive write. Archive MAY BE FLAWED"); 693 else 694 paxwarn(1,"WARNING: partial archive write. Archive IS FLAWED"); 695 return(res); 696 } 697 698 /* 699 * ar_rdsync() 700 * Try to move past a bad spot on a flawed archive as needed to continue 701 * I/O. Clears error flags to allow I/O to continue. 702 * Return: 703 * 0 when ok to try i/o again, -1 otherwise. 704 */ 705 706 int 707 ar_rdsync(void) 708 { 709 long fsbz; 710 off_t cpos; 711 off_t mpos; 712 struct mtop mb; 713 714 /* 715 * Fail resync attempts at user request (done) or if this is going to be 716 * an update/append to a existing archive. if last i/o hit media end, 717 * we need to go to the next volume not try a resync 718 */ 719 if ((done > 0) || (lstrval == 0)) 720 return(-1); 721 722 if ((act == APPND) || (act == ARCHIVE)) { 723 paxwarn(1, "Cannot allow updates to an archive with flaws."); 724 return(-1); 725 } 726 if (io_ok) 727 did_io = 1; 728 729 switch(artyp) { 730 case ISTAPE: 731 /* 732 * if the last i/o was a successful data transfer, we assume 733 * the fault is just a bad record on the tape that we are now 734 * past. If we did not get any data since the last resync try 735 * to move the tape forward one PHYSICAL record past any 736 * damaged tape section. Some tape drives are stubborn and need 737 * to be pushed. 738 */ 739 if (io_ok) { 740 io_ok = 0; 741 lstrval = 1; 742 break; 743 } 744 mb.mt_op = MTFSR; 745 mb.mt_count = 1; 746 if (ioctl(arfd, MTIOCTOP, &mb) < 0) 747 break; 748 lstrval = 1; 749 break; 750 case ISREG: 751 case ISCHR: 752 case ISBLK: 753 /* 754 * try to step over the bad part of the device. 755 */ 756 io_ok = 0; 757 if (((fsbz = arsb.st_blksize) <= 0) || (artyp != ISREG)) 758 fsbz = BLKMULT; 759 if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0) 760 break; 761 mpos = fsbz - (cpos % (off_t)fsbz); 762 if (lseek(arfd, mpos, SEEK_CUR) < 0) 763 break; 764 lstrval = 1; 765 break; 766 case ISPIPE: 767 default: 768 /* 769 * cannot recover on these archive device types 770 */ 771 io_ok = 0; 772 break; 773 } 774 if (lstrval <= 0) { 775 paxwarn(1, "Unable to recover from an archive read failure."); 776 return(-1); 777 } 778 paxwarn(0, "Attempting to recover from an archive read failure."); 779 return(0); 780 } 781 782 /* 783 * ar_fow() 784 * Move the I/O position within the archive forward the specified number of 785 * bytes as supported by the device. If we cannot move the requested 786 * number of bytes, return the actual number of bytes moved in skipped. 787 * Return: 788 * 0 if moved the requested distance, -1 on complete failure, 1 on 789 * partial move (the amount moved is in skipped) 790 */ 791 792 int 793 ar_fow(off_t sksz, off_t *skipped) 794 { 795 off_t cpos; 796 off_t mpos; 797 798 *skipped = 0; 799 if (sksz <= 0) 800 return(0); 801 802 /* 803 * we cannot move forward at EOF or error 804 */ 805 if (lstrval <= 0) 806 return(lstrval); 807 808 /* 809 * Safer to read forward on devices where it is hard to find the end of 810 * the media without reading to it. With tapes we cannot be sure of the 811 * number of physical blocks to skip (we do not know physical block 812 * size at this point), so we must only read forward on tapes! 813 */ 814 if (artyp != ISREG) 815 return(0); 816 817 /* 818 * figure out where we are in the archive 819 */ 820 if ((cpos = lseek(arfd, (off_t)0L, 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, (off_t)0L, SEEK_CUR)) < 0) { 889 syswarn(1, errno, 890 "Unable to obtain current archive byte offset"); 891 lstrval = -1; 892 return(-1); 893 } 894 895 /* 896 * we may try to go backwards past the start when the archive 897 * is only a single record. If this happens and we are on a 898 * multi-volume archive, we need to go to the end of the 899 * previous volume and continue our movement backwards from 900 * there. 901 */ 902 if ((cpos -= sksz) < (off_t)0L) { 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 = (off_t)0L; 912 } 913 if (lseek(arfd, cpos, SEEK_SET) < 0) { 914 syswarn(1, errno, "Unable to seek archive backwards"); 915 lstrval = -1; 916 return(-1); 917 } 918 break; 919 case ISTAPE: 920 /* 921 * Calculate and move the proper number of PHYSICAL tape 922 * blocks. If the sksz is not an even multiple of the physical 923 * tape size, we cannot do the move (this should never happen). 924 * (We also cannot handle trailers spread over two vols.) 925 * get_phys() also makes sure we are in front of the filemark. 926 */ 927 if ((phyblk = get_phys()) <= 0) { 928 lstrval = -1; 929 return(-1); 930 } 931 932 /* 933 * make sure future tape reads only go by physical tape block 934 * size (set rdblksz to the real size). 935 */ 936 rdblksz = phyblk; 937 938 /* 939 * if no movement is required, just return (we must be after 940 * get_phys() so the physical blocksize is properly set) 941 */ 942 if (sksz <= 0) 943 break; 944 945 /* 946 * ok we have to move. Make sure the tape drive can do it. 947 */ 948 if (sksz % phyblk) { 949 paxwarn(1, 950 "Tape drive unable to backspace requested amount"); 951 lstrval = -1; 952 return(-1); 953 } 954 955 /* 956 * move backwards the requested number of bytes 957 */ 958 mb.mt_op = MTBSR; 959 mb.mt_count = sksz/phyblk; 960 if (ioctl(arfd, MTIOCTOP, &mb) < 0) { 961 syswarn(1,errno, "Unable to backspace tape %d blocks.", 962 mb.mt_count); 963 lstrval = -1; 964 return(-1); 965 } 966 break; 967 } 968 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 < 0) { 1004 syswarn(1, errno, "Unable to locate tape filemark."); 1005 return(-1); 1006 } 1007 } 1008 1009 /* 1010 * move backwards over the file mark so we are at the end of the 1011 * last record. 1012 */ 1013 mb.mt_op = MTBSF; 1014 mb.mt_count = 1; 1015 if (ioctl(arfd, MTIOCTOP, &mb) < 0) { 1016 syswarn(1, errno, "Unable to backspace over tape filemark."); 1017 return(-1); 1018 } 1019 1020 /* 1021 * move backwards so we are in front of the last record and read it to 1022 * get physical tape blocksize. 1023 */ 1024 mb.mt_op = MTBSR; 1025 mb.mt_count = 1; 1026 if (ioctl(arfd, MTIOCTOP, &mb) < 0) { 1027 syswarn(1, errno, "Unable to backspace over last tape block."); 1028 return(-1); 1029 } 1030 if ((phyblk = read(arfd, scbuf, sizeof(scbuf))) <= 0) { 1031 syswarn(1, errno, "Cannot determine archive tape blocksize."); 1032 return(-1); 1033 } 1034 1035 /* 1036 * read forward to the file mark, then back up in front of the filemark 1037 * (this is a bit paranoid, but should be safe to do). 1038 */ 1039 while ((res = read(arfd, scbuf, sizeof(scbuf))) > 0) 1040 ; 1041 if (res < 0) { 1042 syswarn(1, errno, "Unable to locate tape filemark."); 1043 return(-1); 1044 } 1045 mb.mt_op = MTBSF; 1046 mb.mt_count = 1; 1047 if (ioctl(arfd, MTIOCTOP, &mb) < 0) { 1048 syswarn(1, errno, "Unable to backspace over tape filemark."); 1049 return(-1); 1050 } 1051 1052 /* 1053 * set lstrval so we know that the filemark has not been seen 1054 */ 1055 lstrval = 1; 1056 1057 /* 1058 * return if there was no padding 1059 */ 1060 if (padsz == 0) 1061 return(phyblk); 1062 1063 /* 1064 * make sure we can move backwards over the padding. (this should 1065 * never fail). 1066 */ 1067 if (padsz % phyblk) { 1068 paxwarn(1, "Tape drive unable to backspace requested amount"); 1069 return(-1); 1070 } 1071 1072 /* 1073 * move backwards over the padding so the head is where it was when 1074 * we were first called (if required). 1075 */ 1076 mb.mt_op = MTBSR; 1077 mb.mt_count = padsz/phyblk; 1078 if (ioctl(arfd, MTIOCTOP, &mb) < 0) { 1079 syswarn(1,errno,"Unable to backspace tape over %d pad blocks", 1080 mb.mt_count); 1081 return(-1); 1082 } 1083 return(phyblk); 1084 } 1085 1086 /* 1087 * ar_next() 1088 * prompts the user for the next volume in this archive. For some devices 1089 * we may allow the media to be changed. Otherwise a new archive is 1090 * prompted for. By pax spec, if there is no controlling tty or an eof is 1091 * read on tty input, we must quit pax. 1092 * Return: 1093 * 0 when ready to continue, -1 when all done 1094 */ 1095 1096 int 1097 ar_next(void) 1098 { 1099 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) < 0) 1109 syswarn(0, errno, "Unable to set signal mask"); 1110 ar_close(); 1111 if (sigprocmask(SIG_SETMASK, &o_mask, NULL) < 0) 1112 syswarn(0, errno, "Unable to restore signal mask"); 1113 1114 if (done || !wr_trail || strcmp(NM_TAR, argv0) == 0) 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(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 *gzip_program, int wr) 1244 { 1245 int fds[2]; 1246 char *gzip_flags; 1247 1248 if (pipe(fds) < 0) 1249 err(1, "could not pipe"); 1250 zpid = fork(); 1251 if (zpid < 0) 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 } else { 1263 if (wr) { 1264 dup2(fds[0], STDIN_FILENO); 1265 dup2(fd, STDOUT_FILENO); 1266 gzip_flags = "-c"; 1267 } else { 1268 dup2(fds[1], STDOUT_FILENO); 1269 dup2(fd, STDIN_FILENO); 1270 gzip_flags = "-dc"; 1271 } 1272 close(fds[0]); 1273 close(fds[1]); 1274 if (execlp(gzip_program, gzip_program, gzip_flags, 1275 (char *)NULL) < 0) 1276 err(1, "could not exec"); 1277 /* NOTREACHED */ 1278 } 1279 } 1280