/*-

 * 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 "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 int vtc_use_cleaner = 0;

static int vtc_ntest = 1;               /* Run tests this many times */

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;

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

 * autocrap test-driver command arguments

 */

#define TDARGS(MACRO) \

        MACRO("--test-name",            td_test_name) \

        MACRO("--log-file",             td_log_file) \

        MACRO("--trs-file",             td_trs_file) \

        MACRO("--color-tests",          td_color_tests) \

        MACRO("--collect_skipped_logs", td_collect_skipped_logs) \

        MACRO("--expect-failure",       td_expect_failure) \

        MACRO("--enable-hard-errors",   td_enable_hard_errors)

#define TDVAR(name, dst) static const char *dst;

        TDARGS(TDVAR)

#undef TDVAR

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

static struct buf *

get_buf(void)

{

        struct buf *bp;

        CHECK_OBJ_ORNULL(bp, BUF_MAGIC);

        if (bp != NULL) {

                VTAILQ_REMOVE(&free_bufs, bp, list);

        }

{

        CHECK_OBJ_NOTNULL(*bp, BUF_MAGIC);

        *bp = NULL;

 */

static int

parse_D_opt(char *arg)

{

        char *p, *q;

        q = strchr(p, '=');

        if (!q)

                return (0);

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

static void v_noreturn_

usage(void)

{

        fprintf(stderr, "usage: %s [options] file ...\n", argv0);

#define FMT "    %-28s # %s\n"

            "Set internal buffer size (default: 1M)");

        fprintf(stderr, FMT, "-D name=val", "Define macro");

        fprintf(stderr, FMT, "-i", "Find varnish binaries in build tree");

 * 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)));

                bprintf(buf, "%s\n", dirname);

                assert(write(cleaner_fd, buf, strlen(buf)) == strlen(buf));

                return;

static void

        char buf[BUFSIZ];

        char *q;

        AZ(pipe(p));

        assert(p[0] > STDERR_FILENO);

        assert(p[1] > STDERR_FILENO);

        cleaner_pid = fork();

        assert(cleaner_pid >= 0);

                                exit(execlp(

                                    "rm", "rm", "-rf", buf, (char*)0));

}

static void

                closefd(&cleaner_fd);

}

static void

        if (cleaner_pid > 0) {

                assert(waitpid(cleaner_pid, &st, 0) == cleaner_pid);

                AZ(st);

        }

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) {

                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) {

                px = wait4(jp->child, &stx, 0, NULL);

                assert(px == jp->child);

                        ecode = WEXITSTATUS(stx);

                if (p > jp->bp->buf && p[-1] != '\n')

                if (!ecode)

                else if (ecode == 1)

                        AN(f);

                }

                        AN(f);

                        AZ(fclose(f));

                                fprintf(f, ":test-result: SKIP\n");

                        } else {

                        free(jp->evt);

                        FREE_OBJ(jp->tst);

start_test(void)

        char default_n[PATH_MAX];

        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)

        jp->tst = tp;

        REPLACE(jp->tmpdir, tmpdir);

        AZ(pipe(p));

        assert(p[0] > STDERR_FILENO);

        assert(p[1] > STDERR_FILENO);

        assert(jp->child >= 0);

                cleaner_neuter();       // Too dangerous to have around

                VFIL_null_fd(STDIN_FILENO);

                assert(dup2(p[1], STDERR_FILENO) == STDERR_FILENO);

                    jp->tmpdir, jp->bp->buf, jp->bp->bufsiz);

        }

        jp->ev->callback = tst_cb;

        jp->evt = VEV_Alloc();

 * Set vmod_path to all vmods build directories

 */

        AN(makefile);

                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);

}

    const char *pfx, const char *sfx, struct vsb *vsb)

        DIR *dir;

        if (*subdir != '\0')

        while (1) {

                de = readdir(dir);

                bprintf(buf, "%s%s%s/%s", topdir, topsep, subdir, de->d_name);

                }

        }

}

static void

i_mode(void)

{

        struct vsb *vsb;

        if (topbuild == NULL || topsrc == NULL) {

                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=");

#ifdef VTEST_WITH_VTC_VARNISH

        build_path(topbuild, "bin", "varnish", "", vsb);

#endif

        build_path(topbuild, "bin", "vinyl", "", vsb);

#endif

#ifdef WITH_CONTRIB

        VSB_putc(vsb, ':');

        build_path(topsrc, "", "contrib", "", vsb);

#endif

        VSB_printf(vsb, ":%s", getenv("PATH"));

        AZ(VSB_finish(vsb));

        /*

        build_path(topbuild, "vmod", ".libs", "", vsb);

        AZ(VSB_finish(vsb));

        /*

        AZ(putenv(strdup("MALLOC_CONF=abort:true,junk:true")));

}

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

static void

ip_magic(void)

{

        const struct suckaddr *sa;

        char abuf[VTCP_ADDRBUFSIZE];

        /*

         * In FreeBSD jails localhost/127.0.0.1 becomes the jails IP#

         * XXX: "localhost", but that doesn't work out of the box.

         * XXX: Things like "prefer_ipv6" parameter complicates things.

         */

                sa = VSS_ResolveFirst(NULL, "localhost", "0", 0, SOCK_STREAM, 0);

        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);

         * for the best.

        /* Expose a backend that is forever down. */

        if (VSA_Get_Proto(sa) == AF_INET)

                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);

                bprintf(abuf, "[%s]:0", s);

        free(s);

        extmacro_def("listen_addr", NULL, "%s", abuf);

         * lot harder than it sounds.  This IP# is from RFC5737 and a

         * check your /proc/sys/net/ipv4/ip_nonlocal_bind setting.

         */

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

}

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

 */

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) {

        struct vsb vsb[1];

        const char *p;

        char *res;

        size_t l;

        int i;

        if (argc != 4) {

                *err = "repeat takes 2 arguments";

                return (NULL);

        }

                return (NULL);

                return (NULL);

        l = (strlen(argv[3]) * i) + 1;

                AZ(VSB_cat(vsb, argv[3]));

                i--;

        }

        AZ(VSB_finish(vsb));

        VSB_fini(vsb);

        return (res);

}

static char *

        assert(argc >= 2);

        AN(argv);

        AN(err);

        if (argc == 2) {

                return (NULL);

        }

        if (!strcmp(argv[2], "repeat"))

        return (NULL);

 * Main

 */

        p = VFIL_readfile(NULL, fn, 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 == NULL)

                        break;

        if (q == NULL || *q == '\0') {

                return (2);

            (strncmp(q, "vtest", 5) || !isspace(q[5]))) {

                fprintf(stderr,

        AN(tp);

        VTAILQ_INSERT_TAIL(&tst_head, tp, list);

        return (0);

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

static void

        argc -= 1;

        argv += 1;

#define TDSAVE(name, dst) \

                        argc -= 2; \

                        argv += 2; \

                        continue; \

                }

        TDARGS(TDSAVE)

#undef TDSAVE

                        add_extension(argv[1]);

                        argc -= 2;

                        argv += 2;

                        continue;

                if (read_file(argv[1]))

 */

        int ch;

        uintmax_t bufsiz;

                case 'b':

                        }

                        break;

                case 'D':

                        if (!parse_D_opt(optarg)) {

                                fprintf(stderr, "Cannot parse D opt '%s'\n",

                                    optarg);

                                exit(2);

                        break;

                case 'E':

                case 'i':

                        break;

                case 'j':

                        npar = strtoul(optarg, NULL, 0);

                        break;

                case 'L':

                        leave_temp = 2;

                        break;

                case 'l':

                        break;

                        break;

                        if (vtc_verbosity > 0)

                case 'v':

                default:

        argc -= optind;

        if (argc < 1)

                usage();

        for (; argc > 0; argc--, argv++) {

                if (!read_file(*argv))

                        continue;

                        exit(2);

        }

}

 */

        int i;

        argv0 = strrchr(argv[0], '/');

        else

        if (getenv("TMPDIR") != NULL)

#ifdef PACKAGE_VERSION

#endif

#endif

        extmacro_def("pwd", NULL, "%s", cwd);

        extmacro_def("string", macro_func_string, NULL);

        p = getenv("VTEST_DURATION");

        if (p != NULL)

        VRND_SeedAll();

        setbuf(stderr, NULL);

        } else {

        ip_magic();

        if (iflg)

                i_mode();

                                (void)usleep(random() % 100000L);

                        i = 1;

                        continue;

                }

                i = VEV_Once(vb);

        }

        (void)close(bad_backend_fd);

        if (td_trs_file != 0)

        if (vtc_continue)

                fprintf(stderr,

                    "%d tests failed, %d tests skipped, %d tests passed\n",

        if (vtc_skip && !vtc_good)

        return (0);