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.
 *
 * VEP Varnish Esi Parsing
 */

#include "config.h"

#include "cache_varnishd.h"
#include "cache_filter.h"

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

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

struct vep_state;

enum dowhat {DO_ATTR, DO_TAG};
typedef void dostuff_f(struct vep_state *, enum dowhat);

struct vep_match {
        const char      *match;
        const char      * const *state;
};

enum vep_mark { VERBATIM = 0, SKIP };

struct vep_state {
        unsigned                magic;
#define VEP_MAGIC               0x55cb9b82
        struct vsb              *vsb;

        const char              *url;
        struct vfp_ctx          *vc;
        int                     dogzip;
        vep_callback_t          *cb;
        void                    *cb_priv;

        /* Internal Counter for default call-back function */
        ssize_t                 cb_x;

        /* parser state */
        const char              *state;
        unsigned                startup;
        unsigned                esi_found;

        unsigned                endtag;
        unsigned                emptytag;
        unsigned                canattr;

        unsigned                remove;

        ssize_t                 o_wait;
        ssize_t                 o_pending;
        ssize_t                 o_total;
        uint32_t                crc;
        ssize_t                 o_crc;
        uint32_t                crcp;
        ssize_t                 o_last;

        const char              *hack_p;
        const char              *ver_p;

        const char              *until;
        const char              *until_p;
        const char              *until_s;

        int                     in_esi_tag;

        const char              *esicmt;
        const char              *esicmt_p;

        struct vep_match        *attr;
        struct vsb              *attr_vsb;
        int                     attr_delim;

        struct vep_match        *match;
        struct vep_match        *match_hit;

        char                    tag[8];
        int                     tag_i;

        dostuff_f               *dostuff;

        struct vsb              *include_src;
        unsigned                include_continue;

        unsigned                nm_skip;
        unsigned                nm_verbatim;
        unsigned                nm_pending;
        enum vep_mark           last_mark;
};

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

static const char * const VEP_START =           "[Start]";
static const char * const VEP_BOM =             "[BOM]";
static const char * const VEP_TESTXML =         "[TestXml]";
static const char * const VEP_NOTXML =          "[NotXml]";

static const char * const VEP_NEXTTAG =         "[NxtTag]";
static const char * const VEP_NOTMYTAG =        "[NotMyTag]";

static const char * const VEP_STARTTAG =        "[StartTag]";
static const char * const VEP_COMMENTESI =      "[CommentESI]";
static const char * const VEP_COMMENT =         "[Comment]";
static const char * const VEP_CDATA =           "[CDATA]";
static const char * const VEP_ESITAG =          "[ESITag]";
static const char * const VEP_ESIENDTAG =       "[/ESITag]";

static const char * const VEP_ESIREMOVE =       "[ESI:Remove]";
static const char * const VEP_ESIINCLUDE =      "[ESI:Include]";
static const char * const VEP_ESICOMMENT =      "[ESI:Comment]";
static const char * const VEP_ESIBOGON =        "[ESI:Bogon]";

static const char * const VEP_INTAG =           "[InTag]";
static const char * const VEP_TAGERROR =        "[TagError]";

static const char * const VEP_ATTR =            "[Attribute]";
static const char * const VEP_SKIPATTR =        "[SkipAttribute]";
static const char * const VEP_ATTRDELIM =       "[AttrDelim]";
static const char * const VEP_ATTRGETVAL =      "[AttrGetValue]";
static const char * const VEP_ATTRVAL =         "[AttrValue]";

static const char * const VEP_UNTIL =           "[Until]";
static const char * const VEP_MATCHBUF =        "[MatchBuf]";
static const char * const VEP_MATCH =           "[Match]";

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

static struct vep_match vep_match_starttag[] = {
        { "!--esi",     &VEP_COMMENTESI },
        { "!---->",     &VEP_NEXTTAG },
        { "!--",        &VEP_COMMENT },
        { "/esi:",      &VEP_ESIENDTAG },
        { "esi:",       &VEP_ESITAG },
        { "![CDATA[",   &VEP_CDATA },
        { NULL,         &VEP_NOTMYTAG }
};

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

static struct vep_match vep_match_esi[] = {
        { "include",    &VEP_ESIINCLUDE },
        { "remove",     &VEP_ESIREMOVE },
        { "comment",    &VEP_ESICOMMENT },
        { NULL,         &VEP_ESIBOGON }
};

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

static struct vep_match vep_match_attr_include[] = {
        { "src=",       &VEP_ATTRGETVAL },
        { "onerror=",   &VEP_ATTRGETVAL },
        { NULL,         &VEP_SKIPATTR }
};

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

static struct vep_match vep_match_bom[] = {
        { "\xeb\xbb\xbf",       &VEP_START },
        { NULL,                 &VEP_BOM }
};

/*--------------------------------------------------------------------
 * Report a parsing error
 */

static void
vep_error(const struct vep_state *vep, const char *p)
{
        VSC_C_main->esi_errors++;
        VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, "ERR after %zd %s",
             vep->o_last, p);
}

/*--------------------------------------------------------------------
 * Report a parsing warning
 */

static void
vep_warn(const struct vep_state *vep, const char *p)
{
        VSC_C_main->esi_warnings++;
        VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, "WARN after %zd %s",
             vep->o_last, p);
}

/*---------------------------------------------------------------------
 * return match or NULL if more input needed.
 */

static struct vep_match *
vep_match(const struct vep_state *vep, const char *b, const char *e)
{
        struct vep_match *vm;
        const char *q, *r;

        AN(vep->match);
        for (vm = vep->match; vm->match != NULL; vm++) {
                assert(strlen(vm->match) <= sizeof (vep->tag));
                r = b;
                for (q = vm->match; *q != '\0' && r < e; q++, r++)
                        if (*q != *r)
                                break;
                if (*q == '\0')
                        break;
                if (r == e)
                        return (NULL);
        }
        return (vm);
}

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

static void
vep_emit_len(const struct vep_state *vep, ssize_t l, int m8, int m16, int m64)
{
        uint8_t buf[9];

        assert(l > 0);
        if (l < 256) {
                buf[0] = (uint8_t)m8;
                buf[1] = (uint8_t)l;
                assert((ssize_t)buf[1] == l);
                VSB_bcat(vep->vsb, buf, 2);
        } else if (l < 65536) {
                buf[0] = (uint8_t)m16;
                vbe16enc(buf + 1, (uint16_t)l);
                assert((ssize_t)vbe16dec(buf + 1) == l);
                VSB_bcat(vep->vsb, buf, 3);
        } else {
                buf[0] = (uint8_t)m64;
                vbe64enc(buf + 1, l);
                assert((ssize_t)vbe64dec(buf + 1) == l);
                VSB_bcat(vep->vsb, buf, 9);
        }
}

static void
vep_emit_skip(const struct vep_state *vep, ssize_t l)
{

        vep_emit_len(vep, l, VEC_S1, VEC_S2, VEC_S8);
}

static void
vep_emit_verbatim(const struct vep_state *vep, ssize_t l, ssize_t l_crc)
{
        uint8_t buf[4];

        vep_emit_len(vep, l, VEC_V1, VEC_V2, VEC_V8);
        if (vep->dogzip) {
                vep_emit_len(vep, l_crc, VEC_C1, VEC_C2, VEC_C8);
                vbe32enc(buf, vep->crc);
                VSB_bcat(vep->vsb, buf, sizeof buf);
        }
}

static void
vep_emit_common(struct vep_state *vep, ssize_t l, enum vep_mark mark)
{

        assert(l >= 0);
        if (l == 0)
                return;
        assert(mark == SKIP || mark == VERBATIM);
        if (mark == SKIP)
                vep_emit_skip(vep, l);
        else
                vep_emit_verbatim(vep, l, vep->o_crc);

        vep->crc = crc32(0L, Z_NULL, 0);
        vep->o_crc = 0;
        vep->o_total += l;
}

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

static void
vep_mark_common(struct vep_state *vep, const char *p, enum vep_mark mark)
{
        ssize_t l, lcb;

        assert(mark == SKIP || mark == VERBATIM);

        /* The NO-OP case, no data, no pending data & no change of mode */
        if (vep->last_mark == mark && p == vep->ver_p && vep->o_pending == 0)
                return;

        /*
         * If we changed mode, emit whatever the opposite mode
         * assembled before the pending bytes.
         */

        if (vep->last_mark != mark && (vep->o_wait > 0 || vep->startup)) {
                lcb = vep->cb(vep->vc, vep->cb_priv, 0,
                    mark == VERBATIM ? VGZ_RESET : VGZ_ALIGN);
                vep_emit_common(vep, lcb - vep->o_last, vep->last_mark);
                vep->o_last = lcb;
                vep->o_wait = 0;
        }

        /* Transfer pending bytes CRC into active mode CRC */
        if (vep->o_pending) {
                (void)vep->cb(vep->vc, vep->cb_priv, vep->o_pending,
                     VGZ_NORMAL);
                if (vep->o_crc == 0) {
                        vep->crc = vep->crcp;
                        vep->o_crc = vep->o_pending;
                } else {
                        vep->crc = crc32_combine(vep->crc,
                            vep->crcp, vep->o_pending);
                        vep->o_crc += vep->o_pending;
                }
                vep->crcp = crc32(0L, Z_NULL, 0);
                vep->o_wait += vep->o_pending;
                vep->o_pending = 0;
        }

        /* * Process this bit of input */
        AN(vep->ver_p);
        l = p - vep->ver_p;
        assert(l >= 0);
        vep->crc = crc32(vep->crc, (const void*)vep->ver_p, l);
        vep->o_crc += l;
        vep->ver_p = p;

        vep->o_wait += l;
        vep->last_mark = mark;
        (void)vep->cb(vep->vc, vep->cb_priv, l, VGZ_NORMAL);
}

static void
vep_mark_verbatim(struct vep_state *vep, const char *p)
{

        vep_mark_common(vep, p, VERBATIM);
        vep->nm_verbatim++;
}

static void
vep_mark_skip(struct vep_state *vep, const char *p)
{

        vep_mark_common(vep, p, SKIP);
        vep->nm_skip++;
}

static void
vep_mark_pending(struct vep_state *vep, const char *p)
{
        ssize_t l;

        AN(vep->ver_p);
        l = p - vep->ver_p;
        assert(l > 0);
        vep->crcp = crc32(vep->crcp, (const void *)vep->ver_p, l);
        vep->ver_p = p;

        vep->o_pending += l;
        vep->nm_pending++;
}

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

static void v_matchproto_()
vep_do_comment(struct vep_state *vep, enum dowhat what)
{
        Debug("DO_COMMENT(%d)\n", what);
        assert(what == DO_TAG);
        if (!vep->emptytag)
                vep_error(vep, "ESI 1.0 <esi:comment> needs final '/'");
}

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

static void v_matchproto_()
vep_do_remove(struct vep_state *vep, enum dowhat what)
{
        Debug("DO_REMOVE(%d, end %d empty %d remove %d)\n",
            what, vep->endtag, vep->emptytag, vep->remove);
        assert(what == DO_TAG);
        if (vep->emptytag)
                vep_error(vep, "ESI 1.0 <esi:remove/> not legal");
        else if (vep->remove && !vep->endtag)
                vep_error(vep, "ESI 1.0 <esi:remove> already open");
        else if (!vep->remove && vep->endtag)
                vep_error(vep, "ESI 1.0 <esi:remove> not open");
        else
                vep->remove = !vep->endtag;
}

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

static void
include_attr_src(struct vep_state *vep)
{
        const char *p;

        if (vep->include_src != NULL) {
                vep_error(vep,
                    "ESI 1.0 <esi:include> "
                    "has multiple src= attributes");
                vep->state = VEP_TAGERROR;
                VSB_destroy(&vep->attr_vsb);
                VSB_destroy(&vep->include_src);
                return;
        }
        for (p = VSB_data(vep->attr_vsb); *p != '\0'; p++)
                if (vct_islws(*p))
                        break;
        if (*p != '\0') {
                vep_error(vep,
                    "ESI 1.0 <esi:include> "
                    "has whitespace in src= attribute");
                vep->state = VEP_TAGERROR;
                VSB_destroy(&vep->attr_vsb);
                if (vep->include_src != NULL)
                        VSB_destroy(&vep->include_src);
                return;
        }
        vep->include_src = vep->attr_vsb;
        vep->attr_vsb = NULL;
}

static void
include_attr_onerror(struct vep_state *vep)
{

        vep->include_continue = !strcmp("continue", VSB_data(vep->attr_vsb));
        VSB_destroy(&vep->attr_vsb);
}

static void v_matchproto_()
vep_do_include(struct vep_state *vep, enum dowhat what)
{
        const char *p, *q, *h;
        ssize_t l;
        char incl;

        Debug("DO_INCLUDE(%d)\n", what);
        if (what == DO_ATTR) {
                Debug("ATTR (%s) (%s)\n", vep->match_hit->match,
                        VSB_data(vep->attr_vsb));
                if (!strcmp("src=", vep->match_hit->match)) {
                        include_attr_src(vep);
                        return;
                }
                if (!strcmp("onerror=", vep->match_hit->match)) {
                        include_attr_onerror(vep);
                        return;
                }
                WRONG("Unhandled <esi:include> attribute");
        }
        assert(what == DO_TAG);
        if (!vep->emptytag)
                vep_warn(vep, "ESI 1.0 <esi:include> lacks final '/'");
        if (vep->include_src == NULL) {
                vep_error(vep, "ESI 1.0 <esi:include> lacks src attr");
                return;
        }

        /*
         * Strictly speaking, we ought to spit out any piled up skip before
         * emitting the VEC for the include, but objectively that makes no
         * difference and robs us of a chance to collapse another skip into
         * this on so we don't do that.
         * However, we cannot tolerate any verbatim stuff piling up.
         * The mark_skip() before calling dostuff should have taken
         * care of that.  Make sure.
         */
        assert(vep->o_wait == 0 || vep->last_mark == SKIP);
        /* XXX: what if it contains NUL bytes ?? */
        p = VSB_data(vep->include_src);
        l = VSB_len(vep->include_src);
        h = 0;

        incl = vep->include_continue ? VEC_IC : VEC_IA;

        if (l > 7 && !memcmp(p, "http://", 7)) {
                h = p + 7;
                p = strchr(h, '/');
                if (p == NULL) {
                        vep_error(vep,
                            "ESI 1.0 <esi:include> invalid src= URL");
                        vep->state = VEP_TAGERROR;
                        AZ(vep->attr_vsb);
                        VSB_destroy(&vep->include_src);
                        return;
                }
                Debug("HOST <%.*s> PATH <%s>\n", (int)(p-h),h, p);
                VSB_printf(vep->vsb, "%c", incl);
                VSB_printf(vep->vsb, "Host: %.*s%c", (int)(p-h), h, 0);
        } else if (l > 8 && !memcmp(p, "https://", 8)) {
                if (!FEATURE(FEATURE_ESI_IGNORE_HTTPS)) {
                        vep_warn(vep,
                            "ESI 1.0 <esi:include> with https:// ignored");
                        vep->state = VEP_TAGERROR;
                        AZ(vep->attr_vsb);
                        VSB_destroy(&vep->include_src);
                        return;
                }
                vep_warn(vep,
                    "ESI 1.0 <esi:include> https:// treated as http://");
                h = p + 8;
                p = strchr(h, '/');
                if (p == NULL) {
                        vep_error(vep,
                            "ESI 1.0 <esi:include> invalid src= URL");
                        vep->state = VEP_TAGERROR;
                        AZ(vep->attr_vsb);
                        VSB_destroy(&vep->include_src);
                        return;
                }
                VSB_printf(vep->vsb, "%c", incl);
                VSB_printf(vep->vsb, "Host: %.*s%c", (int)(p-h), h, 0);
        } else if (*p == '/') {
                VSB_printf(vep->vsb, "%c", incl);
                VSB_printf(vep->vsb, "%c", 0);
        } else {
                VSB_printf(vep->vsb, "%c", incl);
                VSB_printf(vep->vsb, "%c", 0);
                /* Look for the last / before a '?' */
                h = NULL;
                for (q = vep->url; *q && *q != '?'; q++)
                        if (*q == '/')
                                h = q;
                if (h == NULL)
                        h = q + 1;

                Debug("INCL:: [%.*s]/[%s]\n",
                    (int)(h - vep->url), vep->url, p);
                VSB_printf(vep->vsb, "%.*s/", (int)(h - vep->url), vep->url);
        }
        l -= (p - VSB_data(vep->include_src));
        for (q = p; *q != '\0'; ) {
                if (*q == '&') {
#define R(w,f,r)                                                        \
                        if (q + w <= p + l && !memcmp(q, f, w)) { \
                                VSB_printf(vep->vsb, "%c", r);  \
                                q += w;                         \
                                continue;                       \
                        }
                        R(6, "&apos;", '\'');
                        R(6, "&quot;", '"');
                        R(4, "&lt;", '<');
                        R(4, "&gt;", '>');
                        R(5, "&amp;", '&');
                }
                VSB_printf(vep->vsb, "%c", *q++);
        }
#undef R
        VSB_printf(vep->vsb, "%c", 0);
        VSB_destroy(&vep->include_src);
        vep->include_continue = 0;
}

/*---------------------------------------------------------------------
 * Lex/Parse object for ESI instructions
 *
 * This function is called with the input object piecemeal so do not
 * assume that we have more than one char available at at time, but
 * optimize for getting huge chunks.
 *
 * NB: At the bottom of this source-file, there is a dot-diagram matching
 * NB: the state-machine.  Please maintain it along with the code.
 */

void
VEP_Parse(struct vep_state *vep, const char *p, size_t l)
{
        const char *e;
        struct vep_match *vm;
        int i;

        CHECK_OBJ_NOTNULL(vep, VEP_MAGIC);
        assert(l > 0);

        if (vep->startup) {
                /*
                 * We must force the GZIP header out as a SKIP string,
                 * otherwise an object starting with <esi:include would
                 * have its GZIP header appear after the included object
                 * (e000026.vtc)
                 */
                vep->ver_p = "";
                vep->last_mark = SKIP;
                vep_mark_common(vep, vep->ver_p, VERBATIM);
                vep->startup = 0;
                AZ(vep->hack_p);
                vep->hack_p = p;
        }

        vep->ver_p = p;

        e = p + l;

        while (p < e) {
                AN(vep->state);
                Debug("EP %s %d (%.*s) [%.*s]\n",
                    vep->state,
                    vep->remove,
                    vep->tag_i, vep->tag,
                    (e - p) > 10 ? 10 : (int)(e-p), p);
                assert(p >= vep->ver_p);

                /******************************************************
                 * SECTION A
                 */

                if (vep->state == VEP_START) {
                        if (FEATURE(FEATURE_ESI_REMOVE_BOM) &&
                            *p == (char)0xeb) {
                                vep->match = vep_match_bom;
                                vep->state = VEP_MATCH;
                        } else
                                vep->state = VEP_BOM;
                } else if (vep->state == VEP_BOM) {
                        vep_mark_skip(vep, p);
                        if (FEATURE(FEATURE_ESI_DISABLE_XML_CHECK))
                                vep->state = VEP_NEXTTAG;
                        else
                                vep->state = VEP_TESTXML;
                } else if (vep->state == VEP_TESTXML) {
                        /*
                         * If the first non-whitespace char is different
                         * from '<' we assume this is not XML.
                         */
                        while (p < e && vct_islws(*p))
                                p++;
                        vep_mark_verbatim(vep, p);
                        if (p < e && *p == '<') {
                                p++;
                                vep->state = VEP_STARTTAG;
                        } else if (p < e && *p == (char)0xeb) {
                                VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror,
                                    "No ESI processing, "
                                    "first char not '<' but BOM."
                                    " (See feature esi_remove_bom)"
                                );
                                vep->state = VEP_NOTXML;
                        } else if (p < e) {
                                VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror,
                                    "No ESI processing, "
                                    "first char not '<'."
                                    " (See feature esi_disable_xml_check)"
                                );
                                vep->state = VEP_NOTXML;
                        }
                } else if (vep->state == VEP_NOTXML) {
                        /*
                         * This is not recognized as XML, just skip thru
                         * vfp_esi_end() will handle the rest
                         */
                        p = e;
                        vep_mark_verbatim(vep, p);

                /******************************************************
                 * SECTION B
                 */

                } else if (vep->state == VEP_NOTMYTAG) {
                        if (FEATURE(FEATURE_ESI_IGNORE_OTHER_ELEMENTS)) {
                                p++;
                                vep->state = VEP_NEXTTAG;
                        } else {
                                vep->tag_i = 0;
                                while (p < e) {
                                        if (*p++ == '>') {
                                                vep->state = VEP_NEXTTAG;
                                                break;
                                        }
                                }
                        }
                        if (p == e && !vep->remove)
                                vep_mark_verbatim(vep, p);
                } else if (vep->state == VEP_NEXTTAG) {
                        /*
                         * Hunt for start of next tag and keep an eye
                         * out for end of EsiCmt if armed.
                         */
                        vep->emptytag = 0;
                        vep->attr = NULL;
                        vep->dostuff = NULL;
                        while (p < e && *p != '<') {
                                if (vep->esicmt_p == NULL) {
                                        p++;
                                        continue;
                                }
                                if (*p != *vep->esicmt_p) {
                                        p++;
                                        vep->esicmt_p = vep->esicmt;
                                        continue;
                                }
                                if (!vep->remove && vep->esicmt_p == vep->esicmt)
                                        vep_mark_verbatim(vep, p);
                                p++;
                                if (*++vep->esicmt_p == '\0') {
                                        vep->esi_found = 1;
                                        vep->esicmt = NULL;
                                        vep->esicmt_p = NULL;
                                        /*
                                         * The end of the esicmt
                                         * should not be emitted.
                                         * But the stuff before should
                                         */
                                        vep_mark_skip(vep, p);
                                }
                        }
                        if (p < e) {
                                if (!vep->remove)
                                        vep_mark_verbatim(vep, p);
                                assert(*p == '<');
                                p++;
                                vep->state = VEP_STARTTAG;
                        } else if (vep->esicmt_p == vep->esicmt && !vep->remove)
                                vep_mark_verbatim(vep, p);

                /******************************************************
                 * SECTION C
                 */

                } else if (vep->state == VEP_STARTTAG) {
                        /* Start of tag, set up match table */
                        vep->endtag = 0;
                        vep->match = vep_match_starttag;
                        vep->state = VEP_MATCH;
                } else if (vep->state == VEP_COMMENT) {
                        vep->esicmt_p = vep->esicmt = NULL;
                        vep->until_p = vep->until = "-->";
                        vep->until_s = VEP_NEXTTAG;
                        vep->state = VEP_UNTIL;
                } else if (vep->state == VEP_COMMENTESI) {
                        if (vep->remove)
                                vep_error(vep,
                                    "ESI 1.0 Nested <!--esi"
                                    " element in <esi:remove>");
                        vep->esicmt_p = vep->esicmt = "-->";
                        vep->state = VEP_NEXTTAG;
                        vep_mark_skip(vep, p);
                } else if (vep->state == VEP_CDATA) {
                        /*
                         * Easy: just look for the end of CDATA
                         */
                        vep->until_p = vep->until = "]]>";
                        vep->until_s = VEP_NEXTTAG;
                        vep->state = VEP_UNTIL;
                } else if (vep->state == VEP_ESIENDTAG) {
                        vep->endtag = 1;
                        vep->state = VEP_ESITAG;
                } else if (vep->state == VEP_ESITAG) {
                        vep->in_esi_tag = 1;
                        vep->esi_found = 1;
                        vep_mark_skip(vep, p);
                        vep->match = vep_match_esi;
                        vep->state = VEP_MATCH;
                } else if (vep->state == VEP_ESIINCLUDE) {
                        if (vep->remove) {
                                vep_error(vep,
                                    "ESI 1.0 <esi:include> element"
                                    " nested in <esi:remove>");
                                vep->state = VEP_TAGERROR;
                        } else if (vep->endtag) {
                                vep_error(vep,
                                    "ESI 1.0 </esi:include> illegal end-tag");
                                vep->state = VEP_TAGERROR;
                        } else {
                                vep->dostuff = vep_do_include;
                                vep->state = VEP_INTAG;
                                vep->attr = vep_match_attr_include;
                        }
                } else if (vep->state == VEP_ESIREMOVE) {
                        vep->dostuff = vep_do_remove;
                        vep->state = VEP_INTAG;
                } else if (vep->state == VEP_ESICOMMENT) {
                        if (vep->remove) {
                                vep_error(vep,
                                    "ESI 1.0 <esi:comment> element"
                                    " nested in <esi:remove>");
                                vep->state = VEP_TAGERROR;
                        } else if (vep->endtag) {
                                vep_error(vep,
                                    "ESI 1.0 </esi:comment> illegal end-tag");
                                vep->state = VEP_TAGERROR;
                        } else {
                                vep->dostuff = vep_do_comment;
                                vep->state = VEP_INTAG;
                        }
                } else if (vep->state == VEP_ESIBOGON) {
                        vep_error(vep,
                            "ESI 1.0 <esi:bogus> element");
                        vep->state = VEP_TAGERROR;

                /******************************************************
                 * SECTION D
                 */

                } else if (vep->state == VEP_INTAG) {
                        vep->tag_i = 0;
                        while (p < e && vct_islws(*p) && !vep->emptytag) {
                                p++;
                                vep->canattr = 1;
                        }
                        if (p < e && *p == '/' && !vep->emptytag) {
                                p++;
                                vep->emptytag = 1;
                                vep->canattr = 0;
                        }
                        if (p < e && *p == '>') {
                                p++;
                                AN(vep->dostuff);
                                vep_mark_skip(vep, p);
                                vep->dostuff(vep, DO_TAG);
                                vep->in_esi_tag = 0;
                                vep->state = VEP_NEXTTAG;
                        } else if (p < e && vep->emptytag) {
                                vep_error(vep,
                                    "XML 1.0 '>' does not follow '/' in tag");
                                vep->state = VEP_TAGERROR;
                        } else if (p < e && vep->canattr &&
                            vct_isxmlnamestart(*p)) {
                                vep->state = VEP_ATTR;
                        } else if (p < e) {
                                vep_error(vep,
                                    "XML 1.0 Illegal attribute start char");
                                vep->state = VEP_TAGERROR;
                        }
                } else if (vep->state == VEP_TAGERROR) {
                        while (p < e && *p != '>')
                                p++;
                        if (p < e) {
                                p++;
                                vep_mark_skip(vep, p);
                                vep->in_esi_tag = 0;
                                vep->state = VEP_NEXTTAG;
                                if (vep->attr_vsb)
                                        VSB_destroy(&vep->attr_vsb);
                        }

                /******************************************************
                 * SECTION E
                 */

                } else if (vep->state == VEP_ATTR) {
                        AZ(vep->attr_delim);
                        if (vep->attr == NULL) {
                                p++;
                                AZ(vep->attr_vsb);
                                vep->state = VEP_SKIPATTR;
                        } else {
                                vep->match = vep->attr;
                                vep->state = VEP_MATCH;
                        }
                } else if (vep->state == VEP_SKIPATTR) {
                        while (p < e && vct_isxmlname(*p))
                                p++;
                        if (p < e && *p == '=') {
                                p++;
                                vep->state = VEP_ATTRDELIM;
                        } else if (p < e && *p == '>') {
                                vep->state = VEP_INTAG;
                        } else if (p < e && *p == '/') {
                                vep->state = VEP_INTAG;
                        } else if (p < e && vct_issp(*p)) {
                                vep->state = VEP_INTAG;
                        } else if (p < e) {
                                vep_error(vep,
                                    "XML 1.0 Illegal attr char");
                                vep->state = VEP_TAGERROR;
                        }
                } else if (vep->state == VEP_ATTRGETVAL) {
                        AZ(vep->attr_vsb);
                        vep->attr_vsb = VSB_new_auto();
                        vep->state = VEP_ATTRDELIM;
                } else if (vep->state == VEP_ATTRDELIM) {
                        AZ(vep->attr_delim);
                        if (*p == '"' || *p == '\'') {
                                vep->attr_delim = *p++;
                                vep->state = VEP_ATTRVAL;
                        } else if (!vct_issp(*p)) {
                                vep->attr_delim = ' ';
                                vep->state = VEP_ATTRVAL;
                        } else {
                                vep_error(vep,
                                    "XML 1.0 Illegal attribute delimiter");
                                vep->state = VEP_TAGERROR;
                        }

                } else if (vep->state == VEP_ATTRVAL) {
                        while (p < e && *p != '>' && *p != vep->attr_delim &&
                           (vep->attr_delim != ' ' || !vct_issp(*p))) {
                                if (vep->attr_vsb != NULL)
                                        VSB_putc(vep->attr_vsb, *p);
                                p++;
                        }
                        if (p < e && *p == '>') {
                                vep_error(vep,
                                    "XML 1.0 Missing end attribute delimiter");
                                vep->state = VEP_TAGERROR;
                                vep->attr_delim = 0;
                                if (vep->attr_vsb != NULL) {
                                        AZ(VSB_finish(vep->attr_vsb));
                                        VSB_destroy(&vep->attr_vsb);
                                }
                        } else if (p < e) {
                                vep->attr_delim = 0;
                                p++;
                                vep->state = VEP_INTAG;
                                if (vep->attr_vsb != NULL) {
                                        AZ(VSB_finish(vep->attr_vsb));
                                        AN(vep->dostuff);
                                        vep->dostuff(vep, DO_ATTR);
                                        vep->attr_vsb = NULL;
                                }
                        }

                /******************************************************
                 * Utility Section
                 */

                } else if (vep->state == VEP_MATCH) {
                        /*
                         * Match against a table
                         */
                        vm = vep_match(vep, p, e);
                        vep->match_hit = vm;
                        if (vm != NULL) {
                                if (vm->match != NULL)
                                        p += strlen(vm->match);
                                vep->state = *vm->state;
                                vep->match = NULL;
                                vep->tag_i = 0;
                        } else {
                                assert(p + sizeof(vep->tag) >= e);
                                memcpy(vep->tag, p, e - p);
                                vep->tag_i = e - p;
                                vep->state = VEP_MATCHBUF;
                                p = e;
                        }
                } else if (vep->state == VEP_MATCHBUF) {
                        /*
                         * Match against a table while split over input
                         * sections.
                         */
                        AN(vep->match);
                        i = sizeof(vep->tag) - vep->tag_i;
                        if (i > e - p)
                                i = e - p;
                        memcpy(vep->tag + vep->tag_i, p, i);
                        vm = vep_match(vep, vep->tag,
                            vep->tag + vep->tag_i + i);
                        Debug("MB (%.*s) tag_i %d i %d = vm %p match %s\n",
                            vep->tag_i + i, vep->tag,
                            vep->tag_i,
                            i,
                            vm,
                            vm ? vm->match : "(nil)");

                        if (vm == NULL) {
                                vep->tag_i += i;
                                p += i;
                                assert(p == e);
                        } else {
                                vep->match_hit = vm;
                                vep->state = *vm->state;
                                if (vm->match != NULL) {
                                        i = strlen(vm->match);
                                        if (i > vep->tag_i)
                                                p += i - vep->tag_i;
                                }
                                vep->match = NULL;
                                vep->tag_i = 0;
                        }
                } else if (vep->state == VEP_UNTIL) {
                        /*
                         * Skip until we see magic string
                         */
                        while (p < e) {
                                if (*p++ != *vep->until_p++) {
                                        vep->until_p = vep->until;
                                } else if (*vep->until_p == '\0') {
                                        vep->state = vep->until_s;
                                        break;
                                }
                        }
                        if (p == e && !vep->remove)
                                vep_mark_verbatim(vep, p);
                } else {
                        Debug("*** Unknown state %s\n", vep->state);
                        WRONG("WRONG ESI PARSER STATE");
                }
        }
        /*
         * We must always mark up the storage we got, try to do so
         * in the most efficient way, in particular with respect to
         * minimizing and limiting use of pending.
         */
        if (p == vep->ver_p)
                ;
        else if (vep->in_esi_tag)
                vep_mark_skip(vep, p);
        else if (vep->remove)
                vep_mark_skip(vep, p);
        else
                vep_mark_pending(vep, p);
}

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

static ssize_t v_matchproto_(vep_callback_t)
vep_default_cb(struct vfp_ctx *vc, void *priv, ssize_t l, enum vgz_flag flg)
{
        ssize_t *s;

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        AN(priv);
        s = priv;
        *s += l;
        (void)flg;
        return (*s);
}

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

struct vep_state *
VEP_Init(struct vfp_ctx *vc, const struct http *req, vep_callback_t *cb,
    void *cb_priv)
{
        struct vep_state *vep;

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(req, HTTP_MAGIC);
        vep = WS_Alloc(vc->resp->ws, sizeof *vep);
        if (vep == NULL) {
                VSLb(vc->wrk->vsl, SLT_VCL_Error,
                     "VEP_Init() workspace overflow");
                return (NULL);
        }

        INIT_OBJ(vep, VEP_MAGIC);
        vep->url = req->hd[HTTP_HDR_URL].b;
        vep->vc = vc;
        vep->vsb = VSB_new_auto();
        AN(vep->vsb);

        if (cb != NULL) {
                vep->dogzip = 1;
                /* XXX */
                VSB_printf(vep->vsb, "%c", VEC_GZ);
                vep->cb = cb;
                vep->cb_priv = cb_priv;
        } else {
                vep->cb = vep_default_cb;
                vep->cb_priv = &vep->cb_x;
        }

        vep->state = VEP_START;
        vep->crc = crc32(0L, Z_NULL, 0);
        vep->crcp = crc32(0L, Z_NULL, 0);

        vep->startup = 1;
        return (vep);
}

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

struct vsb *
VEP_Finish(struct vep_state *vep)
{
        ssize_t l, lcb;

        CHECK_OBJ_NOTNULL(vep, VEP_MAGIC);

        if (vep->include_src)
                VSB_destroy(&vep->include_src);
        if (vep->attr_vsb)
                VSB_destroy(&vep->attr_vsb);

        if (vep->state != VEP_START &&
            vep->state != VEP_BOM &&
            vep->state != VEP_TESTXML &&
            vep->state != VEP_NOTXML &&
            vep->state != VEP_NEXTTAG) {
                vep_error(vep, "VEP ended inside a tag");
        }

        if (vep->o_pending)
                vep_mark_common(vep, vep->ver_p, vep->last_mark);
        if (vep->o_wait > 0) {
                lcb = vep->cb(vep->vc, vep->cb_priv, 0, VGZ_ALIGN);
                vep_emit_common(vep, lcb - vep->o_last, vep->last_mark);
        }
        // NB: We don't account for PAD+SUM+LEN in gzipped objects
        (void)vep->cb(vep->vc, vep->cb_priv, 0, VGZ_FINISH);

        AZ(VSB_finish(vep->vsb));
        l = VSB_len(vep->vsb);
        if (vep->esi_found && l > 0)
                return (vep->vsb);
        VSB_destroy(&vep->vsb);
        return (NULL);
}

#if 0

digraph xml {
        rankdir="LR"
        size="7,10"
#################################################################
# SECTION A
#

START           [shape=ellipse]
TESTXML         [shape=ellipse]
NOTXML          [shape=ellipse]
NEXTTAGa        [shape=hexagon, label="NEXTTAG"]
STARTTAGa       [shape=hexagon, label="STARTTAG"]
START           -> TESTXML
START           -> NEXTTAGa     [style=dotted, label="syntax:1"]
TESTXML         -> TESTXML      [label="lws"]
TESTXML         -> NOTXML
TESTXML         -> STARTTAGa    [label="'<'"]

#################################################################
# SECTION B

NOTMYTAG        [shape=ellipse]
NEXTTAG         [shape=ellipse]
NOTMYTAG        -> NEXTTAG      [style=dotted, label="syntax:2"]
STARTTAGb       [shape=hexagon, label="STARTTAG"]
NOTMYTAG        -> NEXTTAG      [label="'>'"]
NOTMYTAG        -> NOTMYTAG     [label="*"]
NEXTTAG         -> NEXTTAG      [label="'-->'"]
NEXTTAG         -> NEXTTAG      [label="*"]
NEXTTAG         -> STARTTAGb    [label="'<'"]

#################################################################
# SECTION C

STARTTAG        [shape=ellipse]
COMMENT         [shape=ellipse]
CDATA           [shape=ellipse]
ESITAG          [shape=ellipse]
ESIETAG         [shape=ellipse]
ESIINCLUDE      [shape=ellipse]
ESIREMOVE       [shape=ellipse]
ESICOMMENT      [shape=ellipse]
ESIBOGON        [shape=ellipse]
INTAGc          [shape=hexagon, label="INTAG"]
NOTMYTAGc       [shape=hexagon, label="NOTMYTAG"]
NEXTTAGc        [shape=hexagon, label="NEXTTAG"]
TAGERRORc       [shape=hexagon, label="TAGERROR"]
C1              [shape=circle,label=""]
STARTTAG        -> COMMENT      [label="'<!--'"]
STARTTAG        -> ESITAG       [label="'<esi'"]
STARTTAG        -> CDATA        [label="'<![CDATA['"]
STARTTAG        -> NOTMYTAGc    [label="'*'"]
COMMENT         -> NEXTTAGc     [label="'esi'"]
COMMENT         -> C1           [label="*"]
C1              -> C1           [label="*"]
C1              -> NEXTTAGc     [label="-->"]
CDATA           -> CDATA        [label="*"]
CDATA           -> NEXTTAGc     [label="]]>"]
ESITAG          -> ESIINCLUDE   [label="'include'"]
ESITAG          -> ESIREMOVE    [label="'remove'"]
ESITAG          -> ESICOMMENT   [label="'comment'"]
ESITAG          -> ESIBOGON     [label="*"]
ESICOMMENT      -> INTAGc
ESICOMMENT      -> TAGERRORc
ESICOMMENT      -> TAGERRORc    [style=dotted, label="nested\nin\nremove"]
ESIREMOVE       -> INTAGc
ESIREMOVE       -> TAGERRORc
ESIINCLUDE      -> INTAGc
ESIINCLUDE      -> TAGERRORc
ESIINCLUDE      -> TAGERRORc    [style=dotted, label="nested\nin\nremove"]
ESIBOGON        -> TAGERRORc

#################################################################
# SECTION D

INTAG           [shape=ellipse]
TAGERROR        [shape=ellipse]
NEXTTAGd        [shape=hexagon, label="NEXTTAG"]
ATTRd           [shape=hexagon, label="ATTR"]
D1              [shape=circle, label=""]
D2              [shape=circle, label=""]
INTAG           -> D1           [label="lws"]
D1              -> D2           [label="/"]
INTAG           -> D2           [label="/"]
INTAG           -> NEXTTAGd     [label=">"]
D1              -> NEXTTAGd     [label=">"]
D2              -> NEXTTAGd     [label=">"]
D1              -> ATTRd        [label="XMLstartchar"]
D1              -> TAGERROR     [label="*"]
D2              -> TAGERROR     [label="*"]
TAGERROR        -> TAGERROR     [label="*"]
TAGERROR        -> NEXTTAGd     [label="'>'"]

#################################################################
# SECTION E

ATTR            [shape=ellipse]
SKIPATTR        [shape=ellipse]
ATTRGETVAL      [shape=ellipse]
ATTRDELIM       [shape=ellipse]
ATTRVAL         [shape=ellipse]
TAGERRORe       [shape=hexagon, label="TAGERROR"]
INTAGe          [shape=hexagon, label="INTAG"]
ATTR            -> SKIPATTR     [label="*"]
ATTR            -> ATTRGETVAL   [label="wanted attr"]
SKIPATTR        -> SKIPATTR     [label="XMLname"]
SKIPATTR        -> ATTRDELIM    [label="'='"]
SKIPATTR        -> TAGERRORe    [label="*"]
ATTRGETVAL      -> ATTRDELIM
ATTRDELIM       -> ATTRVAL      [label="\""]
ATTRDELIM       -> ATTRVAL      [label="\'"]
ATTRDELIM       -> ATTRVAL      [label="*"]
ATTRDELIM       -> TAGERRORe    [label="lws"]
ATTRVAL         -> TAGERRORe    [label="'>'"]
ATTRVAL         -> INTAGe       [label="delim"]
ATTRVAL         -> ATTRVAL      [label="*"]

}

#endif

		varnish-cache/bin/varnishd/cache/cache_esi_parse.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		* VEP Varnish Esi Parsing
30		*/
31
32		#include "config.h"
33
34		#include "cache_varnishd.h"
35		#include "cache_filter.h"
36
37		#include "cache_vgz.h"
38		#include "cache_esi.h"
39		#include "vct.h"
40		#include "vend.h"
41		#include "vgz.h"
42
43		//#define Debug(fmt, ...) printf(fmt, __VA_ARGS__)
44		#define Debug(fmt, ...) /**/
45
46		struct vep_state;
47
48		enum dowhat {DO_ATTR, DO_TAG};
49		typedef void dostuff_f(struct vep_state *, enum dowhat);
50
51		struct vep_match {
52		const char *match;
53		const char * const *state;
54		};
55
56		enum vep_mark { VERBATIM = 0, SKIP };
57
58		struct vep_state {
59		unsigned magic;
60		#define VEP_MAGIC 0x55cb9b82
61		struct vsb *vsb;
62
63		const char *url;
64		struct vfp_ctx *vc;
65		int dogzip;
66		vep_callback_t *cb;
67		void *cb_priv;
68
69		/* Internal Counter for default call-back function */
70		ssize_t cb_x;
71
72		/* parser state */
73		const char *state;
74		unsigned startup;
75		unsigned esi_found;
76
77		unsigned endtag;
78		unsigned emptytag;
79		unsigned canattr;
80
81		unsigned remove;
82
83		ssize_t o_wait;
84		ssize_t o_pending;
85		ssize_t o_total;
86		uint32_t crc;
87		ssize_t o_crc;
88		uint32_t crcp;
89		ssize_t o_last;
90
91		const char *hack_p;
92		const char *ver_p;
93
94		const char *until;
95		const char *until_p;
96		const char *until_s;
97
98		int in_esi_tag;
99
100		const char *esicmt;
101		const char *esicmt_p;
102
103		struct vep_match *attr;
104		struct vsb *attr_vsb;
105		int attr_delim;
106
107		struct vep_match *match;
108		struct vep_match *match_hit;
109
110		char tag[8];
111		int tag_i;
112
113		dostuff_f *dostuff;
114
115		struct vsb *include_src;
116		unsigned include_continue;
117
118		unsigned nm_skip;
119		unsigned nm_verbatim;
120		unsigned nm_pending;
121		enum vep_mark last_mark;
122		};
123
124		/---------------------------------------------------------------------/
125
126		static const char * const VEP_START = "[Start]";
127		static const char * const VEP_BOM = "[BOM]";
128		static const char * const VEP_TESTXML = "[TestXml]";
129		static const char * const VEP_NOTXML = "[NotXml]";
130
131		static const char * const VEP_NEXTTAG = "[NxtTag]";
132		static const char * const VEP_NOTMYTAG = "[NotMyTag]";
133
134		static const char * const VEP_STARTTAG = "[StartTag]";
135		static const char * const VEP_COMMENTESI = "[CommentESI]";
136		static const char * const VEP_COMMENT = "[Comment]";
137		static const char * const VEP_CDATA = "[CDATA]";
138		static const char * const VEP_ESITAG = "[ESITag]";
139		static const char * const VEP_ESIENDTAG = "[/ESITag]";
140
141		static const char * const VEP_ESIREMOVE = "[ESI:Remove]";
142		static const char * const VEP_ESIINCLUDE = "[ESI:Include]";
143		static const char * const VEP_ESICOMMENT = "[ESI:Comment]";
144		static const char * const VEP_ESIBOGON = "[ESI:Bogon]";
145
146		static const char * const VEP_INTAG = "[InTag]";
147		static const char * const VEP_TAGERROR = "[TagError]";
148
149		static const char * const VEP_ATTR = "[Attribute]";
150		static const char * const VEP_SKIPATTR = "[SkipAttribute]";
151		static const char * const VEP_ATTRDELIM = "[AttrDelim]";
152		static const char * const VEP_ATTRGETVAL = "[AttrGetValue]";
153		static const char * const VEP_ATTRVAL = "[AttrValue]";
154
155		static const char * const VEP_UNTIL = "[Until]";
156		static const char * const VEP_MATCHBUF = "[MatchBuf]";
157		static const char * const VEP_MATCH = "[Match]";
158
159		/---------------------------------------------------------------------/
160
161		static struct vep_match vep_match_starttag[] = {
162		{ "!--esi", &VEP_COMMENTESI },
163		{ "!---->", &VEP_NEXTTAG },
164		{ "!--", &VEP_COMMENT },
165		{ "/esi:", &VEP_ESIENDTAG },
166		{ "esi:", &VEP_ESITAG },
167		{ "![CDATA[", &VEP_CDATA },
168		{ NULL, &VEP_NOTMYTAG }
169		};
170
171		/---------------------------------------------------------------------/
172
173		static struct vep_match vep_match_esi[] = {
174		{ "include", &VEP_ESIINCLUDE },
175		{ "remove", &VEP_ESIREMOVE },
176		{ "comment", &VEP_ESICOMMENT },
177		{ NULL, &VEP_ESIBOGON }
178		};
179
180		/---------------------------------------------------------------------/
181
182		static struct vep_match vep_match_attr_include[] = {
183		{ "src=", &VEP_ATTRGETVAL },
184		{ "onerror=", &VEP_ATTRGETVAL },
185		{ NULL, &VEP_SKIPATTR }
186		};
187
188		/---------------------------------------------------------------------/
189
190		static struct vep_match vep_match_bom[] = {
191		{ "\xeb\xbb\xbf", &VEP_START },
192		{ NULL, &VEP_BOM }
193		};
194
195		/*--------------------------------------------------------------------
196		* Report a parsing error
197		*/
198
199		static void
200	1424	vep_error(const struct vep_state vep, const char p)
201		{
202	1424	VSC_C_main->esi_errors++;
203	2848	VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, "ERR after %zd %s",
204	1424	vep->o_last, p);
205	1424	}
206
207		/*--------------------------------------------------------------------
208		* Report a parsing warning
209		*/
210
211		static void
212	200	vep_warn(const struct vep_state vep, const char p)
213		{
214	200	VSC_C_main->esi_warnings++;
215	400	VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, "WARN after %zd %s",
216	200	vep->o_last, p);
217	200	}
218
219		/*---------------------------------------------------------------------
220		* return match or NULL if more input needed.
221		*/
222
223		static struct vep_match *
224	492801	vep_match(const struct vep_state vep, const char b, const char *e)
225		{
226		struct vep_match *vm;
227		const char q, r;
228
229	492801	AN(vep->match);
230	3204600	for (vm = vep->match; vm->match != NULL; vm++) {
231	2767039	assert(strlen(vm->match) <= sizeof (vep->tag));
232	2767039	r = b;
233	3032309	for (q = vm->match; *q != '\0' && r < e; q++, r++)
234	2977069	if (q != r)
235	2711799	break;
236	2767039	if (*q == '\0')
237	45560	break;
238	2721479	if (r == e)
239	9680	return (NULL);
240	2711799	}
241	483121	return (vm);
242	492801	}
243
244		/*---------------------------------------------------------------------
245		*
246		*/
247
248		static void
249	39160	vep_emit_len(const struct vep_state *vep, ssize_t l, int m8, int m16, int m64)
250		{
251		uint8_t buf[9];
252
253	39160	assert(l > 0);
254	39160	if (l < 256) {
255	38480	buf[0] = (uint8_t)m8;
256	38480	buf[1] = (uint8_t)l;
257	38480	assert((ssize_t)buf[1] == l);
258	38480	VSB_bcat(vep->vsb, buf, 2);
259	39160	} else if (l < 65536) {
260	440	buf[0] = (uint8_t)m16;
261	440	vbe16enc(buf + 1, (uint16_t)l);
262	440	assert((ssize_t)vbe16dec(buf + 1) == l);
263	440	VSB_bcat(vep->vsb, buf, 3);
264	440	} else {
265	240	buf[0] = (uint8_t)m64;
266	240	vbe64enc(buf + 1, l);
267	240	assert((ssize_t)vbe64dec(buf + 1) == l);
268	240	VSB_bcat(vep->vsb, buf, 9);
269		}
270	39160	}
271
272		static void
273	17800	vep_emit_skip(const struct vep_state *vep, ssize_t l)
274		{
275
276	17800	vep_emit_len(vep, l, VEC_S1, VEC_S2, VEC_S8);
277	17800	}
278
279		static void
280	17320	vep_emit_verbatim(const struct vep_state *vep, ssize_t l, ssize_t l_crc)
281		{
282		uint8_t buf[4];
283
284	17320	vep_emit_len(vep, l, VEC_V1, VEC_V2, VEC_V8);
285	17320	if (vep->dogzip) {
286	4040	vep_emit_len(vep, l_crc, VEC_C1, VEC_C2, VEC_C8);
287	4040	vbe32enc(buf, vep->crc);
288	4040	VSB_bcat(vep->vsb, buf, sizeof buf);
289	4040	}
290	17320	}
291
292		static void
293	40720	vep_emit_common(struct vep_state *vep, ssize_t l, enum vep_mark mark)
294		{
295
296	40720	assert(l >= 0);
297	40720	if (l == 0)
298	5600	return;
299	35120	assert(mark == SKIP \|\| mark == VERBATIM);
300	35120	if (mark == SKIP)
301	17800	vep_emit_skip(vep, l);
302		else
303	17320	vep_emit_verbatim(vep, l, vep->o_crc);
304
305	35120	vep->crc = crc32(0L, Z_NULL, 0);
306	35120	vep->o_crc = 0;
307	35120	vep->o_total += l;
308	40720	}
309
310		/*---------------------------------------------------------------------
311		*
312		*/
313
314		static void
315	2648427	vep_mark_common(struct vep_state vep, const char p, enum vep_mark mark)
316		{
317		ssize_t l, lcb;
318
319	2648427	assert(mark == SKIP \|\| mark == VERBATIM);
320
321		/* The NO-OP case, no data, no pending data & no change of mode */
322	2648427	if (vep->last_mark == mark && p == vep->ver_p && vep->o_pending == 0)
323	1770	return;
324
325		/*
326		* If we changed mode, emit whatever the opposite mode
327		* assembled before the pending bytes.
328		*/
329
330	2646657	if (vep->last_mark != mark && (vep->o_wait > 0 \|\| vep->startup)) {
331	64400	lcb = vep->cb(vep->vc, vep->cb_priv, 0,
332	32200	mark == VERBATIM ? VGZ_RESET : VGZ_ALIGN);
333	32200	vep_emit_common(vep, lcb - vep->o_last, vep->last_mark);
334	32200	vep->o_last = lcb;
335	32200	vep->o_wait = 0;
336	32200	}
337
338		/* Transfer pending bytes CRC into active mode CRC */
339	2646657	if (vep->o_pending) {
340	2687	(void)vep->cb(vep->vc, vep->cb_priv, vep->o_pending,
341		VGZ_NORMAL);
342	2687	if (vep->o_crc == 0) {
343	2087	vep->crc = vep->crcp;
344	2087	vep->o_crc = vep->o_pending;
345	2087	} else {
346	1200	vep->crc = crc32_combine(vep->crc,
347	600	vep->crcp, vep->o_pending);
348	600	vep->o_crc += vep->o_pending;
349		}
350	2687	vep->crcp = crc32(0L, Z_NULL, 0);
351	2687	vep->o_wait += vep->o_pending;
352	2687	vep->o_pending = 0;
353	2687	}
354
355		/* * Process this bit of input */
356	2646657	AN(vep->ver_p);
357	2646657	l = p - vep->ver_p;
358	2646657	assert(l >= 0);
359	2646657	vep->crc = crc32(vep->crc, (const void*)vep->ver_p, l);
360	2646657	vep->o_crc += l;
361	2646657	vep->ver_p = p;
362
363	2646657	vep->o_wait += l;
364	2646657	vep->last_mark = mark;
365	2646657	(void)vep->cb(vep->vc, vep->cb_priv, l, VGZ_NORMAL);
366	2648427	}
367
368		static void
369	1528145	vep_mark_verbatim(struct vep_state vep, const char p)
370		{
371
372	1528145	vep_mark_common(vep, p, VERBATIM);
373	1528145	vep->nm_verbatim++;
374	1528145	}
375
376		static void
377	1111762	vep_mark_skip(struct vep_state vep, const char p)
378		{
379
380	1111762	vep_mark_common(vep, p, SKIP);
381	1111762	vep->nm_skip++;
382	1111762	}
383
384		static void
385	5000	vep_mark_pending(struct vep_state vep, const char p)
386		{
387		ssize_t l;
388
389	5000	AN(vep->ver_p);
390	5000	l = p - vep->ver_p;
391	5000	assert(l > 0);
392	5000	vep->crcp = crc32(vep->crcp, (const void *)vep->ver_p, l);
393	5000	vep->ver_p = p;
394
395	5000	vep->o_pending += l;
396	5000	vep->nm_pending++;
397	5000	}
398
399		/*---------------------------------------------------------------------
400		*/
401
402		static void v_matchproto_()
403	240	vep_do_comment(struct vep_state *vep, enum dowhat what)
404		{
405		Debug("DO_COMMENT(%d)\n", what);
406	240	assert(what == DO_TAG);
407	240	if (!vep->emptytag)
408	80	vep_error(vep, "ESI 1.0 <esi:comment> needs final '/'");
409	240	}
410
411		/*---------------------------------------------------------------------
412		*/
413
414		static void v_matchproto_()
415	5680	vep_do_remove(struct vep_state *vep, enum dowhat what)
416		{
417		Debug("DO_REMOVE(%d, end %d empty %d remove %d)\n",
418		what, vep->endtag, vep->emptytag, vep->remove);
419	5680	assert(what == DO_TAG);
420	5680	if (vep->emptytag)
421	40	vep_error(vep, "ESI 1.0 <esi:remove/> not legal");
422	5640	else if (vep->remove && !vep->endtag)
423	40	vep_error(vep, "ESI 1.0 <esi:remove> already open");
424	5600	else if (!vep->remove && vep->endtag)
425	40	vep_error(vep, "ESI 1.0 <esi:remove> not open");
426		else
427	5560	vep->remove = !vep->endtag;
428	5680	}
429
430		/*---------------------------------------------------------------------
431		*/
432
433		static void
434	10280	include_attr_src(struct vep_state *vep)
435		{
436		const char *p;
437
438	10280	if (vep->include_src != NULL) {
439	40	vep_error(vep,
440		"ESI 1.0 <esi:include> "
441		"has multiple src= attributes");
442	40	vep->state = VEP_TAGERROR;
443	40	VSB_destroy(&vep->attr_vsb);
444	40	VSB_destroy(&vep->include_src);
445	40	return;
446		}
447	369680	for (p = VSB_data(vep->attr_vsb); *p != '\0'; p++)
448	359480	if (vct_islws(*p))
449	40	break;
450	10240	if (*p != '\0') {
451	40	vep_error(vep,
452		"ESI 1.0 <esi:include> "
453		"has whitespace in src= attribute");
454	40	vep->state = VEP_TAGERROR;
455	40	VSB_destroy(&vep->attr_vsb);
456	40	if (vep->include_src != NULL)
457	0	VSB_destroy(&vep->include_src);
458	40	return;
459		}
460	10200	vep->include_src = vep->attr_vsb;
461	10200	vep->attr_vsb = NULL;
462	10280	}
463
464		static void
465	280	include_attr_onerror(struct vep_state *vep)
466		{
467
468	280	vep->include_continue = !strcmp("continue", VSB_data(vep->attr_vsb));
469	280	VSB_destroy(&vep->attr_vsb);
470	280	}
471
472		static void v_matchproto_()
473	20800	vep_do_include(struct vep_state *vep, enum dowhat what)
474		{
475		const char p, q, *h;
476		ssize_t l;
477		char incl;
478
479		Debug("DO_INCLUDE(%d)\n", what);
480	20800	if (what == DO_ATTR) {
481		Debug("ATTR (%s) (%s)\n", vep->match_hit->match,
482		VSB_data(vep->attr_vsb));
483	10560	if (!strcmp("src=", vep->match_hit->match)) {
484	10280	include_attr_src(vep);
485	10280	return;
486		}
487	280	if (!strcmp("onerror=", vep->match_hit->match)) {
488	280	include_attr_onerror(vep);
489	280	return;
490		}
491	0	WRONG("Unhandled <esi:include> attribute");
492	0	}
493	10240	assert(what == DO_TAG);
494	10240	if (!vep->emptytag)
495	80	vep_warn(vep, "ESI 1.0 <esi:include> lacks final '/'");
496	10240	if (vep->include_src == NULL) {
497	80	vep_error(vep, "ESI 1.0 <esi:include> lacks src attr");
498	80	return;
499		}