GCOV - Varnish Cache


/*-
 * Copyright (c) 2013-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * Interaction with the libvgz (zlib) library.
 *
 * The zlib library pollutes namespace a LOT when you include the "vgz.h"
 * (aka "zlib.h") file so we contain the damage by vectoring all access
 * to libz through this source file.
 *
 * The API defined by this file, will also insulate the rest of the code,
 * should we find a better gzip library at a later date.
 *
 */

#include "config.h"

#include <stdlib.h>

#include "cache_varnishd.h"
#include "cache_filter.h"
#include "cache_objhead.h"
#include "cache_vgz.h"

#include "storage/storage.h"

#include "vend.h"

#include "vgz.h"

struct vgz {
        unsigned                magic;
#define VGZ_MAGIC               0x162df0cb
        enum {VGZ_GZ,VGZ_UN}    dir;
        struct vsl_log          *vsl;
        const char              *id;
        int                     last_i;
        enum vgz_flag           flag;

        struct stv_buffer       *stvbuf;
        char                    *m_buf;
        ssize_t                 m_sz;
        ssize_t                 m_len;

        intmax_t                bits;

        z_stream                vz;
};

static const char *
vgz_msg(const struct vgz *vg)
{
        CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
        return (vg->vz.msg ? vg->vz.msg : "(null)");
}

/*--------------------------------------------------------------------
 * Set up a gunzip instance
 */

static struct vgz *
vgz_gunzip(struct vsl_log *vsl, const char *id)
{
        struct vgz *vg;

        ALLOC_OBJ(vg, VGZ_MAGIC);
        AN(vg);
        vg->vsl = vsl;
        vg->id = id;
        vg->dir = VGZ_UN;

        /*
         * Max memory usage according to zonf.h:
         *      mem_needed = "a few kb" + (1 << (windowBits))
         * Since we don't control windowBits, we have to assume
         * it is 15, so 34-35KB or so.
         */
        assert(Z_OK == inflateInit2(&vg->vz, 31));
        return (vg);
}

static struct vgz *
VGZ_NewGunzip(struct vsl_log *vsl, const char *id)
{
        VSC_C_main->n_gunzip++;
        return (vgz_gunzip(vsl, id));
}

static struct vgz *
VGZ_NewTestGunzip(struct vsl_log *vsl, const char *id)
{
        VSC_C_main->n_test_gunzip++;
        return (vgz_gunzip(vsl, id));
}

struct vgz *
VGZ_NewGzip(struct vsl_log *vsl, const char *id)
{
        struct vgz *vg;
        int i;

        VSC_C_main->n_gzip++;
        ALLOC_OBJ(vg, VGZ_MAGIC);
        AN(vg);
        vg->vsl = vsl;
        vg->id = id;
        vg->dir = VGZ_GZ;

        /*
         * From zconf.h:
         *
         *      mem_needed = "a few kb"
         *              + (1 << (windowBits+2))
         *              +  (1 << (memLevel+9))
         *
         * windowBits [8..15] (-> 1K..128K)
         * memLevel [1..9] (-> 1K->256K)
         */
        i = deflateInit2(&vg->vz,
            cache_param->gzip_level,            /* Level */
            Z_DEFLATED,                         /* Method */
            16 + 15,                            /* Window bits (16=gzip) */
            cache_param->gzip_memlevel,         /* memLevel */
            Z_DEFAULT_STRATEGY);
        assert(Z_OK == i);
        return (vg);
}

/*--------------------------------------------------------------------
 */

static int
vgz_getmbuf(struct worker *wrk, struct vgz *vg)
{
        size_t sz;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
        AZ(vg->m_sz);
        AZ(vg->m_len);
        AZ(vg->m_buf);
        AZ(vg->stvbuf);

        vg->stvbuf = STV_AllocBuf(wrk, stv_transient, cache_param->gzip_buffer);
        if (vg->stvbuf == NULL)
                return (-1);
        vg->m_buf = STV_GetBufPtr(vg->stvbuf, &sz);
        vg->m_sz = sz;
        AN(vg->m_buf);
        assert(vg->m_sz > 0);
        return (0);
}

/*--------------------------------------------------------------------*/

void
VGZ_Ibuf(struct vgz *vg, const void *ptr, ssize_t len)
{

        CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
        AZ(vg->vz.avail_in);
        assert(len >= 0);
        if (len > 0)
                AN(ptr);

        vg->vz.next_in = TRUST_ME(ptr);
        vg->vz.avail_in = len;
}

int
VGZ_IbufEmpty(const struct vgz *vg)
{

        CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
        return (vg->vz.avail_in == 0);
}

/*--------------------------------------------------------------------*/

void
VGZ_Obuf(struct vgz *vg, void *ptr, ssize_t len)
{

        CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
        AN(ptr);
        assert(len > 0);

        vg->vz.next_out = ptr;
        vg->vz.avail_out = len;
}

int
VGZ_ObufFull(const struct vgz *vg)
{

        CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
        return (vg->vz.avail_out == 0);
}

/*--------------------------------------------------------------------*/

static enum vgzret_e
VGZ_Gunzip(struct vgz *vg, const void **pptr, ssize_t *plen)
{
        int i;
        ssize_t l;
        const uint8_t *before;

        CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);

        *pptr = NULL;
        *plen = 0;
        AN(vg->vz.next_out);
        AN(vg->vz.avail_out);
        before = vg->vz.next_out;
        i = inflate(&vg->vz, 0);
        if (i == Z_OK || i == Z_STREAM_END) {
                *pptr = before;
                l = (const uint8_t *)vg->vz.next_out - before;
                *plen = l;
        }
        vg->last_i = i;
        if (i == Z_OK)
                return (VGZ_OK);
        if (i == Z_STREAM_END)
                return (VGZ_END);
        if (i == Z_BUF_ERROR)
                return (VGZ_STUCK);
        VSLb(vg->vsl, SLT_Gzip, "Gunzip error: %d (%s)", i, vgz_msg(vg));
        return (VGZ_ERROR);
}

/* set vz pointers for in and out iovecs */
static inline void
vgz_iovec_update(struct vgz *vg, const struct iovec *in, const struct iovec *buf)
{
        /* in: either fully consumed or the same */
        assert(vg->vz.avail_in == 0 || vg->vz.next_in == TRUST_ME(in->iov_base));
        vg->vz.next_in = TRUST_ME(in->iov_base);
        vg->vz.avail_in = in->iov_len;
        vg->vz.next_out = TRUST_ME(buf->iov_base);
        vg->vz.avail_out = buf->iov_len;
}

static enum vgzret_e
vgz_gunzip_iovec(struct vgz *vg, struct iovec *in, struct iovec *buf, struct iovec *out)
{
        int i;

        CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
        AN(in && buf && out);
        vgz_iovec_update(vg, in, buf);

        i = inflate(&vg->vz, 0);
        if (i == Z_OK || i == Z_STREAM_END) {
                iovec_collect(buf, out, pdiff(buf->iov_base, vg->vz.next_out));
                in->iov_base = TRUST_ME(vg->vz.next_in);
                in->iov_len = vg->vz.avail_in;
        }
        vg->last_i = i;
        if (i == Z_OK)
                return (VGZ_OK);
        if (i == Z_STREAM_END)
                return (VGZ_END);
        if (i == Z_BUF_ERROR)
                return (VGZ_STUCK);
        VSLb(vg->vsl, SLT_Gzip, "Gunzip error: %d (%s)", i, vgz_msg(vg));
        return (VGZ_ERROR);
}

/*--------------------------------------------------------------------*/

enum vgzret_e
VGZ_Gzip(struct vgz *vg, const void **pptr, ssize_t *plen, enum vgz_flag flags)
{
        int i;
        int zflg;
        ssize_t l;
        const uint8_t *before;

        CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);

        *pptr = NULL;
        *plen = 0;
        AN(vg->vz.next_out);
        AN(vg->vz.avail_out);
        before = vg->vz.next_out;
        switch (flags) {
        case VGZ_NORMAL:        zflg = Z_NO_FLUSH; break;
        case VGZ_ALIGN:         zflg = Z_SYNC_FLUSH; break;
        case VGZ_RESET:         zflg = Z_FULL_FLUSH; break;
        case VGZ_FINISH:        zflg = Z_FINISH; break;
        default:                WRONG("Invalid VGZ flag");
        }
        i = deflate(&vg->vz, zflg);
        if (i == Z_OK || i == Z_STREAM_END) {
                *pptr = before;
                l = (const uint8_t *)vg->vz.next_out - before;
                *plen = l;
        }
        vg->last_i = i;
        if (i == Z_OK)
                return (VGZ_OK);
        if (i == Z_STREAM_END)
                return (VGZ_END);
        if (i == Z_BUF_ERROR)
                return (VGZ_STUCK);
        VSLb(vg->vsl, SLT_Gzip, "Gzip error: %d (%s)", i, vgz_msg(vg));
        return (VGZ_ERROR);
}

/*--------------------------------------------------------------------
 * VDP for gunzip'ing
 */

// common for traditional interface and vdpio
static int vdp_gunzip_init_common(struct vdp_ctx *vdc);

static int v_matchproto_(vdp_init_f)
vdp_gunzip_init(VRT_CTX, struct vdp_ctx *vdc, void **priv)
{
        struct vgz *vg;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
        CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
        AN(vdc->clen);
        AN(priv);

        vg = VGZ_NewGunzip(vdc->vsl, "U D -");
        AN(vg);
        if (vgz_getmbuf(vdc->wrk, vg)) {
                (void)VGZ_Destroy(vdc->wrk, &vg);
                return (-1);
        }

        VGZ_Obuf(vg, vg->m_buf, vg->m_sz);
        *priv = vg;
        return (vdp_gunzip_init_common(vdc));
}

static int
vdp_gunzip_init_common(struct vdp_ctx *vdc)
{
        struct boc *boc;
        enum boc_state_e bos;
        const char *p;
        ssize_t dl;
        uint64_t u;
        http_Unset(vdc->hp, H_Content_Encoding);

        *vdc->clen = -1;

        if (vdc->oc == NULL)
                return (0);

        boc = HSH_RefBoc(vdc->oc);
        if (boc != NULL) {
                CHECK_OBJ(boc, BOC_MAGIC);
                bos = boc->state;
                HSH_DerefBoc(vdc->wrk, vdc->oc);
                if (bos < BOS_FINISHED)
                        return (0); /* OA_GZIPBITS is not stable yet */
        }

        p = ObjGetAttr(vdc->wrk, vdc->oc, OA_GZIPBITS, &dl);
        if (p != NULL && dl == 32) {
                u = vbe64dec(p + 24);
                if (u != 0)
                        *vdc->clen = u;
        }
        return (0);
}

static int v_matchproto_(vdp_fini_f)
vdp_gunzip_fini(struct vdp_ctx *vdc, void **priv)
{
        struct vgz *vg;

        (void)vdc;
        TAKE_OBJ_NOTNULL(vg, priv, VGZ_MAGIC);
        AN(vg->m_buf);
        (void)VGZ_Destroy(vdc->wrk, &vg);
        return (0);
}

static int v_matchproto_(vdp_bytes_f)
vdp_gunzip_bytes(struct vdp_ctx *vdc, enum vdp_action act, void **priv,
    const void *ptr, ssize_t len)
{
        enum vgzret_e vr;
        ssize_t dl;
        const void *dp;
        struct vgz *vg;

        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vdc->wrk, WORKER_MAGIC);
        (void)act;

        CAST_OBJ_NOTNULL(vg, *priv, VGZ_MAGIC);
        AN(vg->m_buf);

        if (len == 0)
                return (0);

        VGZ_Ibuf(vg, ptr, len);
        do {
                vr = VGZ_Gunzip(vg, &dp, &dl);
                if (vr == VGZ_END && !VGZ_IbufEmpty(vg)) {
                        VSLb(vg->vsl, SLT_Gzip, "G(un)zip error: %d (%s)",
                             vr, "junk after VGZ_END");
                        return (-1);
                }
                vg->m_len += dl;
                if (vr < VGZ_OK)
                        return (-1);
                // END or STUCK
                if (vg->m_len == vg->m_sz || vr != VGZ_OK) {
                        if (VDP_bytes(vdc, vr == VGZ_END ? VDP_END : VDP_FLUSH,
                            vg->m_buf, vg->m_len))
                                return (vdc->retval);
                        vg->m_len = 0;
                        VGZ_Obuf(vg, vg->m_buf, vg->m_sz);
                }
        } while (!VGZ_IbufEmpty(vg));
        assert(vr == VGZ_STUCK || vr == VGZ_OK || vr == VGZ_END);
        return (0);
}

#ifdef LATER
/*
 * XXX does it make sense to work on more than one buffer?
 */
static int v_matchproto_(vdpio_init_f)
vdpio_gunzip_init(VRT_CTX, struct vdp_ctx *vdc, void **priv, int capacity)
{
        struct vgz *vg;
        struct vscarab *in;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
        CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
        AN(vdc->clen);
        AN(priv);
        assert(capacity >= 1);

        if (capacity < 4)
                capacity = 4;

        in = WS_Alloc(ctx->ws, VSCARAB_SIZE(capacity));
        if (in == NULL)
                return (-1);

        vg = VGZ_NewGunzip(vdc->vsl, "U D -");
        if (vg == NULL)
                return (-1);

        AZ(vg->m_buf);
        vg->m_buf = (void *)in;

        *priv = vg;
        AZ(vdp_gunzip_init_common(vdc));
        return (1);
}
#endif

static int v_matchproto_(vdpio_init_f)
vdpio_gunzip_upgrade(VRT_CTX, struct vdp_ctx *vdc, void **priv, int capacity)
{
        struct vgz *vg;
        struct vscarab *in;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        AN(priv);
        assert(capacity >= 1);

        if (capacity < 4)
                capacity = 4;

        /* done in vdp_gunzip_init */
        CAST_OBJ_NOTNULL(vg, *priv, VGZ_MAGIC);

        in = WS_Alloc(ctx->ws, VSCARAB_SIZE(capacity));
        if (in == NULL)
                return (-1);
        VSCARAB_INIT(in, capacity);

        // XXX duplicate work - remove when completing transition to VAI
        AN(vg->m_buf);
        AN(vg->stvbuf);
        STV_FreeBuf(vdc->wrk, &vg->stvbuf);
        vg->stvbuf = NULL;
        vg->m_buf = (void *)in;

        return (1);
}

static int v_matchproto_(vdpio_lease_f)
vdpio_gunzip_lease(struct vdp_ctx *vdc, struct vdp_entry *this, struct vscarab *out)
{
        struct vscarab *in;
        enum vgzret_e vr;
        struct vgz *vg;
        struct viov *v, *b, *o;
        int r;

        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(this, VDP_ENTRY_MAGIC);
        CAST_OBJ_NOTNULL(vg, this->priv, VGZ_MAGIC);
        CAST_OBJ_NOTNULL(in, (void*)vg->m_buf, VSCARAB_MAGIC);

        this->calls++;

        if (out->used == out->capacity)
                return (0);

        if (in->used < in->capacity && (in->flags & VSCARAB_F_END) == 0)
                r = vdpio_pull(vdc, this, in);
        else
                r = 0;

        if (in->used == 0) {
                out->flags = in->flags & VSCARAB_F_END;
                return (r);
        }

        // XXX more than one buffer?
        VSCARAB_LOCAL(buf, 1);
        b = VSCARAB_GET(buf);
        AN(b);
        b->iov.iov_len = cache_param->gzip_buffer;
        r = ObjVAIbuffer(vdc->wrk, vdc->vai_hdl, buf);
        if (r < 0)
                return (out->used ? 0 : r);

        o = VSCARAB_GET(out);
        AN(o);
        r = 0;

        VSCARAB_FOREACH(v, in) {
                this->bytes_in += v->iov.iov_len;
                vr = vgz_gunzip_iovec(vg, &v->iov, &b->iov, &o->iov);
                if (vr == VGZ_END && v->iov.iov_len > 0) {
                        VSLb(vg->vsl, SLT_Gzip, "G(un)zip error: %d (%s)",
                             vr, "junk after VGZ_END");
                        r = -EMSGSIZE;
                        break;
                }
                if (vr < VGZ_OK)
                        break;

                if (b->iov.iov_len == 0 || vr != VGZ_OK) {
                        r = 1;
                        break;
                }
        }

        if (r <= 0) {
                o->iov.iov_base = NULL;
                o->iov.iov_len = 0;
                vdpio_return_lease(vdc, b->lease);
                return (r);
        }

        o->lease = b->lease;
        b->lease = 0;

        vdpio_consolidate_vscarab(vdc, in);
        if (in->used == 0)
                out->flags = in->flags & VSCARAB_F_END;

        return (r);
}

static void v_matchproto_(vdpio_fini_f)
vdpio_gunzip_fini(struct vdp_ctx *vdc, void **priv)
{
        struct vscarab *in;
        struct vgz *vg;

        (void)vdc;
        TAKE_OBJ_NOTNULL(vg, priv, VGZ_MAGIC);
        CAST_OBJ_NOTNULL(in, (void *)vg->m_buf, VSCARAB_MAGIC);
        vg->m_buf = NULL;

        (void)VGZ_Destroy(vdc->wrk, &vg);
}

const struct vdp VDP_gunzip = {
        .name =         "gunzip",
        .init =         vdp_gunzip_init,
        .bytes =        vdp_gunzip_bytes,
        .fini =         vdp_gunzip_fini,

#ifdef LATER
        .io_init =      vdpio_gunzip_init,
#endif
        .io_upgrade =   vdpio_gunzip_upgrade,
        .io_lease =     vdpio_gunzip_lease,
        .io_fini =      vdpio_gunzip_fini,
};

/*--------------------------------------------------------------------*/

void
VGZ_UpdateObj(const struct vfp_ctx *vc, struct vgz *vg, enum vgzret_e e)
{
        char *p;
        intmax_t ii;

        CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
        if (e < VGZ_OK)
                return;
        ii = vg->vz.start_bit + vg->vz.last_bit + vg->vz.stop_bit;
        if (e != VGZ_END && ii == vg->bits)
                return;
        vg->bits = ii;
        p = ObjSetAttr(vc->wrk, vc->oc, OA_GZIPBITS, 32, NULL);
        AN(p);
        vbe64enc(p, vg->vz.start_bit);
        vbe64enc(p + 8, vg->vz.last_bit);
        vbe64enc(p + 16, vg->vz.stop_bit);
        if (e != VGZ_END)
                return;
        if (vg->dir == VGZ_GZ)
                vbe64enc(p + 24, vg->vz.total_in);
        if (vg->dir == VGZ_UN)
                vbe64enc(p + 24, vg->vz.total_out);
}

/*--------------------------------------------------------------------
 */

enum vgzret_e
VGZ_Destroy(struct worker *wrk, struct vgz **vgp)
{
        struct vgz *vg;
        enum vgzret_e vr;
        int i;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        TAKE_OBJ_NOTNULL(vg, vgp, VGZ_MAGIC);
        AN(vg->id);
        VSLb(vg->vsl, SLT_Gzip, "%s %jd %jd %jd %jd %jd",
            vg->id,
            (intmax_t)vg->vz.total_in,
            (intmax_t)vg->vz.total_out,
            (intmax_t)vg->vz.start_bit,
            (intmax_t)vg->vz.last_bit,
            (intmax_t)vg->vz.stop_bit);
        if (vg->dir == VGZ_GZ)
                i = deflateEnd(&vg->vz);
        else
                i = inflateEnd(&vg->vz);
        if (vg->last_i == Z_STREAM_END && i == Z_OK)
                i = Z_STREAM_END;
        if (vg->m_buf != NULL) {
                AN(vg->stvbuf);
                STV_FreeBuf(wrk, &vg->stvbuf);
        }
        AZ(vg->stvbuf);
        if (i == Z_OK)
                vr = VGZ_OK;
        else if (i == Z_STREAM_END)
                vr = VGZ_END;
        else if (i == Z_BUF_ERROR)
                vr = VGZ_STUCK;
        else {
                VSLb(vg->vsl, SLT_Gzip, "G(un)zip error: %d (%s)",
                    i, vgz_msg(vg));
                vr = VGZ_ERROR;
        }
        FREE_OBJ(vg);
        return (vr);
}

/*--------------------------------------------------------------------*/

static enum vfp_status v_matchproto_(vfp_init_f)
vfp_gzip_init(VRT_CTX, struct vfp_ctx *vc, struct vfp_entry *vfe)
{
        struct vgz *vg;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);

        /*
         * G(un)zip makes no sence on partial responses, but since
         * it is an pure 1:1 transform, we can just ignore it.
         */
        if (http_GetStatus(vc->resp) == 206)
                return (VFP_NULL);

        if (vfe->vfp == &VFP_gzip) {
                if (http_GetHdr(vc->resp, H_Content_Encoding, NULL))
                        return (VFP_NULL);
                vg = VGZ_NewGzip(vc->wrk->vsl, vfe->vfp->priv1);
                vc->obj_flags |= OF_GZIPED | OF_CHGCE;
        } else {
                if (!http_HdrIs(vc->resp, H_Content_Encoding, "gzip"))
                        return (VFP_NULL);
                if (vfe->vfp == &VFP_gunzip) {
                        vg = VGZ_NewGunzip(vc->wrk->vsl, vfe->vfp->priv1);
                        vc->obj_flags &= ~OF_GZIPED;
                        vc->obj_flags |= OF_CHGCE;
                } else {
                        vg = VGZ_NewTestGunzip(vc->wrk->vsl, vfe->vfp->priv1);
                        vc->obj_flags |= OF_GZIPED;
                }
        }
        AN(vg);
        vfe->priv1 = vg;
        if (vgz_getmbuf(vc->wrk, vg))
                return (VFP_ERROR);
        VGZ_Ibuf(vg, vg->m_buf, 0);
        AZ(vg->m_len);

        if (vfe->vfp == &VFP_gunzip || vfe->vfp == &VFP_gzip) {
                http_Unset(vc->resp, H_Content_Encoding);
                http_Unset(vc->resp, H_Content_Length);
                RFC2616_Weaken_Etag(vc->resp);
        }

        if (vfe->vfp == &VFP_gzip)
                http_SetHeader(vc->resp, "Content-Encoding: gzip");

        if (vfe->vfp == &VFP_gzip || vfe->vfp == &VFP_testgunzip)
                RFC2616_Vary_AE(vc->resp);

        return (VFP_OK);
}

/*--------------------------------------------------------------------
 * VFP_GUNZIP
 *
 * A VFP for gunzip'ing an object as we receive it from the backend
 */

static enum vfp_status v_matchproto_(vfp_pull_f)
vfp_gunzip_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p,
    ssize_t *lp)
{
        ssize_t l;
        struct vgz *vg;
        enum vgzret_e vr = VGZ_ERROR;
        const void *dp;
        ssize_t dl;
        enum vfp_status vp = VFP_OK;

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
        CAST_OBJ_NOTNULL(vg, vfe->priv1, VGZ_MAGIC);
        AN(p);
        AN(lp);
        l = *lp;
        *lp = 0;
        VGZ_Obuf(vg, p, l);
        do {
                if (VGZ_IbufEmpty(vg)) {
                        l = vg->m_sz;
                        vp = VFP_Suck(vc, vg->m_buf, &l);
                        if (vp == VFP_ERROR)
                                return (vp);
                        VGZ_Ibuf(vg, vg->m_buf, l);
                }
                if (!VGZ_IbufEmpty(vg) || vp == VFP_END) {
                        vr = VGZ_Gunzip(vg, &dp, &dl);
                        if (vr == VGZ_END && !VGZ_IbufEmpty(vg))
                                return (VFP_Error(vc, "Junk after gzip data"));
                        if (vr < VGZ_OK)
                                return (VFP_Error(vc,
                                    "Invalid Gzip data: %s", vgz_msg(vg)));
                        if (dl > 0) {
                                *lp = dl;
                                assert(dp == p);
                                return (VFP_OK);
                        }
                }
                AN(VGZ_IbufEmpty(vg));
        } while (vp == VFP_OK);
        if (vr != VGZ_END)
                return (VFP_Error(vc, "Gunzip error at the very end"));
        return (vp);
}


/*--------------------------------------------------------------------
 * VFP_GZIP
 *
 * A VFP for gzip'ing an object as we receive it from the backend
 */

static enum vfp_status v_matchproto_(vfp_pull_f)
vfp_gzip_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p,
    ssize_t *lp)
{
        ssize_t l;
        struct vgz *vg;
        enum vgzret_e vr = VGZ_ERROR;
        const void *dp;
        ssize_t dl;
        enum vfp_status vp = VFP_ERROR;

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
        CAST_OBJ_NOTNULL(vg, vfe->priv1, VGZ_MAGIC);
        AN(p);
        AN(lp);
        l = *lp;
        *lp = 0;
        VGZ_Obuf(vg, p, l);
        do {
                if (VGZ_IbufEmpty(vg)) {
                        l = vg->m_sz;
                        vp = VFP_Suck(vc, vg->m_buf, &l);
                        if (vp == VFP_ERROR)
                                break;
                        if (vp == VFP_END)
                                vg->flag = VGZ_FINISH;
                        VGZ_Ibuf(vg, vg->m_buf, l);
                }
                if (!VGZ_IbufEmpty(vg) || vg->flag == VGZ_FINISH) {
                        vr = VGZ_Gzip(vg, &dp, &dl, vg->flag);
                        if (vr < VGZ_OK)
                                return (VFP_Error(vc, "Gzip failed"));
                        if (dl > 0) {
                                VGZ_UpdateObj(vc, vg, vr);
                                *lp = dl;
                                assert(dp == p);
                                if (vr != VGZ_END || !VGZ_IbufEmpty(vg))
                                        return (VFP_OK);
                        }
                }
                AN(VGZ_IbufEmpty(vg));
        } while (vg->flag != VGZ_FINISH);

        if (vr != VGZ_END)
                return (VFP_Error(vc, "Gzip failed"));
        VGZ_UpdateObj(vc, vg, VGZ_END);
        return (VFP_END);
}

/*--------------------------------------------------------------------
 * VFP_TESTGZIP
 *
 * A VFP for testing that received gzip data is valid, and for
 * collecting the magic bits while we're at it.
 */

static enum vfp_status v_matchproto_(vfp_pull_f)
vfp_testgunzip_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p,
    ssize_t *lp)
{
        struct vgz *vg;
        enum vgzret_e vr = VGZ_ERROR;
        const void *dp;
        ssize_t dl;
        enum vfp_status vp;

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
        CAST_OBJ_NOTNULL(vg, vfe->priv1, VGZ_MAGIC);
        AN(p);
        AN(lp);
        vp = VFP_Suck(vc, p, lp);
        if (vp == VFP_ERROR)
                return (vp);
        if (*lp > 0 || vp == VFP_END) {
                VGZ_Ibuf(vg, p, *lp);
                do {
                        VGZ_Obuf(vg, vg->m_buf, vg->m_sz);
                        vr = VGZ_Gunzip(vg, &dp, &dl);
                        if (vr == VGZ_END && !VGZ_IbufEmpty(vg))
                                return (VFP_Error(vc, "Junk after gzip data"));
                        if (vr < VGZ_OK)
                                return (VFP_Error(vc,
                                    "Invalid Gzip data: %s", vgz_msg(vg)));
                } while (!VGZ_IbufEmpty(vg));
        }
        VGZ_UpdateObj(vc, vg, vr);
        if (vp == VFP_END && vr != VGZ_END)
                return (VFP_Error(vc, "tGunzip failed"));
        return (vp);
}

/*--------------------------------------------------------------------*/

static void v_matchproto_(vfp_fini_f)
vfp_gzip_fini(struct vfp_ctx *vc, struct vfp_entry *vfe)
{
        struct vgz *vg;

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);

        if (vfe->priv1 != NULL) {
                TAKE_OBJ_NOTNULL(vg, &vfe->priv1, VGZ_MAGIC);
                (void)VGZ_Destroy(vc->wrk, &vg);
        }
}

/*--------------------------------------------------------------------*/

const struct vfp VFP_gunzip = {
        .name = "gunzip",
        .init = vfp_gzip_init,
        .pull = vfp_gunzip_pull,
        .fini = vfp_gzip_fini,
        .priv1 = "U F -",
};

const struct vfp VFP_gzip = {
        .name = "gzip",
        .init = vfp_gzip_init,
        .pull = vfp_gzip_pull,
        .fini = vfp_gzip_fini,
        .priv1 = "G F -",
};

const struct vfp VFP_testgunzip = {
        .name = "testgunzip",
        .init = vfp_gzip_init,
        .pull = vfp_testgunzip_pull,
        .fini = vfp_gzip_fini,
        .priv1 = "u F -",
};

		varnish-cache/bin/varnishd/cache/cache_gzip.c
0		/*-
1		* Copyright (c) 2013-2015 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
5		*
6		* SPDX-License-Identifier: BSD-2-Clause
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted provided that the following conditions
10		* are met:
11		* 1. Redistributions of source code must retain the above copyright
12		* notice, this list of conditions and the following disclaimer.
13		* 2. Redistributions in binary form must reproduce the above copyright
14		* notice, this list of conditions and the following disclaimer in the
15		* documentation and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27		* SUCH DAMAGE.
28		*
29		* Interaction with the libvgz (zlib) library.
30		*
31		* The zlib library pollutes namespace a LOT when you include the "vgz.h"
32		* (aka "zlib.h") file so we contain the damage by vectoring all access
33		* to libz through this source file.
34		*
35		* The API defined by this file, will also insulate the rest of the code,
36		* should we find a better gzip library at a later date.
37		*
38		*/
39
40		#include "config.h"
41
42		#include <stdlib.h>
43
44		#include "cache_varnishd.h"
45		#include "cache_filter.h"
46		#include "cache_objhead.h"
47		#include "cache_vgz.h"
48
49		#include "storage/storage.h"
50
51		#include "vend.h"
52
53		#include "vgz.h"
54
55		struct vgz {
56		unsigned magic;
57		#define VGZ_MAGIC 0x162df0cb
58		enum {VGZ_GZ,VGZ_UN} dir;
59		struct vsl_log *vsl;
60		const char *id;
61		int last_i;
62		enum vgz_flag flag;
63
64		struct stv_buffer *stvbuf;
65		char *m_buf;
66		ssize_t m_sz;
67		ssize_t m_len;
68
69		intmax_t bits;
70
71		z_stream vz;
72		};
73
74		static const char *
75	240	vgz_msg(const struct vgz *vg)
76		{
77	240	CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
78	240	return (vg->vz.msg ? vg->vz.msg : "(null)");
79		}
80
81		/*--------------------------------------------------------------------
82		* Set up a gunzip instance
83		*/
84
85		static struct vgz *
86	10240	vgz_gunzip(struct vsl_log vsl, const char id)
87		{
88		struct vgz *vg;
89
90	10240	ALLOC_OBJ(vg, VGZ_MAGIC);
91	10240	AN(vg);
92	10240	vg->vsl = vsl;
93	10240	vg->id = id;
94	10240	vg->dir = VGZ_UN;
95
96		/*
97		* Max memory usage according to zonf.h:
98		* mem_needed = "a few kb" + (1 << (windowBits))
99		* Since we don't control windowBits, we have to assume
100		* it is 15, so 34-35KB or so.
101		*/
102	10240	assert(Z_OK == inflateInit2(&vg->vz, 31));
103	10240	return (vg);
104		}
105
106		static struct vgz *
107	9000	VGZ_NewGunzip(struct vsl_log vsl, const char id)
108		{
109	9000	VSC_C_main->n_gunzip++;
110	9000	return (vgz_gunzip(vsl, id));
111		}
112
113		static struct vgz *
114	1240	VGZ_NewTestGunzip(struct vsl_log vsl, const char id)
115		{
116	1240	VSC_C_main->n_test_gunzip++;
117	1240	return (vgz_gunzip(vsl, id));
118		}
119
120		struct vgz *
121	3680	VGZ_NewGzip(struct vsl_log vsl, const char id)
122		{
123		struct vgz *vg;
124		int i;
125
126	3680	VSC_C_main->n_gzip++;
127	3680	ALLOC_OBJ(vg, VGZ_MAGIC);
128	3680	AN(vg);
129	3680	vg->vsl = vsl;
130	3680	vg->id = id;
131	3680	vg->dir = VGZ_GZ;
132
133		/*
134		* From zconf.h:
135		*
136		* mem_needed = "a few kb"
137		* + (1 << (windowBits+2))
138		* + (1 << (memLevel+9))
139		*
140		* windowBits [8..15] (-> 1K..128K)
141		* memLevel [1..9] (-> 1K->256K)
142		*/
143	3680	i = deflateInit2(&vg->vz,
144		cache_param->gzip_level, /* Level */
145		Z_DEFLATED, /* Method */
146		16 + 15, /* Window bits (16=gzip) */
147		cache_param->gzip_memlevel, /* memLevel */
148		Z_DEFAULT_STRATEGY);
149	3680	assert(Z_OK == i);
150	3680	return (vg);
151		}
152
153		/*--------------------------------------------------------------------
154		*/
155
156		static int
157	10880	vgz_getmbuf(struct worker wrk, struct vgz vg)
158		{
159		size_t sz;
160
161	10880	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
162	10880	CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
163	10880	AZ(vg->m_sz);
164	10880	AZ(vg->m_len);
165	10880	AZ(vg->m_buf);
166	10880	AZ(vg->stvbuf);
167
168	10880	vg->stvbuf = STV_AllocBuf(wrk, stv_transient, cache_param->gzip_buffer);
169	10880	if (vg->stvbuf == NULL)
170	0	return (-1);
171	10880	vg->m_buf = STV_GetBufPtr(vg->stvbuf, &sz);
172	10880	vg->m_sz = sz;
173	10880	AN(vg->m_buf);
174	10880	assert(vg->m_sz > 0);
175	10880	return (0);
176	10880	}
177
178		/--------------------------------------------------------------------/
179
180		void
181	67351	VGZ_Ibuf(struct vgz vg, const void ptr, ssize_t len)
182		{
183
184	67351	CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
185	67351	AZ(vg->vz.avail_in);
186	67351	assert(len >= 0);
187	67351	if (len > 0)
188	45271	AN(ptr);
189
190	67351	vg->vz.next_in = TRUST_ME(ptr);
191	67351	vg->vz.avail_in = len;
192	67351	}
193
194		int
195	151293	VGZ_IbufEmpty(const struct vgz *vg)
196		{
197
198	151293	CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
199	151293	return (vg->vz.avail_in == 0);
200		}
201
202		/--------------------------------------------------------------------/
203
204		void
205	72229	VGZ_Obuf(struct vgz vg, void ptr, ssize_t len)
206		{
207
208	72229	CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
209	72229	AN(ptr);
210	72229	assert(len > 0);
211
212	72229	vg->vz.next_out = ptr;
213	72229	vg->vz.avail_out = len;
214	72229	}
215
216		int
217	42748	VGZ_ObufFull(const struct vgz *vg)
218		{
219
220	42748	CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
221	42748	return (vg->vz.avail_out == 0);
222		}
223
224		/--------------------------------------------------------------------/
225
226		static enum vgzret_e
227	33001	VGZ_Gunzip(struct vgz vg, const void pptr, ssize_t plen)
228		{
229		int i;
230		ssize_t l;
231		const uint8_t *before;
232
233	33001	CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
234
235	33001	*pptr = NULL;
236	33001	*plen = 0;
237	33001	AN(vg->vz.next_out);
238	33001	AN(vg->vz.avail_out);
239	33001	before = vg->vz.next_out;
240	33001	i = inflate(&vg->vz, 0);
241	33001	if (i == Z_OK \|\| i == Z_STREAM_END) {
242	32839	*pptr = before;
243	32839	l = (const uint8_t *)vg->vz.next_out - before;
244	32839	*plen = l;
245	32839	}
246	33001	vg->last_i = i;
247	33001	if (i == Z_OK)
248	22561	return (VGZ_OK);
249	10440	if (i == Z_STREAM_END)
250	10280	return (VGZ_END);
251	160	if (i == Z_BUF_ERROR)
252	80	return (VGZ_STUCK);
253	80	VSLb(vg->vsl, SLT_Gzip, "Gunzip error: %d (%s)", i, vgz_msg(vg));
254	80	return (VGZ_ERROR);
255	33001	}
256
257		/* set vz pointers for in and out iovecs */
258		static inline void
259	640	vgz_iovec_update(struct vgz vg, const struct iovec in, const struct iovec *buf)
260		{
261		/* in: either fully consumed or the same */
262	640	assert(vg->vz.avail_in == 0 \|\| vg->vz.next_in == TRUST_ME(in->iov_base));
263	640	vg->vz.next_in = TRUST_ME(in->iov_base);
264	640	vg->vz.avail_in = in->iov_len;
265	640	vg->vz.next_out = TRUST_ME(buf->iov_base);
266	640	vg->vz.avail_out = buf->iov_len;
267	640	}
268
269		static enum vgzret_e
270	640	vgz_gunzip_iovec(struct vgz vg, struct iovec in, struct iovec buf, struct iovec out)
271		{
272		int i;
273
274	640	CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
275	640	AN(in && buf && out);
276	640	vgz_iovec_update(vg, in, buf);
277
278	640	i = inflate(&vg->vz, 0);
279	640	if (i == Z_OK \|\| i == Z_STREAM_END) {
280	640	iovec_collect(buf, out, pdiff(buf->iov_base, vg->vz.next_out));
281	640	in->iov_base = TRUST_ME(vg->vz.next_in);
282	640	in->iov_len = vg->vz.avail_in;
283	640	}
284	640	vg->last_i = i;
285	640	if (i == Z_OK)
286	0	return (VGZ_OK);
287	640	if (i == Z_STREAM_END)
288	640	return (VGZ_END);
289	0	if (i == Z_BUF_ERROR)
290	0	return (VGZ_STUCK);
291	0	VSLb(vg->vsl, SLT_Gzip, "Gunzip error: %d (%s)", i, vgz_msg(vg));
292	0	return (VGZ_ERROR);
293	640	}
294
295		/--------------------------------------------------------------------/
296
297		enum vgzret_e
298	45428	VGZ_Gzip(struct vgz vg, const void pptr, ssize_t plen, enum vgz_flag flags)
299		{
300		int i;
301		int zflg;
302		ssize_t l;
303		const uint8_t *before;
304
305	45428	CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
306
307	45428	*pptr = NULL;
308	45428	*plen = 0;
309	45428	AN(vg->vz.next_out);
310	45428	AN(vg->vz.avail_out);
311	45428	before = vg->vz.next_out;
312	45428	switch (flags) {
313	29908	case VGZ_NORMAL: zflg = Z_NO_FLUSH; break;
314	5000	case VGZ_ALIGN: zflg = Z_SYNC_FLUSH; break;
315	5040	case VGZ_RESET: zflg = Z_FULL_FLUSH; break;
316	5480	case VGZ_FINISH: zflg = Z_FINISH; break;
317	0	default: WRONG("Invalid VGZ flag");
318	0	}
319	45428	i = deflate(&vg->vz, zflg);
320	45428	if (i == Z_OK \|\| i == Z_STREAM_END) {
321	45428	*pptr = before;
322	45428	l = (const uint8_t *)vg->vz.next_out - before;
323	45428	*plen = l;
324	45428	}
325	45428	vg->last_i = i;
326	45428	if (i == Z_OK)
327	41948	return (VGZ_OK);
328	3480	if (i == Z_STREAM_END)
329	3480	return (VGZ_END);
330	0	if (i == Z_BUF_ERROR)
331	0	return (VGZ_STUCK);
332	0	VSLb(vg->vsl, SLT_Gzip, "Gzip error: %d (%s)", i, vgz_msg(vg));
333	0	return (VGZ_ERROR);
334	45428	}
335
336		/*--------------------------------------------------------------------
337		* VDP for gunzip'ing
338		*/
339
340		// common for traditional interface and vdpio
341		static int vdp_gunzip_init_common(struct vdp_ctx *vdc);
342
343		static int v_matchproto_(vdp_init_f)
344	4000	vdp_gunzip_init(VRT_CTX, struct vdp_ctx vdc, void *priv)
345		{
346		struct vgz *vg;
347
348	4000	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
349	4000	CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
350	4000	CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
351	4000	CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
352	4000	AN(vdc->clen);
353	4000	AN(priv);
354
355	4000	vg = VGZ_NewGunzip(vdc->vsl, "U D -");
356	4000	AN(vg);
357	4000	if (vgz_getmbuf(vdc->wrk, vg)) {
358	0	(void)VGZ_Destroy(vdc->wrk, &vg);
359	0	return (-1);
360		}
361
362	4000	VGZ_Obuf(vg, vg->m_buf, vg->m_sz);
363	4000	*priv = vg;
364	4000	return (vdp_gunzip_init_common(vdc));
365	4000	}
366
367		static int
368	4000	vdp_gunzip_init_common(struct vdp_ctx *vdc)
369		{
370		struct boc *boc;
371		enum boc_state_e bos;
372		const char *p;
373		ssize_t dl;
374		uint64_t u;
375	4000	http_Unset(vdc->hp, H_Content_Encoding);
376
377	4000	*vdc->clen = -1;
378
379	4000	if (vdc->oc == NULL)
380	680	return (0);
381
382	3320	boc = HSH_RefBoc(vdc->oc);
383	3320	if (boc != NULL) {
384	520	CHECK_OBJ(boc, BOC_MAGIC);
385	520	bos = boc->state;
386	520	HSH_DerefBoc(vdc->wrk, vdc->oc);
387	520	if (bos < BOS_FINISHED)
388	520	return (0); /* OA_GZIPBITS is not stable yet */
389	0	}
390
391	2800	p = ObjGetAttr(vdc->wrk, vdc->oc, OA_GZIPBITS, &dl);
392	2800	if (p != NULL && dl == 32) {
393	2800	u = vbe64dec(p + 24);
394	2800	if (u != 0)
395	2760	*vdc->clen = u;
396	2800	}
397	2800	return (0);
398	4000	}
399
400		static int v_matchproto_(vdp_fini_f)
401	3360	vdp_gunzip_fini(struct vdp_ctx vdc, void *priv)
402		{
403		struct vgz *vg;
404
405	3360	(void)vdc;
406	3360	TAKE_OBJ_NOTNULL(vg, priv, VGZ_MAGIC);
407	3360	AN(vg->m_buf);
408	3360	(void)VGZ_Destroy(vdc->wrk, &vg);
409	3360	return (0);
410		}
411
412		static int v_matchproto_(vdp_bytes_f)
413	17716	vdp_gunzip_bytes(struct vdp_ctx vdc, enum vdp_action act, void *priv,
414		const void *ptr, ssize_t len)
415		{
416		enum vgzret_e vr;
417		ssize_t dl;
418		const void *dp;
419		struct vgz *vg;
420
421	17716	CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
422	17716	CHECK_OBJ_NOTNULL(vdc->wrk, WORKER_MAGIC);
423	17716	(void)act;
424
425	17716	CAST_OBJ_NOTNULL(vg, *priv, VGZ_MAGIC);
426	17716	AN(vg->m_buf);
427
428	17716	if (len == 0)
429	4676	return (0);
430
431	13040	VGZ_Ibuf(vg, ptr, len);
432	13040	do {
433	13040	vr = VGZ_Gunzip(vg, &dp, &dl);
434	13040	if (vr == VGZ_END && !VGZ_IbufEmpty(vg)) {
435	80	VSLb(vg->vsl, SLT_Gzip, "G(un)zip error: %d (%s)",
436	40	vr, "junk after VGZ_END");
437	40	return (-1);
438		}
439	13000	vg->m_len += dl;
440	13000	if (vr < VGZ_OK)
441	0	return (-1);
442		// END or STUCK
443	13000	if (vg->m_len == vg->m_sz \|\| vr != VGZ_OK) {
444	6480	if (VDP_bytes(vdc, vr == VGZ_END ? VDP_END : VDP_FLUSH,
445	3240	vg->m_buf, vg->m_len))
446	160	return (vdc->retval);
447	3080	vg->m_len = 0;
448	3080	VGZ_Obuf(vg, vg->m_buf, vg->m_sz);
449	3080	}
450	12840	} while (!VGZ_IbufEmpty(vg));
451	12840	assert(vr == VGZ_STUCK \|\| vr == VGZ_OK \|\| vr == VGZ_END);
452	12840	return (0);
453	17716	}
454
455		#ifdef LATER
456		/*
457		* XXX does it make sense to work on more than one buffer?
458		*/
459		static int v_matchproto_(vdpio_init_f)
460		vdpio_gunzip_init(VRT_CTX, struct vdp_ctx vdc, void *priv, int capacity)
461		{
462		struct vgz *vg;
463		struct vscarab *in;
464
465		CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
466		CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
467		CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
468		CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
469		AN(vdc->clen);
470		AN(priv);
471		assert(capacity >= 1);
472
473		if (capacity < 4)
474		capacity = 4;
475
476		in = WS_Alloc(ctx->ws, VSCARAB_SIZE(capacity));
477		if (in == NULL)
478		return (-1);
479
480		vg = VGZ_NewGunzip(vdc->vsl, "U D -");
481		if (vg == NULL)
482		return (-1);
483
484		AZ(vg->m_buf);
485		vg->m_buf = (void *)in;
486
487		*priv = vg;
488		AZ(vdp_gunzip_init_common(vdc));
489		return (1);
490		}
491		#endif
492
493		static int v_matchproto_(vdpio_init_f)
494	640	vdpio_gunzip_upgrade(VRT_CTX, struct vdp_ctx vdc, void *priv, int capacity)
495		{
496		struct vgz *vg;
497		struct vscarab *in;
498
499	640	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);