![[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 / e / bin / pax|
Return to buffer.c CVS log | Up to [MW Coherent from dump] / coherent / e / bin / pax |
1.1 ! root 1: /* $Source: /src386/usr/bin/pax/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: buffer.c,v $ ! 36: * Revision 1.1 92/08/28 08:01:56 bin ! 37: * Initial revision ! 38: * ! 39: * Revision 1.1 89/02/14 16:47:38 jep ! 40: * Initial revision ! 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.1 92/08/28 08:01:56 bin Exp Locker: bin $"; ! 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, O_RDONLY)) < 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: if (!f_modified) /* VLAD */ ! 139: utime(name, tstamp); ! 140: return (0); ! 141: } ! 142: ! 143: ! 144: /* outdata - write archive data ! 145: * ! 146: * DESCRIPTION ! 147: * ! 148: * Outdata transfers data from the named file to the archive buffer. ! 149: * It knows about the file padding which is required by tar, but no ! 150: * by cpio. Outdata continues after file read errors, padding with ! 151: * null characters if neccessary. Closes the input file descriptor ! 152: * when finished. ! 153: * ! 154: * PARAMETERS ! 155: * ! 156: * int fd - file descriptor of file to read data from ! 157: * char *name - name of file ! 158: * OFFSET size - size of the file ! 159: * ! 160: */ ! 161: ! 162: #if __STDC__ ! 163: ! 164: void outdata(int fd, char *name, OFFSET size) ! 165: ! 166: #else ! 167: ! 168: void outdata(fd, name, size) ! 169: int fd; ! 170: char *name; ! 171: OFFSET size; ! 172: ! 173: #endif ! 174: { ! 175: uint chunk; ! 176: int got; ! 177: int oops; ! 178: uint avail; ! 179: int pad; ! 180: char *buf; ! 181: ! 182: oops = got = 0; ! 183: if (pad = (size % BLOCKSIZE)) { ! 184: pad = (BLOCKSIZE - pad); ! 185: } ! 186: while (size) { ! 187: avail = buf_out_avail(&buf); ! 188: size -= (chunk = size < avail ? (uint) size : avail); ! 189: if (oops == 0 && (got = read(fd, buf, (unsigned int) chunk)) < 0) { ! 190: oops = -1; ! 191: warn(name, strerror()); ! 192: got = 0; ! 193: } ! 194: if (got < chunk) { ! 195: if (oops == 0) { ! 196: oops = -1; ! 197: } ! 198: warn(name, "Early EOF"); ! 199: while (got < chunk) { ! 200: buf[got++] = '\0'; ! 201: } ! 202: } ! 203: buf_use(chunk); ! 204: } ! 205: close(fd); ! 206: if (ar_format == TAR) { ! 207: buf_pad((OFFSET) pad); ! 208: } ! 209: } ! 210: ! 211: ! 212: /* write_eot - write the end of archive record(s) ! 213: * ! 214: * DESCRIPTION ! 215: * ! 216: * Write out an End-Of-Tape record. We actually zero at least one ! 217: * record, through the end of the block. Old tar writes garbage after ! 218: * two zeroed records -- and PDtar used to. ! 219: */ ! 220: ! 221: #if __STDC__ ! 222: ! 223: void write_eot(void) ! 224: ! 225: #else ! 226: ! 227: void write_eot() ! 228: ! 229: #endif ! 230: { ! 231: OFFSET pad; ! 232: char header[M_STRLEN + H_STRLEN + 1]; ! 233: ! 234: if (ar_format == TAR) { ! 235: /* write out two zero blocks for trailer */ ! 236: pad = 2 * BLOCKSIZE; ! 237: } else { ! 238: if (pad = (total + M_STRLEN + H_STRLEN + TRAILZ) % BLOCKSIZE) { ! 239: pad = BLOCKSIZE - pad; ! 240: } ! 241: strcpy(header, M_ASCII); ! 242: sprintf(header + M_STRLEN, H_PRINT, 0, 0, ! 243: 0, 0, 0, 1, 0, (time_t) 0, TRAILZ, pad); ! 244: outwrite(header, M_STRLEN + H_STRLEN); ! 245: outwrite(TRAILER, TRAILZ); ! 246: } ! 247: buf_pad((OFFSET) pad); ! 248: outflush(); ! 249: } ! 250: ! 251: ! 252: /* outwrite - write archive data ! 253: * ! 254: * DESCRIPTION ! 255: * ! 256: * Writes out data in the archive buffer to the archive file. The ! 257: * buffer index and the total byte count are incremented by the number ! 258: * of data bytes written. ! 259: * ! 260: * PARAMETERS ! 261: * ! 262: * char *idx - pointer to data to write ! 263: * uint len - length of the data to write ! 264: */ ! 265: ! 266: #if __STDC__ ! 267: ! 268: void outwrite(char *idx, uint len) ! 269: ! 270: #else ! 271: ! 272: void outwrite(idx, len) ! 273: char *idx; /* pointer to data to write */ ! 274: uint len; /* length of data to write */ ! 275: ! 276: #endif ! 277: { ! 278: uint have; ! 279: uint want; ! 280: char *endx; ! 281: ! 282: endx = idx + len; ! 283: while (want = endx - idx) { ! 284: if (bufend - bufidx < 0) { ! 285: fatal("Buffer overlow in out_write\n"); ! 286: } ! 287: if ((have = bufend - bufidx) == 0) { ! 288: outflush(); ! 289: } ! 290: if (have > want) { ! 291: have = want; ! 292: } ! 293: memcpy(bufidx, idx, (int) have); ! 294: bufidx += have; ! 295: idx += have; ! 296: total += have; ! 297: } ! 298: } ! 299: ! 300: ! 301: /* passdata - copy data to one file ! 302: * ! 303: * DESCRIPTION ! 304: * ! 305: * Copies a file from one place to another. Doesn't believe in input ! 306: * file descriptor zero (see description of kludge in openin() comments). ! 307: * Closes the provided output file descriptor. ! 308: * ! 309: * PARAMETERS ! 310: * ! 311: * char *from - input file name (old file) ! 312: * int ifd - input file descriptor ! 313: * char *to - output file name (new file) ! 314: * int ofd - output file descriptor ! 315: */ ! 316: ! 317: #if __STDC__ ! 318: ! 319: void passdata(char *from, int ifd, char *to, int ofd) ! 320: ! 321: #else ! 322: ! 323: void passdata(from, ifd, to, ofd) ! 324: char *from; ! 325: int ifd; ! 326: char *to; ! 327: int ofd; ! 328: ! 329: #endif ! 330: { ! 331: int got; ! 332: int sparse; ! 333: char block[BUFSIZ]; ! 334: ! 335: if (ifd) { ! 336: lseek(ifd, (OFFSET) 0, 0); ! 337: sparse = 0; ! 338: while ((got = read(ifd, block, sizeof(block))) > 0 ! 339: && (sparse = ar_write(ofd, block, (uint) got)) >= 0) { ! 340: total += got; ! 341: } ! 342: if (got) { ! 343: warn(got < 0 ? from : to, strerror()); ! 344: } else if (sparse > 0 ! 345: && (lseek(ofd, (OFFSET)(-sparse), 1) < 0 ! 346: || write(ofd, block, (uint) sparse) != sparse)) { ! 347: warn(to, strerror()); ! 348: } ! 349: } ! 350: close(ofd); ! 351: } ! 352: ! 353: ! 354: /* buf_allocate - get space for the I/O buffer ! 355: * ! 356: * DESCRIPTION ! 357: * ! 358: * buf_allocate allocates an I/O buffer using malloc. The resulting ! 359: * buffer is used for all data buffering throughout the program. ! 360: * Buf_allocate must be called prior to any use of the buffer or any ! 361: * of the buffering calls. ! 362: * ! 363: * PARAMETERS ! 364: * ! 365: * int size - size of the I/O buffer to request ! 366: * ! 367: * ERRORS ! 368: * ! 369: * If an invalid size is given for a buffer or if a buffer of the ! 370: * required size cannot be allocated, then the function prints out an ! 371: * error message and returns a non-zero exit status to the calling ! 372: * process, terminating the program. ! 373: * ! 374: */ ! 375: ! 376: #if __STDC__ ! 377: ! 378: void buf_allocate(OFFSET size) ! 379: ! 380: #else ! 381: ! 382: void buf_allocate(size) ! 383: OFFSET size; ! 384: ! 385: #endif ! 386: { ! 387: if (size <= 0) { ! 388: fatal("invalid value for blocksize"); ! 389: } ! 390: if ((bufstart = malloc((unsigned) size)) == (char *)NULL) { ! 391: fatal("Cannot allocate I/O buffer"); ! 392: } ! 393: bufend = bufidx = bufstart; ! 394: bufend += size; ! 395: } ! 396: ! 397: ! 398: /* buf_skip - skip input archive data ! 399: * ! 400: * DESCRIPTION ! 401: * ! 402: * Buf_skip skips past archive data. It is used when the length of ! 403: * the archive data is known, and we do not wish to process the data. ! 404: * ! 405: * PARAMETERS ! 406: * ! 407: * OFFSET len - number of bytes to skip ! 408: * ! 409: * RETURNS ! 410: * ! 411: * Returns zero under normal circumstances, -1 if unreadable data is ! 412: * encountered. ! 413: */ ! 414: ! 415: #if __STDC__ ! 416: ! 417: int buf_skip(OFFSET len) ! 418: ! 419: #else ! 420: ! 421: int buf_skip(len) ! 422: OFFSET len; ! 423: ! 424: #endif ! 425: { ! 426: uint chunk; ! 427: int corrupt = 0; ! 428: ! 429: while (len) { ! 430: if (bufend - bufidx < 0) { ! 431: fatal("Buffer overlow in buf_skip\n"); ! 432: } ! 433: while ((chunk = bufend - bufidx) == 0) { ! 434: corrupt |= ar_read(); ! 435: } ! 436: if (chunk > len) { ! 437: chunk = len; ! 438: } ! 439: bufidx += chunk; ! 440: len -= chunk; ! 441: total += chunk; ! 442: } ! 443: return (corrupt); ! 444: } ! 445: ! 446: ! 447: /* buf_read - read a given number of characters from the input archive ! 448: * ! 449: * DESCRIPTION ! 450: * ! 451: * Reads len number of characters from the input archive and ! 452: * stores them in the buffer pointed at by dst. ! 453: * ! 454: * PARAMETERS ! 455: * ! 456: * char *dst - pointer to buffer to store data into ! 457: * uint len - length of data to read ! 458: * ! 459: * RETURNS ! 460: * ! 461: * Returns zero with valid data, -1 if unreadable portions were ! 462: * replaced by null characters. ! 463: */ ! 464: ! 465: #if __STDC__ ! 466: ! 467: int buf_read(char *dst, uint len) ! 468: ! 469: #else ! 470: ! 471: int buf_read(dst, len) ! 472: char *dst; ! 473: uint len; ! 474: ! 475: #endif ! 476: { ! 477: int have; ! 478: int want; ! 479: int corrupt = 0; ! 480: char *endx = dst + len; ! 481: ! 482: while (want = endx - dst) { ! 483: if (bufend - bufidx < 0) { ! 484: fatal("Buffer overlow in buf_read\n"); ! 485: } ! 486: while ((have = bufend - bufidx) == 0) { ! 487: have = 0; ! 488: corrupt |= ar_read(); ! 489: } ! 490: if (have > want) { ! 491: have = want; ! 492: } ! 493: memcpy(dst, bufidx, have); ! 494: bufidx += have; ! 495: dst += have; ! 496: total += have; ! 497: } ! 498: return (corrupt); ! 499: } ! 500: ! 501: ! 502: /* indata - install data from an archive ! 503: * ! 504: * DESCRIPTION ! 505: * ! 506: * Indata writes size bytes of data from the archive buffer to the output ! 507: * file specified by fd. The filename which is being written, pointed ! 508: * to by name is provided only for diagnostics. ! 509: * ! 510: * PARAMETERS ! 511: * ! 512: * int fd - output file descriptor ! 513: * OFFSET size - number of bytes to write to output file ! 514: * char *name - name of file which corresponds to fd ! 515: * ! 516: * RETURNS ! 517: * ! 518: * Returns given file descriptor. ! 519: */ ! 520: ! 521: #if __STDC__ ! 522: ! 523: static int indata(int fd, OFFSET size, char *name) ! 524: ! 525: #else ! 526: ! 527: static int indata(fd, size, name) ! 528: int fd; ! 529: OFFSET size; ! 530: char *name; ! 531: ! 532: #endif ! 533: { ! 534: uint chunk; ! 535: char *oops; ! 536: int sparse; ! 537: int corrupt; ! 538: char *buf; ! 539: uint avail; ! 540: ! 541: corrupt = sparse = 0; ! 542: oops = (char *)NULL; ! 543: while (size) { ! 544: corrupt |= buf_in_avail(&buf, &avail); ! 545: size -= (chunk = size < avail ? (uint) size : avail); ! 546: if (oops == (char *)NULL && (sparse = ar_write(fd, buf, chunk)) < 0) { ! 547: oops = strerror(); ! 548: } ! 549: buf_use(chunk); ! 550: } ! 551: if (corrupt) { ! 552: warn(name, "Corrupt archive data"); ! 553: } ! 554: if (oops) { ! 555: warn(name, oops); ! 556: } else if (sparse > 0 && (lseek(fd, (OFFSET) - 1, 1) < 0 ! 557: || write(fd, "", 1) != 1)) { ! 558: warn(name, strerror()); ! 559: } ! 560: return (fd); ! 561: } ! 562: ! 563: ! 564: /* outflush - flush the output buffer ! 565: * ! 566: * DESCRIPTION ! 567: * ! 568: * The output buffer is written, if there is anything in it, to the ! 569: * archive file. ! 570: */ ! 571: ! 572: #if __STDC__ ! 573: ! 574: static void outflush(void) ! 575: ! 576: #else ! 577: ! 578: static void outflush() ! 579: ! 580: #endif ! 581: { ! 582: char *buf; ! 583: int got; ! 584: uint len; ! 585: ! 586: /* if (bufidx - buf > 0) */ ! 587: for (buf = bufstart; len = bufidx - buf;) { ! 588: if ((got = write(archivefd, buf, MIN(len, blocksize))) > 0) { ! 589: buf += got; ! 590: } else if (got < 0) { ! 591: next(AR_WRITE); ! 592: } ! 593: } ! 594: bufend = (bufidx = bufstart) + blocksize; ! 595: } ! 596: ! 597: ! 598: /* ar_read - fill the archive buffer ! 599: * ! 600: * DESCRIPTION ! 601: * ! 602: * Remembers mid-buffer read failures and reports them the next time ! 603: * through. Replaces unreadable data with null characters. Resets ! 604: * the buffer pointers as appropriate. ! 605: * ! 606: * RETURNS ! 607: * ! 608: * Returns zero with valid data, -1 otherwise. ! 609: */ ! 610: ! 611: #if __STDC__ ! 612: ! 613: int ar_read(void) ! 614: ! 615: #else ! 616: ! 617: int ar_read() ! 618: ! 619: #endif ! 620: { ! 621: int got; ! 622: static int failed; ! 623: static int myfld = 0; /* VLAD */ ! 624: ! 625: bufend = bufidx = bufstart; ! 626: if (!failed) { ! 627: if (areof) { ! 628: if (total == 0) { ! 629: fatal("No input"); ! 630: } else { ! 631: next(AR_READ); ! 632: } ! 633: } ! 634: while (!failed && !areof && bufstart + blocksize - bufend >= blocksize) { ! 635: if ((got = read(archivefd, bufend, (unsigned int) blocksize)) > 0) { ! 636: bufend += got; ! 637: if (myfld == 0) /* VLAD */ ! 638: myfld++; /* VLAD */ ! 639: } else if (got < 0 && myfld == 0) { /* VLAD */ ! 640: failed = -1; ! 641: warnarch(strerror(), (OFFSET) 0 - (bufend - bufidx)); ! 642: } else { ! 643: got = 0; /* VLAD */ ! 644: ++areof; ! 645: } ! 646: } ! 647: } ! 648: if (failed && bufend == bufstart) { ! 649: failed = 0; ! 650: for (got = 0; got < blocksize; ++got) { ! 651: *bufend++ = '\0'; ! 652: } ! 653: return (-1); ! 654: } ! 655: return (0); ! 656: } ! 657: ! 658: ! 659: /* ar_write - write a filesystem block ! 660: * ! 661: * DESCRIPTION ! 662: * ! 663: * Writes len bytes of data data from the specified buffer to the ! 664: * specified file. Seeks past sparse blocks. ! 665: * ! 666: * PARAMETERS ! 667: * ! 668: * int fd - file to write to ! 669: * char *buf - buffer to get data from ! 670: * uint len - number of bytes to transfer ! 671: * ! 672: * RETURNS ! 673: * ! 674: * Returns 0 if the block was written, the given length for a sparse ! 675: * block or -1 if unsuccessful. ! 676: */ ! 677: ! 678: #if __STDC__ ! 679: ! 680: static int ar_write(int fd, char *buf, uint len) ! 681: ! 682: #else ! 683: ! 684: static int ar_write(fd, buf, len) ! 685: int fd; ! 686: char *buf; ! 687: uint len; ! 688: ! 689: #endif ! 690: { ! 691: char *bidx; ! 692: char *bend; ! 693: ! 694: bend = (bidx = buf) + len; ! 695: while (bidx < bend) { ! 696: if (*bidx++) { ! 697: return (write(fd, buf, len) == len ? 0 : -1); ! 698: } ! 699: } ! 700: return (lseek(fd, (OFFSET) len, 1) < 0 ? -1 : len); ! 701: } ! 702: ! 703: ! 704: /* buf_pad - pad the archive buffer ! 705: * ! 706: * DESCRIPTION ! 707: * ! 708: * Buf_pad writes len zero bytes to the archive buffer in order to ! 709: * pad it. ! 710: * ! 711: * PARAMETERS ! 712: * ! 713: * OFFSET pad - number of zero bytes to pad ! 714: * ! 715: */ ! 716: ! 717: #if __STDC__ ! 718: ! 719: static void buf_pad(OFFSET pad) ! 720: ! 721: #else ! 722: ! 723: static void buf_pad(pad) ! 724: OFFSET pad; ! 725: ! 726: #endif ! 727: { ! 728: int idx; ! 729: int have; ! 730: ! 731: while (pad) { ! 732: if ((have = bufend - bufidx) > pad) { ! 733: have = pad; ! 734: } ! 735: for (idx = 0; idx < have; ++idx) { ! 736: *bufidx++ = '\0'; ! 737: } ! 738: total += have; ! 739: pad -= have; ! 740: if (bufend - bufidx == 0) { ! 741: outflush(); ! 742: } ! 743: } ! 744: } ! 745: ! 746: ! 747: /* buf_use - allocate buffer space ! 748: * ! 749: * DESCRIPTION ! 750: * ! 751: * Buf_use marks space in the buffer as being used; advancing both the ! 752: * buffer index (bufidx) and the total byte count (total). ! 753: * ! 754: * PARAMETERS ! 755: * ! 756: * uint len - Amount of space to allocate in the buffer ! 757: */ ! 758: ! 759: #if __STDC__ ! 760: ! 761: static void buf_use(uint len) ! 762: ! 763: #else ! 764: ! 765: static void buf_use(len) ! 766: uint len; ! 767: ! 768: #endif ! 769: { ! 770: bufidx += len; ! 771: total += len; ! 772: } ! 773: ! 774: ! 775: /* buf_in_avail - index available input data within the buffer ! 776: * ! 777: * DESCRIPTION ! 778: * ! 779: * Buf_in_avail fills the archive buffer, and points the bufp ! 780: * parameter at the start of the data. The lenp parameter is ! 781: * modified to contain the number of bytes which were read. ! 782: * ! 783: * PARAMETERS ! 784: * ! 785: * char **bufp - pointer to the buffer to read data into ! 786: * uint *lenp - pointer to the number of bytes which were read ! 787: * (returned to the caller) ! 788: * ! 789: * RETURNS ! 790: * ! 791: * Stores a pointer to the data and its length in given locations. ! 792: * Returns zero with valid data, -1 if unreadable portions were ! 793: * replaced with nulls. ! 794: * ! 795: * ERRORS ! 796: * ! 797: * If an error occurs in ar_read, the error code is returned to the ! 798: * calling function. ! 799: * ! 800: */ ! 801: ! 802: #if __STDC__ ! 803: ! 804: static int buf_in_avail(char **bufp, uint *lenp) ! 805: ! 806: #else ! 807: ! 808: static int buf_in_avail(bufp, lenp) ! 809: char **bufp; ! 810: uint *lenp; ! 811: ! 812: #endif ! 813: { ! 814: uint have; ! 815: int corrupt = 0; ! 816: ! 817: while ((have = bufend - bufidx) == 0) { ! 818: corrupt |= ar_read(); ! 819: } ! 820: *bufp = bufidx; ! 821: *lenp = have; ! 822: return (corrupt); ! 823: } ! 824: ! 825: ! 826: /* buf_out_avail - index buffer space for archive output ! 827: * ! 828: * DESCRIPTION ! 829: * ! 830: * Stores a buffer pointer at a given location. Returns the number ! 831: * of bytes available. ! 832: * ! 833: * PARAMETERS ! 834: * ! 835: * char **bufp - pointer to the buffer which is to be stored ! 836: * ! 837: * RETURNS ! 838: * ! 839: * The number of bytes which are available in the buffer. ! 840: * ! 841: */ ! 842: ! 843: #if __STDC__ ! 844: ! 845: static uint buf_out_avail(char **bufp) ! 846: ! 847: #else ! 848: ! 849: static uint buf_out_avail(bufp) ! 850: char **bufp; ! 851: ! 852: #endif ! 853: { ! 854: int have; ! 855: ! 856: if (bufend - bufidx < 0) { ! 857: fatal("Buffer overlow in buf_out_avail\n"); ! 858: } ! 859: if ((have = bufend - bufidx) == 0) { ! 860: outflush(); ! 861: } ! 862: *bufp = bufidx; ! 863: return (have); ! 864: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.