GCOV - Varnish Cache


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

#include "config.h"

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

#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

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

#include "vcli_serve.h"
#include "vev.h"
#include "vrnd.h"
#include "vsa.h"
#include "vss.h"
#include "vtcp.h"

#define CLI_CMD(U,l,s,h,d,m,M) \
const struct cli_cmd_desc CLICMD_##U[1] = {{ l, s, h, d, m, M }};
#include "tbl/cli_cmds.h"

static const struct cli_cmd_desc *cmds[] = {
#define CLI_CMD(U,l,s,h,d,m,M) CLICMD_##U,
#include "tbl/cli_cmds.h"
};

static const int ncmds = vcountof(cmds);

static int              cli_i = -1, cli_o = -1;
struct VCLS             *mgt_cls;
static const char       *secret_file;

static struct vsb       *cli_buf = NULL;

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

static void v_matchproto_(cli_func_t)
mcf_banner(struct cli *cli, const char *const *av, void *priv)
{

        (void)av;
        (void)priv;
        VCLI_Out(cli, "-----------------------------\n");
        VCLI_Out(cli, "Varnish Cache CLI 1.0\n");
        VCLI_Out(cli, "-----------------------------\n");
        VCLI_Out(cli, "%s\n", VSB_data(vident) + 1);
        VCLI_Out(cli, "%s\n", VCS_String("V"));
        VCLI_Out(cli, "\n");
        VCLI_Out(cli, "Type 'help' for command list.\n");
        VCLI_Out(cli, "Type 'quit' to close CLI session.\n");
        if (!MCH_Running())
                VCLI_Out(cli, "Type 'start' to launch worker process.\n");
        VCLI_SetResult(cli, CLIS_OK);
}

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

static struct cli_proto cli_proto[] = {
        { CLICMD_BANNER,                "", mcf_banner },
        { NULL }
};

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

static void v_noreturn_ v_matchproto_(cli_func_t)
mcf_panic(struct cli *cli, const char * const *av, void *priv)
{

        (void)cli;
        (void)av;
        (void)priv;
        v_gcov_flush();
        AZ(strcmp("", "You asked for it"));
        /* NOTREACHED */
        abort();
}

static struct cli_proto cli_debug[] = {
        { CLICMD_DEBUG_PANIC_MASTER,            "d", mcf_panic },
        { NULL }
};

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

static void v_matchproto_(cli_func_t)
mcf_askchild(struct cli *cli, const char * const *av, void *priv)
{
        int i;
        char *q;
        unsigned u;

        (void)priv;
        /*
         * Command not recognized in master, try cacher if it is
         * running.
         */
        if (cli_o <= 0) {
                VCLI_SetResult(cli, CLIS_UNKNOWN);
                VCLI_Out(cli,
                    "Unknown request in manager process "
                    "(child not running).\n"
                    "Type 'help' for more info.");
                return;
        }
        VSB_clear(cli_buf);
        for (i = 1; av[i] != NULL; i++) {
                VSB_quote(cli_buf, av[i], strlen(av[i]), 0);
                VSB_putc(cli_buf, ' ');
        }
        VSB_putc(cli_buf, '\n');
        AZ(VSB_finish(cli_buf));
        if (VSB_tofile(cli_buf, cli_o)) {
                VCLI_SetResult(cli, CLIS_COMMS);
                VCLI_Out(cli, "CLI communication error");
                MCH_Cli_Fail();
                return;
        }
        if (VCLI_ReadResult(cli_i, &u, &q, mgt_param.cli_timeout))
                MCH_Cli_Fail();
        VCLI_SetResult(cli, u);
        VCLI_Out(cli, "%s", q);
        free(q);
}

static const struct cli_cmd_desc CLICMD_WILDCARD[1] =
    {{ "*", "<wild-card-entry>", "<fall through to cacher>", "", 0, 999 }};

static struct cli_proto cli_askchild[] = {
        { CLICMD_WILDCARD, "h*", mcf_askchild, mcf_askchild },
        { NULL }
};

/*--------------------------------------------------------------------
 * Ask the child something over CLI, return zero only if everything is
 * happy happy.
 */

int
mgt_cli_askchild(unsigned *status, char **resp, const char *fmt, ...)
{
        int i;
        va_list ap;
        unsigned u;

        AN(status);
        VSB_clear(cli_buf);

        if (resp != NULL)
                *resp = NULL;
        *status = 0;
        if (cli_i < 0 || cli_o < 0) {
                *status = CLIS_CANT;
                return (CLIS_CANT);
        }
        va_start(ap, fmt);
        AZ(VSB_vprintf(cli_buf, fmt, ap));
        va_end(ap);
        AZ(VSB_finish(cli_buf));
        i = VSB_len(cli_buf);
        assert(i > 0 && VSB_data(cli_buf)[i - 1] == '\n');
        if (VSB_tofile(cli_buf, cli_o)) {
                *status = CLIS_COMMS;
                if (resp != NULL)
                        *resp = strdup("CLI communication error");
                MCH_Cli_Fail();
                return (CLIS_COMMS);
        }

        if (VCLI_ReadResult(cli_i, &u, resp, mgt_param.cli_timeout))
                MCH_Cli_Fail();
        *status = u;
        return (u == CLIS_OK || u == CLIS_TRUNCATED ? 0 : u);
}

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

unsigned
mgt_cli_start_child(int fd, double tmo)
{
        unsigned u;

        cli_i = fd;
        cli_o = fd;
        if (VCLI_ReadResult(cli_i, &u, NULL, tmo)) {
                return (CLIS_COMMS);
        }
        return (u);
}

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

void
mgt_cli_stop_child(void)
{

        cli_i = -1;
        cli_o = -1;
        /* XXX: kick any users */
}

/*--------------------------------------------------------------------
 * Generate a random challenge
 */

static void
mgt_cli_challenge(struct cli *cli)
{
        size_t z;
        uint8_t u;

        AZ(VRND_RandomCrypto(cli->challenge, sizeof cli->challenge - 2));
        for (z = 0; z < (sizeof cli->challenge) - 2; z++) {
                AZ(VRND_RandomCrypto(&u, sizeof u));
                cli->challenge[z] = (u % 26) + 'a';
        }
        cli->challenge[z++] = '\n';
        cli->challenge[z] = '\0';
        VCLI_Out(cli, "%s", cli->challenge);
        VCLI_Out(cli, "\nAuthentication required.\n");
        VCLI_SetResult(cli, CLIS_AUTH);
}

/*--------------------------------------------------------------------
 * Validate the authentication
 */

static void
mcf_auth(struct cli *cli, const char *const *av, void *priv)
{
        int fd;
        char buf[CLI_AUTH_RESPONSE_LEN + 1];

        AN(av[2]);
        (void)priv;
        if (secret_file == NULL) {
                VCLI_Out(cli, "Secret file not configured\n");
                VCLI_SetResult(cli, CLIS_CANT);
                return;
        }
        VJ_master(JAIL_MASTER_FILE);
        fd = open(secret_file, O_RDONLY);
        if (fd < 0) {
                VCLI_Out(cli, "Cannot open secret file (%s)\n",
                    VAS_errtxt(errno));
                VCLI_SetResult(cli, CLIS_CANT);
                VJ_master(JAIL_MASTER_LOW);
                return;
        }
        VJ_master(JAIL_MASTER_LOW);
        MCH_TrackHighFd(fd);
        VCLI_AuthResponse(fd, cli->challenge, buf);
        closefd(&fd);
        if (strcasecmp(buf, av[2])) {
                MGT_Complain(C_SECURITY,
                    "CLI Authentication failure from %s", cli->ident);
                VCLI_SetResult(cli, CLIS_CLOSE);
                return;
        }
        cli->auth = MCF_AUTH;
        memset(cli->challenge, 0, sizeof cli->challenge);
        VCLI_SetResult(cli, CLIS_OK);
        mcf_banner(cli, av, priv);
}

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

static void v_matchproto_(cli_func_t)
mcf_help(struct cli *cli, const char * const *av, void *priv)
{
        if (cli_o <= 0)
                VCLS_func_help(cli, av, priv);
        else
                mcf_askchild(cli, av, priv);
}

static void v_matchproto_(cli_func_t)
mcf_help_json(struct cli *cli, const char * const *av, void *priv)
{
        if (cli_o <= 0)
                VCLS_func_help_json(cli, av, priv);
        else
                mcf_askchild(cli, av, priv);
}

static struct cli_proto cli_auth[] = {
        { CLICMD_HELP,          "", mcf_help, mcf_help_json },
        { CLICMD_PING,          "", VCLS_func_ping, VCLS_func_ping_json },
        { CLICMD_AUTH,          "", mcf_auth },
        { CLICMD_QUIT,          "", VCLS_func_close },
        { NULL }
};

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

static void
mgt_cli_cb_before(const struct cli *cli)
{

        if (cli->priv == stderr)
                fprintf(stderr, "> %s\n", VSB_data(cli->cmd));
        MGT_Complain(C_CLI, "CLI %s Rd %s", cli->ident, VSB_data(cli->cmd));
}

static void
mgt_cli_cb_after(const struct cli *cli)
{

        MGT_Complain(C_CLI, "CLI %s Wr %03u %s",
            cli->ident, cli->result, VSB_data(cli->sb));
        if (cli->priv != stderr)
                return;
        if (cli->result == CLIS_TRUNCATED)
                ARGV_ERR("-I file had incomplete CLI command at the end\n");
        if (cli->result != CLIS_OK && *VSB_data(cli->cmd) != '-') {
                ARGV_ERR("-I file CLI command failed (%d)\n%s\n",
                    cli->result, VSB_data(cli->sb));
        }
}

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

void
mgt_cli_init_cls(void)
{

        mgt_cls = VCLS_New(NULL);
        AN(mgt_cls);
        VCLS_SetHooks(mgt_cls, mgt_cli_cb_before, mgt_cli_cb_after);
        VCLS_AddFunc(mgt_cls, MCF_NOAUTH, cli_auth);
        VCLS_AddFunc(mgt_cls, MCF_AUTH, cli_proto);
        VCLS_AddFunc(mgt_cls, MCF_AUTH, cli_debug);
        VCLS_AddFunc(mgt_cls, MCF_AUTH, cli_askchild);
        cli_buf = VSB_new_auto();
        AN(cli_buf);
}

/*--------------------------------------------------------------------
 * Get rid of all CLI sessions
 */

void
mgt_cli_close_all(void)
{

        VCLS_Destroy(&mgt_cls);
}

/*--------------------------------------------------------------------
 * Callback whenever something happens to the input fd of the session.
 */

static int
mgt_cli_callback2(const struct vev *e, int what)
{
        int i;

        (void)what;
        i = VCLS_Poll(mgt_cls, e->priv, 0);
        return (i);
}

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

void
mgt_cli_setup(int fdi, int fdo, int auth, const char *ident,
    mgt_cli_close_f *closefunc, void *priv)
{
        struct cli *cli;
        struct vev *ev;

        cli = VCLS_AddFd(mgt_cls, fdi, fdo, closefunc, priv);

        REPLACE(cli->ident, ident);

        if (!auth && secret_file != NULL) {
                cli->auth = MCF_NOAUTH;
                mgt_cli_challenge(cli);
        } else {
                cli->auth = MCF_AUTH;
                mcf_banner(cli, NULL, NULL);
        }
        AZ(VSB_finish(cli->sb));
        (void)VCLI_WriteResult(fdo, cli->result, VSB_data(cli->sb));

        ev = VEV_Alloc();
        AN(ev);
        ev->name = cli->ident;
        ev->fd = fdi;
        ev->fd_flags = VEV__RD;
        ev->callback = mgt_cli_callback2;
        ev->priv = cli;
        AZ(VEV_Start(mgt_evb, ev));
}

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

static struct vsb *
sock_id(const char *pfx, int fd)
{
        struct vsb *vsb;

        char abuf1[VTCP_ADDRBUFSIZE], abuf2[VTCP_ADDRBUFSIZE];
        char pbuf1[VTCP_PORTBUFSIZE], pbuf2[VTCP_PORTBUFSIZE];

        vsb = VSB_new_auto();
        AN(vsb);
        VTCP_myname(fd, abuf1, sizeof abuf1, pbuf1, sizeof pbuf1);
        VTCP_hisname(fd, abuf2, sizeof abuf2, pbuf2, sizeof pbuf2);
        VSB_printf(vsb, "%s %s %s %s %s", pfx, abuf2, pbuf2, abuf1, pbuf1);
        AZ(VSB_finish(vsb));
        return (vsb);
}

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

static int
telnet_accept(const struct vev *ev, int what)
{
        struct vsb *vsb;
        int i;

        (void)what;
        i = accept(ev->fd, NULL, NULL);
        if (i < 0 && errno == EBADF)
                return (1);
        if (i < 0)
                return (0);

        MCH_TrackHighFd(i);
        vsb = sock_id("telnet", i);
        mgt_cli_setup(i, i, 0, VSB_data(vsb), NULL, NULL);
        VSB_destroy(&vsb);
        return (0);
}

void
mgt_cli_secret(const char *S_arg)
{
        int i, fd;
        char buf[BUFSIZ];

        /* Save in shmem */
        mgt_SHM_static_alloc(S_arg, strlen(S_arg) + 1L, "Arg", "-S");

        VJ_master(JAIL_MASTER_FILE);
        fd = open(S_arg, O_RDONLY);
        if (fd < 0) {
                fprintf(stderr, "Cannot open secret-file \"%s\"\n", S_arg);
                exit(2);
        }
        VJ_master(JAIL_MASTER_LOW);
        MCH_TrackHighFd(fd);
        i = read(fd, buf, sizeof buf);
        if (i == 0) {
                fprintf(stderr, "Empty secret-file \"%s\"\n", S_arg);
                exit(2);
        }
        if (i < 0) {
                fprintf(stderr, "Cannot read secret-file \"%s\"\n", S_arg);
                exit(2);
        }
        closefd(&fd);
        secret_file = S_arg;
}

static int v_matchproto_(vss_resolved_f)
mct_callback(void *priv, const struct suckaddr *sa)
{
        int sock;
        struct vsb *vsb = priv;
        const char *err;
        char abuf[VTCP_ADDRBUFSIZE];
        char pbuf[VTCP_PORTBUFSIZE];
        struct vev *ev;

        VJ_master(JAIL_MASTER_PRIVPORT);
        sock = VTCP_listen(sa, 10, &err);
        VJ_master(JAIL_MASTER_LOW);
        assert(sock != 0);              // We know where stdin is
        if (sock > 0) {
                VTCP_myname(sock, abuf, sizeof abuf, pbuf, sizeof pbuf);
                VSB_printf(vsb, "%s %s\n", abuf, pbuf);
                ev = VEV_Alloc();
                AN(ev);
                ev->fd = sock;
                ev->fd_flags = POLLIN;
                ev->callback = telnet_accept;
                AZ(VEV_Start(mgt_evb, ev));
        }
        return (0);
}

void
mgt_cli_telnet(const char *T_arg)
{
        int error;
        const char *err;
        struct vsb *vsb;

        AN(T_arg);
        vsb = VSB_new_auto();
        AN(vsb);
        error = VSS_resolver(T_arg, NULL, mct_callback, vsb, &err);
        if (err != NULL)
                ARGV_ERR("Could not resolve -T argument to address\n\t%s\n",
                    err);
        AZ(error);
        AZ(VSB_finish(vsb));
        if (VSB_len(vsb) == 0)
                ARGV_ERR("-T %s could not be listened on.\n", T_arg);
        /* Save in shmem */
        mgt_SHM_static_alloc(VSB_data(vsb), VSB_len(vsb) + 1, "Arg", "-T");
        VSB_destroy(&vsb);
}

/* Reverse CLI ("Master") connections --------------------------------*/

struct m_addr {
        unsigned                magic;
#define M_ADDR_MAGIC            0xbc6217ed
        const struct suckaddr   *sa;
        VTAILQ_ENTRY(m_addr)    list;
};

static int M_fd = -1;
static struct vev *M_poker, *M_conn;
static double M_poll = 0.1;

static VTAILQ_HEAD(,m_addr)     m_addr_list =
    VTAILQ_HEAD_INITIALIZER(m_addr_list);

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

        (void)priv;
        M_fd = -1;
        return (0);
}

static int v_matchproto_(vev_cb_f)
Marg_connect(const struct vev *e, int what)
{
        struct vsb *vsb;
        struct m_addr *ma;

        assert(e == M_conn);
        (void)what;

        M_fd = VTCP_connected(M_fd);
        if (M_fd < 0) {
                MGT_Complain(C_INFO, "Could not connect to CLI-master: %s",
                        VAS_errtxt(errno));
                ma = VTAILQ_FIRST(&m_addr_list);
                AN(ma);
                VTAILQ_REMOVE(&m_addr_list, ma, list);
                VTAILQ_INSERT_TAIL(&m_addr_list, ma, list);
                if (M_poll < 10)
                        M_poll++;
                return (1);
        }
        vsb = sock_id("master", M_fd);
        mgt_cli_setup(M_fd, M_fd, 0, VSB_data(vsb), Marg_closer, NULL);
        VSB_destroy(&vsb);
        M_poll = 1;
        return (1);
}

static int v_matchproto_(vev_cb_f)
Marg_poker(const struct vev *e, int what)
{
        int s;
        struct m_addr *ma;

        assert(e == M_poker);
        (void)what;

        M_poker->timeout = M_poll;      /* XXX nasty ? */
        if (M_fd > 0)
                return (0);

        ma = VTAILQ_FIRST(&m_addr_list);
        AN(ma);

        /* Try to connect asynchronously */
        s = VTCP_connect(ma->sa, -1);
        if (s < 0)
                return (0);

        MCH_TrackHighFd(s);

        M_conn = VEV_Alloc();
        AN(M_conn);
        M_conn->callback = Marg_connect;
        M_conn->name = "-M connector";
        M_conn->fd_flags = VEV__WR;
        M_conn->fd = s;
        M_fd = s;
        AZ(VEV_Start(mgt_evb, M_conn));
        return (0);
}

static int v_matchproto_(vss_resolved_f)
marg_cb(void *priv, const struct suckaddr *sa)
{
        struct m_addr *ma;

        (void)priv;
        ALLOC_OBJ(ma, M_ADDR_MAGIC);
        AN(ma);
        ma->sa = VSA_Clone(sa);
        VTAILQ_INSERT_TAIL(&m_addr_list, ma, list);
        return (0);
}

void
mgt_cli_master(const char *M_arg)
{
        const char *err;
        int error;

        AN(M_arg);

        error = VSS_resolver(M_arg, NULL, marg_cb, NULL, &err);
        if (err != NULL)
                ARGV_ERR("Could not resolve -M argument to address\n\t%s\n",
                    err);
        AZ(error);
        if (VTAILQ_EMPTY(&m_addr_list))
                ARGV_ERR("Could not resolve -M argument to address\n");
        AZ(M_poker);
        M_poker = VEV_Alloc();
        AN(M_poker);
        M_poker->timeout = M_poll;
        M_poker->callback = Marg_poker;
        M_poker->name = "-M poker";
        AZ(VEV_Start(mgt_evb, M_poker));
}

static int
cli_cmp(const void *a, const void *b)
{
        struct cli_cmd_desc * const * const aa = a;
        struct cli_cmd_desc * const * const bb = b;

        return (strcmp((*aa)->request, (*bb)->request));
}

void
mgt_DumpRstCli(void)
{
        const struct cli_cmd_desc *cp;
        const char *p;
        int z;
        size_t j;

        qsort(cmds, ncmds, sizeof cmds[0], cli_cmp);
        for (z = 0; z < ncmds; z++, cp++) {
                cp = cmds[z];
                if (!strncmp(cp->request, "debug.", 6))
                        continue;
                printf(".. _ref_cli_");
                for (p = cp->request; *p; p++)
                        fputc(*p == '.' ? '_' : *p, stdout);
                printf(":\n\n");
                printf("%s\n", cp->syntax);
                for (j = 0; j < strlen(cp->syntax); j++)
                        printf("~");
                printf("\n");
                printf("  %s\n", cp->help);
                if (*cp->doc != '\0')
                        printf("\n%s\n", cp->doc);

                printf("\n");
        }
}

		varnish-cache/bin/varnishd/mgt/mgt_cli.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2011 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' CLI handling
31		*/
32
33		#include "config.h"
34
35		#include <sys/types.h>
36		#include <sys/socket.h>
37
38		#include <fcntl.h>
39		#include <poll.h>
40		#include <signal.h>
41		#include <stdarg.h>
42		#include <stdio.h>
43		#include <stdlib.h>
44		#include <string.h>
45		#include <unistd.h>
46
47		#include "mgt/mgt.h"
48		#include "common/heritage.h"
49
50		#include "vcli_serve.h"
51		#include "vev.h"
52		#include "vrnd.h"
53		#include "vsa.h"
54		#include "vss.h"
55		#include "vtcp.h"
56
57		#define CLI_CMD(U,l,s,h,d,m,M) \
58		const struct cli_cmd_desc CLICMD_##U[1] = {{ l, s, h, d, m, M }};
59		#include "tbl/cli_cmds.h"
60
61		static const struct cli_cmd_desc *cmds[] = {
62		#define CLI_CMD(U,l,s,h,d,m,M) CLICMD_##U,
63		#include "tbl/cli_cmds.h"
64		};
65
66		static const int ncmds = vcountof(cmds);
67
68		static int cli_i = -1, cli_o = -1;
69		struct VCLS *mgt_cls;
70		static const char *secret_file;
71
72		static struct vsb *cli_buf = NULL;
73
74		/--------------------------------------------------------------------/
75
76		static void v_matchproto_(cli_func_t)
77	78840	mcf_banner(struct cli cli, const char const av, void priv)
78		{
79
80	78840	(void)av;
81	78840	(void)priv;
82	78840	VCLI_Out(cli, "-----------------------------\n");
83	78840	VCLI_Out(cli, "Varnish Cache CLI 1.0\n");
84	78840	VCLI_Out(cli, "-----------------------------\n");
85	78840	VCLI_Out(cli, "%s\n", VSB_data(vident) + 1);
86	78840	VCLI_Out(cli, "%s\n", VCS_String("V"));
87	78840	VCLI_Out(cli, "\n");
88	78840	VCLI_Out(cli, "Type 'help' for command list.\n");
89	78840	VCLI_Out(cli, "Type 'quit' to close CLI session.\n");
90	78840	if (!MCH_Running())
91	77560	VCLI_Out(cli, "Type 'start' to launch worker process.\n");
92	78840	VCLI_SetResult(cli, CLIS_OK);
93	78840	}
94
95		/--------------------------------------------------------------------/
96
97		static struct cli_proto cli_proto[] = {
98		{ CLICMD_BANNER, "", mcf_banner },
99		{ NULL }
100		};
101
102		/--------------------------------------------------------------------/
103
104		static void v_noreturn_ v_matchproto_(cli_func_t)
105	0	mcf_panic(struct cli cli, const char const av, void priv)
106		{
107
108	0	(void)cli;
109	0	(void)av;
110	0	(void)priv;
111	0	v_gcov_flush();
112	0	AZ(strcmp("", "You asked for it"));
113		/* NOTREACHED */
114	0	abort();
115		}
116
117		static struct cli_proto cli_debug[] = {
118		{ CLICMD_DEBUG_PANIC_MASTER, "d", mcf_panic },
119		{ NULL }
120		};
121
122		/--------------------------------------------------------------------/
123
124		static void v_matchproto_(cli_func_t)
125	166240	mcf_askchild(struct cli cli, const char const av, void priv)
126		{
127		int i;
128		char *q;
129		unsigned u;
130
131	166240	(void)priv;
132		/*
133		* Command not recognized in master, try cacher if it is
134		* running.
135		*/
136	166240	if (cli_o <= 0) {
137	2720	VCLI_SetResult(cli, CLIS_UNKNOWN);
138	2720	VCLI_Out(cli,
139		"Unknown request in manager process "
140		"(child not running).\n"
141		"Type 'help' for more info.");
142	2720	return;
143		}
144	163520	VSB_clear(cli_buf);
145	384960	for (i = 1; av[i] != NULL; i++) {
146	221440	VSB_quote(cli_buf, av[i], strlen(av[i]), 0);
147	221440	VSB_putc(cli_buf, ' ');
148	221440	}
149	163520	VSB_putc(cli_buf, '\n');
150	163520	AZ(VSB_finish(cli_buf));
151	163520	if (VSB_tofile(cli_buf, cli_o)) {
152	0	VCLI_SetResult(cli, CLIS_COMMS);
153	0	VCLI_Out(cli, "CLI communication error");
154	0	MCH_Cli_Fail();
155	0	return;
156		}
157	163520	if (VCLI_ReadResult(cli_i, &u, &q, mgt_param.cli_timeout))
158	40	MCH_Cli_Fail();
159	163520	VCLI_SetResult(cli, u);
160	163520	VCLI_Out(cli, "%s", q);
161	163520	free(q);
162	166240	}
163
164		static const struct cli_cmd_desc CLICMD_WILDCARD[1] =
165		{{ "*", "<wild-card-entry>", "<fall through to cacher>", "", 0, 999 }};
166
167		static struct cli_proto cli_askchild[] = {
168		{ CLICMD_WILDCARD, "h*", mcf_askchild, mcf_askchild },
169		{ NULL }
170		};
171
172		/*--------------------------------------------------------------------
173		* Ask the child something over CLI, return zero only if everything is
174		* happy happy.
175		*/
176
177		int
178	151296	mgt_cli_askchild(unsigned status, char resp, const char fmt, ...)
179		{
180		int i;
181		va_list ap;
182		unsigned u;
183
184	151296	AN(status);
185	151296	VSB_clear(cli_buf);
186
187	151296	if (resp != NULL)
188	151296	*resp = NULL;
189	151296	*status = 0;
190	151296	if (cli_i < 0 \|\| cli_o < 0) {
191	0	*status = CLIS_CANT;
192	0	return (CLIS_CANT);
193		}
194	151296	va_start(ap, fmt);
195	151296	AZ(VSB_vprintf(cli_buf, fmt, ap));
196	151296	va_end(ap);
197	151296	AZ(VSB_finish(cli_buf));
198	151296	i = VSB_len(cli_buf);
199	151296	assert(i > 0 && VSB_data(cli_buf)[i - 1] == '\n');
200	151296	if (VSB_tofile(cli_buf, cli_o)) {
201	0	*status = CLIS_COMMS;
202	0	if (resp != NULL)
203	0	*resp = strdup("CLI communication error");
204	0	MCH_Cli_Fail();
205	0	return (CLIS_COMMS);
206		}
207
208	151296	if (VCLI_ReadResult(cli_i, &u, resp, mgt_param.cli_timeout))
209	40	MCH_Cli_Fail();
210	151296	*status = u;
211	151296	return (u == CLIS_OK \|\| u == CLIS_TRUNCATED ? 0 : u);
212	151296	}
213
214		/--------------------------------------------------------------------/
215
216		unsigned
217	39080	mgt_cli_start_child(int fd, double tmo)
218		{
219		unsigned u;
220
221	39080	cli_i = fd;
222	39080	cli_o = fd;
223	39080	if (VCLI_ReadResult(cli_i, &u, NULL, tmo)) {
224	440	return (CLIS_COMMS);
225		}
226	38640	return (u);
227	39080	}
228
229		/--------------------------------------------------------------------/
230
231		void
232	39080	mgt_cli_stop_child(void)
233		{
234
235	39080	cli_i = -1;
236	39080	cli_o = -1;
237		/* XXX: kick any users */
238	39080	}
239
240		/*--------------------------------------------------------------------
241		* Generate a random challenge
242		*/
243
244		static void
245	40080	mgt_cli_challenge(struct cli *cli)
246		{
247		size_t z;
248		uint8_t u;
249
250	40080	AZ(VRND_RandomCrypto(cli->challenge, sizeof cli->challenge - 2));
251	1322640	for (z = 0; z < (sizeof cli->challenge) - 2; z++) {
252	1282560	AZ(VRND_RandomCrypto(&u, sizeof u));
253	1282560	cli->challenge[z] = (u % 26) + 'a';
254	1282560	}
255	40080	cli->challenge[z++] = '\n';
256	40080	cli->challenge[z] = '\0';
257	40080	VCLI_Out(cli, "%s", cli->challenge);
258	40080	VCLI_Out(cli, "\nAuthentication required.\n");
259	40080	VCLI_SetResult(cli, CLIS_AUTH);
260	40080	}
261
262		/*--------------------------------------------------------------------
263		* Validate the authentication
264		*/
265
266		static void
267	40080	mcf_auth(struct cli cli, const char const av, void priv)
268		{
269		int fd;
270		char buf[CLI_AUTH_RESPONSE_LEN + 1];
271
272	40080	AN(av[2]);
273	40080	(void)priv;
274	40080	if (secret_file == NULL) {
275	0	VCLI_Out(cli, "Secret file not configured\n");
276	0	VCLI_SetResult(cli, CLIS_CANT);
277	0	return;
278		}
279	40080	VJ_master(JAIL_MASTER_FILE);
280	40080	fd = open(secret_file, O_RDONLY);
281	40080	if (fd < 0) {
282	0	VCLI_Out(cli, "Cannot open secret file (%s)\n",
283	0	VAS_errtxt(errno));
284	0	VCLI_SetResult(cli, CLIS_CANT);
285	0	VJ_master(JAIL_MASTER_LOW);
286	0	return;
287		}
288	40080	VJ_master(JAIL_MASTER_LOW);
289	40080	MCH_TrackHighFd(fd);
290	40080	VCLI_AuthResponse(fd, cli->challenge, buf);
291	40080	closefd(&fd);
292	40080	if (strcasecmp(buf, av[2])) {
293	0	MGT_Complain(C_SECURITY,
294	0	"CLI Authentication failure from %s", cli->ident);
295	0	VCLI_SetResult(cli, CLIS_CLOSE);
296	0	return;
297		}
298	40080	cli->auth = MCF_AUTH;
299	40080	memset(cli->challenge, 0, sizeof cli->challenge);
300	40080	VCLI_SetResult(cli, CLIS_OK);
301	40080	mcf_banner(cli, av, priv);
302	40080	}
303
304		/--------------------------------------------------------------------/
305
306		static void v_matchproto_(cli_func_t)
307	840	mcf_help(struct cli cli, const char const av, void priv)
308		{
309	840	if (cli_o <= 0)
310	560	VCLS_func_help(cli, av, priv);
311		else
312	280	mcf_askchild(cli, av, priv);
313	840	}
314
315		static void v_matchproto_(cli_func_t)
316	280	mcf_help_json(struct cli cli, const char const av, void priv)
317		{
318	280	if (cli_o <= 0)
319	0	VCLS_func_help_json(cli, av, priv);
320		else
321	280	mcf_askchild(cli, av, priv);
322	280	}
323
324		static struct cli_proto cli_auth[] = {
325		{ CLICMD_HELP, "", mcf_help, mcf_help_json },
326		{ CLICMD_PING, "", VCLS_func_ping, VCLS_func_ping_json },
327		{ CLICMD_AUTH, "", mcf_auth },
328		{ CLICMD_QUIT, "", VCLS_func_close },
329		{ NULL }
330		};
331
332		/--------------------------------------------------------------------/
333
334		static void
335	551200	mgt_cli_cb_before(const struct cli *cli)
336		{
337
338	551200	if (cli->priv == stderr)
339	160	fprintf(stderr, "> %s\n", VSB_data(cli->cmd));
340	551200	MGT_Complain(C_CLI, "CLI %s Rd %s", cli->ident, VSB_data(cli->cmd));
341	551200	}
342
343		static void
344	551280	mgt_cli_cb_after(const struct cli *cli)
345		{
346
347	551280	MGT_Complain(C_CLI, "CLI %s Wr %03u %s",
348	551280	cli->ident, cli->result, VSB_data(cli->sb));
349	551280	if (cli->priv != stderr)
350	551040	return;
351	240	if (cli->result == CLIS_TRUNCATED)
352	80	ARGV_ERR("-I file had incomplete CLI command at the end\n");
353	160	if (cli->result != CLIS_OK && *VSB_data(cli->cmd) != '-') {
354	40	ARGV_ERR("-I file CLI command failed (%d)\n%s\n",
355		cli->result, VSB_data(cli->sb));
356	0	}
357	551160	}
358
359		/--------------------------------------------------------------------/
360
361		void
362	42200	mgt_cli_init_cls(void)
363		{
364
365	42200	mgt_cls = VCLS_New(NULL);
366	42200	AN(mgt_cls);
367	42200	VCLS_SetHooks(mgt_cls, mgt_cli_cb_before, mgt_cli_cb_after);
368	42200	VCLS_AddFunc(mgt_cls, MCF_NOAUTH, cli_auth);
369	42200	VCLS_AddFunc(mgt_cls, MCF_AUTH, cli_proto);
370	42200	VCLS_AddFunc(mgt_cls, MCF_AUTH, cli_debug);
371	42200	VCLS_AddFunc(mgt_cls, MCF_AUTH, cli_askchild);
372	42200	cli_buf = VSB_new_auto();
373	42200	AN(cli_buf);
374	42200	}
375
376		/*--------------------------------------------------------------------
377		* Get rid of all CLI sessions
378		*/
379
380		void
381	38600	mgt_cli_close_all(void)
382		{
383
384	38600	VCLS_Destroy(&mgt_cls);
385	38600	}
386
387		/*--------------------------------------------------------------------
388		* Callback whenever something happens to the input fd of the session.
389		*/
390
391		static int
392	1132656	mgt_cli_callback2(const struct vev *e, int what)
393		{
394		int i;
395
396	1132656	(void)what;
397	1132656	i = VCLS_Poll(mgt_cls, e->priv, 0);
398	1132656	return (i);
399		}
400
401		/--------------------------------------------------------------------/
402
403		void
404	78800	mgt_cli_setup(int fdi, int fdo, int auth, const char *ident,
405		mgt_cli_close_f closefunc, void priv)
406		{
407		struct cli *cli;
408		struct vev *ev;
409
410	78800	cli = VCLS_AddFd(mgt_cls, fdi, fdo, closefunc, priv);
411
412	78800	REPLACE(cli->ident, ident);
413
414	78800	if (!auth && secret_file != NULL) {
415	40080	cli->auth = MCF_NOAUTH;
416	40080	mgt_cli_challenge(cli);
417	40080	} else {
418	38720	cli->auth = MCF_AUTH;
419	38720	mcf_banner(cli, NULL, NULL);
420		}
421	78800	AZ(VSB_finish(cli->sb));
422	78800	(void)VCLI_WriteResult(fdo, cli->result, VSB_data(cli->sb));
423
424	78800	ev = VEV_Alloc();
425	78800	AN(ev);
426	78800	ev->name = cli->ident;
427	78800	ev->fd = fdi;
428	78800	ev->fd_flags = VEV__RD;
429	78800	ev->callback = mgt_cli_callback2;
430	78800	ev->priv = cli;
431	78800	AZ(VEV_Start(mgt_evb, ev));
432	78800	}
433
434		/--------------------------------------------------------------------/
435
436		static struct vsb *
437	40080	sock_id(const char *pfx, int fd)
438		{
439		struct vsb *vsb;
440
441		char abuf1[VTCP_ADDRBUFSIZE], abuf2[VTCP_ADDRBUFSIZE];
442		char pbuf1[VTCP_PORTBUFSIZE], pbuf2[VTCP_PORTBUFSIZE];
443
444	40080	vsb = VSB_new_auto();
445	40080	AN(vsb);
446	40080	VTCP_myname(fd, abuf1, sizeof abuf1, pbuf1, sizeof pbuf1);
447	40080	VTCP_hisname(fd, abuf2, sizeof abuf2, pbuf2, sizeof pbuf2);
448	40080	VSB_printf(vsb, "%s %s %s %s %s", pfx, abuf2, pbuf2, abuf1, pbuf1);
449	40080	AZ(VSB_finish(vsb));
450	40080	return (vsb);
451		}
452
453		/--------------------------------------------------------------------/
454
455		static int
456	1640	telnet_accept(const struct vev *ev, int what)
457		{
458		struct vsb *vsb;
459		int i;
460
461	1640	(void)what;
462	1640	i = accept(ev->fd, NULL, NULL);
463	1640	if (i < 0 && errno == EBADF)
464	0	return (1);
465	1640	if (i < 0)
466	0	return (0);
467
468	1640	MCH_TrackHighFd(i);
469	1640	vsb = sock_id("telnet", i);
470	1640	mgt_cli_setup(i, i, 0, VSB_data(vsb), NULL, NULL);
471	1640	VSB_destroy(&vsb);
472	1640	return (0);
473	1640	}
474
475		void
476	39040	mgt_cli_secret(const char *S_arg)
477		{
478		int i, fd;
479		char buf[BUFSIZ];
480
481		/* Save in shmem */
482	39040	mgt_SHM_static_alloc(S_arg, strlen(S_arg) + 1L, "Arg", "-S");
483
484	39040	VJ_master(JAIL_MASTER_FILE);
485	39040	fd = open(S_arg, O_RDONLY);
486	39040	if (fd < 0) {
487	0	fprintf(stderr, "Cannot open secret-file \"%s\"\n", S_arg);
488	0	exit(2);
489		}
490	39040	VJ_master(JAIL_MASTER_LOW);
491	39040	MCH_TrackHighFd(fd);
492	39040	i = read(fd, buf, sizeof buf);
493	39040	if (i == 0) {
494	0	fprintf(stderr, "Empty secret-file \"%s\"\n", S_arg);
495	0	exit(2);
496		}
497	39040	if (i < 0) {
498	0	fprintf(stderr, "Cannot read secret-file \"%s\"\n", S_arg);
499	0	exit(2);