![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to buffer.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / usr / bin / pax / shipping|
Return to buffer.c CVS log | Up to [MW Coherent from dump] / coherent / d / usr / bin / pax / shipping |
1.1 ! root 1: /* $Source: /newbits/usr/bin/pax/shipping/buffer.c,v $ ! 2: * ! 3: * $Revision: 1.1 $ ! 4: * ! 5: * buffer.c - Buffer management functions ! 6: * ! 7: * DESCRIPTION ! 8: * ! 9: * These functions handle buffer manipulations for the archiving ! 10: * formats. Functions are provided to get memory for buffers, ! 11: * flush buffers, read and write buffers and de-allocate buffers. ! 12: * Several housekeeping functions are provided as well to get some ! 13: * information about how full buffers are, etc. ! 14: * ! 15: * AUTHOR ! 16: * ! 17: * Mark H. Colburn, NAPS International ([email protected]) ! 18: * ! 19: * Sponsored by The USENIX Association for public distribution. ! 20: * ! 21: * Copyright (c) 1989 Mark H. Colburn. ! 22: * All rights reserved. ! 23: * ! 24: * Redistribution and use in source and binary forms are permitted ! 25: * provided that the above copyright notice is duplicated in all such ! 26: * forms and that any documentation, advertising materials, and other ! 27: * materials related to such distribution and use acknowledge that the ! 28: * software was developed * by Mark H. Colburn and sponsored by The ! 29: * USENIX Association. ! 30: * ! 31: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 32: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 33: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 34: * ! 35: * $Log: /newbits/usr/bin/pax/shipping/buffer.c,v $ ! 36: * Revision 1.1 91/02/05 11:55:12 bin ! 37: * Initial revision ! 38: * ! 39: * Revision 1.2 89/02/12 10:04:02 mark ! 40: * 1.2 release fixes ! 41: * ! 42: * Revision 1.1 88/12/23 18:02:01 mark ! 43: * Initial revision ! 44: * ! 45: */ ! 46: ! 47: #ifndef lint ! 48: static char *ident = "$Id: buffer.c,v 1.2 89/02/12 10:04:02 mark Exp $"; ! 49: static char *copyright = "Copyright (c) 1989 Mark H. Colburn.\nAll rights reserved.\n"; ! 50: #endif /* ! lint */ ! 51: ! 52: ! 53: /* Headers */ ! 54: ! 55: #include "pax.h" ! 56: ! 57: ! 58: /* Function Prototypes */ ! 59: ! 60: #if __STDC__ ! 61: ! 62: static int ar_write(int, char *, uint); ! 63: static void buf_pad(OFFSET); ! 64: static int indata(int, OFFSET, char *); ! 65: static void outflush(void); ! 66: static void buf_use(uint); ! 67: static int buf_in_avail(char **, uint *); ! 68: static uint buf_out_avail(char **); ! 69: ! 70: #else /* !__STDC__ */ ! 71: ! 72: static int ar_write(); ! 73: static void buf_pad(); ! 74: static int indata(); ! 75: static void outflush(); ! 76: static void buf_use(); ! 77: static int buf_in_avail(); ! 78: static uint buf_out_avail(); ! 79: ! 80: #endif /* __STDC__ */ ! 81: ! 82: ! 83: /* inentry - install a single archive entry ! 84: * ! 85: * DESCRIPTION ! 86: * ! 87: * Inentry reads an archive entry from the archive file and writes it ! 88: * out the the named file. If we are in PASS mode during archive ! 89: * processing, the pass() function is called, otherwise we will ! 90: * extract from the archive file. ! 91: * ! 92: * Inentry actaully calls indata to process the actual data to the ! 93: * file. ! 94: * ! 95: * PARAMETERS ! 96: * ! 97: * char *name - name of the file to extract from the archive ! 98: * Stat *asb - stat block of the file to be extracted from the ! 99: * archive. ! 100: * ! 101: * RETURNS ! 102: * ! 103: * Returns zero if successful, -1 otherwise. ! 104: */ ! 105: ! 106: #if __STDC__ ! 107: ! 108: int inentry(char *name, Stat *asb) ! 109: ! 110: #else ! 111: ! 112: int inentry(name, asb) ! 113: char *name; ! 114: Stat *asb; ! 115: ! 116: #endif ! 117: { ! 118: Link *linkp; ! 119: int ifd; ! 120: int ofd; ! 121: time_t tstamp[2]; ! 122: ! 123: if ((ofd = openout(name, asb, linkp = linkfrom(name, asb), 0)) > 0) { ! 124: if (asb->sb_size || linkp == (Link *)NULL || linkp->l_size == 0) { ! 125: close(indata(ofd, asb->sb_size, name)); ! 126: } else if ((ifd = open(linkp->l_path->p_name, 0)) < 0) { ! 127: warn(linkp->l_path->p_name, strerror()); ! 128: } else { ! 129: passdata(linkp->l_path->p_name, ifd, name, ofd); ! 130: close(ifd); ! 131: close(ofd); ! 132: } ! 133: } else { ! 134: return(buf_skip((OFFSET) asb->sb_size) >= 0); ! 135: } ! 136: tstamp[0] = (!f_pass && f_access_time) ? asb->sb_atime : time((time_t *) 0); ! 137: tstamp[1] = f_mtime ? asb->sb_mtime : time((time_t *) 0); ! 138: utime(name, tstamp); ! 139: return (0); ! 140: } ! 141: ! 142: /* outdata - write archive data ! 143: * ! 144: * DESCRIPTION ! 145: * ! 146: * Outdata transfers data from the named file to the archive buffer. ! 147: * It knows about the file padding which is required by tar, but no ! 148: * by cpio. Outdata continues after file read errors, padding with ! 149: * null characters if neccessary. Closes the input file descriptor ! 150: * when finished. ! 151: * ! 152: * PARAMETERS ! 153: * ! 154: * int fd - file descriptor of file to read data from ! 155: * char *name - name of file ! 156: * OFFSET size - size of the file ! 157: * ! 158: */ ! 159: ! 160: #if __STDC__ ! 161: ! 162: void outdata(int fd, char *name, OFFSET size) ! 163: ! 164: #else ! 165: ! 166: void outdata(fd, name, size) ! 167: int fd; ! 168: char *name; ! 169: OFFSET size; ! 170: ! 171: #endif ! 172: { ! 173: uint chunk; ! 174: int got; ! 175: int oops; ! 176: uint avail; ! 177: int pad; ! 178: char *buf; ! 179: ! 180: oops = got = 0; ! 181: if (pad = (size % BLOCKSIZE)) { ! 182: pad = (BLOCKSIZE - pad); ! 183: } ! 184: while (size) { ! 185: avail = buf_out_avail(&buf); ! 186: size -= (chunk = size < avail ? (uint) size : avail); ! 187: if (oops == 0 && (got = read(fd, buf, (unsigned int) chunk)) < 0) { ! 188: oops = -1; ! 189: warn(name, strerror()); ! 190: got = 0; ! 191: } ! 192: if (got < chunk) { ! 193: if (oops == 0) { ! 194: oops = -1; ! 195: } ! 196: warn(name, "Early EOF"); ! 197: while (got < chunk) { ! 198: buf[got++] = '\0'; ! 199: } ! 200: } ! 201: buf_use(chunk); ! 202: } ! 203: close(fd); ! 204: if (ar_format == TAR) { ! 205: buf_pad((OFFSET) pad); ! 206: } ! 207: } ! 208: ! 209: ! 210: /* write_eot - write the end of archive record(s) ! 211: * ! 212: * DESCRIPTION ! 213: * ! 214: * Write out an End-Of-Tape record. We actually zero at least one ! 215: * record, through the end of the block. Old tar writes garbage after ! 216: * two zeroed records -- and PDtar used to. ! 217: */ ! 218: ! 219: #if __STDC__ ! 220: ! 221: void write_eot(void) ! 222: ! 223: #else ! 224: ! 225: void write_eot() ! 226: ! 227: #endif ! 228: { ! 229: OFFSET pad; ! 230: char header[M_STRLEN + H_STRLEN + 1]; ! 231: ! 232: if (ar_format == TAR) { ! 233: /* write out two zero blocks for trailer */ ! 234: pad = 2 * BLOCKSIZE; ! 235: } else { ! 236: if (pad = (total + M_STRLEN + H_STRLEN + TRAILZ) % BLOCKSIZE) { ! 237: pad = BLOCKSIZE - pad; ! 238: } ! 239: strcpy(header, M_ASCII); ! 240: sprintf(header + M_STRLEN, H_PRINT, 0, 0, ! 241: 0, 0, 0, 1, 0, (time_t) 0, TRAILZ, pad); ! 242: outwrite(header, M_STRLEN + H_STRLEN); ! 243: outwrite(TRAILER, TRAILZ); ! 244: } ! 245: buf_pad((OFFSET) pad); ! 246: outflush(); ! 247: } ! 248: ! 249: ! 250: /* outwrite - write archive data ! 251: * ! 252: * DESCRIPTION ! 253: * ! 254: * Writes out data in the archive buffer to the archive file. The ! 255: * buffer index and the total byte count are incremented by the number ! 256: * of data bytes written. ! 257: * ! 258: * PARAMETERS ! 259: * ! 260: * char *idx - pointer to data to write ! 261: * uint len - length of the data to write ! 262: */ ! 263: ! 264: #if __STDC__ ! 265: ! 266: void outwrite(char *idx, uint len) ! 267: ! 268: #else ! 269: ! 270: void outwrite(idx, len) ! 271: char *idx; /* pointer to data to write */ ! 272: uint len; /* length of data to write */ ! 273: ! 274: #endif ! 275: { ! 276: uint have; ! 277: uint want; ! 278: char *endx; ! 279: ! 280: endx = idx + len; ! 281: while (want = endx - idx) { ! 282: if (bufend - bufidx < 0) { ! 283: fatal("Buffer overlow in out_write\n"); ! 284: } ! 285: if ((have = bufend - bufidx) == 0) { ! 286: outflush(); ! 287: } ! 288: if (have > want) { ! 289: have = want; ! 290: } ! 291: memcpy(bufidx, idx, (int) have); ! 292: bufidx += have; ! 293: idx += have; ! 294: total += have; ! 295: } ! 296: } ! 297: ! 298: ! 299: /* passdata - copy data to one file ! 300: * ! 301: * DESCRIPTION ! 302: * ! 303: * Copies a file from one place to another. Doesn't believe in input ! 304: * file descriptor zero (see description of kludge in openin() comments). ! 305: * Closes the provided output file descriptor. ! 306: * ! 307: * PARAMETERS ! 308: * ! 309: * char *from - input file name (old file) ! 310: * int ifd - input file descriptor ! 311: * char *to - output file name (new file) ! 312: * int ofd - output file descriptor ! 313: */ ! 314: ! 315: #if __STDC__ ! 316: ! 317: void passdata(char *from, int ifd, char *to, int ofd) ! 318: ! 319: #else ! 320: ! 321: void passdata(from, ifd, to, ofd) ! 322: char *from; ! 323: int ifd; ! 324: char *to; ! 325: int ofd; ! 326: ! 327: #endif ! 328: { ! 329: int got; ! 330: int sparse; ! 331: char block[BUFSIZ]; ! 332: ! 333: if (ifd) { ! 334: lseek(ifd, (OFFSET) 0, 0); ! 335: sparse = 0; ! 336: while ((got = read(ifd, block, sizeof(block))) > 0 ! 337: && (sparse = ar_write(ofd, block, (uint) got)) >= 0) { ! 338: total += got; ! 339: } ! 340: if (got) { ! 341: warn(got < 0 ? from : to, strerror()); ! 342: } else if (sparse > 0 ! 343: && (lseek(ofd, (OFFSET)(-sparse), 1) < 0 ! 344: || write(ofd, block, (uint) sparse) != sparse)) { ! 345: warn(to, strerror()); ! 346: } ! 347: } ! 348: close(ofd); ! 349: } ! 350: ! 351: ! 352: /* buf_allocate - get space for the I/O buffer ! 353: * ! 354: * DESCRIPTION ! 355: * ! 356: * buf_allocate allocates an I/O buffer using malloc. The resulting ! 357: * buffer is used for all data buffering throughout the program. ! 358: * Buf_allocate must be called prior to any use of the buffer or any ! 359: * of the buffering calls. ! 360: * ! 361: * PARAMETERS ! 362: * ! 363: * int size - size of the I/O buffer to request ! 364: * ! 365: * ERRORS ! 366: * ! 367: * If an invalid size is given for a buffer or if a buffer of the ! 368: * required size cannot be allocated, then the function prints out an ! 369: * error message and returns a non-zero exit status to the calling ! 370: * process, terminating the program. ! 371: * ! 372: */ ! 373: ! 374: #if __STDC__ ! 375: ! 376: void buf_allocate(OFFSET size) ! 377: ! 378: #else ! 379: ! 380: void buf_allocate(size) ! 381: OFFSET size; ! 382: ! 383: #endif ! 384: { ! 385: if (size <= 0) { ! 386: fatal("invalid value for blocksize"); ! 387: } ! 388: if ((bufstart = malloc((unsigned) size)) == (char *)NULL) { ! 389: fatal("Cannot allocate I/O buffer"); ! 390: } ! 391: bufend = bufidx = bufstart; ! 392: bufend += size; ! 393: } ! 394: ! 395: ! 396: /* buf_skip - skip input archive data ! 397: * ! 398: * DESCRIPTION ! 399: * ! 400: * Buf_skip skips past archive data. It is used when the length of ! 401: * the archive data is known, and we do not wish to process the data. ! 402: * ! 403: * PARAMETERS ! 404: * ! 405: * OFFSET len - number of bytes to skip ! 406: * ! 407: * RETURNS ! 408: * ! 409: * Returns zero under normal circumstances, -1 if unreadable data is ! 410: * encountered. ! 411: */ ! 412: ! 413: #if __STDC__ ! 414: ! 415: int buf_skip(OFFSET len) ! 416: ! 417: #else ! 418: ! 419: int buf_skip(len) ! 420: OFFSET len; ! 421: ! 422: #endif ! 423: { ! 424: uint chunk; ! 425: int corrupt = 0; ! 426: ! 427: while (len) { ! 428: if (bufend - bufidx < 0) { ! 429: fatal("Buffer overlow in buf_skip\n"); ! 430: } ! 431: ! 432: while ((chunk = bufend - bufidx) == 0) { ! 433: corrupt |= ar_read(); ! 434: } ! 435: if (chunk > len) { ! 436: chunk = len; ! 437: } ! 438: bufidx += chunk; ! 439: len -= chunk; ! 440: total += chunk; ! 441: } ! 442: return (corrupt); ! 443: } ! 444: ! 445: /* buf_read - read a given number of characters from the input archive ! 446: * ! 447: * DESCRIPTION ! 448: * ! 449: * Reads len number of characters from the input archive and ! 450: * stores them in the buffer pointed at by dst. ! 451: * ! 452: * PARAMETERS ! 453: * ! 454: * char *dst - pointer to buffer to store data into ! 455: * uint len - length of data to read ! 456: * ! 457: * RETURNS ! 458: * ! 459: * Returns zero with valid data, -1 if unreadable portions were ! 460: * replaced by null characters. ! 461: */ ! 462: ! 463: #if __STDC__ ! 464: ! 465: int buf_read(char *dst, uint len) ! 466: ! 467: #else ! 468: ! 469: int buf_read(dst, len) ! 470: char *dst; ! 471: uint len; ! 472: ! 473: #endif ! 474: { ! 475: int have; ! 476: int want; ! 477: int corrupt = 0; ! 478: char *endx = dst + len; ! 479: ! 480: while (want = endx - dst) { ! 481: if (bufend - bufidx < 0) { ! 482: fatal("Buffer overlow in buf_read\n"); ! 483: } ! 484: while ((have = bufend - bufidx) == 0) { ! 485: have = 0; ! 486: corrupt |= ar_read(); ! 487: } ! 488: if (have > want) { ! 489: have = want; ! 490: } ! 491: memcpy(dst, bufidx, have); ! 492: bufidx += have; ! 493: dst += have; ! 494: total += have; ! 495: } ! 496: return (corrupt); ! 497: } ! 498: ! 499: /* indata - install data from an archive ! 500: * ! 501: * DESCRIPTION ! 502: * ! 503: * Indata writes size bytes of data from the archive buffer to the output ! 504: * file specified by fd. The filename which is being written, pointed ! 505: * to by name is provided only for diagnostics. ! 506: * ! 507: * PARAMETERS ! 508: * ! 509: * int fd - output file descriptor ! 510: * OFFSET size - number of bytes to write to output file ! 511: * char *name - name of file which corresponds to fd ! 512: * ! 513: * RETURNS ! 514: * ! 515: * Returns given file descriptor. ! 516: */ ! 517: ! 518: #if __STDC__ ! 519: ! 520: static int indata(int fd, OFFSET size, char *name) ! 521: ! 522: #else ! 523: ! 524: static int indata(fd, size, name) ! 525: int fd; ! 526: OFFSET size; ! 527: char *name; ! 528: ! 529: #endif ! 530: { ! 531: uint chunk; ! 532: char *oops; ! 533: int sparse; ! 534: int corrupt; ! 535: char *buf; ! 536: uint avail; ! 537: ! 538: corrupt = sparse = 0; ! 539: oops = (char *)NULL; ! 540: while (size) { ! 541: corrupt |= buf_in_avail(&buf, &avail); ! 542: size -= (chunk = size < avail ? (uint) size : avail); ! 543: if (oops == (char *)NULL && (sparse = ar_write(fd, buf, chunk)) < 0) { ! 544: oops = strerror(); ! 545: } ! 546: buf_use(chunk); ! 547: } ! 548: if (corrupt) { ! 549: warn(name, "Corrupt archive data"); ! 550: } ! 551: if (oops) { ! 552: warn(name, oops); ! 553: } else if (sparse > 0 && (lseek(fd, (OFFSET) - 1, 1) < 0 ! 554: || write(fd, "", 1) != 1)) { ! 555: warn(name, strerror()); ! 556: } ! 557: return (fd); ! 558: } ! 559: ! 560: ! 561: /* outflush - flush the output buffer ! 562: * ! 563: * DESCRIPTION ! 564: * ! 565: * The output buffer is written, if there is anything in it, to the ! 566: * archive file. ! 567: */ ! 568: ! 569: #if __STDC__ ! 570: ! 571: static void outflush(void) ! 572: ! 573: #else ! 574: ! 575: static void outflush() ! 576: ! 577: #endif ! 578: { ! 579: char *buf; ! 580: int got; ! 581: uint len; ! 582: ! 583: /* if (bufidx - buf > 0) */ ! 584: for (buf = bufstart; len = bufidx - buf;) { ! 585: if ((got = write(archivefd, buf, MIN(len, blocksize))) > 0) { ! 586: buf += got; ! 587: } else if (got < 0) { ! 588: next(AR_WRITE); ! 589: } ! 590: } ! 591: bufend = (bufidx = bufstart) + blocksize; ! 592: } ! 593: ! 594: ! 595: /* ar_read - fill the archive buffer ! 596: * ! 597: * DESCRIPTION ! 598: * ! 599: * Remembers mid-buffer read failures and reports them the next time ! 600: * through. Replaces unreadable data with null characters. Resets ! 601: * the buffer pointers as appropriate. ! 602: * ! 603: * RETURNS ! 604: * ! 605: * Returns zero with valid data, -1 otherwise. ! 606: */ ! 607: ! 608: #if __STDC__ ! 609: ! 610: int ar_read(void) ! 611: ! 612: #else ! 613: ! 614: int ar_read() ! 615: ! 616: #endif ! 617: { ! 618: int got; ! 619: static int failed; ! 620: static int myfld = 0; ! 621: ! 622: bufend = bufidx = bufstart; ! 623: if (!failed) { ! 624: if (areof) { ! 625: if (total == 0) { ! 626: fatal("No input"); ! 627: } else { ! 628: next(AR_READ); ! 629: } ! 630: } ! 631: while (!failed && !areof && bufstart + blocksize - bufend >= blocksize) { ! 632: if ((got = read(archivefd, bufend, (unsigned int) blocksize)) > 0) { ! 633: bufend += got; ! 634: if (myfld == 0) ! 635: myfld++; ! 636: } else if (got < 0 && myfld == 0) { ! 637: failed = -1; ! 638: warnarch(strerror(), (OFFSET) 0 - (bufend - bufidx)); ! 639: } else { ! 640: got = 0; ! 641: ++areof; ! 642: } ! 643: } ! 644: } ! 645: if (failed && bufend == bufstart) { ! 646: failed = 0; ! 647: for (got = 0; got < blocksize; ++got) { ! 648: *bufend++ = '\0'; ! 649: } ! 650: return (-1); ! 651: } ! 652: return (0); ! 653: } ! 654: ! 655: ! 656: /* ar_write - write a filesystem block ! 657: * ! 658: * DESCRIPTION ! 659: * ! 660: * Writes len bytes of data data from the specified buffer to the ! 661: * specified file. Seeks past sparse blocks. ! 662: * ! 663: * PARAMETERS ! 664: * ! 665: * int fd - file to write to ! 666: * char *buf - buffer to get data from ! 667: * uint len - number of bytes to transfer ! 668: * ! 669: * RETURNS ! 670: * ! 671: * Returns 0 if the block was written, the given length for a sparse ! 672: * block or -1 if unsuccessful. ! 673: */ ! 674: ! 675: #if __STDC__ ! 676: ! 677: static int ar_write(int fd, char *buf, uint len) ! 678: ! 679: #else ! 680: ! 681: static int ar_write(fd, buf, len) ! 682: int fd; ! 683: char *buf; ! 684: uint len; ! 685: ! 686: #endif ! 687: { ! 688: char *bidx; ! 689: char *bend; ! 690: ! 691: bend = (bidx = buf) + len; ! 692: while (bidx < bend) { ! 693: if (*bidx++) { ! 694: return (write(fd, buf, len) == len ? 0 : -1); ! 695: } ! 696: } ! 697: return (lseek(fd, (OFFSET) len, 1) < 0 ? -1 : len); ! 698: } ! 699: ! 700: ! 701: /* buf_pad - pad the archive buffer ! 702: * ! 703: * DESCRIPTION ! 704: * ! 705: * Buf_pad writes len zero bytes to the archive buffer in order to ! 706: * pad it. ! 707: * ! 708: * PARAMETERS ! 709: * ! 710: * OFFSET pad - number of zero bytes to pad ! 711: * ! 712: */ ! 713: ! 714: #if __STDC__ ! 715: ! 716: static void buf_pad(OFFSET pad) ! 717: ! 718: #else ! 719: ! 720: static void buf_pad(pad) ! 721: OFFSET pad; ! 722: ! 723: #endif ! 724: { ! 725: int idx; ! 726: int have; ! 727: ! 728: while (pad) { ! 729: if ((have = bufend - bufidx) > pad) { ! 730: have = pad; ! 731: } ! 732: for (idx = 0; idx < have; ++idx) { ! 733: *bufidx++ = '\0'; ! 734: } ! 735: total += have; ! 736: pad -= have; ! 737: if (bufend - bufidx == 0) { ! 738: outflush(); ! 739: } ! 740: } ! 741: } ! 742: ! 743: ! 744: /* buf_use - allocate buffer space ! 745: * ! 746: * DESCRIPTION ! 747: * ! 748: * Buf_use marks space in the buffer as being used; advancing both the ! 749: * buffer index (bufidx) and the total byte count (total). ! 750: * ! 751: * PARAMETERS ! 752: * ! 753: * uint len - Amount of space to allocate in the buffer ! 754: */ ! 755: ! 756: #if __STDC__ ! 757: ! 758: static void buf_use(uint len) ! 759: ! 760: #else ! 761: ! 762: static void buf_use(len) ! 763: uint len; ! 764: ! 765: #endif ! 766: { ! 767: bufidx += len; ! 768: total += len; ! 769: } ! 770: ! 771: ! 772: /* buf_in_avail - index available input data within the buffer ! 773: * ! 774: * DESCRIPTION ! 775: * ! 776: * Buf_in_avail fills the archive buffer, and points the bufp ! 777: * parameter at the start of the data. The lenp parameter is ! 778: * modified to contain the number of bytes which were read. ! 779: * ! 780: * PARAMETERS ! 781: * ! 782: * char **bufp - pointer to the buffer to read data into ! 783: * uint *lenp - pointer to the number of bytes which were read ! 784: * (returned to the caller) ! 785: * ! 786: * RETURNS ! 787: * ! 788: * Stores a pointer to the data and its length in given locations. ! 789: * Returns zero with valid data, -1 if unreadable portions were ! 790: * replaced with nulls. ! 791: * ! 792: * ERRORS ! 793: * ! 794: * If an error occurs in ar_read, the error code is returned to the ! 795: * calling function. ! 796: * ! 797: */ ! 798: ! 799: #if __STDC__ ! 800: ! 801: static int buf_in_avail(char **bufp, uint *lenp) ! 802: ! 803: #else ! 804: ! 805: static int buf_in_avail(bufp, lenp) ! 806: char **bufp; ! 807: uint *lenp; ! 808: ! 809: #endif ! 810: { ! 811: uint have; ! 812: int corrupt = 0; ! 813: ! 814: while ((have = bufend - bufidx) == 0) { ! 815: corrupt |= ar_read(); ! 816: } ! 817: *bufp = bufidx; ! 818: *lenp = have; ! 819: return (corrupt); ! 820: } ! 821: ! 822: ! 823: /* buf_out_avail - index buffer space for archive output ! 824: * ! 825: * DESCRIPTION ! 826: * ! 827: * Stores a buffer pointer at a given location. Returns the number ! 828: * of bytes available. ! 829: * ! 830: * PARAMETERS ! 831: * ! 832: * char **bufp - pointer to the buffer which is to be stored ! 833: * ! 834: * RETURNS ! 835: * ! 836: * The number of bytes which are available in the buffer. ! 837: * ! 838: */ ! 839: ! 840: #if __STDC__ ! 841: ! 842: static uint buf_out_avail(char **bufp) ! 843: ! 844: #else ! 845: ! 846: static uint buf_out_avail(bufp) ! 847: char **bufp; ! 848: ! 849: #endif ! 850: { ! 851: int have; ! 852: ! 853: if (bufend - bufidx < 0) { ! 854: fatal("Buffer overlow in buf_out_avail\n"); ! 855: } ! 856: if ((have = bufend - bufidx) == 0) { ! 857: outflush(); ! 858: } ! 859: *bufp = bufidx; ! 860: return (have); ! 861: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.