varnish-cache/lib/libvarnishapi/vsl_arg.c
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
 * Author: Martin Blix Grydeland <martin@varnish-software.com>
7
 *
8
 * SPDX-License-Identifier: BSD-2-Clause
9
 *
10
 * Redistribution and use in source and binary forms, with or without
11
 * modification, are permitted provided that the following conditions
12
 * are met:
13
 * 1. Redistributions of source code must retain the above copyright
14
 *    notice, this list of conditions and the following disclaimer.
15
 * 2. Redistributions in binary form must reproduce the above copyright
16
 *    notice, this list of conditions and the following disclaimer in the
17
 *    documentation and/or other materials provided with the distribution.
18
 *
19
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
23
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29
 * SUCH DAMAGE.
30
 */
31
32
#include "config.h"
33
34
#include <ctype.h>
35
#include <limits.h>
36
#include <math.h>
37
#include <stdio.h>
38
#include <stdlib.h>
39
40
#include "vdef.h"
41
#include "vas.h"
42
#include "miniobj.h"
43
44
#include "vbm.h"
45
#include "vnum.h"
46
#include "vqueue.h"
47
#include "vre.h"
48
#include "vsb.h"
49
50
#include "vapi/vsl.h"
51
52
#include "vsl_api.h"
53
54
/*--------------------------------------------------------------------
55
 * Look up a tag
56
 *   0..255     tag number
57
 *   -1         no tag matches
58
 *   -2         multiple tags match
59
 */
60
61
int
62 46325
VSL_Name2Tag(const char *name, int l)
63
{
64
        int i, n;
65
66 46325
        if (l == -1)
67 4325
                l = strlen(name);
68 46325
        n = -1;
69 2113875
        for (i = 0; i < SLT__MAX; i++) {
70 2113475
                if (VSL_tags[i] != NULL &&
71 2002350
                    !strncasecmp(name, VSL_tags[i], l)) {
72 46775
                        if (strlen(VSL_tags[i]) == l) {
73
                                /* Exact match */
74 45925
                                return (i);
75
                        }
76 850
                        if (n == -1)
77 100
                                n = i;
78
                        else
79 750
                                n = -2;
80 850
                }
81 2067550
        }
82 400
        return (n);
83 46325
}
84
85
int
86 5775
VSL_Glob2Tags(const char *glob, int l, VSL_tagfind_f *func, void *priv)
87
{
88 5775
        const char *p1 = NULL;
89 5775
        const char *p2 = NULL;
90
        const char *e, *p;
91 5775
        int i, l1 = 0, l2 = 0, r = 0;
92
93 5775
        AN(glob);
94 5775
        if (l >= 0)
95 1475
                e = glob + l;
96
        else
97 4300
                e = strchr(glob, '\0');
98 5775
        if (glob == e)
99 50
                return (-1);            // Empty pattern cannot match
100
101 46550
        for (p = glob; p < e; p++)
102 41350
                if (*p == '*')
103 525
                        break;
104
105 5725
        if (p == e) {                   // No wildcard
106 5200
                i = VSL_Name2Tag(glob, l);
107 5200
                if (i < 0)
108 225
                        return (i);
109 4975
                if (func != NULL)
110 4975
                        (func)(i, priv);
111 4975
                return (1);
112
        }
113
114 525
        if (p != glob) {                // Prefix match
115 350
                p1 = glob;
116 350
                l1 = p - p1;
117 350
        }
118
119 525
        if (p != e - 1) {               // Postfix match
120 250
                p2 = p + 1;
121 250
                l2 = e - p2;
122 250
        }
123
124 1000
        for (p++; p < e; p++)
125 625
                if (*p == '*')
126 150
                        return (-3);    // More than one wildcard
127
128 96375
        for (i = 0; i < SLT__MAX; i++) {
129 96000
                p = VSL_tags[i];
130 96000
                if (p == NULL)
131 61125
                        continue;
132 34875
                e = strchr(p, '\0');
133 34875
                if ((e - p) - l1 < l2)
134 2450
                        continue;
135 32425
                if (p1 != NULL && strncasecmp(p, p1, l1))
136 23525
                        continue;
137 8900
                if (p2 != NULL && strncasecmp(e - l2, p2, l2))
138 4000
                        continue;
139 4900
                if (func != NULL)
140 4900
                        (func)(i, priv);
141 4900
                r++;
142 4900
        }
143 375
        if (r == 0)
144 25
                return (-1);
145 350
        return (r);
146 5775
}
147
148
int
149 1150
VSL_List2Tags(const char *list, int l, VSL_tagfind_f *func, void *priv)
150
{
151
        const char *p, *b, *e;
152 1150
        int r, t = 0;
153
154 1150
        p = list;
155 1150
        if (l >= 0)
156 75
                e = p + l;
157
        else
158 1075
                e = strchr(p, '\0');
159 2400
        while (p < e) {
160 1875
                while (p < e && *p == ',')
161 400
                        p++;
162 1475
                if (p == e)
163 25
                        break;
164 1450
                b = p;
165 9600
                while (p < e && *p != ',')
166 8150
                        p++;
167 1450
                r = VSL_Glob2Tags(b, p - b, func, priv);
168 1450
                if (r < 0)
169 200
                        return (r);
170 1250
                t += r;
171
        }
172 950
        if (t == 0)
173 25
                return (-1);
174 925
        return (t);
175 1150
}
176
177
const char *VSLQ_grouping[VSL_g__MAX] = {
178
        [VSL_g_raw]     = "raw",
179
        [VSL_g_vxid]    = "vxid",
180
        [VSL_g_request] = "request",
181
        [VSL_g_session] = "session",
182
};
183
184
int
185 5475
VSLQ_Name2Grouping(const char *name, int l)
186
{
187
        int i, n;
188
189 5475
        AN(name);
190 5475
        if (l == -1)
191 325
                l = strlen(name);
192 5475
        n = -1;
193 9875
        for (i = 0; i < VSL_g__MAX; i++) {
194 9825
                if (!strncasecmp(name, VSLQ_grouping[i], l)) {
195 5475
                        if (strlen(VSLQ_grouping[i]) == l) {
196
                                /* Exact match */
197 5425
                                return (i);
198
                        }
199 50
                        if (n == -1)
200 25
                                n = i;
201
                        else
202 25
                                n = -2;
203 50
                }
204 4400
        }
205 50
        return (n);
206 5475
}
207
208
void v_matchproto_(VSL_tagfind_f)
209 4450
vsl_vbm_bitset(int bit, void *priv)
210
{
211
212 4450
        vbit_set((struct vbitmap *)priv, bit);
213 4450
}
214
215
void v_matchproto_(VSL_tagfind_f)
216 1050
vsl_vbm_bitclr(int bit, void *priv)
217
{
218
219 1050
        vbit_clr((struct vbitmap *)priv, bit);
220 1050
}
221
222
static int
223 950
vsl_ix_arg(struct VSL_data *vsl, int opt, const char *arg)
224
{
225
        int i;
226
227 950
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
228 950
        vsl->flags |= F_SEEN_ixIX;
229
230 1900
        i = VSL_List2Tags(arg, -1, opt == 'x' ? vsl_vbm_bitset : vsl_vbm_bitclr,
231 950
            vsl->vbm_supress);
232 950
        if (i == -1)
233 50
                return (vsl_diag(vsl, "-%c: \"%s\" matches zero tags",
234 25
                    (char)opt, arg));
235 925
        else if (i == -2)
236 50
                return (vsl_diag(vsl, "-%c: \"%s\" is ambiguous",
237 25
                    (char)opt, arg));
238 900
        else if (i == -3)
239 100
                return (vsl_diag(vsl, "-%c: Syntax error in \"%s\"",
240 50
                    (char)opt, arg));
241
242 850
        return (1);
243 950
}
244
245
static int
246 175
vsl_IX_arg(struct VSL_data *vsl, int opt, const char *arg)
247
{
248
        int i, l, off, err;
249
        const char *b, *e;
250
        vre_t *vre;
251
        struct vsb vsb[1];
252
        struct vslf *vslf;
253 175
        struct vbitmap *tags = NULL;
254
        char errbuf[VRE_ERROR_LEN];
255
256
257 175
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
258 175
        AN(arg);
259 175
        vsl->flags |= F_SEEN_ixIX;
260
261 175
        b = arg;
262 175
        e = strchr(b, ':');
263 175
        if (e) {
264 75
                tags = vbit_new(SLT__MAX);
265 75
                AN(tags);
266 75
                l = e - b;
267 75
                i = VSL_List2Tags(b, l, vsl_vbm_bitset, tags);
268 75
                if (i < 0)
269 75
                        vbit_destroy(tags);
270 75
                if (i == -1)
271 50
                        return (vsl_diag(vsl,
272
                            "-%c: \"%*.*s\" matches zero tags",
273 25
                            (char)opt, l, l, b));
274 50
                else if (i == -2)
275 50
                        return (vsl_diag(vsl,
276
                            "-%c: \"%*.*s\" is ambiguous",
277 25
                            (char)opt, l, l, b));
278 25
                else if (i <= -3)
279 50
                        return (vsl_diag(vsl,
280
                            "-%c: Syntax error in \"%*.*s\"",
281 25
                            (char)opt, l, l, b));
282 0
                b = e + 1;
283 0
        }
284
285 100
        vre = VRE_compile(b, vsl->C_opt ? VRE_CASELESS : 0, &err, &off, 1);
286 100
        if (vre == NULL) {
287 25
                if (tags)
288 0
                        vbit_destroy(tags);
289 25
                AN(VSB_init(vsb, errbuf, sizeof errbuf));
290 25
                AZ(VRE_error(vsb, err));
291 25
                AZ(VSB_finish(vsb));
292 25
                VSB_fini(vsb);
293 50
                return (vsl_diag(vsl, "-%c: Regex error at position %d (%s)",
294 25
                    (char)opt, off, errbuf));
295
        }
296
297 75
        ALLOC_OBJ(vslf, VSLF_MAGIC);
298 75
        AN(vslf);
299 75
        vslf->tags = tags;
300 75
        vslf->vre = vre;
301
302 75
        if (opt == 'I')
303 50
                VTAILQ_INSERT_TAIL(&vsl->vslf_select, vslf, list);
304
        else {
305 25
                assert(opt == 'X');
306 25
                VTAILQ_INSERT_TAIL(&vsl->vslf_suppress, vslf, list);
307
        }
308
309 75
        return (1);
310 175
}
311
312
static int
313 275
vsl_R_arg(struct VSL_data *vsl, const char *arg)
314
{
315 275
        char buf[32] = "";
316
        char *p;
317
        long l;
318
319 275
        AN(arg);
320 275
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
321
322 275
        errno = 0;
323 275
        l = strtol(arg, &p, 0);
324 275
        if ((l == LONG_MIN || l == LONG_MAX) && errno == ERANGE)
325 0
                return (vsl_diag(vsl, "-R: Range error"));
326 275
        if (l <= 0 || l > INT_MAX)
327 75
                return (vsl_diag(vsl, "-R: Range error"));
328 200
        vsl->R_opt_l = l;
329 200
        assert(p != arg);
330 200
        AN(p);
331 200
        if (*p == '\0') {
332 0
                vsl->R_opt_p = 1.0;
333 0
                return (1);
334
        }
335 200
        if (*p != '/' || p[1] == '\0')
336 25
                return (vsl_diag(vsl, "-R: Syntax error"));
337 175
        p++;
338 175
        if (strlen(p) > sizeof(buf) - 2)
339 25
                return (vsl_diag(vsl, "-R: Syntax error"));
340 150
        if (!isdigit(*p))
341 75
                strcat(buf, "1");
342 150
        strcat(buf, p);
343 150
        vsl->R_opt_p = VNUM_duration(buf);
344 150
        if (isnan(vsl->R_opt_p) || vsl->R_opt_p <= 0.0)
345 100
                return (vsl_diag(vsl, "-R: Syntax error: Invalid duration"));
346 50
        return (1);
347 275
}
348
349
int
350 3900
VSL_Arg(struct VSL_data *vsl, int opt, const char *arg)
351
{
352
        int i;
353
        char *p;
354
        double d;
355
        long l;
356
357 3900
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
358
        /* If first option is 'i', set all bits for supression */
359 3900
        if ((opt == 'i' || opt == 'I') && !(vsl->flags & F_SEEN_ixIX))
360 173475
                for (i = 0; i < SLT__MAX; i++)
361 173475
                        vbit_set(vsl->vbm_supress, i);
362
363 3900
        switch (opt) {
364 350
        case 'b': vsl->b_opt = 1; return (1);
365 1750
        case 'c': vsl->c_opt = 1; return (1);
366
        case 'C':
367
                /* Caseless regular expressions */
368 50
                vsl->C_opt = 1;
369 50
                return (1);
370
        case 'E':
371 225
                vsl->E_opt = 1;
372 225
                vsl->c_opt = 1;
373 225
                return (1);
374 950
        case 'i': case 'x': return (vsl_ix_arg(vsl, opt, arg));
375 175
        case 'I': case 'X': return (vsl_IX_arg(vsl, opt, arg));
376
        case 'L':
377 25
                AN(arg);
378 25
                l = strtol(arg, &p, 0);
379 25
                while (isspace(*p))
380 0
                        p++;
381 25
                if (*p != '\0')
382 0
                        return (vsl_diag(vsl, "-L: Syntax error"));
383 25
                if (l <= 0 || l > INT_MAX)
384 25
                        return (vsl_diag(vsl, "-L: Range error"));
385 0
                vsl->L_opt = (int)l;
386 0
                return (1);
387
        case 'R':
388 275
                return (vsl_R_arg(vsl, arg));
389
        case 'T':
390 25
                AN(arg);
391 25
                d = VNUM(arg);
392 25
                if (isnan(d))
393 0
                        return (vsl_diag(vsl, "-T: Syntax error"));
394 25
                if (d < 0.)
395 0
                        return (vsl_diag(vsl, "-T: Range error"));
396 25
                vsl->T_opt = d;
397 25
                return (1);
398 25
        case 'v': vsl->v_opt = 1; return (1);
399
        default:
400 50
                return (0);
401
        }
402 3900
}