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             incl_cont;

        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->incl_cont)
                        preq->top->topreq->vdc->retval = -1;
                return;
        }

        req = Req_New(sp);
        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));

        memset(req->top, 0, sizeof *req->top);
        req->top = preq->top;

        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);
        AN(req->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 objcore *oc)
{
        struct ecx *ecx;
        struct req *req;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        CHECK_OBJ_ORNULL(oc, OBJCORE_MAGIC);
        if (oc == NULL || !ObjHasAttr(vdc->wrk, oc, OA_ESIDATA))
                return (1);

        req = vdc->req;
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        AN(priv);
        AZ(*priv);

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

        req->res_mode |= RES_ESI;
        if (req->resp_len != 0)
                req->resp_len = -1;
        if (req->esi_level > 0) {
                assert(req->transport == &VED_transport);
                CAST_OBJ_NOTNULL(ecx->pecx, 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_IC:
                                ecx->incl_cont =
                                    FEATURE(FEATURE_ESI_INCLUDE_ONERROR);
                                /* FALLTHROUGH */
                        case VEC_IA:
                                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 gzip'ed ESI object includes a ungzip'ed object, we need to make
 * it looked like a gzip'ed 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 ungzip'ed 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 gzip'ed object in a gzip'ed 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, struct objcore *oc)
{
        ssize_t l;
        const char *p;
        struct ved_foo *foo;
        struct req *req;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        (void)oc;
        req = vdc->req;
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        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 it's 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 v_matchproto_(vtr_deliver_f)
ved_deliver(struct req *req, struct boc *boc, 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(boc, BOC_MAGIC);
        CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);

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

        if (wantbody == 0)
                return;

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

        if (!ecx->incl_cont && status != 200 && status != 204) {
                req->top->topreq->vdc->retval = -1;
                req->top->topreq->doclose = req->doclose;
                return;
        }

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

        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_mode & RES_ESI)) {
                /* A gzip'ed include which is not ESI processed */

                /* OA_GZIPBITS are not valid until BOS_FINISHED */
                if (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. */
                        return;
                }

                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 gzip'ed 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;

        req->acct.resp_bodybytes += VDP_Close(req->vdc, req->objcore, boc);

        if (i && !ecx->incl_cont) {
                req->top->topreq->vdc->retval = -1;
                req->top->topreq->doclose = req->doclose;
        }
}

		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 incl_cont;
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	31	ved_reembark(struct worker wrk, struct req req)
95		{
96		struct ecx *ecx;
97
98	31	(void)wrk;
99	31	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
100	31	CAST_OBJ_NOTNULL(ecx, req->transport_priv, ECX_MAGIC);
101	31	Lck_Lock(&req->sp->mtx);
102	31	ecx->woken = 1;
103	31	PTOK(pthread_cond_signal(&ecx->preq->wrk->cond));
104	31	Lck_Unlock(&req->sp->mtx);
105	31	}
106
107		/--------------------------------------------------------------------/
108
109		static void
110	10725	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	10725	CHECK_OBJ_NOTNULL(preq, REQ_MAGIC);
119	10725	CHECK_OBJ_NOTNULL(preq->top, REQTOP_MAGIC);
120	10725	sp = preq->sp;
121	10725	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
122	10725	CHECK_OBJ_NOTNULL(ecx, ECX_MAGIC);
123	10725	wrk = preq->wrk;
124
125	10725	if (preq->esi_level >= cache_param->max_esi_depth) {
126	3300	VSLb(preq->vsl, SLT_VCL_Error,
127		"ESI depth limit reached (param max_esi_depth = %u)",
128	1650	cache_param->max_esi_depth);
129	1650	if (!ecx->incl_cont)
130	25	preq->top->topreq->vdc->retval = -1;
131	1650	return;
132		}
133
134	9075	req = Req_New(sp);
135	9075	AN(req);
136	9075	THR_SetRequest(req);
137	9075	assert(IS_NO_VXID(req->vsl->wid));
138	9075	req->vsl->wid = VXID_Get(wrk, VSL_CLIENTMARKER);
139
140	9075	wrk->stats->esi_req++;
141	9075	req->esi_level = preq->esi_level + 1;
142
143	18150	VSLb(req->vsl, SLT_Begin, "req %ju esi %u",
144	9075	(uintmax_t)VXID(preq->vsl->wid), req->esi_level);
145	18150	VSLb(preq->vsl, SLT_Link, "req %ju esi %u",
146	9075	(uintmax_t)VXID(req->vsl->wid), req->esi_level);
147
148	9075	VSLb_ts_req(req, "Start", W_TIM_real(wrk));
149
150	9075	memset(req->top, 0, sizeof *req->top);
151	9075	req->top = preq->top;
152
153	9075	HTTP_Setup(req->http, req->ws, req->vsl, SLT_ReqMethod);
154	9075	HTTP_Dup(req->http, preq->http0);
155
156	9075	http_SetH(req->http, HTTP_HDR_URL, src);
157	9075	if (host != NULL && *host != '\0') {
158	50	http_Unset(req->http, H_Host);
159	50	http_SetHeader(req->http, host);
160	50	}
161
162	9075	http_ForceField(req->http, HTTP_HDR_METHOD, "GET");
163	9075	http_ForceField(req->http, HTTP_HDR_PROTO, "HTTP/1.1");
164
165		/* Don't allow conditionals, we can't use a 304 */
166	9075	http_Unset(req->http, H_If_Modified_Since);
167	9075	http_Unset(req->http, H_If_None_Match);
168
169		/* Don't allow Range */
170	9075	http_Unset(req->http, H_Range);
171
172		/* Set Accept-Encoding according to what we want */
173	9075	if (ecx->isgzip)
174	3225	http_ForceHeader(req->http, H_Accept_Encoding, "gzip");
175		else
176	5850	http_Unset(req->http, H_Accept_Encoding);
177
178		/* Client content already taken care of */
179	9075	http_Unset(req->http, H_Content_Length);
180	9075	http_Unset(req->http, H_Transfer_Encoding);
181	9075	req->req_body_status = BS_NONE;
182
183	9075	AZ(req->vcl);
184	9075	AN(req->top);
185	9075	if (req->top->vcl0)
186	50	req->vcl = req->top->vcl0;
187		else
188	9025	req->vcl = preq->vcl;
189	9075	VCL_Ref(req->vcl);
190
191	9075	assert(req->req_step == R_STP_TRANSPORT);
192	9075	req->t_req = preq->t_req;
193
194	9075	req->transport = &VED_transport;
195	9075	req->transport_priv = ecx;
196
197	9075	VCL_TaskEnter(req->privs);
198
199	9106	while (1) {
200	9106	CNT_Embark(wrk, req);
201	9106	ecx->woken = 0;
202	9106	s = CNT_Request(req);
203	9106	if (s == REQ_FSM_DONE)
204	9075	break;
205	31	DSL(DBG_WAITINGLIST, req->vsl->wid,
206		"waiting for ESI (%d)", (int)s);
207	31	assert(s == REQ_FSM_DISEMBARK);
208	31	Lck_Lock(&sp->mtx);
209	31	if (!ecx->woken)
210	31	(void)Lck_CondWait(&ecx->preq->wrk->cond, &sp->mtx);
211	31	Lck_Unlock(&sp->mtx);
212	31	AZ(req->wrk);
213		}
214
215	9075	VCL_Rel(&req->vcl);
216
217	9075	req->wrk = NULL;
218	9075	THR_SetRequest(preq);
219
220	9075	Req_Cleanup(sp, wrk, req);
221	9075	Req_Release(req);
222	10725	}
223
224		/--------------------------------------------------------------------/
225
226		//#define Debug(fmt, ...) printf(fmt, __VA_ARGS__)
227		#define Debug(fmt, ...) /**/
228
229		static ssize_t
230	37725	ved_decode_len(struct vsl_log vsl, const uint8_t *pp)
231		{
232		const uint8_t *p;
233		ssize_t l;
234
235	37725	p = *pp;
236	37725	switch (*p & 15) {
237		case 1:
238	32900	l = p[1];
239	32900	p += 2;
240	32900	break;
241		case 2:
242	4775	l = vbe16dec(p + 1);
243	4775	p += 3;
244	4775	break;
245		case 8:
246	50	l = vbe64dec(p + 1);
247	50	p += 9;
248	50	break;
249		default:
250	0	VSLb(vsl, SLT_Error,
251	0	"ESI-corruption: Illegal Length %d %d\n", p, (p & 15));
252	0	WRONG("ESI-codes: illegal length");
253	0	}
254	37725	*pp = p;
255	37725	assert(l > 0);
256	37725	return (l);
257		}
258
259		/*---------------------------------------------------------------------
260		*/
261
262		static int v_matchproto_(vdp_init_f)
263	5125	ved_vdp_esi_init(VRT_CTX, struct vdp_ctx vdc, void priv, struct objcore oc)
264		{
265		struct ecx *ecx;
266		struct req *req;
267
268	5125	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
269	5125	CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
270	5125	CHECK_OBJ_ORNULL(oc, OBJCORE_MAGIC);
271	5125	if (oc == NULL \|\| !ObjHasAttr(vdc->wrk, oc, OA_ESIDATA))
272	0	return (1);
273
274	5125	req = vdc->req;
275	5125	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
276	5125	AN(priv);
277	5125	AZ(*priv);
278
279	5125	ALLOC_OBJ(ecx, ECX_MAGIC);
280	5125	AN(ecx);
281	5125	assert(sizeof gzip_hdr == 10);
282	5125	ecx->preq = req;
283	5125	*priv = ecx;
284	5125	RFC2616_Weaken_Etag(req->resp);
285
286	5125	req->res_mode \|= RES_ESI;
287	5125	if (req->resp_len != 0)
288	5125	req->resp_len = -1;
289	5125	if (req->esi_level > 0) {
290	2100	assert(req->transport == &VED_transport);
291	2100	CAST_OBJ_NOTNULL(ecx->pecx, req->transport_priv, ECX_MAGIC);
292	2100	if (!ecx->pecx->isgzip)
293	400	ecx->pecx = NULL;
294	2100	}
295
296	5125	return (0);
297	5125	}
298
299		static int v_matchproto_(vdp_fini_f)
300	5125	ved_vdp_esi_fini(struct vdp_ctx vdc, void *priv)
301		{
302		struct ecx *ecx;
303
304	5125	(void)vdc;
305	5125	TAKE_OBJ_NOTNULL(ecx, priv, ECX_MAGIC);
306	5125	FREE_OBJ(ecx);
307	5125	return (0);
308		}
309
310		static int v_matchproto_(vdp_bytes_f)
311	6525	ved_vdp_esi_bytes(struct vdp_ctx vdc, enum vdp_action act, void *priv,
312		const void *ptr, ssize_t len)
313		{
314		const uint8_t q, r;
315	6525	ssize_t l = 0;
316	6525	uint32_t icrc = 0;
317		uint8_t tailbuf[8 + 5];
318		const uint8_t *pp;
319		struct ecx *ecx;
320	6525	int retval = 0;
321
322	6525	if (act == VDP_END)
323	5100	act = VDP_FLUSH;
324
325	6525	AN(priv);
326	6525	CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
327	6525	CAST_OBJ_NOTNULL(ecx, *priv, ECX_MAGIC);
328	6525	pp = ptr;
329
330	88825	while (1) {
331	88825	switch (ecx->state) {
332		case 0:
333	5100	ecx->p = ObjGetAttr(vdc->wrk, ecx->preq->objcore,
334		OA_ESIDATA, &l);
335	5100	AN(ecx->p);
336	5100	assert(l > 0);
337	5100	ecx->e = ecx->p + l;
338
339	5100	if (*ecx->p == VEC_GZ) {
340	2675	if (ecx->pecx == NULL)
341	1025	retval = VDP_bytes(vdc, VDP_NULL,
342		gzip_hdr, 10);
343	2675	ecx->l_crc = 0;
344	2675	ecx->crc = crc32(0L, Z_NULL, 0);
345	2675	ecx->isgzip = 1;
346	2675	ecx->p++;
347	2675	}
348	5100	ecx->state = 1;
349	5100	break;
350		case 1:
351	46525	if (ecx->p >= ecx->e) {
352	4925	ecx->state = 2;
353	4925	break;
354		}
355	41600	switch (*ecx->p) {
356		case VEC_V1:
357		case VEC_V2:
358		case VEC_V8:
359	14425	ecx->l = ved_decode_len(vdc->vsl, &ecx->p);
360	14425	if (ecx->l < 0)
361	0	return (-1);
362	14425	if (ecx->isgzip) {
363	6875	assert(*ecx->p == VEC_C1 \|\|
364		*ecx->p == VEC_C2 \|\|
365		*ecx->p == VEC_C8);
366	6875	l = ved_decode_len(vdc->vsl, &ecx->p);
367	6875	if (l < 0)
368	0	return (-1);
369	6875	icrc = vbe32dec(ecx->p);
370	6875	ecx->p += 4;
371	6875	ecx->crc = crc32_combine(
372	6875	ecx->crc, icrc, l);
373	6875	ecx->l_crc += l;
374	6875	}
375	14425	ecx->state = 3;
376	14425	break;
377		case VEC_S1:
378		case VEC_S2:
379		case VEC_S8:
380	16425	ecx->l = ved_decode_len(vdc->vsl, &ecx->p);
381	16425	if (ecx->l < 0)
382	0	return (-1);
383		Debug("SKIP1(%d)\n", (int)ecx->l);
384	16425	ecx->state = 4;
385	16425	break;
386		case VEC_IC:
387	3225	ecx->incl_cont =
388	3225	FEATURE(FEATURE_ESI_INCLUDE_ONERROR);
389		/* FALLTHROUGH */
390		case VEC_IA:
391	10750	ecx->p++;
392	10750	q = (void)strchr((const char)ecx->p, '\0');
393	10750	AN(q);
394	10750	q++;
395	10750	r = (void)strchr((const char)q, '\0');
396	10750	AN(r);
397	10750	if (VDP_bytes(vdc, VDP_FLUSH, NULL, 0)) {
398	25	ecx->p = ecx->e;
399	25	break;
400		}
401		Debug("INCL [%s][%s] BEGIN\n", q, ecx->p);
402	21450	ved_include(ecx->preq,
403	10725	(const char)q, (const char)ecx->p, ecx);
404		Debug("INCL [%s][%s] END\n", q, ecx->p);
405	10725	ecx->p = r + 1;
406	10725	break;
407		default:
408	0	VSLb(vdc->vsl, SLT_Error,
409		"ESI corruption line %d 0x%02x [%s]\n",
410	0	__LINE__, *ecx->p, ecx->p);
411	0	WRONG("ESI-codes: Illegal code");
412	0	}
413	41600	break;
414		case 2:
415	4925	ptr = NULL;
416	4925	len = 0;
417	4925	if (ecx->isgzip && ecx->pecx == NULL) {
418		/*
419		* We are bytealigned here, so simply emit
420		* a gzip literal block with finish bit set.
421		*/
422	1025	tailbuf[0] = 0x01;
423	1025	tailbuf[1] = 0x00;
424	1025	tailbuf[2] = 0x00;
425	1025	tailbuf[3] = 0xff;
426	1025	tailbuf[4] = 0xff;
427
428		/* Emit CRC32 */
429	1025	vle32enc(tailbuf + 5, ecx->crc);
430
431		/* MOD(2^32) length */
432	1025	vle32enc(tailbuf + 9, ecx->l_crc);
433
434	1025	ptr = tailbuf;
435	1025	len = 13;
436	4925	} else if (ecx->pecx != NULL) {
437	3400	ecx->pecx->crc = crc32_combine(ecx->pecx->crc,
438	1700	ecx->crc, ecx->l_crc);
439	1700	ecx->pecx->l_crc += ecx->l_crc;
440	1700	}
441	4925	retval = VDP_bytes(vdc, VDP_END, ptr, len);
442	4925	ecx->state = 99;
443	4925	return (retval);
444		case 3:
445		case 4:
446		/*
447		* There is no guarantee that the 'l' bytes are all
448		* in the same storage segment, so loop over storage
449		* until we have processed them all.
450		*/
451	32025	if (ecx->l <= len) {
452	30850	if (ecx->state == 3)
453	28850	retval = VDP_bytes(vdc, act,
454	14425	pp, ecx->l);
455	30850	len -= ecx->l;
456	30850	pp += ecx->l;
457	30850	ecx->state = 1;
458	30850	break;
459		}
460	1175	if (ecx->state == 3 && len > 0)
461	425	retval = VDP_bytes(vdc, act, pp, len);
462	1175	ecx->l -= len;
463	1175	return (retval);
464		case 99:
465		/*
466		* VEP does not account for the PAD+CRC+LEN
467		* so we can see up to approx 15 bytes here.
468		*/
469	250	return (retval);
470		default:
471	0	WRONG("FOO");
472	0	break;
473		}
474	82475	if (retval)
475	175	return (retval);
476		}
477	6525	}
478
479		const struct vdp VDP_esi = {
480		.name = "esi",
481		.init = ved_vdp_esi_init,
482		.bytes = ved_vdp_esi_bytes,
483		.fini = ved_vdp_esi_fini,
484		};
485
486		/*
487		* Account body bytes on req
488		* Push bytes to preq
489		*/
490		static inline int
491	55125	ved_bytes(struct ecx *ecx, enum vdp_action act,
492		const void *ptr, ssize_t len)
493		{
494	55125	if (act == VDP_END)
495	9250	act = VDP_FLUSH;
496	55125	return (VDP_bytes(ecx->preq->vdc, act, ptr, len));
497		}
498
499		/*---------------------------------------------------------------------