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