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