bin/pax/ar_io.c

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