GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2016 Varnish Software AS
 * All rights reserved.
 *
 * Author: Anders Berg <andersb@vgnett.no>
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 * Author: Tollef Fog Heen <tfheen@varnish-software.com>
 * Author: Martin Blix Grydeland <mbgrydeland@varnish-software.com>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * Obtain log data from the shared memory log, order it by session ID, and
 * display it in Apache / NCSA combined log format.
 *
 * See doc/sphinx/reference/varnishncsa.rst for the supported format
 * specifiers.
 *
 */

#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <stdarg.h>
#include <inttypes.h>
#include <limits.h>
#include <ctype.h>
#include <time.h>
#include <math.h>

#define VOPT_DEFINITION
#define VOPT_INC "varnishncsa_options.h"

#include "vdef.h"

#include "vapi/vsl.h"
#include "vapi/voptget.h"
#include "vas.h"
#include "venc.h"
#include "vsb.h"
#include "vut.h"
#include "vqueue.h"
#include "miniobj.h"

#define TIME_FMT "[%d/%b/%Y:%T %z]"
#define FORMAT "%h %l %u %t \"%r\" %s %b \"%{Referer}i\" \"%{User-agent}i\""

static struct VUT *vut;

struct format;

enum e_frag {
        F_H,                    /* %H Proto */
        F_U,                    /* %U URL path */
        F_q,                    /* %q Query string */
        F_b,                    /* %b Body bytes sent */
        F_h,                    /* %h Host name / IP Address */
        F_m,                    /* %m Method */
        F_s,                    /* %s Status */
        F_I,                    /* %I Bytes received */
        F_O,                    /* %O Bytes sent */
        F_tstart,               /* Time start */
        F_tend,                 /* Time end */
        F_ttfb,                 /* %{Varnish:time_firstbyte}x */
        F_host,                 /* Host header */
        F_auth,                 /* Authorization header */
        F__MAX,
};

struct fragment {
        uint64_t                gen;
        const char              *b, *e;
};

typedef int format_f(const struct format *format);

struct format {
        unsigned                magic;
#define FORMAT_MAGIC            0xC3119CDA

        char                    time_type;
        VTAILQ_ENTRY(format)    list;
        format_f                *func;
        struct fragment         *frag;
        char                    *string;
        const char *const       *strptr;
        char                    *time_fmt;
        int64_t                 *int64;
};

struct watch {
        unsigned                magic;
#define WATCH_MAGIC             0xA7D4005C

        VTAILQ_ENTRY(watch)     list;
        char                    *key;
        int                     keylen;
        struct fragment         frag;
};
VTAILQ_HEAD(watch_head, watch);

struct vsl_watch {
        unsigned                magic;
#define VSL_WATCH_MAGIC         0xE3E27D23

        VTAILQ_ENTRY(vsl_watch) list;
        enum VSL_tag_e          tag;
        int                     idx;
        char                    *prefix;
        int                     prefixlen;
        struct fragment         frag;
};
VTAILQ_HEAD(vsl_watch_head, vsl_watch);

static struct ctx {
        /* Options */
        int                     a_opt;
        char                    *w_arg;

        FILE                    *fo;
        struct vsb              *vsb;
        uint64_t                gen;
        VTAILQ_HEAD(,format)    format;
        int                     quote_how;
        char                    *missing_string;
        char                    *missing_int;

        /* State */
        struct watch_head       watch_vcl_log;
        struct watch_head       watch_reqhdr; /* also bereqhdr */
        struct watch_head       watch_resphdr; /* also beresphdr */
        struct vsl_watch_head   watch_vsl;
        struct fragment         frag[F__MAX];
        const char              *hitmiss;
        const char              *handling;
        const char              *side;
        int64_t                 vxid;
        int                     recv_compl;
} CTX;

enum format_policy {
        FMTPOL_INTERNAL,
        FMTPOL_REQ,
        FMTPOL_RESP,
};

static void parse_format(const char *format);

static unsigned
frag_needed(const struct fragment *frag, enum format_policy fp)
{
        unsigned is_first, want_first, want_frag;

        is_first = CTX.gen != frag->gen;

        switch (fp) {
        case FMTPOL_INTERNAL:
                want_first = 1;
                want_frag = 1;
                break;
        case FMTPOL_REQ:
                want_first = *CTX.side == 'c';
                want_frag = !CTX.recv_compl;
                break;
        case FMTPOL_RESP:
                want_first = *CTX.side == 'b';
                want_frag = (*CTX.side == 'c') || !CTX.recv_compl;
                break;
        default:
                WRONG("Invalid format policy");
        }

        if (!want_frag)
                return (0);
        if (want_first && !is_first)
                return (0);
        return (1);
}

static void
openout(int append)
{

        AN(CTX.w_arg);
        if (!strcmp(CTX.w_arg, "-"))
                CTX.fo = stdout;
        else
                CTX.fo = fopen(CTX.w_arg, append ? "a" : "w");
        if (CTX.fo == NULL)
                VUT_Error(vut, 1, "Can't open output file (%s)",
                    strerror(errno));
}

static int v_matchproto_(VUT_cb_f)
rotateout(struct VUT *v)
{

        assert(v == vut);
        AN(CTX.w_arg);
        AN(CTX.fo);
        (void)fclose(CTX.fo);
        openout(1);
        AN(CTX.fo);
        return (0);
}

static int v_matchproto_(VUT_cb_f)
flushout(struct VUT *v)
{

        assert(v == vut);
        AN(CTX.fo);
        if (fflush(CTX.fo))
                return (-5);
        return (0);
}

static inline int
vsb_fcat(struct vsb *vsb, const struct fragment *f, const char *dflt)
{
        if (f->gen == CTX.gen) {
                assert(f->b <= f->e);
                VSB_quote(vsb, f->b, f->e - f->b, CTX.quote_how);
        } else if (dflt)
                VSB_quote(vsb, dflt, -1, CTX.quote_how);
        else
                return (-1);
        return (0);
}

static int v_matchproto_(format_f)
format_string(const struct format *format)
{

        CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
        AN(format->string);
        AZ(VSB_cat(CTX.vsb, format->string));
        return (1);
}

static int v_matchproto_(format_f)
format_strptr(const struct format *format)
{

        CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
        AN(format->strptr);
        AN(*format->strptr);
        AZ(VSB_cat(CTX.vsb, *format->strptr));
        return (1);
}

static int v_matchproto_(format_f)
format_int64(const struct format *format)
{

        CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
        VSB_printf(CTX.vsb, "%jd", (intmax_t)*format->int64);
        return (1);
}

static int v_matchproto_(format_f)
format_fragment(const struct format *format)
{

        CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
        AN(format->frag);

        if (format->frag->gen != CTX.gen) {
                if (format->string == NULL)
                        return (-1);
                VSB_quote(CTX.vsb, format->string, -1, CTX.quote_how);
                return (0);
        }
        AZ(vsb_fcat(CTX.vsb, format->frag, NULL));
        return (1);
}

static int v_matchproto_(format_f)
format_time(const struct format *format)
{
        double t_start, t_end, d;
        char *p;
        char buf[64];
        time_t t;
        intmax_t l;
        struct tm tm;

        CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
        if (CTX.frag[F_tstart].gen == CTX.gen) {
                t_start = strtod(CTX.frag[F_tstart].b, &p);
                if (p != CTX.frag[F_tstart].e)
                        t_start = NAN;
        } else
                t_start = NAN;
        if (isnan(t_start)) {
                /* Missing t_start is a no go */
                if (format->string == NULL)
                        return (-1);
                AZ(VSB_cat(CTX.vsb, format->string));
                return (0);
        }

        /* Missing t_end defaults to t_start */
        if (CTX.frag[F_tend].gen == CTX.gen) {
                t_end = strtod(CTX.frag[F_tend].b, &p);
                if (p != CTX.frag[F_tend].e)
                        t_end = t_start;
        } else
                t_end = t_start;

        AN(format->time_fmt);

        switch (format->time_type) {
        case 't':
                t = (intmax_t)floor(t_start);
                (void)localtime_r(&t, &tm);
                AN(strftime(buf, sizeof buf, format->time_fmt, &tm));
                AZ(VSB_cat(CTX.vsb, buf));
                return (1);
        case '3':
                l = (intmax_t)(modf(t_start, &d) * 1e3);
                break;
        case '6':
                l = (intmax_t)(modf(t_start, &d) * 1e6);
                break;
        case 'S':
                l = (intmax_t)t_start;
                break;
        case 'M':
                l = (intmax_t)(t_start * 1e3);
                break;
        case 'U':
                l = (intmax_t)(t_start * 1e6);
                break;
        case 's':
                l = (intmax_t)(t_end - t_start);
                break;
        case 'm':
                l = (intmax_t)((t_end - t_start) * 1e3);
                break;
        case 'u':
                l = (intmax_t)((t_end - t_start) * 1e6);
                break;
        default:
                WRONG("Time format specifier");
        }

#ifdef __FreeBSD__
        assert(fmtcheck(format->time_fmt, "%jd") == format->time_fmt);
#endif
        AZ(VSB_printf(CTX.vsb, format->time_fmt, l));

        return (1);
}

static int v_matchproto_(format_f)
format_requestline(const struct format *format)
{

        (void)format;
        AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_m], "-"));
        AZ(VSB_putc(CTX.vsb, ' '));
        if (CTX.frag[F_host].gen == CTX.gen) {
                if (strncmp(CTX.frag[F_host].b, "http://", 7))
                        AZ(VSB_cat(CTX.vsb, "http://"));
                AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_host], NULL));
        } else
                AZ(VSB_cat(CTX.vsb, "http://localhost"));
        AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_U], ""));
        AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_q], ""));
        AZ(VSB_putc(CTX.vsb, ' '));
        AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_H], "HTTP/1.0"));
        return (1);
}

static int v_matchproto_(format_f)
format_auth(const struct format *format)
{
        struct vsb *vsb = VSB_new_auto();
        AN(vsb);
        char *q;

        if (CTX.frag[F_auth].gen != CTX.gen ||
            VENC_Decode_Base64(vsb, CTX.frag[F_auth].b, CTX.frag[F_auth].e)) {
                VSB_destroy(&vsb);
                if (format->string == NULL)
                        return (-1);
                VSB_quote(CTX.vsb, format->string, -1, CTX.quote_how);
                return (0);
        }
        AZ(VSB_finish(vsb));
        q = strchr(VSB_data(vsb), ':');
        if (q != NULL)
                *q = '\0';
        VSB_quote(CTX.vsb, VSB_data(vsb), -1, CTX.quote_how);
        VSB_destroy(&vsb);
        return (1);
}

static int
print(void)
{
        const struct format *f;
        int i, r = 1;

        VSB_clear(CTX.vsb);
        VTAILQ_FOREACH(f, &CTX.format, list) {
                CHECK_OBJ_NOTNULL(f, FORMAT_MAGIC);
                i = (f->func)(f);
                AZ(VSB_error(CTX.vsb));
                if (r > i)
                        r = i;
        }
        AZ(VSB_putc(CTX.vsb, '\n'));
        AZ(VSB_finish(CTX.vsb));
        if (r >= 0) {
                i = fwrite(VSB_data(CTX.vsb), 1, VSB_len(CTX.vsb), CTX.fo);
                if (i != VSB_len(CTX.vsb))
                        return (-5);
        }
        return (0);
}

static void
addf_string(const char *str)
{
        struct format *f;

        AN(str);
        ALLOC_OBJ(f, FORMAT_MAGIC);
        AN(f);
        f->func = format_string;
        f->string = strdup(str);
        AN(f->string);
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
}

static void
addf_strptr(const char *const *strptr)
{
        struct format *f;

        AN(strptr);
        ALLOC_OBJ(f, FORMAT_MAGIC);
        AN(f);
        f->func = format_strptr;
        f->strptr = strptr;
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
}

static void
addf_fragment(struct fragment *frag, const char *str)
{
        struct format *f;

        AN(frag);
        ALLOC_OBJ(f, FORMAT_MAGIC);
        AN(f);
        f->func = format_fragment;
        f->frag = frag;
        if (str != NULL) {
                f->string = strdup(str);
                AN(f->string);
        }
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
}

static void
addf_int64(int64_t *i)
{
        struct format *f;

        AN(i);
        ALLOC_OBJ(f, FORMAT_MAGIC);
        AN(f);
        f->func = format_int64;
        f->int64 = i;
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
}

static void
addf_time(char type, const char *fmt)
{
        struct format *f;

        ALLOC_OBJ(f, FORMAT_MAGIC);
        AN(f);
        AN(fmt);
        f->func = format_time;
        f->time_type = type;
        f->time_fmt = strdup(fmt);

        if (f->time_type == 'T') {
                if (!strcmp(fmt, "s"))
                        f->time_type = 's';
                else if (!strcmp(fmt, "ms"))
                        f->time_type = 'm';
                else if (!strcmp(fmt, "us"))
                        f->time_type = 'u';
                else
                        VUT_Error(vut, 1, "Unknown specifier: %%{%s}T",
                            fmt);
                REPLACE(f->time_fmt, "%jd");
        } else if (f->time_type == 't') {
                if (!strcmp(fmt, "sec")) {
                        f->time_type = 'S';
                        REPLACE(f->time_fmt, "%jd");
                } else if (!strncmp(fmt, "msec", 4)) {
                        fmt += 4;
                        if (!strcmp(fmt, "_frac")) {
                                f->time_type = '3';
                                REPLACE(f->time_fmt, "%03jd");
                        } else if (*fmt == '\0') {
                                f->time_type = 'M';
                                REPLACE(f->time_fmt, "%jd");
                        }
                } else if (!strncmp(fmt, "usec", 4)) {
                        fmt += 4;
                        if (!strcmp(fmt, "_frac")) {
                                f->time_type = '6';
                                REPLACE(f->time_fmt, "%06jd");
                        } else if (*fmt == '\0') {
                                f->time_type = 'U';
                                REPLACE(f->time_fmt, "%jd");
                        }
                }
        }

        AN(f->time_fmt);
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
}

static void
addf_requestline(void)
{
        struct format *f;

        ALLOC_OBJ(f, FORMAT_MAGIC);
        AN(f);
        f->func = format_requestline;
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
}

static void
addf_vcl_log(const char *key)
{
        struct watch *w;
        struct format *f;

        AN(key);
        ALLOC_OBJ(w, WATCH_MAGIC);
        AN(w);
        w->keylen = asprintf(&w->key, "%s:", key);
        assert(w->keylen > 0);
        VTAILQ_INSERT_TAIL(&CTX.watch_vcl_log, w, list);

        ALLOC_OBJ(f, FORMAT_MAGIC);
        AN(f);
        f->func = format_fragment;
        f->frag = &w->frag;
        f->string = strdup("");
        AN(f->string);
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
}

static void
addf_hdr(struct watch_head *head, const char *key)
{
        struct watch *w;
        struct format *f;

        AN(head);
        AN(key);
        ALLOC_OBJ(w, WATCH_MAGIC);
        AN(w);
        w->keylen = asprintf(&w->key, "%s:", key);
        assert(w->keylen > 0);
        VTAILQ_INSERT_TAIL(head, w, list);

        ALLOC_OBJ(f, FORMAT_MAGIC);
        AN(f);
        f->func = format_fragment;
        f->frag = &w->frag;
        f->string = strdup(CTX.missing_string);
        AN(f->string);
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
}

static void
addf_vsl(enum VSL_tag_e tag, long i, const char *prefix)
{
        struct vsl_watch *w;

        ALLOC_OBJ(w, VSL_WATCH_MAGIC);
        AN(w);
        if (VSL_tagflags[tag] && CTX.quote_how != VSB_QUOTE_JSON)
                VUT_Error(vut, 1, "Tag %s can contain control characters",
                    VSL_tags[tag]);
        w->tag = tag;
        assert(i <= INT_MAX);
        w->idx = i;
        if (prefix != NULL) {
                w->prefixlen = asprintf(&w->prefix, "%s:", prefix);
                assert(w->prefixlen > 0);
        }
        VTAILQ_INSERT_TAIL(&CTX.watch_vsl, w, list);
        addf_fragment(&w->frag, CTX.missing_string);
}

static void
addf_auth(void)
{
        struct format *f;

        ALLOC_OBJ(f, FORMAT_MAGIC);
        AN(f);
        f->func = format_auth;
        f->string = strdup("-");
        AN(f->string);
        VTAILQ_INSERT_TAIL(&CTX.format, f, list);
}

static void
parse_x_format(char *buf)
{
        char *e, *r, *s;
        long lval;
        int slt;

        if (!strcmp(buf, "Varnish:time_firstbyte")) {
                addf_fragment(&CTX.frag[F_ttfb], CTX.missing_int);
                return;
        }
        if (!strcmp(buf, "Varnish:hitmiss")) {
                addf_strptr(&CTX.hitmiss);
                return;
        }
        if (!strcmp(buf, "Varnish:handling")) {
                addf_strptr(&CTX.handling);
                return;
        }
        if (!strcmp(buf, "Varnish:side")) {
                addf_strptr(&CTX.side);
                return;
        }
        if (!strcmp(buf, "Varnish:vxid")) {
                addf_int64(&CTX.vxid);
                return;
        }
        if (!strncmp(buf, "VCL_Log:", 8)) {
                addf_vcl_log(buf + 8);
                return;
        }
        if (!strncmp(buf, "VSL:", 4)) {
                buf += 4;
                e = buf;
                while (*e != '\0')
                        e++;
                if (e == buf)
                        VUT_Error(vut, 1, "Missing tag in VSL:");
                if (e[-1] == ']') {
                        r = e - 1;
                        while (r > buf && *r != '[')
                                r--;
                        if (r == buf || r[1] == ']')
                                VUT_Error(vut, 1, "Syntax error: VSL:%s", buf);
                        e[-1] = '\0';
                        lval = strtol(r + 1, &s, 10);
                        if (s != e - 1)
                                VUT_Error(vut, 1, "Syntax error: VSL:%s]", buf);
                        if (lval <= 0 || lval > 255) {
                                VUT_Error(vut, 1,
                                    "Syntax error. Field specifier must be"
                                    " between 1 and 255: %s]",
                                    buf);
                        }
                        *r = '\0';
                } else
                        lval = 0;
                r = buf;
                while (r < e && *r != ':')
                        r++;
                if (r != e) {
                        slt = VSL_Name2Tag(buf, r - buf);
                        r++;
                } else {
                        slt = VSL_Name2Tag(buf, -1);
                        r = NULL;
                }
                if (slt == -2)
                        VUT_Error(vut, 1, "Tag not unique: %s", buf);
                if (slt == -1)
                        VUT_Error(vut, 1, "Unknown log tag: %s", buf);
                assert(slt >= 0);

                addf_vsl((enum VSL_tag_e)slt, lval, r);
                return;
        }
        if (!strcmp(buf, "Varnish:default_format")) {
                parse_format(FORMAT);
                return;
        }
        VUT_Error(vut, 1, "Unknown formatting extension: %s", buf);
}

static void
parse_format(const char *format)
{
        const char *p, *q;
        struct vsb *vsb;
        char buf[256];
        int b;

        if (format == NULL)
                format = FORMAT;

        vsb = VSB_new_auto();
        AN(vsb);

        for (p = format; *p != '\0'; p++) {

                /* Allow the most essential escape sequences in format */
                if (*p == '\\' && p[1] != '\0') {
                        if (*++p == 't')
                                AZ(VSB_putc(vsb, '\t'));
                        else if (*p == 'n')
                                AZ(VSB_putc(vsb, '\n'));
                        else
                                AZ(VSB_putc(vsb, *p));
                        continue;
                }

                if (*p != '%') {
                        AZ(VSB_putc(vsb, *p));
                        continue;
                }

                if (VSB_len(vsb) > 0) {
                        AZ(VSB_finish(vsb));
                        addf_string(VSB_data(vsb));
                        VSB_clear(vsb);
                }

                p++;
                switch (*p) {
                case 'b':       /* Body bytes sent */
                        addf_fragment(&CTX.frag[F_b], CTX.missing_int);
                        break;
                case 'D':       /* Float request time */
                        addf_time('T', "us");
                        break;
                case 'h':       /* Client host name / IP Address */
                        addf_fragment(&CTX.frag[F_h], CTX.missing_string);
                        break;
                case 'H':       /* Protocol */
                        addf_fragment(&CTX.frag[F_H], "HTTP/1.0");
                        break;
                case 'I':       /* Bytes received */
                        addf_fragment(&CTX.frag[F_I], CTX.missing_int);
                        break;
                case 'l':       /* Client user ID (identd) always '-' */
                        AZ(VSB_putc(vsb, '-'));
                        break;
                case 'm':       /* Method */
                        addf_fragment(&CTX.frag[F_m], CTX.missing_string);
                        break;
                case 'O':       /* Bytes sent */
                        addf_fragment(&CTX.frag[F_O], CTX.missing_int);
                        break;
                case 'q':       /* Query string */
                        addf_fragment(&CTX.frag[F_q], "");
                        break;
                case 'r':       /* Request line */
                        addf_requestline();
                        break;
                case 's':       /* Status code */
                        addf_fragment(&CTX.frag[F_s], CTX.missing_int);
                        break;
                case 't':       /* strftime */
                        addf_time(*p, TIME_FMT);
                        break;
                case 'T':       /* Int request time */
                        addf_time(*p, "s");
                        break;
                case 'u':       /* Remote user from auth */
                        addf_auth();
                        break;
                case 'U':       /* URL */
                        addf_fragment(&CTX.frag[F_U], CTX.missing_string);
                        break;
                case '{':
                        p++;
                        q = p;
                        b = 1;
                        while (*q) {
                                if (*q == '{')
                                        b++;
                                else if (*q == '}')
                                        if (--b == 0)
                                                break;
                                q++;
                        }
                        if (b > 0)
                                VUT_Error(vut, 1, "Unmatched bracket at: %s",
                                    p - 2);
                        assert((unsigned)(q - p) < sizeof buf - 1);
                        strncpy(buf, p, q - p);
                        buf[q - p] = '\0';
                        q++;
                        switch (*q) {
                        case 'i':
                                addf_hdr(&CTX.watch_reqhdr, buf);
                                break;
                        case 'o':
                                addf_hdr(&CTX.watch_resphdr, buf);
                                break;
                        case 't':
                                addf_time(*q, buf);
                                break;
                        case 'T':
                                addf_time(*q, buf);
                                break;
                        case 'x':
                                parse_x_format(buf);
                                break;
                        default:
                                VUT_Error(vut, 1,
                                    "Unknown format specifier at: %s",
                                    p - 2);
                        }
                        p = q;
                        break;
                default:
                        VUT_Error(vut, 1, "Unknown format specifier at: %s",
                            p - 1);
                }
        }

        if (VSB_len(vsb) > 0) {
                /* Add any remaining static */
                AZ(VSB_finish(vsb));
                addf_string(VSB_data(vsb));
                VSB_clear(vsb);
        }

        VSB_destroy(&vsb);
}

static int
isprefix(const char *prefix, size_t len, const char *b,
    const char *e, const char **next)
{
        assert(len > 0);
        if (e < b + len || strncasecmp(b, prefix, len))
                return (0);
        b += len;
        if (next) {
                while (b < e && *b == ' ')
                        b++;
                *next = b;
        }
        return (1);
}

static void
frag_fields(enum format_policy fp, const char *b, const char *e, ...)
{
        va_list ap;
        const char *p, *q;
        int n, field;
        struct fragment *frag;

        AN(b);
        AN(e);
        va_start(ap, e);

        n = 0;
        while (1) {
                field = va_arg(ap, int);
                frag = va_arg(ap, struct fragment *);
                if (field == 0) {
                        AZ(frag);
                        break;
                }
                p = q = NULL;
                while (n < field) {
                        while (b < e && isspace(*b))
                                b++;
                        p = b;
                        while (b < e && !isspace(*b))
                                b++;
                        q = b;
                        n++;
                }
                assert(p != NULL && q != NULL);
                if (p >= e || q <= p)
                        continue;
                if (frag_needed(frag, fp)) {
                        /* We only grab the same matching field once */
                        frag->gen = CTX.gen;
                        frag->b = p;
                        frag->e = q;
                }
        }
        va_end(ap);
}

static void
frag_line(enum format_policy fp, const char *b, const char *e,
    struct fragment *f)
{

        if (!frag_needed(f, fp))
                /* We only grab the same matching record once */
                return;

        if (e == NULL)
                e = b + strlen(b);

        /* Skip leading space */
        while (b < e && isspace(*b))
                ++b;

        /* Skip trailing space */
        while (e > b && isspace(e[-1]))
                --e;

        f->gen = CTX.gen;
        f->b = b;
        f->e = e;
}

static void
process_hdr(enum format_policy fp, const struct watch_head *head, const char *b,
    const char *e, int unset)
{
        struct watch *w;
        const char *p;

        VTAILQ_FOREACH(w, head, list) {
                CHECK_OBJ_NOTNULL(w, WATCH_MAGIC);
                if (!isprefix(w->key, w->keylen, b, e, &p))
                        continue;
                if (unset) {
                        frag_line(fp, CTX.missing_string,
                            NULL,
                            &w->frag);
                } else
                        frag_line(fp, p, e, &w->frag);
        }
}

static void
process_vsl(const struct vsl_watch_head *head, enum VSL_tag_e tag,
    const char *b, const char *e)
{
        struct vsl_watch *w;
        const char *p;
        VTAILQ_FOREACH(w, head, list) {
                CHECK_OBJ_NOTNULL(w, VSL_WATCH_MAGIC);
                if (tag != w->tag)
                        continue;
                p = b;
                if (w->prefixlen > 0 &&
                    !isprefix(w->prefix, w->prefixlen, b, e, &p))
                        continue;
                if (w->idx == 0)
                        frag_line(FMTPOL_INTERNAL, p, e, &w->frag);
                else
                        frag_fields(FMTPOL_INTERNAL, p, e, w->idx, &w->frag, 0, NULL);
        }
}

static int v_matchproto_(VSLQ_dispatch_f)
dispatch_f(struct VSL_data *vsl, struct VSL_transaction * const pt[],
    void *priv)
{
        struct VSL_transaction *t;
        enum VSL_tag_e tag;
        const char *b, *e, *p;
        struct watch *w;
        int i, skip;

        (void)vsl;
        (void)priv;

        for (t = pt[0]; t != NULL; t = *++pt) {
                CTX.gen++;

                if (t->type == VSL_t_req) {
                        CTX.side = "c";
                } else if (t->type == VSL_t_bereq) {
                        CTX.side = "b";
                } else
                        continue;

                CTX.recv_compl = 0;
                CTX.hitmiss = "-";
                CTX.handling = "-";
                CTX.vxid = t->vxid;
                skip = 0;
                while (skip == 0 && 1 == VSL_Next(t->c)) {
                        tag = VSL_TAG(t->c->rec.ptr);
                        if (VSL_tagflags[tag] &&
                            CTX.quote_how != VSB_QUOTE_JSON)
                                continue;

                        b = VSL_CDATA(t->c->rec.ptr);
                        e = b + VSL_LEN(t->c->rec.ptr);
                        if (!VSL_tagflags[tag]) {
                                while (e > b && e[-1] == '\0')
                                        e--;
                        }

                        switch (tag) {
                        case SLT_HttpGarbage:
                                skip = 1;
                                break;
                        case SLT_PipeAcct:
                                frag_fields(FMTPOL_INTERNAL, b, e,
                                    3, &CTX.frag[F_I],
                                    4, &CTX.frag[F_O],
                                    0, NULL);
                                break;
                        case SLT_BackendOpen:
                                frag_fields(FMTPOL_INTERNAL, b, e,
                                    3, &CTX.frag[F_h],
                                    0, NULL);
                                break;
                        case SLT_ReqStart:
                                frag_fields(FMTPOL_INTERNAL, b, e,
                                    1, &CTX.frag[F_h],
                                    0, NULL);
                                break;
                        case SLT_BereqMethod:
                        case SLT_ReqMethod:
                                frag_line(FMTPOL_REQ, b, e, &CTX.frag[F_m]);
                                break;
                        case SLT_BereqURL:
                        case SLT_ReqURL:
                                p = memchr(b, '?', e - b);
                                if (p == NULL)
                                        p = e;
                                frag_line(FMTPOL_REQ, b, p, &CTX.frag[F_U]);
                                frag_line(FMTPOL_REQ, p, e, &CTX.frag[F_q]);
                                break;
                        case SLT_BereqProtocol:
                        case SLT_ReqProtocol:
                                frag_line(FMTPOL_REQ, b, e, &CTX.frag[F_H]);
                                break;
                        case SLT_BerespStatus:
                        case SLT_RespStatus:
                                frag_line(FMTPOL_RESP, b, e, &CTX.frag[F_s]);
                                break;
                        case SLT_BereqAcct:
                        case SLT_ReqAcct:
                                frag_fields(FMTPOL_INTERNAL, b, e,
                                    3, &CTX.frag[F_I],
                                    5, &CTX.frag[F_b],
                                    6, &CTX.frag[F_O],
                                    0, NULL);
                                break;
                        case SLT_Timestamp:
#define ISPREFIX(a, b, c, d)    isprefix(a, strlen(a), b, c, d)
                                if (ISPREFIX("Start:", b, e, &p)) {
                                        frag_fields(FMTPOL_INTERNAL, p, e, 1,
                                            &CTX.frag[F_tstart], 0, NULL);

                                } else if (ISPREFIX("Resp:", b, e, &p) ||
                                    ISPREFIX("PipeSess:", b, e, &p) ||
                                    ISPREFIX("BerespBody:", b, e, &p)) {
                                        frag_fields(FMTPOL_INTERNAL, p, e, 1,
                                            &CTX.frag[F_tend], 0, NULL);

                                } else if (ISPREFIX("Process:", b, e, &p) ||
                                    ISPREFIX("Pipe:", b, e, &p) ||
                                    ISPREFIX("Beresp:", b, e, &p)) {
                                        frag_fields(FMTPOL_INTERNAL, p, e, 2,
                                            &CTX.frag[F_ttfb], 0, NULL);
                                }
                                break;
                        case SLT_BereqHeader:
                        case SLT_ReqHeader:
                                process_hdr(FMTPOL_REQ, &CTX.watch_reqhdr, b, e, 0);
                                if (ISPREFIX("Authorization:", b, e, &p) &&
                                    ISPREFIX("basic ", p, e, &p))
                                        frag_line(FMTPOL_REQ, p, e,
                                            &CTX.frag[F_auth]);
                                else if (ISPREFIX("Host:", b, e, &p))
                                        frag_line(FMTPOL_REQ, p, e,
                                            &CTX.frag[F_host]);
#undef ISPREFIX
                                break;
                        case SLT_BerespHeader:
                        case SLT_RespHeader:
                                process_hdr(FMTPOL_RESP, &CTX.watch_resphdr, b, e, 0);
                                break;
                        case SLT_BereqUnset:
                        case SLT_ReqUnset:
                                process_hdr(FMTPOL_REQ, &CTX.watch_reqhdr, b, e, 1);
                                break;
                        case SLT_BerespUnset:
                        case SLT_RespUnset:
                                process_hdr(FMTPOL_RESP, &CTX.watch_resphdr, b, e, 1);
                                break;
                        case SLT_HitMiss:
                                CTX.hitmiss = "miss";
                                CTX.handling = "hitmiss";
                                break;
                        case SLT_HitPass:
                                CTX.hitmiss = "miss";
                                CTX.handling = "hitpass";
                                break;
                        case SLT_VCL_call:
                                if (!strcasecmp(b, "recv")) {
                                        CTX.recv_compl = 1;
                                        CTX.hitmiss = "-";
                                        CTX.handling = "-";
                                } else if (!strcasecmp(b, "hit")) {
                                        CTX.hitmiss = "hit";
                                        CTX.handling = "hit";
                                } else if (!strcasecmp(b, "miss") && strcmp(CTX.handling, "hitmiss")) {
                                        CTX.hitmiss = "miss";
                                        CTX.handling = "miss";
                                } else if (!strcasecmp(b, "pass") && strcmp(CTX.handling, "hitpass")) {
                                        CTX.hitmiss = "miss";
                                        CTX.handling = "pass";
                                } else if (!strcasecmp(b, "synth")) {
                                        /* Arguably, synth isn't a hit or
                                           a miss, but miss is less
                                           wrong */
                                        CTX.hitmiss = "miss";
                                        CTX.handling = "synth";
                                } else if (!strcasecmp(b, "backend_response")) {
                                        CTX.recv_compl = 1;
                                }
                                break;
                        case SLT_VCL_return:
                                if (!strcasecmp(b, "pipe")) {
                                        CTX.hitmiss = "miss";
                                        CTX.handling = "pipe";
                                } else if (!strcasecmp(b, "restart"))
                                        skip = 1;
                                break;
                        case SLT_VCL_Log:
                                VTAILQ_FOREACH(w, &CTX.watch_vcl_log, list) {
                                        CHECK_OBJ_NOTNULL(w, WATCH_MAGIC);
                                        if (e - b < w->keylen ||
                                            strncmp(b, w->key, w->keylen))
                                                continue;
                                        p = b + w->keylen;
                                        frag_line(FMTPOL_INTERNAL, p, e, &w->frag);
                                }
                                break;
                        default:
                                break;
                        }

                        process_vsl(&CTX.watch_vsl, tag, b, e);
                }
                if (skip)
                        continue;
                i = print();
                if (i)
                        return (i);
        }

        return (0);
}

static char *
read_format(const char *formatfile)
{
        FILE *fmtfile;
        size_t len = 0;
        int fmtlen;
        char *fmt = NULL;

        fmtfile = fopen(formatfile, "r");
        if (fmtfile == NULL)
                VUT_Error(vut, 1, "Can't open format file (%s)",
                    strerror(errno));
        AN(fmtfile);
        fmtlen = getline(&fmt, &len, fmtfile);
        if (fmtlen == -1) {
                free(fmt);
                if (feof(fmtfile))
                        VUT_Error(vut, 1, "Empty format file");
                VUT_Error(vut, 1, "Can't read format from file (%s)",
                    strerror(errno));
        }
        AZ(fclose(fmtfile));
        if (fmt[fmtlen - 1] == '\n')
                fmt[fmtlen - 1] = '\0';
        return (fmt);
}

int
main(int argc, char * const *argv)
{
        signed char opt;
        char *format = NULL;
        int mode_opt = 0;

        vut = VUT_InitProg(argc, argv, &vopt_spec);
        AN(vut);
        memset(&CTX, 0, sizeof CTX);
        VTAILQ_INIT(&CTX.format);
        VTAILQ_INIT(&CTX.watch_vcl_log);
        VTAILQ_INIT(&CTX.watch_reqhdr);
        VTAILQ_INIT(&CTX.watch_resphdr);
        VTAILQ_INIT(&CTX.watch_vsl);
        CTX.vsb = VSB_new_auto();
        AN(CTX.vsb);
        CTX.quote_how = VSB_QUOTE_ESCHEX;
        REPLACE(CTX.missing_string, "-");
        REPLACE(CTX.missing_int, "-");

        tzset();                // We use localtime_r(3)

        while ((opt = getopt(argc, argv, vopt_spec.vopt_optstring)) != -1) {
                switch (opt) {
                case 'a':
                        /* Append to file */
                        CTX.a_opt = 1;
                        break;
                case 'b': /* backend mode */
                case 'c': /* client mode */
                case 'E': /* show ESI */
                        AN(VUT_Arg(vut, opt, NULL));
                        mode_opt = 1;
                        break;
                case 'F':
                        if (format != NULL)
                                VUT_Error(vut, 1, "Format already set");
                        REPLACE(format, optarg);
                        break;
                case 'f':
                        if (format != NULL)
                                VUT_Error(vut, 1, "Format already set");
                        /* Format string from file */
                        format = read_format(optarg);
                        AN(format);
                        break;
                case 'h':
                        /* Usage help */
                        VUT_Usage(vut, &vopt_spec, 0);
                        break;
                case 'j':
                        REPLACE(CTX.missing_string, "");
                        REPLACE(CTX.missing_int, "0");
                        CTX.quote_how = VSB_QUOTE_JSON;
                        break;
                case 'w':
                        /* Write to file */
                        REPLACE(CTX.w_arg, optarg);
                        break;
                default:
                        if (!VUT_Arg(vut, opt, optarg))
                                VUT_Usage(vut, &vopt_spec, 1);
                }
        }

        /* default is client mode: */
        if (!mode_opt)
                AN(VUT_Arg(vut, 'c', NULL));

        if (optind != argc)
                VUT_Usage(vut, &vopt_spec, 1);

        if (vut->D_opt && !CTX.w_arg)
                VUT_Error(vut, 1, "Missing -w option");

        if (vut->D_opt && !strcmp(CTX.w_arg, "-"))
                VUT_Error(vut, 1, "Daemon cannot write to stdout");

        /* Check for valid grouping mode */
        assert(vut->g_arg < VSL_g__MAX);
        if (vut->g_arg != VSL_g_vxid && vut->g_arg != VSL_g_request)
                VUT_Error(vut, 1, "Invalid grouping mode: %s",
                    VSLQ_grouping[vut->g_arg]);

        /* Prepare output format */
        parse_format(format);
        REPLACE(format, NULL);

        /* Setup output */
        vut->dispatch_f = dispatch_f;
        vut->dispatch_priv = NULL;
        if (CTX.w_arg) {
                openout(CTX.a_opt);
                AN(CTX.fo);
                if (vut->D_opt)
                        vut->sighup_f = rotateout;
        } else
                CTX.fo = stdout;
        vut->idle_f = flushout;

        VUT_Setup(vut);
        (void)VUT_Main(vut);
        VUT_Fini(&vut);

        exit(0);
}

		varnish-cache/bin/varnishncsa/varnishncsa.c
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/varnishncsa.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 "varnishncsa_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		#define TIME_FMT "[%d/%b/%Y:%T %z]"
70		#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, /* %{Varnish:time_firstbyte}x */
89		F_host, /* Host header */
90		F_auth, /* Authorization header */
91		F__MAX,
92		};
93
94		struct fragment {
95		uint64_t gen;
96		const char b, e;
97		};
98
99		typedef int format_f(const struct format *format);
100
101		struct format {
102		unsigned magic;
103		#define FORMAT_MAGIC 0xC3119CDA
104
105		char time_type;
106		VTAILQ_ENTRY(format) list;
107		format_f *func;
108		struct fragment *frag;
109		char *string;
110		const char const strptr;
111		char *time_fmt;
112		int64_t *int64;
113		};
114
115		struct watch {
116		unsigned magic;
117		#define WATCH_MAGIC 0xA7D4005C
118
119		VTAILQ_ENTRY(watch) list;
120		char *key;
121		int keylen;
122		struct fragment frag;
123		};
124		VTAILQ_HEAD(watch_head, watch);
125
126		struct vsl_watch {
127		unsigned magic;
128		#define VSL_WATCH_MAGIC 0xE3E27D23
129
130		VTAILQ_ENTRY(vsl_watch) list;
131		enum VSL_tag_e tag;
132		int idx;
133		char *prefix;
134		int prefixlen;
135		struct fragment frag;
136		};
137		VTAILQ_HEAD(vsl_watch_head, vsl_watch);
138
139		static struct ctx {
140		/* Options */
141		int a_opt;
142		char *w_arg;
143
144		FILE *fo;
145		struct vsb *vsb;
146		uint64_t gen;
147		VTAILQ_HEAD(,format) format;
148		int quote_how;
149		char *missing_string;
150		char *missing_int;
151
152		/* State */
153		struct watch_head watch_vcl_log;
154		struct watch_head watch_reqhdr; /* also bereqhdr */
155		struct watch_head watch_resphdr; /* also beresphdr */
156		struct vsl_watch_head watch_vsl;
157		struct fragment frag[F__MAX];
158		const char *hitmiss;
159		const char *handling;
160		const char *side;
161		int64_t vxid;
162		int recv_compl;
163		} CTX;
164
165		enum format_policy {
166		FMTPOL_INTERNAL,
167		FMTPOL_REQ,
168		FMTPOL_RESP,
169		};
170
171		static void parse_format(const char *format);
172
173		static unsigned
174	1386	frag_needed(const struct fragment *frag, enum format_policy fp)
175		{
176		unsigned is_first, want_first, want_frag;
177
178	1386	is_first = CTX.gen != frag->gen;
179
180	1386	switch (fp) {
181		case FMTPOL_INTERNAL:
182	709	want_first = 1;
183	709	want_frag = 1;
184	709	break;
185		case FMTPOL_REQ:
186	575	want_first = *CTX.side == 'c';
187	575	want_frag = !CTX.recv_compl;
188	575	break;
189		case FMTPOL_RESP:
190	102	want_first = *CTX.side == 'b';
191	102	want_frag = (*CTX.side == 'c') \|\| !CTX.recv_compl;
192	102	break;
193		default:
194	0	WRONG("Invalid format policy");
195	0	}
196
197	1386	if (!want_frag)
198	44	return (0);
199	1342	if (want_first && !is_first)
200	36	return (0);
201	1306	return (1);
202	1386	}
203
204		static void
205	5	openout(int append)
206		{
207
208	5	AN(CTX.w_arg);
209	5	if (!strcmp(CTX.w_arg, "-"))
210	0	CTX.fo = stdout;
211		else
212	5	CTX.fo = fopen(CTX.w_arg, append ? "a" : "w");
213	5	if (CTX.fo == NULL)
214	2	VUT_Error(vut, 1, "Can't open output file (%s)",
215	1	strerror(errno));
216	4	}
217
218		static int v_matchproto_(VUT_cb_f)
219	1	rotateout(struct VUT *v)
220		{
221
222	1	assert(v == vut);
223	1	AN(CTX.w_arg);
224	1	AN(CTX.fo);
225	1	(void)fclose(CTX.fo);
226	1	openout(1);
227	1	AN(CTX.fo);
228	1	return (0);
229		}
230
231		static int v_matchproto_(VUT_cb_f)
232	857	flushout(struct VUT *v)
233		{
234
235	857	assert(v == vut);
236	857	AN(CTX.fo);
237	857	if (fflush(CTX.fo))
238	0	return (-5);
239	857	return (0);
240	857	}
241
242		static inline int
243	238	vsb_fcat(struct vsb vsb, const struct fragment f, const char *dflt)
244		{
245	238	if (f->gen == CTX.gen) {
246	234	assert(f->b <= f->e);
247	234	VSB_quote(vsb, f->b, f->e - f->b, CTX.quote_how);
248	238	} else if (dflt)
249	4	VSB_quote(vsb, dflt, -1, CTX.quote_how);
250		else
251	0	return (-1);
252	238	return (0);
253	238	}
254
255		static int v_matchproto_(format_f)
256	305	format_string(const struct format *format)
257		{
258
259	305	CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
260	305	AN(format->string);
261	305	AZ(VSB_cat(CTX.vsb, format->string));
262	305	return (1);
263		}
264
265		static int v_matchproto_(format_f)
266	37	format_strptr(const struct format *format)
267		{
268
269	37	CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
270	37	AN(format->strptr);
271	37	AN(*format->strptr);
272	37	AZ(VSB_cat(CTX.vsb, *format->strptr));
273	37	return (1);
274		}
275
276		static int v_matchproto_(format_f)
277	21	format_int64(const struct format *format)
278		{
279
280	21	CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
281	21	VSB_printf(CTX.vsb, "%jd", (intmax_t)*format->int64);
282	21	return (1);
283		}
284
285		static int v_matchproto_(format_f)
286	213	format_fragment(const struct format *format)
287		{
288
289	213	CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
290	213	AN(format->frag);
291
292	213	if (format->frag->gen != CTX.gen) {
293	48	if (format->string == NULL)
294	0	return (-1);
295	48	VSB_quote(CTX.vsb, format->string, -1, CTX.quote_how);
296	48	return (0);
297		}
298	165	AZ(vsb_fcat(CTX.vsb, format->frag, NULL));
299	165	return (1);
300	213	}
301
302		static int v_matchproto_(format_f)
303	60	format_time(const struct format *format)
304		{
305		double t_start, t_end, d;
306		char *p;
307		char buf[64];
308		time_t t;
309		intmax_t l;
310		struct tm tm;
311
312	60	CHECK_OBJ_NOTNULL(format, FORMAT_MAGIC);
313	60	if (CTX.frag[F_tstart].gen == CTX.gen) {
314	60	t_start = strtod(CTX.frag[F_tstart].b, &p);
315	60	if (p != CTX.frag[F_tstart].e)
316	0	t_start = NAN;
317	60	} else
318	0	t_start = NAN;
319	60	if (isnan(t_start)) {
320		/* Missing t_start is a no go */
321	0	if (format->string == NULL)
322	0	return (-1);
323	0	AZ(VSB_cat(CTX.vsb, format->string));
324	0	return (0);
325		}
326
327		/* Missing t_end defaults to t_start */
328	60	if (CTX.frag[F_tend].gen == CTX.gen) {
329	59	t_end = strtod(CTX.frag[F_tend].b, &p);
330	59	if (p != CTX.frag[F_tend].e)
331	0	t_end = t_start;
332	59	} else
333	1	t_end = t_start;
334
335	60	AN(format->time_fmt);
336
337	60	switch (format->time_type) {
338		case 't':
339	30	t = (intmax_t)floor(t_start);
340	30	(void)localtime_r(&t, &tm);
341	30	AN(strftime(buf, sizeof buf, format->time_fmt, &tm));
342	30	AZ(VSB_cat(CTX.vsb, buf));
343	30	return (1);
344		case '3':
345	3	l = (intmax_t)(modf(t_start, &d) * 1e3);
346	3	break;
347		case '6':
348	3	l = (intmax_t)(modf(t_start, &d) * 1e6);
349	3	break;
350		case 'S':
351	3	l = (intmax_t)t_start;
352	3	break;
353		case 'M':
354	3	l = (intmax_t)(t_start * 1e3);
355	3	break;
356		case 'U':
357	3	l = (intmax_t)(t_start * 1e6);
358	3	break;
359		case 's':
360	6	l = (intmax_t)(t_end - t_start);
361	6	break;
362		case 'm':
363	3	l = (intmax_t)((t_end - t_start) * 1e3);
364	3	break;
365		case 'u':
366	6	l = (intmax_t)((t_end - t_start) * 1e6);
367	6	break;
368		default:
369	0	WRONG("Time format specifier");
370	0	}
371
372		#ifdef __FreeBSD__
373	30	assert(fmtcheck(format->time_fmt, "%jd") == format->time_fmt);
374		#endif
375	30	AZ(VSB_printf(CTX.vsb, format->time_fmt, l));
376
377	30	return (1);
378	60	}
379
380		static int v_matchproto_(format_f)
381	15	format_requestline(const struct format *format)
382		{
383
384	15	(void)format;
385	15	AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_m], "-"));
386	15	AZ(VSB_putc(CTX.vsb, ' '));
387	15	if (CTX.frag[F_host].gen == CTX.gen) {
388	13	if (strncmp(CTX.frag[F_host].b, "http://", 7))
389	13	AZ(VSB_cat(CTX.vsb, "http://"));
390	13	AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_host], NULL));
391	13	} else
392	2	AZ(VSB_cat(CTX.vsb, "http://localhost"));
393	15	AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_U], ""));
394	15	AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_q], ""));
395	15	AZ(VSB_putc(CTX.vsb, ' '));
396	15	AZ(vsb_fcat(CTX.vsb, &CTX.frag[F_H], "HTTP/1.0"));
397	15	return (1);
398		}
399
400		static int v_matchproto_(format_f)
401	18	format_auth(const struct format *format)
402		{
403	18	struct vsb *vsb = VSB_new_auto();
404	18	AN(vsb);
405		char *q;
406
407	18	if (CTX.frag[F_auth].gen != CTX.gen \|\|
408	8	VENC_Decode_Base64(vsb, CTX.frag[F_auth].b, CTX.frag[F_auth].e)) {
409	10	VSB_destroy(&vsb);
410	10	if (format->string == NULL)
411	0	return (-1);
412	10	VSB_quote(CTX.vsb, format->string, -1, CTX.quote_how);
413	10	return (0);
414		}
415	8	AZ(VSB_finish(vsb));
416	8	q = strchr(VSB_data(vsb), ':');
417	8	if (q != NULL)
418	8	*q = '\0';
419	8	VSB_quote(CTX.vsb, VSB_data(vsb), -1, CTX.quote_how);
420	8	VSB_destroy(&vsb);
421	8	return (1);
422	18	}
423
424		static int
425	96	print(void)
426		{
427		const struct format *f;
428	96	int i, r = 1;
429
430	96	VSB_clear(CTX.vsb);
431	765	VTAILQ_FOREACH(f, &CTX.format, list) {
432	669	CHECK_OBJ_NOTNULL(f, FORMAT_MAGIC);
433	669	i = (f->func)(f);
434	669	AZ(VSB_error(CTX.vsb));
435	669	if (r > i)
436	26	r = i;
437	669	}
438	96	AZ(VSB_putc(CTX.vsb, '\n'));
439	96	AZ(VSB_finish(CTX.vsb));
440	96	if (r >= 0) {
441	96	i = fwrite(VSB_data(CTX.vsb), 1, VSB_len(CTX.vsb), CTX.fo);
442	96	if (i != VSB_len(CTX.vsb))
443	0	return (-5);
444	96	}
445	96	return (0);
446	96	}
447
448		static void
449	226	addf_string(const char *str)
450		{
451		struct format *f;
452
453	226	AN(str);
454	226	ALLOC_OBJ(f, FORMAT_MAGIC);
455	226	AN(f);
456	226	f->func = format_string;
457	226	f->string = strdup(str);
458	226	AN(f->string);
459	226	VTAILQ_INSERT_TAIL(&CTX.format, f, list);
460	226	}
461
462		static void
463	8	addf_strptr(const char const strptr)
464		{
465		struct format *f;
466
467	8	AN(strptr);
468	8	ALLOC_OBJ(f, FORMAT_MAGIC);
469	8	AN(f);
470	8	f->func = format_strptr;
471	8	f->strptr = strptr;
472	8	VTAILQ_INSERT_TAIL(&CTX.format, f, list);
473	8	}
474
475		static void
476	99	addf_fragment(struct fragment frag, const char str)
477		{
478		struct format *f;
479
480	99	AN(frag);
481	99	ALLOC_OBJ(f, FORMAT_MAGIC);
482	99	AN(f);
483	99	f->func = format_fragment;
484	99	f->frag = frag;
485	99	if (str != NULL) {
486	99	f->string = strdup(str);
487	99	AN(f->string);
488	99	}
489	99	VTAILQ_INSERT_TAIL(&CTX.format, f, list);
490	99	}
491
492		static void
493	5	addf_int64(int64_t *i)
494		{
495		struct format *f;
496
497	5	AN(i);
498	5	ALLOC_OBJ(f, FORMAT_MAGIC);
499	5	AN(f);