blob: e0d32543f65fea6b9432f8fc22ee640564662d7a [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
Willy Tarreaub2551052020-06-09 09:07:15 +020029#include <haproxy/activity.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020030#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020031#include <haproxy/applet-t.h>
32#include <haproxy/base64.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020033#include <haproxy/cfgparse.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020034#include <haproxy/channel.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020035#include <haproxy/check.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020036#include <haproxy/cli.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020037#include <haproxy/compression.h>
Willy Tarreaueb92deb2020-06-04 10:53:16 +020038#include <haproxy/dns-t.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020039#include <haproxy/errors.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020040#include <haproxy/fd.h>
41#include <haproxy/freq_ctr.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020042#include <haproxy/frontend.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020043#include <haproxy/global.h>
Willy Tarreau853b2972020-05-27 18:01:47 +020044#include <haproxy/list.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020045#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020046#include <haproxy/log.h>
Willy Tarreaub5abe5b2020-06-04 14:07:37 +020047#include <haproxy/mworker-t.h>
Willy Tarreau225a90a2020-06-04 15:06:28 +020048#include <haproxy/pattern-t.h>
Willy Tarreau3c2a7c22020-06-04 18:38:21 +020049#include <haproxy/peers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020050#include <haproxy/pipe.h>
51#include <haproxy/protocol.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020052#include <haproxy/proxy.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020053#include <haproxy/sample-t.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020054#include <haproxy/server.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020055#include <haproxy/session.h>
Willy Tarreaua74cb382020-10-15 21:29:49 +020056#include <haproxy/sock.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020057#include <haproxy/stats-t.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020058#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020059#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020060#include <haproxy/task.h>
Willy Tarreauc2f7c582020-06-02 18:15:32 +020061#include <haproxy/ticks.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020062#include <haproxy/time.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020063#include <haproxy/tools.h>
Willy Tarreaud6788052020-05-27 15:59:00 +020064#include <haproxy/version.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010065
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020066#define PAYLOAD_PATTERN "<<"
67
William Lallemand74c24fb2016-11-21 17:18:36 +010068static struct applet cli_applet;
William Lallemand99e0bb92020-11-05 10:28:53 +010069static struct applet mcli_applet;
William Lallemand74c24fb2016-11-21 17:18:36 +010070
71static const char stats_sock_usage_msg[] =
72 "Unknown command. Please enter one of the following commands only :\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010073 " help : this message\n"
74 " prompt : toggle interactive mode with prompt\n"
75 " quit : disconnect\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010076 "";
77
78static const char stats_permission_denied_msg[] =
79 "Permission denied\n"
80 "";
81
82
Christopher Faulet1bc04c72017-10-29 20:14:08 +010083static THREAD_LOCAL char *dynamic_usage_msg = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +010084
85/* List head of cli keywords */
86static struct cli_kw_list cli_keywords = {
87 .list = LIST_HEAD_INIT(cli_keywords.list)
88};
89
90extern const char *stat_status_codes[];
91
William Lallemand8a022572018-10-26 14:47:35 +020092static struct proxy *mworker_proxy; /* CLI proxy of the master */
93
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020094static char *cli_gen_usage_msg(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +010095{
96 struct cli_kw_list *kw_list;
97 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +020098 struct buffer *tmp = get_trash_chunk();
99 struct buffer out;
William Lallemand74c24fb2016-11-21 17:18:36 +0100100
101 free(dynamic_usage_msg);
102 dynamic_usage_msg = NULL;
103
104 if (LIST_ISEMPTY(&cli_keywords.list))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200105 goto end;
William Lallemand74c24fb2016-11-21 17:18:36 +0100106
107 chunk_reset(tmp);
108 chunk_strcat(tmp, stats_sock_usage_msg);
109 list_for_each_entry(kw_list, &cli_keywords.list, list) {
110 kw = &kw_list->kw[0];
William Lallemand0154edc2018-05-15 11:50:04 +0200111 while (kw->str_kw[0]) {
William Lallemand14721be2018-10-26 14:47:37 +0200112
113 /* in a worker or normal process, don't display master only commands */
William Lallemand99e0bb92020-11-05 10:28:53 +0100114 if (appctx->applet == &cli_applet && (kw->level & ACCESS_MASTER_ONLY))
William Lallemand14721be2018-10-26 14:47:37 +0200115 goto next_kw;
116
117 /* in master don't displays if we don't have the master bits */
William Lallemand99e0bb92020-11-05 10:28:53 +0100118 if (appctx->applet == &mcli_applet && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
William Lallemand14721be2018-10-26 14:47:37 +0200119 goto next_kw;
120
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200121 /* only show expert commands in expert mode */
122 if ((kw->level & ~appctx->cli_level) & ACCESS_EXPERT)
123 goto next_kw;
124
William Lallemand0154edc2018-05-15 11:50:04 +0200125 if (kw->usage)
126 chunk_appendf(tmp, " %s\n", kw->usage);
William Lallemand14721be2018-10-26 14:47:37 +0200127
128next_kw:
129
William Lallemand74c24fb2016-11-21 17:18:36 +0100130 kw++;
131 }
132 }
133 chunk_init(&out, NULL, 0);
134 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200135 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200136
137end:
138 if (dynamic_usage_msg) {
139 appctx->ctx.cli.severity = LOG_INFO;
140 appctx->ctx.cli.msg = dynamic_usage_msg;
141 }
142 else {
143 appctx->ctx.cli.severity = LOG_INFO;
144 appctx->ctx.cli.msg = stats_sock_usage_msg;
145 }
146 appctx->st0 = CLI_ST_PRINT;
147
William Lallemand74c24fb2016-11-21 17:18:36 +0100148 return dynamic_usage_msg;
149}
150
151struct cli_kw* cli_find_kw(char **args)
152{
153 struct cli_kw_list *kw_list;
154 struct cli_kw *kw;/* current cli_kw */
155 char **tmp_args;
156 const char **tmp_str_kw;
157 int found = 0;
158
159 if (LIST_ISEMPTY(&cli_keywords.list))
160 return NULL;
161
162 list_for_each_entry(kw_list, &cli_keywords.list, list) {
163 kw = &kw_list->kw[0];
164 while (*kw->str_kw) {
165 tmp_args = args;
166 tmp_str_kw = kw->str_kw;
167 while (*tmp_str_kw) {
168 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
169 found = 1;
170 } else {
171 found = 0;
172 break;
173 }
174 tmp_args++;
175 tmp_str_kw++;
176 }
177 if (found)
178 return (kw);
179 kw++;
180 }
181 }
182 return NULL;
183}
184
Thierry Fournierb2239a72020-11-28 20:10:08 +0100185struct cli_kw* cli_find_kw_exact(char **args)
186{
187 struct cli_kw_list *kw_list;
188 int found = 0;
189 int i;
190 int j;
191
192 if (LIST_ISEMPTY(&cli_keywords.list))
193 return NULL;
194
195 list_for_each_entry(kw_list, &cli_keywords.list, list) {
196 for (i = 0; kw_list->kw[i].str_kw[0]; i++) {
197 found = 1;
198 for (j = 0; j < CLI_PREFIX_KW_NB; j++) {
199 if (args[j] == NULL && kw_list->kw[i].str_kw[j] == NULL) {
200 break;
201 }
202 if (args[j] == NULL || kw_list->kw[i].str_kw[j] == NULL) {
203 found = 0;
204 break;
205 }
206 if (strcmp(args[j], kw_list->kw[i].str_kw[j]) != 0) {
207 found = 0;
208 break;
209 }
210 }
211 if (found)
212 return &kw_list->kw[i];
213 }
214 }
215 return NULL;
216}
217
William Lallemand74c24fb2016-11-21 17:18:36 +0100218void cli_register_kw(struct cli_kw_list *kw_list)
219{
220 LIST_ADDQ(&cli_keywords.list, &kw_list->list);
221}
222
223
224/* allocate a new stats frontend named <name>, and return it
225 * (or NULL in case of lack of memory).
226 */
227static struct proxy *alloc_stats_fe(const char *name, const char *file, int line)
228{
229 struct proxy *fe;
230
231 fe = calloc(1, sizeof(*fe));
232 if (!fe)
233 return NULL;
234
235 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100236 fe->next = proxies_list;
237 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100238 fe->last_change = now.tv_sec;
239 fe->id = strdup("GLOBAL");
240 fe->cap = PR_CAP_FE;
241 fe->maxconn = 10; /* default to 10 concurrent connections */
242 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
243 fe->conf.file = strdup(file);
244 fe->conf.line = line;
245 fe->accept = frontend_accept;
246 fe->default_target = &cli_applet.obj_type;
247
248 /* the stats frontend is the only one able to assign ID #0 */
249 fe->conf.id.key = fe->uuid = 0;
250 eb32_insert(&used_proxy_id, &fe->conf.id);
251 return fe;
252}
253
254/* This function parses a "stats" statement in the "global" section. It returns
255 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
256 * error message into the <err> buffer which will be preallocated. The trailing
257 * '\n' must not be written. The function must be called with <args> pointing to
258 * the first word after "stats".
259 */
260static int stats_parse_global(char **args, int section_type, struct proxy *curpx,
261 struct proxy *defpx, const char *file, int line,
262 char **err)
263{
264 struct bind_conf *bind_conf;
265 struct listener *l;
266
267 if (!strcmp(args[1], "socket")) {
268 int cur_arg;
269
270 if (*args[2] == 0) {
271 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
272 return -1;
273 }
274
275 if (!global.stats_fe) {
276 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
277 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
278 return -1;
279 }
280 }
281
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100282 bind_conf = bind_conf_alloc(global.stats_fe, file, line, args[2], xprt_get(XPRT_RAW));
William Lallemand07a62f72017-05-24 00:57:40 +0200283 bind_conf->level &= ~ACCESS_LVL_MASK;
284 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100285
286 if (!str2listener(args[2], global.stats_fe, bind_conf, file, line, err)) {
287 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
288 file, line, args[0], args[1], err && *err ? *err : "error");
289 return -1;
290 }
291
292 cur_arg = 3;
293 while (*args[cur_arg]) {
294 static int bind_dumped;
295 struct bind_kw *kw;
296
297 kw = bind_find_kw(args[cur_arg]);
298 if (kw) {
299 if (!kw->parse) {
300 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
301 args[0], args[1], args[cur_arg]);
302 return -1;
303 }
304
305 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, err) != 0) {
306 if (err && *err)
307 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
308 else
309 memprintf(err, "'%s %s' : error encountered while processing '%s'",
310 args[0], args[1], args[cur_arg]);
311 return -1;
312 }
313
314 cur_arg += 1 + kw->skip;
315 continue;
316 }
317
318 if (!bind_dumped) {
319 bind_dump_kws(err);
320 indent_msg(err, 4);
321 bind_dumped = 1;
322 }
323
324 memprintf(err, "'%s %s' : unknown keyword '%s'.%s%s",
325 args[0], args[1], args[cur_arg],
326 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
327 return -1;
328 }
329
330 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100331 l->accept = session_accept_fd;
William Lallemand74c24fb2016-11-21 17:18:36 +0100332 l->default_target = global.stats_fe->default_target;
333 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
334 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100335 global.maxsock++; /* for the listening socket */
William Lallemand74c24fb2016-11-21 17:18:36 +0100336 }
337 }
338 else if (!strcmp(args[1], "timeout")) {
339 unsigned timeout;
340 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
341
Willy Tarreau9faebe32019-06-07 19:00:37 +0200342 if (res == PARSE_TIME_OVER) {
343 memprintf(err, "timer overflow in argument '%s' to '%s %s' (maximum value is 2147483647 ms or ~24.8 days)",
344 args[2], args[0], args[1]);
345 return -1;
346 }
347 else if (res == PARSE_TIME_UNDER) {
348 memprintf(err, "timer underflow in argument '%s' to '%s %s' (minimum non-null value is 1 ms)",
349 args[2], args[0], args[1]);
350 return -1;
351 }
352 else if (res) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100353 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
354 return -1;
355 }
356
357 if (!timeout) {
358 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
359 return -1;
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 global.stats_fe->timeout.client = MS_TO_TICKS(timeout);
368 }
369 else if (!strcmp(args[1], "maxconn")) {
370 int maxconn = atol(args[2]);
371
372 if (maxconn <= 0) {
373 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
374 return -1;
375 }
376
377 if (!global.stats_fe) {
378 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
379 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
380 return -1;
381 }
382 }
383 global.stats_fe->maxconn = maxconn;
384 }
385 else if (!strcmp(args[1], "bind-process")) { /* enable the socket only on some processes */
386 int cur_arg = 2;
387 unsigned long set = 0;
388
389 if (!global.stats_fe) {
390 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
391 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
392 return -1;
393 }
394 }
395
396 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100397 if (strcmp(args[cur_arg], "all") == 0) {
398 set = 0;
399 break;
400 }
Willy Tarreauff9c9142019-02-07 10:39:36 +0100401 if (parse_process_number(args[cur_arg], &set, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100402 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100403 return -1;
404 }
405 cur_arg++;
406 }
407 global.stats_fe->bind_proc = set;
408 }
409 else {
410 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
411 return -1;
412 }
413 return 0;
414}
415
William Lallemand33d29e22019-04-01 11:30:06 +0200416/*
William Lallemand9a37fd02019-04-12 16:09:24 +0200417 * This function exports the bound addresses of a <frontend> in the environment
418 * variable <varname>. Those addresses are separated by semicolons and prefixed
419 * with their type (abns@, unix@, sockpair@ etc)
420 * Return -1 upon error, 0 otherwise
William Lallemand33d29e22019-04-01 11:30:06 +0200421 */
William Lallemand9a37fd02019-04-12 16:09:24 +0200422int listeners_setenv(struct proxy *frontend, const char *varname)
William Lallemand33d29e22019-04-01 11:30:06 +0200423{
424 struct buffer *trash = get_trash_chunk();
425 struct bind_conf *bind_conf;
426
William Lallemand9a37fd02019-04-12 16:09:24 +0200427 if (frontend) {
428 list_for_each_entry(bind_conf, &frontend->conf.bind, by_fe) {
William Lallemand33d29e22019-04-01 11:30:06 +0200429 struct listener *l;
430
431 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
432 char addr[46];
433 char port[6];
434
William Lallemand620072b2019-04-12 16:09:25 +0200435 /* separate listener by semicolons */
436 if (trash->data)
437 chunk_appendf(trash, ";");
438
Willy Tarreau37159062020-08-27 07:48:42 +0200439 if (l->rx.addr.ss_family == AF_UNIX) {
William Lallemand33d29e22019-04-01 11:30:06 +0200440 const struct sockaddr_un *un;
441
Willy Tarreau37159062020-08-27 07:48:42 +0200442 un = (struct sockaddr_un *)&l->rx.addr;
William Lallemand33d29e22019-04-01 11:30:06 +0200443 if (un->sun_path[0] == '\0') {
444 chunk_appendf(trash, "abns@%s", un->sun_path+1);
445 } else {
446 chunk_appendf(trash, "unix@%s", un->sun_path);
447 }
Willy Tarreau37159062020-08-27 07:48:42 +0200448 } else if (l->rx.addr.ss_family == AF_INET) {
449 addr_to_str(&l->rx.addr, addr, sizeof(addr));
450 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemand33d29e22019-04-01 11:30:06 +0200451 chunk_appendf(trash, "ipv4@%s:%s", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +0200452 } else if (l->rx.addr.ss_family == AF_INET6) {
453 addr_to_str(&l->rx.addr, addr, sizeof(addr));
454 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemand33d29e22019-04-01 11:30:06 +0200455 chunk_appendf(trash, "ipv6@[%s]:%s", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +0200456 } else if (l->rx.addr.ss_family == AF_CUST_SOCKPAIR) {
457 chunk_appendf(trash, "sockpair@%d", ((struct sockaddr_in *)&l->rx.addr)->sin_addr.s_addr);
William Lallemand33d29e22019-04-01 11:30:06 +0200458 }
William Lallemand33d29e22019-04-01 11:30:06 +0200459 }
460 }
461 trash->area[trash->data++] = '\0';
William Lallemand9a37fd02019-04-12 16:09:24 +0200462 if (setenv(varname, trash->area, 1) < 0)
William Lallemand33d29e22019-04-01 11:30:06 +0200463 return -1;
464 }
465
466 return 0;
467}
468
William Lallemand9a37fd02019-04-12 16:09:24 +0200469int cli_socket_setenv()
470{
471 if (listeners_setenv(global.stats_fe, "HAPROXY_CLI") < 0)
472 return -1;
473 if (listeners_setenv(mworker_proxy, "HAPROXY_MASTER_CLI") < 0)
474 return -1;
475
476 return 0;
477}
478
William Lallemand33d29e22019-04-01 11:30:06 +0200479REGISTER_CONFIG_POSTPARSER("cli", cli_socket_setenv);
480
Willy Tarreaude57a572016-11-23 17:01:39 +0100481/* Verifies that the CLI at least has a level at least as high as <level>
482 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
483 * failure, an error message is prepared and the appctx's state is adjusted
484 * to print it so that a return 1 is enough to abort any processing.
485 */
486int cli_has_level(struct appctx *appctx, int level)
487{
Willy Tarreaude57a572016-11-23 17:01:39 +0100488
William Lallemandf630d012018-12-13 09:05:44 +0100489 if ((appctx->cli_level & ACCESS_LVL_MASK) < level) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200490 cli_err(appctx, stats_permission_denied_msg);
Willy Tarreaude57a572016-11-23 17:01:39 +0100491 return 0;
492 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100493 return 1;
494}
495
William Lallemandb7ea1412018-12-13 09:05:47 +0100496/* same as cli_has_level but for the CLI proxy and without error message */
497int pcli_has_level(struct stream *s, int level)
498{
499 if ((s->pcli_flags & ACCESS_LVL_MASK) < level) {
500 return 0;
501 }
502 return 1;
503}
504
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200505/* Returns severity_output for the current session if set, or default for the socket */
506static int cli_get_severity_output(struct appctx *appctx)
507{
508 if (appctx->cli_severity_output)
509 return appctx->cli_severity_output;
510 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
511}
William Lallemand74c24fb2016-11-21 17:18:36 +0100512
Willy Tarreau41908562016-11-24 16:23:38 +0100513/* Processes the CLI interpreter on the stats socket. This function is called
514 * from the CLI's IO handler running in an appctx context. The function returns 1
515 * if the request was understood, otherwise zero. It is called with appctx->st0
516 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
517 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
518 * have its own I/O handler called again. Most of the time, parsers will only
519 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100520 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
521 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100522 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200523static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100524{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200525 char *args[MAX_STATS_ARGS + 1], *p, *end, *payload = NULL;
526 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100527 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100528
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200529 appctx->st2 = 0;
530 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
William Lallemand74c24fb2016-11-21 17:18:36 +0100531
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200532 p = appctx->chunk->area;
533 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100534
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200535 /*
536 * Get the payload start if there is one.
537 * For the sake of simplicity, the payload pattern is looked up
538 * everywhere from the start of the input but it can only be found
539 * at the end of the first line if APPCTX_CLI_ST1_PAYLOAD is set.
540 *
541 * The input string was zero terminated so it is safe to use
542 * the str*() functions throughout the parsing
543 */
544 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
545 payload = strstr(p, PAYLOAD_PATTERN);
546 end = payload;
547 /* skip the pattern */
548 payload += strlen(PAYLOAD_PATTERN);
549 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100550
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200551 /*
552 * Get pointers on words.
553 * One extra slot is reserved to store a pointer on a null byte.
554 */
555 while (i < MAX_STATS_ARGS && p < end) {
556 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100557
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200558 /* skip leading spaces/tabs */
559 p += strspn(p, " \t");
560 if (!*p)
561 break;
William Lallemand74c24fb2016-11-21 17:18:36 +0100562
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200563 args[i] = p;
Yves Lafonb08c6d02020-06-08 16:08:06 +0200564 while (1) {
565 p += strcspn(p, " \t\\");
566 /* escaped chars using backlashes (\) */
567 if (*p == '\\') {
568 if (!*++p)
569 break;
570 if (!*++p)
571 break;
572 } else {
573 break;
574 }
575 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200576 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100577
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200578 /* unescape backslashes (\) */
579 for (j = 0, k = 0; args[i][k]; k++) {
580 if (args[i][k] == '\\') {
581 if (args[i][k + 1] == '\\')
582 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100583 else
584 continue;
585 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200586 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100587 j++;
588 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200589 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100590
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200591 i++;
592 }
593 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200594 p = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200595 for (; i < MAX_STATS_ARGS + 1; i++)
596 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100597
598 kw = cli_find_kw(args);
Willy Tarreaueaffde32016-12-16 17:59:25 +0100599 if (!kw)
Willy Tarreau41908562016-11-24 16:23:38 +0100600 return 0;
601
William Lallemand14721be2018-10-26 14:47:37 +0200602 /* in a worker or normal process, don't display master only commands */
William Lallemand99e0bb92020-11-05 10:28:53 +0100603 if (appctx->applet == &cli_applet && (kw->level & ACCESS_MASTER_ONLY))
William Lallemand14721be2018-10-26 14:47:37 +0200604 return 0;
605
606 /* in master don't displays if we don't have the master bits */
William Lallemand99e0bb92020-11-05 10:28:53 +0100607 if (appctx->applet == &mcli_applet && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
William Lallemand14721be2018-10-26 14:47:37 +0200608 return 0;
609
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200610 /* only accept expert commands in expert mode */
611 if ((kw->level & ~appctx->cli_level) & ACCESS_EXPERT)
612 return 0;
613
Willy Tarreau41908562016-11-24 16:23:38 +0100614 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200615 appctx->io_release = kw->io_release;
William Lallemand90b098c2019-10-25 21:10:14 +0200616
617 if (kw->parse && kw->parse(args, payload, appctx, kw->private) != 0)
618 goto fail;
619
620 /* kw->parse could set its own io_handler or io_release handler */
621 if (!appctx->io_handler)
622 goto fail;
623
624 appctx->st0 = CLI_ST_CALLBACK;
625 return 1;
626fail:
627 appctx->io_handler = NULL;
628 appctx->io_release = NULL;
Willy Tarreau41908562016-11-24 16:23:38 +0100629 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100630}
631
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200632/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
633static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
634{
Willy Tarreau83061a82018-07-13 11:56:34 +0200635 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200636
637 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200638 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200639
640 tmp = get_trash_chunk();
641 chunk_reset(tmp);
642
643 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100644 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200645 chunk_printf(tmp, "[%d]: ", severity);
646 }
647 else {
648 switch (severity_output) {
649 case CLI_SEVERITY_NUMBER:
650 chunk_printf(tmp, "[%d]: ", severity);
651 break;
652 case CLI_SEVERITY_STRING:
653 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
654 break;
655 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100656 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200657 }
658 }
659 chunk_appendf(tmp, "%s", msg);
660
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200661 return ci_putblk(chn, tmp->area, strlen(tmp->area));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200662}
663
William Lallemand74c24fb2016-11-21 17:18:36 +0100664/* This I/O handler runs as an applet embedded in a stream interface. It is
665 * used to processes I/O from/to the stats unix socket. The system relies on a
666 * state machine handling requests and various responses. We read a request,
667 * then we process it and send the response, and we possibly display a prompt.
668 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100669 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100670 * or not.
671 */
672static void cli_io_handler(struct appctx *appctx)
673{
674 struct stream_interface *si = appctx->owner;
675 struct channel *req = si_oc(si);
676 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200677 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100678 int reql;
679 int len;
680
681 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
682 goto out;
683
Joseph Herlant008b3ce2018-11-25 12:51:45 -0800684 /* Check if the input buffer is available. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200685 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +0100686 /* buf.size==0 means we failed to get a buffer and were
687 * already subscribed to a wait list to get a buffer.
688 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100689 goto out;
690 }
691
William Lallemand74c24fb2016-11-21 17:18:36 +0100692 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100693 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100694 /* Stats output not initialized yet */
695 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200696 /* reset severity to default at init */
697 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100698 appctx->st0 = CLI_ST_GETREQ;
William Lallemandf630d012018-12-13 09:05:44 +0100699 appctx->cli_level = bind_conf->level;
William Lallemand74c24fb2016-11-21 17:18:36 +0100700 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100701 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100702 /* Let's close for real now. We just close the request
703 * side, the conditions below will complete if needed.
704 */
705 si_shutw(si);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200706 free_trash_chunk(appctx->chunk);
William Lallemand74c24fb2016-11-21 17:18:36 +0100707 break;
708 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100709 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200710 char *str;
711
712 /* use a trash chunk to store received data */
713 if (!appctx->chunk) {
714 appctx->chunk = alloc_trash_chunk();
715 if (!appctx->chunk) {
716 appctx->st0 = CLI_ST_END;
717 continue;
718 }
719 }
720
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200721 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200722
William Lallemand74c24fb2016-11-21 17:18:36 +0100723 /* ensure we have some output room left in the event we
724 * would want to return some info right after parsing.
725 */
726 if (buffer_almost_full(si_ib(si))) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100727 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100728 break;
729 }
730
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200731 /* '- 1' is to ensure a null byte can always be inserted at the end */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200732 reql = co_getline(si_oc(si), str,
733 appctx->chunk->size - appctx->chunk->data - 1);
William Lallemand74c24fb2016-11-21 17:18:36 +0100734 if (reql <= 0) { /* closed or EOL not found */
735 if (reql == 0)
736 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100737 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100738 continue;
739 }
740
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200741 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
742 /* seek for a possible unescaped semi-colon. If we find
743 * one, we replace it with an LF and skip only this part.
744 */
745 for (len = 0; len < reql; len++) {
746 if (str[len] == '\\') {
747 len++;
748 continue;
749 }
750 if (str[len] == ';') {
751 str[len] = '\n';
752 reql = len + 1;
753 break;
754 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100755 }
756 }
757
758 /* now it is time to check that we have a full line,
759 * remove the trailing \n and possibly \r, then cut the
760 * line.
761 */
762 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200763 if (str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100764 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100765 continue;
766 }
767
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200768 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100769 len--;
770
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200771 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200772 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200773
774 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200775 appctx->chunk->area[appctx->chunk->data] = '\n';
776 appctx->chunk->area[appctx->chunk->data + 1] = 0;
777 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200778 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100779
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100780 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200781
782 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
783 /* empty line */
784 if (!len) {
785 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200786 appctx->chunk->data -= 2;
787 appctx->chunk->area[appctx->chunk->data] = 0;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200788
789 if (!cli_parse_request(appctx))
790 cli_gen_usage_msg(appctx);
791
792 chunk_reset(appctx->chunk);
793 /* NB: cli_sock_parse_request() may have put
794 * another CLI_ST_O_* into appctx->st0.
795 */
796
797 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +0100798 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100799 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200800 else {
801 /*
802 * Look for the "payload start" pattern at the end of a line
803 * Its location is not remembered here, this is just to switch
804 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +0100805 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200806 if (!strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200807 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200808 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200809 /* no payload, the command is complete: parse the request */
810 if (!cli_parse_request(appctx))
811 cli_gen_usage_msg(appctx);
812
813 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200814 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100815 }
816
817 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200818 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100819 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
820 }
821 else { /* output functions */
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200822 const char *msg;
823 int sev;
824
William Lallemand74c24fb2016-11-21 17:18:36 +0100825 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100826 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100827 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200828 case CLI_ST_PRINT: /* print const message in msg */
829 case CLI_ST_PRINT_ERR: /* print const error in msg */
830 case CLI_ST_PRINT_DYN: /* print dyn message in msg, free */
831 case CLI_ST_PRINT_FREE: /* print dyn error in err, free */
832 if (appctx->st0 == CLI_ST_PRINT || appctx->st0 == CLI_ST_PRINT_ERR) {
833 sev = appctx->st0 == CLI_ST_PRINT_ERR ?
834 LOG_ERR : appctx->ctx.cli.severity;
835 msg = appctx->ctx.cli.msg;
836 }
837 else if (appctx->st0 == CLI_ST_PRINT_DYN || appctx->st0 == CLI_ST_PRINT_FREE) {
838 sev = appctx->st0 == CLI_ST_PRINT_FREE ?
839 LOG_ERR : appctx->ctx.cli.severity;
840 msg = appctx->ctx.cli.err;
841 if (!msg) {
842 sev = LOG_ERR;
843 msg = "Out of memory.\n";
844 }
845 }
846 else {
847 sev = LOG_ERR;
848 msg = "Internal error.\n";
849 }
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200850
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200851 if (cli_output_msg(res, msg, sev, cli_get_severity_output(appctx)) != -1) {
852 if (appctx->st0 == CLI_ST_PRINT_FREE ||
853 appctx->st0 == CLI_ST_PRINT_DYN) {
854 free(appctx->ctx.cli.err);
855 appctx->ctx.cli.err = NULL;
856 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100857 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100858 }
859 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100860 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100861 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200862
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100863 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100864 if (appctx->io_handler)
865 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100866 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100867 if (appctx->io_release) {
868 appctx->io_release(appctx);
869 appctx->io_release = NULL;
870 }
871 }
872 break;
873 default: /* abnormal state */
874 si->flags |= SI_FL_ERR;
875 break;
876 }
877
878 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100879 if (appctx->st0 == CLI_ST_PROMPT) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200880 const char *prompt = "";
881
882 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
883 /*
884 * when entering a payload with interactive mode, change the prompt
885 * to emphasize that more data can still be sent
886 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200887 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200888 prompt = "+ ";
889 else
890 prompt = "\n> ";
891 }
892 else {
William Lallemandad032882019-07-01 10:56:15 +0200893 if (!(appctx->st1 & (APPCTX_CLI_ST1_PAYLOAD|APPCTX_CLI_ST1_NOLF)))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200894 prompt = "\n";
895 }
896
897 if (ci_putstr(si_ic(si), prompt) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100898 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100899 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100900 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100901 }
902
903 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100904 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100905 break;
906
907 /* Now we close the output if one of the writers did so,
908 * or if we're not in interactive mode and the request
909 * buffer is empty. This still allows pipelined requests
910 * to be sent in non-interactive mode.
911 */
William Lallemand3de09d52018-12-11 16:10:56 +0100912 if (((res->flags & (CF_SHUTW|CF_SHUTW_NOW))) ||
913 (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req) && (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)))) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100914 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100915 continue;
916 }
917
918 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100919 appctx->st0 = CLI_ST_GETREQ;
William Lallemandad032882019-07-01 10:56:15 +0200920 /* reactivate the \n at the end of the response for the next command */
921 appctx->st1 &= ~APPCTX_CLI_ST1_NOLF;
William Lallemand74c24fb2016-11-21 17:18:36 +0100922 }
923 }
924
925 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
926 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
927 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
928 /* Other side has closed, let's abort if we have no more processing to do
929 * and nothing more to consume. This is comparable to a broken pipe, so
930 * we forward the close to the request side so that it flows upstream to
931 * the client.
932 */
933 si_shutw(si);
934 }
935
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100936 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100937 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
938 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
939 /* We have no more processing to do, and nothing more to send, and
940 * the client side has closed. So we'll forward this state downstream
941 * on the response buffer.
942 */
943 si_shutr(si);
944 res->flags |= CF_READ_NULL;
945 }
946
947 out:
Christopher Faulet45073512018-07-20 10:16:29 +0200948 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 +0100949 __FUNCTION__, __LINE__,
Christopher Faulet45073512018-07-20 10:16:29 +0200950 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 +0100951}
952
William Lallemand74c24fb2016-11-21 17:18:36 +0100953/* This is called when the stream interface is closed. For instance, upon an
954 * external abort, we won't call the i/o handler anymore so we may need to
955 * remove back references to the stream currently being dumped.
956 */
957static void cli_release_handler(struct appctx *appctx)
958{
959 if (appctx->io_release) {
960 appctx->io_release(appctx);
961 appctx->io_release = NULL;
962 }
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200963 else if (appctx->st0 == CLI_ST_PRINT_FREE || appctx->st0 == CLI_ST_PRINT_DYN) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100964 free(appctx->ctx.cli.err);
965 appctx->ctx.cli.err = NULL;
966 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100967}
968
969/* This function dumps all environmnent variables to the buffer. It returns 0
970 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +0100971 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
972 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +0100973 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100974static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100975{
Willy Tarreau0a739292016-11-22 20:21:23 +0100976 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100977 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100978
979 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
980 return 1;
981
982 chunk_reset(&trash);
983
984 /* we have two inner loops here, one for the proxy, the other one for
985 * the buffer.
986 */
Willy Tarreauf6710f82016-12-16 17:45:44 +0100987 while (*var) {
988 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +0100989
Willy Tarreau06d80a92017-10-19 14:32:15 +0200990 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100991 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100992 return 0;
993 }
994 if (appctx->st2 == STAT_ST_END)
995 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100996 var++;
997 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +0100998 }
999
1000 /* dump complete */
1001 return 1;
1002}
1003
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001004/* This function dumps all file descriptors states (or the requested one) to
1005 * the buffer. It returns 0 if the output buffer is full and it needs to be
1006 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
1007 * It uses cli.i0 as the fd number to restart from.
1008 */
1009static int cli_io_handler_show_fd(struct appctx *appctx)
1010{
1011 struct stream_interface *si = appctx->owner;
1012 int fd = appctx->ctx.cli.i0;
Willy Tarreauca1b1572018-12-18 15:45:11 +01001013 int ret = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001014
1015 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
Willy Tarreauca1b1572018-12-18 15:45:11 +01001016 goto end;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001017
1018 chunk_reset(&trash);
1019
Willy Tarreauca1b1572018-12-18 15:45:11 +01001020 /* isolate the threads once per round. We're limited to a buffer worth
1021 * of output anyway, it cannot last very long.
1022 */
1023 thread_isolate();
1024
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001025 /* we have two inner loops here, one for the proxy, the other one for
1026 * the buffer.
1027 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +01001028 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001029 struct fdtab fdt;
Willy Tarreau7f4973e2021-01-20 14:13:46 +01001030 const struct listener *li = NULL;
1031 const struct server *sv = NULL;
1032 const struct proxy *px = NULL;
1033 const struct connection *conn = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +02001034 const struct mux_ops *mux = NULL;
Willy Tarreau7f4973e2021-01-20 14:13:46 +01001035 const void *ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +02001036 uint32_t conn_flags = 0;
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001037 int is_back = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001038
1039 fdt = fdtab[fd];
1040
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001041 /* When DEBUG_FD is set, we also report closed FDs that have a
1042 * non-null event count to detect stuck ones.
1043 */
Willy Tarreau13c1a012020-06-29 14:23:31 +02001044 if (!fdt.owner) {
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001045#ifdef DEBUG_FD
Willy Tarreau13c1a012020-06-29 14:23:31 +02001046 if (!fdt.event_count)
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001047#endif
Willy Tarreau13c1a012020-06-29 14:23:31 +02001048 goto skip; // closed
1049 }
1050 else if (fdt.iocb == conn_fd_handler) {
Willy Tarreau7f4973e2021-01-20 14:13:46 +01001051 conn = (const struct connection *)fdt.owner;
1052 conn_flags = conn->flags;
1053 mux = conn->mux;
1054 ctx = conn->ctx;
1055 li = objt_listener(conn->target);
1056 sv = objt_server(conn->target);
1057 px = objt_proxy(conn->target);
1058 is_back = conn_is_back(conn);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001059 }
Willy Tarreaua74cb382020-10-15 21:29:49 +02001060 else if (fdt.iocb == sock_accept_iocb)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001061 li = fdt.owner;
1062
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001063 chunk_printf(&trash,
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001064 " %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 +02001065 fd,
1066 fdt.state,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001067 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
1068 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001069 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
1070 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
1071 fdt.ev,
1072 (fdt.ev & FD_POLL_HUP) ? 'H' : 'h',
1073 (fdt.ev & FD_POLL_ERR) ? 'E' : 'e',
1074 (fdt.ev & FD_POLL_OUT) ? 'O' : 'o',
1075 (fdt.ev & FD_POLL_PRI) ? 'P' : 'p',
1076 (fdt.ev & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001077 fdt.linger_risk ? 'L' : 'l',
1078 fdt.cloned ? 'C' : 'c',
Willy Tarreauc754b342018-03-30 15:00:15 +02001079 fdt.thread_mask, fdt.update_mask,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001080 fdt.owner,
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001081 fdt.iocb);
1082 resolve_sym_name(&trash, NULL, fdt.iocb);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001083
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001084 if (!fdt.owner) {
1085 chunk_appendf(&trash, ")");
1086 }
1087 else if (fdt.iocb == conn_fd_handler) {
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001088 chunk_appendf(&trash, ") back=%d cflg=0x%08x", is_back, conn_flags);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001089 if (px)
1090 chunk_appendf(&trash, " px=%s", px->id);
1091 else if (sv)
1092 chunk_appendf(&trash, " sv=%s/%s", sv->id, sv->proxy->id);
1093 else if (li)
1094 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +02001095
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001096 if (mux) {
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001097 chunk_appendf(&trash, " mux=%s ctx=%p", mux->name, ctx);
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001098 if (mux->show_fd)
1099 mux->show_fd(&trash, fdt.owner);
1100 }
Willy Tarreau35b1b482018-03-28 18:41:30 +02001101 else
1102 chunk_appendf(&trash, " nomux");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001103 }
Willy Tarreaua74cb382020-10-15 21:29:49 +02001104 else if (fdt.iocb == sock_accept_iocb) {
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001105 chunk_appendf(&trash, ") l.st=%s fe=%s",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001106 listener_state_str(li),
1107 li->bind_conf->frontend->id);
1108 }
Willy Tarreau7f4973e2021-01-20 14:13:46 +01001109 else
1110 chunk_appendf(&trash, ")");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001111
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001112#ifdef DEBUG_FD
1113 chunk_appendf(&trash, " evcnt=%u", fdtab[fd].event_count);
1114#endif
Willy Tarreau7f4973e2021-01-20 14:13:46 +01001115 chunk_appendf(&trash, "\n");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001116
Willy Tarreau06d80a92017-10-19 14:32:15 +02001117 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001118 si_rx_room_blk(si);
Willy Tarreauca1b1572018-12-18 15:45:11 +01001119 appctx->ctx.cli.i0 = fd;
1120 ret = 0;
1121 break;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001122 }
1123 skip:
1124 if (appctx->st2 == STAT_ST_END)
1125 break;
1126
1127 fd++;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001128 }
1129
Willy Tarreauca1b1572018-12-18 15:45:11 +01001130 end:
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001131 /* dump complete */
Willy Tarreauca1b1572018-12-18 15:45:11 +01001132
1133 thread_release();
1134 return ret;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001135}
1136
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001137/* This function dumps some activity counters used by developers and support to
1138 * rule out some hypothesis during bug reports. It returns 0 if the output
1139 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
1140 * everything at once in the buffer and is not designed to do it in multiple
1141 * passes.
1142 */
1143static int cli_io_handler_show_activity(struct appctx *appctx)
1144{
1145 struct stream_interface *si = appctx->owner;
1146 int thr;
1147
1148 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1149 return 1;
1150
1151 chunk_reset(&trash);
1152
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001153#undef SHOW_TOT
1154#define SHOW_TOT(t, x) \
Willy Tarreaua0211b82019-05-28 15:09:08 +02001155 do { \
1156 unsigned int _v[MAX_THREADS]; \
1157 unsigned int _tot; \
1158 const unsigned int _nbt = global.nbthread; \
1159 for (_tot = t = 0; t < _nbt; t++) \
1160 _tot += _v[t] = (x); \
1161 if (_nbt == 1) { \
1162 chunk_appendf(&trash, " %u\n", _tot); \
1163 break; \
1164 } \
1165 chunk_appendf(&trash, " %u [", _tot); \
1166 for (t = 0; t < _nbt; t++) \
1167 chunk_appendf(&trash, " %u", _v[t]); \
1168 chunk_appendf(&trash, " ]\n"); \
1169 } while (0)
1170
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001171#undef SHOW_AVG
1172#define SHOW_AVG(t, x) \
1173 do { \
1174 unsigned int _v[MAX_THREADS]; \
1175 unsigned int _tot; \
1176 const unsigned int _nbt = global.nbthread; \
1177 for (_tot = t = 0; t < _nbt; t++) \
1178 _tot += _v[t] = (x); \
1179 if (_nbt == 1) { \
1180 chunk_appendf(&trash, " %u\n", _tot); \
1181 break; \
1182 } \
1183 chunk_appendf(&trash, " %u [", (_tot + _nbt/2) / _nbt); \
1184 for (t = 0; t < _nbt; t++) \
1185 chunk_appendf(&trash, " %u", _v[t]); \
1186 chunk_appendf(&trash, " ]\n"); \
1187 } while (0)
1188
Willy Tarreaua0211b82019-05-28 15:09:08 +02001189 chunk_appendf(&trash, "thread_id: %u (%u..%u)\n", tid + 1, 1, global.nbthread);
1190 chunk_appendf(&trash, "date_now: %lu.%06lu\n", (long)now.tv_sec, (long)now.tv_usec);
Willy Tarreaua00cf9b2020-06-17 20:44:28 +02001191 chunk_appendf(&trash, "ctxsw:"); SHOW_TOT(thr, activity[thr].ctxsw);
1192 chunk_appendf(&trash, "tasksw:"); SHOW_TOT(thr, activity[thr].tasksw);
1193 chunk_appendf(&trash, "empty_rq:"); SHOW_TOT(thr, activity[thr].empty_rq);
1194 chunk_appendf(&trash, "long_rq:"); SHOW_TOT(thr, activity[thr].long_rq);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001195 chunk_appendf(&trash, "loops:"); SHOW_TOT(thr, activity[thr].loops);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001196 chunk_appendf(&trash, "wake_tasks:"); SHOW_TOT(thr, activity[thr].wake_tasks);
1197 chunk_appendf(&trash, "wake_signal:"); SHOW_TOT(thr, activity[thr].wake_signal);
Willy Tarreaue5451532020-06-17 20:25:18 +02001198 chunk_appendf(&trash, "poll_io:"); SHOW_TOT(thr, activity[thr].poll_io);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001199 chunk_appendf(&trash, "poll_exp:"); SHOW_TOT(thr, activity[thr].poll_exp);
Willy Tarreaue4063862020-06-17 20:35:33 +02001200 chunk_appendf(&trash, "poll_drop_fd:"); SHOW_TOT(thr, activity[thr].poll_drop_fd);
1201 chunk_appendf(&trash, "poll_dead_fd:"); SHOW_TOT(thr, activity[thr].poll_dead_fd);
1202 chunk_appendf(&trash, "poll_skip_fd:"); SHOW_TOT(thr, activity[thr].poll_skip_fd);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001203 chunk_appendf(&trash, "conn_dead:"); SHOW_TOT(thr, activity[thr].conn_dead);
Willy Tarreau7af4fa92020-06-17 20:49:49 +02001204 chunk_appendf(&trash, "stream_calls:"); SHOW_TOT(thr, activity[thr].stream_calls);
Willy Tarreaua8b2ce02019-05-28 17:04:16 +02001205 chunk_appendf(&trash, "pool_fail:"); SHOW_TOT(thr, activity[thr].pool_fail);
1206 chunk_appendf(&trash, "buf_wait:"); SHOW_TOT(thr, activity[thr].buf_wait);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001207 chunk_appendf(&trash, "cpust_ms_tot:"); SHOW_TOT(thr, activity[thr].cpust_total / 2);
1208 chunk_appendf(&trash, "cpust_ms_1s:"); SHOW_TOT(thr, read_freq_ctr(&activity[thr].cpust_1s) / 2);
1209 chunk_appendf(&trash, "cpust_ms_15s:"); SHOW_TOT(thr, read_freq_ctr_period(&activity[thr].cpust_15s, 15000) / 2);
1210 chunk_appendf(&trash, "avg_loop_us:"); SHOW_AVG(thr, swrate_avg(activity[thr].avg_loop_us, TIME_STATS_SAMPLES));
1211 chunk_appendf(&trash, "accepted:"); SHOW_TOT(thr, activity[thr].accepted);
1212 chunk_appendf(&trash, "accq_pushed:"); SHOW_TOT(thr, activity[thr].accq_pushed);
1213 chunk_appendf(&trash, "accq_full:"); SHOW_TOT(thr, activity[thr].accq_full);
Willy Tarreaue6182842019-04-15 18:54:10 +02001214#ifdef USE_THREAD
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001215 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 Tarreaub1591322020-06-29 14:17:59 +02001216 chunk_appendf(&trash, "fd_takeover:"); SHOW_TOT(thr, activity[thr].fd_takeover);
Willy Tarreaue6182842019-04-15 18:54:10 +02001217#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001218
Willy Tarreaud6a78502019-05-27 07:03:38 +02001219#if defined(DEBUG_DEV)
1220 /* keep these ones at the end */
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001221 chunk_appendf(&trash, "ctr0:"); SHOW_TOT(thr, activity[thr].ctr0);
1222 chunk_appendf(&trash, "ctr1:"); SHOW_TOT(thr, activity[thr].ctr1);
1223 chunk_appendf(&trash, "ctr2:"); SHOW_TOT(thr, activity[thr].ctr2);
Willy Tarreaud6a78502019-05-27 07:03:38 +02001224#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001225
1226 if (ci_putchk(si_ic(si), &trash) == -1) {
1227 chunk_reset(&trash);
1228 chunk_printf(&trash, "[output too large, cannot dump]\n");
Willy Tarreaudb398432018-11-15 11:08:52 +01001229 si_rx_room_blk(si);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001230 }
1231
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001232#undef SHOW_AVG
1233#undef SHOW_TOT
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001234 /* dump complete */
1235 return 1;
1236}
1237
William Lallemandeceddf72016-12-15 18:06:44 +01001238/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001239 * CLI IO handler for `show cli sockets`.
1240 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +01001241 */
1242static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1243{
1244 struct bind_conf *bind_conf;
1245 struct stream_interface *si = appctx->owner;
1246
1247 chunk_reset(&trash);
1248
1249 switch (appctx->st2) {
1250 case STAT_ST_INIT:
1251 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +02001252 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001253 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001254 return 0;
1255 }
William Lallemandeceddf72016-12-15 18:06:44 +01001256 appctx->st2 = STAT_ST_LIST;
Tim Duesterhus588b3142020-05-29 14:35:51 +02001257 /* fall through */
William Lallemandeceddf72016-12-15 18:06:44 +01001258
1259 case STAT_ST_LIST:
1260 if (global.stats_fe) {
1261 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
1262 struct listener *l;
1263
1264 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001265 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +01001266 * if the current node is the first of the list
1267 */
1268
Willy Tarreau3af9d832016-12-16 12:58:09 +01001269 if (appctx->ctx.cli.p0 &&
1270 &bind_conf->by_fe == (&global.stats_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +01001271 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +01001272 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +01001273 continue;
1274 }
1275
1276 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
1277
1278 char addr[46];
1279 char port[6];
1280
Willy Tarreau37159062020-08-27 07:48:42 +02001281 if (l->rx.addr.ss_family == AF_UNIX) {
William Lallemandeceddf72016-12-15 18:06:44 +01001282 const struct sockaddr_un *un;
1283
Willy Tarreau37159062020-08-27 07:48:42 +02001284 un = (struct sockaddr_un *)&l->rx.addr;
William Lallemande58915f2019-04-01 11:30:05 +02001285 if (un->sun_path[0] == '\0') {
William Lallemand75812a72019-04-01 11:30:04 +02001286 chunk_appendf(&trash, "abns@%s ", un->sun_path+1);
William Lallemande58915f2019-04-01 11:30:05 +02001287 } else {
1288 chunk_appendf(&trash, "unix@%s ", un->sun_path);
1289 }
Willy Tarreau37159062020-08-27 07:48:42 +02001290 } else if (l->rx.addr.ss_family == AF_INET) {
1291 addr_to_str(&l->rx.addr, addr, sizeof(addr));
1292 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001293 chunk_appendf(&trash, "ipv4@%s:%s ", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +02001294 } else if (l->rx.addr.ss_family == AF_INET6) {
1295 addr_to_str(&l->rx.addr, addr, sizeof(addr));
1296 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001297 chunk_appendf(&trash, "ipv6@[%s]:%s ", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +02001298 } else if (l->rx.addr.ss_family == AF_CUST_SOCKPAIR) {
1299 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->rx.addr)->sin_addr.s_addr);
William Lallemandeceddf72016-12-15 18:06:44 +01001300 } else
William Lallemand26314342018-10-26 14:47:41 +02001301 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001302
William Lallemand07a62f72017-05-24 00:57:40 +02001303 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +01001304 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +02001305 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1306 chunk_appendf(&trash, "operator ");
1307 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1308 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +01001309 else
1310 chunk_appendf(&trash, " ");
1311
Willy Tarreaue26993c2020-09-03 07:18:55 +02001312 if (bind_conf->settings.bind_proc != 0) {
William Lallemandeceddf72016-12-15 18:06:44 +01001313 int pos;
Willy Tarreaue26993c2020-09-03 07:18:55 +02001314 for (pos = 0; pos < 8 * sizeof(bind_conf->settings.bind_proc); pos++) {
1315 if (bind_conf->settings.bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +01001316 chunk_appendf(&trash, "%d,", pos+1);
1317 }
1318 }
1319 /* replace the latest comma by a newline */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001320 trash.area[trash.data-1] = '\n';
William Lallemandeceddf72016-12-15 18:06:44 +01001321
1322 } else {
1323 chunk_appendf(&trash, "all\n");
1324 }
1325
Willy Tarreau06d80a92017-10-19 14:32:15 +02001326 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001327 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001328 return 0;
1329 }
1330 }
Willy Tarreau3af9d832016-12-16 12:58:09 +01001331 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001332 }
1333 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02001334 /* fall through */
William Lallemandeceddf72016-12-15 18:06:44 +01001335 default:
1336 appctx->st2 = STAT_ST_FIN;
1337 return 1;
1338 }
1339}
1340
1341
Willy Tarreau0a739292016-11-22 20:21:23 +01001342/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001343 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1344 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001345 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001346static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001347{
1348 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001349 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001350
1351 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1352 return 1;
1353
Willy Tarreauf6710f82016-12-16 17:45:44 +01001354 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001355
1356 if (*args[2]) {
1357 int len = strlen(args[2]);
1358
Willy Tarreauf6710f82016-12-16 17:45:44 +01001359 for (; *var; var++) {
1360 if (strncmp(*var, args[2], len) == 0 &&
1361 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001362 break;
1363 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001364 if (!*var)
1365 return cli_err(appctx, "Variable not found\n");
1366
Willy Tarreau0a739292016-11-22 20:21:23 +01001367 appctx->st2 = STAT_ST_END;
1368 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001369 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001370 return 0;
1371}
1372
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001373/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1374 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1375 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1376 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001377static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001378{
1379 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1380 return 1;
1381
1382 appctx->ctx.cli.i0 = 0;
1383
1384 if (*args[2]) {
1385 appctx->ctx.cli.i0 = atoi(args[2]);
1386 appctx->st2 = STAT_ST_END;
1387 }
1388 return 0;
1389}
1390
Willy Tarreau599852e2016-11-22 20:33:32 +01001391/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001392static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001393{
1394 struct stream_interface *si = appctx->owner;
1395 struct stream *s = si_strm(si);
1396
1397 if (strcmp(args[2], "cli") == 0) {
1398 unsigned timeout;
1399 const char *res;
1400
Willy Tarreau9d008692019-08-09 11:21:01 +02001401 if (!*args[3])
1402 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001403
1404 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
Willy Tarreau9d008692019-08-09 11:21:01 +02001405 if (res || timeout < 1)
1406 return cli_err(appctx, "Invalid timeout value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001407
1408 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1409 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1410 return 1;
1411 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001412
1413 return cli_err(appctx, "'set timeout' only supports 'cli'.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001414}
1415
Willy Tarreau2af99412016-11-23 11:10:59 +01001416/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001417static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001418{
1419 int v;
1420
1421 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1422 return 1;
1423
Willy Tarreau9d008692019-08-09 11:21:01 +02001424 if (!*args[3])
1425 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001426
1427 v = atoi(args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001428 if (v > global.hardmaxconn)
1429 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001430
1431 /* check for unlimited values */
1432 if (v <= 0)
1433 v = global.hardmaxconn;
1434
1435 global.maxconn = v;
1436
1437 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001438 dequeue_all_listeners();
Willy Tarreau2af99412016-11-23 11:10:59 +01001439
1440 return 1;
1441}
1442
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001443static int set_severity_output(int *target, char *argument)
1444{
1445 if (!strcmp(argument, "none")) {
1446 *target = CLI_SEVERITY_NONE;
1447 return 1;
1448 }
1449 else if (!strcmp(argument, "number")) {
1450 *target = CLI_SEVERITY_NUMBER;
1451 return 1;
1452 }
1453 else if (!strcmp(argument, "string")) {
1454 *target = CLI_SEVERITY_STRING;
1455 return 1;
1456 }
1457 return 0;
1458}
1459
1460/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001461static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001462{
1463 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1464 return 0;
1465
Willy Tarreau9d008692019-08-09 11:21:01 +02001466 return cli_err(appctx, "one of 'none', 'number', 'string' is a required argument\n");
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001467}
William Lallemandeceddf72016-12-15 18:06:44 +01001468
William Lallemand67a234f2018-12-13 09:05:45 +01001469
1470/* show the level of the current CLI session */
1471static int cli_parse_show_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1472{
William Lallemand67a234f2018-12-13 09:05:45 +01001473 if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
Willy Tarreau9d008692019-08-09 11:21:01 +02001474 return cli_msg(appctx, LOG_INFO, "admin\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001475 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001476 return cli_msg(appctx, LOG_INFO, "operator\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001477 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001478 return cli_msg(appctx, LOG_INFO, "user\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001479 else
Willy Tarreau9d008692019-08-09 11:21:01 +02001480 return cli_msg(appctx, LOG_INFO, "unknown\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001481}
1482
1483/* parse and set the CLI level dynamically */
1484static int cli_parse_set_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1485{
William Lallemandad032882019-07-01 10:56:15 +02001486 /* this will ask the applet to not output a \n after the command */
1487 if (!strcmp(args[1], "-"))
1488 appctx->st1 |= APPCTX_CLI_ST1_NOLF;
1489
William Lallemand67a234f2018-12-13 09:05:45 +01001490 if (!strcmp(args[0], "operator")) {
1491 if (!cli_has_level(appctx, ACCESS_LVL_OPER)) {
1492 return 1;
1493 }
1494 appctx->cli_level &= ~ACCESS_LVL_MASK;
1495 appctx->cli_level |= ACCESS_LVL_OPER;
1496
1497 } else if (!strcmp(args[0], "user")) {
1498 if (!cli_has_level(appctx, ACCESS_LVL_USER)) {
1499 return 1;
1500 }
1501 appctx->cli_level &= ~ACCESS_LVL_MASK;
1502 appctx->cli_level |= ACCESS_LVL_USER;
1503 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001504 appctx->cli_level &= ~ACCESS_EXPERT;
1505 return 1;
1506}
1507
1508
1509/* parse and set the CLI expert-mode dynamically */
1510static int cli_parse_expert_mode(char **args, char *payload, struct appctx *appctx, void *private)
1511{
1512 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1513 return 1;
1514
1515 if (!*args[1])
1516 return (appctx->cli_level & ACCESS_EXPERT)
1517 ? cli_msg(appctx, LOG_INFO, "expert-mode is ON\n")
1518 : cli_msg(appctx, LOG_INFO, "expert-mode is OFF\n");
1519
1520 appctx->cli_level &= ~ACCESS_EXPERT;
1521 if (strcmp(args[1], "on") == 0)
1522 appctx->cli_level |= ACCESS_EXPERT;
William Lallemand67a234f2018-12-13 09:05:45 +01001523 return 1;
1524}
1525
William Lallemanda57b7e32018-12-14 21:11:31 +01001526
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001527int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001528{
1529 return 0;
1530}
1531
Willy Tarreau45c742b2016-11-24 14:51:17 +01001532/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001533static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001534{
1535 int v;
1536 int *res;
1537 int mul = 1;
1538
1539 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1540 return 1;
1541
1542 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1543 res = &global.cps_lim;
1544 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1545 res = &global.sps_lim;
1546#ifdef USE_OPENSSL
1547 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1548 res = &global.ssl_lim;
1549#endif
1550 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1551 res = &global.comp_rate_lim;
1552 mul = 1024;
1553 }
1554 else {
Willy Tarreau9d008692019-08-09 11:21:01 +02001555 return cli_err(appctx,
Willy Tarreau45c742b2016-11-24 14:51:17 +01001556 "'set rate-limit' only supports :\n"
1557 " - 'connections global' to set the per-process maximum connection rate\n"
1558 " - 'sessions global' to set the per-process maximum session rate\n"
1559#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001560 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001561#endif
Willy Tarreau9d008692019-08-09 11:21:01 +02001562 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001563 }
1564
Willy Tarreau9d008692019-08-09 11:21:01 +02001565 if (!*args[4])
1566 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001567
1568 v = atoi(args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001569 if (v < 0)
1570 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001571
1572 *res = v * mul;
1573
1574 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001575 dequeue_all_listeners();
Willy Tarreau45c742b2016-11-24 14:51:17 +01001576
1577 return 1;
1578}
1579
William Lallemandf6975e92017-05-26 17:42:10 +02001580/* parse the "expose-fd" argument on the bind lines */
1581static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1582{
1583 if (!*args[cur_arg + 1]) {
1584 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1585 return ERR_ALERT | ERR_FATAL;
1586 }
1587 if (!strcmp(args[cur_arg+1], "listeners")) {
1588 conf->level |= ACCESS_FD_LISTENERS;
1589 } else {
1590 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1591 args[cur_arg], args[cur_arg+1]);
1592 return ERR_ALERT | ERR_FATAL;
1593 }
1594
1595 return 0;
1596}
1597
William Lallemand74c24fb2016-11-21 17:18:36 +01001598/* parse the "level" argument on the bind lines */
1599static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1600{
1601 if (!*args[cur_arg + 1]) {
1602 memprintf(err, "'%s' : missing level", args[cur_arg]);
1603 return ERR_ALERT | ERR_FATAL;
1604 }
1605
William Lallemand07a62f72017-05-24 00:57:40 +02001606 if (!strcmp(args[cur_arg+1], "user")) {
1607 conf->level &= ~ACCESS_LVL_MASK;
1608 conf->level |= ACCESS_LVL_USER;
1609 } else if (!strcmp(args[cur_arg+1], "operator")) {
1610 conf->level &= ~ACCESS_LVL_MASK;
1611 conf->level |= ACCESS_LVL_OPER;
1612 } else if (!strcmp(args[cur_arg+1], "admin")) {
1613 conf->level &= ~ACCESS_LVL_MASK;
1614 conf->level |= ACCESS_LVL_ADMIN;
1615 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001616 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1617 args[cur_arg], args[cur_arg+1]);
1618 return ERR_ALERT | ERR_FATAL;
1619 }
1620
1621 return 0;
1622}
1623
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001624static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1625{
1626 if (!*args[cur_arg + 1]) {
1627 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1628 return ERR_ALERT | ERR_FATAL;
1629 }
1630
1631 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1632 return 0;
1633 else {
1634 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1635 args[cur_arg], args[cur_arg+1]);
1636 return ERR_ALERT | ERR_FATAL;
1637 }
1638}
1639
Olivier Houchardf886e342017-04-05 22:24:59 +02001640/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001641static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02001642{
1643 char *cmsgbuf = NULL;
1644 unsigned char *tmpbuf = NULL;
1645 struct cmsghdr *cmsg;
1646 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001647 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001648 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001649 struct msghdr msghdr;
1650 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001651 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001652 const char *ns_name, *if_name;
1653 unsigned char ns_nlen, if_nlen;
1654 int nb_queued;
1655 int cur_fd = 0;
Olivier Houchardf886e342017-04-05 22:24:59 +02001656 int *tmpfd;
1657 int tot_fd_nb = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001658 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001659 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001660 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001661 int ret;
1662
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001663 if (!remote) {
1664 ha_warning("Only works on real connections\n");
1665 goto out;
1666 }
1667
1668 fd = remote->handle.fd;
1669
Olivier Houchardf886e342017-04-05 22:24:59 +02001670 /* Temporary set the FD in blocking mode, that will make our life easier */
1671 old_fcntl = fcntl(fd, F_GETFL);
1672 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001673 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001674 goto out;
1675 }
1676 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1677 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001678 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001679 goto out;
1680 }
1681 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001682 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001683 goto out;
1684 }
Olivier Houchard54740872017-04-06 14:45:14 +02001685 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001686 iov.iov_base = &tot_fd_nb;
1687 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001688 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001689 goto out;
1690 memset(&msghdr, 0, sizeof(msghdr));
1691 /*
1692 * First, calculates the total number of FD, so that we can let
Jackie Tapia749f74c2020-07-22 18:59:40 -05001693 * the caller know how much it should expect.
Olivier Houchardf886e342017-04-05 22:24:59 +02001694 */
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001695 for (cur_fd = 0;cur_fd < global.maxsock; cur_fd++)
1696 tot_fd_nb += fdtab[cur_fd].exported;
William Lallemand5fd3b282020-01-16 15:32:08 +01001697
Olivier Houchardf886e342017-04-05 22:24:59 +02001698 if (tot_fd_nb == 0)
1699 goto out;
1700
1701 /* First send the total number of file descriptors, so that the
1702 * receiving end knows what to expect.
1703 */
1704 msghdr.msg_iov = &iov;
1705 msghdr.msg_iovlen = 1;
1706 ret = sendmsg(fd, &msghdr, 0);
1707 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001708 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001709 goto out;
1710 }
1711
1712 /* Now send the fds */
1713 msghdr.msg_control = cmsgbuf;
1714 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1715 cmsg = CMSG_FIRSTHDR(&msghdr);
1716 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1717 cmsg->cmsg_level = SOL_SOCKET;
1718 cmsg->cmsg_type = SCM_RIGHTS;
1719 tmpfd = (int *)CMSG_DATA(cmsg);
1720
Olivier Houchardf886e342017-04-05 22:24:59 +02001721 /* For each socket, e message is sent, containing the following :
1722 * Size of the namespace name (or 0 if none), as an unsigned char.
1723 * The namespace name, if any
1724 * Size of the interface name (or 0 if none), as an unsigned char
1725 * The interface name, if any
Willy Tarreaucf1f1932020-08-26 10:30:09 +02001726 * 32 bits of zeroes (used to be listener options).
Olivier Houchardf886e342017-04-05 22:24:59 +02001727 */
1728 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
Ilya Shipitsind4259502020-04-08 01:07:56 +05001729 * buffer big enough to store the socket information.
Olivier Houchardf886e342017-04-05 22:24:59 +02001730 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001731 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001732 if (tmpbuf == NULL) {
Ilya Shipitsind4259502020-04-08 01:07:56 +05001733 ha_warning("Failed to allocate memory to transfer socket information\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001734 goto out;
1735 }
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001736
1737 nb_queued = 0;
Olivier Houchardf886e342017-04-05 22:24:59 +02001738 iov.iov_base = tmpbuf;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001739 for (cur_fd = 0; cur_fd < global.maxsock; cur_fd++) {
1740 if (!(fdtab[cur_fd].exported))
1741 continue;
1742
1743 ns_name = if_name = "";
1744 ns_nlen = if_nlen = 0;
1745
1746 /* for now we can only retrieve namespaces and interfaces from
1747 * pure listeners.
1748 */
Willy Tarreaua74cb382020-10-15 21:29:49 +02001749 if (fdtab[cur_fd].iocb == sock_accept_iocb) {
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001750 const struct listener *l = fdtab[cur_fd].owner;
1751
Willy Tarreau818a92e2020-09-03 07:50:19 +02001752 if (l->rx.settings->interface) {
1753 if_name = l->rx.settings->interface;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001754 if_nlen = strlen(if_name);
1755 }
1756
1757#ifdef USE_NS
Willy Tarreau818a92e2020-09-03 07:50:19 +02001758 if (l->rx.settings->netns) {
1759 ns_name = l->rx.settings->netns->node.key;
1760 ns_nlen = l->rx.settings->netns->name_len;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001761 }
1762#endif
1763 }
1764
1765 /* put the FD into the CMSG_DATA */
1766 tmpfd[nb_queued++] = cur_fd;
1767
1768 /* first block is <ns_name_len> <ns_name> */
1769 tmpbuf[curoff++] = ns_nlen;
1770 if (ns_nlen)
1771 memcpy(tmpbuf + curoff, ns_name, ns_nlen);
1772 curoff += ns_nlen;
1773
1774 /* second block is <if_name_len> <if_name> */
1775 tmpbuf[curoff++] = if_nlen;
1776 if (if_nlen)
1777 memcpy(tmpbuf + curoff, if_name, if_nlen);
1778 curoff += if_nlen;
1779
1780 /* we used to send the listener options here before 2.3 */
1781 memset(tmpbuf + curoff, 0, sizeof(int));
1782 curoff += sizeof(int);
1783
1784 /* there's a limit to how many FDs may be sent at once */
1785 if (nb_queued == MAX_SEND_FD) {
1786 iov.iov_len = curoff;
1787 if (sendmsg(fd, &msghdr, 0) != curoff) {
1788 ha_warning("Failed to transfer sockets\n");
1789 return -1;
1790 }
1791
1792 /* Wait for an ack */
1793 do {
1794 ret = recv(fd, &tot_fd_nb, sizeof(tot_fd_nb), 0);
1795 } while (ret == -1 && errno == EINTR);
1796
1797 if (ret <= 0) {
1798 ha_warning("Unexpected error while transferring sockets\n");
1799 return -1;
1800 }
1801 curoff = 0;
1802 nb_queued = 0;
1803 }
William Lallemand5fd3b282020-01-16 15:32:08 +01001804 }
1805
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001806 /* flush pending stuff */
1807 if (nb_queued) {
Olivier Houchardf886e342017-04-05 22:24:59 +02001808 iov.iov_len = curoff;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001809 cmsg->cmsg_len = CMSG_LEN(nb_queued * sizeof(int));
1810 msghdr.msg_controllen = CMSG_SPACE(nb_queued * sizeof(int));
Olivier Houchardf886e342017-04-05 22:24:59 +02001811 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001812 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001813 goto out;
1814 }
1815 }
1816
1817out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001818 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001819 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001820 goto out;
1821 }
1822 appctx->st0 = CLI_ST_END;
1823 free(cmsgbuf);
1824 free(tmpbuf);
1825 return 1;
1826}
1827
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001828static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
1829{
1830 if (*args[0] == 'h')
1831 /* help */
1832 cli_gen_usage_msg(appctx);
1833 else if (*args[0] == 'p')
1834 /* prompt */
1835 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
1836 else if (*args[0] == 'q')
1837 /* quit */
1838 appctx->st0 = CLI_ST_END;
1839
1840 return 1;
1841}
Olivier Houchardf886e342017-04-05 22:24:59 +02001842
William Lallemand2f4ce202018-10-26 14:47:47 +02001843void pcli_write_prompt(struct stream *s)
1844{
1845 struct buffer *msg = get_trash_chunk();
1846 struct channel *oc = si_oc(&s->si[0]);
1847
William Lallemanddc12c2e2018-12-13 09:05:46 +01001848 if (!(s->pcli_flags & PCLI_F_PROMPT))
William Lallemand5b80fa22018-12-11 16:10:54 +01001849 return;
1850
William Lallemanddc12c2e2018-12-13 09:05:46 +01001851 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01001852 chunk_appendf(msg, "+ ");
1853 } else {
1854 if (s->pcli_next_pid == 0)
Willy Tarreau52880f92018-12-15 13:30:03 +01001855 chunk_appendf(msg, "master%s> ",
1856 (global.mode & MODE_MWORKER_WAIT) ? "[ReloadFailed]" : "");
William Lallemandebf61802018-12-11 16:10:57 +01001857 else
1858 chunk_appendf(msg, "%d> ", s->pcli_next_pid);
1859 }
William Lallemand2f4ce202018-10-26 14:47:47 +02001860 co_inject(oc, msg->area, msg->data);
1861}
1862
William Lallemand291810d2018-10-26 14:47:38 +02001863
William Lallemandcf62f7e2018-10-26 14:47:40 +02001864/* The pcli_* functions are used for the CLI proxy in the master */
1865
William Lallemanddeeaa592018-10-26 14:47:48 +02001866void pcli_reply_and_close(struct stream *s, const char *msg)
1867{
1868 struct buffer *buf = get_trash_chunk();
1869
1870 chunk_initstr(buf, msg);
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001871 si_retnclose(&s->si[0], buf);
William Lallemanddeeaa592018-10-26 14:47:48 +02001872}
1873
William Lallemand291810d2018-10-26 14:47:38 +02001874static enum obj_type *pcli_pid_to_server(int proc_pid)
1875{
1876 struct mworker_proc *child;
1877
William Lallemand99e0bb92020-11-05 10:28:53 +01001878 /* return the mCLI applet of the master */
William Lallemandbddd33a2018-12-11 16:10:53 +01001879 if (proc_pid == 0)
William Lallemand99e0bb92020-11-05 10:28:53 +01001880 return &mcli_applet.obj_type;
William Lallemandbddd33a2018-12-11 16:10:53 +01001881
William Lallemand291810d2018-10-26 14:47:38 +02001882 list_for_each_entry(child, &proc_list, list) {
1883 if (child->pid == proc_pid){
1884 return &child->srv->obj_type;
1885 }
1886 }
1887 return NULL;
1888}
1889
1890/* Take a CLI prefix in argument (eg: @!1234 @master @1)
1891 * Return:
1892 * 0: master
1893 * > 0: pid of a worker
1894 * < 0: didn't find a worker
1895 */
1896static int pcli_prefix_to_pid(const char *prefix)
1897{
1898 int proc_pid;
1899 struct mworker_proc *child;
1900 char *errtol = NULL;
1901
1902 if (*prefix != '@') /* not a prefix, should not happen */
1903 return -1;
1904
1905 prefix++;
1906 if (!*prefix) /* sent @ alone, return the master */
1907 return 0;
1908
1909 if (strcmp("master", prefix) == 0) {
1910 return 0;
1911 } else if (*prefix == '!') {
1912 prefix++;
1913 if (!*prefix)
1914 return -1;
1915
1916 proc_pid = strtol(prefix, &errtol, 10);
1917 if (*errtol != '\0')
1918 return -1;
1919 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001920 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001921 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001922 if (child->pid == proc_pid){
1923 return child->pid;
1924 }
1925 }
1926 } else {
1927 struct mworker_proc *chosen = NULL;
1928 /* this is a relative pid */
1929
1930 proc_pid = strtol(prefix, &errtol, 10);
1931 if (*errtol != '\0')
1932 return -1;
1933
1934 if (proc_pid == 0) /* return the master */
1935 return 0;
1936
1937 /* chose the right process, the current one is the one with the
1938 least number of reloads */
1939 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001940 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001941 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001942 if (child->relative_pid == proc_pid){
1943 if (child->reloads == 0)
1944 return child->pid;
1945 else if (chosen == NULL || child->reloads < chosen->reloads)
1946 chosen = child;
1947 }
1948 }
1949 if (chosen)
1950 return chosen->pid;
1951 }
1952 return -1;
1953}
1954
William Lallemandbddd33a2018-12-11 16:10:53 +01001955/* Return::
1956 * >= 0 : number of words to escape
1957 * = -1 : error
1958 */
1959
1960int pcli_find_and_exec_kw(struct stream *s, char **args, int argl, char **errmsg, int *next_pid)
1961{
1962 if (argl < 1)
1963 return 0;
1964
1965 /* there is a prefix */
1966 if (args[0][0] == '@') {
1967 int target_pid = pcli_prefix_to_pid(args[0]);
1968
1969 if (target_pid == -1) {
1970 memprintf(errmsg, "Can't find the target PID matching the prefix '%s'\n", args[0]);
1971 return -1;
1972 }
1973
1974 /* if the prefix is alone, define a default target */
1975 if (argl == 1)
1976 s->pcli_next_pid = target_pid;
1977 else
1978 *next_pid = target_pid;
1979 return 1;
William Lallemand5b80fa22018-12-11 16:10:54 +01001980 } else if (!strcmp("prompt", args[0])) {
William Lallemanddc12c2e2018-12-13 09:05:46 +01001981 s->pcli_flags ^= PCLI_F_PROMPT;
William Lallemand5b80fa22018-12-11 16:10:54 +01001982 return argl; /* return the number of elements in the array */
William Lallemand5f610682018-12-11 16:10:55 +01001983
1984 } else if (!strcmp("quit", args[0])) {
1985 channel_shutr_now(&s->req);
1986 channel_shutw_now(&s->res);
1987 return argl; /* return the number of elements in the array */
William Lallemandb7ea1412018-12-13 09:05:47 +01001988 } else if (!strcmp(args[0], "operator")) {
1989 if (!pcli_has_level(s, ACCESS_LVL_OPER)) {
1990 memprintf(errmsg, "Permission denied!\n");
1991 return -1;
1992 }
1993 s->pcli_flags &= ~ACCESS_LVL_MASK;
1994 s->pcli_flags |= ACCESS_LVL_OPER;
1995 return argl;
1996
1997 } else if (!strcmp(args[0], "user")) {
1998 if (!pcli_has_level(s, ACCESS_LVL_USER)) {
1999 memprintf(errmsg, "Permission denied!\n");
2000 return -1;
2001 }
2002 s->pcli_flags &= ~ACCESS_LVL_MASK;
2003 s->pcli_flags |= ACCESS_LVL_USER;
2004 return argl;
William Lallemandbddd33a2018-12-11 16:10:53 +01002005 }
2006
2007 return 0;
2008}
2009
2010/*
2011 * Parse the CLI request:
2012 * - It does basically the same as the cli_io_handler, but as a proxy
2013 * - It can exec a command and strip non forwardable commands
William Lallemandcf62f7e2018-10-26 14:47:40 +02002014 *
2015 * Return:
William Lallemandbddd33a2018-12-11 16:10:53 +01002016 * - the number of characters to forward or
2017 * - 1 if there is an error or not enough data
William Lallemandcf62f7e2018-10-26 14:47:40 +02002018 */
William Lallemandbddd33a2018-12-11 16:10:53 +01002019int pcli_parse_request(struct stream *s, struct channel *req, char **errmsg, int *next_pid)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002020{
William Lallemandbddd33a2018-12-11 16:10:53 +01002021 char *str = (char *)ci_head(req);
2022 char *end = (char *)ci_stop(req);
2023 char *args[MAX_STATS_ARGS + 1]; /* +1 for storing a NULL */
2024 int argl; /* number of args */
2025 char *p;
2026 char *trim = NULL;
William Lallemandebf61802018-12-11 16:10:57 +01002027 char *payload = NULL;
William Lallemandbddd33a2018-12-11 16:10:53 +01002028 int wtrim = 0; /* number of words to trim */
2029 int reql = 0;
William Lallemandb7ea1412018-12-13 09:05:47 +01002030 int ret;
William Lallemandbddd33a2018-12-11 16:10:53 +01002031 int i = 0;
2032
2033 p = str;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002034
William Lallemanddc12c2e2018-12-13 09:05:46 +01002035 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002036
2037 /* Looks for the end of one command */
2038 while (p+reql < end) {
2039 /* handle escaping */
2040 if (p[reql] == '\\') {
William Lallemand02c255e2020-06-18 18:45:04 +02002041 reql+=2;
William Lallemandebf61802018-12-11 16:10:57 +01002042 continue;
2043 }
2044 if (p[reql] == ';' || p[reql] == '\n') {
2045 /* found the end of the command */
2046 p[reql] = '\n';
2047 reql++;
2048 break;
2049 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002050 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002051 }
William Lallemandebf61802018-12-11 16:10:57 +01002052 } else {
2053 while (p+reql < end) {
2054 if (p[reql] == '\n') {
2055 /* found the end of the line */
2056 reql++;
2057 break;
2058 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002059 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002060 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002061 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002062
William Lallemandbddd33a2018-12-11 16:10:53 +01002063 /* set end to first byte after the end of the command */
2064 end = p + reql;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002065
William Lallemandbddd33a2018-12-11 16:10:53 +01002066 /* there is no end to this command, need more to parse ! */
2067 if (*(end-1) != '\n') {
2068 return -1;
2069 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002070
William Lallemand3301f3e2018-12-13 09:05:48 +01002071 if (s->pcli_flags & PCLI_F_PAYLOAD) {
2072 if (reql == 1) /* last line of the payload */
2073 s->pcli_flags &= ~PCLI_F_PAYLOAD;
William Lallemandebf61802018-12-11 16:10:57 +01002074 return reql;
2075 }
2076
William Lallemandbddd33a2018-12-11 16:10:53 +01002077 *(end-1) = '\0';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002078
William Lallemandbddd33a2018-12-11 16:10:53 +01002079 /* splits the command in words */
2080 while (i < MAX_STATS_ARGS && p < end) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002081 /* skip leading spaces/tabs */
2082 p += strspn(p, " \t");
2083 if (!*p)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002084 break;
2085
William Lallemandbddd33a2018-12-11 16:10:53 +01002086 args[i] = p;
William Lallemandfe249c32020-06-18 18:03:57 +02002087 while (1) {
2088 p += strcspn(p, " \t\\");
2089 /* escaped chars using backlashes (\) */
2090 if (*p == '\\') {
2091 if (!*++p)
2092 break;
2093 if (!*++p)
2094 break;
2095 } else {
2096 break;
William Lallemandbddd33a2018-12-11 16:10:53 +01002097 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002098 }
William Lallemandfe249c32020-06-18 18:03:57 +02002099 *p++ = 0;
William Lallemandbddd33a2018-12-11 16:10:53 +01002100 i++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002101 }
2102
William Lallemandbddd33a2018-12-11 16:10:53 +01002103 argl = i;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002104
William Lallemandbddd33a2018-12-11 16:10:53 +01002105 for (; i < MAX_STATS_ARGS + 1; i++)
2106 args[i] = NULL;
2107
2108 wtrim = pcli_find_and_exec_kw(s, args, argl, errmsg, next_pid);
2109
2110 /* End of words are ending by \0, we need to replace the \0s by spaces
21111 before forwarding them */
2112 p = str;
William Lallemand3301f3e2018-12-13 09:05:48 +01002113 while (p < end-1) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002114 if (*p == '\0')
2115 *p = ' ';
2116 p++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002117 }
2118
William Lallemand3301f3e2018-12-13 09:05:48 +01002119 payload = strstr(str, PAYLOAD_PATTERN);
2120 if ((end - 1) == (payload + strlen(PAYLOAD_PATTERN))) {
2121 /* if the payload pattern is at the end */
2122 s->pcli_flags |= PCLI_F_PAYLOAD;
2123 ret = reql;
2124 }
2125
William Lallemandbddd33a2018-12-11 16:10:53 +01002126 *(end-1) = '\n';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002127
William Lallemandbddd33a2018-12-11 16:10:53 +01002128 if (wtrim > 0) {
2129 trim = &args[wtrim][0];
2130 if (trim == NULL) /* if this was the last word in the table */
2131 trim = end;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002132
William Lallemandbddd33a2018-12-11 16:10:53 +01002133 b_del(&req->buf, trim - str);
2134
William Lallemandb7ea1412018-12-13 09:05:47 +01002135 ret = end - trim;
William Lallemandbddd33a2018-12-11 16:10:53 +01002136 } else if (wtrim < 0) {
2137 /* parsing error */
2138 return -1;
William Lallemandb7ea1412018-12-13 09:05:47 +01002139 } else {
2140 /* the whole string */
2141 ret = end - str;
William Lallemandbddd33a2018-12-11 16:10:53 +01002142 }
2143
William Lallemandb7ea1412018-12-13 09:05:47 +01002144 if (ret > 1) {
2145 if (pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2146 goto end;
2147 } else if (pcli_has_level(s, ACCESS_LVL_OPER)) {
William Lallemandad032882019-07-01 10:56:15 +02002148 ci_insert_line2(req, 0, "operator -", strlen("operator -"));
2149 ret += strlen("operator -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002150 } else if (pcli_has_level(s, ACCESS_LVL_USER)) {
William Lallemandad032882019-07-01 10:56:15 +02002151 ci_insert_line2(req, 0, "user -", strlen("user -"));
2152 ret += strlen("user -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002153 }
2154 }
2155end:
William Lallemandbddd33a2018-12-11 16:10:53 +01002156
William Lallemandb7ea1412018-12-13 09:05:47 +01002157 return ret;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002158}
2159
2160int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
2161{
William Lallemandbddd33a2018-12-11 16:10:53 +01002162 int next_pid = -1;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002163 int to_forward;
William Lallemandbddd33a2018-12-11 16:10:53 +01002164 char *errmsg = NULL;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002165
William Lallemandb7ea1412018-12-13 09:05:47 +01002166 if ((s->pcli_flags & ACCESS_LVL_MASK) == ACCESS_LVL_NONE)
2167 s->pcli_flags |= strm_li(s)->bind_conf->level & ACCESS_LVL_MASK;
2168
William Lallemandcf62f7e2018-10-26 14:47:40 +02002169read_again:
2170 /* if the channel is closed for read, we won't receive any more data
2171 from the client, but we don't want to forward this close to the
2172 server */
2173 channel_dont_close(req);
2174
2175 /* We don't know yet to which server we will connect */
2176 channel_dont_connect(req);
2177
2178
2179 /* we are not waiting for a response, there is no more request and we
2180 * receive a close from the client, we can leave */
2181 if (!(ci_data(req)) && req->flags & CF_SHUTR) {
2182 channel_shutw_now(&s->res);
2183 s->req.analysers &= ~AN_REQ_WAIT_CLI;
2184 return 1;
2185 }
2186
2187 req->flags |= CF_READ_DONTWAIT;
2188
2189 /* need more data */
2190 if (!ci_data(req))
2191 return 0;
2192
2193 /* If there is data available for analysis, log the end of the idle time. */
2194 if (c_data(req) && s->logs.t_idle == -1)
2195 s->logs.t_idle = tv_ms_elapsed(&s->logs.tv_accept, &now) - s->logs.t_handshake;
2196
William Lallemandbddd33a2018-12-11 16:10:53 +01002197 to_forward = pcli_parse_request(s, req, &errmsg, &next_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002198 if (to_forward > 0) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002199 int target_pid;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002200 /* enough data */
2201
William Lallemandcf62f7e2018-10-26 14:47:40 +02002202 /* forward only 1 command */
2203 channel_forward(req, to_forward);
William Lallemandebf61802018-12-11 16:10:57 +01002204
William Lallemanddc12c2e2018-12-13 09:05:46 +01002205 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002206 /* we send only 1 command per request, and we write close after it */
2207 channel_shutw_now(req);
2208 } else {
2209 pcli_write_prompt(s);
2210 }
2211
2212 s->res.flags |= CF_WAKE_ONCE; /* need to be called again */
William Lallemandcf62f7e2018-10-26 14:47:40 +02002213
2214 /* remove the XFER_DATA analysers, which forwards all
2215 * the data, we don't want to forward the next requests
2216 * We need to add CF_FLT_ANALYZE to abort the forward too.
2217 */
2218 req->analysers &= ~(AN_REQ_FLT_XFER_DATA|AN_REQ_WAIT_CLI);
2219 req->analysers |= AN_REQ_FLT_END|CF_FLT_ANALYZE;
2220 s->res.analysers |= AN_RES_WAIT_CLI;
2221
William Lallemandebf61802018-12-11 16:10:57 +01002222 if (!(s->flags & SF_ASSIGNED)) {
2223 if (next_pid > -1)
2224 target_pid = next_pid;
2225 else
2226 target_pid = s->pcli_next_pid;
2227 /* we can connect now */
2228 s->target = pcli_pid_to_server(target_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002229
William Lallemandebf61802018-12-11 16:10:57 +01002230 s->flags |= (SF_DIRECT | SF_ASSIGNED);
2231 channel_auto_connect(req);
2232 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002233
2234 } else if (to_forward == 0) {
William Lallemandcf62f7e2018-10-26 14:47:40 +02002235 /* we trimmed things but we might have other commands to consume */
William Lallemandbddd33a2018-12-11 16:10:53 +01002236 pcli_write_prompt(s);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002237 goto read_again;
William Lallemandbddd33a2018-12-11 16:10:53 +01002238 } else if (to_forward == -1 && errmsg) {
2239 /* there was an error during the parsing */
2240 pcli_reply_and_close(s, errmsg);
2241 return 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002242 } else if (to_forward == -1 && channel_full(req, global.tune.maxrewrite)) {
2243 /* buffer is full and we didn't catch the end of a command */
2244 goto send_help;
2245 }
2246
2247 return 0;
2248
2249send_help:
2250 b_reset(&req->buf);
2251 b_putblk(&req->buf, "help\n", 5);
2252 goto read_again;
2253}
2254
2255int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
2256{
2257 struct proxy *fe = strm_fe(s);
2258 struct proxy *be = s->be;
2259
William Lallemand6b7cd0a2018-11-06 17:37:11 +01002260 if (rep->flags & CF_READ_ERROR) {
2261 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
2262 s->res.analysers &= ~AN_RES_WAIT_CLI;
2263 return 0;
2264 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002265 rep->flags |= CF_READ_DONTWAIT; /* try to get back here ASAP */
2266 rep->flags |= CF_NEVER_WAIT;
2267
2268 /* don't forward the close */
2269 channel_dont_close(&s->res);
2270 channel_dont_close(&s->req);
2271
William Lallemanddc12c2e2018-12-13 09:05:46 +01002272 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002273 s->req.analysers |= AN_REQ_WAIT_CLI;
2274 s->res.analysers &= ~AN_RES_WAIT_CLI;
2275 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2276 return 0;
2277 }
2278
William Lallemandcf62f7e2018-10-26 14:47:40 +02002279 /* forward the data */
2280 if (ci_data(rep)) {
2281 c_adv(rep, ci_data(rep));
2282 return 0;
2283 }
2284
2285 if ((rep->flags & (CF_SHUTR|CF_READ_NULL))) {
2286 /* stream cleanup */
2287
William Lallemand2f4ce202018-10-26 14:47:47 +02002288 pcli_write_prompt(s);
2289
William Lallemandcf62f7e2018-10-26 14:47:40 +02002290 s->si[1].flags |= SI_FL_NOLINGER | SI_FL_NOHALF;
2291 si_shutr(&s->si[1]);
2292 si_shutw(&s->si[1]);
2293
2294 /*
2295 * starting from there this the same code as
2296 * http_end_txn_clean_session().
2297 *
2298 * It allows to do frontend keepalive while reconnecting to a
2299 * new server for each request.
2300 */
2301
2302 if (s->flags & SF_BE_ASSIGNED) {
2303 HA_ATOMIC_SUB(&be->beconn, 1);
2304 if (unlikely(s->srv_conn))
2305 sess_change_server(s, NULL);
2306 }
2307
2308 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2309 stream_process_counters(s);
2310
2311 /* don't count other requests' data */
2312 s->logs.bytes_in -= ci_data(&s->req);
2313 s->logs.bytes_out -= ci_data(&s->res);
2314
2315 /* we may need to know the position in the queue */
2316 pendconn_free(s);
2317
2318 /* let's do a final log if we need it */
2319 if (!LIST_ISEMPTY(&fe->logformat) && s->logs.logwait &&
2320 !(s->flags & SF_MONITOR) &&
2321 (!(fe->options & PR_O_NULLNOLOG) || s->req.total)) {
2322 s->do_log(s);
2323 }
2324
2325 /* stop tracking content-based counters */
2326 stream_stop_content_counters(s);
2327 stream_update_time_stats(s);
2328
2329 s->logs.accept_date = date; /* user-visible date for logging */
2330 s->logs.tv_accept = now; /* corrected date for internal use */
2331 s->logs.t_handshake = 0; /* There are no handshake in keep alive connection. */
2332 s->logs.t_idle = -1;
2333 tv_zero(&s->logs.tv_request);
2334 s->logs.t_queue = -1;
2335 s->logs.t_connect = -1;
2336 s->logs.t_data = -1;
2337 s->logs.t_close = 0;
2338 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
2339 s->logs.srv_queue_pos = 0; /* we will get this number soon */
2340
2341 s->logs.bytes_in = s->req.total = ci_data(&s->req);
2342 s->logs.bytes_out = s->res.total = ci_data(&s->res);
2343
2344 stream_del_srv_conn(s);
2345 if (objt_server(s->target)) {
2346 if (s->flags & SF_CURR_SESS) {
2347 s->flags &= ~SF_CURR_SESS;
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002348 HA_ATOMIC_SUB(&__objt_server(s->target)->cur_sess, 1);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002349 }
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002350 if (may_dequeue_tasks(__objt_server(s->target), be))
2351 process_srv_queue(__objt_server(s->target));
William Lallemandcf62f7e2018-10-26 14:47:40 +02002352 }
2353
2354 s->target = NULL;
2355
2356 /* only release our endpoint if we don't intend to reuse the
2357 * connection.
2358 */
2359 if (!si_conn_ready(&s->si[1])) {
2360 si_release_endpoint(&s->si[1]);
2361 s->srv_conn = NULL;
2362 }
2363
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002364 sockaddr_free(&s->target_addr);
2365
William Lallemandcf62f7e2018-10-26 14:47:40 +02002366 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
2367 s->si[1].err_type = SI_ET_NONE;
2368 s->si[1].conn_retries = 0; /* used for logging too */
2369 s->si[1].exp = TICK_ETERNITY;
2370 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 +02002371 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 +02002372 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 +02002373 s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_ADDR_SET|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
2374 s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
2375 s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
2376 /* reinitialise the current rule list pointer to NULL. We are sure that
2377 * any rulelist match the NULL pointer.
2378 */
2379 s->current_rule_list = NULL;
2380
2381 s->be = strm_fe(s);
2382 s->logs.logwait = strm_fe(s)->to_log;
2383 s->logs.level = 0;
2384 stream_del_srv_conn(s);
2385 s->target = NULL;
2386 /* re-init store persistence */
2387 s->store_count = 0;
2388 s->uniq_id = global.req_count++;
2389
2390 s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */
2391
2392 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2393
2394 s->req.analysers |= AN_REQ_WAIT_CLI;
2395 s->res.analysers &= ~AN_RES_WAIT_CLI;
2396
2397 /* We must trim any excess data from the response buffer, because we
2398 * may have blocked an invalid response from a server that we don't
Ilya Shipitsind4259502020-04-08 01:07:56 +05002399 * want to accidentally forward once we disable the analysers, nor do
William Lallemandcf62f7e2018-10-26 14:47:40 +02002400 * we want those data to come along with next response. A typical
2401 * example of such data would be from a buggy server responding to
2402 * a HEAD with some data, or sending more than the advertised
2403 * content-length.
2404 */
2405 if (unlikely(ci_data(&s->res)))
2406 b_set_data(&s->res.buf, co_data(&s->res));
2407
2408 /* Now we can realign the response buffer */
2409 c_realign_if_empty(&s->res);
2410
2411 s->req.rto = strm_fe(s)->timeout.client;
2412 s->req.wto = TICK_ETERNITY;
2413
2414 s->res.rto = TICK_ETERNITY;
2415 s->res.wto = strm_fe(s)->timeout.client;
2416
2417 s->req.rex = TICK_ETERNITY;
2418 s->req.wex = TICK_ETERNITY;
2419 s->req.analyse_exp = TICK_ETERNITY;
2420 s->res.rex = TICK_ETERNITY;
2421 s->res.wex = TICK_ETERNITY;
2422 s->res.analyse_exp = TICK_ETERNITY;
2423 s->si[1].hcto = TICK_ETERNITY;
2424
2425 /* we're removing the analysers, we MUST re-enable events detection.
2426 * We don't enable close on the response channel since it's either
2427 * already closed, or in keep-alive with an idle connection handler.
2428 */
2429 channel_auto_read(&s->req);
2430 channel_auto_close(&s->req);
2431 channel_auto_read(&s->res);
2432
2433
2434 return 1;
2435 }
2436 return 0;
2437}
2438
William Lallemand8a022572018-10-26 14:47:35 +02002439/*
2440 * The mworker functions are used to initialize the CLI in the master process
2441 */
2442
William Lallemand309dc9a2018-10-26 14:47:45 +02002443 /*
2444 * Stop the mworker proxy
2445 */
2446void mworker_cli_proxy_stop()
2447{
William Lallemand550db6d2018-11-06 17:37:12 +01002448 if (mworker_proxy)
2449 stop_proxy(mworker_proxy);
William Lallemand309dc9a2018-10-26 14:47:45 +02002450}
2451
William Lallemand8a022572018-10-26 14:47:35 +02002452/*
2453 * Create the mworker CLI proxy
2454 */
2455int mworker_cli_proxy_create()
2456{
2457 struct mworker_proc *child;
William Lallemand744a0892018-11-22 16:46:51 +01002458 char *msg = NULL;
2459 char *errmsg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002460
2461 mworker_proxy = calloc(1, sizeof(*mworker_proxy));
2462 if (!mworker_proxy)
2463 return -1;
2464
2465 init_new_proxy(mworker_proxy);
2466 mworker_proxy->next = proxies_list;
2467 proxies_list = mworker_proxy;
2468 mworker_proxy->id = strdup("MASTER");
William Lallemandcf62f7e2018-10-26 14:47:40 +02002469 mworker_proxy->mode = PR_MODE_CLI;
William Lallemand8a022572018-10-26 14:47:35 +02002470 mworker_proxy->last_change = now.tv_sec;
2471 mworker_proxy->cap = PR_CAP_LISTEN; /* this is a listen section */
2472 mworker_proxy->maxconn = 10; /* default to 10 concurrent connections */
2473 mworker_proxy->timeout.client = 0; /* no timeout */
2474 mworker_proxy->conf.file = strdup("MASTER");
2475 mworker_proxy->conf.line = 0;
2476 mworker_proxy->accept = frontend_accept;
2477 mworker_proxy-> lbprm.algo = BE_LB_ALGO_NONE;
2478
2479 /* Does not init the default target the CLI applet, but must be done in
2480 * the request parsing code */
2481 mworker_proxy->default_target = NULL;
2482
2483 /* the check_config_validity() will get an ID for the proxy */
2484 mworker_proxy->uuid = -1;
2485
2486 proxy_store_name(mworker_proxy);
2487
2488 /* create all servers using the mworker_proc list */
2489 list_for_each_entry(child, &proc_list, list) {
William Lallemand8a022572018-10-26 14:47:35 +02002490 struct server *newsrv = NULL;
2491 struct sockaddr_storage *sk;
2492 int port1, port2, port;
2493 struct protocol *proto;
William Lallemand8a022572018-10-26 14:47:35 +02002494
William Lallemanda31b09e2020-01-14 15:25:02 +01002495 /* only the workers support the master CLI */
2496 if (!(child->options & PROC_O_TYPE_WORKER))
2497 continue;
2498
William Lallemand8a022572018-10-26 14:47:35 +02002499 newsrv = new_server(mworker_proxy);
2500 if (!newsrv)
William Lallemand744a0892018-11-22 16:46:51 +01002501 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002502
2503 /* we don't know the new pid yet */
2504 if (child->pid == -1)
2505 memprintf(&msg, "cur-%d", child->relative_pid);
2506 else
2507 memprintf(&msg, "old-%d", child->pid);
2508
2509 newsrv->next = mworker_proxy->srv;
2510 mworker_proxy->srv = newsrv;
2511 newsrv->conf.file = strdup(msg);
2512 newsrv->id = strdup(msg);
2513 newsrv->conf.line = 0;
2514
2515 memprintf(&msg, "sockpair@%d", child->ipc_fd[0]);
Willy Tarreau5fc93282020-09-16 18:25:03 +02002516 if ((sk = str2sa_range(msg, &port, &port1, &port2, NULL, &proto,
Willy Tarreaua93e5c72020-09-15 14:01:16 +02002517 &errmsg, NULL, NULL, PA_O_STREAM)) == 0) {
William Lallemand744a0892018-11-22 16:46:51 +01002518 goto error;
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002519 }
2520 free(msg);
2521 msg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002522
Willy Tarreau5fc93282020-09-16 18:25:03 +02002523 if (!proto->connect) {
William Lallemand744a0892018-11-22 16:46:51 +01002524 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002525 }
2526
2527 /* no port specified */
2528 newsrv->flags |= SRV_F_MAPPORTS;
2529 newsrv->addr = *sk;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002530 /* don't let the server participate to load balancing */
2531 newsrv->iweight = 0;
2532 newsrv->uweight = 0;
William Lallemand8a022572018-10-26 14:47:35 +02002533 srv_lb_commit_status(newsrv);
William Lallemand291810d2018-10-26 14:47:38 +02002534
2535 child->srv = newsrv;
William Lallemand8a022572018-10-26 14:47:35 +02002536 }
2537 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002538
2539error:
2540 ha_alert("%s\n", errmsg);
2541
2542 list_for_each_entry(child, &proc_list, list) {
2543 free((char *)child->srv->conf.file); /* cast because of const char * */
2544 free(child->srv->id);
2545 free(child->srv);
2546 child->srv = NULL;
2547 }
2548 free(mworker_proxy->id);
2549 free(mworker_proxy->conf.file);
2550 free(mworker_proxy);
2551 mworker_proxy = NULL;
2552 free(errmsg);
2553 free(msg);
2554
2555 return -1;
William Lallemand8a022572018-10-26 14:47:35 +02002556}
Olivier Houchardf886e342017-04-05 22:24:59 +02002557
William Lallemandce83b4a2018-10-26 14:47:30 +02002558/*
William Lallemande7361152018-10-26 14:47:36 +02002559 * Create a new listener for the master CLI proxy
2560 */
2561int mworker_cli_proxy_new_listener(char *line)
2562{
2563 struct bind_conf *bind_conf;
2564 struct listener *l;
2565 char *err = NULL;
2566 char *args[MAX_LINE_ARGS + 1];
2567 int arg;
2568 int cur_arg;
2569
William Lallemand2e945c82019-11-25 09:58:37 +01002570 arg = 1;
William Lallemande7361152018-10-26 14:47:36 +02002571 args[0] = line;
2572
2573 /* args is a bind configuration with spaces replaced by commas */
2574 while (*line && arg < MAX_LINE_ARGS) {
2575
2576 if (*line == ',') {
2577 *line++ = '\0';
2578 while (*line == ',')
2579 line++;
William Lallemand2e945c82019-11-25 09:58:37 +01002580 args[arg++] = line;
William Lallemande7361152018-10-26 14:47:36 +02002581 }
2582 line++;
2583 }
2584
William Lallemand2e945c82019-11-25 09:58:37 +01002585 args[arg] = "\0";
William Lallemande7361152018-10-26 14:47:36 +02002586
2587 bind_conf = bind_conf_alloc(mworker_proxy, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002588 if (!bind_conf)
2589 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002590
2591 bind_conf->level &= ~ACCESS_LVL_MASK;
2592 bind_conf->level |= ACCESS_LVL_ADMIN;
2593
2594 if (!str2listener(args[0], mworker_proxy, bind_conf, "master-socket", 0, &err)) {
2595 ha_alert("Cannot create the listener of the master CLI\n");
William Lallemand744a0892018-11-22 16:46:51 +01002596 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002597 }
2598
2599 cur_arg = 1;
2600
2601 while (*args[cur_arg]) {
2602 static int bind_dumped;
2603 struct bind_kw *kw;
2604
2605 kw = bind_find_kw(args[cur_arg]);
2606 if (kw) {
2607 if (!kw->parse) {
2608 memprintf(&err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
2609 args[0], args[1], args[cur_arg]);
2610 goto err;
2611 }
2612
2613 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, &err) != 0) {
2614 if (err)
2615 memprintf(&err, "'%s %s' : '%s'", args[0], args[1], err);
2616 else
2617 memprintf(&err, "'%s %s' : error encountered while processing '%s'",
2618 args[0], args[1], args[cur_arg]);
2619 goto err;
2620 }
2621
2622 cur_arg += 1 + kw->skip;
2623 continue;
2624 }
2625
2626 if (!bind_dumped) {
2627 bind_dump_kws(&err);
2628 indent_msg(&err, 4);
2629 bind_dumped = 1;
2630 }
2631
2632 memprintf(&err, "'%s %s' : unknown keyword '%s'.%s%s",
2633 args[0], args[1], args[cur_arg],
2634 err ? " Registered keywords :" : "", err ? err : "");
2635 goto err;
2636 }
2637
2638
2639 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemande7361152018-10-26 14:47:36 +02002640 l->accept = session_accept_fd;
2641 l->default_target = mworker_proxy->default_target;
2642 /* don't make the peers subject to global limits and don't close it in the master */
Willy Tarreau18c20d22020-10-09 16:11:46 +02002643 l->options |= LI_O_UNLIMITED;
2644 l->rx.flags |= RX_F_MWORKER; /* we are keeping this FD in the master */
William Lallemande7361152018-10-26 14:47:36 +02002645 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002646 global.maxsock++; /* for the listening socket */
William Lallemande7361152018-10-26 14:47:36 +02002647 }
Willy Tarreau18215cb2019-02-27 16:25:28 +01002648 global.maxsock += mworker_proxy->maxconn;
William Lallemande7361152018-10-26 14:47:36 +02002649
2650 return 0;
2651
2652err:
2653 ha_alert("%s\n", err);
William Lallemand744a0892018-11-22 16:46:51 +01002654 free(err);
2655 free(bind_conf);
William Lallemande7361152018-10-26 14:47:36 +02002656 return -1;
2657
2658}
2659
2660/*
William Lallemandce83b4a2018-10-26 14:47:30 +02002661 * Create a new CLI socket using a socketpair for a worker process
2662 * <mworker_proc> is the process structure, and <proc> is the process number
2663 */
2664int mworker_cli_sockpair_new(struct mworker_proc *mworker_proc, int proc)
2665{
2666 struct bind_conf *bind_conf;
2667 struct listener *l;
2668 char *path = NULL;
2669 char *err = NULL;
2670
2671 /* master pipe to ensure the master is still alive */
2672 if (socketpair(AF_UNIX, SOCK_STREAM, 0, mworker_proc->ipc_fd) < 0) {
2673 ha_alert("Cannot create worker socketpair.\n");
2674 return -1;
2675 }
2676
2677 /* XXX: we might want to use a separate frontend at some point */
2678 if (!global.stats_fe) {
2679 if ((global.stats_fe = alloc_stats_fe("GLOBAL", "master-socket", 0)) == NULL) {
2680 ha_alert("out of memory trying to allocate the stats frontend");
William Lallemand744a0892018-11-22 16:46:51 +01002681 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002682 }
2683 }
2684
2685 bind_conf = bind_conf_alloc(global.stats_fe, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002686 if (!bind_conf)
2687 goto error;
2688
William Lallemandce83b4a2018-10-26 14:47:30 +02002689 bind_conf->level &= ~ACCESS_LVL_MASK;
2690 bind_conf->level |= ACCESS_LVL_ADMIN; /* TODO: need to lower the rights with a CLI keyword*/
2691
Willy Tarreaue26993c2020-09-03 07:18:55 +02002692 bind_conf->settings.bind_proc = 1UL << proc;
William Lallemandce83b4a2018-10-26 14:47:30 +02002693 global.stats_fe->bind_proc = 0; /* XXX: we should be careful with that, it can be removed by configuration */
2694
2695 if (!memprintf(&path, "sockpair@%d", mworker_proc->ipc_fd[1])) {
2696 ha_alert("Cannot allocate listener.\n");
William Lallemand744a0892018-11-22 16:46:51 +01002697 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002698 }
2699
2700 if (!str2listener(path, global.stats_fe, bind_conf, "master-socket", 0, &err)) {
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002701 free(path);
William Lallemandce83b4a2018-10-26 14:47:30 +02002702 ha_alert("Cannot create a CLI sockpair listener for process #%d\n", proc);
William Lallemand744a0892018-11-22 16:46:51 +01002703 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002704 }
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002705 free(path);
2706 path = NULL;
William Lallemandce83b4a2018-10-26 14:47:30 +02002707
2708 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemandce83b4a2018-10-26 14:47:30 +02002709 l->accept = session_accept_fd;
2710 l->default_target = global.stats_fe->default_target;
William Lallemanda3372292018-11-16 16:57:22 +01002711 l->options |= (LI_O_UNLIMITED | LI_O_NOSTOP);
Willy Tarreau455585e2020-10-09 18:25:14 +02002712 HA_ATOMIC_ADD(&unstoppable_jobs, 1);
William Lallemandce83b4a2018-10-26 14:47:30 +02002713 /* it's a sockpair but we don't want to keep the fd in the master */
Willy Tarreau43046fa2020-09-01 15:41:59 +02002714 l->rx.flags &= ~RX_F_INHERITED;
William Lallemandce83b4a2018-10-26 14:47:30 +02002715 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002716 global.maxsock++; /* for the listening socket */
William Lallemandce83b4a2018-10-26 14:47:30 +02002717 }
2718
2719 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002720
2721error:
2722 close(mworker_proc->ipc_fd[0]);
2723 close(mworker_proc->ipc_fd[1]);
2724 free(err);
2725
2726 return -1;
William Lallemandce83b4a2018-10-26 14:47:30 +02002727}
2728
William Lallemand74c24fb2016-11-21 17:18:36 +01002729static struct applet cli_applet = {
2730 .obj_type = OBJ_TYPE_APPLET,
2731 .name = "<CLI>", /* used for logging */
2732 .fct = cli_io_handler,
2733 .release = cli_release_handler,
2734};
2735
William Lallemand99e0bb92020-11-05 10:28:53 +01002736/* master CLI */
2737static struct applet mcli_applet = {
2738 .obj_type = OBJ_TYPE_APPLET,
2739 .name = "<MCLI>", /* used for logging */
2740 .fct = cli_io_handler,
2741 .release = cli_release_handler,
2742};
2743
Willy Tarreau0a739292016-11-22 20:21:23 +01002744/* register cli keywords */
2745static struct cli_kw_list cli_kws = {{ },{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002746 { { "help", NULL }, NULL, cli_parse_simple, NULL },
2747 { { "prompt", NULL }, NULL, cli_parse_simple, NULL },
2748 { { "quit", NULL }, NULL, cli_parse_simple, NULL },
Willy Tarreau2af99412016-11-23 11:10:59 +01002749 { { "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 +01002750 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002751 { { "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 +01002752 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002753 { { "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 +02002754 { { "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 +01002755 { { "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 +02002756 { { "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 +01002757 { { "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 +01002758 { { "operator", NULL }, "operator : lower the level of the current CLI session to operator", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
2759 { { "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 +02002760 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02002761 { { "expert-mode", NULL }, NULL, cli_parse_expert_mode, NULL }, // not listed
Willy Tarreau0a739292016-11-22 20:21:23 +01002762 {{},}
2763}};
2764
Willy Tarreau0108d902018-11-25 19:14:37 +01002765INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
2766
William Lallemand74c24fb2016-11-21 17:18:36 +01002767static struct cfg_kw_list cfg_kws = {ILH, {
2768 { CFG_GLOBAL, "stats", stats_parse_global },
2769 { 0, NULL, NULL },
2770}};
2771
Willy Tarreau0108d902018-11-25 19:14:37 +01002772INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
2773
William Lallemand74c24fb2016-11-21 17:18:36 +01002774static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02002775 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
2776 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002777 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01002778 { NULL, NULL, 0 },
2779}};
2780
Willy Tarreau0108d902018-11-25 19:14:37 +01002781INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01002782
2783/*
2784 * Local variables:
2785 * c-indent-level: 8
2786 * c-basic-offset: 8
2787 * End:
2788 */