Code Coverage: vinyl-cache/bin/vinyld/cache/cache_esi_parse.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
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 Vinyl Esi Parsing
30
 */
31
32
#include "config.h"
33
34
#include "cache_int.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
        // flags from bereq
62
        struct vep_flags        flags;
63
64
        struct vsb              *vsb;
65
66
        const char              *url;
67
        struct vfp_ctx          *vc;
68
        int                     dogzip;
69
        vep_callback_t          *cb;
70
        void                    *cb_priv;
71
72
        /* Internal Counter for default call-back function */
73
        ssize_t                 cb_x;
74
75
        /* parser state */
76
        const char              *state;
77
        unsigned                startup;
78
        unsigned                esi_found;
79
80
        unsigned                endtag;
81
        unsigned                emptytag;
82
        unsigned                canattr;
83
84
        unsigned                remove;
85
86
        ssize_t                 o_wait;
87
        ssize_t                 o_pending;
88
        ssize_t                 o_total;
89
        uint32_t                crc;
90
        ssize_t                 o_crc;
91
        uint32_t                crcp;
92
        ssize_t                 o_last;
93
94
        const char              *hack_p;
95
        const char              *ver_p;
96
97
        const char              *until;
98
        const char              *until_p;
99
        const char              *until_s;
100
101
        int                     in_esi_tag;
102
103
        const char              *esicmt;
104
        const char              *esicmt_p;
105
106
        struct vep_match        *attr;
107
        struct vsb              *attr_vsb;
108
        int                     attr_delim;
109
110
        struct vep_match        *match;
111
        struct vep_match        *match_hit;
112
113
        char                    tag[8];
114
        int                     tag_i;
115
116
        dostuff_f               *dostuff;
117
118
        struct vsb              *include_src;
119
        unsigned                include_continue;
120
121
        unsigned                nm_skip;
122
        unsigned                nm_verbatim;
123
        unsigned                nm_pending;
124
        enum vep_mark           last_mark;
125
};
126
127
/*---------------------------------------------------------------------*/
128
129
static const char * const VEP_START =           "[Start]";
130
static const char * const VEP_BOM =             "[BOM]";
131
static const char * const VEP_TESTXML =         "[TestXml]";
132
static const char * const VEP_NOTXML =          "[NotXml]";
133
134
static const char * const VEP_NEXTTAG =         "[NxtTag]";
135
static const char * const VEP_NOTMYTAG =        "[NotMyTag]";
136
137
static const char * const VEP_STARTTAG =        "[StartTag]";
138
static const char * const VEP_COMMENTESI =      "[CommentESI]";
139
static const char * const VEP_COMMENT =         "[Comment]";
140
static const char * const VEP_CDATA =           "[CDATA]";
141
static const char * const VEP_ESITAG =          "[ESITag]";
142
static const char * const VEP_ESIENDTAG =       "[/ESITag]";
143
144
static const char * const VEP_ESIREMOVE =       "[ESI:Remove]";
145
static const char * const VEP_ESIINCLUDE =      "[ESI:Include]";
146
static const char * const VEP_ESICOMMENT =      "[ESI:Comment]";
147
static const char * const VEP_ESIBOGON =        "[ESI:Bogon]";
148
149
static const char * const VEP_INTAG =           "[InTag]";
150
static const char * const VEP_TAGERROR =        "[TagError]";
151
152
static const char * const VEP_ATTR =            "[Attribute]";
153
static const char * const VEP_SKIPATTR =        "[SkipAttribute]";
154
static const char * const VEP_ATTRDELIM =       "[AttrDelim]";
155
static const char * const VEP_ATTRGETVAL =      "[AttrGetValue]";
156
static const char * const VEP_ATTRVAL =         "[AttrValue]";
157
158
static const char * const VEP_UNTIL =           "[Until]";
159
static const char * const VEP_MATCHBUF =        "[MatchBuf]";
160
static const char * const VEP_MATCH =           "[Match]";
161
162
/*---------------------------------------------------------------------*/
163
164
static struct vep_match vep_match_starttag[] = {
165
        { "!--esi",     &VEP_COMMENTESI },
166
        { "!---->",     &VEP_NEXTTAG },
167
        { "!--",        &VEP_COMMENT },
168
        { "/esi:",      &VEP_ESIENDTAG },
169
        { "esi:",       &VEP_ESITAG },
170
        { "![CDATA[",   &VEP_CDATA },
171
        { NULL,         &VEP_NOTMYTAG }
172
};
173
174
/*---------------------------------------------------------------------*/
175
176
static struct vep_match vep_match_esi[] = {
177
        { "include",    &VEP_ESIINCLUDE },
178
        { "remove",     &VEP_ESIREMOVE },
179
        { "comment",    &VEP_ESICOMMENT },
180
        { NULL,         &VEP_ESIBOGON }
181
};
182
183
/*---------------------------------------------------------------------*/
184
185
static struct vep_match vep_match_attr_include[] = {
186
        { "src=",       &VEP_ATTRGETVAL },
187
        { "onerror=",   &VEP_ATTRGETVAL },
188
        { NULL,         &VEP_SKIPATTR }
189
};
190
191
/*---------------------------------------------------------------------*/
192
193
static struct vep_match vep_match_bom[] = {
194
        { "\xeb\xbb\xbf",       &VEP_START },
195
        { NULL,                 &VEP_BOM }
196
};
197
198
/*--------------------------------------------------------------------
199
 * Report a parsing error
200
 */
201
202
static void
203
vep_error(const struct vep_state *vep, const char *p)
204 37
{
205 37
        VSC_C_main->esi_errors++;
206 37
        VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, "ERR: after %zd %s",
207 37
             vep->o_last, p);
208 37
}
209
210
/*--------------------------------------------------------------------
211
 * Report a parsing warning
212
 */
213
214
static void
215
vep_warn(const struct vep_state *vep, const char *p)
216 6
{
217 6
        VSC_C_main->esi_warnings++;
218 6
        VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror, "WARN: after %zd %s",
219 6
             vep->o_last, p);
220 6
}
221
222
/*---------------------------------------------------------------------
223
 * return match or NULL if more input needed.
224
 */
225
226
static struct vep_match *
227
vep_match(const struct vep_state *vep, const char *b, const char *e)
228 24201
{
229 24201
        struct vep_match *vm;
230 24201
        const char *q, *r;
231
232 24201
        AN(vep->match);
233 107811
        for (vm = vep->match; vm->match != NULL; vm++) {
234 96934
                assert(vstrlen(vm->match) <= sizeof (vep->tag));
235 96934
                r = b;
236 162608
                for (q = vm->match; *q != '\0' && r < e; q++, r++)
237 149488
                        if (*q != *r)
238 83814
                                break;
239 96934
                if (*q == '\0')
240 13088
                        break;
241 83846
                if (r == e)
242 236
                        return (NULL);
243 83846
        }
244 23965
        return (vm);
245 24201
}
246
247
/*---------------------------------------------------------------------
248
 *
249
 */
250
251
static void
252
vep_emit_len(const struct vep_state *vep, ssize_t l, int m8, int m16, int m64)
253 7403
{
254 7403
        uint8_t buf[9];
255
256 7403
        assert(l > 0);
257 7403
        if (l < 256) {
258 7386
                buf[0] = (uint8_t)m8;
259 7386
                buf[1] = (uint8_t)l;
260 7386
                assert((ssize_t)buf[1] == l);
261 7386
                VSB_bcat(vep->vsb, buf, 2);
262 7386
        } else if (l < 65536) {
263 11
                buf[0] = (uint8_t)m16;
264 11
                vbe16enc(buf + 1, (uint16_t)l);
265 11
                assert((ssize_t)vbe16dec(buf + 1) == l);
266 11
                VSB_bcat(vep->vsb, buf, 3);
267 11
        } else {
268 6
                buf[0] = (uint8_t)m64;
269 6
                vbe64enc(buf + 1, l);
270 6
                assert((ssize_t)vbe64dec(buf + 1) == l);
271 6
                VSB_bcat(vep->vsb, buf, 9);
272 6
        }
273 7403
}
274
275
static void
276
vep_emit_skip(const struct vep_state *vep, ssize_t l)
277 4499
{
278
279 4499
        vep_emit_len(vep, l, VEC_S1, VEC_S2, VEC_S8);
280 4499
}
281
282
static void
283
vep_emit_verbatim(const struct vep_state *vep, ssize_t l, ssize_t l_crc)
284 2439
{
285 2439
        uint8_t buf[4];
286
287 2439
        vep_emit_len(vep, l, VEC_V1, VEC_V2, VEC_V8);
288 2439
        if (vep->dogzip) {
289 472
                vep_emit_len(vep, l_crc, VEC_C1, VEC_C2, VEC_C8);
290 472
                vbe32enc(buf, vep->crc);
291 472
                VSB_bcat(vep->vsb, buf, sizeof buf);
292 472
        }
293 2439
}
294
295
static void
296
vep_emit_common(struct vep_state *vep, ssize_t l, enum vep_mark mark)
297 7345
{
298
299 7345
        assert(l >= 0);
300 7345
        if (l == 0)
301 416
                return;
302 6929
        assert(mark == SKIP || mark == VERBATIM);
303 6929
        if (mark == SKIP)
304 4499
                vep_emit_skip(vep, l);
305 2430
        else
306 2430
                vep_emit_verbatim(vep, l, vep->o_crc);
307
308 6929
        vep->crc = crc32(0L, Z_NULL, 0);
309 6929
        vep->o_crc = 0;
310 6929
        vep->o_total += l;
311 6929
}
312
313
/*---------------------------------------------------------------------
314
 *
315
 */
316
317
static void
318
vep_mark_common(struct vep_state *vep, const char *p, enum vep_mark mark)
319 79064
{
320 79064
        ssize_t l, lcb;
321
322 79064
        assert(mark == SKIP || mark == VERBATIM);
323
324
        /* The NO-OP case, no data, no pending data & no change of mode */
325 79064
        if (vep->last_mark == mark && p == vep->ver_p && vep->o_pending == 0)
326 44
                return;
327
328
        /*
329
         * If we changed mode, emit whatever the opposite mode
330
         * assembled before the pending bytes.
331
         */
332
333 79020
        if (vep->last_mark != mark && (vep->o_wait > 0 || vep->startup)) {
334 6800
                lcb = vep->cb(vep->vc, vep->cb_priv, 0,
335 6800
                    mark == VERBATIM ? VGZ_RESET : VGZ_ALIGN);
336 6800
                vep_emit_common(vep, lcb - vep->o_last, vep->last_mark);
337 6800
                vep->o_last = lcb;
338 6800
                vep->o_wait = 0;
339 6800
        }
340
341
        /* Transfer pending bytes CRC into active mode CRC */
342 79020
        if (vep->o_pending) {
343 62
                (void)vep->cb(vep->vc, vep->cb_priv, vep->o_pending,
344 62
                     VGZ_NORMAL);
345 62
                if (vep->o_crc == 0) {
346 50
                        vep->crc = vep->crcp;
347 50
                        vep->o_crc = vep->o_pending;
348 50
                } else {
349 12
                        vep->crc = crc32_combine(vep->crc,
350 12
                            vep->crcp, vep->o_pending);
351 12
                        vep->o_crc += vep->o_pending;
352 12
                }
353 62
                vep->crcp = crc32(0L, Z_NULL, 0);
354 62
                vep->o_wait += vep->o_pending;
355 62
                vep->o_pending = 0;
356 62
        }
357
358
        /* * Process this bit of input */
359 79020
        AN(vep->ver_p);
360 79020
        l = p - vep->ver_p;
361 79020
        assert(l >= 0);
362 79020
        vep->crc = crc32(vep->crc, (const void*)vep->ver_p, l);
363 79020
        vep->o_crc += l;
364 79020
        vep->ver_p = p;
365
366 79020
        vep->o_wait += l;
367 79020
        vep->last_mark = mark;
368 79020
        (void)vep->cb(vep->vc, vep->cb_priv, l, VGZ_NORMAL);
369 79020
}
370
371
static void
372
vep_mark_verbatim(struct vep_state *vep, const char *p)
373 42438
{
374
375 42438
        vep_mark_common(vep, p, VERBATIM);
376 42438
        vep->nm_verbatim++;
377 42438
}
378
379
static void
380
vep_mark_skip(struct vep_state *vep, const char *p)
381 36096
{
382
383 36096
        vep_mark_common(vep, p, SKIP);
384 36096
        vep->nm_skip++;
385 36096
}
386
387
static void
388
vep_mark_pending(struct vep_state *vep, const char *p)
389 122
{
390 122
        ssize_t l;
391
392 122
        AN(vep->ver_p);
393 122
        l = p - vep->ver_p;
394 122
        assert(l > 0);
395 122
        vep->crcp = crc32(vep->crcp, (const void *)vep->ver_p, l);
396 122
        vep->ver_p = p;
397
398 122
        vep->o_pending += l;
399 122
        vep->nm_pending++;
400 122
}
401
402
/*---------------------------------------------------------------------
403
 */
404
405
static void v_matchproto_()
406
vep_do_comment(struct vep_state *vep, enum dowhat what)
407 6
{
408 6
        Debug("DO_COMMENT(%d)\n", what);
409 6
        assert(what == DO_TAG);
410 6
        if (!vep->emptytag)
411 2
                vep_error(vep, "ESI 1.0 <esi:comment> needs final '/'");
412 6
}
413
414
/*---------------------------------------------------------------------
415
 */
416
417
static void v_matchproto_()
418
vep_do_remove(struct vep_state *vep, enum dowhat what)
419 142
{
420 142
        Debug("DO_REMOVE(%d, end %d empty %d remove %d)\n",
421 142
            what, vep->endtag, vep->emptytag, vep->remove);
422 142
        assert(what == DO_TAG);
423 142
        if (vep->emptytag)
424 1
                vep_error(vep, "ESI 1.0 <esi:remove/> not legal");
425 141
        else if (vep->remove && !vep->endtag)
426 1
                vep_error(vep, "ESI 1.0 <esi:remove> already open");
427 140
        else if (!vep->remove && vep->endtag)
428 1
                vep_error(vep, "ESI 1.0 <esi:remove> not open");
429 139
        else
430 139
                vep->remove = !vep->endtag;
431 142
}
432
433
/*---------------------------------------------------------------------
434
 */
435
436
static void
437
include_attr_src(struct vep_state *vep)
438 4232
{
439 4232
        const char *p;
440
441 4232
        if (vep->include_src != NULL) {
442 1
                vep_error(vep,
443 1
                    "ESI 1.0 <esi:include> "
444 1
                    "has multiple src= attributes");
445 1
                vep->state = VEP_TAGERROR;
446 1
                VSB_destroy(&vep->attr_vsb);
447 1
                VSB_destroy(&vep->include_src);
448 1
                return;
449 1
        }
450 29090
        for (p = VSB_data(vep->attr_vsb); *p != '\0'; p++)
451 24860
                if (vct_islws(*p))
452 1
                        break;
453 4231
        if (*p != '\0') {
454 1
                vep_error(vep,
455 1
                    "ESI 1.0 <esi:include> "
456 1
                    "has whitespace in src= attribute");
457 1
                vep->state = VEP_TAGERROR;
458 1
                VSB_destroy(&vep->attr_vsb);
459 1
                if (vep->include_src != NULL)
460 0
                        VSB_destroy(&vep->include_src);
461 1
                return;
462 1
        }
463 4230
        vep->include_src = vep->attr_vsb;
464 4230
        vep->attr_vsb = NULL;
465 4230
}
466
467
static void
468
include_attr_onerror(struct vep_state *vep)
469 9
{
470
471 9
        vep->include_continue = !vstrcmp("continue", VSB_data(vep->attr_vsb));
472 9
        VSB_destroy(&vep->attr_vsb);
473 9
}
474
475
static void v_matchproto_()
476
vep_do_include(struct vep_state *vep, enum dowhat what)
477 8473
{
478 8473
        const char *p, *q, *h;
479 8473
        ssize_t l;
480 8473
        char incl;
481
482 8473
        Debug("DO_INCLUDE(%d)\n", what);
483 8473
        if (what == DO_ATTR) {
484 4239
                Debug("ATTR (%s) (%s)\n", vep->match_hit->match,
485 4239
                        VSB_data(vep->attr_vsb));
486 4239
                if (!vstrcmp("src=", vep->match_hit->match)) {
487 4230
                        include_attr_src(vep);
488 4230
                        return;
489 4230
                }
490 9
                if (!vstrcmp("onerror=", vep->match_hit->match)) {
491 9
                        include_attr_onerror(vep);
492 9
                        return;
493 9
                }
494 0
                WRONG("Unhandled <esi:include> attribute");
495 0
        }
496 4234
        assert(what == DO_TAG);
497 4234
        if (!vep->emptytag)
498 2
                vep_warn(vep, "ESI 1.0 <esi:include> lacks final '/'");
499 4234
        if (vep->include_src == NULL) {
500 2
                vep_error(vep, "ESI 1.0 <esi:include> lacks src attr");
501 2
                return;
502 2
        }
503
504
        /*
505
         * Strictly speaking, we ought to spit out any piled up skip before
506
         * emitting the VEC for the include, but objectively that makes no
507
         * difference and robs us of a chance to collapse another skip into
508
         * this on so we don't do that.
509
         * However, we cannot tolerate any verbatim stuff piling up.
510
         * The mark_skip() before calling dostuff should have taken
511
         * care of that.  Make sure.
512
         */
513 4232
        assert(vep->o_wait == 0 || vep->last_mark == SKIP);
514
        /* XXX: what if it contains NUL bytes ?? */
515 4232
        p = VSB_data(vep->include_src);
516 4232
        l = VSB_len(vep->include_src);
517 4232
        h = 0;
518
519 4232
        incl = vep->include_continue ? VEC_IC : VEC_IA;
520
521 4232
        if (l > 7 && !vmemcmp(p, "http://", 7)) {
522 3
                h = p + 7;
523 3
                p = strchr(h, '/');
524 3
                if (p == NULL) {
525 2
                        vep_error(vep,
526 2
                            "ESI 1.0 <esi:include> invalid src= URL");
527 2
                        vep->state = VEP_TAGERROR;
528 2
                        AZ(vep->attr_vsb);
529 2
                        VSB_destroy(&vep->include_src);
530 2
                        return;
531 2
                }
532 1
                Debug("HOST <%.*s> PATH <%s>\n", (int)(p-h),h, p);
533 1
                VSB_printf(vep->vsb, "%c", incl);
534 1
                VSB_printf(vep->vsb, "Host: %.*s%c", (int)(p-h), h, 0);
535 4229
        } else if (l > 8 && !vmemcmp(p, "https://", 8)) {
536 4
                if (!vep->flags.esi_ignore_https) {
537 1
                        vep_warn(vep,
538 1
                            "ESI 1.0 <esi:include> with https:// ignored");
539 1
                        vep->state = VEP_TAGERROR;
540 1
                        AZ(vep->attr_vsb);
541 1
                        VSB_destroy(&vep->include_src);
542 1
                        return;
543 1
                }
544 3
                vep_warn(vep,
545 3
                    "ESI 1.0 <esi:include> https:// treated as http://");
546 3
                h = p + 8;
547 3
                p = strchr(h, '/');
548 3
                if (p == NULL) {
549 2
                        vep_error(vep,
550 2
                            "ESI 1.0 <esi:include> invalid src= URL");
551 2
                        vep->state = VEP_TAGERROR;
552 2
                        AZ(vep->attr_vsb);
553 2
                        VSB_destroy(&vep->include_src);
554 2
                        return;
555 2
                }
556 1
                VSB_printf(vep->vsb, "%c", incl);
557 1
                VSB_printf(vep->vsb, "Host: %.*s%c", (int)(p-h), h, 0);
558 4225
        } else if (*p == '/') {
559 4186
                VSB_printf(vep->vsb, "%c", incl);
560 4186
                VSB_printf(vep->vsb, "%c", 0);
561 4186
        } else {
562 39
                VSB_printf(vep->vsb, "%c", incl);
563 39
                VSB_printf(vep->vsb, "%c", 0);
564
                /* Look for the last / before a '?' */
565 39
                h = NULL;
566 105
                for (q = vep->url; *q && *q != '?'; q++)
567 66
                        if (*q == '/')
568 35
                                h = q;
569 39
                if (h == NULL)
570 0
                        h = q + 1;
571
572 39
                Debug("INCL:: [%.*s]/[%s]\n",
573 39
                    (int)(h - vep->url), vep->url, p);
574 39
                VSB_printf(vep->vsb, "%.*s/", (int)(h - vep->url), vep->url);
575 39
        }
576 4227
        l -= (p - VSB_data(vep->include_src));
577 28878
        for (q = p; *q != '\0'; ) {
578 24651
                if (*q == '&') {
579 10
#define R(w,f,r)                                                        \
580 30
                        if (q + w <= p + l && !vmemcmp(q, f, w)) { \
581 10
                                VSB_printf(vep->vsb, "%c", r);  \
582 10
                                q += w;                         \
583 10
                                continue;                       \
584 10
                        }
585 10
                        R(6, "&apos;", '\'');
586 8
                        R(6, "&quot;", '"');
587 6
                        R(4, "&lt;", '<');
588 4
                        R(4, "&gt;", '>');
589 2
                        R(5, "&amp;", '&');
590 0
                }
591 24641
                VSB_printf(vep->vsb, "%c", *q++);
592 24641
        }
593 4227
#undef R
594 4227
        VSB_printf(vep->vsb, "%c", 0);
595 4227
        VSB_destroy(&vep->include_src);
596 4227
        vep->include_continue = 0;
597 4227
}
598
599
/*---------------------------------------------------------------------
600
 * Lex/Parse object for ESI instructions
601
 *
602
 * This function is called with the input object piecemeal so do not
603
 * assume that we have more than one char available at at time, but
604
 * optimize for getting huge chunks.
605
 *
606
 * NB: At the bottom of this source-file, there is a dot-diagram matching
607
 * NB: the state-machine.  Please maintain it along with the code.
608
 */
609
610
void
611
VEP_Parse(struct vep_state *vep, const char *p, size_t l)
612 54032
{
613 54032
        const char *e;
614 54032
        struct vep_match *vm;
615 54032
        int i;
616
617 54032
        CHECK_OBJ_NOTNULL(vep, VEP_MAGIC);
618 54032
        assert(l > 0);
619
620 54032
        if (vep->startup) {
621
                /*
622
                 * We must force the GZIP header out as a SKIP string,
623
                 * otherwise an object starting with <esi:include would
624
                 * have its GZIP header appear after the included object
625
                 * (e000026.vtc)
626
                 */
627 555
                vep->ver_p = "";
628 555
                vep->last_mark = SKIP;
629 555
                vep_mark_common(vep, vep->ver_p, VERBATIM);
630 555
                vep->startup = 0;
631 555
                AZ(vep->hack_p);
632 555
                vep->hack_p = p;
633 555
        }
634
635 54032
        vep->ver_p = p;
636
637 54032
        e = p + l;
638
639 209225
        while (p < e) {
640 154220
                AN(vep->state);
641 154220
                Debug("EP %s %d (%.*s) [%.*s]\n",
642 154220
                    vep->state,
643 154220
                    vep->remove,
644 154220
                    vep->tag_i, vep->tag,
645 154220
                    (e - p) > 10 ? 10 : (int)(e-p), p);
646 154220
                assert(p >= vep->ver_p);
647
648
                /******************************************************
649
                 * SECTION A
650
                 */
651
652 154220
                if (vep->state == VEP_START) {
653 558
                        if (vep->flags.esi_remove_bom &&
654 558
                            *p == (char)0xeb) {
655 4
                                vep->match = vep_match_bom;
656 4
                                vep->state = VEP_MATCH;
657 4
                        } else
658 554
                                vep->state = VEP_BOM;
659 153662
                } else if (vep->state == VEP_BOM) {
660 554
                        vep_mark_skip(vep, p);
661 554
                        if (vep->flags.esi_disable_xml_check)
662 56
                                vep->state = VEP_NEXTTAG;
663 498
                        else
664 498
                                vep->state = VEP_TESTXML;
665 153108
                } else if (vep->state == VEP_TESTXML) {
666
                        /*
667
                         * If the first non-whitespace char is different
668
                         * from '<' we assume this is not XML.
669
                         */
670 714
                        while (p < e && vct_islws(*p))
671 206
                                p++;
672 508
                        vep_mark_verbatim(vep, p);
673 508
                        if (p < e && *p == '<') {
674 484
                                p++;
675 484
                                vep->state = VEP_STARTTAG;
676 484
                        } else if (p < e && *p == (char)0xeb) {
677 2
                                VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror,
678 2
                                    "WARN: No ESI processing, "
679 2
                                    "first char not '<' but BOM."
680 2
                                    " (See feature esi_remove_bom)"
681 2
                                );
682 2
                                vep->state = VEP_NOTXML;
683 22
                        } else if (p < e) {
684 11
                                VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror,
685 11
                                    "WARN: No ESI processing, "
686 11
                                    "first char not '<'."
687 11
                                    " (See feature esi_disable_xml_check)"
688 11
                                );
689 11
                                vep->state = VEP_NOTXML;
690 11
                        }
691 152600
                } else if (vep->state == VEP_NOTXML) {
692
                        /*
693
                         * This is not recognized as XML, just skip thru
694
                         * vfp_esi_end() will handle the rest
695
                         */
696 13
                        p = e;
697 13
                        vep_mark_verbatim(vep, p);
698
699
                /******************************************************
700
                 * SECTION B
701
                 */
702
703 152587
                } else if (vep->state == VEP_NOTMYTAG) {
704 10985
                        if (vep->flags.esi_ignore_other_elements) {
705 2
                                p++;
706 2
                                vep->state = VEP_NEXTTAG;
707 10983
                        } else {
708 10983
                                vep->tag_i = 0;
709 46568
                                while (p < e) {
710 46528
                                        if (*p++ == '>') {
711 10943
                                                vep->state = VEP_NEXTTAG;
712 10943
                                                break;
713 10943
                                        }
714 46528
                                }
715 10983
                        }
716 10985
                        if (p == e && !vep->remove)
717 103
                                vep_mark_verbatim(vep, p);
718 141602
                } else if (vep->state == VEP_NEXTTAG) {
719
                        /*
720
                         * Hunt for start of next tag and keep an eye
721
                         * out for end of EsiCmt if armed.
722
                         */
723 68293
                        vep->emptytag = 0;
724 68293
                        vep->attr = NULL;
725 68293
                        vep->dostuff = NULL;
726 2233096
                        while (p < e && *p != '<') {
727 2164803
                                if (vep->esicmt_p == NULL) {
728 2164687
                                        p++;
729 2164687
                                        continue;
730 2164687
                                }
731 116
                                if (*p != *vep->esicmt_p) {
732 66
                                        p++;
733 66
                                        vep->esicmt_p = vep->esicmt;
734 66
                                        continue;
735 66
                                }
736 50
                                if (!vep->remove && vep->esicmt_p == vep->esicmt)
737 12
                                        vep_mark_verbatim(vep, p);
738 50
                                p++;
739 50
                                if (*++vep->esicmt_p == '\0') {
740 16
                                        vep->esi_found = 1;
741 16
                                        vep->esicmt = NULL;
742 16
                                        vep->esicmt_p = NULL;
743
                                        /*
744
                                         * The end of the esicmt
745
                                         * should not be emitted.
746
                                         * But the stuff before should
747
                                         */
748 16
                                        vep_mark_skip(vep, p);
749 16
                                }
750 50
                        }
751 68293
                        if (p < e) {
752 14901
                                if (!vep->remove)
753 14818
                                        vep_mark_verbatim(vep, p);
754 14901
                                assert(*p == '<');
755 14901
                                p++;
756 14901
                                vep->state = VEP_STARTTAG;
757 53392
                        } else if (vep->esicmt_p == vep->esicmt && !vep->remove)
758 26968
                                vep_mark_verbatim(vep, p);
759
760
                /******************************************************
761
                 * SECTION C
762
                 */
763
764 73309
                } else if (vep->state == VEP_STARTTAG) {
765
                        /* Start of tag, set up match table */
766 15372
                        vep->endtag = 0;
767 15372
                        vep->match = vep_match_starttag;
768 15372
                        vep->state = VEP_MATCH;
769 57937
                } else if (vep->state == VEP_COMMENT) {
770 5
                        vep->esicmt_p = vep->esicmt = NULL;
771 5
                        vep->until_p = vep->until = "-->";
772 5
                        vep->until_s = VEP_NEXTTAG;
773 5
                        vep->state = VEP_UNTIL;
774 57932
                } else if (vep->state == VEP_COMMENTESI) {
775 17
                        if (vep->remove)
776 5
                                vep_error(vep,
777 5
                                    "ESI 1.0 Nested <!--esi"
778 5
                                    " element in <esi:remove>");
779 17
                        vep->esicmt_p = vep->esicmt = "-->";
780 17
                        vep->state = VEP_NEXTTAG;
781 17
                        vep_mark_skip(vep, p);
782 57915
                } else if (vep->state == VEP_CDATA) {
783
                        /*
784
                         * Easy: just look for the end of CDATA
785
                         */
786 4
                        vep->until_p = vep->until = "]]>";
787 4
                        vep->until_s = VEP_NEXTTAG;
788 4
                        vep->state = VEP_UNTIL;
789 57911
                } else if (vep->state == VEP_ESIENDTAG) {
790 73
                        vep->endtag = 1;
791 73
                        vep->state = VEP_ESITAG;
792 57838
                } else if (vep->state == VEP_ESITAG) {
793 4410
                        vep->in_esi_tag = 1;
794 4410
                        vep->esi_found = 1;
795 4410
                        vep_mark_skip(vep, p);
796 4410
                        vep->match = vep_match_esi;
797 4410
                        vep->state = VEP_MATCH;
798 53428
                } else if (vep->state == VEP_ESIINCLUDE) {
799 4248
                        if (vep->remove) {
800 4
                                vep_error(vep,
801 4
                                    "ESI 1.0 <esi:include> element"
802 4
                                    " nested in <esi:remove>");
803 4
                                vep->state = VEP_TAGERROR;
804 4244
                        } else if (vep->endtag) {
805 1
                                vep_error(vep,
806 1
                                    "ESI 1.0 </esi:include> illegal end-tag");
807 1
                                vep->state = VEP_TAGERROR;
808 4243
                        } else {
809 4243
                                vep->dostuff = vep_do_include;
810 4243
                                vep->state = VEP_INTAG;
811 4243
                                vep->attr = vep_match_attr_include;
812 4243
                        }
813 49180
                } else if (vep->state == VEP_ESIREMOVE) {
814 142
                        vep->dostuff = vep_do_remove;
815 142
                        vep->state = VEP_INTAG;
816 49038
                } else if (vep->state == VEP_ESICOMMENT) {
817 10
                        if (vep->remove) {
818 1
                                vep_error(vep,
819 1
                                    "ESI 1.0 <esi:comment> element"
820 1
                                    " nested in <esi:remove>");
821 1
                                vep->state = VEP_TAGERROR;
822 9
                        } else if (vep->endtag) {
823 2
                                vep_error(vep,
824 2
                                    "ESI 1.0 </esi:comment> illegal end-tag");
825 2
                                vep->state = VEP_TAGERROR;
826 7
                        } else {
827 7
                                vep->dostuff = vep_do_comment;
828 7
                                vep->state = VEP_INTAG;
829 7
                        }
830 49028
                } else if (vep->state == VEP_ESIBOGON) {
831 2
                        vep_error(vep,
832 2
                            "ESI 1.0 <esi:bogus> element");
833 2
                        vep->state = VEP_TAGERROR;
834
835
                /******************************************************
836
                 * SECTION D
837
                 */
838
839 49026
                } else if (vep->state == VEP_INTAG) {
840 8651
                        vep->tag_i = 0;
841 13019
                        while (p < e && vct_islws(*p) && !vep->emptytag) {
842 4368
                                p++;
843 4368
                                vep->canattr = 1;
844 4368
                        }
845 8651
                        if (p < e && *p == '/' && !vep->emptytag) {
846 4230
                                p++;
847 4230
                                vep->emptytag = 1;
848 4230
                                vep->canattr = 0;
849 4230
                        }
850 8651
                        if (p < e && *p == '>') {
851 4375
                                p++;
852 4375
                                AN(vep->dostuff);
853 4375
                                vep_mark_skip(vep, p);
854 4375
                                vep->dostuff(vep, DO_TAG);
855 4375
                                vep->in_esi_tag = 0;
856 4375
                                vep->state = VEP_NEXTTAG;
857 4375
                        } else if (p < e && vep->emptytag) {
858 1
                                vep_error(vep,
859 1
                                    "XML 1.0 '>' does not follow '/' in tag");
860 1
                                vep->state = VEP_TAGERROR;
861 4275
                        } else if (p < e && vep->canattr &&
862 4275
                            vct_isxmlnamestart(*p)) {
863 4257
                                vep->state = VEP_ATTR;
864 4257
                        } else if (p < e) {
865 1
                                vep_error(vep,
866 1
                                    "XML 1.0 Illegal attribute start char");
867 1
                                vep->state = VEP_TAGERROR;
868 1
                        }
869 40375
                } else if (vep->state == VEP_TAGERROR) {
870 180
                        while (p < e && *p != '>')
871 130
                                p++;
872 50
                        if (p < e) {
873 18
                                p++;
874 18
                                vep_mark_skip(vep, p);
875 18
                                vep->in_esi_tag = 0;
876 18
                                vep->state = VEP_NEXTTAG;
877 18
                                if (vep->attr_vsb)
878 1
                                        VSB_destroy(&vep->attr_vsb);
879 18
                        }
880
881
                /******************************************************
882
                 * SECTION E
883
                 */
884
885 40325
                } else if (vep->state == VEP_ATTR) {
886 4249
                        AZ(vep->attr_delim);
887 4249
                        if (vep->attr == NULL) {
888 3
                                p++;
889 3
                                AZ(vep->attr_vsb);
890 3
                                vep->state = VEP_SKIPATTR;
891 4246
                        } else {
892 4246
                                vep->match = vep->attr;
893 4246
                                vep->state = VEP_MATCH;
894 4246
                        }
895 36076
                } else if (vep->state == VEP_SKIPATTR) {
896 50
                        while (p < e && vct_isxmlname(*p))
897 30
                                p++;
898 20
                        if (p < e && *p == '=') {
899 9
                                p++;
900 9
                                vep->state = VEP_ATTRDELIM;
901 11
                        } else if (p < e && *p == '>') {
902 1
                                vep->state = VEP_INTAG;
903 10
                        } else if (p < e && *p == '/') {
904 1
                                vep->state = VEP_INTAG;
905 9
                        } else if (p < e && vct_issp(*p)) {
906 2
                                vep->state = VEP_INTAG;
907 7
                        } else if (p < e) {
908 1
                                vep_error(vep,
909 1
                                    "XML 1.0 Illegal attr char");
910 1
                                vep->state = VEP_TAGERROR;
911 1
                        }
912 36056
                } else if (vep->state == VEP_ATTRGETVAL) {
913 4252
                        AZ(vep->attr_vsb);
914 4252
                        vep->attr_vsb = VSB_new_auto();
915 4252
                        vep->state = VEP_ATTRDELIM;
916 31804
                } else if (vep->state == VEP_ATTRDELIM) {
917 4259
                        AZ(vep->attr_delim);
918 4259
                        if (*p == '"' || *p == '\'') {
919 4256
                                vep->attr_delim = *p++;
920 4256
                                vep->state = VEP_ATTRVAL;
921 4256
                        } else if (!vct_issp(*p)) {
922 3
                                vep->attr_delim = ' ';
923 3
                                vep->state = VEP_ATTRVAL;
924 3
                        } else {
925 0
                                vep_error(vep,
926 0
                                    "XML 1.0 Illegal attribute delimiter");
927 0
                                vep->state = VEP_TAGERROR;
928 0
                        }
929
930 27545
                } else if (vep->state == VEP_ATTRVAL) {
931 29297
                        while (p < e && *p != '>' && *p != vep->attr_delim &&
932 29281
                           (vep->attr_delim != ' ' || !vct_issp(*p))) {
933 24987
                                if (vep->attr_vsb != NULL)
934 24896
                                        VSB_putc(vep->attr_vsb, *p);
935 24987
                                p++;
936 24987
                        }
937 4294
                        if (p < e && *p == '>') {
938 2
                                vep_error(vep,
939 2
                                    "XML 1.0 Missing end attribute delimiter");
940 2
                                vep->state = VEP_TAGERROR;
941 2
                                vep->attr_delim = 0;
942 2
                                if (vep->attr_vsb != NULL) {
943 2
                                        AZ(VSB_finish(vep->attr_vsb));
944 2
                                        VSB_destroy(&vep->attr_vsb);
945 2
                                }
946 4292
                        } else if (p < e) {
947 4260
                                vep->attr_delim = 0;
948 4260
                                p++;
949 4260
                                vep->state = VEP_INTAG;
950 4260
                                if (vep->attr_vsb != NULL) {
951 4251
                                        AZ(VSB_finish(vep->attr_vsb));
952 4251
                                        AN(vep->dostuff);
953 4251
                                        vep->dostuff(vep, DO_ATTR);
954 4251
                                        vep->attr_vsb = NULL;
955 4251
                                }
956 4260
                        }
957
958
                /******************************************************
959
                 * Utility Section
960
                 */
961
962 23965
                } else if (vep->state == VEP_MATCH) {
963
                        /*
964
                         * Match against a table
965
                         */
966 23965
                        vm = vep_match(vep, p, e);
967 23965
                        vep->match_hit = vm;
968 23965
                        if (vm != NULL) {
969 23883
                                if (vm->match != NULL)
970 12919
                                        p += vstrlen(vm->match);
971 23883
                                vep->state = *vm->state;
972 23883
                                vep->match = NULL;
973 23883
                                vep->tag_i = 0;
974 23883
                        } else {
975 82
                                assert(p + sizeof(vep->tag) >= e);
976 82
                                vmemcpy(vep->tag, p, e - p);
977 82
                                vep->tag_i = e - p;
978 82
                                vep->state = VEP_MATCHBUF;
979 82
                                p = e;
980 82
                        }
981 18446744073709550902
                } else if (vep->state == VEP_MATCHBUF) {
982
                        /*
983
                         * Match against a table while split over input
984
                         * sections.
985
                         */
986 236
                        AN(vep->match);
987 236
                        i = sizeof(vep->tag) - vep->tag_i;
988 236
                        if (i > e - p)
989 195
                                i = e - p;
990 236
                        vmemcpy(vep->tag + vep->tag_i, p, i);
991 236
                        vm = vep_match(vep, vep->tag,
992 236
                            vep->tag + vep->tag_i + i);
993 236
                        Debug("MB (%.*s) tag_i %d i %d = vm %p match %s\n",
994 236
                            vep->tag_i + i, vep->tag,
995 236
                            vep->tag_i,
996 236
                            i,
997 236
                            vm,
998 236
                            vm ? vm->match : "(nil)");
999
1000 236
                        if (vm == NULL) {
1001 101
                                vep->tag_i += i;
1002 101
                                p += i;
1003 101
                                assert(p == e);
1004 135
                        } else {
1005 135
                                vep->match_hit = vm;
1006 135
                                vep->state = *vm->state;
1007 135
                                if (vm->match != NULL) {
1008 130
                                        i = vstrlen(vm->match);
1009 130
                                        if (i > vep->tag_i)
1010 129
                                                p += i - vep->tag_i;
1011 130
                                }
1012 135
                                vep->match = NULL;
1013 135
                                vep->tag_i = 0;
1014 135
                        }
1015 18446744073709550666
                } else if (vep->state == VEP_UNTIL) {
1016
                        /*
1017
                         * Skip until we see magic string
1018
                         */
1019 185
                        while (p < e) {
1020 169
                                if (*p++ != *vep->until_p++) {
1021 146
                                        vep->until_p = vep->until;
1022 146
                                } else if (*vep->until_p == '\0') {
1023 7
                                        vep->state = vep->until_s;
1024 7
                                        break;
1025 7
                                }
1026 169
                        }
1027 23
                        if (p == e && !vep->remove)
1028 18
                                vep_mark_verbatim(vep, p);
1029 18446744073709550643
                } else {
1030 18446744073709550643
                        Debug("*** Unknown state %s\n", vep->state);
1031 18446744073709550643
                        WRONG("WRONG ESI PARSER STATE");
1032 18446744073709550643
                }
1033 154220
        }
1034
        /*
1035
         * We must always mark up the storage we got, try to do so
1036
         * in the most efficient way, in particular with respect to
1037
         * minimizing and limiting use of pending.
1038
         */
1039 55005
        if (p == vep->ver_p)
1040 27175
                ;
1041 27830
        else if (vep->in_esi_tag)
1042 281
                vep_mark_skip(vep, p);
1043 27549
        else if (vep->remove)
1044 26454
                vep_mark_skip(vep, p);
1045 1095
        else
1046 1095
                vep_mark_pending(vep, p);
1047 55005
}
1048
1049
/*---------------------------------------------------------------------
1050
 */
1051
1052
static ssize_t v_matchproto_(vep_callback_t)
1053
vep_default_cb(struct vfp_ctx *vc, void *priv, ssize_t l, enum vgz_flag flg)
1054 82171
{
1055 82171
        ssize_t *s;
1056
1057 82171
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
1058 82171
        AN(priv);
1059 82171
        s = priv;
1060 82171
        *s += l;
1061 82171
        (void)flg;
1062 82171
        return (*s);
1063 82171
}
1064
1065
/*---------------------------------------------------------------------
1066
 */
1067
1068
struct vep_state *
1069
VEP_Init(struct vfp_ctx *vc, const struct http *req, vep_callback_t *cb,
1070
    void *cb_priv, struct vep_flags flags)
1071 611
{
1072 611
        struct vep_state *vep;
1073
1074 611
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
1075 611
        CHECK_OBJ_NOTNULL(req, HTTP_MAGIC);
1076 611
        vep = WS_Alloc(vc->resp->ws, sizeof *vep);
1077 611
        if (vep == NULL) {
1078 52
                VSLb(vc->wrk->vsl, SLT_VCL_Error,
1079 52
                     "VEP_Init() workspace overflow");
1080 52
                return (NULL);
1081 52
        }
1082
1083 559
        INIT_OBJ(vep, VEP_MAGIC);
1084 559
        vep->flags = flags;
1085 559
        vep->url = req->hd[HTTP_HDR_URL].b;
1086 559
        vep->vc = vc;
1087 559
        vep->vsb = VSB_new_auto();
1088 559
        AN(vep->vsb);
1089
1090 559
        if (cb != NULL) {
1091 142
                vep->dogzip = 1;
1092
                /* XXX */
1093 142
                VSB_printf(vep->vsb, "%c", VEC_GZ);
1094 142
                vep->cb = cb;
1095 142
                vep->cb_priv = cb_priv;
1096 417
        } else {
1097 417
                vep->cb = vep_default_cb;
1098 417
                vep->cb_priv = &vep->cb_x;
1099 417
        }
1100
1101 559
        vep->state = VEP_START;
1102 559
        vep->crc = crc32(0L, Z_NULL, 0);
1103 559
        vep->crcp = crc32(0L, Z_NULL, 0);
1104
1105 559
        vep->startup = 1;
1106 559
        return (vep);
1107 559
}
1108
1109
/*---------------------------------------------------------------------
1110
 */
1111
1112
struct vsb *
1113
VEP_Finish(struct vep_state *vep)
1114 559
{
1115 559
        ssize_t l, lcb;
1116
1117 559
        CHECK_OBJ_NOTNULL(vep, VEP_MAGIC);
1118
1119 559
        if (vep->include_src)
1120 0
                VSB_destroy(&vep->include_src);
1121 559
        if (vep->attr_vsb)
1122 0
                VSB_destroy(&vep->attr_vsb);
1123
1124 559
        if (vep->state != VEP_START &&
1125 559
            vep->state != VEP_BOM &&
1126 559
            vep->state != VEP_TESTXML &&
1127 559
            vep->state != VEP_NOTXML &&
1128 559
            vep->state != VEP_NEXTTAG) {
1129 3
                vep_error(vep, "VEP ended inside a tag");
1130 3
        }
1131
1132 559
        if (vep->o_pending)
1133 0
                vep_mark_common(vep, vep->ver_p, vep->last_mark);
1134 559
        if (vep->o_wait > 0) {
1135 555
                lcb = vep->cb(vep->vc, vep->cb_priv, 0, VGZ_ALIGN);
1136 555
                vep_emit_common(vep, lcb - vep->o_last, vep->last_mark);
1137 555
        }
1138
        // NB: We don't account for PAD+SUM+LEN in gzipped objects
1139 559
        (void)vep->cb(vep->vc, vep->cb_priv, 0, VGZ_FINISH);
1140
1141 559
        AZ(VSB_finish(vep->vsb));
1142 559
        l = VSB_len(vep->vsb);
1143 559
        if (vep->esi_found && l > 0)
1144 458
                return (vep->vsb);
1145 101
        VSB_destroy(&vep->vsb);
1146
        return (NULL);
1147 559
}
1148
1149
#if 0
1150
1151
digraph xml {
1152
        rankdir="LR"
1153
        size="7,10"
1154
#################################################################
1155
# SECTION A
1156
#
1157
1158
START           [shape=ellipse]
1159
TESTXML         [shape=ellipse]
1160
NOTXML          [shape=ellipse]
1161
NEXTTAGa        [shape=hexagon, label="NEXTTAG"]
1162
STARTTAGa       [shape=hexagon, label="STARTTAG"]
1163
START           -> TESTXML
1164
START           -> NEXTTAGa     [style=dotted, label="syntax:1"]
1165
TESTXML         -> TESTXML      [label="lws"]
1166
TESTXML         -> NOTXML
1167
TESTXML         -> STARTTAGa    [label="'<'"]
1168
1169
#################################################################
1170
# SECTION B
1171
1172
NOTMYTAG        [shape=ellipse]
1173
NEXTTAG         [shape=ellipse]
1174
NOTMYTAG        -> NEXTTAG      [style=dotted, label="syntax:2"]
1175
STARTTAGb       [shape=hexagon, label="STARTTAG"]
1176
NOTMYTAG        -> NEXTTAG      [label="'>'"]
1177
NOTMYTAG        -> NOTMYTAG     [label="*"]
1178
NEXTTAG         -> NEXTTAG      [label="'-->'"]
1179
NEXTTAG         -> NEXTTAG      [label="*"]
1180
NEXTTAG         -> STARTTAGb    [label="'<'"]
1181
1182
#################################################################
1183
# SECTION C
1184
1185
STARTTAG        [shape=ellipse]
1186
COMMENT         [shape=ellipse]
1187
CDATA           [shape=ellipse]
1188
ESITAG          [shape=ellipse]
1189
ESIETAG         [shape=ellipse]
1190
ESIINCLUDE      [shape=ellipse]
1191
ESIREMOVE       [shape=ellipse]
1192
ESICOMMENT      [shape=ellipse]
1193
ESIBOGON        [shape=ellipse]
1194
INTAGc          [shape=hexagon, label="INTAG"]
1195
NOTMYTAGc       [shape=hexagon, label="NOTMYTAG"]
1196
NEXTTAGc        [shape=hexagon, label="NEXTTAG"]
1197
TAGERRORc       [shape=hexagon, label="TAGERROR"]
1198
C1              [shape=circle,label=""]
1199
STARTTAG        -> COMMENT      [label="'<!--'"]
1200
STARTTAG        -> ESITAG       [label="'<esi'"]
1201
STARTTAG        -> CDATA        [label="'<![CDATA['"]
1202
STARTTAG        -> NOTMYTAGc    [label="'*'"]
1203
COMMENT         -> NEXTTAGc     [label="'esi'"]
1204
COMMENT         -> C1           [label="*"]
1205
C1              -> C1           [label="*"]
1206
C1              -> NEXTTAGc     [label="-->"]
1207
CDATA           -> CDATA        [label="*"]
1208
CDATA           -> NEXTTAGc     [label="]]>"]
1209
ESITAG          -> ESIINCLUDE   [label="'include'"]
1210
ESITAG          -> ESIREMOVE    [label="'remove'"]
1211
ESITAG          -> ESICOMMENT   [label="'comment'"]
1212
ESITAG          -> ESIBOGON     [label="*"]
1213
ESICOMMENT      -> INTAGc
1214
ESICOMMENT      -> TAGERRORc
1215
ESICOMMENT      -> TAGERRORc    [style=dotted, label="nested\nin\nremove"]
1216
ESIREMOVE       -> INTAGc
1217
ESIREMOVE       -> TAGERRORc
1218
ESIINCLUDE      -> INTAGc
1219
ESIINCLUDE      -> TAGERRORc
1220
ESIINCLUDE      -> TAGERRORc    [style=dotted, label="nested\nin\nremove"]
1221
ESIBOGON        -> TAGERRORc
1222
1223
#################################################################
1224
# SECTION D
1225
1226
INTAG           [shape=ellipse]
1227
TAGERROR        [shape=ellipse]
1228
NEXTTAGd        [shape=hexagon, label="NEXTTAG"]
1229
ATTRd           [shape=hexagon, label="ATTR"]
1230
D1              [shape=circle, label=""]
1231
D2              [shape=circle, label=""]
1232
INTAG           -> D1           [label="lws"]
1233
D1              -> D2           [label="/"]
1234
INTAG           -> D2           [label="/"]
1235
INTAG           -> NEXTTAGd     [label=">"]
1236
D1              -> NEXTTAGd     [label=">"]
1237
D2              -> NEXTTAGd     [label=">"]
1238
D1              -> ATTRd        [label="XMLstartchar"]
1239
D1              -> TAGERROR     [label="*"]
1240
D2              -> TAGERROR     [label="*"]
1241
TAGERROR        -> TAGERROR     [label="*"]
1242
TAGERROR        -> NEXTTAGd     [label="'>'"]
1243
1244
#################################################################
1245
# SECTION E
1246
1247
ATTR            [shape=ellipse]
1248
SKIPATTR        [shape=ellipse]
1249
ATTRGETVAL      [shape=ellipse]
1250
ATTRDELIM       [shape=ellipse]
1251
ATTRVAL         [shape=ellipse]
1252
TAGERRORe       [shape=hexagon, label="TAGERROR"]
1253
INTAGe          [shape=hexagon, label="INTAG"]
1254
ATTR            -> SKIPATTR     [label="*"]
1255
ATTR            -> ATTRGETVAL   [label="wanted attr"]
1256
SKIPATTR        -> SKIPATTR     [label="XMLname"]
1257
SKIPATTR        -> ATTRDELIM    [label="'='"]
1258
SKIPATTR        -> TAGERRORe    [label="*"]
1259
ATTRGETVAL      -> ATTRDELIM
1260
ATTRDELIM       -> ATTRVAL      [label="\""]
1261
ATTRDELIM       -> ATTRVAL      [label="\'"]
1262
ATTRDELIM       -> ATTRVAL      [label="*"]
1263
ATTRDELIM       -> TAGERRORe    [label="lws"]
1264
ATTRVAL         -> TAGERRORe    [label="'>'"]
1265
ATTRVAL         -> INTAGe       [label="delim"]
1266
ATTRVAL         -> ATTRVAL      [label="*"]
1267
1268
}
1269
1270
#endif