varnish-cache/bin/varnishtest/vtc.c
0
/*-
1
 * Copyright (c) 2008-2011 Varnish Software AS
2
 * All rights reserved.
3
 *
4
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
5
 *
6
 * SPDX-License-Identifier: BSD-2-Clause
7
 *
8
 * Redistribution and use in source and binary forms, with or without
9
 * modification, are permitted provided that the following conditions
10
 * are met:
11
 * 1. Redistributions of source code must retain the above copyright
12
 *    notice, this list of conditions and the following disclaimer.
13
 * 2. Redistributions in binary form must reproduce the above copyright
14
 *    notice, this list of conditions and the following disclaimer in the
15
 *    documentation and/or other materials provided with the distribution.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
 * SUCH DAMAGE.
28
 */
29
30
#include "config.h"
31
32
#include <sys/wait.h>
33
34
#include <ctype.h>
35
#include <stdarg.h>
36
#include <stdio.h>
37
#include <stdlib.h>
38
#include <string.h>
39
#include <unistd.h>
40
41
#include "vtc.h"
42
#include "vtc_log.h"
43
44
#include "vav.h"
45
#include "vrnd.h"
46
47
#define         MAX_TOKENS              200
48
49
volatile sig_atomic_t   vtc_error;      /* Error encountered */
50
int                     vtc_stop;       /* Stops current test without error */
51
pthread_t               vtc_thread;
52
int                     ign_unknown_macro = 0;
53
static struct vtclog    *vltop;
54
55
static pthread_mutex_t  vtc_vrnd_mtx;
56
57
static void
58 103200
vtc_vrnd_lock(void)
59
{
60 103200
        PTOK(pthread_mutex_lock(&vtc_vrnd_mtx));
61 103200
}
62
63
static void
64 103200
vtc_vrnd_unlock(void)
65
{
66 103200
        PTOK(pthread_mutex_unlock(&vtc_vrnd_mtx));
67 103200
}
68
69
static const char *tfn;
70
71
/**********************************************************************
72
 * Macro facility
73
 */
74
75
struct macro {
76
        unsigned                magic;
77
#define MACRO_MAGIC             0x803423e3
78
        VTAILQ_ENTRY(macro)     list;
79
        char                    *name;
80
        char                    *val;
81
        macro_f                 *func;
82
};
83
84
static VTAILQ_HEAD(,macro) macro_list = VTAILQ_HEAD_INITIALIZER(macro_list);
85
86
static const struct cmds global_cmds[] = {
87
#define CMD_GLOBAL(n) { #n, cmd_##n },
88
#include "cmds.h"
89
        { NULL, NULL }
90
};
91
92
static const struct cmds top_cmds[] = {
93
#define CMD_TOP(n) { #n, cmd_##n },
94
#include "cmds.h"
95
        { NULL, NULL }
96
};
97
98
/**********************************************************************/
99
100
static struct macro *
101 604750
macro_def_int(const char *name, macro_f *func, const char *fmt, va_list ap)
102
{
103
        struct macro *m;
104
        char buf[2048];
105
106 8091625
        VTAILQ_FOREACH(m, &macro_list, list)
107 7498200
                if (!strcmp(name, m->name))
108 11325
                        break;
109 604750
        if (m == NULL) {
110 593425
                ALLOC_OBJ(m, MACRO_MAGIC);
111 593425
                AN(m);
112 593425
                REPLACE(m->name, name);
113 593425
                AN(m->name);
114 593425
                VTAILQ_INSERT_TAIL(&macro_list, m, list);
115 593425
        }
116 604750
        AN(m);
117 604750
        if (func != NULL) {
118 47750
                AZ(fmt);
119 47750
                m->func = func;
120 47750
        } else {
121 557000
                AN(fmt);
122 557000
                vbprintf(buf, fmt, ap);
123 557000
                REPLACE(m->val, buf);
124 557000
                AN(m->val);
125
        }
126 604750
        return (m);
127
}
128
129
130
/**********************************************************************
131
 * This is for defining macros before we fork the child process which
132
 * runs the test-case.
133
 */
134
135
void
136 260925
extmacro_def(const char *name, macro_f *func, const char *fmt, ...)
137
{
138
        va_list ap;
139
140 260925
        va_start(ap, fmt);
141 260925
        (void)macro_def_int(name, func, fmt, ap);
142 260925
        va_end(ap);
143 260925
}
144
145
/**********************************************************************
146
 * Below this point is run inside the testing child-process.
147
 */
148
149
static pthread_mutex_t          macro_mtx;
150
151
static void
152 24425
init_macro(void)
153
{
154
        struct macro *m;
155
156
        /* Dump the extmacros for completeness */
157 292250
        VTAILQ_FOREACH(m, &macro_list, list) {
158 267825
                if (m->val != NULL)
159 437950
                        vtc_log(vltop, 4,
160 218975
                            "extmacro def %s=%s", m->name, m->val);
161
                else
162 48850
                        vtc_log(vltop, 4, "extmacro def %s(...)", m->name);
163 267825
        }
164
165 24425
        PTOK(pthread_mutex_init(&macro_mtx, NULL));
166 24425
}
167
168
void
169 343825
macro_def(struct vtclog *vl, const char *instance, const char *name,
170
    const char *fmt, ...)
171
{
172
        char buf1[256];
173
        struct macro *m;
174
        va_list ap;
175
176 343825
        AN(fmt);
177
178 343825
        if (instance != NULL) {
179 270550
                bprintf(buf1, "%s_%s", instance, name);
180 270550
                name = buf1;
181 270550
        }
182
183 343825
        PTOK(pthread_mutex_lock(&macro_mtx));
184 343825
        va_start(ap, fmt);
185 343825
        m = macro_def_int(name, NULL, fmt, ap);
186 343825
        va_end(ap);
187 343825
        vtc_log(vl, 4, "macro def %s=%s", name, m->val);
188 343825
        PTOK(pthread_mutex_unlock(&macro_mtx));
189 343825
}
190
191
void
192 86539
macro_undef(struct vtclog *vl, const char *instance, const char *name)
193
{
194
        char buf1[256];
195
        struct macro *m;
196
197 86539
        if (instance != NULL) {
198 86538
                bprintf(buf1, "%s_%s", instance, name);
199 86538
                name = buf1;
200 86538
        }
201
202 86539
        PTOK(pthread_mutex_lock(&macro_mtx));
203 1400004
        VTAILQ_FOREACH(m, &macro_list, list)
204 1395090
                if (!strcmp(name, m->name))
205 81625
                        break;
206 86539
        if (m != NULL) {
207 81625
                if (!vtc_stop)
208 4325
                        vtc_log(vl, 4, "macro undef %s", name);
209 81625
                CHECK_OBJ(m, MACRO_MAGIC);
210 81625
                VTAILQ_REMOVE(&macro_list, m, list);
211 81625
                free(m->name);
212 81625
                free(m->val);
213 81625
                FREE_OBJ(m);
214 81625
        }
215 86539
        PTOK(pthread_mutex_unlock(&macro_mtx));
216 86539
}
217
218
unsigned
219 45250
macro_isdef(const char *instance, const char *name)
220
{
221
        char buf1[256];
222
        struct macro *m;
223
224 45250
        if (instance != NULL) {
225 0
                bprintf(buf1, "%s_%s", instance, name);
226 0
                name = buf1;
227 0
        }
228
229 45250
        PTOK(pthread_mutex_lock(&macro_mtx));
230 830350
        VTAILQ_FOREACH(m, &macro_list, list)
231 785100
                if (!strcmp(name, m->name))
232 0
                        break;
233 45250
        PTOK(pthread_mutex_unlock(&macro_mtx));
234
235 45250
        return (m != NULL);
236
}
237
238
void
239 282300
macro_cat(struct vtclog *vl, struct vsb *vsb, const char *b, const char *e)
240
{
241
        struct macro *m;
242 282300
        char **argv, *retval = NULL;
243 282300
        const char *err = NULL;
244
        int argc;
245
246 282300
        AN(b);
247 282300
        if (e == NULL)
248 149560
                e = strchr(b, '\0');
249 282300
        AN(e);
250
251 282300
        argv = VAV_ParseTxt(b, e, &argc, ARGV_COMMA);
252 282300
        AN(argv);
253
254 282300
        if (*argv != NULL)
255 0
                vtc_fatal(vl, "Macro ${%.*s} parsing failed: %s",
256 0
                    (int)(e - b), b, *argv);
257
258 282300
        assert(argc >= 2);
259
260 282300
        PTOK(pthread_mutex_lock(&macro_mtx));
261 2623650
        VTAILQ_FOREACH(m, &macro_list, list) {
262 2622400
                CHECK_OBJ_NOTNULL(m, MACRO_MAGIC);
263 2622400
                if (!strcmp(argv[1], m->name))
264 281050
                        break;
265 2341350
        }
266 282300
        if (m != NULL) {
267 281050
                if (m->func != NULL) {
268 52850
                        AZ(m->val);
269 52850
                        retval = m->func(argc, argv, &err);
270 52850
                        if (err == NULL)
271 52850
                                AN(retval);
272 52850
                } else {
273 228200
                        AN(m->val);
274 228200
                        if (argc == 2)
275 228200
                                REPLACE(retval, m->val);
276
                        else
277 0
                                err = "macro does not take arguments";
278
                }
279 281050
        }
280 282300
        PTOK(pthread_mutex_unlock(&macro_mtx));
281
282 282300
        VAV_Free(argv);
283
284 282300
        if (err != NULL)
285 0
                vtc_fatal(vl, "Macro ${%.*s} failed: %s",
286 0
                    (int)(e - b), b, err);
287
288 282300
        if (retval == NULL) {
289 1250
                if (!ign_unknown_macro)
290 0
                        vtc_fatal(vl, "Macro ${%.*s} not found",
291 0
                            (int)(e - b), b);
292 1250
                VSB_printf(vsb, "${%.*s}", (int)(e - b), b);
293 1250
                return;
294
        }
295
296 281050
        VSB_cat(vsb, retval);
297 281050
        free(retval);
298 282300
}
299
300
struct vsb *
301 33723
macro_expandf(struct vtclog *vl, const char *fmt, ...)
302
{
303
        va_list ap;
304
        struct vsb *vsb1, *vsb2;
305
306 33723
        vsb1 = VSB_new_auto();
307 33723
        AN(vsb1);
308 33723
        va_start(ap, fmt);
309 33723
        VSB_vprintf(vsb1, fmt, ap);
310 33723
        va_end(ap);
311 33723
        AZ(VSB_finish(vsb1));
312 33723
        vsb2 = macro_expand(vl, VSB_data(vsb1));
313 33723
        VSB_destroy(&vsb1);
314 33723
        return (vsb2);
315
}
316
317
struct vsb *
318 126675
macro_expand(struct vtclog *vl, const char *text)
319
{
320
        struct vsb *vsb;
321
        const char *p, *q;
322
323 126675
        vsb = VSB_new_auto();
324 126675
        AN(vsb);
325 259398
        while (*text != '\0') {
326 214798
                p = strstr(text, "${");
327 214798
                if (p == NULL) {
328 82075
                        VSB_cat(vsb, text);
329 82075
                        break;
330
                }
331 132723
                VSB_bcat(vsb, text, p - text);
332 132723
                q = strchr(p, '}');
333 132723
                if (q == NULL) {
334 0
                        VSB_cat(vsb, text);
335 0
                        break;
336
                }
337 132723
                assert(p[0] == '$');
338 132723
                assert(p[1] == '{');
339 132723
                assert(q[0] == '}');
340 132723
                p += 2;
341 132723
                macro_cat(vl, vsb, p, q);
342 132723
                text = q + 1;
343
        }
344 126675
        AZ(VSB_finish(vsb));
345 126675
        return (vsb);
346
}
347
348
/**********************************************************************
349
 * Parse a string
350
 *
351
 * We make a copy of the string and deliberately leak it, so that all
352
 * the cmd functions we call don't have to strdup(3) all over the place.
353
 *
354
 * Static checkers like Coverity may bitch about this, but we don't care.
355
 */
356
357
358
void
359 164706
parse_string(struct vtclog *vl, void *priv, const char *spec)
360
{
361
        char *token_s[MAX_TOKENS], *token_e[MAX_TOKENS];
362
        struct vsb *token_exp;
363
        char *e, *p, *q, *f, *buf;
364
        int nest_brace;
365
        int tn;
366
        unsigned n, m;
367
        const struct cmds *cp;
368
369 164706
        AN(spec);
370 164706
        buf = strdup(spec);
371 164706
        AN(buf);
372 164706
        e = strchr(buf, '\0');
373 164706
        AN(e);
374 2260033
        for (p = buf; p < e; p++) {
375 2096075
                if (vtc_error || vtc_stop)
376 748
                        break;
377
                /* Start of line */
378 2095327
                if (isspace(*p))
379 1180253
                        continue;
380 915074
                if (*p == '\n')
381 0
                        continue;
382
383 915074
                if (*p == '#') {
384 2121225
                        for (; *p != '\0' && *p != '\n'; p++)
385
                                ;
386 51275
                        if (*p == '\0')
387 0
                                break;
388 51275
                        continue;
389
                }
390
391 863799
                q = strchr(p, '\n');
392 863799
                if (q == NULL)
393 9172
                        q = strchr(p, '\0');
394 863799
                if (q - p > 60)
395 46913
                        vtc_log(vl, 2, "=== %.60s...", p);
396
                else
397 816886
                        vtc_log(vl, 2, "=== %.*s", (int)(q - p), p);
398
399
                /* First content on line, collect tokens */
400 863799
                memset(token_s, 0, sizeof token_s);
401 863799
                memset(token_e, 0, sizeof token_e);
402 863799
                tn = 0;
403 863799
                f = p;
404 5751535
                while (p < e) {
405 5742578
                        assert(tn < MAX_TOKENS);
406 5742578
                        assert(p < e);
407 5742578
                        if (*p == '\n') { /* End on NL */
408 854842
                                break;
409
                        }
410 4887736
                        if (isspace(*p)) { /* Inter-token whitespace */
411 2069305
                                p++;
412 2069305
                                continue;
413
                        }
414 2818431
                        if (*p == '\\' && p[1] == '\n') { /* line-cont */
415 22475
                                p += 2;
416 22475
                                continue;
417
                        }
418 2795956
                        if (*p == '"') { /* quotes */
419 281751
                                token_s[tn] = ++p;
420 281751
                                q = p;
421 6849400
                                for (; *p != '\0'; p++) {
422 6849001
                                        assert(p < e);
423 6849001
                                        if (*p == '"')
424 281352
                                                break;
425 6567649
                                        if (*p == '\\') {
426 68866
                                                p += VAV_BackSlash(p, q) - 1;
427 68866
                                                q++;
428 68866
                                        } else {
429 6498783
                                                if (*p == '\n')
430 0
                                                        vtc_fatal(vl,
431
                                "Unterminated quoted string in line: %*.*s",
432 0
                                (int)(p - f), (int)(p - f), f);
433 6498783
                                                assert(*p != '\n');
434 6498783
                                                *q++ = *p;
435
                                        }
436 6567649
                                }
437 281751
                                token_e[tn++] = q;
438 281751
                                p++;
439 2795956
                        } else if (*p == '{') { /* Braces */
440 184128
                                nest_brace = 0;
441 184128
                                token_s[tn] = p + 1;
442 29508035
                                for (; p < e; p++) {
443 29508035
                                        if (*p == '{')
444 336301
                                                nest_brace++;
445 29171734
                                        else if (*p == '}') {
446 336303
                                                if (--nest_brace == 0)
447 184128
                                                        break;
448 152175
                                        }
449 29323907
                                }
450 184128
                                assert(*p == '}');
451 184128
                                token_e[tn++] = p++;
452 184128
                        } else { /* other tokens */
453 2330077
                                token_s[tn] = p;
454 15303776
                                for (; p < e && !isspace(*p); p++)
455 12973699
                                        continue;
456 2330077
                                token_e[tn++] = p;
457
                        }
458
                }
459
460 863799
                assert(p <= e);
461 863799
                assert(tn < MAX_TOKENS);
462 863799
                token_s[tn] = NULL;
463 3659854
                for (tn = 0; token_s[tn] != NULL; tn++) {
464 2796055
                        AN(token_e[tn]);        /*lint !e771 */
465 2796055
                        *token_e[tn] = '\0';    /*lint !e771 */
466 2796055
                        if (NULL != strstr(token_s[tn], "${")) {
467 25550
                                token_exp = macro_expand(vl, token_s[tn]);
468 25550
                                if (vtc_error)
469 0
                                        return;
470 25550
                                token_s[tn] = VSB_data(token_exp);
471 25550
                                token_e[tn] = strchr(token_s[tn], '\0');
472 25550
                        }
473 2796055
                }
474
475
476
/* SECTION: loop loop
477
 *
478
 * loop NUMBER STRING
479
 *         Process STRING as a specification, NUMBER times.
480
 *
481
 * This works inside all specification strings
482
 */
483
484 863799
                if (!strcmp(token_s[0], "loop")) {
485 1036
                        n = strtoul(token_s[1], NULL, 0);
486 19749
                        for (m = 0; m < n; m++) {
487 18713
                                vtc_log(vl, 4, "Loop #%u", m);
488 18713
                                parse_string(vl, priv, token_s[2]);
489 18713
                        }
490 1036
                        continue;
491
                }
492
493 862763
                AN(vl->cmds);
494 14756625
                for (cp = vl->cmds; cp->name != NULL; cp++)
495 14714812
                        if (!strcmp(token_s[0], cp->name))
496 820950
                                break;
497
498 862763
                if (cp->name == NULL) {
499 78989
                        for (cp = global_cmds; cp->name != NULL; cp++)
500 78989
                                if (!strcmp(token_s[0], cp->name))
501 41819
                                        break;
502 41819
                }
503
504 862763
                if (cp->name == NULL)
505 0
                        vtc_fatal(vl, "Unknown command: \"%s\"", token_s[0]);
506
507 862763
                assert(cp->cmd != NULL);
508 862763
                cp->cmd(token_s, priv, vl);
509 862763
        }
510 164226
}
511
512
/**********************************************************************
513
 * Reset commands (between tests)
514
 */
515
516
static void
517 48850
reset_cmds(const struct cmds *cmd)
518
{
519
520 464075
        for (; cmd->name != NULL; cmd++)
521 415225
                cmd->cmd(NULL, NULL, NULL);
522 48850
}
523
524
/**********************************************************************
525
 * Execute a file
526
 */
527
528
int
529 24425
fail_out(void)
530
{
531
        unsigned old_err;
532
        static int once = 0;
533
534 24425
        if (once++) {
535 0
                vtc_log(vltop, 1, "failure during reset");
536 0
                return (vtc_error);
537
        }
538 24425
        old_err = vtc_error;
539 24425
        if (!vtc_stop)
540 24125
                vtc_stop = 1;
541 24425
        vtc_log(vltop, 1, "RESETTING after %s", tfn);
542 24425
        reset_cmds(global_cmds);
543 24425
        reset_cmds(top_cmds);
544 24425
        vtc_error |= old_err;
545
546 24425
        if (vtc_error)
547 50
                vtc_log(vltop, 1, "TEST %s FAILED", tfn);
548
        else
549 24375
                vtc_log(vltop, 1, "TEST %s completed", tfn);
550
551 24425
        if (vtc_stop > 1)
552 300
                return (1);
553 24125
        return (vtc_error);
554 24425
}
555
556
int
557 24425
exec_file(const char *fn, const char *script, const char *tmpdir,
558
    char *logbuf, unsigned loglen)
559
{
560
        FILE *f;
561
        struct vsb *vsb;
562
        const char *p;
563
564 24425
        (void)signal(SIGPIPE, SIG_IGN);
565
566 24425
        PTOK(pthread_mutex_init(&vtc_vrnd_mtx, NULL));
567 24425
        VRND_Lock = vtc_vrnd_lock;
568 24425
        VRND_Unlock = vtc_vrnd_unlock;
569 24425
        VRND_SeedAll();
570
571 24425
        tfn = fn;
572 24425
        vtc_loginit(logbuf, loglen);
573 24425
        vltop = vtc_logopen("top");
574 24425
        AN(vltop);
575 24425
        vtc_log_set_cmd(vltop, top_cmds);
576
577 24425
        vtc_log(vltop, 1, "TEST %s starting", fn);
578
579 24425
        init_macro();
580 24425
        init_server();
581 24425
        init_syslog();
582 24425
        init_tunnel();
583
584 24425
        vsb = VSB_new_auto();
585 24425
        AN(vsb);
586 24425
        if (*fn != '/')
587 24175
                macro_cat(vltop, vsb, "pwd", NULL);
588 24425
        p = strrchr(fn, '/');
589 24425
        if (p != NULL) {
590 24225
                VSB_putc(vsb, '/');
591 24225
                VSB_bcat(vsb, fn, p - fn);
592 24225
        }
593 24425
        if (VSB_len(vsb) == 0)
594 0
                VSB_putc(vsb, '/');
595 24425
        AZ(VSB_finish(vsb));
596 24425
        macro_def(vltop, NULL, "testdir", "%s", VSB_data(vsb));
597 24425
        VSB_destroy(&vsb);
598
599
        /* Move into our tmpdir */
600 24425
        AZ(chdir(tmpdir));
601 24425
        macro_def(vltop, NULL, "tmpdir", "%s", tmpdir);
602 24425
        p = strrchr(tmpdir, '/');
603 24425
        AN(p);
604 24425
        p++;
605 24425
        AN(*p);
606 24425
        macro_def(vltop, NULL, "vtcid", "%s", p);
607
608
        /* Drop file to tell what was going on here */
609 24425
        f = fopen("INFO", "w");
610 24425
        AN(f);
611 24425
        fprintf(f, "Test case: %s\n", fn);
612 24425
        AZ(fclose(f));
613
614 24425
        vtc_stop = 0;
615
616 24425
        vtc_thread = pthread_self();
617 24425
        parse_string(vltop, NULL, script);
618 24425
        return (fail_out());
619
}