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 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 varnishd 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
        " Varnish build environment and options.";
120
121
/*--------------------------------------------------------------------*/
122
123
static struct parspec *
124 367896
mcf_findpar(const char *name)
125
{
126
        struct plist *pl;
127
128 367896
        AN(name);
129 34855672
        VTAILQ_FOREACH(pl, &phead, list)
130 34855640
                if (!strcmp(pl->spec->name, name))
131 367864
                        return (pl->spec);
132 32
        return (NULL);
133 367896
}
134
135
static void
136 1007616
mcf_addpar(struct parspec *ps)
137
{
138
        struct plist *pl, *pl2;
139
        int i;
140
141 1007616
        ALLOC_OBJ(pl, PLIST_MAGIC);
142 1007616
        AN(pl);
143 1007616
        pl->spec = ps;
144 48111616
        VTAILQ_FOREACH(pl2, &phead, list) {
145 47898624
                i = strcmp(pl2->spec->name, pl->spec->name);
146 47898624
                if (i == 0) {
147 0
                        fprintf(stderr, "Duplicate param: %s\n", ps->name);
148 0
                        exit(4);
149 47898624
                } else if (i > 0) {
150 794624
                        VTAILQ_INSERT_BEFORE(pl2, pl, list);
151 794624
                        return;
152
                }
153 47104000
        }
154 212992
        VTAILQ_INSERT_TAIL(&phead, pl, list);
155 1007616
}
156
157
/*--------------------------------------------------------------------
158
 * Wrap the text nicely.
159
 * Lines are allowed to contain two TABS and we render that as a table
160
 * taking the width of the first column into account.
161
 */
162
163
static void
164 20320
mcf_wrap_line(struct cli *cli, const char *b, const char *e, int tabs, int m0)
165
{
166 20320
        int n, hadtabs = 0;
167
        const char *w;
168
169 20320
        n = m0;
170 20320
        VCLI_Out(cli, "%*s", n, "");
171
172 299792
        while (b < e) {
173 289720
                if (!isspace(*b)) {
174 139408
                        VCLI_Out(cli, "%c", *b);
175 139408
                        b++;
176 139408
                        n++;
177 289720
                } else if (*b == '\t') {
178 3952
                        assert(tabs);
179 3952
                        assert(hadtabs < 2);
180 3952
                        do {
181 31216
                                VCLI_Out(cli, " ");
182 31216
                                n++;
183 31216
                        } while ((n % tabs) != (m0 + tab0) % tabs);
184 3952
                        b++;
185 3952
                        hadtabs++;
186 3952
                } else {
187 146360
                        assert (*b == ' ');
188 877288
                        for (w = b + 1; w < e; w++)
189 867216
                                if (isspace(*w))
190 136288
                                        break;
191 146360
                        if (n + (w - b) < wrap_at) {
192 136112
                                VCLI_Out(cli, "%.*s", (int)(w - b), b);
193 136112
                                n += (w - b);
194 136112
                                b = w;
195 136112
                        } else {
196 10248
                                assert(hadtabs == 0 || hadtabs == 2);
197 10248
                                VCLI_Out(cli, "\n");
198 20496
                                mcf_wrap_line(cli, b + 1, e, 0,
199 10248
                                    hadtabs ? m0 + tab0 + tabs : m0);
200 10248
                                return;
201
                        }
202
                }
203
        }
204 10072
        assert(b == e);
205 20320
}
206
207
static void
208 5032
mcf_wrap(struct cli *cli, const char *text)
209
{
210
        const char *p, *q, *r;
211 5032
        int tw = 0;
212
213 5032
        if (strchr(text, '\t') != NULL) {
214 2232
                for (p = text; *p != '\0'; ) {
215 2232
                        q = strstr(p, "\n\t");
216 2232
                        if (q == NULL)
217 256
                                break;
218 1976
                        q += 2;
219 1976
                        r = strchr(q, '\t');
220 1976
                        if (r == NULL) {
221 0
                                fprintf(stderr,
222 0
                                    "LINE with just one TAB: <%s>\n", text);
223 0
                                exit(4);
224
                        }
225 1976
                        if (r - q > tw)
226 704
                                tw = r - q;
227 1976
                        p = q;
228
                }
229 256
                tw += 2;
230 256
                if (tw < 20)
231 216
                        tw = 20;
232 256
        }
233
234 25784
        for (p = text; *p != '\0'; ) {
235 20752
                if (*p == '\n') {
236 10680
                        VCLI_Out(cli, "\n");
237 10680
                        p++;
238 10680
                        continue;
239
                }
240 10072
                q = strchr(p, '\n');
241 10072
                if (q == NULL)
242 5032
                        q = strchr(p, '\0');
243 10072
                mcf_wrap_line(cli, p, q, tw, margin1);
244 10072
                p = q;
245
        }
246 5032
}
247
248
/*--------------------------------------------------------------------*/
249
250
static void v_matchproto_(cli_func_t)
251 264
mcf_param_show(struct cli *cli, const char * const *av, void *priv)
252
{
253
        struct plist *pl;
254
        const struct parspec *pp, *pa;
255 264
        int n, lfmt = 0, chg = 0;
256
        struct vsb *vsb;
257 264
        const char *show = NULL;
258
259 264
        (void)priv;
260
261 480
        for (n = 2; av[n] != NULL; n++) {
262 224
                if (strcmp(av[n], "-l") == 0) {
263 24
                        lfmt = 1;
264 24
                        continue;
265
                }
266 200
                if (strcmp(av[n], "changed") == 0) {
267 8
                        chg = 1;
268 8
                        continue;
269
                }
270 192
                if (show != NULL) {
271 8
                        VCLI_SetResult(cli, CLIS_TOOMANY);
272 8
                        VCLI_Out(cli, "Too many parameters");
273 8
                        return;
274
                }
275 184
                show = av[n];
276 184
                lfmt = 1;
277 184
        }
278
279 256
        vsb = VSB_new_auto();
280 256
        AN(vsb);
281
282 256
        n = 0;
283 31744
        VTAILQ_FOREACH(pl, &phead, list) {
284 31488
                pp = pl->spec;
285 31488
                if (lfmt && show != NULL && strcmp(pp->name, show))
286 21480
                        continue;
287 10040
                if (pp->func == tweak_alias &&
288 352
                    (show == NULL || strcmp(pp->name, show)))
289 320
                        continue;
290 9688
                n++;
291
292 9688
                VSB_clear(vsb);
293 9688
                if (pp->func(vsb, pp, NULL))
294 0
                        VCLI_SetResult(cli, CLIS_PARAM);
295 9688
                AZ(VSB_finish(vsb));
296 9688
                if (chg && pp->def != NULL && !strcmp(pp->def, VSB_data(vsb)))
297 856
                        continue;
298
299 8832
                if (pp->flags & NOT_IMPLEMENTED) {
300 0
                        if (lfmt) {
301 0
                                VCLI_Out(cli, "%s\n", pp->name);
302 0
                                VCLI_Out(cli, "%-*sNot available", margin1, " ");
303 0
                        } else {
304 0
                                VCLI_Out(cli, "%-*s-", margin2, pp->name);
305
                        }
306 0
                } else {
307 8832
                        if (lfmt) {
308 3024
                                VCLI_Out(cli, "%s\n", pp->name);
309 3024
                                VCLI_Out(cli, "%-*sValue is: ", margin1, " ");
310 3024
                        } else {
311 5808
                                VCLI_Out(cli, "%-*s", margin2, pp->name);
312
                        }
313
314 8832
                        VCLI_Out(cli, "%s", VSB_data(vsb));
315 8832
                        if (pp->units != NULL && *pp->units != '\0')
316 7048
                                VCLI_Out(cli, " [%s]", pp->units);
317 8832
                        if (pp->def != NULL && !strcmp(pp->def, VSB_data(vsb)))
318 7896
                                VCLI_Out(cli, " (default)");
319
                }
320 8832
                VCLI_Out(cli, "\n");
321
322 8832
                if (lfmt && pp->func == tweak_alias) {
323 32
                        pa = TRUST_ME(pp->priv);
324 64
                        VCLI_Out(cli, "%-*sAlias of: %s\n",
325 32
                            margin1, " ", pa->name);
326 32
                }
327 8832
                if (lfmt && pp->flags & NOT_IMPLEMENTED) {
328 0
                        VCLI_Out(cli, "\n");
329 0
                        mcf_wrap(cli, NOT_IMPLEMENTED_TEXT);
330 0
                        VCLI_Out(cli, "\n\n");
331 8832
                } else if (lfmt) {
332 3024
                        if (pp->def != NULL && strcmp(pp->def, VSB_data(vsb)))
333 672
                                VCLI_Out(cli, "%-*sDefault is: %s\n",
334 336
                                    margin1, "", pp->def);
335 3024
                        if (pp->min != NULL)
336 4688
                                VCLI_Out(cli, "%-*sMinimum is: %s\n",
337 2344
                                    margin1, "", pp->min);
338 3024
                        if (pp->max != NULL)
339 1392
                                VCLI_Out(cli, "%-*sMaximum is: %s\n",
340 696
                                    margin1, "", pp->max);
341 3024
                        VCLI_Out(cli, "\n");
342 3024
                        mcf_wrap(cli, pp->descr);
343 3024
                        if (pp->func == tweak_timeout)
344 320
                                mcf_wrap(cli, TYPE_TIMEOUT_TEXT);
345 3024
                        if (pp->flags & OBJ_STICKY)
346 80
                                mcf_wrap(cli, OBJ_STICKY_TEXT);
347 3024
                        if (pp->flags & DELAYED_EFFECT)
348 384
                                mcf_wrap(cli, DELAYED_EFFECT_TEXT);
349 3024
                        if (pp->flags & EXPERIMENTAL)
350 720
                                mcf_wrap(cli, EXPERIMENTAL_TEXT);
351 3024
                        if (pp->flags & MUST_RELOAD)
352 56
                                mcf_wrap(cli, MUST_RELOAD_TEXT);
353 3024
                        if (pp->flags & MUST_RESTART)
354 192
                                mcf_wrap(cli, MUST_RESTART_TEXT);
355 3024
                        if (pp->flags & WIZARD)
356 144
                                mcf_wrap(cli, WIZARD_TEXT);
357 3024
                        if (pp->flags & PROTECTED)
358 8
                                mcf_wrap(cli, PROTECTED_TEXT);
359 3024
                        if (pp->flags & ONLY_ROOT)
360 0
                                mcf_wrap(cli, ONLY_ROOT_TEXT);
361 3024
                        if (pp->flags & BUILD_OPTIONS)
362 104
                                mcf_wrap(cli, BUILD_OPTIONS_TEXT);
363 3024
                        VCLI_Out(cli, "\n\n");
364 3024
                }
365 8832
        }
366 256
        if (show != NULL && n == 0) {
367 8
                VCLI_SetResult(cli, CLIS_PARAM);
368 8
                VCLI_Out(cli, "Unknown parameter \"%s\".", show);
369 8
        }
370 256
        VSB_destroy(&vsb);
371 264
}
372
373
static inline void
374 9904
mcf_json_key_valstr(struct cli *cli, const char *key, const char *val)
375
{
376 9904
        VCLI_Out(cli, "\"%s\": ", key);
377 9904
        VCLI_JSON_str(cli, val);
378 9904
        VCLI_Out(cli, ",\n");
379 9904
}
380
381
static void v_matchproto_(cli_func_t)
382 120
mcf_param_show_json(struct cli *cli, const char * const *av, void *priv)
383
{
384 120
        int n, comma = 0, chg = 0;
385
        struct plist *pl;
386
        const struct parspec *pp, *pa;
387
        struct vsb *vsb, *def;
388 120
        const char *show = NULL, *sep;
389
390 120
        (void)priv;
391
392 336
        for (int i = 2; av[i] != NULL; i++) {
393 232
                if (strcmp(av[i], "-l") == 0) {
394 8
                        VCLI_SetResult(cli, CLIS_PARAM);
395 8
                        VCLI_Out(cli, "-l not permitted with param.show -j");
396 8
                        return;
397
                }
398 224
                if (strcmp(av[i], "changed") == 0) {
399 8
                        chg = 1;
400 8
                        continue;
401
                }
402 216
                if (strcmp(av[i], "-j") == 0)
403 120
                        continue;
404 96
                if (show != NULL) {
405 8
                        VCLI_SetResult(cli, CLIS_TOOMANY);
406 8
                        VCLI_Out(cli, "Too many parameters");
407 8
                        return;
408
                }
409 88
                show = av[i];
410 88
        }
411
412 104
        vsb = VSB_new_auto();
413 104
        AN(vsb);
414 104
        def = VSB_new_auto();
415 104
        AN(def);
416
417 104
        n = 0;
418 104
        VCLI_JSON_begin(cli, 2, av);
419 104
        VCLI_Out(cli, ",\n");
420 12896
        VTAILQ_FOREACH(pl, &phead, list) {
421 12792
                pp = pl->spec;
422 12792
                if (show != NULL && strcmp(pp->name, show) != 0)
423 9768
                        continue;
424 3032
                if (pp->func == tweak_alias &&
425 104
                    (show == NULL || strcmp(pp->name, show)))
426 96
                        continue;
427 2928
                n++;
428
429 2928
                VSB_clear(vsb);
430 2928
                if (pp->func(vsb, pp, JSON_FMT))
431 0
                        VCLI_SetResult(cli, CLIS_PARAM);
432 2928
                AZ(VSB_finish(vsb));
433 2928
                VSB_clear(def);
434 2928
                if (pp->func(def, pp, NULL))
435 0
                        VCLI_SetResult(cli, CLIS_PARAM);
436 2928
                AZ(VSB_finish(def));
437 2928
                if (chg && pp->def != NULL && !strcmp(pp->def, VSB_data(def)))
438 856
                        continue;
439
440 2072
                VCLI_Out(cli, "%s", comma ? ",\n" : "");
441 2072
                comma++;
442 2072
                VCLI_Out(cli, "{\n");
443 2072
                VSB_indent(cli->sb, 2);
444 2072
                mcf_json_key_valstr(cli, "name", pp->name);
445 2072
                if (pp->func == tweak_alias) {
446 8
                        pa = TRUST_ME(pp->priv);
447 8
                        mcf_json_key_valstr(cli, "alias", pa->name);
448 8
                }
449 2072
                if (pp->flags & NOT_IMPLEMENTED) {
450 0
                        VCLI_Out(cli, "\"implemented\": false\n");
451 0
                        VSB_indent(cli->sb, -2);
452 0
                        VCLI_Out(cli, "}");
453 0
                        continue;
454
                }
455 2072
                VCLI_Out(cli, "\"implemented\": true,\n");
456 2072
                VCLI_Out(cli, "\"value\": %s,\n", VSB_data(vsb));
457 2072
                if (pp->units != NULL && *pp->units != '\0')
458 1616
                        mcf_json_key_valstr(cli, "units", pp->units);
459
460 2072
                if (pp->def != NULL)
461 2064
                        mcf_json_key_valstr(cli, "default", pp->def);
462 2072
                if (pp->min != NULL)
463 1576
                        mcf_json_key_valstr(cli, "minimum", pp->min);
464 2072
                if (pp->max != NULL)
465 496
                        mcf_json_key_valstr(cli, "maximum", pp->max);
466 2072
                mcf_json_key_valstr(cli, "description", pp->descr);
467
468 2072
                VCLI_Out(cli, "\"flags\": [");
469 2072
                VSB_indent(cli->sb, 2);
470 2072
                sep = "";
471
472
#define flag_out(flag, string) do {                                     \
473
                        if (pp->flags & flag) {                         \
474
                                VCLI_Out(cli, "%s\n", sep);             \
475
                                VCLI_Out(cli, "\"%s\"", #string);       \
476
                                sep = ",";                              \
477
                        }                                               \
478
                } while(0)
479
480 2072
                flag_out(OBJ_STICKY, obj_sticky);
481 2072
                flag_out(DELAYED_EFFECT, delayed_effect);
482 2072
                flag_out(EXPERIMENTAL, experimental);
483 2072
                flag_out(MUST_RELOAD, must_reload);
484 2072
                flag_out(MUST_RESTART, must_restart);
485 2072
                flag_out(WIZARD, wizard);
486 2072
                flag_out(PROTECTED, protected);
487 2072
                flag_out(ONLY_ROOT, only_root);
488 2072
                flag_out(BUILD_OPTIONS, build_options);
489
490
#undef flag_out
491
492 2072
                if (pp->flags)
493 1016
                        VCLI_Out(cli, "\n");
494 2072
                VSB_indent(cli->sb, -2);
495 2072
                VCLI_Out(cli, "]\n");
496 2072
                VSB_indent(cli->sb, -2);
497 2072
                VCLI_Out(cli, "}");
498 2072
        }
499 104
        VCLI_JSON_end(cli);
500 104
        if (show != NULL && n == 0) {
501 8
                VSB_clear(cli->sb);
502 8
                VCLI_SetResult(cli, CLIS_PARAM);
503 8
                VCLI_Out(cli, "Unknown parameter \"%s\".", show);
504 8
        }
505 104
        VSB_destroy(&vsb);
506 104
        VSB_destroy(&def);
507 120
}
508
509
/*--------------------------------------------------------------------
510
 * Mark parameters as protected
511
 */
512
513
void
514 8
MCF_ParamProtect(struct cli *cli, const char *args)
515
{
516
        char **av;
517
        struct parspec *pp;
518
        int i;
519
520 8
        av = VAV_Parse(args, NULL, ARGV_COMMA);
521 8
        if (av[0] != NULL) {
522 0
                VCLI_Out(cli, "Parse error: %s", av[0]);
523 0
                VCLI_SetResult(cli, CLIS_PARAM);
524 0
                VAV_Free(av);
525 0
                return;
526
        }
527 16
        for (i = 1; av[i] != NULL; i++) {
528 8
                pp = mcf_findpar(av[i]);
529 8
                if (pp == NULL) {
530 0
                        VCLI_Out(cli, "Unknown parameter %s", av[i]);
531 0
                        VCLI_SetResult(cli, CLIS_PARAM);
532 0
                        VAV_Free(av);
533 0
                        return;
534
                }
535 8
                pp->flags |= PROTECTED;
536 8
        }
537 8
        VAV_Free(av);
538 8
}
539
540
/*--------------------------------------------------------------------*/
541
542
void
543 73296
MCF_ParamSet(struct cli *cli, const char *param, const char *val)
544
{
545
        const struct parspec *pp;
546
547 73296
        pp = mcf_findpar(param);
548 73296
        if (pp == NULL) {
549 32
                VCLI_SetResult(cli, CLIS_PARAM);
550 32
                VCLI_Out(cli, "Unknown parameter \"%s\".", param);
551 32
                return;
552
        }
553 73264
        if (pp->flags & NOT_IMPLEMENTED) {
554 0
                VCLI_SetResult(cli, CLIS_CANT);
555 0
                VCLI_Out(cli,
556
                    "parameter \"%s\" is not available on this platform.",
557 0
                    param
558
                );
559 0
                return;
560
        }
561 73264
        if (pp->flags & PROTECTED) {
562 8
                VCLI_SetResult(cli, CLIS_AUTH);
563 8
                VCLI_Out(cli, "parameter \"%s\" is protected.", param);
564 8
                return;
565
        }
566 73256
        if (!val)
567 280
                val = pp->def;
568 73256
        if (pp->func(cli->sb, pp, val))
569 232
                VCLI_SetResult(cli, CLIS_PARAM);
570
571 73256
        if (cli->result == CLIS_OK && heritage.param != NULL)
572 2696
                *heritage.param = mgt_param;
573
574 73256
        if (cli->result != CLIS_OK) {
575 464
                VCLI_Out(cli, "\n(attempting to set param '%s' to '%s')",
576 232
                    pp->name, val);
577 73256
        } else if (MCH_Running() && pp->flags & MUST_RESTART) {
578 0
                VCLI_Out(cli,
579
                    "\nChange will take effect when child is restarted");
580 73024
        } else if (pp->flags & MUST_RELOAD) {
581 16
                VCLI_Out(cli,
582
                    "\nChange will take effect when VCL script is reloaded");
583 16
        }
584 73296
}
585
586
587
/*--------------------------------------------------------------------*/
588
589
static void v_matchproto_(cli_func_t)
590 4200
mcf_param_set(struct cli *cli, const char * const *av, void *priv)
591
{
592
593 4200
        (void)priv;
594 4200
        MCF_ParamSet(cli, av[2], av[3]);
595 4200
}
596
597
static void v_matchproto_(cli_func_t)
598 48
mcf_param_set_json(struct cli *cli, const char * const *av, void *priv)
599
{
600 48
        const char *const avs[] = { av[0], av[1], av[2], av[3], NULL };
601
602 48
        MCF_ParamSet(cli, av[3], av[4]);
603 48
        if (cli->result == CLIS_OK)
604 48
                mcf_param_show_json(cli, avs, priv);
605 48
}
606
607
/*--------------------------------------------------------------------*/
608
609
static void v_matchproto_(cli_func_t)
610 272
mcf_param_reset(struct cli *cli, const char * const *av, void *priv)
611
{
612
613 272
        (void)priv;
614 272
        MCF_ParamSet(cli, av[2], NULL);
615 272
}
616
617
/*--------------------------------------------------------------------
618
 * Initialize parameters and sort by name.
619
 */
620
621
static struct parspec mgt_parspec[] = {
622
#define PARAM_ALL
623
#define PARAM_PRE {
624
#define PARAM(typ, fld, nm, ...) #nm, __VA_ARGS__
625
#define PARAM_POST },
626
#include "tbl/params.h"
627
        { NULL, NULL, NULL }
628
};
629
630
static void
631 8192
mcf_init_params(void)
632
{
633
        struct parspec *pp;
634
        const char *s;
635
636 1015808
        for (pp = mgt_parspec; pp->name != NULL; pp++) {
637 1007616
                AN(pp->func);
638 1007616
                s = strchr(pp->descr, '\0');
639 1007616
                if (isspace(s[-1])) {
640 0
                        fprintf(stderr,
641 0
                            "Param->descr has trailing space: %s\n", pp->name);
642 0
                        exit(4);
643
                }
644 1007616
                mcf_addpar(pp);
645 1007616
                margin2 = vmax_t(int, margin2, strlen(pp->name) + 1);
646 1007616
        }
647 8192
}
648
649
/*--------------------------------------------------------------------
650
 * Wash a min/max/default value
651
 */
652
653
static void
654 696000
mcf_dyn_vsb(enum mcf_which_e which, struct parspec *pp, struct vsb *vsb)
655
{
656
657 696000
        switch (which) {
658
        case MCF_DEFAULT:
659 221184
                REPLACE(pp->dyn_def, VSB_data(vsb));
660 221184
                pp->def = pp->dyn_def;
661 221184
                break;
662
        case MCF_MINIMUM:
663 294608
                REPLACE(pp->dyn_min, VSB_data(vsb));
664 294608
                pp->min = pp->dyn_min;
665 294608
                break;
666
        case MCF_MAXIMUM:
667 180208
                REPLACE(pp->dyn_max, VSB_data(vsb));
668 180208
                pp->max = pp->dyn_max;
669 180208
                break;
670
        default:
671 0
                WRONG("bad 'which'");
672 0
        }
673 696000
}
674
675
static void
676 2015232
mcf_wash_param(struct cli *cli, struct parspec *pp, enum mcf_which_e which,
677
    const char *name, struct vsb *vsb)
678
{
679
        const char *val;
680
        int err;
681
682 2015232
        switch (which) {
683 1007616
        case MCF_DEFAULT: val = pp->def; break;
684 770048
        case MCF_MINIMUM: val = pp->min; break;
685 237568
        case MCF_MAXIMUM: val = pp->max; break;
686
        default:
687 0
                WRONG("bad 'which'");
688 0
        }
689 2015232
        AN(val);
690
691 2015232
        if (pp->func == tweak_alias) {
692 32768
                assert(which == MCF_DEFAULT);
693 32768
                pp->priv = mcf_findpar(pp->def);
694 32768
                pp->def = NULL;
695 32768
                return;
696
        }
697
698 1982464
        VSB_clear(vsb);
699 3964928
        VSB_printf(vsb, "FAILED to set %s for param %s: %s\n",
700 1982464
            name, pp->name, val);
701 1982464
        err = pp->func(vsb, pp, val);
702 1982464
        AZ(VSB_finish(vsb));
703 1982464
        if (err) {
704 0
                VCLI_Out(cli, "%s\n", VSB_data(vsb));
705 0
                VCLI_SetResult(cli, CLIS_CANT);
706 0
                return;
707
        }
708 1982464
        VSB_clear(vsb);
709 1982464
        err = pp->func(vsb, pp, NULL);
710 1982464
        AZ(err);
711 1982464
        AZ(VSB_finish(vsb));
712 1982464
        if (strcmp(val, VSB_data(vsb)))
713 434176
                mcf_dyn_vsb(which, pp, vsb);
714 2015232
}
715
716
/*--------------------------------------------------------------------*/
717
718
static struct cli_proto cli_params[] = {
719
        { CLICMD_PARAM_SHOW,    "", mcf_param_show, mcf_param_show_json },
720
        { CLICMD_PARAM_SET,     "", mcf_param_set, mcf_param_set_json },
721
        { CLICMD_PARAM_RESET,   "", mcf_param_reset, mcf_param_set_json },
722
        { NULL }
723
};
724
725
/*--------------------------------------------------------------------
726
 * Configure the parameters
727
 */
728
729
void
730 8192
MCF_InitParams(struct cli *cli)
731
{
732
        struct plist *pl;
733
        struct parspec *pp;
734
        struct vsb *vsb;
735
        ssize_t def, low;
736
737 8192
        mcf_init_params();
738 8192
        MCF_TcpParams();
739
740 8192
        def = 80 * 1024;
741
742
        if (sizeof(void *) < 8) {               /*lint !e506 !e774  */
743
                /*
744
                 * Adjust default parameters for 32 bit systems to conserve
745
                 * VM space.
746
                 *
747
                 * Reflect changes in doc/sphinx/reference/varnishd.rst !
748
                 */
749
                MCF_ParamConf(MCF_DEFAULT, "workspace_client", "24k");
750
                MCF_ParamConf(MCF_DEFAULT, "workspace_backend", "20k");
751
                MCF_ParamConf(MCF_DEFAULT, "http_resp_size", "8k");
752
                MCF_ParamConf(MCF_DEFAULT, "http_req_size", "12k");
753
                MCF_ParamConf(MCF_DEFAULT, "gzip_buffer", "4k");
754
                MCF_ParamConf(MCF_DEFAULT, "vsl_buffer", "4k");
755
                MCF_ParamConf(MCF_MAXIMUM, "vsl_space", "1G");
756
                def = 64 * 1024;
757
        }
758
759 8192
        low = sysconf(_SC_THREAD_STACK_MIN);
760 8192
        MCF_ParamConf(MCF_MINIMUM, "thread_pool_stack", "%jdb", (intmax_t)low);
761
762
#if defined(ENABLE_SANITIZER) || defined(ENABLE_COVERAGE)
763 8192
        def = 192 * 1024;
764
#endif
765
766 8192
        if (def < low)
767 0
                def = low;
768 8192
        MCF_ParamConf(MCF_DEFAULT, "thread_pool_stack", "%jdb", (intmax_t)def);
769
770
#if !defined(MAX_THREAD_POOLS)
771
#  define MAX_THREAD_POOLS 32
772
#endif
773
774 8192
        MCF_ParamConf(MCF_MAXIMUM, "thread_pools", "%d", MAX_THREAD_POOLS);
775
776
#if !defined(HAVE_ACCEPT_FILTERS) || defined(__linux)
777
        MCF_ParamConf(MCF_DEFAULT, "accept_filter", "off");
778
#endif
779
780 8192
        VCLS_AddFunc(mgt_cls, MCF_AUTH, cli_params);
781
782 8192
        vsb = VSB_new_auto();
783 8192
        AN(vsb);
784
785 1015808
        VTAILQ_FOREACH(pl, &phead, list) {
786 1007616
                pp = pl->spec;
787
788 1007616
                if (pp->flags & NOT_IMPLEMENTED)
789 0
                        continue;
790 1007616
                if (pp->min != NULL)
791 770048
                        mcf_wash_param(cli, pp, MCF_MINIMUM, "minimum", vsb);
792 1007616
                if (pp->max != NULL)
793 237568
                        mcf_wash_param(cli, pp, MCF_MAXIMUM, "maximum", vsb);
794 1007616
                AN(pp->def);
795 1007616
                mcf_wash_param(cli, pp, MCF_DEFAULT, "default", vsb);
796 1007616
        }
797 8192
        VSB_destroy(&vsb);
798
799 8192
        AN(mgt_cc_cmd);
800 8192
        REPLACE(mgt_cc_cmd_def, mgt_cc_cmd);
801 8192
}
802
803
/*--------------------------------------------------------------------*/
804
805
void
806 261824
MCF_ParamConf(enum mcf_which_e which, const char * const param,
807
    const char *fmt, ...)
808
{
809
        struct parspec *pp;
810
        struct vsb *vsb;
811
        va_list ap;
812
813 261824
        pp = mcf_findpar(param);
814 261824
        AN(pp);
815 261824
        vsb = VSB_new_auto();
816 261824
        AN(vsb);
817 261824
        va_start(ap, fmt);
818 261824
        VSB_vprintf(vsb, fmt, ap);
819 261824
        va_end(ap);
820 261824
        AZ(VSB_finish(vsb));
821 261824
        mcf_dyn_vsb(which, pp, vsb);
822 261824
        VSB_destroy(&vsb);
823 261824
}
824
825
/*--------------------------------------------------------------------*/
826
827
void
828 16
MCF_DumpRstParam(void)
829
{
830
        struct plist *pl;
831
        const struct parspec *pp;
832
        const char *p, *q, *t1, *t2;
833
        unsigned flags;
834
        size_t z;
835
836 16
        printf("\n.. The following is the autogenerated "
837
            "output from varnishd -x parameter\n\n");
838 1984
        VTAILQ_FOREACH(pl, &phead, list) {
839 1968
                pp = pl->spec;
840 1968
                if (!strcmp("deprecated_dummy", pp->name))
841 16
                    continue;
842 1952
                printf(".. _ref_param_%s:\n\n", pp->name);
843 1952
                printf("%s\n", pp->name);
844 31216
                for (z = 0; z < strlen(pp->name); z++)
845 29264
                        printf("~");
846 1952
                printf("\n");
847
848 1952
                if (pp->flags && pp->flags & PLATFORM_DEPENDENT)
849 80
                        printf("\n%s\n\n", PLATFORM_DEPENDENT_TEXT);
850
851 1952
                if (pp->flags && pp->flags & BUILD_OPTIONS)
852 64
                        printf("\n%s\n\n", BUILD_OPTIONS_TEXT);
853
854 1952
                if (pp->units != NULL && *pp->units != '\0')
855 1536
                        printf("\t* Units: %s\n", pp->units);
856
#define MCF_DYN_REASON(lbl, nm)                                 \
857
                if (pp->dyn_ ## nm ## _reason != NULL)          \
858
                        printf("\t* " #lbl ": %s\n",            \
859
                            pp->dyn_ ## nm ## _reason);         \
860
                else if (pp->nm != NULL)                        \
861
                        printf("\t* " #lbl ": %s\n", pp->nm);
862 1952
                MCF_DYN_REASON(Default, def);
863 1952
                MCF_DYN_REASON(Minimum, min);
864 1952
                MCF_DYN_REASON(Maximum, max);
865
#undef MCF_DYN_REASON
866 1952
                flags = pp->flags & ~DOCS_FLAGS;
867 1952
                if (pp->func == tweak_timeout)
868 176
                        flags |= TYPE_TIMEOUT;
869 1952
                if (flags) {
870 1040
                        printf("\t* Flags: ");
871 1040
                        q = "";
872
873 1040
                        if (flags & TYPE_TIMEOUT) {
874 176
                                printf("%stimeout", q);
875 176
                                q = ", ";
876 176
                        }
877 1040
                        if (flags & DELAYED_EFFECT) {
878 256
                                printf("%sdelayed", q);
879 256
                                q = ", ";
880 256
                        }
881 1040
                        if (flags & MUST_RESTART) {
882 128
                                printf("%smust_restart", q);
883 128
                                q = ", ";
884 128
                        }
885 1040
                        if (flags & MUST_RELOAD) {
886 32
                                printf("%smust_reload", q);
887 32
                                q = ", ";
888 32
                        }
889 1040
                        if (flags & EXPERIMENTAL) {
890 480
                                printf("%sexperimental", q);
891 480
                                q = ", ";
892 480
                        }
893 1040
                        if (flags & WIZARD) {
894 96
                                printf("%swizard", q);
895 96
                                q = ", ";
896 96
                        }
897 1040
                        if (flags & ONLY_ROOT) {
898 0
                                printf("%sonly_root", q);
899 0
                                q = ", ";
900 0
                        }
901 1040
                        if (flags & OBJ_STICKY) {
902 48
                                printf("%sobj_sticky", q);
903 48
                                q = ", ";
904 48
                        }
905 1040
                        printf("\n");
906 1040
                }
907 1952
                printf("\n");
908 1952
                p = pp->descr;
909 7760
                while (*p != '\0') {
910 5808
                        q = strchr(p, '\n');
911 5808
                        if (q == NULL)
912 1952
                                q = strchr(p, '\0');
913 5808
                        t1 = strchr(p, '\t');
914 5808
                        if (t1 != NULL && t1 < q) {
915 880
                                t2 = strchr(t1 + 1, '\t');
916 880
                                AN(t2);
917 880
                                printf("\n\t*");
918 880
                                (void)fwrite(t1 + 1, (t2 - 1) - t1, 1, stdout);
919 880
                                printf("*\n\t\t");
920 880
                                p = t2 + 1;
921 880
                        }
922 5808
                        (void)fwrite(p, q - p, 1, stdout);
923 5808
                        p = q;
924 5808
                        if (*p == '\n') {
925 3856
                                printf("\n");
926 3856
                                p++;
927 3856
                        }
928 5808
                        continue;
929
                }
930 1952
                printf("\n\n");
931 1952
        }
932 16
}