Code Coverage: vinyl-cache/bin/vinylncsa/vinylncsa.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2016 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Anders Berg <andersb@vgnett.no>
6
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
7
 * Author: Tollef Fog Heen <tfheen@varnish-software.com>
8
 * Author: Martin Blix Grydeland <mbgrydeland@varnish-software.com>
9
 *
10
 * SPDX-License-Identifier: BSD-2-Clause
11
 *
12
 * Redistribution and use in source and binary forms, with or without
13
 * modification, are permitted provided that the following conditions
14
 * are met:
15
 * 1. Redistributions of source code must retain the above copyright
16
 *    notice, this list of conditions and the following disclaimer.
17
 * 2. Redistributions in binary form must reproduce the above copyright
18
 *    notice, this list of conditions and the following disclaimer in the
19
 *    documentation and/or other materials provided with the distribution.
20
 *
21
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
22
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
25
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31
 * SUCH DAMAGE.
32
 *
33
 * Obtain log data from the shared memory log, order it by session ID, and
34
 * display it in Apache / NCSA combined log format.
35
 *
36
 * See doc/sphinx/reference/vinylncsa.rst for the supported format
37
 * specifiers.
38
 *
39
 */
40
41
#include "config.h"
42
43
#include <stdlib.h>
44
#include <stdio.h>
45
#include <unistd.h>
46
#include <string.h>
47
#include <signal.h>
48
#include <stdarg.h>
49
#include <inttypes.h>
50
#include <limits.h>
51
#include <ctype.h>
52
#include <time.h>
53
#include <math.h>
54
55
#define VOPT_DEFINITION
56
#define VOPT_INC "vinylncsa_options.h"
57
58
#include "vdef.h"
59
60
#include "vapi/vsl.h"
61
#include "vapi/voptget.h"
62
#include "vas.h"
63
#include "venc.h"
64
#include "vsb.h"
65
#include "vut.h"
66
#include "vqueue.h"
67
#include "miniobj.h"
68
69 17
#define TIME_FMT "[%d/%b/%Y:%T %z]"
70 16
#define FORMAT "%h %l %u %t \"%r\" %s %b \"%{Referer}i\" \"%{User-agent}i\""
71
72
static struct VUT *vut;
73
74
struct format;
75
76
enum e_frag {
77
        F_H,                    /* %H Proto */
78
        F_U,                    /* %U URL path */
79
        F_q,                    /* %q Query string */
80
        F_b,                    /* %b Body bytes sent */
81
        F_h,                    /* %h Host name / IP Address */
82
        F_m,                    /* %m Method */
83
        F_s,                    /* %s Status */
84
        F_I,                    /* %I Bytes received */
85
        F_O,                    /* %O Bytes sent */
86
        F_tstart,               /* Time start */
87
        F_tend,                 /* Time end */
88
        F_ttfb,                 /* %{Vinyl:time_firstbyte}x */
89
        F_host,                 /* Host header */
90
        F_auth,                 /* Authorization header */
91
        F__MAX,
92
};
93
94
enum format_policy {
95
        FMTPOL_INTERNAL = 1,
96
        FMTPOL_REQ,
97
        FMTPOL_RESP,
98
        FMTPOL_FIRST,
99
        FMTPOL_LAST
100
};
101
102
struct fragment {
103
        uint64_t                gen;
104
        const char              *b, *e;
105
};
106
107
typedef int format_f(const struct format *format);
108
109
struct format {
110
        unsigned                magic;
111
#define FORMAT_MAGIC            0xC3119CDA
112
113
        char                    time_type;
114
        VTAILQ_ENTRY(format)    list;
115
        format_f                *func;
116
        struct fragment         *frag;
117
        char                    *string;
118
        const char *const       *strptr;
119
        char                    *time_fmt;
120
        int64_t                 *int64;
121
};
122
123
struct watch {
124
        unsigned                magic;
125
#define WATCH_MAGIC             0xA7D4005C
126
127
        VTAILQ_ENTRY(watch)     list;
128
        char                    *key;
129
        int                     keylen;
130
        struct fragment         frag;
131
        enum format_policy      match;
132
};
133
VTAILQ_HEAD(watch_head, watch);
134
135
struct vsl_watch {
136
        unsigned                magic;
137
#define VSL_WATCH_MAGIC         0xE3E27D23
138
139
        VTAILQ_ENTRY(vsl_watch) list;
140
        enum VSL_tag_e          tag;
141
        int                     idx;
142
        char                    *prefix;
143
        int                     prefixlen;
144
        struct fragment         frag;
145
};
146
VTAILQ_HEAD(vsl_watch_head, vsl_watch);
147
148
static struct ctx {
149
        /* Options */
150
        int                     a_opt;
151
        char                    *w_arg;
152
153
        FILE                    *fo;
154
        struct vsb              *vsb;
155
        uint64_t                gen;
156
        VTAILQ_HEAD(,format)    format;
157
        int                     quote_how;
158
        char                    *missing_string;
159
        char                    *missing_int;
160
161
        /* State */
162
        struct watch_head       watch_vcl_log;
163
        struct watch_head       watch_reqhdr; /* also bereqhdr */
164
        struct watch_head       watch_resphdr; /* also beresphdr */
165
        struct vsl_watch_head   watch_vsl;
166
        struct fragment         frag[F__MAX];
167
        const char              *hitmiss;
168
        const char              *handling;
169
        const char              *side;
170
        int64_t                 vxid;
171
        int                     recv_compl;
172
} CTX;
173
174
static void parse_format(const char *format);
175
176
static unsigned
177
frag_needed(const struct fragment *frag, enum format_policy fp)
178 1501
{
179 1501
        unsigned is_first, want_first, want_frag;
180
181 1501
        is_first = CTX.gen != frag->gen;
182
183 1501
        switch (fp) {
184 20
        case FMTPOL_LAST:
185 20
                want_frag = 1;
186 20
                want_first = 0;
187 20
                break;
188 20
        case FMTPOL_FIRST:
189 759
        case FMTPOL_INTERNAL:
190 759
                want_first = 1;
191 759
                want_frag = 1;
192 759
                break;
193 614
        case FMTPOL_REQ:
194 614
                want_first = *CTX.side == 'c';
195 614
                want_frag = !CTX.recv_compl;
196 614
                break;
197 108
        case FMTPOL_RESP:
198 108
                want_first = *CTX.side == 'b';
199 108
                want_frag = (*CTX.side == 'c') || !CTX.recv_compl;
200 108
                break;
201 0
        default:
202 0
                WRONG("Invalid format policy");
203 1501
        }
204
205 1501
        if (!want_frag)
206 58
                return (0);
207 1443
        if (want_first && !is_first)
208 50
                return (0);
209 1393
        return (1);
210 1443
}
211
212
static void
213
openout(int append)
214 5
{
215
216 5
        AN(CTX.w_arg);
217 5
        if (!vstrcmp(CTX.w_arg, "-"))
218 0
                CTX.fo = stdout;
219 5
        else
220 5
                CTX.fo = fopen(CTX.w_arg, append ? "a" : "w");
221 5
        if (CTX.fo == NULL)
222 1
                VUT_Error(vut, 1, "Can't open output file (%s)",
223 1
                    strerror(errno));
224 5
}
225
226
static int v_matchproto_(VUT_cb_f)
227
rotateout(struct VUT *v)
228 1
{
229
230 1
        assert(v == vut);
231 1
        AN(CTX.w_arg);
232 1
        AN(CTX.fo);
233 1
        (void)fclose(CTX.fo);
234 1
        openout(1);
235 1
        AN(CTX.fo);
236 1
        return (0);
237 1
}
238
239
static int v_matchproto_(VUT_cb_f)
240
flushout(struct VUT *v)
241 863
{
242
243 863
        assert(v == vut);
244 863
        AN(CTX.fo);
245 863
        if (fflush(CTX.fo))
246 0
                return (-5);
247 863
        return (0);
248 863
}
249
250
static inline int
251
vsb_fcat(struct vsb *vsb, const struct fragment *f, const char *dflt)
252 254
{
253 254
        if (f->gen == CTX.gen) {
254 250
                assert(f->b <= f->e);
255 250
                VSB_quote(vsb, f->b, f->e - f->b, CTX.quote_how);
256 250
        } else if (dflt)
257 4
                VSB_quote(vsb, dflt, -1, CTX.quote_how);
258 0
        else
259 0
                return (-1);
260 254
        return (0);
261 254
}
262
263
static int v_matchproto_(format_f)
264
format_string(const struct format *format)
265 317
{
266
267 317
        CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
268 317
        AN(format->string);
269 317
        AZ(VSB_cat(CTX.vsb, format->string));
270 317
        return (1);
271 317
}
272
273
static int v_matchproto_(format_f)
274
format_strptr(const struct format *format)
275 37
{
276
277 37
        CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
278 37
        AN(format->strptr);
279 37
        AN(*format->strptr);
280 37
        AZ(VSB_cat(CTX.vsb, *format->strptr));
281 37
        return (1);
282 37
}
283
284
static int v_matchproto_(format_f)
285
format_int64(const struct format *format)
286 21
{
287
288 21
        CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
289 21
        VSB_printf(CTX.vsb, "%jd", (intmax_t)*format->int64);
290 21
        return (1);
291 21
}
292
293
static int v_matchproto_(format_f)
294
format_fragment(const struct format *format)
295 229
{
296
297 229
        CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
298 229
        AN(format->frag);
299
300 229
        if (format->frag->gen != CTX.gen) {
301 48
                if (format->string == NULL)
302 0
                        return (-1);
303 48
                VSB_quote(CTX.vsb, format->string, -1, CTX.quote_how);
304 48
                return (0);
305 48
        }
306 181
        AZ(vsb_fcat(CTX.vsb, format->frag, NULL));
307 181
        return (1);
308 181
}
309
310
static int v_matchproto_(format_f)
311
format_time(const struct format *format)
312 60
{
313 60
        double t_start, t_end, d;
314 60
        char *p;
315 60
        char buf[64];
316 60
        time_t t;
317 60
        intmax_t l;
318 60
        struct tm tm;
319
320 60
        CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
321 60
        if (CTX.frag[F_tstart].gen == CTX.gen) {
322 60
                t_start = strtod(CTX.frag[F_tstart].b, &p);
323 60
                if (p != CTX.frag[F_tstart].e)
324 0
                        t_start = NAN;
325 60
        } else
326 0
                t_start = NAN;
327 60
        if (isnan(t_start)) {
328
                /* Missing t_start is a no go */
329 0
                if (format->string == NULL)
330 0
                        return (-1);
331 0
                AZ(VSB_cat(CTX.vsb, format->string));
332 0
                return (0);
333 0
        }
334
335
        /* Missing t_end defaults to t_start */
336 60
        if (CTX.frag[F_tend].gen == CTX.gen) {
337 59
                t_end = strtod(CTX.frag[F_tend].b, &p);
338 59
                if (p != CTX.frag[F_tend].e)
339 0
                        t_end = t_start;
340 59
        } else
341 1
                t_end = t_start;
342
343 60
        AN(format->time_fmt);
344
345 60
        switch (format->time_type) {
346 30
        case 't':
347 30
                t = (intmax_t)floor(t_start);
348 30
                (void)localtime_r(&t, &tm);
349 30
                AN(strftime(buf, sizeof buf, format->time_fmt, &tm));
350 30
                AZ(VSB_cat(CTX.vsb, buf));
351 30
                return (1);
352 3
        case '3':
353 3
                l = (intmax_t)(modf(t_start, &d) * 1e3);
354 3
                break;
355 3
        case '6':
356 3
                l = (intmax_t)(modf(t_start, &d) * 1e6);
357 3
                break;
358 3
        case 'S':
359 3
                l = (intmax_t)t_start;
360 3
                break;
361 3
        case 'M':
362 3
                l = (intmax_t)(t_start * 1e3);
363 3
                break;
364 3
        case 'U':
365 3
                l = (intmax_t)(t_start * 1e6);
366 3
                break;
367 6
        case 's':
368 6
                l = (intmax_t)(t_end - t_start);
369 6
                break;
370 3
        case 'm':
371 3
                l = (intmax_t)((t_end - t_start) * 1e3);
372 3
                break;
373 6
        case 'u':
374 6
                l = (intmax_t)((t_end - t_start) * 1e6);
375 6
                break;
376 0
        default:
377 0
                WRONG("Time format specifier");
378 60
        }
379
380 30
#ifdef __FreeBSD__
381 30
        assert(fmtcheck(format->time_fmt, "%jd") == format->time_fmt);
382 30
#endif
383 30
        AZ(VSB_printf(CTX.vsb, format->time_fmt, l));
384
385 30
        return (1);
386 30
}
387
388
static int v_matchproto_(format_f)
389
format_requestline(const struct format *format)
390 15
{
391
392 15
        (void)format;
393 15
        AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_m], "-"));
394 15
        AZ(VSB_putc(CTX.vsb, ' '));
395 15
        if (CTX.frag[F_host].gen == CTX.gen) {
396 13
                if (vstrncmp(CTX.frag[F_host].b, "http://", 7))
397 13
                        AZ(VSB_cat(CTX.vsb, "http://"));
398 13
                AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_host], NULL));
399 13
        } else
400 2
                AZ(VSB_cat(CTX.vsb, "http://localhost"));
401 15
        AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_U], ""));
402 15
        AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_q], ""));
403 15
        AZ(VSB_putc(CTX.vsb, ' '));
404 15
        AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_H], "HTTP/1.0"));
405 15
        return (1);
406 15
}
407
408
static int v_matchproto_(format_f)
409
format_auth(const struct format *format)
410 18
{
411 18
        struct vsb *vsb = VSB_new_auto();
412 18
        AN(vsb);
413 18
        char *q;
414
415 18
        if (CTX.frag[F_auth].gen != CTX.gen ||
416 18
            VENC_Decode_Base64(vsb, CTX.frag[F_auth].b, CTX.frag[F_auth].e)) {
417 10
                VSB_destroy(&vsb);
418 10
                if (format->string == NULL)
419 0
                        return (-1);
420 10
                VSB_quote(CTX.vsb, format->string, -1, CTX.quote_how);
421 10
                return (0);
422 10
        }
423 8
        AZ(VSB_finish(vsb));
424 8
        q = strchr(VSB_data(vsb), ':');
425 8
        if (q != NULL)
426 8
                *q = '\0';
427 8
        VSB_quote(CTX.vsb, VSB_data(vsb), -1, CTX.quote_how);
428 8
        VSB_destroy(&vsb);
429 8
        return (1);
430 8
}
431
432
static int
433
print(void)
434 100
{
435 100
        const struct format *f;
436 100
        int i, r = 1;
437
438 100
        VSB_clear(CTX.vsb);
439 697
        VTAILQ_FOREACH(f, &CTX.format, list) {
440 697
                CHECK_OBJ_NOTNULL(f, FORMAT_MAGIC);
441 697
                i = (f->func)(f);
442 697
                AZ(VSB_error(CTX.vsb));
443 697
                if (r > i)
444 26
                        r = i;
445 697
        }
446 100
        AZ(VSB_putc(CTX.vsb, '\n'));
447 100
        AZ(VSB_finish(CTX.vsb));
448 100
        if (r >= 0) {
449 100
                i = fwrite(VSB_data(CTX.vsb), 1, VSB_len(CTX.vsb), CTX.fo);
450 100
                if (i != VSB_len(CTX.vsb))
451 0
                        return (-5);
452 100
        }
453 100
        return (0);
454 100
}
455
456
static void
457
addf_string(const char *str)
458 238
{
459 238
        struct format *f;
460
461 238
        AN(str);
462 238
        ALLOC_OBJ(f, FORMAT_MAGIC);
463 238
        AN(f);
464 238
        f->func = format_string;
465 238
        f->string = strdup(str);
466 238
        AN(f->string);
467 238
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
468 238
}
469
470
static void
471
addf_strptr(const char *const *strptr)
472 8
{
473 8
        struct format *f;
474
475 8
        AN(strptr);
476 8
        ALLOC_OBJ(f, FORMAT_MAGIC);
477 8
        AN(f);
478 8
        f->func = format_strptr;
479 8
        f->strptr = strptr;
480 8
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
481 8
}
482
483
static void
484
addf_fragment(struct fragment *frag, const char *str)
485 99
{
486 99
        struct format *f;
487
488 99
        AN(frag);
489 99
        ALLOC_OBJ(f, FORMAT_MAGIC);
490 99
        AN(f);
491 99
        f->func = format_fragment;
492 99
        f->frag = frag;
493 99
        if (str != NULL) {
494 99
                f->string = strdup(str);
495 99
                AN(f->string);
496 99
        }
497 99
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
498 99
}
499
500
static void
501
addf_int64(int64_t *i)
502 5
{
503 5
        struct format *f;
504
505 5
        AN(i);
506 5
        ALLOC_OBJ(f, FORMAT_MAGIC);
507 5
        AN(f);
508 5
        f->func = format_int64;
509 5
        f->int64 = i;
510 5
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
511 5
}
512
513
static void
514
addf_time(char type, const char *fmt)
515 32
{
516 32
        struct format *f;
517
518 32
        ALLOC_OBJ(f, FORMAT_MAGIC);
519 32
        AN(f);
520 32
        AN(fmt);
521 32
        f->func = format_time;
522 32
        f->time_type = type;
523 32
        f->time_fmt = strdup(fmt);
524
525 32
        if (f->time_type == 'T') {
526 5
                if (!vstrcmp(fmt, "s"))
527 2
                        f->time_type = 's';
528 3
                else if (!vstrcmp(fmt, "ms"))
529 1
                        f->time_type = 'm';
530 2
                else if (!vstrcmp(fmt, "us"))
531 2
                        f->time_type = 'u';
532 0
                else
533 0
                        VUT_Error(vut, 1, "Unknown specifier: %%{%s}T",
534 0
                            fmt);
535 5
                REPLACE(f->time_fmt, "%jd");
536 27
        } else if (f->time_type == 't') {
537 27
                if (!vstrcmp(fmt, "sec")) {
538 1
                        f->time_type = 'S';
539 1
                        REPLACE(f->time_fmt, "%jd");
540 26
                } else if (!vstrncmp(fmt, "msec", 4)) {
541 3
                        fmt += 4;
542 3
                        if (!vstrcmp(fmt, "_frac")) {
543 1
                                f->time_type = '3';
544 1
                                REPLACE(f->time_fmt, "%03jd");
545 2
                        } else if (*fmt == '\0') {
546 1
                                f->time_type = 'M';
547 1
                                REPLACE(f->time_fmt, "%jd");
548 1
                        }
549 23
                } else if (!vstrncmp(fmt, "usec", 4)) {
550 3
                        fmt += 4;
551 3
                        if (!vstrcmp(fmt, "_frac")) {
552 1
                                f->time_type = '6';
553 1
                                REPLACE(f->time_fmt, "%06jd");
554 2
                        } else if (*fmt == '\0') {
555 1
                                f->time_type = 'U';
556 1
                                REPLACE(f->time_fmt, "%jd");
557 1
                        }
558 3
                }
559 27
        }
560
561 32
        AN(f->time_fmt);
562 32
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
563 32
}
564
565
static void
566
addf_requestline(void)
567 19
{
568 19
        struct format *f;
569
570 19
        ALLOC_OBJ(f, FORMAT_MAGIC);
571 19
        AN(f);
572 19
        f->func = format_requestline;
573 19
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
574 19
}
575
576
static void
577
addf_vcl_log(const char *key)
578 2
{
579 2
        struct watch *w;
580 2
        struct format *f;
581
582 2
        AN(key);
583 2
        ALLOC_OBJ(w, WATCH_MAGIC);
584 2
        AN(w);
585 2
        w->keylen = asprintf(&w->key, "%s:", key);
586 2
        assert(w->keylen > 0);
587 2
        VTAILQ_INSERT_TAIL(&CTX.watch_vcl_log, w, list);
588
589 2
        ALLOC_OBJ(f, FORMAT_MAGIC);
590 2
        AN(f);
591 2
        f->func = format_fragment;
592 2
        f->frag = &w->frag;
593 2
        f->string = strdup("");
594 2
        AN(f->string);
595 2
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
596 2
}
597
598
static void
599
addf_hdr(struct watch_head *head, char *key)
600 71
{
601 71
        struct watch *w;
602 71
        struct format *f;
603 71
        char *match;
604
605 71
        AN(head);
606 71
        AN(key);
607 71
        ALLOC_OBJ(w, WATCH_MAGIC);
608 71
        AN(w);
609
610 71
        match = strchr(key, ':');
611 71
        if (match != NULL) {
612 16
                match++;
613 16
                if (!vstrncmp(match, "first", 5))
614 8
                        w->match = FMTPOL_FIRST;
615 8
                else if (!vstrncmp(match, "last", 4))
616 8
                        w->match = FMTPOL_LAST;
617 0
                else
618 0
                        VUT_Error(vut, 1, "Unknown match rule :%s", match);
619 16
                match[-1] = '\0';
620 16
        }
621
622 71
        w->keylen = asprintf(&w->key, "%s:", key);
623 71
        assert(w->keylen > 0);
624 71
        VTAILQ_INSERT_TAIL(head, w, list);
625
626 71
        ALLOC_OBJ(f, FORMAT_MAGIC);
627 71
        AN(f);
628 71
        f->func = format_fragment;
629 71
        f->frag = &w->frag;
630 71
        f->string = strdup(CTX.missing_string);
631 71
        AN(f->string);
632 71
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
633 71
}
634
635
static void
636
addf_vsl(enum VSL_tag_e tag, long i, const char *prefix)
637 13
{
638 13
        struct vsl_watch *w;
639
640 13
        ALLOC_OBJ(w, VSL_WATCH_MAGIC);
641 13
        AN(w);
642 13
        if (VSL_tagflags[tag] && CTX.quote_how != VSB_QUOTE_JSON)
643 1
                VUT_Error(vut, 1, "Tag %s can contain control characters",
644 1
                    VSL_tags[tag]);
645 12
        w->tag = tag;
646 12
        assert(i <= INT_MAX);
647 12
        w->idx = i;
648 12
        if (prefix != NULL) {
649 3
                w->prefixlen = asprintf(&w->prefix, "%s:", prefix);
650 3
                assert(w->prefixlen > 0);
651 3
        }
652 12
        VTAILQ_INSERT_TAIL(&CTX.watch_vsl, w, list);
653 12
        addf_fragment(&w->frag, CTX.missing_string);
654 12
}
655
656
static void
657
addf_auth(void)
658 20
{
659 20
        struct format *f;
660
661 20
        ALLOC_OBJ(f, FORMAT_MAGIC);
662 20
        AN(f);
663 20
        f->func = format_auth;
664 20
        f->string = strdup("-");
665 20
        AN(f->string);
666 20
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
667 20
}
668
669
static void
670
parse_x_format(char *buf)
671 40
{
672 40
        char *e, *r, *s;
673 40
        long lval;
674 40
        int slt;
675
676 40
        if (!vstrcmp(buf, "Vinyl:time_firstbyte")) {
677 1
                addf_fragment(&CTX.frag[F_ttfb], CTX.missing_int);
678 1
                return;
679 1
        }
680 39
        if (!vstrcmp(buf, "Vinyl:hitmiss")) {
681 1
                addf_strptr(&CTX.hitmiss);
682 1
                return;
683 1
        }
684 38
        if (!vstrcmp(buf, "Vinyl:handling")) {
685 2
                addf_strptr(&CTX.handling);
686 2
                return;
687 2
        }
688 36
        if (!vstrcmp(buf, "Vinyl:side")) {
689 5
                addf_strptr(&CTX.side);
690 5
                return;
691 5
        }
692 31
        if (!vstrcmp(buf, "Vinyl:vxid")) {
693 5
                addf_int64(&CTX.vxid);
694 5
                return;
695 5
        }
696 26
        if (!vstrncmp(buf, "VCL_Log:", 8)) {
697 2
                addf_vcl_log(buf + 8);
698 2
                return;
699 2
        }
700 24
        if (!vstrncmp(buf, "VSL:", 4)) {
701 22
                buf += 4;
702 22
                e = buf;
703 206
                while (*e != '\0')
704 184
                        e++;
705 22
                if (e == buf)
706 1
                        VUT_Error(vut, 1, "Missing tag in VSL:");
707 21
                if (e[-1] == ']') {
708 12
                        r = e - 1;
709 50
                        while (r > buf && *r != '[')
710 38
                                r--;
711 12
                        if (r == buf || r[1] == ']')
712 1
                                VUT_Error(vut, 1, "Syntax error: VSL:%s", buf);
713 11
                        e[-1] = '\0';
714 11
                        lval = strtol(r + 1, &s, 10);
715 11
                        if (s != e - 1)
716 1
                                VUT_Error(vut, 1, "Syntax error: VSL:%s]", buf);
717 10
                        if (lval <= 0 || lval > 255) {
718 2
                                VUT_Error(vut, 1,
719 2
                                    "Syntax error. Field specifier must be"
720 2
                                    " between 1 and 255: %s]",
721 2
                                    buf);
722 2
                        }
723 8
                        *r = '\0';
724 8
                } else
725 9
                        lval = 0;
726 17
                r = buf;
727 143
                while (r < e && *r != ':')
728 126
                        r++;
729 17
                if (r != e) {
730 3
                        slt = VSL_Name2Tag(buf, r - buf);
731 3
                        r++;
732 14
                } else {
733 14
                        slt = VSL_Name2Tag(buf, -1);
734 14
                        r = NULL;
735 14
                }
736 17
                if (slt == -2)
737 1
                        VUT_Error(vut, 1, "Tag not unique: %s", buf);
738 16
                if (slt == -1)
739 3
                        VUT_Error(vut, 1, "Unknown log tag: %s", buf);
740 13
                assert(slt >= 0);
741
742 13
                addf_vsl((enum VSL_tag_e)slt, lval, r);
743 13
                return;
744 13
        }
745 2
        if (!vstrcmp(buf, "Vinyl:default_format")) {
746 1
                parse_format(FORMAT);
747 1
                return;
748 1
        }
749 1
        VUT_Error(vut, 1, "Unknown formatting extension: %s", buf);
750 2
}
751
752
static void
753
parse_format(const char *format)
754 76
{
755 76
        const char *p, *q;
756 76
        struct vsb *vsb;
757 76
        char buf[256];
758 76
        int b;
759
760 76
        if (format == NULL)
761 15
                format = FORMAT;
762
763 76
        vsb = VSB_new_auto();
764 76
        AN(vsb);
765
766 718
        for (p = format; *p != '\0'; p++) {
767
768
                /* Allow the most essential escape sequences in format */
769 656
                if (*p == '\\' && p[1] != '\0') {
770 1
                        if (*++p == 't')
771 0
                                AZ(VSB_putc(vsb, '\t'));
772 1
                        else if (*p == 'n')
773 1
                                AZ(VSB_putc(vsb, '\n'));
774 0
                        else
775 0
                                AZ(VSB_putc(vsb, *p));
776 1
                        continue;
777 1
                }
778
779 655
                if (*p != '%') {
780 367
                        AZ(VSB_putc(vsb, *p));
781 367
                        continue;
782 367
                }
783
784 288
                if (VSB_len(vsb) > 0) {
785 217
                        AZ(VSB_finish(vsb));
786 217
                        addf_string(VSB_data(vsb));
787 217
                        VSB_clear(vsb);
788 217
                }
789
790 288
                p++;
791 288
                switch (*p) {
792 20
                case 'b':       /* Body bytes sent */
793 20
                        addf_fragment(&CTX.frag[F_b], CTX.missing_int);
794 20
                        break;
795 1
                case 'D':       /* Float request time */
796 1
                        addf_time('T', "us");
797 1
                        break;
798 20
                case 'h':       /* Client host name / IP Address */
799 20
                        addf_fragment(&CTX.frag[F_h], CTX.missing_string);
800 20
                        break;
801 3
                case 'H':       /* Protocol */
802 3
                        addf_fragment(&CTX.frag[F_H], "HTTP/1.0");
803 3
                        break;
804 1
                case 'I':       /* Bytes received */
805 1
                        addf_fragment(&CTX.frag[F_I], CTX.missing_int);
806 1
                        break;
807 17
                case 'l':       /* Client user ID (identd) always '-' */
808 17
                        AZ(VSB_putc(vsb, '-'));
809 17
                        break;
810 17
                case 'm':       /* Method */
811 3
                        addf_fragment(&CTX.frag[F_m], CTX.missing_string);
812 3
                        break;
813 1
                case 'O':       /* Bytes sent */
814 1
                        addf_fragment(&CTX.frag[F_O], CTX.missing_int);
815 1
                        break;
816 3
                case 'q':       /* Query string */
817 3
                        addf_fragment(&CTX.frag[F_q], "");
818 3
                        break;
819 19
                case 'r':       /* Request line */
820 19
                        addf_requestline();
821 19
                        break;
822 31
                case 's':       /* Status code */
823 31
                        addf_fragment(&CTX.frag[F_s], CTX.missing_int);
824 31
                        break;
825 17
                case 't':       /* strftime */
826 17
                        addf_time(*p, TIME_FMT);
827 17
                        break;
828 1
                case 'T':       /* Int request time */
829 1
                        addf_time(*p, "s");
830 1
                        break;
831 20
                case 'u':       /* Remote user from auth */
832 20
                        addf_auth();
833 20
                        break;
834 4
                case 'U':       /* URL */
835 4
                        addf_fragment(&CTX.frag[F_U], CTX.missing_string);
836 4
                        break;
837 126
                case '{':
838 126
                        p++;
839 126
                        q = p;
840 126
                        b = 1;
841 1294
                        while (*q) {
842 1293
                                if (*q == '{')
843 4
                                        b++;
844 1289
                                else if (*q == '}')
845 129
                                        if (--b == 0)
846 125
                                                break;
847 1168
                                q++;
848 1168
                        }
849 126
                        if (b > 0)
850 1
                                VUT_Error(vut, 1, "Unmatched bracket at: %s",
851 1
                                    p - 2);
852 125
                        assert((unsigned)(q - p) < sizeof buf - 1);
853 125
                        strncpy(buf, p, q - p);
854 125
                        buf[q - p] = '\0';
855 125
                        q++;
856 125
                        switch (*q) {
857 57
                        case 'i':
858 57
                                addf_hdr(&CTX.watch_reqhdr, buf);
859 57
                                break;
860 14
                        case 'o':
861 14
                                addf_hdr(&CTX.watch_resphdr, buf);
862 14
                                break;
863 10
                        case 't':
864 10
                                addf_time(*q, buf);
865 10
                                break;
866 3
                        case 'T':
867 3
                                addf_time(*q, buf);
868 3
                                break;
869 40
                        case 'x':
870 40
                                parse_x_format(buf);
871 40
                                break;
872 1
                        default:
873 1
                                VUT_Error(vut, 1,
874 1
                                    "Unknown format specifier at: %s",
875 1
                                    p - 2);
876 125
                        }
877 113
                        p = q;
878 113
                        break;
879 1
                default:
880 1
                        VUT_Error(vut, 1, "Unknown format specifier at: %s",
881 1
                            p - 1);
882 288
                }
883 288
        }
884
885 62
        if (VSB_len(vsb) > 0) {
886
                /* Add any remaining static */
887 21
                AZ(VSB_finish(vsb));
888 21
                addf_string(VSB_data(vsb));
889 21
                VSB_clear(vsb);
890 21
        }
891
892 62
        VSB_destroy(&vsb);
893 62
}
894
895
static int
896
isprefix(const char *prefix, size_t len, const char *b,
897
    const char *e, const char **next)
898 3744
{
899 3744
        assert(len > 0);
900 3744
        if (e < b + len || strncasecmp(b, prefix, len))
901 3190
                return (0);
902 554
        b += len;
903 554
        if (next) {
904 1073
                while (b < e && *b == ' ')
905 519
                        b++;
906 554
                *next = b;
907 554
        }
908 554
        return (1);
909 3744
}
910
911
static void
912
frag_fields(enum format_policy fp, const char *b, const char *e, ...)
913 542
{
914 542
        va_list ap;
915 542
        const char *p, *q;
916 542
        int n, field;
917 542
        struct fragment *frag;
918
919 542
        AN(b);
920 542
        AN(e);
921 542
        va_start(ap, e);
922
923 542
        n = 0;
924 1277
        while (1) {
925 1277
                field = va_arg(ap, int);
926 1277
                frag = va_arg(ap, struct fragment *);
927 1277
                if (field == 0) {
928 542
                        AZ(frag);
929 542
                        break;
930 542
                }
931 735
                p = q = NULL;
932 1954
                while (n < field) {
933 1893
                        while (b < e && isspace(*b))
934 674
                                b++;
935 1219
                        p = b;
936 9960
                        while (b < e && !isspace(*b))
937 8741
                                b++;
938 1219
                        q = b;
939 1219
                        n++;
940 1219
                }
941 735
                assert(p != NULL && q != NULL);
942 735
                if (p >= e || q <= p)
943 3
                        continue;
944 732
                if (frag_needed(frag, fp)) {
945
                        /* We only grab the same matching field once */
946 713
                        frag->gen = CTX.gen;
947 713
                        frag->b = p;
948 713
                        frag->e = q;
949 713
                }
950 732
        }
951 542
        va_end(ap);
952 542
}
953
954
static void
955
frag_line(enum format_policy fp, const char *b, const char *e,
956
    struct fragment *f)
957 769
{
958
959 769
        if (!frag_needed(f, fp)) {
960
                /* We only grab the same matching record once */
961 89
                return;
962 89
        }
963
964 680
        if (e == NULL)
965 4
                e = b + vstrlen(b);
966
967
        /* Skip leading space */
968 680
        while (b < e && isspace(*b))
969 0
                ++b;
970
971
        /* Skip trailing space */
972 680
        while (e > b && isspace(e[-1]))
973 0
                --e;
974
975 680
        f->gen = CTX.gen;
976 680
        f->b = b;
977 680
        f->e = e;
978 680
}
979
980
static void
981
process_hdr(enum format_policy fp, const struct watch_head *head, const char *b,
982
    const char *e, int unset)
983 1184
{
984 1184
        struct watch *w;
985 1184
        const char *p;
986
987 1184
        VTAILQ_FOREACH(w, head, list) {
988 602
                CHECK_OBJ_NOTNULL(w, WATCH_MAGIC);
989 602
                if (!isprefix(w->key, w->keylen, b, e, &p))
990 515
                        continue;
991
992 87
                if (w->match) {
993 40
                        assert(w->match == FMTPOL_FIRST ||
994 40
                            w->match == FMTPOL_LAST);
995 40
                        fp = w->match;
996 40
                }
997
998 87
                if (unset && !w->match) {
999 11
                        frag_line(fp, CTX.missing_string,
1000 11
                            NULL,
1001 11
                            &w->frag);
1002 11
                } else
1003 76
                        frag_line(fp, p, e, &w->frag);
1004 87
        }
1005 1184
}
1006
1007
static void
1008
process_vsl(const struct vsl_watch_head *head, enum VSL_tag_e tag,
1009
    const char *b, const char *e)
1010 3759
{
1011 3759
        struct vsl_watch *w;
1012 3759
        const char *p;
1013 3759
        VTAILQ_FOREACH(w, head, list) {
1014 1396
                CHECK_OBJ_NOTNULL(w, VSL_WATCH_MAGIC);
1015 1396
                if (tag != w->tag)
1016 1325
                        continue;
1017 71
                p = b;
1018 71
                if (w->prefixlen > 0 &&
1019 71
                    !isprefix(w->prefix, w->prefixlen, b, e, &p))
1020 38
                        continue;
1021 33
                if (w->idx == 0)
1022 6
                        frag_line(FMTPOL_INTERNAL, p, e, &w->frag);
1023 27
                else
1024 27
                        frag_fields(FMTPOL_INTERNAL, p, e, w->idx, &w->frag, 0, NULL);
1025 33
        }
1026 3759
}
1027
1028
static int v_matchproto_(VSLQ_dispatch_f)
1029
dispatch_f(struct VSL_data *vsl, struct VSL_transaction * const pt[],
1030
    void *priv)
1031 128
{
1032 128
        struct VSL_transaction *t;
1033 128
        enum VSL_tag_e tag;
1034 128
        const char *b, *e, *p;
1035 128
        struct watch *w;
1036 128
        int i, skip;
1037
1038 128
        (void)vsl;
1039 128
        (void)priv;
1040
1041 256
        for (t = pt[0]; t != NULL; t = *++pt) {
1042 128
                CTX.gen++;
1043
1044 128
                if (t->type == VSL_t_req) {
1045 86
                        CTX.side = "c";
1046 86
                } else if (t->type == VSL_t_bereq) {
1047 14
                        CTX.side = "b";
1048 14
                } else
1049 28
                        continue;
1050
1051 100
                CTX.recv_compl = 0;
1052 100
                CTX.hitmiss = "-";
1053 100
                CTX.handling = "-";
1054 100
                CTX.vxid = t->vxid;
1055 100
                skip = 0;
1056 3861
                while (skip == 0 && 1 == VSL_Next(t->c)) {
1057 3761
                        tag = VSL_TAG(t->c->rec.ptr);
1058 3761
                        if (VSL_tagflags[tag] &&
1059 3761
                            CTX.quote_how != VSB_QUOTE_JSON)
1060 2
                                continue;
1061
1062 3759
                        b = VSL_CDATA(t->c->rec.ptr);
1063 3759
                        e = b + VSL_LEN(t->c->rec.ptr);
1064 3759
                        if (!VSL_tagflags[tag]) {
1065 7516
                                while (e > b && e[-1] == '\0')
1066 3758
                                        e--;
1067 3758
                        }
1068
1069 3759
                        switch (tag) {
1070 0
                        case SLT_HttpGarbage:
1071 0
                                skip = 1;
1072 0
                                break;
1073 7
                        case SLT_PipeAcct:
1074 7
                                frag_fields(FMTPOL_INTERNAL, b, e,
1075 7
                                    3, &CTX.frag[F_I],
1076 7
                                    4, &CTX.frag[F_O],
1077 7
                                    0, NULL);
1078 7
                                break;
1079 14
                        case SLT_BackendOpen:
1080 14
                                frag_fields(FMTPOL_INTERNAL, b, e,
1081 14
                                    3, &CTX.frag[F_h],
1082 14
                                    0, NULL);
1083 14
                                break;
1084 86
                        case SLT_ReqStart:
1085 86
                                frag_fields(FMTPOL_INTERNAL, b, e,
1086 86
                                    1, &CTX.frag[F_h],
1087 86
                                    0, NULL);
1088 86
                                break;
1089 18
                        case SLT_BereqMethod:
1090 107
                        case SLT_ReqMethod:
1091 107
                                frag_line(FMTPOL_REQ, b, e, &CTX.frag[F_m]);
1092 107
                                break;
1093 18
                        case SLT_BereqURL:
1094 124
                        case SLT_ReqURL:
1095 124
                                p = vmemchr(b, '?', e - b);
1096 124
                                if (p == NULL)
1097 93
                                        p = e;
1098 124
                                frag_line(FMTPOL_REQ, b, p, &CTX.frag[F_U]);
1099 124
                                frag_line(FMTPOL_REQ, p, e, &CTX.frag[F_q]);
1100 124
                                break;
1101 16
                        case SLT_BereqProtocol:
1102 102
                        case SLT_ReqProtocol:
1103 102
                                frag_line(FMTPOL_REQ, b, e, &CTX.frag[F_H]);
1104 102
                                break;
1105 14
                        case SLT_BerespStatus:
1106 96
                        case SLT_RespStatus:
1107 96
                                frag_line(FMTPOL_RESP, b, e, &CTX.frag[F_s]);
1108 96
                                break;
1109 14
                        case SLT_BereqAcct:
1110 93
                        case SLT_ReqAcct:
1111 93
                                frag_fields(FMTPOL_INTERNAL, b, e,
1112 93
                                    3, &CTX.frag[F_I],
1113 93
                                    5, &CTX.frag[F_b],
1114 93
                                    6, &CTX.frag[F_O],
1115 93
                                    0, NULL);
1116 93
                                break;
1117 489
                        case SLT_Timestamp:
1118 4930
#define ISPREFIX(a, b, c, d)    isprefix(a, vstrlen(a), b, c, d)
1119 489
                                if (ISPREFIX("Start:", b, e, &p)) {
1120 100
                                        frag_fields(FMTPOL_INTERNAL, p, e, 1,
1121 100
                                            &CTX.frag[F_tstart], 0, NULL);
1122
1123 389
                                } else if (ISPREFIX("Resp:", b, e, &p) ||
1124 389
                                    ISPREFIX("PipeSess:", b, e, &p) ||
1125 389
                                    ISPREFIX("BerespBody:", b, e, &p)) {
1126 97
                                        frag_fields(FMTPOL_INTERNAL, p, e, 1,
1127 97
                                            &CTX.frag[F_tend], 0, NULL);
1128
1129 292
                                } else if (ISPREFIX("Process:", b, e, &p) ||
1130 292
                                    ISPREFIX("Pipe:", b, e, &p) ||
1131 292
                                    ISPREFIX("Beresp:", b, e, &p)) {
1132 118
                                        frag_fields(FMTPOL_INTERNAL, p, e, 2,
1133 118
                                            &CTX.frag[F_ttfb], 0, NULL);
1134 118
                                }
1135 489
                                break;
1136 100
                        case SLT_BereqHeader:
1137 468
                        case SLT_ReqHeader:
1138 468
                                process_hdr(FMTPOL_REQ, &CTX.watch_reqhdr, b, e, 0);
1139 468
                                if (ISPREFIX("Authorization:", b, e, &p) &&
1140 468
                                    ISPREFIX("basic ", p, e, &p))
1141 26
                                        frag_line(FMTPOL_REQ, p, e,
1142 26
                                            &CTX.frag[F_auth]);
1143 442
                                else if (ISPREFIX("Host:", b, e, &p))
1144 96
                                        frag_line(FMTPOL_REQ, p, e,
1145 96
                                            &CTX.frag[F_host]);
1146 468
#undef ISPREFIX
1147 468
                                break;
1148 42
                        case SLT_BerespHeader:
1149 670
                        case SLT_RespHeader:
1150 670
                                process_hdr(FMTPOL_RESP, &CTX.watch_resphdr, b, e, 0);
1151 670
                                break;
1152 10
                        case SLT_BereqUnset:
1153 22
                        case SLT_ReqUnset:
1154 22
                                process_hdr(FMTPOL_REQ, &CTX.watch_reqhdr, b, e, 1);
1155 22
                                break;
1156 4
                        case SLT_BerespUnset:
1157 24
                        case SLT_RespUnset:
1158 24
                                process_hdr(FMTPOL_RESP, &CTX.watch_resphdr, b, e, 1);
1159 24
                                break;
1160 11
                        case SLT_HitMiss:
1161 11
                                CTX.hitmiss = "miss";
1162 11
                                CTX.handling = "hitmiss";
1163 11
                                break;
1164 1
                        case SLT_HitPass:
1165 1
                                CTX.hitmiss = "miss";
1166 1
                                CTX.handling = "hitpass";
1167 1
                                break;
1168 350
                        case SLT_VCL_call:
1169 350
                                if (!strcasecmp(b, "recv")) {
1170 85
                                        CTX.recv_compl = 1;
1171 85
                                        CTX.hitmiss = "-";
1172 85
                                        CTX.handling = "-";
1173 265
                                } else if (!strcasecmp(b, "hit")) {
1174 17
                                        CTX.hitmiss = "hit";
1175 17
                                        CTX.handling = "hit";
1176 248
                                } else if (!strcasecmp(b, "miss") && vstrcmp(CTX.handling, "hitmiss")) {
1177 37
                                        CTX.hitmiss = "miss";
1178 37
                                        CTX.handling = "miss";
1179 211
                                } else if (!strcasecmp(b, "pass") && vstrcmp(CTX.handling, "hitpass")) {
1180 7
                                        CTX.hitmiss = "miss";
1181 7
                                        CTX.handling = "pass";
1182 204
                                } else if (!strcasecmp(b, "synth")) {
1183
                                        /* Arguably, synth isn't a hit or
1184
                                           a miss, but miss is less
1185
                                           wrong */
1186 12
                                        CTX.hitmiss = "miss";
1187 12
                                        CTX.handling = "synth";
1188 192
                                } else if (!strcasecmp(b, "backend_response")) {
1189 12
                                        CTX.recv_compl = 1;
1190 12
                                }
1191 350
                                break;
1192 350
                        case SLT_VCL_return:
1193 350
                                if (!strcasecmp(b, "pipe")) {
1194 14
                                        CTX.hitmiss = "miss";
1195 14
                                        CTX.handling = "pipe";
1196 336
                                } else if (!strcasecmp(b, "restart"))
1197 0
                                        skip = 1;
1198 350
                                break;
1199 10
                        case SLT_VCL_Log:
1200 10
                                VTAILQ_FOREACH(w, &CTX.watch_vcl_log, list) {
1201 1
                                        CHECK_OBJ_NOTNULL(w, WATCH_MAGIC);
1202 1
                                        if (e - b < w->keylen ||
1203 1
                                            vstrncmp(b, w->key, w->keylen))
1204 0
                                                continue;
1205 1
                                        p = b + w->keylen;
1206 1
                                        frag_line(FMTPOL_INTERNAL, p, e, &w->frag);
1207 1
                                }
1208 10
                                break;
1209 735
                        default:
1210 735
                                break;
1211 3759
                        }
1212
1213 3759
                        process_vsl(&CTX.watch_vsl, tag, b, e);
1214 3759
                }
1215 100
                if (skip)
1216 0
                        continue;
1217 100
                i = print();
1218 100
                if (i)
1219 0
                        return (i);
1220 100
        }
1221
1222 128
        return (0);
1223 128
}
1224
1225
static char *
1226
read_format(const char *formatfile)
1227 3
{
1228 3
        FILE *fmtfile;
1229 3
        size_t len = 0;
1230 3
        int fmtlen;
1231 3
        char *fmt = NULL;
1232
1233 3
        fmtfile = fopen(formatfile, "r");
1234 3
        if (fmtfile == NULL)
1235 1
                VUT_Error(vut, 1, "Can't open format file (%s)",
1236 1
                    strerror(errno));
1237 2
        AN(fmtfile);
1238 2
        fmtlen = getline(&fmt, &len, fmtfile);
1239 2
        if (fmtlen == -1) {
1240 1
                free(fmt);
1241 1
                if (feof(fmtfile))
1242 1
                        VUT_Error(vut, 1, "Empty format file");
1243 0
                VUT_Error(vut, 1, "Can't read format from file (%s)",
1244 0
                    strerror(errno));
1245 1
        }
1246 1
        AZ(fclose(fmtfile));
1247 1
        if (fmt[fmtlen - 1] == '\n')
1248 1
                fmt[fmtlen - 1] = '\0';
1249 1
        return (fmt);
1250 1
}
1251
1252
int
1253
main(int argc, char * const *argv)
1254 83
{
1255 83
        signed char opt;
1256 83
        char *format = NULL;
1257 83
        int mode_opt = 0;
1258
1259 83
        vut = VUT_InitProg(argc, argv, &vopt_spec);
1260 83
        AN(vut);
1261 83
        memset(&CTX, 0, sizeof CTX);
1262 83
        VTAILQ_INIT(&CTX.format);
1263 83
        VTAILQ_INIT(&CTX.watch_vcl_log);
1264 83
        VTAILQ_INIT(&CTX.watch_reqhdr);
1265 83
        VTAILQ_INIT(&CTX.watch_resphdr);
1266 83
        VTAILQ_INIT(&CTX.watch_vsl);
1267 83
        CTX.vsb = VSB_new_auto();
1268 83
        AN(CTX.vsb);
1269 83
        CTX.quote_how = VSB_QUOTE_ESCHEX;
1270 83
        REPLACE(CTX.missing_string, "-");
1271 83
        REPLACE(CTX.missing_int, "-");
1272
1273 83
        tzset();                // We use localtime_r(3)
1274
1275 328
        while ((opt = getopt(argc, argv, vopt_spec.vopt_optstring)) != -1) {
1276 250
                switch (opt) {
1277 0
                case 'a':
1278
                        /* Append to file */
1279 0
                        CTX.a_opt = 1;
1280 0
                        break;
1281 10
                case 'b': /* backend mode */
1282 17
                case 'c': /* client mode */
1283 20
                case 'E': /* show ESI */
1284 20
                        AN(VUT_Arg(vut, opt, NULL));
1285 20
                        mode_opt = 1;
1286 20
                        break;
1287 59
                case 'F':
1288 59
                        if (format != NULL)
1289 0
                                VUT_Error(vut, 1, "Format already set");
1290 59
                        REPLACE(format, optarg);
1291 59
                        break;
1292 59
                case 'f':
1293 3
                        if (format != NULL)
1294 0
                                VUT_Error(vut, 1, "Format already set");
1295
                        /* Format string from file */
1296 3
                        format = read_format(optarg);
1297 3
                        AN(format);
1298 3
                        break;
1299 3
                case 'h':
1300
                        /* Usage help */
1301 1
                        VUT_Usage(vut, &vopt_spec, 0);
1302 0
                        break;
1303 5
                case 'j':
1304 5
                        REPLACE(CTX.missing_string, "");
1305 5
                        REPLACE(CTX.missing_int, "0");
1306 5
                        CTX.quote_how = VSB_QUOTE_JSON;
1307 5
                        break;
1308 4
                case 'w':
1309
                        /* Write to file */
1310 4
                        REPLACE(CTX.w_arg, optarg);
1311 4
                        break;
1312 158
                default:
1313 158
                        if (!VUT_Arg(vut, opt, optarg))
1314 0
                                VUT_Usage(vut, &vopt_spec, 1);
1315 250
                }
1316 250
        }
1317
1318
        /* default is client mode: */
1319 78
        if (!mode_opt)
1320 59
                AN(VUT_Arg(vut, 'c', NULL));
1321
1322 78
        if (optind != argc)
1323 1
                VUT_Usage(vut, &vopt_spec, 1);
1324
1325 77
        if (vut->D_opt && !CTX.w_arg)
1326 1
                VUT_Error(vut, 1, "Missing -w option");
1327
1328 76
        if (vut->D_opt && !vstrcmp(CTX.w_arg, "-"))
1329 0
                VUT_Error(vut, 1, "Daemon cannot write to stdout");
1330
1331
        /* Check for valid grouping mode */
1332 76
        assert(vut->g_arg < VSL_g__MAX);
1333 76
        if (vut->g_arg != VSL_g_vxid && vut->g_arg != VSL_g_request)
1334 1
                VUT_Error(vut, 1, "Invalid grouping mode: %s",
1335 1
                    VSLQ_grouping[vut->g_arg]);
1336
1337
        /* Prepare output format */
1338 75
        parse_format(format);
1339 75
        REPLACE(format, NULL);
1340
1341
        /* Setup output */
1342 75
        vut->dispatch_f = dispatch_f;
1343 75
        vut->dispatch_priv = NULL;
1344 75
        if (CTX.w_arg) {
1345 4
                openout(CTX.a_opt);
1346 4
                AN(CTX.fo);
1347 4
                if (vut->D_opt)
1348 1
                        vut->sighup_f = rotateout;
1349 4
        } else
1350 71
                CTX.fo = stdout;
1351 75
        vut->idle_f = flushout;
1352
1353 75
        VUT_Setup(vut);
1354 75
        (void)VUT_Main(vut);
1355 75
        VUT_Fini(&vut);
1356
1357 75
        exit(0);
1358 75
}