GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 * Author: Martin Blix Grydeland <martin@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.
 */

#include "config.h"

#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>

#include "vdef.h"
#include "vas.h"
#include "miniobj.h"

#include "vbm.h"
#include "vqueue.h"
#include "vre.h"
#include "vsb.h"

#include "vapi/vsl.h"

#include "vsl_api.h"

/*--------------------------------------------------------------------*/

const char                      vsl_file_id[] = {'V', 'S', 'L', '2'};

const char * const VSL_tags[SLT__MAX] = {
#  define SLTM(foo,flags,sdesc,ldesc)       [SLT_##foo] = #foo,
#  include "tbl/vsl_tags.h"
};

const unsigned VSL_tagflags[SLT__MAX] = {
#  define SLTM(foo, flags, sdesc, ldesc)        [SLT_##foo] = flags,
#  include "tbl/vsl_tags.h"
#  undef SLTM
};

int
vsl_diag(struct VSL_data *vsl, const char *fmt, ...)
{
        va_list ap;

        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
        AN(fmt);

        if (vsl->diag == NULL)
                vsl->diag = VSB_new_auto();
        AN(vsl->diag);
        VSB_clear(vsl->diag);
        va_start(ap, fmt);
        VSB_vprintf(vsl->diag, fmt, ap);
        va_end(ap);
        AZ(VSB_finish(vsl->diag));
        return (-1);
}

struct VSL_data *
VSL_New(void)
{
        struct VSL_data *vsl;

        ALLOC_OBJ(vsl, VSL_MAGIC);
        if (vsl == NULL)
                return (NULL);

        vsl->L_opt = 1000;
        vsl->T_opt = 120.;
        vsl->vbm_select = vbit_new(SLT__MAX);
        vsl->vbm_suppress = vbit_new(SLT__MAX);
        VTAILQ_INIT(&vsl->vslf_select);
        VTAILQ_INIT(&vsl->vslf_suppress);

        return (vsl);
}

static void
vsl_IX_free(vslf_list *filters)
{
        struct vslf *vslf;

        while (!VTAILQ_EMPTY(filters)) {
                vslf = VTAILQ_FIRST(filters);
                CHECK_OBJ_NOTNULL(vslf, VSLF_MAGIC);
                VTAILQ_REMOVE(filters, vslf, list);
                if (vslf->tags)
                        vbit_destroy(vslf->tags);
                AN(vslf->vre);
                VRE_free(&vslf->vre);
                AZ(vslf->vre);
                FREE_OBJ(vslf);
        }
}

void
VSL_Delete(struct VSL_data *vsl)
{

        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);

        vbit_destroy(vsl->vbm_select);
        vbit_destroy(vsl->vbm_suppress);
        vsl_IX_free(&vsl->vslf_select);
        vsl_IX_free(&vsl->vslf_suppress);
        VSL_ResetError(vsl);
        FREE_OBJ(vsl);
}

const char *
VSL_Error(const struct VSL_data *vsl)
{

        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);

        if (vsl->diag == NULL)
                return (NULL);
        else
                return (VSB_data(vsl->diag));
}

void
VSL_ResetError(struct VSL_data *vsl)
{

        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);

        if (vsl->diag == NULL)
                return;
        VSB_destroy(&vsl->diag);
}

static int
vsl_match_IX(struct VSL_data *vsl, const vslf_list *list,
    const struct VSL_cursor *c)
{
        enum VSL_tag_e tag;
        const char *cdata;
        int len;
        const struct vslf *vslf;

        (void)vsl;
        tag = VSL_TAG(c->rec.ptr);
        cdata = VSL_CDATA(c->rec.ptr);
        len = VSL_LEN(c->rec.ptr);

        VTAILQ_FOREACH(vslf, list, list) {
                CHECK_OBJ_NOTNULL(vslf, VSLF_MAGIC);
                if (vslf->tags != NULL && !vbit_test(vslf->tags, tag))
                        continue;
                if (VRE_match(vslf->vre, cdata, len, 0, NULL) >= 0)
                        return (1);
        }
        return (0);
}

int
VSL_Match(struct VSL_data *vsl, const struct VSL_cursor *c)
{
        enum VSL_tag_e tag;

        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
        if (c == NULL || c->rec.ptr == NULL)
                return (0);
        tag = VSL_TAG(c->rec.ptr);
        if (tag <= SLT__Bogus || tag >= SLT__Reserved)
                return (0);
        if (!vsl->c_opt || !vsl->b_opt) {
                if (vsl->c_opt && !VSL_CLIENT(c->rec.ptr))
                        return (0);
                if (vsl->b_opt && !VSL_BACKEND(c->rec.ptr))
                        return (0);
        }
        if (!VTAILQ_EMPTY(&vsl->vslf_select) &&
            vsl_match_IX(vsl, &vsl->vslf_select, c))
                return (1);
        else if (vbit_test(vsl->vbm_select, tag))
                return (1);
        else if (!VTAILQ_EMPTY(&vsl->vslf_suppress) &&
            vsl_match_IX(vsl, &vsl->vslf_suppress, c))
                return (0);
        else if (vbit_test(vsl->vbm_suppress, tag))
                return (0);

        /* Default show */
        return (1);
}

static const char * const VSL_transactions[VSL_t__MAX] = {
        /*                 12345678901234 */
        [VSL_t_unknown] = "<< Unknown  >>",
        [VSL_t_sess]    = "<< Session  >>",
        [VSL_t_req]     = "<< Request  >>",
        [VSL_t_bereq]   = "<< BeReq    >>",
        [VSL_t_raw]     = "<< Record   >>",
};

#define VSL_PRINT(...)                                  \
        do {                                            \
                if (0 > fprintf(__VA_ARGS__))           \
                        return (-5);                    \
        } while (0)

static int
vsl_print_unsafe(FILE *fo, unsigned len, const char *data)
{

        VSL_PRINT(fo, "\"");
        while (len-- > 0) {
                if (*data >= ' ' && *data <= '~')
                        VSL_PRINT(fo, "%c", *data);
                else
                        VSL_PRINT(fo, "%%%02x", (unsigned char)*data);
                data++;
        }
        VSL_PRINT(fo, "\"\n");
        return (0);
}


static int
vsl_print_binary(FILE *fo, unsigned len, const char *data)
{

        VSL_PRINT(fo, "[");
        while (len-- > 0) {
                VSL_PRINT(fo, "%02x", (unsigned char)*data);
                data++;
        }
        VSL_PRINT(fo, "]\n");
        return (0);
}

static int
vsl_print(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo,
    int terse)
{
        enum VSL_tag_e tag;
        uint64_t vxid;
        unsigned len;
        const char *data;
        int type;

        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
        if (c == NULL || c->rec.ptr == NULL)
                return (0);
        if (fo == NULL)
                fo = stdout;
        tag = VSL_TAG(c->rec.ptr);
        vxid = VSL_ID(c->rec.ptr);
        len = VSL_LEN(c->rec.ptr);
        type = VSL_CLIENT(c->rec.ptr) ? 'c' : VSL_BACKEND(c->rec.ptr) ?
            'b' : '-';
        data = VSL_CDATA(c->rec.ptr);

        if (!terse)
                VSL_PRINT(fo, "%10ju ", (uintmax_t)vxid);
        VSL_PRINT(fo, "%-14s ", VSL_tags[tag]);
        if (!terse)
                VSL_PRINT(fo, "%c ", type);

        if (VSL_tagflags[tag] & SLT_F_UNSAFE)
                (void)vsl_print_unsafe(fo, len, data);
        else if (VSL_tagflags[tag] & SLT_F_BINARY)
                (void)vsl_print_binary(fo, len, data);
        else
                VSL_PRINT(fo, "%.*s\n", (int)len, data);

        return (0);
}

int
VSL_Print(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
{

        return (vsl_print(vsl, c, fo, 0));
}

int
VSL_PrintTerse(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
{

        return (vsl_print(vsl, c, fo, 1));
}

int
VSL_PrintAll(struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
{
        int i;

        if (c == NULL)
                return (0);
        while (1) {
                i = VSL_Next(c);
                if (i <= 0)
                        return (i);
                if (!VSL_Match(vsl, c))
                        continue;
                i = VSL_Print(vsl, c, fo);
                if (i != 0)
                        return (i);
        }
}

int v_matchproto_(VSLQ_dispatch_f)
VSL_PrintTransactions(struct VSL_data *vsl, struct VSL_transaction * const pt[],
    void *fo)
{
        struct VSL_transaction *t;
        int i;
        int delim = 0;
        int verbose;

        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
        if (fo == NULL)
                fo = stdout;
        if (pt[0] == NULL)
                return (0);

        for (t = pt[0]; t != NULL; t = *++pt) {
                if (vsl->c_opt || vsl->b_opt) {
                        switch (t->type) {
                        case VSL_t_req:
                                if (!vsl->c_opt)
                                        continue;
                                if (t->reason == VSL_r_esi && !vsl->E_opt)
                                        continue;
                                break;
                        case VSL_t_bereq:
                                if (!vsl->b_opt)
                                        continue;
                                break;
                        case VSL_t_raw:
                                break;
                        default:
                                continue;
                        }
                }

                verbose = 0;
                if (t->level == 0 || vsl->v_opt)
                        verbose = 1;

                if (t->level) {
                        /* Print header */
                        if (t->level > 3)
                                VSL_PRINT(fo, "*%1.1d* ", t->level);
                        else
                                VSL_PRINT(fo, "%-3.*s ",
                                    (int)(t->level), "***");
                        VSL_PRINT(fo, "%*.s%-14s %*.s%-10ju\n",
                            verbose ? 10 + 1 : 0, " ",
                            VSL_transactions[t->type],
                            verbose ? 1 + 1 : 0, " ",
                            (uintmax_t)t->vxid);
                        delim = 1;
                }

                while (1) {
                        /* Print records */
                        i = VSL_Next(t->c);
                        if (i < 0)
                                return (i);
                        if (i == 0)
                                break;
                        if (!VSL_Match(vsl, t->c))
                                continue;
                        if (t->level > 3)
                                VSL_PRINT(fo, "-%1.1d- ", t->level);
                        else if (t->level)
                                VSL_PRINT(fo, "%-3.*s ",
                                    (int)(t->level), "---");
                        if (verbose)
                                i = VSL_Print(vsl, t->c, fo);
                        else
                                i = VSL_PrintTerse(vsl, t->c, fo);
                        if (i != 0)
                                return (i);
                }
        }

        if (delim)
                VSL_PRINT(fo, "\n");;

        return (0);
}

FILE*
VSL_WriteOpen(struct VSL_data *vsl, const char *name, int append, int unbuf)
{
        FILE* f;

        if (!strcmp(name, "-"))
                f = stdout;
        else
                f = fopen(name, append ? "a" : "w");
        if (f == NULL) {
                vsl_diag(vsl, "%s", strerror(errno));
                return (NULL);
        }
        if (unbuf)
                setbuf(f, NULL);
        if (ftell(f) == 0 || f == stdout) {
                if (fwrite(VSL_FILE_ID, 1, sizeof VSL_FILE_ID, f) !=
                    sizeof VSL_FILE_ID) {
                        vsl_diag(vsl, "%s", strerror(errno));
                        (void)fclose(f);
                        return (NULL);
                }
        }
        return (f);
}

int
VSL_Write(const struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
{
        size_t r;

        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
        if (c == NULL || c->rec.ptr == NULL)
                return (0);
        if (fo == NULL)
                fo = stdout;
        r = fwrite(c->rec.ptr, sizeof *c->rec.ptr,
            VSL_NEXT(c->rec.ptr) - c->rec.ptr, fo);
        if (r == 0)
                return (-5);
        return (0);
}

int
VSL_WriteAll(struct VSL_data *vsl, const struct VSL_cursor *c, void *fo)
{
        int i;

        if (c == NULL)
                return (0);
        while (1) {
                i = VSL_Next(c);
                if (i <= 0)
                        return (i);
                if (!VSL_Match(vsl, c))
                        continue;
                i = VSL_Write(vsl, c, fo);
                if (i != 0)
                        return (i);
        }
}

int v_matchproto_(VSLQ_dispatch_f)
VSL_WriteTransactions(struct VSL_data *vsl, struct VSL_transaction * const pt[],
    void *fo)
{
        struct VSL_transaction *t;
        int i;

        if (pt == NULL)
                return (0);
        for (i = 0, t = pt[0]; i == 0 && t != NULL; t = *++pt)
                i = VSL_WriteAll(vsl, t->c, fo);
        return (i);
}

		varnish-cache/lib/libvarnishapi/vsl.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2015 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		* Author: Martin Blix Grydeland <martin@varnish-software.com>
7		*
8		* SPDX-License-Identifier: BSD-2-Clause
9		*
10		* Redistribution and use in source and binary forms, with or without
11		* modification, are permitted provided that the following conditions
12		* are met:
13		* 1. Redistributions of source code must retain the above copyright
14		* notice, this list of conditions and the following disclaimer.
15		* 2. Redistributions in binary form must reproduce the above copyright
16		* notice, this list of conditions and the following disclaimer in the
17		* documentation and/or other materials provided with the distribution.
18		*
19		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
23		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29		* SUCH DAMAGE.
30		*/
31
32		#include "config.h"
33
34		#include <stdarg.h>
35		#include <stdint.h>
36		#include <stdio.h>
37
38		#include "vdef.h"
39		#include "vas.h"
40		#include "miniobj.h"
41
42		#include "vbm.h"
43		#include "vqueue.h"
44		#include "vre.h"
45		#include "vsb.h"
46
47		#include "vapi/vsl.h"
48
49		#include "vsl_api.h"
50
51		/--------------------------------------------------------------------/
52
53		const char vsl_file_id[] = {'V', 'S', 'L', '2'};
54
55		const char * const VSL_tags[SLT__MAX] = {
56		# define SLTM(foo,flags,sdesc,ldesc) [SLT_##foo] = #foo,
57		# include "tbl/vsl_tags.h"
58		};
59
60		const unsigned VSL_tagflags[SLT__MAX] = {
61		# define SLTM(foo, flags, sdesc, ldesc) [SLT_##foo] = flags,
62		# include "tbl/vsl_tags.h"
63		# undef SLTM
64		};
65
66		int
67	191022	vsl_diag(struct VSL_data vsl, const char fmt, ...)
68		{
69		va_list ap;
70
71	191022	CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
72	191022	AN(fmt);
73
74	191022	if (vsl->diag == NULL)
75	191022	vsl->diag = VSB_new_auto();
76	191022	AN(vsl->diag);
77	191022	VSB_clear(vsl->diag);
78	191022	va_start(ap, fmt);
79	191022	VSB_vprintf(vsl->diag, fmt, ap);
80	191022	va_end(ap);
81	191022	AZ(VSB_finish(vsl->diag));
82	191022	return (-1);
83		}
84
85		struct VSL_data *
86	56560	VSL_New(void)
87		{
88		struct VSL_data *vsl;
89
90	56560	ALLOC_OBJ(vsl, VSL_MAGIC);
91	56560	if (vsl == NULL)
92	0	return (NULL);
93
94	56560	vsl->L_opt = 1000;
95	56560	vsl->T_opt = 120.;
96	56560	vsl->vbm_select = vbit_new(SLT__MAX);
97	56560	vsl->vbm_suppress = vbit_new(SLT__MAX);
98	56560	VTAILQ_INIT(&vsl->vslf_select);
99	56560	VTAILQ_INIT(&vsl->vslf_suppress);
100
101	56560	return (vsl);
102	56560	}
103
104		static void
105	101680	vsl_IX_free(vslf_list *filters)
106		{
107		struct vslf *vslf;
108
109	101840	while (!VTAILQ_EMPTY(filters)) {
110	160	vslf = VTAILQ_FIRST(filters);
111	160	CHECK_OBJ_NOTNULL(vslf, VSLF_MAGIC);
112	160	VTAILQ_REMOVE(filters, vslf, list);
113	160	if (vslf->tags)
114	0	vbit_destroy(vslf->tags);
115	160	AN(vslf->vre);
116	160	VRE_free(&vslf->vre);
117	160	AZ(vslf->vre);
118	160	FREE_OBJ(vslf);
119		}
120	101680	}
121
122		void
123	50840	VSL_Delete(struct VSL_data *vsl)
124		{
125
126	50840	CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
127
128	50840	vbit_destroy(vsl->vbm_select);
129	50840	vbit_destroy(vsl->vbm_suppress);
130	50840	vsl_IX_free(&vsl->vslf_select);
131	50840	vsl_IX_free(&vsl->vslf_suppress);
132	50840	VSL_ResetError(vsl);
133	50840	FREE_OBJ(vsl);
134	50840	}
135
136		const char *
137	191022	VSL_Error(const struct VSL_data *vsl)
138		{
139
140	191022	CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
141
142	191022	if (vsl->diag == NULL)
143	0	return (NULL);
144		else
145	191022	return (VSB_data(vsl->diag));
146	191022	}
147
148		void
149	239742	VSL_ResetError(struct VSL_data *vsl)
150		{
151
152	239742	CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
153
154	239742	if (vsl->diag == NULL)
155	50840	return;
156	188902	VSB_destroy(&vsl->diag);
157	239742	}
158
159		static int
160	2080	vsl_match_IX(struct VSL_data vsl, const vslf_list list,
161		const struct VSL_cursor *c)
162		{
163		enum VSL_tag_e tag;
164		const char *cdata;
165		int len;
166		const struct vslf *vslf;
167
168	2080	(void)vsl;
169	2080	tag = VSL_TAG(c->rec.ptr);
170	2080	cdata = VSL_CDATA(c->rec.ptr);
171	2080	len = VSL_LEN(c->rec.ptr);
172
173	3600	VTAILQ_FOREACH(vslf, list, list) {
174	2080	CHECK_OBJ_NOTNULL(vslf, VSLF_MAGIC);
175	2080	if (vslf->tags != NULL && !vbit_test(vslf->tags, tag))
176	0	continue;
177	2080	if (VRE_match(vslf->vre, cdata, len, 0, NULL) >= 0)
178	560	return (1);
179	1520	}
180	1520	return (0);
181	2080	}
182
183		int
184	1305550	VSL_Match(struct VSL_data vsl, const struct VSL_cursor c)
185		{
186		enum VSL_tag_e tag;
187
188	1305550	CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
189	1305550	if (c == NULL \|\| c->rec.ptr == NULL)
190	72	return (0);
191	1305550	tag = VSL_TAG(c->rec.ptr);
192	1305550	if (tag <= SLT__Bogus \|\| tag >= SLT__Reserved)
193	42	return (0);
194	1305544	if (!vsl->c_opt \|\| !vsl->b_opt) {
195	1304181	if (vsl->c_opt && !VSL_CLIENT(c->rec.ptr))
196	3920	return (0);
197	1300261	if (vsl->b_opt && !VSL_BACKEND(c->rec.ptr))
198	0	return (0);
199	1300261	}
200	1301624	if (!VTAILQ_EMPTY(&vsl->vslf_select) &&
201	240	vsl_match_IX(vsl, &vsl->vslf_select, c))
202	80	return (1);
203	1301544	else if (vbit_test(vsl->vbm_select, tag))
204	0	return (1);
205	1301544	else if (!VTAILQ_EMPTY(&vsl->vslf_suppress) &&
206	1840	vsl_match_IX(vsl, &vsl->vslf_suppress, c))
207	480	return (0);
208	1301064	else if (vbit_test(vsl->vbm_suppress, tag))
209	65400	return (0);
210
211		/* Default show */
212	1235664	return (1);
213	1305544	}
214
215		static const char * const VSL_transactions[VSL_t__MAX] = {
216		/* 12345678901234 */
217		[VSL_t_unknown] = "<< Unknown >>",
218		[VSL_t_sess] = "<< Session >>",
219		[VSL_t_req] = "<< Request >>",
220		[VSL_t_bereq] = "<< BeReq >>",
221		[VSL_t_raw] = "<< Record >>",
222		};
223
224		#define VSL_PRINT(...) \
225		do { \
226		if (0 > fprintf(__VA_ARGS__)) \
227		return (-5); \
228		} while (0)
229
230		static int
231	3231	vsl_print_unsafe(FILE fo, unsigned len, const char data)
232		{
233
234	3231	VSL_PRINT(fo, "\"");
235	198458	while (len-- > 0) {
236	195227	if (data >= ' ' && data <= '~')
237	191996	VSL_PRINT(fo, "%c", *data);
238		else
239	3231	VSL_PRINT(fo, "%%%02x", (unsigned char)*data);
240	195227	data++;
241		}
242	3231	VSL_PRINT(fo, "\"\n");
243	3231	return (0);
244	3231	}
245
246
247		static int
248	922	vsl_print_binary(FILE fo, unsigned len, const char data)
249		{
250
251	922	VSL_PRINT(fo, "[");
252	20955	while (len-- > 0) {
253	20033	VSL_PRINT(fo, "%02x", (unsigned char)*data);
254	20033	data++;
255		}
256	922	VSL_PRINT(fo, "]\n");
257	922	return (0);
258	922	}
259
260		static int
261	22771	vsl_print(const struct VSL_data vsl, const struct VSL_cursor c, void *fo,
262		int terse)
263		{
264		enum VSL_tag_e tag;
265		uint64_t vxid;
266		unsigned len;
267		const char *data;
268		int type;
269
270	22771	CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
271	22771	if (c == NULL \|\| c->rec.ptr == NULL)
272	0	return (0);
273	22771	if (fo == NULL)
274	0	fo = stdout;
275	22771	tag = VSL_TAG(c->rec.ptr);
276	22771	vxid = VSL_ID(c->rec.ptr);
277	22771	len = VSL_LEN(c->rec.ptr);
278	22771	type = VSL_CLIENT(c->rec.ptr) ? 'c' : VSL_BACKEND(c->rec.ptr) ?
279		'b' : '-';
280	22771	data = VSL_CDATA(c->rec.ptr);
281
282	22771	if (!terse)
283	18251	VSL_PRINT(fo, "%10ju ", (uintmax_t)vxid);
284	22771	VSL_PRINT(fo, "%-14s ", VSL_tags[tag]);
285	22771	if (!terse)
286	18251	VSL_PRINT(fo, "%c ", type);
287
288	22771	if (VSL_tagflags[tag] & SLT_F_UNSAFE)
289	3231	(void)vsl_print_unsafe(fo, len, data);
290	19540	else if (VSL_tagflags[tag] & SLT_F_BINARY)
291	922	(void)vsl_print_binary(fo, len, data);
292		else
293	18618	VSL_PRINT(fo, "%.*s\n", (int)len, data);
294
295	22771	return (0);
296	22771	}
297
298		int
299	18251	VSL_Print(const struct VSL_data vsl, const struct VSL_cursor c, void *fo)
300		{
301
302	18251	return (vsl_print(vsl, c, fo, 0));
303		}
304
305		int
306	4520	VSL_PrintTerse(const struct VSL_data vsl, const struct VSL_cursor c, void *fo)
307		{
308
309	4520	return (vsl_print(vsl, c, fo, 1));
310		}
311
312		int
313	0	VSL_PrintAll(struct VSL_data vsl, const struct VSL_cursor c, void *fo)
314		{
315		int i;
316
317	0	if (c == NULL)
318	0	return (0);
319	0	while (1) {
320	0	i = VSL_Next(c);
321	0	if (i <= 0)
322	0	return (i);
323	0	if (!VSL_Match(vsl, c))
324	0	continue;
325	0	i = VSL_Print(vsl, c, fo);
326	0	if (i != 0)
327	0	return (i);
328		}
329	0	}
330
331		int v_matchproto_(VSLQ_dispatch_f)
332	33211	VSL_PrintTransactions(struct VSL_data vsl, struct VSL_transaction const pt[],
333		void *fo)
334		{
335		struct VSL_transaction *t;
336		int i;
337	33211	int delim = 0;
338		int verbose;
339
340	33211	CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
341	33211	if (fo == NULL)
342	27308	fo = stdout;
343	33211	if (pt[0] == NULL)
344	0	return (0);
345
346	66662	for (t = pt[0]; t != NULL; t = *++pt) {
347	33451	if (vsl->c_opt \|\| vsl->b_opt) {
348	14760	switch (t->type) {
349		case VSL_t_req:
350	800	if (!vsl->c_opt)
351	0	continue;
352	800	if (t->reason == VSL_r_esi && !vsl->E_opt)
353	160	continue;
354	640	break;
355		case VSL_t_bereq:
356	160	if (!vsl->b_opt)
357	80	continue;
358	80	break;
359		case VSL_t_raw:
360	13680	break;
361		default:
362	120	continue;
363		}
364	14400	}
365
366	33091	verbose = 0;
367	33091	if (t->level == 0 \|\| vsl->v_opt)
368	32131	verbose = 1;
369
370	33091	if (t->level) {
371		/* Print header */
372	1000	if (t->level > 3)
373	0	VSL_PRINT(fo, "%1.1d ", t->level);
374		else
375	1000	VSL_PRINT(fo, "%-3.*s ",
376		(int)(t->level), "***");
377	1000	VSL_PRINT(fo, "%.s%-14s %.s%-10ju\n",
378		verbose ? 10 + 1 : 0, " ",
379		VSL_transactions[t->type],
380		verbose ? 1 + 1 : 0, " ",
381		(uintmax_t)t->vxid);
382	1000	delim = 1;
383	1000	}
384
385	55862	while (1) {
386		/* Print records */
387	94822	i = VSL_Next(t->c);
388	94822	if (i < 0)
389	0	return (i);
390	94822	if (i == 0)
391	33091	break;
392	61731	if (!VSL_Match(vsl, t->c))
393	38960	continue;
394	22771	if (t->level > 3)
395	0	VSL_PRINT(fo, "-%1.1d- ", t->level);
396	22771	else if (t->level)
397	4560	VSL_PRINT(fo, "%-3.*s ",
398		(int)(t->level), "---");
399	22771	if (verbose)
400	18251	i = VSL_Print(vsl, t->c, fo);
401		else
402	4520	i = VSL_PrintTerse(vsl, t->c, fo);
403	22771	if (i != 0)
404	0	return (i);
405		}
406	33091	}
407
408	33211	if (delim)
409	1000	VSL_PRINT(fo, "\n");;
410
411	33211	return (0);
412	33211	}
413
414		FILE*
415	160	VSL_WriteOpen(struct VSL_data vsl, const char name, int append, int unbuf)
416		{
417		FILE* f;
418
419	160	if (!strcmp(name, "-"))
420	40	f = stdout;
421		else
422	120	f = fopen(name, append ? "a" : "w");
423	160	if (f == NULL) {
424	40	vsl_diag(vsl, "%s", strerror(errno));
425	40	return (NULL);
426		}
427	120	if (unbuf)
428	0	setbuf(f, NULL);
429	120	if (ftell(f) == 0 \|\| f == stdout) {
430	120	if (fwrite(VSL_FILE_ID, 1, sizeof VSL_FILE_ID, f) !=
431		sizeof VSL_FILE_ID) {
432	0	vsl_diag(vsl, "%s", strerror(errno));
433	0	(void)fclose(f);
434	0	return (NULL);
435		}
436	120	}
437	120	return (f);
438	160	}
439
440		int
441	4280	VSL_Write(const struct VSL_data vsl, const struct VSL_cursor c, void *fo)
442		{
443		size_t r;
444
445	4280	CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
446	4280	if (c == NULL \|\| c->rec.ptr == NULL)
447	0	return (0);
448	4280	if (fo == NULL)
449	0	fo = stdout;
450	8560	r = fwrite(c->rec.ptr, sizeof *c->rec.ptr,
451	4280	VSL_NEXT(c->rec.ptr) - c->rec.ptr, fo);
452	4280	if (r == 0)
453	0	return (-5);
454	4280	return (0);
455	4280	}
456
457		int
458	360	VSL_WriteAll(struct VSL_data vsl, const struct VSL_cursor c, void *fo)
459		{
460		int i;
461
462	360	if (c == NULL)
463	0	return (0);
464	4640	while (1) {
465	10960	i = VSL_Next(c);
466	10960	if (i <= 0)
467	360	return (i);
468	10600	if (!VSL_Match(vsl, c))
469	6320	continue;
470	4280	i = VSL_Write(vsl, c, fo);
471	4280	if (i != 0)
472	0	return (i);
473		}
474	360	}
475
476		int v_matchproto_(VSLQ_dispatch_f)
477	360	VSL_WriteTransactions(struct VSL_data vsl, struct VSL_transaction const pt[],
478		void *fo)
479		{
480		struct VSL_transaction *t;
481		int i;
482
483	360	if (pt == NULL)
484	0	return (0);
485	720	for (i = 0, t = pt[0]; i == 0 && t != NULL; t = *++pt)
486	360	i = VSL_WriteAll(vsl, t->c, fo);
487	360	return (i);
488	360	}