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 integertype, 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	204825	vcc_cstrcat(struct vcc tl, struct vsb vsb)
52		{
53		struct token *t1;
54
55	204825	assert(tl->t->tok == CSTR);
56	204825	VSB_cat(vsb, tl->t->dec);
57
58	204825	t1 = vcc_PeekToken(tl);
59	204825	AN(t1);
60
61	204925	while (t1->tok == '+') {
62	125	vcc_NextToken(tl);
63	125	SkipToken(tl, '+');
64	125	ExpectErr(tl, CSTR);
65	100	VSB_cat(vsb, tl->t->dec);
66	100	t1 = vcc_PeekToken(tl);
67	100	AN(t1);
68		}
69	204825	}
70
71		void
72	204825	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	204825	t0 = tl->t;
82	204825	pattern = VSB_new_auto();
83	204825	AN(pattern);
84	204825	vcc_cstrcat(tl, pattern);
85	204825	AZ(VSB_finish(pattern));
86
87	204825	t = VRE_compile(VSB_data(pattern), 0, &error, &erroroffset, 0);
88	204825	if (t == NULL) {
89	50	VSB_cat(tl->sb, "Regexp compilation error:\n\n");
90	50	AZ(VRE_error(tl->sb, error));
91	50	VSB_cat(tl->sb, "\n\n");
92	50	vcc_ErrWhere2(tl, t0, tl->t);
93	50	VSB_destroy(&pattern);
94	50	return;
95		}
96	204775	VRE_free(&t);
97	204775	bprintf(buf, "VGC_re_%u", tl->unique++);
98	204775	if (vgc_name)
99	204775	VSB_cat(vgc_name, buf);
100
101	204775	Fh(tl, 0, "static struct vre *%s;\n", buf);
102	204775	ifp = New_IniFin(tl);
103	204775	VSB_printf(ifp->ini, "\tVPI_re_init(&%s, ",buf);
104	204775	VSB_quote(ifp->ini, VSB_data(pattern), -1, VSB_QUOTE_CSTR);
105	204775	VSB_cat(ifp->ini, ");");
106	204775	VSB_printf(ifp->fin, "\t\tVPI_re_fini(%s);", buf);
107	204775	VSB_destroy(&pattern);
108	204825	}
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 integertype, hoping that this will ensure sufficient
123		* alignment.
124		*/
125
126		static void
127	33500	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	33500	const int sz = sizeof(unsigned long long);
133	33500	const unsigned n = (vsa_suckaddr_len + sz - 1) / sz;
134	33500	unsigned long long b[n];
135		unsigned len;
136		char *q;
137
138	33500	VTCP_name(vsa, a, sizeof a, p, sizeof p);
139	33500	Fh(tl, 0, "\n/* \"%s\" -> %s */\n", host, a);
140	33500	if (ip_ascii != NULL)
141	32825	*ip_ascii = TlDup(tl, a);
142	33500	if (p_ascii != NULL && *p_ascii == NULL)
143	32650	*p_ascii = TlDup(tl, p);
144
145	33500	Fh(tl, 0, "static const unsigned long long");
146	33500	Fh(tl, 0, " suckaddr_%u[%d] = {\n", tl->unique, n);
147	33500	memcpy(b, vsa, vsa_suckaddr_len);
148	167500	for (len = 0; len < n; len++)
149	268000	Fh(tl, 0, "%s 0x%0*llxULL",
150	134000	len ? ",\n" : "", sz * 2, b[len]);
151	33500	Fh(tl, 0, "\n};\n");
152
153	33500	q = TlAlloc(tl, 40);
154	33500	AN(q);
155	33500	assert(snprintf(q, 40, "(const void*)suckaddr_%u", tl->unique) < 40);
156	33500	*ip = q;
157	33500	tl->unique++;
158	33500	}
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	33550	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	33550	CAST_OBJ_NOTNULL(rss, priv, RSS_MAGIC);
191	33550	assert(VSA_Sane(vsa));
192
193	33550	v = VSA_Get_Proto(vsa);
194	33550	assert(v != AF_UNIX);
195	33550	VTCP_name(vsa, a, sizeof a, p, sizeof p);
196	33550	VSB_printf(rss->vsb, "\t%s:%s\n", a, p);
197	33550	if (v == AF_INET) {
198	33025	if (rss->vsa4 == NULL)
199	32975	rss->vsa4 = VSA_Clone(vsa);
200	50	else if (VSA_Compare(vsa, rss->vsa4))
201	50	rss->wrong++;
202	33025	rss->retval++;
203	33550	} else if (v == AF_INET6) {
204	525	if (rss->vsa6 == NULL)
205	525	rss->vsa6 = VSA_Clone(vsa);
206	0	else if (VSA_Compare(vsa, rss->vsa6))
207	0	rss->wrong++;
208	525	rss->retval++;
209	525	}
210	33550	return (0);
211		}
212
213		void
214	33425	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	33425	*ipv4 = NULL;
231	33425	*ipv6 = NULL;
232	33425	if (p_ascii != NULL)
233	32700	*p_ascii = NULL;
234
235	33425	INIT_OBJ(rss, RSS_MAGIC);
236	33425	rss->vsb = VSB_new_auto();
237	33425	AN(rss->vsb);
238
239	33425	error = VSS_resolver(host, def_port, rs_callback, rss, &err);
240	33425	AZ(VSB_finish(rss->vsb));
241	33425	if (err != NULL) {
242	200	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	100	errid, PF(t_err), err);
247	100	vcc_ErrWhere(tl, t_err);
248	100	if (rss->vsa4 != NULL)
249	0	VSA_free(&rss->vsa4);
250	100	if (rss->vsa6 != NULL)
251	0	VSA_free(&rss->vsa6);
252	100	VSB_destroy(&rss->vsb);
253	100	ZERO_OBJ(rss, sizeof rss);
254	100	return;
255		}
256	33325	AZ(error);
257	33325	if (rss->vsa4 != NULL) {
258	32975	vcc_suckaddr(tl, host, rss->vsa4, ipv4, ipv4_ascii, p_ascii);
259	32975	VSA_free(&rss->vsa4);
260	32975	}
261	33325	if (rss->vsa6 != NULL) {
262	525	vcc_suckaddr(tl, host, rss->vsa6, ipv6, ipv6_ascii, p_ascii);
263	525	VSA_free(&rss->vsa6);
264	525	}
265	33325	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	33325	if (rss->wrong \|\| rss->retval > maxips) {
273	50	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	25	errid, PF(t_err),
279	25	maxips > 1 ? "and one" : "or",
280	25	VSB_data(rss->vsb));
281	25	vcc_ErrWhere(tl, t_err);
282	25	}
283	33325	VSB_destroy(&rss->vsb);
284	33325	ZERO_OBJ(rss, sizeof rss);
285	33425	}
286
287		/*--------------------------------------------------------------------
288		* Recognize boolean const "true" or "false"
289		*/
290
291		uint8_t
292	100	vcc_BoolVal(struct vcc *tl)
293		{
294		struct symbol* sym;
295
296	100	if (tl->t->tok != ID) {
297	25	VSB_cat(tl->sb, "Expected \"true\" or \"false\"\n");
298	25	vcc_ErrWhere(tl, tl->t);
299	25	return (0);
300		}
301	75	sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_NONE, SYMTAB_NOERR, XREF_NONE);
302	75	if (sym == NULL \|\| sym->type != BOOL) {
303	25	VSB_cat(tl->sb, "Expected \"true\" or \"false\"\n");
304	25	vcc_ErrWhere(tl, tl->t);
305	25	return (0);
306		}
307	50	return (sym->eval_priv != NULL);
308	100	}
309
310		/*--------------------------------------------------------------------
311		* Recognize and convert units of duration, return seconds.
312		*/
313
314		double
315	140700	vcc_DurationUnit(struct vcc *tl)
316		{
317		double sc;
318
319	140700	assert(tl->t->tok == ID);
320	140700	sc = VNUM_duration_unit(1.0, tl->t->b, tl->t->e);
321	140700	if (!isnan(sc)) {
322	140675	vcc_NextToken(tl);
323	140675	return (sc);
324		}
325	25	VSB_cat(tl->sb, "Unknown duration unit ");
326	25	vcc_ErrToken(tl, tl->t);
327	25	VSB_printf(tl->sb, "\n%s\n", VNUM_LEGAL_DURATION);
328	25	vcc_ErrWhere(tl, tl->t);
329	25	return (1.0);
330	140700	}
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	4975	vcc_UintVal(struct vcc *tl)
339		{
340		int64_t retval;
341
342	4975	if (tl->t->tok != CNUM) {
343	0	Expect(tl, CNUM);
344	0	return (0);
345		}
346	4975	retval = (int64_t)round(tl->t->num);
347	4975	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	4975	vcc_NextToken(tl);
353	4975	return (retval);
354	4975	}
355
356		static double
357	925	vcc_DoubleVal(struct vcc *tl)
358		{
359		double retval;
360
361	925	if (tl->t->tok != CNUM && tl->t->tok != FNUM) {
362	25	Expect(tl, CNUM);
363	25	return (0);
364		}
365	900	retval = tl->t->num;
366	900	vcc_NextToken(tl);
367	900	return (retval);
368	925	}
369
370		/--------------------------------------------------------------------/
371
372		void
373	925	vcc_Duration(struct vcc tl, double d)
374		{
375		double v, sc;
376
377	925	v = vcc_DoubleVal(tl);
378	925	ERRCHK(tl);
379	900	ExpectErr(tl, ID);
380	900	sc = vcc_DurationUnit(tl);
381	900	d = v sc;
382	925	}
383
384		/--------------------------------------------------------------------/
385
386		void
387	1175	vcc_ByteVal(struct vcc tl, VCL_INT d)
388		{
389		double v;
390		VCL_INT retval;
391		const char *errtxt;
392
393	1175	if (tl->t->tok != CNUM && tl->t->tok != FNUM) {
394	0	Expect(tl, CNUM);
395	0	return;
396		}
397	1175	v = tl->t->num;
398	1175	vcc_NextToken(tl);
399	1175	if (tl->t->tok != ID) {
400	25	VSB_cat(tl->sb, "Expected BYTES unit (B, KB, MB...) got ");
401	25	vcc_ErrToken(tl, tl->t);
402	25	VSB_cat(tl->sb, "\n");
403	25	vcc_ErrWhere(tl, tl->t);
404	25	return;
405		}
406	1150	retval = VNUM_bytes_unit(v, tl->t->b, tl->t->e, 0, &errtxt);
407	1150	if (errno) {
408	25	VSB_cat(tl->sb, errtxt);
409	25	vcc_ErrToken(tl, tl->t);
410	25	vcc_ErrWhere(tl, tl->t);
411	25	return;
412		}
413	1125	vcc_NextToken(tl);
414	1125	*d = retval;
415	1175	}
416
417		/--------------------------------------------------------------------/
418
419		int
420	2600	vcc_IsFlagRaw(struct vcc tl, const struct token t1, const struct token *t2)
421		{
422
423	2600	if (t1->tok != '-' && t1->tok != '+')
424	2050	return (-1);
425	550	if (t2->b != t1->e) {
426	25	VSB_cat(tl->sb, "Expected a flag at:\n");
427	25	vcc_ErrWhere(tl, t1);
428	25	return (-1);
429		}
430	525	return (t1->tok == '+' ? 1 : 0);
431	2600	}
432
433		int
434	1375	vcc_IsFlag(struct vcc *tl)
435		{
436		struct token *t;
437		int retval;
438
439	1375	t = vcc_PeekToken(tl);
440	1375	if (t == NULL)
441	0	return (-1);
442	1375	retval = vcc_IsFlagRaw(tl, tl->t, t);
443	1375	if (retval >= 0)
444	400	vcc_NextToken(tl);
445	1375	return (retval);
446	1375	}
447
448		char *
449	15219425	vcc_Dup_be(const char b, const char e)
450		{
451		char *p;
452
453	15219425	AN(b);
454	15219425	if (e == NULL)
455	0	e = strchr(b, '\0');
456	15219425	AN(e);
457	15219425	assert(e >= b);
458
459	15219425	p = strndup(b, e - b);
460	15219425	AN(p);
461	15219425	return (p);
462		}
463
464		int
465	59275	vcc_Has_vcl_prefix(const char *b)
466		{
467	54275	return (
468	59275	(b[0] == 'v' \|\| b[0] == 'V') &&
469	5075	(b[1] == 'c' \|\| b[1] == 'C') &&
470	59350	(b[2] == 'l' \|\| b[2] == 'L') &&
471	75	(b[3] == '_')
472		);
473		}