GCOV - Varnish Cache


/*-
 * Copyright (c) 2011 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.
 *
 * VED - Varnish Esi Delivery
 */

#include "config.h"

#include "cache_varnishd.h"

#include <stdlib.h>

#include "cache_transport.h"
#include "cache_filter.h"
#include "cache_vgz.h"

#include "vct.h"
#include "vtim.h"
#include "cache_esi.h"
#include "vend.h"
#include "vgz.h"

static vtr_deliver_f ved_deliver;
static vtr_reembark_f ved_reembark;

static const uint8_t gzip_hdr[] = {
        0x1f, 0x8b, 0x08,
        0x00, 0x00, 0x00, 0x00,
        0x00,
        0x02, 0x03
};

struct ecx {
        unsigned        magic;
#define ECX_MAGIC       0x0b0f9163
        const uint8_t   *p;
        const uint8_t   *e;
        int             state;
        ssize_t         l;
        int             isgzip;
        int             woken;
        int             abrt;

        struct req      *preq;
        struct ecx      *pecx;
        ssize_t         l_crc;
        uint32_t        crc;
};

static int v_matchproto_(vtr_minimal_response_f)
ved_minimal_response(struct req *req, uint16_t status)
{
        (void)req;
        (void)status;
        WRONG("esi:includes should not try minimal responses");
}

static const struct transport VED_transport = {
        .magic =                TRANSPORT_MAGIC,
        .name =                 "ESI_INCLUDE",
        .deliver =              ved_deliver,
        .reembark =             ved_reembark,
        .minimal_response =     ved_minimal_response,
};

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

static void v_matchproto_(vtr_reembark_f)
ved_reembark(struct worker *wrk, struct req *req)
{
        struct ecx *ecx;

        (void)wrk;
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        CAST_OBJ_NOTNULL(ecx, req->transport_priv, ECX_MAGIC);
        Lck_Lock(&req->sp->mtx);
        ecx->woken = 1;
        PTOK(pthread_cond_signal(&ecx->preq->wrk->cond));
        Lck_Unlock(&req->sp->mtx);
}

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

static void
ved_include(struct req *preq, const char *src, const char *host,
    struct ecx *ecx)
{
        struct worker *wrk;
        struct sess *sp;
        struct req *req;
        enum req_fsm_nxt s;

        CHECK_OBJ_NOTNULL(preq, REQ_MAGIC);
        CHECK_OBJ_NOTNULL(preq->top, REQTOP_MAGIC);
        sp = preq->sp;
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
        CHECK_OBJ_NOTNULL(ecx, ECX_MAGIC);
        wrk = preq->wrk;

        if (preq->esi_level >= cache_param->max_esi_depth) {
                VSLb(preq->vsl, SLT_VCL_Error,
                    "ESI depth limit reached (param max_esi_depth = %u)",
                    cache_param->max_esi_depth);
                if (ecx->abrt)
                        preq->top->topreq->vdc->retval = -1;
                return;
        }

        req = Req_New(sp, preq);
        AN(req);
        THR_SetRequest(req);
        assert(IS_NO_VXID(req->vsl->wid));
        req->vsl->wid = VXID_Get(wrk, VSL_CLIENTMARKER);

        wrk->stats->esi_req++;
        req->esi_level = preq->esi_level + 1;

        VSLb(req->vsl, SLT_Begin, "req %ju esi %u",
            (uintmax_t)VXID(preq->vsl->wid), req->esi_level);
        VSLb(preq->vsl, SLT_Link, "req %ju esi %u",
            (uintmax_t)VXID(req->vsl->wid), req->esi_level);

        VSLb_ts_req(req, "Start", W_TIM_real(wrk));

        HTTP_Setup(req->http, req->ws, req->vsl, SLT_ReqMethod);
        HTTP_Dup(req->http, preq->http0);

        http_SetH(req->http, HTTP_HDR_URL, src);
        if (host != NULL && *host != '\0')  {
                http_Unset(req->http, H_Host);
                http_SetHeader(req->http, host);
        }

        http_ForceField(req->http, HTTP_HDR_METHOD, "GET");
        http_ForceField(req->http, HTTP_HDR_PROTO, "HTTP/1.1");

        /* Don't allow conditionals, we can't use a 304 */
        http_Unset(req->http, H_If_Modified_Since);
        http_Unset(req->http, H_If_None_Match);

        /* Don't allow Range */
        http_Unset(req->http, H_Range);

        /* Set Accept-Encoding according to what we want */
        if (ecx->isgzip)
                http_ForceHeader(req->http, H_Accept_Encoding, "gzip");
        else
                http_Unset(req->http, H_Accept_Encoding);

        /* Client content already taken care of */
        http_Unset(req->http, H_Content_Length);
        http_Unset(req->http, H_Transfer_Encoding);
        req->req_body_status = BS_NONE;

        AZ(req->vcl);
        assert(req->top == preq->top);
        if (req->top->vcl0)
                req->vcl = req->top->vcl0;
        else
                req->vcl = preq->vcl;
        VCL_Ref(req->vcl);

        assert(req->req_step == R_STP_TRANSPORT);
        req->t_req = preq->t_req;

        req->transport = &VED_transport;
        req->transport_priv = ecx;

        VCL_TaskEnter(req->privs);

        while (1) {
                CNT_Embark(wrk, req);
                ecx->woken = 0;
                s = CNT_Request(req);
                if (s == REQ_FSM_DONE)
                        break;
                DSL(DBG_WAITINGLIST, req->vsl->wid,
                    "waiting for ESI (%d)", (int)s);
                assert(s == REQ_FSM_DISEMBARK);
                Lck_Lock(&sp->mtx);
                if (!ecx->woken)
                        (void)Lck_CondWait(&ecx->preq->wrk->cond, &sp->mtx);
                Lck_Unlock(&sp->mtx);
                AZ(req->wrk);
        }

        VCL_Rel(&req->vcl);

        req->wrk = NULL;
        THR_SetRequest(preq);

        Req_Cleanup(sp, wrk, req);
        Req_Release(req);
}

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

//#define Debug(fmt, ...) printf(fmt, __VA_ARGS__)
#define Debug(fmt, ...) /**/

static ssize_t
ved_decode_len(struct vsl_log *vsl, const uint8_t **pp)
{
        const uint8_t *p;
        ssize_t l;

        p = *pp;
        switch (*p & 15) {
        case 1:
                l = p[1];
                p += 2;
                break;
        case 2:
                l = vbe16dec(p + 1);
                p += 3;
                break;
        case 8:
                l = vbe64dec(p + 1);
                p += 9;
                break;
        default:
                VSLb(vsl, SLT_Error,
                    "ESI-corruption: Illegal Length %d %d\n", *p, (*p & 15));
                WRONG("ESI-codes: illegal length");
        }
        *pp = p;
        assert(l > 0);
        return (l);
}

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

static int v_matchproto_(vdp_init_f)
ved_vdp_esi_init(VRT_CTX, struct vdp_ctx *vdc, void **priv)
{
        struct ecx *ecx;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_ORNULL(ctx->req, REQ_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);

        AZ(*priv);
        if (vdc->oc == NULL || !ObjHasAttr(vdc->wrk, vdc->oc, OA_ESIDATA))
                return (1);

        if (ctx->req == NULL) {
                VSLb(vdc->vsl, SLT_Error,
                     "esi can only be used on the client side");
                return (1);
        }

        ALLOC_OBJ(ecx, ECX_MAGIC);
        AN(ecx);
        assert(sizeof gzip_hdr == 10);
        ecx->preq = ctx->req;
        *priv = ecx;
        RFC2616_Weaken_Etag(vdc->hp);

        ctx->req->res_esi = 1;
        if (*vdc->clen != 0)
                *vdc->clen = -1;
        if (ctx->req->esi_level > 0) {
                assert(ctx->req->transport == &VED_transport);
                CAST_OBJ_NOTNULL(ecx->pecx, ctx->req->transport_priv, ECX_MAGIC);
                if (!ecx->pecx->isgzip)
                        ecx->pecx = NULL;
        }

        return (0);
}

static int v_matchproto_(vdp_fini_f)
ved_vdp_esi_fini(struct vdp_ctx *vdc, void **priv)
{
        struct ecx *ecx;

        (void)vdc;
        TAKE_OBJ_NOTNULL(ecx, priv, ECX_MAGIC);
        FREE_OBJ(ecx);
        return (0);
}

static int v_matchproto_(vdp_bytes_f)
ved_vdp_esi_bytes(struct vdp_ctx *vdc, enum vdp_action act, void **priv,
    const void *ptr, ssize_t len)
{
        const uint8_t *q, *r;
        ssize_t l = 0;
        uint32_t icrc = 0;
        uint8_t tailbuf[8 + 5];
        const uint8_t *pp;
        struct ecx *ecx;
        int retval = 0;

        if (act == VDP_END)
                act = VDP_FLUSH;

        AN(priv);
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        CAST_OBJ_NOTNULL(ecx, *priv, ECX_MAGIC);
        pp = ptr;

        while (1) {
                switch (ecx->state) {
                case 0:
                        ecx->p = ObjGetAttr(vdc->wrk, ecx->preq->objcore,
                            OA_ESIDATA, &l);
                        AN(ecx->p);
                        assert(l > 0);
                        ecx->e = ecx->p + l;

                        if (*ecx->p == VEC_GZ) {
                                if (ecx->pecx == NULL)
                                        retval = VDP_bytes(vdc, VDP_NULL,
                                            gzip_hdr, 10);
                                ecx->l_crc = 0;
                                ecx->crc = crc32(0L, Z_NULL, 0);
                                ecx->isgzip = 1;
                                ecx->p++;
                        }
                        ecx->state = 1;
                        break;
                case 1:
                        if (ecx->p >= ecx->e) {
                                ecx->state = 2;
                                break;
                        }
                        switch (*ecx->p) {
                        case VEC_V1:
                        case VEC_V2:
                        case VEC_V8:
                                ecx->l = ved_decode_len(vdc->vsl, &ecx->p);
                                if (ecx->l < 0)
                                        return (-1);
                                if (ecx->isgzip) {
                                        assert(*ecx->p == VEC_C1 ||
                                            *ecx->p == VEC_C2 ||
                                            *ecx->p == VEC_C8);
                                        l = ved_decode_len(vdc->vsl, &ecx->p);
                                        if (l < 0)
                                                return (-1);
                                        icrc = vbe32dec(ecx->p);
                                        ecx->p += 4;
                                        ecx->crc = crc32_combine(
                                            ecx->crc, icrc, l);
                                        ecx->l_crc += l;
                                }
                                ecx->state = 3;
                                break;
                        case VEC_S1:
                        case VEC_S2:
                        case VEC_S8:
                                ecx->l = ved_decode_len(vdc->vsl, &ecx->p);
                                if (ecx->l < 0)
                                        return (-1);
                                Debug("SKIP1(%d)\n", (int)ecx->l);
                                ecx->state = 4;
                                break;
                        case VEC_IA:
                                ecx->abrt =
                                    FEATURE(FEATURE_ESI_INCLUDE_ONERROR);
                                /* FALLTHROUGH */
                        case VEC_IC:
                                ecx->p++;
                                q = (void*)strchr((const char*)ecx->p, '\0');
                                AN(q);
                                q++;
                                r = (void*)strchr((const char*)q, '\0');
                                AN(r);
                                if (VDP_bytes(vdc, VDP_FLUSH, NULL, 0)) {
                                        ecx->p = ecx->e;
                                        break;
                                }
                                Debug("INCL [%s][%s] BEGIN\n", q, ecx->p);
                                ved_include(ecx->preq,
                                    (const char*)q, (const char*)ecx->p, ecx);
                                Debug("INCL [%s][%s] END\n", q, ecx->p);
                                ecx->p = r + 1;
                                break;
                        default:
                                VSLb(vdc->vsl, SLT_Error,
                                    "ESI corruption line %d 0x%02x [%s]\n",
                                    __LINE__, *ecx->p, ecx->p);
                                WRONG("ESI-codes: Illegal code");
                        }
                        break;
                case 2:
                        ptr = NULL;
                        len = 0;
                        if (ecx->isgzip && ecx->pecx == NULL) {
                                /*
                                 * We are bytealigned here, so simply emit
                                 * a gzip literal block with finish bit set.
                                 */
                                tailbuf[0] = 0x01;
                                tailbuf[1] = 0x00;
                                tailbuf[2] = 0x00;
                                tailbuf[3] = 0xff;
                                tailbuf[4] = 0xff;

                                /* Emit CRC32 */
                                vle32enc(tailbuf + 5, ecx->crc);

                                /* MOD(2^32) length */
                                vle32enc(tailbuf + 9, ecx->l_crc);

                                ptr = tailbuf;
                                len = 13;
                        } else if (ecx->pecx != NULL) {
                                ecx->pecx->crc = crc32_combine(ecx->pecx->crc,
                                    ecx->crc, ecx->l_crc);
                                ecx->pecx->l_crc += ecx->l_crc;
                        }
                        retval = VDP_bytes(vdc, VDP_END, ptr, len);
                        ecx->state = 99;
                        return (retval);
                case 3:
                case 4:
                        /*
                         * There is no guarantee that the 'l' bytes are all
                         * in the same storage segment, so loop over storage
                         * until we have processed them all.
                         */
                        if (ecx->l <= len) {
                                if (ecx->state == 3)
                                        retval = VDP_bytes(vdc, act,
                                            pp, ecx->l);
                                len -= ecx->l;
                                pp += ecx->l;
                                ecx->state = 1;
                                break;
                        }
                        if (ecx->state == 3 && len > 0)
                                retval = VDP_bytes(vdc, act, pp, len);
                        ecx->l -= len;
                        return (retval);
                case 99:
                        /*
                         * VEP does not account for the PAD+CRC+LEN
                         * so we can see up to approx 15 bytes here.
                         */
                        return (retval);
                default:
                        WRONG("FOO");
                        break;
                }
                if (retval)
                        return (retval);
        }
}

const struct vdp VDP_esi = {
        .name =         "esi",
        .init =         ved_vdp_esi_init,
        .bytes =        ved_vdp_esi_bytes,
        .fini =         ved_vdp_esi_fini,
};

/*
 * Account body bytes on req
 * Push bytes to preq
 */
static inline int
ved_bytes(struct ecx *ecx, enum vdp_action act,
    const void *ptr, ssize_t len)
{
        if (act == VDP_END)
                act = VDP_FLUSH;
        return (VDP_bytes(ecx->preq->vdc, act, ptr, len));
}

/*---------------------------------------------------------------------
 * If a gzipped ESI object includes a ungzipped object, we need to make
 * it looked like a gzipped data stream.  The official way to do so would
 * be to fire up libvgz and gzip it, but we don't, we fake it.
 *
 * First, we cannot know if it is ungzipped on purpose, the admin may
 * know something we don't.
 *
 * What do you mean "BS ?"
 *
 * All right then...
 *
 * The matter of the fact is that we simply will not fire up a gzip in
 * the output path because it costs too much memory and CPU, so we simply
 * wrap the data in very convenient "gzip copy-blocks" and send it down
 * the stream with a bit more overhead.
 */

static int v_matchproto_(vdp_fini_f)
ved_pretend_gzip_fini(struct vdp_ctx *vdc, void **priv)
{
        (void)vdc;
        *priv = NULL;
        return (0);
}

static int v_matchproto_(vdp_bytes_f)
ved_pretend_gzip_bytes(struct vdp_ctx *vdc, enum vdp_action act, void **priv,
    const void *pv, ssize_t l)
{
        uint8_t buf1[5], buf2[5];
        const uint8_t *p;
        uint16_t lx;
        struct ecx *ecx;

        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        CAST_OBJ_NOTNULL(ecx, *priv, ECX_MAGIC);

        (void)priv;
        if (l == 0)
                return (ved_bytes(ecx, act, pv, l));

        p = pv;

        AN (ecx->isgzip);
        ecx->crc = crc32(ecx->crc, p, l);
        ecx->l_crc += l;

        /*
         * buf1 can safely be emitted multiple times for objects longer
         * than 64K-1 bytes.
         */
        lx = 65535;
        buf1[0] = 0;
        vle16enc(buf1 + 1, lx);
        vle16enc(buf1 + 3, ~lx);

        while (l > 0) {
                if (l >= 65535) {
                        lx = 65535;
                        if (ved_bytes(ecx, VDP_NULL, buf1, sizeof buf1))
                                return (-1);
                } else {
                        lx = (uint16_t)l;
                        buf2[0] = 0;
                        vle16enc(buf2 + 1, lx);
                        vle16enc(buf2 + 3, ~lx);
                        if (ved_bytes(ecx, VDP_NULL, buf2, sizeof buf2))
                                return (-1);
                }
                if (ved_bytes(ecx, VDP_NULL, p, lx))
                        return (-1);
                l -= lx;
                p += lx;
        }
        /* buf1 & buf2 are local, so we have to flush */
        return (ved_bytes(ecx, VDP_FLUSH, NULL, 0));
}

static const struct vdp ved_pretend_gz = {
        .name =         "PGZ",
        .bytes =        ved_pretend_gzip_bytes,
        .fini =         ved_pretend_gzip_fini,
};

/*---------------------------------------------------------------------
 * Include a gzipped object in a gzipped ESI object delivery
 *
 * This is the interesting case: Deliver all the deflate blocks, stripping
 * the "LAST" bit of the last one and padding it, as necessary, to a byte
 * boundary.
 *
 */

struct ved_foo {
        unsigned                magic;
#define VED_FOO_MAGIC           0x6a5a262d
        struct ecx              *ecx;
        struct objcore          *objcore;
        uint64_t                start, last, stop, lpad;
        ssize_t                 ll;
        uint64_t                olen;
        uint8_t                 dbits[8];
        uint8_t                 tailbuf[8];
};

static int v_matchproto_(vdp_init_f)
ved_gzgz_init(VRT_CTX, struct vdp_ctx *vdc, void **priv)
{
        ssize_t l;
        const char *p;
        struct ved_foo *foo;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        AN(priv);

        CAST_OBJ_NOTNULL(foo, *priv, VED_FOO_MAGIC);
        CHECK_OBJ_NOTNULL(foo->objcore, OBJCORE_MAGIC);

        memset(foo->tailbuf, 0xdd, sizeof foo->tailbuf);

        AN(ObjCheckFlag(vdc->wrk, foo->objcore, OF_GZIPED));

        p = ObjGetAttr(vdc->wrk, foo->objcore, OA_GZIPBITS, &l);
        AN(p);
        assert(l == 32);
        foo->start = vbe64dec(p);
        foo->last = vbe64dec(p + 8);
        foo->stop = vbe64dec(p + 16);
        foo->olen = ObjGetLen(vdc->wrk, foo->objcore);
        assert(foo->start > 0 && foo->start < foo->olen * 8);
        assert(foo->last > 0 && foo->last < foo->olen * 8);
        assert(foo->stop > 0 && foo->stop < foo->olen * 8);
        assert(foo->last >= foo->start);
        assert(foo->last < foo->stop);

        /* The start bit must be byte aligned. */
        AZ(foo->start & 7);
        return (0);
}

/*
 * XXX: for act == VDP_END || act == VDP_FLUSH, we send a flush more often than
 * we need. The VDP_END case would trip our "at most one VDP_END call" assertion
 * in VDP_bytes(), but ved_bytes() covers it.
 *
 * To avoid unnecessary chunks downstream, it would be nice to re-structure the
 * code to identify the last block, send VDP_END/VDP_FLUSH for that one and
 * VDP_NULL for anything before it.
 */

static int v_matchproto_(vdp_bytes_f)
ved_gzgz_bytes(struct vdp_ctx *vdc, enum vdp_action act, void **priv,
    const void *ptr, ssize_t len)
{
        struct ved_foo *foo;
        const uint8_t *pp;
        ssize_t dl;
        ssize_t l;

        (void)vdc;
        CAST_OBJ_NOTNULL(foo, *priv, VED_FOO_MAGIC);
        pp = ptr;
        if (len > 0) {
                /* Skip over the GZIP header */
                dl = foo->start / 8 - foo->ll;
                if (dl > 0) {
                        /* Before foo.start, skip */
                        if (dl > len)
                                dl = len;
                        foo->ll += dl;
                        len -= dl;
                        pp += dl;
                }
        }
        if (len > 0) {
                /* The main body of the object */
                dl = foo->last / 8 - foo->ll;
                if (dl > 0) {
                        dl = vmin(dl, len);
                        if (ved_bytes(foo->ecx, act, pp, dl))
                                return (-1);
                        foo->ll += dl;
                        len -= dl;
                        pp += dl;
                }
        }
        if (len > 0 && foo->ll == foo->last / 8) {
                /* Remove the "LAST" bit */
                foo->dbits[0] = *pp;
                foo->dbits[0] &= ~(1U << (foo->last & 7));
                if (ved_bytes(foo->ecx, act, foo->dbits, 1))
                        return (-1);
                foo->ll++;
                len--;
                pp++;
        }
        if (len > 0) {
                /* Last block */
                dl = foo->stop / 8 - foo->ll;
                if (dl > 0) {
                        dl = vmin(dl, len);
                        if (ved_bytes(foo->ecx, act, pp, dl))
                                return (-1);
                        foo->ll += dl;
                        len -= dl;
                        pp += dl;
                }
        }
        if (len > 0 && (foo->stop & 7) && foo->ll == foo->stop / 8) {
                /* Add alignment to byte boundary */
                foo->dbits[1] = *pp;
                foo->ll++;
                len--;
                pp++;
                switch ((int)(foo->stop & 7)) {
                case 1: /*
                         * x000....
                         * 00000000 00000000 11111111 11111111
                         */
                case 3: /*
                         * xxx000..
                         * 00000000 00000000 11111111 11111111
                         */
                case 5: /*
                         * xxxxx000
                         * 00000000 00000000 11111111 11111111
                         */
                        foo->dbits[2] = 0x00; foo->dbits[3] = 0x00;
                        foo->dbits[4] = 0xff; foo->dbits[5] = 0xff;
                        foo->lpad = 5;
                        break;
                case 2: /* xx010000 00000100 00000001 00000000 */
                        foo->dbits[1] |= 0x08;
                        foo->dbits[2] = 0x20;
                        foo->dbits[3] = 0x80;
                        foo->dbits[4] = 0x00;
                        foo->lpad = 4;
                        break;
                case 4: /* xxxx0100 00000001 00000000 */
                        foo->dbits[1] |= 0x20;
                        foo->dbits[2] = 0x80;
                        foo->dbits[3] = 0x00;
                        foo->lpad = 3;
                        break;
                case 6: /* xxxxxx01 00000000 */
                        foo->dbits[1] |= 0x80;
                        foo->dbits[2] = 0x00;
                        foo->lpad = 2;
                        break;
                case 7: /*
                         * xxxxxxx0
                         * 00......
                         * 00000000 00000000 11111111 11111111
                         */
                        foo->dbits[2] = 0x00;
                        foo->dbits[3] = 0x00; foo->dbits[4] = 0x00;
                        foo->dbits[5] = 0xff; foo->dbits[6] = 0xff;
                        foo->lpad = 6;
                        break;
                case 0: /* xxxxxxxx */
                default:
                        WRONG("compiler must be broken");
                }
                if (ved_bytes(foo->ecx, act, foo->dbits + 1, foo->lpad))
                        return (-1);
        }
        if (len > 0) {
                /* Recover GZIP tail */
                dl = foo->olen - foo->ll;
                assert(dl >= 0);
                if (dl > len)
                        dl = len;
                if (dl > 0) {
                        assert(dl <= 8);
                        l = foo->ll - (foo->olen - 8);
                        assert(l >= 0);
                        assert(l <= 8);
                        assert(l + dl <= 8);
                        memcpy(foo->tailbuf + l, pp, dl);
                        foo->ll += dl;
                        len -= dl;
                }
        }
        assert(len == 0);
        return (0);
}

static int v_matchproto_(vdp_fini_f)
ved_gzgz_fini(struct vdp_ctx *vdc, void **priv)
{
        uint32_t icrc;
        uint32_t ilen;
        struct ved_foo *foo;

        (void)vdc;
        TAKE_OBJ_NOTNULL(foo, priv, VED_FOO_MAGIC);

        /* XXX
         * this works due to the esi layering, a VDP pushing bytes from _fini
         * will otherwise have its own _bytes method called.
         *
         * Could rewrite use VDP_END
         */
        (void)ved_bytes(foo->ecx, VDP_FLUSH, NULL, 0);

        icrc = vle32dec(foo->tailbuf);
        ilen = vle32dec(foo->tailbuf + 4);
        foo->ecx->crc = crc32_combine(foo->ecx->crc, icrc, ilen);
        foo->ecx->l_crc += ilen;

        return (0);
}

static const struct vdp ved_gzgz = {
        .name =         "VZZ",
        .init =         ved_gzgz_init,
        .bytes =        ved_gzgz_bytes,
        .fini =         ved_gzgz_fini,
};

/*--------------------------------------------------------------------
 * Straight through without processing.
 */

static int v_matchproto_(vdp_fini_f)
ved_vdp_fini(struct vdp_ctx *vdc, void **priv)
{
        (void)vdc;
        *priv = NULL;
        return (0);
}

static int v_matchproto_(vdp_bytes_f)
ved_vdp_bytes(struct vdp_ctx *vdc, enum vdp_action act, void **priv,
    const void *ptr, ssize_t len)
{
        struct ecx *ecx;

        (void)vdc;
        CAST_OBJ_NOTNULL(ecx, *priv, ECX_MAGIC);
        return (ved_bytes(ecx, act, ptr, len));
}

static const struct vdp ved_ved = {
        .name =         "VED",
        .bytes =        ved_vdp_bytes,
        .fini =         ved_vdp_fini,
};

static void
ved_close(struct req *req, int error)
{
        req->acct.resp_bodybytes += VDP_Close(req->vdc, req->objcore, req->boc);

        if (! error)
                return;
        req->top->topreq->vdc->retval = -1;
        req->top->topreq->doclose = req->doclose;
}

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

static enum vtr_deliver_e v_matchproto_(vtr_deliver_f)
ved_deliver(struct req *req, int wantbody)
{
        int i = 0;
        const char *p;
        uint16_t status;
        struct ecx *ecx;
        struct ved_foo foo[1];
        struct vrt_ctx ctx[1];

        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        CHECK_OBJ_ORNULL(req->boc, BOC_MAGIC);
        CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);

        CAST_OBJ_NOTNULL(ecx, req->transport_priv, ECX_MAGIC);

        status = req->resp->status % 1000;

        if (FEATURE(FEATURE_ESI_INCLUDE_ONERROR) &&
            status != 200 && status != 204) {
                ved_close(req, ecx->abrt);
                return (VTR_D_DONE);
        }

        if (wantbody == 0) {
                ved_close(req, 0);
                return (VTR_D_DONE);
        }

        if (req->boc == NULL && ObjGetLen(req->wrk, req->objcore) == 0) {
                ved_close(req, 0);
                return (VTR_D_DONE);
        }

        if (http_GetHdr(req->resp, H_Content_Encoding, &p))
                i = http_coding_eq(p, gzip);
        if (i)
                i = ObjCheckFlag(req->wrk, req->objcore, OF_GZIPED);

        INIT_OBJ(ctx, VRT_CTX_MAGIC);
        VCL_Req2Ctx(ctx, req);

        if (ecx->isgzip && i && !req->res_esi) {
                /* A gzipped include which is not ESI processed */

                /* OA_GZIPBITS are not valid until BOS_FINISHED */
                if (req->boc != NULL)
                        ObjWaitState(req->objcore, BOS_FINISHED);

                if (req->objcore->flags & OC_F_FAILED) {
                        /* No way of signalling errors in the middle of
                         * the ESI body. Omit this ESI fragment.
                         * XXX change error argument to 1
                         */
                        ved_close(req, 0);
                        return (VTR_D_DONE);
                }

                INIT_OBJ(foo, VED_FOO_MAGIC);
                foo->ecx = ecx;
                foo->objcore = req->objcore;
                i = VDP_Push(ctx, req->vdc, req->ws, &ved_gzgz, foo);
        } else if (ecx->isgzip && !i) {
                /* Non-Gzip'ed include in gzipped parent */
                i = VDP_Push(ctx, req->vdc, req->ws, &ved_pretend_gz, ecx);
        } else {
                /* Anything else goes straight through */
                i = VDP_Push(ctx, req->vdc, req->ws, &ved_ved, ecx);
        }

        if (i == 0) {
                i = VDP_DeliverObj(req->vdc, req->objcore);
        } else {
                VSLb(req->vsl, SLT_Error, "Failure to push ESI processors");
                req->doclose = SC_OVERLOAD;
        }

        if (i && req->doclose == SC_NULL)
                req->doclose = SC_REM_CLOSE;

        ved_close(req, i && ecx->abrt ? 1 : 0);
        return (VTR_D_DONE);
}

		varnish-cache/bin/varnishd/cache/cache_esi_deliver.c
0		/*-
1		* Copyright (c) 2011 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		* VED - Varnish Esi Delivery
30		*/
31
32		#include "config.h"
33
34		#include "cache_varnishd.h"
35
36		#include <stdlib.h>
37
38		#include "cache_transport.h"
39		#include "cache_filter.h"
40		#include "cache_vgz.h"
41
42		#include "vct.h"
43		#include "vtim.h"
44		#include "cache_esi.h"
45		#include "vend.h"
46		#include "vgz.h"
47
48		static vtr_deliver_f ved_deliver;
49		static vtr_reembark_f ved_reembark;
50
51		static const uint8_t gzip_hdr[] = {
52		0x1f, 0x8b, 0x08,
53		0x00, 0x00, 0x00, 0x00,
54		0x00,
55		0x02, 0x03
56		};
57
58		struct ecx {
59		unsigned magic;
60		#define ECX_MAGIC 0x0b0f9163
61		const uint8_t *p;
62		const uint8_t *e;
63		int state;
64		ssize_t l;
65		int isgzip;
66		int woken;
67		int abrt;
68
69		struct req *preq;
70		struct ecx *pecx;
71		ssize_t l_crc;
72		uint32_t crc;
73		};
74
75		static int v_matchproto_(vtr_minimal_response_f)
76	0	ved_minimal_response(struct req *req, uint16_t status)
77		{
78	0	(void)req;
79	0	(void)status;
80	0	WRONG("esi:includes should not try minimal responses");
81	0	}
82
83		static const struct transport VED_transport = {
84		.magic = TRANSPORT_MAGIC,
85		.name = "ESI_INCLUDE",
86		.deliver = ved_deliver,
87		.reembark = ved_reembark,
88		.minimal_response = ved_minimal_response,
89		};
90
91		/--------------------------------------------------------------------/
92
93		static void v_matchproto_(vtr_reembark_f)
94	40	ved_reembark(struct worker wrk, struct req req)
95		{
96		struct ecx *ecx;
97
98	40	(void)wrk;
99	40	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
100	40	CAST_OBJ_NOTNULL(ecx, req->transport_priv, ECX_MAGIC);
101	40	Lck_Lock(&req->sp->mtx);
102	40	ecx->woken = 1;
103	40	PTOK(pthread_cond_signal(&ecx->preq->wrk->cond));
104	40	Lck_Unlock(&req->sp->mtx);
105	40	}
106
107		/--------------------------------------------------------------------/
108
109		static void
110	17281	ved_include(struct req preq, const char src, const char *host,
111		struct ecx *ecx)
112		{
113		struct worker *wrk;
114		struct sess *sp;
115		struct req *req;
116		enum req_fsm_nxt s;
117
118	17281	CHECK_OBJ_NOTNULL(preq, REQ_MAGIC);
119	17281	CHECK_OBJ_NOTNULL(preq->top, REQTOP_MAGIC);
120	17281	sp = preq->sp;
121	17281	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
122	17281	CHECK_OBJ_NOTNULL(ecx, ECX_MAGIC);
123	17281	wrk = preq->wrk;
124
125	17281	if (preq->esi_level >= cache_param->max_esi_depth) {
126	5280	VSLb(preq->vsl, SLT_VCL_Error,
127		"ESI depth limit reached (param max_esi_depth = %u)",
128	2640	cache_param->max_esi_depth);
129	2640	if (ecx->abrt)
130	40	preq->top->topreq->vdc->retval = -1;
131	2640	return;
132		}
133
134	14641	req = Req_New(sp, preq);
135	14641	AN(req);
136	14641	THR_SetRequest(req);
137	14641	assert(IS_NO_VXID(req->vsl->wid));
138	14641	req->vsl->wid = VXID_Get(wrk, VSL_CLIENTMARKER);
139
140	14641	wrk->stats->esi_req++;
141	14641	req->esi_level = preq->esi_level + 1;
142
143	29282	VSLb(req->vsl, SLT_Begin, "req %ju esi %u",
144	14641	(uintmax_t)VXID(preq->vsl->wid), req->esi_level);
145	29282	VSLb(preq->vsl, SLT_Link, "req %ju esi %u",
146	14641	(uintmax_t)VXID(req->vsl->wid), req->esi_level);
147
148	14641	VSLb_ts_req(req, "Start", W_TIM_real(wrk));
149
150	14641	HTTP_Setup(req->http, req->ws, req->vsl, SLT_ReqMethod);
151	14641	HTTP_Dup(req->http, preq->http0);
152
153	14641	http_SetH(req->http, HTTP_HDR_URL, src);
154	14641	if (host != NULL && *host != '\0') {
155	80	http_Unset(req->http, H_Host);
156	80	http_SetHeader(req->http, host);
157	80	}
158
159	14641	http_ForceField(req->http, HTTP_HDR_METHOD, "GET");
160	14641	http_ForceField(req->http, HTTP_HDR_PROTO, "HTTP/1.1");
161
162		/* Don't allow conditionals, we can't use a 304 */
163	14641	http_Unset(req->http, H_If_Modified_Since);
164	14641	http_Unset(req->http, H_If_None_Match);
165
166		/* Don't allow Range */
167	14641	http_Unset(req->http, H_Range);
168
169		/* Set Accept-Encoding according to what we want */
170	14641	if (ecx->isgzip)
171	5160	http_ForceHeader(req->http, H_Accept_Encoding, "gzip");
172		else
173	9481	http_Unset(req->http, H_Accept_Encoding);
174
175		/* Client content already taken care of */
176	14641	http_Unset(req->http, H_Content_Length);
177	14641	http_Unset(req->http, H_Transfer_Encoding);
178	14641	req->req_body_status = BS_NONE;
179
180	14641	AZ(req->vcl);
181	14641	assert(req->top == preq->top);
182	14641	if (req->top->vcl0)
183	80	req->vcl = req->top->vcl0;
184		else
185	14561	req->vcl = preq->vcl;
186	14641	VCL_Ref(req->vcl);
187
188	14641	assert(req->req_step == R_STP_TRANSPORT);
189	14641	req->t_req = preq->t_req;
190
191	14641	req->transport = &VED_transport;
192	14641	req->transport_priv = ecx;
193
194	14641	VCL_TaskEnter(req->privs);
195
196	14681	while (1) {
197	14681	CNT_Embark(wrk, req);
198	14681	ecx->woken = 0;
199	14681	s = CNT_Request(req);
200	14681	if (s == REQ_FSM_DONE)
201	14641	break;
202	40	DSL(DBG_WAITINGLIST, req->vsl->wid,
203		"waiting for ESI (%d)", (int)s);
204	40	assert(s == REQ_FSM_DISEMBARK);
205	40	Lck_Lock(&sp->mtx);
206	40	if (!ecx->woken)
207	40	(void)Lck_CondWait(&ecx->preq->wrk->cond, &sp->mtx);
208	40	Lck_Unlock(&sp->mtx);
209	40	AZ(req->wrk);
210		}
211
212	14641	VCL_Rel(&req->vcl);
213
214	14641	req->wrk = NULL;
215	14641	THR_SetRequest(preq);
216
217	14641	Req_Cleanup(sp, wrk, req);
218	14641	Req_Release(req);
219	17281	}
220
221		/--------------------------------------------------------------------/
222
223		//#define Debug(fmt, ...) printf(fmt, __VA_ARGS__)
224		#define Debug(fmt, ...) /**/
225
226		static ssize_t
227	60720	ved_decode_len(struct vsl_log vsl, const uint8_t *pp)
228		{
229		const uint8_t *p;
230		ssize_t l;
231
232	60720	p = *pp;
233	60720	switch (*p & 15) {
234		case 1:
235	53000	l = p[1];
236	53000	p += 2;
237	53000	break;
238		case 2:
239	7640	l = vbe16dec(p + 1);
240	7640	p += 3;
241	7640	break;
242		case 8:
243	80	l = vbe64dec(p + 1);
244	80	p += 9;
245	80	break;
246		default:
247	0	VSLb(vsl, SLT_Error,
248	0	"ESI-corruption: Illegal Length %d %d\n", p, (p & 15));
249	0	WRONG("ESI-codes: illegal length");
250	0	}
251	60720	*pp = p;
252	60720	assert(l > 0);
253	60720	return (l);
254		}
255
256		/*---------------------------------------------------------------------
257		*/
258
259		static int v_matchproto_(vdp_init_f)
260	8320	ved_vdp_esi_init(VRT_CTX, struct vdp_ctx vdc, void *priv)
261		{
262		struct ecx *ecx;
263
264	8320	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
265	8320	CHECK_OBJ_ORNULL(ctx->req, REQ_MAGIC);
266	8320	CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
267	8320	CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
268	8320	CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
269	8320	AN(vdc->clen);
270	8320	AN(priv);
271
272	8320	AZ(*priv);
273	8320	if (vdc->oc == NULL \|\| !ObjHasAttr(vdc->wrk, vdc->oc, OA_ESIDATA))
274	0	return (1);
275
276	8320	if (ctx->req == NULL) {
277	0	VSLb(vdc->vsl, SLT_Error,
278		"esi can only be used on the client side");
279	0	return (1);
280		}
281
282	8320	ALLOC_OBJ(ecx, ECX_MAGIC);
283	8320	AN(ecx);
284	8320	assert(sizeof gzip_hdr == 10);
285	8320	ecx->preq = ctx->req;
286	8320	*priv = ecx;
287	8320	RFC2616_Weaken_Etag(vdc->hp);
288
289	8320	ctx->req->res_esi = 1;
290	8320	if (*vdc->clen != 0)
291	8320	*vdc->clen = -1;
292	8320	if (ctx->req->esi_level > 0) {
293	3360	assert(ctx->req->transport == &VED_transport);
294	3360	CAST_OBJ_NOTNULL(ecx->pecx, ctx->req->transport_priv, ECX_MAGIC);
295	3360	if (!ecx->pecx->isgzip)
296	640	ecx->pecx = NULL;
297	3360	}
298
299	8320	return (0);
300	8320	}
301
302		static int v_matchproto_(vdp_fini_f)
303	8320	ved_vdp_esi_fini(struct vdp_ctx vdc, void *priv)
304		{
305		struct ecx *ecx;
306
307	8320	(void)vdc;
308	8320	TAKE_OBJ_NOTNULL(ecx, priv, ECX_MAGIC);
309	8320	FREE_OBJ(ecx);
310	8320	return (0);
311		}
312
313		static int v_matchproto_(vdp_bytes_f)
314	10560	ved_vdp_esi_bytes(struct vdp_ctx vdc, enum vdp_action act, void *priv,
315		const void *ptr, ssize_t len)
316		{
317		const uint8_t q, r;
318	10560	ssize_t l = 0;
319	10560	uint32_t icrc = 0;
320		uint8_t tailbuf[8 + 5];
321		const uint8_t *pp;
322		struct ecx *ecx;
323	10560	int retval = 0;
324
325	10560	if (act == VDP_END)
326	8280	act = VDP_FLUSH;
327
328	10560	AN(priv);
329	10560	CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
330	10560	CAST_OBJ_NOTNULL(ecx, *priv, ECX_MAGIC);
331	10560	pp = ptr;
332
333	143321	while (1) {
334	143321	switch (ecx->state) {
335		case 0:
336	8280	ecx->p = ObjGetAttr(vdc->wrk, ecx->preq->objcore,
337		OA_ESIDATA, &l);
338	8280	AN(ecx->p);
339	8280	assert(l > 0);
340	8280	ecx->e = ecx->p + l;
341
342	8280	if (*ecx->p == VEC_GZ) {
343	4280	if (ecx->pecx == NULL)
344	1640	retval = VDP_bytes(vdc, VDP_NULL,
345		gzip_hdr, 10);
346	4280	ecx->l_crc = 0;
347	4280	ecx->crc = crc32(0L, Z_NULL, 0);
348	4280	ecx->isgzip = 1;
349	4280	ecx->p++;
350	4280	}
351	8280	ecx->state = 1;
352	8280	break;
353		case 1:
354	75041	if (ecx->p >= ecx->e) {
355	8000	ecx->state = 2;
356	8000	break;
357		}
358	67041	switch (*ecx->p) {
359		case VEC_V1:
360		case VEC_V2:
361		case VEC_V8:
362	23320	ecx->l = ved_decode_len(vdc->vsl, &ecx->p);
363	23320	if (ecx->l < 0)
364	0	return (-1);
365	23320	if (ecx->isgzip) {
366	11000	assert(*ecx->p == VEC_C1 \|\|
367		*ecx->p == VEC_C2 \|\|
368		*ecx->p == VEC_C8);
369	11000	l = ved_decode_len(vdc->vsl, &ecx->p);
370	11000	if (l < 0)
371	0	return (-1);
372	11000	icrc = vbe32dec(ecx->p);
373	11000	ecx->p += 4;
374	11000	ecx->crc = crc32_combine(
375	11000	ecx->crc, icrc, l);
376	11000	ecx->l_crc += l;
377	11000	}
378	23320	ecx->state = 3;
379	23320	break;
380		case VEC_S1:
381		case VEC_S2:
382		case VEC_S8:
383	26400	ecx->l = ved_decode_len(vdc->vsl, &ecx->p);
384	26400	if (ecx->l < 0)
385	0	return (-1);
386		Debug("SKIP1(%d)\n", (int)ecx->l);
387	26400	ecx->state = 4;
388	26400	break;
389		case VEC_IA:
390	12121	ecx->abrt =
391	12121	FEATURE(FEATURE_ESI_INCLUDE_ONERROR);
392		/* FALLTHROUGH */
393		case VEC_IC:
394	17321	ecx->p++;
395	17321	q = (void)strchr((const char)ecx->p, '\0');
396	17321	AN(q);
397	17321	q++;
398	17321	r = (void)strchr((const char)q, '\0');
399	17321	AN(r);
400	17321	if (VDP_bytes(vdc, VDP_FLUSH, NULL, 0)) {
401	40	ecx->p = ecx->e;
402	40	break;
403		}
404		Debug("INCL [%s][%s] BEGIN\n", q, ecx->p);
405	34562	ved_include(ecx->preq,
406	17281	(const char)q, (const char)ecx->p, ecx);
407		Debug("INCL [%s][%s] END\n", q, ecx->p);
408	17281	ecx->p = r + 1;
409	17281	break;
410		default:
411	0	VSLb(vdc->vsl, SLT_Error,
412		"ESI corruption line %d 0x%02x [%s]\n",
413	0	__LINE__, *ecx->p, ecx->p);
414	0	WRONG("ESI-codes: Illegal code");
415	0	}
416	67041	break;
417		case 2:
418	8001	ptr = NULL;
419	8001	len = 0;
420	8001	if (ecx->isgzip && ecx->pecx == NULL) {
421		/*
422		* We are bytealigned here, so simply emit
423		* a gzip literal block with finish bit set.
424		*/
425	1640	tailbuf[0] = 0x01;
426	1640	tailbuf[1] = 0x00;
427	1640	tailbuf[2] = 0x00;
428	1640	tailbuf[3] = 0xff;
429	1640	tailbuf[4] = 0xff;
430
431		/* Emit CRC32 */
432	1640	vle32enc(tailbuf + 5, ecx->crc);
433
434		/* MOD(2^32) length */
435	1640	vle32enc(tailbuf + 9, ecx->l_crc);
436
437	1640	ptr = tailbuf;
438	1640	len = 13;
439	8001	} else if (ecx->pecx != NULL) {
440	5440	ecx->pecx->crc = crc32_combine(ecx->pecx->crc,
441	2720	ecx->crc, ecx->l_crc);
442	2720	ecx->pecx->l_crc += ecx->l_crc;
443	2720	}
444	8001	retval = VDP_bytes(vdc, VDP_END, ptr, len);
445	8001	ecx->state = 99;
446	8001	return (retval);
447		case 3:
448		case 4:
449		/*
450		* There is no guarantee that the 'l' bytes are all
451		* in the same storage segment, so loop over storage
452		* until we have processed them all.
453		*/
454	51599	if (ecx->l <= len) {
455	49719	if (ecx->state == 3)
456	46640	retval = VDP_bytes(vdc, act,
457	23320	pp, ecx->l);
458	49719	len -= ecx->l;
459	49719	pp += ecx->l;
460	49719	ecx->state = 1;
461	49719	break;
462		}
463	1880	if (ecx->state == 3 && len > 0)
464	680	retval = VDP_bytes(vdc, act, pp, len);
465	1880	ecx->l -= len;
466	1880	return (retval);
467		case 99:
468		/*
469		* VEP does not account for the PAD+CRC+LEN
470		* so we can see up to approx 15 bytes here.
471		*/
472	400	return (retval);
473		default:
474	0	WRONG("FOO");
475	0	break;
476		}
477	133040	if (retval)
478	279	return (retval);
479		}
480	10560	}
481
482		const struct vdp VDP_esi = {
483		.name = "esi",
484		.init = ved_vdp_esi_init,
485		.bytes = ved_vdp_esi_bytes,
486		.fini = ved_vdp_esi_fini,
487		};
488
489		/*
490		* Account body bytes on req
491		* Push bytes to preq
492		*/
493		static inline int
494	88280	ved_bytes(struct ecx *ecx, enum vdp_action act,
495		const void *ptr, ssize_t len)
496		{
497	88280	if (act == VDP_END)
498	14801	act = VDP_FLUSH;
499	88280	return (VDP_bytes(ecx->preq->vdc, act, ptr, len));