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 <dlfcn.h>
#include <fcntl.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 "vsub.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;

/**********************************************************************
 * Commands
 */

struct icmds {
        unsigned                magic;
#define ICMDS_MAGIC             0xa743d463
        struct cmds             *cmd;
        VTAILQ_ENTRY(icmds)     list;
};

static VTAILQ_HEAD(,icmds) icmd_list = VTAILQ_HEAD_INITIALIZER(icmd_list);

void
add_cmd(const char *name, cmd_f *cmd, unsigned flags)
{
        struct icmds *cp;

        AN(name);
        AN(cmd);
        ALLOC_OBJ(cp, ICMDS_MAGIC);
        AN(cp);
        ALLOC_OBJ(cp->cmd, CMDS_MAGIC);
        AN(cp->cmd);
        cp->cmd->name = strdup(name);
        AN(cp->cmd->name);
        cp->cmd->cmd = cmd;
        cp->cmd->flags = flags;
        VTAILQ_INSERT_HEAD(&icmd_list, cp, list);
}

struct cmds *
find_cmd(const char *name)
{
        struct icmds *cp;
        char buf[BUFSIZ];

        VTAILQ_FOREACH(cp, &icmd_list, list) {
                CHECK_OBJ_NOTNULL(cp, ICMDS_MAGIC);
                CHECK_OBJ_NOTNULL(cp->cmd, CMDS_MAGIC);
                if (!strcmp(name, cp->cmd->name))
                        return (cp->cmd);
        }

        bprintf(buf, "libvtest_ext_%s.so", name);
        void *dlp = dlopen(buf, RTLD_NOW);
        if (dlp == NULL) {
                vtc_log(vltop, 4, "Autoload %s failed: %s", buf, dlerror());
                return (NULL);
        }
        vtc_log(vltop, 4, "Autoloaded %s", buf);

        VTAILQ_FOREACH(cp, &icmd_list, list) {
                CHECK_OBJ_NOTNULL(cp, ICMDS_MAGIC);
                CHECK_OBJ_NOTNULL(cp->cmd, CMDS_MAGIC);
                if (!strcmp(name, cp->cmd->name))
                        return (cp->cmd);
        }
        return (NULL);
}

static void
init_cmd_list(void)
{
#define CMD_GLOBAL(n) add_cmd(#n, cmd_##n, CMDS_F_GLOBAL);
#define CMD_TOP(n) add_cmd(#n, cmd_##n, CMDS_F_NONE);
#include "cmds.h"
}

/**********************************************************************
 * Extensions
 *
 * We need to open the extension while doing argument processing
 * in order for relative paths to work.  This complicates the
 * VSUB_closefrom() a little bit.
 */

struct extension {
       unsigned                 magic;
#define EXTENSION_MAGIC         0x69e788db
       VTAILQ_ENTRY(extension)  list;
       const char               *name;
};

static VTAILQ_HEAD(,extension) extension_list =
    VTAILQ_HEAD_INITIALIZER(extension_list);

void
add_extension(const char *name)
{
        int fd;
        struct extension *ep;

        AN(name);
        fd = open(name, O_RDONLY);
        if (fd < 0) {
                fprintf(stderr, "Cannot open extension file '%s': %s\n",
                    name, strerror(errno));
                exit(2);
        }
        closefd(&fd);

        ALLOC_OBJ(ep, EXTENSION_MAGIC);
        AN(ep);
        ep->name = strdup(name);
        AN(ep->name);
        VTAILQ_INSERT_HEAD(&extension_list, ep, list);
}

static int
init_extensions(void)
{
        struct extension *ep;

        VTAILQ_FOREACH(ep, &extension_list, list) {
                CHECK_OBJ_NOTNULL(ep, EXTENSION_MAGIC);
                void *dlp = dlopen(ep->name, RTLD_NOW);
                if (dlp == NULL) {
                        vtc_log(vltop, 1, "Cannot dlopen '%s': %s\n",
                            ep->name, dlerror());
                        return (1);
                }
        }
        return (0);
}

/**********************************************************************
 * 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 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;
                }

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

                if (cp == NULL || cp->name == NULL) {
                        cp = find_cmd(token_s[0]);
                        if (cp != NULL && vl->cmds != NULL &&
                            !(cp->flags & CMDS_F_GLOBAL))
                                cp = NULL;
                }

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

                AN(cp->name);
                AN(cp->cmd);
                cp->cmd(token_s, priv, vl);
        }
}

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

static void
reset_cmd(const char *name)
{
        struct cmds *cp;

        cp = find_cmd(name);
        AN(cp);
        cp->cmd(NULL, NULL, NULL);
        cp->flags |= CMDS_F_SHUT;
}

static void
reset_cmds(void)
{
        struct icmds *cp;

        // Cleanup is easier if the sockets are closed first.
        reset_cmd("client");
        reset_cmd("server");

        VTAILQ_FOREACH(cp, &icmd_list, list) {
                CHECK_OBJ_NOTNULL(cp, ICMDS_MAGIC);
                CHECK_OBJ_NOTNULL(cp->cmd, CMDS_MAGIC);
                if (cp->cmd->flags & CMDS_F_SHUT) {
                        cp->cmd->flags &= ~CMDS_F_SHUT;
                } else {
                        cp->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();
        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);

        VSUB_closefrom(STDERR_FILENO + 1);

        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(vltop, 1, "TEST %s starting", fn);

        init_cmd_list();
        if (init_extensions()) {
                vtc_error = 2;
                return (fail_out());
        }
        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());
}

		vinyl-cache/bin/vinyltest/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 <dlfcn.h>
36		#include <fcntl.h>
37		#include <stdarg.h>
38		#include <stdio.h>
39		#include <stdlib.h>
40		#include <string.h>
41		#include <unistd.h>
42
43		#include "vtc.h"
44		#include "vtc_log.h"
45
46		#include "vav.h"
47		#include "vsub.h"
48		#include "vrnd.h"
49
50		#define MAX_TOKENS 200
51
52		volatile sig_atomic_t vtc_error; /* Error encountered */
53		int vtc_stop; /* Stops current test without error */
54		pthread_t vtc_thread;
55		int ign_unknown_macro = 0;
56		static struct vtclog *vltop;
57
58		static pthread_mutex_t vtc_vrnd_mtx;
59
60		static void
61	357651	vtc_vrnd_lock(void)
62		{
63	357651	PTOK(pthread_mutex_lock(&vtc_vrnd_mtx));
64	357651	}
65
66		static void
67	357651	vtc_vrnd_unlock(void)
68		{
69	357651	PTOK(pthread_mutex_unlock(&vtc_vrnd_mtx));
70	357651	}
71
72		static const char *tfn;
73
74		/**********************************************************************
75		* Commands
76		*/
77
78		struct icmds {
79		unsigned magic;
80		#define ICMDS_MAGIC 0xa743d463
81		struct cmds *cmd;
82		VTAILQ_ENTRY(icmds) list;
83		};
84
85		static VTAILQ_HEAD(,icmds) icmd_list = VTAILQ_HEAD_INITIALIZER(icmd_list);
86
87		void
88	443289	add_cmd(const char name, cmd_f cmd, unsigned flags)
89		{
90		struct icmds *cp;
91
92	443289	AN(name);
93	443289	AN(cmd);
94	443289	ALLOC_OBJ(cp, ICMDS_MAGIC);
95	443289	AN(cp);
96	443289	ALLOC_OBJ(cp->cmd, CMDS_MAGIC);
97	443289	AN(cp->cmd);
98	443289	cp->cmd->name = strdup(name);
99	443289	AN(cp->cmd->name);
100	443289	cp->cmd->cmd = cmd;
101	443289	cp->cmd->flags = flags;
102	443289	VTAILQ_INSERT_HEAD(&icmd_list, cp, list);
103	443289	}
104
105		struct cmds *
106	315058	find_cmd(const char *name)
107		{
108		struct icmds *cp;
109		char buf[BUFSIZ];
110
111	3186807	VTAILQ_FOREACH(cp, &icmd_list, list) {
112	3186702	CHECK_OBJ_NOTNULL(cp, ICMDS_MAGIC);
113	3186702	CHECK_OBJ_NOTNULL(cp->cmd, CMDS_MAGIC);
114	3186702	if (!strcmp(name, cp->cmd->name))
115	314953	return (cp->cmd);
116	2871749	}
117
118	105	bprintf(buf, "libvtest_ext_%s.so", name);
119	105	void *dlp = dlopen(buf, RTLD_NOW);
120	105	if (dlp == NULL) {
121	105	vtc_log(vltop, 4, "Autoload %s failed: %s", buf, dlerror());
122	105	return (NULL);
123		}
124	0	vtc_log(vltop, 4, "Autoloaded %s", buf);
125
126	0	VTAILQ_FOREACH(cp, &icmd_list, list) {
127	0	CHECK_OBJ_NOTNULL(cp, ICMDS_MAGIC);
128	0	CHECK_OBJ_NOTNULL(cp->cmd, CMDS_MAGIC);
129	0	if (!strcmp(name, cp->cmd->name))
130	0	return (cp->cmd);
131	0	}
132	0	return (NULL);
133	315058	}
134
135		static void
136	23331	init_cmd_list(void)
137		{
138		#define CMD_GLOBAL(n) add_cmd(#n, cmd_##n, CMDS_F_GLOBAL);
139		#define CMD_TOP(n) add_cmd(#n, cmd_##n, CMDS_F_NONE);
140		#include "cmds.h"
141		}
142
143		/**********************************************************************
144		* Extensions
145		*
146		* We need to open the extension while doing argument processing
147		* in order for relative paths to work. This complicates the
148		* VSUB_closefrom() a little bit.
149		*/
150
151		struct extension {
152		unsigned magic;
153		#define EXTENSION_MAGIC 0x69e788db
154		VTAILQ_ENTRY(extension) list;
155		const char *name;
156		};
157
158		static VTAILQ_HEAD(,extension) extension_list =
159		VTAILQ_HEAD_INITIALIZER(extension_list);
160
161		void
162	0	add_extension(const char *name)
163		{
164		int fd;
165		struct extension *ep;
166	0
167		AN(name);
168	0	fd = open(name, O_RDONLY);
169	0	if (fd < 0) {
170	0	fprintf(stderr, "Cannot open extension file '%s': %s\n",
171		name, strerror(errno));
172		exit(2);
173	0	}
174	0	closefd(&fd);
175	0
176	0	ALLOC_OBJ(ep, EXTENSION_MAGIC);
177	0	AN(ep);
178	0	ep->name = strdup(name);
179		AN(ep->name);
180		VTAILQ_INSERT_HEAD(&extension_list, ep, list);
181		}
182
183		static int
184		init_extensions(void)
185		{
186		struct extension *ep;
187
188		VTAILQ_FOREACH(ep, &extension_list, list) {
189		CHECK_OBJ_NOTNULL(ep, EXTENSION_MAGIC);
190		void *dlp = dlopen(ep->name, RTLD_NOW);
191		if (dlp == NULL) {
192		vtc_log(vltop, 1, "Cannot dlopen '%s': %s\n",
193		ep->name, dlerror());
194		return (1);
195		}
196		}
197		return (0);
198	682541	}
199
200		/**********************************************************************
201		* Macro facility
202		*/
203	9576822
204	8995586	struct macro {
205	101305	unsigned magic;
206	682541	#define MACRO_MAGIC 0x803423e3
207	581236	VTAILQ_ENTRY(macro) list;
208	581236	char *name;
209	581236	char *val;
210	581236	macro_f *func;
211	581236	};
212	581236
213	682541	static VTAILQ_HEAD(,macro) macro_list = VTAILQ_HEAD_INITIALIZER(macro_list);
214	682541
215	44814	/**********************************************************************/
216	44814
217	44814	static struct macro *
218	637727	macro_def_int(const char name, macro_f func, const char *fmt, va_list ap)
219	637727	{
220	637727	struct macro *m;
221	637727	char buf[2048];
222
223	682541	VTAILQ_FOREACH(m, &macro_list, list)
224		if (!strcmp(name, m->name))
225		break;
226		if (m == NULL) {
227		ALLOC_OBJ(m, MACRO_MAGIC);
228		AN(m);
229		REPLACE(m->name, name);
230		AN(m->name);
231		VTAILQ_INSERT_TAIL(&macro_list, m, list);
232		}
233	244965	AN(m);
234		if (func != NULL) {
235		AZ(fmt);
236		m->func = func;
237	244965	} else {
238	244965	AN(fmt);
239	244965	vbprintf(buf, fmt, ap);
240	244965	REPLACE(m->val, buf);
241		AN(m->val);
242		}
243		return (m);
244		}
245
246
247		/**********************************************************************
248		* This is for defining macros before we fork the child process which
249	23331	* runs the test-case.
250		*/
251
252		void
253		extmacro_def(const char name, macro_f func, const char *fmt, ...)
254	279174	{
255	255843	va_list ap;
256	418362
257	209181	va_start(ap, fmt);
258		(void)macro_def_int(name, func, fmt, ap);
259	46662	va_end(ap);
260	255843	}
261
262	23331	/**********************************************************************
263	23331	* Below this point is run inside the testing child-process.
264		*/
265
266	437576	static pthread_mutex_t macro_mtx;
267
268		static void
269		init_macro(void)
270		{
271		struct macro *m;
272
273	437576	/* Dump the extmacros for completeness */
274		VTAILQ_FOREACH(m, &macro_list, list) {
275	437576	if (m->val != NULL)
276	255043	vtc_log(vltop, 4,
277	255043	"extmacro def %s=%s", m->name, m->val);
278	255043	else
279		vtc_log(vltop, 4, "extmacro def %s(...)", m->name);
280	437576	}
281	437576
282	437576	PTOK(pthread_mutex_init(&macro_mtx, NULL));
283	437576	}
284	437576
285	437576	void
286	437576	macro_def(struct vtclog vl, const char instance, const char *name,
287		const char *fmt, ...)
288		{
289	82368	char buf1[256];
290		struct macro *m;
291		va_list ap;
292
293		AN(fmt);
294	82368
295	82368	if (instance != NULL) {
296	82368	bprintf(buf1, "%s_%s", instance, name);
297	82368	name = buf1;
298		}
299	82368
300	1422669	PTOK(pthread_mutex_lock(&macro_mtx));
301	1416279	va_start(ap, fmt);
302	75978	m = macro_def_int(name, NULL, fmt, ap);
303	82368	va_end(ap);
304	75978	vtc_log(vl, 4, "macro def %s=%s", name, m->val);
305	4536	PTOK(pthread_mutex_unlock(&macro_mtx));
306	75978	}
307	75978
308	75978	void
309	75978	macro_undef(struct vtclog vl, const char instance, const char *name)
310	75978	{
311	75978	char buf1[256];
312	82368	struct macro *m;
313	82368
314		if (instance != NULL) {
315		bprintf(buf1, "%s_%s", instance, name);
316	42544	name = buf1;
317		}
318
319		PTOK(pthread_mutex_lock(&macro_mtx));
320		VTAILQ_FOREACH(m, &macro_list, list)
321	42544	if (!strcmp(name, m->name))
322	0	break;
323	0	if (m != NULL) {
324	0	if (!vtc_stop)
325		vtc_log(vl, 4, "macro undef %s", name);
326	42544	CHECK_OBJ(m, MACRO_MAGIC);
327	824764	VTAILQ_REMOVE(&macro_list, m, list);
328	782220	free(m->name);
329	0	free(m->val);
330	42544	FREE_OBJ(m);
331		}
332	42544	PTOK(pthread_mutex_unlock(&macro_mtx));
333		}
334
335		unsigned
336	283106	macro_isdef(const char instance, const char name)
337		{
338		char buf1[256];
339	283106	struct macro *m;
340	283106
341		if (instance != NULL) {
342		bprintf(buf1, "%s_%s", instance, name);
343	283106	name = buf1;
344	283106	}
345	146116
346	283106	PTOK(pthread_mutex_lock(&macro_mtx));
347		VTAILQ_FOREACH(m, &macro_list, list)
348	283106	if (!strcmp(name, m->name))
349	283106	break;
350		PTOK(pthread_mutex_unlock(&macro_mtx));
351	283106
352	0	return (m != NULL);
353	0	}
354
355	283106	void
356		macro_cat(struct vtclog vl, struct vsb vsb, const char b, const char e)
357	283106	{
358	2762077	struct macro *m;
359	2760250	char *argv, retval = NULL;
360	2760250	const char *err = NULL;
361	281279	int argc;
362	2478971
363	283106	AN(b);
364	281279	if (e == NULL)
365	51184	e = strchr(b, '\0');
366	51184	AN(e);
367	51184
368	51184	argv = VAV_ParseTxt(b, e, &argc, ARGV_COMMA);
369	51184	AN(argv);
370	230095
371	230095	if (*argv != NULL)
372	230095	vtc_fatal(vl, "Macro ${%.*s} parsing failed: %s",
373		(int)(e - b), b, *argv);
374	0
375		assert(argc >= 2);
376	281279
377	283106	PTOK(pthread_mutex_lock(&macro_mtx));
378		VTAILQ_FOREACH(m, &macro_list, list) {
379	283106	CHECK_OBJ_NOTNULL(m, MACRO_MAGIC);
380		if (!strcmp(argv[1], m->name))
381	283106	break;
382	0	}
383	0	if (m != NULL) {
384		if (m->func != NULL) {
385	283106	AZ(m->val);
386	1827	retval = m->func(argc, argv, &err);
387	0	if (err == NULL)
388	0	AN(retval);
389	1827	} else {
390	1827	AN(m->val);
391		if (argc == 2)
392		REPLACE(retval, m->val);
393	281279	else
394	281279	err = "macro does not take arguments";
395	283106	}
396		}
397		PTOK(pthread_mutex_unlock(&macro_mtx));
398	33893
399		VAV_Free(argv);
400
401		if (err != NULL)
402		vtc_fatal(vl, "Macro ${%.*s} failed: %s",
403	33893	(int)(e - b), b, err);
404	33893
405	33893	if (retval == NULL) {
406	33893	if (!ign_unknown_macro)
407	33893	vtc_fatal(vl, "Macro ${%.*s} not found",
408	33893	(int)(e - b), b);
409	33893	VSB_printf(vsb, "${%.*s}", (int)(e - b), b);
410	33893	return;
411	33893	}
412
413		VSB_cat(vsb, retval);
414		free(retval);
415	212721	}
416
417		struct vsb *
418		macro_expandf(struct vtclog vl, const char fmt, ...)
419		{
420	212721	va_list ap;
421	212721	struct vsb vsb1, vsb2;
422	349702
423	304804	vsb1 = VSB_new_auto();
424	304804	AN(vsb1);
425	167823	va_start(ap, fmt);
426	167823	VSB_vprintf(vsb1, fmt, ap);
427		va_end(ap);
428	136981	AZ(VSB_finish(vsb1));
429	136981	vsb2 = macro_expand(vl, VSB_data(vsb1));
430	136981	VSB_destroy(&vsb1);
431	0	return (vsb2);
432	0	}
433
434	136981	struct vsb *
435	136981	macro_expand(struct vtclog vl, const char text)
436	136981	{
437	136981	struct vsb *vsb;
438	136981	const char p, q;
439	136981
440		vsb = VSB_new_auto();
441	212721	AN(vsb);
442	212721	while (*text != '\0') {
443		p = strstr(text, "${");
444		if (p == NULL) {
445		VSB_cat(vsb, text);
446		break;
447		}
448		VSB_bcat(vsb, text, p - text);
449		q = strchr(p, '}');
450		if (q == NULL) {
451		VSB_cat(vsb, text);
452		break;
453		}
454		assert(p[0] == '$');
455		assert(p[1] == '{');
456	231925	assert(q[0] == '}');
457		p += 2;
458		macro_cat(vl, vsb, p, q);
459		text = q + 1;
460		}
461		AZ(VSB_finish(vsb));
462		return (vsb);
463		}
464
465		/**********************************************************************
466	231925	* Parse a string
467	231925	*
468	231925	* We make a copy of the string and deliberately leak it, so that all
469	231925	* the cmd functions we call don't have to strdup(3) all over the place.
470	231925	*
471	2782621	* Static checkers like Coverity may bitch about this, but we don't care.
472	2551498	*/
473	1604
474	802
475	802	void
476		parse_string(struct vtclog vl, void priv, const char *spec)
477		{
478	2550696	char token_s[MAX_TOKENS], token_e[MAX_TOKENS];
479	1540621	struct vsb *token_exp;
480	1010075	char e, p, q, f, *buf;
481	0	int nest_brace;
482		int tn;
483	1010075	unsigned n, m;
484	2132760	const struct cmds *cp;
485
486	51387	AN(spec);
487	0	buf = strdup(spec);
488	51387	AN(buf);
489		e = strchr(buf, '\0');
490		AN(e);
491	958688	for (p = buf; p < e; p++) {
492	958688	if (vtc_error \|\| vtc_stop) {
493	8358	vtc_log(vl, 1, "Aborting execution, test %s",
494	958688	vtc_error ? "failed" : "ended");
495	66844	break;
496		}
497	891844	/* Start of line */
498		if (isspace(*p))
499		continue;