Code Coverage: vinyl-cache/bin/vinyld/cache/cache_ban_build.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2015 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 <stdlib.h>
35
36
#include "cache_int.h"
37
#include "cache_ban.h"
38
39
#include "vend.h"
40
#include "vtim.h"
41
#include "vnum.h"
42
43
void BAN_Build_Init(void);
44
void BAN_Build_Fini(void);
45
46
struct ban_proto {
47
        unsigned                magic;
48
#define BAN_PROTO_MAGIC         0xd8adc494
49
        unsigned                flags;          /* BANS_FLAG_* */
50
51
        struct vsb              *vsb;
52
        char                    *err;
53
};
54
55
/*--------------------------------------------------------------------
56
 * Variables we can ban on
57
 */
58
59
static const struct pvar {
60
        const char              *name;
61
        unsigned                flag;
62
        uint8_t                 tag;
63
} pvars[] = {
64
#define PVAR(a, b, c)   { (a), (b), (c) },
65
#include "tbl/ban_vars.h"
66
        { 0, 0, 0}
67
};
68
69
/* operators allowed per argument (pvar.tag) */
70
static const unsigned arg_opervalid[BAN_ARGARRSZ + 1] = {
71
#define ARGOPER(arg, mask) [BAN_ARGIDX(arg)] = (mask),
72
#include "tbl/ban_arg_oper.h"
73
        [BAN_ARGARRSZ] = 0
74
};
75
76
// init'ed in _Init
77
static const char *arg_operhelp[BAN_ARGARRSZ + 1];
78
79
// operators
80
const char * const ban_oper[BAN_OPERARRSZ + 1] = {
81
#define OPER(op, str) [BAN_OPERIDX(op)] = (str),
82
#include "tbl/ban_oper.h"
83
        [BAN_OPERARRSZ] = NULL
84
};
85
86
87
/*--------------------------------------------------------------------
88
 */
89
90
static char ban_build_err_no_mem[] = "No Memory";
91
92
/*--------------------------------------------------------------------
93
 */
94
95
struct ban_proto *
96
BAN_Build(void)
97 1188
{
98 1188
        struct ban_proto *bp;
99
100 1188
        ALLOC_OBJ(bp, BAN_PROTO_MAGIC);
101 1188
        if (bp == NULL)
102 0
                return (bp);
103 1188
        bp->vsb = VSB_new_auto();
104 1188
        if (bp->vsb == NULL) {
105 0
                FREE_OBJ(bp);
106 0
                return (NULL);
107 0
        }
108 1188
        return (bp);
109 1188
}
110
111
// TODO: change to (struct ban_proto **)
112
void
113
BAN_Abandon(struct ban_proto *bp)
114 1188
{
115
116 1188
        CHECK_OBJ_NOTNULL(bp, BAN_PROTO_MAGIC);
117 1188
        VSB_destroy(&bp->vsb);
118 1188
        FREE_OBJ(bp);
119 1188
}
120
121
/*--------------------------------------------------------------------
122
 */
123
124
static void
125
ban_add_lump(const struct ban_proto *bp, const void *p, uint32_t len)
126 170
{
127 170
        uint8_t buf[PRNDUP(sizeof len)] = { 0xff };
128
129 1020
        while (VSB_len(bp->vsb) & PALGN)
130 850
                VSB_putc(bp->vsb, buf[0]);
131 170
        vbe32enc(buf, len);
132 170
        VSB_bcat(bp->vsb, buf, sizeof buf);
133 170
        VSB_bcat(bp->vsb, p, len);
134 170
}
135
136
/*--------------------------------------------------------------------
137
 */
138
139
static const char *
140
ban_error(struct ban_proto *bp, const char *fmt, ...)
141 30
{
142 30
        va_list ap;
143
144 30
        CHECK_OBJ_NOTNULL(bp, BAN_PROTO_MAGIC);
145 30
        AN(bp->vsb);
146
147
        /* First error is sticky */
148 30
        if (bp->err == NULL) {
149 30
                if (fmt == ban_build_err_no_mem) {
150 0
                        bp->err = ban_build_err_no_mem;
151 30
                } else {
152
                        /* Record the error message in the vsb */
153 30
                        VSB_clear(bp->vsb);
154 30
                        va_start(ap, fmt);
155 30
                        VSB_vprintf(bp->vsb, fmt, ap);
156 30
                        va_end(ap);
157 30
                        AZ(VSB_finish(bp->vsb));
158 30
                        bp->err = VSB_data(bp->vsb);
159 30
                }
160 30
        }
161 30
        return (bp->err);
162 30
}
163
164
/*--------------------------------------------------------------------
165
 * Parse and add a http argument specification
166
 * Output something which HTTP_GetHdr understands
167
 */
168
169
static void
170
ban_parse_http(const struct ban_proto *bp, const char *a1)
171 48
{
172 48
        int l;
173
174 48
        l = vstrlen(a1) + 1;
175 48
        assert(l <= 127);
176 48
        VSB_putc(bp->vsb, (char)l);
177 48
        VSB_cat(bp->vsb, a1);
178 48
        VSB_putc(bp->vsb, ':');
179 48
        VSB_putc(bp->vsb, '\0');
180 48
}
181
182
/*--------------------------------------------------------------------
183
 * Parse and add a ban test specification
184
 */
185
186
static const char *
187
ban_parse_regexp(struct ban_proto *bp, const char *a3)
188 30
{
189 30
        struct vsb vsb[1];
190 30
        char errbuf[VRE_ERROR_LEN];
191 30
        int errorcode, erroroffset;
192 30
        size_t sz;
193 30
        vre_t *re, *rex;
194
195 30
        re = VRE_compile(a3, VRE_NO_AUTO_CAPTURE, &errorcode, &erroroffset, 0);
196 30
        if (re == NULL) {
197 1
                AN(VSB_init(vsb, errbuf, sizeof errbuf));
198 1
                AZ(VRE_error(vsb, errorcode));
199 1
                AZ(VSB_finish(vsb));
200 1
                VSB_fini(vsb);
201 1
                return (ban_error(bp, "Regex compile error: %s", errbuf));
202 1
        }
203
204 29
        rex = VRE_export(re, &sz);
205 29
        AN(rex);
206 29
        ban_add_lump(bp, rex, sz);
207 29
        VRE_free(&rex);
208 29
        VRE_free(&re);
209 29
        return (0);
210 29
}
211
212
static int
213
ban_parse_oper(const char *p)
214 161
{
215 161
        int i;
216
217 340
        for (i = 0; i < BAN_OPERARRSZ; i++) {
218 336
                if (!vstrcmp(p, ban_oper[i]))
219 157
                        return (BANS_OPER_OFF_ + i);
220 336
        }
221 4
        return (-1);
222 161
}
223
224
/*--------------------------------------------------------------------
225
 * Add a (and'ed) test-condition to a ban
226
 */
227
static const char *
228
ban_add_spec(struct ban_proto *bp, const struct pvar *pv, int op, const char *a3)
229 89
{
230
231 89
        assert(! BANS_HAS_ARG2_DOUBLE(pv->tag) &&
232 89
            ! BANS_HAS_ARG2_BOOL(pv->tag));
233
234 89
        ban_add_lump(bp, a3, vstrlen(a3) + 1);
235 89
        VSB_putc(bp->vsb, op);
236
237 89
        if (! BANS_HAS_ARG2_SPEC(op))
238 59
                return (NULL);
239
240 30
        return (ban_parse_regexp(bp, a3));
241 89
}
242
243
static const char *
244
ban_add_double(const struct ban_proto *bp, const struct pvar *pv, int op, double darg)
245 28
{
246 28
        uint64_t dtmp;
247 28
        uint8_t denc[sizeof darg];
248
249 28
        assert(BANS_HAS_ARG2_DOUBLE(pv->tag));
250 28
        assert(sizeof darg == sizeof dtmp);
251 28
        assert(sizeof dtmp == sizeof denc);
252 28
        vmemcpy(&dtmp, &darg, sizeof dtmp);
253 28
        vbe64enc(denc, dtmp);
254
255 28
        ban_add_lump(bp, denc, sizeof denc);
256 28
        VSB_putc(bp->vsb, op);
257 28
        return (NULL);
258 28
}
259
260
static const char *
261
ban_add_bool(struct ban_proto *bp, const struct pvar *pv, int op, const char *a3)
262 30
{
263 30
        uint8_t b;
264
265 30
        CHECK_OBJ_NOTNULL(bp, BAN_PROTO_MAGIC);
266 30
        AN(pv);
267 30
        AN(a3);
268 30
        assert(BANS_HAS_ARG2_BOOL(pv->tag));
269
270 30
        if (!vstrcmp("true", a3))
271 12
                b = 1;
272 18
        else if (!vstrcmp("false", a3))
273 12
                b = 0;
274 6
        else {
275 6
                return (ban_error(bp,
276 6
                    "expected boolean (true/false), got \"%s\"", a3));
277 6
        }
278
279 24
        ban_add_lump(bp, &b, 1);
280 24
        VSB_putc(bp->vsb, op);
281 24
        return (NULL);
282 30
}
283
284
static const char *
285
ban_add_duration(struct ban_proto *bp, const struct pvar *pv, int op, const char *a3)
286 30
{
287 30
        double darg;
288
289 30
        assert(pv->flag & BANS_FLAG_DURATION);
290 30
        darg = VNUM_duration(a3);
291 30
        if (isnan(darg)) {
292 2
                return (ban_error(bp,
293 2
                    "expected duration <n.nn>[ms|s|m|h|d|w|y] got \"%s\"", a3));
294 2
        }
295 28
        return (ban_add_double(bp, pv, op, darg));
296 30
}
297
298
const char *
299
BAN_AddTest(struct ban_proto *bp,
300
    const char *a1, const char *a2, const char *a3)
301 170
{
302 170
        const struct pvar *pv;
303 170
        int op;
304
305 170
        CHECK_OBJ_NOTNULL(bp, BAN_PROTO_MAGIC);
306 170
        AN(bp->vsb);
307 170
        AN(a1);
308 170
        AN(a2);
309 170
        AN(a3);
310
311 170
        if (bp->err != NULL)
312 0
                return (bp->err);
313
314 962
        for (pv = pvars; pv->name != NULL; pv++) {
315 954
                if (!(pv->flag & BANS_FLAG_HTTP) && !vstrcmp(a1, pv->name))
316 113
                        break;
317 841
                if ((pv->flag & BANS_FLAG_HTTP) && !vstrncmp(a1, pv->name, vstrlen(pv->name)))
318 49
                        break;
319 841
        }
320
321 170
        if (pv->name == NULL)
322 8
                return (ban_error(bp,
323 8
                    "Unknown or unsupported field \"%s\"", a1));
324
325 162
        bp->flags |= pv->flag;
326
327 162
        VSB_putc(bp->vsb, pv->tag);
328 162
        if (pv->flag & BANS_FLAG_HTTP) {
329 49
                if (vstrlen(a1 + vstrlen(pv->name)) < 1)
330 1
                        return (ban_error(bp,
331 1
                            "Missing header name: \"%s\"", pv->name));
332 48
                assert(BANS_HAS_ARG1_SPEC(pv->tag));
333 48
                ban_parse_http(bp, a1 + vstrlen(pv->name));
334 48
        }
335
336 161
        op = ban_parse_oper(a2);
337 161
        if (op < BANS_OPER_OFF_ ||
338 161
            ((1U << BAN_OPERIDX(op)) & arg_opervalid[BAN_ARGIDX(pv->tag)]) == 0)
339 12
                return (ban_error(bp,
340 12
                    "expected conditional (%s) got \"%s\"",
341 12
                    arg_operhelp[BAN_ARGIDX(pv->tag)], a2));
342
343 149
        if (pv->flag & BANS_FLAG_DURATION)
344 30
                return (ban_add_duration(bp, pv, op, a3));
345 119
        else if (pv->flag & BANS_FLAG_BOOL)
346 30
                return (ban_add_bool(bp, pv, op, a3));
347 89
        else
348 89
                return (ban_add_spec(bp, pv, op, a3));
349 149
}
350
351
/*--------------------------------------------------------------------
352
 * We maintain ban_start as a pointer to the first element of the list
353
 * as a separate variable from the VTAILQ, to avoid depending on the
354
 * internals of the VTAILQ macros.  We tacitly assume that a pointer
355
 * write is always atomic in doing so.
356
 *
357
 * Returns:
358
 *   0: Ban successfully inserted
359
 *  -1: Ban not inserted due to shutdown in progress. The ban has been
360
 *      deleted.
361
 */
362
363
const char *
364
BAN_Commit(struct ban_proto *bp)
365 1150
{
366 1150
        struct ban  *b, *bi, *inited;
367 1150
        ssize_t ln;
368 1150
        vtim_real t0;
369 1150
        uint64_t u;
370
371 1150
        CHECK_OBJ_NOTNULL(bp, BAN_PROTO_MAGIC);
372 1150
        AN(bp->vsb);
373 1150
        assert(sizeof u == sizeof t0);
374
375 1150
        if (ban_shutdown)
376 0
                return (ban_error(bp, "Shutting down"));
377
378 1150
        AZ(VSB_finish(bp->vsb));
379 1150
        ln = VSB_len(bp->vsb);
380 1150
        assert(ln >= 0);
381
382 1150
        ALLOC_OBJ(b, BAN_MAGIC);
383 1150
        if (b == NULL)
384 0
                return (ban_error(bp, ban_build_err_no_mem));
385 1150
        VTAILQ_INIT(&b->objcore);
386
387 1150
        b->spec = malloc(ln + BANS_HEAD_LEN);
388 1150
        if (b->spec == NULL) {
389 0
                free(b);
390 0
                return (ban_error(bp, ban_build_err_no_mem));
391 0
        }
392
393 1150
        b->flags = bp->flags;
394
395 1150
        memset(b->spec, 0, BANS_HEAD_LEN);
396 1150
        t0 = VTIM_real();
397 1150
        vmemcpy(&u, &t0, sizeof u);
398 1150
        vbe64enc(b->spec + BANS_TIMESTAMP, u);
399 1150
        b->spec[BANS_FLAGS] = b->flags & 0xff;
400 1150
        vmemcpy(b->spec + BANS_HEAD_LEN, VSB_data(bp->vsb), ln);
401 1150
        ln += BANS_HEAD_LEN;
402 1150
        vbe32enc(b->spec + BANS_LENGTH, ln);
403
404 1150
        Lck_Lock(&ban_mtx);
405 1150
        if (ban_shutdown) {
406
                /* We could have raced a shutdown */
407 0
                Lck_Unlock(&ban_mtx);
408 0
                BAN_Free(b);
409 0
                return (ban_error(bp, "Shutting down"));
410 0
        }
411 1150
        inited = VTAILQ_FIRST(&ban_head);
412 1150
        VTAILQ_INSERT_HEAD(&ban_head, b, list);
413 1150
        ban_start = b;
414
415 1150
        VSC_C_main->bans++;
416 1150
        VSC_C_main->bans_added++;
417 1150
        bans_persisted_bytes += ln;
418 1150
        VSC_C_main->bans_persisted_bytes = bans_persisted_bytes;
419
420 1150
        if (b->flags & BANS_FLAG_OBJ)
421 86
                VSC_C_main->bans_obj++;
422 1150
        if (b->flags & BANS_FLAG_REQ)
423 42
                VSC_C_main->bans_req++;
424
425 1150
        if (cache_param->ban_dups) {
426
                /* Hunt down duplicates, and mark them as completed */
427 1514
                for (bi = VTAILQ_NEXT(b, list); bi != NULL;
428 1150
                    bi = VTAILQ_NEXT(bi, list)) {
429 364
                        if (!(bi->flags & BANS_FLAG_COMPLETED) &&
430 364
                            ban_equal(b->spec, bi->spec)) {
431 13
                                ban_mark_completed(bi);
432 13
                                VSC_C_main->bans_dups++;
433 13
                        }
434 364
                }
435 1150
        }
436
437 1150
        if (!(b->flags & BANS_FLAG_REQ))
438 1108
                ban_kick_lurker();
439
440 1150
        if (inited != NULL)
441 124
                ban_info_new(b->spec, ln);      /* Notify stevedores */
442 1150
        Lck_Unlock(&ban_mtx);
443
444 1150
        BAN_Abandon(bp);
445 1150
        return (NULL);
446 1150
}
447
448
static void
449
ban_build_arg_operhelp(struct vsb *vsb, int arg)
450 12312
{
451 12312
        unsigned mask;
452 12312
        const char *p = NULL, *n = NULL;
453 12312
        int i;
454
455 12312
        ASSERT_BAN_ARG(arg);
456 12312
        mask = arg_opervalid[BAN_ARGIDX(arg)];
457
458 110808
        for (i = 0; i < BAN_OPERARRSZ; i++) {
459 98496
                if ((mask & (1U << i)) == 0)
460 45144
                        continue;
461 53352
                if (p == NULL)
462 12312
                        p = ban_oper[i];
463 41040
                else if (n == NULL)
464 12312
                        n = ban_oper[i];
465 28728
                else {
466 28728
                        VSB_cat(vsb, p);
467 28728
                        VSB_cat(vsb, ", ");
468 28728
                        p = n;
469 28728
                        n = ban_oper[i];
470 28728
                }
471 53352
        }
472
473 12312
        if (n) {
474 12312
                AN(p);
475 12312
                VSB_cat(vsb, p);
476 12312
                VSB_cat(vsb, " or ");
477 12312
                VSB_cat(vsb, n);
478 12312
                return;
479 12312
        }
480
481 0
        AN(p);
482 0
        VSB_cat(vsb, p);
483 0
}
484
485
void
486 1026
BAN_Build_Init(void) {
487 1026
        struct vsb *vsb;
488 1026
        int i;
489
490 1026
        vsb = VSB_new_auto();
491 1026
        AN(vsb);
492 13338
        for (i = BANS_ARG_OFF_; i < BANS_ARG_LIM; i ++) {
493 12312
                VSB_clear(vsb);
494 12312
                ban_build_arg_operhelp(vsb, i);
495 12312
                AZ(VSB_finish(vsb));
496
497 12312
                arg_operhelp[BAN_ARGIDX(i)] = strdup(VSB_data(vsb));
498 12312
                AN(arg_operhelp[BAN_ARGIDX(i)]);
499 12312
        }
500 1026
        arg_operhelp[BAN_ARGIDX(i)] = NULL;
501 1026
        VSB_destroy(&vsb);
502 1026
}
503
504
void
505 1013
BAN_Build_Fini(void) {
506 1013
        int i;
507
508 13169
        for (i = 0; i < BAN_ARGARRSZ; i++)
509 12156
                free(TRUST_ME(arg_operhelp[i]));
510 1013
}