女同性恋cbcb


/*-
 * 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	3934	mcf_banner(struct cli cli, const char const av, void priv)
78		{
79
80	3934	(void)av;
81	3934	(void)priv;
82	3934	VCLI_Out(cli, "-----------------------------\n");
83	3934	VCLI_Out(cli, "Varnish Cache CLI 1.0\n");
84	3934	VCLI_Out(cli, "-----------------------------\n");
85	3934	VCLI_Out(cli, "%s\n", VSB_data(vident) + 1);
86	3934	VCLI_Out(cli, "%s\n", VCS_String("V"));
87	3934	VCLI_Out(cli, "\n");
88	3934	VCLI_Out(cli, "Type 'help' for command list.\n");
89	3934	VCLI_Out(cli, "Type 'quit' to close CLI session.\n");
90	3934	if (!MCH_Running())
91	3870	VCLI_Out(cli, "Type 'start' to launch worker process.\n");
92	3934	VCLI_SetResult(cli, CLIS_OK);
93	3934	}
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	8294	mcf_askchild(struct cli cli, const char const av, void priv)
126		{
127		int i;
128		char *q;
129		unsigned u;
130
131	8294	(void)priv;
132		/*
133		* Command not recognized in master, try cacher if it is
134		* running.
135		*/
136	8294	if (cli_o <= 0) {
137	136	VCLI_SetResult(cli, CLIS_UNKNOWN);
138	136	VCLI_Out(cli,
139		"Unknown request in manager process "
140		"(child not running).\n"
141		"Type 'help' for more info.");
142	136	return;
143		}
144	8158	VSB_clear(cli_buf);
145	19206	for (i = 1; av[i] != NULL; i++) {
146	11048	VSB_quote(cli_buf, av[i], strlen(av[i]), 0);
147	11048	VSB_putc(cli_buf, ' ');
148	11048	}
149	8158	VSB_putc(cli_buf, '\n');
150	8158	AZ(VSB_finish(cli_buf));
151	8158	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	8158	if (VCLI_ReadResult(cli_i, &u, &q, mgt_param.cli_timeout))
158	2	MCH_Cli_Fail();
159	8158	VCLI_SetResult(cli, u);
160	8158	VCLI_Out(cli, "%s", q);
161	8158	free(q);
162	8294	}
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	7541	mgt_cli_askchild(unsigned status, char resp, const char fmt, ...)
179		{
180		int i;
181		va_list ap;
182		unsigned u;
183
184	7541	AN(status);
185	7541	VSB_clear(cli_buf);
186
187	7541	if (resp != NULL)
188	7541	*resp = NULL;
189	7541	*status = 0;
190	7541	if (cli_i < 0 \|\| cli_o < 0) {
191	0	*status = CLIS_CANT;
192	0	return (CLIS_CANT);
193		}
194	7541	va_start(ap, fmt);
195	7541	AZ(VSB_vprintf(cli_buf, fmt, ap));
196	7541	va_end(ap);
197	7541	AZ(VSB_finish(cli_buf));
198	7541	i = VSB_len(cli_buf);
199	7541	assert(i > 0 && VSB_data(cli_buf)[i - 1] == '\n');
200	7541	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	7541	if (VCLI_ReadResult(cli_i, &u, resp, mgt_param.cli_timeout))
209	2	MCH_Cli_Fail();
210	7541	*status = u;
211	7541	return (u == CLIS_OK \|\| u == CLIS_TRUNCATED ? 0 : u);
212	7541	}
213
214		/--------------------------------------------------------------------/
215
216		unsigned
217	1950	mgt_cli_start_child(int fd, double tmo)
218		{
219		unsigned u;
220
221	1950	cli_i = fd;
222	1950	cli_o = fd;
223	1950	if (VCLI_ReadResult(cli_i, &u, NULL, tmo)) {
224	22	return (CLIS_COMMS);
225		}
226	1928	return (u);
227	1950	}
228
229		/--------------------------------------------------------------------/
230
231		void
232	1950	mgt_cli_stop_child(void)
233		{
234
235	1950	cli_i = -1;
236	1950	cli_o = -1;
237		/* XXX: kick any users */
238	1950	}
239
240		/*--------------------------------------------------------------------
241		* Generate a random challenge
242		*/
243
244		static void
245	2000	mgt_cli_challenge(struct cli *cli)
246		{
247		size_t z;
248		uint8_t u;
249
250	2000	AZ(VRND_RandomCrypto(cli->challenge, sizeof cli->challenge - 2));
251	66000	for (z = 0; z < (sizeof cli->challenge) - 2; z++) {
252	64000	AZ(VRND_RandomCrypto(&u, sizeof u));
253	64000	cli->challenge[z] = (u % 26) + 'a';
254	64000	}
255	2000	cli->challenge[z++] = '\n';
256	2000	cli->challenge[z] = '\0';
257	2000	VCLI_Out(cli, "%s", cli->challenge);
258	2000	VCLI_Out(cli, "\nAuthentication required.\n");
259	2000	VCLI_SetResult(cli, CLIS_AUTH);
260	2000	}
261
262		/*--------------------------------------------------------------------
263		* Validate the authentication
264		*/
265
266		static void
267	2000	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	2000	AN(av[2]);
273	2000	(void)priv;
274	2000	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	2000	VJ_master(JAIL_MASTER_FILE);
280	2000	fd = open(secret_file, O_RDONLY);
281	2000	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	2000	VJ_master(JAIL_MASTER_LOW);
289	2000	MCH_TrackHighFd(fd);
290	2000	VCLI_AuthResponse(fd, cli->challenge, buf);
291	2000	closefd(&fd);
292	2000	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	2000	cli->auth = MCF_AUTH;
299	2000	memset(cli->challenge, 0, sizeof cli->challenge);
300	2000	VCLI_SetResult(cli, CLIS_OK);
301	2000	mcf_banner(cli, av, priv);
302	2000	}
303
304		/--------------------------------------------------------------------/
305
306		static void v_matchproto_(cli_func_t)
307	42	mcf_help(struct cli cli, const char const av, void priv)
308		{
309	42	if (cli_o <= 0)
310	28	VCLS_func_help(cli, av, priv);
311		else
312	14	mcf_askchild(cli, av, priv);
313	42	}
314
315		static void v_matchproto_(cli_func_t)
316	14	mcf_help_json(struct cli cli, const char const av, void priv)
317		{
318	14	if (cli_o <= 0)
319	0	VCLS_func_help_json(cli, av, priv);
320		else
321	14	mcf_askchild(cli, av, priv);
322	14	}
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	27498	mgt_cli_cb_before(const struct cli *cli)
336		{
337
338	27498	if (cli->priv == stderr)
339	8	fprintf(stderr, "> %s\n", VSB_data(cli->cmd));
340	27498	MGT_Complain(C_CLI, "CLI %s Rd %s", cli->ident, VSB_data(cli->cmd));
341	27498	}
342
343		static void
344	27502	mgt_cli_cb_after(const struct cli *cli)
345		{
346
347	27502	MGT_Complain(C_CLI, "CLI %s Wr %03u %s",
348	27502	cli->ident, cli->result, VSB_data(cli->sb));
349	27502	if (cli->priv != stderr)
350	27490	return;
351	12	if (cli->result == CLIS_TRUNCATED)
352	4	ARGV_ERR("-I file had incomplete CLI command at the end\n");
353	8	if (cli->result != CLIS_OK && *VSB_data(cli->cmd) != '-') {
354	2	ARGV_ERR("-I file CLI command failed (%d)\n%s\n",
355		cli->result, VSB_data(cli->sb));
356	0	}
357	27496	}
358
359		/--------------------------------------------------------------------/
360
361		void
362	2106	mgt_cli_init_cls(void)
363		{
364
365	2106	mgt_cls = VCLS_New(NULL);
366	2106	AN(mgt_cls);
367	2106	VCLS_SetHooks(mgt_cls, mgt_cli_cb_before, mgt_cli_cb_after);
368	2106	VCLS_AddFunc(mgt_cls, MCF_NOAUTH, cli_auth);
369	2106	VCLS_AddFunc(mgt_cls, MCF_AUTH, cli_proto);
370	2106	VCLS_AddFunc(mgt_cls, MCF_AUTH, cli_debug);
371	2106	VCLS_AddFunc(mgt_cls, MCF_AUTH, cli_askchild);
372	2106	cli_buf = VSB_new_auto();
373	2106	AN(cli_buf);
374	2106	}
375
376		/*--------------------------------------------------------------------
377		* Get rid of all CLI sessions
378		*/
379
380		void
381	1926	mgt_cli_close_all(void)
382		{
383
384	1926	VCLS_Destroy(&mgt_cls);
385	1926	}
386
387		/*--------------------------------------------------------------------
388		* Callback whenever something happens to the input fd of the session.
389		*/
390
391		static int
392	56538	mgt_cli_callback2(const struct vev *e, int what)
393		{
394		int i;
395
396	56538	(void)what;
397	56538	i = VCLS_Poll(mgt_cls, e->priv, 0);
398	56538	return (i);
399		}
400
401		/--------------------------------------------------------------------/
402
403		void
404	3932	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	3932	cli = VCLS_AddFd(mgt_cls, fdi, fdo, closefunc, priv);
411
412	3932	REPLACE(cli->ident, ident);
413
414	3932	if (!auth && secret_file != NULL) {
415	2000	cli->auth = MCF_NOAUTH;
416	2000	mgt_cli_challenge(cli);
417	2000	} else {
418	1932	cli->auth = MCF_AUTH;
419	1932	mcf_banner(cli, NULL, NULL);
420		}
421	3932	AZ(VSB_finish(cli->sb));
422	3932	(void)VCLI_WriteResult(fdo, cli->result, VSB_data(cli->sb));
423
424	3932	ev = VEV_Alloc();
425	3932	AN(ev);
426	3932	ev->name = cli->ident;
427	3932	ev->fd = fdi;
428	3932	ev->fd_flags = VEV__RD;
429	3932	ev->callback = mgt_cli_callback2;
430	3932	ev->priv = cli;
431	3932	AZ(VEV_Start(mgt_evb, ev));
432	3932	}
433
434		/--------------------------------------------------------------------/
435
436		static struct vsb *
437	2000	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	2000	vsb = VSB_new_auto();
445	2000	AN(vsb);
446	2000	VTCP_myname(fd, abuf1, sizeof abuf1, pbuf1, sizeof pbuf1);
447	2000	VTCP_hisname(fd, abuf2, sizeof abuf2, pbuf2, sizeof pbuf2);
448	2000	VSB_printf(vsb, "%s %s %s %s %s", pfx, abuf2, pbuf2, abuf1, pbuf1);
449	2000	AZ(VSB_finish(vsb));
450	2000	return (vsb);
451		}
452
453		/--------------------------------------------------------------------/
454
455		static int
456	82	telnet_accept(const struct vev *ev, int what)
457		{
458		struct vsb *vsb;
459		int i;
460
461	82	(void)what;
462	82	i = accept(ev->fd, NULL, NULL);
463	82	if (i < 0 && errno == EBADF)
464	0	return (1);
465	82	if (i < 0)
466	0	return (0);
467
468	82	MCH_TrackHighFd(i);
469	82	vsb = sock_id("telnet", i);
470	82	mgt_cli_setup(i, i, 0, VSB_data(vsb), NULL, NULL);
471	82	VSB_destroy(&vsb);
472	82	return (0);
473	82	}
474
475		void
476	1948	mgt_cli_secret(const char *S_arg)
477		{
478		int i, fd;
479		char buf[BUFSIZ];
480
481		/* Save in shmem */
482	1948	mgt_SHM_static_alloc(S_arg, strlen(S_arg) + 1L, "Arg", "-S");
483
484	1948	VJ_master(JAIL_MASTER_FILE);
485	1948	fd = open(S_arg, O_RDONLY);
486	1948	if (fd < 0) {
487	0	fprintf(stderr, "Cannot open secret-file \"%s\"\n", S_arg);
488	0	exit(2);
489		}
490	1948	VJ_master(JAIL_MASTER_LOW);
491	1948	MCH_TrackHighFd(fd);
492	1948	i = read(fd, buf, sizeof buf);
493	1948	if (i == 0) {
494	0	fprintf(stderr, "Empty secret-file \"%s\"\n", S_arg);
495	0	exit(2);
496		}
497	1948	if (i < 0) {
498	0	fprintf(stderr, "Cannot read secret-file \"%s\"\n", S_arg);
499	0	exit(2);

Henceforth, whatever our philosopher says about Matter will apply to extension and to extension alone. It cannot be apprehended by sight, nor by hearing, nor by smell, nor by taste, for it is neither colour, nor sound, nor odour, nor juice. Neither can it be touched, for it is not a body, but it becomes corporeal on being blended with sensible qualities. And, in a later essay, he describes it as receiving all things and letting them depart again without retaining the slightest trace of their presence.483 Why then, it may be asked, if Plotinus meant extension, could he not say so at once, and save us all this trouble in hunting out his meaning? There were very good reasons why he should not. In the first place, he wished to express himself, so far as possible, in Aristotelian phraseology, and this was incompatible with the reduction of Matter to extension. In the next place, the idea of an infinite void had been already appropriated by the Epicureans, to whose system he was bitterly opposed. And, finally, the extension of ordinary327 experience had not the absolute generality which was needed in order to bring Matter into relation with that ultimate abstraction whence, like everything else, it has now to be derived. That the millionaire was genuine, “in person and not a caricature,” as Dick put it, was evident. Both the nurse, his relative, and his wife, were chatting with him as Jeff delivered the heavy packed ball made up of the gum. 233 "I guess not," said Landor, tolerantly, as he turned[Pg 106] his horse over to his orderly; "but, anyway," he added to Ellton, "we had a picnic—of a sort." Si, unable to think of anything better, went with him. The train had stopped on a switch, and seemed likely to rust fast to the rails, from the way other trains were going by in both directions. The bridge gang, under charge of a burly, red-faced young Englishman, was in the rear car, with their tools, equipments, bedding and cooking utensils. THE DEACON HAS SOME EXPERIENCES WITH THE QUADRUPED. "You are not within a mile of the truth. I know it. Look here: I believe that is Gen. Rosecrans's own cow. She's gone, and I got an order to look around for her. I've never seen her, but from the description given me I believe that's she. Who brought her here?" "Deacon, these brothers and sisters who have come here with me to-night are, like myself, deeply interested in the moral condition of the army, where we all have sons or kinsmen. Now, can't you sit right there and tell us of your observations and experiences, as a Christian man and father, from day to day, of every day that you were down there? Tell us everything, just as it happened each day, that we may be able to judge for ourselves." HAS AN ENCOUNTER WITH THE PROVOST-MARSHAL. "Wonder which one o' them is the 200th Injianny's?" said Si to Shorty. "And your mother, and Harry?" The daughter must be the girl who was talking to him now. She sat on a little stool by the fire, and had brought out some sewing. "Over at Grandturzel—can't see wot's burning from here. Git buckets and come!" These things, however, gave little concern to the worthy who commanded the Kentish division. Tyler, though an excellent blacksmith, possessed few of the qualities requisite for forming a good general. Provided there was no very sensible diminution in the number of his followers, he cared not a straw for the score or two who, after quarrelling, or perhaps fighting, withdrew in such disgust that they vowed rather to pay the full tax for ever than submit to the insolence of the rebels. One man could fight as well as another, reasoned he; and, provided he was obeyed, what mattered it by whom. Dick went and Tom came—it was sure to be all one in the end. But this burst of indignation soon passed away, and upon the suggestion of the prudent Sir Robert Hailes, he sent an evasive answer, with a command that the Commons should attend him at Windsor on the Sunday following. That it was a stratagem to gain entrance to the Tower, was the opinion of several, but, after much discussion, it was decided that the man should be admitted, and that the monk should be exhibited merely to intimidate the rebels, until the result of this promised communication should be known. HoME 女同性恋cbcb ENTER NUMBET 0017
www.gechu9.com.cn
scb10.com.cn
www.hege2.net.cn
xishouba.com.cn
www.aa6d7.com.cn
xuer7.net.cn
56line.com.cn
www.junan7.net.cn
www.yeyin5.com.cn
www.faguo1.com.cn