buf_subs.c revision 1.22
1/* $NetBSD: buf_subs.c,v 1.22 2003/10/13 07:41:22 agc Exp $ */ 2 3/*- 4 * Copyright (c) 1992 Keith Muller. 5 * Copyright (c) 1992, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * This code is derived from software contributed to Berkeley by 9 * Keith Muller of the University of California, San Diego. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36#include <sys/cdefs.h> 37#if defined(__RCSID) && !defined(lint) 38#if 0 39static char sccsid[] = "@(#)buf_subs.c 8.2 (Berkeley) 4/18/94"; 40#else 41__RCSID("$NetBSD: buf_subs.c,v 1.22 2003/10/13 07:41:22 agc Exp $"); 42#endif 43#endif /* not lint */ 44 45#include <sys/types.h> 46#include <sys/time.h> 47#include <sys/stat.h> 48#include <sys/param.h> 49#include <stdio.h> 50#include <ctype.h> 51#include <errno.h> 52#include <unistd.h> 53#include <stdlib.h> 54#include <string.h> 55#include "pax.h" 56#include "extern.h" 57 58/* 59 * routines which implement archive and file buffering 60 */ 61 62#define MINFBSZ 512 /* default block size for hole detect */ 63#define MAXFLT 10 /* default media read error limit */ 64 65/* 66 * Need to change bufmem to dynamic allocation when the upper 67 * limit on blocking size is removed (though that will violate pax spec) 68 * MAXBLK define and tests will also need to be updated. 69 */ 70static char bufmem[MAXBLK+BLKMULT]; /* i/o buffer + pushback id space */ 71static char *buf; /* normal start of i/o buffer */ 72static char *bufend; /* end or last char in i/o buffer */ 73static char *bufpt; /* read/write point in i/o buffer */ 74int blksz = MAXBLK; /* block input/output size in bytes */ 75int wrblksz; /* user spec output size in bytes */ 76int maxflt = MAXFLT; /* MAX consecutive media errors */ 77int rdblksz; /* first read blksize (tapes only) */ 78off_t wrlimit; /* # of bytes written per archive vol */ 79off_t wrcnt; /* # of bytes written on current vol */ 80off_t rdcnt; /* # of bytes read on current vol */ 81 82/* 83 * wr_start() 84 * set up the buffering system to operate in a write mode 85 * Return: 86 * 0 if ok, -1 if the user specified write block size violates pax spec 87 */ 88 89int 90wr_start(void) 91{ 92 buf = &(bufmem[BLKMULT]); 93 /* 94 * Check to make sure the write block size meets pax specs. If the user 95 * does not specify a blocksize, we use the format default blocksize. 96 * We must be picky on writes, so we do not allow the user to create an 97 * archive that might be hard to read elsewhere. If all ok, we then 98 * open the first archive volume 99 */ 100 if (!wrblksz) 101 wrblksz = frmt->bsz; 102 if (wrblksz > MAXBLK) { 103 tty_warn(1, "Write block size of %d too large, maximum is: %d", 104 wrblksz, MAXBLK); 105 return(-1); 106 } 107 if (wrblksz % BLKMULT) { 108 tty_warn(1, "Write block size of %d is not a %d byte multiple", 109 wrblksz, BLKMULT); 110 return(-1); 111 } 112 113 /* 114 * we only allow wrblksz to be used with all archive operations 115 */ 116 blksz = rdblksz = wrblksz; 117 if ((ar_open(arcname) < 0) && (ar_next() < 0)) 118 return(-1); 119 wrcnt = 0; 120 bufend = buf + wrblksz; 121 bufpt = buf; 122 return(0); 123} 124 125/* 126 * rd_start() 127 * set up buffering system to read an archive 128 * Return: 129 * 0 if ok, -1 otherwise 130 */ 131 132int 133rd_start(void) 134{ 135 /* 136 * leave space for the header pushback (see get_arc()). If we are 137 * going to append and user specified a write block size, check it 138 * right away 139 */ 140 buf = &(bufmem[BLKMULT]); 141 if ((act == APPND) && wrblksz) { 142 if (wrblksz > MAXBLK) { 143 tty_warn(1, 144 "Write block size %d too large, maximum is: %d", 145 wrblksz, MAXBLK); 146 return(-1); 147 } 148 if (wrblksz % BLKMULT) { 149 tty_warn(1, 150 "Write block size %d is not a %d byte multiple", 151 wrblksz, BLKMULT); 152 return(-1); 153 } 154 } 155 156 /* 157 * open the archive 158 */ 159 if ((ar_open(arcname) < 0) && (ar_next() < 0)) 160 return(-1); 161 bufend = buf + rdblksz; 162 bufpt = bufend; 163 rdcnt = 0; 164 return(0); 165} 166 167/* 168 * cp_start() 169 * set up buffer system for copying within the file system 170 */ 171 172void 173cp_start(void) 174{ 175 buf = &(bufmem[BLKMULT]); 176 rdblksz = blksz = MAXBLK; 177} 178 179/* 180 * appnd_start() 181 * Set up the buffering system to append new members to an archive that 182 * was just read. The last block(s) of an archive may contain a format 183 * specific trailer. To append a new member, this trailer has to be 184 * removed from the archive. The first byte of the trailer is replaced by 185 * the start of the header of the first file added to the archive. The 186 * format specific end read function tells us how many bytes to move 187 * backwards in the archive to be positioned BEFORE the trailer. Two 188 * different positions have to be adjusted, the O.S. file offset (e.g. the 189 * position of the tape head) and the write point within the data we have 190 * stored in the read (soon to become write) buffer. We may have to move 191 * back several records (the number depends on the size of the archive 192 * record and the size of the format trailer) to read up the record where 193 * the first byte of the trailer is recorded. Trailers may span (and 194 * overlap) record boundaries. 195 * We first calculate which record has the first byte of the trailer. We 196 * move the OS file offset back to the start of this record and read it 197 * up. We set the buffer write pointer to be at this byte (the byte where 198 * the trailer starts). We then move the OS file pointer back to the 199 * start of this record so a flush of this buffer will replace the record 200 * in the archive. 201 * A major problem is rewriting this last record. For archives stored 202 * on disk files, this is trivial. However, many devices are really picky 203 * about the conditions under which they will allow a write to occur. 204 * Often devices restrict the conditions where writes can be made, 205 * so it may not be feasable to append archives stored on all types of 206 * devices. 207 * Return: 208 * 0 for success, -1 for failure 209 */ 210 211int 212appnd_start(off_t skcnt) 213{ 214 int res; 215 off_t cnt; 216 217 if (exit_val != 0) { 218 tty_warn(0, "Cannot append to an archive that may have flaws."); 219 return(-1); 220 } 221 /* 222 * if the user did not specify a write blocksize, inherit the size used 223 * in the last archive volume read. (If a is set we still use rdblksz 224 * until next volume, cannot shift sizes within a single volume). 225 */ 226 if (!wrblksz) 227 wrblksz = blksz = rdblksz; 228 else 229 blksz = rdblksz; 230 231 /* 232 * make sure that this volume allows appends 233 */ 234 if (ar_app_ok() < 0) 235 return(-1); 236 237 /* 238 * Calculate bytes to move back and move in front of record where we 239 * need to start writing from. Remember we have to add in any padding 240 * that might be in the buffer after the trailer in the last block. We 241 * travel skcnt + padding ROUNDED UP to blksize. 242 */ 243 skcnt += bufend - bufpt; 244 if ((cnt = (skcnt/blksz) * blksz) < skcnt) 245 cnt += blksz; 246 if (ar_rev((off_t)cnt) < 0) 247 goto out; 248 249 /* 250 * We may have gone too far if there is valid data in the block we are 251 * now in front of, read up the block and position the pointer after 252 * the valid data. 253 */ 254 if ((cnt -= skcnt) > 0) { 255 /* 256 * watch out for stupid tape drives. ar_rev() will set rdblksz 257 * to be real physical blocksize so we must loop until we get 258 * the old rdblksz (now in blksz). If ar_rev() fouls up the 259 * determination of the physical block size, we will fail. 260 */ 261 bufpt = buf; 262 bufend = buf + blksz; 263 while (bufpt < bufend) { 264 if ((res = ar_read(bufpt, rdblksz)) <= 0) 265 goto out; 266 bufpt += res; 267 } 268 if (ar_rev((off_t)(bufpt - buf)) < 0) 269 goto out; 270 bufpt = buf + cnt; 271 bufend = buf + blksz; 272 } else { 273 /* 274 * buffer is empty 275 */ 276 bufend = buf + blksz; 277 bufpt = buf; 278 } 279 rdblksz = blksz; 280 rdcnt -= skcnt; 281 wrcnt = 0; 282 283 /* 284 * At this point we are ready to write. If the device requires special 285 * handling to write at a point were previously recorded data resides, 286 * that is handled in ar_set_wr(). From now on we operate under normal 287 * ARCHIVE mode (write) conditions 288 */ 289 if (ar_set_wr() < 0) 290 return(-1); 291 act = ARCHIVE; 292 return(0); 293 294 out: 295 tty_warn(1, "Unable to rewrite archive trailer, cannot append."); 296 return(-1); 297} 298 299/* 300 * rd_sync() 301 * A read error occurred on this archive volume. Resync the buffer and 302 * try to reset the device (if possible) so we can continue to read. Keep 303 * trying to do this until we get a valid read, or we reach the limit on 304 * consecutive read faults (at which point we give up). The user can 305 * adjust the read error limit through a command line option. 306 * Returns: 307 * 0 on success, and -1 on failure 308 */ 309 310int 311rd_sync(void) 312{ 313 int errcnt = 0; 314 int res; 315 316 /* 317 * if the user says bail out on first fault, we are out of here... 318 */ 319 if (maxflt == 0) 320 return(-1); 321 if (act == APPND) { 322 tty_warn(1, 323 "Unable to append when there are archive read errors."); 324 return(-1); 325 } 326 327 /* 328 * poke at device and try to get past media error 329 */ 330 if (ar_rdsync() < 0) { 331 if (ar_next() < 0) 332 return(-1); 333 else 334 rdcnt = 0; 335 } 336 337 for (;;) { 338 if ((res = ar_read(buf, blksz)) > 0) { 339 /* 340 * All right! got some data, fill that buffer 341 */ 342 bufpt = buf; 343 bufend = buf + res; 344 rdcnt += res; 345 return(0); 346 } 347 348 /* 349 * Oh well, yet another failed read... 350 * if error limit reached, ditch. otherwise poke device to move past 351 * bad media and try again. if media is badly damaged, we ask 352 * the poor (and upset user at this point) for the next archive 353 * volume. remember the goal on reads is to get the most we 354 * can extract out of the archive. 355 */ 356 if ((maxflt > 0) && (++errcnt > maxflt)) 357 tty_warn(0, 358 "Archive read error limit (%d) reached",maxflt); 359 else if (ar_rdsync() == 0) 360 continue; 361 if (ar_next() < 0) 362 break; 363 rdcnt = 0; 364 errcnt = 0; 365 } 366 return(-1); 367} 368 369/* 370 * pback() 371 * push the data used during the archive id phase back into the I/O 372 * buffer. This is required as we cannot be sure that the header does NOT 373 * overlap a block boundary (as in the case we are trying to recover a 374 * flawed archived). This was not designed to be used for any other 375 * purpose. (What software engineering, HA!) 376 * WARNING: do not even THINK of pback greater than BLKMULT, unless the 377 * pback space is increased. 378 */ 379 380void 381pback(char *pt, int cnt) 382{ 383 bufpt -= cnt; 384 memcpy(bufpt, pt, cnt); 385 return; 386} 387 388/* 389 * rd_skip() 390 * skip forward in the archive during a archive read. Used to get quickly 391 * past file data and padding for files the user did NOT select. 392 * Return: 393 * 0 if ok, -1 failure, and 1 when EOF on the archive volume was detected. 394 */ 395 396int 397rd_skip(off_t skcnt) 398{ 399 off_t res; 400 off_t cnt; 401 off_t skipped = 0; 402 403 /* 404 * consume what data we have in the buffer. If we have to move forward 405 * whole records, we call the low level skip function to see if we can 406 * move within the archive without doing the expensive reads on data we 407 * do not want. 408 */ 409 if (skcnt == 0) 410 return(0); 411 res = MIN((bufend - bufpt), skcnt); 412 bufpt += res; 413 skcnt -= res; 414 415 /* 416 * if skcnt is now 0, then no additional i/o is needed 417 */ 418 if (skcnt == 0) 419 return(0); 420 421 /* 422 * We have to read more, calculate complete and partial record reads 423 * based on rdblksz. we skip over "cnt" complete records 424 */ 425 res = skcnt%rdblksz; 426 cnt = (skcnt/rdblksz) * rdblksz; 427 428 /* 429 * if the skip fails, we will have to resync. ar_fow will tell us 430 * how much it can skip over. We will have to read the rest. 431 */ 432 if (ar_fow(cnt, &skipped) < 0) 433 return(-1); 434 res += cnt - skipped; 435 rdcnt += skipped; 436 437 /* 438 * what is left we have to read (which may be the whole thing if 439 * ar_fow() told us the device can only read to skip records); 440 */ 441 while (res > 0L) { 442 cnt = bufend - bufpt; 443 /* 444 * if the read fails, we will have to resync 445 */ 446 if ((cnt <= 0) && ((cnt = buf_fill()) < 0)) 447 return(-1); 448 if (cnt == 0) 449 return(1); 450 cnt = MIN(cnt, res); 451 bufpt += cnt; 452 res -= cnt; 453 } 454 return(0); 455} 456 457/* 458 * wr_fin() 459 * flush out any data (and pad if required) the last block. We always pad 460 * with zero (even though we do not have to). Padding with 0 makes it a 461 * lot easier to recover if the archive is damaged. zero paddding SHOULD 462 * BE a requirement.... 463 */ 464 465void 466wr_fin(void) 467{ 468 if (bufpt > buf) { 469 memset(bufpt, 0, bufend - bufpt); 470 bufpt = bufend; 471 (void)buf_flush(blksz); 472 } 473} 474 475/* 476 * wr_rdbuf() 477 * fill the write buffer from data passed to it in a buffer (usually used 478 * by format specific write routines to pass a file header). On failure we 479 * punt. We do not allow the user to continue to write flawed archives. 480 * We assume these headers are not very large (the memory copy we use is 481 * a bit expensive). 482 * Return: 483 * 0 if buffer was filled ok, -1 o.w. (buffer flush failure) 484 */ 485 486int 487wr_rdbuf(char *out, int outcnt) 488{ 489 int cnt; 490 491 /* 492 * while there is data to copy copy into the write buffer. when the 493 * write buffer fills, flush it to the archive and continue 494 */ 495 while (outcnt > 0) { 496 cnt = bufend - bufpt; 497 if ((cnt <= 0) && ((cnt = buf_flush(blksz)) < 0)) 498 return(-1); 499 /* 500 * only move what we have space for 501 */ 502 cnt = MIN(cnt, outcnt); 503 memcpy(bufpt, out, cnt); 504 bufpt += cnt; 505 out += cnt; 506 outcnt -= cnt; 507 } 508 return(0); 509} 510 511/* 512 * rd_wrbuf() 513 * copy from the read buffer into a supplied buffer a specified number of 514 * bytes. If the read buffer is empty fill it and continue to copy. 515 * usually used to obtain a file header for processing by a format 516 * specific read routine. 517 * Return 518 * number of bytes copied to the buffer, 0 indicates EOF on archive volume, 519 * -1 is a read error 520 */ 521 522int 523rd_wrbuf(char *in, int cpcnt) 524{ 525 int res; 526 int cnt; 527 int incnt = cpcnt; 528 529 /* 530 * loop until we fill the buffer with the requested number of bytes 531 */ 532 while (incnt > 0) { 533 cnt = bufend - bufpt; 534 if ((cnt <= 0) && ((cnt = buf_fill()) <= 0)) { 535 /* 536 * read error, return what we got (or the error if 537 * no data was copied). The caller must know that an 538 * error occurred and has the best knowledge what to 539 * do with it 540 */ 541 if ((res = cpcnt - incnt) > 0) 542 return(res); 543 return(cnt); 544 } 545 546 /* 547 * calculate how much data to copy based on whats left and 548 * state of buffer 549 */ 550 cnt = MIN(cnt, incnt); 551 memcpy(in, bufpt, cnt); 552 bufpt += cnt; 553 incnt -= cnt; 554 in += cnt; 555 } 556 return(cpcnt); 557} 558 559/* 560 * wr_skip() 561 * skip forward during a write. In other words add padding to the file. 562 * we add zero filled padding as it makes flawed archives much easier to 563 * recover from. the caller tells us how many bytes of padding to add 564 * This routine was not designed to add HUGE amount of padding, just small 565 * amounts (a few 512 byte blocks at most) 566 * Return: 567 * 0 if ok, -1 if there was a buf_flush failure 568 */ 569 570int 571wr_skip(off_t skcnt) 572{ 573 int cnt; 574 575 /* 576 * loop while there is more padding to add 577 */ 578 while (skcnt > 0L) { 579 cnt = bufend - bufpt; 580 if ((cnt <= 0) && ((cnt = buf_flush(blksz)) < 0)) 581 return(-1); 582 cnt = MIN(cnt, skcnt); 583 memset(bufpt, 0, cnt); 584 bufpt += cnt; 585 skcnt -= cnt; 586 } 587 return(0); 588} 589 590/* 591 * wr_rdfile() 592 * fill write buffer with the contents of a file. We are passed an open 593 * file descriptor to the file an the archive structure that describes the 594 * file we are storing. The variable "left" is modified to contain the 595 * number of bytes of the file we were NOT able to write to the archive. 596 * it is important that we always write EXACTLY the number of bytes that 597 * the format specific write routine told us to. The file can also get 598 * bigger, so reading to the end of file would create an improper archive, 599 * we just detect this case and warn the user. We never create a bad 600 * archive if we can avoid it. Of course trying to archive files that are 601 * active is asking for trouble. It we fail, we pass back how much we 602 * could NOT copy and let the caller deal with it. 603 * Return: 604 * 0 ok, -1 if archive write failure. a short read of the file returns a 605 * 0, but "left" is set to be greater than zero. 606 */ 607 608int 609wr_rdfile(ARCHD *arcn, int ifd, off_t *left) 610{ 611 int cnt; 612 int res = 0; 613 off_t size = arcn->sb.st_size; 614 struct stat origsb, sb; 615 616 /* 617 * by default, remember the previously obtained stat information 618 * (in arcn->sb) for comparing the mtime after reading. 619 * if Mflag is set, use the actual mtime instead. 620 */ 621 origsb = arcn->sb; 622 if (Mflag && (fstat(ifd, &origsb) < 0)) 623 syswarn(1, errno, "Failed stat on %s", arcn->org_name); 624 625 /* 626 * while there are more bytes to write 627 */ 628 while (size > 0L) { 629 cnt = bufend - bufpt; 630 if ((cnt <= 0) && ((cnt = buf_flush(blksz)) < 0)) { 631 *left = size; 632 return(-1); 633 } 634 cnt = MIN(cnt, size); 635 if ((res = read_with_restart(ifd, bufpt, cnt)) <= 0) 636 break; 637 size -= res; 638 bufpt += res; 639 } 640 641 /* 642 * better check the file did not change during this operation 643 * or the file read failed. 644 */ 645 if (res < 0) 646 syswarn(1, errno, "Read fault on %s", arcn->org_name); 647 else if (size != 0L) 648 tty_warn(1, "File changed size during read %s", arcn->org_name); 649 else if (fstat(ifd, &sb) < 0) 650 syswarn(1, errno, "Failed stat on %s", arcn->org_name); 651 else if (origsb.st_mtime != sb.st_mtime) 652 tty_warn(1, "File %s was modified during copy to archive", 653 arcn->org_name); 654 *left = size; 655 return(0); 656} 657 658/* 659 * rd_wrfile() 660 * extract the contents of a file from the archive. If we are unable to 661 * extract the entire file (due to failure to write the file) we return 662 * the numbers of bytes we did NOT process. This way the caller knows how 663 * many bytes to skip past to find the next archive header. If the failure 664 * was due to an archive read, we will catch that when we try to skip. If 665 * the format supplies a file data crc value, we calculate the actual crc 666 * so that it can be compared to the value stored in the header 667 * NOTE: 668 * We call a special function to write the file. This function attempts to 669 * restore file holes (blocks of zeros) into the file. When files are 670 * sparse this saves space, and is a LOT faster. For non sparse files 671 * the performance hit is small. As of this writing, no archive supports 672 * information on where the file holes are. 673 * Return: 674 * 0 ok, -1 if archive read failure. if we cannot write the entire file, 675 * we return a 0 but "left" is set to be the amount unwritten 676 */ 677 678int 679rd_wrfile(ARCHD *arcn, int ofd, off_t *left) 680{ 681 int cnt = 0; 682 off_t size = arcn->sb.st_size; 683 int res = 0; 684 char *fnm = arcn->name; 685 int isem = 1; 686 int rem; 687 int sz = MINFBSZ; 688 struct stat sb; 689 u_long crc = 0L; 690 691 /* 692 * pass the blocksize of the file being written to the write routine, 693 * if the size is zero, use the default MINFBSZ 694 */ 695 if (ofd == -1) 696 sz = PAXPATHLEN+1; 697 else if (fstat(ofd, &sb) == 0) { 698 if (sb.st_blksize > 0) 699 sz = (int)sb.st_blksize; 700 } else 701 syswarn(0, errno, 702 "Unable to obtain block size for file %s", fnm); 703 rem = sz; 704 *left = 0L; 705 706 /* 707 * Copy the archive to the file the number of bytes specified. We have 708 * to assume that we want to recover file holes as none of the archive 709 * formats can record the location of file holes. 710 */ 711 while (size > 0L) { 712 cnt = bufend - bufpt; 713 /* 714 * if we get a read error, we do not want to skip, as we may 715 * miss a header, so we do not set left, but if we get a write 716 * error, we do want to skip over the unprocessed data. 717 */ 718 if ((cnt <= 0) && ((cnt = buf_fill()) <= 0)) 719 break; 720 cnt = MIN(cnt, size); 721 if ((res = file_write(ofd,bufpt,cnt,&rem,&isem,sz,fnm)) <= 0) { 722 *left = size; 723 break; 724 } 725 726 if (docrc) { 727 /* 728 * update the actual crc value 729 */ 730 cnt = res; 731 while (--cnt >= 0) 732 crc += *bufpt++ & 0xff; 733 } else 734 bufpt += res; 735 size -= res; 736 } 737 738 /* 739 * if the last block has a file hole (all zero), we must make sure this 740 * gets updated in the file. We force the last block of zeros to be 741 * written. just closing with the file offset moved forward may not put 742 * a hole at the end of the file. 743 */ 744 if (ofd != -1 && isem && (arcn->sb.st_size > 0L)) 745 file_flush(ofd, fnm, isem); 746 747 /* 748 * if we failed from archive read, we do not want to skip 749 */ 750 if ((size > 0L) && (*left == 0L)) 751 return(-1); 752 753 /* 754 * some formats record a crc on file data. If so, then we compare the 755 * calculated crc to the crc stored in the archive 756 */ 757 if (docrc && (size == 0L) && (arcn->crc != crc)) 758 tty_warn(1,"Actual crc does not match expected crc %s", 759 arcn->name); 760 return(0); 761} 762 763/* 764 * cp_file() 765 * copy the contents of one file to another. used during -rw phase of pax 766 * just as in rd_wrfile() we use a special write function to write the 767 * destination file so we can properly copy files with holes. 768 */ 769 770void 771cp_file(ARCHD *arcn, int fd1, int fd2) 772{ 773 int cnt; 774 off_t cpcnt = 0L; 775 int res = 0; 776 char *fnm = arcn->name; 777 int no_hole = 0; 778 int isem = 1; 779 int rem; 780 int sz = MINFBSZ; 781 struct stat sb, origsb; 782 783 /* 784 * check for holes in the source file. If none, we will use regular 785 * write instead of file write. 786 */ 787 if (((off_t)(arcn->sb.st_blocks * BLKMULT)) >= arcn->sb.st_size) 788 ++no_hole; 789 790 /* 791 * by default, remember the previously obtained stat information 792 * (in arcn->sb) for comparing the mtime after reading. 793 * if Mflag is set, use the actual mtime instead. 794 */ 795 origsb = arcn->sb; 796 if (Mflag && (fstat(fd1, &origsb) < 0)) 797 syswarn(1, errno, "Failed stat on %s", arcn->org_name); 798 799 /* 800 * pass the blocksize of the file being written to the write routine, 801 * if the size is zero, use the default MINFBSZ 802 */ 803 if (fstat(fd2, &sb) == 0) { 804 if (sb.st_blksize > 0) 805 sz = sb.st_blksize; 806 } else 807 syswarn(0, errno, 808 "Unable to obtain block size for file %s", fnm); 809 rem = sz; 810 811 /* 812 * read the source file and copy to destination file until EOF 813 */ 814 for(;;) { 815 if ((cnt = read_with_restart(fd1, buf, blksz)) <= 0) 816 break; 817 if (no_hole) 818 res = xwrite(fd2, buf, cnt); 819 else 820 res = file_write(fd2, buf, cnt, &rem, &isem, sz, fnm); 821 if (res != cnt) 822 break; 823 cpcnt += cnt; 824 } 825 826 /* 827 * check to make sure the copy is valid. 828 */ 829 if (res < 0) 830 syswarn(1, errno, "Failed write during copy of %s to %s", 831 arcn->org_name, arcn->name); 832 else if (cpcnt != arcn->sb.st_size) 833 tty_warn(1, "File %s changed size during copy to %s", 834 arcn->org_name, arcn->name); 835 else if (fstat(fd1, &sb) < 0) 836 syswarn(1, errno, "Failed stat of %s", arcn->org_name); 837 else if (origsb.st_mtime != sb.st_mtime) 838 tty_warn(1, "File %s was modified during copy to %s", 839 arcn->org_name, arcn->name); 840 841 /* 842 * if the last block has a file hole (all zero), we must make sure this 843 * gets updated in the file. We force the last block of zeros to be 844 * written. just closing with the file offset moved forward may not put 845 * a hole at the end of the file. 846 */ 847 if (!no_hole && isem && (arcn->sb.st_size > 0L)) 848 file_flush(fd2, fnm, isem); 849 return; 850} 851 852/* 853 * buf_fill() 854 * fill the read buffer with the next record (or what we can get) from 855 * the archive volume. 856 * Return: 857 * Number of bytes of data in the read buffer, -1 for read error, and 858 * 0 when finished (user specified termination in ar_next()). 859 */ 860 861int 862buf_fill(void) 863{ 864 int cnt; 865 static int fini = 0; 866 867 if (fini) 868 return(0); 869 870 for(;;) { 871 /* 872 * try to fill the buffer. on error the next archive volume is 873 * opened and we try again. 874 */ 875 if ((cnt = ar_read(buf, blksz)) > 0) { 876 bufpt = buf; 877 bufend = buf + cnt; 878 rdcnt += cnt; 879 return(cnt); 880 } 881 882 /* 883 * errors require resync, EOF goes to next archive 884 */ 885 if (cnt < 0) 886 break; 887 if (ar_next() < 0) { 888 fini = 1; 889 return(0); 890 } 891 rdcnt = 0; 892 } 893 exit_val = 1; 894 return(-1); 895} 896 897/* 898 * buf_flush() 899 * force the write buffer to the archive. We are passed the number of 900 * bytes in the buffer at the point of the flush. When we change archives 901 * the record size might change. (either larger or smaller). 902 * Return: 903 * 0 if all is ok, -1 when a write error occurs. 904 */ 905 906int 907buf_flush(int bufcnt) 908{ 909 int cnt; 910 int push = 0; 911 int totcnt = 0; 912 913 /* 914 * if we have reached the user specified byte count for each archive 915 * volume, prompt for the next volume. (The non-standard -R flag). 916 * NOTE: If the wrlimit is smaller than wrcnt, we will always write 917 * at least one record. We always round limit UP to next blocksize. 918 */ 919 if ((wrlimit > 0) && (wrcnt > wrlimit)) { 920 tty_warn(0, 921 "User specified archive volume byte limit reached."); 922 if (ar_next() < 0) { 923 wrcnt = 0; 924 exit_val = 1; 925 return(-1); 926 } 927 wrcnt = 0; 928 929 /* 930 * The new archive volume might have changed the size of the 931 * write blocksize. if so we figure out if we need to write 932 * (one or more times), or if there is now free space left in 933 * the buffer (it is no longer full). bufcnt has the number of 934 * bytes in the buffer, (the blocksize, at the point we were 935 * CALLED). Push has the amount of "extra" data in the buffer 936 * if the block size has shrunk from a volume change. 937 */ 938 bufend = buf + blksz; 939 if (blksz > bufcnt) 940 return(0); 941 if (blksz < bufcnt) 942 push = bufcnt - blksz; 943 } 944 945 /* 946 * We have enough data to write at least one archive block 947 */ 948 for (;;) { 949 /* 950 * write a block and check if it all went out ok 951 */ 952 cnt = ar_write(buf, blksz); 953 if (cnt == blksz) { 954 /* 955 * the write went ok 956 */ 957 wrcnt += cnt; 958 totcnt += cnt; 959 if (push > 0) { 960 /* we have extra data to push to the front. 961 * check for more than 1 block of push, and if 962 * so we loop back to write again 963 */ 964 memcpy(buf, bufend, push); 965 bufpt = buf + push; 966 if (push >= blksz) { 967 push -= blksz; 968 continue; 969 } 970 } else 971 bufpt = buf; 972 return(totcnt); 973 } else if (cnt > 0) { 974 /* 975 * Oh drat we got a partial write! 976 * if format doesnt care about alignment let it go, 977 * we warned the user in ar_write().... but this means 978 * the last record on this volume violates pax spec.... 979 */ 980 totcnt += cnt; 981 wrcnt += cnt; 982 bufpt = buf + cnt; 983 cnt = bufcnt - cnt; 984 memcpy(buf, bufpt, cnt); 985 bufpt = buf + cnt; 986 if (!frmt->blkalgn || ((cnt % frmt->blkalgn) == 0)) 987 return(totcnt); 988 break; 989 } 990 991 /* 992 * All done, go to next archive 993 */ 994 wrcnt = 0; 995 if (ar_next() < 0) 996 break; 997 998 /* 999 * The new archive volume might also have changed the block 1000 * size. if so, figure out if we have too much or too little 1001 * data for using the new block size 1002 */ 1003 bufend = buf + blksz; 1004 if (blksz > bufcnt) 1005 return(0); 1006 if (blksz < bufcnt) 1007 push = bufcnt - blksz; 1008 } 1009 1010 /* 1011 * write failed, stop pax. we must not create a bad archive! 1012 */ 1013 exit_val = 1; 1014 return(-1); 1015} 1016