Code Coverage: vinyl-cache/lib/libvinylapi/vsl.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
 * 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
vsl_diag(struct VSL_data *vsl, const char *fmt, ...)
68 3593
{
69 3593
        va_list ap;
70
71 3593
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
72 3593
        AN(fmt);
73
74 3593
        if (vsl->diag == NULL)
75 3593
                vsl->diag = VSB_new_auto();
76 3593
        AN(vsl->diag);
77 3593
        VSB_clear(vsl->diag);
78 3593
        va_start(ap, fmt);
79 3593
        VSB_vprintf(vsl->diag, fmt, ap);
80 3593
        va_end(ap);
81 3593
        AZ(VSB_finish(vsl->diag));
82 3593
        return (-1);
83 3593
}
84
85
struct VSL_data *
86
VSL_New(void)
87 1558
{
88 1558
        struct VSL_data *vsl;
89
90 1558
        ALLOC_OBJ(vsl, VSL_MAGIC);
91 1558
        if (vsl == NULL)
92 0
                return (NULL);
93
94 1558
        vsl->L_opt = 1000;
95 1558
        vsl->T_opt = 120.;
96 1558
        vsl->vbm_select = vbit_new(SLT__MAX);
97 1558
        vsl->vbm_suppress = vbit_new(SLT__MAX);
98 1558
        VTAILQ_INIT(&vsl->vslf_select);
99 1558
        VTAILQ_INIT(&vsl->vslf_suppress);
100
101 1558
        return (vsl);
102 1558
}
103
104
static void
105
vsl_IX_free(vslf_list *filters)
106 2822
{
107 2822
        struct vslf *vslf;
108
109 2826
        while (!VTAILQ_EMPTY(filters)) {
110 4
                vslf = VTAILQ_FIRST(filters);
111 4
                CHECK_OBJ_NOTNULL(vslf, VSLF_MAGIC);
112 4
                VTAILQ_REMOVE(filters, vslf, list);
113 4
                if (vslf->tags)
114 0
                        vbit_destroy(vslf->tags);
115 4
                AN(vslf->vre);
116 4
                VRE_free(&vslf->vre);
117 4
                AZ(vslf->vre);
118 4
                FREE_OBJ(vslf);
119 4
        }
120 2822
}
121
122
void
123
VSL_Delete(struct VSL_data *vsl)
124 1411
{
125
126 1411
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
127
128 1411
        vbit_destroy(vsl->vbm_select);
129 1411
        vbit_destroy(vsl->vbm_suppress);
130 1411
        vsl_IX_free(&vsl->vslf_select);
131 1411
        vsl_IX_free(&vsl->vslf_suppress);
132 1411
        VSL_ResetError(vsl);
133 1411
        FREE_OBJ(vsl);
134 1411
}
135
136
const char *
137
VSL_Error(const struct VSL_data *vsl)
138 3593
{
139
140 3593
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
141
142 3593
        if (vsl->diag == NULL)
143 0
                return (NULL);
144 3593
        else
145 3593
                return (VSB_data(vsl->diag));
146 3593
}
147
148
void
149
VSL_ResetError(struct VSL_data *vsl)
150 4951
{
151
152 4951
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
153
154 4951
        if (vsl->diag == NULL)
155 1411
                return;
156 3540
        VSB_destroy(&vsl->diag);
157 3540
}
158
159
static int
160
vsl_match_IX(struct VSL_data *vsl, const vslf_list *list,
161
    const struct VSL_cursor *c)
162 52
{
163 52
        enum VSL_tag_e tag;
164 52
        const char *cdata;
165 52
        int len;
166 52
        const struct vslf *vslf;
167
168 52
        (void)vsl;
169 52
        tag = VSL_TAG(c->rec.ptr);
170 52
        cdata = VSL_CDATA(c->rec.ptr);
171 52
        len = VSL_LEN(c->rec.ptr);
172
173 52
        VTAILQ_FOREACH(vslf, list, list) {
174 52
                CHECK_OBJ_NOTNULL(vslf, VSLF_MAGIC);
175 52
                if (vslf->tags != NULL && !vbit_test(vslf->tags, tag))
176 0
                        continue;
177 52
                if (VRE_match(vslf->vre, cdata, len, 0, NULL) >= 0)
178 14
                        return (1);
179 52
        }
180 38
        return (0);
181 52
}
182
183
int
184
VSL_Match(struct VSL_data *vsl, const struct VSL_cursor *c)
185 32159
{
186 32159
        enum VSL_tag_e tag;
187
188 32159
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
189 32159
        if (c == NULL || c->rec.ptr == NULL)
190 0
                return (0);
191 32159
        tag = VSL_TAG(c->rec.ptr);
192 32159
        if (tag <= SLT__Bogus || tag >= SLT__Reserved)
193 0
                return (0);
194 32159
        if (!vsl->c_opt || !vsl->b_opt) {
195 32125
                if (vsl->c_opt && !VSL_CLIENT(c->rec.ptr))
196 96
                        return (0);
197 32029
                if (vsl->b_opt && !VSL_BACKEND(c->rec.ptr))
198 0
                        return (0);
199 32029
        }
200 32063
        if (!VTAILQ_EMPTY(&vsl->vslf_select) &&
201 32063
            vsl_match_IX(vsl, &vsl->vslf_select, c))
202 2
                return (1);
203 32061
        else if (vbit_test(vsl->vbm_select, tag))
204 0
                return (1);
205 32061
        else if (!VTAILQ_EMPTY(&vsl->vslf_suppress) &&
206 32061
            vsl_match_IX(vsl, &vsl->vslf_suppress, c))
207 12
                return (0);
208 32049
        else if (vbit_test(vsl->vbm_suppress, tag))
209 1693
                return (0);
210
211
        /* Default show */
212 30356
        return (1);
213 32063
}
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 7134
        do {                                            \
226 7134
                if (0 > fprintf(__VA_ARGS__))           \
227 7134
                        return (-5);                    \
228 7134
        } while (0)
229
230
static int
231
vsl_print_unsafe(FILE *fo, unsigned len, const char *data)
232 76
{
233
234 76
        VSL_PRINT(fo, "\"");
235 4412
        while (len-- > 0) {
236 4336
                if (*data >= ' ' && *data <= '~')
237 4260
                        VSL_PRINT(fo, "%c", *data);
238 76
                else
239 76
                        VSL_PRINT(fo, "%%%02x", (unsigned char)*data);
240 4336
                data++;
241 4336
        }
242 76
        VSL_PRINT(fo, "\"\n");
243 76
        return (0);
244 76
}
245
246
247
static int
248
vsl_print_binary(FILE *fo, unsigned len, const char *data)
249 22
{
250
251 22
        VSL_PRINT(fo, "[");
252 515
        while (len-- > 0) {
253 493
                VSL_PRINT(fo, "%02x", (unsigned char)*data);
254 493
                data++;
255 493
        }
256 22
        VSL_PRINT(fo, "]\n");
257 22
        return (0);
258 22
}
259
260
static int
261
vsl_print(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo,
262
    int terse)
263 561
{
264 561
        enum VSL_tag_e tag;
265 561
        uint64_t vxid;
266 561
        unsigned len;
267 561
        const char *data;
268 561
        int type;
269
270 561
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
271 561
        if (c == NULL || c->rec.ptr == NULL)
272 0
                return (0);
273 561
        if (fo == NULL)
274 0
                fo = stdout;
275 561
        tag = VSL_TAG(c->rec.ptr);
276 561
        vxid = VSL_ID(c->rec.ptr);
277 561
        len = VSL_LEN(c->rec.ptr);
278 561
        type = VSL_CLIENT(c->rec.ptr) ? 'c' : VSL_BACKEND(c->rec.ptr) ?
279 184
            'b' : '-';
280 561
        data = VSL_CDATA(c->rec.ptr);
281
282 561
        if (!terse)
283 448
                VSL_PRINT(fo, "%10ju ", (uintmax_t)vxid);
284 561
        VSL_PRINT(fo, "%-14s ", VSL_tags[tag]);
285 561
        if (!terse)
286 448
                VSL_PRINT(fo, "%c ", type);
287
288 561
        if (VSL_tagflags[tag] & SLT_F_UNSAFE)
289 76
                (void)vsl_print_unsafe(fo, len, data);
290 485
        else if (VSL_tagflags[tag] & SLT_F_BINARY)
291 22
                (void)vsl_print_binary(fo, len, data);
292 463
        else
293 463
                VSL_PRINT(fo, "%.*s\n", (int)len, data);
294
295 561
        return (0);
296 561
}
297
298
int
299
VSL_Print(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
300 448
{
301
302 448
        return (vsl_print(vsl, c, fo, 0));
303 448
}
304
305
int
306
VSL_PrintTerse(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
307 113
{
308
309 113
        return (vsl_print(vsl, c, fo, 1));
310 113
}
311
312
int
313
VSL_PrintAll(struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
314 0
{
315 0
        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 0
        }
329 0
}
330
331
int v_matchproto_(VSLQ_dispatch_f)
332
VSL_PrintTransactions(struct VSL_data *vsl, struct VSL_transaction * const pt[],
333
    void *fo)
334 836
{
335 836
        struct VSL_transaction *t;
336 836
        int i;
337 836
        int delim = 0;
338 836
        int verbose;
339
340 836
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
341 836
        if (fo == NULL)
342 694
                fo = stdout;
343 836
        if (pt[0] == NULL)
344 0
                return (0);
345
346 1678
        for (t = pt[0]; t != NULL; t = *++pt) {
347 842
                if (vsl->c_opt || vsl->b_opt) {
348 383
                        switch (t->type) {
349 20
                        case VSL_t_req:
350 20
                                if (!vsl->c_opt)
351 0
                                        continue;
352 20
                                if (t->reason == VSL_r_esi && !vsl->E_opt)
353 4
                                        continue;
354 16
                                break;
355 16
                        case VSL_t_bereq:
356 4
                                if (!vsl->b_opt)
357 2
                                        continue;
358 2
                                break;
359 356
                        case VSL_t_raw:
360 356
                                break;
361 3
                        default:
362 3
                                continue;
363 383
                        }
364 383
                }
365
366 833
                verbose = 0;
367 833
                if (t->level == 0 || vsl->v_opt)
368 809
                        verbose = 1;
369
370 833
                if (t->level) {
371
                        /* Print header */
372 25
                        if (t->level > 3)
373 0
                                VSL_PRINT(fo, "*%1.1d* ", t->level);
374 25
                        else
375 25
                                VSL_PRINT(fo, "%-3.*s ",
376 25
                                    (int)(t->level), "***");
377 25
                        VSL_PRINT(fo, "%*.s%-14s %*.s%-10ju\n",
378 25
                            verbose ? 10 + 1 : 0, " ",
379 25
                            VSL_transactions[t->type],
380 25
                            verbose ? 1 + 1 : 0, " ",
381 25
                            (uintmax_t)t->vxid);
382 25
                        delim = 1;
383 25
                }
384
385 2430
                while (1) {
386
                        /* Print records */
387 2430
                        i = VSL_Next(t->c);
388 2430
                        if (i < 0)
389 0
                                return (i);
390 2430
                        if (i == 0)
391 833
                                break;
392 1597
                        if (!VSL_Match(vsl, t->c))
393 1036
                                continue;
394 561
                        if (t->level > 3)
395 0
                                VSL_PRINT(fo, "-%1.1d- ", t->level);
396 561
                        else if (t->level)
397 114
                                VSL_PRINT(fo, "%-3.*s ",
398 561
                                    (int)(t->level), "---");
399 561
                        if (verbose)
400 448
                                i = VSL_Print(vsl, t->c, fo);
401 113
                        else
402 113
                                i = VSL_PrintTerse(vsl, t->c, fo);
403 561
                        if (i != 0)
404 0
                                return (i);
405 561
                }
406 833
        }
407
408 836
        if (delim)
409 836
                VSL_PRINT(fo, "\n");;
410
411 836
        return (0);
412 836
}
413
414
FILE*
415
VSL_WriteOpen(struct VSL_data *vsl, const char *name, int append, int unbuf)
416 4
{
417 4
        FILE* f;
418
419 4
        if (!vstrcmp(name, "-"))
420 1
                f = stdout;
421 3
        else
422 3
                f = fopen(name, append ? "a" : "w");
423 4
        if (f == NULL) {
424 1
                vsl_diag(vsl, "%s", strerror(errno));
425 1
                return (NULL);
426 1
        }
427 3
        if (unbuf)
428 0
                setbuf(f, NULL);
429 3
        if (ftell(f) == 0 || f == stdout) {
430 3
                if (fwrite(VSL_FILE_ID, 1, sizeof VSL_FILE_ID, f) !=
431 3
                    sizeof VSL_FILE_ID) {
432 0
                        vsl_diag(vsl, "%s", strerror(errno));
433 0
                        (void)fclose(f);
434 0
                        return (NULL);
435 0
                }
436 3
        }
437 3
        return (f);
438 3
}
439
440
int
441
VSL_Write(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
442 107
{
443 107
        size_t r;
444
445 107
        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
446 107
        if (c == NULL || c->rec.ptr == NULL)
447 0
                return (0);
448 107
        if (fo == NULL)
449 0
                fo = stdout;
450 107
        r = fwrite(c->rec.ptr, sizeof *c->rec.ptr,
451 107
            VSL_NEXT(c->rec.ptr) - c->rec.ptr, fo);
452 107
        if (r == 0)
453 0
                return (-5);
454 107
        return (0);
455 107
}
456
457
int
458
VSL_WriteAll(struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
459 9
{
460 9
        int i;
461
462 9
        if (c == NULL)
463 0
                return (0);
464 272
        while (1) {
465 272
                i = VSL_Next(c);
466 272
                if (i <= 0)
467 9
                        return (i);
468 263
                if (!VSL_Match(vsl, c))
469 156
                        continue;
470 107
                i = VSL_Write(vsl, c, fo);
471 107
                if (i != 0)
472 0
                        return (i);
473 107
        }
474 9
}
475
476
int v_matchproto_(VSLQ_dispatch_f)
477
VSL_WriteTransactions(struct VSL_data *vsl, struct VSL_transaction * const pt[],
478
    void *fo)
479 9
{
480 9
        struct VSL_transaction *t;
481 9
        int i;
482
483 9
        if (pt == NULL)
484 0
                return (0);
485 18
        for (i = 0, t = pt[0]; i == 0 && t != NULL; t = *++pt)
486 9
                i = VSL_WriteAll(vsl, t->c, fo);
487 9
        return (i);
488 9
}