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, "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 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	39720	cmd_vtest(CMD_ARGS)
72		{
73
74	39720	(void)priv;
75	39720	(void)vl;
76
77	39720	if (av == NULL)
78	39640	return;
79	80	AZ(strcmp(av[0], "vtest"));
80
81	80	vtc_log(vl, 1, "VTEST %s", av[1]);
82	80	AZ(av[2]);
83	39720	}
84
85		/* SECTION: varnishtest varnishtest
86		*
87		* Alternate name for 'vtest', see above.
88		*
89		*/
90
91		void v_matchproto_(cmd_f)
92	79200	cmd_varnishtest(CMD_ARGS)
93		{
94
95	79200	(void)priv;
96	79200	(void)vl;
97
98	79200	if (av == NULL)
99	39640	return;
100	39560	AZ(strcmp(av[0], "varnishtest"));
101
102	39560	vtc_log(vl, 1, "VTEST %s", av[1]);
103	39560	AZ(av[2]);
104	79200	}
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	18600	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	18600	vre_t *vre = NULL;
152		int r, c;
153		int err, erroff;
154		char errbuf[VRE_ERROR_LEN];
155
156	18600	AN(vl);
157	18600	AN(cmd);
158	18600	vsb = VSB_new_auto();
159	18600	AN(vsb);
160	18600	if (re != NULL) {
161	2840	vre = VRE_compile(re, 0, &err, &erroff, 1);
162	2840	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	2840	}
172	18600	VSB_printf(vsb, "exec 2>&1 ; %s", cmd);
173	18600	AZ(VSB_finish(vsb));
174	18600	vtc_dump(vl, 4, "shell_cmd", VSB_data(vsb), -1);
175	18600	fp = popen(VSB_data(vsb), "r");
176	18600	if (fp == NULL)
177	0	vtc_fatal(vl, "popen fails: %s", strerror(errno));
178	18600	VSB_clear(vsb);
179	18600	do {
180	23481132	c = getc(fp);
181	23481132	if (c != EOF)
182	23462532	VSB_putc(vsb, c);
183	23481132	} while (c != EOF);
184	18600	r = pclose(fp);
185	18600	AZ(VSB_finish(vsb));
186	18600	vtc_dump(vl, 4, "shell_out", VSB_data(vsb), VSB_len(vsb));
187	18600	vtc_log(vl, 4, "shell_status = 0x%04x", WEXITSTATUS(r));
188	18600	if (WIFSIGNALED(r))
189	0	vtc_log(vl, 4, "shell_signal = %d", WTERMSIG(r));
190
191	18600	if (ok < 0 && !WEXITSTATUS(r) && !WIFSIGNALED(r))
192	0	vtc_fatal(vl, "shell did not fail as expected");
193	18600	else if (ok >= 0 && WEXITSTATUS(r) != ok)
194	160	vtc_fatal(vl, "shell_exit not as expected: "
195	80	"got 0x%04x wanted 0x%04x", WEXITSTATUS(r), ok);
196
197	18520	if (expect != NULL) {
198	9200	if (strstr(VSB_data(vsb), expect) == NULL)
199	0	vtc_fatal(vl,
200	0	"shell_expect not found: (\"%s\")", expect);
201		else
202	9200	vtc_log(vl, 4, "shell_expect found");
203	18520	} else if (vre != NULL) {
204	2840	if (VRE_match(vre, VSB_data(vsb), VSB_len(vsb), 0, NULL) < 1)
205	0	vtc_fatal(vl, "shell_match failed: (\"%s\")", re);
206		else
207	2840	vtc_log(vl, 4, "shell_match succeeded");
208	2840	VRE_free(&vre);
209	2840	}
210	18520	VSB_destroy(&vsb);
211	18520	}
212
213
214		void
215	58240	cmd_shell(CMD_ARGS)
216		{
217	58240	const char *expect = NULL;
218	58240	const char *re = NULL;
219		int n;
220	58240	int ok = 0;
221
222	58240	(void)priv;
223
224	58240	if (av == NULL)
225	39640	return;
226	39480	for (n = 1; av[n] != NULL; n++) {
227	39480	if (!strcmp(av[n], "-err")) {
228	8200	ok = -1;
229	39480	} else if (!strcmp(av[n], "-exit")) {
230	640	n += 1;
231	640	ok = atoi(av[n]);
232	31280	} else if (!strcmp(av[n], "-expect")) {
233	9200	if (re != NULL)
234	0	vtc_fatal(vl,
235		"Cannot use -expect with -match");
236	9200	n += 1;
237	9200	expect = av[n];
238	30640	} else if (!strcmp(av[n], "-match")) {
239	2840	if (expect != NULL)
240	0	vtc_fatal(vl,
241		"Cannot use -match with -expect");
242	2840	n += 1;
243	2840	re = av[n];
244	2840	} else {
245	18600	break;
246		}
247	20880	}
248	18600	AN(av[n]);
249	18600	cmd_shell_engine(vl, ok, av[n], expect, re);
250	58240	}
251
252		/* SECTION: filewrite filewrite
253		*
254		* Write strings to file
255		*
256		* filewrite [-a] /somefile "Hello" " " "World\n"
257		*
258		* The -a flag opens the file in append mode.
259		*
260		*/
261
262		void v_matchproto_(cmd_f)
263	40880	cmd_filewrite(CMD_ARGS)
264		{
265		FILE *fo;
266		int n;
267	40880	const char *mode = "w";
268
269	40880	(void)priv;
270
271	40880	if (av == NULL)
272	39640	return;
273	1240	if (av[1] != NULL && !strcmp(av[1], "-a")) {
274	560	av++;
275	560	mode = "a";
276	560	}
277	1240	if (av[1] == NULL)
278	0	vtc_fatal(vl, "Need filename");
279	1240	fo = fopen(av[1], mode);
280	1240	if (fo == NULL)
281	0	vtc_fatal(vl, "Cannot open %s: %s", av[1], strerror(errno));
282	2960	for (n = 2; av[n] != NULL; n++)
283	1720	(void)fputs(av[n], fo);
284	1240	AZ(fclose(fo));
285	40880	}
286
287		/* SECTION: setenv setenv
288		*
289		* Set or change an environment variable::
290		*
291		* setenv FOO "bar baz"
292		*
293		* The above will set the environment variable $FOO to the value
294		* provided. There is also an ``-ifunset`` argument which will only
295		* set the value if the the environment variable does not already
296		* exist::
297		*
298		* setenv -ifunset FOO quux
299		*/
300
301		void v_matchproto_(cmd_f)
302	39800	cmd_setenv(CMD_ARGS)
303		{
304		int r;
305		int force;
306
307	39800	(void)priv;
308
309	39800	if (av == NULL)
310	39640	return;
311	160	AN(av[1]);
312	160	AN(av[2]);
313
314	160	force = 1;
315	160	if (strcmp("-ifunset", av[1]) == 0) {
316	40	force = 0;
317	40	av++;
318	40	AN(av[2]);
319	40	}
320	160	if (av[3] != NULL)
321	0	vtc_fatal(vl, "CMD setenv: Unexpected argument '%s'", av[3]);
322	160	r = setenv(av[1], av[2], force);
323	160	if (r != 0)
324	0	vtc_log(vl, 0, "CMD setenv %s=\"%s\" failed: %s",
325	0	av[1], av[2], strerror(errno));
326	39800	}
327
328		/* SECTION: delay delay
329		*
330		* NOTE: This command is available everywhere commands are given.
331		*
332		* Sleep for the number of seconds specified in the argument. The number
333		* can include a fractional part, e.g. 1.5.
334		*/
335		void
336	63191	cmd_delay(CMD_ARGS)
337		{
338		double f;
339
340	63191	(void)priv;
341	63191	if (av == NULL)
342	39640	return;
343	23551	AN(av[1]);
344	23551	AZ(av[2]);
345	23551	f = VNUM(av[1]);
346	23551	if (isnan(f))
347	0	vtc_fatal(vl, "Syntax error in number (%s)", av[1]);
348	23551	vtc_log(vl, 3, "delaying %g second(s)", f);
349	23551	VTIM_sleep(f);
350	63191	}
351
352		/* SECTION: include include
353		*
354		* Executes a vtc fragment::
355		*
356		* include FILE [...]
357		*
358		* Open a file and execute it as a VTC fragment. This command is available
359		* everywhere commands are given.
360		*
361		*/
362		void
363	39640	cmd_include(CMD_ARGS)
364		{
365		char *spec;
366		unsigned i;
367
368	39640	if (av == NULL)
369	39640	return;
370
371	0	if (av[1] == NULL)
372	0	vtc_fatal(vl, "CMD include: At least 1 argument required");
373
374	0	for (i = 1; av[i] != NULL; i++) {
375	0	spec = VFIL_readfile(NULL, av[i], NULL);
376	0	if (spec == NULL)
377	0	vtc_fatal(vl, "CMD include: Unable to read file '%s' "
378	0	"(%s)", av[i], strerror(errno));
379	0	vtc_log(vl, 2, "Begin include '%s'", av[i]);
380	0	parse_string(vl, priv, spec);
381	0	vtc_log(vl, 2, "End include '%s'", av[i]);
382	0	free(spec);
383	0	}
384	39640	}
385
386		/**********************************************************************
387		* Most test-cases use only numeric IP#'s but a few requires non-demented
388		* DNS services. This is a basic sanity check for those.
389		*/
390
391		static int
392	40	dns_works(void)
393		{
394		const struct suckaddr *sa;
395		char abuf[VTCP_ADDRBUFSIZE];
396		char pbuf[VTCP_PORTBUFSIZE];
397
398	40	sa = VSS_ResolveOne(NULL, "dns-canary.varnish-cache.org", NULL,
399		AF_INET, SOCK_STREAM, 0);
400	40	if (sa == NULL)
401	0	return (0);
402	40	VTCP_name(sa, abuf, sizeof abuf, pbuf, sizeof pbuf);
403	40	VSA_free(&sa);
404	40	if (strcmp(abuf, "192.0.2.255"))
405	0	return (0);
406
407	40	sa = VSS_ResolveOne(NULL, "dns-canary.varnish-cache.org", NULL,
408		AF_INET6, SOCK_STREAM, 0);
409	40	if (sa == NULL)
410	40	return (1); /* the canary is ipv4 only */
411	0	VSA_free(&sa);
412	0	return (0);
413	40	}
414
415		/**********************************************************************
416		* Test if IPv4/IPv6 works
417		*/
418
419		static int
420	280	ipvx_works(const char *target)
421		{
422		const struct suckaddr *sa;
423		int fd;
424
425	280	sa = VSS_ResolveOne(NULL, target, "0", 0, SOCK_STREAM, 0);
426	280	if (sa == NULL)
427	0	return (0);
428	280	fd = VTCP_bind(sa, NULL);
429	280	VSA_free(&sa);
430	280	if (fd >= 0) {
431	280	VTCP_close(&fd);
432	280	return (1);
433		}
434	0	return (0);
435	280	}
436
437		/**********************************************************************/
438
439		static int
440	40	addr_no_randomize_works(void)
441		{
442	40	int r = 0;
443
444		#ifdef HAVE_SYS_PERSONALITY_H
445		r = personality(0xffffffff);
446		r = personality(r \| ADDR_NO_RANDOMIZE);
447		#endif
448	40	return (r >= 0);
449		}
450
451		/**********************************************************************/
452
453		static int
454	40	uds_socket(void priv, const struct sockaddr_un uds)
455		{
456
457	40	return (VUS_bind(uds, priv));
458		}
459		static int
460	40	abstract_uds_works(void)
461		{
462		const char *err;
463		int fd;
464
465	40	fd = VUS_resolver("@vtc.feature.abstract_uds", uds_socket, NULL, &err);
466	40	if (fd < 0)
467	40	return (0);
468	0	AZ(close(fd));
469	0	return (1);
470	40	}
471
472		/* SECTION: feature feature
473		*
474		* Test that the required feature(s) for a test are available, and skip
475		* the test otherwise; or change the interpretation of the test, as
476		* documented below. feature takes any number of arguments from this list:
477		*
478		* 64bit
479		* The environment is 64 bits
480		* ipv4
481		* 127.0.0.1 works
482		* ipv6
483		* [::1] works
484		* dns
485		* DNS lookups are working
486		* topbuild
487		* The test has been started with '-i'
488		* root
489		* The test has been invoked by the root user
490		* user_varnish
491		* The varnish user is present
492		* user_vcache
493		* The vcache user is present
494		* group_varnish
495		* The varnish group is present
496		* cmd <command-line>
497		* A command line that should execute with a zero exit status
498		* ignore_unknown_macro
499		* Do not fail the test if a string of the form ${...} is not