varnish-cache/lib/libvarnishapi/vsl_query.c
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2015 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Martin Blix Grydeland <martin@varnish-software.com>
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 <ctype.h>
35
#include <math.h>
36
#include <stdio.h>
37
38
#include "vdef.h"
39
#include "vas.h"
40
#include "miniobj.h"
41
42
#include "vbm.h"
43
#include "vqueue.h"
44
#include "vre.h"
45
#include "vsb.h"
46
47
#include "vapi/vsl.h"
48
49
#include "vsl_api.h"
50
#include "vxp.h"
51
52
struct vslq_query {
53
        unsigned                magic;
54
#define VSLQ_QUERY_MAGIC        0x122322A5
55
56
        struct vex              *vex;
57
};
58
59
#define VSLQ_TEST_NUMOP(TYPE, PRE_LHS, OP, PRE_RHS)             \
60
        do {                                                    \
61
                switch (TYPE) {                                 \
62
                case VEX_INT:                                   \
63
                        if (PRE_LHS##_int OP PRE_RHS##_int)     \
64
                                return (1);                     \
65
                        return (0);                             \
66
                case VEX_FLOAT:                                 \
67
                        if (PRE_LHS##_float OP PRE_RHS##_float) \
68
                                return (1);                     \
69
                        return (0);                             \
70
                default:                                        \
71
                        WRONG("Wrong RHS type");                \
72
                }                                               \
73
        } while(0)                                              \
74
75
static int
76 3955
vslq_test_vxid(const struct vex *vex, const struct VSL_transaction *trans)
77
{
78
        const struct vex_rhs *rhs;
79
80 3955
        AN(vex);
81 3955
        AN(trans);
82
83 3955
        rhs = vex->rhs;
84 3955
        CHECK_OBJ_NOTNULL(rhs, VEX_RHS_MAGIC);
85
86
        /* Prepare */
87 3955
        switch (vex->tok) {
88
        case T_EQ:              /* == */
89
        case T_NEQ:             /* != */
90
        case '<':
91
        case '>':
92
        case T_LEQ:             /* <= */
93
        case T_GEQ:             /* >= */
94 3955
                if (rhs->type != VEX_INT)
95 0
                        WRONG("Wrong RHS type for vxid");
96
                /* FALLTHROUGH */
97
        default:
98 3955
                break;
99
        }
100
101
        /* Compare */
102 3955
        switch (vex->tok) {
103
#define VXID_TEST_NUMOP(OP) return (trans->vxid OP rhs->val_int)
104 3955
        case T_EQ:      VXID_TEST_NUMOP(==);
105 0
        case T_NEQ:     VXID_TEST_NUMOP(!=);
106 0
        case '<':       VXID_TEST_NUMOP(<);
107 0
        case '>':       VXID_TEST_NUMOP(>);
108 0
        case T_LEQ:     VXID_TEST_NUMOP(<=);
109 0
        case T_GEQ:     VXID_TEST_NUMOP(>=);
110
        #undef VXID_TEST_NUMOP
111 0
        default:        WRONG("Bad vxid expression token");
112 0
        }
113
114 0
        NEEDLESS(return (0));
115 3955
}
116
117
static int
118 1924
vslq_test_rec(const struct vex *vex, const struct VSLC_ptr *rec)
119
{
120
        const struct vex_rhs *rhs;
121 1924
        long long lhs_int = 0;
122 1924
        double lhs_float = 0.;
123
        const char *b, *e;
124
        int i, dq;
125 1924
        char *q = NULL;
126
127 1924
        AN(vex);
128 1924
        AN(rec);
129
130 1924
        b = VSL_CDATA(rec->ptr);
131 1924
        e = b + VSL_LEN(rec->ptr) - 1;
132
133
        /* Prefix */
134 1924
        if (vex->lhs->prefix != NULL) {
135 545
                if (strncasecmp(b, vex->lhs->prefix, vex->lhs->prefixlen))
136 415
                        return (0);
137 130
                if (b[vex->lhs->prefixlen] != ':')
138 0
                        return (0);
139 130
                b += vex->lhs->prefixlen + 1;
140
                /* Skip ws */
141 185
                while (*b && isspace(*b))
142 55
                        b++;
143 130
        }
144
145
        /* Field */
146 1509
        if (vex->lhs->field > 0) {
147 680
                for (e = b, i = 0, dq = 0; *e && i < vex->lhs->field; i++) {
148
                        /* Skip end of previous field */
149 545
                        if (dq) {
150 15
                                assert(e > b);
151 15
                                assert(*e == '"');
152 15
                                dq = 0;
153 15
                                e++;
154 15
                                if (*e == '\0')
155 0
                                        break;
156 15
                                if (!isspace(*e))
157 5
                                        return (0);
158 10
                        }
159
160 540
                        b = e;
161
                        /* Skip ws */
162 1015
                        while (*b && isspace(*b))
163 475
                                b++;
164
165 540
                        dq = (*b == '"');
166 540
                        if (dq)
167 55
                                b++;
168 540
                        e = b;
169
170 540
                        if (dq) {
171
                                /* Find end of string */
172 320
                                while (*e && *e != '"')
173 265
                                        e++;
174 55
                                if (*e != '"')
175 5
                                        return (0);
176 50
                        } else {
177
                                /* Skip non-ws */
178 3020
                                while (*e && !isspace(*e))
179 2535
                                        e++;
180
                        }
181 535
                }
182 135
                assert(b <= e);
183 135
                if (*b == '\0' || i < vex->lhs->field)
184
                        /* Missing field - no match */
185 0
                        return (0);
186 135
        }
187
188 1499
        if (vex->tok == T_TRUE)
189
                /* Always true */
190 520
                return (1);
191
192 979
        rhs = vex->rhs;
193 979
        CHECK_OBJ_NOTNULL(rhs, VEX_RHS_MAGIC);
194
195
        /* Prepare */
196 979
        switch (vex->tok) {
197
        case T_EQ:              /* == */
198
        case T_NEQ:             /* != */
199
        case '<':
200
        case '>':
201
        case T_LEQ:             /* <= */
202
        case T_GEQ:             /* >= */
203
                /* Numerical comparison */
204 375
                if (*b == '\0')
205
                        /* Empty string doesn't match */
206 0
                        return (0);
207 375
                errno = 0;
208 375
                switch (rhs->type) {
209
                case VEX_INT:
210 285
                        lhs_int = strtoll(b, &q, 0);
211 285
                        AN(q);
212 285
                        if (q != e && (*q == '.' || *q == 'e')) {
213 25
                                errno = 0;
214 25
                                lhs_float = strtod(b, &q);
215 25
                                lhs_int = (long long)lhs_float;
216 25
                                lhs_float = 0.;
217 25
                        }
218 285
                        break;
219
                case VEX_FLOAT:
220 90
                        lhs_float = strtod(b, &q);
221 90
                        break;
222
                default:
223 0
                        WRONG("Wrong RHS type");
224 0
                }
225 375
                if (q != e || errno != 0)
226 40
                        return (0);
227 335
                break;
228
        default:
229 604
                break;
230
        }
231
232
        /* Compare */
233 939
        switch (vex->tok) {
234
        case T_EQ:              /* == */
235 255
                VSLQ_TEST_NUMOP(rhs->type, lhs, ==, rhs->val);
236
        case T_NEQ:             /* != */
237 10
                VSLQ_TEST_NUMOP(rhs->type, lhs, !=, rhs->val);
238
        case '<':               /* < */
239 25
                VSLQ_TEST_NUMOP(rhs->type, lhs, <, rhs->val);
240
        case '>':
241 15
                VSLQ_TEST_NUMOP(rhs->type, lhs, >, rhs->val);
242
        case T_LEQ:             /* <= */
243 15
                VSLQ_TEST_NUMOP(rhs->type, lhs, <=, rhs->val);
244
        case T_GEQ:             /* >= */
245 15
                VSLQ_TEST_NUMOP(rhs->type, lhs, >=, rhs->val);
246
        case T_SEQ:             /* eq */
247 130
                assert(rhs->type == VEX_STRING);
248 130
                if (e - b != rhs->val_stringlen)
249 70
                        return (0);
250 60
                if (vex->options & VEX_OPT_CASELESS) {
251 0
                        if (strncasecmp(b, rhs->val_string, e - b))
252 0
                                return (0);
253 0
                } else {
254 60
                        if (strncmp(b, rhs->val_string, e - b))
255 0
                                return (0);
256
                }
257 60
                return (1);
258
        case T_SNEQ:            /* ne */
259 5
                assert(rhs->type == VEX_STRING);
260 5
                if (e - b != rhs->val_stringlen)
261 0
                        return (1);
262 5
                if (vex->options & VEX_OPT_CASELESS) {
263 0
                        if (strncasecmp(b, rhs->val_string, e - b))
264 0
                                return (1);
265 0
                } else {
266 5
                        if (strncmp(b, rhs->val_string, e - b))
267 5
                                return (1);
268
                }
269 0
                return (0);
270
        case '~':               /* ~ */
271 464
                assert(rhs->type == VEX_REGEX && rhs->val_regex != NULL);
272 464
                i = VRE_match(rhs->val_regex, b, e - b, 0, NULL);
273 464
                if (i != VRE_ERROR_NOMATCH)
274 250
                        return (1);
275 214
                return (0);
276
        case T_NOMATCH:         /* !~ */
277 5
                assert(rhs->type == VEX_REGEX && rhs->val_regex != NULL);
278 5
                i = VRE_match(rhs->val_regex, b, e - b, 0, NULL);
279 5
                if (i == VRE_ERROR_NOMATCH)
280 5
                        return (1);
281 0
                return (0);
282
        default:
283 0
                WRONG("Bad expression token");
284 0
        }
285 0
        NEEDLESS(return (0));
286 1924
}
287
288
static int
289 12915
vslq_test(const struct vex *vex, struct VSL_transaction * const ptrans[])
290
{
291
        struct VSL_transaction *t;
292
        int i;
293
294 12915
        CHECK_OBJ_NOTNULL(vex, VEX_MAGIC);
295 12915
        CHECK_OBJ_NOTNULL(vex->lhs, VEX_LHS_MAGIC);
296 12915
        AN(vex->lhs->tags);
297 12915
        assert(vex->lhs->vxid <= 1);
298
299 12915
        if (vex->lhs->vxid) {
300 3955
                AZ(vex->lhs->taglist);
301 7440
                for (t = ptrans[0]; t != NULL; t = *++ptrans)
302 3955
                        if (vslq_test_vxid(vex, t))
303 470
                                return (1);
304 3485
                return (0);
305
        }
306
307 8960
        AN(vex->lhs->taglist);
308
309 16979
        for (t = ptrans[0]; t != NULL; t = *++ptrans) {
310 9089
                if (vex->lhs->level >= 0) {
311 15
                        if (vex->lhs->level_pm < 0) {
312
                                /* OK if less than or equal */
313 5
                                if (t->level > vex->lhs->level)
314 0
                                        continue;
315 15
                        } else if (vex->lhs->level_pm > 0) {
316
                                /* OK if greater than or equal */
317 5
                                if (t->level < vex->lhs->level)
318 0
                                        continue;
319 5
                        } else {
320
                                /* OK if equal */
321 5
                                if (t->level != vex->lhs->level)
322 0
                                        continue;
323
                        }
324 15
                }
325
326 9089
                AZ(VSL_ResetCursor(t->c));
327 9943
                while (1) {
328 90398
                        i = VSL_Next(t->c);
329 90398
                        if (i < 0)
330 0
                                return (i);
331 90398
                        if (i == 0)
332 8019
                                break;
333 82379
                        assert(i == 1);
334 82379
                        AN(t->c->rec.ptr);
335
336 82379
                        if (!vbit_test(vex->lhs->tags, VSL_TAG(t->c->rec.ptr)))
337 80455
                                continue;
338
339 1924
                        i = vslq_test_rec(vex, &t->c->rec);
340 1924
                        if (i)
341 1070
                                return (i);
342
                }
343 8019
        }
344
345 7890
        return (0);
346 12915
}
347
348
static int
349 13145
vslq_exec(const struct vex *vex, struct VSL_transaction * const ptrans[])
350
{
351
        int r;
352
353 13145
        CHECK_OBJ_NOTNULL(vex, VEX_MAGIC);
354
355 13145
        switch (vex->tok) {
356
        case T_OR:
357 150
                AN(vex->a);
358 150
                AN(vex->b);
359 150
                r = vslq_exec(vex->a, ptrans);
360 150
                if (r != 0)
361 45
                        return (r);
362 105
                return (vslq_exec(vex->b, ptrans));
363
        case T_AND:
364 75
                AN(vex->a);
365 75
                AN(vex->b);
366 75
                r = vslq_exec(vex->a, ptrans);
367 75
                if (r <= 0)
368 35
                        return (r);
369 40
                return (vslq_exec(vex->b, ptrans));
370
        case T_NOT:
371 5
                AN(vex->a);
372 5
                AZ(vex->b);
373 5
                r = vslq_exec(vex->a, ptrans);
374 5
                if (r < 0)
375 0
                        return (r);
376 5
                return (!r);
377
        default:
378 12915
                return (vslq_test(vex, ptrans));
379
        }
380
        NEEDLESS(return (0));
381 13145
}
382
383
struct vslq_query *
384 865
vslq_newquery(struct VSL_data *vsl, enum VSL_grouping_e grouping,
385
    const char *querystring)
386
{
387
        struct vsb *vsb;
388
        struct vex *vex;
389 865
        struct vslq_query *query = NULL;
390
391 865
        (void)grouping;
392 865
        AN(querystring);
393
394 865
        vsb = VSB_new_auto();
395 865
        AN(vsb);
396 865
        vex = vex_New(querystring, vsb, vsl->C_opt ? VEX_OPT_CASELESS : 0);
397 865
        AZ(VSB_finish(vsb));
398 865
        if (vex == NULL)
399 160
                vsl_diag(vsl, "%s", VSB_data(vsb));
400
        else {
401 705
                ALLOC_OBJ(query, VSLQ_QUERY_MAGIC);
402 705
                XXXAN(query);
403 705
                query->vex = vex;
404
        }
405 865
        VSB_destroy(&vsb);
406 865
        return (query);
407
}
408
409
void
410 705
vslq_deletequery(struct vslq_query **pquery)
411
{
412
        struct vslq_query *query;
413
414 705
        TAKE_OBJ_NOTNULL(query, pquery, VSLQ_QUERY_MAGIC);
415
416 705
        AN(query->vex);
417 705
        vex_Free(&query->vex);
418 705
        AZ(query->vex);
419
420 705
        FREE_OBJ(query);
421 705
}
422
423
int
424 12771
vslq_runquery(const struct vslq_query *query,
425
    struct VSL_transaction * const ptrans[])
426
{
427
        struct VSL_transaction *t;
428
        int r;
429
430 12771
        CHECK_OBJ_NOTNULL(query, VSLQ_QUERY_MAGIC);
431
432 12771
        r = vslq_exec(query->vex, ptrans);
433 25735
        for (t = ptrans[0]; t != NULL; t = *++ptrans)
434 12964
                AZ(VSL_ResetCursor(t->c));
435 12771
        return (r);
436
}