varnish-cache/lib/libvarnishapi/vsl.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 <stdarg.h>
35
#include <stdint.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
51
/*--------------------------------------------------------------------*/
52
53
const char                      vsl_file_id[] = {'V', 'S', 'L', '2'};
54
55
const char * const VSL_tags[SLT__MAX] = {
56
#  define SLTM(foo,flags,sdesc,ldesc)       [SLT_##foo] = #foo,
57
#  include "tbl/vsl_tags.h"
58
};
59
60
const unsigned VSL_tagflags[SLT__MAX] = {
61
#  define SLTM(foo, flags, sdesc, ldesc)        [SLT_##foo] = flags,
62
#  include "tbl/vsl_tags.h"
63
#  undef SLTM
64
};
65
66
int
67 9183
vsl_diag(struct VSL_data *vsl, const char *fmt, ...)
68
{
69
        va_list ap;
70
71 9183
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
72 9183
        AN(fmt);
73
74 9183
        if (vsl->diag == NULL)
75 9183
                vsl->diag = VSB_new_auto();
76 9183
        AN(vsl->diag);
77 9183
        VSB_clear(vsl->diag);
78 9183
        va_start(ap, fmt);
79 9183
        VSB_vprintf(vsl->diag, fmt, ap);
80 9183
        va_end(ap);
81 9183
        AZ(VSB_finish(vsl->diag));
82 9183
        return (-1);
83
}
84
85
struct VSL_data *
86 2806
VSL_New(void)
87
{
88
        struct VSL_data *vsl;
89
90 2806
        ALLOC_OBJ(vsl, VSL_MAGIC);
91 2806
        if (vsl == NULL)
92 0
                return (NULL);
93
94 2806
        vsl->L_opt = 1000;
95 2806
        vsl->T_opt = 120.;
96 2806
        vsl->vbm_select = vbit_new(SLT__MAX);
97 2806
        vsl->vbm_suppress = vbit_new(SLT__MAX);
98 2806
        VTAILQ_INIT(&vsl->vslf_select);
99 2806
        VTAILQ_INIT(&vsl->vslf_suppress);
100
101 2806
        return (vsl);
102 2806
}
103
104
static void
105 5040
vsl_IX_free(vslf_list *filters)
106
{
107
        struct vslf *vslf;
108
109 5048
        while (!VTAILQ_EMPTY(filters)) {
110 8
                vslf = VTAILQ_FIRST(filters);
111 8
                CHECK_OBJ_NOTNULL(vslf, VSLF_MAGIC);
112 8
                VTAILQ_REMOVE(filters, vslf, list);
113 8
                if (vslf->tags)
114 0
                        vbit_destroy(vslf->tags);
115 8
                AN(vslf->vre);
116 8
                VRE_free(&vslf->vre);
117 8
                AZ(vslf->vre);
118 8
                FREE_OBJ(vslf);
119
        }
120 5040
}
121
122
void
123 2520
VSL_Delete(struct VSL_data *vsl)
124
{
125
126 2520
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
127
128 2520
        vbit_destroy(vsl->vbm_select);
129 2520
        vbit_destroy(vsl->vbm_suppress);
130 2520
        vsl_IX_free(&vsl->vslf_select);
131 2520
        vsl_IX_free(&vsl->vslf_suppress);
132 2520
        VSL_ResetError(vsl);
133 2520
        FREE_OBJ(vsl);
134 2520
}
135
136
const char *
137 9183
VSL_Error(const struct VSL_data *vsl)
138
{
139
140 9183
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
141
142 9183
        if (vsl->diag == NULL)
143 0
                return (NULL);
144
        else
145 9183
                return (VSB_data(vsl->diag));
146 9183
}
147
148
void
149 11597
VSL_ResetError(struct VSL_data *vsl)
150
{
151
152 11597
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
153
154 11597
        if (vsl->diag == NULL)
155 2520
                return;
156 9077
        VSB_destroy(&vsl->diag);
157 11597
}
158
159
static int
160 104
vsl_match_IX(struct VSL_data *vsl, const vslf_list *list,
161
    const struct VSL_cursor *c)
162
{
163
        enum VSL_tag_e tag;
164
        const char *cdata;
165
        int len;
166
        const struct vslf *vslf;
167
168 104
        (void)vsl;
169 104
        tag = VSL_TAG(c->rec.ptr);
170 104
        cdata = VSL_CDATA(c->rec.ptr);
171 104
        len = VSL_LEN(c->rec.ptr);
172
173 180
        VTAILQ_FOREACH(vslf, list, list) {
174 104
                CHECK_OBJ_NOTNULL(vslf, VSLF_MAGIC);
175 104
                if (vslf->tags != NULL && !vbit_test(vslf->tags, tag))
176 0
                        continue;
177 104
                if (VRE_match(vslf->vre, cdata, len, 0, NULL) >= 0)
178 28
                        return (1);
179 76
        }
180 76
        return (0);
181 104
}
182
183
int
184 65267
VSL_Match(struct VSL_data *vsl, const struct VSL_cursor *c)
185
{
186
        enum VSL_tag_e tag;
187
188 65267
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
189 65267
        if (c == NULL || c->rec.ptr == NULL)
190 2
                return (0);
191 65267
        tag = VSL_TAG(c->rec.ptr);
192 65267
        if (tag <= SLT__Bogus || tag >= SLT__Reserved)
193 2
                return (0);
194 65267
        if (!vsl->c_opt || !vsl->b_opt) {
195 65198
                if (vsl->c_opt && !VSL_CLIENT(c->rec.ptr))
196 196
                        return (0);
197 65002
                if (vsl->b_opt && !VSL_BACKEND(c->rec.ptr))
198 0
                        return (0);
199 65002
        }
200 65071
        if (!VTAILQ_EMPTY(&vsl->vslf_select) &&
201 12
            vsl_match_IX(vsl, &vsl->vslf_select, c))
202 4
                return (1);
203 65067
        else if (vbit_test(vsl->vbm_select, tag))
204 0
                return (1);
205 65067
        else if (!VTAILQ_EMPTY(&vsl->vslf_suppress) &&
206 92
            vsl_match_IX(vsl, &vsl->vslf_suppress, c))
207 24
                return (0);
208 65043
        else if (vbit_test(vsl->vbm_suppress, tag))
209 3270
                return (0);
210
211
        /* Default show */
212 61773
        return (1);
213 65267
}
214
215
static const char * const VSL_transactions[VSL_t__MAX] = {
216
        /*                 12345678901234 */
217
        [VSL_t_unknown] = "<< Unknown  >>",
218
        [VSL_t_sess]    = "<< Session  >>",
219
        [VSL_t_req]     = "<< Request  >>",
220
        [VSL_t_bereq]   = "<< BeReq    >>",
221
        [VSL_t_raw]     = "<< Record   >>",
222
};
223
224
#define VSL_PRINT(...)                                  \
225
        do {                                            \
226
                if (0 > fprintf(__VA_ARGS__))           \
227
                        return (-5);                    \
228
        } while (0)
229
230
static int
231 163
vsl_print_unsafe(FILE *fo, unsigned len, const char *data)
232
{
233
234 163
        VSL_PRINT(fo, "\"");
235 9989
        while (len-- > 0) {
236 9826
                if (*data >= ' ' && *data <= '~')
237 9663
                        VSL_PRINT(fo, "%c", *data);
238
                else
239 163
                        VSL_PRINT(fo, "%%%02x", (unsigned char)*data);
240 9826
                data++;
241
        }
242 163
        VSL_PRINT(fo, "\"\n");
243 163
        return (0);
244 163
}
245
246
247
static int
248 48
vsl_print_binary(FILE *fo, unsigned len, const char *data)
249
{
250
251 48
        VSL_PRINT(fo, "[");
252 1064
        while (len-- > 0) {
253 1016
                VSL_PRINT(fo, "%02x", (unsigned char)*data);
254 1016
                data++;
255
        }
256 48
        VSL_PRINT(fo, "]\n");
257 48
        return (0);
258 48
}
259
260
static int
261 1144
vsl_print(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo,
262
    int terse)
263
{
264
        enum VSL_tag_e tag;
265
        uint64_t vxid;
266
        unsigned len;
267
        const char *data;
268
        int type;
269
270 1144
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
271 1144
        if (c == NULL || c->rec.ptr == NULL)
272 0
                return (0);
273 1144
        if (fo == NULL)
274 0
                fo = stdout;
275 1144
        tag = VSL_TAG(c->rec.ptr);
276 1144
        vxid = VSL_ID(c->rec.ptr);
277 1144
        len = VSL_LEN(c->rec.ptr);
278 1144
        type = VSL_CLIENT(c->rec.ptr) ? 'c' : VSL_BACKEND(c->rec.ptr) ?
279
            'b' : '-';
280 1144
        data = VSL_CDATA(c->rec.ptr);
281
282 1144
        if (!terse)
283 918
                VSL_PRINT(fo, "%10ju ", (uintmax_t)vxid);
284 1144
        VSL_PRINT(fo, "%-14s ", VSL_tags[tag]);
285 1144
        if (!terse)
286 918
                VSL_PRINT(fo, "%c ", type);
287
288 1144
        if (VSL_tagflags[tag] & SLT_F_UNSAFE)
289 163
                (void)vsl_print_unsafe(fo, len, data);
290 981
        else if (VSL_tagflags[tag] & SLT_F_BINARY)
291 48
                (void)vsl_print_binary(fo, len, data);
292
        else
293 933
                VSL_PRINT(fo, "%.*s\n", (int)len, data);
294
295 1144
        return (0);
296 1144
}
297
298
int
299 918
VSL_Print(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
300
{
301
302 918
        return (vsl_print(vsl, c, fo, 0));
303
}
304
305
int
306 226
VSL_PrintTerse(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
307
{
308
309 226
        return (vsl_print(vsl, c, fo, 1));
310
}
311
312
int
313 0
VSL_PrintAll(struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
314
{
315
        int i;
316
317 0
        if (c == NULL)
318 0
                return (0);
319 0
        while (1) {
320 0
                i = VSL_Next(c);
321 0
                if (i <= 0)
322 0
                        return (i);
323 0
                if (!VSL_Match(vsl, c))
324 0
                        continue;
325 0
                i = VSL_Print(vsl, c, fo);
326 0
                if (i != 0)
327 0
                        return (i);
328
        }
329 0
}
330
331
int v_matchproto_(VSLQ_dispatch_f)
332 1666
VSL_PrintTransactions(struct VSL_data *vsl, struct VSL_transaction * const pt[],
333
    void *fo)
334
{
335
        struct VSL_transaction *t;
336
        int i;
337 1666
        int delim = 0;
338
        int verbose;
339
340 1666
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
341 1666
        if (fo == NULL)
342 1366
                fo = stdout;
343 1666
        if (pt[0] == NULL)
344 0
                return (0);
345
346 3344
        for (t = pt[0]; t != NULL; t = *++pt) {
347 1678
                if (vsl->c_opt || vsl->b_opt) {
348 738
                        switch (t->type) {
349
                        case VSL_t_req:
350 40
                                if (!vsl->c_opt)
351 0
                                        continue;
352 40
                                if (t->reason == VSL_r_esi && !vsl->E_opt)
353 8
                                        continue;
354 32
                                break;
355
                        case VSL_t_bereq:
356 8
                                if (!vsl->b_opt)
357 4
                                        continue;
358 4
                                break;
359
                        case VSL_t_raw:
360 684
                                break;
361
                        default:
362 6
                                continue;
363
                        }
364 720
                }
365
366 1660
                verbose = 0;
367 1660
                if (t->level == 0 || vsl->v_opt)
368 1612
                        verbose = 1;
369
370 1660
                if (t->level) {
371
                        /* Print header */
372 50
                        if (t->level > 3)
373 0
                                VSL_PRINT(fo, "*%1.1d* ", t->level);
374
                        else
375 50
                                VSL_PRINT(fo, "%-3.*s ",
376
                                    (int)(t->level), "***");
377 50
                        VSL_PRINT(fo, "%*.s%-14s %*.s%-10ju\n",
378
                            verbose ? 10 + 1 : 0, " ",
379
                            VSL_transactions[t->type],
380
                            verbose ? 1 + 1 : 0, " ",
381
                            (uintmax_t)t->vxid);
382 50
                        delim = 1;
383 50
                }
384
385 2804
                while (1) {
386
                        /* Print records */
387 4752
                        i = VSL_Next(t->c);
388 4752
                        if (i < 0)
389 0
                                return (i);
390 4752
                        if (i == 0)
391 1660
                                break;
392 3092
                        if (!VSL_Match(vsl, t->c))
393 1948
                                continue;
394 1144
                        if (t->level > 3)
395 0
                                VSL_PRINT(fo, "-%1.1d- ", t->level);
396 1144
                        else if (t->level)
397 228
                                VSL_PRINT(fo, "%-3.*s ",
398
                                    (int)(t->level), "---");
399 1144
                        if (verbose)
400 918
                                i = VSL_Print(vsl, t->c, fo);
401
                        else
402 226
                                i = VSL_PrintTerse(vsl, t->c, fo);
403 1144
                        if (i != 0)
404 0
                                return (i);
405
                }
406 1660
        }
407
408 1666
        if (delim)
409 50
                VSL_PRINT(fo, "\n");;
410
411 1666
        return (0);
412 1666
}
413
414
FILE*
415 8
VSL_WriteOpen(struct VSL_data *vsl, const char *name, int append, int unbuf)
416
{
417
        FILE* f;
418
419 8
        if (!strcmp(name, "-"))
420 2
                f = stdout;
421
        else
422 6
                f = fopen(name, append ? "a" : "w");
423 8
        if (f == NULL) {
424 2
                vsl_diag(vsl, "%s", strerror(errno));
425 2
                return (NULL);
426
        }
427 6
        if (unbuf)
428 0
                setbuf(f, NULL);
429 6
        if (ftell(f) == 0 || f == stdout) {
430 6
                if (fwrite(VSL_FILE_ID, 1, sizeof VSL_FILE_ID, f) !=
431
                    sizeof VSL_FILE_ID) {
432 0
                        vsl_diag(vsl, "%s", strerror(errno));
433 0
                        (void)fclose(f);
434 0
                        return (NULL);
435
                }
436 6
        }
437 6
        return (f);
438 8
}
439
440
int
441 214
VSL_Write(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
442
{
443
        size_t r;
444
445 214
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
446 214
        if (c == NULL || c->rec.ptr == NULL)
447 0
                return (0);
448 214
        if (fo == NULL)
449 0
                fo = stdout;
450 428
        r = fwrite(c->rec.ptr, sizeof *c->rec.ptr,
451 214
            VSL_NEXT(c->rec.ptr) - c->rec.ptr, fo);
452 214
        if (r == 0)
453 0
                return (-5);
454 214
        return (0);
455 214
}
456
457
int
458 18
VSL_WriteAll(struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
459
{
460
        int i;
461
462 18
        if (c == NULL)
463 0
                return (0);
464 232
        while (1) {
465 548
                i = VSL_Next(c);
466 548
                if (i <= 0)
467 18
                        return (i);
468 530
                if (!VSL_Match(vsl, c))
469 316
                        continue;
470 214
                i = VSL_Write(vsl, c, fo);
471 214
                if (i != 0)
472 0
                        return (i);
473
        }
474 18
}
475
476
int v_matchproto_(VSLQ_dispatch_f)
477 18
VSL_WriteTransactions(struct VSL_data *vsl, struct VSL_transaction * const pt[],
478
    void *fo)
479
{
480
        struct VSL_transaction *t;
481
        int i;
482
483 18
        if (pt == NULL)
484 0
                return (0);
485 36
        for (i = 0, t = pt[0]; i == 0 && t != NULL; t = *++pt)
486 18
                i = VSL_WriteAll(vsl, t->c, fo);
487 18
        return (i);
488 18
}