GCOV - Varnish Cache


/*-
 * Copyright (c) 2008-2011 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "config.h"

#include <sys/wait.h>
#include <sys/socket.h>

#include <grp.h>
#include <math.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/un.h>
#include <unistd.h>

#ifdef HAVE_SYS_PERSONALITY_H
#  include <sys/personality.h>
#endif

#include "vtc.h"

#include "vfil.h"
#include "vnum.h"
#include "vre.h"
#include "vtcp.h"
#include "vsa.h"
#include "vss.h"
#include "vtim.h"
#include "vus.h"

/* SECTION: vtest vtest
 *
 * This should be the first command in your vtc as it will identify the test
 * case with a short yet descriptive sentence. It takes exactly one argument, a
 * string, eg::
 *
 *         vtest "Check that vtest is actually a valid command"
 *
 * It will also print that string in the log.
 */

void v_matchproto_(cmd_f)
cmd_vtest(CMD_ARGS)
{

        (void)priv;
        (void)vl;

        if (av == NULL)
                return;
        AZ(strcmp(av[0], "vtest"));

        vtc_log(vl, 1, "VTEST %s", av[1]);
        AZ(av[2]);
}

/* SECTION: varnishtest varnishtest
 *
 * Alternate name for 'vtest', see above.
 *
 */

void v_matchproto_(cmd_f)
cmd_varnishtest(CMD_ARGS)
{

        (void)priv;
        (void)vl;

        if (av == NULL)
                return;
        AZ(strcmp(av[0], "varnishtest"));

        vtc_log(vl, 1, "VTEST %s", av[1]);
        AZ(av[2]);
}

/* SECTION: shell shell
 *
 * NOTE: This command is available everywhere commands are given.
 *
 * Pass the string given as argument to a shell. If you have multiple
 * commands to run, you can use curly brackets to describe a multi-lines
 * script, eg::
 *
 *         shell {
 *                 echo begin
 *                 cat /etc/fstab
 *                 echo end
 *         }
 *
 * By default a zero exit code is expected, otherwise the vtc will fail.
 *
 * Notice that the commandstring is prefixed with "exec 2>&1;" to combine
 * stderr and stdout back to the test process.
 *
 * Optional arguments:
 *
 * \-err
 *      Expect non-zero exit code.
 *
 * \-exit N
 *      Expect exit code N instead of zero.
 *
 * \-expect STRING
 *      Expect string to be found in stdout+err.
 *
 * \-match REGEXP
 *      Expect regexp to match the stdout+err output.
 */
/* SECTION: client-server.spec.shell
 *
 * shell
 *      Same as for the top-level shell.
 */

static void
cmd_shell_engine(struct vtclog *vl, int ok, const char *cmd,
    const char *expect, const char *re)
{
        struct vsb *vsb, re_vsb[1];
        FILE *fp;
        vre_t *vre = NULL;
        int r, c;
        int err, erroff;
        char errbuf[VRE_ERROR_LEN];

        AN(vl);
        AN(cmd);
        vsb = VSB_new_auto();
        AN(vsb);
        if (re != NULL) {
                vre = VRE_compile(re, 0, &err, &erroff, 1);
                if (vre == NULL) {
                        AN(VSB_init(re_vsb, errbuf, sizeof errbuf));
                        AZ(VRE_error(re_vsb, err));
                        AZ(VSB_finish(re_vsb));
                        VSB_fini(re_vsb);
                        vtc_fatal(vl,
                            "shell_match invalid regexp (\"%s\" at %d)",
                            errbuf, erroff);
                }
        }
        VSB_printf(vsb, "set -e ;");
        VSB_printf(vsb, "exec 2>&1 ; %s", cmd);
        AZ(VSB_finish(vsb));
        vtc_dump(vl, 4, "shell_cmd", VSB_data(vsb), -1);
        fp = popen(VSB_data(vsb), "r");
        if (fp == NULL)
                vtc_fatal(vl, "popen fails: %s", strerror(errno));
        VSB_clear(vsb);
        do {
                c = getc(fp);
                if (c != EOF)
                        VSB_putc(vsb, c);
        } while (c != EOF);
        r = pclose(fp);
        AZ(VSB_finish(vsb));
        vtc_dump(vl, 4, "shell_out", VSB_data(vsb), VSB_len(vsb));
        vtc_log(vl, 4, "shell_status = 0x%04x", WEXITSTATUS(r));
        if (WIFSIGNALED(r))
                vtc_log(vl, 4, "shell_signal = %d", WTERMSIG(r));

        if (ok < 0 && !WEXITSTATUS(r) && !WIFSIGNALED(r))
                vtc_fatal(vl, "shell did not fail as expected");
        else if (ok >= 0 && WEXITSTATUS(r) != ok)
                vtc_fatal(vl, "shell_exit not as expected: "
                    "got 0x%04x wanted 0x%04x", WEXITSTATUS(r), ok);

        if (expect != NULL) {
                if (strstr(VSB_data(vsb), expect) == NULL)
                        vtc_fatal(vl,
                            "shell_expect not found: (\"%s\")", expect);
                else
                        vtc_log(vl, 4, "shell_expect found");
        } else if (vre != NULL) {
                if (VRE_match(vre, VSB_data(vsb), VSB_len(vsb), 0, NULL) < 1)
                        vtc_fatal(vl, "shell_match failed: (\"%s\")", re);
                else
                        vtc_log(vl, 4, "shell_match succeeded");
                VRE_free(&vre);
        }
        VSB_destroy(&vsb);
}


void
cmd_shell(CMD_ARGS)
{
        const char *expect = NULL;
        const char *re = NULL;
        int n;
        int ok = 0;

        (void)priv;

        if (av == NULL)
                return;
        for (n = 1; av[n] != NULL; n++) {
                if (!strcmp(av[n], "-err")) {
                        ok = -1;
                } else if (!strcmp(av[n], "-exit")) {
                        n += 1;
                        ok = atoi(av[n]);
                } else if (!strcmp(av[n], "-expect")) {
                        if (re != NULL)
                                vtc_fatal(vl,
                                    "Cannot use -expect with -match");
                        n += 1;
                        expect = av[n];
                } else if (!strcmp(av[n], "-match")) {
                        if (expect != NULL)
                                vtc_fatal(vl,
                                    "Cannot use -match with -expect");
                        n += 1;
                        re = av[n];
                } else {
                        break;
                }
        }
        AN(av[n]);
        cmd_shell_engine(vl, ok, av[n], expect, re);
}

/* SECTION: filewrite filewrite
 *
 * Write strings to file
 *
 *         filewrite [-a] /somefile "Hello" " " "World\n"
 *
 * The -a flag opens the file in append mode.
 *
 */

void v_matchproto_(cmd_f)
cmd_filewrite(CMD_ARGS)
{
        FILE *fo;
        int n;
        const char *mode = "w";

        (void)priv;

        if (av == NULL)
                return;
        if (av[1] != NULL && !strcmp(av[1], "-a")) {
                av++;
                mode = "a";
        }
        if (av[1] == NULL)
                vtc_fatal(vl, "Need filename");
        fo = fopen(av[1], mode);
        if (fo == NULL)
                vtc_fatal(vl, "Cannot open %s: %s", av[1], strerror(errno));
        for (n = 2; av[n] != NULL; n++)
                (void)fputs(av[n], fo);
        AZ(fclose(fo));
}

/* SECTION: setenv setenv
 *
 * Set or change an environment variable::
 *
 *         setenv FOO "bar baz"
 *
 * The above will set the environment variable $FOO to the value
 * provided. There is also an ``-ifunset`` argument which will only
 * set the value if the environment variable does not already
 * exist::
 *
 *        setenv -ifunset FOO quux
 */

void v_matchproto_(cmd_f)
cmd_setenv(CMD_ARGS)
{
        int r;
        int force;

        (void)priv;

        if (av == NULL)
                return;
        AN(av[1]);
        AN(av[2]);

        force = 1;
        if (strcmp("-ifunset", av[1]) == 0) {
                force = 0;
                av++;
                AN(av[2]);
        }
        if (av[3] != NULL)
                vtc_fatal(vl, "CMD setenv: Unexpected argument '%s'", av[3]);
        r = setenv(av[1], av[2], force);
        if (r != 0)
                vtc_log(vl, 0, "CMD setenv %s=\"%s\" failed: %s",
                    av[1], av[2], strerror(errno));
}

/* SECTION: delay delay
 *
 * NOTE: This command is available everywhere commands are given.
 *
 * Sleep for the number of seconds specified in the argument. The number
 * can include a fractional part, e.g. 1.5.
 */
void
cmd_delay(CMD_ARGS)
{
        double f;

        (void)priv;
        if (av == NULL)
                return;
        AN(av[1]);
        AZ(av[2]);
        f = VNUM(av[1]);
        if (isnan(f))
                vtc_fatal(vl, "Syntax error in number (%s)", av[1]);
        vtc_log(vl, 3, "delaying %g second(s)", f);
        VTIM_sleep(f);
}

/* SECTION: include include
 *
 * Executes a vtc fragment::
 *
 *         include FILE [...]
 *
 * Open a file and execute it as a VTC fragment. This command is available
 * everywhere commands are given.
 *
 */
void
cmd_include(CMD_ARGS)
{
        char *spec;
        unsigned i;

        if (av == NULL)
                return;

        if (av[1] == NULL)
                vtc_fatal(vl, "CMD include: At least 1 argument required");

        for (i = 1; av[i] != NULL; i++) {
                spec = VFIL_readfile(NULL, av[i], NULL);
                if (spec == NULL)
                        vtc_fatal(vl, "CMD include: Unable to read file '%s' "
                            "(%s)", av[i], strerror(errno));
                vtc_log(vl, 2, "Begin include '%s'", av[i]);
                parse_string(vl, priv, spec);
                vtc_log(vl, 2, "End include '%s'", av[i]);
                free(spec);
        }
}

/**********************************************************************
 * Most test-cases use only numeric IP#'s but a few requires non-demented
 * DNS services.  This is a basic sanity check for those.
 */

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

        sa = VSS_ResolveOne(NULL, "dns-canary.varnish-cache.org", NULL,
            AF_INET, SOCK_STREAM, 0);
        if (sa == NULL)
                return (0);
        VTCP_name(sa, abuf, sizeof abuf, pbuf, sizeof pbuf);
        VSA_free(&sa);
        if (strcmp(abuf, "192.0.2.255"))
                return (0);

        sa = VSS_ResolveOne(NULL, "dns-canary.varnish-cache.org", NULL,
            AF_INET6, SOCK_STREAM, 0);
        if (sa == NULL)
                return (1); /* the canary is ipv4 only */
        VSA_free(&sa);
        return (0);
}

/**********************************************************************
 * Test if IPv4/IPv6 works
 */

static int
ipvx_works(const char *target)
{
        const struct suckaddr *sa;
        int fd;

        sa = VSS_ResolveOne(NULL, target, "0", 0, SOCK_STREAM, 0);
        if (sa == NULL)
                return (0);
        fd = VTCP_bind(sa, NULL);
        VSA_free(&sa);
        if (fd >= 0) {
                VTCP_close(&fd);
                return (1);
        }
        return (0);
}

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

static int
addr_no_randomize_works(void)
{
        int r = 0;

#ifdef HAVE_SYS_PERSONALITY_H
        r = personality(0xffffffff);
        r = personality(r | ADDR_NO_RANDOMIZE);
#endif
        return (r >= 0);
}

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

static int
uds_socket(void *priv, const struct sockaddr_un *uds)
{

        return (VUS_bind(uds, priv));
}
static int
abstract_uds_works(void)
{
        const char *err;
        int fd;

        fd = VUS_resolver("@vtc.feature.abstract_uds", uds_socket, NULL, &err);
        if (fd < 0)
                return (0);
        AZ(close(fd));
        return (1);
}

/* SECTION: feature feature
 *
 * Test that the required feature(s) for a test are available, and skip
 * the test otherwise; or change the interpretation of the test, as
 * documented below. feature takes any number of arguments from this list:
 *
 * 64bit
 *        The environment is 64 bits
 * ipv4
 *        127.0.0.1 works
 * ipv6
 *        [::1] works
 * dns
 *        DNS lookups are working
 * topbuild
 *        The test has been started with '-i'
 * root
 *        The test has been invoked by the root user
 * user_varnish
 *        The varnish user is present
 * user_vcache
 *        The vcache user is present
 * group_varnish
 *        The varnish group is present
 * cmd <command-line>
 *        A command line that should execute with a zero exit status
 * ignore_unknown_macro
 *        Do not fail the test if a string of the form ${...} is not
 *        recognized as a macro.
 * persistent_storage
 *        Varnish was built with the deprecated persistent storage.
 * coverage
 *        Varnish was built with code coverage enabled.
 * asan
 *        Varnish was built with the address sanitizer.
 * msan
 *        Varnish was built with the memory sanitizer.
 * tsan
 *        Varnish was built with the thread sanitizer.
 * ubsan
 *        Varnish was built with the undefined behavior sanitizer.
 * sanitizer
 *        Varnish was built with a sanitizer.
 * workspace_emulator
 *        Varnish was built with its workspace emulator.
 * abstract_uds
 *        Creation of an abstract unix domain socket succeeded.
 * disable_aslr
 *        ASLR can be disabled.
 *
 * A feature name can be prefixed with an exclamation mark (!) to skip a
 * test if the feature is present.
 *
 * Be careful with ignore_unknown_macro, because it may cause a test with a
 * misspelled macro to fail silently. You should only need it if you must
 * run a test with strings of the form "${...}".
 */

#if ENABLE_COVERAGE
static const unsigned coverage = 1;
#else
static const unsigned coverage = 0;
#endif

#if ENABLE_ASAN
static const unsigned asan = 1;
#else
static const unsigned asan = 0;
#endif

#if ENABLE_MSAN
static const unsigned msan = 1;
#else
static const unsigned msan = 0;
#endif

#if ENABLE_TSAN
static const unsigned tsan = 1;
#else
static const unsigned tsan = 0;
#endif

#if ENABLE_UBSAN
static const unsigned ubsan = 1;
#else
static const unsigned ubsan = 0;
#endif

#if ENABLE_SANITIZER
static const unsigned sanitizer = 1;
#else
static const unsigned sanitizer = 0;
#endif

#if ENABLE_WORKSPACE_EMULATOR
static const unsigned workspace_emulator = 1;
#else
static const unsigned workspace_emulator = 0;
#endif

#if WITH_PERSISTENT_STORAGE
static const unsigned with_persistent_storage = 1;
#else
static const unsigned with_persistent_storage = 0;
#endif

void v_matchproto_(cmd_f)
cmd_feature(CMD_ARGS)
{
        const char *feat;
        int r, good, skip, neg;

        (void)priv;

        if (av == NULL)
                return;

#define FEATURE(nm, tst)                                \
        do {                                            \
                if (!strcmp(feat, nm)) {                \
                        good = 1;                       \
                        if (tst) {                      \
                                skip = neg;             \
                        } else {                        \
                                skip = !neg;            \
                        }                               \
                }                                       \
        } while (0)

        skip = 0;

        for (av++; *av != NULL; av++) {
                good = 0;
                neg = 0;
                feat = *av;

                if (feat[0] == '!') {
                        neg = 1;
                        feat++;
                }

                FEATURE("ipv4", ipvx_works("127.0.0.1"));
                FEATURE("ipv6", ipvx_works("[::1]"));
                FEATURE("64bit", sizeof(void*) == 8);
                FEATURE("disable_aslr", addr_no_randomize_works());
                FEATURE("dns", dns_works());
                FEATURE("topbuild", iflg);
                FEATURE("root", !geteuid());
                FEATURE("user_varnish", getpwnam("varnish") != NULL);
                FEATURE("user_vcache", getpwnam("vcache") != NULL);
                FEATURE("group_varnish", getgrnam("varnish") != NULL);
                FEATURE("persistent_storage", with_persistent_storage);
                FEATURE("coverage", coverage);
                FEATURE("asan", asan);
                FEATURE("msan", msan);
                FEATURE("tsan", tsan);
                FEATURE("ubsan", ubsan);
                FEATURE("sanitizer", sanitizer);
                FEATURE("workspace_emulator", workspace_emulator);
                FEATURE("abstract_uds", abstract_uds_works());

                if (!strcmp(feat, "cmd")) {
                        good = 1;
                        skip = neg;
                        av++;
                        if (*av == NULL)
                                vtc_fatal(vl, "Missing the command-line");
                        r = system(*av);
                        if (WEXITSTATUS(r) != 0)
                                skip = !neg;
                } else if (!strcmp(feat, "ignore_unknown_macro")) {
                        ign_unknown_macro = 1;
                        good = 1;
                }
                if (!good)
                        vtc_fatal(vl, "FAIL test, unknown feature: %s", feat);

                if (!skip)
                        continue;

                vtc_stop = 2;
                if (neg)
                        vtc_log(vl, 1,
                            "SKIPPING test, conflicting feature: %s", feat);
                else
                        vtc_log(vl, 1,
                            "SKIPPING test, lacking feature: %s", feat);
                return;
        }
}

		varnish-cache/bin/varnishtest/vtc_misc.c
0		/*-
1		* Copyright (c) 2008-2011 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
5		*
6		* SPDX-License-Identifier: BSD-2-Clause
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted provided that the following conditions
10		* are met:
11		* 1. Redistributions of source code must retain the above copyright
12		* notice, this list of conditions and the following disclaimer.
13		* 2. Redistributions in binary form must reproduce the above copyright
14		* notice, this list of conditions and the following disclaimer in the
15		* documentation and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27		* SUCH DAMAGE.
28		*/
29
30		#include "config.h"
31
32		#include <sys/wait.h>
33		#include <sys/socket.h>
34
35		#include <grp.h>
36		#include <math.h>
37		#include <pwd.h>
38		#include <stdio.h>
39		#include <stdlib.h>
40		#include <string.h>
41		#include <sys/un.h>
42		#include <unistd.h>
43
44		#ifdef HAVE_SYS_PERSONALITY_H
45		# include <sys/personality.h>
46		#endif
47
48		#include "vtc.h"
49
50		#include "vfil.h"
51		#include "vnum.h"
52		#include "vre.h"
53		#include "vtcp.h"
54		#include "vsa.h"
55		#include "vss.h"
56		#include "vtim.h"
57		#include "vus.h"
58
59		/* SECTION: vtest vtest
60		*
61		* This should be the first command in your vtc as it will identify the test
62		* case with a short yet descriptive sentence. It takes exactly one argument, a
63		* string, eg::
64		*
65		* vtest "Check that vtest is actually a valid command"
66		*
67		* It will also print that string in the log.
68		*/
69
70		void v_matchproto_(cmd_f)
71	8080	cmd_vtest(CMD_ARGS)
72		{
73
74	8080	(void)priv;
75	8080	(void)vl;
76
77	8080	if (av == NULL)
78	8064	return;
79	16	AZ(strcmp(av[0], "vtest"));
80
81	16	vtc_log(vl, 1, "VTEST %s", av[1]);
82	16	AZ(av[2]);
83	8080	}
84
85		/* SECTION: varnishtest varnishtest
86		*
87		* Alternate name for 'vtest', see above.
88		*
89		*/
90
91		void v_matchproto_(cmd_f)
92	16112	cmd_varnishtest(CMD_ARGS)
93		{
94
95	16112	(void)priv;
96	16112	(void)vl;
97
98	16112	if (av == NULL)
99	8064	return;
100	8048	AZ(strcmp(av[0], "varnishtest"));
101
102	8048	vtc_log(vl, 1, "VTEST %s", av[1]);
103	8048	AZ(av[2]);
104	16112	}
105
106		/* SECTION: shell shell
107		*
108		* NOTE: This command is available everywhere commands are given.
109		*
110		* Pass the string given as argument to a shell. If you have multiple
111		* commands to run, you can use curly brackets to describe a multi-lines
112		* script, eg::
113		*
114		* shell {
115		* echo begin
116		* cat /etc/fstab
117		* echo end
118		* }
119		*
120		* By default a zero exit code is expected, otherwise the vtc will fail.
121		*
122		* Notice that the commandstring is prefixed with "exec 2>&1;" to combine
123		* stderr and stdout back to the test process.
124		*
125		* Optional arguments:
126		*
127		* \-err
128		* Expect non-zero exit code.
129		*
130		* \-exit N
131		* Expect exit code N instead of zero.
132		*
133		* \-expect STRING
134		* Expect string to be found in stdout+err.
135		*
136		* \-match REGEXP
137		* Expect regexp to match the stdout+err output.
138		*/
139		/* SECTION: client-server.spec.shell
140		*
141		* shell
142		* Same as for the top-level shell.
143		*/
144
145		static void
146	3760	cmd_shell_engine(struct vtclog vl, int ok, const char cmd,
147		const char expect, const char re)
148		{
149		struct vsb *vsb, re_vsb[1];
150		FILE *fp;
151	3760	vre_t *vre = NULL;
152		int r, c;
153		int err, erroff;
154		char errbuf[VRE_ERROR_LEN];
155
156	3760	AN(vl);
157	3760	AN(cmd);
158	3760	vsb = VSB_new_auto();
159	3760	AN(vsb);
160	3760	if (re != NULL) {
161	568	vre = VRE_compile(re, 0, &err, &erroff, 1);
162	568	if (vre == NULL) {
163	0	AN(VSB_init(re_vsb, errbuf, sizeof errbuf));
164	0	AZ(VRE_error(re_vsb, err));
165	0	AZ(VSB_finish(re_vsb));
166	0	VSB_fini(re_vsb);
167	0	vtc_fatal(vl,
168		"shell_match invalid regexp (\"%s\" at %d)",
169	0	errbuf, erroff);
170		}
171	568	}
172	3760	VSB_printf(vsb, "set -e ;");
173	3760	VSB_printf(vsb, "exec 2>&1 ; %s", cmd);
174	3760	AZ(VSB_finish(vsb));
175	3760	vtc_dump(vl, 4, "shell_cmd", VSB_data(vsb), -1);
176	3760	fp = popen(VSB_data(vsb), "r");
177	3760	if (fp == NULL)
178	0	vtc_fatal(vl, "popen fails: %s", strerror(errno));
179	3760	VSB_clear(vsb);
180	3760	do {
181	4814354	c = getc(fp);
182	4814354	if (c != EOF)
183	4810594	VSB_putc(vsb, c);
184	4814354	} while (c != EOF);
185	3760	r = pclose(fp);
186	3760	AZ(VSB_finish(vsb));
187	3760	vtc_dump(vl, 4, "shell_out", VSB_data(vsb), VSB_len(vsb));
188	3760	vtc_log(vl, 4, "shell_status = 0x%04x", WEXITSTATUS(r));
189	3760	if (WIFSIGNALED(r))
190	0	vtc_log(vl, 4, "shell_signal = %d", WTERMSIG(r));
191
192	3760	if (ok < 0 && !WEXITSTATUS(r) && !WIFSIGNALED(r))
193	0	vtc_fatal(vl, "shell did not fail as expected");
194	3760	else if (ok >= 0 && WEXITSTATUS(r) != ok)
195	32	vtc_fatal(vl, "shell_exit not as expected: "
196	16	"got 0x%04x wanted 0x%04x", WEXITSTATUS(r), ok);
197
198	3744	if (expect != NULL) {
199	1840	if (strstr(VSB_data(vsb), expect) == NULL)
200	0	vtc_fatal(vl,
201	0	"shell_expect not found: (\"%s\")", expect);
202		else
203	1840	vtc_log(vl, 4, "shell_expect found");
204	3744	} else if (vre != NULL) {
205	568	if (VRE_match(vre, VSB_data(vsb), VSB_len(vsb), 0, NULL) < 1)
206	0	vtc_fatal(vl, "shell_match failed: (\"%s\")", re);
207		else
208	568	vtc_log(vl, 4, "shell_match succeeded");
209	568	VRE_free(&vre);
210	568	}
211	3744	VSB_destroy(&vsb);
212	3744	}
213
214
215		void
216	11824	cmd_shell(CMD_ARGS)
217		{
218	11824	const char *expect = NULL;
219	11824	const char *re = NULL;
220		int n;
221	11824	int ok = 0;
222
223	11824	(void)priv;
224
225	11824	if (av == NULL)
226	8064	return;
227	7936	for (n = 1; av[n] != NULL; n++) {
228	7936	if (!strcmp(av[n], "-err")) {
229	1640	ok = -1;
230	7936	} else if (!strcmp(av[n], "-exit")) {
231	128	n += 1;
232	128	ok = atoi(av[n]);
233	6296	} else if (!strcmp(av[n], "-expect")) {
234	1840	if (re != NULL)
235	0	vtc_fatal(vl,
236		"Cannot use -expect with -match");
237	1840	n += 1;
238	1840	expect = av[n];
239	6168	} else if (!strcmp(av[n], "-match")) {
240	568	if (expect != NULL)
241	0	vtc_fatal(vl,
242		"Cannot use -match with -expect");
243	568	n += 1;
244	568	re = av[n];
245	568	} else {
246	3760	break;
247		}
248	4176	}
249	3760	AN(av[n]);
250	3760	cmd_shell_engine(vl, ok, av[n], expect, re);
251	11824	}
252
253		/* SECTION: filewrite filewrite
254		*
255		* Write strings to file
256		*
257		* filewrite [-a] /somefile "Hello" " " "World\n"
258		*
259		* The -a flag opens the file in append mode.
260		*
261		*/
262
263		void v_matchproto_(cmd_f)
264	8312	cmd_filewrite(CMD_ARGS)
265		{
266		FILE *fo;
267		int n;
268	8312	const char *mode = "w";
269
270	8312	(void)priv;
271
272	8312	if (av == NULL)
273	8064	return;
274	248	if (av[1] != NULL && !strcmp(av[1], "-a")) {
275	112	av++;
276	112	mode = "a";
277	112	}
278	248	if (av[1] == NULL)
279	0	vtc_fatal(vl, "Need filename");
280	248	fo = fopen(av[1], mode);
281	248	if (fo == NULL)
282	0	vtc_fatal(vl, "Cannot open %s: %s", av[1], strerror(errno));
283	592	for (n = 2; av[n] != NULL; n++)
284	344	(void)fputs(av[n], fo);
285	248	AZ(fclose(fo));
286	8312	}
287
288		/* SECTION: setenv setenv
289		*
290		* Set or change an environment variable::
291		*
292		* setenv FOO "bar baz"
293		*
294		* The above will set the environment variable $FOO to the value
295		* provided. There is also an ``-ifunset`` argument which will only
296		* set the value if the environment variable does not already
297		* exist::
298		*
299		* setenv -ifunset FOO quux
300		*/
301
302		void v_matchproto_(cmd_f)
303	8096	cmd_setenv(CMD_ARGS)
304		{
305		int r;
306		int force;
307
308	8096	(void)priv;
309
310	8096	if (av == NULL)
311	8064	return;
312	32	AN(av[1]);
313	32	AN(av[2]);
314
315	32	force = 1;
316	32	if (strcmp("-ifunset", av[1]) == 0) {
317	8	force = 0;
318	8	av++;
319	8	AN(av[2]);
320	8	}
321	32	if (av[3] != NULL)
322	0	vtc_fatal(vl, "CMD setenv: Unexpected argument '%s'", av[3]);
323	32	r = setenv(av[1], av[2], force);
324	32	if (r != 0)
325	0	vtc_log(vl, 0, "CMD setenv %s=\"%s\" failed: %s",
326	0	av[1], av[2], strerror(errno));
327	8096	}
328
329		/* SECTION: delay delay
330		*
331		* NOTE: This command is available everywhere commands are given.
332		*
333		* Sleep for the number of seconds specified in the argument. The number
334		* can include a fractional part, e.g. 1.5.
335		*/
336		void
337	12855	cmd_delay(CMD_ARGS)
338		{
339		double f;
340
341	12855	(void)priv;
342	12855	if (av == NULL)
343	8064	return;
344	4791	AN(av[1]);
345	4791	AZ(av[2]);
346	4791	f = VNUM(av[1]);
347	4791	if (isnan(f))
348	0	vtc_fatal(vl, "Syntax error in number (%s)", av[1]);
349	4791	vtc_log(vl, 3, "delaying %g second(s)", f);
350	4791	VTIM_sleep(f);
351	12855	}
352
353		/* SECTION: include include
354		*
355		* Executes a vtc fragment::
356		*
357		* include FILE [...]
358		*
359		* Open a file and execute it as a VTC fragment. This command is available
360		* everywhere commands are given.
361		*
362		*/
363		void
364	8064	cmd_include(CMD_ARGS)
365		{
366		char *spec;
367		unsigned i;
368
369	8064	if (av == NULL)
370	8064	return;
371
372	0	if (av[1] == NULL)
373	0	vtc_fatal(vl, "CMD include: At least 1 argument required");
374
375	0	for (i = 1; av[i] != NULL; i++) {
376	0	spec = VFIL_readfile(NULL, av[i], NULL);
377	0	if (spec == NULL)
378	0	vtc_fatal(vl, "CMD include: Unable to read file '%s' "
379	0	"(%s)", av[i], strerror(errno));
380	0	vtc_log(vl, 2, "Begin include '%s'", av[i]);
381	0	parse_string(vl, priv, spec);
382	0	vtc_log(vl, 2, "End include '%s'", av[i]);
383	0	free(spec);
384	0	}
385	8064	}
386
387		/**********************************************************************
388		* Most test-cases use only numeric IP#'s but a few requires non-demented
389		* DNS services. This is a basic sanity check for those.
390		*/
391
392		static int
393	8	dns_works(void)
394		{
395		const struct suckaddr *sa;
396		char abuf[VTCP_ADDRBUFSIZE];
397		char pbuf[VTCP_PORTBUFSIZE];
398
399	8	sa = VSS_ResolveOne(NULL, "dns-canary.varnish-cache.org", NULL,
400		AF_INET, SOCK_STREAM, 0);
401	8	if (sa == NULL)
402	0	return (0);
403	8	VTCP_name(sa, abuf, sizeof abuf, pbuf, sizeof pbuf);
404	8	VSA_free(&sa);
405	8	if (strcmp(abuf, "192.0.2.255"))
406	0	return (0);
407
408	8	sa = VSS_ResolveOne(NULL, "dns-canary.varnish-cache.org", NULL,
409		AF_INET6, SOCK_STREAM, 0);
410	8	if (sa == NULL)
411	8	return (1); /* the canary is ipv4 only */
412	0	VSA_free(&sa);
413	0	return (0);
414	8	}
415
416		/**********************************************************************
417		* Test if IPv4/IPv6 works
418		*/
419
420		static int
421	56	ipvx_works(const char *target)
422		{
423		const struct suckaddr *sa;
424		int fd;
425
426	56	sa = VSS_ResolveOne(NULL, target, "0", 0, SOCK_STREAM, 0);
427	56	if (sa == NULL)
428	0	return (0);
429	56	fd = VTCP_bind(sa, NULL);
430	56	VSA_free(&sa);
431	56	if (fd >= 0) {
432	56	VTCP_close(&fd);
433	56	return (1);
434		}
435	0	return (0);
436	56	}
437
438		/**********************************************************************/
439
440		static int
441	8	addr_no_randomize_works(void)
442		{
443	8	int r = 0;
444
445		#ifdef HAVE_SYS_PERSONALITY_H
446		r = personality(0xffffffff);
447		r = personality(r \| ADDR_NO_RANDOMIZE);
448		#endif
449	8	return (r >= 0);
450		}
451
452		/**********************************************************************/
453
454		static int
455	8	uds_socket(void priv, const struct sockaddr_un uds)
456		{
457
458	8	return (VUS_bind(uds, priv));
459		}
460		static int
461	8	abstract_uds_works(void)
462		{
463		const char *err;
464		int fd;
465
466	8	fd = VUS_resolver("@vtc.feature.abstract_uds", uds_socket, NULL, &err);
467	8	if (fd < 0)
468	8	return (0);
469	0	AZ(close(fd));
470	0	return (1);
471	8	}
472
473		/* SECTION: feature feature
474		*
475		* Test that the required feature(s) for a test are available, and skip
476		* the test otherwise; or change the interpretation of the test, as
477		* documented below. feature takes any number of arguments from this list:
478		*
479		* 64bit
480		* The environment is 64 bits
481		* ipv4
482		* 127.0.0.1 works
483		* ipv6
484		* [::1] works
485		* dns
486		* DNS lookups are working
487		* topbuild
488		* The test has been started with '-i'
489		* root
490		* The test has been invoked by the root user
491		* user_varnish
492		* The varnish user is present
493		* user_vcache
494		* The vcache user is present
495		* group_varnish
496		* The varnish group is present
497		* cmd <command-line>
498		* A command line that should execute with a zero exit status
499		* ignore_unknown_macro