GCOV - Varnish Cache


/*-
 * Copyright (c) 2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Dridi Boukelmoune <dridi@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 <netdb.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <unistd.h>

#include "cache/cache.h"

#include "vsa.h"
#include "vss.h"
#include "vus.h"
#include "vcc_debug_if.h"

struct xyzzy_debug_dyn {
        unsigned                magic;
#define VMOD_DEBUG_DYN_MAGIC    0x9b77ccbd
        pthread_mutex_t         mtx;
        char                    *vcl_name;
        VCL_BACKEND             dir;
};

struct xyzzy_debug_dyn_uds {
        unsigned                magic;
#define VMOD_DEBUG_UDS_MAGIC    0x6c7370e6
        pthread_mutex_t         mtx;
        char                    *vcl_name;
        VCL_BACKEND             dir;
};

static void
dyn_dir_init(VRT_CTX, struct xyzzy_debug_dyn *dyn,
     VCL_STRING addr, VCL_STRING port, VCL_PROBE probe)
{
        const struct suckaddr *sa;
        VCL_BACKEND dir, dir2;
        struct vrt_endpoint vep;
        struct vrt_backend vrt;

        CHECK_OBJ_NOTNULL(dyn, VMOD_DEBUG_DYN_MAGIC);
        XXXAN(addr);
        XXXAN(port);

        INIT_OBJ(&vep, VRT_ENDPOINT_MAGIC);
        INIT_OBJ(&vrt, VRT_BACKEND_MAGIC);
        vrt.endpoint = &vep;
        vrt.vcl_name = dyn->vcl_name;
        vrt.hosthdr = addr;
        vrt.probe = probe;

        sa = VSS_ResolveOne(NULL, addr, port, AF_UNSPEC, SOCK_STREAM, 0);
        AN(sa);
        if (VSA_Get_Proto(sa) == AF_INET)
                vep.ipv4 = sa;
        else if (VSA_Get_Proto(sa) == AF_INET6)
                vep.ipv6 = sa;
        else
                WRONG("Wrong proto family");

        dir = VRT_new_backend(ctx, &vrt);
        AN(dir);

        /*
         * NB: A real dynamic backend should not replace the previous
         * instance if the new one is identical.  We do it here because
         * the d* tests requires a replacement.
         */
        AZ(pthread_mutex_lock(&dyn->mtx));
        dir2 = dyn->dir;
        dyn->dir = dir;
        AZ(pthread_mutex_unlock(&dyn->mtx));

        if (dir2 != NULL)
                VRT_delete_backend(ctx, &dir2);

        VSA_free(&sa);
}

VCL_VOID
xyzzy_dyn__init(VRT_CTX, struct xyzzy_debug_dyn **dynp,
    const char *vcl_name, VCL_STRING addr, VCL_STRING port, VCL_PROBE probe)
{
        struct xyzzy_debug_dyn *dyn;

        ASSERT_CLI();
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(dynp);
        AZ(*dynp);
        AN(vcl_name);

        if (*addr == '\0' || *port == '\0') {
                AZ(VRT_handled(ctx));
                VRT_fail(ctx, "Missing dynamic backend address or port");
                return;
        }

        ALLOC_OBJ(dyn, VMOD_DEBUG_DYN_MAGIC);
        AN(dyn);
        REPLACE(dyn->vcl_name, vcl_name);

        AZ(pthread_mutex_init(&dyn->mtx, NULL));

        dyn_dir_init(ctx, dyn, addr, port, probe);
        XXXAN(dyn->dir);
        *dynp = dyn;
}

VCL_VOID v_matchproto_(td_xyzzy_debug_dyn__fini)
xyzzy_dyn__fini(struct xyzzy_debug_dyn **dynp)
{
        struct xyzzy_debug_dyn *dyn;

        TAKE_OBJ_NOTNULL(dyn, dynp, VMOD_DEBUG_DYN_MAGIC);
        /* at this point all backends will be deleted by the vcl */
        free(dyn->vcl_name);
        AZ(pthread_mutex_destroy(&dyn->mtx));
        FREE_OBJ(dyn);
}

VCL_BACKEND v_matchproto_()
xyzzy_dyn_backend(VRT_CTX, struct xyzzy_debug_dyn *dyn)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(dyn, VMOD_DEBUG_DYN_MAGIC);
        AN(dyn->dir);
        return (dyn->dir);
}

VCL_VOID
xyzzy_dyn_refresh(VRT_CTX, struct xyzzy_debug_dyn *dyn,
    VCL_STRING addr, VCL_STRING port, VCL_PROBE probe)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(dyn, VMOD_DEBUG_DYN_MAGIC);
        dyn_dir_init(ctx, dyn, addr, port, probe);
}

static int
dyn_uds_init(VRT_CTX, struct xyzzy_debug_dyn_uds *uds, VCL_STRING path)
{
        VCL_BACKEND dir, dir2;
        struct vrt_endpoint vep;
        struct vrt_backend vrt;
        struct stat st;

        if (path == NULL) {
                VRT_fail(ctx, "path is NULL");
                return (-1);
        }
        if (! VUS_is(path)) {
                VRT_fail(ctx, "path must be an absolute path: %s", path);
                return (-1);
        }

        /* XXX: now that we accept that sockets may come after vcl.load
         * and change during the life of a VCL, do we still need to check
         * this? It looks like both if blocks can be retired.
         */
        errno = 0;
        if (stat(path, &st) != 0) {
                VRT_fail(ctx, "Cannot stat path %s: %s", path, strerror(errno));
                return (-1);
        }
        if (!S_ISSOCK(st.st_mode)) {
                VRT_fail(ctx, "%s is not a socket", path);
                return (-1);
        }

        INIT_OBJ(&vep, VRT_ENDPOINT_MAGIC);
        INIT_OBJ(&vrt, VRT_BACKEND_MAGIC);
        vrt.endpoint = &vep;
        vep.uds_path = path;
        vrt.vcl_name = uds->vcl_name;
        vrt.hosthdr = "localhost";
        vep.ipv4 = NULL;
        vep.ipv6 = NULL;

        if ((dir = VRT_new_backend(ctx, &vrt)) == NULL)
                return (-1);

        AZ(pthread_mutex_lock(&uds->mtx));
        dir2 = uds->dir;
        uds->dir = dir;
        AZ(pthread_mutex_unlock(&uds->mtx));

        if (dir2 != NULL)
                VRT_delete_backend(ctx, &dir2);
        return (0);
}

VCL_VOID v_matchproto_(td_xyzzy_debug_dyn_uds__init)
xyzzy_dyn_uds__init(VRT_CTX, struct xyzzy_debug_dyn_uds **udsp,
    const char *vcl_name, VCL_STRING path)
{
        struct xyzzy_debug_dyn_uds *uds;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(udsp);
        AZ(*udsp);
        AN(vcl_name);

        ALLOC_OBJ(uds, VMOD_DEBUG_UDS_MAGIC);
        AN(uds);
        REPLACE(uds->vcl_name, vcl_name);
        AZ(pthread_mutex_init(&uds->mtx, NULL));

        if (dyn_uds_init(ctx, uds, path) != 0) {
                free(uds->vcl_name);
                AZ(pthread_mutex_destroy(&uds->mtx));
                FREE_OBJ(uds);
                return;
        }

        *udsp = uds;
}

VCL_VOID v_matchproto_(td_debug_dyn_uds__fini)
xyzzy_dyn_uds__fini(struct xyzzy_debug_dyn_uds **udsp)
{
        struct xyzzy_debug_dyn_uds *uds;

        TAKE_OBJ_NOTNULL(uds, udsp, VMOD_DEBUG_UDS_MAGIC);
        free(uds->vcl_name);
        AZ(pthread_mutex_destroy(&uds->mtx));
        FREE_OBJ(uds);
}

VCL_BACKEND v_matchproto_(td_debug_dyn_uds_backend)
xyzzy_dyn_uds_backend(VRT_CTX, struct xyzzy_debug_dyn_uds *uds)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(uds, VMOD_DEBUG_UDS_MAGIC);
        AN(uds->dir);
        return (uds->dir);
}

VCL_VOID v_matchproto_(td_debug_dyn_uds_refresh)
xyzzy_dyn_uds_refresh(VRT_CTX, struct xyzzy_debug_dyn_uds *uds, VCL_STRING path)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(uds, VMOD_DEBUG_UDS_MAGIC);
        (void) dyn_uds_init(ctx, uds, path);
}

		varnish-cache/vmod/vmod_debug_dyn.c
0		/*-
1		* Copyright (c) 2015 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Dridi Boukelmoune <dridi@varnish-software.com>
5		*
6		* SPDX-License-Identifier: BSD-2-Clause
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted provided that the following conditions
10		* are met:
11		* 1. Redistributions of source code must retain the above copyright
12		* notice, this list of conditions and the following disclaimer.
13		* 2. Redistributions in binary form must reproduce the above copyright
14		* notice, this list of conditions and the following disclaimer in the
15		* documentation and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27		* SUCH DAMAGE.
28		*/
29
30		#include "config.h"
31
32		#include <netdb.h>
33		#include <stdlib.h>
34		#include <string.h>
35		#include <sys/socket.h>
36		#include <sys/stat.h>
37		#include <unistd.h>
38
39		#include "cache/cache.h"
40
41		#include "vsa.h"
42		#include "vss.h"
43		#include "vus.h"
44		#include "vcc_debug_if.h"
45
46		struct xyzzy_debug_dyn {
47		unsigned magic;
48		#define VMOD_DEBUG_DYN_MAGIC 0x9b77ccbd
49		pthread_mutex_t mtx;
50		char *vcl_name;
51		VCL_BACKEND dir;
52		};
53
54		struct xyzzy_debug_dyn_uds {
55		unsigned magic;
56		#define VMOD_DEBUG_UDS_MAGIC 0x6c7370e6
57		pthread_mutex_t mtx;
58		char *vcl_name;
59		VCL_BACKEND dir;
60		};
61
62		static void
63	560	dyn_dir_init(VRT_CTX, struct xyzzy_debug_dyn *dyn,
64		VCL_STRING addr, VCL_STRING port, VCL_PROBE probe)
65		{
66		const struct suckaddr *sa;
67		VCL_BACKEND dir, dir2;
68		struct vrt_endpoint vep;
69		struct vrt_backend vrt;
70
71	560	CHECK_OBJ_NOTNULL(dyn, VMOD_DEBUG_DYN_MAGIC);
72	560	XXXAN(addr);
73	560	XXXAN(port);
74
75	560	INIT_OBJ(&vep, VRT_ENDPOINT_MAGIC);
76	560	INIT_OBJ(&vrt, VRT_BACKEND_MAGIC);
77	560	vrt.endpoint = &vep;
78	560	vrt.vcl_name = dyn->vcl_name;
79	560	vrt.hosthdr = addr;
80	560	vrt.probe = probe;
81
82	560	sa = VSS_ResolveOne(NULL, addr, port, AF_UNSPEC, SOCK_STREAM, 0);
83	560	AN(sa);
84	560	if (VSA_Get_Proto(sa) == AF_INET)
85	560	vep.ipv4 = sa;
86	0	else if (VSA_Get_Proto(sa) == AF_INET6)
87	0	vep.ipv6 = sa;
88		else
89	0	WRONG("Wrong proto family");
90
91	560	dir = VRT_new_backend(ctx, &vrt);
92	560	AN(dir);
93
94		/*
95		* NB: A real dynamic backend should not replace the previous
96		* instance if the new one is identical. We do it here because
97		* the d* tests requires a replacement.
98		*/
99	560	AZ(pthread_mutex_lock(&dyn->mtx));
100	560	dir2 = dyn->dir;
101	560	dyn->dir = dir;
102	560	AZ(pthread_mutex_unlock(&dyn->mtx));
103
104	560	if (dir2 != NULL)
105	240	VRT_delete_backend(ctx, &dir2);
106
107	560	VSA_free(&sa);
108	560	}
109
110		VCL_VOID
111	360	xyzzy_dyn__init(VRT_CTX, struct xyzzy_debug_dyn **dynp,
112		const char *vcl_name, VCL_STRING addr, VCL_STRING port, VCL_PROBE probe)
113		{
114		struct xyzzy_debug_dyn *dyn;
115
116	360	ASSERT_CLI();
117	360	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
118	360	AN(dynp);
119	360	AZ(*dynp);
120	360	AN(vcl_name);
121
122	360	if (addr == '\0' \|\| port == '\0') {
123	40	AZ(VRT_handled(ctx));
124	40	VRT_fail(ctx, "Missing dynamic backend address or port");
125	40	return;
126		}
127
128	320	ALLOC_OBJ(dyn, VMOD_DEBUG_DYN_MAGIC);
129	320	AN(dyn);
130	320	REPLACE(dyn->vcl_name, vcl_name);
131
132	320	AZ(pthread_mutex_init(&dyn->mtx, NULL));
133
134	320	dyn_dir_init(ctx, dyn, addr, port, probe);
135	320	XXXAN(dyn->dir);
136	320	*dynp = dyn;
137	360	}
138
139		VCL_VOID v_matchproto_(td_xyzzy_debug_dyn__fini)
140	40	xyzzy_dyn__fini(struct xyzzy_debug_dyn **dynp)
141		{
142		struct xyzzy_debug_dyn *dyn;
143
144	40	TAKE_OBJ_NOTNULL(dyn, dynp, VMOD_DEBUG_DYN_MAGIC);
145		/* at this point all backends will be deleted by the vcl */
146	40	free(dyn->vcl_name);
147	40	AZ(pthread_mutex_destroy(&dyn->mtx));
148	40	FREE_OBJ(dyn);
149	40	}
150
151		VCL_BACKEND v_matchproto_()
152	520	xyzzy_dyn_backend(VRT_CTX, struct xyzzy_debug_dyn *dyn)
153		{
154	520	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
155	520	CHECK_OBJ_NOTNULL(dyn, VMOD_DEBUG_DYN_MAGIC);
156	520	AN(dyn->dir);
157	520	return (dyn->dir);
158		}
159
160		VCL_VOID
161	240	xyzzy_dyn_refresh(VRT_CTX, struct xyzzy_debug_dyn *dyn,
162		VCL_STRING addr, VCL_STRING port, VCL_PROBE probe)
163		{
164	240	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
165	240	CHECK_OBJ_NOTNULL(dyn, VMOD_DEBUG_DYN_MAGIC);
166	240	dyn_dir_init(ctx, dyn, addr, port, probe);
167	240	}
168
169		static int
170	680	dyn_uds_init(VRT_CTX, struct xyzzy_debug_dyn_uds *uds, VCL_STRING path)
171		{
172		VCL_BACKEND dir, dir2;
173		struct vrt_endpoint vep;
174		struct vrt_backend vrt;
175		struct stat st;
176
177	680	if (path == NULL) {
178	0	VRT_fail(ctx, "path is NULL");
179	0	return (-1);
180		}
181	680	if (! VUS_is(path)) {
182	80	VRT_fail(ctx, "path must be an absolute path: %s", path);
183	80	return (-1);
184		}
185
186		/* XXX: now that we accept that sockets may come after vcl.load
187		* and change during the life of a VCL, do we still need to check
188		* this? It looks like both if blocks can be retired.
189		*/
190	600	errno = 0;
191	600	if (stat(path, &st) != 0) {
192	40	VRT_fail(ctx, "Cannot stat path %s: %s", path, strerror(errno));
193	40	return (-1);
194		}
195	560	if (!S_ISSOCK(st.st_mode)) {
196	40	VRT_fail(ctx, "%s is not a socket", path);
197	40	return (-1);
198		}
199
200	520	INIT_OBJ(&vep, VRT_ENDPOINT_MAGIC);
201	520	INIT_OBJ(&vrt, VRT_BACKEND_MAGIC);
202	520	vrt.endpoint = &vep;
203	520	vep.uds_path = path;
204	520	vrt.vcl_name = uds->vcl_name;
205	520	vrt.hosthdr = "localhost";
206	520	vep.ipv4 = NULL;
207	520	vep.ipv6 = NULL;
208
209	520	if ((dir = VRT_new_backend(ctx, &vrt)) == NULL)
210	0	return (-1);
211
212	520	AZ(pthread_mutex_lock(&uds->mtx));
213	520	dir2 = uds->dir;
214	520	uds->dir = dir;
215	520	AZ(pthread_mutex_unlock(&uds->mtx));
216
217	520	if (dir2 != NULL)
218	200	VRT_delete_backend(ctx, &dir2);
219	520	return (0);
220	680	}
221
222		VCL_VOID v_matchproto_(td_xyzzy_debug_dyn_uds__init)
223	480	xyzzy_dyn_uds__init(VRT_CTX, struct xyzzy_debug_dyn_uds **udsp,
224		const char *vcl_name, VCL_STRING path)
225		{
226		struct xyzzy_debug_dyn_uds *uds;
227
228	480	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
229	480	AN(udsp);
230	480	AZ(*udsp);
231	480	AN(vcl_name);
232
233	480	ALLOC_OBJ(uds, VMOD_DEBUG_UDS_MAGIC);
234	480	AN(uds);
235	480	REPLACE(uds->vcl_name, vcl_name);
236	480	AZ(pthread_mutex_init(&uds->mtx, NULL));
237
238	480	if (dyn_uds_init(ctx, uds, path) != 0) {
239	160	free(uds->vcl_name);
240	160	AZ(pthread_mutex_destroy(&uds->mtx));
241	160	FREE_OBJ(uds);
242	160	return;
243		}
244
245	320	*udsp = uds;
246	480	}
247
248		VCL_VOID v_matchproto_(td_debug_dyn_uds__fini)
249	40	xyzzy_dyn_uds__fini(struct xyzzy_debug_dyn_uds **udsp)
250		{
251		struct xyzzy_debug_dyn_uds *uds;
252
253	40	TAKE_OBJ_NOTNULL(uds, udsp, VMOD_DEBUG_UDS_MAGIC);
254	40	free(uds->vcl_name);
255	40	AZ(pthread_mutex_destroy(&uds->mtx));
256	40	FREE_OBJ(uds);
257	40	}
258
259		VCL_BACKEND v_matchproto_(td_debug_dyn_uds_backend)
260	520	xyzzy_dyn_uds_backend(VRT_CTX, struct xyzzy_debug_dyn_uds *uds)
261		{
262	520	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
263	520	CHECK_OBJ_NOTNULL(uds, VMOD_DEBUG_UDS_MAGIC);
264	520	AN(uds->dir);
265	520	return (uds->dir);
266		}
267
268		VCL_VOID v_matchproto_(td_debug_dyn_uds_refresh)
269	200	xyzzy_dyn_uds_refresh(VRT_CTX, struct xyzzy_debug_dyn_uds *uds, VCL_STRING path)
270		{
271	200	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
272	200	CHECK_OBJ_NOTNULL(uds, VMOD_DEBUG_UDS_MAGIC);
273	200	(void) dyn_uds_init(ctx, uds, path);
274	200	}