GCOV - Varnish Cache


/*-
 * Copyright (c) 2012-2017 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@FreeBSD.org>
 * Author: Dridi Boukelmoune <dridi.boukelmoune@gmail.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 <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "cache/cache.h"

#include "vsb.h"
#include "vtcp.h"
#include "vtim.h"

#include "vcc_vtc_if.h"

VCL_VOID v_matchproto_(td_vtc_barrier_sync)
vmod_barrier_sync(VRT_CTX, VCL_STRING addr, VCL_DURATION tmo)
{
        const char *err;
        char buf[32];
        int sock, i;
        ssize_t sz;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(addr);
        AN(*addr);
        assert(tmo >= 0.0);

        if (ctx->vsl != NULL)
                VSLb(ctx->vsl, SLT_Debug, "barrier_sync(\"%s\")", addr);
        else
                VSL(SLT_Debug, NO_VXID, "barrier_sync(\"%s\")", addr);

        sock = VTCP_open(addr, NULL, 0., &err);
        if (sock < 0) {
                VRT_fail(ctx, "Barrier connection failed: %s", err);
                return;
        }

        sz = VTCP_read(sock, buf, sizeof buf, tmo);
        i = errno;
        closefd(&sock);
        if (sz < 0)
                VRT_fail(ctx, "Barrier read failed: %s (errno=%d)",
                    strerror(i), i);
        if (sz > 0)
                VRT_fail(ctx, "Barrier unexpected data (%zdB)", sz);
}

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

VCL_BACKEND v_matchproto_(td_vtc_no_backend)
vmod_no_backend(VRT_CTX)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        return (NULL);
}

VCL_STEVEDORE v_matchproto_(td_vtc_no_stevedore)
vmod_no_stevedore(VRT_CTX)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        return (NULL);
}

VCL_IP v_matchproto_(td_vtc_no_ip)
vmod_no_ip(VRT_CTX)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        return (NULL);
}

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

VCL_VOID v_noreturn_ v_matchproto_(td_vtc_panic)
vmod_panic(VRT_CTX, VCL_STRANDS str)
{
        const char *b;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        b = VRT_StrandsWS(ctx->ws, "PANIC:", str);
        VAS_Fail("VCL", "", 0, b, VAS_VCL);
}

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

VCL_VOID v_matchproto_(td_vtc_sleep)
vmod_sleep(VRT_CTX, VCL_DURATION t)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        VTIM_sleep(t);
}

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

// XXX this really should be PRIV_TASK state
static uintptr_t vtc_ws_snapshot;

static struct ws *
vtc_ws_find(VRT_CTX, VCL_ENUM which)
{

        if (which == VENUM(client))
                return (ctx->ws);
        if (which == VENUM(backend))
                return (ctx->bo->ws);
        if (which == VENUM(session))
                return (ctx->req->sp->ws);
        if (which == VENUM(thread) && ctx->req != NULL)
                return (ctx->req->wrk->aws);
        if (which == VENUM(thread) && ctx->bo != NULL)
                return (ctx->bo->wrk->aws);
        WRONG("vtc_ws_find Illegal enum");
}

VCL_VOID v_matchproto_(td_vtc_workspace_alloc)
vmod_workspace_alloc(VRT_CTX, VCL_ENUM which, VCL_INT size)
{
        struct ws *ws;
        void *p;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        ws = vtc_ws_find(ctx, which);
        if (ws == NULL)
                return;
        WS_Assert(ws);

        if (size < 0) {
                size += WS_ReserveAll(ws);
                WS_Release(ws, 0);
        }
        if (size <= 0) {
                VRT_fail(ctx, "Attempted negative WS allocation");
                return;
        }
        p = WS_Alloc(ws, size);
        if (p == NULL)
                VRT_fail(ctx, "vtc.workspace_alloc");
        else
                memset(p, '\0', size);
}

VCL_BYTES v_matchproto_(td_vtc_workspace_reserve)
vmod_workspace_reserve(VRT_CTX, VCL_ENUM which, VCL_INT size)
{
        struct ws *ws;
        unsigned r;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        ws = vtc_ws_find(ctx, which);
        if (ws == NULL)
                return (0);
        WS_Assert(ws);

        if (size < 0) {
                size += WS_ReserveAll(ws);
                WS_Release(ws, 0);
        }
        if (size <= 0) {
                VRT_fail(ctx, "Attempted negative WS reservation");
                return (0);
        }
        r = WS_ReserveSize(ws, size);
        if (r == 0)
                return (0);
        memset(WS_Reservation(ws), 0, r);
        WS_Release(ws, 0);
        return (r);
}

VCL_INT v_matchproto_(td_vtc_workspace_free)
vmod_workspace_free(VRT_CTX, VCL_ENUM which)
{
        struct ws *ws;
        unsigned u;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        ws = vtc_ws_find(ctx, which);
        if (ws == NULL)
                return (-1);
        WS_Assert(ws);

        u = WS_ReserveAll(ws);
        WS_Release(ws, 0);
        return (u);
}

#define VTC_WS_OP(type, def, name, op)                  \
VCL_##type v_matchproto_(td_vtc_workspace_##name)       \
vmod_workspace_##name(VRT_CTX, VCL_ENUM which)          \
{                                                       \
        struct ws *ws;                                  \
                                                        \
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);          \
                                                        \
        ws = vtc_ws_find(ctx, which);                   \
        if (ws == NULL)                                 \
                return def ;                            \
        WS_Assert(ws);                                  \
                                                        \
        op;                                             \
}
VTC_WS_OP(VOID, , snapshot, (vtc_ws_snapshot = WS_Snapshot(ws)))
VTC_WS_OP(VOID, , reset, WS_Reset(ws, vtc_ws_snapshot))
VTC_WS_OP(VOID, , overflow, WS_MarkOverflow(ws))
VTC_WS_OP(BOOL, (0), overflowed, return (WS_Overflowed(ws)))
#undef VTC_WS_OP

VCL_BLOB v_matchproto_(td_vtc_workspace_dump)
vmod_workspace_dump(VRT_CTX, VCL_ENUM which, VCL_ENUM where,
    VCL_BYTES off, VCL_BYTES len)
{
        struct ws *ws;
        unsigned l;
        const unsigned maxlen = 1024;
        unsigned char buf[maxlen];
        const char *p, *err;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(where);

        ws = vtc_ws_find(ctx, which);
        if (ws == NULL)
                return (NULL);
        WS_Assert(ws);

        if (len > maxlen) {
                VRT_fail(ctx, "workspace_dump: max length is %jd",
                    (intmax_t)maxlen);
                return (NULL);
        }

        l = WS_Dump(ws, *where, off, buf, len);
        assert(l <= maxlen);

        if (l == 0) {
                switch (errno) {
                case EINVAL: WRONG(where); break;
                case EAGAIN: err = "NULL"; break;
                case EFAULT: err = "off limit"; break;
                default: err = "unknown error"; break;
                }
                VRT_fail(ctx, "workspace_dump: %s", err);
                return (NULL);
        }

        p = WS_Copy(ctx->ws, buf, (int)l);
        if (p == NULL) {
                VRT_fail(ctx, "workspace_dump: copy failed");
                return (NULL);
        }
        return (VRT_blob(ctx, "workspace_dump", p, l, 0xd000d000));
}

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

VCL_INT v_matchproto_(td_vtc_typesize)
vmod_typesize(VRT_CTX, VCL_STRING s)
{
        size_t i = 0, l, a, p = 0;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(s);
        AN(*s);

        for (; *s; s++) {
                switch (*s) {
#define VTC_TYPESIZE(c, t) case c: l = sizeof(t); break;
                VTC_TYPESIZE('c', char)
                VTC_TYPESIZE('d', double)
                VTC_TYPESIZE('f', float)
                VTC_TYPESIZE('i', int)
                VTC_TYPESIZE('j', intmax_t)
                VTC_TYPESIZE('l', long)
                VTC_TYPESIZE('o', off_t)
                VTC_TYPESIZE('p', void *)
                VTC_TYPESIZE('s', short)
                VTC_TYPESIZE('u', unsigned)
                VTC_TYPESIZE('z', size_t)
#undef VTC_TYPESIZE
                default:        return (-1);
                }
                if (l > p)
                        p = l;
                a = i % l;
                if (a != 0)
                        i += (l - a); /* align */
                i += l;
        }
        AN(p);
        a = i % p;
        if (a != 0)
                i += (p - a); /* pad */
        return ((VCL_INT)i);
}

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

#define BLOB_VMOD_PROXY_HEADER_TYPE     0xc8f34f78

VCL_BLOB v_matchproto_(td_vtc_proxy_header)
vmod_proxy_header(VRT_CTX, VCL_ENUM venum, VCL_IP client, VCL_IP server,
    VCL_STRING authority)
{
        struct vsb *vsb;
        const void *h;
        int version;
        size_t l;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        if (venum == VENUM(v1))
                version = 1;
        else if (venum == VENUM(v2))
                version = 2;
        else
                WRONG(venum);

        vsb = VSB_new_auto();
        AN(vsb);
        VRT_Format_Proxy(vsb, version, client, server, authority);
        l = VSB_len(vsb);
        h = WS_Copy(ctx->ws, VSB_data(vsb), l);
        VSB_destroy(&vsb);

        if (h == NULL) {
                VRT_fail(ctx, "proxy_header: out of workspace");
                return (NULL);
        }

        return (VRT_blob(ctx, "proxy_header", h, l,
            BLOB_VMOD_PROXY_HEADER_TYPE));
}

// ref vsl.c
struct vsl_tag2enum {
        const char      *string;
        enum VSL_tag_e  tag;
};

static struct vsl_tag2enum vsl_tag2enum[SLT__MAX] = {
#define SLTM(name,flags,sdesc,ldesc) [SLT_ ## name] = { \
                .string = #name,                                \
                .tag = SLT_ ## name                             \
        },
#include "tbl/vsl_tags.h"
};

static int
vsl_tagcmp(const void *aa, const void *bb)
{
        const struct vsl_tag2enum *a = aa, *b = bb;

        // ref vsl2rst.c ptag_cmp
        if (a->string == NULL && b->string != NULL)
                return (1);
        else if (a->string != NULL && b->string == NULL)
                return (-1);
        else if (a->string == NULL && b->string == NULL)
                return (0);
        return (strcmp(a->string, b->string));
}

/*lint -esym(528, init_vsl_tag2enum) */
static void __attribute__((constructor))
init_vsl_tag2enum(void)
{
        qsort(vsl_tag2enum, SLT__MAX, sizeof *vsl_tag2enum, vsl_tagcmp);
}


VCL_VOID
vmod_vsl(VRT_CTX, VCL_INT id, VCL_STRING tag_s, VCL_ENUM side, VCL_STRANDS s)
{
        struct vsl_tag2enum *te, key;
        vxid_t vxid;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        key.string = tag_s;
        te = bsearch(&key, vsl_tag2enum, SLT__MAX,
            sizeof *vsl_tag2enum, vsl_tagcmp);

        if (te == NULL) {
                VRT_fail(ctx, "No such tag: %s", tag_s);
                return;
        }

        if (id < 0 || id > VRT_INTEGER_MAX) {
                VRT_fail(ctx, "id out of bounds");
                return;
        }

        vxid.vxid = id & VSL_IDENTMASK;
        if (side == VENUM(c))
                vxid.vxid |= VSL_CLIENTMARKER;
        else if (side == VENUM(b))
                vxid.vxid |= VSL_BACKENDMARKER;
        else
                WRONG("side");

        VSLs(te->tag, vxid, s);
}

static void
vsl_line(VRT_CTX, char *str)
{
        VCL_INT id;
        VCL_ENUM side;
        VCL_STRANDS s;
        const char *tag, *delim = " \t\r\n";
        char *e, *save;

        if (*str == '*') {
                // varnishtest
                str = strstr(str, "vsl|");
                if (str == NULL)
                        return;
                str += 4;
        }
        if ((str = strtok_r(str, delim, &save)) == NULL)
                return;
        id = strtoll(str, &e, 10);
        if (e == str)
                return;

        if ((str = strtok_r(NULL, delim, &save)) == NULL)
                return;
        tag = str;

        if ((str = strtok_r(NULL, delim, &save)) == NULL)
                return;
        if (*str == 'c')
                side = VENUM(c);
        else if (*str == 'b')
                side = VENUM(b);
        else
                return;

        str = strtok_r(NULL, "\r\n", &save);
        // needs to be assigned here because of the compound literal lifetime
        s = TOSTRAND(str);
        if (str == NULL)
                s = vrt_null_strands;

        vmod_vsl(ctx, id, tag, side, s);
}

VCL_VOID
vmod_vsl_replay(VRT_CTX, VCL_STRANDS s)
{
        struct vsb cp[1];
        const char *p, *pp;
        size_t l;
        int i, err = 0;

        CHECK_OBJ_ORNULL(s, STRANDS_MAGIC);
        if (s == NULL || s->n == 0)
                return;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
        WS_VSB_new(cp, ctx->ws);

        for (i = 0; i < s->n; i++) {
                p = s->p[i];
                if (p == NULL || *p == '\0')
                        continue;
                pp = strpbrk(p, "\r\n");
                while (pp != NULL) {
                        l = pp - p;
                        if (VSB_bcat(cp, p, l) || VSB_finish(cp)) {
                                err = 1;
                                break;
                        }
                        vsl_line(ctx, VSB_data(cp));
                        VSB_clear(cp);
                        p = pp + 1;
                        pp = strpbrk(p, "\r\n");
                }
                if (err || VSB_cat(cp, p)) {
                        err = 1;
                        break;
                }
        }
        if (err || VSB_finish(cp)) {
                AZ(WS_VSB_finish(cp, ctx->ws, NULL));
                VRT_fail(ctx, "out of workspace");
                return;
        }
        vsl_line(ctx, VSB_data(cp));
        VSB_clear(cp);
        AN(WS_VSB_finish(cp, ctx->ws, NULL));
}

		varnish-cache/vmod/vmod_vtc.c
0		/*-
1		* Copyright (c) 2012-2017 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Poul-Henning Kamp <phk@FreeBSD.org>
5		* Author: Dridi Boukelmoune <dridi.boukelmoune@gmail.com>
6		*
7		* SPDX-License-Identifier: BSD-2-Clause
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		* 1. Redistributions of source code must retain the above copyright
13		* notice, this list of conditions and the following disclaimer.
14		* 2. Redistributions in binary form must reproduce the above copyright
15		* notice, this list of conditions and the following disclaimer in the
16		* documentation and/or other materials provided with the distribution.
17		*
18		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28		* SUCH DAMAGE.
29		*/
30
31		#include "config.h"
32
33		#include <stdlib.h>
34		#include <stdio.h>
35		#include <string.h>
36		#include <unistd.h>
37
38		#include "cache/cache.h"
39
40		#include "vsb.h"
41		#include "vtcp.h"
42		#include "vtim.h"
43
44		#include "vcc_vtc_if.h"
45
46		VCL_VOID v_matchproto_(td_vtc_barrier_sync)
47	750	vmod_barrier_sync(VRT_CTX, VCL_STRING addr, VCL_DURATION tmo)
48		{
49		const char *err;
50		char buf[32];
51		int sock, i;
52		ssize_t sz;
53
54	750	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
55	750	AN(addr);
56	750	AN(*addr);
57	750	assert(tmo >= 0.0);
58
59	750	if (ctx->vsl != NULL)
60	750	VSLb(ctx->vsl, SLT_Debug, "barrier_sync(\"%s\")", addr);
61		else
62	0	VSL(SLT_Debug, NO_VXID, "barrier_sync(\"%s\")", addr);
63
64	750	sock = VTCP_open(addr, NULL, 0., &err);
65	750	if (sock < 0) {
66	0	VRT_fail(ctx, "Barrier connection failed: %s", err);
67	0	return;
68		}
69
70	750	sz = VTCP_read(sock, buf, sizeof buf, tmo);
71	750	i = errno;
72	750	closefd(&sock);
73	750	if (sz < 0)
74	0	VRT_fail(ctx, "Barrier read failed: %s (errno=%d)",
75	0	strerror(i), i);
76	750	if (sz > 0)
77	0	VRT_fail(ctx, "Barrier unexpected data (%zdB)", sz);
78	750	}
79
80		/--------------------------------------------------------------------/
81
82		VCL_BACKEND v_matchproto_(td_vtc_no_backend)
83	20	vmod_no_backend(VRT_CTX)
84		{
85
86	20	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
87	20	return (NULL);
88		}
89
90		VCL_STEVEDORE v_matchproto_(td_vtc_no_stevedore)
91	10	vmod_no_stevedore(VRT_CTX)
92		{
93
94	10	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
95	10	return (NULL);
96		}
97
98		VCL_IP v_matchproto_(td_vtc_no_ip)
99	10	vmod_no_ip(VRT_CTX)
100		{
101
102	10	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
103	10	return (NULL);
104		}
105
106		/--------------------------------------------------------------------/
107
108		VCL_VOID v_noreturn_ v_matchproto_(td_vtc_panic)
109	0	vmod_panic(VRT_CTX, VCL_STRANDS str)
110		{
111		const char *b;
112
113	0	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
114
115	0	b = VRT_StrandsWS(ctx->ws, "PANIC:", str);
116	0	VAS_Fail("VCL", "", 0, b, VAS_VCL);
117		}
118
119		/--------------------------------------------------------------------/
120
121		VCL_VOID v_matchproto_(td_vtc_sleep)
122	250	vmod_sleep(VRT_CTX, VCL_DURATION t)
123		{
124
125	250	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
126	250	VTIM_sleep(t);
127	250	}
128
129		/--------------------------------------------------------------------/
130
131		// XXX this really should be PRIV_TASK state
132		static uintptr_t vtc_ws_snapshot;
133
134		static struct ws *
135	5390	vtc_ws_find(VRT_CTX, VCL_ENUM which)
136		{
137
138	5390	if (which == VENUM(client))
139	2580	return (ctx->ws);
140	2810	if (which == VENUM(backend))
141	2520	return (ctx->bo->ws);
142	290	if (which == VENUM(session))
143	270	return (ctx->req->sp->ws);
144	20	if (which == VENUM(thread) && ctx->req != NULL)
145	20	return (ctx->req->wrk->aws);
146	0	if (which == VENUM(thread) && ctx->bo != NULL)
147	0	return (ctx->bo->wrk->aws);
148	0	WRONG("vtc_ws_find Illegal enum");
149	5390	}
150
151		VCL_VOID v_matchproto_(td_vtc_workspace_alloc)
152	4910	vmod_workspace_alloc(VRT_CTX, VCL_ENUM which, VCL_INT size)
153		{
154		struct ws *ws;
155		void *p;
156
157	4910	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
158
159	4910	ws = vtc_ws_find(ctx, which);
160	4910	if (ws == NULL)
161	0	return;
162	4910	WS_Assert(ws);
163
164	4910	if (size < 0) {
165	4750	size += WS_ReserveAll(ws);
166	4750	WS_Release(ws, 0);
167	4750	}
168	4910	if (size <= 0) {
169	20	VRT_fail(ctx, "Attempted negative WS allocation");
170	20	return;
171		}
172	4890	p = WS_Alloc(ws, size);
173	4890	if (p == NULL)
174	10	VRT_fail(ctx, "vtc.workspace_alloc");
175		else
176	4880	memset(p, '\0', size);
177	4910	}
178
179		VCL_BYTES v_matchproto_(td_vtc_workspace_reserve)
180	120	vmod_workspace_reserve(VRT_CTX, VCL_ENUM which, VCL_INT size)
181		{
182		struct ws *ws;
183		unsigned r;
184
185	120	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
186
187	120	ws = vtc_ws_find(ctx, which);
188	120	if (ws == NULL)
189	0	return (0);
190	120	WS_Assert(ws);
191
192	120	if (size < 0) {
193	70	size += WS_ReserveAll(ws);
194	70	WS_Release(ws, 0);
195	70	}
196	120	if (size <= 0) {
197	0	VRT_fail(ctx, "Attempted negative WS reservation");
198	0	return (0);
199		}
200	120	r = WS_ReserveSize(ws, size);
201	120	if (r == 0)
202	10	return (0);
203	110	memset(WS_Reservation(ws), 0, r);
204	110	WS_Release(ws, 0);
205	110	return (r);
206	120	}
207
208		VCL_INT v_matchproto_(td_vtc_workspace_free)
209	160	vmod_workspace_free(VRT_CTX, VCL_ENUM which)
210		{
211		struct ws *ws;
212		unsigned u;
213
214	160	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
215
216	160	ws = vtc_ws_find(ctx, which);
217	160	if (ws == NULL)
218	0	return (-1);
219	160	WS_Assert(ws);
220
221	160	u = WS_ReserveAll(ws);
222	160	WS_Release(ws, 0);
223	160	return (u);
224	160	}
225
226		#define VTC_WS_OP(type, def, name, op) \
227		VCL_##type v_matchproto_(td_vtc_workspace_##name) \
228		vmod_workspace_##name(VRT_CTX, VCL_ENUM which) \
229		{ \
230		struct ws *ws; \
231		\
232		CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); \
233		\
234		ws = vtc_ws_find(ctx, which); \
235		if (ws == NULL) \
236		return def ; \
237		WS_Assert(ws); \
238		\
239		op; \
240		}
241	10	VTC_WS_OP(VOID, , snapshot, (vtc_ws_snapshot = WS_Snapshot(ws)))
242	10	VTC_WS_OP(VOID, , reset, WS_Reset(ws, vtc_ws_snapshot))
243	10	VTC_WS_OP(VOID, , overflow, WS_MarkOverflow(ws))
244	50	VTC_WS_OP(BOOL, (0), overflowed, return (WS_Overflowed(ws)))
245		#undef VTC_WS_OP
246
247		VCL_BLOB v_matchproto_(td_vtc_workspace_dump)
248	120	vmod_workspace_dump(VRT_CTX, VCL_ENUM which, VCL_ENUM where,
249		VCL_BYTES off, VCL_BYTES len)
250		{
251		struct ws *ws;
252		unsigned l;
253	120	const unsigned maxlen = 1024;
254	120	unsigned char buf[maxlen];
255		const char p, err;
256
257	120	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
258	120	AN(where);
259
260	120	ws = vtc_ws_find(ctx, which);
261	120	if (ws == NULL)
262	0	return (NULL);
263	120	WS_Assert(ws);
264
265	120	if (len > maxlen) {
266	0	VRT_fail(ctx, "workspace_dump: max length is %jd",
267		(intmax_t)maxlen);
268	0	return (NULL);
269		}
270
271	120	l = WS_Dump(ws, *where, off, buf, len);
272	120	assert(l <= maxlen);
273
274	120	if (l == 0) {
275	0	switch (errno) {
276	0	case EINVAL: WRONG(where); break;
277	0	case EAGAIN: err = "NULL"; break;
278	0	case EFAULT: err = "off limit"; break;
279	0	default: err = "unknown error"; break;
280		}
281	0	VRT_fail(ctx, "workspace_dump: %s", err);
282	0	return (NULL);
283		}
284
285	120	p = WS_Copy(ctx->ws, buf, (int)l);
286	120	if (p == NULL) {
287	0	VRT_fail(ctx, "workspace_dump: copy failed");
288	0	return (NULL);
289		}
290	120	return (VRT_blob(ctx, "workspace_dump", p, l, 0xd000d000));
291	120	}
292
293		/--------------------------------------------------------------------/
294
295		VCL_INT v_matchproto_(td_vtc_typesize)
296	250	vmod_typesize(VRT_CTX, VCL_STRING s)
297		{
298	250	size_t i = 0, l, a, p = 0;
299
300	250	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
301	250	AN(s);
302	250	AN(*s);
303
304	1120	for (; *s; s++) {
305	880	switch (*s) {
306		#define VTC_TYPESIZE(c, t) case c: l = sizeof(t); break;
307	110	VTC_TYPESIZE('c', char)
308	30	VTC_TYPESIZE('d', double)
309	10	VTC_TYPESIZE('f', float)
310	30	VTC_TYPESIZE('i', int)
311	10	VTC_TYPESIZE('j', intmax_t)
312	10	VTC_TYPESIZE('l', long)
313	10	VTC_TYPESIZE('o', off_t)
314	160	VTC_TYPESIZE('p', void *)
315	30	VTC_TYPESIZE('s', short)
316	290	VTC_TYPESIZE('u', unsigned)
317	180	VTC_TYPESIZE('z', size_t)
318		#undef VTC_TYPESIZE
319	10	default: return (-1);
320		}
321	870	if (l > p)
322	420	p = l;
323	870	a = i % l;
324	870	if (a != 0)
325	50	i += (l - a); /* align */
326	870	i += l;
327	870	}
328	240	AN(p);
329	240	a = i % p;
330	240	if (a != 0)
331	60	i += (p - a); /* pad */
332	240	return ((VCL_INT)i);
333	250	}
334
335		/--------------------------------------------------------------------/
336
337		#define BLOB_VMOD_PROXY_HEADER_TYPE 0xc8f34f78
338
339		VCL_BLOB v_matchproto_(td_vtc_proxy_header)
340	20	vmod_proxy_header(VRT_CTX, VCL_ENUM venum, VCL_IP client, VCL_IP server,
341		VCL_STRING authority)
342		{
343		struct vsb *vsb;
344		const void *h;
345		int version;
346		size_t l;
347
348	20	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
349
350	20	if (venum == VENUM(v1))
351	10	version = 1;
352	10	else if (venum == VENUM(v2))
353	10	version = 2;
354		else
355	0	WRONG(venum);
356
357	20	vsb = VSB_new_auto();
358	20	AN(vsb);
359	20	VRT_Format_Proxy(vsb, version, client, server, authority);
360	20	l = VSB_len(vsb);
361	20	h = WS_Copy(ctx->ws, VSB_data(vsb), l);
362	20	VSB_destroy(&vsb);
363
364	20	if (h == NULL) {
365	0	VRT_fail(ctx, "proxy_header: out of workspace");
366	0	return (NULL);
367		}
368
369	20	return (VRT_blob(ctx, "proxy_header", h, l,
370		BLOB_VMOD_PROXY_HEADER_TYPE));
371	20	}
372
373		// ref vsl.c
374		struct vsl_tag2enum {
375		const char *string;
376		enum VSL_tag_e tag;
377		};
378
379		static struct vsl_tag2enum vsl_tag2enum[SLT__MAX] = {
380		#define SLTM(name,flags,sdesc,ldesc) [SLT_ ## name] = { \
381		.string = #name, \
382		.tag = SLT_ ## name \
383		},
384		#include "tbl/vsl_tags.h"
385		};
386
387		static int
388	635990	vsl_tagcmp(const void aa, const void bb)
389		{
390	635990	const struct vsl_tag2enum a = aa, b = bb;
391
392		// ref vsl2rst.c ptag_cmp
393	635990	if (a->string == NULL && b->string != NULL)
394	1440	return (1);
395	634550	else if (a->string != NULL && b->string == NULL)
396	69310	return (-1);
397	565240	else if (a->string == NULL && b->string == NULL)
398	121680	return (0);
399	443560	return (strcmp(a->string, b->string));
400	635990	}
401
402		/lint -esym(528, init_vsl_tag2enum) /
403		static void __attribute__((constructor))
404	720	init_vsl_tag2enum(void)
405		{
406	720	qsort(vsl_tag2enum, SLT__MAX, sizeof *vsl_tag2enum, vsl_tagcmp);
407	720	}
408
409
410		VCL_VOID
411	610	vmod_vsl(VRT_CTX, VCL_INT id, VCL_STRING tag_s, VCL_ENUM side, VCL_STRANDS s)
412		{
413		struct vsl_tag2enum *te, key;
414		vxid_t vxid;
415
416	610	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
417
418	610	key.string = tag_s;
419	610	te = bsearch(&key, vsl_tag2enum, SLT__MAX,
420		sizeof *vsl_tag2enum, vsl_tagcmp);
421
422	610	if (te == NULL) {
423	0	VRT_fail(ctx, "No such tag: %s", tag_s);
424	0	return;
425		}
426
427	610	if (id < 0 \|\| id > VRT_INTEGER_MAX) {
428	0	VRT_fail(ctx, "id out of bounds");
429	0	return;
430		}
431
432	610	vxid.vxid = id & VSL_IDENTMASK;
433	610	if (side == VENUM(c))
434	590	vxid.vxid \|= VSL_CLIENTMARKER;
435	20	else if (side == VENUM(b))
436	20	vxid.vxid \|= VSL_BACKENDMARKER;
437		else
438	0	WRONG("side");
439
440	610	VSLs(te->tag, vxid, s);
441	610	}
442
443		static void
444	590	vsl_line(VRT_CTX, char *str)
445		{
446		VCL_INT id;
447		VCL_ENUM side;
448		VCL_STRANDS s;
449	590	const char tag, delim = " \t\r\n";
450		char e, save;
451
452	590	if (str == '') {
453		// varnishtest
454	550	str = strstr(str, "vsl\|");
455	550	if (str == NULL)
456	0	return;
457	550	str += 4;
458	550	}
459	590	if ((str = strtok_r(str, delim, &save)) == NULL)
460	40	return;
461	550	id = strtoll(str, &e, 10);
462	550	if (e == str)
463	0	return;
464
465	550	if ((str = strtok_r(NULL, delim, &save)) == NULL)
466	0	return;
467	550	tag = str;
468
469	550	if ((str = strtok_r(NULL, delim, &save)) == NULL)
470	0	return;
471	550	if (*str == 'c')
472	530	side = VENUM(c);
473	20	else if (*str == 'b')
474	20	side = VENUM(b);
475		else
476	0	return;
477
478	550	str = strtok_r(NULL, "\r\n", &save);
479		// needs to be assigned here because of the compound literal lifetime
480	550	s = TOSTRAND(str);
481	550	if (str == NULL)
482	80	s = vrt_null_strands;
483
484	550	vmod_vsl(ctx, id, tag, side, s);
485	590	}
486
487		VCL_VOID
488	20	vmod_vsl_replay(VRT_CTX, VCL_STRANDS s)
489		{
490		struct vsb cp[1];
491		const char p, pp;
492		size_t l;
493	20	int i, err = 0;
494
495	20	CHECK_OBJ_ORNULL(s, STRANDS_MAGIC);
496	20	if (s == NULL \|\| s->n == 0)
497	0	return;
498
499	20	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);