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