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.
 */

#include "config.h"

#include <ctype.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 "mgt/mgt_param.h"
#include "vav.h"
#include "vcli_serve.h"

struct plist {
        unsigned                        magic;
#define PLIST_MAGIC                     0xbfc3ea16
        VTAILQ_ENTRY(plist)             list;
        struct parspec                  *spec;
};

static VTAILQ_HEAD(, plist)             phead = VTAILQ_HEAD_INITIALIZER(phead);

struct params mgt_param;
static const int margin1 = 8;
static int margin2 = 0;
static const int wrap_at = 72;
static const int tab0 = 3;

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

static const char OBJ_STICKY_TEXT[] =
        "\n\n"
        "NB: This parameter is evaluated only when objects are created. "
        "To change it for all objects, restart or ban everything.";

static const char DELAYED_EFFECT_TEXT[] =
        "\n\n"
        "NB: This parameter may take quite some time to take (full) effect.";

static const char MUST_RESTART_TEXT[] =
        "\n\n"
        "NB: This parameter will not take any effect until the "
        "child process has been restarted.";

static const char MUST_RELOAD_TEXT[] =
        "\n\n"
        "NB: This parameter will not take any effect until the "
        "VCL programs have been reloaded.";

static const char EXPERIMENTAL_TEXT[] =
        "\n\n"
        "NB: We do not know yet if it is a good idea to change "
        "this parameter, or if the default value is even sensible. "
        "Caution is advised, and feedback is most welcome.";

static const char WIZARD_TEXT[] =
        "\n\n"
        "NB: Do not change this parameter, unless a developer tell "
        "you to do so.";

static const char PROTECTED_TEXT[] =
        "\n\n"
        "NB: This parameter is protected and can not be changed.";

static const char ONLY_ROOT_TEXT[] =
        "\n\n"
        "NB: This parameter only works if varnishd is run as root.";

static const char NOT_IMPLEMENTED_TEXT[] =
        "\n\n"
        "NB: This parameter depends on a feature which is not available"
        " on this platform.";

static const char PLATFORM_DEPENDENT_TEXT[] =
        "\n\n"
        "NB: This parameter depends on a feature which is not available"
        " on all platforms.";

static const char BUILD_OPTIONS_TEXT[] =
        "\n\n"
        "NB: The actual default value for this parameter depends on the"
        " Varnish build environment and options.";

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

static struct parspec *
mcf_findpar(const char *name)
{
        struct plist *pl;

        AN(name);
        VTAILQ_FOREACH(pl, &phead, list)
                if (!strcmp(pl->spec->name, name))
                        return (pl->spec);
        return (NULL);
}

static void
mcf_addpar(struct parspec *ps)
{
        struct plist *pl, *pl2;
        int i;

        ALLOC_OBJ(pl, PLIST_MAGIC);
        AN(pl);
        pl->spec = ps;
        VTAILQ_FOREACH(pl2, &phead, list) {
                i = strcmp(pl2->spec->name, pl->spec->name);
                if (i == 0) {
                        fprintf(stderr, "Duplicate param: %s\n", ps->name);
                        exit(4);
                } else if (i > 0) {
                        VTAILQ_INSERT_BEFORE(pl2, pl, list);
                        return;
                }
        }
        VTAILQ_INSERT_TAIL(&phead, pl, list);
}

/*--------------------------------------------------------------------
 * Wrap the text nicely.
 * Lines are allowed to contain two TABS and we render that as a table
 * taking the width of the first column into account.
 */

static void
mcf_wrap_line(struct cli *cli, const char *b, const char *e, int tabs, int m0)
{
        int n, hadtabs = 0;
        const char *w;

        n = m0;
        VCLI_Out(cli, "%*s", n, "");

        while (b < e) {
                if (!isspace(*b)) {
                        VCLI_Out(cli, "%c", *b);
                        b++;
                        n++;
                } else if (*b == '\t') {
                        assert(tabs);
                        assert(hadtabs < 2);
                        do {
                                VCLI_Out(cli, " ");
                                n++;
                        } while ((n % tabs) != (m0 + tab0) % tabs);
                        b++;
                        hadtabs++;
                } else {
                        assert (*b == ' ');
                        for (w = b + 1; w < e; w++)
                                if (isspace(*w))
                                        break;
                        if (n + (w - b) < wrap_at) {
                                VCLI_Out(cli, "%.*s", (int)(w - b), b);
                                n += (w - b);
                                b = w;
                        } else {
                                assert(hadtabs == 0 || hadtabs == 2);
                                VCLI_Out(cli, "\n");
                                mcf_wrap_line(cli, b + 1, e, 0,
                                    hadtabs ? m0 + tab0 + tabs : m0);
                                return;
                        }
                }
        }
        assert(b == e);
}

static void
mcf_wrap(struct cli *cli, const char *text)
{
        const char *p, *q, *r;
        int tw = 0;

        if (strchr(text, '\t') != NULL) {
                for (p = text; *p != '\0'; ) {
                        q = strstr(p, "\n\t");
                        if (q == NULL)
                                break;
                        q += 2;
                        r = strchr(q, '\t');
                        if (r == NULL) {
                                fprintf(stderr,
                                    "LINE with just one TAB: <%s>\n", text);
                                exit(4);
                        }
                        if (r - q > tw)
                                tw = r - q;
                        p = q;
                }
                tw += 2;
                if (tw < 20)
                        tw = 20;
        }

        for (p = text; *p != '\0'; ) {
                if (*p == '\n') {
                        VCLI_Out(cli, "\n");
                        p++;
                        continue;
                }
                q = strchr(p, '\n');
                if (q == NULL)
                        q = strchr(p, '\0');
                mcf_wrap_line(cli, p, q, tw, margin1);
                p = q;
        }
}

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

static void v_matchproto_(cli_func_t)
mcf_param_show(struct cli *cli, const char * const *av, void *priv)
{
        struct plist *pl;
        const struct parspec *pp, *pa;
        int n, lfmt = 0, chg = 0;
        struct vsb *vsb;
        const char *show = NULL;

        (void)priv;

        for (n = 2; av[n] != NULL; n++) {
                if (strcmp(av[n], "-l") == 0) {
                        lfmt = 1;
                        continue;
                }
                if (strcmp(av[n], "changed") == 0) {
                        chg = 1;
                        continue;
                }
                if (show != NULL) {
                        VCLI_SetResult(cli, CLIS_TOOMANY);
                        VCLI_Out(cli, "Too many parameters");
                        return;
                }
                show = av[n];
                lfmt = 1;
        }

        vsb = VSB_new_auto();
        AN(vsb);

        n = 0;
        VTAILQ_FOREACH(pl, &phead, list) {
                pp = pl->spec;
                if (lfmt && show != NULL && strcmp(pp->name, show))
                        continue;
                if (pp->func == tweak_alias &&
                    (show == NULL || strcmp(pp->name, show)))
                        continue;
                n++;

                VSB_clear(vsb);
                if (pp->func(vsb, pp, NULL))
                        VCLI_SetResult(cli, CLIS_PARAM);
                AZ(VSB_finish(vsb));
                if (chg && pp->def != NULL && !strcmp(pp->def, VSB_data(vsb)))
                        continue;

                if (pp->flags & NOT_IMPLEMENTED) {
                        if (lfmt) {
                                VCLI_Out(cli, "%s\n", pp->name);
                                VCLI_Out(cli, "%-*sNot available", margin1, " ");
                        } else {
                                VCLI_Out(cli, "%-*s-", margin2, pp->name);
                        }
                } else {
                        if (lfmt) {
                                VCLI_Out(cli, "%s\n", pp->name);
                                VCLI_Out(cli, "%-*sValue is: ", margin1, " ");
                        } else {
                                VCLI_Out(cli, "%-*s", margin2, pp->name);
                        }

                        VCLI_Out(cli, "%s", VSB_data(vsb));
                        if (pp->units != NULL && *pp->units != '\0')
                                VCLI_Out(cli, " [%s]", pp->units);
                        if (pp->def != NULL && !strcmp(pp->def, VSB_data(vsb)))
                                VCLI_Out(cli, " (default)");
                }
                VCLI_Out(cli, "\n");

                if (lfmt && pp->func == tweak_alias) {
                        pa = TRUST_ME(pp->priv);
                        VCLI_Out(cli, "%-*sAlias of: %s\n",
                            margin1, " ", pa->name);
                }
                if (lfmt && pp->flags & NOT_IMPLEMENTED) {
                        VCLI_Out(cli, "\n");
                        mcf_wrap(cli, NOT_IMPLEMENTED_TEXT);
                        VCLI_Out(cli, "\n\n");
                } else if (lfmt) {
                        if (pp->def != NULL && strcmp(pp->def, VSB_data(vsb)))
                                VCLI_Out(cli, "%-*sDefault is: %s\n",
                                    margin1, "", pp->def);
                        if (pp->min != NULL)
                                VCLI_Out(cli, "%-*sMinimum is: %s\n",
                                    margin1, "", pp->min);
                        if (pp->max != NULL)
                                VCLI_Out(cli, "%-*sMaximum is: %s\n",
                                    margin1, "", pp->max);
                        VCLI_Out(cli, "\n");
                        mcf_wrap(cli, pp->descr);
                        if (pp->flags & OBJ_STICKY)
                                mcf_wrap(cli, OBJ_STICKY_TEXT);
                        if (pp->flags & DELAYED_EFFECT)
                                mcf_wrap(cli, DELAYED_EFFECT_TEXT);
                        if (pp->flags & EXPERIMENTAL)
                                mcf_wrap(cli, EXPERIMENTAL_TEXT);
                        if (pp->flags & MUST_RELOAD)
                                mcf_wrap(cli, MUST_RELOAD_TEXT);
                        if (pp->flags & MUST_RESTART)
                                mcf_wrap(cli, MUST_RESTART_TEXT);
                        if (pp->flags & WIZARD)
                                mcf_wrap(cli, WIZARD_TEXT);
                        if (pp->flags & PROTECTED)
                                mcf_wrap(cli, PROTECTED_TEXT);
                        if (pp->flags & ONLY_ROOT)
                                mcf_wrap(cli, ONLY_ROOT_TEXT);
                        if (pp->flags & BUILD_OPTIONS)
                                mcf_wrap(cli, BUILD_OPTIONS_TEXT);
                        VCLI_Out(cli, "\n\n");
                }
        }
        if (show != NULL && n == 0) {
                VCLI_SetResult(cli, CLIS_PARAM);
                VCLI_Out(cli, "Unknown parameter \"%s\".", show);
        }
        VSB_destroy(&vsb);
}

static inline void
mcf_json_key_valstr(struct cli *cli, const char *key, const char *val)
{
        VCLI_Out(cli, "\"%s\": ", key);
        VCLI_JSON_str(cli, val);
        VCLI_Out(cli, ",\n");
}

static void v_matchproto_(cli_func_t)
mcf_param_show_json(struct cli *cli, const char * const *av, void *priv)
{
        int n, comma = 0, chg = 0;
        struct plist *pl;
        const struct parspec *pp, *pa;
        struct vsb *vsb, *def;
        const char *show = NULL, *sep;

        (void)priv;

        for (int i = 2; av[i] != NULL; i++) {
                if (strcmp(av[i], "-l") == 0) {
                        VCLI_SetResult(cli, CLIS_PARAM);
                        VCLI_Out(cli, "-l not permitted with param.show -j");
                        return;
                }
                if (strcmp(av[i], "changed") == 0) {
                        chg = 1;
                        continue;
                }
                if (strcmp(av[i], "-j") == 0)
                        continue;
                if (show != NULL) {
                        VCLI_SetResult(cli, CLIS_TOOMANY);
                        VCLI_Out(cli, "Too many parameters");
                        return;
                }
                show = av[i];
        }

        vsb = VSB_new_auto();
        AN(vsb);
        def = VSB_new_auto();
        AN(def);

        n = 0;
        VCLI_JSON_begin(cli, 2, av);
        VCLI_Out(cli, ",\n");
        VTAILQ_FOREACH(pl, &phead, list) {
                pp = pl->spec;
                if (show != NULL && strcmp(pp->name, show) != 0)
                        continue;
                if (pp->func == tweak_alias &&
                    (show == NULL || strcmp(pp->name, show)))
                        continue;
                n++;

                VSB_clear(vsb);
                if (pp->func(vsb, pp, JSON_FMT))
                        VCLI_SetResult(cli, CLIS_PARAM);
                AZ(VSB_finish(vsb));
                VSB_clear(def);
                if (pp->func(def, pp, NULL))
                        VCLI_SetResult(cli, CLIS_PARAM);
                AZ(VSB_finish(def));
                if (chg && pp->def != NULL && !strcmp(pp->def, VSB_data(def)))
                        continue;

                VCLI_Out(cli, "%s", comma ? ",\n" : "");
                comma++;
                VCLI_Out(cli, "{\n");
                VSB_indent(cli->sb, 2);
                mcf_json_key_valstr(cli, "name", pp->name);
                if (pp->func == tweak_alias) {
                        pa = TRUST_ME(pp->priv);
                        mcf_json_key_valstr(cli, "alias", pa->name);
                }
                if (pp->flags & NOT_IMPLEMENTED) {
                        VCLI_Out(cli, "\"implemented\": false\n");
                        VSB_indent(cli->sb, -2);
                        VCLI_Out(cli, "}");
                        continue;
                }
                VCLI_Out(cli, "\"implemented\": true,\n");
                VCLI_Out(cli, "\"value\": %s,\n", VSB_data(vsb));
                if (pp->units != NULL && *pp->units != '\0')
                        mcf_json_key_valstr(cli, "units", pp->units);

                if (pp->def != NULL)
                        mcf_json_key_valstr(cli, "default", pp->def);
                if (pp->min != NULL)
                        mcf_json_key_valstr(cli, "minimum", pp->min);
                if (pp->max != NULL)
                        mcf_json_key_valstr(cli, "maximum", pp->max);
                mcf_json_key_valstr(cli, "description", pp->descr);

                VCLI_Out(cli, "\"flags\": [");
                VSB_indent(cli->sb, 2);
                sep = "";

#define flag_out(flag, string) do {                                     \
                        if (pp->flags & flag) {                         \
                                VCLI_Out(cli, "%s\n", sep);             \
                                VCLI_Out(cli, "\"%s\"", #string);       \
                                sep = ",";                              \
                        }                                               \
                } while(0)

                flag_out(OBJ_STICKY, obj_sticky);
                flag_out(DELAYED_EFFECT, delayed_effect);
                flag_out(EXPERIMENTAL, experimental);
                flag_out(MUST_RELOAD, must_reload);
                flag_out(MUST_RESTART, must_restart);
                flag_out(WIZARD, wizard);
                flag_out(PROTECTED, protected);
                flag_out(ONLY_ROOT, only_root);
                flag_out(BUILD_OPTIONS, build_options);

#undef flag_out

                if (pp->flags)
                        VCLI_Out(cli, "\n");
                VSB_indent(cli->sb, -2);
                VCLI_Out(cli, "]\n");
                VSB_indent(cli->sb, -2);
                VCLI_Out(cli, "}");
        }
        VCLI_JSON_end(cli);
        if (show != NULL && n == 0) {
                VSB_clear(cli->sb);
                VCLI_SetResult(cli, CLIS_PARAM);
                VCLI_Out(cli, "Unknown parameter \"%s\".", show);
        }
        VSB_destroy(&vsb);
        VSB_destroy(&def);
}

/*--------------------------------------------------------------------
 * Mark parameters as protected
 */

void
MCF_ParamProtect(struct cli *cli, const char *args)
{
        char **av;
        struct parspec *pp;
        int i;

        av = VAV_Parse(args, NULL, ARGV_COMMA);
        if (av[0] != NULL) {
                VCLI_Out(cli, "Parse error: %s", av[0]);
                VCLI_SetResult(cli, CLIS_PARAM);
                VAV_Free(av);
                return;
        }
        for (i = 1; av[i] != NULL; i++) {
                pp = mcf_findpar(av[i]);
                if (pp == NULL) {
                        VCLI_Out(cli, "Unknown parameter %s", av[i]);
                        VCLI_SetResult(cli, CLIS_PARAM);
                        VAV_Free(av);
                        return;
                }
                pp->flags |= PROTECTED;
        }
        VAV_Free(av);
}

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

void
MCF_ParamSet(struct cli *cli, const char *param, const char *val)
{
        const struct parspec *pp;

        pp = mcf_findpar(param);
        if (pp == NULL) {
                VCLI_SetResult(cli, CLIS_PARAM);
                VCLI_Out(cli, "Unknown parameter \"%s\".", param);
                return;
        }
        if (pp->flags & NOT_IMPLEMENTED) {
                VCLI_SetResult(cli, CLIS_CANT);
                VCLI_Out(cli,
                    "parameter \"%s\" is not available on this platform.",
                    param
                );
                return;
        }
        if (pp->flags & PROTECTED) {
                VCLI_SetResult(cli, CLIS_AUTH);
                VCLI_Out(cli, "parameter \"%s\" is protected.", param);
                return;
        }
        if (!val)
                val = pp->def;
        if (pp->func(cli->sb, pp, val))
                VCLI_SetResult(cli, CLIS_PARAM);

        if (cli->result == CLIS_OK && heritage.param != NULL)
                *heritage.param = mgt_param;

        if (cli->result != CLIS_OK) {
                VCLI_Out(cli, "\n(attempting to set param '%s' to '%s')",
                    pp->name, val);
        } else if (MCH_Running() && pp->flags & MUST_RESTART) {
                VCLI_Out(cli,
                    "\nChange will take effect when child is restarted");
        } else if (pp->flags & MUST_RELOAD) {
                VCLI_Out(cli,
                    "\nChange will take effect when VCL script is reloaded");
        }
}


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

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

        (void)priv;
        MCF_ParamSet(cli, av[2], av[3]);
}

static void v_matchproto_(cli_func_t)
mcf_param_set_json(struct cli *cli, const char * const *av, void *priv)
{
        const char *const avs[] = { av[0], av[1], av[2], av[3], NULL };

        MCF_ParamSet(cli, av[3], av[4]);
        if (cli->result == CLIS_OK)
                mcf_param_show_json(cli, avs, priv);
}

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

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

        (void)priv;
        MCF_ParamSet(cli, av[2], NULL);
}

/*--------------------------------------------------------------------
 * Initialize parameters and sort by name.
 */

static struct parspec mgt_parspec[] = {
#define PARAM_ALL
#define PARAM_PRE {
#define PARAM(typ, fld, nm, ...) #nm, __VA_ARGS__
#define PARAM_POST },
#include "tbl/params.h"
        { NULL, NULL, NULL }
};

static void
mcf_init_params(void)
{
        struct parspec *pp;
        const char *s;

        for (pp = mgt_parspec; pp->name != NULL; pp++) {
                AN(pp->func);
                s = strchr(pp->descr, '\0');
                if (isspace(s[-1])) {
                        fprintf(stderr,
                            "Param->descr has trailing space: %s\n", pp->name);
                        exit(4);
                }
                mcf_addpar(pp);
                margin2 = vmax_t(int, margin2, strlen(pp->name) + 1);
        }
}

/*--------------------------------------------------------------------
 * Wash a min/max/default value
 */

static void
mcf_dyn_vsb(enum mcf_which_e which, struct parspec *pp, struct vsb *vsb)
{

        switch (which) {
        case MCF_DEFAULT:
                REPLACE(pp->dyn_def, VSB_data(vsb));
                pp->def = pp->dyn_def;
                break;
        case MCF_MINIMUM:
                REPLACE(pp->dyn_min, VSB_data(vsb));
                pp->min = pp->dyn_min;
                break;
        case MCF_MAXIMUM:
                REPLACE(pp->dyn_max, VSB_data(vsb));
                pp->max = pp->dyn_max;
                break;
        default:
                WRONG("bad 'which'");
        }
}

static void
mcf_wash_param(struct cli *cli, struct parspec *pp, enum mcf_which_e which,
    const char *name, struct vsb *vsb)
{
        const char *val;
        int err;

        switch (which) {
        case MCF_DEFAULT: val = pp->def; break;
        case MCF_MINIMUM: val = pp->min; break;
        case MCF_MAXIMUM: val = pp->max; break;
        default:
                WRONG("bad 'which'");
        }
        AN(val);

        if (pp->func == tweak_alias) {
                assert(which == MCF_DEFAULT);
                pp->priv = mcf_findpar(pp->def);
                pp->def = NULL;
                return;
        }

        VSB_clear(vsb);
        VSB_printf(vsb, "FAILED to set %s for param %s: %s\n",
            name, pp->name, val);
        err = pp->func(vsb, pp, val);
        AZ(VSB_finish(vsb));
        if (err) {
                VCLI_Out(cli, "%s\n", VSB_data(vsb));
                VCLI_SetResult(cli, CLIS_CANT);
                return;
        }
        VSB_clear(vsb);
        err = pp->func(vsb, pp, NULL);
        AZ(err);
        AZ(VSB_finish(vsb));
        if (strcmp(val, VSB_data(vsb)))
                mcf_dyn_vsb(which, pp, vsb);
}

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

static struct cli_proto cli_params[] = {
        { CLICMD_PARAM_SHOW,    "", mcf_param_show, mcf_param_show_json },
        { CLICMD_PARAM_SET,     "", mcf_param_set, mcf_param_set_json },
        { CLICMD_PARAM_RESET,   "", mcf_param_reset, mcf_param_set_json },
        { NULL }
};

/*--------------------------------------------------------------------
 * Configure the parameters
 */

void
MCF_InitParams(struct cli *cli)
{
        struct plist *pl;
        struct parspec *pp;
        struct vsb *vsb;
        ssize_t def, low;

        mcf_init_params();
        MCF_TcpParams();

        def = 80 * 1024;

        if (sizeof(void *) < 8) {               /*lint !e506 !e774  */
                /*
                 * Adjust default parameters for 32 bit systems to conserve
                 * VM space.
                 *
                 * Reflect changes in doc/sphinx/reference/varnishd.rst !
                 */
                MCF_ParamConf(MCF_DEFAULT, "workspace_client", "24k");
                MCF_ParamConf(MCF_DEFAULT, "workspace_backend", "20k");
                MCF_ParamConf(MCF_DEFAULT, "http_resp_size", "8k");
                MCF_ParamConf(MCF_DEFAULT, "http_req_size", "12k");
                MCF_ParamConf(MCF_DEFAULT, "gzip_buffer", "4k");
                MCF_ParamConf(MCF_DEFAULT, "vsl_buffer", "4k");
                MCF_ParamConf(MCF_MAXIMUM, "vsl_space", "1G");
                def = 64 * 1024;
        }

        low = sysconf(_SC_THREAD_STACK_MIN);
        MCF_ParamConf(MCF_MINIMUM, "thread_pool_stack", "%jdb", (intmax_t)low);

#if defined(ENABLE_SANITIZER) || defined(ENABLE_COVERAGE)
        def = 192 * 1024;
#endif

        if (def < low)
                def = low;
        MCF_ParamConf(MCF_DEFAULT, "thread_pool_stack", "%jdb", (intmax_t)def);

#if !defined(MAX_THREAD_POOLS)
#  define MAX_THREAD_POOLS 32
#endif

        MCF_ParamConf(MCF_MAXIMUM, "thread_pools", "%d", MAX_THREAD_POOLS);

#if !defined(HAVE_ACCEPT_FILTERS) || defined(__linux)
        MCF_ParamConf(MCF_DEFAULT, "accept_filter", "off");
#endif

        VCLS_AddFunc(mgt_cls, MCF_AUTH, cli_params);

        vsb = VSB_new_auto();
        AN(vsb);

        VTAILQ_FOREACH(pl, &phead, list) {
                pp = pl->spec;

                if (pp->flags & NOT_IMPLEMENTED)
                        continue;
                if (pp->min != NULL)
                        mcf_wash_param(cli, pp, MCF_MINIMUM, "minimum", vsb);
                if (pp->max != NULL)
                        mcf_wash_param(cli, pp, MCF_MAXIMUM, "maximum", vsb);
                AN(pp->def);
                mcf_wash_param(cli, pp, MCF_DEFAULT, "default", vsb);
        }
        VSB_destroy(&vsb);

        AN(mgt_cc_cmd);
        REPLACE(mgt_cc_cmd_def, mgt_cc_cmd);
}

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

void
MCF_ParamConf(enum mcf_which_e which, const char * const param,
    const char *fmt, ...)
{
        struct parspec *pp;
        struct vsb *vsb;
        va_list ap;

        pp = mcf_findpar(param);
        AN(pp);
        vsb = VSB_new_auto();
        AN(vsb);
        va_start(ap, fmt);
        VSB_vprintf(vsb, fmt, ap);
        va_end(ap);
        AZ(VSB_finish(vsb));
        mcf_dyn_vsb(which, pp, vsb);
        VSB_destroy(&vsb);
}

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

void
MCF_DumpRstParam(void)
{
        struct plist *pl;
        const struct parspec *pp;
        const char *p, *q, *t1, *t2;
        size_t z;

        printf("\n.. The following is the autogenerated "
            "output from varnishd -x parameter\n\n");
        VTAILQ_FOREACH(pl, &phead, list) {
                pp = pl->spec;
                if (!strcmp("deprecated_dummy", pp->name))
                    continue;
                printf(".. _ref_param_%s:\n\n", pp->name);
                printf("%s\n", pp->name);
                for (z = 0; z < strlen(pp->name); z++)
                        printf("~");
                printf("\n");

                if (pp->flags && pp->flags & PLATFORM_DEPENDENT)
                        printf("\n%s\n\n", PLATFORM_DEPENDENT_TEXT);

                if (pp->flags && pp->flags & BUILD_OPTIONS)
                        printf("\n%s\n\n", BUILD_OPTIONS_TEXT);

                if (pp->units != NULL && *pp->units != '\0')
                        printf("\t* Units: %s\n", pp->units);
#define MCF_DYN_REASON(lbl, nm)                                 \
                if (pp->dyn_ ## nm ## _reason != NULL)          \
                        printf("\t* " #lbl ": %s\n",            \
                            pp->dyn_ ## nm ## _reason);         \
                else if (pp->nm != NULL)                        \
                        printf("\t* " #lbl ": %s\n", pp->nm);
                MCF_DYN_REASON(Default, def);
                MCF_DYN_REASON(Minimum, min);
                MCF_DYN_REASON(Maximum, max);
#undef MCF_DYN_REASON
                if (pp->flags & ~DOCS_FLAGS) {
                        printf("\t* Flags: ");
                        q = "";

                        if (pp->flags & DELAYED_EFFECT) {
                                printf("%sdelayed", q);
                                q = ", ";
                        }
                        if (pp->flags & MUST_RESTART) {
                                printf("%smust_restart", q);
                                q = ", ";
                        }
                        if (pp->flags & MUST_RELOAD) {
                                printf("%smust_reload", q);
                                q = ", ";
                        }
                        if (pp->flags & EXPERIMENTAL) {
                                printf("%sexperimental", q);
                                q = ", ";
                        }
                        if (pp->flags & WIZARD) {
                                printf("%swizard", q);
                                q = ", ";
                        }
                        if (pp->flags & ONLY_ROOT) {
                                printf("%sonly_root", q);
                                q = ", ";
                        }
                        if (pp->flags & OBJ_STICKY) {
                                printf("%sobj_sticky", q);
                                q = ", ";
                        }
                        printf("\n");
                }
                printf("\n");
                p = pp->descr;
                while (*p != '\0') {
                        q = strchr(p, '\n');
                        if (q == NULL)
                                q = strchr(p, '\0');
                        t1 = strchr(p, '\t');
                        if (t1 != NULL && t1 < q) {
                                t2 = strchr(t1 + 1, '\t');
                                AN(t2);
                                printf("\n\t*");
                                (void)fwrite(t1 + 1, (t2 - 1) - t1, 1, stdout);
                                printf("*\n\t\t");
                                p = t2 + 1;
                        }
                        (void)fwrite(p, q - p, 1, stdout);
                        p = q;
                        if (*p == '\n') {
                                printf("\n");
                                p++;
                        }
                        continue;
                }
                printf("\n\n");
        }
}

		varnish-cache/bin/varnishd/mgt/mgt_param.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
31		#include "config.h"
32
33		#include <ctype.h>
34		#include <stdarg.h>
35		#include <stdio.h>
36		#include <stdlib.h>
37		#include <string.h>
38		#include <unistd.h>
39
40		#include "mgt/mgt.h"
41		#include "common/heritage.h"
42
43		#include "mgt/mgt_param.h"
44		#include "vav.h"
45		#include "vcli_serve.h"
46
47		struct plist {
48		unsigned magic;
49		#define PLIST_MAGIC 0xbfc3ea16
50		VTAILQ_ENTRY(plist) list;
51		struct parspec *spec;
52		};
53
54		static VTAILQ_HEAD(, plist) phead = VTAILQ_HEAD_INITIALIZER(phead);
55
56		struct params mgt_param;
57		static const int margin1 = 8;
58		static int margin2 = 0;
59		static const int wrap_at = 72;
60		static const int tab0 = 3;
61
62		/--------------------------------------------------------------------/
63
64		static const char OBJ_STICKY_TEXT[] =
65		"\n\n"
66		"NB: This parameter is evaluated only when objects are created. "
67		"To change it for all objects, restart or ban everything.";
68
69		static const char DELAYED_EFFECT_TEXT[] =
70		"\n\n"
71		"NB: This parameter may take quite some time to take (full) effect.";
72
73		static const char MUST_RESTART_TEXT[] =
74		"\n\n"
75		"NB: This parameter will not take any effect until the "
76		"child process has been restarted.";
77
78		static const char MUST_RELOAD_TEXT[] =
79		"\n\n"
80		"NB: This parameter will not take any effect until the "
81		"VCL programs have been reloaded.";
82
83		static const char EXPERIMENTAL_TEXT[] =
84		"\n\n"
85		"NB: We do not know yet if it is a good idea to change "
86		"this parameter, or if the default value is even sensible. "
87		"Caution is advised, and feedback is most welcome.";
88
89		static const char WIZARD_TEXT[] =
90		"\n\n"
91		"NB: Do not change this parameter, unless a developer tell "
92		"you to do so.";
93
94		static const char PROTECTED_TEXT[] =
95		"\n\n"
96		"NB: This parameter is protected and can not be changed.";
97
98		static const char ONLY_ROOT_TEXT[] =
99		"\n\n"
100		"NB: This parameter only works if varnishd is run as root.";
101
102		static const char NOT_IMPLEMENTED_TEXT[] =
103		"\n\n"
104		"NB: This parameter depends on a feature which is not available"
105		" on this platform.";
106
107		static const char PLATFORM_DEPENDENT_TEXT[] =
108		"\n\n"
109		"NB: This parameter depends on a feature which is not available"
110		" on all platforms.";
111
112		static const char BUILD_OPTIONS_TEXT[] =
113		"\n\n"
114		"NB: The actual default value for this parameter depends on the"
115		" Varnish build environment and options.";
116
117		/--------------------------------------------------------------------/
118
119		static struct parspec *
120	1113100	mcf_findpar(const char *name)
121		{
122		struct plist *pl;
123
124	1113100	AN(name);
125	99251350	VTAILQ_FOREACH(pl, &phead, list)
126	99251250	if (!strcmp(pl->spec->name, name))
127	1113000	return (pl->spec);
128	100	return (NULL);
129	1113100	}
130
131		static void
132	2901600	mcf_addpar(struct parspec *ps)
133		{
134		struct plist pl, pl2;
135		int i;
136
137	2901600	ALLOC_OBJ(pl, PLIST_MAGIC);
138	2901600	AN(pl);
139	2901600	pl->spec = ps;
140	131539200	VTAILQ_FOREACH(pl2, &phead, list) {
141	130894400	i = strcmp(pl2->spec->name, pl->spec->name);
142	130894400	if (i == 0) {
143	0	fprintf(stderr, "Duplicate param: %s\n", ps->name);
144	0	exit(4);
145	130894400	} else if (i > 0) {
146	2256800	VTAILQ_INSERT_BEFORE(pl2, pl, list);
147	2256800	return;
148		}
149	128637600	}
150	644800	VTAILQ_INSERT_TAIL(&phead, pl, list);
151	2901600	}
152
153		/*--------------------------------------------------------------------
154		* Wrap the text nicely.
155		* Lines are allowed to contain two TABS and we render that as a table
156		* taking the width of the first column into account.
157		*/
158
159		static void
160	57200	mcf_wrap_line(struct cli cli, const char b, const char *e, int tabs, int m0)
161		{
162	57200	int n, hadtabs = 0;
163		const char *w;
164
165	57200	n = m0;
166	57200	VCLI_Out(cli, "%*s", n, "");
167
168	847625	while (b < e) {
169	818725	if (!isspace(*b)) {
170	400725	VCLI_Out(cli, "%c", *b);
171	400725	b++;
172	400725	n++;
173	818725	} else if (*b == '\t') {
174	12350	assert(tabs);
175	12350	assert(hadtabs < 2);
176	12350	do {
177	97550	VCLI_Out(cli, " ");
178	97550	n++;
179	97550	} while ((n % tabs) != (m0 + tab0) % tabs);
180	12350	b++;
181	12350	hadtabs++;
182	12350	} else {
183	405650	assert (*b == ' ');
184	2420850	for (w = b + 1; w < e; w++)
185	2391950	if (isspace(*w))
186	376750	break;
187	405650	if (n + (w - b) < wrap_at) {
188	377350	VCLI_Out(cli, "%.*s", (int)(w - b), b);
189	377350	n += (w - b);
190	377350	b = w;
191	377350	} else {
192	28300	assert(hadtabs == 0 \|\| hadtabs == 2);
193	28300	VCLI_Out(cli, "\n");
194	56600	mcf_wrap_line(cli, b + 1, e, 0,
195	28300	hadtabs ? m0 + tab0 + tabs : m0);
196	28300	return;
197		}
198		}
199		}
200	28900	assert(b == e);
201	57200	}
202
203		static void
204	13975	mcf_wrap(struct cli cli, const char text)
205		{
206		const char p, q, *r;
207	13975	int tw = 0;
208
209	13975	if (strchr(text, '\t') != NULL) {
210	6975	for (p = text; *p != '\0'; ) {
211	6975	q = strstr(p, "\n\t");
212	6975	if (q == NULL)
213	800	break;
214	6175	q += 2;
215	6175	r = strchr(q, '\t');
216	6175	if (r == NULL) {
217	0	fprintf(stderr,
218	0	"LINE with just one TAB: <%s>\n", text);
219	0	exit(4);
220		}
221	6175	if (r - q > tw)
222	2200	tw = r - q;
223	6175	p = q;
224		}
225	800	tw += 2;
226	800	if (tw < 20)
227	675	tw = 20;
228	800	}
229
230	72150	for (p = text; *p != '\0'; ) {
231	58175	if (*p == '\n') {
232	29275	VCLI_Out(cli, "\n");
233	29275	p++;
234	29275	continue;
235		}
236	28900	q = strchr(p, '\n');
237	28900	if (q == NULL)
238	13975	q = strchr(p, '\0');
239	28900	mcf_wrap_line(cli, p, q, tw, margin1);
240	28900	p = q;
241		}
242	13975	}
243
244		/--------------------------------------------------------------------/
245
246		static void v_matchproto_(cli_func_t)
247	825	mcf_param_show(struct cli cli, const char const av, void priv)
248		{
249		struct plist *pl;
250		const struct parspec pp, pa;
251	825	int n, lfmt = 0, chg = 0;
252		struct vsb *vsb;
253	825	const char *show = NULL;
254
255	825	(void)priv;
256
257	1500	for (n = 2; av[n] != NULL; n++) {
258	700	if (strcmp(av[n], "-l") == 0) {
259	75	lfmt = 1;
260	75	continue;
261		}
262	625	if (strcmp(av[n], "changed") == 0) {
263	25	chg = 1;
264	25	continue;
265		}
266	600	if (show != NULL) {
267	25	VCLI_SetResult(cli, CLIS_TOOMANY);
268	25	VCLI_Out(cli, "Too many parameters");
269	25	return;
270		}
271	575	show = av[n];
272	575	lfmt = 1;
273	575	}
274
275	800	vsb = VSB_new_auto();
276	800	AN(vsb);
277
278	800	n = 0;
279	94400	VTAILQ_FOREACH(pl, &phead, list) {
280	93600	pp = pl->spec;
281	93600	if (lfmt && show != NULL && strcmp(pp->name, show))
282	63825	continue;
283	29875	if (pp->func == tweak_alias &&
284	1100	(show == NULL \|\| strcmp(pp->name, show)))
285	1000	continue;
286	28775	n++;
287
288	28775	VSB_clear(vsb);
289	28775	if (pp->func(vsb, pp, NULL))
290	0	VCLI_SetResult(cli, CLIS_PARAM);
291	28775	AZ(VSB_finish(vsb));
292	28775	if (chg && pp->def != NULL && !strcmp(pp->def, VSB_data(vsb)))
293	2525	continue;
294
295	26250	if (pp->flags & NOT_IMPLEMENTED) {
296	0	if (lfmt) {
297	0	VCLI_Out(cli, "%s\n", pp->name);
298	0	VCLI_Out(cli, "%-*sNot available", margin1, " ");
299	0	} else {
300	0	VCLI_Out(cli, "%-*s-", margin2, pp->name);
301		}
302	0	} else {
303	26250	if (lfmt) {
304	9000	VCLI_Out(cli, "%s\n", pp->name);
305	9000	VCLI_Out(cli, "%-*sValue is: ", margin1, " ");
306	9000	} else {
307	17250	VCLI_Out(cli, "%-*s", margin2, pp->name);
308		}
309
310	26250	VCLI_Out(cli, "%s", VSB_data(vsb));
311	26250	if (pp->units != NULL && *pp->units != '\0')
312	20900	VCLI_Out(cli, " [%s]", pp->units);
313	26250	if (pp->def != NULL && !strcmp(pp->def, VSB_data(vsb)))
314	23325	VCLI_Out(cli, " (default)");
315		}
316	26250	VCLI_Out(cli, "\n");
317
318	26250	if (lfmt && pp->func == tweak_alias) {
319	100	pa = TRUST_ME(pp->priv);
320	200	VCLI_Out(cli, "%-*sAlias of: %s\n",
321	100	margin1, " ", pa->name);
322	100	}
323	26250	if (lfmt && pp->flags & NOT_IMPLEMENTED) {
324	0	VCLI_Out(cli, "\n");
325	0	mcf_wrap(cli, NOT_IMPLEMENTED_TEXT);
326	0	VCLI_Out(cli, "\n\n");
327	26250	} else if (lfmt) {
328	9000	if (pp->def != NULL && strcmp(pp->def, VSB_data(vsb)))
329	2100	VCLI_Out(cli, "%-*sDefault is: %s\n",
330	1050	margin1, "", pp->def);
331	9000	if (pp->min != NULL)
332	13750	VCLI_Out(cli, "%-*sMinimum is: %s\n",
333	6875	margin1, "", pp->min);
334	9000	if (pp->max != NULL)
335	3600	VCLI_Out(cli, "%-*sMaximum is: %s\n",
336	1800	margin1, "", pp->max);
337	9000	VCLI_Out(cli, "\n");
338	9000	mcf_wrap(cli, pp->descr);
339	9000	if (pp->flags & OBJ_STICKY)
340	250	mcf_wrap(cli, OBJ_STICKY_TEXT);
341	9000	if (pp->flags & DELAYED_EFFECT)
342	1200	mcf_wrap(cli, DELAYED_EFFECT_TEXT);
343	9000	if (pp->flags & EXPERIMENTAL)
344	2100	mcf_wrap(cli, EXPERIMENTAL_TEXT);
345	9000	if (pp->flags & MUST_RELOAD)
346	175	mcf_wrap(cli, MUST_RELOAD_TEXT);
347	9000	if (pp->flags & MUST_RESTART)
348	525	mcf_wrap(cli, MUST_RESTART_TEXT);
349	9000	if (pp->flags & WIZARD)
350	375	mcf_wrap(cli, WIZARD_TEXT);
351	9000	if (pp->flags & PROTECTED)
352	25	mcf_wrap(cli, PROTECTED_TEXT);
353	9000	if (pp->flags & ONLY_ROOT)
354	0	mcf_wrap(cli, ONLY_ROOT_TEXT);
355	9000	if (pp->flags & BUILD_OPTIONS)
356	325	mcf_wrap(cli, BUILD_OPTIONS_TEXT);
357	9000	VCLI_Out(cli, "\n\n");
358	9000	}
359	26250	}
360	800	if (show != NULL && n == 0) {
361	25	VCLI_SetResult(cli, CLIS_PARAM);
362	25	VCLI_Out(cli, "Unknown parameter \"%s\".", show);
363	25	}
364	800	VSB_destroy(&vsb);
365	825	}
366
367		static inline void
368	29100	mcf_json_key_valstr(struct cli cli, const char key, const char *val)
369		{
370	29100	VCLI_Out(cli, "\"%s\": ", key);
371	29100	VCLI_JSON_str(cli, val);
372	29100	VCLI_Out(cli, ",\n");
373	29100	}
374
375		static void v_matchproto_(cli_func_t)
376	325	mcf_param_show_json(struct cli cli, const char const av, void priv)
377		{
378	325	int n, comma = 0, chg = 0;
379		struct plist *pl;
380		const struct parspec pp, pa;
381		struct vsb vsb, def;
382	325	const char show = NULL, sep;
383
384	325	(void)priv;
385
386	900	for (int i = 2; av[i] != NULL; i++) {
387	625	if (strcmp(av[i], "-l") == 0) {
388	25	VCLI_SetResult(cli, CLIS_PARAM);
389	25	VCLI_Out(cli, "-l not permitted with param.show -j");
390	25	return;
391		}
392	600	if (strcmp(av[i], "changed") == 0) {
393	25	chg = 1;
394	25	continue;
395		}
396	575	if (strcmp(av[i], "-j") == 0)
397	325	continue;
398	250	if (show != NULL) {
399	25	VCLI_SetResult(cli, CLIS_TOOMANY);
400	25	VCLI_Out(cli, "Too many parameters");
401	25	return;
402		}
403	225	show = av[i];
404	225	}
405
406	275	vsb = VSB_new_auto();
407	275	AN(vsb);
408	275	def = VSB_new_auto();
409	275	AN(def);
410
411	275	n = 0;
412	275	VCLI_JSON_begin(cli, 2, av);
413	275	VCLI_Out(cli, ",\n");
414	32450	VTAILQ_FOREACH(pl, &phead, list) {
415	32175	pp = pl->spec;
416	32175	if (show != NULL && strcmp(pp->name, show) != 0)
417	23225	continue;
418	8975	if (pp->func == tweak_alias &&
419	325	(show == NULL \|\| strcmp(pp->name, show)))
420	300	continue;
421	8650	n++;
422
423	8650	VSB_clear(vsb);
424	8650	if (pp->func(vsb, pp, JSON_FMT))
425	0	VCLI_SetResult(cli, CLIS_PARAM);
426	8650	AZ(VSB_finish(vsb));
427	8650	VSB_clear(def);
428	8650	if (pp->func(def, pp, NULL))
429	0	VCLI_SetResult(cli, CLIS_PARAM);
430	8650	AZ(VSB_finish(def));
431	8650	if (chg && pp->def != NULL && !strcmp(pp->def, VSB_data(def)))
432	2525	continue;
433
434	6125	VCLI_Out(cli, "%s", comma ? ",\n" : "");
435	6125	comma++;
436	6125	VCLI_Out(cli, "{\n");
437	6125	VSB_indent(cli->sb, 2);
438	6125	mcf_json_key_valstr(cli, "name", pp->name);
439	6125	if (pp->func == tweak_alias) {
440	25	pa = TRUST_ME(pp->priv);
441	25	mcf_json_key_valstr(cli, "alias", pa->name);
442	25	}
443	6125	if (pp->flags & NOT_IMPLEMENTED) {
444	0	VCLI_Out(cli, "\"implemented\": false\n");
445	0	VSB_indent(cli->sb, -2);
446	0	VCLI_Out(cli, "}");
447	0	continue;
448		}
449	6125	VCLI_Out(cli, "\"implemented\": true,\n");
450	6125	VCLI_Out(cli, "\"value\": %s,\n", VSB_data(vsb));
451	6125	if (pp->units != NULL && *pp->units != '\0')
452	4800	mcf_json_key_valstr(cli, "units", pp->units);
453
454	6125	if (pp->def != NULL)
455	6100	mcf_json_key_valstr(cli, "default", pp->def);
456	6125	if (pp->min != NULL)
457	4625	mcf_json_key_valstr(cli, "minimum", pp->min);
458	6125	if (pp->max != NULL)
459	1300	mcf_json_key_valstr(cli, "maximum", pp->max);
460	6125	mcf_json_key_valstr(cli, "description", pp->descr);
461
462	6125	VCLI_Out(cli, "\"flags\": [");
463	6125	VSB_indent(cli->sb, 2);
464	6125	sep = "";
465
466		#define flag_out(flag, string) do { \
467		if (pp->flags & flag) { \
468		VCLI_Out(cli, "%s\n", sep); \
469		VCLI_Out(cli, "\"%s\"", #string); \
470		sep = ","; \
471		} \
472		} while(0)
473
474	6125	flag_out(OBJ_STICKY, obj_sticky);
475	6125	flag_out(DELAYED_EFFECT, delayed_effect);
476	6125	flag_out(EXPERIMENTAL, experimental);
477	6125	flag_out(MUST_RELOAD, must_reload);
478	6125	flag_out(MUST_RESTART, must_restart);
479	6125	flag_out(WIZARD, wizard);
480	6125	flag_out(PROTECTED, protected);
481	6125	flag_out(ONLY_ROOT, only_root);
482	6125	flag_out(BUILD_OPTIONS, build_options);
483
484		#undef flag_out
485
486	6125	if (pp->flags)
487	2975	VCLI_Out(cli, "\n");
488	6125	VSB_indent(cli->sb, -2);
489	6125	VCLI_Out(cli, "]\n");
490	6125	VSB_indent(cli->sb, -2);
491	6125	VCLI_Out(cli, "}");
492	6125	}
493	275	VCLI_JSON_end(cli);
494	275	if (show != NULL && n == 0) {
495	25	VSB_clear(cli->sb);
496	25	VCLI_SetResult(cli, CLIS_PARAM);
497	25	VCLI_Out(cli, "Unknown parameter \"%s\".", show);
498	25	}
499	275	VSB_destroy(&vsb);