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