Code Coverage: vinyl-cache/bin/vinyld/cache/cache_vrt_filter.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2016 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 *
7
 * SPDX-License-Identifier: BSD-2-Clause
8
 *
9
 * Redistribution and use in source and binary forms, with or without
10
 * modification, are permitted provided that the following conditions
11
 * are met:
12
 * 1. Redistributions of source code must retain the above copyright
13
 *    notice, this list of conditions and the following disclaimer.
14
 * 2. Redistributions in binary form must reproduce the above copyright
15
 *    notice, this list of conditions and the following disclaimer in the
16
 *    documentation and/or other materials provided with the distribution.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28
 * SUCH DAMAGE.
29
 *
30
 */
31
32
#include "config.h"
33
34
#include <stdio.h>
35
#include <stdint.h>
36
#include <stdlib.h>
37
38
#include "cache_int.h"
39
#include "cache_vcl.h"
40
#include "vrt_obj.h"
41
42
#include "vct.h"
43
44
#include "cache_filter.h"
45
46
/*--------------------------------------------------------------------
47
 */
48
49
struct vfilter {
50
        unsigned                        magic;
51
#define VFILTER_MAGIC                   0xd40894e9
52
        const struct vfp                *vfp;
53
        const struct vdp                *vdp;
54
        const char                      *name;
55
        int                             nlen;
56
        VTAILQ_ENTRY(vfilter)           list;
57
};
58
59
static struct vfilter_head vrt_filters =
60
    VTAILQ_HEAD_INITIALIZER(vrt_filters);
61
62
static const char *
63
is_dup_filter(const struct vfilter_head *head, const struct vfp * vfp,
64
    const struct vdp *vdp, const char *name)
65 10490
{
66 10490
        struct vfilter *vp;
67 42988
        VTAILQ_FOREACH(vp, head, list) {
68 42988
                if (vfp != NULL && vp->vfp != NULL) {
69 11521
                        if (vp->vfp == vfp)
70 1
                                return ("VFP already registered");
71 11520
                        if (!strcasecmp(vp->name, name))
72 0
                                return ("VFP name already used");
73 11520
                }
74 42987
                if (vdp != NULL && vp->vdp != NULL) {
75 11632
                        if (vp->vdp == vdp)
76 0
                                return ("VDP already registered");
77 11632
                        if (!strcasecmp(vp->name, name))
78 0
                                return ("VDP name already used");
79 11632
                }
80 42987
        }
81 10489
        return (NULL);
82 10490
}
83
84
static const char *
85
vrt_addfilter(VRT_CTX, const struct vfp *vfp, const struct vdp *vdp)
86 9349
{
87 9349
        struct vfilter *vp;
88 9349
        struct vfilter_head *hd = &vrt_filters;
89 9349
        const char *err, *name = NULL;
90
91 9349
        CHECK_OBJ_ORNULL(ctx, VRT_CTX_MAGIC);
92 9349
        assert(vfp != NULL || vdp != NULL);
93 9349
        assert(vfp == NULL || vfp->name != NULL);
94 9349
        assert(vdp == NULL || vdp->name != NULL);
95 9349
        assert(vfp == NULL || vdp == NULL || !strcasecmp(vfp->name, vdp->name));
96 9349
        if (vfp != NULL)
97 5359
                name = vfp->name;
98 3990
        else if (vdp != NULL)
99 3990
                name = vdp->name;
100 9349
        AN(name);
101
102 9349
        err = is_dup_filter(hd, vfp, vdp, name);
103 9349
        if (err != NULL) {
104 0
                if (ctx != NULL)
105 0
                        VRT_fail(ctx, "%s: %s (global)", name, err);
106 0
                return (err);
107 0
        }
108 9349
        if (ctx != NULL) {
109 1141
                ASSERT_CLI();
110 1141
                CHECK_OBJ_NOTNULL(ctx->vcl, VCL_MAGIC);
111 1141
                hd = &ctx->vcl->filters;
112 1141
                err = is_dup_filter(hd, vfp, vdp, name);
113 1141
                if (err != NULL) {
114 1
                        VRT_fail(ctx, "%s: %s (per-vcl)", name, err);
115 1
                        return (err);
116 1
                }
117 1141
        }
118
119 9348
        ALLOC_OBJ(vp, VFILTER_MAGIC);
120 9348
        AN(vp);
121 9348
        vp->vfp = vfp;
122 9348
        vp->vdp = vdp;
123 9348
        vp->name = name;
124 9348
        vp->nlen = vstrlen(name);
125 9348
        VTAILQ_INSERT_TAIL(hd, vp, list);
126 9348
        return (err);
127 9348
}
128
129
const char *
130
VRT_AddFilter(VRT_CTX, const struct vfp *vfp, const struct vdp *vdp)
131 1141
{
132
133 1141
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
134 1141
        return (vrt_addfilter(ctx, vfp, vdp));
135 1141
}
136
137
void
138
VRT_RemoveFilter(VRT_CTX, const struct vfp *vfp, const struct vdp *vdp)
139 230
{
140 230
        struct vfilter *vp;
141 230
        struct vfilter_head *hd;
142
143 230
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
144 230
        CHECK_OBJ_NOTNULL(ctx->vcl, VCL_MAGIC);
145 230
        hd = &ctx->vcl->filters;
146 230
        assert(vfp != NULL || vdp != NULL);
147 230
        assert(vfp == NULL || vfp->name != NULL);
148 230
        assert(vdp == NULL || vdp->name != NULL);
149 230
        assert(vfp == NULL || vdp == NULL || !strcasecmp(vfp->name, vdp->name));
150
151 230
        ASSERT_CLI();
152 230
        VTAILQ_FOREACH(vp, hd, list) {
153 230
                CHECK_OBJ_NOTNULL(vp, VFILTER_MAGIC);
154 230
                if (vp->vfp == vfp && vp->vdp == vdp)
155 230
                        break;
156 230
        }
157 230
        AN(vp);
158 230
        assert(vfp == NULL || !strcasecmp(vfp->name, vp->name));
159 230
        assert(vdp == NULL || !strcasecmp(vdp->name, vp->name));
160 230
        VTAILQ_REMOVE(hd, vp, list);
161 230
        FREE_OBJ(vp);
162 230
}
163
164
static const struct vfilter vfilter_error[1] = {{0}};
165
166
static const struct vfilter *
167
vcl_filter_list_iter(int want_vfp, const struct vfilter_head *h1,
168
    const struct vfilter_head *h2, const char **flp)
169 13419
{
170 13419
        const char *fl, *q;
171 13419
        const struct vfilter *vp;
172
173 13419
        AN(h1);
174 13419
        AN(h2);
175 13419
        AN(flp);
176
177 13419
        fl = *flp;
178 13419
        AN(fl);
179
180 15677
        while (vct_isspace(*fl))
181 2258
                fl++;
182 13419
        if (*fl == '\0') {
183 11111
                *flp = NULL;
184 11111
                return (NULL);
185 11111
        }
186 16284
        for (q = fl; *q && !vct_isspace(*q); q++)
187 13976
                continue;
188 2308
        *flp = q;
189 12871
        VTAILQ_FOREACH(vp, h1, list) {
190 12871
                if (want_vfp && vp->vfp == NULL)
191 42
                        continue;
192 12829
                else if (!want_vfp && vp->vdp == NULL)
193 6903
                        continue;
194 5926
                if (vp->nlen == q - fl && !vmemcmp(fl, vp->name, vp->nlen))
195 1946
                        return (vp);
196 5926
        }
197 1201
        VTAILQ_FOREACH(vp, h2, list) {
198 1201
                if (want_vfp && vp->vfp == NULL)
199 16
                        continue;
200 1185
                else if (!want_vfp && vp->vdp == NULL)
201 0
                        continue;
202 1185
                if (vp->nlen == q - fl && !vmemcmp(fl, vp->name, vp->nlen))
203 362
                        return (vp);
204 1185
        }
205 0
        *flp = fl;
206 0
        return (vfilter_error);
207 362
}
208
209
int
210
VCL_StackVFP(struct vfp_ctx *vc, const struct vcl *vcl, const char *fl)
211 2626
{
212 2626
        const struct vfilter *vp;
213
214 2626
        AN(fl);
215 2626
        VSLbs(vc->wrk->vsl, SLT_Filters, TOSTRAND(fl));
216
217 3529
        while (1) {
218 3529
                vp = vcl_filter_list_iter(1, &vrt_filters, &vcl->filters, &fl);
219 3529
                if (vp == NULL)
220 2603
                        return (0);
221 926
                if (vp == vfilter_error)
222 2
                        return (VFP_Error(vc, "Filter '...%s' not found", fl));
223 924
                if (VFP_Push(vc, vp->vfp) == NULL)
224 22
                        return (-1);
225 924
        }
226 2626
}
227
228
int
229
VCL_StackVDP(struct vdp_ctx *vdc, const struct vcl *vcl, const char *fl,
230
    struct req *req, struct busyobj *bo)
231 8574
{
232 8574
        const struct vfilter *vp;
233 8574
        struct vrt_ctx ctx[1];
234
235 8574
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
236 8574
        AN(vcl);
237 8574
        AN(fl);
238
239 8574
        CHECK_OBJ_ORNULL(req, REQ_MAGIC);
240 8574
        CHECK_OBJ_ORNULL(bo, BUSYOBJ_MAGIC);
241
242 8574
        assert((req ? 1 : 0) ^ (bo ? 1 : 0));
243
244 8574
        VSLbs(vdc->vsl, SLT_Filters, TOSTRAND(fl));
245 8574
        INIT_OBJ(ctx, VRT_CTX_MAGIC);
246
247 8574
        if (req)
248 8555
                VCL_Req2Ctx(ctx, req);
249 19
        else
250 19
                VCL_Bo2Ctx(ctx, bo);
251
252 9890
        while (1) {
253 9890
                vp = vcl_filter_list_iter(0, &vrt_filters, &vcl->filters, &fl);
254 9890
                if (vp == NULL)
255 8509
                        return (0);
256 1381
                if (vp == vfilter_error) {
257 1
                        VSLb(ctx->vsl, SLT_Error,
258 1
                            "Filter '...%s' not found", fl);
259 1
                        return (-1);
260 1
                }
261 1380
                if (VDP_Push(ctx, vdc, ctx->ws, vp->vdp, NULL))
262 64
                        return (-1);
263 1380
        }
264 8574
}
265
266
void
267
VCL_VRT_Init(void)
268 1026
{
269 1026
        AZ(vrt_addfilter(NULL, &VFP_testgunzip, NULL));
270 1026
        AZ(vrt_addfilter(NULL, &VFP_gunzip, NULL));
271 1026
        AZ(vrt_addfilter(NULL, &VFP_gzip, NULL));
272 1026
        AZ(vrt_addfilter(NULL, &VFP_esi, NULL));
273 1026
        AZ(vrt_addfilter(NULL, &VFP_esi_gzip, NULL));
274 1026
        AZ(vrt_addfilter(NULL, NULL, &VDP_esi));
275 1026
        AZ(vrt_addfilter(NULL, NULL, &VDP_gunzip));
276 1026
        AZ(vrt_addfilter(NULL, NULL, &VDP_range));
277 1026
}
278
279
/*--------------------------------------------------------------------
280
 */
281
282
typedef void filter_list_t(void *, struct vsb *vsb);
283
284
static const char *
285
filter_on_ws(struct ws *ws, filter_list_t *func, void *arg)
286 10382
{
287 10382
        struct vsb vsb[1];
288 10382
        const char *p;
289
290 10382
        AN(func);
291 10382
        AN(arg);
292 10382
        WS_VSB_new(vsb, ws);
293 10382
        func(arg, vsb);
294 10382
        p = WS_VSB_finish(vsb, ws, NULL);
295 10382
        if (p == NULL)
296 23
                p = "";
297 10382
        return (p);
298 10382
}
299
300
/*--------------------------------------------------------------------
301
 */
302
303
static void v_matchproto_(filter_list_t)
304
vbf_default_filter_list(void *arg, struct vsb *vsb)
305 1791
{
306 1791
        const struct busyobj *bo;
307 1791
        const char *p;
308 1791
        int do_gzip, do_gunzip, is_gzip = 0, is_gunzip = 0;
309
310 1791
        CAST_OBJ_NOTNULL(bo, arg, BUSYOBJ_MAGIC);
311
312 1791
        do_gzip = bo->do_gzip;
313 1791
        do_gunzip = bo->do_gunzip;
314
315
        /*
316
         * The VCL variables beresp.do_g[un]zip tells us how we want the
317
         * object processed before it is stored.
318
         *
319
         * The backend Content-Encoding header tells us what we are going
320
         * to receive, which we classify in the following three classes:
321
         *
322
         *      "Content-Encoding: gzip"        --> object is gzipped.
323
         *      no Content-Encoding             --> object is not gzipped.
324
         *      anything else                   --> do nothing wrt gzip
325
         */
326
327
        /* No body -> done */
328 1791
        if (bo->htc->body_status == BS_NONE || bo->htc->content_length == 0)
329 0
                return;
330
331 1791
        if (!cache_param->http_gzip_support)
332 4
                do_gzip = do_gunzip = 0;
333
334 1791
        if (http_GetHdr(bo->beresp, H_Content_Encoding, &p))
335 295
                is_gzip = !strcasecmp(p, "gzip");
336 1496
        else
337 1496
                is_gunzip = 1;
338
339
        /* We won't gunzip unless it is gzipped */
340 1791
        if (do_gunzip && !is_gzip)
341 2
                do_gunzip = 0;
342
343
        /* We wont gzip unless if it already is gzipped */
344 1791
        if (do_gzip && !is_gunzip)
345 0
                do_gzip = 0;
346
347 1791
        if (do_gunzip || (is_gzip && bo->do_esi))
348 223
                VSB_cat(vsb, " gunzip");
349
350 1791
        if (bo->do_esi && (do_gzip || (is_gzip && !do_gunzip))) {
351 228
                VSB_cat(vsb, " esi_gzip");
352 228
                return;
353 228
        }
354
355 1563
        if (bo->do_esi) {
356 426
                VSB_cat(vsb, " esi");
357 426
                return;
358 426
        }
359
360 1137
        if (do_gzip)
361 18
                VSB_cat(vsb, " gzip");
362
363 1137
        if (is_gzip && !do_gunzip)
364 72
                VSB_cat(vsb, " testgunzip");
365 1137
}
366
367
const char *
368
VBF_Get_Filter_List(struct busyobj *bo)
369 1789
{
370
371 1789
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
372 1789
        return (filter_on_ws(bo->ws, vbf_default_filter_list, bo));
373 1789
}
374
375
static const char *
376
bereq_Empty_Filter(struct busyobj *bo)
377 1
{
378
379 1
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
380 1
        return ("");
381 1
}
382
383
/*--------------------------------------------------------------------
384
 */
385
386
static void v_matchproto_(filter_list_t)
387
resp_default_filter_list(void *arg, struct vsb *vsb)
388 8594
{
389 8594
        struct req *req;
390
391 8594
        CAST_OBJ_NOTNULL(req, arg, REQ_MAGIC);
392
393 8594
        if (!req->disable_esi && req->objcore != NULL &&
394 8594
            ObjHasAttr(req->wrk, req->objcore, OA_ESIDATA))
395 572
                VSB_cat(vsb, " esi");
396
397 8594
        if (cache_param->http_gzip_support &&
398 8594
            req->objcore != NULL &&
399 8594
            ObjCheckFlag(req->wrk, req->objcore, OF_GZIPED) &&
400 8594
            !RFC2616_Req_Gzip(req->http))
401 436
                VSB_cat(vsb, " gunzip");
402
403 8594
        if (cache_param->http_range_support &&
404 8594
            http_GetStatus(req->resp) == 200 &&
405 8594
            http_GetHdr(req->http, H_Range, NULL))
406 59
                VSB_cat(vsb, " range");
407 8594
}
408
409
const char *
410
resp_Get_Filter_List(struct req *req)
411 8594
{
412
413 8594
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
414 8594
        return (filter_on_ws(req->ws, resp_default_filter_list, req));
415 8594
}
416
417
static const char *
418
req_Empty_Filter(struct req *req)
419 2
{
420
421 2
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
422 2
        return ("");
423 2
}
424
425
/*--------------------------------------------------------------------
426
 * control if "set req.filters" is allowed
427
 *
428
 * req.body (conversely to other body object) is one where VCL has control over
429
 * when it gets processed by means of std.cache_req_body(): Filters act on the
430
 * received body when that function is called, so confusion could be caused if
431
 * people expect filters to have an effect when set/changed after the req.body
432
 * is already cached.
433
 */
434
435
static int
436
req_filter_can(struct req *req)
437 10
{
438
439 10
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
440 10
        return (req->req_body_status->avail == 1);
441 10
}
442
443
/*--------------------------------------------------------------------*/
444
445
//lint -emacro(506, FILTER_VAR) constant value boolean
446
//lint -emacro(774, FILTER_VAR) if always evaluates to false
447
#define FILTER_VAR(vcl, in, func, cond, fld)                            \
448
        VCL_STRING                                                      \
449
        VRT_r_##vcl##_filters(VRT_CTX)                                  \
450 405
        {                                                               \
451 405
                                                                        \
452 405
                CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
453 405
                if (ctx->in->fld != NULL)                               \
454 405
                        return(ctx->in->fld);                           \
455 405
                return (func(ctx->in));                                 \
456 405
        }                                                               \
457
                                                                        \
458
        VCL_VOID                                                        \
459
        VRT_l_##vcl##_filters(VRT_CTX, const char *str, VCL_STRANDS s)  \
460 356
        {                                                               \
461 356
                const char *b;                                          \
462 356
                                                                        \
463 356
                (void)str;                                              \
464 356
                CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
465 356
                if (! (cond)) {                                         \
466 2
                        VRT_fail(ctx, #vcl ".filters not settable");    \
467 2
                        return;                                         \
468 2
                }                                                       \
469 356
                b = VRT_StrandsWS(ctx->in->ws, str, s);                 \
470 354
                if (b == NULL)                                          \
471 354
                        WS_MarkOverflow(ctx->in->ws);                   \
472 354
                else                                                    \
473 354
                        ctx->in->fld = b;                               \
474 354
        }
475
476 55
FILTER_VAR(bereq, bo, bereq_Empty_Filter, 1, vdp_filter_list)
477 42
FILTER_VAR(beresp, bo, VBF_Get_Filter_List, 1, vfp_filter_list)
478 12
FILTER_VAR(req, req, req_Empty_Filter, req_filter_can(ctx->req), vfp_filter_list)
479
FILTER_VAR(resp, req, resp_Get_Filter_List, 1, vdp_filter_list)