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.
 *
 * 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 (!vstrcmp(av[0], "-a")) {
                        filter = 3;
                } else if (!vstrcmp(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 && !vstrcmp(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 (!vstrcmp(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 && !vstrcmp(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(vstrlen(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 &&
                            !vstrcmp(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 (!vstrcmp(clp->desc->request, "*")) {
                        cs->wildcard = clp;
                } else {
                        i = 0;
                        VTAILQ_FOREACH(clp2, &cs->funcs, list) {
                                i = vstrcmp(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);
        }
}

		vinyl-cache/lib/libvinyl/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	84	VCLS_func_close(struct cli cli, const char const av, void priv)
85		{
86
87	84	(void)av;
88	84	(void)priv;
89	84	VCLI_Out(cli, "Closing CLI connection");
90	84	VCLI_SetResult(cli, CLIS_CLOSE);
91	84	}
92
93		/--------------------------------------------------------------------/
94
95		void v_matchproto_(cli_func_t)
96	5464	VCLS_func_ping(struct cli cli, const char const av, void priv)
97		{
98		time_t t;
99
100	5464	(void)av;
101	5464	(void)priv;
102	5464	t = time(NULL);
103	5464	VCLI_Out(cli, "PONG %jd 1.0", (intmax_t)t);
104	5464	}
105
106		void v_matchproto_(cli_func_t)
107	42	VCLS_func_ping_json(struct cli cli, const char const av, void priv)
108		{
109	42	(void)av;
110	42	(void)priv;
111	42	VCLI_JSON_begin(cli, 2, av);
112	42	VCLI_Out(cli, ", \"PONG\"\n");
113	42	VCLI_JSON_end(cli);
114	42	}
115
116		/--------------------------------------------------------------------/
117
118		static void
119	4893	help_helper(struct cli cli, struct cli_proto clp, const char * const *av)
120		{
121	4893	AN(clp->desc->syntax);
122	4893	if (av[0] != NULL)
123	63	VCLI_Out(cli, "%s\n%s\n", clp->desc->syntax, clp->desc->help);
124		else
125	4830	VCLI_Out(cli, "%s\n", clp->desc->syntax);
126	4893	}
127
128		void v_matchproto_(cli_func_t)
129	378	VCLS_func_help(struct cli cli, const char const av, void priv)
130		{
131		struct cli_proto *clp;
132	378	unsigned filter = 1, d;
133		struct VCLS *cs;
134
135	378	(void)priv;
136	378	cs = cli->cls;
137	378	CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
138
139	462	for (av += 2; av[0] != NULL && av[0][0] == '-'; av++) {
140	126	if (!vstrcmp(av[0], "-a")) {
141	42	filter = 3;
142	126	} else if (!vstrcmp(av[0], "-d")) {
143	42	filter = 2;
144	42	} else {
145	42	VCLI_Out(cli, "Unknown flag\n");
146	42	VCLI_SetResult(cli, CLIS_UNKNOWN);
147	42	return;
148		}
149	84	}
150	9093	VTAILQ_FOREACH(clp, &cs->funcs, list) {
151	8820	if (clp->auth > cli->auth)
152	0	continue;
153	8820	if (av[0] != NULL && !vstrcmp(clp->desc->request, av[0])) {
154	63	help_helper(cli, clp, av);
155	63	return;
156	8757	} else if (av[0] == NULL) {
157	6531	d = strchr(clp->flags, 'd') != NULL ? 2 : 1;
158	6531	if (filter & d)
159	4830	help_helper(cli, clp, av);
160	6531	}
161	8757	}
162	273	if (av[0] != NULL) {
163	42	VCLI_Out(cli, "Unknown request.\nType 'help' for more info.\n");
164	42	VCLI_SetResult(cli, CLIS_UNKNOWN);
165	42	}
166	378	}
167
168		void v_matchproto_(cli_func_t)
169	126	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	126	(void)priv;
175	126	cs = cli->cls;
176	126	CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
177
178	126	VCLI_JSON_begin(cli, 2, av);
179	4788	VTAILQ_FOREACH(clp, &cs->funcs, list) {
180	4662	if (clp->auth > cli->auth)
181	0	continue;
182	4662	VCLI_Out(cli, ",\n {\n");
183	4662	VSB_indent(cli->sb, 2);
184	4662	VCLI_Out(cli, "\"request\": ");
185	4662	VCLI_JSON_str(cli, clp->desc->request);
186	4662	VCLI_Out(cli, ",\n");
187	4662	VCLI_Out(cli, "\"syntax\": ");
188	4662	VCLI_JSON_str(cli, clp->desc->syntax);
189	4662	VCLI_Out(cli, ",\n");
190	4662	VCLI_Out(cli, "\"help\": ");
191	4662	VCLI_JSON_str(cli, clp->desc->help);
192	4662	VCLI_Out(cli, ",\n");
193	4662	VCLI_Out(cli, "\"minarg\": %d", clp->desc->minarg);
194	4662	VCLI_Out(cli, ",\n");
195	4662	VCLI_Out(cli, "\"maxarg\": %d", clp->desc->maxarg);
196	4662	VCLI_Out(cli, ",\n");
197	4662	VCLI_Out(cli, "\"flags\": ");
198	4662	VCLI_JSON_str(cli, clp->flags);
199	4662	VCLI_Out(cli, ",\n");
200	9324	VCLI_Out(cli, "\"json\": %s",
201	4662	clp->jsonfunc == NULL ? "false" : "true");
202	4662	VCLI_Out(cli, "\n");
203	4662	VSB_indent(cli->sb, -2);
204	4662	VCLI_Out(cli, "}");
205	4662	}
206	126	VCLI_JSON_end(cli);
207	126	}
208
209		/*--------------------------------------------------------------------
210		* Look for a CLI command to execute
211		*/
212
213		static void
214	474094	cls_dispatch(struct cli cli, struct VCLS cs, char * const * av, int ac)
215		{
216	474094	int json = 0;
217		struct cli_proto *cp;
218
219	474094	AN(av);
220	474094	assert(ac >= 0);
221	474094	AZ(av[0]);
222	474094	AN(av[1]);
223
224	8504923	VTAILQ_FOREACH(cp, &cs->funcs, list) {
225	8413469	if (cp->auth > cli->auth)
226	0	continue;
227	8413469	if (!vstrcmp(cp->desc->request, av[1]))
228	382640	break;
229	8030829	}
230
231	474094	if (cp == NULL && cs->wildcard && cs->wildcard->auth <= cli->auth)
232	91433	cp = cs->wildcard;
233
234	474094	if (cp == NULL) {
235	21	VCLI_Out(cli, "Unknown request.\nType 'help' for more info.\n");
236	21	return;
237		}
238
239	474073	VSB_clear(cli->sb);
240
241	474073	if (ac > 1 && !vstrcmp(av[2], "-j"))
242	1680	json = 1;
243
244	474073	if (cp->func == NULL && !json) {
245	0	VCLI_Out(cli, "Unimplemented\n");
246	0	VCLI_SetResult(cli, CLIS_UNIMPL);
247	0	return;
248		}
249	474073	if (cp->jsonfunc == NULL && json) {
250	21	VCLI_Out(cli, "JSON unimplemented\n");
251	21	VCLI_SetResult(cli, CLIS_UNIMPL);
252	21	return;
253		}
254
255	474052	if (ac - 1 < cp->desc->minarg + json) {
256	84	VCLI_Out(cli, "Too few parameters\n");
257	84	VCLI_SetResult(cli, CLIS_TOOFEW);
258	84	return;
259		}
260
261	473968	if (cp->desc->maxarg >= 0 && ac - 1 > cp->desc->maxarg + json) {
262	42	VCLI_Out(cli, "Too many parameters\n");
263	42	VCLI_SetResult(cli, CLIS_TOOMANY);
264	42	return;
265		}
266
267	473926	cli->result = CLIS_OK;
268	473926	cli->cls = cs;
269	473926	if (json)
270	1659	cp->jsonfunc(cli, (const char * const *)av, cp->priv);
271		else
272	472267	cp->func(cli, (const char * const *)av, cp->priv);
273	473926	cli->cls = NULL;
274	474094	}
275
276		/*--------------------------------------------------------------------
277		* We have collected a full cli line, parse it and execute, if possible.
278		*/
279
280		static int
281	474220	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	474220	int retval = 0;
289
290	474220	CHECK_OBJ_NOTNULL(cfd, VCLS_FD_MAGIC);
291	474220	cs = cfd->cls;
292	474220	CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
293
294	474220	cli = cfd->cli;
295	474220	CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
296	474220	AN(cli->cmd);
297
298	474220	cli->result = CLIS_UNKNOWN;
299	474220	VSB_clear(cli->sb);
300
301	474220	if (cs->before != NULL)
302	474220	cs->before(cli);
303
304	474220	do {
305	474220	if (av[0] != NULL) {
306	42	VCLI_Out(cli, "Syntax Error: %s\n", av[0]);
307	42	VCLI_SetResult(cli, CLIS_SYNTAX);
308	42	break;
309		}
310
311	474178	if (av[1] == NULL) {
312	21	VCLI_Out(cli, "Empty CLI command.\n");
313	21	VCLI_SetResult(cli, CLIS_SYNTAX);
314	21	break;
315		}
316
317	474157	if (!islower(av[1][0])) {
318	63	VCLI_Out(cli, "All commands are in lower-case.\n");
319	63	VCLI_SetResult(cli, CLIS_UNKNOWN);
320	63	break;
321		}
322
323	474094	cls_dispatch(cli, cs, av, ac);
324
325	474094	} while (0);
326
327	474220	AZ(VSB_finish(cli->sb));
328
329	474220	if (cs->after != NULL)
330	474178	cs->after(cli);
331
332	474220	s = VSB_data(cli->sb);
333	474220	len = VSB_len(cli->sb);
334	474220	lim = *cs->limit;
335	474220	if (len > lim) {
336	105	if (cli->result == CLIS_OK)
337	0	cli->result = CLIS_TRUNCATED;
338	105	s[lim - 1] = '\0';
339	105	assert(vstrlen(s) <= lim);
340	105	}
341	474220	if (VCLI_WriteResult(cfd->fdo, cli->result, s) \|\|
342	474157	cli->result == CLIS_CLOSE)
343	84	retval = 1;
344
345		/*
346		* In unauthenticated mode we are very intolerant, and close the
347		* connection at the least provocation.
348		*/
349	474220	if (cli->auth == 0 && cli->result != CLIS_OK)
350	0	retval = 1;
351
352	474220	return (retval);
353		}
354
355		static int
356	754110	cls_feed(struct VCLS_fd cfd, const char p, const char *e)
357		{
358		struct cli *cli;
359	754110	int i, retval = 0, ac;
360		char *av, q;
361
362	754110	CHECK_OBJ_NOTNULL(cfd, VCLS_FD_MAGIC);
363	754110	AN(p);
364	754110	assert(e > p);
365
366	754110	cli = cfd->cli;
367	754110	CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
368
369	21533504	for (;p < e; p++) {
370	20779478	if (cli->cmd == NULL && isspace(*p)) {
371		/* Ignore all leading space before cmd */
372	54577	continue;
373		}
374	20724901	if (cfd->argv == NULL) {
375
376		/* Collect first line up to \n or \r */
377	9750168	if (cli->cmd == NULL) {
378	474262	cli->cmd = VSB_new_auto();
379	474262	AN(cli->cmd);
380	474262	}
381
382		/* Until authenticated, limit length hard */
383	11278794	if (p != '\n' && p != '\r' &&
384	9275990	(cli->auth > 0 \|\| VSB_len(cli->cmd) < 80)) {
385	9275990	VSB_putc(cli->cmd, *p);
386	9275990	continue;
387		}
388
389	474178	AZ(VSB_finish(cli->cmd));
390
391		/* Ignore leading '-' */
392	474178	q = VSB_data(cli->cmd);
393	474178	if (*q == '-')
394	84	q++;
395	474178	av = VAV_Parse(q, &ac, 0);
396	474178	AN(av);
397
398	507378	if (cli->auth > 0 &&
399	452087	av[0] == NULL &&
400	452045	ac >= 3 &&
401	183287	!vstrcmp(av[ac - 2], "<<") &&
402	33200	*av[ac - 1] != '\0') {
403		/* Go to "<< nonce" mode */
404	33200	cfd->argv = av;
405	33200	cfd->argc = ac;
406	33200	cfd->match = av[ac - 1];
407	33200	cfd->last_arg = VSB_new_auto();
408	33200	AN(cfd->last_arg);
409	33200	} else {
410		/* Plain command */
411	440978	i = cls_exec(cfd, av, ac - 1);
412	440978	VAV_Free(av);
413	440978	VSB_destroy(&cli->cmd);
414	440978	if (i)
415	84	return (i);
416		}
417	474094	} else {
418		/* "<< nonce" mode */
419	10974733	AN(cfd->argv);
420	10974733	AN(cfd->argc);
421	10974733	AN(cfd->match);
422	10974733	AN(cfd->last_arg);
423	10974733	if (cfd->match == '\0' && (p == '\r' \|\| *p == '\n')) {
424	33179	AZ(VSB_finish(cfd->last_arg));
425		// NB: VAV lib internals trusted
426	33179	cfd->match = NULL;
427	33179	REPLACE(cfd->argv[cfd->argc - 1], NULL);
428	33179	REPLACE(cfd->argv[cfd->argc - 2], NULL);
429	33179	cfd->argv[cfd->argc - 2] =
430	33179	VSB_data(cfd->last_arg);
431	33179	i = cls_exec(cfd, cfd->argv, cfd->argc - 2);
432	33179	cfd->argv[cfd->argc - 2] = NULL;
433	33179	VAV_Free(cfd->argv);
434	33179	cfd->argv = NULL;
435	33179	VSB_destroy(&cfd->last_arg);
436	33179	VSB_destroy(&cli->cmd);
437	33179	if (i)
438	0	return (i);
439	10974733	} else if (p == cfd->match) {
440	589958	cfd->match++;
441	10941554	} else if (cfd->match != cfd->argv[cfd->argc - 1]) {
442	59913	q = cfd->argv[cfd->argc - 1];
443	59913	VSB_bcat(cfd->last_arg, q, cfd->match - q);
444	59913	cfd->match = q;
445	59913	VSB_putc(cfd->last_arg, *p);
446	59913	} else {
447	10291683	VSB_putc(cfd->last_arg, *p);
448		}
449		}
450	11448827	}
451	754026	return (retval);
452	754110	}
453
454		struct VCLS *
455	44239	VCLS_New(struct VCLS *model)
456		{
457		struct VCLS *cs;
458
459	44239	CHECK_OBJ_ORNULL(model, VCLS_MAGIC);
460
461	44239	ALLOC_OBJ(cs, VCLS_MAGIC);
462	44239	AN(cs);
463	44239	VTAILQ_INIT(&cs->fds);
464	44239	VTAILQ_INIT(&cs->funcs);
465	44239	if (model != NULL)
466	20888	VTAILQ_CONCAT(&cs->funcs, &model->funcs, list);
467	44239	return (cs);
468		}
469
470		void
471	42685	VCLS_SetLimit(struct VCLS cs, volatile unsigned limit)
472		{
473	42685	CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
474	42685	cs->limit = limit;
475	42685	}
476
477		void
478	44239	VCLS_SetHooks(struct VCLS cs, cls_cbc_f before, cls_cbc_f *after)
479		{
480
481	44239	CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
482	44239	cs->before = before;
483	44239	cs->after = after;
484	44239	}
485
486		struct cli *
487	64384	VCLS_AddFd(struct VCLS cs, int fdi, int fdo, cls_cb_f closefunc, void *priv)
488		{
489		struct VCLS_fd *cfd;
490
491	64384	CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
492	64384	assert(fdi >= 0);
493	64384	assert(fdo >= 0);
494	64384	ALLOC_OBJ(cfd, VCLS_FD_MAGIC);
495	64384	AN(cfd);
496	64384	cfd->cls = cs;
497	64384	cfd->fdi = fdi;
498	64384	cfd->fdo = fdo;
499	64384	cfd->cli = &cfd->clis;