blob: 199d25fcf99d8de90359ad009731bca278b8c65c [file] [log] [blame]
William Lallemand74c24fb2016-11-21 17:18:36 +01001/*
2 * Functions dedicated to statistics output and the stats socket
3 *
4 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
5 * Copyright 2007-2009 Krzysztof Piotr Oledzki <ole@ans.pl>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 */
13
14#include <ctype.h>
15#include <errno.h>
16#include <fcntl.h>
17#include <stdio.h>
18#include <stdlib.h>
19#include <string.h>
20#include <pwd.h>
21#include <grp.h>
22
23#include <sys/socket.h>
24#include <sys/stat.h>
25#include <sys/types.h>
26
Olivier Houchardf886e342017-04-05 22:24:59 +020027#include <net/if.h>
28
William Lallemand74c24fb2016-11-21 17:18:36 +010029#include <common/cfgparse.h>
30#include <common/compat.h>
31#include <common/config.h>
32#include <common/debug.h>
33#include <common/memory.h>
34#include <common/mini-clist.h>
35#include <common/standard.h>
36#include <common/ticks.h>
37#include <common/time.h>
38#include <common/uri_auth.h>
39#include <common/version.h>
40#include <common/base64.h>
41
42#include <types/applet.h>
William Lallemand9ed62032016-11-21 17:49:11 +010043#include <types/cli.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010044#include <types/global.h>
45#include <types/dns.h>
William Lallemand9ed62032016-11-21 17:49:11 +010046#include <types/stats.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010047
48#include <proto/backend.h>
49#include <proto/channel.h>
50#include <proto/checks.h>
51#include <proto/compression.h>
William Lallemand9ed62032016-11-21 17:49:11 +010052#include <proto/stats.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010053#include <proto/fd.h>
54#include <proto/freq_ctr.h>
55#include <proto/frontend.h>
56#include <proto/log.h>
57#include <proto/pattern.h>
58#include <proto/pipe.h>
William Lallemandce83b4a2018-10-26 14:47:30 +020059#include <proto/protocol.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010060#include <proto/listener.h>
61#include <proto/map.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010062#include <proto/proxy.h>
63#include <proto/sample.h>
64#include <proto/session.h>
65#include <proto/stream.h>
66#include <proto/server.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010067#include <proto/stream_interface.h>
68#include <proto/task.h>
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +020069#include <proto/proto_udp.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010070
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020071#define PAYLOAD_PATTERN "<<"
72
William Lallemand74c24fb2016-11-21 17:18:36 +010073static struct applet cli_applet;
74
75static const char stats_sock_usage_msg[] =
76 "Unknown command. Please enter one of the following commands only :\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010077 " help : this message\n"
78 " prompt : toggle interactive mode with prompt\n"
79 " quit : disconnect\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010080 "";
81
82static const char stats_permission_denied_msg[] =
83 "Permission denied\n"
84 "";
85
86
Christopher Faulet1bc04c72017-10-29 20:14:08 +010087static THREAD_LOCAL char *dynamic_usage_msg = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +010088
89/* List head of cli keywords */
90static struct cli_kw_list cli_keywords = {
91 .list = LIST_HEAD_INIT(cli_keywords.list)
92};
93
94extern const char *stat_status_codes[];
95
William Lallemand14721be2018-10-26 14:47:37 +020096extern int master;
97
William Lallemand8a022572018-10-26 14:47:35 +020098static struct proxy *mworker_proxy; /* CLI proxy of the master */
99
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200100static char *cli_gen_usage_msg(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100101{
102 struct cli_kw_list *kw_list;
103 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +0200104 struct buffer *tmp = get_trash_chunk();
105 struct buffer out;
William Lallemand74c24fb2016-11-21 17:18:36 +0100106
107 free(dynamic_usage_msg);
108 dynamic_usage_msg = NULL;
109
110 if (LIST_ISEMPTY(&cli_keywords.list))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200111 goto end;
William Lallemand74c24fb2016-11-21 17:18:36 +0100112
113 chunk_reset(tmp);
114 chunk_strcat(tmp, stats_sock_usage_msg);
115 list_for_each_entry(kw_list, &cli_keywords.list, list) {
116 kw = &kw_list->kw[0];
William Lallemand0154edc2018-05-15 11:50:04 +0200117 while (kw->str_kw[0]) {
William Lallemand14721be2018-10-26 14:47:37 +0200118
119 /* in a worker or normal process, don't display master only commands */
120 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
121 goto next_kw;
122
123 /* in master don't displays if we don't have the master bits */
124 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
125 goto next_kw;
126
William Lallemand0154edc2018-05-15 11:50:04 +0200127 if (kw->usage)
128 chunk_appendf(tmp, " %s\n", kw->usage);
William Lallemand14721be2018-10-26 14:47:37 +0200129
130next_kw:
131
William Lallemand74c24fb2016-11-21 17:18:36 +0100132 kw++;
133 }
134 }
135 chunk_init(&out, NULL, 0);
136 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200137 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200138
139end:
140 if (dynamic_usage_msg) {
141 appctx->ctx.cli.severity = LOG_INFO;
142 appctx->ctx.cli.msg = dynamic_usage_msg;
143 }
144 else {
145 appctx->ctx.cli.severity = LOG_INFO;
146 appctx->ctx.cli.msg = stats_sock_usage_msg;
147 }
148 appctx->st0 = CLI_ST_PRINT;
149
William Lallemand74c24fb2016-11-21 17:18:36 +0100150 return dynamic_usage_msg;
151}
152
153struct cli_kw* cli_find_kw(char **args)
154{
155 struct cli_kw_list *kw_list;
156 struct cli_kw *kw;/* current cli_kw */
157 char **tmp_args;
158 const char **tmp_str_kw;
159 int found = 0;
160
161 if (LIST_ISEMPTY(&cli_keywords.list))
162 return NULL;
163
164 list_for_each_entry(kw_list, &cli_keywords.list, list) {
165 kw = &kw_list->kw[0];
166 while (*kw->str_kw) {
167 tmp_args = args;
168 tmp_str_kw = kw->str_kw;
169 while (*tmp_str_kw) {
170 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
171 found = 1;
172 } else {
173 found = 0;
174 break;
175 }
176 tmp_args++;
177 tmp_str_kw++;
178 }
179 if (found)
180 return (kw);
181 kw++;
182 }
183 }
184 return NULL;
185}
186
187void cli_register_kw(struct cli_kw_list *kw_list)
188{
189 LIST_ADDQ(&cli_keywords.list, &kw_list->list);
190}
191
192
193/* allocate a new stats frontend named <name>, and return it
194 * (or NULL in case of lack of memory).
195 */
196static struct proxy *alloc_stats_fe(const char *name, const char *file, int line)
197{
198 struct proxy *fe;
199
200 fe = calloc(1, sizeof(*fe));
201 if (!fe)
202 return NULL;
203
204 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100205 fe->next = proxies_list;
206 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100207 fe->last_change = now.tv_sec;
208 fe->id = strdup("GLOBAL");
209 fe->cap = PR_CAP_FE;
210 fe->maxconn = 10; /* default to 10 concurrent connections */
211 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
212 fe->conf.file = strdup(file);
213 fe->conf.line = line;
214 fe->accept = frontend_accept;
215 fe->default_target = &cli_applet.obj_type;
216
217 /* the stats frontend is the only one able to assign ID #0 */
218 fe->conf.id.key = fe->uuid = 0;
219 eb32_insert(&used_proxy_id, &fe->conf.id);
220 return fe;
221}
222
223/* This function parses a "stats" statement in the "global" section. It returns
224 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
225 * error message into the <err> buffer which will be preallocated. The trailing
226 * '\n' must not be written. The function must be called with <args> pointing to
227 * the first word after "stats".
228 */
229static int stats_parse_global(char **args, int section_type, struct proxy *curpx,
230 struct proxy *defpx, const char *file, int line,
231 char **err)
232{
233 struct bind_conf *bind_conf;
234 struct listener *l;
235
236 if (!strcmp(args[1], "socket")) {
237 int cur_arg;
238
239 if (*args[2] == 0) {
240 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
241 return -1;
242 }
243
244 if (!global.stats_fe) {
245 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
246 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
247 return -1;
248 }
249 }
250
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100251 bind_conf = bind_conf_alloc(global.stats_fe, file, line, args[2], xprt_get(XPRT_RAW));
William Lallemand07a62f72017-05-24 00:57:40 +0200252 bind_conf->level &= ~ACCESS_LVL_MASK;
253 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100254
255 if (!str2listener(args[2], global.stats_fe, bind_conf, file, line, err)) {
256 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
257 file, line, args[0], args[1], err && *err ? *err : "error");
258 return -1;
259 }
260
261 cur_arg = 3;
262 while (*args[cur_arg]) {
263 static int bind_dumped;
264 struct bind_kw *kw;
265
266 kw = bind_find_kw(args[cur_arg]);
267 if (kw) {
268 if (!kw->parse) {
269 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
270 args[0], args[1], args[cur_arg]);
271 return -1;
272 }
273
274 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, err) != 0) {
275 if (err && *err)
276 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
277 else
278 memprintf(err, "'%s %s' : error encountered while processing '%s'",
279 args[0], args[1], args[cur_arg]);
280 return -1;
281 }
282
283 cur_arg += 1 + kw->skip;
284 continue;
285 }
286
287 if (!bind_dumped) {
288 bind_dump_kws(err);
289 indent_msg(err, 4);
290 bind_dumped = 1;
291 }
292
293 memprintf(err, "'%s %s' : unknown keyword '%s'.%s%s",
294 args[0], args[1], args[cur_arg],
295 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
296 return -1;
297 }
298
299 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
300 l->maxconn = global.stats_fe->maxconn;
301 l->backlog = global.stats_fe->backlog;
302 l->accept = session_accept_fd;
William Lallemand74c24fb2016-11-21 17:18:36 +0100303 l->default_target = global.stats_fe->default_target;
304 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
305 l->nice = -64; /* we want to boost priority for local stats */
306 global.maxsock += l->maxconn;
307 }
308 }
309 else if (!strcmp(args[1], "timeout")) {
310 unsigned timeout;
311 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
312
313 if (res) {
314 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
315 return -1;
316 }
317
318 if (!timeout) {
319 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
320 return -1;
321 }
322 if (!global.stats_fe) {
323 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
324 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
325 return -1;
326 }
327 }
328 global.stats_fe->timeout.client = MS_TO_TICKS(timeout);
329 }
330 else if (!strcmp(args[1], "maxconn")) {
331 int maxconn = atol(args[2]);
332
333 if (maxconn <= 0) {
334 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
335 return -1;
336 }
337
338 if (!global.stats_fe) {
339 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
340 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
341 return -1;
342 }
343 }
344 global.stats_fe->maxconn = maxconn;
345 }
346 else if (!strcmp(args[1], "bind-process")) { /* enable the socket only on some processes */
347 int cur_arg = 2;
348 unsigned long set = 0;
349
350 if (!global.stats_fe) {
351 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
352 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
353 return -1;
354 }
355 }
356
357 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100358 if (strcmp(args[cur_arg], "all") == 0) {
359 set = 0;
360 break;
361 }
Christopher Faulet26028f62017-11-22 15:01:51 +0100362 if (parse_process_number(args[cur_arg], &set, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100363 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100364 return -1;
365 }
366 cur_arg++;
367 }
368 global.stats_fe->bind_proc = set;
369 }
370 else {
371 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
372 return -1;
373 }
374 return 0;
375}
376
Willy Tarreaude57a572016-11-23 17:01:39 +0100377/* Verifies that the CLI at least has a level at least as high as <level>
378 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
379 * failure, an error message is prepared and the appctx's state is adjusted
380 * to print it so that a return 1 is enough to abort any processing.
381 */
382int cli_has_level(struct appctx *appctx, int level)
383{
384 struct stream_interface *si = appctx->owner;
385 struct stream *s = si_strm(si);
386
William Lallemand07a62f72017-05-24 00:57:40 +0200387 if ((strm_li(s)->bind_conf->level & ACCESS_LVL_MASK) < level) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200388 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreaude57a572016-11-23 17:01:39 +0100389 appctx->ctx.cli.msg = stats_permission_denied_msg;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100390 appctx->st0 = CLI_ST_PRINT;
Willy Tarreaude57a572016-11-23 17:01:39 +0100391 return 0;
392 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100393 return 1;
394}
395
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200396/* Returns severity_output for the current session if set, or default for the socket */
397static int cli_get_severity_output(struct appctx *appctx)
398{
399 if (appctx->cli_severity_output)
400 return appctx->cli_severity_output;
401 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
402}
William Lallemand74c24fb2016-11-21 17:18:36 +0100403
Willy Tarreau41908562016-11-24 16:23:38 +0100404/* Processes the CLI interpreter on the stats socket. This function is called
405 * from the CLI's IO handler running in an appctx context. The function returns 1
406 * if the request was understood, otherwise zero. It is called with appctx->st0
407 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
408 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
409 * have its own I/O handler called again. Most of the time, parsers will only
410 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100411 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
412 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100413 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200414static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100415{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200416 char *args[MAX_STATS_ARGS + 1], *p, *end, *payload = NULL;
417 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100418 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100419
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200420 appctx->st2 = 0;
421 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
William Lallemand74c24fb2016-11-21 17:18:36 +0100422
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200423 p = appctx->chunk->area;
424 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100425
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200426 /*
427 * Get the payload start if there is one.
428 * For the sake of simplicity, the payload pattern is looked up
429 * everywhere from the start of the input but it can only be found
430 * at the end of the first line if APPCTX_CLI_ST1_PAYLOAD is set.
431 *
432 * The input string was zero terminated so it is safe to use
433 * the str*() functions throughout the parsing
434 */
435 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
436 payload = strstr(p, PAYLOAD_PATTERN);
437 end = payload;
438 /* skip the pattern */
439 payload += strlen(PAYLOAD_PATTERN);
440 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100441
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200442 /*
443 * Get pointers on words.
444 * One extra slot is reserved to store a pointer on a null byte.
445 */
446 while (i < MAX_STATS_ARGS && p < end) {
447 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100448
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200449 /* skip leading spaces/tabs */
450 p += strspn(p, " \t");
451 if (!*p)
452 break;
William Lallemand74c24fb2016-11-21 17:18:36 +0100453
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200454 args[i] = p;
455 p += strcspn(p, " \t");
456 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100457
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200458 /* unescape backslashes (\) */
459 for (j = 0, k = 0; args[i][k]; k++) {
460 if (args[i][k] == '\\') {
461 if (args[i][k + 1] == '\\')
462 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100463 else
464 continue;
465 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200466 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100467 j++;
468 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200469 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100470
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200471 i++;
472 }
473 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200474 p = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200475 for (; i < MAX_STATS_ARGS + 1; i++)
476 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100477
478 kw = cli_find_kw(args);
Willy Tarreaueaffde32016-12-16 17:59:25 +0100479 if (!kw)
Willy Tarreau41908562016-11-24 16:23:38 +0100480 return 0;
481
William Lallemand14721be2018-10-26 14:47:37 +0200482 /* in a worker or normal process, don't display master only commands */
483 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
484 return 0;
485
486 /* in master don't displays if we don't have the master bits */
487 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
488 return 0;
489
Willy Tarreau41908562016-11-24 16:23:38 +0100490 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200491 appctx->io_release = kw->io_release;
492 /* kw->parse could set its own io_handler or ip_release handler */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200493 if ((!kw->parse || kw->parse(args, payload, appctx, kw->private) == 0) && appctx->io_handler) {
Willy Tarreau41908562016-11-24 16:23:38 +0100494 appctx->st0 = CLI_ST_CALLBACK;
William Lallemand74c24fb2016-11-21 17:18:36 +0100495 }
Willy Tarreau41908562016-11-24 16:23:38 +0100496 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100497}
498
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200499/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
500static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
501{
Willy Tarreau83061a82018-07-13 11:56:34 +0200502 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200503
504 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200505 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200506
507 tmp = get_trash_chunk();
508 chunk_reset(tmp);
509
510 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100511 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200512 chunk_printf(tmp, "[%d]: ", severity);
513 }
514 else {
515 switch (severity_output) {
516 case CLI_SEVERITY_NUMBER:
517 chunk_printf(tmp, "[%d]: ", severity);
518 break;
519 case CLI_SEVERITY_STRING:
520 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
521 break;
522 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100523 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200524 }
525 }
526 chunk_appendf(tmp, "%s", msg);
527
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200528 return ci_putblk(chn, tmp->area, strlen(tmp->area));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200529}
530
William Lallemand74c24fb2016-11-21 17:18:36 +0100531/* This I/O handler runs as an applet embedded in a stream interface. It is
532 * used to processes I/O from/to the stats unix socket. The system relies on a
533 * state machine handling requests and various responses. We read a request,
534 * then we process it and send the response, and we possibly display a prompt.
535 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100536 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100537 * or not.
538 */
539static void cli_io_handler(struct appctx *appctx)
540{
541 struct stream_interface *si = appctx->owner;
542 struct channel *req = si_oc(si);
543 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200544 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100545 int reql;
546 int len;
547
548 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
549 goto out;
550
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100551 /* Check if the input buffer is avalaible. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200552 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +0100553 /* buf.size==0 means we failed to get a buffer and were
554 * already subscribed to a wait list to get a buffer.
555 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100556 goto out;
557 }
558
William Lallemand74c24fb2016-11-21 17:18:36 +0100559 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100560 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100561 /* Stats output not initialized yet */
562 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200563 /* reset severity to default at init */
564 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100565 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100566 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100567 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100568 /* Let's close for real now. We just close the request
569 * side, the conditions below will complete if needed.
570 */
571 si_shutw(si);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200572 free_trash_chunk(appctx->chunk);
William Lallemand74c24fb2016-11-21 17:18:36 +0100573 break;
574 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100575 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200576 char *str;
577
578 /* use a trash chunk to store received data */
579 if (!appctx->chunk) {
580 appctx->chunk = alloc_trash_chunk();
581 if (!appctx->chunk) {
582 appctx->st0 = CLI_ST_END;
583 continue;
584 }
585 }
586
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200587 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200588
William Lallemand74c24fb2016-11-21 17:18:36 +0100589 /* ensure we have some output room left in the event we
590 * would want to return some info right after parsing.
591 */
592 if (buffer_almost_full(si_ib(si))) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100593 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100594 break;
595 }
596
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200597 /* '- 1' is to ensure a null byte can always be inserted at the end */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200598 reql = co_getline(si_oc(si), str,
599 appctx->chunk->size - appctx->chunk->data - 1);
William Lallemand74c24fb2016-11-21 17:18:36 +0100600 if (reql <= 0) { /* closed or EOL not found */
601 if (reql == 0)
602 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100603 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100604 continue;
605 }
606
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200607 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
608 /* seek for a possible unescaped semi-colon. If we find
609 * one, we replace it with an LF and skip only this part.
610 */
611 for (len = 0; len < reql; len++) {
612 if (str[len] == '\\') {
613 len++;
614 continue;
615 }
616 if (str[len] == ';') {
617 str[len] = '\n';
618 reql = len + 1;
619 break;
620 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100621 }
622 }
623
624 /* now it is time to check that we have a full line,
625 * remove the trailing \n and possibly \r, then cut the
626 * line.
627 */
628 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200629 if (str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100630 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100631 continue;
632 }
633
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200634 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100635 len--;
636
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200637 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200638 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200639
640 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200641 appctx->chunk->area[appctx->chunk->data] = '\n';
642 appctx->chunk->area[appctx->chunk->data + 1] = 0;
643 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200644 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100645
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100646 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200647
648 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
649 /* empty line */
650 if (!len) {
651 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200652 appctx->chunk->data -= 2;
653 appctx->chunk->area[appctx->chunk->data] = 0;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200654
655 if (!cli_parse_request(appctx))
656 cli_gen_usage_msg(appctx);
657
658 chunk_reset(appctx->chunk);
659 /* NB: cli_sock_parse_request() may have put
660 * another CLI_ST_O_* into appctx->st0.
661 */
662
663 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +0100664 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100665 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200666 else {
667 /*
668 * Look for the "payload start" pattern at the end of a line
669 * Its location is not remembered here, this is just to switch
670 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +0100671 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200672 if (!strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200673 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200674 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200675 /* no payload, the command is complete: parse the request */
676 if (!cli_parse_request(appctx))
677 cli_gen_usage_msg(appctx);
678
679 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200680 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100681 }
682
683 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200684 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100685 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
686 }
687 else { /* output functions */
688 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100689 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100690 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100691 case CLI_ST_PRINT:
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200692 if (cli_output_msg(res, appctx->ctx.cli.msg, appctx->ctx.cli.severity,
693 cli_get_severity_output(appctx)) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100694 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100695 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100696 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100697 break;
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200698 case CLI_ST_PRINT_FREE: {
699 const char *msg = appctx->ctx.cli.err;
700
701 if (!msg)
702 msg = "Out of memory.\n";
703
704 if (cli_output_msg(res, msg, LOG_ERR, cli_get_severity_output(appctx)) != -1) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100705 free(appctx->ctx.cli.err);
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100706 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100707 }
708 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100709 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100710 break;
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200711 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100712 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100713 if (appctx->io_handler)
714 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100715 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100716 if (appctx->io_release) {
717 appctx->io_release(appctx);
718 appctx->io_release = NULL;
719 }
720 }
721 break;
722 default: /* abnormal state */
723 si->flags |= SI_FL_ERR;
724 break;
725 }
726
727 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100728 if (appctx->st0 == CLI_ST_PROMPT) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200729 const char *prompt = "";
730
731 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
732 /*
733 * when entering a payload with interactive mode, change the prompt
734 * to emphasize that more data can still be sent
735 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200736 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200737 prompt = "+ ";
738 else
739 prompt = "\n> ";
740 }
741 else {
742 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD))
743 prompt = "\n";
744 }
745
746 if (ci_putstr(si_ic(si), prompt) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100747 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100748 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100749 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100750 }
751
752 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100753 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100754 break;
755
756 /* Now we close the output if one of the writers did so,
757 * or if we're not in interactive mode and the request
758 * buffer is empty. This still allows pipelined requests
759 * to be sent in non-interactive mode.
760 */
Willy Tarreau851d12c2018-06-19 07:01:36 +0200761 if ((res->flags & (CF_SHUTW|CF_SHUTW_NOW)) || (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req))) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100762 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100763 continue;
764 }
765
766 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100767 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100768 }
769 }
770
771 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
772 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
773 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
774 /* Other side has closed, let's abort if we have no more processing to do
775 * and nothing more to consume. This is comparable to a broken pipe, so
776 * we forward the close to the request side so that it flows upstream to
777 * the client.
778 */
779 si_shutw(si);
780 }
781
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100782 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100783 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
784 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
785 /* We have no more processing to do, and nothing more to send, and
786 * the client side has closed. So we'll forward this state downstream
787 * on the response buffer.
788 */
789 si_shutr(si);
790 res->flags |= CF_READ_NULL;
791 }
792
793 out:
Christopher Faulet45073512018-07-20 10:16:29 +0200794 DPRINTF(stderr, "%s@%d: st=%d, rqf=%x, rpf=%x, rqh=%lu, rqs=%lu, rh=%lu, rs=%lu\n",
William Lallemand74c24fb2016-11-21 17:18:36 +0100795 __FUNCTION__, __LINE__,
Christopher Faulet45073512018-07-20 10:16:29 +0200796 si->state, req->flags, res->flags, ci_data(req), co_data(req), ci_data(res), co_data(res));
William Lallemand74c24fb2016-11-21 17:18:36 +0100797}
798
William Lallemand74c24fb2016-11-21 17:18:36 +0100799/* This is called when the stream interface is closed. For instance, upon an
800 * external abort, we won't call the i/o handler anymore so we may need to
801 * remove back references to the stream currently being dumped.
802 */
803static void cli_release_handler(struct appctx *appctx)
804{
805 if (appctx->io_release) {
806 appctx->io_release(appctx);
807 appctx->io_release = NULL;
808 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100809 else if (appctx->st0 == CLI_ST_PRINT_FREE) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100810 free(appctx->ctx.cli.err);
811 appctx->ctx.cli.err = NULL;
812 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100813}
814
815/* This function dumps all environmnent variables to the buffer. It returns 0
816 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +0100817 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
818 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +0100819 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100820static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100821{
Willy Tarreau0a739292016-11-22 20:21:23 +0100822 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100823 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100824
825 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
826 return 1;
827
828 chunk_reset(&trash);
829
830 /* we have two inner loops here, one for the proxy, the other one for
831 * the buffer.
832 */
Willy Tarreauf6710f82016-12-16 17:45:44 +0100833 while (*var) {
834 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +0100835
Willy Tarreau06d80a92017-10-19 14:32:15 +0200836 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100837 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100838 return 0;
839 }
840 if (appctx->st2 == STAT_ST_END)
841 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100842 var++;
843 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +0100844 }
845
846 /* dump complete */
847 return 1;
848}
849
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200850/* This function dumps all file descriptors states (or the requested one) to
851 * the buffer. It returns 0 if the output buffer is full and it needs to be
852 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
853 * It uses cli.i0 as the fd number to restart from.
854 */
855static int cli_io_handler_show_fd(struct appctx *appctx)
856{
857 struct stream_interface *si = appctx->owner;
858 int fd = appctx->ctx.cli.i0;
859
860 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
861 return 1;
862
863 chunk_reset(&trash);
864
865 /* we have two inner loops here, one for the proxy, the other one for
866 * the buffer.
867 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +0100868 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200869 struct fdtab fdt;
Willy Tarreau286ec682017-08-09 16:35:44 +0200870 struct listener *li = NULL;
871 struct server *sv = NULL;
872 struct proxy *px = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +0200873 const struct mux_ops *mux = NULL;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200874 void *ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +0200875 uint32_t conn_flags = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200876
Willy Tarreaubf9fd652018-08-02 11:05:48 +0200877 thread_isolate();
878
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200879 fdt = fdtab[fd];
880
Willy Tarreaubf9fd652018-08-02 11:05:48 +0200881 if (!fdt.owner) {
882 thread_release();
Willy Tarreau017af242017-10-04 20:24:54 +0200883 goto skip; // closed
Willy Tarreaubf9fd652018-08-02 11:05:48 +0200884 }
Willy Tarreau017af242017-10-04 20:24:54 +0200885
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200886 if (fdt.iocb == conn_fd_handler) {
887 conn_flags = ((struct connection *)fdt.owner)->flags;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200888 mux = ((struct connection *)fdt.owner)->mux;
889 ctx = ((struct connection *)fdt.owner)->mux_ctx;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200890 li = objt_listener(((struct connection *)fdt.owner)->target);
891 sv = objt_server(((struct connection *)fdt.owner)->target);
892 px = objt_proxy(((struct connection *)fdt.owner)->target);
893 }
894 else if (fdt.iocb == listener_accept)
895 li = fdt.owner;
896
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200897 chunk_printf(&trash,
Willy Tarreauc754b342018-03-30 15:00:15 +0200898 " %5d : st=0x%02x(R:%c%c%c W:%c%c%c) ev=0x%02x(%c%c%c%c%c) [%c%c] cnext=%d cprev=%d tmask=0x%lx umask=0x%lx owner=%p iocb=%p(%s)",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200899 fd,
900 fdt.state,
901 (fdt.state & FD_EV_POLLED_R) ? 'P' : 'p',
902 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
903 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
904 (fdt.state & FD_EV_POLLED_W) ? 'P' : 'p',
905 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
906 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
907 fdt.ev,
908 (fdt.ev & FD_POLL_HUP) ? 'H' : 'h',
909 (fdt.ev & FD_POLL_ERR) ? 'E' : 'e',
910 (fdt.ev & FD_POLL_OUT) ? 'O' : 'o',
911 (fdt.ev & FD_POLL_PRI) ? 'P' : 'p',
912 (fdt.ev & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200913 fdt.linger_risk ? 'L' : 'l',
914 fdt.cloned ? 'C' : 'c',
Willy Tarreauc754b342018-03-30 15:00:15 +0200915 fdt.cache.next,
916 fdt.cache.prev,
917 fdt.thread_mask, fdt.update_mask,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200918 fdt.owner,
919 fdt.iocb,
920 (fdt.iocb == conn_fd_handler) ? "conn_fd_handler" :
921 (fdt.iocb == dgram_fd_handler) ? "dgram_fd_handler" :
922 (fdt.iocb == listener_accept) ? "listener_accept" :
Olivier Houchard79321b92018-07-26 17:55:11 +0200923 (fdt.iocb == poller_pipe_io_handler) ? "poller_pipe_io_handler" :
Willy Tarreauc754b342018-03-30 15:00:15 +0200924 "unknown");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200925
926 if (fdt.iocb == conn_fd_handler) {
927 chunk_appendf(&trash, " cflg=0x%08x", conn_flags);
928 if (px)
929 chunk_appendf(&trash, " px=%s", px->id);
930 else if (sv)
931 chunk_appendf(&trash, " sv=%s/%s", sv->id, sv->proxy->id);
932 else if (li)
933 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +0200934
Willy Tarreaub011d8f2018-03-30 14:41:19 +0200935 if (mux) {
Willy Tarreau35b1b482018-03-28 18:41:30 +0200936 chunk_appendf(&trash, " mux=%s mux_ctx=%p", mux->name, ctx);
Willy Tarreaub011d8f2018-03-30 14:41:19 +0200937 if (mux->show_fd)
938 mux->show_fd(&trash, fdt.owner);
939 }
Willy Tarreau35b1b482018-03-28 18:41:30 +0200940 else
941 chunk_appendf(&trash, " nomux");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200942 }
943 else if (fdt.iocb == listener_accept) {
944 chunk_appendf(&trash, " l.st=%s fe=%s",
945 listener_state_str(li),
946 li->bind_conf->frontend->id);
947 }
948
Willy Tarreaubf9fd652018-08-02 11:05:48 +0200949 thread_release();
950
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200951 chunk_appendf(&trash, "\n");
952
Willy Tarreau06d80a92017-10-19 14:32:15 +0200953 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100954 si_rx_room_blk(si);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200955 return 0;
956 }
957 skip:
958 if (appctx->st2 == STAT_ST_END)
959 break;
960
961 fd++;
962 appctx->ctx.cli.i0 = fd;
963 }
964
965 /* dump complete */
966 return 1;
967}
968
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100969/* This function dumps some activity counters used by developers and support to
970 * rule out some hypothesis during bug reports. It returns 0 if the output
971 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
972 * everything at once in the buffer and is not designed to do it in multiple
973 * passes.
974 */
975static int cli_io_handler_show_activity(struct appctx *appctx)
976{
977 struct stream_interface *si = appctx->owner;
978 int thr;
979
980 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
981 return 1;
982
983 chunk_reset(&trash);
984
985 chunk_appendf(&trash, "thread_id: %u", tid);
986 chunk_appendf(&trash, "\ndate_now: %lu.%06lu", (long)now.tv_sec, (long)now.tv_usec);
987 chunk_appendf(&trash, "\nloops:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].loops);
988 chunk_appendf(&trash, "\nwake_cache:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_cache);
989 chunk_appendf(&trash, "\nwake_tasks:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_tasks);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100990 chunk_appendf(&trash, "\nwake_signal:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_signal);
991 chunk_appendf(&trash, "\npoll_exp:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_exp);
992 chunk_appendf(&trash, "\npoll_drop:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_drop);
993 chunk_appendf(&trash, "\npoll_dead:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_dead);
994 chunk_appendf(&trash, "\npoll_skip:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_skip);
995 chunk_appendf(&trash, "\nfd_skip:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_skip);
996 chunk_appendf(&trash, "\nfd_lock:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_lock);
997 chunk_appendf(&trash, "\nfd_del:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_del);
998 chunk_appendf(&trash, "\nconn_dead:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].conn_dead);
999 chunk_appendf(&trash, "\nstream:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].stream);
1000 chunk_appendf(&trash, "\nempty_rq:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].empty_rq);
1001 chunk_appendf(&trash, "\nlong_rq:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].long_rq);
Willy Tarreaued72d822018-10-17 19:01:24 +02001002 chunk_appendf(&trash, "\ncpust_tot:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].cpust_total/2);
1003 chunk_appendf(&trash, "\ncpust_1s:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", read_freq_ctr(&activity[thr].cpust_1s)/2);
1004 chunk_appendf(&trash, "\ncpust_15s:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", read_freq_ctr_period(&activity[thr].cpust_15s, 15000)/2);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001005
1006 chunk_appendf(&trash, "\n");
1007
1008 if (ci_putchk(si_ic(si), &trash) == -1) {
1009 chunk_reset(&trash);
1010 chunk_printf(&trash, "[output too large, cannot dump]\n");
Willy Tarreaudb398432018-11-15 11:08:52 +01001011 si_rx_room_blk(si);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001012 }
1013
1014 /* dump complete */
1015 return 1;
1016}
1017
William Lallemandeceddf72016-12-15 18:06:44 +01001018/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001019 * CLI IO handler for `show cli sockets`.
1020 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +01001021 */
1022static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1023{
1024 struct bind_conf *bind_conf;
1025 struct stream_interface *si = appctx->owner;
1026
1027 chunk_reset(&trash);
1028
1029 switch (appctx->st2) {
1030 case STAT_ST_INIT:
1031 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +02001032 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001033 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001034 return 0;
1035 }
William Lallemandeceddf72016-12-15 18:06:44 +01001036 appctx->st2 = STAT_ST_LIST;
1037
1038 case STAT_ST_LIST:
1039 if (global.stats_fe) {
1040 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
1041 struct listener *l;
1042
1043 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001044 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +01001045 * if the current node is the first of the list
1046 */
1047
Willy Tarreau3af9d832016-12-16 12:58:09 +01001048 if (appctx->ctx.cli.p0 &&
1049 &bind_conf->by_fe == (&global.stats_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +01001050 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +01001051 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +01001052 continue;
1053 }
1054
1055 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
1056
1057 char addr[46];
1058 char port[6];
1059
1060 if (l->addr.ss_family == AF_UNIX) {
1061 const struct sockaddr_un *un;
1062
1063 un = (struct sockaddr_un *)&l->addr;
1064 chunk_appendf(&trash, "%s ", un->sun_path);
1065 } else if (l->addr.ss_family == AF_INET) {
1066 addr_to_str(&l->addr, addr, sizeof(addr));
1067 port_to_str(&l->addr, port, sizeof(port));
1068 chunk_appendf(&trash, "%s:%s ", addr, port);
1069 } else if (l->addr.ss_family == AF_INET6) {
1070 addr_to_str(&l->addr, addr, sizeof(addr));
1071 port_to_str(&l->addr, port, sizeof(port));
1072 chunk_appendf(&trash, "[%s]:%s ", addr, port);
William Lallemand26314342018-10-26 14:47:41 +02001073 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
1074 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
William Lallemandeceddf72016-12-15 18:06:44 +01001075 } else
William Lallemand26314342018-10-26 14:47:41 +02001076 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001077
William Lallemand07a62f72017-05-24 00:57:40 +02001078 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +01001079 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +02001080 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1081 chunk_appendf(&trash, "operator ");
1082 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1083 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +01001084 else
1085 chunk_appendf(&trash, " ");
1086
1087 if (bind_conf->bind_proc != 0) {
1088 int pos;
Willy Tarreau20c5e522016-12-16 12:50:55 +01001089 for (pos = 0; pos < 8 * sizeof(bind_conf->bind_proc); pos++) {
Willy Tarreau4305ac72016-12-16 12:56:31 +01001090 if (bind_conf->bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +01001091 chunk_appendf(&trash, "%d,", pos+1);
1092 }
1093 }
1094 /* replace the latest comma by a newline */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001095 trash.area[trash.data-1] = '\n';
William Lallemandeceddf72016-12-15 18:06:44 +01001096
1097 } else {
1098 chunk_appendf(&trash, "all\n");
1099 }
1100
Willy Tarreau06d80a92017-10-19 14:32:15 +02001101 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001102 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001103 return 0;
1104 }
1105 }
Willy Tarreau3af9d832016-12-16 12:58:09 +01001106 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001107 }
1108 }
1109 default:
1110 appctx->st2 = STAT_ST_FIN;
1111 return 1;
1112 }
1113}
1114
1115
Willy Tarreau0a739292016-11-22 20:21:23 +01001116/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001117 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1118 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001119 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001120static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001121{
1122 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001123 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001124
1125 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1126 return 1;
1127
Willy Tarreauf6710f82016-12-16 17:45:44 +01001128 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001129
1130 if (*args[2]) {
1131 int len = strlen(args[2]);
1132
Willy Tarreauf6710f82016-12-16 17:45:44 +01001133 for (; *var; var++) {
1134 if (strncmp(*var, args[2], len) == 0 &&
1135 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001136 break;
1137 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001138 if (!*var) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001139 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau0a739292016-11-22 20:21:23 +01001140 appctx->ctx.cli.msg = "Variable not found\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001141 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau0a739292016-11-22 20:21:23 +01001142 return 1;
1143 }
1144 appctx->st2 = STAT_ST_END;
1145 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001146 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001147 return 0;
1148}
1149
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001150/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1151 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1152 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1153 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001154static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001155{
1156 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1157 return 1;
1158
1159 appctx->ctx.cli.i0 = 0;
1160
1161 if (*args[2]) {
1162 appctx->ctx.cli.i0 = atoi(args[2]);
1163 appctx->st2 = STAT_ST_END;
1164 }
1165 return 0;
1166}
1167
Willy Tarreau599852e2016-11-22 20:33:32 +01001168/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001169static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001170{
1171 struct stream_interface *si = appctx->owner;
1172 struct stream *s = si_strm(si);
1173
1174 if (strcmp(args[2], "cli") == 0) {
1175 unsigned timeout;
1176 const char *res;
1177
1178 if (!*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001179 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001180 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001181 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001182 return 1;
1183 }
1184
1185 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
1186 if (res || timeout < 1) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001187 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001188 appctx->ctx.cli.msg = "Invalid timeout value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001189 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001190 return 1;
1191 }
1192
1193 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1194 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1195 return 1;
1196 }
1197 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001198 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001199 appctx->ctx.cli.msg = "'set timeout' only supports 'cli'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001200 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001201 return 1;
1202 }
1203}
1204
Willy Tarreau2af99412016-11-23 11:10:59 +01001205/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001206static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001207{
1208 int v;
1209
1210 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1211 return 1;
1212
1213 if (!*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001214 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau2af99412016-11-23 11:10:59 +01001215 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001216 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +01001217 return 1;
1218 }
1219
1220 v = atoi(args[3]);
1221 if (v > global.hardmaxconn) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001222 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau2af99412016-11-23 11:10:59 +01001223 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001224 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +01001225 return 1;
1226 }
1227
1228 /* check for unlimited values */
1229 if (v <= 0)
1230 v = global.hardmaxconn;
1231
1232 global.maxconn = v;
1233
1234 /* Dequeues all of the listeners waiting for a resource */
1235 if (!LIST_ISEMPTY(&global_listener_queue))
1236 dequeue_all_listeners(&global_listener_queue);
1237
1238 return 1;
1239}
1240
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001241static int set_severity_output(int *target, char *argument)
1242{
1243 if (!strcmp(argument, "none")) {
1244 *target = CLI_SEVERITY_NONE;
1245 return 1;
1246 }
1247 else if (!strcmp(argument, "number")) {
1248 *target = CLI_SEVERITY_NUMBER;
1249 return 1;
1250 }
1251 else if (!strcmp(argument, "string")) {
1252 *target = CLI_SEVERITY_STRING;
1253 return 1;
1254 }
1255 return 0;
1256}
1257
1258/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001259static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001260{
1261 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1262 return 0;
1263
1264 appctx->ctx.cli.severity = LOG_ERR;
Aurélien Nephtali6e8a41d2018-03-15 21:48:50 +01001265 appctx->ctx.cli.msg = "one of 'none', 'number', 'string' is a required argument\n";
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001266 appctx->st0 = CLI_ST_PRINT;
1267 return 1;
1268}
William Lallemandeceddf72016-12-15 18:06:44 +01001269
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001270int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001271{
1272 return 0;
1273}
1274
Willy Tarreau45c742b2016-11-24 14:51:17 +01001275/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001276static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001277{
1278 int v;
1279 int *res;
1280 int mul = 1;
1281
1282 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1283 return 1;
1284
1285 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1286 res = &global.cps_lim;
1287 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1288 res = &global.sps_lim;
1289#ifdef USE_OPENSSL
1290 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1291 res = &global.ssl_lim;
1292#endif
1293 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1294 res = &global.comp_rate_lim;
1295 mul = 1024;
1296 }
1297 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001298 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001299 appctx->ctx.cli.msg =
1300 "'set rate-limit' only supports :\n"
1301 " - 'connections global' to set the per-process maximum connection rate\n"
1302 " - 'sessions global' to set the per-process maximum session rate\n"
1303#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001304 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001305#endif
1306 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001307 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001308 return 1;
1309 }
1310
1311 if (!*args[4]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001312 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001313 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001314 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001315 return 1;
1316 }
1317
1318 v = atoi(args[4]);
1319 if (v < 0) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001320 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001321 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001322 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001323 return 1;
1324 }
1325
1326 *res = v * mul;
1327
1328 /* Dequeues all of the listeners waiting for a resource */
1329 if (!LIST_ISEMPTY(&global_listener_queue))
1330 dequeue_all_listeners(&global_listener_queue);
1331
1332 return 1;
1333}
1334
William Lallemandf6975e92017-05-26 17:42:10 +02001335/* parse the "expose-fd" argument on the bind lines */
1336static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1337{
1338 if (!*args[cur_arg + 1]) {
1339 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1340 return ERR_ALERT | ERR_FATAL;
1341 }
1342 if (!strcmp(args[cur_arg+1], "listeners")) {
1343 conf->level |= ACCESS_FD_LISTENERS;
1344 } else {
1345 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1346 args[cur_arg], args[cur_arg+1]);
1347 return ERR_ALERT | ERR_FATAL;
1348 }
1349
1350 return 0;
1351}
1352
William Lallemand74c24fb2016-11-21 17:18:36 +01001353/* parse the "level" argument on the bind lines */
1354static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1355{
1356 if (!*args[cur_arg + 1]) {
1357 memprintf(err, "'%s' : missing level", args[cur_arg]);
1358 return ERR_ALERT | ERR_FATAL;
1359 }
1360
William Lallemand07a62f72017-05-24 00:57:40 +02001361 if (!strcmp(args[cur_arg+1], "user")) {
1362 conf->level &= ~ACCESS_LVL_MASK;
1363 conf->level |= ACCESS_LVL_USER;
1364 } else if (!strcmp(args[cur_arg+1], "operator")) {
1365 conf->level &= ~ACCESS_LVL_MASK;
1366 conf->level |= ACCESS_LVL_OPER;
1367 } else if (!strcmp(args[cur_arg+1], "admin")) {
1368 conf->level &= ~ACCESS_LVL_MASK;
1369 conf->level |= ACCESS_LVL_ADMIN;
1370 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001371 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1372 args[cur_arg], args[cur_arg+1]);
1373 return ERR_ALERT | ERR_FATAL;
1374 }
1375
1376 return 0;
1377}
1378
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001379static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1380{
1381 if (!*args[cur_arg + 1]) {
1382 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1383 return ERR_ALERT | ERR_FATAL;
1384 }
1385
1386 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1387 return 0;
1388 else {
1389 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1390 args[cur_arg], args[cur_arg+1]);
1391 return ERR_ALERT | ERR_FATAL;
1392 }
1393}
1394
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001395
1396 /* Displays workers and processes */
1397static int cli_io_handler_show_proc(struct appctx *appctx)
1398{
1399 struct stream_interface *si = appctx->owner;
1400 struct mworker_proc *child;
1401
1402 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1403 return 1;
1404
1405 chunk_reset(&trash);
1406
William Lallemandadbce8e2018-11-06 17:37:10 +01001407 chunk_printf(&trash, "# <PID> <type> <relative PID> <reloads>\n");
1408 chunk_appendf(&trash, "%u %s %u %d\n", getpid(), "master", 0, -1);
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001409
1410
1411 list_for_each_entry(child, &proc_list, list) {
William Lallemandadbce8e2018-11-06 17:37:10 +01001412 chunk_appendf(&trash, "%u %s %u %d\n", child->pid, "worker", child->relative_pid, child->reloads);
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001413 }
1414
1415 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001416 si_rx_room_blk(si);
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001417 return 0;
1418 }
1419
1420 /* dump complete */
1421 return 1;
1422}
1423
Olivier Houchardf886e342017-04-05 22:24:59 +02001424/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001425static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02001426{
1427 char *cmsgbuf = NULL;
1428 unsigned char *tmpbuf = NULL;
1429 struct cmsghdr *cmsg;
1430 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001431 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001432 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001433 struct msghdr msghdr;
1434 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001435 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Olivier Houchardf886e342017-04-05 22:24:59 +02001436 int *tmpfd;
1437 int tot_fd_nb = 0;
1438 struct proxy *px;
1439 int i = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001440 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001441 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001442 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001443 int ret;
1444
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001445 if (!remote) {
1446 ha_warning("Only works on real connections\n");
1447 goto out;
1448 }
1449
1450 fd = remote->handle.fd;
1451
Olivier Houchardf886e342017-04-05 22:24:59 +02001452 /* Temporary set the FD in blocking mode, that will make our life easier */
1453 old_fcntl = fcntl(fd, F_GETFL);
1454 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001455 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001456 goto out;
1457 }
1458 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1459 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001460 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001461 goto out;
1462 }
1463 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001464 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001465 goto out;
1466 }
Olivier Houchard54740872017-04-06 14:45:14 +02001467 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001468 iov.iov_base = &tot_fd_nb;
1469 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001470 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001471 goto out;
1472 memset(&msghdr, 0, sizeof(msghdr));
1473 /*
1474 * First, calculates the total number of FD, so that we can let
1475 * the caller know how much he should expects.
1476 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001477 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001478 while (px) {
1479 struct listener *l;
1480
1481 list_for_each_entry(l, &px->conf.listeners, by_fe) {
Olivier Houchard1fc05162017-04-06 01:05:05 +02001482 /* Only transfer IPv4/IPv6/UNIX sockets */
1483 if (l->state >= LI_ZOMBIE &&
1484 (l->proto->sock_family == AF_INET ||
Olivier Houchardf886e342017-04-05 22:24:59 +02001485 l->proto->sock_family == AF_INET6 ||
Olivier Houchard1fc05162017-04-06 01:05:05 +02001486 l->proto->sock_family == AF_UNIX))
Olivier Houchardf886e342017-04-05 22:24:59 +02001487 tot_fd_nb++;
1488 }
1489 px = px->next;
1490 }
1491 if (tot_fd_nb == 0)
1492 goto out;
1493
1494 /* First send the total number of file descriptors, so that the
1495 * receiving end knows what to expect.
1496 */
1497 msghdr.msg_iov = &iov;
1498 msghdr.msg_iovlen = 1;
1499 ret = sendmsg(fd, &msghdr, 0);
1500 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001501 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001502 goto out;
1503 }
1504
1505 /* Now send the fds */
1506 msghdr.msg_control = cmsgbuf;
1507 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1508 cmsg = CMSG_FIRSTHDR(&msghdr);
1509 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1510 cmsg->cmsg_level = SOL_SOCKET;
1511 cmsg->cmsg_type = SCM_RIGHTS;
1512 tmpfd = (int *)CMSG_DATA(cmsg);
1513
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001514 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001515 /* For each socket, e message is sent, containing the following :
1516 * Size of the namespace name (or 0 if none), as an unsigned char.
1517 * The namespace name, if any
1518 * Size of the interface name (or 0 if none), as an unsigned char
1519 * The interface name, if any
1520 * Listener options, as an int.
1521 */
1522 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
1523 * buffer big enough to store the socket informations.
1524 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001525 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001526 if (tmpbuf == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001527 ha_warning("Failed to allocate memory to transfer socket informations\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001528 goto out;
1529 }
1530 iov.iov_base = tmpbuf;
1531 while (px) {
1532 struct listener *l;
1533
1534 list_for_each_entry(l, &px->conf.listeners, by_fe) {
1535 int ret;
1536 /* Only transfer IPv4/IPv6 sockets */
Olivier Houchard1fc05162017-04-06 01:05:05 +02001537 if (l->state >= LI_ZOMBIE &&
Olivier Houchardf886e342017-04-05 22:24:59 +02001538 (l->proto->sock_family == AF_INET ||
1539 l->proto->sock_family == AF_INET6 ||
1540 l->proto->sock_family == AF_UNIX)) {
1541 memcpy(&tmpfd[i % MAX_SEND_FD], &l->fd, sizeof(l->fd));
1542 if (!l->netns)
1543 tmpbuf[curoff++] = 0;
1544#ifdef CONFIG_HAP_NS
1545 else {
1546 char *name = l->netns->node.key;
1547 unsigned char len = l->netns->name_len;
1548 tmpbuf[curoff++] = len;
1549 memcpy(tmpbuf + curoff, name, len);
1550 curoff += len;
1551 }
1552#endif
1553 if (l->interface) {
1554 unsigned char len = strlen(l->interface);
1555 tmpbuf[curoff++] = len;
1556 memcpy(tmpbuf + curoff, l->interface, len);
1557 curoff += len;
1558 } else
1559 tmpbuf[curoff++] = 0;
1560 memcpy(tmpbuf + curoff, &l->options,
1561 sizeof(l->options));
1562 curoff += sizeof(l->options);
1563
1564
1565 i++;
1566 } else
1567 continue;
1568 if ((!(i % MAX_SEND_FD))) {
1569 iov.iov_len = curoff;
1570 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001571 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001572 goto out;
1573 }
1574 /* Wait for an ack */
1575 do {
1576 ret = recv(fd, &tot_fd_nb,
1577 sizeof(tot_fd_nb), 0);
1578 } while (ret == -1 && errno == EINTR);
1579 if (ret <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001580 ha_warning("Unexpected error while transferring sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001581 goto out;
1582 }
1583 curoff = 0;
1584 }
1585
1586 }
1587 px = px->next;
1588 }
1589 if (i % MAX_SEND_FD) {
1590 iov.iov_len = curoff;
1591 cmsg->cmsg_len = CMSG_LEN((i % MAX_SEND_FD) * sizeof(int));
1592 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * (i % MAX_SEND_FD));
1593 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001594 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001595 goto out;
1596 }
1597 }
1598
1599out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001600 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001601 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001602 goto out;
1603 }
1604 appctx->st0 = CLI_ST_END;
1605 free(cmsgbuf);
1606 free(tmpbuf);
1607 return 1;
1608}
1609
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001610static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
1611{
1612 if (*args[0] == 'h')
1613 /* help */
1614 cli_gen_usage_msg(appctx);
1615 else if (*args[0] == 'p')
1616 /* prompt */
1617 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
1618 else if (*args[0] == 'q')
1619 /* quit */
1620 appctx->st0 = CLI_ST_END;
1621
1622 return 1;
1623}
Olivier Houchardf886e342017-04-05 22:24:59 +02001624
William Lallemand2f4ce202018-10-26 14:47:47 +02001625void pcli_write_prompt(struct stream *s)
1626{
1627 struct buffer *msg = get_trash_chunk();
1628 struct channel *oc = si_oc(&s->si[0]);
1629
1630 if (s->pcli_next_pid == 0)
1631 chunk_appendf(msg, "master> ");
1632 else
1633 chunk_appendf(msg, "%d> ", s->pcli_next_pid);
1634 co_inject(oc, msg->area, msg->data);
1635}
1636
William Lallemand291810d2018-10-26 14:47:38 +02001637
William Lallemandcf62f7e2018-10-26 14:47:40 +02001638/* The pcli_* functions are used for the CLI proxy in the master */
1639
William Lallemanddeeaa592018-10-26 14:47:48 +02001640void pcli_reply_and_close(struct stream *s, const char *msg)
1641{
1642 struct buffer *buf = get_trash_chunk();
1643
1644 chunk_initstr(buf, msg);
1645 stream_int_retnclose(&s->si[0], buf);
1646}
1647
William Lallemand291810d2018-10-26 14:47:38 +02001648static enum obj_type *pcli_pid_to_server(int proc_pid)
1649{
1650 struct mworker_proc *child;
1651
1652 list_for_each_entry(child, &proc_list, list) {
1653 if (child->pid == proc_pid){
1654 return &child->srv->obj_type;
1655 }
1656 }
1657 return NULL;
1658}
1659
1660/* Take a CLI prefix in argument (eg: @!1234 @master @1)
1661 * Return:
1662 * 0: master
1663 * > 0: pid of a worker
1664 * < 0: didn't find a worker
1665 */
1666static int pcli_prefix_to_pid(const char *prefix)
1667{
1668 int proc_pid;
1669 struct mworker_proc *child;
1670 char *errtol = NULL;
1671
1672 if (*prefix != '@') /* not a prefix, should not happen */
1673 return -1;
1674
1675 prefix++;
1676 if (!*prefix) /* sent @ alone, return the master */
1677 return 0;
1678
1679 if (strcmp("master", prefix) == 0) {
1680 return 0;
1681 } else if (*prefix == '!') {
1682 prefix++;
1683 if (!*prefix)
1684 return -1;
1685
1686 proc_pid = strtol(prefix, &errtol, 10);
1687 if (*errtol != '\0')
1688 return -1;
1689 list_for_each_entry(child, &proc_list, list) {
1690 if (child->pid == proc_pid){
1691 return child->pid;
1692 }
1693 }
1694 } else {
1695 struct mworker_proc *chosen = NULL;
1696 /* this is a relative pid */
1697
1698 proc_pid = strtol(prefix, &errtol, 10);
1699 if (*errtol != '\0')
1700 return -1;
1701
1702 if (proc_pid == 0) /* return the master */
1703 return 0;
1704
1705 /* chose the right process, the current one is the one with the
1706 least number of reloads */
1707 list_for_each_entry(child, &proc_list, list) {
1708 if (child->relative_pid == proc_pid){
1709 if (child->reloads == 0)
1710 return child->pid;
1711 else if (chosen == NULL || child->reloads < chosen->reloads)
1712 chosen = child;
1713 }
1714 }
1715 if (chosen)
1716 return chosen->pid;
1717 }
1718 return -1;
1719}
1720
William Lallemandcf62f7e2018-10-26 14:47:40 +02001721/* Parse the CLI request:
1722 *
1723 * - it can rewrite the buffer by trimming the prefix
1724 * - fill dst with the destination server if there is one
1725 *
1726 * Return:
1727 * - the amount of data to forward or
1728 * - -1 if there is no end to the command or
1729 * - 0 everything has been trimmed (only a prefix)
1730 */
1731#define PCLI_REQ_INIT 0
1732#define PCLI_REQ_PFX 1
1733#define PCLI_REQ_TRIM 2
1734#define PCLI_REQ_CMD 3
1735
1736int pcli_parse_request(struct channel *req, int *target_pid)
1737{
1738 char *input = (char *)ci_head(req);
1739 const char *end;
1740 char *ptr, *trim = NULL, *pfx_b = NULL, *cmd_b = NULL;
1741 struct buffer *buf = &req->buf;
1742 int ret = 0;
1743 int state = PCLI_REQ_INIT;
1744
1745 ptr = input;
1746 end = b_stop(buf);
1747
1748 /* The while loop condition is checking the end of the command.
1749 It is needed to iterate for each ptr++ done in the parser */
1750 while (ptr < end && *ptr != '\n' && *ptr != '\r' && *ptr != ';') {
1751 switch (state) {
1752 /* The init state only trims the useless chars */
1753 case PCLI_REQ_INIT:
1754
1755 /* skip every spaces at the start of the command */
1756 if (*ptr == ' ') {
1757 ptr++;
1758 continue;
1759 }
1760 pfx_b = ptr; /* this is the start of the command or of the @ prefix */
1761 state = PCLI_REQ_PFX;
1762
1763 /* the atprefix state looks for a @ prefix. If it finds
1764 it, it will check to which server send the request.
1765 It also ajust the trim pointer */
1766 case PCLI_REQ_PFX:
1767
1768 if (*pfx_b != '@') {
1769 /* there is no prefix */
1770 pfx_b = NULL;
William Lallemand744de5b2018-10-29 17:14:00 +01001771 cmd_b = input; /* if no prefix we don't trim anything */
William Lallemandcf62f7e2018-10-26 14:47:40 +02001772 state = PCLI_REQ_CMD;
1773 continue;
1774 }
1775
1776 if (*ptr != ' ') {
1777 ptr++;
1778 continue;
1779 }
1780 *ptr = '\0'; /* this the end of the prefix */
1781 ptr++;
1782 trim = ptr;
1783 state = PCLI_REQ_TRIM;
1784 break;
1785
1786 /* we really need to trim there because that's the only
1787 way to know if we are going to send a command or if
1788 there is only a prefix */
1789 case PCLI_REQ_TRIM:
1790 if (*ptr == ' ') {
1791 ptr++;
1792 continue;
1793 }
1794 cmd_b = trim = ptr;
1795 state = PCLI_REQ_CMD;
1796
1797 /* just look for the end of the command */
1798 case PCLI_REQ_CMD:
1799 ptr++;
1800 continue;
1801 }
1802 }
1803
1804 /* we didn't find a command separator, not enough data */
1805 if (ptr >= end)
1806 return -1;
1807
1808 if (!pfx_b && !cmd_b) {
1809 /* probably just a \n or a ; */
1810 return 1;
1811 } else if (pfx_b && !cmd_b) {
1812 /* it's only a prefix, we don't want to forward it */
1813 *ptr = '\0';
1814 trim = ptr + 1; /* we want to trim the whole command */
1815 ret = 0;
1816 } else if (cmd_b) {
1817 /* command without a prefix */
1818 *ptr = '\n';
1819 ret = ptr - cmd_b + 1;
1820 }
1821
1822 if (pfx_b)
1823 *target_pid = pcli_prefix_to_pid(pfx_b);
1824
1825 /* trim the useless chars */
1826 if (trim)
1827 b_del(&req->buf, trim - input);
1828
1829 return ret;
1830}
1831
1832int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
1833{
1834 int target_pid;
1835 int to_forward;
1836
1837 target_pid = s->pcli_next_pid;
1838
1839read_again:
1840 /* if the channel is closed for read, we won't receive any more data
1841 from the client, but we don't want to forward this close to the
1842 server */
1843 channel_dont_close(req);
1844
1845 /* We don't know yet to which server we will connect */
1846 channel_dont_connect(req);
1847
1848
1849 /* we are not waiting for a response, there is no more request and we
1850 * receive a close from the client, we can leave */
1851 if (!(ci_data(req)) && req->flags & CF_SHUTR) {
1852 channel_shutw_now(&s->res);
1853 s->req.analysers &= ~AN_REQ_WAIT_CLI;
1854 return 1;
1855 }
1856
1857 req->flags |= CF_READ_DONTWAIT;
1858
1859 /* need more data */
1860 if (!ci_data(req))
1861 return 0;
1862
1863 /* If there is data available for analysis, log the end of the idle time. */
1864 if (c_data(req) && s->logs.t_idle == -1)
1865 s->logs.t_idle = tv_ms_elapsed(&s->logs.tv_accept, &now) - s->logs.t_handshake;
1866
1867 to_forward = pcli_parse_request(req, &target_pid);
1868 if (to_forward > 0) {
1869 /* enough data */
1870
1871 /* we didn't find the process, send an error and close */
1872 if (target_pid < 0) {
1873 pcli_reply_and_close(s, "Can't find the target CLI!\n");
1874 return 0;
1875 }
1876
1877 /* forward only 1 command */
1878 channel_forward(req, to_forward);
1879 /* we send only 1 command per request, and we write close after it */
1880 channel_shutw_now(req);
1881
1882 /* remove the XFER_DATA analysers, which forwards all
1883 * the data, we don't want to forward the next requests
1884 * We need to add CF_FLT_ANALYZE to abort the forward too.
1885 */
1886 req->analysers &= ~(AN_REQ_FLT_XFER_DATA|AN_REQ_WAIT_CLI);
1887 req->analysers |= AN_REQ_FLT_END|CF_FLT_ANALYZE;
1888 s->res.analysers |= AN_RES_WAIT_CLI;
1889
1890 /* we can connect now */
1891 s->target = pcli_pid_to_server(target_pid);
1892 if (!s->target) {
1893 s->target = &cli_applet.obj_type;
1894 }
1895
1896 s->flags |= (SF_DIRECT | SF_ASSIGNED);
1897 channel_auto_connect(req);
1898
1899 } else if (to_forward == 0) {
1900 /* we only received a prefix without command, which
1901 mean that we want to store it for every other
1902 command for this session */
1903 if (target_pid > -1) {
1904 s->pcli_next_pid = target_pid;
William Lallemand2f4ce202018-10-26 14:47:47 +02001905 pcli_write_prompt(s);
William Lallemandcf62f7e2018-10-26 14:47:40 +02001906 } else {
William Lallemandcf62f7e2018-10-26 14:47:40 +02001907 s->pcli_next_pid = 0;
William Lallemanddeeaa592018-10-26 14:47:48 +02001908 pcli_reply_and_close(s, "Can't find the target CLI!\n");
William Lallemandcf62f7e2018-10-26 14:47:40 +02001909 }
1910
1911 /* we trimmed things but we might have other commands to consume */
1912 goto read_again;
1913 } else if (to_forward == -1 && channel_full(req, global.tune.maxrewrite)) {
1914 /* buffer is full and we didn't catch the end of a command */
1915 goto send_help;
1916 }
1917
1918 return 0;
1919
1920send_help:
1921 b_reset(&req->buf);
1922 b_putblk(&req->buf, "help\n", 5);
1923 goto read_again;
1924}
1925
1926int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
1927{
1928 struct proxy *fe = strm_fe(s);
1929 struct proxy *be = s->be;
1930
William Lallemand6b7cd0a2018-11-06 17:37:11 +01001931 if (rep->flags & CF_READ_ERROR) {
1932 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
1933 s->res.analysers &= ~AN_RES_WAIT_CLI;
1934 return 0;
1935 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02001936 rep->flags |= CF_READ_DONTWAIT; /* try to get back here ASAP */
1937 rep->flags |= CF_NEVER_WAIT;
1938
1939 /* don't forward the close */
1940 channel_dont_close(&s->res);
1941 channel_dont_close(&s->req);
1942
1943 /* forward the data */
1944 if (ci_data(rep)) {
1945 c_adv(rep, ci_data(rep));
1946 return 0;
1947 }
1948
1949 if ((rep->flags & (CF_SHUTR|CF_READ_NULL))) {
1950 /* stream cleanup */
1951
William Lallemand2f4ce202018-10-26 14:47:47 +02001952 pcli_write_prompt(s);
1953
William Lallemandcf62f7e2018-10-26 14:47:40 +02001954 s->si[1].flags |= SI_FL_NOLINGER | SI_FL_NOHALF;
1955 si_shutr(&s->si[1]);
1956 si_shutw(&s->si[1]);
1957
1958 /*
1959 * starting from there this the same code as
1960 * http_end_txn_clean_session().
1961 *
1962 * It allows to do frontend keepalive while reconnecting to a
1963 * new server for each request.
1964 */
1965
1966 if (s->flags & SF_BE_ASSIGNED) {
1967 HA_ATOMIC_SUB(&be->beconn, 1);
1968 if (unlikely(s->srv_conn))
1969 sess_change_server(s, NULL);
1970 }
1971
1972 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
1973 stream_process_counters(s);
1974
1975 /* don't count other requests' data */
1976 s->logs.bytes_in -= ci_data(&s->req);
1977 s->logs.bytes_out -= ci_data(&s->res);
1978
1979 /* we may need to know the position in the queue */
1980 pendconn_free(s);
1981
1982 /* let's do a final log if we need it */
1983 if (!LIST_ISEMPTY(&fe->logformat) && s->logs.logwait &&
1984 !(s->flags & SF_MONITOR) &&
1985 (!(fe->options & PR_O_NULLNOLOG) || s->req.total)) {
1986 s->do_log(s);
1987 }
1988
1989 /* stop tracking content-based counters */
1990 stream_stop_content_counters(s);
1991 stream_update_time_stats(s);
1992
1993 s->logs.accept_date = date; /* user-visible date for logging */
1994 s->logs.tv_accept = now; /* corrected date for internal use */
1995 s->logs.t_handshake = 0; /* There are no handshake in keep alive connection. */
1996 s->logs.t_idle = -1;
1997 tv_zero(&s->logs.tv_request);
1998 s->logs.t_queue = -1;
1999 s->logs.t_connect = -1;
2000 s->logs.t_data = -1;
2001 s->logs.t_close = 0;
2002 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
2003 s->logs.srv_queue_pos = 0; /* we will get this number soon */
2004
2005 s->logs.bytes_in = s->req.total = ci_data(&s->req);
2006 s->logs.bytes_out = s->res.total = ci_data(&s->res);
2007
2008 stream_del_srv_conn(s);
2009 if (objt_server(s->target)) {
2010 if (s->flags & SF_CURR_SESS) {
2011 s->flags &= ~SF_CURR_SESS;
2012 HA_ATOMIC_SUB(&objt_server(s->target)->cur_sess, 1);
2013 }
2014 if (may_dequeue_tasks(objt_server(s->target), be))
2015 process_srv_queue(objt_server(s->target));
2016 }
2017
2018 s->target = NULL;
2019
2020 /* only release our endpoint if we don't intend to reuse the
2021 * connection.
2022 */
2023 if (!si_conn_ready(&s->si[1])) {
2024 si_release_endpoint(&s->si[1]);
2025 s->srv_conn = NULL;
2026 }
2027
2028 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
2029 s->si[1].err_type = SI_ET_NONE;
2030 s->si[1].conn_retries = 0; /* used for logging too */
2031 s->si[1].exp = TICK_ETERNITY;
2032 s->si[1].flags &= SI_FL_ISBACK | SI_FL_DONT_WAKE; /* we're in the context of process_stream */
2033 s->req.flags &= ~(CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CONNECT|CF_WRITE_ERROR|CF_STREAMER|CF_STREAMER_FAST|CF_NEVER_WAIT|CF_WAKE_CONNECT|CF_WROTE_DATA);
2034 s->res.flags &= ~(CF_SHUTR|CF_SHUTR_NOW|CF_READ_ATTACHED|CF_READ_ERROR|CF_READ_NOEXP|CF_STREAMER|CF_STREAMER_FAST|CF_WRITE_PARTIAL|CF_NEVER_WAIT|CF_WROTE_DATA);
2035 s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_ADDR_SET|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
2036 s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
2037 s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
2038 /* reinitialise the current rule list pointer to NULL. We are sure that
2039 * any rulelist match the NULL pointer.
2040 */
2041 s->current_rule_list = NULL;
2042
2043 s->be = strm_fe(s);
2044 s->logs.logwait = strm_fe(s)->to_log;
2045 s->logs.level = 0;
2046 stream_del_srv_conn(s);
2047 s->target = NULL;
2048 /* re-init store persistence */
2049 s->store_count = 0;
2050 s->uniq_id = global.req_count++;
2051
2052 s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */
2053
2054 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2055
2056 s->req.analysers |= AN_REQ_WAIT_CLI;
2057 s->res.analysers &= ~AN_RES_WAIT_CLI;
2058
2059 /* We must trim any excess data from the response buffer, because we
2060 * may have blocked an invalid response from a server that we don't
2061 * want to accidentely forward once we disable the analysers, nor do
2062 * we want those data to come along with next response. A typical
2063 * example of such data would be from a buggy server responding to
2064 * a HEAD with some data, or sending more than the advertised
2065 * content-length.
2066 */
2067 if (unlikely(ci_data(&s->res)))
2068 b_set_data(&s->res.buf, co_data(&s->res));
2069
2070 /* Now we can realign the response buffer */
2071 c_realign_if_empty(&s->res);
2072
2073 s->req.rto = strm_fe(s)->timeout.client;
2074 s->req.wto = TICK_ETERNITY;
2075
2076 s->res.rto = TICK_ETERNITY;
2077 s->res.wto = strm_fe(s)->timeout.client;
2078
2079 s->req.rex = TICK_ETERNITY;
2080 s->req.wex = TICK_ETERNITY;
2081 s->req.analyse_exp = TICK_ETERNITY;
2082 s->res.rex = TICK_ETERNITY;
2083 s->res.wex = TICK_ETERNITY;
2084 s->res.analyse_exp = TICK_ETERNITY;
2085 s->si[1].hcto = TICK_ETERNITY;
2086
2087 /* we're removing the analysers, we MUST re-enable events detection.
2088 * We don't enable close on the response channel since it's either
2089 * already closed, or in keep-alive with an idle connection handler.
2090 */
2091 channel_auto_read(&s->req);
2092 channel_auto_close(&s->req);
2093 channel_auto_read(&s->res);
2094
2095
2096 return 1;
2097 }
2098 return 0;
2099}
2100
William Lallemand8a022572018-10-26 14:47:35 +02002101/*
2102 * The mworker functions are used to initialize the CLI in the master process
2103 */
2104
William Lallemand309dc9a2018-10-26 14:47:45 +02002105 /*
2106 * Stop the mworker proxy
2107 */
2108void mworker_cli_proxy_stop()
2109{
William Lallemand550db6d2018-11-06 17:37:12 +01002110 if (mworker_proxy)
2111 stop_proxy(mworker_proxy);
William Lallemand309dc9a2018-10-26 14:47:45 +02002112}
2113
William Lallemand8a022572018-10-26 14:47:35 +02002114/*
2115 * Create the mworker CLI proxy
2116 */
2117int mworker_cli_proxy_create()
2118{
2119 struct mworker_proc *child;
2120
2121 mworker_proxy = calloc(1, sizeof(*mworker_proxy));
2122 if (!mworker_proxy)
2123 return -1;
2124
2125 init_new_proxy(mworker_proxy);
2126 mworker_proxy->next = proxies_list;
2127 proxies_list = mworker_proxy;
2128 mworker_proxy->id = strdup("MASTER");
William Lallemandcf62f7e2018-10-26 14:47:40 +02002129 mworker_proxy->mode = PR_MODE_CLI;
William Lallemand8a022572018-10-26 14:47:35 +02002130 mworker_proxy->state = PR_STNEW;
2131 mworker_proxy->last_change = now.tv_sec;
2132 mworker_proxy->cap = PR_CAP_LISTEN; /* this is a listen section */
2133 mworker_proxy->maxconn = 10; /* default to 10 concurrent connections */
2134 mworker_proxy->timeout.client = 0; /* no timeout */
2135 mworker_proxy->conf.file = strdup("MASTER");
2136 mworker_proxy->conf.line = 0;
2137 mworker_proxy->accept = frontend_accept;
2138 mworker_proxy-> lbprm.algo = BE_LB_ALGO_NONE;
2139
2140 /* Does not init the default target the CLI applet, but must be done in
2141 * the request parsing code */
2142 mworker_proxy->default_target = NULL;
2143
2144 /* the check_config_validity() will get an ID for the proxy */
2145 mworker_proxy->uuid = -1;
2146
2147 proxy_store_name(mworker_proxy);
2148
2149 /* create all servers using the mworker_proc list */
2150 list_for_each_entry(child, &proc_list, list) {
2151 char *msg = NULL;
2152 struct server *newsrv = NULL;
2153 struct sockaddr_storage *sk;
2154 int port1, port2, port;
2155 struct protocol *proto;
2156 char *errmsg;
2157
2158 newsrv = new_server(mworker_proxy);
2159 if (!newsrv)
2160 return -1;
2161
2162 /* we don't know the new pid yet */
2163 if (child->pid == -1)
2164 memprintf(&msg, "cur-%d", child->relative_pid);
2165 else
2166 memprintf(&msg, "old-%d", child->pid);
2167
2168 newsrv->next = mworker_proxy->srv;
2169 mworker_proxy->srv = newsrv;
2170 newsrv->conf.file = strdup(msg);
2171 newsrv->id = strdup(msg);
2172 newsrv->conf.line = 0;
2173
2174 memprintf(&msg, "sockpair@%d", child->ipc_fd[0]);
2175 if ((sk = str2sa_range(msg, &port, &port1, &port2, &errmsg, NULL, NULL, 0)) == 0)
2176 return -1;
2177
2178 proto = protocol_by_family(sk->ss_family);
2179 if (!proto || !proto->connect) {
2180 return -1;
2181 }
2182
2183 /* no port specified */
2184 newsrv->flags |= SRV_F_MAPPORTS;
2185 newsrv->addr = *sk;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002186 /* don't let the server participate to load balancing */
2187 newsrv->iweight = 0;
2188 newsrv->uweight = 0;
William Lallemand8a022572018-10-26 14:47:35 +02002189 srv_lb_commit_status(newsrv);
William Lallemand291810d2018-10-26 14:47:38 +02002190
2191 child->srv = newsrv;
William Lallemand8a022572018-10-26 14:47:35 +02002192 }
2193 return 0;
2194}
Olivier Houchardf886e342017-04-05 22:24:59 +02002195
William Lallemandce83b4a2018-10-26 14:47:30 +02002196/*
William Lallemande7361152018-10-26 14:47:36 +02002197 * Create a new listener for the master CLI proxy
2198 */
2199int mworker_cli_proxy_new_listener(char *line)
2200{
2201 struct bind_conf *bind_conf;
2202 struct listener *l;
2203 char *err = NULL;
2204 char *args[MAX_LINE_ARGS + 1];
2205 int arg;
2206 int cur_arg;
2207
2208 arg = 0;
2209 args[0] = line;
2210
2211 /* args is a bind configuration with spaces replaced by commas */
2212 while (*line && arg < MAX_LINE_ARGS) {
2213
2214 if (*line == ',') {
2215 *line++ = '\0';
2216 while (*line == ',')
2217 line++;
2218 args[++arg] = line;
2219 }
2220 line++;
2221 }
2222
2223 args[++arg] = "\0";
2224
2225 bind_conf = bind_conf_alloc(mworker_proxy, "master-socket", 0, "", xprt_get(XPRT_RAW));
2226
2227 bind_conf->level &= ~ACCESS_LVL_MASK;
2228 bind_conf->level |= ACCESS_LVL_ADMIN;
2229
2230 if (!str2listener(args[0], mworker_proxy, bind_conf, "master-socket", 0, &err)) {
2231 ha_alert("Cannot create the listener of the master CLI\n");
2232 return -1;
2233 }
2234
2235 cur_arg = 1;
2236
2237 while (*args[cur_arg]) {
2238 static int bind_dumped;
2239 struct bind_kw *kw;
2240
2241 kw = bind_find_kw(args[cur_arg]);
2242 if (kw) {
2243 if (!kw->parse) {
2244 memprintf(&err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
2245 args[0], args[1], args[cur_arg]);
2246 goto err;
2247 }
2248
2249 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, &err) != 0) {
2250 if (err)
2251 memprintf(&err, "'%s %s' : '%s'", args[0], args[1], err);
2252 else
2253 memprintf(&err, "'%s %s' : error encountered while processing '%s'",
2254 args[0], args[1], args[cur_arg]);
2255 goto err;
2256 }
2257
2258 cur_arg += 1 + kw->skip;
2259 continue;
2260 }
2261
2262 if (!bind_dumped) {
2263 bind_dump_kws(&err);
2264 indent_msg(&err, 4);
2265 bind_dumped = 1;
2266 }
2267
2268 memprintf(&err, "'%s %s' : unknown keyword '%s'.%s%s",
2269 args[0], args[1], args[cur_arg],
2270 err ? " Registered keywords :" : "", err ? err : "");
2271 goto err;
2272 }
2273
2274
2275 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
2276 l->maxconn = 10;
2277 l->backlog = 10;
2278 l->accept = session_accept_fd;
2279 l->default_target = mworker_proxy->default_target;
2280 /* don't make the peers subject to global limits and don't close it in the master */
2281 l->options |= (LI_O_UNLIMITED|LI_O_MWORKER); /* we are keeping this FD in the master */
2282 l->nice = -64; /* we want to boost priority for local stats */
2283 global.maxsock += l->maxconn;
2284 }
2285
2286 return 0;
2287
2288err:
2289 ha_alert("%s\n", err);
2290 return -1;
2291
2292}
2293
2294/*
William Lallemandce83b4a2018-10-26 14:47:30 +02002295 * Create a new CLI socket using a socketpair for a worker process
2296 * <mworker_proc> is the process structure, and <proc> is the process number
2297 */
2298int mworker_cli_sockpair_new(struct mworker_proc *mworker_proc, int proc)
2299{
2300 struct bind_conf *bind_conf;
2301 struct listener *l;
2302 char *path = NULL;
2303 char *err = NULL;
2304
2305 /* master pipe to ensure the master is still alive */
2306 if (socketpair(AF_UNIX, SOCK_STREAM, 0, mworker_proc->ipc_fd) < 0) {
2307 ha_alert("Cannot create worker socketpair.\n");
2308 return -1;
2309 }
2310
2311 /* XXX: we might want to use a separate frontend at some point */
2312 if (!global.stats_fe) {
2313 if ((global.stats_fe = alloc_stats_fe("GLOBAL", "master-socket", 0)) == NULL) {
2314 ha_alert("out of memory trying to allocate the stats frontend");
2315 return -1;
2316 }
2317 }
2318
2319 bind_conf = bind_conf_alloc(global.stats_fe, "master-socket", 0, "", xprt_get(XPRT_RAW));
2320 bind_conf->level &= ~ACCESS_LVL_MASK;
2321 bind_conf->level |= ACCESS_LVL_ADMIN; /* TODO: need to lower the rights with a CLI keyword*/
2322
2323 bind_conf->bind_proc = 1UL << proc;
2324 global.stats_fe->bind_proc = 0; /* XXX: we should be careful with that, it can be removed by configuration */
2325
2326 if (!memprintf(&path, "sockpair@%d", mworker_proc->ipc_fd[1])) {
2327 ha_alert("Cannot allocate listener.\n");
2328 return -1;
2329 }
2330
2331 if (!str2listener(path, global.stats_fe, bind_conf, "master-socket", 0, &err)) {
2332 ha_alert("Cannot create a CLI sockpair listener for process #%d\n", proc);
2333 return -1;
2334 }
2335
2336 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
2337 l->maxconn = global.stats_fe->maxconn;
2338 l->backlog = global.stats_fe->backlog;
2339 l->accept = session_accept_fd;
2340 l->default_target = global.stats_fe->default_target;
William Lallemanda3372292018-11-16 16:57:22 +01002341 l->options |= (LI_O_UNLIMITED | LI_O_NOSTOP);
William Lallemandce83b4a2018-10-26 14:47:30 +02002342 /* it's a sockpair but we don't want to keep the fd in the master */
2343 l->options &= ~LI_O_INHERITED;
2344 l->nice = -64; /* we want to boost priority for local stats */
2345 global.maxsock += l->maxconn;
2346 }
2347
2348 return 0;
2349}
2350
William Lallemand74c24fb2016-11-21 17:18:36 +01002351static struct applet cli_applet = {
2352 .obj_type = OBJ_TYPE_APPLET,
2353 .name = "<CLI>", /* used for logging */
2354 .fct = cli_io_handler,
2355 .release = cli_release_handler,
2356};
2357
Willy Tarreau0a739292016-11-22 20:21:23 +01002358/* register cli keywords */
2359static struct cli_kw_list cli_kws = {{ },{
William Lallemand4e8450b2018-10-26 14:47:43 +02002360 { { "@<relative pid>", NULL }, "@<relative pid> : send a command to the <relative pid> process", NULL, cli_io_handler_show_proc, NULL, NULL, ACCESS_MASTER_ONLY},
2361 { { "@!<pid>", NULL }, "@!<pid> : send a command to the <pid> process", cli_parse_default, NULL, NULL, NULL, ACCESS_MASTER_ONLY},
2362 { { "@master", NULL }, "@master : send a command to the master process", cli_parse_default, NULL, NULL, NULL, ACCESS_MASTER_ONLY},
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002363 { { "help", NULL }, NULL, cli_parse_simple, NULL },
2364 { { "prompt", NULL }, NULL, cli_parse_simple, NULL },
2365 { { "quit", NULL }, NULL, cli_parse_simple, NULL },
Willy Tarreau2af99412016-11-23 11:10:59 +01002366 { { "set", "maxconn", "global", NULL }, "set maxconn global : change the per-process maxconn setting", cli_parse_set_maxconn_global, NULL },
Willy Tarreau45c742b2016-11-24 14:51:17 +01002367 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002368 { { "set", "severity-output", NULL }, "set severity-output [none|number|string] : set presence of severity level in feedback information", cli_parse_set_severity_output, NULL, NULL },
Willy Tarreau599852e2016-11-22 20:33:32 +01002369 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002370 { { "show", "env", NULL }, "show env [var] : dump environment variables known to the process", cli_parse_show_env, cli_io_handler_show_env, NULL },
William Lallemand35851fb2018-10-26 14:47:42 +02002371 { { "show", "cli", "sockets", NULL }, "show cli sockets : dump list of cli sockets", cli_parse_default, cli_io_handler_show_cli_sock, NULL, NULL, ACCESS_MASTER },
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02002372 { { "show", "fd", NULL }, "show fd [num] : dump list of file descriptors in use", cli_parse_show_fd, cli_io_handler_show_fd, NULL },
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01002373 { { "show", "activity", NULL }, "show activity : show per-thread activity stats (for support/developers)", cli_parse_default, cli_io_handler_show_activity, NULL },
William Lallemandb9f9e3b2018-10-26 14:47:39 +02002374 { { "show", "proc", NULL }, "show proc : show processes status", cli_parse_default, cli_io_handler_show_proc, NULL, NULL, ACCESS_MASTER_ONLY},
Olivier Houchardf886e342017-04-05 22:24:59 +02002375 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002376 {{},}
2377}};
2378
William Lallemand74c24fb2016-11-21 17:18:36 +01002379static struct cfg_kw_list cfg_kws = {ILH, {
2380 { CFG_GLOBAL, "stats", stats_parse_global },
2381 { 0, NULL, NULL },
2382}};
2383
2384static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02002385 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
2386 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002387 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01002388 { NULL, NULL, 0 },
2389}};
2390
2391__attribute__((constructor))
2392static void __dumpstats_module_init(void)
2393{
2394 cfg_register_keywords(&cfg_kws);
Willy Tarreau0a739292016-11-22 20:21:23 +01002395 cli_register_kw(&cli_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01002396 bind_register_keywords(&bind_kws);
2397}
2398
2399/*
2400 * Local variables:
2401 * c-indent-level: 8
2402 * c-basic-offset: 8
2403 * End:
2404 */