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