#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <openssl/objects.h>

#include <openssl/comp.h>

#include <openssl/err.h>

COMP_METHOD *COMP_zlib(void);

static COMP_METHOD zlib_method_nozlib = {

    NID_undef,

    "(undef)",

    NULL,

    NULL,

    NULL,

    NULL,

    NULL,

    NULL,

};

#ifndef ZLIB

# undef ZLIB_SHARED

#else

# include <zlib.h>

static int zlib_stateful_init(COMP_CTX *ctx);

static void zlib_stateful_finish(COMP_CTX *ctx);

static int zlib_stateful_compress_block(COMP_CTX *ctx, unsigned char *out,

                                        unsigned int olen, unsigned char *in,

                                        unsigned int ilen);

static int zlib_stateful_expand_block(COMP_CTX *ctx, unsigned char *out,

                                      unsigned int olen, unsigned char *in,

                                      unsigned int ilen);

/* memory allocations functions for zlib intialization */

static void *zlib_zalloc(void *opaque, unsigned int no, unsigned int size)

{

    void *p;

    p = OPENSSL_malloc(no * size);

    if (p)

        memset(p, 0, no * size);

    return p;

}

static void zlib_zfree(void *opaque, void *address)

{

    OPENSSL_free(address);

}

# if 0

static int zlib_compress_block(COMP_CTX *ctx, unsigned char *out,

                               unsigned int olen, unsigned char *in,

                               unsigned int ilen);

static int zlib_expand_block(COMP_CTX *ctx, unsigned char *out,

                             unsigned int olen, unsigned char *in,

                             unsigned int ilen);

static int zz_uncompress(Bytef *dest, uLongf * destLen, const Bytef *source,

                         uLong sourceLen);

static COMP_METHOD zlib_stateless_method = {

    NID_zlib_compression,

    LN_zlib_compression,

    NULL,

    NULL,

    zlib_compress_block,

    zlib_expand_block,

    NULL,

    NULL,

};

# endif

static COMP_METHOD zlib_stateful_method = {

    NID_zlib_compression,

    LN_zlib_compression,

    zlib_stateful_init,

    zlib_stateful_finish,

    zlib_stateful_compress_block,

    zlib_stateful_expand_block,

    NULL,

    NULL,

};

/*

 * When OpenSSL is built on Windows, we do not want to require that

 * the ZLIB.DLL be available in order for the OpenSSL DLLs to

 * work.  Therefore, all ZLIB routines are loaded at run time

 * and we do not link to a .LIB file when ZLIB_SHARED is set.

 */

# if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32)

#  include <windows.h>

# endif                         /* !(OPENSSL_SYS_WINDOWS ||

                                 * OPENSSL_SYS_WIN32) */

# ifdef ZLIB_SHARED

#  include <openssl/dso.h>

/* Function pointers */

typedef int (*compress_ft) (Bytef *dest, uLongf * destLen,

                            const Bytef *source, uLong sourceLen);

typedef int (*inflateEnd_ft) (z_streamp strm);

typedef int (*inflate_ft) (z_streamp strm, int flush);

typedef int (*inflateInit__ft) (z_streamp strm,

                                const char *version, int stream_size);

typedef int (*deflateEnd_ft) (z_streamp strm);

typedef int (*deflate_ft) (z_streamp strm, int flush);

typedef int (*deflateInit__ft) (z_streamp strm, int level,

                                const char *version, int stream_size);

typedef const char *(*zError__ft) (int err);

static compress_ft p_compress = NULL;

static inflateEnd_ft p_inflateEnd = NULL;

static inflate_ft p_inflate = NULL;

static inflateInit__ft p_inflateInit_ = NULL;

static deflateEnd_ft p_deflateEnd = NULL;

static deflate_ft p_deflate = NULL;

static deflateInit__ft p_deflateInit_ = NULL;

static zError__ft p_zError = NULL;

static int zlib_loaded = 0;     /* only attempt to init func pts once */

static DSO *zlib_dso = NULL;

#  define compress                p_compress

#  define inflateEnd              p_inflateEnd

#  define inflate                 p_inflate

#  define inflateInit_            p_inflateInit_

#  define deflateEnd              p_deflateEnd

#  define deflate                 p_deflate

#  define deflateInit_            p_deflateInit_

#  define zError                  p_zError

# endif                         /* ZLIB_SHARED */

struct zlib_state {

    z_stream istream;

    z_stream ostream;

};

static int zlib_stateful_ex_idx = -1;

static int zlib_stateful_init(COMP_CTX *ctx)

{

    int err;

    struct zlib_state *state =

        (struct zlib_state *)OPENSSL_malloc(sizeof(struct zlib_state));

    if (state == NULL)

        goto err;

    state->istream.zalloc = zlib_zalloc;

    state->istream.zfree = zlib_zfree;

    state->istream.opaque = Z_NULL;

    state->istream.next_in = Z_NULL;

    state->istream.next_out = Z_NULL;

    state->istream.avail_in = 0;

    state->istream.avail_out = 0;

    err = inflateInit_(&state->istream, ZLIB_VERSION, sizeof(z_stream));

    if (err != Z_OK)

        goto err;

    state->ostream.zalloc = zlib_zalloc;

    state->ostream.zfree = zlib_zfree;

    state->ostream.opaque = Z_NULL;

    state->ostream.next_in = Z_NULL;

    state->ostream.next_out = Z_NULL;

    state->ostream.avail_in = 0;

    state->ostream.avail_out = 0;

    err = deflateInit_(&state->ostream, Z_DEFAULT_COMPRESSION,

                       ZLIB_VERSION, sizeof(z_stream));

    if (err != Z_OK)

        goto err;

    CRYPTO_new_ex_data(CRYPTO_EX_INDEX_COMP, ctx, &ctx->ex_data);

    CRYPTO_set_ex_data(&ctx->ex_data, zlib_stateful_ex_idx, state);

    return 1;

 err:

    if (state)

        OPENSSL_free(state);

    return 0;

}

static void zlib_stateful_finish(COMP_CTX *ctx)

{

    struct zlib_state *state =

        (struct zlib_state *)CRYPTO_get_ex_data(&ctx->ex_data,

                                                zlib_stateful_ex_idx);

    inflateEnd(&state->istream);

    deflateEnd(&state->ostream);

    OPENSSL_free(state);

    CRYPTO_free_ex_data(CRYPTO_EX_INDEX_COMP, ctx, &ctx->ex_data);

}

static int zlib_stateful_compress_block(COMP_CTX *ctx, unsigned char *out,

                                        unsigned int olen, unsigned char *in,

                                        unsigned int ilen)

{

    int err = Z_OK;

    struct zlib_state *state =

        (struct zlib_state *)CRYPTO_get_ex_data(&ctx->ex_data,

                                                zlib_stateful_ex_idx);

    if (state == NULL)

        return -1;

    state->ostream.next_in = in;

    state->ostream.avail_in = ilen;

    state->ostream.next_out = out;

    state->ostream.avail_out = olen;

    if (ilen > 0)

        err = deflate(&state->ostream, Z_SYNC_FLUSH);

    if (err != Z_OK)

        return -1;

# ifdef DEBUG_ZLIB

    fprintf(stderr, "compress(%4d)->%4d %s\n",

            ilen, olen - state->ostream.avail_out,

            (ilen != olen - state->ostream.avail_out) ? "zlib" : "clear");

# endif

    return olen - state->ostream.avail_out;

}

static int zlib_stateful_expand_block(COMP_CTX *ctx, unsigned char *out,

                                      unsigned int olen, unsigned char *in,

                                      unsigned int ilen)

{

    int err = Z_OK;

    struct zlib_state *state =

        (struct zlib_state *)CRYPTO_get_ex_data(&ctx->ex_data,

                                                zlib_stateful_ex_idx);

    if (state == NULL)

        return 0;

    state->istream.next_in = in;

    state->istream.avail_in = ilen;

    state->istream.next_out = out;

    state->istream.avail_out = olen;

    if (ilen > 0)

        err = inflate(&state->istream, Z_SYNC_FLUSH);

    if (err != Z_OK)

        return -1;

# ifdef DEBUG_ZLIB

    fprintf(stderr, "expand(%4d)->%4d %s\n",

            ilen, olen - state->istream.avail_out,

            (ilen != olen - state->istream.avail_out) ? "zlib" : "clear");

# endif

    return olen - state->istream.avail_out;

}

# if 0

static int zlib_compress_block(COMP_CTX *ctx, unsigned char *out,

                               unsigned int olen, unsigned char *in,

                               unsigned int ilen)

{

    unsigned long l;

    int i;

    int clear = 1;

    if (ilen > 128) {

        out[0] = 1;

        l = olen - 1;

        i = compress(&(out[1]), &l, in, (unsigned long)ilen);

        if (i != Z_OK)

            return (-1);

        if (ilen > l) {

            clear = 0;

            l++;

        }

    }

    if (clear) {

        out[0] = 0;

        memcpy(&(out[1]), in, ilen);

        l = ilen + 1;

    }

#  ifdef DEBUG_ZLIB

    fprintf(stderr, "compress(%4d)->%4d %s\n",

            ilen, (int)l, (clear) ? "clear" : "zlib");

#  endif

    return ((int)l);

}

static int zlib_expand_block(COMP_CTX *ctx, unsigned char *out,

                             unsigned int olen, unsigned char *in,

                             unsigned int ilen)

{

    unsigned long l;

    int i;

    if (in[0]) {

        l = olen;

        i = zz_uncompress(out, &l, &(in[1]), (unsigned long)ilen - 1);

        if (i != Z_OK)

            return (-1);

    } else {

        memcpy(out, &(in[1]), ilen - 1);

        l = ilen - 1;

    }

#  ifdef DEBUG_ZLIB

    fprintf(stderr, "expand  (%4d)->%4d %s\n",

            ilen, (int)l, in[0] ? "zlib" : "clear");

#  endif

    return ((int)l);

}

static int zz_uncompress(Bytef *dest, uLongf * destLen, const Bytef *source,

                         uLong sourceLen)

{

    z_stream stream;

    int err;

    stream.next_in = (Bytef *)source;

    stream.avail_in = (uInt) sourceLen;

    /* Check for source > 64K on 16-bit machine: */

    if ((uLong) stream.avail_in != sourceLen)

        return Z_BUF_ERROR;

    stream.next_out = dest;

    stream.avail_out = (uInt) * destLen;

    if ((uLong) stream.avail_out != *destLen)

        return Z_BUF_ERROR;

    stream.zalloc = (alloc_func) 0;

    stream.zfree = (free_func) 0;

    err = inflateInit_(&stream, ZLIB_VERSION, sizeof(z_stream));

    if (err != Z_OK)

        return err;

    err = inflate(&stream, Z_FINISH);

    if (err != Z_STREAM_END) {

        inflateEnd(&stream);

        return err;

    }

    *destLen = stream.total_out;

    err = inflateEnd(&stream);

    return err;

}

# endif

#endif

COMP_METHOD *COMP_zlib(void)

{

    COMP_METHOD *meth = &zlib_method_nozlib;

#ifdef ZLIB_SHARED

    if (!zlib_loaded) {

# if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32)

        zlib_dso = DSO_load(NULL, "ZLIB1", NULL, 0);

# else

        zlib_dso = DSO_load(NULL, "z", NULL, 0);

# endif

        if (zlib_dso != NULL) {

            p_compress = (compress_ft) DSO_bind_func(zlib_dso, "compress");

            p_inflateEnd

                = (inflateEnd_ft) DSO_bind_func(zlib_dso, "inflateEnd");

            p_inflate = (inflate_ft) DSO_bind_func(zlib_dso, "inflate");

            p_inflateInit_

                = (inflateInit__ft) DSO_bind_func(zlib_dso, "inflateInit_");

            p_deflateEnd

                = (deflateEnd_ft) DSO_bind_func(zlib_dso, "deflateEnd");

            p_deflate = (deflate_ft) DSO_bind_func(zlib_dso, "deflate");

            p_deflateInit_

                = (deflateInit__ft) DSO_bind_func(zlib_dso, "deflateInit_");

            p_zError = (zError__ft) DSO_bind_func(zlib_dso, "zError");

            if (p_compress && p_inflateEnd && p_inflate

                && p_inflateInit_ && p_deflateEnd

                && p_deflate && p_deflateInit_ && p_zError)

                zlib_loaded++;

        }

    }

#endif

#ifdef ZLIB_SHARED

    if (zlib_loaded)

#endif

#if defined(ZLIB) || defined(ZLIB_SHARED)

    {

        /*

         * init zlib_stateful_ex_idx here so that in a multi-process

         * application it's enough to intialize openssl before forking (idx

         * will be inherited in all the children)

         */

        if (zlib_stateful_ex_idx == -1) {

            CRYPTO_w_lock(CRYPTO_LOCK_COMP);

            if (zlib_stateful_ex_idx == -1)

                zlib_stateful_ex_idx =

                    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_COMP,

                                            0, NULL, NULL, NULL, NULL);

            CRYPTO_w_unlock(CRYPTO_LOCK_COMP);

            if (zlib_stateful_ex_idx == -1)

                goto err;

        }

        meth = &zlib_stateful_method;

    }

 err:

#endif

    return (meth);

}

void COMP_zlib_cleanup(void)

{

#ifdef ZLIB_SHARED

    if (zlib_dso != NULL)

        DSO_free(zlib_dso);

    zlib_dso = NULL;

#endif

}

#ifdef ZLIB

/* Zlib based compression/decompression filter BIO */

typedef struct {

    unsigned char *ibuf;        /* Input buffer */

    int ibufsize;               /* Buffer size */

    z_stream zin;               /* Input decompress context */

    unsigned char *obuf;        /* Output buffer */

    int obufsize;               /* Output buffer size */

    unsigned char *optr;        /* Position in output buffer */

    int ocount;                 /* Amount of data in output buffer */

    int odone;                  /* deflate EOF */

    int comp_level;             /* Compression level to use */

    z_stream zout;              /* Output compression context */

} BIO_ZLIB_CTX;

# define ZLIB_DEFAULT_BUFSIZE 1024

static int bio_zlib_new(BIO *bi);

static int bio_zlib_free(BIO *bi);

static int bio_zlib_read(BIO *b, char *out, int outl);

static int bio_zlib_write(BIO *b, const char *in, int inl);

static long bio_zlib_ctrl(BIO *b, int cmd, long num, void *ptr);

static long bio_zlib_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp);

static BIO_METHOD bio_meth_zlib = {

    BIO_TYPE_COMP,

    "zlib",

    bio_zlib_write,

    bio_zlib_read,

    NULL,

    NULL,

    bio_zlib_ctrl,

    bio_zlib_new,

    bio_zlib_free,

    bio_zlib_callback_ctrl

};

BIO_METHOD *BIO_f_zlib(void)

{

    return &bio_meth_zlib;

}

static int bio_zlib_new(BIO *bi)

{

    BIO_ZLIB_CTX *ctx;

# ifdef ZLIB_SHARED

    (void)COMP_zlib();

    if (!zlib_loaded) {

        COMPerr(COMP_F_BIO_ZLIB_NEW, COMP_R_ZLIB_NOT_SUPPORTED);

        return 0;

    }

# endif

    ctx = OPENSSL_malloc(sizeof(BIO_ZLIB_CTX));

    if (!ctx) {

        COMPerr(COMP_F_BIO_ZLIB_NEW, ERR_R_MALLOC_FAILURE);

        return 0;

    }

    ctx->ibuf = NULL;

    ctx->obuf = NULL;

    ctx->ibufsize = ZLIB_DEFAULT_BUFSIZE;

    ctx->obufsize = ZLIB_DEFAULT_BUFSIZE;

    ctx->zin.zalloc = Z_NULL;

    ctx->zin.zfree = Z_NULL;

    ctx->zin.next_in = NULL;

    ctx->zin.avail_in = 0;

    ctx->zin.next_out = NULL;

    ctx->zin.avail_out = 0;

    ctx->zout.zalloc = Z_NULL;

    ctx->zout.zfree = Z_NULL;

    ctx->zout.next_in = NULL;

    ctx->zout.avail_in = 0;

    ctx->zout.next_out = NULL;

    ctx->zout.avail_out = 0;

    ctx->odone = 0;

    ctx->comp_level = Z_DEFAULT_COMPRESSION;

    bi->init = 1;

    bi->ptr = (char *)ctx;

    bi->flags = 0;

    return 1;

}

static int bio_zlib_free(BIO *bi)

{

    BIO_ZLIB_CTX *ctx;

    if (!bi)

        return 0;

    ctx = (BIO_ZLIB_CTX *) bi->ptr;

    if (ctx->ibuf) {

        /* Destroy decompress context */

        inflateEnd(&ctx->zin);

        OPENSSL_free(ctx->ibuf);

    }

    if (ctx->obuf) {

        /* Destroy compress context */

        deflateEnd(&ctx->zout);

        OPENSSL_free(ctx->obuf);

    }

    OPENSSL_free(ctx);

    bi->ptr = NULL;

    bi->init = 0;

    bi->flags = 0;

    return 1;

}

static int bio_zlib_read(BIO *b, char *out, int outl)

{

    BIO_ZLIB_CTX *ctx;

    int ret;

    z_stream *zin;

    if (!out || !outl)

        return 0;

    ctx = (BIO_ZLIB_CTX *) b->ptr;

    zin = &ctx->zin;

    BIO_clear_retry_flags(b);

    if (!ctx->ibuf) {

        ctx->ibuf = OPENSSL_malloc(ctx->ibufsize);

        if (!ctx->ibuf) {

            COMPerr(COMP_F_BIO_ZLIB_READ, ERR_R_MALLOC_FAILURE);

            return 0;

        }

        inflateInit(zin);

        zin->next_in = ctx->ibuf;

        zin->avail_in = 0;

    }

    /* Copy output data directly to supplied buffer */

    zin->next_out = (unsigned char *)out;

    zin->avail_out = (unsigned int)outl;

    for (;;) {

        /* Decompress while data available */

        while (zin->avail_in) {

            ret = inflate(zin, 0);

            if ((ret != Z_OK) && (ret != Z_STREAM_END)) {

                COMPerr(COMP_F_BIO_ZLIB_READ, COMP_R_ZLIB_INFLATE_ERROR);

                ERR_add_error_data(2, "zlib error:", zError(ret));

                return 0;

            }

            /* If EOF or we've read everything then return */

            if ((ret == Z_STREAM_END) || !zin->avail_out)

                return outl - zin->avail_out;

        }

        /*

         * No data in input buffer try to read some in, if an error then

         * return the total data read.

         */

        ret = BIO_read(b->next_bio, ctx->ibuf, ctx->ibufsize);

        if (ret <= 0) {

            /* Total data read */

            int tot = outl - zin->avail_out;

            BIO_copy_next_retry(b);

            if (ret < 0)

                return (tot > 0) ? tot : ret;

            return tot;

        }

        zin->avail_in = ret;

        zin->next_in = ctx->ibuf;

    }

}

static int bio_zlib_write(BIO *b, const char *in, int inl)

{

    BIO_ZLIB_CTX *ctx;

    int ret;

    z_stream *zout;

    if (!in || !inl)

        return 0;

    ctx = (BIO_ZLIB_CTX *) b->ptr;

    if (ctx->odone)

        return 0;

    zout = &ctx->zout;

    BIO_clear_retry_flags(b);

    if (!ctx->obuf) {

        ctx->obuf = OPENSSL_malloc(ctx->obufsize);

        /* Need error here */

        if (!ctx->obuf) {

            COMPerr(COMP_F_BIO_ZLIB_WRITE, ERR_R_MALLOC_FAILURE);

            return 0;

        }

        ctx->optr = ctx->obuf;

        ctx->ocount = 0;

        deflateInit(zout, ctx->comp_level);

        zout->next_out = ctx->obuf;

        zout->avail_out = ctx->obufsize;

    }

    /* Obtain input data directly from supplied buffer */

    zout->next_in = (void *)in;

    zout->avail_in = inl;

    for (;;) {

        /* If data in output buffer write it first */

        while (ctx->ocount) {

            ret = BIO_write(b->next_bio, ctx->optr, ctx->ocount);

            if (ret <= 0) {

                /* Total data written */

                int tot = inl - zout->avail_in;

                BIO_copy_next_retry(b);

                if (ret < 0)

                    return (tot > 0) ? tot : ret;

                return tot;

            }

            ctx->optr += ret;

            ctx->ocount -= ret;

        }

        /* Have we consumed all supplied data? */

        if (!zout->avail_in)

            return inl;

        /* Compress some more */

        /* Reset buffer */

        ctx->optr = ctx->obuf;

        zout->next_out = ctx->obuf;

        zout->avail_out = ctx->obufsize;

        /* Compress some more */

        ret = deflate(zout, 0);

        if (ret != Z_OK) {

            COMPerr(COMP_F_BIO_ZLIB_WRITE, COMP_R_ZLIB_DEFLATE_ERROR);

            ERR_add_error_data(2, "zlib error:", zError(ret));

            return 0;

        }

        ctx->ocount = ctx->obufsize - zout->avail_out;

    }

}

static int bio_zlib_flush(BIO *b)

{

    BIO_ZLIB_CTX *ctx;

    int ret;

    z_stream *zout;

    ctx = (BIO_ZLIB_CTX *) b->ptr;

    /* If no data written or already flush show success */

    if (!ctx->obuf || (ctx->odone && !ctx->ocount))

        return 1;

    zout = &ctx->zout;

    BIO_clear_retry_flags(b);

    /* No more input data */

    zout->next_in = NULL;

    zout->avail_in = 0;

    for (;;) {

        /* If data in output buffer write it first */

        while (ctx->ocount) {

            ret = BIO_write(b->next_bio, ctx->optr, ctx->ocount);

            if (ret <= 0) {

                BIO_copy_next_retry(b);

                return ret;

            }

            ctx->optr += ret;

            ctx->ocount -= ret;

        }

        if (ctx->odone)

            return 1;

        /* Compress some more */

        /* Reset buffer */

        ctx->optr = ctx->obuf;

        zout->next_out = ctx->obuf;

        zout->avail_out = ctx->obufsize;

        /* Compress some more */

        ret = deflate(zout, Z_FINISH);

        if (ret == Z_STREAM_END)

            ctx->odone = 1;

        else if (ret != Z_OK) {

            COMPerr(COMP_F_BIO_ZLIB_FLUSH, COMP_R_ZLIB_DEFLATE_ERROR);

            ERR_add_error_data(2, "zlib error:", zError(ret));

            return 0;

        }

        ctx->ocount = ctx->obufsize - zout->avail_out;

    }

}

static long bio_zlib_ctrl(BIO *b, int cmd, long num, void *ptr)

{

    BIO_ZLIB_CTX *ctx;

    int ret, *ip;

    int ibs, obs;

    if (!b->next_bio)

        return 0;

    ctx = (BIO_ZLIB_CTX *) b->ptr;

    switch (cmd) {

    case BIO_CTRL_RESET:

        ctx->ocount = 0;

        ctx->odone = 0;

        ret = 1;

        break;

    case BIO_CTRL_FLUSH:

        ret = bio_zlib_flush(b);

        if (ret > 0)

            ret = BIO_flush(b->next_bio);

        break;

    case BIO_C_SET_BUFF_SIZE:

        ibs = -1;

        obs = -1;

        if (ptr != NULL) {

            ip = ptr;

            if (*ip == 0)

                ibs = (int)num;

            else

                obs = (int)num;

        } else {

            ibs = (int)num;

            obs = ibs;

        }

        if (ibs != -1) {

            if (ctx->ibuf) {

                OPENSSL_free(ctx->ibuf);

                ctx->ibuf = NULL;

            }

            ctx->ibufsize = ibs;

        }

        if (obs != -1) {

            if (ctx->obuf) {

                OPENSSL_free(ctx->obuf);

                ctx->obuf = NULL;

            }

            ctx->obufsize = obs;

        }

        ret = 1;

        break;

    case BIO_C_DO_STATE_MACHINE:

        BIO_clear_retry_flags(b);

        ret = BIO_ctrl(b->next_bio, cmd, num, ptr);

        BIO_copy_next_retry(b);

        break;

    default:

        ret = BIO_ctrl(b->next_bio, cmd, num, ptr);

        break;

    }

    return ret;

}

static long bio_zlib_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)

{

    if (!b->next_bio)

        return 0;

    return BIO_callback_ctrl(b->next_bio, cmd, fp);

}

#endif