Code Coverage: vinyl-cache/bin/vinyld/mgt/mgt_param.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
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 TYPE_TIMEOUT_TEXT[] =
65
        "\n\n"
66
        "NB: This parameter can be disabled with the value \"never\".";
67
68
static const char OBJ_STICKY_TEXT[] =
69
        "\n\n"
70
        "NB: This parameter is evaluated only when objects are created. "
71
        "To change it for all objects, restart or ban everything.";
72
73
static const char DELAYED_EFFECT_TEXT[] =
74
        "\n\n"
75
        "NB: This parameter may take quite some time to take (full) effect.";
76
77
static const char MUST_RESTART_TEXT[] =
78
        "\n\n"
79
        "NB: This parameter will not take any effect until the "
80
        "child process has been restarted.";
81
82
static const char MUST_RELOAD_TEXT[] =
83
        "\n\n"
84
        "NB: This parameter will not take any effect until the "
85
        "VCL programs have been reloaded.";
86
87
static const char EXPERIMENTAL_TEXT[] =
88
        "\n\n"
89
        "NB: We do not know yet if it is a good idea to change "
90
        "this parameter, or if the default value is even sensible. "
91
        "Caution is advised, and feedback is most welcome.";
92
93
static const char WIZARD_TEXT[] =
94
        "\n\n"
95
        "NB: Do not change this parameter, unless a developer tell "
96
        "you to do so.";
97
98
static const char PROTECTED_TEXT[] =
99
        "\n\n"
100
        "NB: This parameter is protected and cannot be changed.";
101
102
static const char ONLY_ROOT_TEXT[] =
103
        "\n\n"
104
        "NB: This parameter only works if vinyld is run as root.";
105
106
static const char NOT_IMPLEMENTED_TEXT[] =
107
        "\n\n"
108
        "NB: This parameter depends on a feature which is not available"
109
        " on this platform.";
110
111
static const char PLATFORM_DEPENDENT_TEXT[] =
112
        "\n\n"
113
        "NB: This parameter depends on a feature which is not available"
114
        " on all platforms.";
115
116
static const char BUILD_OPTIONS_TEXT[] =
117
        "\n\n"
118
        "NB: The actual default value for this parameter depends on the"
119
        " Vinyl Cache build environment and options.";
120
121
/*--------------------------------------------------------------------*/
122
123
static struct parspec *
124
mcf_findpar(const char *name)
125 50384
{
126 50384
        struct plist *pl;
127
128 50384
        AN(name);
129 50384
        VTAILQ_FOREACH(pl, &phead, list)
130 4791409
                if (!vstrcmp(pl->spec->name, name))
131 50380
                        return (pl->spec);
132 4
        return (NULL);
133 50384
}
134
135
static void
136
mcf_addpar(struct parspec *ps)
137 140125
{
138 140125
        struct plist *pl, *pl2;
139 140125
        int i;
140
141 140125
        ALLOC_OBJ(pl, PLIST_MAGIC);
142 140125
        AN(pl);
143 140125
        pl->spec = ps;
144 6705822
        VTAILQ_FOREACH(pl2, &phead, list) {
145 6705822
                i = vstrcmp(pl2->spec->name, pl->spec->name);
146 6705822
                if (i == 0) {
147 0
                        fprintf(stderr, "Duplicate param: %s\n", ps->name);
148 0
                        exit(4);
149 6705822
                } else if (i > 0) {
150 118826
                        VTAILQ_INSERT_BEFORE(pl2, pl, list);
151 118826
                        return;
152 118826
                }
153 6705822
        }
154 21299
        VTAILQ_INSERT_TAIL(&phead, pl, list);
155 21299
}
156
157
static const struct parspec *
158
mcf_alias(struct parspec *alias, const struct parspec *pp)
159 6
{
160 6
        const struct parspec *orig;
161
162 6
        orig = TRUST_ME(pp->priv);
163 6
        AN(orig);
164 6
        vmemcpy(alias, orig, sizeof *alias);
165 6
        alias->priv = TRUST_ME(orig);
166 6
        return (alias);
167 6
}
168
169
/*--------------------------------------------------------------------
170
 * Wrap the text nicely.
171
 * Lines are allowed to contain two TABS and we render that as a table
172
 * taking the width of the first column into account.
173
 */
174
175
static void
176
mcf_wrap_line(struct cli *cli, const char *b, const char *e, int tabs, int m0)
177 2633
{
178 2633
        int n, hadtabs = 0;
179 2633
        const char *w;
180
181 2633
        n = m0;
182 2633
        VCLI_Out(cli, "%*s", n, "");
183
184 38849
        while (b < e) {
185 37529
                if (!isspace(*b)) {
186 18129
                        VCLI_Out(cli, "%c", *b);
187 18129
                        b++;
188 18129
                        n++;
189 19400
                } else if (*b == '\t') {
190 564
                        assert(tabs);
191 564
                        assert(hadtabs < 2);
192 4416
                        do {
193 4416
                                VCLI_Out(cli, " ");
194 4416
                                n++;
195 4416
                        } while ((n % tabs) != (m0 + tab0) % tabs);
196 564
                        b++;
197 564
                        hadtabs++;
198 18836
                } else {
199 18836
                        assert (*b == ' ');
200 112784
                        for (w = b + 1; w < e; w++)
201 111464
                                if (isspace(*w))
202 17516
                                        break;
203 18836
                        if (n + (w - b) < wrap_at) {
204 17523
                                VCLI_Out(cli, "%.*s", (int)(w - b), b);
205 17523
                                n += (w - b);
206 17523
                                b = w;
207 17523
                        } else {
208 1313
                                assert(hadtabs == 0 || hadtabs == 2);
209 1313
                                VCLI_Out(cli, "\n");
210 1313
                                mcf_wrap_line(cli, b + 1, e, 0,
211 1313
                                    hadtabs ? m0 + tab0 + tabs : m0);
212 1313
                                return;
213 1313
                        }
214 18836
                }
215 37529
        }
216 1320
        assert(b == e);
217 1320
}
218
219
static void
220
mcf_wrap(struct cli *cli, const char *text)
221 648
{
222 648
        const char *p, *q, *r;
223 648
        int tw = 0;
224
225 648
        if (strchr(text, '\t') != NULL) {
226 318
                for (p = text; *p != '\0'; ) {
227 318
                        q = strstr(p, "\n\t");
228 318
                        if (q == NULL)
229 36
                                break;
230 282
                        q += 2;
231 282
                        r = strchr(q, '\t');
232 282
                        if (r == NULL) {
233 0
                                fprintf(stderr,
234 0
                                    "LINE with just one TAB: <%s>\n", text);
235 0
                                exit(4);
236 0
                        }
237 282
                        if (r - q > tw)
238 101
                                tw = r - q;
239 282
                        p = q;
240 282
                }
241 36
                tw += 2;
242 36
                if (tw < 20)
243 31
                        tw = 20;
244 36
        }
245
246 3371
        for (p = text; *p != '\0'; ) {
247 2723
                if (*p == '\n') {
248 1403
                        VCLI_Out(cli, "\n");
249 1403
                        p++;
250 1403
                        continue;
251 1403
                }
252 1320
                q = strchr(p, '\n');
253 1320
                if (q == NULL)
254 648
                        q = strchr(p, '\0');
255 1320
                mcf_wrap_line(cli, p, q, tw, margin1);
256 1320
                p = q;
257 1320
        }
258 648
}
259
260
/*--------------------------------------------------------------------*/
261
262
static void v_matchproto_(cli_func_t)
263
mcf_param_show(struct cli *cli, const char * const *av, void *priv)
264 35
{
265 35
        struct plist *pl;
266 35
        const struct parspec *pp, *pa;
267 35
        struct parspec alias[1];
268 35
        int n, lfmt = 0, chg = 0;
269 35
        struct vsb *vsb;
270 35
        const char *show = NULL;
271
272 35
        (void)priv;
273
274 64
        for (n = 2; av[n] != NULL; n++) {
275 30
                if (strcmp(av[n], "-l") == 0) {
276 3
                        lfmt = 1;
277 3
                        continue;
278 3
                }
279 27
                if (strcmp(av[n], "changed") == 0) {
280 1
                        chg = 1;
281 1
                        continue;
282 1
                }
283 26
                if (show != NULL) {
284 1
                        VCLI_SetResult(cli, CLIS_TOOMANY);
285 1
                        VCLI_Out(cli, "Too many parameters");
286 1
                        return;
287 1
                }
288 25
                show = av[n];
289 25
                lfmt = 1;
290 25
        }
291
292 34
        vsb = VSB_new_auto();
293 34
        AN(vsb);
294
295 34
        n = 0;
296 4250
        VTAILQ_FOREACH(pl, &phead, list) {
297 4250
                pp = pl->spec;
298 4250
                if (lfmt && show != NULL && strcmp(pp->name, show))
299 2977
                        continue;
300 1273
                if (pp->func == tweak_alias) {
301 44
                        if (show == NULL)
302 40
                                continue;
303 4
                        if (strcmp(pp->name, show))
304 0
                                continue;
305 4
                        pp = mcf_alias(alias, pp);
306 4
                }
307 1233
                n++;
308
309 1233
                VSB_clear(vsb);
310 1233
                if (pp->func(vsb, pp, NULL))
311 0
                        VCLI_SetResult(cli, CLIS_PARAM);
312 1233
                AZ(VSB_finish(vsb));
313 1233
                if (chg && pp->def != NULL && !strcmp(pp->def, VSB_data(vsb)))
314 109
                        continue;
315
316 1124
                if (pp->flags & NOT_IMPLEMENTED) {
317 0
                        if (lfmt) {
318 0
                                VCLI_Out(cli, "%s\n", pp->name);
319 0
                                VCLI_Out(cli, "%-*sNot available", margin1, " ");
320 0
                        } else {
321 0
                                VCLI_Out(cli, "%-*s-", margin2, pp->name);
322 0
                        }
323 1124
                } else {
324 1124
                        if (lfmt) {
325 386
                                VCLI_Out(cli, "%s\n", pp->name);
326 386
                                VCLI_Out(cli, "%-*sValue is: ", margin1, " ");
327 738
                        } else {
328 738
                                VCLI_Out(cli, "%-*s", margin2, pp->name);
329 738
                        }
330
331 1124
                        VCLI_Out(cli, "%s", VSB_data(vsb));
332 1124
                        if (pp->units != NULL && *pp->units != '\0')
333 901
                                VCLI_Out(cli, " [%s]", pp->units);
334 1124
                        if (pp->def != NULL && !strcmp(pp->def, VSB_data(vsb)))
335 1008
                                VCLI_Out(cli, " (default)");
336 1124
                }
337 1124
                VCLI_Out(cli, "\n");
338
339 1124
                if (lfmt && pp->func == tweak_alias) {
340 0
                        pa = TRUST_ME(pp->priv);
341 0
                        VCLI_Out(cli, "%-*sAlias of: %s\n",
342 0
                            margin1, " ", pa->name);
343 0
                }
344 1124
                if (lfmt && pp->flags & NOT_IMPLEMENTED) {
345 0
                        VCLI_Out(cli, "\n");
346 0
                        mcf_wrap(cli, NOT_IMPLEMENTED_TEXT);
347 0
                        VCLI_Out(cli, "\n\n");
348 1124
                } else if (lfmt) {
349 386
                        if (pp->def != NULL && strcmp(pp->def, VSB_data(vsb)))
350 45
                                VCLI_Out(cli, "%-*sDefault is: %s\n",
351 45
                                    margin1, "", pp->def);
352 386
                        if (pp->min != NULL)
353 301
                                VCLI_Out(cli, "%-*sMinimum is: %s\n",
354 301
                                    margin1, "", pp->min);
355 386
                        if (pp->max != NULL)
356 95
                                VCLI_Out(cli, "%-*sMaximum is: %s\n",
357 95
                                    margin1, "", pp->max);
358 386
                        VCLI_Out(cli, "\n");
359 386
                        mcf_wrap(cli, pp->descr);
360 386
                        if (pp->func == tweak_timeout)
361 40
                                mcf_wrap(cli, TYPE_TIMEOUT_TEXT);
362 386
                        if (pp->flags & OBJ_STICKY)
363 13
                                mcf_wrap(cli, OBJ_STICKY_TEXT);
364 386
                        if (pp->flags & DELAYED_EFFECT)
365 57
                                mcf_wrap(cli, DELAYED_EFFECT_TEXT);
366 386
                        if (pp->flags & EXPERIMENTAL)
367 87
                                mcf_wrap(cli, EXPERIMENTAL_TEXT);
368 386
                        if (pp->flags & MUST_RELOAD)
369 7
                                mcf_wrap(cli, MUST_RELOAD_TEXT);
370 386
                        if (pp->flags & MUST_RESTART)
371 26
                                mcf_wrap(cli, MUST_RESTART_TEXT);
372 386
                        if (pp->flags & WIZARD)
373 18
                                mcf_wrap(cli, WIZARD_TEXT);
374 386
                        if (pp->flags & PROTECTED)
375 1
                                mcf_wrap(cli, PROTECTED_TEXT);
376 386
                        if (pp->flags & ONLY_ROOT)
377 0
                                mcf_wrap(cli, ONLY_ROOT_TEXT);
378 386
                        if (pp->flags & BUILD_OPTIONS)
379 13
                                mcf_wrap(cli, BUILD_OPTIONS_TEXT);
380 386
                        VCLI_Out(cli, "\n\n");
381 386
                }
382 1124
        }
383 34
        if (show != NULL && n == 0) {
384 1
                VCLI_SetResult(cli, CLIS_PARAM);
385 1
                VCLI_Out(cli, "Unknown parameter \"%s\".", show);
386 1
        }
387 34
        VSB_destroy(&vsb);
388 34
}
389
390
static inline void
391
mcf_json_key_valstr(struct cli *cli, const char *key, const char *val)
392 1262
{
393 1262
        VCLI_Out(cli, "\"%s\": ", key);
394 1262
        VCLI_JSON_str(cli, val);
395 1262
        VCLI_Out(cli, ",\n");
396 1262
}
397
398
static void v_matchproto_(cli_func_t)
399
mcf_param_show_json(struct cli *cli, const char * const *av, void *priv)
400 15
{
401 15
        int n, comma = 0, chg = 0;
402 15
        struct plist *pl;
403 15
        const struct parspec *pp, *pa;
404 15
        struct parspec alias[1];
405 15
        struct vsb *vsb, *def;
406 15
        const char *show = NULL, *sep;
407
408 15
        (void)priv;
409
410 42
        for (int i = 2; av[i] != NULL; i++) {
411 29
                if (strcmp(av[i], "-l") == 0) {
412 1
                        VCLI_SetResult(cli, CLIS_PARAM);
413 1
                        VCLI_Out(cli, "-l not permitted with param.show -j");
414 1
                        return;
415 1
                }
416 28
                if (strcmp(av[i], "changed") == 0) {
417 1
                        chg = 1;
418 1
                        continue;
419 1
                }
420 27
                if (strcmp(av[i], "-j") == 0)
421 15
                        continue;
422 12
                if (show != NULL) {
423 1
                        VCLI_SetResult(cli, CLIS_TOOMANY);
424 1
                        VCLI_Out(cli, "Too many parameters");
425 1
                        return;
426 1
                }
427 11
                show = av[i];
428 11
        }
429
430 13
        vsb = VSB_new_auto();
431 13
        AN(vsb);
432 13
        def = VSB_new_auto();
433 13
        AN(def);
434
435 13
        n = 0;
436 13
        VCLI_JSON_begin(cli, 2, av);
437 13
        VCLI_Out(cli, ",\n");
438 1625
        VTAILQ_FOREACH(pl, &phead, list) {
439 1625
                pp = pl->spec;
440 1625
                if (show != NULL && strcmp(pp->name, show) != 0)
441 1241
                        continue;
442 384
                if (pp->func == tweak_alias) {
443 13
                        if (show == NULL)
444 12
                                continue;
445 1
                        if (strcmp(pp->name, show))
446 0
                                continue;
447 1
                        pp = mcf_alias(alias, pp);
448 1
                }
449 372
                n++;
450
451 372
                VSB_clear(vsb);
452 372
                if (pp->func(vsb, pp, JSON_FMT))
453 0
                        VCLI_SetResult(cli, CLIS_PARAM);
454 372
                AZ(VSB_finish(vsb));
455 372
                VSB_clear(def);
456 372
                if (pp->func(def, pp, NULL))
457 0
                        VCLI_SetResult(cli, CLIS_PARAM);
458 372
                AZ(VSB_finish(def));
459 372
                if (chg && pp->def != NULL && !strcmp(pp->def, VSB_data(def)))
460 109
                        continue;
461
462 263
                VCLI_Out(cli, "%s", comma ? ",\n" : "");
463 263
                comma++;
464 263
                VCLI_Out(cli, "{\n");
465 263
                VSB_indent(cli->sb, 2);
466 263
                mcf_json_key_valstr(cli, "name", pp->name);
467 263
                if (pp->func == tweak_alias) {
468 0
                        pa = TRUST_ME(pp->priv);
469 0
                        mcf_json_key_valstr(cli, "alias", pa->name);
470 0
                }
471 263
                if (pp->flags & NOT_IMPLEMENTED) {
472 0
                        VCLI_Out(cli, "\"implemented\": false\n");
473 0
                        VSB_indent(cli->sb, -2);
474 0
                        VCLI_Out(cli, "}");
475 0
                        continue;
476 0
                }
477 263
                VCLI_Out(cli, "\"implemented\": true,\n");
478 263
                VCLI_Out(cli, "\"value\": %s,\n", VSB_data(vsb));
479 263
                if (pp->units != NULL && *pp->units != '\0')
480 206
                        mcf_json_key_valstr(cli, "units", pp->units);
481
482 263
                if (pp->def != NULL)
483 263
                        mcf_json_key_valstr(cli, "default", pp->def);
484 263
                if (pp->min != NULL)
485 201
                        mcf_json_key_valstr(cli, "minimum", pp->min);
486 263
                if (pp->max != NULL)
487 66
                        mcf_json_key_valstr(cli, "maximum", pp->max);
488 263
                mcf_json_key_valstr(cli, "description", pp->descr);
489
490 263
                VCLI_Out(cli, "\"flags\": [");
491 263
                VSB_indent(cli->sb, 2);
492 263
                sep = "";
493
494 2367
#define flag_out(flag, string) do {                                     \
495 2367
                        if (pp->flags & flag) {                         \
496 151
                                VCLI_Out(cli, "%s\n", sep);             \
497 151
                                VCLI_Out(cli, "\"%s\"", #string);       \
498 151
                                sep = ",";                              \
499 151
                        }                                               \
500 2367
                } while(0)
501
502 263
                flag_out(OBJ_STICKY, obj_sticky);
503 263
                flag_out(DELAYED_EFFECT, delayed_effect);
504 263
                flag_out(EXPERIMENTAL, experimental);
505 263
                flag_out(MUST_RELOAD, must_reload);
506 263
                flag_out(MUST_RESTART, must_restart);
507 263
                flag_out(WIZARD, wizard);
508 263
                flag_out(PROTECTED, protected);
509 263
                flag_out(ONLY_ROOT, only_root);
510 263
                flag_out(BUILD_OPTIONS, build_options);
511
512 263
#undef flag_out
513
514 263
                if (pp->flags)
515 135
                        VCLI_Out(cli, "\n");
516 263
                VSB_indent(cli->sb, -2);
517 263
                VCLI_Out(cli, "]\n");
518 263
                VSB_indent(cli->sb, -2);
519 263
                VCLI_Out(cli, "}");
520 263
        }
521 13
        VCLI_JSON_end(cli);
522 13
        if (show != NULL && n == 0) {
523 1
                VSB_clear(cli->sb);
524 1
                VCLI_SetResult(cli, CLIS_PARAM);
525 1
                VCLI_Out(cli, "Unknown parameter \"%s\".", show);
526 1
        }
527 13
        VSB_destroy(&vsb);
528 13
        VSB_destroy(&def);
529 13
}
530
531
/*--------------------------------------------------------------------
532
 * Mark parameters as protected
533
 */
534
535
void
536
MCF_ParamProtect(struct cli *cli, const char *args)
537 3
{
538 3
        const struct parspec *orig;
539 3
        struct parspec *pp;
540 3
        char **av;
541 3
        int i;
542
543 3
        av = VAV_Parse(args, NULL, ARGV_COMMA);
544 3
        if (av[0] != NULL) {
545 0
                VCLI_Out(cli, "Parse error: %s", av[0]);
546 0
                VCLI_SetResult(cli, CLIS_PARAM);
547 0
                VAV_Free(av);
548 0
                return;
549 0
        }
550 5
        for (i = 1; av[i] != NULL; i++) {
551 3
                pp = mcf_findpar(av[i]);
552 3
                if (pp == NULL) {
553 0
                        VCLI_Out(cli, "Unknown parameter %s", av[i]);
554 0
                        VCLI_SetResult(cli, CLIS_PARAM);
555 0
                        break;
556 0
                }
557 3
                if (pp->func == tweak_alias) {
558 1
                        orig = TRUST_ME(pp->priv);
559 1
                        AN(orig);
560 1
                        VCLI_Out(cli,
561 1
                            "Cannot mark alias %s read only.\n"
562 1
                            "Did you mean to mark %s read only?",
563 1
                            pp->name, orig->name);
564 1
                        VCLI_SetResult(cli, CLIS_PARAM);
565 1
                        break;
566 1
                }
567 2
                pp->flags |= PROTECTED;
568 2
        }
569 3
        VAV_Free(av);
570 3
}
571
572
/*--------------------------------------------------------------------*/
573
574
void
575
MCF_ParamSet(struct cli *cli, const char *param, const char *val)
576 10070
{
577 10070
        const struct parspec *pp;
578 10070
        struct parspec alias[1];
579
580 10070
        pp = mcf_findpar(param);
581 10070
        if (pp == NULL) {
582 4
                VCLI_SetResult(cli, CLIS_PARAM);
583 4
                VCLI_Out(cli, "Unknown parameter \"%s\".", param);
584 4
                return;
585 4
        }
586 10066
        if (pp->flags & NOT_IMPLEMENTED) {
587 0
                VCLI_SetResult(cli, CLIS_CANT);
588 0
                VCLI_Out(cli,
589 0
                    "parameter \"%s\" is not available on this platform.",
590 0
                    param
591 0
                );
592 0
                return;
593 0
        }
594 10066
        if (!val)
595 34
                val = pp->def;
596 10066
        if (pp->func == tweak_alias) {
597 1
                pp = mcf_alias(alias, pp);
598 1
                alias->name = param;
599 1
        }
600 10066
        if (pp->flags & PROTECTED) {
601 3
                VCLI_SetResult(cli, CLIS_AUTH);
602 3
                VCLI_Out(cli, "parameter \"%s\" is protected.", param);
603 3
                return;
604 3
        }
605 10063
        if (pp->func(cli->sb, pp, val))
606 29
                VCLI_SetResult(cli, CLIS_PARAM);
607
608 10063
        if (cli->result == CLIS_OK && heritage.param != NULL)
609 388
                *heritage.param = mgt_param;
610
611 10063
        if (cli->result != CLIS_OK) {
612 29
                VCLI_Out(cli, "\n(attempting to set param '%s' to '%s')",
613 29
                    pp->name, val);
614 10034
        } else if (MCH_Running() && pp->flags & MUST_RESTART) {
615 0
                VCLI_Out(cli,
616 0
                    "\nChange will take effect when child is restarted");
617 10034
        } else if (pp->flags & MUST_RELOAD) {
618 2
                VCLI_Out(cli,
619 2
                    "\nChange will take effect when VCL script is reloaded");
620 2
        }
621 10063
}
622
623
624
/*--------------------------------------------------------------------*/
625
626
static void v_matchproto_(cli_func_t)
627
mcf_param_set(struct cli *cli, const char * const *av, void *priv)
628 600
{
629
630 600
        (void)priv;
631 600
        MCF_ParamSet(cli, av[2], av[3]);
632 600
}
633
634
static void v_matchproto_(cli_func_t)
635
mcf_param_set_json(struct cli *cli, const char * const *av, void *priv)
636 6
{
637 6
        const char *const avs[] = { av[0], av[1], av[2], av[3], NULL };
638
639 6
        MCF_ParamSet(cli, av[3], av[4]);
640 6
        if (cli->result == CLIS_OK)
641 6
                mcf_param_show_json(cli, avs, priv);
642 6
}
643
644
/*--------------------------------------------------------------------*/
645
646
static void v_matchproto_(cli_func_t)
647
mcf_param_reset(struct cli *cli, const char * const *av, void *priv)
648 33
{
649
650 33
        (void)priv;
651 33
        MCF_ParamSet(cli, av[2], NULL);
652 33
}
653
654
/*--------------------------------------------------------------------
655
 * Initialize parameters and sort by name.
656
 */
657
658
static struct parspec mgt_parspec[] = {
659
#define PARAM_ALL
660
#define PARAM_PRE {
661
#define PARAM(typ, fld, nm, ...) #nm, __VA_ARGS__
662
#define PARAM_POST },
663
#include "tbl/params.h"
664
        { NULL, NULL, NULL }
665
};
666
667
static void
668
mcf_init_params(void)
669 1121
{
670 1121
        struct parspec *pp;
671 1121
        const char *s;
672
673 141246
        for (pp = mgt_parspec; pp->name != NULL; pp++) {
674 140125
                AN(pp->func);
675 140125
                s = strchr(pp->descr, '\0');
676 140125
                if (isspace(s[-1])) {
677 0
                        fprintf(stderr,
678 0
                            "Param->descr has trailing space: %s\n", pp->name);
679 0
                        exit(4);
680 0
                }
681 140125
                mcf_addpar(pp);
682 140125
                margin2 = vmax_t(int, margin2, vstrlen(pp->name) + 1);
683 140125
        }
684 1121
}
685
686
/*--------------------------------------------------------------------
687
 * Wash a min/max/default value
688
 */
689
690
static void
691
mcf_dyn_vsb(enum mcf_which_e which, struct parspec *pp, struct vsb *vsb)
692 96361
{
693
694 96361
        switch (which) {
695 31388
        case MCF_DEFAULT:
696 31388
                REPLACE(pp->dyn_def, VSB_data(vsb));
697 31388
                pp->def = pp->dyn_def;
698 31388
                break;
699 40315
        case MCF_MINIMUM:
700 40315
                REPLACE(pp->dyn_min, VSB_data(vsb));
701 40315
                pp->min = pp->dyn_min;
702 40315
                break;
703 24658
        case MCF_MAXIMUM:
704 24658
                REPLACE(pp->dyn_max, VSB_data(vsb));
705 24658
                pp->max = pp->dyn_max;
706 24658
                break;
707 0
        default:
708 0
                WRONG("bad 'which'");
709 96361
        }
710 96361
}
711
712
static void
713
mcf_wash_param(struct cli *cli, struct parspec *pp, enum mcf_which_e which,
714
    const char *name, struct vsb *vsb)
715 282492
{
716 282492
        const char *val;
717 282492
        int err;
718
719 282492
        switch (which) {
720 140125
        case MCF_DEFAULT: val = pp->def; break;
721 107616
        case MCF_MINIMUM: val = pp->min; break;
722 34751
        case MCF_MAXIMUM: val = pp->max; break;
723 0
        default:
724 0
                WRONG("bad 'which'");
725 282492
        }
726 282492
        AN(val);
727
728 282492
        if (pp->func == tweak_alias) {
729 4484
                assert(which == MCF_DEFAULT);
730 4484
                pp->priv = mcf_findpar(pp->def);
731 4484
                pp->def = NULL;
732 4484
                return;
733 4484
        }
734
735 278008
        VSB_clear(vsb);
736 278008
        VSB_printf(vsb, "FAILED to set %s for param %s: %s\n",
737 278008
            name, pp->name, val);
738 278008
        err = pp->func(vsb, pp, val);
739 278008
        AZ(VSB_finish(vsb));
740 278008
        if (err) {
741 0
                VCLI_Out(cli, "%s\n", VSB_data(vsb));
742 0
                VCLI_SetResult(cli, CLIS_CANT);
743 0
                return;
744 0
        }
745 278008
        VSB_clear(vsb);
746 278008
        err = pp->func(vsb, pp, NULL);
747 278008
        AZ(err);
748 278008
        AZ(VSB_finish(vsb));
749 278008
        if (vstrcmp(val, VSB_data(vsb)))
750 60534
                mcf_dyn_vsb(which, pp, vsb);
751 278008
}
752
753
/*--------------------------------------------------------------------*/
754
755
static struct cli_proto cli_params[] = {
756
        { CLICMD_PARAM_SHOW,    "", mcf_param_show, mcf_param_show_json },
757
        { CLICMD_PARAM_SET,     "", mcf_param_set, mcf_param_set_json },
758
        { CLICMD_PARAM_RESET,   "", mcf_param_reset, mcf_param_set_json },
759
        { NULL }
760
};
761
762
/*--------------------------------------------------------------------
763
 * Configure the parameters
764
 */
765
766
void
767
MCF_InitParams(struct cli *cli)
768 1121
{
769 1121
        struct plist *pl;
770 1121
        struct parspec *pp;
771 1121
        struct vsb *vsb;
772 1121
        ssize_t def, low;
773
774 1121
        mcf_init_params();
775 1121
        MCF_TcpParams();
776
777 1121
        def = 80 * 1024;
778
779 1121
        if (sizeof(void *) < 8) {               /*lint !e506 !e774  */
780
                /*
781
                 * Adjust default parameters for 32 bit systems to conserve
782
                 * VM space.
783
                 *
784
                 * Reflect changes in doc/sphinx/reference/vinyld.rst !
785
                 */
786 0
                MCF_ParamConf(MCF_DEFAULT, "workspace_cli", "24k");
787 0
                MCF_ParamConf(MCF_DEFAULT, "workspace_client", "24k");
788 0
                MCF_ParamConf(MCF_DEFAULT, "workspace_backend", "20k");
789 0
                MCF_ParamConf(MCF_DEFAULT, "http_resp_size", "8k");
790 0
                MCF_ParamConf(MCF_DEFAULT, "http_req_size", "12k");
791 0
                MCF_ParamConf(MCF_DEFAULT, "gzip_buffer", "4k");
792 0
                MCF_ParamConf(MCF_DEFAULT, "vsl_buffer", "4k");
793 0
                MCF_ParamConf(MCF_MAXIMUM, "vsl_space", "1G");
794 0
                def = 64 * 1024;
795 0
        }
796
797 1121
        low = sysconf(_SC_THREAD_STACK_MIN);
798 1121
        MCF_ParamConf(MCF_MINIMUM, "thread_pool_stack", "%jdb", (intmax_t)low);
799
800
#if defined(ENABLE_SANITIZER) || defined(ENABLE_COVERAGE)
801
        def = 192 * 1024;
802
#endif
803
804 1121
        if (def < low)
805 0
                def = low;
806 1121
        MCF_ParamConf(MCF_DEFAULT, "thread_pool_stack", "%jdb", (intmax_t)def);
807
808 1121
#if !defined(MAX_THREAD_POOLS)
809 1121
#  define MAX_THREAD_POOLS 32
810 1121
#endif
811
812 1121
        MCF_ParamConf(MCF_MAXIMUM, "thread_pools", "%d", MAX_THREAD_POOLS);
813
814
#if !defined(HAVE_ACCEPT_FILTERS) || defined(__linux)
815
        MCF_ParamConf(MCF_DEFAULT, "accept_filter", "off");
816
#endif
817
818 1121
        VCLS_AddFunc(mgt_cls, MCF_AUTH, cli_params);
819
820 1121
        vsb = VSB_new_auto();
821 1121
        AN(vsb);
822
823 140125
        VTAILQ_FOREACH(pl, &phead, list) {
824 140125
                pp = pl->spec;
825
826 140125
                if (pp->flags & NOT_IMPLEMENTED)
827 0
                        continue;
828 140125
                if (pp->min != NULL)
829 107616
                        mcf_wash_param(cli, pp, MCF_MINIMUM, "minimum", vsb);
830 140125
                if (pp->max != NULL)
831 34751
                        mcf_wash_param(cli, pp, MCF_MAXIMUM, "maximum", vsb);
832 140125
                AN(pp->def);
833 140125
                mcf_wash_param(cli, pp, MCF_DEFAULT, "default", vsb);
834 140125
        }
835 1121
        VSB_destroy(&vsb);
836
837 1121
        AN(mgt_cc_cmd);
838 1121
        REPLACE(mgt_cc_cmd_def, mgt_cc_cmd);
839 1121
}
840
841
/*--------------------------------------------------------------------*/
842
843
void
844
MCF_ParamConf(enum mcf_which_e which, const char * const param,
845
    const char *fmt, ...)
846 35827
{
847 35827
        struct parspec *pp;
848 35827
        struct vsb *vsb;
849 35827
        va_list ap;
850
851 35827
        pp = mcf_findpar(param);
852 35827
        AN(pp);
853 35827
        vsb = VSB_new_auto();
854 35827
        AN(vsb);
855 35827
        va_start(ap, fmt);
856 35827
        VSB_vprintf(vsb, fmt, ap);
857 35827
        va_end(ap);
858 35827
        AZ(VSB_finish(vsb));
859 35827
        mcf_dyn_vsb(which, pp, vsb);
860 35827
        VSB_destroy(&vsb);
861 35827
}
862
863
/*--------------------------------------------------------------------*/
864
865
void
866
MCF_DumpRstParam(void)
867 1
{
868 1
        struct plist *pl;
869 1
        const struct parspec *pp;
870 1
        const char *p, *q, *t1, *t2;
871 1
        unsigned flags;
872 1
        size_t z;
873
874 1
        printf("\n.. The following is the autogenerated "
875 1
            "output from vinyld -x parameter\n\n");
876 125
        VTAILQ_FOREACH(pl, &phead, list) {
877 125
                pp = pl->spec;
878 125
                if (!strcmp("deprecated_dummy", pp->name))
879 1
                    continue;
880 124
                printf(".. _ref_param_%s:\n\n", pp->name);
881 124
                printf("%s\n", pp->name);
882 1981
                for (z = 0; z < vstrlen(pp->name); z++)
883 1857
                        printf("~");
884 124
                printf("\n");
885
886 124
                if (pp->flags && pp->flags & PLATFORM_DEPENDENT)
887 5
                        printf("\n%s\n\n", PLATFORM_DEPENDENT_TEXT);
888
889 124
                if (pp->flags && pp->flags & BUILD_OPTIONS)
890 4
                        printf("\n%s\n\n", BUILD_OPTIONS_TEXT);
891
892 124
                if (pp->units != NULL && *pp->units != '\0')
893 98
                        printf("\t* Units: %s\n", pp->units);
894 124
#define MCF_DYN_REASON(lbl, nm)                                 \
895 372
                if (pp->dyn_ ## nm ## _reason != NULL)          \
896 372
                        printf("\t* " #lbl ": %s\n",            \
897 20
                            pp->dyn_ ## nm ## _reason);         \
898 372
                else if (pp->nm != NULL)                        \
899 352
                        printf("\t* " #lbl ": %s\n", pp->nm);
900 124
                MCF_DYN_REASON(Default, def);
901 124
                MCF_DYN_REASON(Minimum, min);
902 124
                MCF_DYN_REASON(Maximum, max);
903 124
#undef MCF_DYN_REASON
904 124
                flags = pp->flags & ~DOCS_FLAGS;
905 124
                if (pp->func == tweak_timeout)
906 11
                        flags |= TYPE_TIMEOUT;
907 124
                if (flags) {
908 69
                        printf("\t* Flags: ");
909 69
                        q = "";
910
911 69
                        if (flags & TYPE_TIMEOUT) {
912 11
                                printf("%stimeout", q);
913 11
                                q = ", ";
914 11
                        }
915 69
                        if (flags & DELAYED_EFFECT) {
916 19
                                printf("%sdelayed", q);
917 19
                                q = ", ";
918 19
                        }
919 69
                        if (flags & MUST_RESTART) {
920 8
                                printf("%smust_restart", q);
921 8
                                q = ", ";
922 8
                        }
923 69
                        if (flags & MUST_RELOAD) {
924 2
                                printf("%smust_reload", q);
925 2
                                q = ", ";
926 2
                        }
927 69
                        if (flags & EXPERIMENTAL) {
928 29
                                printf("%sexperimental", q);
929 29
                                q = ", ";
930 29
                        }
931 69
                        if (flags & WIZARD) {
932 6
                                printf("%swizard", q);
933 6
                                q = ", ";
934 6
                        }
935 69
                        if (flags & ONLY_ROOT) {
936 0
                                printf("%sonly_root", q);
937 0
                                q = ", ";
938 0
                        }
939 69
                        if (flags & OBJ_STICKY) {
940 4
                                printf("%sobj_sticky", q);
941 4
                                q = ", ";
942 4
                        }
943 69
                        printf("\n");
944 69
                }
945 124
                printf("\n");
946 124
                p = pp->descr;
947 490
                while (*p != '\0') {
948 366
                        q = strchr(p, '\n');
949 366
                        if (q == NULL)
950 124
                                q = strchr(p, '\0');
951 366
                        t1 = strchr(p, '\t');
952 366
                        if (t1 != NULL && t1 < q) {
953 55
                                t2 = strchr(t1 + 1, '\t');
954 55
                                AN(t2);
955 55
                                printf("\n\t*");
956 55
                                (void)fwrite(t1 + 1, (t2 - 1) - t1, 1, stdout);
957 55
                                printf("*\n\t\t");
958 55
                                p = t2 + 1;
959 55
                        }
960 366
                        (void)fwrite(p, q - p, 1, stdout);
961 366
                        p = q;
962 366
                        if (*p == '\n') {
963 242
                                printf("\n");
964 242
                                p++;
965 242
                        }
966 366
                        continue;
967 366
                }
968 124
                printf("\n\n");
969 124
        }
970 1
}
971
972
void
973
MCF_DumpJsonParam(void)
974 1
{
975 1
        struct plist *pl;
976 1
        const struct parspec *pp;
977 1
        const char *p, *q;
978 1
        unsigned flags;
979 1
        struct vsb *vsb = VSB_new_auto();
980
981 1
        CHECK_OBJ_NOTNULL(vsb, VSB_MAGIC);
982
983 1
        p = "\n";
984 1
        VSB_cat(vsb, "{");
985 1
        VSB_indent(vsb, 2);
986 125
        VTAILQ_FOREACH(pl, &phead, list) {
987 125
                pp = pl->spec;
988 125
                if (!strcmp("deprecated_dummy", pp->name))
989 1
                    continue;
990
991 124
                VSB_cat(vsb, p);
992 124
                p = ",\n";
993 124
                VSB_cat(vsb, "\"");
994 124
                VSB_quote(vsb, pp->name, -1, VSB_QUOTE_JSON);
995 124
                VSB_cat(vsb, "\": {\n");
996 124
                VSB_indent(vsb, 2);
997 124
                if (pp->flags & PLATFORM_DEPENDENT)
998 5
                        VSB_cat(vsb, "\"platformDependent\": true,\n");
999
1000 124
                if (pp->flags & BUILD_OPTIONS)
1001 4
                        VSB_cat(vsb, "\"buildDependent\": true,\n");
1002
1003 124
                if (pp->units != NULL && *pp->units != '\0')
1004 98
                        VSB_printf(vsb, "\"units\": \"%s\",\n", pp->units);
1005 124
#define MCF_DYN_REASON(lbl, nm)                                         \
1006 372
                if (pp->dyn_ ## nm ## _reason != NULL)                  \
1007 372
                        VSB_printf(vsb, "\"" #lbl "\": \"%s\",\n",      \
1008 20
                            pp->dyn_ ## nm ## _reason);                 \
1009 372
                else if (pp->nm != NULL)                                \
1010 352
                        VSB_printf(vsb, "\"" #lbl "\": \"%s\",\n", pp->nm);
1011 124
                MCF_DYN_REASON(default, def);
1012 124
                MCF_DYN_REASON(minimum, min);
1013 124
                MCF_DYN_REASON(maximum, max);
1014 124
#undef MCF_DYN_REASON
1015 124
                flags = pp->flags & ~DOCS_FLAGS;
1016 124
                if (pp->func == tweak_timeout)
1017 11
                        flags |= TYPE_TIMEOUT;
1018 124
                if (flags) {
1019 69
                        q = "\n";
1020 69
                        VSB_cat(vsb, "\"flags\": [");
1021 69
                        VSB_indent(vsb, 2);
1022 69
#define MCF_DYN_FLAGS(f, s)                                     \
1023 552
                        if (flags & f) {                        \
1024 79
                                VSB_bcat(vsb, q, strlen(q));    \
1025 79
                                q = ",\n";                      \
1026 79
                                VSB_printf(vsb, #s);            \
1027 79
                        }
1028 69
                        MCF_DYN_FLAGS(TYPE_TIMEOUT, "timeout");
1029 69
                        MCF_DYN_FLAGS(DELAYED_EFFECT, "delayed");
1030 69
                        MCF_DYN_FLAGS(MUST_RESTART, "must_restart");
1031 69
                        MCF_DYN_FLAGS(MUST_RELOAD, "must_reload");
1032 69
                        MCF_DYN_FLAGS(EXPERIMENTAL, "experimental");
1033 69
                        MCF_DYN_FLAGS(WIZARD, "wizard");
1034 69
                        MCF_DYN_FLAGS(ONLY_ROOT, "only_root");
1035 69
                        MCF_DYN_FLAGS(OBJ_STICKY, "obj_sticky");
1036 69
#undef MCF_DYN_FLAGS
1037 69
                        VSB_indent(vsb, -2);
1038 69
                        VSB_cat(vsb, "\n],\n");
1039 69
                }
1040 124
                VSB_cat(vsb, "\"description\": \"");
1041 124
                VSB_quote(vsb, pp->descr, -1, VSB_QUOTE_JSON);
1042 124
                VSB_bcat(vsb, "\"\n", 2);
1043 124
                VSB_indent(vsb, -2);
1044 124
                VSB_printf(vsb, "}");
1045 124
        }
1046 1
        VSB_indent(vsb, -2);
1047 1
        VSB_cat(vsb, "\n}");
1048 1
        AZ(VSB_finish(vsb));
1049 1
        printf("%s\n", VSB_data(vsb));
1050 1
        VSB_destroy(&vsb);
1051 1
}