GCOV - Varnish Cache


/*-
 * Copyright (c) 2012-2020 Varnish Software AS
 *
 * Author: Lasse Karstensen <lasse.karstensen@gmail.com>
 * Author: Lasse Karstensen <lkarsten@varnish-software.com>
 * 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.
 *
 * Cookie VMOD that simplifies handling of the Cookie request header.
 */

#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <pthread.h>

#include <cache/cache.h>

#include <vsb.h>

#include "vcc_cookie_if.h"

enum filter_action {
        blacklist,
        whitelist
};

struct cookie {
        unsigned                magic;
#define VMOD_COOKIE_ENTRY_MAGIC 0x3BB41543
        const char              *name;
        const char              *value;
        VTAILQ_ENTRY(cookie)    list;
};

/* A structure to represent both whitelists and blacklists */
struct matchlist {
        char                    *name;
        VTAILQ_ENTRY(matchlist) list;
};

struct vmod_cookie {
        unsigned                magic;
#define VMOD_COOKIE_MAGIC       0x4EE5FB2E
        VTAILQ_HEAD(, cookie)   cookielist;
};

static void
cobj_free(VRT_CTX, void *p)
{
        struct vmod_cookie *vcp;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CAST_OBJ_NOTNULL(vcp, p, VMOD_COOKIE_MAGIC);
        FREE_OBJ(vcp);
}

static const struct vmod_priv_methods cookie_cobj_priv_methods[1] = {{
        .magic = VMOD_PRIV_METHODS_MAGIC,
        .type = "vmod_cookie_cobj",
        .fini = cobj_free
}};

static struct vmod_cookie *
cobj_get(struct vmod_priv *priv)
{
        struct vmod_cookie *vcp;

        if (priv->priv == NULL) {
                ALLOC_OBJ(vcp, VMOD_COOKIE_MAGIC);
                AN(vcp);
                VTAILQ_INIT(&vcp->cookielist);
                priv->priv = vcp;
                priv->methods = cookie_cobj_priv_methods;
        } else
                CAST_OBJ_NOTNULL(vcp, priv->priv, VMOD_COOKIE_MAGIC);

        return (vcp);
}

VCL_VOID
vmod_parse(VRT_CTX, struct vmod_priv *priv, VCL_STRING cookieheader)
{
        struct vmod_cookie *vcp = cobj_get(priv);
        char *name, *value;
        const char *p, *sep;
        int i = 0;

        if (cookieheader == NULL || *cookieheader == '\0') {
                VSLb(ctx->vsl, SLT_Debug, "cookie: nothing to parse");
                return;
        }

        /* If called twice during the same request, clean out old state. */
        if (!VTAILQ_EMPTY(&vcp->cookielist))
                vmod_clean(ctx, priv);

        p = cookieheader;
        while (*p != '\0') {
                while (isspace(*p))
                        p++;
                sep = strchr(p, '=');
                if (sep == NULL)
                        break;
                name = strndup(p, pdiff(p, sep));
                p = sep + 1;

                sep = p;
                while (*sep != '\0' && *sep != ';')
                        sep++;
                value = strndup(p, pdiff(p, sep));

                vmod_set(ctx, priv, name, value);
                free(name);
                free(value);
                i++;
                if (*sep == '\0')
                        break;
                p = sep + 1;
        }

        VSLb(ctx->vsl, SLT_Debug, "cookie: parsed %i cookies.", i);
}

static struct cookie *
find_cookie(const struct vmod_cookie *vcp, VCL_STRING name)
{
        struct cookie *cookie;

        VTAILQ_FOREACH(cookie, &vcp->cookielist, list) {
                CHECK_OBJ_NOTNULL(cookie, VMOD_COOKIE_ENTRY_MAGIC);
                if (!vstrcmp(cookie->name, name))
                        break;
        }
        return (cookie);
}

VCL_VOID
vmod_set(VRT_CTX, struct vmod_priv *priv, VCL_STRING name, VCL_STRING value)
{
        struct vmod_cookie *vcp = cobj_get(priv);
        struct cookie *cookie;
        const char *p;

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

        /* Empty cookies should be ignored. */
        if (name == NULL || *name == '\0')
                return;
        if (value == NULL || *value == '\0')
                return;

        cookie = find_cookie(vcp, name);
        if (cookie != NULL) {
                p = WS_Printf(ctx->ws, "%s", value);
                if (p == NULL) {
                        VSLb(ctx->vsl, SLT_Error,
                            "cookie: Workspace overflow in set()");
                } else
                        cookie->value = p;
                return;
        }

        WS_TASK_ALLOC_OBJ(ctx, cookie, VMOD_COOKIE_ENTRY_MAGIC);
        if (cookie == NULL)
                return;

        cookie->name = WS_Printf(ctx->ws, "%s", name);
        cookie->value = WS_Printf(ctx->ws, "%s", value);
        if (cookie->name == NULL || cookie->value == NULL) {
                VSLb(ctx->vsl, SLT_Error,
                    "cookie: unable to get storage for cookie");
                return;
        }
        VTAILQ_INSERT_TAIL(&vcp->cookielist, cookie, list);
}

VCL_BOOL
vmod_isset(VRT_CTX, struct vmod_priv *priv, const char *name)
{
        struct vmod_cookie *vcp = cobj_get(priv);
        struct cookie *cookie;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (name == NULL || *name == '\0')
                return (0);

        cookie = find_cookie(vcp, name);
        return (cookie ? 1 : 0);
}

VCL_STRING
vmod_get(VRT_CTX, struct vmod_priv *priv, VCL_STRING name)
{
        struct vmod_cookie *vcp = cobj_get(priv);
        struct cookie *cookie;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (name == NULL || *name == '\0')
                return (NULL);

        cookie = find_cookie(vcp, name);
        return (cookie ? cookie->value : NULL);
}


VCL_STRING
vmod_get_re(VRT_CTX, struct vmod_priv *priv, VCL_REGEX re)
{
        struct vmod_cookie *vcp = cobj_get(priv);
        struct cookie *cookie = NULL;
        struct cookie *current;
        unsigned match;

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

        VTAILQ_FOREACH(current, &vcp->cookielist, list) {
                CHECK_OBJ_NOTNULL(current, VMOD_COOKIE_ENTRY_MAGIC);
                VSLb(ctx->vsl, SLT_Debug, "cookie: checking %s", current->name);
                match = VRT_re_match(ctx, current->name, re);
                if (!match)
                        continue;
                cookie = current;
                break;
        }

        return (cookie ? cookie->value : NULL);
}

VCL_VOID
vmod_delete(VRT_CTX, struct vmod_priv *priv, VCL_STRING name)
{
        struct vmod_cookie *vcp = cobj_get(priv);
        struct cookie *cookie;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (name == NULL || *name == '\0')
                return;

        cookie = find_cookie(vcp, name);

        if (cookie != NULL)
                VTAILQ_REMOVE(&vcp->cookielist, cookie, list);
}

VCL_VOID
vmod_clean(VRT_CTX, struct vmod_priv *priv)
{
        struct vmod_cookie *vcp = cobj_get(priv);

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(vcp);
        VTAILQ_INIT(&vcp->cookielist);
}

static void
filter_cookies(struct vmod_priv *priv, VCL_STRING list_s,
    enum filter_action mode)
{
        struct cookie *cookieptr, *safeptr;
        struct vmod_cookie *vcp = cobj_get(priv);
        struct matchlist *mlentry, *mlsafe;
        char const *p = list_s, *q;
        int matched = 0;
        VTAILQ_HEAD(, matchlist) matchlist_head;

        VTAILQ_INIT(&matchlist_head);

        /* Parse the supplied list. */
        while (p && *p != '\0') {
                while (isspace(*p))
                        p++;
                if (*p == '\0')
                        break;

                q = p;
                while (*q != '\0' && *q != ',')
                        q++;

                if (q == p) {
                        p++;
                        continue;
                }

                /* XXX: can we reserve/release lumps of txt instead of
                 * malloc/free?
                 */
                mlentry = malloc(sizeof *mlentry);
                AN(mlentry);
                mlentry->name = strndup(p, q - p);
                AN(mlentry->name);

                VTAILQ_INSERT_TAIL(&matchlist_head, mlentry, list);

                p = q;
                if (*p != '\0')
                        p++;
        }

        /* Filter existing cookies that either aren't in the whitelist or
         * are in the blacklist (depending on the filter_action) */
        VTAILQ_FOREACH_SAFE(cookieptr, &vcp->cookielist, list, safeptr) {
                CHECK_OBJ_NOTNULL(cookieptr, VMOD_COOKIE_ENTRY_MAGIC);
                matched = 0;

                VTAILQ_FOREACH(mlentry, &matchlist_head, list) {
                        if (vstrcmp(cookieptr->name, mlentry->name) == 0) {
                                matched = 1;
                                break;
                        }
                }
                if (matched != mode)
                        VTAILQ_REMOVE(&vcp->cookielist, cookieptr, list);
        }

        VTAILQ_FOREACH_SAFE(mlentry, &matchlist_head, list, mlsafe) {
                VTAILQ_REMOVE(&matchlist_head, mlentry, list);
                free(mlentry->name);
                free(mlentry);
        }
}

VCL_VOID
vmod_keep(VRT_CTX, struct vmod_priv *priv, VCL_STRING whitelist_s)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        filter_cookies(priv, whitelist_s, whitelist);
}


VCL_VOID
vmod_filter(VRT_CTX, struct vmod_priv *priv, VCL_STRING blacklist_s)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        filter_cookies(priv, blacklist_s, blacklist);
}

static VCL_VOID
re_filter(VRT_CTX, struct vmod_priv *priv, VCL_REGEX re, enum filter_action mode)
{
        struct vmod_cookie *vcp = cobj_get(priv);
        struct cookie *current, *safeptr;
        unsigned match;

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

        VTAILQ_FOREACH_SAFE(current, &vcp->cookielist, list, safeptr) {
                CHECK_OBJ_NOTNULL(current, VMOD_COOKIE_ENTRY_MAGIC);

                match = VRT_re_match(ctx, current->name, re);

                switch (mode) {
                case blacklist:
                        if (!match)
                                continue;
                        VSLb(ctx->vsl, SLT_Debug,
                            "Removing matching cookie %s (value: %s)",
                            current->name, current->value);
                        VTAILQ_REMOVE(&vcp->cookielist, current, list);
                        break;
                case whitelist:
                        if (match)
                                continue;

                        VSLb(ctx->vsl, SLT_Debug,
                            "Removing cookie %s (value: %s)",
                            current->name, current->value);
                        VTAILQ_REMOVE(&vcp->cookielist, current, list);
                        break;
                default:
                        WRONG("invalid mode");
                }
        }
}


VCL_VOID
vmod_keep_re(VRT_CTX, struct vmod_priv *priv, VCL_REGEX re)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        re_filter(ctx, priv, re, whitelist);
}


VCL_VOID
vmod_filter_re(VRT_CTX, struct vmod_priv *priv, VCL_REGEX re)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        re_filter(ctx, priv, re, blacklist);
}


VCL_STRING
vmod_get_string(VRT_CTX, struct vmod_priv *priv)
{
        struct cookie *curr;
        struct vsb output[1];
        struct vmod_cookie *vcp = cobj_get(priv);
        const char *sep = "", *res;

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

        VTAILQ_FOREACH(curr, &vcp->cookielist, list) {
                CHECK_OBJ_NOTNULL(curr, VMOD_COOKIE_ENTRY_MAGIC);
                AN(curr->name);
                AN(curr->value);
                VSB_printf(output, "%s%s=%s", sep, curr->name, curr->value);
                sep = "; ";
        }
        res = WS_VSB_finish(output, ctx->ws, NULL);
        if (res == NULL)
                VSLb(ctx->vsl, SLT_Error, "cookie: Workspace overflow");
        return (res);
}

VCL_STRING
vmod_format_date(VRT_CTX, VCL_TIME ts, VCL_DURATION duration)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        return (VRT_TIME_string(ctx, ts + duration));
}

		vinyl-cache/vmod/vmod_cookie.c
0		/*-
1		* Copyright (c) 2012-2020 Varnish Software AS
2		*
3		* Author: Lasse Karstensen <lasse.karstensen@gmail.com>
4		* Author: Lasse Karstensen <lkarsten@varnish-software.com>
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		* Cookie VMOD that simplifies handling of the Cookie request header.
31		*/
32
33		#include "config.h"
34
35		#include <stdlib.h>
36		#include <stdio.h>
37		#include <string.h>
38		#include <ctype.h>
39		#include <pthread.h>
40
41		#include <cache/cache.h>
42
43		#include <vsb.h>
44
45		#include "vcc_cookie_if.h"
46
47		enum filter_action {
48		blacklist,
49		whitelist
50		};
51
52		struct cookie {
53		unsigned magic;
54		#define VMOD_COOKIE_ENTRY_MAGIC 0x3BB41543
55		const char *name;
56		const char *value;
57		VTAILQ_ENTRY(cookie) list;
58		};
59
60		/* A structure to represent both whitelists and blacklists */
61		struct matchlist {
62		char *name;
63		VTAILQ_ENTRY(matchlist) list;
64		};
65
66		struct vmod_cookie {
67		unsigned magic;
68		#define VMOD_COOKIE_MAGIC 0x4EE5FB2E
69		VTAILQ_HEAD(, cookie) cookielist;
70		};
71
72		static void
73	1302	cobj_free(VRT_CTX, void *p)
74		{
75		struct vmod_cookie *vcp;
76
77	1302	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
78	1302	CAST_OBJ_NOTNULL(vcp, p, VMOD_COOKIE_MAGIC);
79	1302	FREE_OBJ(vcp);
80	1302	}
81
82		static const struct vmod_priv_methods cookie_cobj_priv_methods[1] = {{
83		.magic = VMOD_PRIV_METHODS_MAGIC,
84		.type = "vmod_cookie_cobj",
85		.fini = cobj_free
86		}};
87
88		static struct vmod_cookie *
89	6111	cobj_get(struct vmod_priv *priv)
90		{
91		struct vmod_cookie *vcp;
92
93	6111	if (priv->priv == NULL) {
94	1302	ALLOC_OBJ(vcp, VMOD_COOKIE_MAGIC);
95	1302	AN(vcp);
96	1302	VTAILQ_INIT(&vcp->cookielist);
97	1302	priv->priv = vcp;
98	1302	priv->methods = cookie_cobj_priv_methods;
99	1302	} else
100	4809	CAST_OBJ_NOTNULL(vcp, priv->priv, VMOD_COOKIE_MAGIC);
101
102	6111	return (vcp);
103		}
104
105		VCL_VOID
106	1176	vmod_parse(VRT_CTX, struct vmod_priv *priv, VCL_STRING cookieheader)
107		{
108	1176	struct vmod_cookie *vcp = cobj_get(priv);
109		char name, value;
110		const char p, sep;
111	1176	int i = 0;
112
113	1176	if (cookieheader == NULL \|\| *cookieheader == '\0') {
114	42	VSLb(ctx->vsl, SLT_Debug, "cookie: nothing to parse");
115	42	return;
116		}
117
118		/* If called twice during the same request, clean out old state. */
119	1134	if (!VTAILQ_EMPTY(&vcp->cookielist))
120	63	vmod_clean(ctx, priv);
121
122	1134	p = cookieheader;
123	2226	while (*p != '\0') {
124	3255	while (isspace(*p))
125	1050	p++;
126	2205	sep = strchr(p, '=');
127	2205	if (sep == NULL)
128	0	break;
129	2205	name = strndup(p, pdiff(p, sep));
130	2205	p = sep + 1;
131
132	2205	sep = p;
133	193473	while (sep != '\0' && sep != ';')
134	191268	sep++;
135	2205	value = strndup(p, pdiff(p, sep));
136
137	2205	vmod_set(ctx, priv, name, value);
138	2205	free(name);
139	2205	free(value);
140	2205	i++;
141	2205	if (*sep == '\0')
142	1113	break;
143	1092	p = sep + 1;
144		}
145
146	1134	VSLb(ctx->vsl, SLT_Debug, "cookie: parsed %i cookies.", i);
147	1176	}
148
149		static struct cookie *
150	2940	find_cookie(const struct vmod_cookie *vcp, VCL_STRING name)
151		{
152		struct cookie *cookie;
153
154	4788	VTAILQ_FOREACH(cookie, &vcp->cookielist, list) {
155	1995	CHECK_OBJ_NOTNULL(cookie, VMOD_COOKIE_ENTRY_MAGIC);
156	1995	if (!vstrcmp(cookie->name, name))
157	147	break;
158	1848	}
159	2940	return (cookie);
160		}
161
162		VCL_VOID
163	2814	vmod_set(VRT_CTX, struct vmod_priv *priv, VCL_STRING name, VCL_STRING value)
164		{
165	2814	struct vmod_cookie *vcp = cobj_get(priv);
166		struct cookie *cookie;
167		const char *p;
168
169	2814	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
170	2814	CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
171
172		/* Empty cookies should be ignored. */
173	2814	if (name == NULL \|\| *name == '\0')
174	63	return;
175	2751	if (value == NULL \|\| *value == '\0')
176	42	return;
177
178	2709	cookie = find_cookie(vcp, name);
179	2709	if (cookie != NULL) {
180	21	p = WS_Printf(ctx->ws, "%s", value);
181	21	if (p == NULL) {
182	0	VSLb(ctx->vsl, SLT_Error,
183		"cookie: Workspace overflow in set()");
184	0	} else
185	21	cookie->value = p;
186	21	return;
187		}
188
189	5376	WS_TASK_ALLOC_OBJ(ctx, cookie, VMOD_COOKIE_ENTRY_MAGIC);
190	2688	if (cookie == NULL)
191	0	return;
192
193	2688	cookie->name = WS_Printf(ctx->ws, "%s", name);
194	2688	cookie->value = WS_Printf(ctx->ws, "%s", value);
195	2688	if (cookie->name == NULL \|\| cookie->value == NULL) {
196	0	VSLb(ctx->vsl, SLT_Error,
197		"cookie: unable to get storage for cookie");
198	0	return;
199		}
200	2688	VTAILQ_INSERT_TAIL(&vcp->cookielist, cookie, list);
201	2814	}
202
203		VCL_BOOL
204	126	vmod_isset(VRT_CTX, struct vmod_priv priv, const char name)
205		{
206	126	struct vmod_cookie *vcp = cobj_get(priv);
207		struct cookie *cookie;
208
209	126	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
210	126	if (name == NULL \|\| *name == '\0')
211	42	return (0);
212
213	84	cookie = find_cookie(vcp, name);
214	84	return (cookie ? 1 : 0);
215	126	}
216
217		VCL_STRING
218	84	vmod_get(VRT_CTX, struct vmod_priv *priv, VCL_STRING name)
219		{
220	84	struct vmod_cookie *vcp = cobj_get(priv);
221		struct cookie *cookie;
222
223	84	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
224	84	if (name == NULL \|\| *name == '\0')
225	0	return (NULL);
226
227	84	cookie = find_cookie(vcp, name);
228	84	return (cookie ? cookie->value : NULL);
229	84	}
230
231
232		VCL_STRING
233	84	vmod_get_re(VRT_CTX, struct vmod_priv *priv, VCL_REGEX re)
234		{
235	84	struct vmod_cookie *vcp = cobj_get(priv);
236	84	struct cookie *cookie = NULL;
237		struct cookie *current;
238		unsigned match;
239
240	84	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
241	84	AN(re);
242
243	210	VTAILQ_FOREACH(current, &vcp->cookielist, list) {
244	168	CHECK_OBJ_NOTNULL(current, VMOD_COOKIE_ENTRY_MAGIC);
245	168	VSLb(ctx->vsl, SLT_Debug, "cookie: checking %s", current->name);
246	168	match = VRT_re_match(ctx, current->name, re);
247	168	if (!match)
248	126	continue;
249	42	cookie = current;
250	42	break;
251		}
252
253	84	return (cookie ? cookie->value : NULL);
254		}
255
256		VCL_VOID
257	84	vmod_delete(VRT_CTX, struct vmod_priv *priv, VCL_STRING name)
258		{
259	84	struct vmod_cookie *vcp = cobj_get(priv);
260		struct cookie *cookie;
261
262	84	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
263	84	if (name == NULL \|\| *name == '\0')
264	21	return;
265
266	63	cookie = find_cookie(vcp, name);
267
268	63	if (cookie != NULL)
269	21	VTAILQ_REMOVE(&vcp->cookielist, cookie, list);
270	84	}
271
272		VCL_VOID
273	105	vmod_clean(VRT_CTX, struct vmod_priv *priv)
274		{
275	105	struct vmod_cookie *vcp = cobj_get(priv);
276
277	105	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
278	105	AN(vcp);
279	105	VTAILQ_INIT(&vcp->cookielist);
280	105	}
281
282		static void
283	126	filter_cookies(struct vmod_priv *priv, VCL_STRING list_s,
284		enum filter_action mode)
285		{
286		struct cookie cookieptr, safeptr;
287	126	struct vmod_cookie *vcp = cobj_get(priv);
288		struct matchlist mlentry, mlsafe;
289	126	char const p = list_s, q;
290	126	int matched = 0;
291		VTAILQ_HEAD(, matchlist) matchlist_head;
292
293	126	VTAILQ_INIT(&matchlist_head);
294
295		/* Parse the supplied list. */
296	567	while (p && *p != '\0') {
297	609	while (isspace(*p))
298	168	p++;
299	441	if (*p == '\0')
300	0	break;
301
302	441	q = p;
303	1659	while (q != '\0' && q != ',')
304	1218	q++;
305
306	441	if (q == p) {
307	210	p++;
308	210	continue;
309		}
310
311		/* XXX: can we reserve/release lumps of txt instead of
312		* malloc/free?
313		*/
314	231	mlentry = malloc(sizeof *mlentry);
315	231	AN(mlentry);
316	231	mlentry->name = strndup(p, q - p);
317	231	AN(mlentry->name);
318
319	231	VTAILQ_INSERT_TAIL(&matchlist_head, mlentry, list);
320
321	231	p = q;
322	231	if (*p != '\0')
323	189	p++;
324		}
325
326		/* Filter existing cookies that either aren't in the whitelist or
327		* are in the blacklist (depending on the filter_action) */
328	462	VTAILQ_FOREACH_SAFE(cookieptr, &vcp->cookielist, list, safeptr) {
329	336	CHECK_OBJ_NOTNULL(cookieptr, VMOD_COOKIE_ENTRY_MAGIC);
330	336	matched = 0;
331
332	693	VTAILQ_FOREACH(mlentry, &matchlist_head, list) {
333	504	if (vstrcmp(cookieptr->name, mlentry->name) == 0) {
334	147	matched = 1;
335	147	break;
336		}
337	357	}
338	336	if (matched != mode)
339	147	VTAILQ_REMOVE(&vcp->cookielist, cookieptr, list);
340	336	}
341
342	357	VTAILQ_FOREACH_SAFE(mlentry, &matchlist_head, list, mlsafe) {
343	231	VTAILQ_REMOVE(&matchlist_head, mlentry, list);
344	231	free(mlentry->name);
345	231	free(mlentry);
346	231	}
347	126	}
348
349		VCL_VOID
350	63	vmod_keep(VRT_CTX, struct vmod_priv *priv, VCL_STRING whitelist_s)
351		{
352
353	63	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
354	63	filter_cookies(priv, whitelist_s, whitelist);
355	63	}
356
357
358		VCL_VOID
359	63	vmod_filter(VRT_CTX, struct vmod_priv *priv, VCL_STRING blacklist_s)
360		{
361
362	63	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
363	63	filter_cookies(priv, blacklist_s, blacklist);
364	63	}
365
366		static VCL_VOID
367	147	re_filter(VRT_CTX, struct vmod_priv *priv, VCL_REGEX re, enum filter_action mode)
368		{
369	147	struct vmod_cookie *vcp = cobj_get(priv);
370		struct cookie current, safeptr;
371		unsigned match;
372
373	147	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
374	147	AN(re);
375
376	546	VTAILQ_FOREACH_SAFE(current, &vcp->cookielist, list, safeptr) {
377	399	CHECK_OBJ_NOTNULL(current, VMOD_COOKIE_ENTRY_MAGIC);
378
379	399	match = VRT_re_match(ctx, current->name, re);
380
381	399	switch (mode) {
382		case blacklist:
383	231	if (!match)
384	168	continue;
385	126	VSLb(ctx->vsl, SLT_Debug,
386		"Removing matching cookie %s (value: %s)",
387	63	current->name, current->value);
388	63	VTAILQ_REMOVE(&vcp->cookielist, current, list);
389	63	break;
390		case whitelist:
391	168	if (match)
392	105	continue;
393
394	126	VSLb(ctx->vsl, SLT_Debug,
395		"Removing cookie %s (value: %s)",
396	63	current->name, current->value);
397	63	VTAILQ_REMOVE(&vcp->cookielist, current, list);
398	63	break;
399		default:
400	0	WRONG("invalid mode");
401	0	}
402	126	}
403	147	}
404
405
406		VCL_VOID
407	63	vmod_keep_re(VRT_CTX, struct vmod_priv *priv, VCL_REGEX re)
408		{
409
410	63	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
411	63	re_filter(ctx, priv, re, whitelist);
412	63	}
413
414
415		VCL_VOID
416	84	vmod_filter_re(VRT_CTX, struct vmod_priv *priv, VCL_REGEX re)
417		{
418
419	84	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
420	84	re_filter(ctx, priv, re, blacklist);
421	84	}
422
423
424		VCL_STRING
425	1365	vmod_get_string(VRT_CTX, struct vmod_priv *priv)
426		{
427		struct cookie *curr;
428		struct vsb output[1];
429	1365	struct vmod_cookie *vcp = cobj_get(priv);
430	1365	const char sep = "", res;
431
432	1365	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
433	1365	CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
434	1365	WS_VSB_new(output, ctx->ws);
435
436	3738	VTAILQ_FOREACH(curr, &vcp->cookielist, list) {
437	2373	CHECK_OBJ_NOTNULL(curr, VMOD_COOKIE_ENTRY_MAGIC);
438	2373	AN(curr->name);
439	2373	AN(curr->value);
440	2373	VSB_printf(output, "%s%s=%s", sep, curr->name, curr->value);
441	2373	sep = "; ";
442	2373	}
443	1365	res = WS_VSB_finish(output, ctx->ws, NULL);
444	1365	if (res == NULL)
445	0	VSLb(ctx->vsl, SLT_Error, "cookie: Workspace overflow");
446	1365	return (res);
447		}
448
449		VCL_STRING
450	21	vmod_format_date(VRT_CTX, VCL_TIME ts, VCL_DURATION duration)
451		{
452
453	21	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
454	21	return (VRT_TIME_string(ctx, ts + duration));
455		}