blob: 0ec8dc85e67a174ce4f1b4e163ffe221a832fbe2 [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
Willy Tarreau609aad92018-11-22 08:31:09 +010048#include <proto/activity.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010049#include <proto/backend.h>
50#include <proto/channel.h>
51#include <proto/checks.h>
52#include <proto/compression.h>
William Lallemand9ed62032016-11-21 17:49:11 +010053#include <proto/stats.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010054#include <proto/fd.h>
55#include <proto/freq_ctr.h>
56#include <proto/frontend.h>
57#include <proto/log.h>
58#include <proto/pattern.h>
59#include <proto/pipe.h>
William Lallemandce83b4a2018-10-26 14:47:30 +020060#include <proto/protocol.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010061#include <proto/listener.h>
62#include <proto/map.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010063#include <proto/proxy.h>
64#include <proto/sample.h>
65#include <proto/session.h>
66#include <proto/stream.h>
67#include <proto/server.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010068#include <proto/stream_interface.h>
69#include <proto/task.h>
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +020070#include <proto/proto_udp.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010071
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020072#define PAYLOAD_PATTERN "<<"
73
William Lallemand74c24fb2016-11-21 17:18:36 +010074static struct applet cli_applet;
75
76static const char stats_sock_usage_msg[] =
77 "Unknown command. Please enter one of the following commands only :\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010078 " help : this message\n"
79 " prompt : toggle interactive mode with prompt\n"
80 " quit : disconnect\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010081 "";
82
83static const char stats_permission_denied_msg[] =
84 "Permission denied\n"
85 "";
86
87
Christopher Faulet1bc04c72017-10-29 20:14:08 +010088static THREAD_LOCAL char *dynamic_usage_msg = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +010089
90/* List head of cli keywords */
91static struct cli_kw_list cli_keywords = {
92 .list = LIST_HEAD_INIT(cli_keywords.list)
93};
94
95extern const char *stat_status_codes[];
96
William Lallemand14721be2018-10-26 14:47:37 +020097extern int master;
98
William Lallemand8a022572018-10-26 14:47:35 +020099static struct proxy *mworker_proxy; /* CLI proxy of the master */
100
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200101static char *cli_gen_usage_msg(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100102{
103 struct cli_kw_list *kw_list;
104 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +0200105 struct buffer *tmp = get_trash_chunk();
106 struct buffer out;
William Lallemand74c24fb2016-11-21 17:18:36 +0100107
108 free(dynamic_usage_msg);
109 dynamic_usage_msg = NULL;
110
111 if (LIST_ISEMPTY(&cli_keywords.list))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200112 goto end;
William Lallemand74c24fb2016-11-21 17:18:36 +0100113
114 chunk_reset(tmp);
115 chunk_strcat(tmp, stats_sock_usage_msg);
116 list_for_each_entry(kw_list, &cli_keywords.list, list) {
117 kw = &kw_list->kw[0];
William Lallemand0154edc2018-05-15 11:50:04 +0200118 while (kw->str_kw[0]) {
William Lallemand14721be2018-10-26 14:47:37 +0200119
120 /* in a worker or normal process, don't display master only commands */
121 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
122 goto next_kw;
123
124 /* in master don't displays if we don't have the master bits */
125 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
126 goto next_kw;
127
William Lallemand0154edc2018-05-15 11:50:04 +0200128 if (kw->usage)
129 chunk_appendf(tmp, " %s\n", kw->usage);
William Lallemand14721be2018-10-26 14:47:37 +0200130
131next_kw:
132
William Lallemand74c24fb2016-11-21 17:18:36 +0100133 kw++;
134 }
135 }
136 chunk_init(&out, NULL, 0);
137 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200138 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200139
140end:
141 if (dynamic_usage_msg) {
142 appctx->ctx.cli.severity = LOG_INFO;
143 appctx->ctx.cli.msg = dynamic_usage_msg;
144 }
145 else {
146 appctx->ctx.cli.severity = LOG_INFO;
147 appctx->ctx.cli.msg = stats_sock_usage_msg;
148 }
149 appctx->st0 = CLI_ST_PRINT;
150
William Lallemand74c24fb2016-11-21 17:18:36 +0100151 return dynamic_usage_msg;
152}
153
154struct cli_kw* cli_find_kw(char **args)
155{
156 struct cli_kw_list *kw_list;
157 struct cli_kw *kw;/* current cli_kw */
158 char **tmp_args;
159 const char **tmp_str_kw;
160 int found = 0;
161
162 if (LIST_ISEMPTY(&cli_keywords.list))
163 return NULL;
164
165 list_for_each_entry(kw_list, &cli_keywords.list, list) {
166 kw = &kw_list->kw[0];
167 while (*kw->str_kw) {
168 tmp_args = args;
169 tmp_str_kw = kw->str_kw;
170 while (*tmp_str_kw) {
171 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
172 found = 1;
173 } else {
174 found = 0;
175 break;
176 }
177 tmp_args++;
178 tmp_str_kw++;
179 }
180 if (found)
181 return (kw);
182 kw++;
183 }
184 }
185 return NULL;
186}
187
188void cli_register_kw(struct cli_kw_list *kw_list)
189{
190 LIST_ADDQ(&cli_keywords.list, &kw_list->list);
191}
192
193
194/* allocate a new stats frontend named <name>, and return it
195 * (or NULL in case of lack of memory).
196 */
197static struct proxy *alloc_stats_fe(const char *name, const char *file, int line)
198{
199 struct proxy *fe;
200
201 fe = calloc(1, sizeof(*fe));
202 if (!fe)
203 return NULL;
204
205 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100206 fe->next = proxies_list;
207 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100208 fe->last_change = now.tv_sec;
209 fe->id = strdup("GLOBAL");
210 fe->cap = PR_CAP_FE;
211 fe->maxconn = 10; /* default to 10 concurrent connections */
212 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
213 fe->conf.file = strdup(file);
214 fe->conf.line = line;
215 fe->accept = frontend_accept;
216 fe->default_target = &cli_applet.obj_type;
217
218 /* the stats frontend is the only one able to assign ID #0 */
219 fe->conf.id.key = fe->uuid = 0;
220 eb32_insert(&used_proxy_id, &fe->conf.id);
221 return fe;
222}
223
224/* This function parses a "stats" statement in the "global" section. It returns
225 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
226 * error message into the <err> buffer which will be preallocated. The trailing
227 * '\n' must not be written. The function must be called with <args> pointing to
228 * the first word after "stats".
229 */
230static int stats_parse_global(char **args, int section_type, struct proxy *curpx,
231 struct proxy *defpx, const char *file, int line,
232 char **err)
233{
234 struct bind_conf *bind_conf;
235 struct listener *l;
236
237 if (!strcmp(args[1], "socket")) {
238 int cur_arg;
239
240 if (*args[2] == 0) {
241 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
242 return -1;
243 }
244
245 if (!global.stats_fe) {
246 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
247 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
248 return -1;
249 }
250 }
251
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100252 bind_conf = bind_conf_alloc(global.stats_fe, file, line, args[2], xprt_get(XPRT_RAW));
William Lallemand07a62f72017-05-24 00:57:40 +0200253 bind_conf->level &= ~ACCESS_LVL_MASK;
254 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100255
256 if (!str2listener(args[2], global.stats_fe, bind_conf, file, line, err)) {
257 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
258 file, line, args[0], args[1], err && *err ? *err : "error");
259 return -1;
260 }
261
262 cur_arg = 3;
263 while (*args[cur_arg]) {
264 static int bind_dumped;
265 struct bind_kw *kw;
266
267 kw = bind_find_kw(args[cur_arg]);
268 if (kw) {
269 if (!kw->parse) {
270 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
271 args[0], args[1], args[cur_arg]);
272 return -1;
273 }
274
275 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, err) != 0) {
276 if (err && *err)
277 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
278 else
279 memprintf(err, "'%s %s' : error encountered while processing '%s'",
280 args[0], args[1], args[cur_arg]);
281 return -1;
282 }
283
284 cur_arg += 1 + kw->skip;
285 continue;
286 }
287
288 if (!bind_dumped) {
289 bind_dump_kws(err);
290 indent_msg(err, 4);
291 bind_dumped = 1;
292 }
293
294 memprintf(err, "'%s %s' : unknown keyword '%s'.%s%s",
295 args[0], args[1], args[cur_arg],
296 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
297 return -1;
298 }
299
300 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
301 l->maxconn = global.stats_fe->maxconn;
302 l->backlog = global.stats_fe->backlog;
303 l->accept = session_accept_fd;
William Lallemand74c24fb2016-11-21 17:18:36 +0100304 l->default_target = global.stats_fe->default_target;
305 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
306 l->nice = -64; /* we want to boost priority for local stats */
307 global.maxsock += l->maxconn;
308 }
309 }
310 else if (!strcmp(args[1], "timeout")) {
311 unsigned timeout;
312 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
313
314 if (res) {
315 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
316 return -1;
317 }
318
319 if (!timeout) {
320 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
321 return -1;
322 }
323 if (!global.stats_fe) {
324 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
325 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
326 return -1;
327 }
328 }
329 global.stats_fe->timeout.client = MS_TO_TICKS(timeout);
330 }
331 else if (!strcmp(args[1], "maxconn")) {
332 int maxconn = atol(args[2]);
333
334 if (maxconn <= 0) {
335 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
336 return -1;
337 }
338
339 if (!global.stats_fe) {
340 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
341 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
342 return -1;
343 }
344 }
345 global.stats_fe->maxconn = maxconn;
346 }
347 else if (!strcmp(args[1], "bind-process")) { /* enable the socket only on some processes */
348 int cur_arg = 2;
349 unsigned long set = 0;
350
351 if (!global.stats_fe) {
352 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
353 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
354 return -1;
355 }
356 }
357
358 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100359 if (strcmp(args[cur_arg], "all") == 0) {
360 set = 0;
361 break;
362 }
Christopher Faulet26028f62017-11-22 15:01:51 +0100363 if (parse_process_number(args[cur_arg], &set, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100364 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100365 return -1;
366 }
367 cur_arg++;
368 }
369 global.stats_fe->bind_proc = set;
370 }
371 else {
372 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
373 return -1;
374 }
375 return 0;
376}
377
Willy Tarreaude57a572016-11-23 17:01:39 +0100378/* Verifies that the CLI at least has a level at least as high as <level>
379 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
380 * failure, an error message is prepared and the appctx's state is adjusted
381 * to print it so that a return 1 is enough to abort any processing.
382 */
383int cli_has_level(struct appctx *appctx, int level)
384{
385 struct stream_interface *si = appctx->owner;
386 struct stream *s = si_strm(si);
387
William Lallemand07a62f72017-05-24 00:57:40 +0200388 if ((strm_li(s)->bind_conf->level & ACCESS_LVL_MASK) < level) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200389 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreaude57a572016-11-23 17:01:39 +0100390 appctx->ctx.cli.msg = stats_permission_denied_msg;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100391 appctx->st0 = CLI_ST_PRINT;
Willy Tarreaude57a572016-11-23 17:01:39 +0100392 return 0;
393 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100394 return 1;
395}
396
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200397/* Returns severity_output for the current session if set, or default for the socket */
398static int cli_get_severity_output(struct appctx *appctx)
399{
400 if (appctx->cli_severity_output)
401 return appctx->cli_severity_output;
402 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
403}
William Lallemand74c24fb2016-11-21 17:18:36 +0100404
Willy Tarreau41908562016-11-24 16:23:38 +0100405/* Processes the CLI interpreter on the stats socket. This function is called
406 * from the CLI's IO handler running in an appctx context. The function returns 1
407 * if the request was understood, otherwise zero. It is called with appctx->st0
408 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
409 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
410 * have its own I/O handler called again. Most of the time, parsers will only
411 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100412 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
413 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100414 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200415static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100416{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200417 char *args[MAX_STATS_ARGS + 1], *p, *end, *payload = NULL;
418 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100419 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100420
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200421 appctx->st2 = 0;
422 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
William Lallemand74c24fb2016-11-21 17:18:36 +0100423
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200424 p = appctx->chunk->area;
425 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100426
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200427 /*
428 * Get the payload start if there is one.
429 * For the sake of simplicity, the payload pattern is looked up
430 * everywhere from the start of the input but it can only be found
431 * at the end of the first line if APPCTX_CLI_ST1_PAYLOAD is set.
432 *
433 * The input string was zero terminated so it is safe to use
434 * the str*() functions throughout the parsing
435 */
436 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
437 payload = strstr(p, PAYLOAD_PATTERN);
438 end = payload;
439 /* skip the pattern */
440 payload += strlen(PAYLOAD_PATTERN);
441 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100442
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200443 /*
444 * Get pointers on words.
445 * One extra slot is reserved to store a pointer on a null byte.
446 */
447 while (i < MAX_STATS_ARGS && p < end) {
448 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100449
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200450 /* skip leading spaces/tabs */
451 p += strspn(p, " \t");
452 if (!*p)
453 break;
William Lallemand74c24fb2016-11-21 17:18:36 +0100454
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200455 args[i] = p;
456 p += strcspn(p, " \t");
457 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100458
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200459 /* unescape backslashes (\) */
460 for (j = 0, k = 0; args[i][k]; k++) {
461 if (args[i][k] == '\\') {
462 if (args[i][k + 1] == '\\')
463 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100464 else
465 continue;
466 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200467 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100468 j++;
469 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200470 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100471
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200472 i++;
473 }
474 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200475 p = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200476 for (; i < MAX_STATS_ARGS + 1; i++)
477 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100478
479 kw = cli_find_kw(args);
Willy Tarreaueaffde32016-12-16 17:59:25 +0100480 if (!kw)
Willy Tarreau41908562016-11-24 16:23:38 +0100481 return 0;
482
William Lallemand14721be2018-10-26 14:47:37 +0200483 /* in a worker or normal process, don't display master only commands */
484 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
485 return 0;
486
487 /* in master don't displays if we don't have the master bits */
488 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
489 return 0;
490
Willy Tarreau41908562016-11-24 16:23:38 +0100491 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200492 appctx->io_release = kw->io_release;
493 /* kw->parse could set its own io_handler or ip_release handler */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200494 if ((!kw->parse || kw->parse(args, payload, appctx, kw->private) == 0) && appctx->io_handler) {
Willy Tarreau41908562016-11-24 16:23:38 +0100495 appctx->st0 = CLI_ST_CALLBACK;
William Lallemand74c24fb2016-11-21 17:18:36 +0100496 }
Willy Tarreau41908562016-11-24 16:23:38 +0100497 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100498}
499
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200500/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
501static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
502{
Willy Tarreau83061a82018-07-13 11:56:34 +0200503 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200504
505 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200506 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200507
508 tmp = get_trash_chunk();
509 chunk_reset(tmp);
510
511 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100512 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200513 chunk_printf(tmp, "[%d]: ", severity);
514 }
515 else {
516 switch (severity_output) {
517 case CLI_SEVERITY_NUMBER:
518 chunk_printf(tmp, "[%d]: ", severity);
519 break;
520 case CLI_SEVERITY_STRING:
521 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
522 break;
523 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100524 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200525 }
526 }
527 chunk_appendf(tmp, "%s", msg);
528
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200529 return ci_putblk(chn, tmp->area, strlen(tmp->area));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200530}
531
William Lallemand74c24fb2016-11-21 17:18:36 +0100532/* This I/O handler runs as an applet embedded in a stream interface. It is
533 * used to processes I/O from/to the stats unix socket. The system relies on a
534 * state machine handling requests and various responses. We read a request,
535 * then we process it and send the response, and we possibly display a prompt.
536 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100537 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100538 * or not.
539 */
540static void cli_io_handler(struct appctx *appctx)
541{
542 struct stream_interface *si = appctx->owner;
543 struct channel *req = si_oc(si);
544 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200545 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100546 int reql;
547 int len;
548
549 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
550 goto out;
551
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100552 /* Check if the input buffer is avalaible. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200553 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +0100554 /* buf.size==0 means we failed to get a buffer and were
555 * already subscribed to a wait list to get a buffer.
556 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100557 goto out;
558 }
559
William Lallemand74c24fb2016-11-21 17:18:36 +0100560 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100561 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100562 /* Stats output not initialized yet */
563 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200564 /* reset severity to default at init */
565 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100566 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100567 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100568 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100569 /* Let's close for real now. We just close the request
570 * side, the conditions below will complete if needed.
571 */
572 si_shutw(si);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200573 free_trash_chunk(appctx->chunk);
William Lallemand74c24fb2016-11-21 17:18:36 +0100574 break;
575 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100576 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200577 char *str;
578
579 /* use a trash chunk to store received data */
580 if (!appctx->chunk) {
581 appctx->chunk = alloc_trash_chunk();
582 if (!appctx->chunk) {
583 appctx->st0 = CLI_ST_END;
584 continue;
585 }
586 }
587
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200588 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200589
William Lallemand74c24fb2016-11-21 17:18:36 +0100590 /* ensure we have some output room left in the event we
591 * would want to return some info right after parsing.
592 */
593 if (buffer_almost_full(si_ib(si))) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100594 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100595 break;
596 }
597
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200598 /* '- 1' is to ensure a null byte can always be inserted at the end */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200599 reql = co_getline(si_oc(si), str,
600 appctx->chunk->size - appctx->chunk->data - 1);
William Lallemand74c24fb2016-11-21 17:18:36 +0100601 if (reql <= 0) { /* closed or EOL not found */
602 if (reql == 0)
603 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100604 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100605 continue;
606 }
607
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200608 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
609 /* seek for a possible unescaped semi-colon. If we find
610 * one, we replace it with an LF and skip only this part.
611 */
612 for (len = 0; len < reql; len++) {
613 if (str[len] == '\\') {
614 len++;
615 continue;
616 }
617 if (str[len] == ';') {
618 str[len] = '\n';
619 reql = len + 1;
620 break;
621 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100622 }
623 }
624
625 /* now it is time to check that we have a full line,
626 * remove the trailing \n and possibly \r, then cut the
627 * line.
628 */
629 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200630 if (str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100631 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100632 continue;
633 }
634
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200635 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100636 len--;
637
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200638 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200639 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200640
641 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200642 appctx->chunk->area[appctx->chunk->data] = '\n';
643 appctx->chunk->area[appctx->chunk->data + 1] = 0;
644 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200645 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100646
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100647 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200648
649 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
650 /* empty line */
651 if (!len) {
652 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200653 appctx->chunk->data -= 2;
654 appctx->chunk->area[appctx->chunk->data] = 0;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200655
656 if (!cli_parse_request(appctx))
657 cli_gen_usage_msg(appctx);
658
659 chunk_reset(appctx->chunk);
660 /* NB: cli_sock_parse_request() may have put
661 * another CLI_ST_O_* into appctx->st0.
662 */
663
664 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +0100665 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100666 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200667 else {
668 /*
669 * Look for the "payload start" pattern at the end of a line
670 * Its location is not remembered here, this is just to switch
671 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +0100672 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200673 if (!strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200674 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200675 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200676 /* no payload, the command is complete: parse the request */
677 if (!cli_parse_request(appctx))
678 cli_gen_usage_msg(appctx);
679
680 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200681 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100682 }
683
684 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200685 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100686 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
687 }
688 else { /* output functions */
689 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100690 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100691 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100692 case CLI_ST_PRINT:
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200693 if (cli_output_msg(res, appctx->ctx.cli.msg, appctx->ctx.cli.severity,
694 cli_get_severity_output(appctx)) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100695 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100696 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100697 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100698 break;
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200699 case CLI_ST_PRINT_FREE: {
700 const char *msg = appctx->ctx.cli.err;
701
702 if (!msg)
703 msg = "Out of memory.\n";
704
705 if (cli_output_msg(res, msg, LOG_ERR, cli_get_severity_output(appctx)) != -1) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100706 free(appctx->ctx.cli.err);
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100707 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100708 }
709 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100710 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100711 break;
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200712 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100713 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100714 if (appctx->io_handler)
715 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100716 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100717 if (appctx->io_release) {
718 appctx->io_release(appctx);
719 appctx->io_release = NULL;
720 }
721 }
722 break;
723 default: /* abnormal state */
724 si->flags |= SI_FL_ERR;
725 break;
726 }
727
728 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100729 if (appctx->st0 == CLI_ST_PROMPT) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200730 const char *prompt = "";
731
732 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
733 /*
734 * when entering a payload with interactive mode, change the prompt
735 * to emphasize that more data can still be sent
736 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200737 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200738 prompt = "+ ";
739 else
740 prompt = "\n> ";
741 }
742 else {
743 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD))
744 prompt = "\n";
745 }
746
747 if (ci_putstr(si_ic(si), prompt) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100748 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100749 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100750 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100751 }
752
753 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100754 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100755 break;
756
757 /* Now we close the output if one of the writers did so,
758 * or if we're not in interactive mode and the request
759 * buffer is empty. This still allows pipelined requests
760 * to be sent in non-interactive mode.
761 */
Willy Tarreau851d12c2018-06-19 07:01:36 +0200762 if ((res->flags & (CF_SHUTW|CF_SHUTW_NOW)) || (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req))) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100763 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100764 continue;
765 }
766
767 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100768 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100769 }
770 }
771
772 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
773 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
774 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
775 /* Other side has closed, let's abort if we have no more processing to do
776 * and nothing more to consume. This is comparable to a broken pipe, so
777 * we forward the close to the request side so that it flows upstream to
778 * the client.
779 */
780 si_shutw(si);
781 }
782
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100783 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100784 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
785 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
786 /* We have no more processing to do, and nothing more to send, and
787 * the client side has closed. So we'll forward this state downstream
788 * on the response buffer.
789 */
790 si_shutr(si);
791 res->flags |= CF_READ_NULL;
792 }
793
794 out:
Christopher Faulet45073512018-07-20 10:16:29 +0200795 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 +0100796 __FUNCTION__, __LINE__,
Christopher Faulet45073512018-07-20 10:16:29 +0200797 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 +0100798}
799
William Lallemand74c24fb2016-11-21 17:18:36 +0100800/* This is called when the stream interface is closed. For instance, upon an
801 * external abort, we won't call the i/o handler anymore so we may need to
802 * remove back references to the stream currently being dumped.
803 */
804static void cli_release_handler(struct appctx *appctx)
805{
806 if (appctx->io_release) {
807 appctx->io_release(appctx);
808 appctx->io_release = NULL;
809 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100810 else if (appctx->st0 == CLI_ST_PRINT_FREE) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100811 free(appctx->ctx.cli.err);
812 appctx->ctx.cli.err = NULL;
813 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100814}
815
816/* This function dumps all environmnent variables to the buffer. It returns 0
817 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +0100818 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
819 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +0100820 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100821static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100822{
Willy Tarreau0a739292016-11-22 20:21:23 +0100823 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100824 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100825
826 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
827 return 1;
828
829 chunk_reset(&trash);
830
831 /* we have two inner loops here, one for the proxy, the other one for
832 * the buffer.
833 */
Willy Tarreauf6710f82016-12-16 17:45:44 +0100834 while (*var) {
835 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +0100836
Willy Tarreau06d80a92017-10-19 14:32:15 +0200837 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100838 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100839 return 0;
840 }
841 if (appctx->st2 == STAT_ST_END)
842 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100843 var++;
844 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +0100845 }
846
847 /* dump complete */
848 return 1;
849}
850
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200851/* This function dumps all file descriptors states (or the requested one) to
852 * the buffer. It returns 0 if the output buffer is full and it needs to be
853 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
854 * It uses cli.i0 as the fd number to restart from.
855 */
856static int cli_io_handler_show_fd(struct appctx *appctx)
857{
858 struct stream_interface *si = appctx->owner;
859 int fd = appctx->ctx.cli.i0;
860
861 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
862 return 1;
863
864 chunk_reset(&trash);
865
866 /* we have two inner loops here, one for the proxy, the other one for
867 * the buffer.
868 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +0100869 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200870 struct fdtab fdt;
Willy Tarreau286ec682017-08-09 16:35:44 +0200871 struct listener *li = NULL;
872 struct server *sv = NULL;
873 struct proxy *px = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +0200874 const struct mux_ops *mux = NULL;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200875 void *ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +0200876 uint32_t conn_flags = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200877
Willy Tarreaubf9fd652018-08-02 11:05:48 +0200878 thread_isolate();
879
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200880 fdt = fdtab[fd];
881
Willy Tarreaubf9fd652018-08-02 11:05:48 +0200882 if (!fdt.owner) {
883 thread_release();
Willy Tarreau017af242017-10-04 20:24:54 +0200884 goto skip; // closed
Willy Tarreaubf9fd652018-08-02 11:05:48 +0200885 }
Willy Tarreau017af242017-10-04 20:24:54 +0200886
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200887 if (fdt.iocb == conn_fd_handler) {
888 conn_flags = ((struct connection *)fdt.owner)->flags;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200889 mux = ((struct connection *)fdt.owner)->mux;
890 ctx = ((struct connection *)fdt.owner)->mux_ctx;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200891 li = objt_listener(((struct connection *)fdt.owner)->target);
892 sv = objt_server(((struct connection *)fdt.owner)->target);
893 px = objt_proxy(((struct connection *)fdt.owner)->target);
894 }
895 else if (fdt.iocb == listener_accept)
896 li = fdt.owner;
897
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200898 chunk_printf(&trash,
Willy Tarreauc754b342018-03-30 15:00:15 +0200899 " %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 +0200900 fd,
901 fdt.state,
902 (fdt.state & FD_EV_POLLED_R) ? 'P' : 'p',
903 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
904 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
905 (fdt.state & FD_EV_POLLED_W) ? 'P' : 'p',
906 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
907 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
908 fdt.ev,
909 (fdt.ev & FD_POLL_HUP) ? 'H' : 'h',
910 (fdt.ev & FD_POLL_ERR) ? 'E' : 'e',
911 (fdt.ev & FD_POLL_OUT) ? 'O' : 'o',
912 (fdt.ev & FD_POLL_PRI) ? 'P' : 'p',
913 (fdt.ev & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200914 fdt.linger_risk ? 'L' : 'l',
915 fdt.cloned ? 'C' : 'c',
Willy Tarreauc754b342018-03-30 15:00:15 +0200916 fdt.cache.next,
917 fdt.cache.prev,
918 fdt.thread_mask, fdt.update_mask,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200919 fdt.owner,
920 fdt.iocb,
921 (fdt.iocb == conn_fd_handler) ? "conn_fd_handler" :
922 (fdt.iocb == dgram_fd_handler) ? "dgram_fd_handler" :
923 (fdt.iocb == listener_accept) ? "listener_accept" :
Olivier Houchard79321b92018-07-26 17:55:11 +0200924 (fdt.iocb == poller_pipe_io_handler) ? "poller_pipe_io_handler" :
William Lallemanddb6bdfb2018-11-20 17:36:51 +0100925 (fdt.iocb == mworker_accept_wrapper) ? "mworker_accept_wrapper" :
Willy Tarreauc754b342018-03-30 15:00:15 +0200926 "unknown");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200927
928 if (fdt.iocb == conn_fd_handler) {
929 chunk_appendf(&trash, " cflg=0x%08x", conn_flags);
930 if (px)
931 chunk_appendf(&trash, " px=%s", px->id);
932 else if (sv)
933 chunk_appendf(&trash, " sv=%s/%s", sv->id, sv->proxy->id);
934 else if (li)
935 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +0200936
Willy Tarreaub011d8f2018-03-30 14:41:19 +0200937 if (mux) {
Willy Tarreau35b1b482018-03-28 18:41:30 +0200938 chunk_appendf(&trash, " mux=%s mux_ctx=%p", mux->name, ctx);
Willy Tarreaub011d8f2018-03-30 14:41:19 +0200939 if (mux->show_fd)
940 mux->show_fd(&trash, fdt.owner);
941 }
Willy Tarreau35b1b482018-03-28 18:41:30 +0200942 else
943 chunk_appendf(&trash, " nomux");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200944 }
945 else if (fdt.iocb == listener_accept) {
946 chunk_appendf(&trash, " l.st=%s fe=%s",
947 listener_state_str(li),
948 li->bind_conf->frontend->id);
949 }
950
Willy Tarreaubf9fd652018-08-02 11:05:48 +0200951 thread_release();
952
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200953 chunk_appendf(&trash, "\n");
954
Willy Tarreau06d80a92017-10-19 14:32:15 +0200955 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100956 si_rx_room_blk(si);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200957 return 0;
958 }
959 skip:
960 if (appctx->st2 == STAT_ST_END)
961 break;
962
963 fd++;
964 appctx->ctx.cli.i0 = fd;
965 }
966
967 /* dump complete */
968 return 1;
969}
970
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100971/* This function dumps some activity counters used by developers and support to
972 * rule out some hypothesis during bug reports. It returns 0 if the output
973 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
974 * everything at once in the buffer and is not designed to do it in multiple
975 * passes.
976 */
977static int cli_io_handler_show_activity(struct appctx *appctx)
978{
979 struct stream_interface *si = appctx->owner;
980 int thr;
981
982 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
983 return 1;
984
985 chunk_reset(&trash);
986
987 chunk_appendf(&trash, "thread_id: %u", tid);
988 chunk_appendf(&trash, "\ndate_now: %lu.%06lu", (long)now.tv_sec, (long)now.tv_usec);
989 chunk_appendf(&trash, "\nloops:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].loops);
990 chunk_appendf(&trash, "\nwake_cache:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_cache);
991 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 +0100992 chunk_appendf(&trash, "\nwake_signal:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_signal);
993 chunk_appendf(&trash, "\npoll_exp:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_exp);
994 chunk_appendf(&trash, "\npoll_drop:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_drop);
995 chunk_appendf(&trash, "\npoll_dead:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_dead);
996 chunk_appendf(&trash, "\npoll_skip:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_skip);
997 chunk_appendf(&trash, "\nfd_skip:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_skip);
998 chunk_appendf(&trash, "\nfd_lock:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_lock);
999 chunk_appendf(&trash, "\nfd_del:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_del);
1000 chunk_appendf(&trash, "\nconn_dead:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].conn_dead);
1001 chunk_appendf(&trash, "\nstream:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].stream);
1002 chunk_appendf(&trash, "\nempty_rq:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].empty_rq);
1003 chunk_appendf(&trash, "\nlong_rq:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].long_rq);
Willy Tarreau4f93e0c2018-11-22 16:13:17 +01001004 chunk_appendf(&trash, "\ncpust_ms_tot:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].cpust_total/2);
1005 chunk_appendf(&trash, "\ncpust_ms_1s:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", read_freq_ctr(&activity[thr].cpust_1s)/2);
1006 chunk_appendf(&trash, "\ncpust_ms_15s:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", read_freq_ctr_period(&activity[thr].cpust_15s, 15000)/2);
Willy Tarreaubaba82f2018-11-22 08:42:42 +01001007 chunk_appendf(&trash, "\navg_loop_us:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", swrate_avg(activity[thr].avg_loop_us, TIME_STATS_SAMPLES));
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001008
1009 chunk_appendf(&trash, "\n");
1010
1011 if (ci_putchk(si_ic(si), &trash) == -1) {
1012 chunk_reset(&trash);
1013 chunk_printf(&trash, "[output too large, cannot dump]\n");
Willy Tarreaudb398432018-11-15 11:08:52 +01001014 si_rx_room_blk(si);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001015 }
1016
1017 /* dump complete */
1018 return 1;
1019}
1020
William Lallemandeceddf72016-12-15 18:06:44 +01001021/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001022 * CLI IO handler for `show cli sockets`.
1023 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +01001024 */
1025static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1026{
1027 struct bind_conf *bind_conf;
1028 struct stream_interface *si = appctx->owner;
1029
1030 chunk_reset(&trash);
1031
1032 switch (appctx->st2) {
1033 case STAT_ST_INIT:
1034 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +02001035 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001036 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001037 return 0;
1038 }
William Lallemandeceddf72016-12-15 18:06:44 +01001039 appctx->st2 = STAT_ST_LIST;
1040
1041 case STAT_ST_LIST:
1042 if (global.stats_fe) {
1043 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
1044 struct listener *l;
1045
1046 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001047 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +01001048 * if the current node is the first of the list
1049 */
1050
Willy Tarreau3af9d832016-12-16 12:58:09 +01001051 if (appctx->ctx.cli.p0 &&
1052 &bind_conf->by_fe == (&global.stats_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +01001053 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +01001054 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +01001055 continue;
1056 }
1057
1058 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
1059
1060 char addr[46];
1061 char port[6];
1062
1063 if (l->addr.ss_family == AF_UNIX) {
1064 const struct sockaddr_un *un;
1065
1066 un = (struct sockaddr_un *)&l->addr;
1067 chunk_appendf(&trash, "%s ", un->sun_path);
1068 } else if (l->addr.ss_family == AF_INET) {
1069 addr_to_str(&l->addr, addr, sizeof(addr));
1070 port_to_str(&l->addr, port, sizeof(port));
1071 chunk_appendf(&trash, "%s:%s ", addr, port);
1072 } else if (l->addr.ss_family == AF_INET6) {
1073 addr_to_str(&l->addr, addr, sizeof(addr));
1074 port_to_str(&l->addr, port, sizeof(port));
1075 chunk_appendf(&trash, "[%s]:%s ", addr, port);
William Lallemand26314342018-10-26 14:47:41 +02001076 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
1077 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
William Lallemandeceddf72016-12-15 18:06:44 +01001078 } else
William Lallemand26314342018-10-26 14:47:41 +02001079 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001080
William Lallemand07a62f72017-05-24 00:57:40 +02001081 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +01001082 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +02001083 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1084 chunk_appendf(&trash, "operator ");
1085 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1086 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +01001087 else
1088 chunk_appendf(&trash, " ");
1089
1090 if (bind_conf->bind_proc != 0) {
1091 int pos;
Willy Tarreau20c5e522016-12-16 12:50:55 +01001092 for (pos = 0; pos < 8 * sizeof(bind_conf->bind_proc); pos++) {
Willy Tarreau4305ac72016-12-16 12:56:31 +01001093 if (bind_conf->bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +01001094 chunk_appendf(&trash, "%d,", pos+1);
1095 }
1096 }
1097 /* replace the latest comma by a newline */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001098 trash.area[trash.data-1] = '\n';
William Lallemandeceddf72016-12-15 18:06:44 +01001099
1100 } else {
1101 chunk_appendf(&trash, "all\n");
1102 }
1103
Willy Tarreau06d80a92017-10-19 14:32:15 +02001104 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001105 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001106 return 0;
1107 }
1108 }
Willy Tarreau3af9d832016-12-16 12:58:09 +01001109 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001110 }
1111 }
1112 default:
1113 appctx->st2 = STAT_ST_FIN;
1114 return 1;
1115 }
1116}
1117
1118
Willy Tarreau0a739292016-11-22 20:21:23 +01001119/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001120 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1121 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001122 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001123static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001124{
1125 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001126 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001127
1128 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1129 return 1;
1130
Willy Tarreauf6710f82016-12-16 17:45:44 +01001131 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001132
1133 if (*args[2]) {
1134 int len = strlen(args[2]);
1135
Willy Tarreauf6710f82016-12-16 17:45:44 +01001136 for (; *var; var++) {
1137 if (strncmp(*var, args[2], len) == 0 &&
1138 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001139 break;
1140 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001141 if (!*var) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001142 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau0a739292016-11-22 20:21:23 +01001143 appctx->ctx.cli.msg = "Variable not found\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001144 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau0a739292016-11-22 20:21:23 +01001145 return 1;
1146 }
1147 appctx->st2 = STAT_ST_END;
1148 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001149 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001150 return 0;
1151}
1152
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001153/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1154 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1155 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1156 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001157static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001158{
1159 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1160 return 1;
1161
1162 appctx->ctx.cli.i0 = 0;
1163
1164 if (*args[2]) {
1165 appctx->ctx.cli.i0 = atoi(args[2]);
1166 appctx->st2 = STAT_ST_END;
1167 }
1168 return 0;
1169}
1170
Willy Tarreau599852e2016-11-22 20:33:32 +01001171/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001172static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001173{
1174 struct stream_interface *si = appctx->owner;
1175 struct stream *s = si_strm(si);
1176
1177 if (strcmp(args[2], "cli") == 0) {
1178 unsigned timeout;
1179 const char *res;
1180
1181 if (!*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001182 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001183 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001184 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001185 return 1;
1186 }
1187
1188 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
1189 if (res || timeout < 1) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001190 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001191 appctx->ctx.cli.msg = "Invalid timeout value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001192 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001193 return 1;
1194 }
1195
1196 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1197 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1198 return 1;
1199 }
1200 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001201 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001202 appctx->ctx.cli.msg = "'set timeout' only supports 'cli'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001203 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001204 return 1;
1205 }
1206}
1207
Willy Tarreau2af99412016-11-23 11:10:59 +01001208/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001209static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001210{
1211 int v;
1212
1213 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1214 return 1;
1215
1216 if (!*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001217 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau2af99412016-11-23 11:10:59 +01001218 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001219 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +01001220 return 1;
1221 }
1222
1223 v = atoi(args[3]);
1224 if (v > global.hardmaxconn) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001225 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau2af99412016-11-23 11:10:59 +01001226 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001227 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +01001228 return 1;
1229 }
1230
1231 /* check for unlimited values */
1232 if (v <= 0)
1233 v = global.hardmaxconn;
1234
1235 global.maxconn = v;
1236
1237 /* Dequeues all of the listeners waiting for a resource */
1238 if (!LIST_ISEMPTY(&global_listener_queue))
1239 dequeue_all_listeners(&global_listener_queue);
1240
1241 return 1;
1242}
1243
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001244static int set_severity_output(int *target, char *argument)
1245{
1246 if (!strcmp(argument, "none")) {
1247 *target = CLI_SEVERITY_NONE;
1248 return 1;
1249 }
1250 else if (!strcmp(argument, "number")) {
1251 *target = CLI_SEVERITY_NUMBER;
1252 return 1;
1253 }
1254 else if (!strcmp(argument, "string")) {
1255 *target = CLI_SEVERITY_STRING;
1256 return 1;
1257 }
1258 return 0;
1259}
1260
1261/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001262static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001263{
1264 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1265 return 0;
1266
1267 appctx->ctx.cli.severity = LOG_ERR;
Aurélien Nephtali6e8a41d2018-03-15 21:48:50 +01001268 appctx->ctx.cli.msg = "one of 'none', 'number', 'string' is a required argument\n";
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001269 appctx->st0 = CLI_ST_PRINT;
1270 return 1;
1271}
William Lallemandeceddf72016-12-15 18:06:44 +01001272
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001273int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001274{
1275 return 0;
1276}
1277
Willy Tarreau45c742b2016-11-24 14:51:17 +01001278/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001279static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001280{
1281 int v;
1282 int *res;
1283 int mul = 1;
1284
1285 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1286 return 1;
1287
1288 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1289 res = &global.cps_lim;
1290 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1291 res = &global.sps_lim;
1292#ifdef USE_OPENSSL
1293 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1294 res = &global.ssl_lim;
1295#endif
1296 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1297 res = &global.comp_rate_lim;
1298 mul = 1024;
1299 }
1300 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001301 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001302 appctx->ctx.cli.msg =
1303 "'set rate-limit' only supports :\n"
1304 " - 'connections global' to set the per-process maximum connection rate\n"
1305 " - 'sessions global' to set the per-process maximum session rate\n"
1306#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001307 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001308#endif
1309 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001310 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001311 return 1;
1312 }
1313
1314 if (!*args[4]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001315 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001316 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001317 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001318 return 1;
1319 }
1320
1321 v = atoi(args[4]);
1322 if (v < 0) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001323 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001324 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001325 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001326 return 1;
1327 }
1328
1329 *res = v * mul;
1330
1331 /* Dequeues all of the listeners waiting for a resource */
1332 if (!LIST_ISEMPTY(&global_listener_queue))
1333 dequeue_all_listeners(&global_listener_queue);
1334
1335 return 1;
1336}
1337
William Lallemandf6975e92017-05-26 17:42:10 +02001338/* parse the "expose-fd" argument on the bind lines */
1339static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1340{
1341 if (!*args[cur_arg + 1]) {
1342 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1343 return ERR_ALERT | ERR_FATAL;
1344 }
1345 if (!strcmp(args[cur_arg+1], "listeners")) {
1346 conf->level |= ACCESS_FD_LISTENERS;
1347 } else {
1348 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1349 args[cur_arg], args[cur_arg+1]);
1350 return ERR_ALERT | ERR_FATAL;
1351 }
1352
1353 return 0;
1354}
1355
William Lallemand74c24fb2016-11-21 17:18:36 +01001356/* parse the "level" argument on the bind lines */
1357static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1358{
1359 if (!*args[cur_arg + 1]) {
1360 memprintf(err, "'%s' : missing level", args[cur_arg]);
1361 return ERR_ALERT | ERR_FATAL;
1362 }
1363
William Lallemand07a62f72017-05-24 00:57:40 +02001364 if (!strcmp(args[cur_arg+1], "user")) {
1365 conf->level &= ~ACCESS_LVL_MASK;
1366 conf->level |= ACCESS_LVL_USER;
1367 } else if (!strcmp(args[cur_arg+1], "operator")) {
1368 conf->level &= ~ACCESS_LVL_MASK;
1369 conf->level |= ACCESS_LVL_OPER;
1370 } else if (!strcmp(args[cur_arg+1], "admin")) {
1371 conf->level &= ~ACCESS_LVL_MASK;
1372 conf->level |= ACCESS_LVL_ADMIN;
1373 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001374 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1375 args[cur_arg], args[cur_arg+1]);
1376 return ERR_ALERT | ERR_FATAL;
1377 }
1378
1379 return 0;
1380}
1381
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001382static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1383{
1384 if (!*args[cur_arg + 1]) {
1385 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1386 return ERR_ALERT | ERR_FATAL;
1387 }
1388
1389 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1390 return 0;
1391 else {
1392 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1393 args[cur_arg], args[cur_arg+1]);
1394 return ERR_ALERT | ERR_FATAL;
1395 }
1396}
1397
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001398
1399 /* Displays workers and processes */
1400static int cli_io_handler_show_proc(struct appctx *appctx)
1401{
1402 struct stream_interface *si = appctx->owner;
1403 struct mworker_proc *child;
William Lallemande09cdc62018-11-19 18:46:16 +01001404 int old = 0;
William Lallemand16dd1b32018-11-19 18:46:18 +01001405 int up = now.tv_sec - proc_self->timestamp;
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001406
1407 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1408 return 1;
1409
1410 chunk_reset(&trash);
1411
William Lallemande3683302018-11-19 18:46:17 +01001412 chunk_printf(&trash, "#%-14s %-15s %-15s %-15s %s\n", "<PID>", "<type>", "<relative PID>", "<reloads>", "<uptime>");
William Lallemand16dd1b32018-11-19 18:46:18 +01001413 chunk_appendf(&trash, "%-15u %-15s %-15u %-15d %dd %02dh%02dm%02ds\n", getpid(), "master", 0, proc_self->reloads, up / 86400, (up % 86400) / 3600, (up % 3600) / 60, (up % 60));
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001414
William Lallemande09cdc62018-11-19 18:46:16 +01001415 /* displays current processes */
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001416
William Lallemande09cdc62018-11-19 18:46:16 +01001417 chunk_appendf(&trash, "# workers\n");
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001418 list_for_each_entry(child, &proc_list, list) {
William Lallemand16dd1b32018-11-19 18:46:18 +01001419 up = now.tv_sec - child->timestamp;
1420
1421 if (child->type != 'w')
1422 continue;
William Lallemande09cdc62018-11-19 18:46:16 +01001423
1424 if (child->reloads > 0) {
1425 old++;
1426 continue;
1427 }
William Lallemande3683302018-11-19 18:46:17 +01001428 chunk_appendf(&trash, "%-15u %-15s %-15u %-15d %dd %02dh%02dm%02ds\n", child->pid, "worker", child->relative_pid, child->reloads, up / 86400, (up % 86400) / 3600, (up % 3600) / 60, (up % 60));
William Lallemande09cdc62018-11-19 18:46:16 +01001429}
1430
1431 /* displays old processes */
1432
1433 if (old) {
1434 chunk_appendf(&trash, "# old workers\n");
1435 list_for_each_entry(child, &proc_list, list) {
William Lallemand16dd1b32018-11-19 18:46:18 +01001436 up = now.tv_sec - child->timestamp;
1437
1438 if (child->type != 'w')
1439 continue;
1440
William Lallemande09cdc62018-11-19 18:46:16 +01001441 if (child->reloads > 0)
William Lallemande3683302018-11-19 18:46:17 +01001442 chunk_appendf(&trash, "%-15u %-15s %-15u %-15d %dd %02dh%02dm%02ds\n", child->pid, "worker", child->relative_pid, child->reloads, up / 86400, (up % 86400) / 3600, (up % 3600) / 60, (up % 60));
William Lallemande09cdc62018-11-19 18:46:16 +01001443 }
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001444 }
1445
1446 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001447 si_rx_room_blk(si);
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001448 return 0;
1449 }
1450
1451 /* dump complete */
1452 return 1;
1453}
1454
Olivier Houchardf886e342017-04-05 22:24:59 +02001455/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001456static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02001457{
1458 char *cmsgbuf = NULL;
1459 unsigned char *tmpbuf = NULL;
1460 struct cmsghdr *cmsg;
1461 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001462 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001463 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001464 struct msghdr msghdr;
1465 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001466 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Olivier Houchardf886e342017-04-05 22:24:59 +02001467 int *tmpfd;
1468 int tot_fd_nb = 0;
1469 struct proxy *px;
1470 int i = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001471 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001472 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001473 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001474 int ret;
1475
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001476 if (!remote) {
1477 ha_warning("Only works on real connections\n");
1478 goto out;
1479 }
1480
1481 fd = remote->handle.fd;
1482
Olivier Houchardf886e342017-04-05 22:24:59 +02001483 /* Temporary set the FD in blocking mode, that will make our life easier */
1484 old_fcntl = fcntl(fd, F_GETFL);
1485 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001486 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001487 goto out;
1488 }
1489 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1490 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001491 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001492 goto out;
1493 }
1494 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001495 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001496 goto out;
1497 }
Olivier Houchard54740872017-04-06 14:45:14 +02001498 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001499 iov.iov_base = &tot_fd_nb;
1500 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001501 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001502 goto out;
1503 memset(&msghdr, 0, sizeof(msghdr));
1504 /*
1505 * First, calculates the total number of FD, so that we can let
1506 * the caller know how much he should expects.
1507 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001508 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001509 while (px) {
1510 struct listener *l;
1511
1512 list_for_each_entry(l, &px->conf.listeners, by_fe) {
Olivier Houchard1fc05162017-04-06 01:05:05 +02001513 /* Only transfer IPv4/IPv6/UNIX sockets */
1514 if (l->state >= LI_ZOMBIE &&
1515 (l->proto->sock_family == AF_INET ||
Olivier Houchardf886e342017-04-05 22:24:59 +02001516 l->proto->sock_family == AF_INET6 ||
Olivier Houchard1fc05162017-04-06 01:05:05 +02001517 l->proto->sock_family == AF_UNIX))
Olivier Houchardf886e342017-04-05 22:24:59 +02001518 tot_fd_nb++;
1519 }
1520 px = px->next;
1521 }
1522 if (tot_fd_nb == 0)
1523 goto out;
1524
1525 /* First send the total number of file descriptors, so that the
1526 * receiving end knows what to expect.
1527 */
1528 msghdr.msg_iov = &iov;
1529 msghdr.msg_iovlen = 1;
1530 ret = sendmsg(fd, &msghdr, 0);
1531 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001532 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001533 goto out;
1534 }
1535
1536 /* Now send the fds */
1537 msghdr.msg_control = cmsgbuf;
1538 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1539 cmsg = CMSG_FIRSTHDR(&msghdr);
1540 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1541 cmsg->cmsg_level = SOL_SOCKET;
1542 cmsg->cmsg_type = SCM_RIGHTS;
1543 tmpfd = (int *)CMSG_DATA(cmsg);
1544
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001545 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001546 /* For each socket, e message is sent, containing the following :
1547 * Size of the namespace name (or 0 if none), as an unsigned char.
1548 * The namespace name, if any
1549 * Size of the interface name (or 0 if none), as an unsigned char
1550 * The interface name, if any
1551 * Listener options, as an int.
1552 */
1553 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
1554 * buffer big enough to store the socket informations.
1555 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001556 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001557 if (tmpbuf == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001558 ha_warning("Failed to allocate memory to transfer socket informations\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001559 goto out;
1560 }
1561 iov.iov_base = tmpbuf;
1562 while (px) {
1563 struct listener *l;
1564
1565 list_for_each_entry(l, &px->conf.listeners, by_fe) {
1566 int ret;
1567 /* Only transfer IPv4/IPv6 sockets */
Olivier Houchard1fc05162017-04-06 01:05:05 +02001568 if (l->state >= LI_ZOMBIE &&
Olivier Houchardf886e342017-04-05 22:24:59 +02001569 (l->proto->sock_family == AF_INET ||
1570 l->proto->sock_family == AF_INET6 ||
1571 l->proto->sock_family == AF_UNIX)) {
1572 memcpy(&tmpfd[i % MAX_SEND_FD], &l->fd, sizeof(l->fd));
1573 if (!l->netns)
1574 tmpbuf[curoff++] = 0;
1575#ifdef CONFIG_HAP_NS
1576 else {
1577 char *name = l->netns->node.key;
1578 unsigned char len = l->netns->name_len;
1579 tmpbuf[curoff++] = len;
1580 memcpy(tmpbuf + curoff, name, len);
1581 curoff += len;
1582 }
1583#endif
1584 if (l->interface) {
1585 unsigned char len = strlen(l->interface);
1586 tmpbuf[curoff++] = len;
1587 memcpy(tmpbuf + curoff, l->interface, len);
1588 curoff += len;
1589 } else
1590 tmpbuf[curoff++] = 0;
1591 memcpy(tmpbuf + curoff, &l->options,
1592 sizeof(l->options));
1593 curoff += sizeof(l->options);
1594
1595
1596 i++;
1597 } else
1598 continue;
1599 if ((!(i % MAX_SEND_FD))) {
1600 iov.iov_len = curoff;
1601 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001602 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001603 goto out;
1604 }
1605 /* Wait for an ack */
1606 do {
1607 ret = recv(fd, &tot_fd_nb,
1608 sizeof(tot_fd_nb), 0);
1609 } while (ret == -1 && errno == EINTR);
1610 if (ret <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001611 ha_warning("Unexpected error while transferring sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001612 goto out;
1613 }
1614 curoff = 0;
1615 }
1616
1617 }
1618 px = px->next;
1619 }
1620 if (i % MAX_SEND_FD) {
1621 iov.iov_len = curoff;
1622 cmsg->cmsg_len = CMSG_LEN((i % MAX_SEND_FD) * sizeof(int));
1623 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * (i % MAX_SEND_FD));
1624 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001625 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001626 goto out;
1627 }
1628 }
1629
1630out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001631 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001632 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001633 goto out;
1634 }
1635 appctx->st0 = CLI_ST_END;
1636 free(cmsgbuf);
1637 free(tmpbuf);
1638 return 1;
1639}
1640
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001641static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
1642{
1643 if (*args[0] == 'h')
1644 /* help */
1645 cli_gen_usage_msg(appctx);
1646 else if (*args[0] == 'p')
1647 /* prompt */
1648 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
1649 else if (*args[0] == 'q')
1650 /* quit */
1651 appctx->st0 = CLI_ST_END;
1652
1653 return 1;
1654}
Olivier Houchardf886e342017-04-05 22:24:59 +02001655
William Lallemand2f4ce202018-10-26 14:47:47 +02001656void pcli_write_prompt(struct stream *s)
1657{
1658 struct buffer *msg = get_trash_chunk();
1659 struct channel *oc = si_oc(&s->si[0]);
1660
1661 if (s->pcli_next_pid == 0)
1662 chunk_appendf(msg, "master> ");
1663 else
1664 chunk_appendf(msg, "%d> ", s->pcli_next_pid);
1665 co_inject(oc, msg->area, msg->data);
1666}
1667
William Lallemand291810d2018-10-26 14:47:38 +02001668
William Lallemandcf62f7e2018-10-26 14:47:40 +02001669/* The pcli_* functions are used for the CLI proxy in the master */
1670
William Lallemanddeeaa592018-10-26 14:47:48 +02001671void pcli_reply_and_close(struct stream *s, const char *msg)
1672{
1673 struct buffer *buf = get_trash_chunk();
1674
1675 chunk_initstr(buf, msg);
1676 stream_int_retnclose(&s->si[0], buf);
1677}
1678
William Lallemand291810d2018-10-26 14:47:38 +02001679static enum obj_type *pcli_pid_to_server(int proc_pid)
1680{
1681 struct mworker_proc *child;
1682
1683 list_for_each_entry(child, &proc_list, list) {
1684 if (child->pid == proc_pid){
1685 return &child->srv->obj_type;
1686 }
1687 }
1688 return NULL;
1689}
1690
1691/* Take a CLI prefix in argument (eg: @!1234 @master @1)
1692 * Return:
1693 * 0: master
1694 * > 0: pid of a worker
1695 * < 0: didn't find a worker
1696 */
1697static int pcli_prefix_to_pid(const char *prefix)
1698{
1699 int proc_pid;
1700 struct mworker_proc *child;
1701 char *errtol = NULL;
1702
1703 if (*prefix != '@') /* not a prefix, should not happen */
1704 return -1;
1705
1706 prefix++;
1707 if (!*prefix) /* sent @ alone, return the master */
1708 return 0;
1709
1710 if (strcmp("master", prefix) == 0) {
1711 return 0;
1712 } else if (*prefix == '!') {
1713 prefix++;
1714 if (!*prefix)
1715 return -1;
1716
1717 proc_pid = strtol(prefix, &errtol, 10);
1718 if (*errtol != '\0')
1719 return -1;
1720 list_for_each_entry(child, &proc_list, list) {
William Lallemand16dd1b32018-11-19 18:46:18 +01001721 if (child->type != 'w')
1722 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001723 if (child->pid == proc_pid){
1724 return child->pid;
1725 }
1726 }
1727 } else {
1728 struct mworker_proc *chosen = NULL;
1729 /* this is a relative pid */
1730
1731 proc_pid = strtol(prefix, &errtol, 10);
1732 if (*errtol != '\0')
1733 return -1;
1734
1735 if (proc_pid == 0) /* return the master */
1736 return 0;
1737
1738 /* chose the right process, the current one is the one with the
1739 least number of reloads */
1740 list_for_each_entry(child, &proc_list, list) {
William Lallemand16dd1b32018-11-19 18:46:18 +01001741 if (child->type != 'w')
1742 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001743 if (child->relative_pid == proc_pid){
1744 if (child->reloads == 0)
1745 return child->pid;
1746 else if (chosen == NULL || child->reloads < chosen->reloads)
1747 chosen = child;
1748 }
1749 }
1750 if (chosen)
1751 return chosen->pid;
1752 }
1753 return -1;
1754}
1755
William Lallemandcf62f7e2018-10-26 14:47:40 +02001756/* Parse the CLI request:
1757 *
1758 * - it can rewrite the buffer by trimming the prefix
1759 * - fill dst with the destination server if there is one
1760 *
1761 * Return:
1762 * - the amount of data to forward or
1763 * - -1 if there is no end to the command or
1764 * - 0 everything has been trimmed (only a prefix)
1765 */
1766#define PCLI_REQ_INIT 0
1767#define PCLI_REQ_PFX 1
1768#define PCLI_REQ_TRIM 2
1769#define PCLI_REQ_CMD 3
1770
1771int pcli_parse_request(struct channel *req, int *target_pid)
1772{
1773 char *input = (char *)ci_head(req);
1774 const char *end;
1775 char *ptr, *trim = NULL, *pfx_b = NULL, *cmd_b = NULL;
1776 struct buffer *buf = &req->buf;
1777 int ret = 0;
1778 int state = PCLI_REQ_INIT;
1779
1780 ptr = input;
1781 end = b_stop(buf);
1782
1783 /* The while loop condition is checking the end of the command.
1784 It is needed to iterate for each ptr++ done in the parser */
1785 while (ptr < end && *ptr != '\n' && *ptr != '\r' && *ptr != ';') {
1786 switch (state) {
1787 /* The init state only trims the useless chars */
1788 case PCLI_REQ_INIT:
1789
1790 /* skip every spaces at the start of the command */
1791 if (*ptr == ' ') {
1792 ptr++;
1793 continue;
1794 }
1795 pfx_b = ptr; /* this is the start of the command or of the @ prefix */
1796 state = PCLI_REQ_PFX;
1797
1798 /* the atprefix state looks for a @ prefix. If it finds
1799 it, it will check to which server send the request.
1800 It also ajust the trim pointer */
1801 case PCLI_REQ_PFX:
1802
1803 if (*pfx_b != '@') {
1804 /* there is no prefix */
1805 pfx_b = NULL;
William Lallemand744de5b2018-10-29 17:14:00 +01001806 cmd_b = input; /* if no prefix we don't trim anything */
William Lallemandcf62f7e2018-10-26 14:47:40 +02001807 state = PCLI_REQ_CMD;
1808 continue;
1809 }
1810
1811 if (*ptr != ' ') {
1812 ptr++;
1813 continue;
1814 }
1815 *ptr = '\0'; /* this the end of the prefix */
1816 ptr++;
1817 trim = ptr;
1818 state = PCLI_REQ_TRIM;
1819 break;
1820
1821 /* we really need to trim there because that's the only
1822 way to know if we are going to send a command or if
1823 there is only a prefix */
1824 case PCLI_REQ_TRIM:
1825 if (*ptr == ' ') {
1826 ptr++;
1827 continue;
1828 }
1829 cmd_b = trim = ptr;
1830 state = PCLI_REQ_CMD;
1831
1832 /* just look for the end of the command */
1833 case PCLI_REQ_CMD:
1834 ptr++;
1835 continue;
1836 }
1837 }
1838
1839 /* we didn't find a command separator, not enough data */
1840 if (ptr >= end)
1841 return -1;
1842
1843 if (!pfx_b && !cmd_b) {
1844 /* probably just a \n or a ; */
1845 return 1;
1846 } else if (pfx_b && !cmd_b) {
1847 /* it's only a prefix, we don't want to forward it */
1848 *ptr = '\0';
1849 trim = ptr + 1; /* we want to trim the whole command */
1850 ret = 0;
1851 } else if (cmd_b) {
1852 /* command without a prefix */
1853 *ptr = '\n';
1854 ret = ptr - cmd_b + 1;
1855 }
1856
1857 if (pfx_b)
1858 *target_pid = pcli_prefix_to_pid(pfx_b);
1859
1860 /* trim the useless chars */
1861 if (trim)
1862 b_del(&req->buf, trim - input);
1863
1864 return ret;
1865}
1866
1867int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
1868{
1869 int target_pid;
1870 int to_forward;
1871
1872 target_pid = s->pcli_next_pid;
1873
1874read_again:
1875 /* if the channel is closed for read, we won't receive any more data
1876 from the client, but we don't want to forward this close to the
1877 server */
1878 channel_dont_close(req);
1879
1880 /* We don't know yet to which server we will connect */
1881 channel_dont_connect(req);
1882
1883
1884 /* we are not waiting for a response, there is no more request and we
1885 * receive a close from the client, we can leave */
1886 if (!(ci_data(req)) && req->flags & CF_SHUTR) {
1887 channel_shutw_now(&s->res);
1888 s->req.analysers &= ~AN_REQ_WAIT_CLI;
1889 return 1;
1890 }
1891
1892 req->flags |= CF_READ_DONTWAIT;
1893
1894 /* need more data */
1895 if (!ci_data(req))
1896 return 0;
1897
1898 /* If there is data available for analysis, log the end of the idle time. */
1899 if (c_data(req) && s->logs.t_idle == -1)
1900 s->logs.t_idle = tv_ms_elapsed(&s->logs.tv_accept, &now) - s->logs.t_handshake;
1901
1902 to_forward = pcli_parse_request(req, &target_pid);
1903 if (to_forward > 0) {
1904 /* enough data */
1905
1906 /* we didn't find the process, send an error and close */
1907 if (target_pid < 0) {
1908 pcli_reply_and_close(s, "Can't find the target CLI!\n");
1909 return 0;
1910 }
1911
1912 /* forward only 1 command */
1913 channel_forward(req, to_forward);
1914 /* we send only 1 command per request, and we write close after it */
1915 channel_shutw_now(req);
1916
1917 /* remove the XFER_DATA analysers, which forwards all
1918 * the data, we don't want to forward the next requests
1919 * We need to add CF_FLT_ANALYZE to abort the forward too.
1920 */
1921 req->analysers &= ~(AN_REQ_FLT_XFER_DATA|AN_REQ_WAIT_CLI);
1922 req->analysers |= AN_REQ_FLT_END|CF_FLT_ANALYZE;
1923 s->res.analysers |= AN_RES_WAIT_CLI;
1924
1925 /* we can connect now */
1926 s->target = pcli_pid_to_server(target_pid);
1927 if (!s->target) {
1928 s->target = &cli_applet.obj_type;
1929 }
1930
1931 s->flags |= (SF_DIRECT | SF_ASSIGNED);
1932 channel_auto_connect(req);
1933
1934 } else if (to_forward == 0) {
1935 /* we only received a prefix without command, which
1936 mean that we want to store it for every other
1937 command for this session */
1938 if (target_pid > -1) {
1939 s->pcli_next_pid = target_pid;
William Lallemand2f4ce202018-10-26 14:47:47 +02001940 pcli_write_prompt(s);
William Lallemandcf62f7e2018-10-26 14:47:40 +02001941 } else {
William Lallemandcf62f7e2018-10-26 14:47:40 +02001942 s->pcli_next_pid = 0;
William Lallemanddeeaa592018-10-26 14:47:48 +02001943 pcli_reply_and_close(s, "Can't find the target CLI!\n");
William Lallemandcf62f7e2018-10-26 14:47:40 +02001944 }
1945
1946 /* we trimmed things but we might have other commands to consume */
1947 goto read_again;
1948 } else if (to_forward == -1 && channel_full(req, global.tune.maxrewrite)) {
1949 /* buffer is full and we didn't catch the end of a command */
1950 goto send_help;
1951 }
1952
1953 return 0;
1954
1955send_help:
1956 b_reset(&req->buf);
1957 b_putblk(&req->buf, "help\n", 5);
1958 goto read_again;
1959}
1960
1961int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
1962{
1963 struct proxy *fe = strm_fe(s);
1964 struct proxy *be = s->be;
1965
William Lallemand6b7cd0a2018-11-06 17:37:11 +01001966 if (rep->flags & CF_READ_ERROR) {
1967 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
1968 s->res.analysers &= ~AN_RES_WAIT_CLI;
1969 return 0;
1970 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02001971 rep->flags |= CF_READ_DONTWAIT; /* try to get back here ASAP */
1972 rep->flags |= CF_NEVER_WAIT;
1973
1974 /* don't forward the close */
1975 channel_dont_close(&s->res);
1976 channel_dont_close(&s->req);
1977
1978 /* forward the data */
1979 if (ci_data(rep)) {
1980 c_adv(rep, ci_data(rep));
1981 return 0;
1982 }
1983
1984 if ((rep->flags & (CF_SHUTR|CF_READ_NULL))) {
1985 /* stream cleanup */
1986
William Lallemand2f4ce202018-10-26 14:47:47 +02001987 pcli_write_prompt(s);
1988
William Lallemandcf62f7e2018-10-26 14:47:40 +02001989 s->si[1].flags |= SI_FL_NOLINGER | SI_FL_NOHALF;
1990 si_shutr(&s->si[1]);
1991 si_shutw(&s->si[1]);
1992
1993 /*
1994 * starting from there this the same code as
1995 * http_end_txn_clean_session().
1996 *
1997 * It allows to do frontend keepalive while reconnecting to a
1998 * new server for each request.
1999 */
2000
2001 if (s->flags & SF_BE_ASSIGNED) {
2002 HA_ATOMIC_SUB(&be->beconn, 1);
2003 if (unlikely(s->srv_conn))
2004 sess_change_server(s, NULL);
2005 }
2006
2007 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2008 stream_process_counters(s);
2009
2010 /* don't count other requests' data */
2011 s->logs.bytes_in -= ci_data(&s->req);
2012 s->logs.bytes_out -= ci_data(&s->res);
2013
2014 /* we may need to know the position in the queue */
2015 pendconn_free(s);
2016
2017 /* let's do a final log if we need it */
2018 if (!LIST_ISEMPTY(&fe->logformat) && s->logs.logwait &&
2019 !(s->flags & SF_MONITOR) &&
2020 (!(fe->options & PR_O_NULLNOLOG) || s->req.total)) {
2021 s->do_log(s);
2022 }
2023
2024 /* stop tracking content-based counters */
2025 stream_stop_content_counters(s);
2026 stream_update_time_stats(s);
2027
2028 s->logs.accept_date = date; /* user-visible date for logging */
2029 s->logs.tv_accept = now; /* corrected date for internal use */
2030 s->logs.t_handshake = 0; /* There are no handshake in keep alive connection. */
2031 s->logs.t_idle = -1;
2032 tv_zero(&s->logs.tv_request);
2033 s->logs.t_queue = -1;
2034 s->logs.t_connect = -1;
2035 s->logs.t_data = -1;
2036 s->logs.t_close = 0;
2037 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
2038 s->logs.srv_queue_pos = 0; /* we will get this number soon */
2039
2040 s->logs.bytes_in = s->req.total = ci_data(&s->req);
2041 s->logs.bytes_out = s->res.total = ci_data(&s->res);
2042
2043 stream_del_srv_conn(s);
2044 if (objt_server(s->target)) {
2045 if (s->flags & SF_CURR_SESS) {
2046 s->flags &= ~SF_CURR_SESS;
2047 HA_ATOMIC_SUB(&objt_server(s->target)->cur_sess, 1);
2048 }
2049 if (may_dequeue_tasks(objt_server(s->target), be))
2050 process_srv_queue(objt_server(s->target));
2051 }
2052
2053 s->target = NULL;
2054
2055 /* only release our endpoint if we don't intend to reuse the
2056 * connection.
2057 */
2058 if (!si_conn_ready(&s->si[1])) {
2059 si_release_endpoint(&s->si[1]);
2060 s->srv_conn = NULL;
2061 }
2062
2063 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
2064 s->si[1].err_type = SI_ET_NONE;
2065 s->si[1].conn_retries = 0; /* used for logging too */
2066 s->si[1].exp = TICK_ETERNITY;
2067 s->si[1].flags &= SI_FL_ISBACK | SI_FL_DONT_WAKE; /* we're in the context of process_stream */
2068 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);
2069 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);
2070 s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_ADDR_SET|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
2071 s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
2072 s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
2073 /* reinitialise the current rule list pointer to NULL. We are sure that
2074 * any rulelist match the NULL pointer.
2075 */
2076 s->current_rule_list = NULL;
2077
2078 s->be = strm_fe(s);
2079 s->logs.logwait = strm_fe(s)->to_log;
2080 s->logs.level = 0;
2081 stream_del_srv_conn(s);
2082 s->target = NULL;
2083 /* re-init store persistence */
2084 s->store_count = 0;
2085 s->uniq_id = global.req_count++;
2086
2087 s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */
2088
2089 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2090
2091 s->req.analysers |= AN_REQ_WAIT_CLI;
2092 s->res.analysers &= ~AN_RES_WAIT_CLI;
2093
2094 /* We must trim any excess data from the response buffer, because we
2095 * may have blocked an invalid response from a server that we don't
2096 * want to accidentely forward once we disable the analysers, nor do
2097 * we want those data to come along with next response. A typical
2098 * example of such data would be from a buggy server responding to
2099 * a HEAD with some data, or sending more than the advertised
2100 * content-length.
2101 */
2102 if (unlikely(ci_data(&s->res)))
2103 b_set_data(&s->res.buf, co_data(&s->res));
2104
2105 /* Now we can realign the response buffer */
2106 c_realign_if_empty(&s->res);
2107
2108 s->req.rto = strm_fe(s)->timeout.client;
2109 s->req.wto = TICK_ETERNITY;
2110
2111 s->res.rto = TICK_ETERNITY;
2112 s->res.wto = strm_fe(s)->timeout.client;
2113
2114 s->req.rex = TICK_ETERNITY;
2115 s->req.wex = TICK_ETERNITY;
2116 s->req.analyse_exp = TICK_ETERNITY;
2117 s->res.rex = TICK_ETERNITY;
2118 s->res.wex = TICK_ETERNITY;
2119 s->res.analyse_exp = TICK_ETERNITY;
2120 s->si[1].hcto = TICK_ETERNITY;
2121
2122 /* we're removing the analysers, we MUST re-enable events detection.
2123 * We don't enable close on the response channel since it's either
2124 * already closed, or in keep-alive with an idle connection handler.
2125 */
2126 channel_auto_read(&s->req);
2127 channel_auto_close(&s->req);
2128 channel_auto_read(&s->res);
2129
2130
2131 return 1;
2132 }
2133 return 0;
2134}
2135
William Lallemand8a022572018-10-26 14:47:35 +02002136/*
2137 * The mworker functions are used to initialize the CLI in the master process
2138 */
2139
William Lallemand309dc9a2018-10-26 14:47:45 +02002140 /*
2141 * Stop the mworker proxy
2142 */
2143void mworker_cli_proxy_stop()
2144{
William Lallemand550db6d2018-11-06 17:37:12 +01002145 if (mworker_proxy)
2146 stop_proxy(mworker_proxy);
William Lallemand309dc9a2018-10-26 14:47:45 +02002147}
2148
William Lallemand8a022572018-10-26 14:47:35 +02002149/*
2150 * Create the mworker CLI proxy
2151 */
2152int mworker_cli_proxy_create()
2153{
2154 struct mworker_proc *child;
2155
2156 mworker_proxy = calloc(1, sizeof(*mworker_proxy));
2157 if (!mworker_proxy)
2158 return -1;
2159
2160 init_new_proxy(mworker_proxy);
2161 mworker_proxy->next = proxies_list;
2162 proxies_list = mworker_proxy;
2163 mworker_proxy->id = strdup("MASTER");
William Lallemandcf62f7e2018-10-26 14:47:40 +02002164 mworker_proxy->mode = PR_MODE_CLI;
William Lallemand8a022572018-10-26 14:47:35 +02002165 mworker_proxy->state = PR_STNEW;
2166 mworker_proxy->last_change = now.tv_sec;
2167 mworker_proxy->cap = PR_CAP_LISTEN; /* this is a listen section */
2168 mworker_proxy->maxconn = 10; /* default to 10 concurrent connections */
2169 mworker_proxy->timeout.client = 0; /* no timeout */
2170 mworker_proxy->conf.file = strdup("MASTER");
2171 mworker_proxy->conf.line = 0;
2172 mworker_proxy->accept = frontend_accept;
2173 mworker_proxy-> lbprm.algo = BE_LB_ALGO_NONE;
2174
2175 /* Does not init the default target the CLI applet, but must be done in
2176 * the request parsing code */
2177 mworker_proxy->default_target = NULL;
2178
2179 /* the check_config_validity() will get an ID for the proxy */
2180 mworker_proxy->uuid = -1;
2181
2182 proxy_store_name(mworker_proxy);
2183
2184 /* create all servers using the mworker_proc list */
2185 list_for_each_entry(child, &proc_list, list) {
2186 char *msg = NULL;
2187 struct server *newsrv = NULL;
2188 struct sockaddr_storage *sk;
2189 int port1, port2, port;
2190 struct protocol *proto;
2191 char *errmsg;
2192
2193 newsrv = new_server(mworker_proxy);
2194 if (!newsrv)
2195 return -1;
2196
2197 /* we don't know the new pid yet */
2198 if (child->pid == -1)
2199 memprintf(&msg, "cur-%d", child->relative_pid);
2200 else
2201 memprintf(&msg, "old-%d", child->pid);
2202
2203 newsrv->next = mworker_proxy->srv;
2204 mworker_proxy->srv = newsrv;
2205 newsrv->conf.file = strdup(msg);
2206 newsrv->id = strdup(msg);
2207 newsrv->conf.line = 0;
2208
2209 memprintf(&msg, "sockpair@%d", child->ipc_fd[0]);
2210 if ((sk = str2sa_range(msg, &port, &port1, &port2, &errmsg, NULL, NULL, 0)) == 0)
2211 return -1;
2212
2213 proto = protocol_by_family(sk->ss_family);
2214 if (!proto || !proto->connect) {
2215 return -1;
2216 }
2217
2218 /* no port specified */
2219 newsrv->flags |= SRV_F_MAPPORTS;
2220 newsrv->addr = *sk;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002221 /* don't let the server participate to load balancing */
2222 newsrv->iweight = 0;
2223 newsrv->uweight = 0;
William Lallemand8a022572018-10-26 14:47:35 +02002224 srv_lb_commit_status(newsrv);
William Lallemand291810d2018-10-26 14:47:38 +02002225
2226 child->srv = newsrv;
William Lallemand8a022572018-10-26 14:47:35 +02002227 }
2228 return 0;
2229}
Olivier Houchardf886e342017-04-05 22:24:59 +02002230
William Lallemandce83b4a2018-10-26 14:47:30 +02002231/*
William Lallemande7361152018-10-26 14:47:36 +02002232 * Create a new listener for the master CLI proxy
2233 */
2234int mworker_cli_proxy_new_listener(char *line)
2235{
2236 struct bind_conf *bind_conf;
2237 struct listener *l;
2238 char *err = NULL;
2239 char *args[MAX_LINE_ARGS + 1];
2240 int arg;
2241 int cur_arg;
2242
2243 arg = 0;
2244 args[0] = line;
2245
2246 /* args is a bind configuration with spaces replaced by commas */
2247 while (*line && arg < MAX_LINE_ARGS) {
2248
2249 if (*line == ',') {
2250 *line++ = '\0';
2251 while (*line == ',')
2252 line++;
2253 args[++arg] = line;
2254 }
2255 line++;
2256 }
2257
2258 args[++arg] = "\0";
2259
2260 bind_conf = bind_conf_alloc(mworker_proxy, "master-socket", 0, "", xprt_get(XPRT_RAW));
2261
2262 bind_conf->level &= ~ACCESS_LVL_MASK;
2263 bind_conf->level |= ACCESS_LVL_ADMIN;
2264
2265 if (!str2listener(args[0], mworker_proxy, bind_conf, "master-socket", 0, &err)) {
2266 ha_alert("Cannot create the listener of the master CLI\n");
2267 return -1;
2268 }
2269
2270 cur_arg = 1;
2271
2272 while (*args[cur_arg]) {
2273 static int bind_dumped;
2274 struct bind_kw *kw;
2275
2276 kw = bind_find_kw(args[cur_arg]);
2277 if (kw) {
2278 if (!kw->parse) {
2279 memprintf(&err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
2280 args[0], args[1], args[cur_arg]);
2281 goto err;
2282 }
2283
2284 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, &err) != 0) {
2285 if (err)
2286 memprintf(&err, "'%s %s' : '%s'", args[0], args[1], err);
2287 else
2288 memprintf(&err, "'%s %s' : error encountered while processing '%s'",
2289 args[0], args[1], args[cur_arg]);
2290 goto err;
2291 }
2292
2293 cur_arg += 1 + kw->skip;
2294 continue;
2295 }
2296
2297 if (!bind_dumped) {
2298 bind_dump_kws(&err);
2299 indent_msg(&err, 4);
2300 bind_dumped = 1;
2301 }
2302
2303 memprintf(&err, "'%s %s' : unknown keyword '%s'.%s%s",
2304 args[0], args[1], args[cur_arg],
2305 err ? " Registered keywords :" : "", err ? err : "");
2306 goto err;
2307 }
2308
2309
2310 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
2311 l->maxconn = 10;
2312 l->backlog = 10;
2313 l->accept = session_accept_fd;
2314 l->default_target = mworker_proxy->default_target;
2315 /* don't make the peers subject to global limits and don't close it in the master */
2316 l->options |= (LI_O_UNLIMITED|LI_O_MWORKER); /* we are keeping this FD in the master */
2317 l->nice = -64; /* we want to boost priority for local stats */
2318 global.maxsock += l->maxconn;
2319 }
2320
2321 return 0;
2322
2323err:
2324 ha_alert("%s\n", err);
2325 return -1;
2326
2327}
2328
2329/*
William Lallemandce83b4a2018-10-26 14:47:30 +02002330 * Create a new CLI socket using a socketpair for a worker process
2331 * <mworker_proc> is the process structure, and <proc> is the process number
2332 */
2333int mworker_cli_sockpair_new(struct mworker_proc *mworker_proc, int proc)
2334{
2335 struct bind_conf *bind_conf;
2336 struct listener *l;
2337 char *path = NULL;
2338 char *err = NULL;
2339
2340 /* master pipe to ensure the master is still alive */
2341 if (socketpair(AF_UNIX, SOCK_STREAM, 0, mworker_proc->ipc_fd) < 0) {
2342 ha_alert("Cannot create worker socketpair.\n");
2343 return -1;
2344 }
2345
2346 /* XXX: we might want to use a separate frontend at some point */
2347 if (!global.stats_fe) {
2348 if ((global.stats_fe = alloc_stats_fe("GLOBAL", "master-socket", 0)) == NULL) {
2349 ha_alert("out of memory trying to allocate the stats frontend");
2350 return -1;
2351 }
2352 }
2353
2354 bind_conf = bind_conf_alloc(global.stats_fe, "master-socket", 0, "", xprt_get(XPRT_RAW));
2355 bind_conf->level &= ~ACCESS_LVL_MASK;
2356 bind_conf->level |= ACCESS_LVL_ADMIN; /* TODO: need to lower the rights with a CLI keyword*/
2357
2358 bind_conf->bind_proc = 1UL << proc;
2359 global.stats_fe->bind_proc = 0; /* XXX: we should be careful with that, it can be removed by configuration */
2360
2361 if (!memprintf(&path, "sockpair@%d", mworker_proc->ipc_fd[1])) {
2362 ha_alert("Cannot allocate listener.\n");
2363 return -1;
2364 }
2365
2366 if (!str2listener(path, global.stats_fe, bind_conf, "master-socket", 0, &err)) {
2367 ha_alert("Cannot create a CLI sockpair listener for process #%d\n", proc);
2368 return -1;
2369 }
2370
2371 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
2372 l->maxconn = global.stats_fe->maxconn;
2373 l->backlog = global.stats_fe->backlog;
2374 l->accept = session_accept_fd;
2375 l->default_target = global.stats_fe->default_target;
William Lallemanda3372292018-11-16 16:57:22 +01002376 l->options |= (LI_O_UNLIMITED | LI_O_NOSTOP);
William Lallemandce83b4a2018-10-26 14:47:30 +02002377 /* it's a sockpair but we don't want to keep the fd in the master */
2378 l->options &= ~LI_O_INHERITED;
2379 l->nice = -64; /* we want to boost priority for local stats */
2380 global.maxsock += l->maxconn;
2381 }
2382
2383 return 0;
2384}
2385
William Lallemand74c24fb2016-11-21 17:18:36 +01002386static struct applet cli_applet = {
2387 .obj_type = OBJ_TYPE_APPLET,
2388 .name = "<CLI>", /* used for logging */
2389 .fct = cli_io_handler,
2390 .release = cli_release_handler,
2391};
2392
Willy Tarreau0a739292016-11-22 20:21:23 +01002393/* register cli keywords */
2394static struct cli_kw_list cli_kws = {{ },{
William Lallemand4e8450b2018-10-26 14:47:43 +02002395 { { "@<relative pid>", NULL }, "@<relative pid> : send a command to the <relative pid> process", NULL, cli_io_handler_show_proc, NULL, NULL, ACCESS_MASTER_ONLY},
2396 { { "@!<pid>", NULL }, "@!<pid> : send a command to the <pid> process", cli_parse_default, NULL, NULL, NULL, ACCESS_MASTER_ONLY},
2397 { { "@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 +02002398 { { "help", NULL }, NULL, cli_parse_simple, NULL },
2399 { { "prompt", NULL }, NULL, cli_parse_simple, NULL },
2400 { { "quit", NULL }, NULL, cli_parse_simple, NULL },
Willy Tarreau2af99412016-11-23 11:10:59 +01002401 { { "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 +01002402 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002403 { { "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 +01002404 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002405 { { "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 +02002406 { { "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 +02002407 { { "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 +01002408 { { "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 +02002409 { { "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 +02002410 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002411 {{},}
2412}};
2413
William Lallemand74c24fb2016-11-21 17:18:36 +01002414static struct cfg_kw_list cfg_kws = {ILH, {
2415 { CFG_GLOBAL, "stats", stats_parse_global },
2416 { 0, NULL, NULL },
2417}};
2418
2419static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02002420 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
2421 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002422 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01002423 { NULL, NULL, 0 },
2424}};
2425
2426__attribute__((constructor))
2427static void __dumpstats_module_init(void)
2428{
2429 cfg_register_keywords(&cfg_kws);
Willy Tarreau0a739292016-11-22 20:21:23 +01002430 cli_register_kw(&cli_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01002431 bind_register_keywords(&bind_kws);
2432}
2433
2434/*
2435 * Local variables:
2436 * c-indent-level: 8
2437 * c-basic-offset: 8
2438 * End:
2439 */