U++

version 1.2.11, January 15th, 2017

Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler

Changes in 1.2.11 (15 Jan 2017)

- Fix deflate stored bug when pulling last block from window

- Permit immediate deflateParams changes before any deflate input

Changes in 1.2.10 (2 Jan 2017)

- Avoid warnings on snprintf() return value

- Fix bug in deflate_stored() for zero-length input

- Fix bug in gzwrite.c that produced corrupt gzip files

- Remove files to be installed before copying them in Makefile.in

- Add warnings when compiling with assembler code

Changes in 1.2.9 (31 Dec 2016)

- Fix contrib/minizip to permit unzipping with desktop API [Zouzou]

- Improve contrib/blast to return unused bytes

- Assure that gzoffset() is correct when appending

- Improve compress() and uncompress() to support large lengths

- Fix bug in test/example.c where error code not saved

- Remedy Coverity warning [Randers-Pehrson]

- Improve speed of gzprintf() in transparent mode

- Fix inflateInit2() bug when windowBits is 16 or 32

- Change DEBUG macro to ZLIB_DEBUG

- Avoid uninitialized access by gzclose_w()

- Allow building zlib outside of the source directory

- Fix bug that accepted invalid zlib header when windowBits is zero

- Fix gzseek() problem on MinGW due to buggy _lseeki64 there

- Loop on write() calls in gzwrite.c in case of non-blocking I/O

- Add --warn (-w) option to ./configure for more compiler warnings

- Reject a window size of 256 bytes if not using the zlib wrapper

- Fix bug when level 0 used with Z_HUFFMAN or Z_RLE

- Add --debug (-d) option to ./configure to define ZLIB_DEBUG

- Fix bugs in creating a very large gzip header

- Add uncompress2() function, which returns the input size used

- Assure that deflateParams() will not switch functions mid-block

- Dramatically speed up deflation for level 0 (storing)

- Add gzfread(), duplicating the interface of fread()

- Add gzfwrite(), duplicating the interface of fwrite()

- Add deflateGetDictionary() function

- Use snprintf() for later versions of Microsoft C

- Fix *Init macros to use z_ prefix when requested

- Replace as400 with os400 for OS/400 support [Monnerat]

- Add crc32_z() and adler32_z() functions with size_t lengths

- Update Visual Studio project files [AraHaan]

- Clean up contrib/vstudio [Roß]

- Fix uninitialized value bug in gzputc() introduced by const patches

- Add a ./config --solo option to make zlib subset with no library use

- Use fdopen() (not _fdopen()) for Interix in zutil.h [Bäck]

   contrib/iostream2/  by Tyge Løvset <Tyge.Lovset@cmr.no>

- fix deflateParams() which could generate bad compressed data.

zlib 1.2.11 is a general purpose data compression library.  All the code is

The changes made in version 1.2.11 are documented in the file ChangeLog.

 (C) 1995-2017 Jean-loup Gailly and Mark Adler

 * Copyright (C) 1995-2011, 2016 Mark Adler

#define BASE 65521U     /* largest prime smaller than 65536 */

uLong ZEXPORT adler32_z(adler, buf, len)

    z_size_t len;

uLong ZEXPORT adler32(adler, buf, len)

    uLong adler;

    const Bytef *buf;

    uInt len;

{

    return adler32_z(adler, buf, len);

}

/* ========================================================================= */

    if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);

 * Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler

    const uInt max = (uInt)-1;

    uLong left;

    left = *destLen;

    *destLen = 0;

    stream.next_out = dest;

    stream.avail_out = 0;

    stream.next_in = (z_const Bytef *)source;

    stream.avail_in = 0;

    do {

        if (stream.avail_out == 0) {

            stream.avail_out = left > (uLong)max ? max : (uInt)left;

            left -= stream.avail_out;

        }

        if (stream.avail_in == 0) {

            stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;

            sourceLen -= stream.avail_in;

        }

        err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);

    } while (err == Z_OK);

    *destLen = stream.total_out;

    deflateEnd(&stream);

    return err == Z_STREAM_END ? Z_OK : err;

 * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler

                        const unsigned char FAR *, z_size_t));

                        const unsigned char FAR *, z_size_t));

unsigned long ZEXPORT crc32_z(crc, buf, len)

    z_size_t len;

/* ========================================================================= */

unsigned long ZEXPORT crc32(crc, buf, len)

    unsigned long crc;

    const unsigned char FAR *buf;

    uInt len;

{

    return crc32_z(crc, buf, len);

}

/*

   This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit

   integer pointer type. This violates the strict aliasing rule, where a

   compiler can assume, for optimization purposes, that two pointers to

   fundamentally different types won't ever point to the same memory. This can

   manifest as a problem only if one of the pointers is written to. This code

   only reads from those pointers. So long as this code remains isolated in

   this compilation unit, there won't be a problem. For this reason, this code

   should not be copied and pasted into a compilation unit in which other code

   writes to the buffer that is passed to these routines.

 */

    z_size_t len;

#define DOBIG4 c ^= *buf4++; \

    z_size_t len;

 * Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler

   " deflate 1.2.11 Copyright 1995-2017 Jean-loup Gailly and Mark Adler ";

local int deflateStateCheck      OF((z_streamp strm));

local void slide_hash     OF((deflate_state *s));

local unsigned read_buf   OF((z_streamp strm, Bytef *buf, unsigned size));

#  pragma message("Assembler code may have bugs -- use at your own risk")

#ifdef ZLIB_DEBUG

#define RANK(f) (((f) * 2) - ((f) > 4 ? 9 : 0))

 * IN  assertion: all calls to UPDATE_HASH are made with consecutive input

 *    characters, so that a running hash key can be computed from the previous

 *    key instead of complete recalculation each time.

 * IN  assertion: all calls to INSERT_STRING are made with consecutive input

 *    characters and the first MIN_MATCH bytes of str are valid (except for

 *    the last MIN_MATCH-1 bytes of the input file).

/* ===========================================================================

 * Slide the hash table when sliding the window down (could be avoided with 32

 * bit values at the expense of memory usage). We slide even when level == 0 to

 * keep the hash table consistent if we switch back to level > 0 later.

 */

local void slide_hash(s)

    deflate_state *s;

{

    unsigned n, m;

    Posf *p;

    uInt wsize = s->w_size;

    n = s->hash_size;

    p = &s->head[n];

    do {

        m = *--p;

        *p = (Pos)(m >= wsize ? m - wsize : NIL);

    } while (--n);

    n = wsize;

#ifndef FASTEST

    p = &s->prev[n];

    do {

        m = *--p;

        *p = (Pos)(m >= wsize ? m - wsize : NIL);

        /* If n is not on any hash chain, prev[n] is garbage but

         * its value will never be used.

         */

    } while (--n);

#endif

}

        strategy < 0 || strategy > Z_FIXED || (windowBits == 8 && wrap != 1)) {

    s->status = INIT_STATE;     /* to pass state test in deflateReset() */

    s->w_bits = (uInt)windowBits;

    s->hash_bits = (uInt)memLevel + 7;

/* =========================================================================

 * Check for a valid deflate stream state. Return 0 if ok, 1 if not.

 */

local int deflateStateCheck (strm)

    z_streamp strm;

{

    deflate_state *s;

    if (strm == Z_NULL ||

        strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)

        return 1;

    s = strm->state;

    if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&

#ifdef GZIP

                                           s->status != GZIP_STATE &&

#endif

                                           s->status != EXTRA_STATE &&

                                           s->status != NAME_STATE &&

                                           s->status != COMMENT_STATE &&

                                           s->status != HCRC_STATE &&

                                           s->status != BUSY_STATE &&

                                           s->status != FINISH_STATE))

        return 1;

    return 0;

}

    if (deflateStateCheck(strm) || dictionary == Z_NULL)

int ZEXPORT deflateGetDictionary (strm, dictionary, dictLength)

    z_streamp strm;

    Bytef *dictionary;

    uInt  *dictLength;

{

    deflate_state *s;

    uInt len;

    if (deflateStateCheck(strm))

        return Z_STREAM_ERROR;

    s = strm->state;

    len = s->strstart + s->lookahead;

    if (len > s->w_size)

        len = s->w_size;

    if (dictionary != Z_NULL && len)

        zmemcpy(dictionary, s->window + s->strstart + s->lookahead - len, len);

    if (dictLength != Z_NULL)

        *dictLength = len;

    return Z_OK;

}

/* ========================================================================= */

    if (deflateStateCheck(strm)) {

    s->status =

#ifdef GZIP

        s->wrap == 2 ? GZIP_STATE :

#endif

        s->wrap ? INIT_STATE : BUSY_STATE;

    if (deflateStateCheck(strm) || strm->state->wrap != 2)

        return Z_STREAM_ERROR;

    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;

    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;

    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;

        s->high_water) {

        int err = deflate(strm, Z_BLOCK);

        if (err == Z_STREAM_ERROR)

            return err;

        if (strm->avail_out == 0)

            return Z_BUF_ERROR;

        if (s->level == 0 && s->matches != 0) {

            if (s->matches == 1)

                slide_hash(s);

            else

                CLEAR_HASH(s);

            s->matches = 0;

        }

    return Z_OK;

    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;

    s->good_match = (uInt)good_length;

    s->max_lazy_match = (uInt)max_lazy;

    s->max_chain_length = (uInt)max_chain;

    if (deflateStateCheck(strm))

#ifdef GZIP

            Bytef *str;

#endif

 * Flush as much pending output as possible. All deflate() output, except for

 * some deflate_stored() output, goes through this function so some

 * applications may wish to modify it to avoid allocating a large

 * strm->next_out buffer and copying into it. (See also read_buf()).

    strm->avail_out -= len;

    s->pending      -= len;

/* ===========================================================================

 * Update the header CRC with the bytes s->pending_buf[beg..s->pending - 1].

 */

#define HCRC_UPDATE(beg) \

    do { \

        if (s->gzhead->hcrc && s->pending > (beg)) \

            strm->adler = crc32(strm->adler, s->pending_buf + (beg), \

                                s->pending - (beg)); \

    } while (0)

    if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) {

        (strm->avail_in != 0 && strm->next_in == Z_NULL) ||

    /* Flush as much pending output as possible */

    if (s->pending != 0) {

        flush_pending(strm);

        if (strm->avail_out == 0) {

            /* Since avail_out is 0, deflate will be called again with

             * more output space, but possibly with both pending and

             * avail_in equal to zero. There won't be anything to do,

             * but this is not an error situation so make sure we

             * return OK instead of BUF_ERROR at next call of deflate:

             */

            s->last_flush = -1;

            return Z_OK;

        }

    /* Make sure there is something to do and avoid duplicate consecutive

     * flushes. For repeated and useless calls with Z_FINISH, we keep

     * returning Z_STREAM_END instead of Z_BUF_ERROR.

     */

    } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&

               flush != Z_FINISH) {

        ERR_RETURN(strm, Z_BUF_ERROR);

    }

    /* User must not provide more input after the first FINISH: */

    if (s->status == FINISH_STATE && strm->avail_in != 0) {

        ERR_RETURN(strm, Z_BUF_ERROR);

    }

        /* zlib header */

        uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;

        uInt level_flags;

        if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)

            level_flags = 0;

        else if (s->level < 6)

            level_flags = 1;

        else if (s->level == 6)

            level_flags = 2;

            level_flags = 3;

        header |= (level_flags << 6);

        if (s->strstart != 0) header |= PRESET_DICT;

        header += 31 - (header % 31);

        putShortMSB(s, header);

        /* Save the adler32 of the preset dictionary: */

        if (s->strstart != 0) {

            putShortMSB(s, (uInt)(strm->adler >> 16));

            putShortMSB(s, (uInt)(strm->adler & 0xffff));

        }

        strm->adler = adler32(0L, Z_NULL, 0);

        s->status = BUSY_STATE;

        /* Compression must start with an empty pending buffer */

        flush_pending(strm);

        if (s->pending != 0) {

            s->last_flush = -1;

            return Z_OK;

        }

    }

#ifdef GZIP

    if (s->status == GZIP_STATE) {

        /* gzip header */

        strm->adler = crc32(0L, Z_NULL, 0);

        put_byte(s, 31);

        put_byte(s, 139);

        put_byte(s, 8);

        if (s->gzhead == Z_NULL) {

            put_byte(s, 0);

            put_byte(s, 0);

            put_byte(s, 0);

            put_byte(s, 0);

            put_byte(s, 0);

            put_byte(s, s->level == 9 ? 2 :

                     (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?

                      4 : 0));

            put_byte(s, OS_CODE);

            /* Compression must start with an empty pending buffer */

            flush_pending(strm);

            if (s->pending != 0) {

                s->last_flush = -1;

                return Z_OK;

        }

        else {

            put_byte(s, (s->gzhead->text ? 1 : 0) +

                     (s->gzhead->hcrc ? 2 : 0) +

                     (s->gzhead->extra == Z_NULL ? 0 : 4) +

                     (s->gzhead->name == Z_NULL ? 0 : 8) +

                     (s->gzhead->comment == Z_NULL ? 0 : 16)

                     );

            put_byte(s, (Byte)(s->gzhead->time & 0xff));

            put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));

            put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));

            put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));

            put_byte(s, s->level == 9 ? 2 :

                     (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?

                      4 : 0));

            put_byte(s, s->gzhead->os & 0xff);

            if (s->gzhead->extra != Z_NULL) {

                put_byte(s, s->gzhead->extra_len & 0xff);

                put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);

            }

            if (s->gzhead->hcrc)

                strm->adler = crc32(strm->adler, s->pending_buf,

                                    s->pending);

            s->gzindex = 0;

            s->status = EXTRA_STATE;

            ulg beg = s->pending;   /* start of bytes to update crc */

            uInt left = (s->gzhead->extra_len & 0xffff) - s->gzindex;

            while (s->pending + left > s->pending_buf_size) {

                uInt copy = s->pending_buf_size - s->pending;

                zmemcpy(s->pending_buf + s->pending,

                        s->gzhead->extra + s->gzindex, copy);

                s->pending = s->pending_buf_size;

                HCRC_UPDATE(beg);

                s->gzindex += copy;

                flush_pending(strm);

                if (s->pending != 0) {

                    s->last_flush = -1;

                    return Z_OK;

                beg = 0;

                left -= copy;

            zmemcpy(s->pending_buf + s->pending,

                    s->gzhead->extra + s->gzindex, left);

            s->pending += left;

            HCRC_UPDATE(beg);

            s->gzindex = 0;

        s->status = NAME_STATE;

            ulg beg = s->pending;   /* start of bytes to update crc */

                    HCRC_UPDATE(beg);

                    if (s->pending != 0) {

                        s->last_flush = -1;

                        return Z_OK;

                    beg = 0;

            HCRC_UPDATE(beg);

            s->gzindex = 0;

        s->status = COMMENT_STATE;

            ulg beg = s->pending;   /* start of bytes to update crc */

                    HCRC_UPDATE(beg);

                    if (s->pending != 0) {

                        s->last_flush = -1;

                        return Z_OK;

                    beg = 0;

            HCRC_UPDATE(beg);

        s->status = HCRC_STATE;

            if (s->pending + 2 > s->pending_buf_size) {

                if (s->pending != 0) {

                    s->last_flush = -1;

                    return Z_OK;

                }

            put_byte(s, (Byte)(strm->adler & 0xff));

            put_byte(s, (Byte)((strm->adler >> 8) & 0xff));

            strm->adler = crc32(0L, Z_NULL, 0);

        s->status = BUSY_STATE;

        /* Compression must start with an empty pending buffer */

        if (s->pending != 0) {

#endif

        bstate = s->level == 0 ? deflate_stored(s, flush) :

                 s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :

                 s->strategy == Z_RLE ? deflate_rle(s, flush) :

                 (*(configuration_table[s->level].func))(s, flush);

    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;

    if (deflateStateCheck(source) || dest == Z_NULL) {

local unsigned read_buf(strm, buf, size)

    return len;

    register Bytef *match;                      /* matched string */

    int best_len = (int)s->prev_length;         /* best match length so far */

    if ((uInt)nice_match > s->lookahead) nice_match = (int)s->lookahead;

#ifdef ZLIB_DEBUG

#define EQUAL 0

/* result of memcmp for equal strings */

#endif /* ZLIB_DEBUG */

    unsigned n;

            zmemcpy(s->window, s->window+wsize, (unsigned)wsize - more);

            slide_hash(s);

/* Maximum stored block length in deflate format (not including header). */

#define MAX_STORED 65535

/* Minimum of a and b. */

#define MIN(a, b) ((a) > (b) ? (b) : (a))

 *

 * In case deflateParams() is used to later switch to a non-zero compression

 * level, s->matches (otherwise unused when storing) keeps track of the number

 * of hash table slides to perform. If s->matches is 1, then one hash table

 * slide will be done when switching. If s->matches is 2, the maximum value

 * allowed here, then the hash table will be cleared, since two or more slides

 * is the same as a clear.

 *

 * deflate_stored() is written to minimize the number of times an input byte is

 * copied. It is most efficient with large input and output buffers, which

 * maximizes the opportunites to have a single copy from next_in to next_out.

    /* Smallest worthy block size when not flushing or finishing. By default

     * this is 32K. This can be as small as 507 bytes for memLevel == 1. For

     * large input and output buffers, the stored block size will be larger.

    unsigned min_block = MIN(s->pending_buf_size - 5, s->w_size);

    /* Copy as many min_block or larger stored blocks directly to next_out as

     * possible. If flushing, copy the remaining available input to next_out as

     * stored blocks, if there is enough space.

     */

    unsigned len, left, have, last = 0;

    unsigned used = s->strm->avail_in;

    do {

        /* Set len to the maximum size block that we can copy directly with the

         * available input data and output space. Set left to how much of that

         * would be copied from what's left in the window.

         */

        len = MAX_STORED;       /* maximum deflate stored block length */

        have = (s->bi_valid + 42) >> 3;         /* number of header bytes */

        if (s->strm->avail_out < have)          /* need room for header */

            break;

            /* maximum stored block length that will fit in avail_out: */

        have = s->strm->avail_out - have;

        left = s->strstart - s->block_start;    /* bytes left in window */

        if (len > (ulg)left + s->strm->avail_in)

            len = left + s->strm->avail_in;     /* limit len to the input */

        if (len > have)

            len = have;                         /* limit len to the output */

        /* If the stored block would be less than min_block in length, or if

         * unable to copy all of the available input when flushing, then try

         * copying to the window and the pending buffer instead. Also don't

         * write an empty block when flushing -- deflate() does that.

         */

        if (len < min_block && ((len == 0 && flush != Z_FINISH) ||

                                flush == Z_NO_FLUSH ||

                                len != left + s->strm->avail_in))

            break;

        /* Make a dummy stored block in pending to get the header bytes,

         * including any pending bits. This also updates the debugging counts.

         */

        last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0;

        _tr_stored_block(s, (char *)0, 0L, last);

        /* Replace the lengths in the dummy stored block with len. */

        s->pending_buf[s->pending - 4] = len;

        s->pending_buf[s->pending - 3] = len >> 8;

        s->pending_buf[s->pending - 2] = ~len;

        s->pending_buf[s->pending - 1] = ~len >> 8;

        /* Write the stored block header bytes. */

        flush_pending(s->strm);

#ifdef ZLIB_DEBUG

        /* Update debugging counts for the data about to be copied. */

        s->compressed_len += len << 3;

        s->bits_sent += len << 3;

#endif

        /* Copy uncompressed bytes from the window to next_out. */

        if (left) {

            if (left > len)

                left = len;

            zmemcpy(s->strm->next_out, s->window + s->block_start, left);

            s->strm->next_out += left;

            s->strm->avail_out -= left;

            s->strm->total_out += left;

            s->block_start += left;

            len -= left;

        /* Copy uncompressed bytes directly from next_in to next_out, updating

         * the check value.

        if (len) {

            read_buf(s->strm, s->strm->next_out, len);

            s->strm->next_out += len;

            s->strm->avail_out -= len;

            s->strm->total_out += len;

        }

    } while (last == 0);

    /* Update the sliding window with the last s->w_size bytes of the copied

     * data, or append all of the copied data to the existing window if less

     * than s->w_size bytes were copied. Also update the number of bytes to

     * insert in the hash tables, in the event that deflateParams() switches to

     * a non-zero compression level.

     */