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>
 *
 * 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 <math.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#include "vcc_compile.h"

#include "vre.h"
#include "vnum.h"
#include "vsa.h"
#include "vss.h"
#include "vtcp.h"

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

static void
vcc_cstrcat(struct vcc *tl, struct vsb *vsb)
{
        struct token *t1;

        assert(tl->t->tok == CSTR);
        VSB_cat(vsb, tl->t->dec);

        t1 = vcc_PeekToken(tl);
        AN(t1);

        while (t1->tok == '+') {
                vcc_NextToken(tl);
                SkipToken(tl, '+');
                ExpectErr(tl, CSTR);
                VSB_cat(vsb, tl->t->dec);
                t1 = vcc_PeekToken(tl);
                AN(t1);
        }
}

void
vcc_regexp(struct vcc *tl, struct vsb *vgc_name)
{
        struct vsb *pattern;
        struct token *t0;
        char buf[BUFSIZ];
        vre_t *t;
        int error, erroroffset;
        struct inifin *ifp;

        t0 = tl->t;
        pattern = VSB_new_auto();
        AN(pattern);
        vcc_cstrcat(tl, pattern);
        AZ(VSB_finish(pattern));

        t = VRE_compile(VSB_data(pattern), 0, &error, &erroroffset, 0);
        if (t == NULL) {
                VSB_cat(tl->sb, "Regexp compilation error:\n\n");
                AZ(VRE_error(tl->sb, error));
                VSB_cat(tl->sb, "\n\n");
                vcc_ErrWhere2(tl, t0, tl->t);
                VSB_destroy(&pattern);
                return;
        }
        VRE_free(&t);
        bprintf(buf, "VGC_re_%u", tl->unique++);
        if (vgc_name)
                VSB_cat(vgc_name, buf);

        Fh(tl, 0, "static struct vre *%s;\n", buf);
        ifp = New_IniFin(tl);
        VSB_printf(ifp->ini, "\tVPI_re_init(&%s, ",buf);
        VSB_quote(ifp->ini, VSB_data(pattern), -1, VSB_QUOTE_CSTR);
        VSB_cat(ifp->ini, ");");
        VSB_printf(ifp->fin, "\t\tVPI_re_fini(%s);", buf);
        VSB_destroy(&pattern);
}

/*
 * The IPv6 crew royally screwed up the entire idea behind
 * struct sockaddr, see libvarnish/vsa.c for blow-by-blow account.
 *
 * There is no sane or even remotely portable way to initialize
 * a sockaddr for random protocols at compile time.
 *
 * In our case it is slightly more tricky than that, because we don't
 * even want to #include the struct sockaddr* definitions.
 *
 * Instead we make sure the sockaddr is sane (for our values of
 * sane) and dump it as our own "struct suckaddr" type, in binary,
 * using the widest integer type, hoping that this will ensure sufficient
 * alignment.
 */

static void
vcc_suckaddr(struct vcc *tl, const char *host, const struct suckaddr *vsa,
    const char **ip, const char **ip_ascii, const char **p_ascii)
{
        char a[VTCP_ADDRBUFSIZE];
        char p[VTCP_PORTBUFSIZE];
        const int sz = sizeof(unsigned long long);
        const unsigned n = (vsa_suckaddr_len + sz - 1) / sz;
        unsigned long long b[n];
        unsigned len;
        char *q;

        VTCP_name(vsa, a, sizeof a, p, sizeof p);
        Fh(tl, 0, "\n/* \"%s\" -> %s */\n", host, a);
        if (ip_ascii != NULL)
                *ip_ascii = TlDup(tl, a);
        if (p_ascii != NULL && *p_ascii == NULL)
                *p_ascii = TlDup(tl, p);

        Fh(tl, 0, "static const unsigned long long");
        Fh(tl, 0, " suckaddr_%u[%d] = {\n", tl->unique, n);
        memcpy(b, vsa, vsa_suckaddr_len);
        for (len = 0; len < n; len++)
                Fh(tl, 0, "%s    0x%0*llxULL",
                    len ? ",\n" : "", sz * 2, b[len]);
        Fh(tl, 0, "\n};\n");

        q = TlAlloc(tl, 40);
        AN(q);
        assert(snprintf(q, 40, "(const void*)suckaddr_%u", tl->unique) < 40);
        *ip = q;
        tl->unique++;
}

/*--------------------------------------------------------------------
 * This routine is a monster, but at least we only have one such monster.
 * Look up a IP number, and return IPv4/IPv6 address as VGC produced names
 * and optionally ascii strings.
 *
 * For IP compile time constants we only want one IP#, but it can be
 * IPv4 or IPv6.
 *
 * For backends, we accept up to one IPv4 and one IPv6.
 */

struct rss {
        unsigned                magic;
#define RSS_MAGIC               0x11e966ab

        const struct suckaddr   *vsa4;
        const struct suckaddr   *vsa6;
        struct vsb              *vsb;
        int                     retval;
        int                     wrong;
};

static int v_matchproto_(vss_resolved_f)
rs_callback(void *priv, const struct suckaddr *vsa)
{
        struct rss *rss;
        int v;
        char a[VTCP_ADDRBUFSIZE];
        char p[VTCP_PORTBUFSIZE];

        CAST_OBJ_NOTNULL(rss, priv, RSS_MAGIC);
        assert(VSA_Sane(vsa));

        v = VSA_Get_Proto(vsa);
        assert(v != AF_UNIX);
        VTCP_name(vsa, a, sizeof a, p, sizeof p);
        VSB_printf(rss->vsb, "\t%s:%s\n", a, p);
        if (v == AF_INET) {
                if (rss->vsa4 == NULL)
                        rss->vsa4 = VSA_Clone(vsa);
                else if (VSA_Compare(vsa, rss->vsa4))
                        rss->wrong++;
                rss->retval++;
        } else if (v == AF_INET6) {
                if (rss->vsa6 == NULL)
                        rss->vsa6 = VSA_Clone(vsa);
                else if (VSA_Compare(vsa, rss->vsa6))
                        rss->wrong++;
                rss->retval++;
        }
        return (0);
}

void
Resolve_Sockaddr(struct vcc *tl,
    const char *host,
    const char *def_port,
    const char **ipv4,
    const char **ipv4_ascii,
    const char **ipv6,
    const char **ipv6_ascii,
    const char **p_ascii,
    int maxips,
    const struct token *t_err,
    const char *errid)
{
        int error;
        struct rss rss[1];
        const char *err;

        *ipv4 = NULL;
        *ipv6 = NULL;
        if (p_ascii != NULL)
                *p_ascii = NULL;

        INIT_OBJ(rss, RSS_MAGIC);
        rss->vsb = VSB_new_auto();
        AN(rss->vsb);

        error = VSS_resolver(host, def_port, rs_callback, rss, &err);
        AZ(VSB_finish(rss->vsb));
        if (err != NULL) {
                VSB_printf(tl->sb,
                    "%s '%.*s' could not be resolved to an IP address:\n"
                    "\t%s\n"
                    "(Sorry if that error message is gibberish.)\n",
                    errid, PF(t_err), err);
                vcc_ErrWhere(tl, t_err);
                if (rss->vsa4 != NULL)
                        VSA_free(&rss->vsa4);
                if (rss->vsa6 != NULL)
                        VSA_free(&rss->vsa6);
                VSB_destroy(&rss->vsb);
                ZERO_OBJ(rss, sizeof rss);
                return;
        }
        AZ(error);
        if (rss->vsa4 != NULL) {
                vcc_suckaddr(tl, host, rss->vsa4, ipv4, ipv4_ascii, p_ascii);
                VSA_free(&rss->vsa4);
        }
        if (rss->vsa6 != NULL) {
                vcc_suckaddr(tl, host, rss->vsa6, ipv6, ipv6_ascii, p_ascii);
                VSA_free(&rss->vsa6);
        }
        if (rss->retval == 0) {
                VSB_printf(tl->sb,
                    "%s '%.*s': resolves to "
                    "neither IPv4 nor IPv6 addresses.\n",
                    errid, PF(t_err) );
                vcc_ErrWhere(tl, t_err);
        }
        if (rss->wrong || rss->retval > maxips) {
                VSB_printf(tl->sb,
                    "%s %.*s: resolves to too many addresses.\n"
                    "Only one IPv4 %s IPv6 are allowed.\n"
                    "Please specify which exact address "
                    "you want to use, we found all of these:\n%s",
                    errid, PF(t_err),
                    maxips > 1 ? "and one" :  "or",
                    VSB_data(rss->vsb));
                vcc_ErrWhere(tl, t_err);
        }
        VSB_destroy(&rss->vsb);
        ZERO_OBJ(rss, sizeof rss);
}

/*--------------------------------------------------------------------
* Recognize boolean const "true" or "false"
*/

uint8_t
vcc_BoolVal(struct vcc *tl)
{
        struct symbol* sym;

        if (tl->t->tok != ID) {
                VSB_cat(tl->sb, "Expected \"true\" or \"false\"\n");
                vcc_ErrWhere(tl, tl->t);
                return (0);
        }
        sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_NONE, SYMTAB_NOERR, XREF_NONE);
        if (sym == NULL || sym->type != BOOL) {
                VSB_cat(tl->sb, "Expected \"true\" or \"false\"\n");
                vcc_ErrWhere(tl, tl->t);
                return (0);
        }
        return (sym->eval_priv != NULL);
}

/*--------------------------------------------------------------------
 * Recognize and convert units of duration, return seconds.
 */

double
vcc_DurationUnit(struct vcc *tl)
{
        double sc;

        assert(tl->t->tok == ID);
        sc = VNUM_duration_unit(1.0, tl->t->b, tl->t->e);
        if (!isnan(sc)) {
                vcc_NextToken(tl);
                return (sc);
        }
        VSB_cat(tl->sb, "Unknown duration unit ");
        vcc_ErrToken(tl, tl->t);
        VSB_printf(tl->sb, "\n%s\n", VNUM_LEGAL_DURATION);
        vcc_ErrWhere(tl, tl->t);
        return (1.0);
}

/*--------------------------------------------------------------------
 * Recognize and convert { CNUM } to unsigned value
 * The tokenizer made sure we only get digits.
 */

uint64_t
vcc_UintVal(struct vcc *tl)
{
        int64_t retval;

        if (tl->t->tok != CNUM) {
                Expect(tl, CNUM);
                return (0);
        }
        retval = (int64_t)round(tl->t->num);
        if (retval < 0) {
                VSB_cat(tl->sb, "UINT cannot be negative\n");
                vcc_ErrWhere(tl, tl->t);
                return (0);
        }
        vcc_NextToken(tl);
        return (retval);
}

static double
vcc_DoubleVal(struct vcc *tl)
{
        double retval;

        if (tl->t->tok != CNUM && tl->t->tok != FNUM) {
                Expect(tl, CNUM);
                return (0);
        }
        retval = tl->t->num;
        vcc_NextToken(tl);
        return (retval);
}

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

void
vcc_Duration(struct vcc *tl, double *d)
{
        double v, sc;

        v = vcc_DoubleVal(tl);
        ERRCHK(tl);
        ExpectErr(tl, ID);
        sc = vcc_DurationUnit(tl);
        *d = v * sc;
}

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

void
vcc_ByteVal(struct vcc *tl, VCL_INT *d)
{
        double v;
        VCL_INT retval;
        const char *errtxt;

        if (tl->t->tok != CNUM && tl->t->tok != FNUM) {
                Expect(tl, CNUM);
                return;
        }
        v = tl->t->num;
        vcc_NextToken(tl);
        if (tl->t->tok != ID) {
                VSB_cat(tl->sb, "Expected BYTES unit (B, KB, MB...) got ");
                vcc_ErrToken(tl, tl->t);
                VSB_cat(tl->sb, "\n");
                vcc_ErrWhere(tl, tl->t);
                return;
        }
        retval = VNUM_bytes_unit(v, tl->t->b, tl->t->e, 0, &errtxt);
        if (errno) {
                VSB_cat(tl->sb, errtxt);
                vcc_ErrToken(tl, tl->t);
                vcc_ErrWhere(tl, tl->t);
                return;
        }
        vcc_NextToken(tl);
        *d = retval;
}

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

int
vcc_IsFlagRaw(struct vcc *tl, const struct token *t1, const struct token *t2)
{

        if (t1->tok != '-' && t1->tok != '+')
                return (-1);
        if (t2->b != t1->e) {
                VSB_cat(tl->sb, "Expected a flag at:\n");
                vcc_ErrWhere(tl, t1);
                return (-1);
        }
        return (t1->tok == '+' ? 1 : 0);
}

int
vcc_IsFlag(struct vcc *tl)
{
        struct token *t;
        int retval;

        t = vcc_PeekToken(tl);
        if (t == NULL)
                return (-1);
        retval = vcc_IsFlagRaw(tl, tl->t, t);
        if (retval >= 0)
                vcc_NextToken(tl);
        return (retval);
}

char *
vcc_Dup_be(const char *b, const char *e)
{
        char *p;

        AN(b);
        if (e == NULL)
                e = strchr(b, '\0');
        AN(e);
        assert(e >= b);

        p = strndup(b, e - b);
        AN(p);
        return (p);
}

int
vcc_Has_vcl_prefix(const char *b)
{
        return (
            (b[0] == 'v' || b[0] == 'V') &&
            (b[1] == 'c' || b[1] == 'C') &&
            (b[2] == 'l' || b[2] == 'L') &&
            (b[3] == '_')
        );
}

		varnish-cache/lib/libvcc/vcc_utils.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		*
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 <math.h>
34		#include <string.h>
35		#include <stdlib.h>
36		#include <sys/socket.h>
37		#include <sys/types.h>
38		#include <unistd.h>
39
40		#include "vcc_compile.h"
41
42		#include "vre.h"
43		#include "vnum.h"
44		#include "vsa.h"
45		#include "vss.h"
46		#include "vtcp.h"
47
48		/--------------------------------------------------------------------/
49
50		static void
51	8606	vcc_cstrcat(struct vcc tl, struct vsb vsb)
52		{
53		struct token *t1;
54
55	8606	assert(tl->t->tok == CSTR);
56	8606	VSB_cat(vsb, tl->t->dec);
57
58	8606	t1 = vcc_PeekToken(tl);
59	8606	AN(t1);
60
61	8610	while (t1->tok == '+') {
62	5	vcc_NextToken(tl);
63	5	SkipToken(tl, '+');
64	5	ExpectErr(tl, CSTR);
65	4	VSB_cat(vsb, tl->t->dec);
66	4	t1 = vcc_PeekToken(tl);
67	4	AN(t1);
68		}
69	8606	}
70
71		void
72	8606	vcc_regexp(struct vcc tl, struct vsb vgc_name)
73		{
74		struct vsb *pattern;
75		struct token *t0;
76		char buf[BUFSIZ];
77		vre_t *t;
78		int error, erroroffset;
79		struct inifin *ifp;
80
81	8606	t0 = tl->t;
82	8606	pattern = VSB_new_auto();
83	8606	AN(pattern);
84	8606	vcc_cstrcat(tl, pattern);
85	8606	AZ(VSB_finish(pattern));
86
87	8606	t = VRE_compile(VSB_data(pattern), 0, &error, &erroroffset, 0);
88	8606	if (t == NULL) {
89	2	VSB_cat(tl->sb, "Regexp compilation error:\n\n");
90	2	AZ(VRE_error(tl->sb, error));
91	2	VSB_cat(tl->sb, "\n\n");
92	2	vcc_ErrWhere2(tl, t0, tl->t);
93	2	VSB_destroy(&pattern);
94	2	return;
95		}
96	8604	VRE_free(&t);
97	8604	bprintf(buf, "VGC_re_%u", tl->unique++);
98	8604	if (vgc_name)
99	8604	VSB_cat(vgc_name, buf);
100
101	8604	Fh(tl, 0, "static struct vre *%s;\n", buf);
102	8604	ifp = New_IniFin(tl);
103	8604	VSB_printf(ifp->ini, "\tVPI_re_init(&%s, ",buf);
104	8604	VSB_quote(ifp->ini, VSB_data(pattern), -1, VSB_QUOTE_CSTR);
105	8604	VSB_cat(ifp->ini, ");");
106	8604	VSB_printf(ifp->fin, "\t\tVPI_re_fini(%s);", buf);
107	8604	VSB_destroy(&pattern);
108	8606	}
109
110		/*
111		* The IPv6 crew royally screwed up the entire idea behind
112		* struct sockaddr, see libvarnish/vsa.c for blow-by-blow account.
113		*
114		* There is no sane or even remotely portable way to initialize
115		* a sockaddr for random protocols at compile time.
116		*
117		* In our case it is slightly more tricky than that, because we don't
118		* even want to #include the struct sockaddr* definitions.
119		*
120		* Instead we make sure the sockaddr is sane (for our values of
121		* sane) and dump it as our own "struct suckaddr" type, in binary,
122		* using the widest integer type, hoping that this will ensure sufficient
123		* alignment.
124		*/
125
126		static void
127	1383	vcc_suckaddr(struct vcc tl, const char host, const struct suckaddr *vsa,
128		const char ip, const char ip_ascii, const char **p_ascii)
129		{
130		char a[VTCP_ADDRBUFSIZE];
131		char p[VTCP_PORTBUFSIZE];
132	1383	const int sz = sizeof(unsigned long long);
133	1383	const unsigned n = (vsa_suckaddr_len + sz - 1) / sz;
134	1383	unsigned long long b[n];
135		unsigned len;
136		char *q;
137
138	1383	VTCP_name(vsa, a, sizeof a, p, sizeof p);
139	1383	Fh(tl, 0, "\n/* \"%s\" -> %s */\n", host, a);
140	1383	if (ip_ascii != NULL)
141	1356	*ip_ascii = TlDup(tl, a);
142	1383	if (p_ascii != NULL && *p_ascii == NULL)
143	1355	*p_ascii = TlDup(tl, p);
144
145	1383	Fh(tl, 0, "static const unsigned long long");
146	1383	Fh(tl, 0, " suckaddr_%u[%d] = {\n", tl->unique, n);
147	1383	memcpy(b, vsa, vsa_suckaddr_len);
148	6915	for (len = 0; len < n; len++)
149	11064	Fh(tl, 0, "%s 0x%0*llxULL",
150	5532	len ? ",\n" : "", sz * 2, b[len]);
151	1383	Fh(tl, 0, "\n};\n");
152
153	1383	q = TlAlloc(tl, 40);
154	1383	AN(q);
155	1383	assert(snprintf(q, 40, "(const void*)suckaddr_%u", tl->unique) < 40);
156	1383	*ip = q;
157	1383	tl->unique++;
158	1383	}
159
160		/*--------------------------------------------------------------------
161		* This routine is a monster, but at least we only have one such monster.
162		* Look up a IP number, and return IPv4/IPv6 address as VGC produced names
163		* and optionally ascii strings.
164		*
165		* For IP compile time constants we only want one IP#, but it can be
166		* IPv4 or IPv6.
167		*
168		* For backends, we accept up to one IPv4 and one IPv6.
169		*/
170
171		struct rss {
172		unsigned magic;
173		#define RSS_MAGIC 0x11e966ab
174
175		const struct suckaddr *vsa4;
176		const struct suckaddr *vsa6;
177		struct vsb *vsb;
178		int retval;
179		int wrong;
180		};
181
182		static int v_matchproto_(vss_resolved_f)
183	1385	rs_callback(void priv, const struct suckaddr vsa)
184		{
185		struct rss *rss;
186		int v;
187		char a[VTCP_ADDRBUFSIZE];
188		char p[VTCP_PORTBUFSIZE];
189
190	1385	CAST_OBJ_NOTNULL(rss, priv, RSS_MAGIC);
191	1385	assert(VSA_Sane(vsa));
192
193	1385	v = VSA_Get_Proto(vsa);
194	1385	assert(v != AF_UNIX);
195	1385	VTCP_name(vsa, a, sizeof a, p, sizeof p);
196	1385	VSB_printf(rss->vsb, "\t%s:%s\n", a, p);
197	1385	if (v == AF_INET) {
198	1370	if (rss->vsa4 == NULL)
199	1368	rss->vsa4 = VSA_Clone(vsa);
200	2	else if (VSA_Compare(vsa, rss->vsa4))
201	2	rss->wrong++;
202	1370	rss->retval++;
203	1385	} else if (v == AF_INET6) {
204	15	if (rss->vsa6 == NULL)
205	15	rss->vsa6 = VSA_Clone(vsa);
206	0	else if (VSA_Compare(vsa, rss->vsa6))
207	0	rss->wrong++;
208	15	rss->retval++;
209	15	}
210	1385	return (0);
211		}
212
213		void
214	1386	Resolve_Sockaddr(struct vcc *tl,
215		const char *host,
216		const char *def_port,
217		const char **ipv4,
218		const char **ipv4_ascii,
219		const char **ipv6,
220		const char **ipv6_ascii,
221		const char **p_ascii,
222		int maxips,
223		const struct token *t_err,
224		const char *errid)
225		{
226		int error;
227		struct rss rss[1];
228		const char *err;
229
230	1386	*ipv4 = NULL;
231	1386	*ipv6 = NULL;
232	1386	if (p_ascii != NULL)
233	1357	*p_ascii = NULL;
234
235	1386	INIT_OBJ(rss, RSS_MAGIC);
236	1386	rss->vsb = VSB_new_auto();
237	1386	AN(rss->vsb);
238
239	1386	error = VSS_resolver(host, def_port, rs_callback, rss, &err);
240	1386	AZ(VSB_finish(rss->vsb));
241	1386	if (err != NULL) {
242	8	VSB_printf(tl->sb,
243		"%s '%.*s' could not be resolved to an IP address:\n"
244		"\t%s\n"
245		"(Sorry if that error message is gibberish.)\n",
246	4	errid, PF(t_err), err);
247	4	vcc_ErrWhere(tl, t_err);
248	4	if (rss->vsa4 != NULL)
249	0	VSA_free(&rss->vsa4);
250	4	if (rss->vsa6 != NULL)
251	0	VSA_free(&rss->vsa6);
252	4	VSB_destroy(&rss->vsb);
253	4	ZERO_OBJ(rss, sizeof rss);
254	4	return;
255		}
256	1382	AZ(error);
257	1382	if (rss->vsa4 != NULL) {
258	1368	vcc_suckaddr(tl, host, rss->vsa4, ipv4, ipv4_ascii, p_ascii);
259	1368	VSA_free(&rss->vsa4);
260	1368	}
261	1382	if (rss->vsa6 != NULL) {
262	15	vcc_suckaddr(tl, host, rss->vsa6, ipv6, ipv6_ascii, p_ascii);
263	15	VSA_free(&rss->vsa6);
264	15	}
265	1382	if (rss->retval == 0) {
266	0	VSB_printf(tl->sb,
267		"%s '%.*s': resolves to "
268		"neither IPv4 nor IPv6 addresses.\n",
269	0	errid, PF(t_err) );
270	0	vcc_ErrWhere(tl, t_err);
271	0	}
272	1382	if (rss->wrong \|\| rss->retval > maxips) {
273	2	VSB_printf(tl->sb,
274		"%s %.*s: resolves to too many addresses.\n"
275		"Only one IPv4 %s IPv6 are allowed.\n"
276		"Please specify which exact address "
277		"you want to use, we found all of these:\n%s",
278	1	errid, PF(t_err),
279	1	maxips > 1 ? "and one" : "or",
280	1	VSB_data(rss->vsb));
281	1	vcc_ErrWhere(tl, t_err);
282	1	}
283	1382	VSB_destroy(&rss->vsb);
284	1382	ZERO_OBJ(rss, sizeof rss);
285	1386	}
286
287		/*--------------------------------------------------------------------
288		* Recognize boolean const "true" or "false"
289		*/
290
291		uint8_t
292	4	vcc_BoolVal(struct vcc *tl)
293		{
294		struct symbol* sym;
295
296	4	if (tl->t->tok != ID) {
297	1	VSB_cat(tl->sb, "Expected \"true\" or \"false\"\n");
298	1	vcc_ErrWhere(tl, tl->t);
299	1	return (0);
300		}
301	3	sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_NONE, SYMTAB_NOERR, XREF_NONE);
302	3	if (sym == NULL \|\| sym->type != BOOL) {
303	1	VSB_cat(tl->sb, "Expected \"true\" or \"false\"\n");
304	1	vcc_ErrWhere(tl, tl->t);
305	1	return (0);
306		}
307	2	return (sym->eval_priv != NULL);
308	4	}
309
310		/*--------------------------------------------------------------------
311		* Recognize and convert units of duration, return seconds.
312		*/
313
314		double
315	3108	vcc_DurationUnit(struct vcc *tl)
316		{
317		double sc;
318
319	3108	assert(tl->t->tok == ID);
320	3108	sc = VNUM_duration_unit(1.0, tl->t->b, tl->t->e);
321	3108	if (!isnan(sc)) {
322	3107	vcc_NextToken(tl);
323	3107	return (sc);
324		}
325	1	VSB_cat(tl->sb, "Unknown duration unit ");
326	1	vcc_ErrToken(tl, tl->t);
327	1	VSB_printf(tl->sb, "\n%s\n", VNUM_LEGAL_DURATION);
328	1	vcc_ErrWhere(tl, tl->t);
329	1	return (1.0);
330	3108	}
331
332		/*--------------------------------------------------------------------
333		* Recognize and convert { CNUM } to unsigned value
334		* The tokenizer made sure we only get digits.
335		*/
336
337		uint64_t
338	221	vcc_UintVal(struct vcc *tl)
339		{
340		int64_t retval;
341
342	221	if (tl->t->tok != CNUM) {
343	0	Expect(tl, CNUM);
344	0	return (0);
345		}
346	221	retval = (int64_t)round(tl->t->num);
347	221	if (retval < 0) {
348	0	VSB_cat(tl->sb, "UINT cannot be negative\n");
349	0	vcc_ErrWhere(tl, tl->t);
350	0	return (0);
351		}
352	221	vcc_NextToken(tl);
353	221	return (retval);
354	221	}
355
356		static double
357	48	vcc_DoubleVal(struct vcc *tl)
358		{
359		double retval;
360
361	48	if (tl->t->tok != CNUM && tl->t->tok != FNUM) {
362	1	Expect(tl, CNUM);
363	1	return (0);
364		}
365	47	retval = tl->t->num;
366	47	vcc_NextToken(tl);
367	47	return (retval);
368	48	}
369
370		/--------------------------------------------------------------------/
371
372		void
373	48	vcc_Duration(struct vcc tl, double d)
374		{
375		double v, sc;
376
377	48	v = vcc_DoubleVal(tl);
378	48	ERRCHK(tl);
379	47	ExpectErr(tl, ID);
380	47	sc = vcc_DurationUnit(tl);
381	47	d = v sc;
382	48	}
383
384		/--------------------------------------------------------------------/
385
386		void
387	50	vcc_ByteVal(struct vcc tl, VCL_INT d)
388		{
389		double v;
390		VCL_INT retval;
391		const char *errtxt;
392
393	50	if (tl->t->tok != CNUM && tl->t->tok != FNUM) {
394	0	Expect(tl, CNUM);
395	0	return;
396		}
397	50	v = tl->t->num;
398	50	vcc_NextToken(tl);
399	50	if (tl->t->tok != ID) {
400	1	VSB_cat(tl->sb, "Expected BYTES unit (B, KB, MB...) got ");
401	1	vcc_ErrToken(tl, tl->t);
402	1	VSB_cat(tl->sb, "\n");
403	1	vcc_ErrWhere(tl, tl->t);
404	1	return;
405		}
406	49	retval = VNUM_bytes_unit(v, tl->t->b, tl->t->e, 0, &errtxt);
407	49	if (errno) {
408	1	VSB_cat(tl->sb, errtxt);
409	1	vcc_ErrToken(tl, tl->t);
410	1	vcc_ErrWhere(tl, tl->t);
411	1	return;
412		}
413	48	vcc_NextToken(tl);
414	48	*d = retval;
415	50	}
416
417		/--------------------------------------------------------------------/
418
419		int
420	111	vcc_IsFlagRaw(struct vcc tl, const struct token t1, const struct token *t2)
421		{
422
423	111	if (t1->tok != '-' && t1->tok != '+')
424	86	return (-1);
425	25	if (t2->b != t1->e) {
426	1	VSB_cat(tl->sb, "Expected a flag at:\n");
427	1	vcc_ErrWhere(tl, t1);
428	1	return (-1);
429		}
430	24	return (t1->tok == '+' ? 1 : 0);
431	111	}
432
433		int
434	60	vcc_IsFlag(struct vcc *tl)
435		{
436		struct token *t;
437		int retval;
438
439	60	t = vcc_PeekToken(tl);
440	60	if (t == NULL)
441	0	return (-1);
442	60	retval = vcc_IsFlagRaw(tl, tl->t, t);
443	60	if (retval >= 0)
444	18	vcc_NextToken(tl);
445	60	return (retval);
446	60	}
447
448		char *
449	714803	vcc_Dup_be(const char b, const char e)
450		{
451		char *p;
452
453	714803	AN(b);
454	714803	if (e == NULL)
455	0	e = strchr(b, '\0');
456	714803	AN(e);
457	714803	assert(e >= b);
458
459	714803	p = strndup(b, e - b);
460	714803	AN(p);
461	714803	return (p);
462		}
463
464		int
465	2466	vcc_Has_vcl_prefix(const char *b)
466		{
467	2256	return (
468	2466	(b[0] == 'v' \|\| b[0] == 'V') &&
469	213	(b[1] == 'c' \|\| b[1] == 'C') &&
470	2469	(b[2] == 'l' \|\| b[2] == 'L') &&
471	3	(b[3] == '_')
472		);
473		}