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