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