blob: 77db8be883259b2845afa3b09f5d779b79398ee4 [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>
Willy Tarreauc125cef2019-05-10 09:58:43 +020069#include <proto/ssl_sock.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010070#include <proto/stream_interface.h>
71#include <proto/task.h>
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +020072#include <proto/proto_udp.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010073
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020074#define PAYLOAD_PATTERN "<<"
75
William Lallemand74c24fb2016-11-21 17:18:36 +010076static struct applet cli_applet;
77
78static const char stats_sock_usage_msg[] =
79 "Unknown command. Please enter one of the following commands only :\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010080 " help : this message\n"
81 " prompt : toggle interactive mode with prompt\n"
82 " quit : disconnect\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010083 "";
84
85static const char stats_permission_denied_msg[] =
86 "Permission denied\n"
87 "";
88
89
Christopher Faulet1bc04c72017-10-29 20:14:08 +010090static THREAD_LOCAL char *dynamic_usage_msg = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +010091
92/* List head of cli keywords */
93static struct cli_kw_list cli_keywords = {
94 .list = LIST_HEAD_INIT(cli_keywords.list)
95};
96
97extern const char *stat_status_codes[];
98
William Lallemand8a022572018-10-26 14:47:35 +020099static struct proxy *mworker_proxy; /* CLI proxy of the master */
100
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200101static char *cli_gen_usage_msg(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100102{
103 struct cli_kw_list *kw_list;
104 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +0200105 struct buffer *tmp = get_trash_chunk();
106 struct buffer out;
William Lallemand74c24fb2016-11-21 17:18:36 +0100107
108 free(dynamic_usage_msg);
109 dynamic_usage_msg = NULL;
110
111 if (LIST_ISEMPTY(&cli_keywords.list))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200112 goto end;
William Lallemand74c24fb2016-11-21 17:18:36 +0100113
114 chunk_reset(tmp);
115 chunk_strcat(tmp, stats_sock_usage_msg);
116 list_for_each_entry(kw_list, &cli_keywords.list, list) {
117 kw = &kw_list->kw[0];
William Lallemand0154edc2018-05-15 11:50:04 +0200118 while (kw->str_kw[0]) {
William Lallemand14721be2018-10-26 14:47:37 +0200119
120 /* in a worker or normal process, don't display master only commands */
121 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
122 goto next_kw;
123
124 /* in master don't displays if we don't have the master bits */
125 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
126 goto next_kw;
127
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200128 /* only show expert commands in expert mode */
129 if ((kw->level & ~appctx->cli_level) & ACCESS_EXPERT)
130 goto next_kw;
131
William Lallemand0154edc2018-05-15 11:50:04 +0200132 if (kw->usage)
133 chunk_appendf(tmp, " %s\n", kw->usage);
William Lallemand14721be2018-10-26 14:47:37 +0200134
135next_kw:
136
William Lallemand74c24fb2016-11-21 17:18:36 +0100137 kw++;
138 }
139 }
140 chunk_init(&out, NULL, 0);
141 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200142 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200143
144end:
145 if (dynamic_usage_msg) {
146 appctx->ctx.cli.severity = LOG_INFO;
147 appctx->ctx.cli.msg = dynamic_usage_msg;
148 }
149 else {
150 appctx->ctx.cli.severity = LOG_INFO;
151 appctx->ctx.cli.msg = stats_sock_usage_msg;
152 }
153 appctx->st0 = CLI_ST_PRINT;
154
William Lallemand74c24fb2016-11-21 17:18:36 +0100155 return dynamic_usage_msg;
156}
157
158struct cli_kw* cli_find_kw(char **args)
159{
160 struct cli_kw_list *kw_list;
161 struct cli_kw *kw;/* current cli_kw */
162 char **tmp_args;
163 const char **tmp_str_kw;
164 int found = 0;
165
166 if (LIST_ISEMPTY(&cli_keywords.list))
167 return NULL;
168
169 list_for_each_entry(kw_list, &cli_keywords.list, list) {
170 kw = &kw_list->kw[0];
171 while (*kw->str_kw) {
172 tmp_args = args;
173 tmp_str_kw = kw->str_kw;
174 while (*tmp_str_kw) {
175 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
176 found = 1;
177 } else {
178 found = 0;
179 break;
180 }
181 tmp_args++;
182 tmp_str_kw++;
183 }
184 if (found)
185 return (kw);
186 kw++;
187 }
188 }
189 return NULL;
190}
191
192void cli_register_kw(struct cli_kw_list *kw_list)
193{
194 LIST_ADDQ(&cli_keywords.list, &kw_list->list);
195}
196
197
198/* allocate a new stats frontend named <name>, and return it
199 * (or NULL in case of lack of memory).
200 */
201static struct proxy *alloc_stats_fe(const char *name, const char *file, int line)
202{
203 struct proxy *fe;
204
205 fe = calloc(1, sizeof(*fe));
206 if (!fe)
207 return NULL;
208
209 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100210 fe->next = proxies_list;
211 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100212 fe->last_change = now.tv_sec;
213 fe->id = strdup("GLOBAL");
214 fe->cap = PR_CAP_FE;
215 fe->maxconn = 10; /* default to 10 concurrent connections */
216 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
217 fe->conf.file = strdup(file);
218 fe->conf.line = line;
219 fe->accept = frontend_accept;
220 fe->default_target = &cli_applet.obj_type;
221
222 /* the stats frontend is the only one able to assign ID #0 */
223 fe->conf.id.key = fe->uuid = 0;
224 eb32_insert(&used_proxy_id, &fe->conf.id);
225 return fe;
226}
227
228/* This function parses a "stats" statement in the "global" section. It returns
229 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
230 * error message into the <err> buffer which will be preallocated. The trailing
231 * '\n' must not be written. The function must be called with <args> pointing to
232 * the first word after "stats".
233 */
234static int stats_parse_global(char **args, int section_type, struct proxy *curpx,
235 struct proxy *defpx, const char *file, int line,
236 char **err)
237{
238 struct bind_conf *bind_conf;
239 struct listener *l;
240
241 if (!strcmp(args[1], "socket")) {
242 int cur_arg;
243
244 if (*args[2] == 0) {
245 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
246 return -1;
247 }
248
249 if (!global.stats_fe) {
250 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
251 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
252 return -1;
253 }
254 }
255
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100256 bind_conf = bind_conf_alloc(global.stats_fe, file, line, args[2], xprt_get(XPRT_RAW));
William Lallemand07a62f72017-05-24 00:57:40 +0200257 bind_conf->level &= ~ACCESS_LVL_MASK;
258 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100259
260 if (!str2listener(args[2], global.stats_fe, bind_conf, file, line, err)) {
261 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
262 file, line, args[0], args[1], err && *err ? *err : "error");
263 return -1;
264 }
265
266 cur_arg = 3;
267 while (*args[cur_arg]) {
268 static int bind_dumped;
269 struct bind_kw *kw;
270
271 kw = bind_find_kw(args[cur_arg]);
272 if (kw) {
273 if (!kw->parse) {
274 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
275 args[0], args[1], args[cur_arg]);
276 return -1;
277 }
278
279 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, err) != 0) {
280 if (err && *err)
281 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
282 else
283 memprintf(err, "'%s %s' : error encountered while processing '%s'",
284 args[0], args[1], args[cur_arg]);
285 return -1;
286 }
287
288 cur_arg += 1 + kw->skip;
289 continue;
290 }
291
292 if (!bind_dumped) {
293 bind_dump_kws(err);
294 indent_msg(err, 4);
295 bind_dumped = 1;
296 }
297
298 memprintf(err, "'%s %s' : unknown keyword '%s'.%s%s",
299 args[0], args[1], args[cur_arg],
300 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
301 return -1;
302 }
303
304 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100305 l->accept = session_accept_fd;
William Lallemand74c24fb2016-11-21 17:18:36 +0100306 l->default_target = global.stats_fe->default_target;
307 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
308 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100309 global.maxsock++; /* for the listening socket */
William Lallemand74c24fb2016-11-21 17:18:36 +0100310 }
311 }
312 else if (!strcmp(args[1], "timeout")) {
313 unsigned timeout;
314 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
315
Willy Tarreau9faebe32019-06-07 19:00:37 +0200316 if (res == PARSE_TIME_OVER) {
317 memprintf(err, "timer overflow in argument '%s' to '%s %s' (maximum value is 2147483647 ms or ~24.8 days)",
318 args[2], args[0], args[1]);
319 return -1;
320 }
321 else if (res == PARSE_TIME_UNDER) {
322 memprintf(err, "timer underflow in argument '%s' to '%s %s' (minimum non-null value is 1 ms)",
323 args[2], args[0], args[1]);
324 return -1;
325 }
326 else if (res) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100327 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
328 return -1;
329 }
330
331 if (!timeout) {
332 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
333 return -1;
334 }
335 if (!global.stats_fe) {
336 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
337 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
338 return -1;
339 }
340 }
341 global.stats_fe->timeout.client = MS_TO_TICKS(timeout);
342 }
343 else if (!strcmp(args[1], "maxconn")) {
344 int maxconn = atol(args[2]);
345
346 if (maxconn <= 0) {
347 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
348 return -1;
349 }
350
351 if (!global.stats_fe) {
352 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
353 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
354 return -1;
355 }
356 }
357 global.stats_fe->maxconn = maxconn;
358 }
359 else if (!strcmp(args[1], "bind-process")) { /* enable the socket only on some processes */
360 int cur_arg = 2;
361 unsigned long set = 0;
362
363 if (!global.stats_fe) {
364 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
365 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
366 return -1;
367 }
368 }
369
370 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100371 if (strcmp(args[cur_arg], "all") == 0) {
372 set = 0;
373 break;
374 }
Willy Tarreauff9c9142019-02-07 10:39:36 +0100375 if (parse_process_number(args[cur_arg], &set, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100376 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100377 return -1;
378 }
379 cur_arg++;
380 }
381 global.stats_fe->bind_proc = set;
382 }
383 else {
384 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
385 return -1;
386 }
387 return 0;
388}
389
William Lallemand33d29e22019-04-01 11:30:06 +0200390/*
William Lallemand9a37fd02019-04-12 16:09:24 +0200391 * This function exports the bound addresses of a <frontend> in the environment
392 * variable <varname>. Those addresses are separated by semicolons and prefixed
393 * with their type (abns@, unix@, sockpair@ etc)
394 * Return -1 upon error, 0 otherwise
William Lallemand33d29e22019-04-01 11:30:06 +0200395 */
William Lallemand9a37fd02019-04-12 16:09:24 +0200396int listeners_setenv(struct proxy *frontend, const char *varname)
William Lallemand33d29e22019-04-01 11:30:06 +0200397{
398 struct buffer *trash = get_trash_chunk();
399 struct bind_conf *bind_conf;
400
William Lallemand9a37fd02019-04-12 16:09:24 +0200401 if (frontend) {
402 list_for_each_entry(bind_conf, &frontend->conf.bind, by_fe) {
William Lallemand33d29e22019-04-01 11:30:06 +0200403 struct listener *l;
404
405 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
406 char addr[46];
407 char port[6];
408
William Lallemand620072b2019-04-12 16:09:25 +0200409 /* separate listener by semicolons */
410 if (trash->data)
411 chunk_appendf(trash, ";");
412
William Lallemand33d29e22019-04-01 11:30:06 +0200413 if (l->addr.ss_family == AF_UNIX) {
414 const struct sockaddr_un *un;
415
416 un = (struct sockaddr_un *)&l->addr;
417 if (un->sun_path[0] == '\0') {
418 chunk_appendf(trash, "abns@%s", un->sun_path+1);
419 } else {
420 chunk_appendf(trash, "unix@%s", un->sun_path);
421 }
422 } else if (l->addr.ss_family == AF_INET) {
423 addr_to_str(&l->addr, addr, sizeof(addr));
424 port_to_str(&l->addr, port, sizeof(port));
425 chunk_appendf(trash, "ipv4@%s:%s", addr, port);
426 } else if (l->addr.ss_family == AF_INET6) {
427 addr_to_str(&l->addr, addr, sizeof(addr));
428 port_to_str(&l->addr, port, sizeof(port));
429 chunk_appendf(trash, "ipv6@[%s]:%s", addr, port);
430 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
431 chunk_appendf(trash, "sockpair@%d", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
432 }
William Lallemand33d29e22019-04-01 11:30:06 +0200433 }
434 }
435 trash->area[trash->data++] = '\0';
William Lallemand9a37fd02019-04-12 16:09:24 +0200436 if (setenv(varname, trash->area, 1) < 0)
William Lallemand33d29e22019-04-01 11:30:06 +0200437 return -1;
438 }
439
440 return 0;
441}
442
William Lallemand9a37fd02019-04-12 16:09:24 +0200443int cli_socket_setenv()
444{
445 if (listeners_setenv(global.stats_fe, "HAPROXY_CLI") < 0)
446 return -1;
447 if (listeners_setenv(mworker_proxy, "HAPROXY_MASTER_CLI") < 0)
448 return -1;
449
450 return 0;
451}
452
William Lallemand33d29e22019-04-01 11:30:06 +0200453REGISTER_CONFIG_POSTPARSER("cli", cli_socket_setenv);
454
Willy Tarreaude57a572016-11-23 17:01:39 +0100455/* Verifies that the CLI at least has a level at least as high as <level>
456 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
457 * failure, an error message is prepared and the appctx's state is adjusted
458 * to print it so that a return 1 is enough to abort any processing.
459 */
460int cli_has_level(struct appctx *appctx, int level)
461{
Willy Tarreaude57a572016-11-23 17:01:39 +0100462
William Lallemandf630d012018-12-13 09:05:44 +0100463 if ((appctx->cli_level & ACCESS_LVL_MASK) < level) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200464 cli_err(appctx, stats_permission_denied_msg);
Willy Tarreaude57a572016-11-23 17:01:39 +0100465 return 0;
466 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100467 return 1;
468}
469
William Lallemandb7ea1412018-12-13 09:05:47 +0100470/* same as cli_has_level but for the CLI proxy and without error message */
471int pcli_has_level(struct stream *s, int level)
472{
473 if ((s->pcli_flags & ACCESS_LVL_MASK) < level) {
474 return 0;
475 }
476 return 1;
477}
478
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200479/* Returns severity_output for the current session if set, or default for the socket */
480static int cli_get_severity_output(struct appctx *appctx)
481{
482 if (appctx->cli_severity_output)
483 return appctx->cli_severity_output;
484 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
485}
William Lallemand74c24fb2016-11-21 17:18:36 +0100486
Willy Tarreau41908562016-11-24 16:23:38 +0100487/* Processes the CLI interpreter on the stats socket. This function is called
488 * from the CLI's IO handler running in an appctx context. The function returns 1
489 * if the request was understood, otherwise zero. It is called with appctx->st0
490 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
491 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
492 * have its own I/O handler called again. Most of the time, parsers will only
493 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100494 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
495 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100496 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200497static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100498{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200499 char *args[MAX_STATS_ARGS + 1], *p, *end, *payload = NULL;
500 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100501 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100502
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200503 appctx->st2 = 0;
504 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
Willy Tarreau300decc2019-08-30 08:05:03 +0200505 LIST_INIT(&appctx->ctx.cli.l0);
William Lallemand74c24fb2016-11-21 17:18:36 +0100506
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200507 p = appctx->chunk->area;
508 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100509
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200510 /*
511 * Get the payload start if there is one.
512 * For the sake of simplicity, the payload pattern is looked up
513 * everywhere from the start of the input but it can only be found
514 * at the end of the first line if APPCTX_CLI_ST1_PAYLOAD is set.
515 *
516 * The input string was zero terminated so it is safe to use
517 * the str*() functions throughout the parsing
518 */
519 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
520 payload = strstr(p, PAYLOAD_PATTERN);
521 end = payload;
522 /* skip the pattern */
523 payload += strlen(PAYLOAD_PATTERN);
524 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100525
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200526 /*
527 * Get pointers on words.
528 * One extra slot is reserved to store a pointer on a null byte.
529 */
530 while (i < MAX_STATS_ARGS && p < end) {
531 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100532
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200533 /* skip leading spaces/tabs */
534 p += strspn(p, " \t");
535 if (!*p)
536 break;
William Lallemand74c24fb2016-11-21 17:18:36 +0100537
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200538 args[i] = p;
539 p += strcspn(p, " \t");
540 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100541
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200542 /* unescape backslashes (\) */
543 for (j = 0, k = 0; args[i][k]; k++) {
544 if (args[i][k] == '\\') {
545 if (args[i][k + 1] == '\\')
546 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100547 else
548 continue;
549 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200550 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100551 j++;
552 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200553 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100554
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200555 i++;
556 }
557 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200558 p = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200559 for (; i < MAX_STATS_ARGS + 1; i++)
560 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100561
562 kw = cli_find_kw(args);
Willy Tarreaueaffde32016-12-16 17:59:25 +0100563 if (!kw)
Willy Tarreau41908562016-11-24 16:23:38 +0100564 return 0;
565
William Lallemand14721be2018-10-26 14:47:37 +0200566 /* in a worker or normal process, don't display master only commands */
567 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
568 return 0;
569
570 /* in master don't displays if we don't have the master bits */
571 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
572 return 0;
573
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200574 /* only accept expert commands in expert mode */
575 if ((kw->level & ~appctx->cli_level) & ACCESS_EXPERT)
576 return 0;
577
Willy Tarreau41908562016-11-24 16:23:38 +0100578 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200579 appctx->io_release = kw->io_release;
William Lallemand90b098c2019-10-25 21:10:14 +0200580
581 if (kw->parse && kw->parse(args, payload, appctx, kw->private) != 0)
582 goto fail;
583
584 /* kw->parse could set its own io_handler or io_release handler */
585 if (!appctx->io_handler)
586 goto fail;
587
588 appctx->st0 = CLI_ST_CALLBACK;
589 return 1;
590fail:
591 appctx->io_handler = NULL;
592 appctx->io_release = NULL;
Willy Tarreau41908562016-11-24 16:23:38 +0100593 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100594}
595
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200596/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
597static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
598{
Willy Tarreau83061a82018-07-13 11:56:34 +0200599 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200600
601 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200602 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200603
604 tmp = get_trash_chunk();
605 chunk_reset(tmp);
606
607 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100608 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200609 chunk_printf(tmp, "[%d]: ", severity);
610 }
611 else {
612 switch (severity_output) {
613 case CLI_SEVERITY_NUMBER:
614 chunk_printf(tmp, "[%d]: ", severity);
615 break;
616 case CLI_SEVERITY_STRING:
617 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
618 break;
619 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100620 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200621 }
622 }
623 chunk_appendf(tmp, "%s", msg);
624
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200625 return ci_putblk(chn, tmp->area, strlen(tmp->area));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200626}
627
William Lallemand74c24fb2016-11-21 17:18:36 +0100628/* This I/O handler runs as an applet embedded in a stream interface. It is
629 * used to processes I/O from/to the stats unix socket. The system relies on a
630 * state machine handling requests and various responses. We read a request,
631 * then we process it and send the response, and we possibly display a prompt.
632 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100633 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100634 * or not.
635 */
636static void cli_io_handler(struct appctx *appctx)
637{
638 struct stream_interface *si = appctx->owner;
639 struct channel *req = si_oc(si);
640 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200641 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100642 int reql;
643 int len;
644
645 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
646 goto out;
647
Joseph Herlant008b3ce2018-11-25 12:51:45 -0800648 /* Check if the input buffer is available. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200649 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +0100650 /* buf.size==0 means we failed to get a buffer and were
651 * already subscribed to a wait list to get a buffer.
652 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100653 goto out;
654 }
655
William Lallemand74c24fb2016-11-21 17:18:36 +0100656 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100657 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100658 /* Stats output not initialized yet */
659 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200660 /* reset severity to default at init */
661 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100662 appctx->st0 = CLI_ST_GETREQ;
William Lallemandf630d012018-12-13 09:05:44 +0100663 appctx->cli_level = bind_conf->level;
William Lallemand74c24fb2016-11-21 17:18:36 +0100664 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100665 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100666 /* Let's close for real now. We just close the request
667 * side, the conditions below will complete if needed.
668 */
669 si_shutw(si);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200670 free_trash_chunk(appctx->chunk);
William Lallemand74c24fb2016-11-21 17:18:36 +0100671 break;
672 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100673 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200674 char *str;
675
676 /* use a trash chunk to store received data */
677 if (!appctx->chunk) {
678 appctx->chunk = alloc_trash_chunk();
679 if (!appctx->chunk) {
680 appctx->st0 = CLI_ST_END;
681 continue;
682 }
683 }
684
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200685 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200686
William Lallemand74c24fb2016-11-21 17:18:36 +0100687 /* ensure we have some output room left in the event we
688 * would want to return some info right after parsing.
689 */
690 if (buffer_almost_full(si_ib(si))) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100691 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100692 break;
693 }
694
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200695 /* '- 1' is to ensure a null byte can always be inserted at the end */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200696 reql = co_getline(si_oc(si), str,
697 appctx->chunk->size - appctx->chunk->data - 1);
William Lallemand74c24fb2016-11-21 17:18:36 +0100698 if (reql <= 0) { /* closed or EOL not found */
699 if (reql == 0)
700 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100701 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100702 continue;
703 }
704
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200705 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
706 /* seek for a possible unescaped semi-colon. If we find
707 * one, we replace it with an LF and skip only this part.
708 */
709 for (len = 0; len < reql; len++) {
710 if (str[len] == '\\') {
711 len++;
712 continue;
713 }
714 if (str[len] == ';') {
715 str[len] = '\n';
716 reql = len + 1;
717 break;
718 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100719 }
720 }
721
722 /* now it is time to check that we have a full line,
723 * remove the trailing \n and possibly \r, then cut the
724 * line.
725 */
726 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200727 if (str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100728 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100729 continue;
730 }
731
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200732 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100733 len--;
734
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200735 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200736 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200737
738 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200739 appctx->chunk->area[appctx->chunk->data] = '\n';
740 appctx->chunk->area[appctx->chunk->data + 1] = 0;
741 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200742 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100743
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100744 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200745
746 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
747 /* empty line */
748 if (!len) {
749 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200750 appctx->chunk->data -= 2;
751 appctx->chunk->area[appctx->chunk->data] = 0;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200752
753 if (!cli_parse_request(appctx))
754 cli_gen_usage_msg(appctx);
755
756 chunk_reset(appctx->chunk);
757 /* NB: cli_sock_parse_request() may have put
758 * another CLI_ST_O_* into appctx->st0.
759 */
760
761 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +0100762 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100763 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200764 else {
765 /*
766 * Look for the "payload start" pattern at the end of a line
767 * Its location is not remembered here, this is just to switch
768 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +0100769 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200770 if (!strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200771 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200772 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200773 /* no payload, the command is complete: parse the request */
774 if (!cli_parse_request(appctx))
775 cli_gen_usage_msg(appctx);
776
777 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200778 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100779 }
780
781 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200782 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100783 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
784 }
785 else { /* output functions */
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200786 const char *msg;
787 int sev;
788
William Lallemand74c24fb2016-11-21 17:18:36 +0100789 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100790 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100791 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200792 case CLI_ST_PRINT: /* print const message in msg */
793 case CLI_ST_PRINT_ERR: /* print const error in msg */
794 case CLI_ST_PRINT_DYN: /* print dyn message in msg, free */
795 case CLI_ST_PRINT_FREE: /* print dyn error in err, free */
796 if (appctx->st0 == CLI_ST_PRINT || appctx->st0 == CLI_ST_PRINT_ERR) {
797 sev = appctx->st0 == CLI_ST_PRINT_ERR ?
798 LOG_ERR : appctx->ctx.cli.severity;
799 msg = appctx->ctx.cli.msg;
800 }
801 else if (appctx->st0 == CLI_ST_PRINT_DYN || appctx->st0 == CLI_ST_PRINT_FREE) {
802 sev = appctx->st0 == CLI_ST_PRINT_FREE ?
803 LOG_ERR : appctx->ctx.cli.severity;
804 msg = appctx->ctx.cli.err;
805 if (!msg) {
806 sev = LOG_ERR;
807 msg = "Out of memory.\n";
808 }
809 }
810 else {
811 sev = LOG_ERR;
812 msg = "Internal error.\n";
813 }
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200814
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200815 if (cli_output_msg(res, msg, sev, cli_get_severity_output(appctx)) != -1) {
816 if (appctx->st0 == CLI_ST_PRINT_FREE ||
817 appctx->st0 == CLI_ST_PRINT_DYN) {
818 free(appctx->ctx.cli.err);
819 appctx->ctx.cli.err = NULL;
820 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100821 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100822 }
823 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100824 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100825 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200826
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100827 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100828 if (appctx->io_handler)
829 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100830 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100831 if (appctx->io_release) {
832 appctx->io_release(appctx);
833 appctx->io_release = NULL;
834 }
835 }
836 break;
837 default: /* abnormal state */
838 si->flags |= SI_FL_ERR;
839 break;
840 }
841
842 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100843 if (appctx->st0 == CLI_ST_PROMPT) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200844 const char *prompt = "";
845
846 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
847 /*
848 * when entering a payload with interactive mode, change the prompt
849 * to emphasize that more data can still be sent
850 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200851 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200852 prompt = "+ ";
853 else
854 prompt = "\n> ";
855 }
856 else {
William Lallemandad032882019-07-01 10:56:15 +0200857 if (!(appctx->st1 & (APPCTX_CLI_ST1_PAYLOAD|APPCTX_CLI_ST1_NOLF)))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200858 prompt = "\n";
859 }
860
861 if (ci_putstr(si_ic(si), prompt) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100862 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100863 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100864 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100865 }
866
867 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100868 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100869 break;
870
871 /* Now we close the output if one of the writers did so,
872 * or if we're not in interactive mode and the request
873 * buffer is empty. This still allows pipelined requests
874 * to be sent in non-interactive mode.
875 */
William Lallemand3de09d52018-12-11 16:10:56 +0100876 if (((res->flags & (CF_SHUTW|CF_SHUTW_NOW))) ||
877 (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req) && (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)))) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100878 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100879 continue;
880 }
881
882 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100883 appctx->st0 = CLI_ST_GETREQ;
William Lallemandad032882019-07-01 10:56:15 +0200884 /* reactivate the \n at the end of the response for the next command */
885 appctx->st1 &= ~APPCTX_CLI_ST1_NOLF;
William Lallemand74c24fb2016-11-21 17:18:36 +0100886 }
887 }
888
889 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
890 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
891 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
892 /* Other side has closed, let's abort if we have no more processing to do
893 * and nothing more to consume. This is comparable to a broken pipe, so
894 * we forward the close to the request side so that it flows upstream to
895 * the client.
896 */
897 si_shutw(si);
898 }
899
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100900 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100901 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
902 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
903 /* We have no more processing to do, and nothing more to send, and
904 * the client side has closed. So we'll forward this state downstream
905 * on the response buffer.
906 */
907 si_shutr(si);
908 res->flags |= CF_READ_NULL;
909 }
910
911 out:
Christopher Faulet45073512018-07-20 10:16:29 +0200912 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 +0100913 __FUNCTION__, __LINE__,
Christopher Faulet45073512018-07-20 10:16:29 +0200914 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 +0100915}
916
William Lallemand74c24fb2016-11-21 17:18:36 +0100917/* This is called when the stream interface is closed. For instance, upon an
918 * external abort, we won't call the i/o handler anymore so we may need to
919 * remove back references to the stream currently being dumped.
920 */
921static void cli_release_handler(struct appctx *appctx)
922{
923 if (appctx->io_release) {
924 appctx->io_release(appctx);
925 appctx->io_release = NULL;
926 }
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200927 else if (appctx->st0 == CLI_ST_PRINT_FREE || appctx->st0 == CLI_ST_PRINT_DYN) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100928 free(appctx->ctx.cli.err);
929 appctx->ctx.cli.err = NULL;
930 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100931}
932
933/* This function dumps all environmnent variables to the buffer. It returns 0
934 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +0100935 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
936 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +0100937 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100938static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100939{
Willy Tarreau0a739292016-11-22 20:21:23 +0100940 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100941 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100942
943 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
944 return 1;
945
946 chunk_reset(&trash);
947
948 /* we have two inner loops here, one for the proxy, the other one for
949 * the buffer.
950 */
Willy Tarreauf6710f82016-12-16 17:45:44 +0100951 while (*var) {
952 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +0100953
Willy Tarreau06d80a92017-10-19 14:32:15 +0200954 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100955 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100956 return 0;
957 }
958 if (appctx->st2 == STAT_ST_END)
959 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100960 var++;
961 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +0100962 }
963
964 /* dump complete */
965 return 1;
966}
967
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200968/* This function dumps all file descriptors states (or the requested one) to
969 * the buffer. It returns 0 if the output buffer is full and it needs to be
970 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
971 * It uses cli.i0 as the fd number to restart from.
972 */
973static int cli_io_handler_show_fd(struct appctx *appctx)
974{
975 struct stream_interface *si = appctx->owner;
976 int fd = appctx->ctx.cli.i0;
Willy Tarreauca1b1572018-12-18 15:45:11 +0100977 int ret = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200978
979 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
Willy Tarreauca1b1572018-12-18 15:45:11 +0100980 goto end;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200981
982 chunk_reset(&trash);
983
Willy Tarreauca1b1572018-12-18 15:45:11 +0100984 /* isolate the threads once per round. We're limited to a buffer worth
985 * of output anyway, it cannot last very long.
986 */
987 thread_isolate();
988
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200989 /* we have two inner loops here, one for the proxy, the other one for
990 * the buffer.
991 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +0100992 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200993 struct fdtab fdt;
Willy Tarreau286ec682017-08-09 16:35:44 +0200994 struct listener *li = NULL;
995 struct server *sv = NULL;
996 struct proxy *px = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +0200997 const struct mux_ops *mux = NULL;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200998 void *ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +0200999 uint32_t conn_flags = 0;
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001000 int is_back = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001001
1002 fdt = fdtab[fd];
1003
Willy Tarreauca1b1572018-12-18 15:45:11 +01001004 if (!fdt.owner)
Willy Tarreau017af242017-10-04 20:24:54 +02001005 goto skip; // closed
1006
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001007 if (fdt.iocb == conn_fd_handler) {
1008 conn_flags = ((struct connection *)fdt.owner)->flags;
Willy Tarreau35b1b482018-03-28 18:41:30 +02001009 mux = ((struct connection *)fdt.owner)->mux;
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001010 ctx = ((struct connection *)fdt.owner)->ctx;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001011 li = objt_listener(((struct connection *)fdt.owner)->target);
1012 sv = objt_server(((struct connection *)fdt.owner)->target);
1013 px = objt_proxy(((struct connection *)fdt.owner)->target);
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001014 is_back = conn_is_back((struct connection *)fdt.owner);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001015 }
1016 else if (fdt.iocb == listener_accept)
1017 li = fdt.owner;
1018
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001019 chunk_printf(&trash,
Willy Tarreau5bee3e22019-09-04 09:52:57 +02001020 " %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(%s)",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001021 fd,
1022 fdt.state,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001023 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
1024 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001025 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
1026 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
1027 fdt.ev,
1028 (fdt.ev & FD_POLL_HUP) ? 'H' : 'h',
1029 (fdt.ev & FD_POLL_ERR) ? 'E' : 'e',
1030 (fdt.ev & FD_POLL_OUT) ? 'O' : 'o',
1031 (fdt.ev & FD_POLL_PRI) ? 'P' : 'p',
1032 (fdt.ev & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001033 fdt.linger_risk ? 'L' : 'l',
1034 fdt.cloned ? 'C' : 'c',
Willy Tarreauc754b342018-03-30 15:00:15 +02001035 fdt.thread_mask, fdt.update_mask,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001036 fdt.owner,
1037 fdt.iocb,
1038 (fdt.iocb == conn_fd_handler) ? "conn_fd_handler" :
1039 (fdt.iocb == dgram_fd_handler) ? "dgram_fd_handler" :
1040 (fdt.iocb == listener_accept) ? "listener_accept" :
Olivier Houchard79321b92018-07-26 17:55:11 +02001041 (fdt.iocb == poller_pipe_io_handler) ? "poller_pipe_io_handler" :
William Lallemanddb6bdfb2018-11-20 17:36:51 +01001042 (fdt.iocb == mworker_accept_wrapper) ? "mworker_accept_wrapper" :
Emeric Brund0e095c2019-04-19 17:15:28 +02001043#ifdef USE_OPENSSL
Willy Tarreau5db847a2019-05-09 14:13:35 +02001044#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brund0e095c2019-04-19 17:15:28 +02001045 (fdt.iocb == ssl_async_fd_free) ? "ssl_async_fd_free" :
1046 (fdt.iocb == ssl_async_fd_handler) ? "ssl_async_fd_handler" :
1047#endif
1048#endif
Willy Tarreauc754b342018-03-30 15:00:15 +02001049 "unknown");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001050
1051 if (fdt.iocb == conn_fd_handler) {
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001052 chunk_appendf(&trash, " back=%d cflg=0x%08x", is_back, conn_flags);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001053 if (px)
1054 chunk_appendf(&trash, " px=%s", px->id);
1055 else if (sv)
1056 chunk_appendf(&trash, " sv=%s/%s", sv->id, sv->proxy->id);
1057 else if (li)
1058 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +02001059
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001060 if (mux) {
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001061 chunk_appendf(&trash, " mux=%s ctx=%p", mux->name, ctx);
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001062 if (mux->show_fd)
1063 mux->show_fd(&trash, fdt.owner);
1064 }
Willy Tarreau35b1b482018-03-28 18:41:30 +02001065 else
1066 chunk_appendf(&trash, " nomux");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001067 }
1068 else if (fdt.iocb == listener_accept) {
1069 chunk_appendf(&trash, " l.st=%s fe=%s",
1070 listener_state_str(li),
1071 li->bind_conf->frontend->id);
1072 }
1073
1074 chunk_appendf(&trash, "\n");
1075
Willy Tarreau06d80a92017-10-19 14:32:15 +02001076 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001077 si_rx_room_blk(si);
Willy Tarreauca1b1572018-12-18 15:45:11 +01001078 appctx->ctx.cli.i0 = fd;
1079 ret = 0;
1080 break;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001081 }
1082 skip:
1083 if (appctx->st2 == STAT_ST_END)
1084 break;
1085
1086 fd++;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001087 }
1088
Willy Tarreauca1b1572018-12-18 15:45:11 +01001089 end:
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001090 /* dump complete */
Willy Tarreauca1b1572018-12-18 15:45:11 +01001091
1092 thread_release();
1093 return ret;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001094}
1095
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001096/* This function dumps some activity counters used by developers and support to
1097 * rule out some hypothesis during bug reports. It returns 0 if the output
1098 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
1099 * everything at once in the buffer and is not designed to do it in multiple
1100 * passes.
1101 */
1102static int cli_io_handler_show_activity(struct appctx *appctx)
1103{
1104 struct stream_interface *si = appctx->owner;
1105 int thr;
1106
1107 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1108 return 1;
1109
1110 chunk_reset(&trash);
1111
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001112#undef SHOW_TOT
1113#define SHOW_TOT(t, x) \
Willy Tarreaua0211b82019-05-28 15:09:08 +02001114 do { \
1115 unsigned int _v[MAX_THREADS]; \
1116 unsigned int _tot; \
1117 const unsigned int _nbt = global.nbthread; \
1118 for (_tot = t = 0; t < _nbt; t++) \
1119 _tot += _v[t] = (x); \
1120 if (_nbt == 1) { \
1121 chunk_appendf(&trash, " %u\n", _tot); \
1122 break; \
1123 } \
1124 chunk_appendf(&trash, " %u [", _tot); \
1125 for (t = 0; t < _nbt; t++) \
1126 chunk_appendf(&trash, " %u", _v[t]); \
1127 chunk_appendf(&trash, " ]\n"); \
1128 } while (0)
1129
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001130#undef SHOW_AVG
1131#define SHOW_AVG(t, x) \
1132 do { \
1133 unsigned int _v[MAX_THREADS]; \
1134 unsigned int _tot; \
1135 const unsigned int _nbt = global.nbthread; \
1136 for (_tot = t = 0; t < _nbt; t++) \
1137 _tot += _v[t] = (x); \
1138 if (_nbt == 1) { \
1139 chunk_appendf(&trash, " %u\n", _tot); \
1140 break; \
1141 } \
1142 chunk_appendf(&trash, " %u [", (_tot + _nbt/2) / _nbt); \
1143 for (t = 0; t < _nbt; t++) \
1144 chunk_appendf(&trash, " %u", _v[t]); \
1145 chunk_appendf(&trash, " ]\n"); \
1146 } while (0)
1147
Willy Tarreaua0211b82019-05-28 15:09:08 +02001148 chunk_appendf(&trash, "thread_id: %u (%u..%u)\n", tid + 1, 1, global.nbthread);
1149 chunk_appendf(&trash, "date_now: %lu.%06lu\n", (long)now.tv_sec, (long)now.tv_usec);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001150 chunk_appendf(&trash, "loops:"); SHOW_TOT(thr, activity[thr].loops);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001151 chunk_appendf(&trash, "wake_tasks:"); SHOW_TOT(thr, activity[thr].wake_tasks);
1152 chunk_appendf(&trash, "wake_signal:"); SHOW_TOT(thr, activity[thr].wake_signal);
1153 chunk_appendf(&trash, "poll_exp:"); SHOW_TOT(thr, activity[thr].poll_exp);
1154 chunk_appendf(&trash, "poll_drop:"); SHOW_TOT(thr, activity[thr].poll_drop);
1155 chunk_appendf(&trash, "poll_dead:"); SHOW_TOT(thr, activity[thr].poll_dead);
1156 chunk_appendf(&trash, "poll_skip:"); SHOW_TOT(thr, activity[thr].poll_skip);
1157 chunk_appendf(&trash, "fd_lock:"); SHOW_TOT(thr, activity[thr].fd_lock);
1158 chunk_appendf(&trash, "conn_dead:"); SHOW_TOT(thr, activity[thr].conn_dead);
1159 chunk_appendf(&trash, "stream:"); SHOW_TOT(thr, activity[thr].stream);
Willy Tarreaua8b2ce02019-05-28 17:04:16 +02001160 chunk_appendf(&trash, "pool_fail:"); SHOW_TOT(thr, activity[thr].pool_fail);
1161 chunk_appendf(&trash, "buf_wait:"); SHOW_TOT(thr, activity[thr].buf_wait);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001162 chunk_appendf(&trash, "empty_rq:"); SHOW_TOT(thr, activity[thr].empty_rq);
1163 chunk_appendf(&trash, "long_rq:"); SHOW_TOT(thr, activity[thr].long_rq);
1164 chunk_appendf(&trash, "ctxsw:"); SHOW_TOT(thr, activity[thr].ctxsw);
1165 chunk_appendf(&trash, "tasksw:"); SHOW_TOT(thr, activity[thr].tasksw);
1166 chunk_appendf(&trash, "cpust_ms_tot:"); SHOW_TOT(thr, activity[thr].cpust_total / 2);
1167 chunk_appendf(&trash, "cpust_ms_1s:"); SHOW_TOT(thr, read_freq_ctr(&activity[thr].cpust_1s) / 2);
1168 chunk_appendf(&trash, "cpust_ms_15s:"); SHOW_TOT(thr, read_freq_ctr_period(&activity[thr].cpust_15s, 15000) / 2);
1169 chunk_appendf(&trash, "avg_loop_us:"); SHOW_AVG(thr, swrate_avg(activity[thr].avg_loop_us, TIME_STATS_SAMPLES));
1170 chunk_appendf(&trash, "accepted:"); SHOW_TOT(thr, activity[thr].accepted);
1171 chunk_appendf(&trash, "accq_pushed:"); SHOW_TOT(thr, activity[thr].accq_pushed);
1172 chunk_appendf(&trash, "accq_full:"); SHOW_TOT(thr, activity[thr].accq_full);
Willy Tarreaue6182842019-04-15 18:54:10 +02001173#ifdef USE_THREAD
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001174 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 +02001175#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001176
Willy Tarreaud6a78502019-05-27 07:03:38 +02001177#if defined(DEBUG_DEV)
1178 /* keep these ones at the end */
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001179 chunk_appendf(&trash, "ctr0:"); SHOW_TOT(thr, activity[thr].ctr0);
1180 chunk_appendf(&trash, "ctr1:"); SHOW_TOT(thr, activity[thr].ctr1);
1181 chunk_appendf(&trash, "ctr2:"); SHOW_TOT(thr, activity[thr].ctr2);
Willy Tarreaud6a78502019-05-27 07:03:38 +02001182#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001183
1184 if (ci_putchk(si_ic(si), &trash) == -1) {
1185 chunk_reset(&trash);
1186 chunk_printf(&trash, "[output too large, cannot dump]\n");
Willy Tarreaudb398432018-11-15 11:08:52 +01001187 si_rx_room_blk(si);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001188 }
1189
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001190#undef SHOW_AVG
1191#undef SHOW_TOT
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001192 /* dump complete */
1193 return 1;
1194}
1195
William Lallemandeceddf72016-12-15 18:06:44 +01001196/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001197 * CLI IO handler for `show cli sockets`.
1198 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +01001199 */
1200static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1201{
1202 struct bind_conf *bind_conf;
1203 struct stream_interface *si = appctx->owner;
1204
1205 chunk_reset(&trash);
1206
1207 switch (appctx->st2) {
1208 case STAT_ST_INIT:
1209 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +02001210 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001211 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001212 return 0;
1213 }
William Lallemandeceddf72016-12-15 18:06:44 +01001214 appctx->st2 = STAT_ST_LIST;
1215
1216 case STAT_ST_LIST:
1217 if (global.stats_fe) {
1218 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
1219 struct listener *l;
1220
1221 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001222 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +01001223 * if the current node is the first of the list
1224 */
1225
Willy Tarreau3af9d832016-12-16 12:58:09 +01001226 if (appctx->ctx.cli.p0 &&
1227 &bind_conf->by_fe == (&global.stats_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +01001228 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +01001229 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +01001230 continue;
1231 }
1232
1233 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
1234
1235 char addr[46];
1236 char port[6];
1237
1238 if (l->addr.ss_family == AF_UNIX) {
1239 const struct sockaddr_un *un;
1240
1241 un = (struct sockaddr_un *)&l->addr;
William Lallemande58915f2019-04-01 11:30:05 +02001242 if (un->sun_path[0] == '\0') {
William Lallemand75812a72019-04-01 11:30:04 +02001243 chunk_appendf(&trash, "abns@%s ", un->sun_path+1);
William Lallemande58915f2019-04-01 11:30:05 +02001244 } else {
1245 chunk_appendf(&trash, "unix@%s ", un->sun_path);
1246 }
William Lallemandeceddf72016-12-15 18:06:44 +01001247 } else if (l->addr.ss_family == AF_INET) {
1248 addr_to_str(&l->addr, addr, sizeof(addr));
1249 port_to_str(&l->addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001250 chunk_appendf(&trash, "ipv4@%s:%s ", addr, port);
William Lallemandeceddf72016-12-15 18:06:44 +01001251 } else if (l->addr.ss_family == AF_INET6) {
1252 addr_to_str(&l->addr, addr, sizeof(addr));
1253 port_to_str(&l->addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001254 chunk_appendf(&trash, "ipv6@[%s]:%s ", addr, port);
William Lallemand26314342018-10-26 14:47:41 +02001255 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
1256 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
William Lallemandeceddf72016-12-15 18:06:44 +01001257 } else
William Lallemand26314342018-10-26 14:47:41 +02001258 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001259
William Lallemand07a62f72017-05-24 00:57:40 +02001260 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +01001261 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +02001262 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1263 chunk_appendf(&trash, "operator ");
1264 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1265 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +01001266 else
1267 chunk_appendf(&trash, " ");
1268
1269 if (bind_conf->bind_proc != 0) {
1270 int pos;
Willy Tarreau20c5e522016-12-16 12:50:55 +01001271 for (pos = 0; pos < 8 * sizeof(bind_conf->bind_proc); pos++) {
Willy Tarreau4305ac72016-12-16 12:56:31 +01001272 if (bind_conf->bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +01001273 chunk_appendf(&trash, "%d,", pos+1);
1274 }
1275 }
1276 /* replace the latest comma by a newline */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001277 trash.area[trash.data-1] = '\n';
William Lallemandeceddf72016-12-15 18:06:44 +01001278
1279 } else {
1280 chunk_appendf(&trash, "all\n");
1281 }
1282
Willy Tarreau06d80a92017-10-19 14:32:15 +02001283 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001284 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001285 return 0;
1286 }
1287 }
Willy Tarreau3af9d832016-12-16 12:58:09 +01001288 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001289 }
1290 }
1291 default:
1292 appctx->st2 = STAT_ST_FIN;
1293 return 1;
1294 }
1295}
1296
1297
Willy Tarreau0a739292016-11-22 20:21:23 +01001298/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001299 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1300 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001301 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001302static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001303{
1304 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001305 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001306
1307 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1308 return 1;
1309
Willy Tarreauf6710f82016-12-16 17:45:44 +01001310 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001311
1312 if (*args[2]) {
1313 int len = strlen(args[2]);
1314
Willy Tarreauf6710f82016-12-16 17:45:44 +01001315 for (; *var; var++) {
1316 if (strncmp(*var, args[2], len) == 0 &&
1317 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001318 break;
1319 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001320 if (!*var)
1321 return cli_err(appctx, "Variable not found\n");
1322
Willy Tarreau0a739292016-11-22 20:21:23 +01001323 appctx->st2 = STAT_ST_END;
1324 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001325 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001326 return 0;
1327}
1328
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001329/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1330 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1331 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1332 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001333static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001334{
1335 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1336 return 1;
1337
1338 appctx->ctx.cli.i0 = 0;
1339
1340 if (*args[2]) {
1341 appctx->ctx.cli.i0 = atoi(args[2]);
1342 appctx->st2 = STAT_ST_END;
1343 }
1344 return 0;
1345}
1346
Willy Tarreau599852e2016-11-22 20:33:32 +01001347/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001348static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001349{
1350 struct stream_interface *si = appctx->owner;
1351 struct stream *s = si_strm(si);
1352
1353 if (strcmp(args[2], "cli") == 0) {
1354 unsigned timeout;
1355 const char *res;
1356
Willy Tarreau9d008692019-08-09 11:21:01 +02001357 if (!*args[3])
1358 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001359
1360 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
Willy Tarreau9d008692019-08-09 11:21:01 +02001361 if (res || timeout < 1)
1362 return cli_err(appctx, "Invalid timeout value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001363
1364 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1365 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1366 return 1;
1367 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001368
1369 return cli_err(appctx, "'set timeout' only supports 'cli'.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001370}
1371
Willy Tarreau2af99412016-11-23 11:10:59 +01001372/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001373static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001374{
1375 int v;
1376
1377 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1378 return 1;
1379
Willy Tarreau9d008692019-08-09 11:21:01 +02001380 if (!*args[3])
1381 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001382
1383 v = atoi(args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001384 if (v > global.hardmaxconn)
1385 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001386
1387 /* check for unlimited values */
1388 if (v <= 0)
1389 v = global.hardmaxconn;
1390
1391 global.maxconn = v;
1392
1393 /* Dequeues all of the listeners waiting for a resource */
Olivier Houchard859dc802019-08-08 15:47:21 +02001394 if (!MT_LIST_ISEMPTY(&global_listener_queue))
Willy Tarreau2af99412016-11-23 11:10:59 +01001395 dequeue_all_listeners(&global_listener_queue);
1396
1397 return 1;
1398}
1399
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001400static int set_severity_output(int *target, char *argument)
1401{
1402 if (!strcmp(argument, "none")) {
1403 *target = CLI_SEVERITY_NONE;
1404 return 1;
1405 }
1406 else if (!strcmp(argument, "number")) {
1407 *target = CLI_SEVERITY_NUMBER;
1408 return 1;
1409 }
1410 else if (!strcmp(argument, "string")) {
1411 *target = CLI_SEVERITY_STRING;
1412 return 1;
1413 }
1414 return 0;
1415}
1416
1417/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001418static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001419{
1420 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1421 return 0;
1422
Willy Tarreau9d008692019-08-09 11:21:01 +02001423 return cli_err(appctx, "one of 'none', 'number', 'string' is a required argument\n");
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001424}
William Lallemandeceddf72016-12-15 18:06:44 +01001425
William Lallemand67a234f2018-12-13 09:05:45 +01001426
1427/* show the level of the current CLI session */
1428static int cli_parse_show_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1429{
William Lallemand67a234f2018-12-13 09:05:45 +01001430 if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
Willy Tarreau9d008692019-08-09 11:21:01 +02001431 return cli_msg(appctx, LOG_INFO, "admin\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001432 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001433 return cli_msg(appctx, LOG_INFO, "operator\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001434 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001435 return cli_msg(appctx, LOG_INFO, "user\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001436 else
Willy Tarreau9d008692019-08-09 11:21:01 +02001437 return cli_msg(appctx, LOG_INFO, "unknown\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001438}
1439
1440/* parse and set the CLI level dynamically */
1441static int cli_parse_set_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1442{
William Lallemandad032882019-07-01 10:56:15 +02001443 /* this will ask the applet to not output a \n after the command */
1444 if (!strcmp(args[1], "-"))
1445 appctx->st1 |= APPCTX_CLI_ST1_NOLF;
1446
William Lallemand67a234f2018-12-13 09:05:45 +01001447 if (!strcmp(args[0], "operator")) {
1448 if (!cli_has_level(appctx, ACCESS_LVL_OPER)) {
1449 return 1;
1450 }
1451 appctx->cli_level &= ~ACCESS_LVL_MASK;
1452 appctx->cli_level |= ACCESS_LVL_OPER;
1453
1454 } else if (!strcmp(args[0], "user")) {
1455 if (!cli_has_level(appctx, ACCESS_LVL_USER)) {
1456 return 1;
1457 }
1458 appctx->cli_level &= ~ACCESS_LVL_MASK;
1459 appctx->cli_level |= ACCESS_LVL_USER;
1460 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001461 appctx->cli_level &= ~ACCESS_EXPERT;
1462 return 1;
1463}
1464
1465
1466/* parse and set the CLI expert-mode dynamically */
1467static int cli_parse_expert_mode(char **args, char *payload, struct appctx *appctx, void *private)
1468{
1469 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1470 return 1;
1471
1472 if (!*args[1])
1473 return (appctx->cli_level & ACCESS_EXPERT)
1474 ? cli_msg(appctx, LOG_INFO, "expert-mode is ON\n")
1475 : cli_msg(appctx, LOG_INFO, "expert-mode is OFF\n");
1476
1477 appctx->cli_level &= ~ACCESS_EXPERT;
1478 if (strcmp(args[1], "on") == 0)
1479 appctx->cli_level |= ACCESS_EXPERT;
William Lallemand67a234f2018-12-13 09:05:45 +01001480 return 1;
1481}
1482
William Lallemanda57b7e32018-12-14 21:11:31 +01001483
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001484int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001485{
1486 return 0;
1487}
1488
Willy Tarreau45c742b2016-11-24 14:51:17 +01001489/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001490static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001491{
1492 int v;
1493 int *res;
1494 int mul = 1;
1495
1496 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1497 return 1;
1498
1499 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1500 res = &global.cps_lim;
1501 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1502 res = &global.sps_lim;
1503#ifdef USE_OPENSSL
1504 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1505 res = &global.ssl_lim;
1506#endif
1507 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1508 res = &global.comp_rate_lim;
1509 mul = 1024;
1510 }
1511 else {
Willy Tarreau9d008692019-08-09 11:21:01 +02001512 return cli_err(appctx,
Willy Tarreau45c742b2016-11-24 14:51:17 +01001513 "'set rate-limit' only supports :\n"
1514 " - 'connections global' to set the per-process maximum connection rate\n"
1515 " - 'sessions global' to set the per-process maximum session rate\n"
1516#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001517 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001518#endif
Willy Tarreau9d008692019-08-09 11:21:01 +02001519 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001520 }
1521
Willy Tarreau9d008692019-08-09 11:21:01 +02001522 if (!*args[4])
1523 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001524
1525 v = atoi(args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001526 if (v < 0)
1527 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001528
1529 *res = v * mul;
1530
1531 /* Dequeues all of the listeners waiting for a resource */
Olivier Houchard859dc802019-08-08 15:47:21 +02001532 if (!MT_LIST_ISEMPTY(&global_listener_queue))
Willy Tarreau45c742b2016-11-24 14:51:17 +01001533 dequeue_all_listeners(&global_listener_queue);
1534
1535 return 1;
1536}
1537
William Lallemandf6975e92017-05-26 17:42:10 +02001538/* parse the "expose-fd" argument on the bind lines */
1539static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1540{
1541 if (!*args[cur_arg + 1]) {
1542 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1543 return ERR_ALERT | ERR_FATAL;
1544 }
1545 if (!strcmp(args[cur_arg+1], "listeners")) {
1546 conf->level |= ACCESS_FD_LISTENERS;
1547 } else {
1548 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1549 args[cur_arg], args[cur_arg+1]);
1550 return ERR_ALERT | ERR_FATAL;
1551 }
1552
1553 return 0;
1554}
1555
William Lallemand74c24fb2016-11-21 17:18:36 +01001556/* parse the "level" argument on the bind lines */
1557static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1558{
1559 if (!*args[cur_arg + 1]) {
1560 memprintf(err, "'%s' : missing level", args[cur_arg]);
1561 return ERR_ALERT | ERR_FATAL;
1562 }
1563
William Lallemand07a62f72017-05-24 00:57:40 +02001564 if (!strcmp(args[cur_arg+1], "user")) {
1565 conf->level &= ~ACCESS_LVL_MASK;
1566 conf->level |= ACCESS_LVL_USER;
1567 } else if (!strcmp(args[cur_arg+1], "operator")) {
1568 conf->level &= ~ACCESS_LVL_MASK;
1569 conf->level |= ACCESS_LVL_OPER;
1570 } else if (!strcmp(args[cur_arg+1], "admin")) {
1571 conf->level &= ~ACCESS_LVL_MASK;
1572 conf->level |= ACCESS_LVL_ADMIN;
1573 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001574 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1575 args[cur_arg], args[cur_arg+1]);
1576 return ERR_ALERT | ERR_FATAL;
1577 }
1578
1579 return 0;
1580}
1581
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001582static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1583{
1584 if (!*args[cur_arg + 1]) {
1585 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1586 return ERR_ALERT | ERR_FATAL;
1587 }
1588
1589 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1590 return 0;
1591 else {
1592 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1593 args[cur_arg], args[cur_arg+1]);
1594 return ERR_ALERT | ERR_FATAL;
1595 }
1596}
1597
William Lallemand16dd1b32018-11-19 18:46:18 +01001598
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001599
Olivier Houchardf886e342017-04-05 22:24:59 +02001600/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001601static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02001602{
1603 char *cmsgbuf = NULL;
1604 unsigned char *tmpbuf = NULL;
1605 struct cmsghdr *cmsg;
1606 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001607 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001608 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001609 struct msghdr msghdr;
1610 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001611 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Olivier Houchardf886e342017-04-05 22:24:59 +02001612 int *tmpfd;
1613 int tot_fd_nb = 0;
1614 struct proxy *px;
1615 int i = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001616 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001617 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001618 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001619 int ret;
1620
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001621 if (!remote) {
1622 ha_warning("Only works on real connections\n");
1623 goto out;
1624 }
1625
1626 fd = remote->handle.fd;
1627
Olivier Houchardf886e342017-04-05 22:24:59 +02001628 /* Temporary set the FD in blocking mode, that will make our life easier */
1629 old_fcntl = fcntl(fd, F_GETFL);
1630 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001631 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001632 goto out;
1633 }
1634 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1635 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001636 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001637 goto out;
1638 }
1639 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001640 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001641 goto out;
1642 }
Olivier Houchard54740872017-04-06 14:45:14 +02001643 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001644 iov.iov_base = &tot_fd_nb;
1645 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001646 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001647 goto out;
1648 memset(&msghdr, 0, sizeof(msghdr));
1649 /*
1650 * First, calculates the total number of FD, so that we can let
1651 * the caller know how much he should expects.
1652 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001653 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001654 while (px) {
1655 struct listener *l;
1656
1657 list_for_each_entry(l, &px->conf.listeners, by_fe) {
Olivier Houchard1fc05162017-04-06 01:05:05 +02001658 /* Only transfer IPv4/IPv6/UNIX sockets */
1659 if (l->state >= LI_ZOMBIE &&
1660 (l->proto->sock_family == AF_INET ||
Olivier Houchardf886e342017-04-05 22:24:59 +02001661 l->proto->sock_family == AF_INET6 ||
Olivier Houchard1fc05162017-04-06 01:05:05 +02001662 l->proto->sock_family == AF_UNIX))
Olivier Houchardf886e342017-04-05 22:24:59 +02001663 tot_fd_nb++;
1664 }
1665 px = px->next;
1666 }
1667 if (tot_fd_nb == 0)
1668 goto out;
1669
1670 /* First send the total number of file descriptors, so that the
1671 * receiving end knows what to expect.
1672 */
1673 msghdr.msg_iov = &iov;
1674 msghdr.msg_iovlen = 1;
1675 ret = sendmsg(fd, &msghdr, 0);
1676 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001677 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001678 goto out;
1679 }
1680
1681 /* Now send the fds */
1682 msghdr.msg_control = cmsgbuf;
1683 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1684 cmsg = CMSG_FIRSTHDR(&msghdr);
1685 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1686 cmsg->cmsg_level = SOL_SOCKET;
1687 cmsg->cmsg_type = SCM_RIGHTS;
1688 tmpfd = (int *)CMSG_DATA(cmsg);
1689
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001690 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001691 /* For each socket, e message is sent, containing the following :
1692 * Size of the namespace name (or 0 if none), as an unsigned char.
1693 * The namespace name, if any
1694 * Size of the interface name (or 0 if none), as an unsigned char
1695 * The interface name, if any
1696 * Listener options, as an int.
1697 */
1698 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
1699 * buffer big enough to store the socket informations.
1700 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001701 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001702 if (tmpbuf == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001703 ha_warning("Failed to allocate memory to transfer socket informations\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001704 goto out;
1705 }
1706 iov.iov_base = tmpbuf;
1707 while (px) {
1708 struct listener *l;
1709
1710 list_for_each_entry(l, &px->conf.listeners, by_fe) {
1711 int ret;
1712 /* Only transfer IPv4/IPv6 sockets */
Olivier Houchard1fc05162017-04-06 01:05:05 +02001713 if (l->state >= LI_ZOMBIE &&
Olivier Houchardf886e342017-04-05 22:24:59 +02001714 (l->proto->sock_family == AF_INET ||
1715 l->proto->sock_family == AF_INET6 ||
1716 l->proto->sock_family == AF_UNIX)) {
1717 memcpy(&tmpfd[i % MAX_SEND_FD], &l->fd, sizeof(l->fd));
1718 if (!l->netns)
1719 tmpbuf[curoff++] = 0;
Willy Tarreaue5733232019-05-22 19:24:06 +02001720#ifdef USE_NS
Olivier Houchardf886e342017-04-05 22:24:59 +02001721 else {
1722 char *name = l->netns->node.key;
1723 unsigned char len = l->netns->name_len;
1724 tmpbuf[curoff++] = len;
1725 memcpy(tmpbuf + curoff, name, len);
1726 curoff += len;
1727 }
1728#endif
1729 if (l->interface) {
1730 unsigned char len = strlen(l->interface);
1731 tmpbuf[curoff++] = len;
1732 memcpy(tmpbuf + curoff, l->interface, len);
1733 curoff += len;
1734 } else
1735 tmpbuf[curoff++] = 0;
1736 memcpy(tmpbuf + curoff, &l->options,
1737 sizeof(l->options));
1738 curoff += sizeof(l->options);
1739
1740
1741 i++;
1742 } else
1743 continue;
1744 if ((!(i % MAX_SEND_FD))) {
1745 iov.iov_len = curoff;
1746 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001747 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001748 goto out;
1749 }
1750 /* Wait for an ack */
1751 do {
1752 ret = recv(fd, &tot_fd_nb,
1753 sizeof(tot_fd_nb), 0);
1754 } while (ret == -1 && errno == EINTR);
1755 if (ret <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001756 ha_warning("Unexpected error while transferring sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001757 goto out;
1758 }
1759 curoff = 0;
1760 }
1761
1762 }
1763 px = px->next;
1764 }
1765 if (i % MAX_SEND_FD) {
1766 iov.iov_len = curoff;
1767 cmsg->cmsg_len = CMSG_LEN((i % MAX_SEND_FD) * sizeof(int));
1768 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * (i % MAX_SEND_FD));
1769 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001770 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001771 goto out;
1772 }
1773 }
1774
1775out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001776 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001777 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001778 goto out;
1779 }
1780 appctx->st0 = CLI_ST_END;
1781 free(cmsgbuf);
1782 free(tmpbuf);
1783 return 1;
1784}
1785
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001786static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
1787{
1788 if (*args[0] == 'h')
1789 /* help */
1790 cli_gen_usage_msg(appctx);
1791 else if (*args[0] == 'p')
1792 /* prompt */
1793 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
1794 else if (*args[0] == 'q')
1795 /* quit */
1796 appctx->st0 = CLI_ST_END;
1797
1798 return 1;
1799}
Olivier Houchardf886e342017-04-05 22:24:59 +02001800
William Lallemand2f4ce202018-10-26 14:47:47 +02001801void pcli_write_prompt(struct stream *s)
1802{
1803 struct buffer *msg = get_trash_chunk();
1804 struct channel *oc = si_oc(&s->si[0]);
1805
William Lallemanddc12c2e2018-12-13 09:05:46 +01001806 if (!(s->pcli_flags & PCLI_F_PROMPT))
William Lallemand5b80fa22018-12-11 16:10:54 +01001807 return;
1808
William Lallemanddc12c2e2018-12-13 09:05:46 +01001809 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01001810 chunk_appendf(msg, "+ ");
1811 } else {
1812 if (s->pcli_next_pid == 0)
Willy Tarreau52880f92018-12-15 13:30:03 +01001813 chunk_appendf(msg, "master%s> ",
1814 (global.mode & MODE_MWORKER_WAIT) ? "[ReloadFailed]" : "");
William Lallemandebf61802018-12-11 16:10:57 +01001815 else
1816 chunk_appendf(msg, "%d> ", s->pcli_next_pid);
1817 }
William Lallemand2f4ce202018-10-26 14:47:47 +02001818 co_inject(oc, msg->area, msg->data);
1819}
1820
William Lallemand291810d2018-10-26 14:47:38 +02001821
William Lallemandcf62f7e2018-10-26 14:47:40 +02001822/* The pcli_* functions are used for the CLI proxy in the master */
1823
William Lallemanddeeaa592018-10-26 14:47:48 +02001824void pcli_reply_and_close(struct stream *s, const char *msg)
1825{
1826 struct buffer *buf = get_trash_chunk();
1827
1828 chunk_initstr(buf, msg);
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001829 si_retnclose(&s->si[0], buf);
William Lallemanddeeaa592018-10-26 14:47:48 +02001830}
1831
William Lallemand291810d2018-10-26 14:47:38 +02001832static enum obj_type *pcli_pid_to_server(int proc_pid)
1833{
1834 struct mworker_proc *child;
1835
William Lallemandbddd33a2018-12-11 16:10:53 +01001836 /* return the CLI applet of the master */
1837 if (proc_pid == 0)
1838 return &cli_applet.obj_type;
1839
William Lallemand291810d2018-10-26 14:47:38 +02001840 list_for_each_entry(child, &proc_list, list) {
1841 if (child->pid == proc_pid){
1842 return &child->srv->obj_type;
1843 }
1844 }
1845 return NULL;
1846}
1847
1848/* Take a CLI prefix in argument (eg: @!1234 @master @1)
1849 * Return:
1850 * 0: master
1851 * > 0: pid of a worker
1852 * < 0: didn't find a worker
1853 */
1854static int pcli_prefix_to_pid(const char *prefix)
1855{
1856 int proc_pid;
1857 struct mworker_proc *child;
1858 char *errtol = NULL;
1859
1860 if (*prefix != '@') /* not a prefix, should not happen */
1861 return -1;
1862
1863 prefix++;
1864 if (!*prefix) /* sent @ alone, return the master */
1865 return 0;
1866
1867 if (strcmp("master", prefix) == 0) {
1868 return 0;
1869 } else if (*prefix == '!') {
1870 prefix++;
1871 if (!*prefix)
1872 return -1;
1873
1874 proc_pid = strtol(prefix, &errtol, 10);
1875 if (*errtol != '\0')
1876 return -1;
1877 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001878 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001879 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001880 if (child->pid == proc_pid){
1881 return child->pid;
1882 }
1883 }
1884 } else {
1885 struct mworker_proc *chosen = NULL;
1886 /* this is a relative pid */
1887
1888 proc_pid = strtol(prefix, &errtol, 10);
1889 if (*errtol != '\0')
1890 return -1;
1891
1892 if (proc_pid == 0) /* return the master */
1893 return 0;
1894
1895 /* chose the right process, the current one is the one with the
1896 least number of reloads */
1897 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001898 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001899 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001900 if (child->relative_pid == proc_pid){
1901 if (child->reloads == 0)
1902 return child->pid;
1903 else if (chosen == NULL || child->reloads < chosen->reloads)
1904 chosen = child;
1905 }
1906 }
1907 if (chosen)
1908 return chosen->pid;
1909 }
1910 return -1;
1911}
1912
William Lallemandbddd33a2018-12-11 16:10:53 +01001913/* Return::
1914 * >= 0 : number of words to escape
1915 * = -1 : error
1916 */
1917
1918int pcli_find_and_exec_kw(struct stream *s, char **args, int argl, char **errmsg, int *next_pid)
1919{
1920 if (argl < 1)
1921 return 0;
1922
1923 /* there is a prefix */
1924 if (args[0][0] == '@') {
1925 int target_pid = pcli_prefix_to_pid(args[0]);
1926
1927 if (target_pid == -1) {
1928 memprintf(errmsg, "Can't find the target PID matching the prefix '%s'\n", args[0]);
1929 return -1;
1930 }
1931
1932 /* if the prefix is alone, define a default target */
1933 if (argl == 1)
1934 s->pcli_next_pid = target_pid;
1935 else
1936 *next_pid = target_pid;
1937 return 1;
William Lallemand5b80fa22018-12-11 16:10:54 +01001938 } else if (!strcmp("prompt", args[0])) {
William Lallemanddc12c2e2018-12-13 09:05:46 +01001939 s->pcli_flags ^= PCLI_F_PROMPT;
William Lallemand5b80fa22018-12-11 16:10:54 +01001940 return argl; /* return the number of elements in the array */
William Lallemand5f610682018-12-11 16:10:55 +01001941
1942 } else if (!strcmp("quit", args[0])) {
1943 channel_shutr_now(&s->req);
1944 channel_shutw_now(&s->res);
1945 return argl; /* return the number of elements in the array */
William Lallemandb7ea1412018-12-13 09:05:47 +01001946 } else if (!strcmp(args[0], "operator")) {
1947 if (!pcli_has_level(s, ACCESS_LVL_OPER)) {
1948 memprintf(errmsg, "Permission denied!\n");
1949 return -1;
1950 }
1951 s->pcli_flags &= ~ACCESS_LVL_MASK;
1952 s->pcli_flags |= ACCESS_LVL_OPER;
1953 return argl;
1954
1955 } else if (!strcmp(args[0], "user")) {
1956 if (!pcli_has_level(s, ACCESS_LVL_USER)) {
1957 memprintf(errmsg, "Permission denied!\n");
1958 return -1;
1959 }
1960 s->pcli_flags &= ~ACCESS_LVL_MASK;
1961 s->pcli_flags |= ACCESS_LVL_USER;
1962 return argl;
William Lallemandbddd33a2018-12-11 16:10:53 +01001963 }
1964
1965 return 0;
1966}
1967
1968/*
1969 * Parse the CLI request:
1970 * - It does basically the same as the cli_io_handler, but as a proxy
1971 * - It can exec a command and strip non forwardable commands
William Lallemandcf62f7e2018-10-26 14:47:40 +02001972 *
1973 * Return:
William Lallemandbddd33a2018-12-11 16:10:53 +01001974 * - the number of characters to forward or
1975 * - 1 if there is an error or not enough data
William Lallemandcf62f7e2018-10-26 14:47:40 +02001976 */
William Lallemandbddd33a2018-12-11 16:10:53 +01001977int pcli_parse_request(struct stream *s, struct channel *req, char **errmsg, int *next_pid)
William Lallemandcf62f7e2018-10-26 14:47:40 +02001978{
William Lallemandbddd33a2018-12-11 16:10:53 +0100