GCOV - Varnish Cache


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

#include "cache_varnishd.h"

void
WS_Id(const struct ws *ws, char *id)
{

        WS_Assert(ws);
        AN(id);
        memcpy(id, ws->id, WS_ID_SIZE);
        id[0] |= 0x20;                  // cheesy tolower()
}

void
WS_MarkOverflow(struct ws *ws)
{
        CHECK_OBJ_NOTNULL(ws, WS_MAGIC);

        ws->id[0] &= ~0x20;             // cheesy toupper()
}

static void
ws_ClearOverflow(struct ws *ws)
{
        CHECK_OBJ_NOTNULL(ws, WS_MAGIC);

        ws->id[0] |= 0x20;              // cheesy tolower()
}

int
WS_Overflowed(const struct ws *ws)
{
        CHECK_OBJ_NOTNULL(ws, WS_MAGIC);
        AN(ws->id[0]);

        if (ws->id[0] & 0x20)           // cheesy islower()
                return (0);
        return (1);
}

/*
 * Reset the WS to a cookie or its start and clears any overflow
 *
 * for varnishd internal use only
 */

void
WS_Rollback(struct ws *ws, uintptr_t pp)
{

        WS_Assert(ws);

        if (pp == 0)
                pp = (uintptr_t)ws->s;
        ws_ClearOverflow(ws);
        WS_Reset(ws, pp);
}

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

const char *
WS_Printf(struct ws *ws, const char *fmt, ...)
{
        unsigned u, v;
        va_list ap;
        char *p;

        u = WS_ReserveAll(ws);
        p = ws->f;
        va_start(ap, fmt);
        v = vsnprintf(p, u, fmt, ap);
        va_end(ap);
        if (v >= u) {
                WS_Release(ws, 0);
                WS_MarkOverflow(ws);
                p = NULL;
        } else {
                WS_Release(ws, v + 1);
        }
        return (p);
}

/*---------------------------------------------------------------------
 * Build a VSB on a workspace.
 * Usage pattern:
 *
 *      struct vsb vsb[1];
 *      char *p;
 *
 *      WS_VSB_new(vsb, ctx->ws);
 *      VSB_printf(vsb, "blablabla");
 *      p = WS_VSB_finish(vsb, ctx->ws, NULL);
 *      if (p == NULL)
 *              return (FAILURE);
 */

void
WS_VSB_new(struct vsb *vsb, struct ws *ws)
{
        unsigned u;
        static char bogus[2];   // Smallest possible vsb

        AN(vsb);
        WS_Assert(ws);
        u = WS_ReserveAll(ws);
        if (WS_Overflowed(ws) || u < 2)
                AN(VSB_init(vsb, bogus, sizeof bogus));
        else
                AN(VSB_init(vsb, WS_Reservation(ws), u));
}

char *
WS_VSB_finish(struct vsb *vsb, struct ws *ws, size_t *szp)
{
        char *p;

        AN(vsb);
        WS_Assert(ws);
        if (!VSB_finish(vsb)) {
                p = VSB_data(vsb);
                if (p == ws->f) {
                        WS_Release(ws, VSB_len(vsb) + 1);
                        if (szp != NULL)
                                *szp = VSB_len(vsb);
                        VSB_fini(vsb);
                        return (p);
                }
        }
        WS_MarkOverflow(ws);
        VSB_fini(vsb);
        WS_Release(ws, 0);
        if (szp)
                *szp = 0;
        return (NULL);
}

		varnish-cache/bin/varnishd/cache/cache_ws_common.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2021 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		* Author: Dridi Boukelmoune <dridi.boukelmoune@gmail.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
33		#include "config.h"
34
35		#include <stdio.h>
36
37		#include "cache_varnishd.h"
38
39		void
40	4160	WS_Id(const struct ws ws, char id)
41		{
42
43	4160	WS_Assert(ws);
44	4160	AN(id);
45	4160	memcpy(id, ws->id, WS_ID_SIZE);
46	4160	id[0] \|= 0x20; // cheesy tolower()
47	4160	}
48
49		void
50	42080	WS_MarkOverflow(struct ws *ws)
51		{
52	42080	CHECK_OBJ_NOTNULL(ws, WS_MAGIC);
53
54	42080	ws->id[0] &= ~0x20; // cheesy toupper()
55	42080	}
56
57		static void
58	1730881	ws_ClearOverflow(struct ws *ws)
59		{
60	1730881	CHECK_OBJ_NOTNULL(ws, WS_MAGIC);
61
62	1730881	ws->id[0] \|= 0x20; // cheesy tolower()
63	1730881	}
64
65		int
66	5433336	WS_Overflowed(const struct ws *ws)
67		{
68	5433336	CHECK_OBJ_NOTNULL(ws, WS_MAGIC);
69	5433336	AN(ws->id[0]);
70
71	5433336	if (ws->id[0] & 0x20) // cheesy islower()
72	5414696	return (0);
73	18640	return (1);
74	5433336	}
75
76		/*
77		* Reset the WS to a cookie or its start and clears any overflow
78		*
79		* for varnishd internal use only
80		*/
81
82		void
83	1731116	WS_Rollback(struct ws *ws, uintptr_t pp)
84		{
85
86	1731116	WS_Assert(ws);
87
88	1731116	if (pp == 0)
89	1371124	pp = (uintptr_t)ws->s;
90	1731116	ws_ClearOverflow(ws);
91	1731116	WS_Reset(ws, pp);
92	1731116	}
93
94		/--------------------------------------------------------------------/
95
96		const char *
97	129478	WS_Printf(struct ws ws, const char fmt, ...)
98		{
99		unsigned u, v;
100		va_list ap;
101		char *p;
102
103	129478	u = WS_ReserveAll(ws);
104	129478	p = ws->f;
105	129478	va_start(ap, fmt);
106	129478	v = vsnprintf(p, u, fmt, ap);
107	129478	va_end(ap);
108	129478	if (v >= u) {
109	11800	WS_Release(ws, 0);
110	11800	WS_MarkOverflow(ws);
111	11800	p = NULL;
112	11800	} else {
113	117678	WS_Release(ws, v + 1);
114		}
115	129478	return (p);
116		}
117
118		/*---------------------------------------------------------------------
119		* Build a VSB on a workspace.
120		* Usage pattern:
121		*
122		* struct vsb vsb[1];
123		* char *p;
124		*
125		* WS_VSB_new(vsb, ctx->ws);
126		* VSB_printf(vsb, "blablabla");
127		* p = WS_VSB_finish(vsb, ctx->ws, NULL);
128		* if (p == NULL)
129		* return (FAILURE);
130		*/
131
132		void
133	1191130	WS_VSB_new(struct vsb vsb, struct ws ws)
134		{
135		unsigned u;
136		static char bogus[2]; // Smallest possible vsb
137
138	1191130	AN(vsb);
139	1191130	WS_Assert(ws);
140	1191130	u = WS_ReserveAll(ws);
141	1191130	if (WS_Overflowed(ws) \|\| u < 2)
142	1760	AN(VSB_init(vsb, bogus, sizeof bogus));
143		else
144	1189374	AN(VSB_init(vsb, WS_Reservation(ws), u));
145	1191134	}
146
147		char *
148	1191341	WS_VSB_finish(struct vsb vsb, struct ws ws, size_t *szp)
149		{
150		char *p;
151
152	1191341	AN(vsb);
153	1191341	WS_Assert(ws);
154	1191341	if (!VSB_finish(vsb)) {
155	1189820	p = VSB_data(vsb);
156	1189820	if (p == ws->f) {
157	1189060	WS_Release(ws, VSB_len(vsb) + 1);
158	1189060	if (szp != NULL)
159	975753	*szp = VSB_len(vsb);
160	1189060	VSB_fini(vsb);
161	1189060	return (p);
162		}
163	760	}
164	2281	WS_MarkOverflow(ws);
165	2281	VSB_fini(vsb);
166	2281	WS_Release(ws, 0);
167	2281	if (szp)
168	1040	*szp = 0;
169	2281	return (NULL);
170	1191341	}