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/mman.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/wait.h>

#include <ctype.h>
#include <dirent.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "vtc.h"

#include "vev.h"
#include "vfil.h"
#include "vnum.h"
#include "vrnd.h"
#include "vsa.h"
#include "vss.h"
#include "vsub.h"
#include "vtcp.h"
#include "vtim.h"
#include "vct.h"

static const char *argv0;

struct buf {
        unsigned                magic;
#define BUF_MAGIC               0x39d1258a
        VTAILQ_ENTRY(buf)       list;
        char                    *buf;
        struct vsb              *diag;
        size_t                  bufsiz;
};

static VTAILQ_HEAD(, buf) free_bufs = VTAILQ_HEAD_INITIALIZER(free_bufs);

struct vtc_tst {
        unsigned                magic;
#define TST_MAGIC               0x618d8b88
        VTAILQ_ENTRY(vtc_tst)   list;
        const char              *filename;
        char                    *script;
        unsigned                ntodo;
        unsigned                nwait;
};

struct vtc_job {
        unsigned                magic;
#define JOB_MAGIC               0x1b5fc419
        struct vtc_tst          *tst;
        pid_t                   child;
        struct vev              *ev;
        struct vev              *evt;
        struct buf              *bp;
        char                    *tmpdir;
        double                  t0;
        int                     killed;
};


int iflg = 0;
vtim_dur vtc_maxdur = 60;
static unsigned vtc_bufsiz = 1024 * 1024;

static VTAILQ_HEAD(, vtc_tst) tst_head = VTAILQ_HEAD_INITIALIZER(tst_head);
static struct vev_root *vb;
static int njob = 0;
static int npar = 1;                    /* Number of parallel tests */
static int vtc_continue;                /* Continue on error */
static int vtc_verbosity = 1;           /* Verbosity Level */
static int vtc_good;
static int vtc_fail;
static int vtc_skip;
static char *tmppath;
static char *cwd = NULL;
char *vmod_path = NULL;
struct vsb *params_vsb = NULL;
int leave_temp;
static struct vsb *cbvsb;
static int bad_backend_fd;

static int cleaner_fd = -1;
static pid_t cleaner_pid;
const char *default_listen_addr;

static struct buf *
get_buf(void)
{
        struct buf *bp;

        bp = VTAILQ_FIRST(&free_bufs);
        CHECK_OBJ_ORNULL(bp, BUF_MAGIC);
        if (bp != NULL) {
                VTAILQ_REMOVE(&free_bufs, bp, list);
                VSB_clear(bp->diag);
        } else {
                ALLOC_OBJ(bp, BUF_MAGIC);
                AN(bp);
                bp->bufsiz = vtc_bufsiz;
                bp->buf = mmap(NULL, bp->bufsiz, PROT_READ|PROT_WRITE,
                    MAP_ANON | MAP_SHARED, -1, 0);
                assert(bp->buf != MAP_FAILED);
                bp->diag = VSB_new_auto();
                AN(bp->diag);
        }
        memset(bp->buf, 0, bp->bufsiz);
        return (bp);
}

static void
rel_buf(struct buf **bp)
{
        CHECK_OBJ_NOTNULL(*bp, BUF_MAGIC);

        VTAILQ_INSERT_HEAD(&free_bufs, (*bp), list);
        *bp = NULL;
}

/**********************************************************************
 * Parse a -D option argument into a name/val pair, and insert
 * into extmacro list
 */

static int
parse_D_opt(char *arg)
{
        char *p, *q;

        p = arg;
        q = strchr(p, '=');
        if (!q)
                return (0);
        *q++ = '\0';
        extmacro_def(p, NULL, "%s", q);

        return (1);
}

/**********************************************************************
 * Print usage
 */

static void v_noreturn_
usage(void)
{
        fprintf(stderr, "usage: %s [options] file ...\n", argv0);
#define FMT "    %-28s # %s\n"
        fprintf(stderr, FMT, "-b size",
            "Set internal buffer size (default: 1M)");
        fprintf(stderr, FMT, "-C", "Use cleaner subprocess");
        fprintf(stderr, FMT, "-D name=val", "Define macro");
        fprintf(stderr, FMT, "-i", "Find varnish binaries in build tree");
        fprintf(stderr, FMT, "-j jobs", "Run this many tests in parallel");
        fprintf(stderr, FMT, "-k", "Continue on test failure");
        fprintf(stderr, FMT, "-L", "Always leave temporary vtc.*");
        fprintf(stderr, FMT, "-l", "Leave temporary vtc.* if test fails");
        fprintf(stderr, FMT, "-n iterations", "Run tests this many times");
        fprintf(stderr, FMT, "-p name=val", "Pass a varnishd parameter");
        fprintf(stderr, FMT, "-q", "Quiet mode: report only failures");
        fprintf(stderr, FMT, "-t duration", "Time tests out after this long");
        fprintf(stderr, FMT, "-v", "Verbose mode: always report test log");
        exit(1);
}

/**********************************************************************
 * When running many tests, cleaning the tmpdir with "rm -rf" becomes
 * chore which limits our performance.
 * When the number of tests are above 100, we spawn a child-process
 * to do that for us.
 */

static void
cleaner_do(const char *dirname)
{
        char buf[BUFSIZ];

        AZ(memcmp(dirname, tmppath, strlen(tmppath)));
        if (cleaner_pid > 0) {
                bprintf(buf, "%s\n", dirname);
                assert(write(cleaner_fd, buf, strlen(buf)) == strlen(buf));
                return;
        }
        bprintf(buf, "exec /bin/rm -rf %s\n", dirname);
        AZ(system(buf));
}

static void
cleaner_setup(void)
{
        int p[2], st;
        char buf[BUFSIZ];
        char *q;
        pid_t pp;

        AZ(pipe(p));
        assert(p[0] > STDERR_FILENO);
        assert(p[1] > STDERR_FILENO);
        cleaner_pid = fork();
        assert(cleaner_pid >= 0);
        if (cleaner_pid == 0) {
                closefd(&p[1]);
                (void)!nice(1);         /* Not important */
                setbuf(stdin, NULL);
                AZ(dup2(p[0], STDIN_FILENO));
                while (fgets(buf, sizeof buf, stdin)) {
                        AZ(memcmp(buf, tmppath, strlen(tmppath)));
                        q = buf + strlen(buf);
                        assert(q > buf);
                        assert(q[-1] == '\n');
                        q[-1] = '\0';

                        /* Dont expend a shell on running /bin/rm */
                        pp = fork();
                        assert(pp >= 0);
                        if (pp == 0)
                                exit(execlp(
                                    "rm", "rm", "-rf", buf, (char*)0));
                        assert(waitpid(pp, &st, 0) == pp);
                        AZ(st);
                }
                exit(0);
        }
        closefd(&p[0]);
        cleaner_fd = p[1];
}

static void
cleaner_neuter(void)
{
        if (cleaner_pid > 0)
                closefd(&cleaner_fd);
}

static void
cleaner_finish(void)
{
        int st;

        if (cleaner_pid > 0) {
                closefd(&cleaner_fd);
                assert(waitpid(cleaner_pid, &st, 0) == cleaner_pid);
                AZ(st);
        }
}

/**********************************************************************
 * CallBack
 */

static int
tst_cb(const struct vev *ve, int what)
{
        struct vtc_job *jp;
        char buf[BUFSIZ];
        int ecode;
        int i, stx;
        pid_t px;
        double t;
        FILE *f;
        char *p;

        CAST_OBJ_NOTNULL(jp, ve->priv, JOB_MAGIC);
        CHECK_OBJ_NOTNULL(jp->tst, TST_MAGIC);

        // printf("CB %p %s %d\n", ve, jp->tst->filename, what);
        if (what == 0) {
                jp->killed = 1;
                AZ(kill(-jp->child, SIGKILL)); /* XXX: Timeout */
        } else {
                assert(what & (VEV__RD | VEV__HUP));
        }

        *buf = '\0';
        i = read(ve->fd, buf, sizeof buf);
        if (i > 0)
                VSB_bcat(jp->bp->diag, buf, i);
        if (i == 0) {

                njob--;
                px = wait4(jp->child, &stx, 0, NULL);
                assert(px == jp->child);
                t = VTIM_mono() - jp->t0;
                AZ(close(ve->fd));

                ecode = WTERMSIG(stx);
                if (ecode == 0)
                        ecode = WEXITSTATUS(stx);

                AZ(VSB_finish(jp->bp->diag));

                VSB_clear(cbvsb);
                VSB_cat(cbvsb, jp->bp->buf);
                p = strchr(jp->bp->buf, '\0');
                if (p > jp->bp->buf && p[-1] != '\n')
                        VSB_putc(cbvsb, '\n');
                VSB_quote_pfx(cbvsb, "*    diag  0.0 ",
                    VSB_data(jp->bp->diag), -1, VSB_QUOTE_NONL);
                AZ(VSB_finish(cbvsb));
                rel_buf(&jp->bp);

                if ((ecode > 1 && vtc_verbosity) || vtc_verbosity > 1)
                        printf("%s", VSB_data(cbvsb));

                if (!ecode)
                        vtc_good++;
                else if (ecode == 1)
                        vtc_skip++;
                else
                        vtc_fail++;

                if (leave_temp == 0 || (leave_temp == 1 && ecode <= 1)) {
                        cleaner_do(jp->tmpdir);
                } else {
                        bprintf(buf, "%s/LOG", jp->tmpdir);
                        f = fopen(buf, "w");
                        AN(f);
                        (void)fprintf(f, "%s\n", VSB_data(cbvsb));
                        AZ(fclose(f));
                }
                free(jp->tmpdir);

                if (jp->killed)
                        printf("#    top  TEST %s TIMED OUT (kill -9)\n",
                            jp->tst->filename);
                if (ecode > 1) {
                        printf("#    top  TEST %s FAILED (%.3f)",
                            jp->tst->filename, t);
                        if (WIFSIGNALED(stx))
                                printf(" signal=%d\n", WTERMSIG(stx));
                        else if (WIFEXITED(stx))
                                printf(" exit=%d\n", WEXITSTATUS(stx));
                        if (!vtc_continue) {
                                /* XXX kill -9 other jobs ? */
                                exit(2);
                        }
                } else if (vtc_verbosity) {
                        printf("#    top  TEST %s %s (%.3f)\n",
                            jp->tst->filename,
                            ecode ? "skipped" : "passed", t);
                }
                if (jp->evt != NULL) {
                        VEV_Stop(vb, jp->evt);
                        free(jp->evt);
                }
                jp->tst->nwait--;
                if (jp->tst->nwait == 0) {
                        free(jp->tst->script);
                        FREE_OBJ(jp->tst);
                }
                FREE_OBJ(jp);
                return (1);
        }
        return (0);
}

/**********************************************************************
 * Start Test
 */

static void
start_test(void)
{
        struct vtc_tst *tp;
        int p[2], retval;
        struct vtc_job *jp;
        char tmpdir[PATH_MAX];
        char default_n[PATH_MAX];

        ALLOC_OBJ(jp, JOB_MAGIC);
        AN(jp);

        jp->bp = get_buf();

        bprintf(tmpdir, "%s/vtc.%d.%08x", tmppath, (int)getpid(),
                (unsigned)random());
        AZ(mkdir(tmpdir, 0755));

        bprintf(default_n, "%s/default_n", tmpdir);

        AZ(setenv("VARNISH_DEFAULT_N", default_n, 1));

        tp = VTAILQ_FIRST(&tst_head);
        CHECK_OBJ_NOTNULL(tp, TST_MAGIC);
        AN(tp->ntodo);
        tp->ntodo--;
        VTAILQ_REMOVE(&tst_head, tp, list);
        if (tp->ntodo > 0)
                VTAILQ_INSERT_TAIL(&tst_head, tp, list);

        jp->tst = tp;
        REPLACE(jp->tmpdir, tmpdir);

        AZ(pipe(p));
        assert(p[0] > STDERR_FILENO);
        assert(p[1] > STDERR_FILENO);
        jp->t0 = VTIM_mono();
        jp->child = fork();
        assert(jp->child >= 0);
        if (jp->child == 0) {
                cleaner_neuter();       // Too dangerous to have around
                AZ(setpgid(getpid(), 0));
                VFIL_null_fd(STDIN_FILENO);
                assert(dup2(p[1], STDOUT_FILENO) == STDOUT_FILENO);
                assert(dup2(p[1], STDERR_FILENO) == STDERR_FILENO);
                VSUB_closefrom(STDERR_FILENO + 1);
                retval = exec_file(jp->tst->filename, jp->tst->script,
                    jp->tmpdir, jp->bp->buf, jp->bp->bufsiz);
                exit(retval);
        }
        closefd(&p[1]);

        jp->ev = VEV_Alloc();
        AN(jp->ev);
        jp->ev->fd_flags = VEV__RD | VEV__HUP | VEV__ERR;
        jp->ev->fd = p[0];
        jp->ev->priv = jp;
        jp->ev->callback = tst_cb;
        AZ(VEV_Start(vb, jp->ev));

        jp->evt = VEV_Alloc();
        AN(jp->evt);
        jp->evt->fd = -1;
        jp->evt->timeout = vtc_maxdur;
        jp->evt->priv = jp;
        jp->evt->callback = tst_cb;
        AZ(VEV_Start(vb, jp->evt));
}

/**********************************************************************
 * i-mode = "we're inside a src-tree"
 *
 * Find the abs path to top of source dir from Makefile, if that
 * fails, fall back on "../../"
 *
 * Set PATH to all programs build directories
 * Set vmod_path to all vmods build directories
 *
 */

static char *
top_dir(const char *makefile, const char *top_var)
{
        const char *b, *e;
        char *var;

        AN(makefile);
        AN(top_var);
        assert(*top_var == '\n');

        b = strstr(makefile, top_var);
        top_var++;

        if (b == NULL) {
                fprintf(stderr, "could not find '%s' in Makefile\n", top_var);
                return (NULL);
        }

        e = strchr(b + 1, '\n');
        if (e == NULL) {
                fprintf(stderr, "No NL after '%s' in Makefile\n", top_var);
                return (NULL);
        }

        b = memchr(b, '/', e - b);
        if (b == NULL) {
                fprintf(stderr, "No '/' after '%s' in Makefile\n", top_var);
                return (NULL);
        }
        var = strndup(b, e - b);
        AN(var);
        return (var);
}

static void
build_path(const char *topdir, const char *subdir,
    const char *pfx, const char *sfx, struct vsb *vsb)
{
        char buf[PATH_MAX];
        DIR *dir;
        struct dirent *de;
        struct stat st;
        const char *topsep = "", *sep = "";

        if (*subdir != '\0')
                topsep = "/";
        bprintf(buf, "%s%s%s/", topdir, topsep, subdir);
        dir = opendir(buf);
        XXXAN(dir);
        while (1) {
                de = readdir(dir);
                if (de == NULL)
                        break;
                if (strncmp(de->d_name, pfx, strlen(pfx)))
                        continue;
                bprintf(buf, "%s%s%s/%s", topdir, topsep, subdir, de->d_name);
                if (!stat(buf, &st) && S_ISDIR(st.st_mode)) {
                        VSB_cat(vsb, sep);
                        VSB_cat(vsb, buf);
                        VSB_cat(vsb, sfx);
                        sep = ":";
                }
        }
        AZ(closedir(dir));
}

static void
i_mode(void)
{
        struct vsb *vsb;
        char *p, *topbuild, *topsrc;

        /*
         * This code has a rather intimate knowledge of auto* generated
         * makefiles.
         */

        vsb = VSB_new_auto();
        AN(vsb);

        p = VFIL_readfile(NULL, "Makefile", NULL);
        if (p == NULL) {
                fprintf(stderr, "No Makefile to search for -i flag.\n");
                exit(2);
        }

        topbuild = top_dir(p, "\nabs_top_builddir");
        topsrc = top_dir(p, "\nabs_top_srcdir");
        free(p);
        if (topbuild == NULL || topsrc == NULL) {
                free(topbuild);
                free(topsrc);
                exit(2);
        }
        extmacro_def("topbuild", NULL, "%s", topbuild);
        extmacro_def("topsrc", NULL, "%s", topsrc);

        /*
         * Build $PATH which can find all programs in the build tree
         */
        VSB_clear(vsb);
        VSB_cat(vsb, "PATH=");
        build_path(topbuild, "bin", "varnish", "", vsb);
#ifdef WITH_CONTRIB
        VSB_putc(vsb, ':');
        build_path(topsrc, "", "contrib", "", vsb);
#endif
        VSB_printf(vsb, ":%s", getenv("PATH"));
        AZ(VSB_finish(vsb));
        AZ(putenv(strdup(VSB_data(vsb))));

        /*
         * Build vmod_path which can find all VMODs in the build tree
         */

        VSB_clear(vsb);
        build_path(topbuild, "vmod", ".libs", "", vsb);
        AZ(VSB_finish(vsb));
        vmod_path = strdup(VSB_data(vsb));
        AN(vmod_path);

        free(topbuild);
        free(topsrc);
        VSB_destroy(&vsb);

        /*
         * strict jemalloc checking
         */
        AZ(putenv(strdup("MALLOC_CONF=abort:true,junk:true")));
}

/**********************************************************************
 * Figure out what IP related magic
 */

static void
ip_magic(void)
{
        const struct suckaddr *sa;
        char abuf[VTCP_ADDRBUFSIZE];
        char pbuf[VTCP_PORTBUFSIZE];
        char *s;

        /*
         * In FreeBSD jails localhost/127.0.0.1 becomes the jails IP#
         * XXX: IPv6-only hosts would have similar issue, but it is not
         * XXX: obvious how to cope.  Ideally "127.0.0.1" would be
         * XXX: "localhost", but that doesn't work out of the box.
         * XXX: Things like "prefer_ipv6" parameter complicates things.
         */
        sa = VSS_ResolveOne(NULL, "127.0.0.1", "0", 0, SOCK_STREAM, 0);
        AN(sa);
        bad_backend_fd = VTCP_bind(sa, NULL);
        if (bad_backend_fd < 0) {
                VSA_free(&sa);
                sa = VSS_ResolveFirst(NULL, "localhost", "0", 0, SOCK_STREAM, 0);
                AN(sa);
                bad_backend_fd = VTCP_bind(sa, NULL);
        }
        assert(bad_backend_fd >= 0);
        VTCP_myname(bad_backend_fd, abuf, sizeof abuf, pbuf, sizeof(pbuf));
        extmacro_def("localhost", NULL, "%s", abuf);
        s = strdup(abuf);
        AN(s);

#if defined (__APPLE__)
        /*
         * In macOS a bound socket that is not listening will timeout
         * instead of refusing the connection so close it and hope
         * for the best.
         */
        VTCP_close(&bad_backend_fd);
#endif

        /* Expose a backend that is forever down. */
        if (VSA_Get_Proto(sa) == AF_INET)
                extmacro_def("bad_backend", NULL, "%s:%s", abuf, pbuf);
        else
                extmacro_def("bad_backend", NULL, "[%s]:%s", abuf, pbuf);

        /* our default bind/listen address */
        if (VSA_Get_Proto(sa) == AF_INET)
                bprintf(abuf, "%s:0", s);
        else
                bprintf(abuf, "[%s]:0", s);
        free(s);

        extmacro_def("listen_addr", NULL, "%s", abuf);
        default_listen_addr = strdup(abuf);
        AN(default_listen_addr);
        VSA_free(&sa);

        /*
         * We need an IP number which will not respond, ever, and that is a
         * lot harder than it sounds.  This IP# is from RFC5737 and a
         * C-class broadcast at that.
         * If tests involving ${bad_ip} fails and you run linux, you should
         * check your /proc/sys/net/ipv4/ip_nonlocal_bind setting.
         */

        extmacro_def("bad_ip", NULL, "%s", "192.0.2.255");
}

/**********************************************************************
 * Macros
 */

static char * v_matchproto_(macro_f)
macro_func_date(int argc, char *const *argv, const char **err)
{
        double t;
        char *s;

        assert(argc >= 2);
        AN(argv);
        AN(err);

        if (argc > 2) {
                *err = "macro does not take arguments";
                return (NULL);
        }

        t = VTIM_real();
        s = malloc(VTIM_FORMAT_SIZE);
        AN(s);
        VTIM_format(t, s);
        return (s);
}

static char *
macro_func_string_repeat(int argc, char *const *argv, const char **err)
{
        struct vsb vsb[1];
        const char *p;
        char *res;
        size_t l;
        int i;

        if (argc != 4) {
                *err = "repeat takes 2 arguments";
                return (NULL);
        }

        p = argv[2];
        i = SF_Parse_Integer(&p, err);

        if (*err != NULL)
                return (NULL);

        if (*p != '\0' || i < 0) {
                *err = "invalid number of repetitions";
                return (NULL);
        }

        l = (strlen(argv[3]) * i) + 1;
        res = malloc(l);
        AN(res);
        AN(VSB_init(vsb, res, l));
        while (i > 0) {
                AZ(VSB_cat(vsb, argv[3]));
                i--;
        }
        AZ(VSB_finish(vsb));
        VSB_fini(vsb);
        return (res);
}

static char *
macro_func_string(int argc, char *const *argv, const char **err)
{

        assert(argc >= 2);
        AN(argv);
        AN(err);

        if (argc == 2) {
                *err = "missing action";
                return (NULL);
        }

        if (!strcmp(argv[2], "repeat"))
                return (macro_func_string_repeat(argc - 1, argv + 1, err));

        *err = "unknown action";
        return (NULL);
}

/**********************************************************************
 * Main
 */

static int
read_file(const char *fn, int ntest)
{
        struct vtc_tst *tp;
        char *p, *q;

        p = VFIL_readfile(NULL, fn, NULL);
        if (p == NULL) {
                fprintf(stderr, "Cannot stat file \"%s\": %s\n",
                    fn, strerror(errno));
                return (2);
        }
        for (q = p ;q != NULL && *q != '\0'; q++) {
                if (vct_islws(*q))
                        continue;
                if (*q != '#')
                        break;
                q = strchr(q, '\n');
                if (q == NULL)
                        break;
        }

        if (q == NULL || *q == '\0') {
                fprintf(stderr, "File \"%s\" has no content.\n", fn);
                free(p);
                return (2);
        }

        if ((strncmp(q, "varnishtest", 11) || !isspace(q[11])) &&
            (strncmp(q, "vtest", 5) || !isspace(q[5]))) {
                fprintf(stderr,
                    "File \"%s\" doesn't start with"
                    " 'vtest' or 'varnishtest'\n", fn);
                free(p);
                vtc_skip++;
                return (2);
        }
        ALLOC_OBJ(tp, TST_MAGIC);
        AN(tp);
        tp->filename = fn;
        tp->script = p;
        tp->ntodo = ntest;
        tp->nwait = ntest;
        VTAILQ_INSERT_TAIL(&tst_head, tp, list);
        return (0);
}

/**********************************************************************
 * Main
 */

int
main(int argc, char * const *argv)
{
        int ch, i;
        int ntest = 1;                  /* Run tests this many times */
        int nstart = 0;
        int use_cleaner = 0;
        uintmax_t bufsiz;
        const char *p;
        char buf[PATH_MAX];

        argv0 = strrchr(argv[0], '/');
        if (argv0 == NULL)
                argv0 = argv[0];
        else
                argv0++;

        if (getenv("TMPDIR") != NULL)
                tmppath = strdup(getenv("TMPDIR"));
        else
                tmppath = strdup("/tmp");

#ifdef PACKAGE_VERSION
        extmacro_def("pkg_version", NULL, PACKAGE_VERSION);
#endif
#ifdef PACKAGE_BRANCH
        extmacro_def("pkg_branch", NULL, PACKAGE_BRANCH);
#endif

        cwd = getcwd(buf, sizeof buf);
        extmacro_def("pwd", NULL, "%s", cwd);

        extmacro_def("date", macro_func_date, NULL);
        extmacro_def("string", macro_func_string, NULL);

        vmod_path = NULL;

        params_vsb = VSB_new_auto();
        AN(params_vsb);
        p = getenv("VTEST_DURATION");
        if (p == NULL)
                p = getenv("VARNISHTEST_DURATION");
        if (p != NULL)
                vtc_maxdur = atoi(p);

        VRND_SeedAll();
        cbvsb = VSB_new_auto();
        AN(cbvsb);
        setbuf(stdout, NULL);
        setbuf(stderr, NULL);
        while ((ch = getopt(argc, argv, "b:CD:hij:kLln:p:qt:vW")) != -1) {
                switch (ch) {
                case 'b':
                        if (VNUM_2bytes(optarg, &bufsiz, 0)) {
                                fprintf(stderr, "Cannot parse b opt '%s'\n",
                                    optarg);
                                exit(2);
                        }
                        if (bufsiz > UINT_MAX) {
                                fprintf(stderr, "Invalid b opt '%s'\n",
                                    optarg);
                                exit(2);
                        }
                        vtc_bufsiz = (unsigned)bufsiz;
                        break;
                case 'C':
                        use_cleaner = !use_cleaner;
                        break;
                case 'D':
                        if (!parse_D_opt(optarg)) {
                                fprintf(stderr, "Cannot parse D opt '%s'\n",
                                    optarg);
                                exit(2);
                        }
                        break;
                case 'i':
                        iflg = 1;
                        break;
                case 'j':
                        npar = strtoul(optarg, NULL, 0);
                        break;
                case 'L':
                        leave_temp = 2;
                        break;
                case 'l':
                        leave_temp = 1;
                        break;
                case 'k':
                        vtc_continue = !vtc_continue;
                        break;
                case 'n':
                        ntest = strtoul(optarg, NULL, 0);
                        break;
                case 'p':
                        VSB_cat(params_vsb, " -p ");
                        VSB_quote(params_vsb, optarg, -1, 0);
                        break;
                case 'q':
                        if (vtc_verbosity > 0)
                                vtc_verbosity--;
                        break;
                case 't':
                        vtc_maxdur = strtoul(optarg, NULL, 0);
                        break;
                case 'v':
                        if (vtc_verbosity < 2)
                                vtc_verbosity++;
                        break;
                default:
                        usage();
                }
        }
        argc -= optind;
        argv += optind;

        if (argc < 1)
                usage();

        for (; argc > 0; argc--, argv++) {
                if (!read_file(*argv, ntest))
                        continue;
                if (!vtc_continue)
                        exit(2);
        }

        AZ(VSB_finish(params_vsb));

        ip_magic();

        if (iflg)
                i_mode();

        vb = VEV_New();

        if (use_cleaner)
                cleaner_setup();

        i = 0;
        while (!VTAILQ_EMPTY(&tst_head) || i) {
                if (!VTAILQ_EMPTY(&tst_head) && njob < npar) {
                        start_test();
                        njob++;
                        /* Stagger ramp-up */
                        if (nstart++ < npar)
                                (void)usleep(random() % 100000L);
                        i = 1;
                        continue;
                }
                i = VEV_Once(vb);
        }
        cleaner_finish();
        (void)close(bad_backend_fd);
        if (vtc_continue)
                fprintf(stderr,
                    "%d tests failed, %d tests skipped, %d tests passed\n",
                    vtc_fail, vtc_skip, vtc_good);
        if (vtc_fail)
                return (1);
        if (vtc_skip && !vtc_good)
                return (77);
        return (0);
}

		varnish-cache/bin/varnishtest/vtest2/src/vtc_main.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/mman.h>
33		#include <sys/socket.h>
34		#include <sys/stat.h>
35		#include <sys/wait.h>
36
37		#include <ctype.h>
38		#include <dirent.h>
39		#include <poll.h>
40		#include <stdio.h>
41		#include <stdlib.h>
42		#include <string.h>
43		#include <unistd.h>
44
45		#include "vtc.h"
46
47		#include "vev.h"
48		#include "vfil.h"
49		#include "vnum.h"
50		#include "vrnd.h"
51		#include "vsa.h"
52		#include "vss.h"
53		#include "vsub.h"
54		#include "vtcp.h"
55		#include "vtim.h"
56		#include "vct.h"
57
58		static const char *argv0;
59
60		struct buf {
61		unsigned magic;
62		#define BUF_MAGIC 0x39d1258a
63		VTAILQ_ENTRY(buf) list;
64		char *buf;
65		struct vsb *diag;
66		size_t bufsiz;
67		};
68
69		static VTAILQ_HEAD(, buf) free_bufs = VTAILQ_HEAD_INITIALIZER(free_bufs);
70
71		struct vtc_tst {
72		unsigned magic;
73		#define TST_MAGIC 0x618d8b88
74		VTAILQ_ENTRY(vtc_tst) list;
75		const char *filename;
76		char *script;
77		unsigned ntodo;
78		unsigned nwait;
79		};
80
81		struct vtc_job {
82		unsigned magic;
83		#define JOB_MAGIC 0x1b5fc419
84		struct vtc_tst *tst;
85		pid_t child;
86		struct vev *ev;
87		struct vev *evt;
88		struct buf *bp;
89		char *tmpdir;
90		double t0;
91		int killed;
92		};
93
94
95		int iflg = 0;
96		vtim_dur vtc_maxdur = 60;
97		static unsigned vtc_bufsiz = 1024 * 1024;
98
99		static VTAILQ_HEAD(, vtc_tst) tst_head = VTAILQ_HEAD_INITIALIZER(tst_head);
100		static struct vev_root *vb;
101		static int njob = 0;
102		static int npar = 1; /* Number of parallel tests */
103		static int vtc_continue; /* Continue on error */
104		static int vtc_verbosity = 1; /* Verbosity Level */
105		static int vtc_good;
106		static int vtc_fail;
107		static int vtc_skip;
108		static char *tmppath;
109		static char *cwd = NULL;
110		char *vmod_path = NULL;
111		struct vsb *params_vsb = NULL;
112		int leave_temp;
113		static struct vsb *cbvsb;
114		static int bad_backend_fd;
115
116		static int cleaner_fd = -1;
117		static pid_t cleaner_pid;
118		const char *default_listen_addr;
119
120		static struct buf *
121		get_buf(void)
122		{
123		struct buf *bp;
124
125		bp = VTAILQ_FIRST(&free_bufs);
126		CHECK_OBJ_ORNULL(bp, BUF_MAGIC);
127		if (bp != NULL) {
128		VTAILQ_REMOVE(&free_bufs, bp, list);
129		VSB_clear(bp->diag);
130		} else {
131		ALLOC_OBJ(bp, BUF_MAGIC);
132		AN(bp);
133		bp->bufsiz = vtc_bufsiz;
134		bp->buf = mmap(NULL, bp->bufsiz, PROT_READ\|PROT_WRITE,
135		MAP_ANON \| MAP_SHARED, -1, 0);
136		assert(bp->buf != MAP_FAILED);
137		bp->diag = VSB_new_auto();
138		AN(bp->diag);
139		}
140		memset(bp->buf, 0, bp->bufsiz);
141	41400	return (bp);
142		}
143
144		static void
145	41400	rel_buf(struct buf **bp)
146	41400	{
147	41400	CHECK_OBJ_NOTNULL(*bp, BUF_MAGIC);
148	760
149	760	VTAILQ_INSERT_HEAD(&free_bufs, (*bp), list);
150	760	*bp = NULL;
151	40640	}
152	40640
153	40640	/**********************************************************************
154	40640	* Parse a -D option argument into a name/val pair, and insert
155		* into extmacro list
156	40640	*/
157	40640
158	40640	static int
159		parse_D_opt(char *arg)
160	41400	{
161	41400	char p, q;
162
163		p = arg;
164		q = strchr(p, '=');
165	41400	if (!q)
166		return (0);
167	41400	*q++ = '\0';
168		extmacro_def(p, NULL, "%s", q);
169	41400
170	41400	return (1);
171	41400	}
172
173		/**********************************************************************
174		* Print usage
175		*/
176
177		static void v_noreturn_
178		usage(void)
179	40	{
180		fprintf(stderr, "usage: %s [options] file ...\n", argv0);
181		#define FMT " %-28s # %s\n"
182		fprintf(stderr, FMT, "-b size",
183	40	"Set internal buffer size (default: 1M)");
184	40	fprintf(stderr, FMT, "-C", "Use cleaner subprocess");
185	40	fprintf(stderr, FMT, "-D name=val", "Define macro");
186	0	fprintf(stderr, FMT, "-i", "Find varnish binaries in build tree");
187	40	fprintf(stderr, FMT, "-j jobs", "Run this many tests in parallel");
188	40	fprintf(stderr, FMT, "-k", "Continue on test failure");
189		fprintf(stderr, FMT, "-L", "Always leave temporary vtc.*");
190	40	fprintf(stderr, FMT, "-l", "Leave temporary vtc.* if test fails");
191	40	fprintf(stderr, FMT, "-n iterations", "Run tests this many times");
192		fprintf(stderr, FMT, "-p name=val", "Pass a varnishd parameter");
193		fprintf(stderr, FMT, "-q", "Quiet mode: report only failures");
194		fprintf(stderr, FMT, "-t duration", "Time tests out after this long");
195		fprintf(stderr, FMT, "-v", "Verbose mode: always report test log");
196		exit(1);
197		}
198	120
199		/**********************************************************************
200	120	* When running many tests, cleaning the tmpdir with "rm -rf" becomes
201		* chore which limits our performance.
202	120	* When the number of tests are above 100, we spawn a child-process
203		* to do that for us.
204	120	*/
205	120
206	120	static void
207	120	cleaner_do(const char *dirname)
208	120	{
209	120	char buf[BUFSIZ];
210	120
211	120	AZ(memcmp(dirname, tmppath, strlen(tmppath)));
212	120	if (cleaner_pid > 0) {
213	120	bprintf(buf, "%s\n", dirname);
214	120	assert(write(cleaner_fd, buf, strlen(buf)) == strlen(buf));
215	120	return;
216	120	}
217	120	bprintf(buf, "exec /bin/rm -rf %s\n", dirname);
218		AZ(system(buf));
219		}
220
221		static void
222		cleaner_setup(void)
223		{
224		int p[2], st;
225		char buf[BUFSIZ];
226		char *q;
227		pid_t pp;
228	41400
229		AZ(pipe(p));
230		assert(p[0] > STDERR_FILENO);
231		assert(p[1] > STDERR_FILENO);
232	41400	cleaner_pid = fork();
233	41400	assert(cleaner_pid >= 0);
234	960	if (cleaner_pid == 0) {
235	960	closefd(&p[1]);
236	960	(void)!nice(1); /* Not important */
237		setbuf(stdin, NULL);
238	40440	AZ(dup2(p[0], STDIN_FILENO));
239	40440	while (fgets(buf, sizeof buf, stdin)) {
240	41400	AZ(memcmp(buf, tmppath, strlen(tmppath)));
241		q = buf + strlen(buf);
242		assert(q > buf);
243	80	assert(q[-1] == '\n');
244		q[-1] = '\0';
245
246		/* Dont expend a shell on running /bin/rm */
247		pp = fork();
248		assert(pp >= 0);
249		if (pp == 0)
250	80	exit(execlp(
251	80	"rm", "rm", "-rf", buf, (char*)0));
252	80	assert(waitpid(pp, &st, 0) == pp);
253	80	AZ(st);
254	80	}
255	160	exit(0);
256	80	}
257	80	closefd(&p[0]);
258	80	cleaner_fd = p[1];
259	80	}
260	1040
261	960	static void
262	960	cleaner_neuter(void)
263	960	{
264	960	if (cleaner_pid > 0)
265	960	closefd(&cleaner_fd);
266		}
267
268	960	static void
269	960	cleaner_finish(void)
270	1920	{
271	960	int st;
272	960
273	960	if (cleaner_pid > 0) {
274	960	closefd(&cleaner_fd);
275		assert(waitpid(cleaner_pid, &st, 0) == cleaner_pid);
276	80	AZ(st);
277		}
278	80	}
279	80
280	80	/**********************************************************************
281		* CallBack
282		*/
283	41400
284		static int
285	41400	tst_cb(const struct vev *ve, int what)
286	960	{
287	41400	struct vtc_job *jp;
288		char buf[BUFSIZ];
289		int ecode;
290	40520	int i, stx;
291		pid_t px;
292		double t;
293		FILE *f;
294	40520	char *p;
295	80
296	80	CAST_OBJ_NOTNULL(jp, ve->priv, JOB_MAGIC);
297	80	CHECK_OBJ_NOTNULL(jp->tst, TST_MAGIC);
298	80
299	40520	// printf("CB %p %s %d\n", ve, jp->tst->filename, what);
300		if (what == 0) {
301		jp->killed = 1;
302		AZ(kill(-jp->child, SIGKILL)); /* XXX: Timeout */
303		} else {
304		assert(what & (VEV__RD \| VEV__HUP));
305		}
306	41722
307		*buf = '\0';
308		i = read(ve->fd, buf, sizeof buf);
309		if (i > 0)
310		VSB_bcat(jp->bp->diag, buf, i);
311		if (i == 0) {
312
313		njob--;
314		px = wait4(jp->child, &stx, 0, NULL);
315		assert(px == jp->child);
316		t = VTIM_mono() - jp->t0;
317	41722	AZ(close(ve->fd));
318	41722
319		ecode = WTERMSIG(stx);
320		if (ecode == 0)
321	41722	ecode = WEXITSTATUS(stx);
322	0
323	0	AZ(VSB_finish(jp->bp->diag));
324	0
325	41722	VSB_clear(cbvsb);
326		VSB_cat(cbvsb, jp->bp->buf);
327		p = strchr(jp->bp->buf, '\0');
328	41722	if (p > jp->bp->buf && p[-1] != '\n')
329	41722	VSB_putc(cbvsb, '\n');
330	41722	VSB_quote_pfx(cbvsb, "* diag 0.0 ",
331	322	VSB_data(jp->bp->diag), -1, VSB_QUOTE_NONL);
332	41722	AZ(VSB_finish(cbvsb));
333		rel_buf(&jp->bp);
334	41400
335	41400	if ((ecode > 1 && vtc_verbosity) \|\| vtc_verbosity > 1)
336	41400	printf("%s", VSB_data(cbvsb));
337	41400
338	41400	if (!ecode)
339		vtc_good++;
340	41400	else if (ecode == 1)
341	41400	vtc_skip++;
342	41400	else
343		vtc_fail++;
344	41400
345		if (leave_temp == 0 \|\| (leave_temp == 1 && ecode <= 1)) {
346	41400	cleaner_do(jp->tmpdir);
347	41400	} else {
348	41400	bprintf(buf, "%s/LOG", jp->tmpdir);
349	41400	f = fopen(buf, "w");
350	0	AN(f);
351	82800	(void)fprintf(f, "%s\n", VSB_data(cbvsb));
352	41400	AZ(fclose(f));
353	41400	}
354	41400	free(jp->tmpdir);
355
356	41400	if (jp->killed)
357	40800	printf("# top TEST %s TIMED OUT (kill -9)\n",
358		jp->tst->filename);
359	41400	if (ecode > 1) {
360	40720	printf("# top TEST %s FAILED (%.3f)",
361	680	jp->tst->filename, t);
362	640	if (WIFSIGNALED(stx))
363		printf(" signal=%d\n", WTERMSIG(stx));
364	40	else if (WIFEXITED(stx))
365		printf(" exit=%d\n", WEXITSTATUS(stx));
366	41400	if (!vtc_continue) {
367	41400	/* XXX kill -9 other jobs ? */
368	41400	exit(2);
369	0	}
370	0	} else if (vtc_verbosity) {
371	0	printf("# top TEST %s %s (%.3f)\n",
372	0	jp->tst->filename,
373	0	ecode ? "skipped" : "passed", t);
374		}
375	41400	if (jp->evt != NULL) {
376		VEV_Stop(vb, jp->evt);
377	41400	free(jp->evt);
378	0	}
379	0	jp->tst->nwait--;
380	0	if (jp->tst->nwait == 0) {
381	0	free(jp->tst->script);
382	0	FREE_OBJ(jp->tst);
383	0	}
384	0	FREE_OBJ(jp);
385	0	return (1);
386	0	}
387	0	return (0);
388	0	}
389	0
390	0	/**********************************************************************
391	0	* Start Test
392	0	*/
393	0
394	0	static void
395		start_test(void)
396	0	{
397	0	struct vtc_tst *tp;
398		int p[2], retval;
399	0	struct vtc_job *jp;
400	0	char tmpdir[PATH_MAX];
401	0	char default_n[PATH_MAX];
402	41400
403	40	ALLOC_OBJ(jp, JOB_MAGIC);
404	40	AN(jp);
405	40
406	0	jp->bp = get_buf();
407	40
408	40	bprintf(tmpdir, "%s/vtc.%d.%08x", tmppath, (int)getpid(),
409	40	(unsigned)random());
410		AZ(mkdir(tmpdir, 0755));
411	40
412		bprintf(default_n, "%s/default_n", tmpdir);
413	41360
414	41320	AZ(setenv("VARNISH_DEFAULT_N", default_n, 1));
415	41320
416	41320	tp = VTAILQ_FIRST(&tst_head);
417	41320	CHECK_OBJ_NOTNULL(tp, TST_MAGIC);
418	41360	AN(tp->ntodo);
419	41360	tp->ntodo--;
420	41360	VTAILQ_REMOVE(&tst_head, tp, list);
421	41360	if (tp->ntodo > 0)
422	41720	VTAILQ_INSERT_TAIL(&tst_head, tp, list);
423	41720
424	41000	jp->tst = tp;
425	41000	REPLACE(jp->tmpdir, tmpdir);
426	41000
427	41360	AZ(pipe(p));
428	41360	assert(p[0] > STDERR_FILENO);
429		assert(p[1] > STDERR_FILENO);
430	322	jp->t0 = VTIM_mono();
431	41682	jp->child = fork();
432		assert(jp->child >= 0);
433		if (jp->child == 0) {
434		cleaner_neuter(); // Too dangerous to have around
435		AZ(setpgid(getpid(), 0));
436		VFIL_null_fd(STDIN_FILENO);
437		assert(dup2(p[1], STDOUT_FILENO) == STDOUT_FILENO);
438	41400	assert(dup2(p[1], STDERR_FILENO) == STDERR_FILENO);
439		VSUB_closefrom(STDERR_FILENO + 1);
440		retval = exec_file(jp->tst->filename, jp->tst->script,
441		jp->tmpdir, jp->bp->buf, jp->bp->bufsiz);
442		exit(retval);
443		}
444		closefd(&p[1]);
445
446	41400	jp->ev = VEV_Alloc();
447	41400	AN(jp->ev);
448		jp->ev->fd_flags = VEV__RD \| VEV__HUP \| VEV__ERR;
449	41400	jp->ev->fd = p[0];
450		jp->ev->priv = jp;
451	41400	jp->ev->callback = tst_cb;
452		AZ(VEV_Start(vb, jp->ev));
453	41400
454		jp->evt = VEV_Alloc();
455	41400	AN(jp->evt);
456		jp->evt->fd = -1;
457	41400	jp->evt->timeout = vtc_maxdur;
458		jp->evt->priv = jp;
459	41400	jp->evt->callback = tst_cb;
460	41400	AZ(VEV_Start(vb, jp->evt));
461	41400	}
462	41400
463	41400	/**********************************************************************
464	41400	* i-mode = "we're inside a src-tree"
465	360	*
466		* Find the abs path to top of source dir from Makefile, if that
467	41400	* fails, fall back on "../../"
468	41400	*
469		* Set PATH to all programs build directories
470	41400	* Set vmod_path to all vmods build directories
471	41400	*
472	41400	*/
473	41400
474	41400	static char *
475	41400	top_dir(const char makefile, const char top_var)
476	82800	{
477	41400	const char b, e;
478	41400	char *var;
479	41400
480	41400	AN(makefile);
481	41400	AN(top_var);
482	82800	assert(*top_var == '\n');
483	41400
484	41400	b = strstr(makefile, top_var);
485		top_var++;
486	41400
487		if (b == NULL) {
488	41400	fprintf(stderr, "could not find '%s' in Makefile\n", top_var);
489	41400	return (NULL);
490	41400	}
491	41400
492	41400	e = strchr(b + 1, '\n');
493	41400	if (e == NULL) {
494	41400	fprintf(stderr, "No NL after '%s' in Makefile\n", top_var);
495		return (NULL);
496	41400	}
497	41400
498	41400	b = memchr(b, '/', e - b);
499	41400	if (b == NULL) {