blob: 25f72eae5dcf6c1861421a456ce9a59037f21f8c [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>
Willy Tarreau0108d902018-11-25 19:14:37 +010033#include <common/initcall.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010034#include <common/memory.h>
35#include <common/mini-clist.h>
36#include <common/standard.h>
37#include <common/ticks.h>
38#include <common/time.h>
39#include <common/uri_auth.h>
40#include <common/version.h>
41#include <common/base64.h>
42
43#include <types/applet.h>
44#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>
Willy Tarreau9d008692019-08-09 11:21:01 +020052#include <proto/cli.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010053#include <proto/compression.h>
William Lallemand9ed62032016-11-21 17:49:11 +010054#include <proto/stats.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010055#include <proto/fd.h>
56#include <proto/freq_ctr.h>
57#include <proto/frontend.h>
58#include <proto/log.h>
59#include <proto/pattern.h>
60#include <proto/pipe.h>
William Lallemandce83b4a2018-10-26 14:47:30 +020061#include <proto/protocol.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010062#include <proto/listener.h>
63#include <proto/map.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010064#include <proto/proxy.h>
65#include <proto/sample.h>
66#include <proto/session.h>
67#include <proto/stream.h>
68#include <proto/server.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010069#include <proto/stream_interface.h>
70#include <proto/task.h>
71
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 Lallemand8a022572018-10-26 14:47:35 +020097static struct proxy *mworker_proxy; /* CLI proxy of the master */
98
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020099static char *cli_gen_usage_msg(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100100{
101 struct cli_kw_list *kw_list;
102 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +0200103 struct buffer *tmp = get_trash_chunk();
104 struct buffer out;
William Lallemand74c24fb2016-11-21 17:18:36 +0100105
106 free(dynamic_usage_msg);
107 dynamic_usage_msg = NULL;
108
109 if (LIST_ISEMPTY(&cli_keywords.list))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200110 goto end;
William Lallemand74c24fb2016-11-21 17:18:36 +0100111
112 chunk_reset(tmp);
113 chunk_strcat(tmp, stats_sock_usage_msg);
114 list_for_each_entry(kw_list, &cli_keywords.list, list) {
115 kw = &kw_list->kw[0];
William Lallemand0154edc2018-05-15 11:50:04 +0200116 while (kw->str_kw[0]) {
William Lallemand14721be2018-10-26 14:47:37 +0200117
118 /* in a worker or normal process, don't display master only commands */
119 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
120 goto next_kw;
121
122 /* in master don't displays if we don't have the master bits */
123 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
124 goto next_kw;
125
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200126 /* only show expert commands in expert mode */
127 if ((kw->level & ~appctx->cli_level) & ACCESS_EXPERT)
128 goto next_kw;
129
William Lallemand0154edc2018-05-15 11:50:04 +0200130 if (kw->usage)
131 chunk_appendf(tmp, " %s\n", kw->usage);
William Lallemand14721be2018-10-26 14:47:37 +0200132
133next_kw:
134
William Lallemand74c24fb2016-11-21 17:18:36 +0100135 kw++;
136 }
137 }
138 chunk_init(&out, NULL, 0);
139 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200140 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200141
142end:
143 if (dynamic_usage_msg) {
144 appctx->ctx.cli.severity = LOG_INFO;
145 appctx->ctx.cli.msg = dynamic_usage_msg;
146 }
147 else {
148 appctx->ctx.cli.severity = LOG_INFO;
149 appctx->ctx.cli.msg = stats_sock_usage_msg;
150 }
151 appctx->st0 = CLI_ST_PRINT;
152
William Lallemand74c24fb2016-11-21 17:18:36 +0100153 return dynamic_usage_msg;
154}
155
156struct cli_kw* cli_find_kw(char **args)
157{
158 struct cli_kw_list *kw_list;
159 struct cli_kw *kw;/* current cli_kw */
160 char **tmp_args;
161 const char **tmp_str_kw;
162 int found = 0;
163
164 if (LIST_ISEMPTY(&cli_keywords.list))
165 return NULL;
166
167 list_for_each_entry(kw_list, &cli_keywords.list, list) {
168 kw = &kw_list->kw[0];
169 while (*kw->str_kw) {
170 tmp_args = args;
171 tmp_str_kw = kw->str_kw;
172 while (*tmp_str_kw) {
173 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
174 found = 1;
175 } else {
176 found = 0;
177 break;
178 }
179 tmp_args++;
180 tmp_str_kw++;
181 }
182 if (found)
183 return (kw);
184 kw++;
185 }
186 }
187 return NULL;
188}
189
190void cli_register_kw(struct cli_kw_list *kw_list)
191{
192 LIST_ADDQ(&cli_keywords.list, &kw_list->list);
193}
194
195
196/* allocate a new stats frontend named <name>, and return it
197 * (or NULL in case of lack of memory).
198 */
199static struct proxy *alloc_stats_fe(const char *name, const char *file, int line)
200{
201 struct proxy *fe;
202
203 fe = calloc(1, sizeof(*fe));
204 if (!fe)
205 return NULL;
206
207 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100208 fe->next = proxies_list;
209 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100210 fe->last_change = now.tv_sec;
211 fe->id = strdup("GLOBAL");
212 fe->cap = PR_CAP_FE;
213 fe->maxconn = 10; /* default to 10 concurrent connections */
214 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
215 fe->conf.file = strdup(file);
216 fe->conf.line = line;
217 fe->accept = frontend_accept;
218 fe->default_target = &cli_applet.obj_type;
219
220 /* the stats frontend is the only one able to assign ID #0 */
221 fe->conf.id.key = fe->uuid = 0;
222 eb32_insert(&used_proxy_id, &fe->conf.id);
223 return fe;
224}
225
226/* This function parses a "stats" statement in the "global" section. It returns
227 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
228 * error message into the <err> buffer which will be preallocated. The trailing
229 * '\n' must not be written. The function must be called with <args> pointing to
230 * the first word after "stats".
231 */
232static int stats_parse_global(char **args, int section_type, struct proxy *curpx,
233 struct proxy *defpx, const char *file, int line,
234 char **err)
235{
236 struct bind_conf *bind_conf;
237 struct listener *l;
238
239 if (!strcmp(args[1], "socket")) {
240 int cur_arg;
241
242 if (*args[2] == 0) {
243 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
244 return -1;
245 }
246
247 if (!global.stats_fe) {
248 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
249 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
250 return -1;
251 }
252 }
253
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100254 bind_conf = bind_conf_alloc(global.stats_fe, file, line, args[2], xprt_get(XPRT_RAW));
William Lallemand07a62f72017-05-24 00:57:40 +0200255 bind_conf->level &= ~ACCESS_LVL_MASK;
256 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100257
258 if (!str2listener(args[2], global.stats_fe, bind_conf, file, line, err)) {
259 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
260 file, line, args[0], args[1], err && *err ? *err : "error");
261 return -1;
262 }
263
264 cur_arg = 3;
265 while (*args[cur_arg]) {
266 static int bind_dumped;
267 struct bind_kw *kw;
268
269 kw = bind_find_kw(args[cur_arg]);
270 if (kw) {
271 if (!kw->parse) {
272 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
273 args[0], args[1], args[cur_arg]);
274 return -1;
275 }
276
277 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, err) != 0) {
278 if (err && *err)
279 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
280 else
281 memprintf(err, "'%s %s' : error encountered while processing '%s'",
282 args[0], args[1], args[cur_arg]);
283 return -1;
284 }
285
286 cur_arg += 1 + kw->skip;
287 continue;
288 }
289
290 if (!bind_dumped) {
291 bind_dump_kws(err);
292 indent_msg(err, 4);
293 bind_dumped = 1;
294 }
295
296 memprintf(err, "'%s %s' : unknown keyword '%s'.%s%s",
297 args[0], args[1], args[cur_arg],
298 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
299 return -1;
300 }
301
302 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100303 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 */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100307 global.maxsock++; /* for the listening socket */
William Lallemand74c24fb2016-11-21 17:18:36 +0100308 }
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
Willy Tarreau9faebe32019-06-07 19:00:37 +0200314 if (res == PARSE_TIME_OVER) {
315 memprintf(err, "timer overflow in argument '%s' to '%s %s' (maximum value is 2147483647 ms or ~24.8 days)",
316 args[2], args[0], args[1]);
317 return -1;
318 }
319 else if (res == PARSE_TIME_UNDER) {
320 memprintf(err, "timer underflow in argument '%s' to '%s %s' (minimum non-null value is 1 ms)",
321 args[2], args[0], args[1]);
322 return -1;
323 }
324 else if (res) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100325 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
326 return -1;
327 }
328
329 if (!timeout) {
330 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
331 return -1;
332 }
333 if (!global.stats_fe) {
334 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
335 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
336 return -1;
337 }
338 }
339 global.stats_fe->timeout.client = MS_TO_TICKS(timeout);
340 }
341 else if (!strcmp(args[1], "maxconn")) {
342 int maxconn = atol(args[2]);
343
344 if (maxconn <= 0) {
345 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
346 return -1;
347 }
348
349 if (!global.stats_fe) {
350 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
351 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
352 return -1;
353 }
354 }
355 global.stats_fe->maxconn = maxconn;
356 }
357 else if (!strcmp(args[1], "bind-process")) { /* enable the socket only on some processes */
358 int cur_arg = 2;
359 unsigned long set = 0;
360
361 if (!global.stats_fe) {
362 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
363 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
364 return -1;
365 }
366 }
367
368 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100369 if (strcmp(args[cur_arg], "all") == 0) {
370 set = 0;
371 break;
372 }
Willy Tarreauff9c9142019-02-07 10:39:36 +0100373 if (parse_process_number(args[cur_arg], &set, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100374 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100375 return -1;
376 }
377 cur_arg++;
378 }
379 global.stats_fe->bind_proc = set;
380 }
381 else {
382 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
383 return -1;
384 }
385 return 0;
386}
387
William Lallemand33d29e22019-04-01 11:30:06 +0200388/*
William Lallemand9a37fd02019-04-12 16:09:24 +0200389 * This function exports the bound addresses of a <frontend> in the environment
390 * variable <varname>. Those addresses are separated by semicolons and prefixed
391 * with their type (abns@, unix@, sockpair@ etc)
392 * Return -1 upon error, 0 otherwise
William Lallemand33d29e22019-04-01 11:30:06 +0200393 */
William Lallemand9a37fd02019-04-12 16:09:24 +0200394int listeners_setenv(struct proxy *frontend, const char *varname)
William Lallemand33d29e22019-04-01 11:30:06 +0200395{
396 struct buffer *trash = get_trash_chunk();
397 struct bind_conf *bind_conf;
398
William Lallemand9a37fd02019-04-12 16:09:24 +0200399 if (frontend) {
400 list_for_each_entry(bind_conf, &frontend->conf.bind, by_fe) {
William Lallemand33d29e22019-04-01 11:30:06 +0200401 struct listener *l;
402
403 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
404 char addr[46];
405 char port[6];
406
William Lallemand620072b2019-04-12 16:09:25 +0200407 /* separate listener by semicolons */
408 if (trash->data)
409 chunk_appendf(trash, ";");
410
William Lallemand33d29e22019-04-01 11:30:06 +0200411 if (l->addr.ss_family == AF_UNIX) {
412 const struct sockaddr_un *un;
413
414 un = (struct sockaddr_un *)&l->addr;
415 if (un->sun_path[0] == '\0') {
416 chunk_appendf(trash, "abns@%s", un->sun_path+1);
417 } else {
418 chunk_appendf(trash, "unix@%s", un->sun_path);
419 }
420 } else if (l->addr.ss_family == AF_INET) {
421 addr_to_str(&l->addr, addr, sizeof(addr));
422 port_to_str(&l->addr, port, sizeof(port));
423 chunk_appendf(trash, "ipv4@%s:%s", addr, port);
424 } else if (l->addr.ss_family == AF_INET6) {
425 addr_to_str(&l->addr, addr, sizeof(addr));
426 port_to_str(&l->addr, port, sizeof(port));
427 chunk_appendf(trash, "ipv6@[%s]:%s", addr, port);
428 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
429 chunk_appendf(trash, "sockpair@%d", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
430 }
William Lallemand33d29e22019-04-01 11:30:06 +0200431 }
432 }
433 trash->area[trash->data++] = '\0';
William Lallemand9a37fd02019-04-12 16:09:24 +0200434 if (setenv(varname, trash->area, 1) < 0)
William Lallemand33d29e22019-04-01 11:30:06 +0200435 return -1;
436 }
437
438 return 0;
439}
440
William Lallemand9a37fd02019-04-12 16:09:24 +0200441int cli_socket_setenv()
442{
443 if (listeners_setenv(global.stats_fe, "HAPROXY_CLI") < 0)
444 return -1;
445 if (listeners_setenv(mworker_proxy, "HAPROXY_MASTER_CLI") < 0)
446 return -1;
447
448 return 0;
449}
450
William Lallemand33d29e22019-04-01 11:30:06 +0200451REGISTER_CONFIG_POSTPARSER("cli", cli_socket_setenv);
452
Willy Tarreaude57a572016-11-23 17:01:39 +0100453/* Verifies that the CLI at least has a level at least as high as <level>
454 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
455 * failure, an error message is prepared and the appctx's state is adjusted
456 * to print it so that a return 1 is enough to abort any processing.
457 */
458int cli_has_level(struct appctx *appctx, int level)
459{
Willy Tarreaude57a572016-11-23 17:01:39 +0100460
William Lallemandf630d012018-12-13 09:05:44 +0100461 if ((appctx->cli_level & ACCESS_LVL_MASK) < level) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200462 cli_err(appctx, stats_permission_denied_msg);
Willy Tarreaude57a572016-11-23 17:01:39 +0100463 return 0;
464 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100465 return 1;
466}
467
William Lallemandb7ea1412018-12-13 09:05:47 +0100468/* same as cli_has_level but for the CLI proxy and without error message */
469int pcli_has_level(struct stream *s, int level)
470{
471 if ((s->pcli_flags & ACCESS_LVL_MASK) < level) {
472 return 0;
473 }
474 return 1;
475}
476
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200477/* Returns severity_output for the current session if set, or default for the socket */
478static int cli_get_severity_output(struct appctx *appctx)
479{
480 if (appctx->cli_severity_output)
481 return appctx->cli_severity_output;
482 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
483}
William Lallemand74c24fb2016-11-21 17:18:36 +0100484
Willy Tarreau41908562016-11-24 16:23:38 +0100485/* Processes the CLI interpreter on the stats socket. This function is called
486 * from the CLI's IO handler running in an appctx context. The function returns 1
487 * if the request was understood, otherwise zero. It is called with appctx->st0
488 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
489 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
490 * have its own I/O handler called again. Most of the time, parsers will only
491 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100492 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
493 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100494 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200495static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100496{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200497 char *args[MAX_STATS_ARGS + 1], *p, *end, *payload = NULL;
498 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100499 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100500
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200501 appctx->st2 = 0;
502 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
Willy Tarreau300decc2019-08-30 08:05:03 +0200503 LIST_INIT(&appctx->ctx.cli.l0);
William Lallemand74c24fb2016-11-21 17:18:36 +0100504
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200505 p = appctx->chunk->area;
506 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100507
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200508 /*
509 * Get the payload start if there is one.
510 * For the sake of simplicity, the payload pattern is looked up
511 * everywhere from the start of the input but it can only be found
512 * at the end of the first line if APPCTX_CLI_ST1_PAYLOAD is set.
513 *
514 * The input string was zero terminated so it is safe to use
515 * the str*() functions throughout the parsing
516 */
517 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
518 payload = strstr(p, PAYLOAD_PATTERN);
519 end = payload;
520 /* skip the pattern */
521 payload += strlen(PAYLOAD_PATTERN);
522 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100523
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200524 /*
525 * Get pointers on words.
526 * One extra slot is reserved to store a pointer on a null byte.
527 */
528 while (i < MAX_STATS_ARGS && p < end) {
529 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100530
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200531 /* skip leading spaces/tabs */
532 p += strspn(p, " \t");
533 if (!*p)
534 break;
William Lallemand74c24fb2016-11-21 17:18:36 +0100535
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200536 args[i] = p;
537 p += strcspn(p, " \t");
538 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100539
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200540 /* unescape backslashes (\) */
541 for (j = 0, k = 0; args[i][k]; k++) {
542 if (args[i][k] == '\\') {
543 if (args[i][k + 1] == '\\')
544 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100545 else
546 continue;
547 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200548 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100549 j++;
550 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200551 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100552
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200553 i++;
554 }
555 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200556 p = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200557 for (; i < MAX_STATS_ARGS + 1; i++)
558 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100559
560 kw = cli_find_kw(args);
Willy Tarreaueaffde32016-12-16 17:59:25 +0100561 if (!kw)
Willy Tarreau41908562016-11-24 16:23:38 +0100562 return 0;
563
William Lallemand14721be2018-10-26 14:47:37 +0200564 /* in a worker or normal process, don't display master only commands */
565 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
566 return 0;
567
568 /* in master don't displays if we don't have the master bits */
569 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
570 return 0;
571
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200572 /* only accept expert commands in expert mode */
573 if ((kw->level & ~appctx->cli_level) & ACCESS_EXPERT)
574 return 0;
575
Willy Tarreau41908562016-11-24 16:23:38 +0100576 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200577 appctx->io_release = kw->io_release;
William Lallemand90b098c2019-10-25 21:10:14 +0200578
579 if (kw->parse && kw->parse(args, payload, appctx, kw->private) != 0)
580 goto fail;
581
582 /* kw->parse could set its own io_handler or io_release handler */
583 if (!appctx->io_handler)
584 goto fail;
585
586 appctx->st0 = CLI_ST_CALLBACK;
587 return 1;
588fail:
589 appctx->io_handler = NULL;
590 appctx->io_release = NULL;
Willy Tarreau41908562016-11-24 16:23:38 +0100591 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100592}
593
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200594/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
595static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
596{
Willy Tarreau83061a82018-07-13 11:56:34 +0200597 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200598
599 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200600 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200601
602 tmp = get_trash_chunk();
603 chunk_reset(tmp);
604
605 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100606 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200607 chunk_printf(tmp, "[%d]: ", severity);
608 }
609 else {
610 switch (severity_output) {
611 case CLI_SEVERITY_NUMBER:
612 chunk_printf(tmp, "[%d]: ", severity);
613 break;
614 case CLI_SEVERITY_STRING:
615 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
616 break;
617 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100618 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200619 }
620 }
621 chunk_appendf(tmp, "%s", msg);
622
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200623 return ci_putblk(chn, tmp->area, strlen(tmp->area));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200624}
625
William Lallemand74c24fb2016-11-21 17:18:36 +0100626/* This I/O handler runs as an applet embedded in a stream interface. It is
627 * used to processes I/O from/to the stats unix socket. The system relies on a
628 * state machine handling requests and various responses. We read a request,
629 * then we process it and send the response, and we possibly display a prompt.
630 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100631 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100632 * or not.
633 */
634static void cli_io_handler(struct appctx *appctx)
635{
636 struct stream_interface *si = appctx->owner;
637 struct channel *req = si_oc(si);
638 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200639 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100640 int reql;
641 int len;
642
643 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
644 goto out;
645
Joseph Herlant008b3ce2018-11-25 12:51:45 -0800646 /* Check if the input buffer is available. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200647 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +0100648 /* buf.size==0 means we failed to get a buffer and were
649 * already subscribed to a wait list to get a buffer.
650 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100651 goto out;
652 }
653
William Lallemand74c24fb2016-11-21 17:18:36 +0100654 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100655 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100656 /* Stats output not initialized yet */
657 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200658 /* reset severity to default at init */
659 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100660 appctx->st0 = CLI_ST_GETREQ;
William Lallemandf630d012018-12-13 09:05:44 +0100661 appctx->cli_level = bind_conf->level;
William Lallemand74c24fb2016-11-21 17:18:36 +0100662 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100663 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100664 /* Let's close for real now. We just close the request
665 * side, the conditions below will complete if needed.
666 */
667 si_shutw(si);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200668 free_trash_chunk(appctx->chunk);
William Lallemand74c24fb2016-11-21 17:18:36 +0100669 break;
670 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100671 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200672 char *str;
673
674 /* use a trash chunk to store received data */
675 if (!appctx->chunk) {
676 appctx->chunk = alloc_trash_chunk();
677 if (!appctx->chunk) {
678 appctx->st0 = CLI_ST_END;
679 continue;
680 }
681 }
682
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200683 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200684
William Lallemand74c24fb2016-11-21 17:18:36 +0100685 /* ensure we have some output room left in the event we
686 * would want to return some info right after parsing.
687 */
688 if (buffer_almost_full(si_ib(si))) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100689 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100690 break;
691 }
692
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200693 /* '- 1' is to ensure a null byte can always be inserted at the end */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200694 reql = co_getline(si_oc(si), str,
695 appctx->chunk->size - appctx->chunk->data - 1);
William Lallemand74c24fb2016-11-21 17:18:36 +0100696 if (reql <= 0) { /* closed or EOL not found */
697 if (reql == 0)
698 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100699 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100700 continue;
701 }
702
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200703 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
704 /* seek for a possible unescaped semi-colon. If we find
705 * one, we replace it with an LF and skip only this part.
706 */
707 for (len = 0; len < reql; len++) {
708 if (str[len] == '\\') {
709 len++;
710 continue;
711 }
712 if (str[len] == ';') {
713 str[len] = '\n';
714 reql = len + 1;
715 break;
716 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100717 }
718 }
719
720 /* now it is time to check that we have a full line,
721 * remove the trailing \n and possibly \r, then cut the
722 * line.
723 */
724 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200725 if (str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100726 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100727 continue;
728 }
729
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200730 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100731 len--;
732
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200733 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200734 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200735
736 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200737 appctx->chunk->area[appctx->chunk->data] = '\n';
738 appctx->chunk->area[appctx->chunk->data + 1] = 0;
739 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200740 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100741
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100742 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200743
744 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
745 /* empty line */
746 if (!len) {
747 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200748 appctx->chunk->data -= 2;
749 appctx->chunk->area[appctx->chunk->data] = 0;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200750
751 if (!cli_parse_request(appctx))
752 cli_gen_usage_msg(appctx);
753
754 chunk_reset(appctx->chunk);
755 /* NB: cli_sock_parse_request() may have put
756 * another CLI_ST_O_* into appctx->st0.
757 */
758
759 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +0100760 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100761 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200762 else {
763 /*
764 * Look for the "payload start" pattern at the end of a line
765 * Its location is not remembered here, this is just to switch
766 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +0100767 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200768 if (!strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200769 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200770 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200771 /* no payload, the command is complete: parse the request */
772 if (!cli_parse_request(appctx))
773 cli_gen_usage_msg(appctx);
774
775 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200776 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100777 }
778
779 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200780 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100781 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
782 }
783 else { /* output functions */
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200784 const char *msg;
785 int sev;
786
William Lallemand74c24fb2016-11-21 17:18:36 +0100787 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100788 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100789 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200790 case CLI_ST_PRINT: /* print const message in msg */
791 case CLI_ST_PRINT_ERR: /* print const error in msg */
792 case CLI_ST_PRINT_DYN: /* print dyn message in msg, free */
793 case CLI_ST_PRINT_FREE: /* print dyn error in err, free */
794 if (appctx->st0 == CLI_ST_PRINT || appctx->st0 == CLI_ST_PRINT_ERR) {
795 sev = appctx->st0 == CLI_ST_PRINT_ERR ?
796 LOG_ERR : appctx->ctx.cli.severity;
797 msg = appctx->ctx.cli.msg;
798 }
799 else if (appctx->st0 == CLI_ST_PRINT_DYN || appctx->st0 == CLI_ST_PRINT_FREE) {
800 sev = appctx->st0 == CLI_ST_PRINT_FREE ?
801 LOG_ERR : appctx->ctx.cli.severity;
802 msg = appctx->ctx.cli.err;
803 if (!msg) {
804 sev = LOG_ERR;
805 msg = "Out of memory.\n";
806 }
807 }
808 else {
809 sev = LOG_ERR;
810 msg = "Internal error.\n";
811 }
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200812
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200813 if (cli_output_msg(res, msg, sev, cli_get_severity_output(appctx)) != -1) {
814 if (appctx->st0 == CLI_ST_PRINT_FREE ||
815 appctx->st0 == CLI_ST_PRINT_DYN) {
816 free(appctx->ctx.cli.err);
817 appctx->ctx.cli.err = NULL;
818 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100819 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100820 }
821 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100822 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100823 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200824
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100825 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100826 if (appctx->io_handler)
827 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100828 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100829 if (appctx->io_release) {
830 appctx->io_release(appctx);
831 appctx->io_release = NULL;
832 }
833 }
834 break;
835 default: /* abnormal state */
836 si->flags |= SI_FL_ERR;
837 break;
838 }
839
840 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100841 if (appctx->st0 == CLI_ST_PROMPT) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200842 const char *prompt = "";
843
844 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
845 /*
846 * when entering a payload with interactive mode, change the prompt
847 * to emphasize that more data can still be sent
848 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200849 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200850 prompt = "+ ";
851 else
852 prompt = "\n> ";
853 }
854 else {
William Lallemandad032882019-07-01 10:56:15 +0200855 if (!(appctx->st1 & (APPCTX_CLI_ST1_PAYLOAD|APPCTX_CLI_ST1_NOLF)))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200856 prompt = "\n";
857 }
858
859 if (ci_putstr(si_ic(si), prompt) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100860 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100861 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100862 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100863 }
864
865 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100866 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100867 break;
868
869 /* Now we close the output if one of the writers did so,
870 * or if we're not in interactive mode and the request
871 * buffer is empty. This still allows pipelined requests
872 * to be sent in non-interactive mode.
873 */
William Lallemand3de09d52018-12-11 16:10:56 +0100874 if (((res->flags & (CF_SHUTW|CF_SHUTW_NOW))) ||
875 (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req) && (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)))) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100876 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100877 continue;
878 }
879
880 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100881 appctx->st0 = CLI_ST_GETREQ;
William Lallemandad032882019-07-01 10:56:15 +0200882 /* reactivate the \n at the end of the response for the next command */
883 appctx->st1 &= ~APPCTX_CLI_ST1_NOLF;
William Lallemand74c24fb2016-11-21 17:18:36 +0100884 }
885 }
886
887 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
888 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
889 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
890 /* Other side has closed, let's abort if we have no more processing to do
891 * and nothing more to consume. This is comparable to a broken pipe, so
892 * we forward the close to the request side so that it flows upstream to
893 * the client.
894 */
895 si_shutw(si);
896 }
897
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100898 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100899 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
900 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
901 /* We have no more processing to do, and nothing more to send, and
902 * the client side has closed. So we'll forward this state downstream
903 * on the response buffer.
904 */
905 si_shutr(si);
906 res->flags |= CF_READ_NULL;
907 }
908
909 out:
Christopher Faulet45073512018-07-20 10:16:29 +0200910 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 +0100911 __FUNCTION__, __LINE__,
Christopher Faulet45073512018-07-20 10:16:29 +0200912 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 +0100913}
914
William Lallemand74c24fb2016-11-21 17:18:36 +0100915/* This is called when the stream interface is closed. For instance, upon an
916 * external abort, we won't call the i/o handler anymore so we may need to
917 * remove back references to the stream currently being dumped.
918 */
919static void cli_release_handler(struct appctx *appctx)
920{
921 if (appctx->io_release) {
922 appctx->io_release(appctx);
923 appctx->io_release = NULL;
924 }
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200925 else if (appctx->st0 == CLI_ST_PRINT_FREE || appctx->st0 == CLI_ST_PRINT_DYN) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100926 free(appctx->ctx.cli.err);
927 appctx->ctx.cli.err = NULL;
928 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100929}
930
931/* This function dumps all environmnent variables to the buffer. It returns 0
932 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +0100933 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
934 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +0100935 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100936static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100937{
Willy Tarreau0a739292016-11-22 20:21:23 +0100938 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100939 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100940
941 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
942 return 1;
943
944 chunk_reset(&trash);
945
946 /* we have two inner loops here, one for the proxy, the other one for
947 * the buffer.
948 */
Willy Tarreauf6710f82016-12-16 17:45:44 +0100949 while (*var) {
950 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +0100951
Willy Tarreau06d80a92017-10-19 14:32:15 +0200952 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100953 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100954 return 0;
955 }
956 if (appctx->st2 == STAT_ST_END)
957 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100958 var++;
959 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +0100960 }
961
962 /* dump complete */
963 return 1;
964}
965
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200966/* This function dumps all file descriptors states (or the requested one) to
967 * the buffer. It returns 0 if the output buffer is full and it needs to be
968 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
969 * It uses cli.i0 as the fd number to restart from.
970 */
971static int cli_io_handler_show_fd(struct appctx *appctx)
972{
973 struct stream_interface *si = appctx->owner;
974 int fd = appctx->ctx.cli.i0;
Willy Tarreauca1b1572018-12-18 15:45:11 +0100975 int ret = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200976
977 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
Willy Tarreauca1b1572018-12-18 15:45:11 +0100978 goto end;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200979
980 chunk_reset(&trash);
981
Willy Tarreauca1b1572018-12-18 15:45:11 +0100982 /* isolate the threads once per round. We're limited to a buffer worth
983 * of output anyway, it cannot last very long.
984 */
985 thread_isolate();
986
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200987 /* we have two inner loops here, one for the proxy, the other one for
988 * the buffer.
989 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +0100990 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200991 struct fdtab fdt;
Willy Tarreau286ec682017-08-09 16:35:44 +0200992 struct listener *li = NULL;
993 struct server *sv = NULL;
994 struct proxy *px = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +0200995 const struct mux_ops *mux = NULL;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200996 void *ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +0200997 uint32_t conn_flags = 0;
Willy Tarreaue9ca8072018-12-19 18:40:58 +0100998 int is_back = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200999
1000 fdt = fdtab[fd];
1001
Willy Tarreauca1b1572018-12-18 15:45:11 +01001002 if (!fdt.owner)
Willy Tarreau017af242017-10-04 20:24:54 +02001003 goto skip; // closed
1004
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001005 if (fdt.iocb == conn_fd_handler) {
1006 conn_flags = ((struct connection *)fdt.owner)->flags;
Willy Tarreau35b1b482018-03-28 18:41:30 +02001007 mux = ((struct connection *)fdt.owner)->mux;
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001008 ctx = ((struct connection *)fdt.owner)->ctx;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001009 li = objt_listener(((struct connection *)fdt.owner)->target);
1010 sv = objt_server(((struct connection *)fdt.owner)->target);
1011 px = objt_proxy(((struct connection *)fdt.owner)->target);
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001012 is_back = conn_is_back((struct connection *)fdt.owner);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001013 }
1014 else if (fdt.iocb == listener_accept)
1015 li = fdt.owner;
1016
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001017 chunk_printf(&trash,
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001018 " %5d : st=0x%02x(R:%c%c W:%c%c) ev=0x%02x(%c%c%c%c%c) [%c%c] tmask=0x%lx umask=0x%lx owner=%p iocb=%p(",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001019 fd,
1020 fdt.state,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001021 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
1022 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001023 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
1024 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
1025 fdt.ev,
1026 (fdt.ev & FD_POLL_HUP) ? 'H' : 'h',
1027 (fdt.ev & FD_POLL_ERR) ? 'E' : 'e',
1028 (fdt.ev & FD_POLL_OUT) ? 'O' : 'o',
1029 (fdt.ev & FD_POLL_PRI) ? 'P' : 'p',
1030 (fdt.ev & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001031 fdt.linger_risk ? 'L' : 'l',
1032 fdt.cloned ? 'C' : 'c',
Willy Tarreauc754b342018-03-30 15:00:15 +02001033 fdt.thread_mask, fdt.update_mask,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001034 fdt.owner,
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001035 fdt.iocb);
1036 resolve_sym_name(&trash, NULL, fdt.iocb);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001037
1038 if (fdt.iocb == conn_fd_handler) {
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001039 chunk_appendf(&trash, ") back=%d cflg=0x%08x", is_back, conn_flags);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001040 if (px)
1041 chunk_appendf(&trash, " px=%s", px->id);
1042 else if (sv)
1043 chunk_appendf(&trash, " sv=%s/%s", sv->id, sv->proxy->id);
1044 else if (li)
1045 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +02001046
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001047 if (mux) {
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001048 chunk_appendf(&trash, " mux=%s ctx=%p", mux->name, ctx);
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001049 if (mux->show_fd)
1050 mux->show_fd(&trash, fdt.owner);
1051 }
Willy Tarreau35b1b482018-03-28 18:41:30 +02001052 else
1053 chunk_appendf(&trash, " nomux");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001054 }
1055 else if (fdt.iocb == listener_accept) {
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001056 chunk_appendf(&trash, ") l.st=%s fe=%s",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001057 listener_state_str(li),
1058 li->bind_conf->frontend->id);
1059 }
1060
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001061 chunk_appendf(&trash, ")\n");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001062
Willy Tarreau06d80a92017-10-19 14:32:15 +02001063 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001064 si_rx_room_blk(si);
Willy Tarreauca1b1572018-12-18 15:45:11 +01001065 appctx->ctx.cli.i0 = fd;
1066 ret = 0;
1067 break;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001068 }
1069 skip:
1070 if (appctx->st2 == STAT_ST_END)
1071 break;
1072
1073 fd++;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001074 }
1075
Willy Tarreauca1b1572018-12-18 15:45:11 +01001076 end:
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001077 /* dump complete */
Willy Tarreauca1b1572018-12-18 15:45:11 +01001078
1079 thread_release();
1080 return ret;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001081}
1082
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001083/* This function dumps some activity counters used by developers and support to
1084 * rule out some hypothesis during bug reports. It returns 0 if the output
1085 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
1086 * everything at once in the buffer and is not designed to do it in multiple
1087 * passes.
1088 */
1089static int cli_io_handler_show_activity(struct appctx *appctx)
1090{
1091 struct stream_interface *si = appctx->owner;
1092 int thr;
1093
1094 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1095 return 1;
1096
1097 chunk_reset(&trash);
1098
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001099#undef SHOW_TOT
1100#define SHOW_TOT(t, x) \
Willy Tarreaua0211b82019-05-28 15:09:08 +02001101 do { \
1102 unsigned int _v[MAX_THREADS]; \
1103 unsigned int _tot; \
1104 const unsigned int _nbt = global.nbthread; \
1105 for (_tot = t = 0; t < _nbt; t++) \
1106 _tot += _v[t] = (x); \
1107 if (_nbt == 1) { \
1108 chunk_appendf(&trash, " %u\n", _tot); \
1109 break; \
1110 } \
1111 chunk_appendf(&trash, " %u [", _tot); \
1112 for (t = 0; t < _nbt; t++) \
1113 chunk_appendf(&trash, " %u", _v[t]); \
1114 chunk_appendf(&trash, " ]\n"); \
1115 } while (0)
1116
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001117#undef SHOW_AVG
1118#define SHOW_AVG(t, x) \
1119 do { \
1120 unsigned int _v[MAX_THREADS]; \
1121 unsigned int _tot; \
1122 const unsigned int _nbt = global.nbthread; \
1123 for (_tot = t = 0; t < _nbt; t++) \
1124 _tot += _v[t] = (x); \
1125 if (_nbt == 1) { \
1126 chunk_appendf(&trash, " %u\n", _tot); \
1127 break; \
1128 } \
1129 chunk_appendf(&trash, " %u [", (_tot + _nbt/2) / _nbt); \
1130 for (t = 0; t < _nbt; t++) \
1131 chunk_appendf(&trash, " %u", _v[t]); \
1132 chunk_appendf(&trash, " ]\n"); \
1133 } while (0)
1134
Willy Tarreaua0211b82019-05-28 15:09:08 +02001135 chunk_appendf(&trash, "thread_id: %u (%u..%u)\n", tid + 1, 1, global.nbthread);
1136 chunk_appendf(&trash, "date_now: %lu.%06lu\n", (long)now.tv_sec, (long)now.tv_usec);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001137 chunk_appendf(&trash, "loops:"); SHOW_TOT(thr, activity[thr].loops);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001138 chunk_appendf(&trash, "wake_tasks:"); SHOW_TOT(thr, activity[thr].wake_tasks);
1139 chunk_appendf(&trash, "wake_signal:"); SHOW_TOT(thr, activity[thr].wake_signal);
1140 chunk_appendf(&trash, "poll_exp:"); SHOW_TOT(thr, activity[thr].poll_exp);
1141 chunk_appendf(&trash, "poll_drop:"); SHOW_TOT(thr, activity[thr].poll_drop);
1142 chunk_appendf(&trash, "poll_dead:"); SHOW_TOT(thr, activity[thr].poll_dead);
1143 chunk_appendf(&trash, "poll_skip:"); SHOW_TOT(thr, activity[thr].poll_skip);
1144 chunk_appendf(&trash, "fd_lock:"); SHOW_TOT(thr, activity[thr].fd_lock);
1145 chunk_appendf(&trash, "conn_dead:"); SHOW_TOT(thr, activity[thr].conn_dead);
1146 chunk_appendf(&trash, "stream:"); SHOW_TOT(thr, activity[thr].stream);
Willy Tarreaua8b2ce02019-05-28 17:04:16 +02001147 chunk_appendf(&trash, "pool_fail:"); SHOW_TOT(thr, activity[thr].pool_fail);
1148 chunk_appendf(&trash, "buf_wait:"); SHOW_TOT(thr, activity[thr].buf_wait);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001149 chunk_appendf(&trash, "empty_rq:"); SHOW_TOT(thr, activity[thr].empty_rq);
1150 chunk_appendf(&trash, "long_rq:"); SHOW_TOT(thr, activity[thr].long_rq);
1151 chunk_appendf(&trash, "ctxsw:"); SHOW_TOT(thr, activity[thr].ctxsw);
1152 chunk_appendf(&trash, "tasksw:"); SHOW_TOT(thr, activity[thr].tasksw);
1153 chunk_appendf(&trash, "cpust_ms_tot:"); SHOW_TOT(thr, activity[thr].cpust_total / 2);
1154 chunk_appendf(&trash, "cpust_ms_1s:"); SHOW_TOT(thr, read_freq_ctr(&activity[thr].cpust_1s) / 2);
1155 chunk_appendf(&trash, "cpust_ms_15s:"); SHOW_TOT(thr, read_freq_ctr_period(&activity[thr].cpust_15s, 15000) / 2);
1156 chunk_appendf(&trash, "avg_loop_us:"); SHOW_AVG(thr, swrate_avg(activity[thr].avg_loop_us, TIME_STATS_SAMPLES));
1157 chunk_appendf(&trash, "accepted:"); SHOW_TOT(thr, activity[thr].accepted);
1158 chunk_appendf(&trash, "accq_pushed:"); SHOW_TOT(thr, activity[thr].accq_pushed);
1159 chunk_appendf(&trash, "accq_full:"); SHOW_TOT(thr, activity[thr].accq_full);
Willy Tarreaue6182842019-04-15 18:54:10 +02001160#ifdef USE_THREAD
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001161 chunk_appendf(&trash, "accq_ring:"); SHOW_TOT(thr, (accept_queue_rings[thr].tail - accept_queue_rings[thr].head + ACCEPT_QUEUE_SIZE) % ACCEPT_QUEUE_SIZE);
Willy Tarreaue6182842019-04-15 18:54:10 +02001162#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001163
Willy Tarreaud6a78502019-05-27 07:03:38 +02001164#if defined(DEBUG_DEV)
1165 /* keep these ones at the end */
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001166 chunk_appendf(&trash, "ctr0:"); SHOW_TOT(thr, activity[thr].ctr0);
1167 chunk_appendf(&trash, "ctr1:"); SHOW_TOT(thr, activity[thr].ctr1);
1168 chunk_appendf(&trash, "ctr2:"); SHOW_TOT(thr, activity[thr].ctr2);
Willy Tarreaud6a78502019-05-27 07:03:38 +02001169#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001170
1171 if (ci_putchk(si_ic(si), &trash) == -1) {
1172 chunk_reset(&trash);
1173 chunk_printf(&trash, "[output too large, cannot dump]\n");
Willy Tarreaudb398432018-11-15 11:08:52 +01001174 si_rx_room_blk(si);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001175 }
1176
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001177#undef SHOW_AVG
1178#undef SHOW_TOT
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001179 /* dump complete */
1180 return 1;
1181}
1182
William Lallemandeceddf72016-12-15 18:06:44 +01001183/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001184 * CLI IO handler for `show cli sockets`.
1185 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +01001186 */
1187static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1188{
1189 struct bind_conf *bind_conf;
1190 struct stream_interface *si = appctx->owner;
1191
1192 chunk_reset(&trash);
1193
1194 switch (appctx->st2) {
1195 case STAT_ST_INIT:
1196 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +02001197 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001198 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001199 return 0;
1200 }
William Lallemandeceddf72016-12-15 18:06:44 +01001201 appctx->st2 = STAT_ST_LIST;
1202
1203 case STAT_ST_LIST:
1204 if (global.stats_fe) {
1205 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
1206 struct listener *l;
1207
1208 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001209 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +01001210 * if the current node is the first of the list
1211 */
1212
Willy Tarreau3af9d832016-12-16 12:58:09 +01001213 if (appctx->ctx.cli.p0 &&
1214 &bind_conf->by_fe == (&global.stats_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +01001215 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +01001216 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +01001217 continue;
1218 }
1219
1220 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
1221
1222 char addr[46];
1223 char port[6];
1224
1225 if (l->addr.ss_family == AF_UNIX) {
1226 const struct sockaddr_un *un;
1227
1228 un = (struct sockaddr_un *)&l->addr;
William Lallemande58915f2019-04-01 11:30:05 +02001229 if (un->sun_path[0] == '\0') {
William Lallemand75812a72019-04-01 11:30:04 +02001230 chunk_appendf(&trash, "abns@%s ", un->sun_path+1);
William Lallemande58915f2019-04-01 11:30:05 +02001231 } else {
1232 chunk_appendf(&trash, "unix@%s ", un->sun_path);
1233 }
William Lallemandeceddf72016-12-15 18:06:44 +01001234 } else if (l->addr.ss_family == AF_INET) {
1235 addr_to_str(&l->addr, addr, sizeof(addr));
1236 port_to_str(&l->addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001237 chunk_appendf(&trash, "ipv4@%s:%s ", addr, port);
William Lallemandeceddf72016-12-15 18:06:44 +01001238 } else if (l->addr.ss_family == AF_INET6) {
1239 addr_to_str(&l->addr, addr, sizeof(addr));
1240 port_to_str(&l->addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001241 chunk_appendf(&trash, "ipv6@[%s]:%s ", addr, port);
William Lallemand26314342018-10-26 14:47:41 +02001242 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
1243 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
William Lallemandeceddf72016-12-15 18:06:44 +01001244 } else
William Lallemand26314342018-10-26 14:47:41 +02001245 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001246
William Lallemand07a62f72017-05-24 00:57:40 +02001247 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +01001248 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +02001249 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1250 chunk_appendf(&trash, "operator ");
1251 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1252 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +01001253 else
1254 chunk_appendf(&trash, " ");
1255
1256 if (bind_conf->bind_proc != 0) {
1257 int pos;
Willy Tarreau20c5e522016-12-16 12:50:55 +01001258 for (pos = 0; pos < 8 * sizeof(bind_conf->bind_proc); pos++) {
Willy Tarreau4305ac72016-12-16 12:56:31 +01001259 if (bind_conf->bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +01001260 chunk_appendf(&trash, "%d,", pos+1);
1261 }
1262 }
1263 /* replace the latest comma by a newline */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001264 trash.area[trash.data-1] = '\n';
William Lallemandeceddf72016-12-15 18:06:44 +01001265
1266 } else {
1267 chunk_appendf(&trash, "all\n");
1268 }
1269
Willy Tarreau06d80a92017-10-19 14:32:15 +02001270 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001271 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001272 return 0;
1273 }
1274 }
Willy Tarreau3af9d832016-12-16 12:58:09 +01001275 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001276 }
1277 }
1278 default:
1279 appctx->st2 = STAT_ST_FIN;
1280 return 1;
1281 }
1282}
1283
1284
Willy Tarreau0a739292016-11-22 20:21:23 +01001285/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001286 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1287 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001288 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001289static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001290{
1291 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001292 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001293
1294 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1295 return 1;
1296
Willy Tarreauf6710f82016-12-16 17:45:44 +01001297 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001298
1299 if (*args[2]) {
1300 int len = strlen(args[2]);
1301
Willy Tarreauf6710f82016-12-16 17:45:44 +01001302 for (; *var; var++) {
1303 if (strncmp(*var, args[2], len) == 0 &&
1304 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001305 break;
1306 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001307 if (!*var)
1308 return cli_err(appctx, "Variable not found\n");
1309
Willy Tarreau0a739292016-11-22 20:21:23 +01001310 appctx->st2 = STAT_ST_END;
1311 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001312 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001313 return 0;
1314}
1315
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001316/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1317 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1318 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1319 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001320static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001321{
1322 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1323 return 1;
1324
1325 appctx->ctx.cli.i0 = 0;
1326
1327 if (*args[2]) {
1328 appctx->ctx.cli.i0 = atoi(args[2]);
1329 appctx->st2 = STAT_ST_END;
1330 }
1331 return 0;
1332}
1333
Willy Tarreau599852e2016-11-22 20:33:32 +01001334/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001335static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001336{
1337 struct stream_interface *si = appctx->owner;
1338 struct stream *s = si_strm(si);
1339
1340 if (strcmp(args[2], "cli") == 0) {
1341 unsigned timeout;
1342 const char *res;
1343
Willy Tarreau9d008692019-08-09 11:21:01 +02001344 if (!*args[3])
1345 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001346
1347 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
Willy Tarreau9d008692019-08-09 11:21:01 +02001348 if (res || timeout < 1)
1349 return cli_err(appctx, "Invalid timeout value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001350
1351 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1352 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1353 return 1;
1354 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001355
1356 return cli_err(appctx, "'set timeout' only supports 'cli'.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001357}
1358
Willy Tarreau2af99412016-11-23 11:10:59 +01001359/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001360static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001361{
1362 int v;
1363
1364 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1365 return 1;
1366
Willy Tarreau9d008692019-08-09 11:21:01 +02001367 if (!*args[3])
1368 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001369
1370 v = atoi(args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001371 if (v > global.hardmaxconn)
1372 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001373
1374 /* check for unlimited values */
1375 if (v <= 0)
1376 v = global.hardmaxconn;
1377
1378 global.maxconn = v;
1379
1380 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001381 dequeue_all_listeners();
Willy Tarreau2af99412016-11-23 11:10:59 +01001382
1383 return 1;
1384}
1385
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001386static int set_severity_output(int *target, char *argument)
1387{
1388 if (!strcmp(argument, "none")) {
1389 *target = CLI_SEVERITY_NONE;
1390 return 1;
1391 }
1392 else if (!strcmp(argument, "number")) {
1393 *target = CLI_SEVERITY_NUMBER;
1394 return 1;
1395 }
1396 else if (!strcmp(argument, "string")) {
1397 *target = CLI_SEVERITY_STRING;
1398 return 1;
1399 }
1400 return 0;
1401}
1402
1403/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001404static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001405{
1406 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1407 return 0;
1408
Willy Tarreau9d008692019-08-09 11:21:01 +02001409 return cli_err(appctx, "one of 'none', 'number', 'string' is a required argument\n");
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001410}
William Lallemandeceddf72016-12-15 18:06:44 +01001411
William Lallemand67a234f2018-12-13 09:05:45 +01001412
1413/* show the level of the current CLI session */
1414static int cli_parse_show_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1415{
William Lallemand67a234f2018-12-13 09:05:45 +01001416 if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
Willy Tarreau9d008692019-08-09 11:21:01 +02001417 return cli_msg(appctx, LOG_INFO, "admin\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001418 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001419 return cli_msg(appctx, LOG_INFO, "operator\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001420 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001421 return cli_msg(appctx, LOG_INFO, "user\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001422 else
Willy Tarreau9d008692019-08-09 11:21:01 +02001423 return cli_msg(appctx, LOG_INFO, "unknown\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001424}
1425
1426/* parse and set the CLI level dynamically */
1427static int cli_parse_set_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1428{
William Lallemandad032882019-07-01 10:56:15 +02001429 /* this will ask the applet to not output a \n after the command */
1430 if (!strcmp(args[1], "-"))
1431 appctx->st1 |= APPCTX_CLI_ST1_NOLF;
1432
William Lallemand67a234f2018-12-13 09:05:45 +01001433 if (!strcmp(args[0], "operator")) {
1434 if (!cli_has_level(appctx, ACCESS_LVL_OPER)) {
1435 return 1;
1436 }
1437 appctx->cli_level &= ~ACCESS_LVL_MASK;
1438 appctx->cli_level |= ACCESS_LVL_OPER;
1439
1440 } else if (!strcmp(args[0], "user")) {
1441 if (!cli_has_level(appctx, ACCESS_LVL_USER)) {
1442 return 1;
1443 }
1444 appctx->cli_level &= ~ACCESS_LVL_MASK;
1445 appctx->cli_level |= ACCESS_LVL_USER;
1446 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001447 appctx->cli_level &= ~ACCESS_EXPERT;
1448 return 1;
1449}
1450
1451
1452/* parse and set the CLI expert-mode dynamically */
1453static int cli_parse_expert_mode(char **args, char *payload, struct appctx *appctx, void *private)
1454{
1455 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1456 return 1;
1457
1458 if (!*args[1])
1459 return (appctx->cli_level & ACCESS_EXPERT)
1460 ? cli_msg(appctx, LOG_INFO, "expert-mode is ON\n")
1461 : cli_msg(appctx, LOG_INFO, "expert-mode is OFF\n");
1462
1463 appctx->cli_level &= ~ACCESS_EXPERT;
1464 if (strcmp(args[1], "on") == 0)
1465 appctx->cli_level |= ACCESS_EXPERT;
William Lallemand67a234f2018-12-13 09:05:45 +01001466 return 1;
1467}
1468
William Lallemanda57b7e32018-12-14 21:11:31 +01001469
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001470int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001471{
1472 return 0;
1473}
1474
Willy Tarreau45c742b2016-11-24 14:51:17 +01001475/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001476static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001477{
1478 int v;
1479 int *res;
1480 int mul = 1;
1481
1482 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1483 return 1;
1484
1485 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1486 res = &global.cps_lim;
1487 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1488 res = &global.sps_lim;
1489#ifdef USE_OPENSSL
1490 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1491 res = &global.ssl_lim;
1492#endif
1493 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1494 res = &global.comp_rate_lim;
1495 mul = 1024;
1496 }
1497 else {
Willy Tarreau9d008692019-08-09 11:21:01 +02001498 return cli_err(appctx,
Willy Tarreau45c742b2016-11-24 14:51:17 +01001499 "'set rate-limit' only supports :\n"
1500 " - 'connections global' to set the per-process maximum connection rate\n"
1501 " - 'sessions global' to set the per-process maximum session rate\n"
1502#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001503 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001504#endif
Willy Tarreau9d008692019-08-09 11:21:01 +02001505 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001506 }
1507
Willy Tarreau9d008692019-08-09 11:21:01 +02001508 if (!*args[4])
1509 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001510
1511 v = atoi(args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001512 if (v < 0)
1513 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001514
1515 *res = v * mul;
1516
1517 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001518 dequeue_all_listeners();
Willy Tarreau45c742b2016-11-24 14:51:17 +01001519
1520 return 1;
1521}
1522
William Lallemandf6975e92017-05-26 17:42:10 +02001523/* parse the "expose-fd" argument on the bind lines */
1524static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1525{
1526 if (!*args[cur_arg + 1]) {
1527 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1528 return ERR_ALERT | ERR_FATAL;
1529 }
1530 if (!strcmp(args[cur_arg+1], "listeners")) {
1531 conf->level |= ACCESS_FD_LISTENERS;
1532 } else {
1533 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1534 args[cur_arg], args[cur_arg+1]);
1535 return ERR_ALERT | ERR_FATAL;
1536 }
1537
1538 return 0;
1539}
1540
William Lallemand74c24fb2016-11-21 17:18:36 +01001541/* parse the "level" argument on the bind lines */
1542static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1543{
1544 if (!*args[cur_arg + 1]) {
1545 memprintf(err, "'%s' : missing level", args[cur_arg]);
1546 return ERR_ALERT | ERR_FATAL;
1547 }
1548
William Lallemand07a62f72017-05-24 00:57:40 +02001549 if (!strcmp(args[cur_arg+1], "user")) {
1550 conf->level &= ~ACCESS_LVL_MASK;
1551 conf->level |= ACCESS_LVL_USER;
1552 } else if (!strcmp(args[cur_arg+1], "operator")) {
1553 conf->level &= ~ACCESS_LVL_MASK;
1554 conf->level |= ACCESS_LVL_OPER;
1555 } else if (!strcmp(args[cur_arg+1], "admin")) {
1556 conf->level &= ~ACCESS_LVL_MASK;
1557 conf->level |= ACCESS_LVL_ADMIN;
1558 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001559 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1560 args[cur_arg], args[cur_arg+1]);
1561 return ERR_ALERT | ERR_FATAL;
1562 }
1563
1564 return 0;
1565}
1566
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001567static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1568{
1569 if (!*args[cur_arg + 1]) {
1570 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1571 return ERR_ALERT | ERR_FATAL;
1572 }
1573
1574 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1575 return 0;
1576 else {
1577 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1578 args[cur_arg], args[cur_arg+1]);
1579 return ERR_ALERT | ERR_FATAL;
1580 }
1581}
1582
William Lallemandd308c5e2020-01-16 16:26:41 +01001583/*
1584 * For one proxy, fill the iov and send the msghdr. Also update fd_it and offset.
1585 * Return -1 upon error, otherwise 0.
1586 *
1587 * This function is only meant to deduplicate the code between the peers and
1588 * the proxy list in _getsocks(), not to be used anywhere else.
1589 */
1590inline static int _getsocks_gen_send(struct proxy *px, int sendfd, int *tmpfd, struct iovec *iov,
1591 int tot_fd_nb, int *fd_it, int *offset, struct msghdr *msghdr)
1592{
1593 int i = *fd_it;
1594 int curoff = *offset;
1595 struct listener *l;
1596 unsigned char *tmpbuf = iov->iov_base;
1597
1598 list_for_each_entry(l, &px->conf.listeners, by_fe) {
1599 int ret;
1600 /* Only transfer IPv4/IPv6 sockets */
1601 if (l->state >= LI_ZOMBIE &&
1602 (l->proto->sock_family == AF_INET ||
1603 l->proto->sock_family == AF_INET6 ||
1604 l->proto->sock_family == AF_UNIX)) {
1605 memcpy(&tmpfd[i % MAX_SEND_FD], &l->fd, sizeof(l->fd));
1606 if (!l->netns)
1607 tmpbuf[curoff++] = 0;
1608#ifdef USE_NS
1609 else {
1610 char *name = l->netns->node.key;
1611 unsigned char len = l->netns->name_len;
1612 tmpbuf[curoff++] = len;
1613 memcpy(tmpbuf + curoff, name, len);
1614 curoff += len;
1615 }
1616#endif
1617 if (l->interface) {
1618 unsigned char len = strlen(l->interface);
1619 tmpbuf[curoff++] = len;
1620 memcpy(tmpbuf + curoff, l->interface, len);
1621 curoff += len;
1622 } else
1623 tmpbuf[curoff++] = 0;
1624 memcpy(tmpbuf + curoff, &l->options,
1625 sizeof(l->options));
1626 curoff += sizeof(l->options);
1627
1628 i++;
1629 } else
1630 continue;
1631 /* if it reaches the max number of fd per msghdr */
1632 if ((!(i % MAX_SEND_FD))) {
1633 iov->iov_len = curoff;
1634 if (sendmsg(sendfd, msghdr, 0) != curoff) {
1635 ha_warning("Failed to transfer sockets\n");
1636 return -1;
1637 }
1638 /* Wait for an ack */
1639 do {
1640 ret = recv(sendfd, &tot_fd_nb,
1641 sizeof(tot_fd_nb), 0);
1642 } while (ret == -1 && errno == EINTR);
1643 if (ret <= 0) {
1644 ha_warning("Unexpected error while transferring sockets\n");
1645 return -1;
1646 }
1647 curoff = 0;
1648 }
1649 }
1650
1651 *fd_it = i;
1652 *offset = curoff;
1653
1654 return 0;
1655}
William Lallemand16dd1b32018-11-19 18:46:18 +01001656
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001657
Olivier Houchardf886e342017-04-05 22:24:59 +02001658/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001659static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02001660{
1661 char *cmsgbuf = NULL;
1662 unsigned char *tmpbuf = NULL;
1663 struct cmsghdr *cmsg;
1664 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001665 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001666 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001667 struct msghdr msghdr;
1668 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001669 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Olivier Houchardf886e342017-04-05 22:24:59 +02001670 int *tmpfd;
1671 int tot_fd_nb = 0;
1672 struct proxy *px;
William Lallemand5fd3b282020-01-16 15:32:08 +01001673 struct peers *prs;
Olivier Houchardf886e342017-04-05 22:24:59 +02001674 int i = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001675 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001676 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001677 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001678 int ret;
1679
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001680 if (!remote) {
1681 ha_warning("Only works on real connections\n");
1682 goto out;
1683 }
1684
1685 fd = remote->handle.fd;
1686
Olivier Houchardf886e342017-04-05 22:24:59 +02001687 /* Temporary set the FD in blocking mode, that will make our life easier */
1688 old_fcntl = fcntl(fd, F_GETFL);
1689 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001690 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001691 goto out;
1692 }
1693 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1694 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001695 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001696 goto out;
1697 }
1698 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001699 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001700 goto out;
1701 }
Olivier Houchard54740872017-04-06 14:45:14 +02001702 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001703 iov.iov_base = &tot_fd_nb;
1704 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001705 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001706 goto out;
1707 memset(&msghdr, 0, sizeof(msghdr));
1708 /*
1709 * First, calculates the total number of FD, so that we can let
1710 * the caller know how much he should expects.
1711 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001712 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001713 while (px) {
1714 struct listener *l;
1715
1716 list_for_each_entry(l, &px->conf.listeners, by_fe) {
Olivier Houchard1fc05162017-04-06 01:05:05 +02001717 /* Only transfer IPv4/IPv6/UNIX sockets */
1718 if (l->state >= LI_ZOMBIE &&
1719 (l->proto->sock_family == AF_INET ||
Olivier Houchardf886e342017-04-05 22:24:59 +02001720 l->proto->sock_family == AF_INET6 ||
Olivier Houchard1fc05162017-04-06 01:05:05 +02001721 l->proto->sock_family == AF_UNIX))
Olivier Houchardf886e342017-04-05 22:24:59 +02001722 tot_fd_nb++;
1723 }
1724 px = px->next;
1725 }
William Lallemand5fd3b282020-01-16 15:32:08 +01001726 prs = cfg_peers;
1727 while (prs) {
1728 if (prs->peers_fe) {
1729 struct listener *l;
1730
1731 list_for_each_entry(l, &prs->peers_fe->conf.listeners, by_fe) {
1732 /* Only transfer IPv4/IPv6/UNIX sockets */
1733 if (l->state >= LI_ZOMBIE &&
1734 (l->proto->sock_family == AF_INET ||
1735 l->proto->sock_family == AF_INET6 ||
1736 l->proto->sock_family == AF_UNIX))
1737 tot_fd_nb++;
1738 }
1739 }
1740 prs = prs->next;
1741 }
Olivier Houchardf886e342017-04-05 22:24:59 +02001742 if (tot_fd_nb == 0)
1743 goto out;
1744
1745 /* First send the total number of file descriptors, so that the
1746 * receiving end knows what to expect.
1747 */
1748 msghdr.msg_iov = &iov;
1749 msghdr.msg_iovlen = 1;
1750 ret = sendmsg(fd, &msghdr, 0);
1751 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001752 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001753 goto out;
1754 }
1755
1756 /* Now send the fds */
1757 msghdr.msg_control = cmsgbuf;
1758 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1759 cmsg = CMSG_FIRSTHDR(&msghdr);
1760 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1761 cmsg->cmsg_level = SOL_SOCKET;
1762 cmsg->cmsg_type = SCM_RIGHTS;
1763 tmpfd = (int *)CMSG_DATA(cmsg);
1764
Olivier Houchardf886e342017-04-05 22:24:59 +02001765 /* For each socket, e message is sent, containing the following :
1766 * Size of the namespace name (or 0 if none), as an unsigned char.
1767 * The namespace name, if any
1768 * Size of the interface name (or 0 if none), as an unsigned char
1769 * The interface name, if any
1770 * Listener options, as an int.
1771 */
1772 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
1773 * buffer big enough to store the socket informations.
1774 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001775 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001776 if (tmpbuf == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001777 ha_warning("Failed to allocate memory to transfer socket informations\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001778 goto out;
1779 }
1780 iov.iov_base = tmpbuf;
William Lallemand5fd3b282020-01-16 15:32:08 +01001781 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001782 while (px) {
William Lallemandd308c5e2020-01-16 16:26:41 +01001783 if (_getsocks_gen_send(px, fd, tmpfd, &iov,
1784 tot_fd_nb, &i, &curoff, &msghdr) < 0)
1785 goto out;
Olivier Houchardf886e342017-04-05 22:24:59 +02001786 px = px->next;
1787 }
William Lallemand5fd3b282020-01-16 15:32:08 +01001788 /* should be done for peers too */
1789 prs = cfg_peers;
1790 while (prs) {
William Lallemandd308c5e2020-01-16 16:26:41 +01001791 if (prs->peers_fe)
1792 if (_getsocks_gen_send(prs->peers_fe, fd, tmpfd, &iov,
1793 tot_fd_nb, &i, &curoff, &msghdr) < 0)
1794 goto out;
William Lallemand5fd3b282020-01-16 15:32:08 +01001795 prs = prs->next;
1796 }
1797
Olivier Houchardf886e342017-04-05 22:24:59 +02001798 if (i % MAX_SEND_FD) {
1799 iov.iov_len = curoff;
1800 cmsg->cmsg_len = CMSG_LEN((i % MAX_SEND_FD) * sizeof(int));
1801 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * (i % MAX_SEND_FD));
1802 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001803 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001804 goto out;
1805 }
1806 }
1807
1808out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001809 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001810 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001811 goto out;
1812 }
1813 appctx->st0 = CLI_ST_END;
1814 free(cmsgbuf);
1815 free(tmpbuf);
1816 return 1;
1817}
1818
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001819static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
1820{
1821 if (*args[0] == 'h')
1822 /* help */
1823 cli_gen_usage_msg(appctx);
1824 else if (*args[0] == 'p')
1825 /* prompt */
1826 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
1827 else if (*args[0] == 'q')
1828 /* quit */
1829 appctx->st0 = CLI_ST_END;
1830
1831 return 1;
1832}
Olivier Houchardf886e342017-04-05 22:24:59 +02001833
William Lallemand2f4ce202018-10-26 14:47:47 +02001834void pcli_write_prompt(struct stream *s)
1835{
1836 struct buffer *msg = get_trash_chunk();
1837 struct channel *oc = si_oc(&s->si[0]);
1838
William Lallemanddc12c2e2018-12-13 09:05:46 +01001839 if (!(s->pcli_flags & PCLI_F_PROMPT))
William Lallemand5b80fa22018-12-11 16:10:54 +01001840 return;
1841
William Lallemanddc12c2e2018-12-13 09:05:46 +01001842 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01001843 chunk_appendf(msg, "+ ");
1844 } else {
1845 if (s->pcli_next_pid == 0)
Willy Tarreau52880f92018-12-15 13:30:03 +01001846 chunk_appendf(msg, "master%s> ",
1847 (global.mode & MODE_MWORKER_WAIT) ? "[ReloadFailed]" : "");
William Lallemandebf61802018-12-11 16:10:57 +01001848 else
1849 chunk_appendf(msg, "%d> ", s->pcli_next_pid);
1850 }
William Lallemand2f4ce202018-10-26 14:47:47 +02001851 co_inject(oc, msg->area, msg->data);
1852}
1853
William Lallemand291810d2018-10-26 14:47:38 +02001854
William Lallemandcf62f7e2018-10-26 14:47:40 +02001855/* The pcli_* functions are used for the CLI proxy in the master */
1856
William Lallemanddeeaa592018-10-26 14:47:48 +02001857void pcli_reply_and_close(struct stream *s, const char *msg)
1858{
1859 struct buffer *buf = get_trash_chunk();
1860
1861 chunk_initstr(buf, msg);
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001862 si_retnclose(&s->si[0], buf);
William Lallemanddeeaa592018-10-26 14:47:48 +02001863}
1864
William Lallemand291810d2018-10-26 14:47:38 +02001865static enum obj_type *pcli_pid_to_server(int proc_pid)
1866{
1867 struct mworker_proc *child;
1868
William Lallemandbddd33a2018-12-11 16:10:53 +01001869 /* return the CLI applet of the master */
1870 if (proc_pid == 0)
1871 return &cli_applet.obj_type;
1872
William Lallemand291810d2018-10-26 14:47:38 +02001873 list_for_each_entry(child, &proc_list, list) {
1874 if (child->pid == proc_pid){
1875 return &child->srv->obj_type;
1876 }
1877 }
1878 return NULL;
1879}
1880
1881/* Take a CLI prefix in argument (eg: @!1234 @master @1)
1882 * Return:
1883 * 0: master
1884 * > 0: pid of a worker
1885 * < 0: didn't find a worker
1886 */
1887static int pcli_prefix_to_pid(const char *prefix)
1888{
1889 int proc_pid;
1890 struct mworker_proc *child;
1891 char *errtol = NULL;
1892
1893 if (*prefix != '@') /* not a prefix, should not happen */
1894 return -1;
1895
1896 prefix++;
1897 if (!*prefix) /* sent @ alone, return the master */
1898 return 0;
1899
1900 if (strcmp("master", prefix) == 0) {
1901 return 0;
1902 } else if (*prefix == '!') {
1903 prefix++;
1904 if (!*prefix)
1905 return -1;
1906
1907 proc_pid = strtol(prefix, &errtol, 10);
1908 if (*errtol != '\0')
1909 return -1;
1910 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001911 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001912 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001913 if (child->pid == proc_pid){
1914 return child->pid;
1915 }
1916 }
1917 } else {
1918 struct mworker_proc *chosen = NULL;
1919 /* this is a relative pid */
1920
1921 proc_pid = strtol(prefix, &errtol, 10);
1922 if (*errtol != '\0')
1923 return -1;
1924
1925 if (proc_pid == 0) /* return the master */
1926 return 0;
1927
1928 /* chose the right process, the current one is the one with the
1929 least number of reloads */
1930 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001931 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001932 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001933 if (child->relative_pid == proc_pid){
1934 if (child->reloads == 0)
1935 return child->pid;
1936 else if (chosen == NULL || child->reloads < chosen->reloads)
1937 chosen = child;
1938 }
1939 }
1940 if (chosen)
1941 return chosen->pid;
1942 }
1943 return -1;
1944}
1945
William Lallemandbddd33a2018-12-11 16:10:53 +01001946/* Return::
1947 * >= 0 : number of words to escape
1948 * = -1 : error
1949 */
1950
1951int pcli_find_and_exec_kw(struct stream *s, char **args, int argl, char **errmsg, int *next_pid)
1952{
1953 if (argl < 1)
1954 return 0;
1955
1956 /* there is a prefix */
1957 if (args[0][0] == '@') {
1958 int target_pid = pcli_prefix_to_pid(args[0]);
1959
1960 if (target_pid == -1) {
1961 memprintf(errmsg, "Can't find the target PID matching the prefix '%s'\n", args[0]);
1962 return -1;
1963 }
1964
1965 /* if the prefix is alone, define a default target */
1966 if (argl == 1)
1967 s->pcli_next_pid = target_pid;
1968 else
1969 *next_pid = target_pid;
1970 return 1;
William Lallemand5b80fa22018-12-11 16:10:54 +01001971 } else if (!strcmp("prompt", args[0])) {
William Lallemanddc12c2e2018-12-13 09:05:46 +01001972 s->pcli_flags ^= PCLI_F_PROMPT;
William Lallemand5b80fa22018-12-11 16:10:54 +01001973 return argl; /* return the number of elements in the array */
William Lallemand5f610682018-12-11 16:10:55 +01001974
1975 } else if (!strcmp("quit", args[0])) {
1976 channel_shutr_now(&s->req);
1977 channel_shutw_now(&s->res);
1978 return argl; /* return the number of elements in the array */
William Lallemandb7ea1412018-12-13 09:05:47 +01001979 } else if (!strcmp(args[0], "operator")) {
1980 if (!pcli_has_level(s, ACCESS_LVL_OPER)) {
1981 memprintf(errmsg, "Permission denied!\n");
1982 return -1;
1983 }
1984 s->pcli_flags &= ~ACCESS_LVL_MASK;
1985 s->pcli_flags |= ACCESS_LVL_OPER;
1986 return argl;
1987
1988 } else if (!strcmp(args[0], "user")) {
1989 if (!pcli_has_level(s, ACCESS_LVL_USER)) {
1990 memprintf(errmsg, "Permission denied!\n");
1991 return -1;
1992 }
1993 s->pcli_flags &= ~ACCESS_LVL_MASK;
1994 s->pcli_flags |= ACCESS_LVL_USER;
1995 return argl;
William Lallemandbddd33a2018-12-11 16:10:53 +01001996 }
1997
1998 return 0;
1999}
2000
2001/*
2002 * Parse the CLI request:
2003 * - It does basically the same as the cli_io_handler, but as a proxy
2004 * - It can exec a command and strip non forwardable commands
William Lallemandcf62f7e2018-10-26 14:47:40 +02002005 *
2006 * Return:
William Lallemandbddd33a2018-12-11 16:10:53 +01002007 * - the number of characters to forward or
2008 * - 1 if there is an error or not enough data
William Lallemandcf62f7e2018-10-26 14:47:40 +02002009 */
William Lallemandbddd33a2018-12-11 16:10:53 +01002010int pcli_parse_request(struct stream *s, struct channel *req, char **errmsg, int *next_pid)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002011{
William Lallemandbddd33a2018-12-11 16:10:53 +01002012 char *str = (char *)ci_head(req);
2013 char *end = (char *)ci_stop(req);
2014 char *args[MAX_STATS_ARGS + 1]; /* +1 for storing a NULL */
2015 int argl; /* number of args */
2016 char *p;
2017 char *trim = NULL;
William Lallemandebf61802018-12-11 16:10:57 +01002018 char *payload = NULL;
William Lallemandbddd33a2018-12-11 16:10:53 +01002019 int wtrim = 0; /* number of words to trim */
2020 int reql = 0;
William Lallemandb7ea1412018-12-13 09:05:47 +01002021 int ret;
William Lallemandbddd33a2018-12-11 16:10:53 +01002022 int i = 0;
2023
2024 p = str;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002025
William Lallemanddc12c2e2018-12-13 09:05:46 +01002026 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002027
2028 /* Looks for the end of one command */
2029 while (p+reql < end) {
2030 /* handle escaping */
2031 if (p[reql] == '\\') {
2032 reql++;
2033 continue;
2034 }
2035 if (p[reql] == ';' || p[reql] == '\n') {
2036 /* found the end of the command */
2037 p[reql] = '\n';
2038 reql++;
2039 break;
2040 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002041 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002042 }
William Lallemandebf61802018-12-11 16:10:57 +01002043 } else {
2044 while (p+reql < end) {
2045 if (p[reql] == '\n') {
2046 /* found the end of the line */
2047 reql++;
2048 break;
2049 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002050 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002051 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002052 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002053
William Lallemandbddd33a2018-12-11 16:10:53 +01002054 /* set end to first byte after the end of the command */
2055 end = p + reql;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002056
William Lallemandbddd33a2018-12-11 16:10:53 +01002057 /* there is no end to this command, need more to parse ! */
2058 if (*(end-1) != '\n') {
2059 return -1;
2060 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002061
William Lallemand3301f3e2018-12-13 09:05:48 +01002062 if (s->pcli_flags & PCLI_F_PAYLOAD) {
2063 if (reql == 1) /* last line of the payload */
2064 s->pcli_flags &= ~PCLI_F_PAYLOAD;
William Lallemandebf61802018-12-11 16:10:57 +01002065 return reql;
2066 }
2067
William Lallemandbddd33a2018-12-11 16:10:53 +01002068 *(end-1) = '\0';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002069
William Lallemandbddd33a2018-12-11 16:10:53 +01002070 /* splits the command in words */
2071 while (i < MAX_STATS_ARGS && p < end) {
2072 int j, k;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002073
William Lallemandbddd33a2018-12-11 16:10:53 +01002074 /* skip leading spaces/tabs */
2075 p += strspn(p, " \t");
2076 if (!*p)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002077 break;
2078
William Lallemandbddd33a2018-12-11 16:10:53 +01002079 args[i] = p;
2080 p += strcspn(p, " \t");
2081 *p++ = 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002082
William Lallemandbddd33a2018-12-11 16:10:53 +01002083 /* unescape backslashes (\) */
2084 for (j = 0, k = 0; args[i][k]; k++) {
2085 if (args[i][k] == '\\') {
2086 if (args[i][k + 1] == '\\')
2087 k++;
2088 else
2089 continue;
2090 }
2091 args[i][j] = args[i][k];
2092 j++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002093 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002094 args[i][j] = 0;
2095 i++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002096 }
2097
William Lallemandbddd33a2018-12-11 16:10:53 +01002098 argl = i;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002099
William Lallemandbddd33a2018-12-11 16:10:53 +01002100 for (; i < MAX_STATS_ARGS + 1; i++)
2101 args[i] = NULL;
2102
2103 wtrim = pcli_find_and_exec_kw(s, args, argl, errmsg, next_pid);
2104
2105 /* End of words are ending by \0, we need to replace the \0s by spaces
21061 before forwarding them */
2107 p = str;
William Lallemand3301f3e2018-12-13 09:05:48 +01002108 while (p < end-1) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002109 if (*p == '\0')
2110 *p = ' ';
2111 p++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002112 }
2113
William Lallemand3301f3e2018-12-13 09:05:48 +01002114 payload = strstr(str, PAYLOAD_PATTERN);
2115 if ((end - 1) == (payload + strlen(PAYLOAD_PATTERN))) {
2116 /* if the payload pattern is at the end */
2117 s->pcli_flags |= PCLI_F_PAYLOAD;
2118 ret = reql;
2119 }
2120
William Lallemandbddd33a2018-12-11 16:10:53 +01002121 *(end-1) = '\n';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002122
William Lallemandbddd33a2018-12-11 16:10:53 +01002123 if (wtrim > 0) {
2124 trim = &args[wtrim][0];
2125 if (trim == NULL) /* if this was the last word in the table */
2126 trim = end;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002127
William Lallemandbddd33a2018-12-11 16:10:53 +01002128 b_del(&req->buf, trim - str);
2129
William Lallemandb7ea1412018-12-13 09:05:47 +01002130 ret = end - trim;
William Lallemandbddd33a2018-12-11 16:10:53 +01002131 } else if (wtrim < 0) {
2132 /* parsing error */
2133 return -1;
William Lallemandb7ea1412018-12-13 09:05:47 +01002134 } else {
2135 /* the whole string */
2136 ret = end - str;
William Lallemandbddd33a2018-12-11 16:10:53 +01002137 }
2138
William Lallemandb7ea1412018-12-13 09:05:47 +01002139 if (ret > 1) {
2140 if (pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2141 goto end;
2142 } else if (pcli_has_level(s, ACCESS_LVL_OPER)) {
William Lallemandad032882019-07-01 10:56:15 +02002143 ci_insert_line2(req, 0, "operator -", strlen("operator -"));
2144 ret += strlen("operator -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002145 } else if (pcli_has_level(s, ACCESS_LVL_USER)) {
William Lallemandad032882019-07-01 10:56:15 +02002146 ci_insert_line2(req, 0, "user -", strlen("user -"));
2147 ret += strlen("user -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002148 }
2149 }
2150end:
William Lallemandbddd33a2018-12-11 16:10:53 +01002151
William Lallemandb7ea1412018-12-13 09:05:47 +01002152 return ret;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002153}
2154
2155int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
2156{
William Lallemandbddd33a2018-12-11 16:10:53 +01002157 int next_pid = -1;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002158 int to_forward;
William Lallemandbddd33a2018-12-11 16:10:53 +01002159 char *errmsg = NULL;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002160
William Lallemandb7ea1412018-12-13 09:05:47 +01002161 if ((s->pcli_flags & ACCESS_LVL_MASK) == ACCESS_LVL_NONE)
2162 s->pcli_flags |= strm_li(s)->bind_conf->level & ACCESS_LVL_MASK;
2163
William Lallemandcf62f7e2018-10-26 14:47:40 +02002164read_again:
2165 /* if the channel is closed for read, we won't receive any more data
2166 from the client, but we don't want to forward this close to the
2167 server */
2168 channel_dont_close(req);
2169
2170 /* We don't know yet to which server we will connect */
2171 channel_dont_connect(req);
2172
2173
2174 /* we are not waiting for a response, there is no more request and we
2175 * receive a close from the client, we can leave */
2176 if (!(ci_data(req)) && req->flags & CF_SHUTR) {
2177 channel_shutw_now(&s->res);
2178 s->req.analysers &= ~AN_REQ_WAIT_CLI;
2179 return 1;
2180 }
2181
2182 req->flags |= CF_READ_DONTWAIT;
2183
2184 /* need more data */
2185 if (!ci_data(req))
2186 return 0;
2187
2188 /* If there is data available for analysis, log the end of the idle time. */
2189 if (c_data(req) && s->logs.t_idle == -1)
2190 s->logs.t_idle = tv_ms_elapsed(&s->logs.tv_accept, &now) - s->logs.t_handshake;
2191
William Lallemandbddd33a2018-12-11 16:10:53 +01002192 to_forward = pcli_parse_request(s, req, &errmsg, &next_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002193 if (to_forward > 0) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002194 int target_pid;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002195 /* enough data */
2196
William Lallemandcf62f7e2018-10-26 14:47:40 +02002197 /* forward only 1 command */
2198 channel_forward(req, to_forward);
William Lallemandebf61802018-12-11 16:10:57 +01002199
William Lallemanddc12c2e2018-12-13 09:05:46 +01002200 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002201 /* we send only 1 command per request, and we write close after it */
2202 channel_shutw_now(req);
2203 } else {
2204 pcli_write_prompt(s);
2205 }
2206
2207 s->res.flags |= CF_WAKE_ONCE; /* need to be called again */
William Lallemandcf62f7e2018-10-26 14:47:40 +02002208
2209 /* remove the XFER_DATA analysers, which forwards all
2210 * the data, we don't want to forward the next requests
2211 * We need to add CF_FLT_ANALYZE to abort the forward too.
2212 */
2213 req->analysers &= ~(AN_REQ_FLT_XFER_DATA|AN_REQ_WAIT_CLI);
2214 req->analysers |= AN_REQ_FLT_END|CF_FLT_ANALYZE;
2215 s->res.analysers |= AN_RES_WAIT_CLI;
2216
William Lallemandebf61802018-12-11 16:10:57 +01002217 if (!(s->flags & SF_ASSIGNED)) {
2218 if (next_pid > -1)
2219 target_pid = next_pid;
2220 else
2221 target_pid = s->pcli_next_pid;
2222 /* we can connect now */
2223 s->target = pcli_pid_to_server(target_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002224
William Lallemandebf61802018-12-11 16:10:57 +01002225 s->flags |= (SF_DIRECT | SF_ASSIGNED);
2226 channel_auto_connect(req);
2227 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002228
2229 } else if (to_forward == 0) {
William Lallemandcf62f7e2018-10-26 14:47:40 +02002230 /* we trimmed things but we might have other commands to consume */
William Lallemandbddd33a2018-12-11 16:10:53 +01002231 pcli_write_prompt(s);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002232 goto read_again;
William Lallemandbddd33a2018-12-11 16:10:53 +01002233 } else if (to_forward == -1 && errmsg) {
2234 /* there was an error during the parsing */
2235 pcli_reply_and_close(s, errmsg);
2236 return 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002237 } else if (to_forward == -1 && channel_full(req, global.tune.maxrewrite)) {
2238 /* buffer is full and we didn't catch the end of a command */
2239 goto send_help;
2240 }
2241
2242 return 0;
2243
2244send_help:
2245 b_reset(&req->buf);
2246 b_putblk(&req->buf, "help\n", 5);
2247 goto read_again;
2248}
2249
2250int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
2251{
2252 struct proxy *fe = strm_fe(s);
2253 struct proxy *be = s->be;
2254
William Lallemand6b7cd0a2018-11-06 17:37:11 +01002255 if (rep->flags & CF_READ_ERROR) {
2256 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
2257 s->res.analysers &= ~AN_RES_WAIT_CLI;
2258 return 0;
2259 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002260 rep->flags |= CF_READ_DONTWAIT; /* try to get back here ASAP */
2261 rep->flags |= CF_NEVER_WAIT;
2262
2263 /* don't forward the close */
2264 channel_dont_close(&s->res);
2265 channel_dont_close(&s->req);
2266
William Lallemanddc12c2e2018-12-13 09:05:46 +01002267 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002268 s->req.analysers |= AN_REQ_WAIT_CLI;
2269 s->res.analysers &= ~AN_RES_WAIT_CLI;
2270 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2271 return 0;
2272 }
2273
William Lallemandcf62f7e2018-10-26 14:47:40 +02002274 /* forward the data */
2275 if (ci_data(rep)) {
2276 c_adv(rep, ci_data(rep));
2277 return 0;
2278 }
2279
2280 if ((rep->flags & (CF_SHUTR|CF_READ_NULL))) {
2281 /* stream cleanup */
2282
William Lallemand2f4ce202018-10-26 14:47:47 +02002283 pcli_write_prompt(s);
2284
William Lallemandcf62f7e2018-10-26 14:47:40 +02002285 s->si[1].flags |= SI_FL_NOLINGER | SI_FL_NOHALF;
2286 si_shutr(&s->si[1]);
2287 si_shutw(&s->si[1]);
2288
2289 /*
2290 * starting from there this the same code as
2291 * http_end_txn_clean_session().
2292 *
2293 * It allows to do frontend keepalive while reconnecting to a
2294 * new server for each request.
2295 */
2296
2297 if (s->flags & SF_BE_ASSIGNED) {
2298 HA_ATOMIC_SUB(&be->beconn, 1);
2299 if (unlikely(s->srv_conn))
2300 sess_change_server(s, NULL);
2301 }
2302
2303 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2304 stream_process_counters(s);
2305
2306 /* don't count other requests' data */
2307 s->logs.bytes_in -= ci_data(&s->req);
2308 s->logs.bytes_out -= ci_data(&s->res);
2309
2310 /* we may need to know the position in the queue */
2311 pendconn_free(s);
2312
2313 /* let's do a final log if we need it */
2314 if (!LIST_ISEMPTY(&fe->logformat) && s->logs.logwait &&
2315 !(s->flags & SF_MONITOR) &&
2316 (!(fe->options & PR_O_NULLNOLOG) || s->req.total)) {
2317 s->do_log(s);
2318 }
2319
2320 /* stop tracking content-based counters */
2321 stream_stop_content_counters(s);
2322 stream_update_time_stats(s);
2323
2324 s->logs.accept_date = date; /* user-visible date for logging */
2325 s->logs.tv_accept = now; /* corrected date for internal use */
2326 s->logs.t_handshake = 0; /* There are no handshake in keep alive connection. */
2327 s->logs.t_idle = -1;
2328 tv_zero(&s->logs.tv_request);
2329 s->logs.t_queue = -1;
2330 s->logs.t_connect = -1;
2331 s->logs.t_data = -1;
2332 s->logs.t_close = 0;
2333 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
2334 s->logs.srv_queue_pos = 0; /* we will get this number soon */
2335
2336 s->logs.bytes_in = s->req.total = ci_data(&s->req);
2337 s->logs.bytes_out = s->res.total = ci_data(&s->res);
2338
2339 stream_del_srv_conn(s);
2340 if (objt_server(s->target)) {
2341 if (s->flags & SF_CURR_SESS) {
2342 s->flags &= ~SF_CURR_SESS;
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002343 HA_ATOMIC_SUB(&__objt_server(s->target)->cur_sess, 1);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002344 }
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002345 if (may_dequeue_tasks(__objt_server(s->target), be))
2346 process_srv_queue(__objt_server(s->target));
William Lallemandcf62f7e2018-10-26 14:47:40 +02002347 }
2348
2349 s->target = NULL;
2350
2351 /* only release our endpoint if we don't intend to reuse the
2352 * connection.
2353 */
2354 if (!si_conn_ready(&s->si[1])) {
2355 si_release_endpoint(&s->si[1]);
2356 s->srv_conn = NULL;
2357 }
2358
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002359 sockaddr_free(&s->target_addr);
2360
William Lallemandcf62f7e2018-10-26 14:47:40 +02002361 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
2362 s->si[1].err_type = SI_ET_NONE;
2363 s->si[1].conn_retries = 0; /* used for logging too */
2364 s->si[1].exp = TICK_ETERNITY;
2365 s->si[1].flags &= SI_FL_ISBACK | SI_FL_DONT_WAKE; /* we're in the context of process_stream */
Christopher Faulet22dc2482019-07-16 14:43:08 +02002366 s->req.flags &= ~(CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CONNECT|CF_WRITE_ERROR|CF_STREAMER|CF_STREAMER_FAST|CF_NEVER_WAIT|CF_WROTE_DATA);
William Lallemand19338012019-06-25 18:00:19 +02002367 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|CF_READ_NULL);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002368 s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_ADDR_SET|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
2369 s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
2370 s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
2371 /* reinitialise the current rule list pointer to NULL. We are sure that
2372 * any rulelist match the NULL pointer.
2373 */
2374 s->current_rule_list = NULL;
2375
2376 s->be = strm_fe(s);
2377 s->logs.logwait = strm_fe(s)->to_log;
2378 s->logs.level = 0;
2379 stream_del_srv_conn(s);
2380 s->target = NULL;
2381 /* re-init store persistence */
2382 s->store_count = 0;
2383 s->uniq_id = global.req_count++;
2384
2385 s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */
2386
2387 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2388
2389 s->req.analysers |= AN_REQ_WAIT_CLI;
2390 s->res.analysers &= ~AN_RES_WAIT_CLI;
2391
2392 /* We must trim any excess data from the response buffer, because we
2393 * may have blocked an invalid response from a server that we don't
Joseph Herlant008b3ce2018-11-25 12:51:45 -08002394 * want to accidently forward once we disable the analysers, nor do
William Lallemandcf62f7e2018-10-26 14:47:40 +02002395 * we want those data to come along with next response. A typical
2396 * example of such data would be from a buggy server responding to
2397 * a HEAD with some data, or sending more than the advertised
2398 * content-length.
2399 */
2400 if (unlikely(ci_data(&s->res)))
2401 b_set_data(&s->res.buf, co_data(&s->res));
2402
2403 /* Now we can realign the response buffer */
2404 c_realign_if_empty(&s->res);
2405
2406 s->req.rto = strm_fe(s)->timeout.client;
2407 s->req.wto = TICK_ETERNITY;
2408
2409 s->res.rto = TICK_ETERNITY;
2410 s->res.wto = strm_fe(s)->timeout.client;
2411
2412 s->req.rex = TICK_ETERNITY;
2413 s->req.wex = TICK_ETERNITY;
2414 s->req.analyse_exp = TICK_ETERNITY;
2415 s->res.rex = TICK_ETERNITY;
2416 s->res.wex = TICK_ETERNITY;
2417 s->res.analyse_exp = TICK_ETERNITY;
2418 s->si[1].hcto = TICK_ETERNITY;
2419
2420 /* we're removing the analysers, we MUST re-enable events detection.
2421 * We don't enable close on the response channel since it's either
2422 * already closed, or in keep-alive with an idle connection handler.
2423 */
2424 channel_auto_read(&s->req);
2425 channel_auto_close(&s->req);
2426 channel_auto_read(&s->res);
2427
2428
2429 return 1;
2430 }
2431 return 0;
2432}
2433
William Lallemand8a022572018-10-26 14:47:35 +02002434/*
2435 * The mworker functions are used to initialize the CLI in the master process
2436 */
2437
William Lallemand309dc9a2018-10-26 14:47:45 +02002438 /*
2439 * Stop the mworker proxy
2440 */
2441void mworker_cli_proxy_stop()
2442{
William Lallemand550db6d2018-11-06 17:37:12 +01002443 if (mworker_proxy)
2444 stop_proxy(mworker_proxy);
William Lallemand309dc9a2018-10-26 14:47:45 +02002445}
2446
William Lallemand8a022572018-10-26 14:47:35 +02002447/*
2448 * Create the mworker CLI proxy
2449 */
2450int mworker_cli_proxy_create()
2451{
2452 struct mworker_proc *child;
William Lallemand744a0892018-11-22 16:46:51 +01002453 char *msg = NULL;
2454 char *errmsg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002455
2456 mworker_proxy = calloc(1, sizeof(*mworker_proxy));
2457 if (!mworker_proxy)
2458 return -1;
2459
2460 init_new_proxy(mworker_proxy);
2461 mworker_proxy->next = proxies_list;
2462 proxies_list = mworker_proxy;
2463 mworker_proxy->id = strdup("MASTER");
William Lallemandcf62f7e2018-10-26 14:47:40 +02002464 mworker_proxy->mode = PR_MODE_CLI;
William Lallemand8a022572018-10-26 14:47:35 +02002465 mworker_proxy->state = PR_STNEW;
2466 mworker_proxy->last_change = now.tv_sec;
2467 mworker_proxy->cap = PR_CAP_LISTEN; /* this is a listen section */
2468 mworker_proxy->maxconn = 10; /* default to 10 concurrent connections */
2469 mworker_proxy->timeout.client = 0; /* no timeout */
2470 mworker_proxy->conf.file = strdup("MASTER");
2471 mworker_proxy->conf.line = 0;
2472 mworker_proxy->accept = frontend_accept;
2473 mworker_proxy-> lbprm.algo = BE_LB_ALGO_NONE;
2474
2475 /* Does not init the default target the CLI applet, but must be done in
2476 * the request parsing code */
2477 mworker_proxy->default_target = NULL;
2478
2479 /* the check_config_validity() will get an ID for the proxy */
2480 mworker_proxy->uuid = -1;
2481
2482 proxy_store_name(mworker_proxy);
2483
2484 /* create all servers using the mworker_proc list */
2485 list_for_each_entry(child, &proc_list, list) {
William Lallemand8a022572018-10-26 14:47:35 +02002486 struct server *newsrv = NULL;
2487 struct sockaddr_storage *sk;
2488 int port1, port2, port;
2489 struct protocol *proto;
William Lallemand8a022572018-10-26 14:47:35 +02002490
William Lallemanda31b09e2020-01-14 15:25:02 +01002491 /* only the workers support the master CLI */
2492 if (!(child->options & PROC_O_TYPE_WORKER))
2493 continue;
2494
William Lallemand8a022572018-10-26 14:47:35 +02002495 newsrv = new_server(mworker_proxy);
2496 if (!newsrv)
William Lallemand744a0892018-11-22 16:46:51 +01002497 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002498
2499 /* we don't know the new pid yet */
2500 if (child->pid == -1)
2501 memprintf(&msg, "cur-%d", child->relative_pid);
2502 else
2503 memprintf(&msg, "old-%d", child->pid);
2504
2505 newsrv->next = mworker_proxy->srv;
2506 mworker_proxy->srv = newsrv;
2507 newsrv->conf.file = strdup(msg);
2508 newsrv->id = strdup(msg);
2509 newsrv->conf.line = 0;
2510
2511 memprintf(&msg, "sockpair@%d", child->ipc_fd[0]);
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002512 if ((sk = str2sa_range(msg, &port, &port1, &port2, &errmsg, NULL, NULL, 0)) == 0) {
William Lallemand744a0892018-11-22 16:46:51 +01002513 goto error;
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002514 }
2515 free(msg);
2516 msg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002517
2518 proto = protocol_by_family(sk->ss_family);
2519 if (!proto || !proto->connect) {
William Lallemand744a0892018-11-22 16:46:51 +01002520 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002521 }
2522
2523 /* no port specified */
2524 newsrv->flags |= SRV_F_MAPPORTS;
2525 newsrv->addr = *sk;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002526 /* don't let the server participate to load balancing */
2527 newsrv->iweight = 0;
2528 newsrv->uweight = 0;
William Lallemand8a022572018-10-26 14:47:35 +02002529 srv_lb_commit_status(newsrv);
William Lallemand291810d2018-10-26 14:47:38 +02002530
2531 child->srv = newsrv;
William Lallemand8a022572018-10-26 14:47:35 +02002532 }
2533 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002534
2535error:
2536 ha_alert("%s\n", errmsg);
2537
2538 list_for_each_entry(child, &proc_list, list) {
2539 free((char *)child->srv->conf.file); /* cast because of const char * */
2540 free(child->srv->id);
2541 free(child->srv);
2542 child->srv = NULL;
2543 }
2544 free(mworker_proxy->id);
2545 free(mworker_proxy->conf.file);
2546 free(mworker_proxy);
2547 mworker_proxy = NULL;
2548 free(errmsg);
2549 free(msg);
2550
2551 return -1;
William Lallemand8a022572018-10-26 14:47:35 +02002552}
Olivier Houchardf886e342017-04-05 22:24:59 +02002553
William Lallemandce83b4a2018-10-26 14:47:30 +02002554/*
William Lallemande7361152018-10-26 14:47:36 +02002555 * Create a new listener for the master CLI proxy
2556 */
2557int mworker_cli_proxy_new_listener(char *line)
2558{
2559 struct bind_conf *bind_conf;
2560 struct listener *l;
2561 char *err = NULL;
2562 char *args[MAX_LINE_ARGS + 1];
2563 int arg;
2564 int cur_arg;
2565
William Lallemand2e945c82019-11-25 09:58:37 +01002566 arg = 1;
William Lallemande7361152018-10-26 14:47:36 +02002567 args[0] = line;
2568
2569 /* args is a bind configuration with spaces replaced by commas */
2570 while (*line && arg < MAX_LINE_ARGS) {
2571
2572 if (*line == ',') {
2573 *line++ = '\0';
2574 while (*line == ',')
2575 line++;
William Lallemand2e945c82019-11-25 09:58:37 +01002576 args[arg++] = line;
William Lallemande7361152018-10-26 14:47:36 +02002577 }
2578 line++;
2579 }
2580
William Lallemand2e945c82019-11-25 09:58:37 +01002581 args[arg] = "\0";
William Lallemande7361152018-10-26 14:47:36 +02002582
2583 bind_conf = bind_conf_alloc(mworker_proxy, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002584 if (!bind_conf)
2585 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002586
2587 bind_conf->level &= ~ACCESS_LVL_MASK;
2588 bind_conf->level |= ACCESS_LVL_ADMIN;
2589
2590 if (!str2listener(args[0], mworker_proxy, bind_conf, "master-socket", 0, &err)) {
2591 ha_alert("Cannot create the listener of the master CLI\n");
William Lallemand744a0892018-11-22 16:46:51 +01002592 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002593 }
2594
2595 cur_arg = 1;
2596
2597 while (*args[cur_arg]) {
2598 static int bind_dumped;
2599 struct bind_kw *kw;
2600
2601 kw = bind_find_kw(args[cur_arg]);
2602 if (kw) {
2603 if (!kw->parse) {
2604 memprintf(&err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
2605 args[0], args[1], args[cur_arg]);
2606 goto err;
2607 }
2608
2609 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, &err) != 0) {
2610 if (err)
2611 memprintf(&err, "'%s %s' : '%s'", args[0], args[1], err);
2612 else
2613 memprintf(&err, "'%s %s' : error encountered while processing '%s'",
2614 args[0], args[1], args[cur_arg]);
2615 goto err;
2616 }
2617
2618 cur_arg += 1 + kw->skip;
2619 continue;
2620 }
2621
2622 if (!bind_dumped) {
2623 bind_dump_kws(&err);
2624 indent_msg(&err, 4);
2625 bind_dumped = 1;
2626 }
2627
2628 memprintf(&err, "'%s %s' : unknown keyword '%s'.%s%s",
2629 args[0], args[1], args[cur_arg],
2630 err ? " Registered keywords :" : "", err ? err : "");
2631 goto err;
2632 }
2633
2634
2635 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemande7361152018-10-26 14:47:36 +02002636 l->accept = session_accept_fd;
2637 l->default_target = mworker_proxy->default_target;
2638 /* don't make the peers subject to global limits and don't close it in the master */
2639 l->options |= (LI_O_UNLIMITED|LI_O_MWORKER); /* we are keeping this FD in the master */
2640 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002641 global.maxsock++; /* for the listening socket */
William Lallemande7361152018-10-26 14:47:36 +02002642 }
Willy Tarreau18215cb2019-02-27 16:25:28 +01002643 global.maxsock += mworker_proxy->maxconn;
William Lallemande7361152018-10-26 14:47:36 +02002644
2645 return 0;
2646
2647err:
2648 ha_alert("%s\n", err);
William Lallemand744a0892018-11-22 16:46:51 +01002649 free(err);
2650 free(bind_conf);
William Lallemande7361152018-10-26 14:47:36 +02002651 return -1;
2652
2653}
2654
2655/*
William Lallemandce83b4a2018-10-26 14:47:30 +02002656 * Create a new CLI socket using a socketpair for a worker process
2657 * <mworker_proc> is the process structure, and <proc> is the process number
2658 */
2659int mworker_cli_sockpair_new(struct mworker_proc *mworker_proc, int proc)
2660{
2661 struct bind_conf *bind_conf;
2662 struct listener *l;
2663 char *path = NULL;
2664 char *err = NULL;
2665
2666 /* master pipe to ensure the master is still alive */
2667 if (socketpair(AF_UNIX, SOCK_STREAM, 0, mworker_proc->ipc_fd) < 0) {
2668 ha_alert("Cannot create worker socketpair.\n");
2669 return -1;
2670 }
2671
2672 /* XXX: we might want to use a separate frontend at some point */
2673 if (!global.stats_fe) {
2674 if ((global.stats_fe = alloc_stats_fe("GLOBAL", "master-socket", 0)) == NULL) {
2675 ha_alert("out of memory trying to allocate the stats frontend");
William Lallemand744a0892018-11-22 16:46:51 +01002676 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002677 }
2678 }
2679
2680 bind_conf = bind_conf_alloc(global.stats_fe, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002681 if (!bind_conf)
2682 goto error;
2683
William Lallemandce83b4a2018-10-26 14:47:30 +02002684 bind_conf->level &= ~ACCESS_LVL_MASK;
2685 bind_conf->level |= ACCESS_LVL_ADMIN; /* TODO: need to lower the rights with a CLI keyword*/
2686
2687 bind_conf->bind_proc = 1UL << proc;
2688 global.stats_fe->bind_proc = 0; /* XXX: we should be careful with that, it can be removed by configuration */
2689
2690 if (!memprintf(&path, "sockpair@%d", mworker_proc->ipc_fd[1])) {
2691 ha_alert("Cannot allocate listener.\n");
William Lallemand744a0892018-11-22 16:46:51 +01002692 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002693 }
2694
2695 if (!str2listener(path, global.stats_fe, bind_conf, "master-socket", 0, &err)) {
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002696 free(path);
William Lallemandce83b4a2018-10-26 14:47:30 +02002697 ha_alert("Cannot create a CLI sockpair listener for process #%d\n", proc);
William Lallemand744a0892018-11-22 16:46:51 +01002698 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002699 }
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002700 free(path);
2701 path = NULL;
William Lallemandce83b4a2018-10-26 14:47:30 +02002702
2703 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemandce83b4a2018-10-26 14:47:30 +02002704 l->accept = session_accept_fd;
2705 l->default_target = global.stats_fe->default_target;
William Lallemanda3372292018-11-16 16:57:22 +01002706 l->options |= (LI_O_UNLIMITED | LI_O_NOSTOP);
William Lallemandce83b4a2018-10-26 14:47:30 +02002707 /* it's a sockpair but we don't want to keep the fd in the master */
2708 l->options &= ~LI_O_INHERITED;
2709 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002710 global.maxsock++; /* for the listening socket */
William Lallemandce83b4a2018-10-26 14:47:30 +02002711 }
2712
2713 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002714
2715error:
2716 close(mworker_proc->ipc_fd[0]);
2717 close(mworker_proc->ipc_fd[1]);
2718 free(err);
2719
2720 return -1;
William Lallemandce83b4a2018-10-26 14:47:30 +02002721}
2722
William Lallemand74c24fb2016-11-21 17:18:36 +01002723static struct applet cli_applet = {
2724 .obj_type = OBJ_TYPE_APPLET,
2725 .name = "<CLI>", /* used for logging */
2726 .fct = cli_io_handler,
2727 .release = cli_release_handler,
2728};
2729
Willy Tarreau0a739292016-11-22 20:21:23 +01002730/* register cli keywords */
2731static struct cli_kw_list cli_kws = {{ },{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002732 { { "help", NULL }, NULL, cli_parse_simple, NULL },
2733 { { "prompt", NULL }, NULL, cli_parse_simple, NULL },
2734 { { "quit", NULL }, NULL, cli_parse_simple, NULL },
Willy Tarreau2af99412016-11-23 11:10:59 +01002735 { { "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 +01002736 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002737 { { "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 +01002738 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002739 { { "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 +02002740 { { "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 },
William Lallemand67a234f2018-12-13 09:05:45 +01002741 { { "show", "cli", "level", NULL }, "show cli level : display the level of the current CLI session", cli_parse_show_lvl, NULL, NULL, NULL, ACCESS_MASTER},
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02002742 { { "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 +01002743 { { "show", "activity", NULL }, "show activity : show per-thread activity stats (for support/developers)", cli_parse_default, cli_io_handler_show_activity, NULL },
William Lallemand67a234f2018-12-13 09:05:45 +01002744 { { "operator", NULL }, "operator : lower the level of the current CLI session to operator", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
2745 { { "user", NULL }, "user : lower the level of the current CLI session to user", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
Olivier Houchardf886e342017-04-05 22:24:59 +02002746 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02002747 { { "expert-mode", NULL }, NULL, cli_parse_expert_mode, NULL }, // not listed
Willy Tarreau0a739292016-11-22 20:21:23 +01002748 {{},}
2749}};
2750
Willy Tarreau0108d902018-11-25 19:14:37 +01002751INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
2752
William Lallemand74c24fb2016-11-21 17:18:36 +01002753static struct cfg_kw_list cfg_kws = {ILH, {
2754 { CFG_GLOBAL, "stats", stats_parse_global },
2755 { 0, NULL, NULL },
2756}};
2757
Willy Tarreau0108d902018-11-25 19:14:37 +01002758INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
2759
William Lallemand74c24fb2016-11-21 17:18:36 +01002760static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02002761 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
2762 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002763 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01002764 { NULL, NULL, 0 },
2765}};
2766
Willy Tarreau0108d902018-11-25 19:14:37 +01002767INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01002768
2769/*
2770 * Local variables:
2771 * c-indent-level: 8
2772 * c-basic-offset: 8
2773 * End:
2774 */