女同性恋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.
 *
 * Stuff for handling the CLI protocol
 */

#include "config.h"

#include <time.h>
#include <ctype.h>
#include <poll.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "vdef.h"
#include "vas.h"
#include "vqueue.h"
#include "miniobj.h"

#include "vav.h"
#include "vcli_serve.h"
#include "vsb.h"
#include "vtim.h"

struct VCLS_fd {
        unsigned                        magic;
#define VCLS_FD_MAGIC                   0x010dbd1e
        VTAILQ_ENTRY(VCLS_fd)           list;
        int                             fdi, fdo;
        struct VCLS                     *cls;
        struct cli                      *cli, clis;
        cls_cb_f                        *closefunc;
        void                            *priv;
        struct vsb                      *last_arg;
        char                            **argv;
        int                             argc;
        char                            *match;
};

struct VCLS {
        unsigned                        magic;
#define VCLS_MAGIC                      0x60f044a3
        VTAILQ_HEAD(,VCLS_fd)           fds;
        unsigned                        nfd;
        VTAILQ_HEAD(,cli_proto)         funcs;
        cls_cbc_f                       *before, *after;
        volatile unsigned               *limit;
        struct cli_proto                *wildcard;
};

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

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

        (void)av;
        (void)priv;
        VCLI_Out(cli, "Closing CLI connection");
        VCLI_SetResult(cli, CLIS_CLOSE);
}

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

void v_matchproto_(cli_func_t)
VCLS_func_ping(struct cli *cli, const char * const *av, void *priv)
{
        time_t t;

        (void)av;
        (void)priv;
        t = time(NULL);
        VCLI_Out(cli, "PONG %jd 1.0", (intmax_t)t);
}

void v_matchproto_(cli_func_t)
VCLS_func_ping_json(struct cli *cli, const char * const *av, void *priv)
{
        (void)av;
        (void)priv;
        VCLI_JSON_begin(cli, 2, av);
        VCLI_Out(cli, ", \"PONG\"\n");
        VCLI_JSON_end(cli);
}

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

static void
help_helper(struct cli *cli, struct cli_proto *clp, const char * const *av)
{
        AN(clp->desc->syntax);
        if (av[0] != NULL)
                VCLI_Out(cli, "%s\n%s\n", clp->desc->syntax, clp->desc->help);
        else
                VCLI_Out(cli, "%s\n", clp->desc->syntax);
}

void v_matchproto_(cli_func_t)
VCLS_func_help(struct cli *cli, const char * const *av, void *priv)
{
        struct cli_proto *clp;
        unsigned filter = 1, d;
        struct VCLS *cs;

        (void)priv;
        cs = cli->cls;
        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);

        for (av += 2; av[0] != NULL && av[0][0] == '-'; av++) {
                if (!strcmp(av[0], "-a")) {
                        filter = 3;
                } else if (!strcmp(av[0], "-d")) {
                        filter = 2;
                } else {
                        VCLI_Out(cli, "Unknown flag\n");
                        VCLI_SetResult(cli, CLIS_UNKNOWN);
                        return;
                }
        }
        VTAILQ_FOREACH(clp, &cs->funcs, list) {
                if (clp->auth > cli->auth)
                        continue;
                if (av[0] != NULL && !strcmp(clp->desc->request, av[0])) {
                        help_helper(cli, clp, av);
                        return;
                } else if (av[0] == NULL) {
                        d = strchr(clp->flags, 'd') != NULL ? 2 : 1;
                        if (filter & d)
                                help_helper(cli, clp, av);
                }
        }
        if (av[0] != NULL) {
                VCLI_Out(cli, "Unknown request.\nType 'help' for more info.\n");
                VCLI_SetResult(cli, CLIS_UNKNOWN);
        }
}

void v_matchproto_(cli_func_t)
VCLS_func_help_json(struct cli *cli, const char * const *av, void *priv)
{
        struct cli_proto *clp;
        struct VCLS *cs;

        (void)priv;
        cs = cli->cls;
        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);

        VCLI_JSON_begin(cli, 2, av);
        VTAILQ_FOREACH(clp, &cs->funcs, list) {
                if (clp->auth > cli->auth)
                        continue;
                VCLI_Out(cli, ",\n  {\n");
                VSB_indent(cli->sb, 2);
                VCLI_Out(cli, "\"request\": ");
                VCLI_JSON_str(cli, clp->desc->request);
                VCLI_Out(cli, ",\n");
                VCLI_Out(cli, "\"syntax\": ");
                VCLI_JSON_str(cli, clp->desc->syntax);
                VCLI_Out(cli, ",\n");
                VCLI_Out(cli, "\"help\": ");
                VCLI_JSON_str(cli, clp->desc->help);
                VCLI_Out(cli, ",\n");
                VCLI_Out(cli, "\"minarg\": %d", clp->desc->minarg);
                VCLI_Out(cli, ",\n");
                VCLI_Out(cli, "\"maxarg\": %d", clp->desc->maxarg);
                VCLI_Out(cli, ",\n");
                VCLI_Out(cli, "\"flags\": ");
                VCLI_JSON_str(cli, clp->flags);
                VCLI_Out(cli, ",\n");
                VCLI_Out(cli, "\"json\": %s",
                    clp->jsonfunc == NULL ? "false" : "true");
                VCLI_Out(cli, "\n");
                VSB_indent(cli->sb, -2);
                VCLI_Out(cli, "}");
        }
        VCLI_JSON_end(cli);
}

/*--------------------------------------------------------------------
 * Look for a CLI command to execute
 */

static void
cls_dispatch(struct cli *cli, struct VCLS *cs, char * const * av, int ac)
{
        int json = 0;
        struct cli_proto *cp;

        AN(av);
        assert(ac >= 0);
        AZ(av[0]);
        AN(av[1]);

        VTAILQ_FOREACH(cp, &cs->funcs, list) {
                if (cp->auth > cli->auth)
                        continue;
                if (!strcmp(cp->desc->request, av[1]))
                        break;
        }

        if (cp == NULL && cs->wildcard && cs->wildcard->auth <= cli->auth)
                cp = cs->wildcard;

        if (cp == NULL) {
                VCLI_Out(cli, "Unknown request.\nType 'help' for more info.\n");
                return;
        }

        VSB_clear(cli->sb);

        if (ac > 1 && !strcmp(av[2], "-j"))
                json = 1;

        if (cp->func == NULL && !json) {
                VCLI_Out(cli, "Unimplemented\n");
                VCLI_SetResult(cli, CLIS_UNIMPL);
                return;
        }
        if (cp->jsonfunc == NULL && json) {
                VCLI_Out(cli, "JSON unimplemented\n");
                VCLI_SetResult(cli, CLIS_UNIMPL);
                return;
        }

        if (ac - 1 < cp->desc->minarg + json) {
                VCLI_Out(cli, "Too few parameters\n");
                VCLI_SetResult(cli, CLIS_TOOFEW);
                return;
        }

        if (cp->desc->maxarg >= 0 && ac - 1 > cp->desc->maxarg + json) {
                VCLI_Out(cli, "Too many parameters\n");
                VCLI_SetResult(cli, CLIS_TOOMANY);
                return;
        }

        cli->result = CLIS_OK;
        cli->cls = cs;
        if (json)
                cp->jsonfunc(cli, (const char * const *)av, cp->priv);
        else
                cp->func(cli, (const char * const *)av, cp->priv);
        cli->cls = NULL;
}

/*--------------------------------------------------------------------
 * We have collected a full cli line, parse it and execute, if possible.
 */

static int
cls_exec(struct VCLS_fd *cfd, char * const *av, int ac)
{
        struct VCLS *cs;
        struct cli *cli;
        ssize_t len;
        char *s;
        unsigned lim;
        int retval = 0;

        CHECK_OBJ_NOTNULL(cfd, VCLS_FD_MAGIC);
        cs = cfd->cls;
        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);

        cli = cfd->cli;
        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
        AN(cli->cmd);

        cli->result = CLIS_UNKNOWN;
        VSB_clear(cli->sb);

        if (cs->before != NULL)
                cs->before(cli);

        do {
                if (av[0] != NULL) {
                        VCLI_Out(cli, "Syntax Error: %s\n", av[0]);
                        VCLI_SetResult(cli, CLIS_SYNTAX);
                        break;
                }

                if (av[1] == NULL) {
                        VCLI_Out(cli, "Empty CLI command.\n");
                        VCLI_SetResult(cli, CLIS_SYNTAX);
                        break;
                }

                if (!islower(av[1][0])) {
                        VCLI_Out(cli, "All commands are in lower-case.\n");
                        VCLI_SetResult(cli, CLIS_UNKNOWN);
                        break;
                }

                cls_dispatch(cli, cs, av, ac);

        } while (0);

        AZ(VSB_finish(cli->sb));

        if (cs->after != NULL)
                cs->after(cli);

        s = VSB_data(cli->sb);
        len = VSB_len(cli->sb);
        lim = *cs->limit;
        if (len > lim) {
                if (cli->result == CLIS_OK)
                        cli->result = CLIS_TRUNCATED;
                s[lim - 1] = '\0';
                assert(strlen(s) <= lim);
        }
        if (VCLI_WriteResult(cfd->fdo, cli->result, s) ||
            cli->result == CLIS_CLOSE)
                retval = 1;

        /*
         * In unauthenticated mode we are very intolerant, and close the
         * connection at the least provocation.
         */
        if (cli->auth == 0 && cli->result != CLIS_OK)
                retval = 1;

        return (retval);
}

static int
cls_feed(struct VCLS_fd *cfd, const char *p, const char *e)
{
        struct cli *cli;
        int i, retval = 0, ac;
        char **av, *q;

        CHECK_OBJ_NOTNULL(cfd, VCLS_FD_MAGIC);
        AN(p);
        assert(e > p);

        cli = cfd->cli;
        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);

        for (;p < e; p++) {
                if (cli->cmd == NULL && isspace(*p)) {
                        /* Ignore all leading space before cmd */
                        continue;
                }
                if (cfd->argv == NULL) {

                        /* Collect first line up to \n or \r */
                        if (cli->cmd == NULL) {
                                cli->cmd = VSB_new_auto();
                                AN(cli->cmd);
                        }

                        /* Until authenticated, limit length hard */
                        if (*p != '\n' && *p != '\r' &&
                            (cli->auth > 0 || VSB_len(cli->cmd) < 80)) {
                                VSB_putc(cli->cmd, *p);
                                continue;
                        }

                        AZ(VSB_finish(cli->cmd));

                        /* Ignore leading '-' */
                        q = VSB_data(cli->cmd);
                        if (*q == '-')
                                q++;
                        av = VAV_Parse(q, &ac, 0);
                        AN(av);

                        if (cli->auth > 0 &&
                            av[0] == NULL &&
                            ac >= 3 &&
                            !strcmp(av[ac-2], "<<") &&
                            *av[ac - 1] != '\0') {
                                /* Go to "<< nonce" mode */
                                cfd->argv = av;
                                cfd->argc = ac;
                                cfd->match = av[ac - 1];
                                cfd->last_arg = VSB_new_auto();
                                AN(cfd->last_arg);
                        } else {
                                /* Plain command */
                                i = cls_exec(cfd, av, ac - 1);
                                VAV_Free(av);
                                VSB_destroy(&cli->cmd);
                                if (i)
                                        return (i);
                        }
                } else {
                        /* "<< nonce" mode */
                        AN(cfd->argv);
                        AN(cfd->argc);
                        AN(cfd->match);
                        AN(cfd->last_arg);
                        if (*cfd->match == '\0' && (*p == '\r' || *p == '\n')) {
                                AZ(VSB_finish(cfd->last_arg));
                                // NB: VAV lib internals trusted
                                cfd->match = NULL;
                                REPLACE(cfd->argv[cfd->argc - 1], NULL);
                                REPLACE(cfd->argv[cfd->argc - 2], NULL);
                                cfd->argv[cfd->argc - 2] =
                                    VSB_data(cfd->last_arg);
                                i = cls_exec(cfd, cfd->argv, cfd->argc - 2);
                                cfd->argv[cfd->argc - 2] = NULL;
                                VAV_Free(cfd->argv);
                                cfd->argv = NULL;
                                VSB_destroy(&cfd->last_arg);
                                VSB_destroy(&cli->cmd);
                                if (i)
                                        return (i);
                        } else if (*p == *cfd->match) {
                                cfd->match++;
                        } else if (cfd->match != cfd->argv[cfd->argc - 1]) {
                                q = cfd->argv[cfd->argc - 1];
                                VSB_bcat(cfd->last_arg, q, cfd->match - q);
                                cfd->match = q;
                                VSB_putc(cfd->last_arg, *p);
                        } else {
                                VSB_putc(cfd->last_arg, *p);
                        }
                }
        }
        return (retval);
}

struct VCLS *
VCLS_New(struct VCLS *model)
{
        struct VCLS *cs;

        CHECK_OBJ_ORNULL(model, VCLS_MAGIC);

        ALLOC_OBJ(cs, VCLS_MAGIC);
        AN(cs);
        VTAILQ_INIT(&cs->fds);
        VTAILQ_INIT(&cs->funcs);
        if (model != NULL)
                VTAILQ_CONCAT(&cs->funcs, &model->funcs, list);
        return (cs);
}

void
VCLS_SetLimit(struct VCLS *cs, volatile unsigned *limit)
{
        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
        cs->limit = limit;
}

void
VCLS_SetHooks(struct VCLS *cs, cls_cbc_f *before, cls_cbc_f *after)
{

        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
        cs->before = before;
        cs->after = after;
}

struct cli *
VCLS_AddFd(struct VCLS *cs, int fdi, int fdo, cls_cb_f *closefunc, void *priv)
{
        struct VCLS_fd *cfd;

        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
        assert(fdi >= 0);
        assert(fdo >= 0);
        ALLOC_OBJ(cfd, VCLS_FD_MAGIC);
        AN(cfd);
        cfd->cls = cs;
        cfd->fdi = fdi;
        cfd->fdo = fdo;
        cfd->cli = &cfd->clis;
        cfd->cli->magic = CLI_MAGIC;
        cfd->cli->sb = VSB_new_auto();
        AN(cfd->cli->sb);
        cfd->cli->limit = cs->limit;
        cfd->cli->priv = priv;
        cfd->closefunc = closefunc;
        cfd->priv = priv;
        VTAILQ_INSERT_TAIL(&cs->fds, cfd, list);
        cs->nfd++;
        return (cfd->cli);
}

static int
cls_close_fd(struct VCLS *cs, struct VCLS_fd *cfd)
{
        int retval = 0;

        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
        CHECK_OBJ_NOTNULL(cfd, VCLS_FD_MAGIC);

        VTAILQ_REMOVE(&cs->fds, cfd, list);
        if (cfd->match != NULL) {
                cfd->cli->result = CLIS_TRUNCATED;
                if (cs->after != NULL)
                        cs->after(cfd->cli);
                VSB_destroy(&cfd->last_arg);
        } else if (cfd->cli->cmd != NULL) {
                (void)VSB_finish(cfd->cli->cmd);
                cfd->cli->result = CLIS_TRUNCATED;
                if (cs->after != NULL)
                        cs->after(cfd->cli);
                VSB_destroy(&cfd->cli->cmd);
        }
        cs->nfd--;
        VSB_destroy(&cfd->cli->sb);
        if (cfd->closefunc != NULL)
                retval = cfd->closefunc(cfd->priv);
        (void)close(cfd->fdi);
        if (cfd->fdo != cfd->fdi)
                (void)close(cfd->fdo);
        if (cfd->cli->ident != NULL)
                free(cfd->cli->ident);
        FREE_OBJ(cfd);
        return (retval);
}

void
VCLS_AddFunc(struct VCLS *cs, unsigned auth, struct cli_proto *clp)
{
        struct cli_proto *clp2;
        int i;

        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
        AN(clp);

        for (;clp->desc != NULL; clp++) {
                clp->auth = auth;
                if (!strcmp(clp->desc->request, "*")) {
                        cs->wildcard = clp;
                } else {
                        i = 0;
                        VTAILQ_FOREACH(clp2, &cs->funcs, list) {
                                i = strcmp(clp->desc->request,
                                    clp2->desc->request);
                                if (i <= 0)
                                        break;
                        }
                        if (clp2 != NULL && i == 0) {
                                VTAILQ_INSERT_BEFORE(clp2, clp, list);
                                VTAILQ_REMOVE(&cs->funcs, clp2, list);
                        } else if (clp2 != NULL)
                                VTAILQ_INSERT_BEFORE(clp2, clp, list);
                        else
                                VTAILQ_INSERT_TAIL(&cs->funcs, clp, list);
                }
        }
}

int
VCLS_Poll(struct VCLS *cs, const struct cli *cli, int timeout)
{
        struct VCLS_fd *cfd;
        struct pollfd pfd[1];
        int i, j, k;
        char buf[BUFSIZ];

        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
        if (cs->nfd == 0) {
                errno = 0;
                return (-1);
        }
        assert(cs->nfd > 0);

        i = 0;
        VTAILQ_FOREACH(cfd, &cs->fds, list) {
                if (cfd->cli != cli)
                        continue;
                pfd[i].fd = cfd->fdi;
                pfd[i].events = POLLIN;
                pfd[i].revents = 0;
                i++;
                break;
        }
        assert(i == 1);
        CHECK_OBJ_NOTNULL(cfd, VCLS_FD_MAGIC);

        j = poll(pfd, 1, timeout);
        if (j <= 0)
                return (j);
        if (pfd[0].revents & POLLHUP)
                k = 1;
        else {
                i = read(cfd->fdi, buf, sizeof buf);
                if (i <= 0)
                        k = 1;
                else
                        k = cls_feed(cfd, buf, buf + i);
        }
        if (k) {
                i = cls_close_fd(cs, cfd);
                if (i < 0)
                        k = i;
        }
        return (k);
}

void
VCLS_Destroy(struct VCLS **csp)
{
        struct VCLS *cs;
        struct VCLS_fd *cfd, *cfd2;
        struct cli_proto *clp;

        TAKE_OBJ_NOTNULL(cs, csp, VCLS_MAGIC);
        VTAILQ_FOREACH_SAFE(cfd, &cs->fds, list, cfd2)
                (void)cls_close_fd(cs, cfd);

        while (!VTAILQ_EMPTY(&cs->funcs)) {
                clp = VTAILQ_FIRST(&cs->funcs);
                VTAILQ_REMOVE(&cs->funcs, clp, list);
        }
        FREE_OBJ(cs);
}

/**********************************************************************
 * Utility functions for implementing CLI commands
 */

static void
vcli_outv(struct cli *cli, const char *fmt, va_list ap)
{

        if (VSB_len(cli->sb) < *cli->limit)
                (void)VSB_vprintf(cli->sb, fmt, ap);
        else if (cli->result == CLIS_OK)
                cli->result = CLIS_TRUNCATED;
}

/*lint -e{818} cli could be const */
void
VCLI_Out(struct cli *cli, const char *fmt, ...)
{
        va_list ap;

        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
        AN(fmt);

        va_start(ap, fmt);
        vcli_outv(cli, fmt, ap);
        va_end(ap);
}

int v_matchproto_(VTE_format_f)
VCLI_VTE_format(void *priv, const char *fmt, ...)
{
        struct cli *cli;
        va_list ap;

        CAST_OBJ_NOTNULL(cli, priv, CLI_MAGIC);
        AN(fmt);

        va_start(ap, fmt);
        vcli_outv(cli, fmt, ap);
        va_end(ap);

        return (0);
}

/*lint -e{818} cli could be const */
int
VCLI_Overflow(struct cli *cli)
{
        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
        if (cli->result == CLIS_TRUNCATED ||
            VSB_len(cli->sb) >= *cli->limit)
                return (1);
        return (0);
}

/*lint -e{818} cli could be const */
void
VCLI_JSON_str(struct cli *cli, const char *s)
{

        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
        VSB_putc(cli->sb, '"');
        VSB_quote(cli->sb, s, -1, VSB_QUOTE_JSON);
        VSB_putc(cli->sb, '"');
}

/*lint -e{818} cli could be const */
void
VCLI_JSON_begin(struct cli *cli, unsigned ver, const char * const * av)
{
        int i;

        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
        VCLI_Out(cli, "[ %u, [", ver);
        for (i = 1; av[i] != NULL; i++) {
                VCLI_JSON_str(cli, av[i]);
                if (av[i + 1] != NULL)
                        VCLI_Out(cli, ", ");
        }
        VCLI_Out(cli, "], %.3f", VTIM_real());
        VSB_indent(cli->sb, 2);
}

void
VCLI_JSON_end(struct cli *cli)
{
        VSB_indent(cli->sb, -2);
        VCLI_Out(cli, "\n");
        VCLI_Out(cli, "]\n");
}

/*lint -e{818} cli could be const */
void
VCLI_Quote(struct cli *cli, const char *s)
{

        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
        VSB_quote(cli->sb, s, -1, 0);
}

void
VCLI_SetResult(struct cli *cli, unsigned res)
{

        if (cli != NULL) {
                CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
                if (cli->result != CLIS_TRUNCATED || res != CLIS_OK)
                        cli->result = res;      /*lint !e64 type mismatch */
        } else {
                printf("CLI result = %u\n", res);
        }
}

		varnish-cache/lib/libvarnish/vcli_serve.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		* Stuff for handling the CLI protocol
31		*/
32
33		#include "config.h"
34
35		#include <time.h>
36		#include <ctype.h>
37		#include <poll.h>
38		#include <stdarg.h>
39		#include <stdint.h>
40		#include <stdio.h>
41		#include <stdlib.h>
42		#include <string.h>
43		#include <unistd.h>
44
45		#include "vdef.h"
46		#include "vas.h"
47		#include "vqueue.h"
48		#include "miniobj.h"
49
50		#include "vav.h"
51		#include "vcli_serve.h"
52		#include "vsb.h"
53		#include "vtim.h"
54
55		struct VCLS_fd {
56		unsigned magic;
57		#define VCLS_FD_MAGIC 0x010dbd1e
58		VTAILQ_ENTRY(VCLS_fd) list;
59		int fdi, fdo;
60		struct VCLS *cls;
61		struct cli *cli, clis;
62		cls_cb_f *closefunc;
63		void *priv;
64		struct vsb *last_arg;
65		char **argv;
66		int argc;
67		char *match;
68		};
69
70		struct VCLS {
71		unsigned magic;
72		#define VCLS_MAGIC 0x60f044a3
73		VTAILQ_HEAD(,VCLS_fd) fds;
74		unsigned nfd;
75		VTAILQ_HEAD(,cli_proto) funcs;
76		cls_cbc_f before, after;
77		volatile unsigned *limit;
78		struct cli_proto *wildcard;
79		};
80
81		/--------------------------------------------------------------------/
82
83		void v_matchproto_(cli_func_t)
84	6	VCLS_func_close(struct cli cli, const char const av, void priv)
85		{
86
87	6	(void)av;
88	6	(void)priv;
89	6	VCLI_Out(cli, "Closing CLI connection");
90	6	VCLI_SetResult(cli, CLIS_CLOSE);
91	6	}
92
93		/--------------------------------------------------------------------/
94
95		void v_matchproto_(cli_func_t)
96	483	VCLS_func_ping(struct cli cli, const char const av, void priv)
97		{
98		time_t t;
99
100	483	(void)av;
101	483	(void)priv;
102	483	t = time(NULL);
103	483	VCLI_Out(cli, "PONG %jd 1.0", (intmax_t)t);
104	483	}
105
106		void v_matchproto_(cli_func_t)
107	4	VCLS_func_ping_json(struct cli cli, const char const av, void priv)
108		{
109	4	(void)av;
110	4	(void)priv;
111	4	VCLI_JSON_begin(cli, 2, av);
112	4	VCLI_Out(cli, ", \"PONG\"\n");
113	4	VCLI_JSON_end(cli);
114	4	}
115
116		/--------------------------------------------------------------------/
117
118		static void
119	466	help_helper(struct cli cli, struct cli_proto clp, const char * const *av)
120		{
121	466	AN(clp->desc->syntax);
122	466	if (av[0] != NULL)
123	6	VCLI_Out(cli, "%s\n%s\n", clp->desc->syntax, clp->desc->help);
124		else
125	460	VCLI_Out(cli, "%s\n", clp->desc->syntax);
126	466	}
127
128		void v_matchproto_(cli_func_t)
129	36	VCLS_func_help(struct cli cli, const char const av, void priv)
130		{
131		struct cli_proto *clp;
132	36	unsigned filter = 1, d;
133		struct VCLS *cs;
134
135	36	(void)priv;
136	36	cs = cli->cls;
137	36	CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
138
139	44	for (av += 2; av[0] != NULL && av[0][0] == '-'; av++) {
140	12	if (!strcmp(av[0], "-a")) {
141	4	filter = 3;
142	12	} else if (!strcmp(av[0], "-d")) {
143	4	filter = 2;
144	4	} else {
145	4	VCLI_Out(cli, "Unknown flag\n");
146	4	VCLI_SetResult(cli, CLIS_UNKNOWN);
147	4	return;
148		}
149	8	}
150	874	VTAILQ_FOREACH(clp, &cs->funcs, list) {
151	848	if (clp->auth > cli->auth)
152	0	continue;
153	848	if (av[0] != NULL && !strcmp(clp->desc->request, av[0])) {
154	6	help_helper(cli, clp, av);
155	6	return;
156	842	} else if (av[0] == NULL) {
157	628	d = strchr(clp->flags, 'd') != NULL ? 2 : 1;
158	628	if (filter & d)
159	460	help_helper(cli, clp, av);
160	628	}
161	842	}
162	26	if (av[0] != NULL) {
163	4	VCLI_Out(cli, "Unknown request.\nType 'help' for more info.\n");
164	4	VCLI_SetResult(cli, CLIS_UNKNOWN);
165	4	}
166	36	}
167
168		void v_matchproto_(cli_func_t)
169	12	VCLS_func_help_json(struct cli cli, const char const av, void priv)
170		{
171		struct cli_proto *clp;
172		struct VCLS *cs;
173
174	12	(void)priv;
175	12	cs = cli->cls;
176	12	CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
177
178	12	VCLI_JSON_begin(cli, 2, av);
179	468	VTAILQ_FOREACH(clp, &cs->funcs, list) {
180	456	if (clp->auth > cli->auth)
181	0	continue;
182	456	VCLI_Out(cli, ",\n {\n");
183	456	VSB_indent(cli->sb, 2);
184	456	VCLI_Out(cli, "\"request\": ");
185	456	VCLI_JSON_str(cli, clp->desc->request);
186	456	VCLI_Out(cli, ",\n");
187	456	VCLI_Out(cli, "\"syntax\": ");
188	456	VCLI_JSON_str(cli, clp->desc->syntax);
189	456	VCLI_Out(cli, ",\n");
190	456	VCLI_Out(cli, "\"help\": ");
191	456	VCLI_JSON_str(cli, clp->desc->help);
192	456	VCLI_Out(cli, ",\n");
193	456	VCLI_Out(cli, "\"minarg\": %d", clp->desc->minarg);
194	456	VCLI_Out(cli, ",\n");
195	456	VCLI_Out(cli, "\"maxarg\": %d", clp->desc->maxarg);
196	456	VCLI_Out(cli, ",\n");
197	456	VCLI_Out(cli, "\"flags\": ");
198	456	VCLI_JSON_str(cli, clp->flags);
199	456	VCLI_Out(cli, ",\n");
200	912	VCLI_Out(cli, "\"json\": %s",
201	456	clp->jsonfunc == NULL ? "false" : "true");
202	456	VCLI_Out(cli, "\n");
203	456	VSB_indent(cli->sb, -2);
204	456	VCLI_Out(cli, "}");
205	456	}
206	12	VCLI_JSON_end(cli);
207	12	}
208
209		/*--------------------------------------------------------------------
210		* Look for a CLI command to execute
211		*/
212
213		static void
214	42931	cls_dispatch(struct cli cli, struct VCLS cs, char * const * av, int ac)
215		{
216	42931	int json = 0;
217		struct cli_proto *cp;
218
219	42931	AN(av);
220	42931	assert(ac >= 0);
221	42931	AZ(av[0]);
222	42931	AN(av[1]);
223
224	783549	VTAILQ_FOREACH(cp, &cs->funcs, list) {
225	775281	if (cp->auth > cli->auth)
226	0	continue;
227	775281	if (!strcmp(cp->desc->request, av[1]))
228	34663	break;
229	740618	}
230
231	42931	if (cp == NULL && cs->wildcard && cs->wildcard->auth <= cli->auth)
232	8266	cp = cs->wildcard;
233
234	42931	if (cp == NULL) {
235	2	VCLI_Out(cli, "Unknown request.\nType 'help' for more info.\n");
236	2	return;
237		}
238
239	42929	VSB_clear(cli->sb);
240
241	42929	if (ac > 1 && !strcmp(av[2], "-j"))
242	160	json = 1;
243
244	42929	if (cp->func == NULL && !json) {
245	0	VCLI_Out(cli, "Unimplemented\n");
246	0	VCLI_SetResult(cli, CLIS_UNIMPL);
247	0	return;
248		}
249	42929	if (cp->jsonfunc == NULL && json) {
250	2	VCLI_Out(cli, "JSON unimplemented\n");
251	2	VCLI_SetResult(cli, CLIS_UNIMPL);
252	2	return;
253		}
254
255	42927	if (ac - 1 < cp->desc->minarg + json) {
256	8	VCLI_Out(cli, "Too few parameters\n");
257	8	VCLI_SetResult(cli, CLIS_TOOFEW);
258	8	return;
259		}
260
261	42919	if (cp->desc->maxarg >= 0 && ac - 1 > cp->desc->maxarg + json) {
262	4	VCLI_Out(cli, "Too many parameters\n");
263	4	VCLI_SetResult(cli, CLIS_TOOMANY);
264	4	return;
265		}
266
267	42915	cli->result = CLIS_OK;
268	42915	cli->cls = cs;
269	42915	if (json)
270	158	cp->jsonfunc(cli, (const char * const *)av, cp->priv);
271		else
272	42757	cp->func(cli, (const char * const *)av, cp->priv);
273	42915	cli->cls = NULL;
274	42931	}
275
276		/*--------------------------------------------------------------------
277		* We have collected a full cli line, parse it and execute, if possible.
278		*/
279
280		static int
281	42943	cls_exec(struct VCLS_fd cfd, char const *av, int ac)
282		{
283		struct VCLS *cs;
284		struct cli *cli;
285		ssize_t len;
286		char *s;
287		unsigned lim;
288	42943	int retval = 0;
289
290	42943	CHECK_OBJ_NOTNULL(cfd, VCLS_FD_MAGIC);
291	42943	cs = cfd->cls;
292	42943	CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
293
294	42943	cli = cfd->cli;
295	42943	CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
296	42943	AN(cli->cmd);
297
298	42943	cli->result = CLIS_UNKNOWN;
299	42943	VSB_clear(cli->sb);
300
301	42943	if (cs->before != NULL)
302	42943	cs->before(cli);
303
304	42943	do {
305	42943	if (av[0] != NULL) {
306	4	VCLI_Out(cli, "Syntax Error: %s\n", av[0]);
307	4	VCLI_SetResult(cli, CLIS_SYNTAX);
308	4	break;
309		}
310
311	42939	if (av[1] == NULL) {
312	2	VCLI_Out(cli, "Empty CLI command.\n");
313	2	VCLI_SetResult(cli, CLIS_SYNTAX);
314	2	break;
315		}
316
317	42937	if (!islower(av[1][0])) {
318	6	VCLI_Out(cli, "All commands are in lower-case.\n");
319	6	VCLI_SetResult(cli, CLIS_UNKNOWN);
320	6	break;
321		}
322
323	42931	cls_dispatch(cli, cs, av, ac);
324
325	42931	} while (0);
326
327	42943	AZ(VSB_finish(cli->sb));
328
329	42943	if (cs->after != NULL)
330	42939	cs->after(cli);
331
332	42943	s = VSB_data(cli->sb);
333	42943	len = VSB_len(cli->sb);
334	42943	lim = *cs->limit;
335	42943	if (len > lim) {
336	10	if (cli->result == CLIS_OK)
337	0	cli->result = CLIS_TRUNCATED;
338	10	s[lim - 1] = '\0';
339	10	assert(strlen(s) <= lim);
340	10	}
341	42943	if (VCLI_WriteResult(cfd->fdo, cli->result, s) \|\|
342	42937	cli->result == CLIS_CLOSE)
343	6	retval = 1;
344
345		/*
346		* In unauthenticated mode we are very intolerant, and close the
347		* connection at the least provocation.
348		*/
349	42943	if (cli->auth == 0 && cli->result != CLIS_OK)
350	0	retval = 1;
351
352	42943	return (retval);
353		}
354
355		static int
356	68206	cls_feed(struct VCLS_fd cfd, const char p, const char *e)
357		{
358		struct cli *cli;
359	68206	int i, retval = 0, ac;
360		char *av, q;
361
362	68206	CHECK_OBJ_NOTNULL(cfd, VCLS_FD_MAGIC);
363	68206	AN(p);
364	68206	assert(e > p);
365
366	68206	cli = cfd->cli;
367	68206	CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
368
369	1896698	for (;p < e; p++) {
370	1828498	if (cli->cmd == NULL && isspace(*p)) {
371		/* Ignore all leading space before cmd */
372	4916	continue;
373		}
374	1823582	if (cfd->argv == NULL) {
375
376		/* Collect first line up to \n or \r */
377	882709	if (cli->cmd == NULL) {
378	42947	cli->cmd = VSB_new_auto();
379	42947	AN(cli->cmd);
380	42947	}
381
382		/* Until authenticated, limit length hard */
383	1020709	if (p != '\n' && p != '\r' &&
384	839770	(cli->auth > 0 \|\| VSB_len(cli->cmd) < 80)) {
385	839770	VSB_putc(cli->cmd, *p);
386	839770	continue;
387		}
388
389	42939	AZ(VSB_finish(cli->cmd));
390
391		/* Ignore leading '-' */
392	42939	q = VSB_data(cli->cmd);
393	42939	if (*q == '-')
394	8	q++;
395	42939	av = VAV_Parse(q, &ac, 0);
396	42939	AN(av);
397
398	45927	if (cli->auth > 0 &&
399	40945	av[0] == NULL &&
400	40941	ac >= 3 &&
401	16584	!strcmp(av[ac-2], "<<") &&
402	2988	*av[ac - 1] != '\0') {
403		/* Go to "<< nonce" mode */
404	2988	cfd->argv = av;
405	2988	cfd->argc = ac;
406	2988	cfd->match = av[ac - 1];
407	2988	cfd->last_arg = VSB_new_auto();
408	2988	AN(cfd->last_arg);
409	2988	} else {
410		/* Plain command */
411	39951	i = cls_exec(cfd, av, ac - 1);
412	39951	VAV_Free(av);
413	39951	VSB_destroy(&cli->cmd);
414	39951	if (i)
415	6	return (i);
416		}
417	42933	} else {
418		/* "<< nonce" mode */
419	940873	AN(cfd->argv);
420	940873	AN(cfd->argc);
421	940873	AN(cfd->match);
422	940873	AN(cfd->last_arg);
423	940873	if (cfd->match == '\0' && (p == '\r' \|\| *p == '\n')) {
424	2986	AZ(VSB_finish(cfd->last_arg));
425		// NB: VAV lib internals trusted
426	2986	cfd->match = NULL;
427	2986	REPLACE(cfd->argv[cfd->argc - 1], NULL);
428	2986	REPLACE(cfd->argv[cfd->argc - 2], NULL);
429	2986	cfd->argv[cfd->argc - 2] =
430	2986	VSB_data(cfd->last_arg);
431	2986	i = cls_exec(cfd, cfd->argv, cfd->argc - 2);
432	2986	cfd->argv[cfd->argc - 2] = NULL;
433	2986	VAV_Free(cfd->argv);
434	2986	cfd->argv = NULL;
435	2986	VSB_destroy(&cfd->last_arg);
436	2986	VSB_destroy(&cli->cmd);
437	2986	if (i)
438	0	return (i);
439	940873	} else if (p == cfd->match) {
440	53410	cfd->match++;
441	937887	} else if (cfd->match != cfd->argv[cfd->argc - 1]) {
442	5686	q = cfd->argv[cfd->argc - 1];
443	5686	VSB_bcat(cfd->last_arg, q, cfd->match - q);
444	5686	cfd->match = q;
445	5686	VSB_putc(cfd->last_arg, *p);
446	5686	} else {
447	878791	VSB_putc(cfd->last_arg, *p);
448		}
449		}
450	983806	}
451	68200	return (retval);
452	68206	}
453
454		struct VCLS *
455	4003	VCLS_New(struct VCLS *model)
456		{
457		struct VCLS *cs;
458
459	4003	CHECK_OBJ_ORNULL(model, VCLS_MAGIC);
460
461	4003	ALLOC_OBJ(cs, VCLS_MAGIC);
462	4003	AN(cs);
463	4003	VTAILQ_INIT(&cs->fds);
464	4003	VTAILQ_INIT(&cs->funcs);
465	4003	if (model != NULL)
466	1897	VTAILQ_CONCAT(&cs->funcs, &model->funcs, list);
467	4003	return (cs);
468		}
469
470		void
471	3867	VCLS_SetLimit(struct VCLS cs, volatile unsigned limit)
472		{
473	3867	CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
474	3867	cs->limit = limit;
475	3867	}
476
477		void
478	4003	VCLS_SetHooks(struct VCLS cs, cls_cbc_f before, cls_cbc_f *after)
479		{
480
481	4003	CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
482	4003	cs->before = before;
483	4003	cs->after = after;
484	4003	}
485
486		struct cli *
487	5822	VCLS_AddFd(struct VCLS cs, int fdi, int fdo, cls_cb_f closefunc, void *priv)
488		{
489		struct VCLS_fd *cfd;
490
491	5822	CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
492	5822	assert(fdi >= 0);
493	5822	assert(fdo >= 0);
494	5822	ALLOC_OBJ(cfd, VCLS_FD_MAGIC);
495	5822	AN(cfd);
496	5822	cfd->cls = cs;
497	5822	cfd->fdi = fdi;
498	5822	cfd->fdo = fdo;
499	5822	cfd->cli = &cfd->clis;

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.yshh1.com.cn
daze5.com.cn
www.zcjw.com.cn
sjdfj.com.cn
tehe9.com.cn
bazu5.com.cn
uuvc.com.cn
www.yanwu5.net.cn
ablsilver.com.cn
1genzhen.com.cn