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.vinyl-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.vinyl-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 <username>
 *        The <username> user is present
 * group <groupname>
 *        The <groupname> group is present
 * user_varnish
 *        The varnish user is present
 * user_vinyl
 *        The vinyl user is present
 * user_vcache
 *        The vcache user is present
 * group_varnish
 *        The varnish group is present
 * group_vinyl
 *        The vinyl 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.
 * vtest_cmd <command>
 *        vtest command <command> is available
 *
 * 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);   // XXX remove?
                FEATURE("user_vinyl", getpwnam("vinyl") != NULL);
                FEATURE("user_vcache", getpwnam("vcache") != NULL);
                FEATURE("group_varnish", getgrnam("varnish") != NULL); // XXX remove?
                FEATURE("group_vinyl", getgrnam("vinyl") != 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, "user")) {
                        av++;
                        if (*av == NULL)
                                vtc_fatal(vl, "Missing username");
                        good = 1;
                        if (getpwnam(*av) != NULL)
                                skip = neg;
                        else
                                skip = !neg;
                } else if (!strcmp(feat, "group")) {
                        av++;
                        if (*av == NULL)
                                vtc_fatal(vl, "Missing groupname");
                        good = 1;
                        if (getgrnam(*av) != NULL)
                                skip = neg;
                        else
                                skip = !neg;
                } else 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;
                } else if (!strcmp(feat, "vtest_cmd")) {
                        good = 1;
                        skip = !neg;
                        av++;
                        if (*av == NULL)
                                vtc_fatal(vl, "vtest_cmd needs the command name");
                        if (find_cmd(*av) != NULL)
                                skip = neg;
                }
                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;
        }
}

		vinyl-cache/bin/vinyltest/vtest2/src/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	46536	cmd_vtest(CMD_ARGS)
72		{
73
74	46536	(void)priv;
75	46536	(void)vl;
76	23331
77	23205	if (av == NULL)
78		return;
79	23205	AZ(strcmp(av[0], "vtest"));
80	23205
81	23205	vtc_log(vl, 1, "VTEST %s", av[1]);
82	46536	AZ(av[2]);
83		}
84
85		/* SECTION: varnishtest varnishtest
86		*
87		* Alternate name for 'vtest', see above.
88		*
89		*/
90
91	23457	void v_matchproto_(cmd_f)
92		cmd_varnishtest(CMD_ARGS)
93		{
94	23457
95	23457	(void)priv;
96	23331	(void)vl;
97	126
98		if (av == NULL)
99	126	return;
100	126	AZ(strcmp(av[0], "varnishtest"));
101	126
102	23457	vtc_log(vl, 1, "VTEST %s", av[1]);
103		AZ(av[2]);
104		}
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	10983
145		static void
146		cmd_shell_engine(struct vtclog vl, int ok, const char cmd,
147		const char expect, const char re)
148		{
149	10983	struct vsb *vsb, re_vsb[1];
150		FILE *fp;
151		vre_t *vre = NULL;
152		int r, c;
153		int err, erroff;
154	10983	char errbuf[VRE_ERROR_LEN];
155	10983
156	10983	AN(vl);
157	10983	AN(cmd);
158	10983	vsb = VSB_new_auto();
159	1806	AN(vsb);
160	1806	if (re != NULL) {
161	0	vre = VRE_compile(re, 0, &err, &erroff, 1);
162	0	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		VSB_fini(re_vsb);
167	0	vtc_fatal(vl,
168		"shell_match invalid regexp (\"%s\" at %d)",
169	1806	errbuf, erroff);
170	10983	}
171	10983	}
172	10983	VSB_printf(vsb, "set -e ;");
173	10983	VSB_printf(vsb, "exec 2>&1 ; %s", cmd);
174	10983	AZ(VSB_finish(vsb));
175	10983	vtc_dump(vl, 4, "shell_cmd", VSB_data(vsb), -1);
176	0	fp = popen(VSB_data(vsb), "r");
177	10983	if (fp == NULL)
178	10983	vtc_fatal(vl, "popen fails: %s", strerror(errno));
179	17171919	VSB_clear(vsb);
180	17171919	do {
181	17160936	c = getc(fp);
182	17171919	if (c != EOF)
183	10983	VSB_putc(vsb, c);
184	10983	} while (c != EOF);
185	10983	r = pclose(fp);
186	10983	AZ(VSB_finish(vsb));
187	10983	vtc_dump(vl, 4, "shell_out", VSB_data(vsb), VSB_len(vsb));
188	0	vtc_log(vl, 4, "shell_status = 0x%04x", WEXITSTATUS(r));
189		if (WIFSIGNALED(r))
190	10983	vtc_log(vl, 4, "shell_signal = %d", WTERMSIG(r));
191	0
192	10983	if (ok < 0 && !WEXITSTATUS(r) && !WIFSIGNALED(r))
193	84	vtc_fatal(vl, "shell did not fail as expected");
194	42	else if (ok >= 0 && WEXITSTATUS(r) != ok)
195		vtc_fatal(vl, "shell_exit not as expected: "
196	10941	"got 0x%04x wanted 0x%04x", WEXITSTATUS(r), ok);
197	5103
198	0	if (expect != NULL) {
199	0	if (strstr(VSB_data(vsb), expect) == NULL)
200		vtc_fatal(vl,
201	5103	"shell_expect not found: (\"%s\")", expect);
202	10941	else
203	1806	vtc_log(vl, 4, "shell_expect found");
204	0	} else if (vre != NULL) {
205		if (VRE_match(vre, VSB_data(vsb), VSB_len(vsb), 0, NULL) < 1)
206	1806	vtc_fatal(vl, "shell_match failed: (\"%s\")", re);
207	1806	else
208	1806	vtc_log(vl, 4, "shell_match succeeded");
209	10941	VRE_free(&vre);
210	10941	}
211		VSB_destroy(&vsb);
212		}
213
214	34314
215		void
216	34314	cmd_shell(CMD_ARGS)
217	34314	{
218		const char *expect = NULL;
219	34314	const char *re = NULL;
220		int n;
221	34314	int ok = 0;
222
223	34314	(void)priv;
224	23331
225	22827	if (av == NULL)
226	22827	return;
227	4452	for (n = 1; av[n] != NULL; n++) {
228	22827	if (!strcmp(av[n], "-err")) {
229	483	ok = -1;
230	483	} else if (!strcmp(av[n], "-exit")) {
231	18375	n += 1;
232	5103	ok = atoi(av[n]);
233	0	} else if (!strcmp(av[n], "-expect")) {
234		if (re != NULL)
235	5103	vtc_fatal(vl,
236	5103	"Cannot use -expect with -match");
237	17892	n += 1;
238	1806	expect = av[n];
239	0	} else if (!strcmp(av[n], "-match")) {
240		if (expect != NULL)
241	1806	vtc_fatal(vl,
242	1806	"Cannot use -match with -expect");
243	1806	n += 1;
244	10983	re = av[n];
245		} else {
246	11844	break;
247	10983	}
248	10983	}
249	34314	AN(av[n]);
250		cmd_shell_engine(vl, ok, av[n], expect, re);
251		}
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	24066
263		void v_matchproto_(cmd_f)
264		cmd_filewrite(CMD_ARGS)
265		{
266	24066	FILE *fo;
267		int n;
268	24066	const char *mode = "w";
269
270	24066	(void)priv;
271	23331
272	735	if (av == NULL)
273	357	return;
274	357	if (av[1] != NULL && !strcmp(av[1], "-a")) {
275	357	av++;
276	735	mode = "a";
277	0	}
278	735	if (av[1] == NULL)
279	735	vtc_fatal(vl, "Need filename");
280	0	fo = fopen(av[1], mode);
281	1764	if (fo == NULL)
282	1029	vtc_fatal(vl, "Cannot open %s: %s", av[1], strerror(errno));
283	735	for (n = 2; av[n] != NULL; n++)
284	24066	(void)fputs(av[n], fo);
285		AZ(fclose(fo));
286		}
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	23478
302		void v_matchproto_(cmd_f)
303		cmd_setenv(CMD_ARGS)
304		{
305		int r;
306	23478	int force;
307
308	23478	(void)priv;
309	23331
310	147	if (av == NULL)
311	147	return;
312		AN(av[1]);
313	147	AN(av[2]);
314	147
315	42	force = 1;
316	42	if (strcmp("-ifunset", av[1]) == 0) {
317	42	force = 0;
318	42	av++;
319	147	AN(av[2]);
320	147	}
321	147	if (av[3] != NULL)
322	0	vtc_fatal(vl, "CMD setenv: Unexpected argument '%s'", av[3]);
323	0	r = setenv(av[1], av[2], force);
324	23478	if (r != 0)
325		vtc_log(vl, 0, "CMD setenv %s=\"%s\" failed: %s",
326		av[1], av[2], strerror(errno));
327		}
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	38549	* can include a fractional part, e.g. 1.5.
335		*/
336		void
337		cmd_delay(CMD_ARGS)
338	38549	{
339	38549	double f;
340	23331
341	15218	(void)priv;
342	15218	if (av == NULL)
343	15218	return;
344	15218	AN(av[1]);
345	0	AZ(av[2]);
346	15218	f = VNUM(av[1]);
347	15218	if (isnan(f))
348	38549	vtc_fatal(vl, "Syntax error in number (%s)", av[1]);
349		vtc_log(vl, 3, "delaying %g second(s)", f);
350		VTIM_sleep(f);
351		}
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	23415	*
362		*/
363		void
364		cmd_include(CMD_ARGS)
365		{
366	23415	char *spec;
367	23331	unsigned i;
368
369	84	if (av == NULL)
370	0	return;
371
372	210	if (av[1] == NULL)
373	126	vtc_fatal(vl, "CMD include: At least 1 argument required");
374	126
375	0	for (i = 1; av[i] != NULL; i++) {
376	0	spec = VFIL_readfile(NULL, av[i], NULL);
377	126	if (spec == NULL)
378	126	vtc_fatal(vl, "CMD include: Unable to read file '%s' "
379	126	"(%s)", av[i], strerror(errno));
380	126	vtc_log(vl, 2, "Begin include '%s'", av[i]);
381	126	parse_string(vl, priv, spec);
382	23415	vtc_log(vl, 2, "End include '%s'", av[i]);
383		free(spec);
384		}
385		}
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	21	*/
391
392		static int
393		dns_works(void)
394		{
395		const struct suckaddr *sa;
396	21	char abuf[VTCP_ADDRBUFSIZE];
397		char pbuf[VTCP_PORTBUFSIZE];
398	21
399	1	sa = VSS_ResolveOne(NULL, "dns-canary.vinyl-cache.org", NULL,
400	20	AF_INET, SOCK_STREAM, 0);
401	20	if (sa == NULL)
402	20	return (0);
403	0	VTCP_name(sa, abuf, sizeof abuf, pbuf, sizeof pbuf);
404		VSA_free(&sa);
405	20	if (strcmp(abuf, "192.0.2.255"))
406		return (0);
407	20
408	20	sa = VSS_ResolveOne(NULL, "dns-canary.vinyl-cache.org", NULL,
409	0	AF_INET6, SOCK_STREAM, 0);
410	0	if (sa == NULL)
411	21	return (1); /* the canary is ipv4 only */
412		VSA_free(&sa);
413		return (0);
414		}
415
416		/**********************************************************************
417		* Test if IPv4/IPv6 works
418	231	*/
419
420		static int
421		ipvx_works(const char *target)
422		{
423	231	const struct suckaddr *sa;
424	231	int fd;
425	0
426	231	sa = VSS_ResolveOne(NULL, target, "0", 0, SOCK_STREAM, 0);
427	231	if (sa == NULL)
428	231	return (0);
429	231	fd = VTCP_bind(sa, NULL);
430	231	VSA_free(&sa);
431		if (fd >= 0) {
432	0	VTCP_close(&fd);
433	231	return (1);
434		}
435		return (0);
436		}
437
438	0	/**********************************************************************/
439
440	0	static int
441		addr_no_randomize_works(void)
442		{
443		int r = 0;
444
445		#ifdef HAVE_SYS_PERSONALITY_H
446	0	r = personality(0xffffffff);
447		r = personality(r \| ADDR_NO_RANDOMIZE);
448		#endif
449		return (r >= 0);
450		}
451
452	21	/**********************************************************************/
453
454		static int
455	21	uds_socket(void priv, const struct sockaddr_un uds)
456		{
457
458	21	return (VUS_bind(uds, priv));
459		}
460		static int
461		abstract_uds_works(void)
462		{
463	21	const char *err;
464	21	int fd;
465	21
466	0	fd = VUS_resolver("@vtc.feature.abstract_uds", uds_socket, NULL, &err);
467	0	if (fd < 0)
468	21	return (0);
469		AZ(close(fd));
470		return (1);
471		}
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 <username>
492		* The <username> user is present
493		* group <groupname>
494		* The <groupname> group is present
495		* user_varnish
496		* The varnish user is present
497		* user_vinyl
498		* The vinyl user is present
499		* user_vcache