varnish-cache/bin/varnishd/cache/cache_vrt_filter.c
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_varnishd.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 18612
is_dup_filter(const struct vfilter_head *head, const struct vfp * vfp,
64
    const struct vdp *vdp, const char *name)
65
{
66
        struct vfilter *vp;
67 91460
        VTAILQ_FOREACH(vp, head, list) {
68 72850
                if (vfp != NULL && vp->vfp != NULL) {
69 21346
                        if (vp->vfp == vfp)
70 2
                                return ("VFP already registered");
71 21344
                        if (!strcasecmp(vp->name, name))
72 0
                                return ("VFP name already used");
73 21344
                }
74 72848
                if (vdp != NULL && vp->vdp != NULL) {
75 16828
                        if (vp->vdp == vdp)
76 0
                                return ("VDP already registered");
77 16828
                        if (!strcasecmp(vp->name, name))
78 0
                                return ("VDP name already used");
79 16828
                }
80 72848
        }
81 18610
        return (NULL);
82 18612
}
83
84
static const char *
85 16898
vrt_addfilter(VRT_CTX, const struct vfp *vfp, const struct vdp *vdp)
86
{
87
        struct vfilter *vp;
88 16898
        struct vfilter_head *hd = &vrt_filters;
89 16898
        const char *err, *name = NULL;
90
91 16898
        CHECK_OBJ_ORNULL(ctx, VRT_CTX_MAGIC);
92 16898
        assert(vfp != NULL || vdp != NULL);
93 16898
        assert(vfp == NULL || vfp->name != NULL);
94 16898
        assert(vdp == NULL || vdp->name != NULL);
95 16898
        assert(vfp == NULL || vdp == NULL || !strcasecmp(vfp->name, vdp->name));
96 16898
        if (vfp != NULL)
97 9920
                name = vfp->name;
98 6978
        else if (vdp != NULL)
99 6978
                name = vdp->name;
100 16898
        AN(name);
101
102 16898
        err = is_dup_filter(hd, vfp, vdp, name);
103 16898
        if (err != NULL) {
104 0
                if (ctx != NULL)
105 0
                        VRT_fail(ctx, "%s: %s (global)", name, err);
106 0
                return (err);
107
        }
108 16898
        if (ctx != NULL) {
109 1714
                ASSERT_CLI();
110 1714
                CHECK_OBJ_NOTNULL(ctx->vcl, VCL_MAGIC);
111 1714
                hd = &ctx->vcl->filters;
112 1714
                err = is_dup_filter(hd, vfp, vdp, name);
113 1714
                if (err != NULL) {
114 2
                        VRT_fail(ctx, "%s: %s (per-vcl)", name, err);
115 2
                        return (err);
116
                }
117 1712
        }
118
119 16896
        ALLOC_OBJ(vp, VFILTER_MAGIC);
120 16896
        AN(vp);
121 16896
        vp->vfp = vfp;
122 16896
        vp->vdp = vdp;
123 16896
        vp->name = name;
124 16896
        vp->nlen = strlen(name);
125 16896
        VTAILQ_INSERT_TAIL(hd, vp, list);
126 16896
        return (err);
127 16898
}
128
129
const char *
130 1714
VRT_AddFilter(VRT_CTX, const struct vfp *vfp, const struct vdp *vdp)
131
{
132
133 1714
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
134 1714
        return (vrt_addfilter(ctx, vfp, vdp));
135
}
136
137
void
138 368
VRT_RemoveFilter(VRT_CTX, const struct vfp *vfp, const struct vdp *vdp)
139
{
140
        struct vfilter *vp;
141
        struct vfilter_head *hd;
142
143 368
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
144 368
        CHECK_OBJ_NOTNULL(ctx->vcl, VCL_MAGIC);
145 368
        hd = &ctx->vcl->filters;
146 368
        assert(vfp != NULL || vdp != NULL);
147 368
        assert(vfp == NULL || vfp->name != NULL);
148 368
        assert(vdp == NULL || vdp->name != NULL);
149 368
        assert(vfp == NULL || vdp == NULL || !strcasecmp(vfp->name, vdp->name));
150
151 368
        ASSERT_CLI();
152 506
        VTAILQ_FOREACH(vp, hd, list) {
153 506
                CHECK_OBJ_NOTNULL(vp, VFILTER_MAGIC);
154 506
                if (vp->vfp == vfp && vp->vdp == vdp)
155 368
                        break;
156 138
        }
157 368
        AN(vp);
158 368
        assert(vfp == NULL || !strcasecmp(vfp->name, vp->name));
159 368
        assert(vdp == NULL || !strcasecmp(vdp->name, vp->name));
160 368
        VTAILQ_REMOVE(hd, vp, list);
161 368
        FREE_OBJ(vp);
162 368
}
163
164
static const struct vfilter vfilter_error[1] = {{0}};
165
166
static const struct vfilter *
167 13434
vcl_filter_list_iter(int want_vfp, const struct vfilter_head *h1,
168
    const struct vfilter_head *h2, const char **flp)
169
{
170
        const char *fl, *q;
171
        const struct vfilter *vp;
172
173 13434
        AN(h1);
174 13434
        AN(h2);
175 13434
        AN(flp);
176
177 13434
        fl = *flp;
178 13434
        AN(fl);
179
180 15700
        while (vct_isspace(*fl))
181 2266
                fl++;
182 13434
        if (*fl == '\0') {
183 11086
                *flp = NULL;
184 11086
                return (NULL);
185
        }
186 19516
        for (q = fl; *q && !vct_isspace(*q); q++)
187 17168
                continue;
188 2348
        *flp = q;
189 14040
        VTAILQ_FOREACH(vp, h1, list) {
190 13378
                if (want_vfp && vp->vfp == NULL)
191 84
                        continue;
192 13294
                else if (!want_vfp && vp->vdp == NULL)
193 6810
                        continue;
194 6484
                if (vp->nlen == q - fl && !memcmp(fl, vp->name, vp->nlen))
195 1686
                        return (vp);
196 4798
        }
197 1480
        VTAILQ_FOREACH(vp, h2, list) {
198 1474
                if (want_vfp && vp->vfp == NULL)
199 28
                        continue;
200 1446
                else if (!want_vfp && vp->vdp == NULL)
201 0
                        continue;
202 1446
                if (vp->nlen == q - fl && !memcmp(fl, vp->name, vp->nlen))
203 656
                        return (vp);
204 790
        }
205 6
        *flp = fl;
206 6
        return (vfilter_error);
207 13434
}
208
209
int
210 3882
VCL_StackVFP(struct vfp_ctx *vc, const struct vcl *vcl, const char *fl)
211
{
212
        const struct vfilter *vp;
213
214 3882
        AN(fl);
215 3882
        VSLbs(vc->wrk->vsl, SLT_Filters, TOSTRAND(fl));
216
217 4820
        while (1) {
218 4820
                vp = vcl_filter_list_iter(1, &vrt_filters, &vcl->filters, &fl);
219 4820
                if (vp == NULL)
220 3834
                        return (0);
221 986
                if (vp == vfilter_error)
222 4
                        return (VFP_Error(vc, "Filter '...%s' not found", fl));
223 982
                if (VFP_Push(vc, vp->vfp) == NULL)
224 44
                        return (-1);
225
        }
226 3882
}
227
228
int
229 7378
VCL_StackVDP(struct vdp_ctx *vdc, const struct vcl *vcl, const char *fl,
230
    struct req *req, struct busyobj *bo)
231
{
232
        const struct vfilter *vp;
233
        struct vrt_ctx ctx[1];
234
235 7378
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
236 7378
        AN(vcl);
237 7378
        AN(fl);
238
239 7378
        CHECK_OBJ_ORNULL(req, REQ_MAGIC);
240 7378
        CHECK_OBJ_ORNULL(bo, BUSYOBJ_MAGIC);
241
242 7378
        assert((req ? 1 : 0) ^ (bo ? 1 : 0));
243
244 7378
        VSLbs(vdc->vsl, SLT_Filters, TOSTRAND(fl));
245 7378
        INIT_OBJ(ctx, VRT_CTX_MAGIC);
246
247 7378
        if (req)
248 7364
                VCL_Req2Ctx(ctx, req);
249
        else
250 14
                VCL_Bo2Ctx(ctx, bo);
251
252 8614
        while (1) {
253 8614
                vp = vcl_filter_list_iter(0, &vrt_filters, &vcl->filters, &fl);
254 8614
                if (vp == NULL)
255 7252
                        return (0);
256 1362
                if (vp == vfilter_error) {
257 4
                        VSLb(ctx->vsl, SLT_Error,
258 2
                            "Filter '...%s' not found", fl);
259 2
                        return (-1);
260
                }
261 1360
                if (VDP_Push(ctx, vdc, ctx->ws, vp->vdp, NULL))
262 124
                        return (-1);
263
        }
264 7378
}
265
266
void
267 1898
VCL_VRT_Init(void)
268
{
269 1898
        AZ(vrt_addfilter(NULL, &VFP_testgunzip, NULL));
270 1898
        AZ(vrt_addfilter(NULL, &VFP_gunzip, NULL));
271 1898
        AZ(vrt_addfilter(NULL, &VFP_gzip, NULL));
272 1898
        AZ(vrt_addfilter(NULL, &VFP_esi, NULL));
273 1898
        AZ(vrt_addfilter(NULL, &VFP_esi_gzip, NULL));
274 1898
        AZ(vrt_addfilter(NULL, NULL, &VDP_esi));
275 1898
        AZ(vrt_addfilter(NULL, NULL, &VDP_gunzip));
276 1898
        AZ(vrt_addfilter(NULL, NULL, &VDP_range));
277 1898
}
278
279
/*--------------------------------------------------------------------
280
 */
281
282
typedef void filter_list_t(void *, struct vsb *vsb);
283
284
static const char *
285 9862
filter_on_ws(struct ws *ws, filter_list_t *func, void *arg)
286
{
287
        struct vsb vsb[1];
288
        const char *p;
289
290 9862
        AN(func);
291 9862
        AN(arg);
292 9862
        WS_VSB_new(vsb, ws);
293 9862
        func(arg, vsb);
294 9862
        p = WS_VSB_finish(vsb, ws, NULL);
295 9862
        if (p == NULL)
296 46
                p = "";
297 9862
        return (p);
298
}
299
300
/*--------------------------------------------------------------------
301
 */
302
303
static void v_matchproto_(filter_list_t)
304 2414
vbf_default_filter_list(void *arg, struct vsb *vsb)
305
{
306
        const struct busyobj *bo;
307
        const char *p;
308 2414
        int do_gzip, do_gunzip, is_gzip = 0, is_gunzip = 0;
309
310 2414
        CAST_OBJ_NOTNULL(bo, arg, BUSYOBJ_MAGIC);
311
312 2414
        do_gzip = bo->do_gzip;
313 2414
        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 2414
        if (bo->htc->body_status == BS_NONE || bo->htc->content_length == 0)
329 0
                return;
330
331 2414
        if (!cache_param->http_gzip_support)
332 8
                do_gzip = do_gunzip = 0;
333
334 2414
        if (http_GetHdr(bo->beresp, H_Content_Encoding, &p))
335 402
                is_gzip = !strcasecmp(p, "gzip");
336
        else
337 2012
                is_gunzip = 1;
338
339
        /* We won't gunzip unless it is gzipped */
340 2414
        if (do_gunzip && !is_gzip)
341 4
                do_gunzip = 0;
342
343
        /* We wont gzip unless if it already is gzipped */
344 2414
        if (do_gzip && !is_gunzip)
345 0
                do_gzip = 0;
346
347 2414
        if (do_gunzip || (is_gzip && bo->do_esi))
348 318
                VSB_cat(vsb, " gunzip");
349
350 2414
        if (bo->do_esi && (do_gzip || (is_gzip && !do_gunzip))) {
351 324
                VSB_cat(vsb, " esi_gzip");
352 324
                return;
353
        }
354
355 2090
        if (bo->do_esi) {
356 300
                VSB_cat(vsb, " esi");
357 300
                return;
358
        }
359
360 1790
        if (do_gzip)
361 32
                VSB_cat(vsb, " gzip");
362
363 1790
        if (is_gzip && !do_gunzip)
364 84
                VSB_cat(vsb, " testgunzip");
365 2414
}
366
367
const char *
368 2414
VBF_Get_Filter_List(struct busyobj *bo)
369
{
370
371 2414
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
372 2414
        return (filter_on_ws(bo->ws, vbf_default_filter_list, bo));
373
}
374
375
static const char *
376 2
bereq_Empty_Filter(struct busyobj *bo)
377
{
378
379 2
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
380 2
        return ("");
381
}
382
383
/*--------------------------------------------------------------------
384
 */
385
386
static void v_matchproto_(filter_list_t)
387 7448
resp_default_filter_list(void *arg, struct vsb *vsb)
388
{
389
        struct req *req;
390
391 7448
        CAST_OBJ_NOTNULL(req, arg, REQ_MAGIC);
392
393 7448
        if (!req->disable_esi && req->objcore != NULL &&
394 7418
            ObjHasAttr(req->wrk, req->objcore, OA_ESIDATA))
395 450
                VSB_cat(vsb, " esi");
396
397 8094
        if (cache_param->http_gzip_support &&
398 7432
            req->objcore != NULL &&
399 7428
            ObjCheckFlag(req->wrk, req->objcore, OF_GZIPED) &&
400 646
            !RFC2616_Req_Gzip(req->http))
401 236
                VSB_cat(vsb, " gunzip");
402
403 13624
        if (cache_param->http_range_support &&
404 7440
            http_GetStatus(req->resp) == 200 &&
405 6176
            http_GetHdr(req->http, H_Range, NULL))
406 116
                VSB_cat(vsb, " range");
407 7448
}
408
409
const char *
410 7448
resp_Get_Filter_List(struct req *req)
411
{
412
413 7448
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
414 7448
        return (filter_on_ws(req->ws, resp_default_filter_list, req));
415
}
416
417
static const char *
418 4
req_Empty_Filter(struct req *req)
419
{
420
421 4
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
422 4
        return ("");
423
}
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 20
req_filter_can(struct req *req)
437
{
438
439 20
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
440 20
        return (req->req_body_status->avail == 1);
441
}
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
        {                                                               \
451
                                                                        \
452
                CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
453
                if (ctx->in->fld != NULL)                               \
454
                        return(ctx->in->fld);                           \
455
                return (func(ctx->in));                                 \
456
        }                                                               \
457
                                                                        \
458
        VCL_VOID                                                        \
459
        VRT_l_##vcl##_filters(VRT_CTX, const char *str, VCL_STRANDS s)  \
460
        {                                                               \
461
                const char *b;                                          \
462
                                                                        \
463
                (void)str;                                              \
464
                CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
465
                if (! (cond)) {                                         \
466
                        VRT_fail(ctx, #vcl ".filters not settable");    \
467
                        return;                                         \
468
                }                                                       \
469
                b = VRT_StrandsWS(ctx->in->ws, str, s);                 \
470
                if (b == NULL)                                          \
471
                        WS_MarkOverflow(ctx->in->ws);                   \
472
                else                                                    \
473
                        ctx->in->fld = b;                               \
474
        }
475
476 16
FILTER_VAR(bereq, bo, bereq_Empty_Filter, 1, vdp_filter_list)
477 84
FILTER_VAR(beresp, bo, VBF_Get_Filter_List, 1, vfp_filter_list)
478 24
FILTER_VAR(req, req, req_Empty_Filter, req_filter_can(ctx->req), vfp_filter_list)
479 1278
FILTER_VAR(resp, req, resp_Get_Filter_List, 1, vdp_filter_list)