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 106086
vsl_diag(struct VSL_data *vsl, const char *fmt, ...)
68
{
69
        va_list ap;
70
71 106086
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
72 106086
        AN(fmt);
73
74 106086
        if (vsl->diag == NULL)
75 106086
                vsl->diag = VSB_new_auto();
76 106086
        AN(vsl->diag);
77 106086
        VSB_clear(vsl->diag);
78 106086
        va_start(ap, fmt);
79 106086
        VSB_vprintf(vsl->diag, fmt, ap);
80 106086
        va_end(ap);
81 106086
        AZ(VSB_finish(vsl->diag));
82 106086
        return (-1);
83
}
84
85
struct VSL_data *
86 33100
VSL_New(void)
87
{
88
        struct VSL_data *vsl;
89
90 33100
        ALLOC_OBJ(vsl, VSL_MAGIC);
91 33100
        if (vsl == NULL)
92 0
                return (NULL);
93
94 33100
        vsl->L_opt = 1000;
95 33100
        vsl->T_opt = 120.;
96 33100
        vsl->vbm_select = vbit_new(SLT__MAX);
97 33100
        vsl->vbm_supress = vbit_new(SLT__MAX);
98 33100
        VTAILQ_INIT(&vsl->vslf_select);
99 33100
        VTAILQ_INIT(&vsl->vslf_suppress);
100
101 33100
        return (vsl);
102 33100
}
103
104
static void
105 59200
vsl_IX_free(vslf_list *filters)
106
{
107
        struct vslf *vslf;
108
109 59275
        while (!VTAILQ_EMPTY(filters)) {
110 75
                vslf = VTAILQ_FIRST(filters);
111 75
                CHECK_OBJ_NOTNULL(vslf, VSLF_MAGIC);
112 75
                VTAILQ_REMOVE(filters, vslf, list);
113 75
                if (vslf->tags)
114 0
                        vbit_destroy(vslf->tags);
115 75
                AN(vslf->vre);
116 75
                VRE_free(&vslf->vre);
117 75
                AZ(vslf->vre);
118 75
                FREE_OBJ(vslf);
119
        }
120 59200
}
121
122
void
123 29600
VSL_Delete(struct VSL_data *vsl)
124
{
125
126 29600
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
127
128 29600
        vbit_destroy(vsl->vbm_select);
129 29600
        vbit_destroy(vsl->vbm_supress);
130 29600
        vsl_IX_free(&vsl->vslf_select);
131 29600
        vsl_IX_free(&vsl->vslf_suppress);
132 29600
        VSL_ResetError(vsl);
133 29600
        FREE_OBJ(vsl);
134 29600
}
135
136
const char *
137 106086
VSL_Error(const struct VSL_data *vsl)
138
{
139
140 106086
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
141
142 106086
        if (vsl->diag == NULL)
143 0
                return (NULL);
144
        else
145 106086
                return (VSB_data(vsl->diag));
146 106086
}
147
148
void
149 134361
VSL_ResetError(struct VSL_data *vsl)
150
{
151
152 134361
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
153
154 134361
        if (vsl->diag == NULL)
155 29600
                return;
156 104761
        VSB_destroy(&vsl->diag);
157 134361
}
158
159
static int
160 725
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 725
        (void)vsl;
169 725
        tag = VSL_TAG(c->rec.ptr);
170 725
        cdata = VSL_CDATA(c->rec.ptr);
171 725
        len = VSL_LEN(c->rec.ptr);
172
173 1250
        VTAILQ_FOREACH(vslf, list, list) {
174 725
                CHECK_OBJ_NOTNULL(vslf, VSLF_MAGIC);
175 725
                if (vslf->tags != NULL && !vbit_test(vslf->tags, tag))
176 0
                        continue;
177 725
                if (VRE_match(vslf->vre, cdata, len, 0, NULL) >= 0)
178 200
                        return (1);
179 525
        }
180 525
        return (0);
181 725
}
182
183
int
184 722672
VSL_Match(struct VSL_data *vsl, const struct VSL_cursor *c)
185
{
186
        enum VSL_tag_e tag;
187
188 722672
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
189 722672
        if (c == NULL || c->rec.ptr == NULL)
190 16
                return (0);
191 722672
        tag = VSL_TAG(c->rec.ptr);
192 722672
        if (tag <= SLT__Bogus || tag >= SLT__Reserved)
193 12
                return (0);
194 722666
        if (!vsl->c_opt || !vsl->b_opt) {
195 721816
                if (vsl->c_opt && !VSL_CLIENT(c->rec.ptr))
196 2400
                        return (0);
197 719416
                if (vsl->b_opt && !VSL_BACKEND(c->rec.ptr))
198 0
                        return (0);
199 719416
        }
200 720266
        if (!VTAILQ_EMPTY(&vsl->vslf_select) &&
201 150
            vsl_match_IX(vsl, &vsl->vslf_select, c))
202 50
                return (1);
203 720216
        else if (vbit_test(vsl->vbm_select, tag))
204 0
                return (1);
205 720216
        else if (!VTAILQ_EMPTY(&vsl->vslf_suppress) &&
206 575
            vsl_match_IX(vsl, &vsl->vslf_suppress, c))
207 150
                return (0);
208 720066
        else if (vbit_test(vsl->vbm_supress, tag))
209 40724
                return (0);
210
211
        /* Default show */
212 679342
        return (1);
213 722666
}
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 1715
vsl_print_unsafe(FILE *fo, unsigned len, const char *data)
232
{
233
234 1715
        VSL_PRINT(fo, "\"");
235 106760
        while (len-- > 0) {
236 105045
                if (*data >= ' ' && *data <= '~')
237 103330
                        VSL_PRINT(fo, "%c", *data);
238
                else
239 1715
                        VSL_PRINT(fo, "%%%02x", (unsigned char)*data);
240 105045
                data++;
241
        }
242 1715
        VSL_PRINT(fo, "\"\n");
243 1715
        return (0);
244 1715
}
245
246
247
static int
248 560
vsl_print_binary(FILE *fo, unsigned len, const char *data)
249
{
250
251 560
        VSL_PRINT(fo, "[");
252 12800
        while (len-- > 0) {
253 12240
                VSL_PRINT(fo, "%02x", (unsigned char)*data);
254 12240
                data++;
255
        }
256 560
        VSL_PRINT(fo, "]\n");
257 560
        return (0);
258 560
}
259
260
static int
261 13634
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 13634
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
271 13634
        if (c == NULL || c->rec.ptr == NULL)
272 0
                return (0);
273 13634
        if (fo == NULL)
274 0
                fo = stdout;
275 13634
        tag = VSL_TAG(c->rec.ptr);
276 13634
        vxid = VSL_ID(c->rec.ptr);
277 13634
        len = VSL_LEN(c->rec.ptr);
278 13634
        type = VSL_CLIENT(c->rec.ptr) ? 'c' : VSL_BACKEND(c->rec.ptr) ?
279
            'b' : '-';
280 13634
        data = VSL_CDATA(c->rec.ptr);
281
282 13634
        if (!terse)
283 10809
                VSL_PRINT(fo, "%10ju ", (uintmax_t)vxid);
284 13634
        VSL_PRINT(fo, "%-14s ", VSL_tags[tag]);
285 13634
        if (!terse)
286 10809
                VSL_PRINT(fo, "%c ", type);
287
288 13634
        if (VSL_tagflags[tag] & SLT_F_UNSAFE)
289 1715
                (void)vsl_print_unsafe(fo, len, data);
290 11919
        else if (VSL_tagflags[tag] & SLT_F_BINARY)
291 560
                (void)vsl_print_binary(fo, len, data);
292
        else
293 11359
                VSL_PRINT(fo, "%.*s\n", (int)len, data);
294
295 13634
        return (0);
296 13634
}
297
298
int
299 10809
VSL_Print(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
300
{
301
302 10809
        return (vsl_print(vsl, c, fo, 0));
303
}
304
305
int
306 2825
VSL_PrintTerse(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
307
{
308
309 2825
        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 19959
VSL_PrintTransactions(struct VSL_data *vsl, struct VSL_transaction * const pt[],
333
    void *fo)
334
{
335
        struct VSL_transaction *t;
336
        int i;
337 19959
        int delim = 0;
338
        int verbose;
339
340 19959
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
341 19959
        if (fo == NULL)
342 16359
                fo = stdout;
343 19959
        if (pt[0] == NULL)
344 0
                return (0);
345
346 40068
        for (t = pt[0]; t != NULL; t = *++pt) {
347 20109
                if (vsl->c_opt || vsl->b_opt) {
348 9175
                        switch (t->type) {
349
                        case VSL_t_req:
350 500
                                if (!vsl->c_opt)
351 0
                                        continue;
352 500
                                if (t->reason == VSL_r_esi && !vsl->E_opt)
353 100
                                        continue;
354 400
                                break;
355
                        case VSL_t_bereq:
356 100
                                if (!vsl->b_opt)
357 50
                                        continue;
358 50
                                break;
359
                        case VSL_t_raw:
360 8500
                                break;
361
                        default:
362 75
                                continue;
363
                        }
364 8950
                }
365
366 19884
                verbose = 0;
367 19884
                if (t->level == 0 || vsl->v_opt)
368 19284
                        verbose = 1;
369
370 19884
                if (t->level) {
371
                        /* Print header */
372 625
                        if (t->level > 3)
373 0
                                VSL_PRINT(fo, "*%1.1d* ", t->level);
374
                        else
375 625
                                VSL_PRINT(fo, "%-3.*s ",
376
                                    (int)(t->level), "***");
377 625
                        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 625
                        delim = 1;
383 625
                }
384
385 33518
                while (1) {
386
                        /* Print records */
387 57668
                        i = VSL_Next(t->c);
388 57668
                        if (i < 0)
389 0
                                return (i);
390 57668
                        if (i == 0)
391 19884
                                break;
392 37784
                        if (!VSL_Match(vsl, t->c))
393 24150
                                continue;
394 13634
                        if (t->level > 3)
395 0
                                VSL_PRINT(fo, "-%1.1d- ", t->level);
396 13634
                        else if (t->level)
397 2850
                                VSL_PRINT(fo, "%-3.*s ",
398
                                    (int)(t->level), "---");
399 13634
                        if (verbose)
400 10809
                                i = VSL_Print(vsl, t->c, fo);
401
                        else
402 2825
                                i = VSL_PrintTerse(vsl, t->c, fo);
403 13634
                        if (i != 0)
404 0
                                return (i);
405
                }
406 19884
        }
407
408 19959
        if (delim)
409 625
                VSL_PRINT(fo, "\n");;
410
411 19959
        return (0);
412 19959
}
413
414
FILE*
415 100
VSL_WriteOpen(struct VSL_data *vsl, const char *name, int append, int unbuf)
416
{
417
        FILE* f;
418
419 100
        if (!strcmp(name, "-"))
420 25
                f = stdout;
421
        else
422 75
                f = fopen(name, append ? "a" : "w");
423 100
        if (f == NULL) {
424 25
                vsl_diag(vsl, "%s", strerror(errno));
425 25
                return (NULL);
426
        }
427 75
        if (unbuf)
428 0
                setbuf(f, NULL);
429 75
        if (ftell(f) == 0 || f == stdout) {
430 75
                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 75
        }
437 75
        return (f);
438 100
}
439
440
int
441 2675
VSL_Write(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
442
{
443
        size_t r;
444
445 2675
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
446 2675
        if (c == NULL || c->rec.ptr == NULL)
447 0
                return (0);
448 2675
        if (fo == NULL)
449 0
                fo = stdout;
450 5350
        r = fwrite(c->rec.ptr, sizeof *c->rec.ptr,
451 2675
            VSL_NEXT(c->rec.ptr) - c->rec.ptr, fo);
452 2675
        if (r == 0)
453 0
                return (-5);
454 2675
        return (0);
455 2675
}
456
457
int
458 225
VSL_WriteAll(struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
459
{
460
        int i;
461
462 225
        if (c == NULL)
463 0
                return (0);
464 2900
        while (1) {
465 6800
                i = VSL_Next(c);
466 6800
                if (i <= 0)
467 225
                        return (i);
468 6575
                if (!VSL_Match(vsl, c))
469 3900
                        continue;
470 2675
                i = VSL_Write(vsl, c, fo);
471 2675
                if (i != 0)
472 0
                        return (i);
473
        }
474 225
}
475
476
int v_matchproto_(VSLQ_dispatch_f)
477 225
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 225
        if (pt == NULL)
484 0
                return (0);
485 450
        for (i = 0, t = pt[0]; i == 0 && t != NULL; t = *++pt)
486 225
                i = VSL_WriteAll(vsl, t->c, fo);
487 225
        return (i);
488 225
}