contrib/cvs-1.12/src/zlib.c

   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) */