Code Coverage: vinyl-cache/lib/libvcc/vcc_utils.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
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
vcc_cstrcat(struct vcc *tl, struct vsb *vsb)
52 15324
{
53 15324
        struct token *t1;
54
55 15324
        assert(tl->t->tok == CSTR);
56 15324
        VSB_cat(vsb, tl->t->dec);
57
58 15324
        t1 = vcc_PeekToken(tl);
59 15324
        AN(t1);
60
61 15328
        while (t1->tok == '+') {
62 5
                vcc_NextToken(tl);
63 5
                SkipToken(tl, '+');
64 5
                ExpectErr(tl, CSTR);
65 4
                VSB_cat(vsb, tl->t->dec);
66 4
                t1 = vcc_PeekToken(tl);
67 4
                AN(t1);
68 4
        }
69 15324
}
70
71
void
72
vcc_regexp(struct vcc *tl, struct vsb *vgc_name)
73 15324
{
74 15324
        struct vsb *pattern;
75 15324
        struct token *t0;
76 15324
        char buf[BUFSIZ];
77 15324
        vre_t *t;
78 15324
        int error, erroroffset;
79 15324
        struct inifin *ifp;
80
81 15324
        t0 = tl->t;
82 15324
        pattern = VSB_new_auto();
83 15324
        AN(pattern);
84 15324
        vcc_cstrcat(tl, pattern);
85 15324
        AZ(VSB_finish(pattern));
86
87 15324
        t = VRE_compile(VSB_data(pattern), 0, &error, &erroroffset, 0);
88 15324
        if (t == NULL) {
89 2
                VSB_cat(tl->sb, "Regexp compilation error:\n\n");
90 2
                AZ(VRE_error(tl->sb, error));
91 2
                VSB_cat(tl->sb, "\n\n");
92 2
                vcc_ErrWhere2(tl, t0, tl->t);
93 2
                VSB_destroy(&pattern);
94 2
                return;
95 2
        }
96 15322
        VRE_free(&t);
97 15322
        bprintf(buf, "VGC_re_%u", tl->unique++);
98 15322
        if (vgc_name)
99 15322
                VSB_cat(vgc_name, buf);
100
101 15322
        Fh(tl, 0, "static struct vre *%s;\n", buf);
102 15322
        ifp = New_IniFin(tl);
103 15322
        VSB_printf(ifp->ini, "\tVPI_re_init(&%s, ",buf);
104 15322
        VSB_quote(ifp->ini, VSB_data(pattern), -1, VSB_QUOTE_CSTR);
105 15322
        VSB_cat(ifp->ini, ");");
106 15322
        VSB_printf(ifp->fin, "\t\tVPI_re_fini(%s);", buf);
107 15322
        VSB_destroy(&pattern);
108 15322
}
109
110
/*
111
 * The IPv6 crew royally screwed up the entire idea behind
112
 * struct sockaddr, see libvinyl/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
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 1445
{
130 1445
        char a[VTCP_ADDRBUFSIZE];
131 1445
        char p[VTCP_PORTBUFSIZE];
132 1445
        const int sz = sizeof(unsigned long long);
133 1445
        const unsigned n = (vsa_suckaddr_len + sz - 1) / sz;
134 1445
        unsigned long long b[n];
135 1445
        unsigned len;
136 1445
        char *q;
137
138 1445
        VTCP_name(vsa, a, sizeof a, p, sizeof p);
139 1445
        Fh(tl, 0, "\n/* \"%s\" -> %s */\n", host, a);
140 1445
        if (ip_ascii != NULL)
141 1418
                *ip_ascii = TlDup(tl, a);
142 1445
        if (p_ascii != NULL && *p_ascii == NULL)
143 1416
                *p_ascii = TlDup(tl, p);
144
145 1445
        Fh(tl, 0, "static const unsigned long long");
146 1445
        Fh(tl, 0, " suckaddr_%u[%d] = {\n", tl->unique, n);
147 1445
        vmemcpy(b, vsa, vsa_suckaddr_len);
148 7225
        for (len = 0; len < n; len++)
149 5780
                Fh(tl, 0, "%s    0x%0*llxULL",
150 5780
                    len ? ",\n" : "", sz * 2, b[len]);
151 1445
        Fh(tl, 0, "\n};\n");
152
153 1445
        q = TlAlloc(tl, 40);
154 1445
        AN(q);
155 1445
        assert(snprintf(q, 40, "(const void*)suckaddr_%u", tl->unique) < 40);
156 1445
        *ip = q;
157 1445
        tl->unique++;
158 1445
}
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
rs_callback(void *priv, const struct suckaddr *vsa)
184 1447
{
185 1447
        struct rss *rss;
186 1447
        int v;
187 1447
        char a[VTCP_ADDRBUFSIZE];
188 1447
        char p[VTCP_PORTBUFSIZE];
189
190 1447
        CAST_OBJ_NOTNULL(rss, priv, RSS_MAGIC);
191 1447
        assert(VSA_Sane(vsa));
192
193 1447
        v = VSA_Get_Proto(vsa);
194 1447
        assert(v != AF_UNIX);
195 1447
        VTCP_name(vsa, a, sizeof a, p, sizeof p);
196 1447
        VSB_printf(rss->vsb, "\t%s:%s\n", a, p);
197 1447
        if (v == AF_INET) {
198 1429
                if (rss->vsa4 == NULL)
199 1427
                        rss->vsa4 = VSA_Clone(vsa);
200 2
                else if (VSA_Compare(vsa, rss->vsa4))
201 2
                        rss->wrong++;
202 1429
                rss->retval++;
203 1429
        } else if (v == AF_INET6) {
204 18
                if (rss->vsa6 == NULL)
205 18
                        rss->vsa6 = VSA_Clone(vsa);
206 0
                else if (VSA_Compare(vsa, rss->vsa6))
207 0
                        rss->wrong++;
208 18
                rss->retval++;
209 18
        }
210 1447
        return (0);
211 1447
}
212
213
void
214
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 1447
{
226 1447
        int error;
227 1447
        struct rss rss[1];
228 1447
        const char *err;
229
230 1447
        *ipv4 = NULL;
231 1447
        *ipv6 = NULL;
232 1447
        if (p_ascii != NULL)
233 1418
                *p_ascii = NULL;
234
235 1447
        INIT_OBJ(rss, RSS_MAGIC);
236 1447
        rss->vsb = VSB_new_auto();
237 1447
        AN(rss->vsb);
238
239 1447
        error = VSS_resolver(host, def_port, rs_callback, rss, &err);
240 1447
        AZ(VSB_finish(rss->vsb));
241 1447
        if (err != NULL) {
242 4
                VSB_printf(tl->sb,
243 4
                    "%s '%.*s' could not be resolved to an IP address:\n"
244 4
                    "\t%s\n"
245 4
                    "(Sorry if that error message is gibberish.)\n",
246 4
                    errid, PF(t_err), err);
247 4
                vcc_ErrWhere(tl, t_err);
248 4
                if (rss->vsa4 != NULL)
249 0
                        VSA_free(&rss->vsa4);
250 4
                if (rss->vsa6 != NULL)
251 0
                        VSA_free(&rss->vsa6);
252 4
                VSB_destroy(&rss->vsb);
253 4
                ZERO_OBJ(rss, sizeof rss);
254 4
                return;
255 4
        }
256 1443
        AZ(error);
257 1443
        if (rss->vsa4 != NULL) {
258 1427
                vcc_suckaddr(tl, host, rss->vsa4, ipv4, ipv4_ascii, p_ascii);
259 1427
                VSA_free(&rss->vsa4);
260 1427
        }
261 1443
        if (rss->vsa6 != NULL) {
262 18
                vcc_suckaddr(tl, host, rss->vsa6, ipv6, ipv6_ascii, p_ascii);
263 18
                VSA_free(&rss->vsa6);
264 18
        }
265 1443
        if (rss->retval == 0) {
266 0
                VSB_printf(tl->sb,
267 0
                    "%s '%.*s': resolves to "
268 0
                    "neither IPv4 nor IPv6 addresses.\n",
269 0
                    errid, PF(t_err) );
270 0
                vcc_ErrWhere(tl, t_err);
271 0
        }
272 1443
        if (rss->wrong || rss->retval > maxips) {
273 1
                VSB_printf(tl->sb,
274 1
                    "%s %.*s: resolves to too many addresses.\n"
275 1
                    "Only one IPv4 %s IPv6 are allowed.\n"
276 1
                    "Please specify which exact address "
277 1
                    "you want to use, we found all of these:\n%s",
278 1
                    errid, PF(t_err),
279 1
                    maxips > 1 ? "and one" :  "or",
280 1
                    VSB_data(rss->vsb));
281 1
                vcc_ErrWhere(tl, t_err);
282 1
        }
283 1443
        VSB_destroy(&rss->vsb);
284 1443
        ZERO_OBJ(rss, sizeof rss);
285 1443
}
286
287
/*--------------------------------------------------------------------
288
* Recognize boolean const "true" or "false"
289
*/
290
291
uint8_t
292
vcc_BoolVal(struct vcc *tl)
293 4
{
294 4
        struct symbol* sym;
295
296 4
        if (tl->t->tok != ID) {
297 1
                VSB_cat(tl->sb, "Expected \"true\" or \"false\"\n");
298 1
                vcc_ErrWhere(tl, tl->t);
299 1
                return (0);
300 1
        }
301 3
        sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_NONE, SYMTAB_NOERR, XREF_NONE);
302 3
        if (sym == NULL || sym->type != BOOL) {
303 1
                VSB_cat(tl->sb, "Expected \"true\" or \"false\"\n");
304 1
                vcc_ErrWhere(tl, tl->t);
305 1
                return (0);
306 1
        }
307 2
        return (sym->eval_priv != NULL);
308 3
}
309
310
/*--------------------------------------------------------------------
311
 * Recognize and convert units of duration, return seconds.
312
 */
313
314
double
315
vcc_DurationUnit(struct vcc *tl)
316 3353
{
317 3353
        double sc;
318
319 3353
        assert(tl->t->tok == ID);
320 3353
        sc = VNUM_duration_unit(1.0, tl->t->b, tl->t->e);
321 3353
        if (!isnan(sc)) {
322 3352
                vcc_NextToken(tl);
323 3352
                return (sc);
324 3352
        }
325 1
        VSB_cat(tl->sb, "Unknown duration unit ");
326 1
        vcc_ErrToken(tl, tl->t);
327 1
        VSB_printf(tl->sb, "\n%s\n", VNUM_LEGAL_DURATION);
328 1
        vcc_ErrWhere(tl, tl->t);
329 1
        return (1.0);
330 3353
}
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
vcc_UintVal(struct vcc *tl)
339 225
{
340 225
        int64_t retval;
341
342 225
        if (tl->t->tok != CNUM) {
343 0
                Expect(tl, CNUM);
344 0
                return (0);
345 0
        }
346 225
        retval = (int64_t)round(tl->t->num);
347 225
        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 0
        }
352 225
        vcc_NextToken(tl);
353 225
        return (retval);
354 225
}
355
356
static double
357
vcc_DoubleVal(struct vcc *tl)
358 48
{
359 48
        double retval;
360
361 48
        if (tl->t->tok != CNUM && tl->t->tok != FNUM) {
362 1
                Expect(tl, CNUM);
363 1
                return (0);
364 1
        }
365 47
        retval = tl->t->num;
366 47
        vcc_NextToken(tl);
367 47
        return (retval);
368 48
}
369
370
/*--------------------------------------------------------------------*/
371
372
void
373
vcc_Duration(struct vcc *tl, double *d)
374 48
{
375 48
        double v, sc;
376
377 48
        v = vcc_DoubleVal(tl);
378 48
        ERRCHK(tl);
379 47
        ExpectErr(tl, ID);
380 47
        sc = vcc_DurationUnit(tl);
381 47
        *d = v * sc;
382 47
}
383
384
/*--------------------------------------------------------------------*/
385
386
void
387
vcc_ByteVal(struct vcc *tl, VCL_INT *d)
388 67
{
389 67
        double v;
390 67
        VCL_INT retval;
391 67
        const char *errtxt;
392
393 67
        if (tl->t->tok != CNUM && tl->t->tok != FNUM) {
394 0
                Expect(tl, CNUM);
395 0
                return;
396 0
        }
397 67
        v = tl->t->num;
398 67
        vcc_NextToken(tl);
399 67
        if (tl->t->tok != ID) {
400 1
                VSB_cat(tl->sb, "Expected BYTES unit (B, KB, MB...) got ");
401 1
                vcc_ErrToken(tl, tl->t);
402 1
                VSB_cat(tl->sb, "\n");
403 1
                vcc_ErrWhere(tl, tl->t);
404 1
                return;
405 1
        }
406 66
        retval = VNUM_bytes_unit(v, tl->t->b, tl->t->e, 0, &errtxt);
407 66
        if (errno) {
408 1
                VSB_cat(tl->sb, errtxt);
409 1
                vcc_ErrToken(tl, tl->t);
410 1
                vcc_ErrWhere(tl, tl->t);
411 1
                return;
412 1
        }
413 65
        vcc_NextToken(tl);
414 65
        *d = retval;
415 65
}
416
417
/*--------------------------------------------------------------------*/
418
419
int
420
vcc_IsFlagRaw(struct vcc *tl, const struct token *t1, const struct token *t2)
421 136
{
422
423 136
        if (t1->tok != '-' && t1->tok != '+')
424 96
                return (-1);
425 40
        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 2
        }
430 38
        return (t1->tok == '+' ? 1 : 0);
431 40
}
432
433
int
434
vcc_IsFlag(struct vcc *tl)
435 79
{
436 79
        struct token *t;
437 79
        int retval;
438
439 79
        t = vcc_PeekToken(tl);
440 79
        if (t == NULL)
441 0
                return (-1);
442 79
        retval = vcc_IsFlagRaw(tl, tl->t, t);
443 79
        if (retval >= 0)
444 31
                vcc_NextToken(tl);
445 79
        return (retval);
446 79
}
447
448
char *
449
vcc_Dup_be(const char *b, const char *e)
450 895488
{
451 895488
        char *p;
452
453 895488
        AN(b);
454 895488
        if (e == NULL)
455 0
                e = strchr(b, '\0');
456 895488
        AN(e);
457 895488
        assert(e >= b);
458
459 895488
        p = strndup(b, e - b);
460 895488
        AN(p);
461 895488
        return (p);
462 895488
}
463
464
int
465
vcc_Has_vcl_prefix(const char *b)
466 2638
{
467 2638
        return (
468 2638
            (b[0] == 'v' || b[0] == 'V') &&
469 2638
            (b[1] == 'c' || b[1] == 'C') &&
470 2638
            (b[2] == 'l' || b[2] == 'L') &&
471 2638
            (b[3] == '_')
472 2638
        );
473 2638
}