GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2017 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.
 *
 * The management process and CLI handling
 */

#include "config.h"

#include <ctype.h>
#include <fcntl.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/socket.h>

#include "mgt/mgt.h"
#include "acceptor/mgt_acceptor.h"
#include "common/heritage.h"

#include "hash/hash_slinger.h"
#include "libvcc.h"
#include "vcli_serve.h"
#include "vct.h"
#include "vev.h"
#include "vfil.h"
#include "vin.h"
#include "vpf.h"
#include "vrnd.h"
#include "vsha256.h"
#include "vsub.h"
#include "vtim.h"
#include "waiter/mgt_waiter.h"
#include "vsa.h"
#include "vus.h"

struct heritage         heritage;
unsigned                d_flag = 0;
struct vev_root         *mgt_evb;
int                     exit_status = 0;
struct vsb              *vident;
struct VSC_mgt          *VSC_C_mgt;
static int              I_fd = -1;
static char             *workdir;

static struct vfil_path *vcl_path = NULL;

static const char opt_spec[] = "?a:b:CdE:f:Fh:i:I:j:l:M:n:P:p:r:S:s:T:t:VW:x:";

/*--------------------------------------------------------------------*/

// Basic options documentation with compile time dependencies
static void
mgt_DumpOptions(void)
{
        printf(".. _opt_n:\n\n");
        printf("-n workdir\n\n");
        printf("  Runtime directory for the shared memory, "
               "compiled VCLs etc.\n\n");
        printf("  In performance critical applications, this directory "
               "should be on a RAM backed filesystem.\n\n");
        printf("  When running multiple vinyld instances, separate "
               "directories need to be used.\n\n");
        VIN_DumpDefaults();
}

static void
usage(void)
{
        char *p;

#define FMT_NONL "  %-35s # %s"
#define FMT FMT_NONL "\n"

        printf( "Usage: vinyld [options]\n");

        printf("\nBasic options:\n");

        printf(FMT, "[-a [name=][listen_address",
            "HTTP listen address, protocol, options.");
        printf(FMT, "     [,PROTO|,option=value,...]]",
            "Can be specified multiple times.");
        printf(FMT, "",
            "  default: \":80,HTTP\"");
        printf(FMT, "  options:",
            "Proto can be \"PROXY\" or \"HTTP\" (default)");
        printf(FMT, "    [,user=<u>][,group=<g>]",
            "user, group and mode set permissions for");
        printf(FMT, "    [,mode=<m>]",
            "  a Unix domain socket.");
        printf(FMT, "-b none", "No backend");
        printf(FMT, "-b [addr[:port]|path]", "Backend address and port");
        printf(FMT, "", "  or socket file path");
        printf(FMT, "", "  default: \":80\"");
        printf(FMT, "-f vclfile", "VCL program");
        printf(FMT, "", "Can be specified multiple times.");
        printf(FMT, "-n dir", "Working directory");

        p = VIN_n_Arg(NULL);
        AN(p);
        printf(FMT_NONL "  default: %s\n", "", "", p);
        free(p);

        printf("\n-b can be used only once, and not together with -f\n");

        printf("\nDocumentation options:\n");
        printf(FMT, "-?", "Prints this usage message");
        printf(FMT, "-x parameter", "Parameter documentation in RST format");
        printf(FMT, "-x parameter-json", "Parameter documentation in JSON format");
        printf(FMT, "-x vsl", "VSL record documentation");
        printf(FMT, "-x cli", "CLI command documentation");
        printf(FMT, "-x builtin", "Builtin VCL program");
        printf(FMT, "-x optstring", "List of getopt options");
        printf(FMT, "-x options", "Dynamic options documentation");

        printf("\nOperations options:\n");

        printf(FMT, "-F", "Run in foreground");
        printf(FMT, "-T address[:port]", "CLI address");
        printf(FMT, "", "Can be specified multiple times.");
        printf(FMT, "-M address:port", "Reverse CLI destination");
        printf(FMT, "", "Can be specified multiple times.");
        printf(FMT, "-P file", "PID file");
        printf(FMT, "-i identity", "Identity of Vinyl Cache instance");
        printf(FMT, "-I clifile", "Initialization CLI commands");
        printf(FMT, "-E extension", "Load extension");

        printf("\nTuning options:\n");

        printf(FMT, "-t TTL", "Default TTL");
        printf(FMT, "-p param=value", "set parameter");
        printf(FMT, "", "Can be specified multiple times.");

        printf(FMT, "-s [name=]kind[,options]", "Storage specification");
        printf(FMT, "", "Can be specified multiple times.");
#ifdef HAVE_UMEM_H
        printf(FMT, "", "  -s default (=umem)");
        printf(FMT, "", "  -s umem");
#else
        printf(FMT, "", "  -s default (=malloc)");
#endif
        printf(FMT, "", "  -s malloc");
        printf(FMT, "", "  -s file");

        printf(FMT, "-l vsl", "Size of shared memory log");
        printf(FMT, "", "  vsl: space for VSL records [80m]");

        printf("\nSecurity options:\n");

        printf(FMT, "-r param[,param...]", "Set parameters read-only from CLI");
        printf(FMT, "", "Can be specified multiple times.");
        printf(FMT, "-S secret-file", "Secret file for CLI authentication");
        printf(FMT, "-j jail[,options]", "Jail specification");
#ifdef HAVE_SETPPRIV
        printf(FMT, "", "  -j solaris");
#endif
#ifdef __linux__
        printf(FMT, "", "  -j linux");
#endif
        printf(FMT, "", "  -j unix");
        printf(FMT, "", "  -j none");

        printf("\nAdvanced/Dev/Debug options:\n");

        printf(FMT, "-d", "debug mode");
        printf(FMT, "", "Stay in foreground, CLI on stdin.");
        printf(FMT, "-C", "Output VCL code compiled to C language");
        printf(FMT, "-V", "version");
        printf(FMT, "-h kind[,options]", "Hash specification");
        printf(FMT, "-W waiter", "Waiter implementation");
}

/*--------------------------------------------------------------------*/

struct arg_list {
        unsigned                magic;
#define ARG_LIST_MAGIC          0x7b0d1bc4
        char                    arg[2];
        char                    *val;
        VTAILQ_ENTRY(arg_list)  list;
        void                    *priv;
};

static VTAILQ_HEAD(, arg_list) arglist = VTAILQ_HEAD_INITIALIZER(arglist);

static struct arg_list *
arg_list_add(const char arg, const char *val)
{
        struct arg_list *alp;

        ALLOC_OBJ(alp, ARG_LIST_MAGIC);
        AN(alp);
        alp->arg[0] = arg;
        alp->arg[1] = '\0';
        REPLACE(alp->val, val);
        VTAILQ_INSERT_TAIL(&arglist, alp, list);
        return (alp);
}

static unsigned
arg_list_count(const char *arg)
{
        unsigned retval = 0;
        struct arg_list *alp;

        VTAILQ_FOREACH(alp, &arglist, list) {
                if (!vstrcmp(alp->arg, arg))
                        retval++;
        }
        return (retval);
}

/*--------------------------------------------------------------------*/

static void
cli_check(const struct cli *cli)
{
        if (cli->result == CLIS_OK || cli->result == CLIS_TRUNCATED) {
                AZ(VSB_finish(cli->sb));
                if (VSB_len(cli->sb) > 0)
                        fprintf(stderr, "Warnings:\n%s\n", VSB_data(cli->sb));
                VSB_clear(cli->sb);
                return;
        }
        AZ(VSB_finish(cli->sb));
        fprintf(stderr, "Error:\n%s\n", VSB_data(cli->sb));
        exit(2);
}

/*--------------------------------------------------------------------
 * This function is called when the CLI on stdin is closed.
 */

static int v_matchproto_(mgt_cli_close_f)
mgt_stdin_close(void *priv)
{

        (void)priv;
        return (-42);
}

/*--------------------------------------------------------------------
 * Autogenerate a -S file using strong random bits from the kernel.
 */

static void
mgt_secret_atexit(void)
{

        /* Only master process */
        if (getpid() != heritage.mgt_pid)
                return;
        VJ_master(JAIL_MASTER_FILE);
        (void)unlink("_.secret");
        VJ_master(JAIL_MASTER_LOW);
}

static const char *
make_secret(const char *dirname)
{
        char *fn;
        int fdo;
        int i;
        unsigned char b;

        assert(asprintf(&fn, "%s/_.secret", dirname) > 0);

        VJ_master(JAIL_MASTER_FILE);
        if (unlink(fn) < 0 && errno != ENOENT) {
                ARGV_ERR("Cannot remove preexisting secret-file in %s (%s)\n",
                    dirname, VAS_errtxt(errno));
        }

        fdo = open(fn, O_RDWR|O_CREAT|O_EXCL, 0640);
        if (fdo < 0) {
                ARGV_ERR("Cannot create secret-file in %s (%s)\n",
                    dirname, VAS_errtxt(errno));
        }

        for (i = 0; i < 256; i++) {
                AZ(VRND_RandomCrypto(&b, 1));
                assert(1 == write(fdo, &b, 1));
        }
        closefd(&fdo);
        VJ_master(JAIL_MASTER_LOW);
        AZ(atexit(mgt_secret_atexit));
        return (fn);
}

static void
mgt_Cflag_atexit(void)
{

        /* Only master process */
        if (getpid() != heritage.mgt_pid)
                return;
        if (arg_list_count("E")) {
                vext_cleanup(1);
                VJ_rmdir("vext_cache");
        }
        VJ_rmdir("vmod_cache");
        VJ_rmdir("worker_tmpdir");
        (void)chdir("/");
        VJ_rmdir(workdir);
}

/*--------------------------------------------------------------------*/

static void
mgt_tests(void)
{
        assert(VTIM_parse("Sun, 06 Nov 1994 08:49:37 GMT") == 784111777);
        assert(VTIM_parse("Sunday, 06-Nov-94 08:49:37 GMT") == 784111777);
        assert(VTIM_parse("Sun Nov  6 08:49:37 1994") == 784111777);

        /* Check that our VSHA256 works */
        VSHA256_Test();
}

static void
mgt_initialize(struct cli *cli)
{
        static unsigned clilim = 32768;

        /* for ASSERT_MGT() */
        heritage.mgt_pid = getpid();

        /* Create a cli for convenience in otherwise CLI functions */
        INIT_OBJ(cli, CLI_MAGIC);
        cli[0].sb = VSB_new_auto();
        AN(cli[0].sb);
        cli[0].result = CLIS_OK;
        cli[0].limit = &clilim;

        mgt_cli_init_cls();             // CLI commands can be registered

        MCF_InitParams(cli);

        VCC_VCL_Range(&heritage.min_vcl_version, &heritage.max_vcl_version);

        cli_check(cli);
}

static void
mgt_x_arg(const char *x_arg)
{
        if (!vstrcmp(x_arg, "parameter"))
                MCF_DumpRstParam();
        else if (!vstrcmp(x_arg, "parameter-json"))
                MCF_DumpJsonParam();
        else if (!vstrcmp(x_arg, "vsl"))
                mgt_DumpRstVsl();
        else if (!vstrcmp(x_arg, "cli"))
                mgt_DumpRstCli();
        else if (!vstrcmp(x_arg, "builtin"))
                mgt_DumpBuiltin();
        else if (!vstrcmp(x_arg, "optstring"))
                (void)printf("%s\n", opt_spec);
        else if (!vstrcmp(x_arg, "options"))
                mgt_DumpOptions();
        else
                ARGV_ERR("Invalid -x argument\n");
}

/*--------------------------------------------------------------------*/

#define ERIC_MAGIC 0x2246988a           /* Eric is not random */

static int
mgt_eric(void)
{
        int eric_pipes[2];
        unsigned u;
        ssize_t sz;

        AZ(pipe(eric_pipes));

        switch (fork()) {
        case -1:
                fprintf(stderr, "Fork() failed: %s\n", VAS_errtxt(errno));
                exit(-1);
        case 0:
                closefd(&eric_pipes[0]);
                assert(setsid() > 1);

                VFIL_null_fd(STDIN_FILENO);
                return (eric_pipes[1]);
        default:
                break;
        }
        closefd(&eric_pipes[1]);
        sz = read(eric_pipes[0], &u, sizeof u);
        if (sz == sizeof u && u == ERIC_MAGIC)
                exit(0);
        else if (sz == sizeof u && u != 0)
                exit(u);
        else
                exit(-1);
}

static void
mgt_eric_im_done(int eric_fd, unsigned u)
{

        if (u == 0)
                u = ERIC_MAGIC;

        VFIL_null_fd(STDIN_FILENO);
        VFIL_null_fd(STDOUT_FILENO);
        VFIL_null_fd(STDERR_FILENO);

        assert(write(eric_fd, &u, sizeof u) == sizeof u);
        closefd(&eric_fd);
}

/*--------------------------------------------------------------------*/

static int v_matchproto_(vev_cb_f)
mgt_sigint(const struct vev *e, int what)
{

        (void)what;
        MGT_Complain(C_INFO, "Manager got %s from PID %jd",
            e->name, (intmax_t)e->siginfo->si_pid);
        (void)fflush(stdout);
        if (MCH_Running())
                MCH_Stop_Child();
        return (-42);
}

/*--------------------------------------------------------------------*/

static int v_matchproto_(vev_cb_f)
mgt_uptime(const struct vev *e, int what)
{
        static double mgt_uptime_t0 = 0;

        (void)e;
        (void)what;
        AN(VSC_C_mgt);
        if (mgt_uptime_t0 == 0)
                mgt_uptime_t0 = VTIM_real();
        VSC_C_mgt->uptime = (uint64_t)(VTIM_real() - mgt_uptime_t0);
        return (0);
}

/*--------------------------------------------------------------------*/

static int v_matchproto_(mgt_cli_close_f)
mgt_I_close(void *priv)
{
        (void)priv;
        fprintf(stderr, "END of -I file processing\n");
        I_fd = -1;
        return (0);
}

/*--------------------------------------------------------------------*/

struct f_arg {
        unsigned                magic;
#define F_ARG_MAGIC             0x840649a8
        char                    *farg;
        char                    *src;
};

static struct f_arg *
mgt_f_read(const char *fn)
{
        struct f_arg *fa;
        char *f, *fnp;

        ALLOC_OBJ(fa, F_ARG_MAGIC);
        AN(fa);
        REPLACE(fa->farg, fn);
        VFIL_setpath(&vcl_path, mgt_vcl_path);
        if (VFIL_searchpath(vcl_path, NULL, &f, fn, &fnp) || f == NULL) {
                ARGV_ERR("Cannot read -f file '%s' (%s)\n",
                    fnp != NULL ? fnp : fn, VAS_errtxt(errno));
        }
        free(fa->farg);
        fa->farg = fnp;
        fa->src = f;
        return (fa);
}

static void
mgt_b_conv(const char *b_arg)
{
        struct f_arg *fa;
        struct vsb *vsb;

        ALLOC_OBJ(fa, F_ARG_MAGIC);
        AN(fa);
        REPLACE(fa->farg, "<-b argument>");
        vsb = VSB_new_auto();
        AN(vsb);
        VSB_cat(vsb, "vcl 4.1;\n");
        VSB_cat(vsb, "backend default ");
        if (!strcasecmp(b_arg, "none"))
                VSB_cat(vsb, "none;\n");
        else if (VUS_is(b_arg))
                VSB_printf(vsb, "{\n    .path = \"%s\";\n}\n", b_arg);
        else
                VSB_printf(vsb, "{\n    .host = \"%s\";\n}\n", b_arg);
        AZ(VSB_finish(vsb));
        fa->src = strdup(VSB_data(vsb));
        AN(fa->src);
        VSB_destroy(&vsb);
        AZ(arg_list_count("f"));
        arg_list_add('f', "")->priv = fa;
}

static int
mgt_process_f_arg(struct cli *cli, unsigned C_flag, void **fap)
{
        int retval = 0;
        struct f_arg *fa;
        const char *name = NULL;

        TAKE_OBJ_NOTNULL(fa, fap, F_ARG_MAGIC);
        if (arg_list_count("f") == 1)
                name = "boot";
        mgt_vcl_startup(cli, fa->src, name, fa->farg, C_flag);
        if (C_flag) {
                if (cli->result != CLIS_OK &&
                    cli->result != CLIS_TRUNCATED)
                        retval = 2;
                AZ(VSB_finish(cli->sb));
                fprintf(stderr, "%s\n", VSB_data(cli->sb));
                VSB_clear(cli->sb);
        } else {
                cli_check(cli);
        }
        free(fa->farg);
        free(fa->src);
        FREE_OBJ(fa);
        return (retval);
}

static char *
create_bogo_n_arg(void)
{
        struct vsb *vsb;
        char *p;

        vsb = VSB_new_auto();
        AN(vsb);
        if (getenv("TMPDIR") != NULL)
                VSB_printf(vsb, "%s", getenv("TMPDIR"));
        else
                VSB_cat(vsb, "/tmp");
        VSB_cat(vsb, "/vinyld_C_XXXXXXX");
        AZ(VSB_finish(vsb));
        p = strdup(VSB_data(vsb));
        AN(p);
        VSB_destroy(&vsb);
        AN(mkdtemp(p));
        AZ(chmod(p, 0750));
        return (p);
}

static struct vpf_fh *
create_pid_file(pid_t *ppid, const char *fmt, ...)
{
        struct vsb *vsb;
        va_list ap;
        struct vpf_fh *pfh;

        va_start(ap, fmt);
        vsb = VSB_new_auto();
        AN(vsb);
        VSB_vprintf(vsb, fmt, ap);
        AZ(VSB_finish(vsb));
        VJ_master(JAIL_MASTER_FILE);
        pfh = VPF_Open(VSB_data(vsb), 0644, ppid);
        if (pfh == NULL && errno == EEXIST)
                ARGV_ERR(
                    "vinyld is already running (pid=%jd) (pidfile=%s)\n",
                    (intmax_t)*ppid, VSB_data(vsb));
        if (pfh == NULL)
                ARGV_ERR("Could not open pid-file (%s): %s\n",
                    VSB_data(vsb), VAS_errtxt(errno));
        VJ_master(JAIL_MASTER_LOW);
        VSB_destroy(&vsb);
        va_end(ap);
        return (pfh);
}

int
main(int argc, char * const *argv)
{
        int o, eric_fd = -1;
        unsigned C_flag = 0;
        unsigned F_flag = 0;
        const char *b_arg = NULL;
        const char *i_arg = NULL;
        const char *j_arg = NULL;
        const char *h_arg = "critbit";
        const char *n_arg = getenv("VINYL_DEFAULT_N");
        const char *S_arg = NULL;
        const char *s_arg = "default,100m";
        const char *W_arg = NULL;
        const char *c;
        char *p;
        struct cli cli[1];
        const char *err;
        unsigned u;
        struct sigaction sac;
        struct vev *e;
        pid_t pid;
        struct arg_list *alp;
        int first_arg = 1;
        struct vsb *vsb;

        if (argc == 2 && !vstrcmp(argv[1], "--optstring")) {
                printf("%s\n", opt_spec);
                exit(0);
        }

        heritage.argc = argc;
        heritage.argv = argv;

        setbuf(stdout, NULL);
        setbuf(stderr, NULL);

        mgt_tests();

        mgt_initialize(cli);

        for (; (o = getopt(argc, argv, opt_spec)) != -1; first_arg = 0) {
                switch (o) {
                case 'V':
                        if (!first_arg)
                                ARGV_ERR("-V must be the first argument\n");
                        if (argc != 2)
                                ARGV_ERR("Too many arguments for -V\n");
                        VCS_Message("vinyld");
                        exit(0);
                case 'x':
                        if (!first_arg)
                                ARGV_ERR("-x must be the first argument\n");
                        if (argc != 3)
                                ARGV_ERR("Too many arguments for -x\n");
                        mgt_x_arg(optarg);
                        exit(0);
                case 'b':
                        b_arg = optarg;
                        break;
                case 'C':
                        C_flag = 1;
                        break;
                case 'd':
                        d_flag++;
                        break;
                case 'F':
                        F_flag = 1;
                        break;
                case 'j':
                        j_arg = optarg;
                        break;
                case 'h':
                        h_arg = optarg;
                        break;
                case 'i':
                        i_arg = optarg;
                        break;
                case 'l':
                        arg_list_add('p', "vsl_space")->priv = optarg;
                        break;
                case 'n':
                        n_arg = optarg;
                        break;
                case 'S':
                        S_arg = optarg;
                        break;
                case 't':
                        arg_list_add('p', "default_ttl")->priv = optarg;
                        break;
                case 'W':
                        W_arg = optarg;
                        break;
                case 'a':
                case 'E':
                case 'f':
                case 'I':
                case 'p':
                case 'P':
                case 'M':
                case 'r':
                case 's':
                case 'T':
                        (void)arg_list_add(o, optarg);
                        break;
                default:
                        usage();
                        exit(2);
                }
        }

        if (argc != optind)
                ARGV_ERR("Too many arguments (%s...)\n", argv[optind]);

        if (b_arg != NULL && arg_list_count("f"))
                ARGV_ERR("Only one of -b or -f can be specified\n");

        if (d_flag && F_flag)
                ARGV_ERR("Only one of -d or -F can be specified\n");

        if (C_flag && b_arg == NULL && !arg_list_count("f"))
                ARGV_ERR("-C needs either -b <backend> or -f <vcl_file>\n");

        if (d_flag && C_flag)
                ARGV_ERR("-d makes no sense with -C\n");

        if (F_flag && C_flag)
                ARGV_ERR("-F makes no sense with -C\n");

        if (!d_flag && b_arg == NULL && !arg_list_count("f"))
                ARGV_ERR("Neither -b nor -f given. (use -f '' to override)\n");

        if (arg_list_count("I") > 1)
                ARGV_ERR("\tOnly one -I allowed\n");

        if (d_flag || F_flag)
                complain_to_stderr = 1;

        if (!arg_list_count("T"))
                (void)arg_list_add('T', "localhost:0");

        /*
         * Start out by closing all unwanted file descriptors we might
         * have inherited from sloppy process control daemons.
         */
        VSUB_closefrom(STDERR_FILENO + 1);
        MCH_TrackHighFd(STDERR_FILENO);

        /*
         * Have Eric Daemonize us if need be
         */
        if (!C_flag && !d_flag && !F_flag) {
                eric_fd = mgt_eric();
                MCH_TrackHighFd(eric_fd);
                heritage.mgt_pid = getpid();
        }

        VRND_SeedAll();

        vident = mgt_BuildVident();

        /* Various initializations */
        VTAILQ_INIT(&heritage.socks);
        VCA_Config();
        mgt_evb = VEV_New();
        AN(mgt_evb);

        /* Initialize transport protocols */
        XPORT_Init();

        VJ_Init(j_arg);

        /* Initialize the bogo-IP VSA */
        VSA_Init();

        if (b_arg != NULL)
                mgt_b_conv(b_arg);

        /* Process delayed arguments */
        VTAILQ_FOREACH(alp, &arglist, list) {
                switch(alp->arg[0]) {
                case 'a':
                        VCA_Arg(alp->val);
                        break;
                case 'f':
                        if (*alp->val != '\0')
                                alp->priv = mgt_f_read(alp->val);
                        break;
                case 'E':
                        vext_argument(alp->val);
                        break;
                case 'I':
                        VJ_master(JAIL_MASTER_FILE);
                        I_fd = open(alp->val, O_RDONLY);
                        if (I_fd < 0)
                                ARGV_ERR("\tCan't open %s: %s\n",
                                    alp->val, VAS_errtxt(errno));
                        VJ_master(JAIL_MASTER_LOW);
                        break;
                case 'p':
                        if (alp->priv) {
                                MCF_ParamSet(cli, alp->val, alp->priv);
                        } else {
                                p = strchr(alp->val, '=');
                                if (p == NULL)
                                        ARGV_ERR("\t-p lacks '='\n");
                                AN(p);
                                *p++ = '\0';
                                MCF_ParamSet(cli, alp->val, p);
                        }
                        break;
                case 'r':
                        MCF_ParamProtect(cli, alp->val);
                        break;
                case 's':
                        STV_Config(alp->val);
                        break;
                default:
                        break;
                }
                cli_check(cli);
        }

        VCLS_SetLimit(mgt_cls, &mgt_param.cli_limit);

        assert(d_flag == 0 || F_flag == 0);

        p = NULL;
        if (C_flag && n_arg == NULL) {
                p = create_bogo_n_arg();
                n_arg = p;
        }

        if (S_arg != NULL && !vstrcmp(S_arg, "none")) {
                fprintf(stderr,
                    "Warning: CLI authentication disabled.\n");
        } else if (S_arg != NULL) {
                VJ_master(JAIL_MASTER_FILE);
                o = open(S_arg, O_RDONLY, 0);
                if (o < 0)
                        ARGV_ERR("Cannot open -S file (%s): %s\n",
                            S_arg, VAS_errtxt(errno));
                closefd(&o);
                VJ_master(JAIL_MASTER_LOW);
        }

        workdir = VIN_n_Arg(n_arg);
        AN(workdir);
        if (p != NULL)
                free(p);

        if (i_arg == NULL || *i_arg == '\0')
                i_arg = mgt_HostName();
        else for (c = i_arg; *c != '\0'; c++) {
                if (!vct_istchar(*c))
                        ARGV_ERR("Invalid character '%c' for -i\n", *c);
        }
        heritage.identity = i_arg;

        mgt_ProcTitle("Mgt");

        openlog("vinyld", LOG_PID, LOG_LOCAL0);

        vsb = VSB_new_auto();
        AN(vsb);
        o = VJ_make_workdir(workdir, vsb);
        MGT_ComplainVSB(o ? C_ERR : C_INFO, vsb);
        if (o)
                ARGV_EXIT;

        if (! C_flag) {
                VTAILQ_FOREACH(alp, &arglist, list) {
                        if (!vstrcmp(alp->arg, "P"))
                                alp->priv = create_pid_file(&pid, "%s", alp->val);
                }

                /* Implicit -P argument */
                alp = arg_list_add('P', NULL);
                alp->priv = create_pid_file(&pid, "%s/_.pid", workdir);
        }

        VJ_master(JAIL_MASTER_SYSTEM);
#ifdef RLIMIT_MEMLOCK
        /* try to raise to max (ignore error), then set _cur to whatever we got */
        struct rlimit rlim;
        rlim.rlim_cur = 0;
        rlim.rlim_max = RLIM_INFINITY;
        (void)setrlimit(RLIMIT_MEMLOCK, &rlim);
        AZ(getrlimit(RLIMIT_MEMLOCK, &rlim));
        rlim.rlim_cur = rlim.rlim_max;
        AZ(setrlimit(RLIMIT_MEMLOCK, &rlim));
#endif

        AZ(system("rm -rf vmod_cache vext_cache worker_tmpdir"));
        VJ_master(JAIL_MASTER_LOW);

        VSB_clear(vsb);
        o = VJ_make_subdir("vmod_cache", "VMOD cache", vsb) ||
            VJ_make_subdir("worker_tmpdir",
                "TMPDIR for the worker process", vsb) ||
            (arg_list_count("E") &&
                VJ_make_subdir("vext_cache", "VEXT cache", vsb));
        MGT_ComplainVSB(o ? C_ERR : C_INFO, vsb);
        VSB_destroy(&vsb);
        if (o)
                ARGV_EXIT;

        o = open("worker_tmpdir", O_RDONLY);
        VJ_master(JAIL_MASTER_SYSTEM);
        VJ_fix_fd(o, JAIL_FIXFD_WRKTMP);
        VJ_master(JAIL_MASTER_LOW);
        closefd(&o);

        if (C_flag)
                AZ(atexit(mgt_Cflag_atexit));

        /* If no -s argument specified, process default -s argument */
        if (!arg_list_count("s"))
                STV_Config(s_arg);

        /* Configure CLI and special storages, if user did not */
        STV_Config_Final();

        mgt_vcl_init();

        vext_copyin(vident);

        u = 0;
        VTAILQ_FOREACH(alp, &arglist, list) {
                if (!vstrcmp(alp->arg, "f") && alp->priv != NULL)
                        u |= mgt_process_f_arg(cli, C_flag, &alp->priv);
        }
        if (C_flag)
                exit(u);

        if (VTAILQ_EMPTY(&heritage.socks))
                VCA_Arg(":80\0");       // XXX: extra NUL for FlexeLint

        assert(!VTAILQ_EMPTY(&heritage.socks));

        HSH_config(h_arg);

        Wait_config(W_arg);

        mgt_SHM_Init();

        mgt_SHM_static_alloc(i_arg, vstrlen(i_arg) + 1L, "Arg", "-i");
        VSC_C_mgt = VSC_mgt_New(NULL, NULL, "");

        VTAILQ_FOREACH(alp, &arglist, list) {
                if (!vstrcmp(alp->arg, "M"))
                        mgt_cli_master(alp->val);
                else if (!vstrcmp(alp->arg, "T") && vstrcmp(alp->val, "none"))
                        mgt_cli_telnet(alp->val);
                else if (!vstrcmp(alp->arg, "P"))
                        VPF_Write(alp->priv);
        }

        AZ(VSB_finish(vident));

        if (S_arg == NULL)
                S_arg = make_secret(workdir);
        AN(S_arg);

        MGT_Complain(C_DEBUG, "Version: %s", VCS_String("V"));
        MGT_Complain(C_DEBUG, "Platform: %s", VSB_data(vident) + 1);

        if (d_flag)
                mgt_cli_setup(0, 1, 1, "debug", mgt_stdin_close, NULL);

        if (vstrcmp(S_arg, "none"))
                mgt_cli_secret(S_arg);

        memset(&sac, 0, sizeof sac);
        sac.sa_handler = SIG_IGN;
        sac.sa_flags = SA_RESTART;

        AZ(sigaction(SIGPIPE, &sac, NULL));
        AZ(sigaction(SIGHUP, &sac, NULL));

        MCH_Init();

        if (I_fd >= 0) {
                fprintf(stderr, "BEGIN of -I file processing\n");
                /* We must dup stderr, because VCLS closes the output fd */
                mgt_cli_setup(I_fd, dup(2), 1, "-I file", mgt_I_close, stderr);
                while (I_fd >= 0) {
                        o = VEV_Once(mgt_evb);
                        if (o != 1)
                                MGT_Complain(C_ERR,
                                    "VEV_Once() = %d", o);
                }
        }
        assert(I_fd == -1);

        err = mgt_has_vcl();
        if (!d_flag && err != NULL && !arg_list_count("f"))
                MGT_Complain(C_ERR, "%s", err);

        if (err == NULL && !d_flag)
                u = MCH_Start_Child();
        else
                u = 0;

        if (eric_fd >= 0)
                mgt_eric_im_done(eric_fd, u);

        if (u)
                exit(u);

        /* Failure is no longer an option */

        if (F_flag)
                VFIL_null_fd(STDIN_FILENO);

        e = VEV_Alloc();
        AN(e);
        e->callback = mgt_uptime;
        e->timeout = 1.0;
        e->name = "mgt_uptime";
        AZ(VEV_Start(mgt_evb, e));

        e = VEV_Alloc();
        AN(e);
        e->sig = SIGTERM;
        e->callback = mgt_sigint;
        e->name = "SIGTERM";
        AZ(VEV_Start(mgt_evb, e));

        e = VEV_Alloc();
        AN(e);
        e->sig = SIGINT;
        e->callback = mgt_sigint;
        e->name = "SIGINT";
        AZ(VEV_Start(mgt_evb, e));

        o = VEV_Loop(mgt_evb);
        if (o != 0 && o != -42)
                MGT_Complain(C_ERR, "VEV_Loop() = %d", o);

        MGT_Complain(C_INFO, "manager stopping child");
        MCH_Stop_Child();
        MGT_Complain(C_INFO, "manager dies");
        mgt_cli_close_all();
        VEV_Destroy(&mgt_evb);
        VJ_master(JAIL_MASTER_SYSTEM);
        /*lint -e(730)*/
        vext_cleanup(! MGT_DO_DEBUG(DBG_VMOD_SO_KEEP));
        (void)rmdir("vext_cache");
        VJ_master(JAIL_MASTER_LOW);
        VTAILQ_FOREACH(alp, &arglist, list) {
                if (!vstrcmp(alp->arg, "P"))
                        VPF_Remove(alp->priv);
        }
        exit(exit_status);
}

		vinyl-cache/bin/vinyld/mgt/mgt_main.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2017 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		*
7		* SPDX-License-Identifier: BSD-2-Clause
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		* 1. Redistributions of source code must retain the above copyright
13		* notice, this list of conditions and the following disclaimer.
14		* 2. Redistributions in binary form must reproduce the above copyright
15		* notice, this list of conditions and the following disclaimer in the
16		* documentation and/or other materials provided with the distribution.
17		*
18		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28		* SUCH DAMAGE.
29		*
30		* The management process and CLI handling
31		*/
32
33		#include "config.h"
34
35		#include <ctype.h>
36		#include <fcntl.h>
37		#include <signal.h>
38		#include <stdarg.h>
39		#include <stdio.h>
40		#include <stdlib.h>
41		#include <string.h>
42		#include <syslog.h>
43		#include <unistd.h>
44		#include <sys/resource.h>
45		#include <sys/stat.h>
46		#include <sys/socket.h>
47
48		#include "mgt/mgt.h"
49		#include "acceptor/mgt_acceptor.h"
50		#include "common/heritage.h"
51
52		#include "hash/hash_slinger.h"
53		#include "libvcc.h"
54		#include "vcli_serve.h"
55		#include "vct.h"
56		#include "vev.h"
57		#include "vfil.h"
58		#include "vin.h"
59		#include "vpf.h"
60		#include "vrnd.h"
61		#include "vsha256.h"
62		#include "vsub.h"
63		#include "vtim.h"
64		#include "waiter/mgt_waiter.h"
65		#include "vsa.h"
66		#include "vus.h"
67
68		struct heritage heritage;
69		unsigned d_flag = 0;
70		struct vev_root *mgt_evb;
71		int exit_status = 0;
72		struct vsb *vident;
73		struct VSC_mgt *VSC_C_mgt;
74		static int I_fd = -1;
75		static char *workdir;
76
77		static struct vfil_path *vcl_path = NULL;
78
79		static const char opt_spec[] = "?a:b:CdE:f:Fh:i:I:j:l:M:n:P:p:r:S:s:T:t:VW:x:";
80
81		/--------------------------------------------------------------------/
82
83		// Basic options documentation with compile time dependencies
84		static void
85	4	mgt_DumpOptions(void)
86		{
87	4	printf(".. _opt_n:\n\n");
88	4	printf("-n workdir\n\n");
89	4	printf(" Runtime directory for the shared memory, "
90		"compiled VCLs etc.\n\n");
91	4	printf(" In performance critical applications, this directory "
92		"should be on a RAM backed filesystem.\n\n");
93	4	printf(" When running multiple vinyld instances, separate "
94		"directories need to be used.\n\n");
95	4	VIN_DumpDefaults();
96	4	}
97
98		static void
99	8	usage(void)
100		{
101		char *p;
102
103		#define FMT_NONL " %-35s # %s"
104		#define FMT FMT_NONL "\n"
105
106	8	printf( "Usage: vinyld [options]\n");
107
108	8	printf("\nBasic options:\n");
109
110	8	printf(FMT, "[-a [name=][listen_address",
111		"HTTP listen address, protocol, options.");
112	8	printf(FMT, " [,PROTO\|,option=value,...]]",
113		"Can be specified multiple times.");
114	8	printf(FMT, "",
115		" default: \":80,HTTP\"");
116	8	printf(FMT, " options:",
117		"Proto can be \"PROXY\" or \"HTTP\" (default)");
118	8	printf(FMT, " [,user=<u>][,group=<g>]",
119		"user, group and mode set permissions for");
120	8	printf(FMT, " [,mode=<m>]",
121		" a Unix domain socket.");
122	8	printf(FMT, "-b none", "No backend");
123	8	printf(FMT, "-b [addr[:port]\|path]", "Backend address and port");
124	8	printf(FMT, "", " or socket file path");
125	8	printf(FMT, "", " default: \":80\"");
126	8	printf(FMT, "-f vclfile", "VCL program");
127	8	printf(FMT, "", "Can be specified multiple times.");
128	8	printf(FMT, "-n dir", "Working directory");
129
130	8	p = VIN_n_Arg(NULL);
131	8	AN(p);
132	8	printf(FMT_NONL " default: %s\n", "", "", p);
133	8	free(p);
134
135	8	printf("\n-b can be used only once, and not together with -f\n");
136
137	8	printf("\nDocumentation options:\n");
138	8	printf(FMT, "-?", "Prints this usage message");
139	8	printf(FMT, "-x parameter", "Parameter documentation in RST format");
140	8	printf(FMT, "-x parameter-json", "Parameter documentation in JSON format");
141	8	printf(FMT, "-x vsl", "VSL record documentation");
142	8	printf(FMT, "-x cli", "CLI command documentation");
143	8	printf(FMT, "-x builtin", "Builtin VCL program");
144	8	printf(FMT, "-x optstring", "List of getopt options");
145	8	printf(FMT, "-x options", "Dynamic options documentation");
146
147	8	printf("\nOperations options:\n");
148
149	8	printf(FMT, "-F", "Run in foreground");
150	8	printf(FMT, "-T address[:port]", "CLI address");
151	8	printf(FMT, "", "Can be specified multiple times.");
152	8	printf(FMT, "-M address:port", "Reverse CLI destination");
153	8	printf(FMT, "", "Can be specified multiple times.");
154	8	printf(FMT, "-P file", "PID file");
155	8	printf(FMT, "-i identity", "Identity of Vinyl Cache instance");
156	8	printf(FMT, "-I clifile", "Initialization CLI commands");
157	8	printf(FMT, "-E extension", "Load extension");
158
159	8	printf("\nTuning options:\n");
160
161	8	printf(FMT, "-t TTL", "Default TTL");
162	8	printf(FMT, "-p param=value", "set parameter");
163	8	printf(FMT, "", "Can be specified multiple times.");
164
165	8	printf(FMT, "-s [name=]kind[,options]", "Storage specification");
166	8	printf(FMT, "", "Can be specified multiple times.");
167		#ifdef HAVE_UMEM_H
168		printf(FMT, "", " -s default (=umem)");
169		printf(FMT, "", " -s umem");
170		#else
171	8	printf(FMT, "", " -s default (=malloc)");
172		#endif
173	8	printf(FMT, "", " -s malloc");
174	8	printf(FMT, "", " -s file");
175
176	8	printf(FMT, "-l vsl", "Size of shared memory log");
177	8	printf(FMT, "", " vsl: space for VSL records [80m]");
178
179	8	printf("\nSecurity options:\n");
180
181	8	printf(FMT, "-r param[,param...]", "Set parameters read-only from CLI");
182	8	printf(FMT, "", "Can be specified multiple times.");
183	8	printf(FMT, "-S secret-file", "Secret file for CLI authentication");
184	8	printf(FMT, "-j jail[,options]", "Jail specification");
185		#ifdef HAVE_SETPPRIV
186		printf(FMT, "", " -j solaris");
187		#endif
188		#ifdef __linux__
189		printf(FMT, "", " -j linux");
190		#endif
191	8	printf(FMT, "", " -j unix");
192	8	printf(FMT, "", " -j none");
193
194	8	printf("\nAdvanced/Dev/Debug options:\n");
195
196	8	printf(FMT, "-d", "debug mode");
197	8	printf(FMT, "", "Stay in foreground, CLI on stdin.");
198	8	printf(FMT, "-C", "Output VCL code compiled to C language");
199	8	printf(FMT, "-V", "version");
200	8	printf(FMT, "-h kind[,options]", "Hash specification");
201	8	printf(FMT, "-W waiter", "Waiter implementation");
202	8	}
203
204		/--------------------------------------------------------------------/
205
206		struct arg_list {
207		unsigned magic;
208		#define ARG_LIST_MAGIC 0x7b0d1bc4
209		char arg[2];
210		char *val;
211		VTAILQ_ENTRY(arg_list) list;
212		void *priv;
213		};
214
215		static VTAILQ_HEAD(, arg_list) arglist = VTAILQ_HEAD_INITIALIZER(arglist);
216
217		static struct arg_list *
218	57832	arg_list_add(const char arg, const char *val)
219		{
220		struct arg_list *alp;
221
222	57832	ALLOC_OBJ(alp, ARG_LIST_MAGIC);
223	57832	AN(alp);
224	57832	alp->arg[0] = arg;
225	57832	alp->arg[1] = '\0';
226	57832	REPLACE(alp->val, val);
227	57832	VTAILQ_INSERT_TAIL(&arglist, alp, list);
228	57832	return (alp);
229		}
230
231		static unsigned
232	17156	arg_list_count(const char *arg)
233		{
234	17156	unsigned retval = 0;
235		struct arg_list *alp;
236
237	232880	VTAILQ_FOREACH(alp, &arglist, list) {
238	215724	if (!vstrcmp(alp->arg, arg))
239	672	retval++;
240	215724	}
241	17156	return (retval);
242		}
243
244		/--------------------------------------------------------------------/
245
246		static void
247	57808	cli_check(const struct cli *cli)
248		{
249	57808	if (cli->result == CLIS_OK \|\| cli->result == CLIS_TRUNCATED) {
250	57800	AZ(VSB_finish(cli->sb));
251	57800	if (VSB_len(cli->sb) > 0)
252	8	fprintf(stderr, "Warnings:\n%s\n", VSB_data(cli->sb));
253	57800	VSB_clear(cli->sb);
254	57800	return;
255		}
256	8	AZ(VSB_finish(cli->sb));
257	8	fprintf(stderr, "Error:\n%s\n", VSB_data(cli->sb));
258	8	exit(2);
259		}
260
261		/*--------------------------------------------------------------------
262		* This function is called when the CLI on stdin is closed.
263		*/
264
265		static int v_matchproto_(mgt_cli_close_f)
266	3980	mgt_stdin_close(void *priv)
267		{
268
269	3980	(void)priv;
270	3980	return (-42);
271		}
272
273		/*--------------------------------------------------------------------
274		* Autogenerate a -S file using strong random bits from the kernel.
275		*/
276
277		static void
278	19148	mgt_secret_atexit(void)
279		{
280
281		/* Only master process */
282	19148	if (getpid() != heritage.mgt_pid)
283	15112	return;
284	4036	VJ_master(JAIL_MASTER_FILE);
285	4036	(void)unlink("_.secret");
286	4036	VJ_master(JAIL_MASTER_LOW);
287	19148	}
288
289		static const char *
290	4040	make_secret(const char *dirname)
291		{
292		char *fn;
293		int fdo;
294		int i;
295		unsigned char b;
296
297	4040	assert(asprintf(&fn, "%s/_.secret", dirname) > 0);
298
299	4040	VJ_master(JAIL_MASTER_FILE);
300	4040	if (unlink(fn) < 0 && errno != ENOENT) {
301	4	ARGV_ERR("Cannot remove preexisting secret-file in %s (%s)\n",
302		dirname, VAS_errtxt(errno));
303	0	}
304
305	0	fdo = open(fn, O_RDWR\|O_CREAT\|O_EXCL, 0640);
306	0	if (fdo < 0) {
307	0	ARGV_ERR("Cannot create secret-file in %s (%s)\n",
308		dirname, VAS_errtxt(errno));
309	0	}
310
311	1037252	for (i = 0; i < 256; i++) {
312	1033216	AZ(VRND_RandomCrypto(&b, 1));
313	1033216	assert(1 == write(fdo, &b, 1));
314	1033216	}
315	4036	closefd(&fdo);
316	4036	VJ_master(JAIL_MASTER_LOW);
317	4036	AZ(atexit(mgt_secret_atexit));
318	4036	return (fn);
319		}
320
321		static void
322	48	mgt_Cflag_atexit(void)
323		{
324
325		/* Only master process */
326	48	if (getpid() != heritage.mgt_pid)
327	32	return;
328	16	if (arg_list_count("E")) {
329	0	vext_cleanup(1);
330	0	VJ_rmdir("vext_cache");
331	0	}
332	16	VJ_rmdir("vmod_cache");
333	16	VJ_rmdir("worker_tmpdir");
334	16	(void)chdir("/");
335	16	VJ_rmdir(workdir);
336	48	}
337
338		/--------------------------------------------------------------------/
339
340		static void
341	4376	mgt_tests(void)
342		{
343	4376	assert(VTIM_parse("Sun, 06 Nov 1994 08:49:37 GMT") == 784111777);
344	4376	assert(VTIM_parse("Sunday, 06-Nov-94 08:49:37 GMT") == 784111777);
345	4376	assert(VTIM_parse("Sun Nov 6 08:49:37 1994") == 784111777);
346
347		/* Check that our VSHA256 works */
348	4376	VSHA256_Test();
349	4376	}
350
351		static void
352	4376	mgt_initialize(struct cli *cli)
353		{
354		static unsigned clilim = 32768;
355
356		/* for ASSERT_MGT() */
357	4376	heritage.mgt_pid = getpid();
358
359		/* Create a cli for convenience in otherwise CLI functions */
360	4376	INIT_OBJ(cli, CLI_MAGIC);
361	4376	cli[0].sb = VSB_new_auto();
362	4376	AN(cli[0].sb);
363	4376	cli[0].result = CLIS_OK;
364	4376	cli[0].limit = &clilim;
365
366	4376	mgt_cli_init_cls(); // CLI commands can be registered
367
368	4376	MCF_InitParams(cli);
369
370	4376	VCC_VCL_Range(&heritage.min_vcl_version, &heritage.max_vcl_version);
371
372	4376	cli_check(cli);
373	4376	}
374
375		static void
376	40	mgt_x_arg(const char *x_arg)
377		{
378	40	if (!vstrcmp(x_arg, "parameter"))
379	8	MCF_DumpRstParam();
380	32	else if (!vstrcmp(x_arg, "parameter-json"))
381	4	MCF_DumpJsonParam();
382	28	else if (!vstrcmp(x_arg, "vsl"))
383	4	mgt_DumpRstVsl();
384	24	else if (!vstrcmp(x_arg, "cli"))
385	8	mgt_DumpRstCli();
386	16	else if (!vstrcmp(x_arg, "builtin"))
387	4	mgt_DumpBuiltin();
388	12	else if (!vstrcmp(x_arg, "optstring"))
389	4	(void)printf("%s\n", opt_spec);
390	8	else if (!vstrcmp(x_arg, "options"))
391	4	mgt_DumpOptions();
392		else
393	4	ARGV_ERR("Invalid -x argument\n");
394	36	}
395
396		/--------------------------------------------------------------------/
397
398		#define ERIC_MAGIC 0x2246988a /* Eric is not random */
399
400		static int
401	96	mgt_eric(void)
402		{
403		int eric_pipes[2];
404		unsigned u;
405		ssize_t sz;
406
407	96	AZ(pipe(eric_pipes));
408
409	96	switch (fork()) {
410		case -1:
411	0	fprintf(stderr, "Fork() failed: %s\n", VAS_errtxt(errno));
412	0	exit(-1);
413		case 0:
414	96	closefd(&eric_pipes[0]);
415	96	assert(setsid() > 1);
416
417	96	VFIL_null_fd(STDIN_FILENO);
418	96	return (eric_pipes[1]);
419		default:
420	96	break;
421		}
422	96	closefd(&eric_pipes[1]);
423	96	sz = read(eric_pipes[0], &u, sizeof u);
424	96	if (sz == sizeof u && u == ERIC_MAGIC)
425	0	exit(0);
426	32	else if (sz == sizeof u && u != 0)
427	32	exit(u);
428		else
429	64	exit(-1);
430		}
431
432		static void
433	32	mgt_eric_im_done(int eric_fd, unsigned u)
434		{
435
436	32	if (u == 0)
437	0	u = ERIC_MAGIC;
438
439	32	VFIL_null_fd(STDIN_FILENO);
440	32	VFIL_null_fd(STDOUT_FILENO);
441	32	VFIL_null_fd(STDERR_FILENO);
442
443	32	assert(write(eric_fd, &u, sizeof u) == sizeof u);
444	32	closefd(&eric_fd);
445	32	}
446
447		/--------------------------------------------------------------------/
448
449		static int v_matchproto_(vev_cb_f)
450	16	mgt_sigint(const struct vev *e, int what)
451		{
452
453	16	(void)what;
454	16	MGT_Complain(C_INFO, "Manager got %s from PID %jd",
455	16	e->name, (intmax_t)e->siginfo->si_pid);
456	16	(void)fflush(stdout);
457	16	if (MCH_Running())
458	12	MCH_Stop_Child();
459	16	return (-42);
460		}
461
462		/--------------------------------------------------------------------/
463
464		static int v_matchproto_(vev_cb_f)
465	10435	mgt_uptime(const struct vev *e, int what)
466		{
467		static double mgt_uptime_t0 = 0;
468
469	10435	(void)e;
470	10435	(void)what;
471	10435	AN(VSC_C_mgt);
472	10435	if (mgt_uptime_t0 == 0)
473	3864	mgt_uptime_t0 = VTIM_real();
474	10435	VSC_C_mgt->uptime = (uint64_t)(VTIM_real() - mgt_uptime_t0);
475	10435	return (0);
476		}
477
478		/--------------------------------------------------------------------/
479
480		static int v_matchproto_(mgt_cli_close_f)
481	4	mgt_I_close(void *priv)
482		{
483	4	(void)priv;
484	4	fprintf(stderr, "END of -I file processing\n");
485	4	I_fd = -1;
486	4	return (0);
487		}
488
489		/--------------------------------------------------------------------/
490
491		struct f_arg {
492		unsigned magic;
493		#define F_ARG_MAGIC 0x840649a8
494		char *farg;
495		char *src;
496		};
497
498		static struct f_arg *
499	52	mgt_f_read(const char *fn)