1 /* zlib.c --- interface to the zlib compression library 2 Ian Lance Taylor <ian@cygnus.com> 3 4 This file is part of GNU CVS. 5 6 GNU CVS is free software; you can redistribute it and/or modify it 7 under the terms of the GNU General Public License as published by the 8 Free Software Foundation; either version 2, or (at your option) any 9 later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. */ 15 16 /* The routines in this file are the interface between the CVS 17 client/server support and the zlib compression library. */ 18 19 #include "cvs.h" 20 #include "buffer.h" 21 #include "pagealign_alloc.h" 22 23 #if defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT) 24 25 #if HAVE_ZLIB_H 26 # include <zlib.h> 27 #else 28 # include "zlib.h" 29 #endif 30 31 /* OS/2 doesn't have EIO. FIXME: this whole notion of turning 32 a different error into EIO strikes me as pretty dubious. */ 33 #if !defined (EIO) 34 #define EIO EBADPOS 35 #endif 36 37 /* The compression interface is built upon the buffer data structure. 38 We provide a buffer type which compresses or decompresses the data 39 which passes through it. An input buffer decompresses the data 40 read from an underlying buffer, and an output buffer compresses the 41 data before writing it to an underlying buffer. */ 42 43 /* This structure is the closure field of the buffer. */ 44 45 struct compress_buffer 46 { 47 /* The underlying buffer. */ 48 struct buffer *buf; 49 50 /* The compression information. */ 51 z_stream zstr; 52 int level; 53 }; 54 55 static void compress_error (int, int, z_stream *, const char *); 56 static int compress_buffer_input (void *, char *, size_t, size_t, size_t *); 57 static int compress_buffer_output (void *, const char *, size_t, size_t *); 58 static int compress_buffer_flush (void *); 59 static int compress_buffer_block (void *, bool); 60 static int compress_buffer_get_fd (void *); 61 static int compress_buffer_shutdown_input (struct buffer *); 62 static int compress_buffer_shutdown_output (struct buffer *); 63 64 /* Report an error from one of the zlib functions. */ 65 66 static void 67 compress_error (int status, int zstatus, z_stream *zstr, const char *msg) 68 { 69 int hold_errno; 70 const char *zmsg; 71 char buf[100]; 72 73 hold_errno = errno; 74 75 zmsg = zstr->msg; 76 if (zmsg == NULL) 77 { 78 sprintf (buf, "error %d", zstatus); 79 zmsg = buf; 80 } 81 82 error (status, 83 zstatus == Z_ERRNO ? hold_errno : 0, 84 "%s: %s", msg, zmsg); 85 } 86 87 88 89 /* Create a compression buffer. */ 90 struct buffer * 91 compress_buffer_initialize (struct buffer *buf, int input, int level, 92 void (*memory) (struct buffer *)) 93 { 94 struct compress_buffer *n; 95 int zstatus; 96 97 n = xmalloc (sizeof *n); 98 memset (n, 0, sizeof *n); 99 100 n->buf = buf; 101 n->level = level; 102 103 if (input) 104 zstatus = inflateInit (&n->zstr); 105 else 106 zstatus = deflateInit (&n->zstr, level); 107 if (zstatus != Z_OK) 108 compress_error (1, zstatus, &n->zstr, "compression initialization"); 109 110 /* There may already be data buffered on BUF. For an output 111 buffer, this is OK, because these routines will just use the 112 buffer routines to append data to the (uncompressed) data 113 already on BUF. An input buffer expects to handle a single 114 buffer_data of buffered input to be uncompressed, so that is OK 115 provided there is only one buffer. At present that is all 116 there ever will be; if this changes, compress_buffer_input must 117 be modified to handle multiple input buffers. */ 118 assert (! input || buf->data == NULL || buf->data->next == NULL); 119 120 return buf_initialize (input ? compress_buffer_input : NULL, 121 input ? NULL : compress_buffer_output, 122 input ? NULL : compress_buffer_flush, 123 compress_buffer_block, compress_buffer_get_fd, 124 (input 125 ? compress_buffer_shutdown_input 126 : compress_buffer_shutdown_output), 127 memory, 128 n); 129 } 130 131 132 133 /* Input data from a compression buffer. */ 134 static int 135 compress_buffer_input (void *closure, char *data, size_t need, size_t size, 136 size_t *got) 137 { 138 struct compress_buffer *cb = closure; 139 struct buffer_data *bd; 140 141 assert (cb->buf->input); 142 143 /* We use a single buffer_data structure to buffer up data which 144 the z_stream structure won't use yet. We can safely store this 145 on cb->buf->data, because we never call the buffer routines on 146 cb->buf; we only call the buffer input routine, since that 147 gives us the semantics we want. As noted in 148 compress_buffer_initialize, the buffer_data structure may 149 already exist, and hold data which was already read and 150 buffered before the decompression began. */ 151 bd = cb->buf->data; 152 if (bd == NULL) 153 { 154 bd = xmalloc (sizeof (struct buffer_data)); 155 if (bd == NULL) 156 return -2; 157 bd->text = pagealign_xalloc (BUFFER_DATA_SIZE); 158 if (bd->text == NULL) 159 { 160 free (bd); 161 return -2; 162 } 163 bd->bufp = bd->text; 164 bd->size = 0; 165 cb->buf->data = bd; 166 } 167 168 cb->zstr.avail_out = size; 169 cb->zstr.next_out = (Bytef *) data; 170 171 while (1) 172 { 173 int zstatus, sofar, status; 174 size_t nread; 175 176 /* First try to inflate any data we already have buffered up. 177 This is useful even if we don't have any buffered data, 178 because there may be data buffered inside the z_stream 179 structure. */ 180 181 cb->zstr.avail_in = bd->size; 182 cb->zstr.next_in = (Bytef *) bd->bufp; 183 184 do 185 { 186 zstatus = inflate (&cb->zstr, Z_NO_FLUSH); 187 if (zstatus == Z_STREAM_END) 188 break; 189 if (zstatus != Z_OK && zstatus != Z_BUF_ERROR) 190 { 191 compress_error (0, zstatus, &cb->zstr, "inflate"); 192 return EIO; 193 } 194 } while (cb->zstr.avail_in > 0 195 && cb->zstr.avail_out > 0); 196 197 bd->size = cb->zstr.avail_in; 198 bd->bufp = (char *) cb->zstr.next_in; 199 200 sofar = size - cb->zstr.avail_out; 201 202 if (zstatus == Z_STREAM_END) 203 { 204 /* If we read any data, then return it, relying on the fact that 205 * we will get Z_STREAM_END on the next read too. 206 */ 207 if (sofar > 0) break; 208 209 /* Otherwise, return EOF. */ 210 return -1; 211 } 212 213 /* If we have obtained NEED bytes, then return, unless NEED is 214 zero and we haven't obtained anything at all. If NEED is 215 zero, we will attempt at least one nonblocking read and see if 216 we can inflate anything then. */ 217 if (sofar > 0 && sofar >= need) 218 break; 219 220 /* All our buffered data should have been processed at this 221 point. */ 222 assert (bd->size == 0); 223 224 /* This will work well in the server, because this call will 225 do an unblocked read and fetch all the available data. In 226 the client, this will read a single byte from the stdio 227 stream, which will cause us to call inflate once per byte. 228 It would be more efficient if we could make a call which 229 would fetch all the available bytes, and at least one byte. */ 230 231 status = (*cb->buf->input) (cb->buf->closure, bd->text, 232 need > 0 ? 1 : 0, BUFFER_DATA_SIZE, &nread); 233 234 if (status == -2) 235 /* Don't try to recover from memory allcoation errors. */ 236 return status; 237 238 if (status != 0) 239 { 240 /* If we read any data, then return it, relying on the fact that 241 * we will get the same error reading the underlying buffer 242 * on the next read too. 243 */ 244 if (sofar > 0) break; 245 246 /* Otherwise, return EOF. */ 247 return status; 248 } 249 250 /* If we didn't read anything, then presumably the buffer is 251 in nonblocking mode, and we should just get out now with 252 whatever we've inflated. */ 253 if (nread == 0) 254 { 255 assert (need == 0); 256 break; 257 } 258 259 bd->bufp = bd->text; 260 bd->size = nread; 261 } 262 263 *got = size - cb->zstr.avail_out; 264 265 return 0; 266 } 267 268 269 270 extern int gzip_level; 271 272 /* Output data to a compression buffer. 273 * 274 * GLOBALS 275 * gzip_level If GZIP_LEVEL has changed to a value different from 276 * CLOSURE->level, then set the compression level on the 277 * stream to the new value. 278 */ 279 static int 280 compress_buffer_output (void *closure, const char *data, size_t have, 281 size_t *wrote) 282 { 283 struct compress_buffer *cb = closure; 284 285 /* This is only used within the while loop below, but allocated here for 286 * efficiency. 287 */ 288 static char *buffer = NULL; 289 if (!buffer) 290 buffer = pagealign_xalloc (BUFFER_DATA_SIZE); 291 292 if (cb->level != gzip_level) 293 { 294 cb->level = gzip_level; 295 deflateParams (&cb->zstr, gzip_level, Z_DEFAULT_STRATEGY); 296 } 297 298 cb->zstr.avail_in = have; 299 cb->zstr.next_in = (unsigned char *) data; 300 301 while (cb->zstr.avail_in > 0) 302 { 303 int zstatus; 304 305 cb->zstr.avail_out = BUFFER_DATA_SIZE; 306 cb->zstr.next_out = (unsigned char *) buffer; 307 308 zstatus = deflate (&cb->zstr, Z_NO_FLUSH); 309 if (zstatus != Z_OK) 310 { 311 compress_error (0, zstatus, &cb->zstr, "deflate"); 312 return EIO; 313 } 314 315 if (cb->zstr.avail_out != BUFFER_DATA_SIZE) 316 buf_output (cb->buf, buffer, 317 BUFFER_DATA_SIZE - cb->zstr.avail_out); 318 } 319 320 *wrote = have; 321 322 /* We will only be here because buf_send_output was called on the 323 compression buffer. That means that we should now call 324 buf_send_output on the underlying buffer. */ 325 return buf_send_output (cb->buf); 326 } 327 328 329 330 /* Flush a compression buffer. */ 331 static int 332 compress_buffer_flush (void *closure) 333 { 334 struct compress_buffer *cb = closure; 335 336 /* This is only used within the while loop below, but allocated here for 337 * efficiency. 338 */ 339 static char *buffer = NULL; 340 if (!buffer) 341 buffer = pagealign_xalloc (BUFFER_DATA_SIZE); 342 343 cb->zstr.avail_in = 0; 344 cb->zstr.next_in = NULL; 345 346 while (1) 347 { 348 int zstatus; 349 350 cb->zstr.avail_out = BUFFER_DATA_SIZE; 351 cb->zstr.next_out = (unsigned char *) buffer; 352 353 zstatus = deflate (&cb->zstr, Z_SYNC_FLUSH); 354 355 /* The deflate function will return Z_BUF_ERROR if it can't do 356 anything, which in this case means that all data has been 357 flushed. */ 358 if (zstatus == Z_BUF_ERROR) 359 break; 360 361 if (zstatus != Z_OK) 362 { 363 compress_error (0, zstatus, &cb->zstr, "deflate flush"); 364 return EIO; 365 } 366 367 if (cb->zstr.avail_out != BUFFER_DATA_SIZE) 368 buf_output (cb->buf, buffer, 369 BUFFER_DATA_SIZE - cb->zstr.avail_out); 370 371 /* If the deflate function did not fill the output buffer, 372 then all data has been flushed. */ 373 if (cb->zstr.avail_out > 0) 374 break; 375 } 376 377 /* Now flush the underlying buffer. Note that if the original 378 call to buf_flush passed 1 for the BLOCK argument, then the 379 buffer will already have been set into blocking mode, so we 380 should always pass 0 here. */ 381 return buf_flush (cb->buf, 0); 382 } 383 384 385 386 /* The block routine for a compression buffer. */ 387 static int 388 compress_buffer_block (void *closure, bool block) 389 { 390 struct compress_buffer *cb = closure; 391 392 if (block) 393 return set_block (cb->buf); 394 else 395 return set_nonblock (cb->buf); 396 } 397 398 399 400 /* Return the file descriptor underlying any child buffers. */ 401 static int 402 compress_buffer_get_fd (void *closure) 403 { 404 struct compress_buffer *cb = closure; 405 return buf_get_fd (cb->buf); 406 } 407 408 409 410 /* Shut down an input buffer. */ 411 static int 412 compress_buffer_shutdown_input (struct buffer *buf) 413 { 414 struct compress_buffer *cb = buf->closure; 415 int zstatus; 416 417 /* Don't make any attempt to pick up trailing data since we are shutting 418 * down. If the client doesn't know we are shutting down, we might not 419 * see the EOF we are expecting. 420 */ 421 422 zstatus = inflateEnd (&cb->zstr); 423 if (zstatus != Z_OK) 424 { 425 compress_error (0, zstatus, &cb->zstr, "inflateEnd"); 426 return EIO; 427 } 428 429 return buf_shutdown (cb->buf); 430 } 431 432 433 434 /* Shut down an output buffer. */ 435 static int 436 compress_buffer_shutdown_output (struct buffer *buf) 437 { 438 struct compress_buffer *cb = buf->closure; 439 int zstatus, status; 440 441 /* This is only used within the while loop below, but allocated here for 442 * efficiency. 443 */ 444 static char *buffer = NULL; 445 if (!buffer) 446 buffer = pagealign_xalloc (BUFFER_DATA_SIZE); 447 448 do 449 { 450 cb->zstr.avail_out = BUFFER_DATA_SIZE; 451 cb->zstr.next_out = (unsigned char *) buffer; 452 453 zstatus = deflate (&cb->zstr, Z_FINISH); 454 if (zstatus != Z_OK && zstatus != Z_STREAM_END) 455 { 456 compress_error (0, zstatus, &cb->zstr, "deflate finish"); 457 return EIO; 458 } 459 460 if (cb->zstr.avail_out != BUFFER_DATA_SIZE) 461 buf_output (cb->buf, buffer, 462 BUFFER_DATA_SIZE - cb->zstr.avail_out); 463 } while (zstatus != Z_STREAM_END); 464 465 zstatus = deflateEnd (&cb->zstr); 466 if (zstatus != Z_OK) 467 { 468 compress_error (0, zstatus, &cb->zstr, "deflateEnd"); 469 return EIO; 470 } 471 472 status = buf_flush (cb->buf, 1); 473 if (status != 0) 474 return status; 475 476 return buf_shutdown (cb->buf); 477 } 478 479 480 481 /* Here is our librarified gzip implementation. It is very minimal 482 but attempts to be RFC1952 compliant. */ 483 484 /* GZIP ID byte values */ 485 #define GZIP_ID1 31 486 #define GZIP_ID2 139 487 488 /* Compression methods */ 489 #define GZIP_CDEFLATE 8 490 491 /* Flags */ 492 #define GZIP_FTEXT 1 493 #define GZIP_FHCRC 2 494 #define GZIP_FEXTRA 4 495 #define GZIP_FNAME 8 496 #define GZIP_FCOMMENT 16 497 498 /* BUF should contain SIZE bytes of gzipped data (RFC1952/RFC1951). 499 We are to uncompress the data and write the result to the file 500 descriptor FD. If something goes wrong, give a nonfatal error message 501 mentioning FULLNAME as the name of the file for FD. Return 1 if 502 it is an error we can't recover from. */ 503 504 int 505 gunzip_and_write (int fd, const char *fullname, unsigned char *buf, 506 size_t size) 507 { 508 size_t pos; 509 z_stream zstr; 510 int zstatus; 511 unsigned char outbuf[32768]; 512 unsigned long crc; 513 514 if (size < 10) 515 { 516 error (0, 0, "gzipped data too small - lacks complete header"); 517 return 1; 518 } 519 if (buf[0] != GZIP_ID1 || buf[1] != GZIP_ID2) 520 { 521 error (0, 0, "gzipped data does not start with gzip identification"); 522 return 1; 523 } 524 if (buf[2] != GZIP_CDEFLATE) 525 { 526 error (0, 0, "only the deflate compression method is supported"); 527 return 1; 528 } 529 530 /* Skip over the fixed header, and then skip any of the variable-length 531 fields. As we skip each field, we keep pos <= size. The checks 532 on positions and lengths are really checks for malformed or 533 incomplete gzip data. */ 534 pos = 10; 535 if (buf[3] & GZIP_FEXTRA) 536 { 537 if (pos + 2 >= size) 538 { 539 error (0, 0, "%s lacks proper gzip XLEN field", fullname); 540 return 1; 541 } 542 pos += buf[pos] + (buf[pos + 1] << 8) + 2; 543 if (pos > size) 544 { 545 error (0, 0, "%s lacks proper gzip \"extra field\"", fullname); 546 return 1; 547 } 548 549 } 550 if (buf[3] & GZIP_FNAME) 551 { 552 unsigned char *p = memchr(buf + pos, '\0', size - pos); 553 if (p == NULL) 554 { 555 error (0, 0, "%s has bad gzip filename field", fullname); 556 return 1; 557 } 558 pos = p - buf + 1; 559 } 560 if (buf[3] & GZIP_FCOMMENT) 561 { 562 unsigned char *p = memchr(buf + pos, '\0', size - pos); 563 if (p == NULL) 564 { 565 error (0, 0, "%s has bad gzip comment field", fullname); 566 return 1; 567 } 568 pos = p - buf + 1; 569 } 570 if (buf[3] & GZIP_FHCRC) 571 { 572 pos += 2; 573 if (pos > size) 574 { 575 error (0, 0, "%s has bad gzip CRC16 field", fullname); 576 return 1; 577 } 578 } 579 580 /* There could be no data to decompress - check and short circuit. */ 581 if (pos >= size) 582 { 583 error (0, 0, "gzip data incomplete for %s (no data)", fullname); 584 return 1; 585 } 586 587 memset (&zstr, 0, sizeof zstr); 588 /* Passing a negative argument tells zlib not to look for a zlib 589 (RFC1950) header. This is an undocumented feature; I suppose if 590 we wanted to be anal we could synthesize a header instead, 591 but why bother? */ 592 zstatus = inflateInit2 (&zstr, -15); 593 594 if (zstatus != Z_OK) 595 compress_error (1, zstatus, &zstr, fullname); 596 597 /* I don't see why we should have to include the 8 byte trailer in 598 avail_in. But I see that zlib/gzio.c does, and it seemed to fix 599 a fairly rare bug in which we'd get a Z_BUF_ERROR for no obvious 600 reason. */ 601 zstr.avail_in = size - pos; 602 zstr.next_in = buf + pos; 603 604 crc = crc32 (0, NULL, 0); 605 606 do 607 { 608 zstr.avail_out = sizeof (outbuf); 609 zstr.next_out = outbuf; 610 zstatus = inflate (&zstr, Z_NO_FLUSH); 611 if (zstatus != Z_STREAM_END && zstatus != Z_OK) 612 { 613 compress_error (0, zstatus, &zstr, fullname); 614 return 1; 615 } 616 if (write (fd, outbuf, sizeof (outbuf) - zstr.avail_out) < 0) 617 { 618 error (0, errno, "writing decompressed file %s", fullname); 619 return 1; 620 } 621 crc = crc32 (crc, outbuf, sizeof (outbuf) - zstr.avail_out); 622 } while (zstatus != Z_STREAM_END); 623 zstatus = inflateEnd (&zstr); 624 if (zstatus != Z_OK) 625 compress_error (0, zstatus, &zstr, fullname); 626 627 /* Check that there is still 8 trailer bytes remaining (CRC32 628 and ISIZE). Check total decomp. data, plus header len (pos) 629 against input buffer total size. */ 630 pos += zstr.total_in; 631 if (size - pos != 8) 632 { 633 error (0, 0, "gzip data incomplete for %s (no trailer)", fullname); 634 return 1; 635 } 636 637 if (crc != ((unsigned long)buf[pos] 638 + ((unsigned long)buf[pos + 1] << 8) 639 + ((unsigned long)buf[pos + 2] << 16) 640 + ((unsigned long)buf[pos + 3] << 24))) 641 { 642 error (0, 0, "CRC error uncompressing %s", fullname); 643 return 1; 644 } 645 646 if (zstr.total_out != ((unsigned long)buf[pos + 4] 647 + ((unsigned long)buf[pos + 5] << 8) 648 + ((unsigned long)buf[pos + 6] << 16) 649 + ((unsigned long)buf[pos + 7] << 24))) 650 { 651 error (0, 0, "invalid length uncompressing %s", fullname); 652 return 1; 653 } 654 655 return 0; 656 } 657 658 /* Read all of FD and put the gzipped data (RFC1952/RFC1951) into *BUF, 659 replacing previous contents of *BUF. *BUF is xmalloc'd and *SIZE is 660 its allocated size. Put the actual number of bytes of data in 661 *LEN. If something goes wrong, give a nonfatal error mentioning 662 FULLNAME as the name of the file for FD, and return 1 if we can't 663 recover from it). LEVEL is the compression level (1-9). */ 664 665 int 666 read_and_gzip (int fd, const char *fullname, unsigned char **buf, size_t *size, 667 size_t *len, int level) 668 { 669 z_stream zstr; 670 int zstatus; 671 unsigned char inbuf[8192]; 672 int nread; 673 unsigned long crc; 674 675 if (*size < 1024) 676 { 677 unsigned char *newbuf; 678 679 *size = 1024; 680 newbuf = xrealloc (*buf, *size); 681 if (newbuf == NULL) 682 { 683 error (0, 0, "out of memory"); 684 return 1; 685 } 686 *buf = newbuf; 687 } 688 (*buf)[0] = GZIP_ID1; 689 (*buf)[1] = GZIP_ID2; 690 (*buf)[2] = GZIP_CDEFLATE; 691 (*buf)[3] = 0; 692 (*buf)[4] = (*buf)[5] = (*buf)[6] = (*buf)[7] = 0; 693 /* Could set this based on level, but why bother? */ 694 (*buf)[8] = 0; 695 (*buf)[9] = 255; 696 697 memset (&zstr, 0, sizeof zstr); 698 zstatus = deflateInit2 (&zstr, level, Z_DEFLATED, -15, 8, 699 Z_DEFAULT_STRATEGY); 700 crc = crc32 (0, NULL, 0); 701 if (zstatus != Z_OK) 702 { 703 compress_error (0, zstatus, &zstr, fullname); 704 return 1; 705 } 706 707 /* Adjust for 10-byte output header (filled in above) */ 708 zstr.total_out = 10; 709 zstr.avail_out = *size - 10; 710 zstr.next_out = *buf + 10; 711 712 while (1) 713 { 714 int finish = 0; 715 716 nread = read (fd, inbuf, sizeof inbuf); 717 if (nread < 0) 718 { 719 error (0, errno, "cannot read %s", fullname); 720 return 1; 721 } 722 else if (nread == 0) 723 /* End of file. */ 724 finish = 1; 725 crc = crc32 (crc, inbuf, nread); 726 zstr.next_in = inbuf; 727 zstr.avail_in = nread; 728 729 do 730 { 731 /* I don't see this documented anywhere, but deflate seems 732 to tend to dump core sometimes if we pass it Z_FINISH and 733 a small (e.g. 2147 byte) avail_out. So we insist on at 734 least 4096 bytes (that is what zlib/gzio.c uses). */ 735 736 if (zstr.avail_out < 4096) 737 { 738 unsigned char *newbuf; 739 740 assert(zstr.avail_out + zstr.total_out == *size); 741 assert(zstr.next_out == *buf + zstr.total_out); 742 *size *= 2; 743 newbuf = xrealloc (*buf, *size); 744 if (newbuf == NULL) 745 { 746 error (0, 0, "out of memory"); 747 return 1; 748 } 749 *buf = newbuf; 750 zstr.next_out = *buf + zstr.total_out; 751 zstr.avail_out = *size - zstr.total_out; 752 assert(zstr.avail_out + zstr.total_out == *size); 753 assert(zstr.next_out == *buf + zstr.total_out); 754 } 755 756 zstatus = deflate (&zstr, finish ? Z_FINISH : 0); 757 if (zstatus == Z_STREAM_END) 758 goto done; 759 else if (zstatus != Z_OK) 760 compress_error (0, zstatus, &zstr, fullname); 761 } while (zstr.avail_out == 0); 762 } 763 done: 764 /* Need to add the CRC information (8 bytes) 765 to the end of the gzip'd output. 766 Ensure there is enough space in the output buffer 767 to do so. */ 768 if (zstr.avail_out < 8) 769 { 770 unsigned char *newbuf; 771 772 assert(zstr.avail_out + zstr.total_out == *size); 773 assert(zstr.next_out == *buf + zstr.total_out); 774 *size += 8 - zstr.avail_out; 775 newbuf = realloc (*buf, *size); 776 if (newbuf == NULL) 777 { 778 error (0, 0, "out of memory"); 779 return 1; 780 } 781 *buf = newbuf; 782 zstr.next_out = *buf + zstr.total_out; 783 zstr.avail_out = *size - zstr.total_out; 784 assert(zstr.avail_out + zstr.total_out == *size); 785 assert(zstr.next_out == *buf + zstr.total_out); 786 } 787 *zstr.next_out++ = (unsigned char)(crc & 0xff); 788 *zstr.next_out++ = (unsigned char)((crc >> 8) & 0xff); 789 *zstr.next_out++ = (unsigned char)((crc >> 16) & 0xff); 790 *zstr.next_out++ = (unsigned char)((crc >> 24) & 0xff); 791 792 *zstr.next_out++ = (unsigned char)(zstr.total_in & 0xff); 793 *zstr.next_out++ = (unsigned char)((zstr.total_in >> 8) & 0xff); 794 *zstr.next_out++ = (unsigned char)((zstr.total_in >> 16) & 0xff); 795 *zstr.next_out++ = (unsigned char)((zstr.total_in >> 24) & 0xff); 796 797 zstr.total_out += 8; 798 zstr.avail_out -= 8; 799 assert(zstr.avail_out + zstr.total_out == *size); 800 assert(zstr.next_out == *buf + zstr.total_out); 801 802 *len = zstr.total_out; 803 804 zstatus = deflateEnd (&zstr); 805 if (zstatus != Z_OK) 806 compress_error (0, zstatus, &zstr, fullname); 807 808 return 0; 809 } 810 #endif /* defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT) */ 811