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