GCOV - Varnish Cache


/*-
 * Copyright (c) 2008-2011 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 <sys/wait.h>

#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "vtc.h"
#include "vtc_log.h"

#include "vav.h"
#include "vrnd.h"

#define         MAX_TOKENS              200

volatile sig_atomic_t   vtc_error;      /* Error encountered */
int                     vtc_stop;       /* Stops current test without error */
pthread_t               vtc_thread;
int                     ign_unknown_macro = 0;
static struct vtclog    *vltop;

static pthread_mutex_t  vtc_vrnd_mtx;

static void
vtc_vrnd_lock(void)
{
        PTOK(pthread_mutex_lock(&vtc_vrnd_mtx));
}

static void
vtc_vrnd_unlock(void)
{
        PTOK(pthread_mutex_unlock(&vtc_vrnd_mtx));
}

static const char *tfn;

/**********************************************************************
 * Macro facility
 */

struct macro {
        unsigned                magic;
#define MACRO_MAGIC             0x803423e3
        VTAILQ_ENTRY(macro)     list;
        char                    *name;
        char                    *val;
        macro_f                 *func;
};

static VTAILQ_HEAD(,macro) macro_list = VTAILQ_HEAD_INITIALIZER(macro_list);

static const struct cmds global_cmds[] = {
#define CMD_GLOBAL(n) { #n, cmd_##n },
#include "cmds.h"
        { NULL, NULL }
};

static const struct cmds top_cmds[] = {
#define CMD_TOP(n) { #n, cmd_##n },
#include "cmds.h"
        { NULL, NULL }
};

/**********************************************************************/

static struct macro *
macro_def_int(const char *name, macro_f *func, const char *fmt, va_list ap)
{
        struct macro *m;
        char buf[2048];

        VTAILQ_FOREACH(m, &macro_list, list)
                if (!strcmp(name, m->name))
                        break;
        if (m == NULL) {
                ALLOC_OBJ(m, MACRO_MAGIC);
                AN(m);
                REPLACE(m->name, name);
                AN(m->name);
                VTAILQ_INSERT_TAIL(&macro_list, m, list);
        }
        AN(m);
        if (func != NULL) {
                AZ(fmt);
                m->func = func;
        } else {
                AN(fmt);
                vbprintf(buf, fmt, ap);
                REPLACE(m->val, buf);
                AN(m->val);
        }
        return (m);
}


/**********************************************************************
 * This is for defining macros before we fork the child process which
 * runs the test-case.
 */

void
extmacro_def(const char *name, macro_f *func, const char *fmt, ...)
{
        va_list ap;

        va_start(ap, fmt);
        (void)macro_def_int(name, func, fmt, ap);
        va_end(ap);
}

/**********************************************************************
 * Below this point is run inside the testing child-process.
 */

static pthread_mutex_t          macro_mtx;

static void
init_macro(void)
{
        struct macro *m;

        /* Dump the extmacros for completeness */
        VTAILQ_FOREACH(m, &macro_list, list) {
                if (m->val != NULL)
                        vtc_log(vltop, 4,
                            "extmacro def %s=%s", m->name, m->val);
                else
                        vtc_log(vltop, 4, "extmacro def %s(...)", m->name);
        }

        PTOK(pthread_mutex_init(&macro_mtx, NULL));
}

void
macro_def(struct vtclog *vl, const char *instance, const char *name,
    const char *fmt, ...)
{
        char buf1[256];
        struct macro *m;
        va_list ap;

        AN(fmt);

        if (instance != NULL) {
                bprintf(buf1, "%s_%s", instance, name);
                name = buf1;
        }

        PTOK(pthread_mutex_lock(&macro_mtx));
        va_start(ap, fmt);
        m = macro_def_int(name, NULL, fmt, ap);
        va_end(ap);
        vtc_log(vl, 4, "macro def %s=%s", name, m->val);
        PTOK(pthread_mutex_unlock(&macro_mtx));
}

void
macro_undef(struct vtclog *vl, const char *instance, const char *name)
{
        char buf1[256];
        struct macro *m;

        if (instance != NULL) {
                bprintf(buf1, "%s_%s", instance, name);
                name = buf1;
        }

        PTOK(pthread_mutex_lock(&macro_mtx));
        VTAILQ_FOREACH(m, &macro_list, list)
                if (!strcmp(name, m->name))
                        break;
        if (m != NULL) {
                if (!vtc_stop)
                        vtc_log(vl, 4, "macro undef %s", name);
                CHECK_OBJ(m, MACRO_MAGIC);
                VTAILQ_REMOVE(&macro_list, m, list);
                free(m->name);
                free(m->val);
                FREE_OBJ(m);
        }
        PTOK(pthread_mutex_unlock(&macro_mtx));
}

unsigned
macro_isdef(const char *instance, const char *name)
{
        char buf1[256];
        struct macro *m;

        if (instance != NULL) {
                bprintf(buf1, "%s_%s", instance, name);
                name = buf1;
        }

        PTOK(pthread_mutex_lock(&macro_mtx));
        VTAILQ_FOREACH(m, &macro_list, list)
                if (!strcmp(name, m->name))
                        break;
        PTOK(pthread_mutex_unlock(&macro_mtx));

        return (m != NULL);
}

void
macro_cat(struct vtclog *vl, struct vsb *vsb, const char *b, const char *e)
{
        struct macro *m;
        char **argv, *retval = NULL;
        const char *err = NULL;
        int argc;

        AN(b);
        if (e == NULL)
                e = strchr(b, '\0');
        AN(e);

        argv = VAV_ParseTxt(b, e, &argc, ARGV_COMMA);
        AN(argv);

        if (*argv != NULL)
                vtc_fatal(vl, "Macro ${%.*s} parsing failed: %s",
                    (int)(e - b), b, *argv);

        assert(argc >= 2);

        PTOK(pthread_mutex_lock(&macro_mtx));
        VTAILQ_FOREACH(m, &macro_list, list) {
                CHECK_OBJ_NOTNULL(m, MACRO_MAGIC);
                if (!strcmp(argv[1], m->name))
                        break;
        }
        if (m != NULL) {
                if (m->func != NULL) {
                        AZ(m->val);
                        retval = m->func(argc, argv, &err);
                        if (err == NULL)
                                AN(retval);
                } else {
                        AN(m->val);
                        if (argc == 2)
                                REPLACE(retval, m->val);
                        else
                                err = "macro does not take arguments";
                }
        }
        PTOK(pthread_mutex_unlock(&macro_mtx));

        VAV_Free(argv);

        if (err != NULL)
                vtc_fatal(vl, "Macro ${%.*s} failed: %s",
                    (int)(e - b), b, err);

        if (retval == NULL) {
                if (!ign_unknown_macro)
                        vtc_fatal(vl, "Macro ${%.*s} not found",
                            (int)(e - b), b);
                VSB_printf(vsb, "${%.*s}", (int)(e - b), b);
                return;
        }

        VSB_cat(vsb, retval);
        free(retval);
}

struct vsb *
macro_expandf(struct vtclog *vl, const char *fmt, ...)
{
        va_list ap;
        struct vsb *vsb1, *vsb2;

        vsb1 = VSB_new_auto();
        AN(vsb1);
        va_start(ap, fmt);
        VSB_vprintf(vsb1, fmt, ap);
        va_end(ap);
        AZ(VSB_finish(vsb1));
        vsb2 = macro_expand(vl, VSB_data(vsb1));
        VSB_destroy(&vsb1);
        return (vsb2);
}

struct vsb *
macro_expand(struct vtclog *vl, const char *text)
{
        struct vsb *vsb;
        const char *p, *q;

        vsb = VSB_new_auto();
        AN(vsb);
        while (*text != '\0') {
                p = strstr(text, "${");
                if (p == NULL) {
                        VSB_cat(vsb, text);
                        break;
                }
                VSB_bcat(vsb, text, p - text);
                q = strchr(p, '}');
                if (q == NULL) {
                        VSB_cat(vsb, text);
                        break;
                }
                assert(p[0] == '$');
                assert(p[1] == '{');
                assert(q[0] == '}');
                p += 2;
                macro_cat(vl, vsb, p, q);
                text = q + 1;
        }
        AZ(VSB_finish(vsb));
        return (vsb);
}

/**********************************************************************
 * Parse a string
 *
 * We make a copy of the string and deliberately leak it, so that all
 * the cmd functions we call don't have to strdup(3) all over the place.
 *
 * Static checkers like Coverity may bitch about this, but we don't care.
 */


void
parse_string(struct vtclog *vl, void *priv, const char *spec)
{
        char *token_s[MAX_TOKENS], *token_e[MAX_TOKENS];
        struct vsb *token_exp;
        char *e, *p, *q, *f, *buf;
        int nest_brace;
        int tn;
        unsigned n, m;
        const struct cmds *cp;

        AN(spec);
        buf = strdup(spec);
        AN(buf);
        e = strchr(buf, '\0');
        AN(e);
        for (p = buf; p < e; p++) {
                if (vtc_error || vtc_stop) {
                        vtc_log(vl, 1, "Aborting execution, test %s",
                            vtc_error ? "failed" : "ended");
                        break;
                }
                /* Start of line */
                if (isspace(*p))
                        continue;
                if (*p == '\n')
                        continue;

                if (*p == '#') {
                        for (; *p != '\0' && *p != '\n'; p++)
                                ;
                        if (*p == '\0')
                                break;
                        continue;
                }

                q = strchr(p, '\n');
                if (q == NULL)
                        q = strchr(p, '\0');
                if (q - p > 60)
                        vtc_log(vl, 2, "=== %.60s...", p);
                else
                        vtc_log(vl, 2, "=== %.*s", (int)(q - p), p);

                /* First content on line, collect tokens */
                memset(token_s, 0, sizeof token_s);
                memset(token_e, 0, sizeof token_e);
                tn = 0;
                f = p;
                while (p < e) {
                        assert(tn < MAX_TOKENS);
                        assert(p < e);
                        if (*p == '\n') { /* End on NL */
                                break;
                        }
                        if (isspace(*p)) { /* Inter-token whitespace */
                                p++;
                                continue;
                        }
                        if (*p == '\\' && p[1] == '\n') { /* line-cont */
                                p += 2;
                                continue;
                        }
                        if (*p == '"') { /* quotes */
                                token_s[tn] = ++p;
                                q = p;
                                for (; *p != '\0'; p++) {
                                        assert(p < e);
                                        if (*p == '"')
                                                break;
                                        if (*p == '\\') {
                                                p += VAV_BackSlash(p, q) - 1;
                                                q++;
                                        } else {
                                                if (*p == '\n')
                                                        vtc_fatal(vl,
                                "Unterminated quoted string in line: %*.*s",
                                (int)(p - f), (int)(p - f), f);
                                                assert(*p != '\n');
                                                *q++ = *p;
                                        }
                                }
                                token_e[tn++] = q;
                                p++;
                        } else if (*p == '{') { /* Braces */
                                nest_brace = 0;
                                token_s[tn] = p + 1;
                                for (; p < e; p++) {
                                        if (*p == '{')
                                                nest_brace++;
                                        else if (*p == '}') {
                                                if (--nest_brace == 0)
                                                        break;
                                        }
                                }
                                assert(*p == '}');
                                token_e[tn++] = p++;
                        } else { /* other tokens */
                                token_s[tn] = p;
                                for (; p < e && !isspace(*p); p++)
                                        continue;
                                token_e[tn++] = p;
                        }
                }

                assert(p <= e);
                assert(tn < MAX_TOKENS);
                token_s[tn] = NULL;
                for (tn = 0; token_s[tn] != NULL; tn++) {
                        AN(token_e[tn]);        /*lint !e771 */
                        *token_e[tn] = '\0';    /*lint !e771 */
                        if (NULL != strstr(token_s[tn], "${")) {
                                token_exp = macro_expand(vl, token_s[tn]);
                                if (vtc_error)
                                        return;
                                token_s[tn] = VSB_data(token_exp);
                                token_e[tn] = strchr(token_s[tn], '\0');
                        }
                }


/* SECTION: loop loop
 *
 * loop NUMBER STRING
 *         Process STRING as a specification, NUMBER times.
 *
 * This works inside all specification strings
 */

                if (!strcmp(token_s[0], "loop")) {
                        n = strtoul(token_s[1], NULL, 0);
                        for (m = 0; m < n && !vtc_error && !vtc_stop; m++) {
                                vtc_log(vl, 4, "Loop #%u", m);
                                parse_string(vl, priv, token_s[2]);
                        }
                        continue;
                }

                AN(vl->cmds);
                for (cp = vl->cmds; cp->name != NULL; cp++)
                        if (!strcmp(token_s[0], cp->name))
                                break;

                if (cp->name == NULL) {
                        for (cp = global_cmds; cp->name != NULL; cp++)
                                if (!strcmp(token_s[0], cp->name))
                                        break;
                }

                if (cp->name == NULL)
                        vtc_fatal(vl, "Unknown command: \"%s\"", token_s[0]);

                assert(cp->cmd != NULL);
                cp->cmd(token_s, priv, vl);
        }
}

/**********************************************************************
 * Reset commands (between tests)
 */

static void
reset_cmds(const struct cmds *cmd)
{

        for (; cmd->name != NULL; cmd++)
                cmd->cmd(NULL, NULL, NULL);
}

/**********************************************************************
 * Execute a file
 */

int
fail_out(void)
{
        unsigned old_err;
        static int once = 0;

        if (once++) {
                vtc_log(vltop, 1, "failure during reset");
                return (vtc_error);
        }
        old_err = vtc_error;
        if (!vtc_stop)
                vtc_stop = 1;
        vtc_log(vltop, 1, "RESETTING after %s", tfn);
        reset_cmds(global_cmds);
        reset_cmds(top_cmds);
        vtc_error |= old_err;

        if (vtc_error)
                vtc_log(vltop, 1, "TEST %s FAILED", tfn);
        else
                vtc_log(vltop, 1, "TEST %s completed", tfn);

        if (vtc_stop > 1)
                return (1);
        return (vtc_error);
}

int
exec_file(const char *fn, const char *script, const char *tmpdir,
    char *logbuf, unsigned loglen)
{
        FILE *f;
        struct vsb *vsb;
        const char *p;

        AN(tmpdir);

        (void)signal(SIGPIPE, SIG_IGN);

        PTOK(pthread_mutex_init(&vtc_vrnd_mtx, NULL));
        VRND_Lock = vtc_vrnd_lock;
        VRND_Unlock = vtc_vrnd_unlock;
        VRND_SeedAll();

        tfn = fn;
        vtc_loginit(logbuf, loglen);
        vltop = vtc_logopen("top");
        AN(vltop);
        vtc_log_set_cmd(vltop, top_cmds);

        vtc_log(vltop, 1, "TEST %s starting", fn);

        init_macro();
        init_server();
        init_syslog();
        init_tunnel();

        vsb = VSB_new_auto();
        AN(vsb);
        if (*fn != '/')
                macro_cat(vltop, vsb, "pwd", NULL);
        p = strrchr(fn, '/');
        if (p != NULL) {
                VSB_putc(vsb, '/');
                VSB_bcat(vsb, fn, p - fn);
        }
        if (VSB_len(vsb) == 0)
                VSB_putc(vsb, '/');
        AZ(VSB_finish(vsb));
        macro_def(vltop, NULL, "testdir", "%s", VSB_data(vsb));
        VSB_destroy(&vsb);

        /* Move into our tmpdir */
        AZ(chdir(tmpdir));
        macro_def(vltop, NULL, "tmpdir", "%s", tmpdir);
        p = strrchr(tmpdir, '/');
        AN(p);
        p++;
        AN(*p);
        macro_def(vltop, NULL, "vtcid", "%s", p);

        /* Drop file to tell what was going on here */
        f = fopen("INFO", "w");
        AN(f);
        fprintf(f, "Test case: %s\n", fn);
        AZ(fclose(f));

        vtc_stop = 0;

        vtc_thread = pthread_self();
        parse_string(vltop, NULL, script);
        return (fail_out());
}

		varnish-cache/bin/varnishtest/vtest2/src/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	681240	vtc_vrnd_lock(void)
59		{
60	681240	PTOK(pthread_mutex_lock(&vtc_vrnd_mtx));
61	681240	}
62
63		static void
64	681240	vtc_vrnd_unlock(void)
65		{
66	681240	PTOK(pthread_mutex_unlock(&vtc_vrnd_mtx));
67	681240	}
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	1025832	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	13736036	VTAILQ_FOREACH(m, &macro_list, list)
107	12732044	if (!strcmp(name, m->name))
108	21840	break;
109	1025832	if (m == NULL) {
110	1003992	ALLOC_OBJ(m, MACRO_MAGIC);
111	1003992	AN(m);
112	1003992	REPLACE(m->name, name);
113	1003992	AN(m->name);
114	1003992	VTAILQ_INSERT_TAIL(&macro_list, m, list);
115	1003992	}
116	1025832	AN(m);
117	1025832	if (func != NULL) {
118	80880	AZ(fmt);
119	80880	m->func = func;
120	80880	} else {
121	944952	AN(fmt);
122	944952	vbprintf(buf, fmt, ap);
123	944952	REPLACE(m->val, buf);
124	944952	AN(m->val);
125		}
126	1025832	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	443120	extmacro_def(const char name, macro_f func, const char *fmt, ...)
137		{
138		va_list ap;
139
140	443120	va_start(ap, fmt);
141	443120	(void)macro_def_int(name, func, fmt, ap);
142	443120	va_end(ap);
143	443120	}
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	41080	init_macro(void)
153		{
154		struct macro *m;
155
156		/* Dump the extmacros for completeness */
157	491800	VTAILQ_FOREACH(m, &macro_list, list) {
158	450720	if (m->val != NULL)
159	737120	vtc_log(vltop, 4,
160	368560	"extmacro def %s=%s", m->name, m->val);
161		else
162	82160	vtc_log(vltop, 4, "extmacro def %s(...)", m->name);
163	450720	}
164
165	41080	PTOK(pthread_mutex_init(&macro_mtx, NULL));
166	41080	}
167
168		void
169	582712	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	582712	AN(fmt);
177
178	582712	if (instance != NULL) {
179	459472	bprintf(buf1, "%s_%s", instance, name);
180	459472	name = buf1;
181	459472	}
182
183	582712	PTOK(pthread_mutex_lock(&macro_mtx));
184	582712	va_start(ap, fmt);
185	582712	m = macro_def_int(name, NULL, fmt, ap);
186	582712	va_end(ap);
187	582712	vtc_log(vl, 4, "macro def %s=%s", name, m->val);
188	582712	PTOK(pthread_mutex_unlock(&macro_mtx));
189	582712	}
190
191		void
192	143352	macro_undef(struct vtclog vl, const char instance, const char *name)
193		{
194		char buf1[256];
195		struct macro *m;
196
197	143352	if (instance != NULL) {
198	143347	bprintf(buf1, "%s_%s", instance, name);
199	143347	name = buf1;
200	143347	}
201
202	143352	PTOK(pthread_mutex_lock(&macro_mtx));
203	2328022	VTAILQ_FOREACH(m, &macro_list, list)
204	2319670	if (!strcmp(name, m->name))
205	135000	break;
206	143352	if (m != NULL) {
207	135000	if (!vtc_stop)
208	7840	vtc_log(vl, 4, "macro undef %s", name);
209	135000	CHECK_OBJ(m, MACRO_MAGIC);
210	135000	VTAILQ_REMOVE(&macro_list, m, list);
211	135000	free(m->name);
212	135000	free(m->val);
213	135000	FREE_OBJ(m);
214	135000	}
215	143352	PTOK(pthread_mutex_unlock(&macro_mtx));
216	143352	}
217
218		unsigned
219	76872	macro_isdef(const char instance, const char name)
220		{
221		char buf1[256];
222		struct macro *m;
223
224	76872	if (instance != NULL) {
225	0	bprintf(buf1, "%s_%s", instance, name);
226	0	name = buf1;
227	0	}
228
229	76872	PTOK(pthread_mutex_lock(&macro_mtx));
230	1410600	VTAILQ_FOREACH(m, &macro_list, list)
231	1333728	if (!strcmp(name, m->name))
232	0	break;
233	76872	PTOK(pthread_mutex_unlock(&macro_mtx));
234
235	76872	return (m != NULL);
236		}
237
238		void
239	484685	macro_cat(struct vtclog vl, struct vsb vsb, const char b, const char e)
240		{
241		struct macro *m;
242	484685	char *argv, retval = NULL;
243	484685	const char *err = NULL;
244		int argc;
245
246	484685	AN(b);
247	484685	if (e == NULL)
248	256920	e = strchr(b, '\0');
249	484685	AN(e);
250
251	484685	argv = VAV_ParseTxt(b, e, &argc, ARGV_COMMA);
252	484685	AN(argv);
253
254	484685	if (*argv != NULL)
255	0	vtc_fatal(vl, "Macro ${%.*s} parsing failed: %s",
256	0	(int)(e - b), b, *argv);
257
258	484685	assert(argc >= 2);
259
260	484685	PTOK(pthread_mutex_lock(&macro_mtx));
261	4551062	VTAILQ_FOREACH(m, &macro_list, list) {
262	4548503	CHECK_OBJ_NOTNULL(m, MACRO_MAGIC);
263	4548503	if (!strcmp(argv[1], m->name))
264	482126	break;
265	4066377	}
266	484685	if (m != NULL) {
267	482126	if (m->func != NULL) {
268	89094	AZ(m->val);
269	89094	retval = m->func(argc, argv, &err);
270	89094	if (err == NULL)
271	89094	AN(retval);
272	89094	} else {
273	393032	AN(m->val);
274	393032	if (argc == 2)
275	393032	REPLACE(retval, m->val);
276		else
277	0	err = "macro does not take arguments";
278		}
279	482126	}
280	484685	PTOK(pthread_mutex_unlock(&macro_mtx));
281
282	484685	VAV_Free(argv);
283
284	484685	if (err != NULL)
285	0	vtc_fatal(vl, "Macro ${%.*s} failed: %s",
286	0	(int)(e - b), b, err);
287
288	484685	if (retval == NULL) {
289	2560	if (!ign_unknown_macro)
290	0	vtc_fatal(vl, "Macro ${%.*s} not found",
291	0	(int)(e - b), b);
292	2560	VSB_printf(vsb, "${%.*s}", (int)(e - b), b);
293	2560	return;
294		}
295
296	482125	VSB_cat(vsb, retval);
297	482125	free(retval);
298	484685	}
299
300		struct vsb *
301	57431	macro_expandf(struct vtclog vl, const char fmt, ...)
302		{
303		va_list ap;
304		struct vsb vsb1, vsb2;
305
306	57431	vsb1 = VSB_new_auto();
307	57431	AN(vsb1);
308	57431	va_start(ap, fmt);
309	57431	VSB_vprintf(vsb1, fmt, ap);
310	57431	va_end(ap);
311	57431	AZ(VSB_finish(vsb1));
312	57431	vsb2 = macro_expand(vl, VSB_data(vsb1));
313	57431	VSB_destroy(&vsb1);
314	57431	return (vsb2);
315		}
316
317		struct vsb *
318	214672	macro_expand(struct vtclog vl, const char text)
319		{
320		struct vsb *vsb;
321		const char p, q;
322
323	214672	vsb = VSB_new_auto();
324	214672	AN(vsb);
325	442421	while (*text != '\0') {
326	364981	p = strstr(text, "${");
327	364981	if (p == NULL) {
328	137232	VSB_cat(vsb, text);
329	137232	break;
330		}
331	227749	VSB_bcat(vsb, text, p - text);
332	227749	q = strchr(p, '}');
333	227749	if (q == NULL) {
334	0	VSB_cat(vsb, text);
335	0	break;
336		}
337	227749	assert(p[0] == '$');
338	227749	assert(p[1] == '{');
339	227749	assert(q[0] == '}');
340	227749	p += 2;
341	227749	macro_cat(vl, vsb, p, q);
342	227749	text = q + 1;
343		}
344	214672	AZ(VSB_finish(vsb));
345	214672	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	321967	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	321967	AN(spec);
370	321967	buf = strdup(spec);
371	321967	AN(buf);
372	321967	e = strchr(buf, '\0');
373	321967	AN(e);
374	4198449	for (p = buf; p < e; p++) {
375	3877791	if (vtc_error \|\| vtc_stop) {
376	2630	vtc_log(vl, 1, "Aborting execution, test %s",
377	1315	vtc_error ? "failed" : "ended");
378	1315	break;
379		}
380		/* Start of line */
381	3876476	if (isspace(*p))
382	2269255	continue;
383	1607221	if (*p == '\n')
384	0	continue;
385
386	1607221	if (*p == '#') {
387	3690925	for (; p != '\0' && p != '\n'; p++)
388		;
389	89520	if (*p == '\0')
390	0	break;
391	89520	continue;
392		}
393
394	1517701	q = strchr(p, '\n');
395	1517701	if (q == NULL)
396	15800	q = strchr(p, '\0');
397	1517701	if (q - p > 60)
398	115877	vtc_log(vl, 2, "=== %.60s...", p);
399		else
400	1401824	vtc_log(vl, 2, "=== %.*s", (int)(q - p), p);
401
402		/* First content on line, collect tokens */
403	1517701	memset(token_s, 0, sizeof token_s);
404	1517701	memset(token_e, 0, sizeof token_e);
405	1517701	tn = 0;
406	1517701	f = p;
407	10184648	while (p < e) {
408	10169220	assert(tn < MAX_TOKENS);
409	10169220	assert(p < e);
410	10169220	if (p == '\n') { / End on NL */
411	1502273	break;
412		}
413	8666947	if (isspace(p)) { / Inter-token whitespace */
414	3675677	p++;
415	3675677	continue;
416		}
417	4991270	if (p == '\\' && p[1] == '\n') { / line-cont */
418	39640	p += 2;
419	39640	continue;
420		}
421	4951630	if (p == '"') { / quotes */
422	475706	token_s[tn] = ++p;
423	475706	q = p;
424	11482436	for (; *p != '\0'; p++) {
425	11482115	assert(p < e);
426	11482115	if (*p == '"')
427	475385	break;
428	11006730	if (*p == '\\') {
429	111008	p += VAV_BackSlash(p, q) - 1;
430	111008	q++;
431	111008	} else {
432	10895722	if (*p == '\n')
433	0	vtc_fatal(vl,
434		"Unterminated quoted string in line: %.s",
435	0	(int)(p - f), (int)(p - f), f);
436	10895722	assert(*p != '\n');
437	10895722	q++ = p;
438		}
439	11006730	}
440	475706	token_e[tn++] = q;
441	475706	p++;
442	4951630	} else if (p == '{') { / Braces */
443	310718	nest_brace = 0;
444	310718	token_s[tn] = p + 1;
445	50459096	for (; p < e; p++) {
446	50459096	if (*p == '{')
447	573109	nest_brace++;
448	49885987	else if (*p == '}') {
449	573110	if (--nest_brace == 0)
450	310718	break;
451	262392	}
452	50148378	}
453	310718	assert(*p == '}');
454	310718	token_e[tn++] = p++;
455	310718	} else { /* other tokens */
456	4165206	token_s[tn] = p;
457	191085391	for (; p < e && !isspace(*p); p++)
458	186920185	continue;
459	4165206	token_e[tn++] = p;
460		}
461		}
462
463	1517701	assert(p <= e);
464	1517701	assert(tn < MAX_TOKENS);
465	1517701	token_s[tn] = NULL;
466	6469453	for (tn = 0; token_s[tn] != NULL; tn++) {
467	4951752	AN(token_e[tn]); /lint !e771 /
468	4951752	token_e[tn] = '\0'; /lint !e771 */
469	4951752	if (NULL != strstr(token_s[tn], "${")) {
470	42360	token_exp = macro_expand(vl, token_s[tn]);
471	42360	if (vtc_error)
472	0	return;
473	42360	token_s[tn] = VSB_data(token_exp);
474	42360	token_e[tn] = strchr(token_s[tn], '\0');
475	42360	}
476	4951752	}
477
478
479		/* SECTION: loop loop
480		*
481		* loop NUMBER STRING
482		* Process STRING as a specification, NUMBER times.
483		*
484		* This works inside all specification strings
485		*/
486
487	1517701	if (!strcmp(token_s[0], "loop")) {
488	1777	n = strtoul(token_s[1], NULL, 0);
489	72383	for (m = 0; m < n && !vtc_error && !vtc_stop; m++) {
490	70606	vtc_log(vl, 4, "Loop #%u", m);
491	70606	parse_string(vl, priv, token_s[2]);
492	70606	}
493	1777	continue;
494		}
495
496	1515924	AN(vl->cmds);
497	26882560	for (cp = vl->cmds; cp->name != NULL; cp++)
498	26808376	if (!strcmp(token_s[0], cp->name))
499	1441740	break;