blob: 977d857102788cc662cc3b75d1bee3d3f1ab2f3d [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 Tarreau2eec9b52020-06-04 19:58:55 +020056#include <haproxy/stats-t.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020057#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020058#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020059#include <haproxy/task.h>
Willy Tarreauc2f7c582020-06-02 18:15:32 +020060#include <haproxy/ticks.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020061#include <haproxy/time.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020062#include <haproxy/tools.h>
Willy Tarreaud6788052020-05-27 15:59:00 +020063#include <haproxy/version.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010064
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020065#define PAYLOAD_PATTERN "<<"
66
William Lallemand74c24fb2016-11-21 17:18:36 +010067static struct applet cli_applet;
68
69static const char stats_sock_usage_msg[] =
70 "Unknown command. Please enter one of the following commands only :\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010071 " help : this message\n"
72 " prompt : toggle interactive mode with prompt\n"
73 " quit : disconnect\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010074 "";
75
76static const char stats_permission_denied_msg[] =
77 "Permission denied\n"
78 "";
79
80
Christopher Faulet1bc04c72017-10-29 20:14:08 +010081static THREAD_LOCAL char *dynamic_usage_msg = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +010082
83/* List head of cli keywords */
84static struct cli_kw_list cli_keywords = {
85 .list = LIST_HEAD_INIT(cli_keywords.list)
86};
87
88extern const char *stat_status_codes[];
89
William Lallemand8a022572018-10-26 14:47:35 +020090static struct proxy *mworker_proxy; /* CLI proxy of the master */
91
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020092static char *cli_gen_usage_msg(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +010093{
94 struct cli_kw_list *kw_list;
95 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +020096 struct buffer *tmp = get_trash_chunk();
97 struct buffer out;
William Lallemand74c24fb2016-11-21 17:18:36 +010098
99 free(dynamic_usage_msg);
100 dynamic_usage_msg = NULL;
101
102 if (LIST_ISEMPTY(&cli_keywords.list))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200103 goto end;
William Lallemand74c24fb2016-11-21 17:18:36 +0100104
105 chunk_reset(tmp);
106 chunk_strcat(tmp, stats_sock_usage_msg);
107 list_for_each_entry(kw_list, &cli_keywords.list, list) {
108 kw = &kw_list->kw[0];
William Lallemand0154edc2018-05-15 11:50:04 +0200109 while (kw->str_kw[0]) {
William Lallemand14721be2018-10-26 14:47:37 +0200110
111 /* in a worker or normal process, don't display master only commands */
112 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
113 goto next_kw;
114
115 /* in master don't displays if we don't have the master bits */
116 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
117 goto next_kw;
118
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200119 /* only show expert commands in expert mode */
120 if ((kw->level & ~appctx->cli_level) & ACCESS_EXPERT)
121 goto next_kw;
122
William Lallemand0154edc2018-05-15 11:50:04 +0200123 if (kw->usage)
124 chunk_appendf(tmp, " %s\n", kw->usage);
William Lallemand14721be2018-10-26 14:47:37 +0200125
126next_kw:
127
William Lallemand74c24fb2016-11-21 17:18:36 +0100128 kw++;
129 }
130 }
131 chunk_init(&out, NULL, 0);
132 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200133 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200134
135end:
136 if (dynamic_usage_msg) {
137 appctx->ctx.cli.severity = LOG_INFO;
138 appctx->ctx.cli.msg = dynamic_usage_msg;
139 }
140 else {
141 appctx->ctx.cli.severity = LOG_INFO;
142 appctx->ctx.cli.msg = stats_sock_usage_msg;
143 }
144 appctx->st0 = CLI_ST_PRINT;
145
William Lallemand74c24fb2016-11-21 17:18:36 +0100146 return dynamic_usage_msg;
147}
148
149struct cli_kw* cli_find_kw(char **args)
150{
151 struct cli_kw_list *kw_list;
152 struct cli_kw *kw;/* current cli_kw */
153 char **tmp_args;
154 const char **tmp_str_kw;
155 int found = 0;
156
157 if (LIST_ISEMPTY(&cli_keywords.list))
158 return NULL;
159
160 list_for_each_entry(kw_list, &cli_keywords.list, list) {
161 kw = &kw_list->kw[0];
162 while (*kw->str_kw) {
163 tmp_args = args;
164 tmp_str_kw = kw->str_kw;
165 while (*tmp_str_kw) {
166 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
167 found = 1;
168 } else {
169 found = 0;
170 break;
171 }
172 tmp_args++;
173 tmp_str_kw++;
174 }
175 if (found)
176 return (kw);
177 kw++;
178 }
179 }
180 return NULL;
181}
182
183void cli_register_kw(struct cli_kw_list *kw_list)
184{
185 LIST_ADDQ(&cli_keywords.list, &kw_list->list);
186}
187
188
189/* allocate a new stats frontend named <name>, and return it
190 * (or NULL in case of lack of memory).
191 */
192static struct proxy *alloc_stats_fe(const char *name, const char *file, int line)
193{
194 struct proxy *fe;
195
196 fe = calloc(1, sizeof(*fe));
197 if (!fe)
198 return NULL;
199
200 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100201 fe->next = proxies_list;
202 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100203 fe->last_change = now.tv_sec;
204 fe->id = strdup("GLOBAL");
205 fe->cap = PR_CAP_FE;
206 fe->maxconn = 10; /* default to 10 concurrent connections */
207 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
208 fe->conf.file = strdup(file);
209 fe->conf.line = line;
210 fe->accept = frontend_accept;
211 fe->default_target = &cli_applet.obj_type;
212
213 /* the stats frontend is the only one able to assign ID #0 */
214 fe->conf.id.key = fe->uuid = 0;
215 eb32_insert(&used_proxy_id, &fe->conf.id);
216 return fe;
217}
218
219/* This function parses a "stats" statement in the "global" section. It returns
220 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
221 * error message into the <err> buffer which will be preallocated. The trailing
222 * '\n' must not be written. The function must be called with <args> pointing to
223 * the first word after "stats".
224 */
225static int stats_parse_global(char **args, int section_type, struct proxy *curpx,
226 struct proxy *defpx, const char *file, int line,
227 char **err)
228{
229 struct bind_conf *bind_conf;
230 struct listener *l;
231
232 if (!strcmp(args[1], "socket")) {
233 int cur_arg;
234
235 if (*args[2] == 0) {
236 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
237 return -1;
238 }
239
240 if (!global.stats_fe) {
241 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
242 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
243 return -1;
244 }
245 }
246
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100247 bind_conf = bind_conf_alloc(global.stats_fe, file, line, args[2], xprt_get(XPRT_RAW));
William Lallemand07a62f72017-05-24 00:57:40 +0200248 bind_conf->level &= ~ACCESS_LVL_MASK;
249 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100250
251 if (!str2listener(args[2], global.stats_fe, bind_conf, file, line, err)) {
252 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
253 file, line, args[0], args[1], err && *err ? *err : "error");
254 return -1;
255 }
256
257 cur_arg = 3;
258 while (*args[cur_arg]) {
259 static int bind_dumped;
260 struct bind_kw *kw;
261
262 kw = bind_find_kw(args[cur_arg]);
263 if (kw) {
264 if (!kw->parse) {
265 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
266 args[0], args[1], args[cur_arg]);
267 return -1;
268 }
269
270 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, err) != 0) {
271 if (err && *err)
272 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
273 else
274 memprintf(err, "'%s %s' : error encountered while processing '%s'",
275 args[0], args[1], args[cur_arg]);
276 return -1;
277 }
278
279 cur_arg += 1 + kw->skip;
280 continue;
281 }
282
283 if (!bind_dumped) {
284 bind_dump_kws(err);
285 indent_msg(err, 4);
286 bind_dumped = 1;
287 }
288
289 memprintf(err, "'%s %s' : unknown keyword '%s'.%s%s",
290 args[0], args[1], args[cur_arg],
291 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
292 return -1;
293 }
294
295 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100296 l->accept = session_accept_fd;
William Lallemand74c24fb2016-11-21 17:18:36 +0100297 l->default_target = global.stats_fe->default_target;
298 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
299 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100300 global.maxsock++; /* for the listening socket */
William Lallemand74c24fb2016-11-21 17:18:36 +0100301 }
302 }
303 else if (!strcmp(args[1], "timeout")) {
304 unsigned timeout;
305 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
306
Willy Tarreau9faebe32019-06-07 19:00:37 +0200307 if (res == PARSE_TIME_OVER) {
308 memprintf(err, "timer overflow in argument '%s' to '%s %s' (maximum value is 2147483647 ms or ~24.8 days)",
309 args[2], args[0], args[1]);
310 return -1;
311 }
312 else if (res == PARSE_TIME_UNDER) {
313 memprintf(err, "timer underflow in argument '%s' to '%s %s' (minimum non-null value is 1 ms)",
314 args[2], args[0], args[1]);
315 return -1;
316 }
317 else if (res) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100318 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
319 return -1;
320 }
321
322 if (!timeout) {
323 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
324 return -1;
325 }
326 if (!global.stats_fe) {
327 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
328 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
329 return -1;
330 }
331 }
332 global.stats_fe->timeout.client = MS_TO_TICKS(timeout);
333 }
334 else if (!strcmp(args[1], "maxconn")) {
335 int maxconn = atol(args[2]);
336
337 if (maxconn <= 0) {
338 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
339 return -1;
340 }
341
342 if (!global.stats_fe) {
343 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
344 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
345 return -1;
346 }
347 }
348 global.stats_fe->maxconn = maxconn;
349 }
350 else if (!strcmp(args[1], "bind-process")) { /* enable the socket only on some processes */
351 int cur_arg = 2;
352 unsigned long set = 0;
353
354 if (!global.stats_fe) {
355 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
356 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
357 return -1;
358 }
359 }
360
361 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100362 if (strcmp(args[cur_arg], "all") == 0) {
363 set = 0;
364 break;
365 }
Willy Tarreauff9c9142019-02-07 10:39:36 +0100366 if (parse_process_number(args[cur_arg], &set, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100367 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100368 return -1;
369 }
370 cur_arg++;
371 }
372 global.stats_fe->bind_proc = set;
373 }
374 else {
375 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
376 return -1;
377 }
378 return 0;
379}
380
William Lallemand33d29e22019-04-01 11:30:06 +0200381/*
William Lallemand9a37fd02019-04-12 16:09:24 +0200382 * This function exports the bound addresses of a <frontend> in the environment
383 * variable <varname>. Those addresses are separated by semicolons and prefixed
384 * with their type (abns@, unix@, sockpair@ etc)
385 * Return -1 upon error, 0 otherwise
William Lallemand33d29e22019-04-01 11:30:06 +0200386 */
William Lallemand9a37fd02019-04-12 16:09:24 +0200387int listeners_setenv(struct proxy *frontend, const char *varname)
William Lallemand33d29e22019-04-01 11:30:06 +0200388{
389 struct buffer *trash = get_trash_chunk();
390 struct bind_conf *bind_conf;
391
William Lallemand9a37fd02019-04-12 16:09:24 +0200392 if (frontend) {
393 list_for_each_entry(bind_conf, &frontend->conf.bind, by_fe) {
William Lallemand33d29e22019-04-01 11:30:06 +0200394 struct listener *l;
395
396 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
397 char addr[46];
398 char port[6];
399
William Lallemand620072b2019-04-12 16:09:25 +0200400 /* separate listener by semicolons */
401 if (trash->data)
402 chunk_appendf(trash, ";");
403
Willy Tarreau37159062020-08-27 07:48:42 +0200404 if (l->rx.addr.ss_family == AF_UNIX) {
William Lallemand33d29e22019-04-01 11:30:06 +0200405 const struct sockaddr_un *un;
406
Willy Tarreau37159062020-08-27 07:48:42 +0200407 un = (struct sockaddr_un *)&l->rx.addr;
William Lallemand33d29e22019-04-01 11:30:06 +0200408 if (un->sun_path[0] == '\0') {
409 chunk_appendf(trash, "abns@%s", un->sun_path+1);
410 } else {
411 chunk_appendf(trash, "unix@%s", un->sun_path);
412 }
Willy Tarreau37159062020-08-27 07:48:42 +0200413 } else if (l->rx.addr.ss_family == AF_INET) {
414 addr_to_str(&l->rx.addr, addr, sizeof(addr));
415 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemand33d29e22019-04-01 11:30:06 +0200416 chunk_appendf(trash, "ipv4@%s:%s", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +0200417 } else if (l->rx.addr.ss_family == AF_INET6) {
418 addr_to_str(&l->rx.addr, addr, sizeof(addr));
419 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemand33d29e22019-04-01 11:30:06 +0200420 chunk_appendf(trash, "ipv6@[%s]:%s", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +0200421 } else if (l->rx.addr.ss_family == AF_CUST_SOCKPAIR) {
422 chunk_appendf(trash, "sockpair@%d", ((struct sockaddr_in *)&l->rx.addr)->sin_addr.s_addr);
William Lallemand33d29e22019-04-01 11:30:06 +0200423 }
William Lallemand33d29e22019-04-01 11:30:06 +0200424 }
425 }
426 trash->area[trash->data++] = '\0';
William Lallemand9a37fd02019-04-12 16:09:24 +0200427 if (setenv(varname, trash->area, 1) < 0)
William Lallemand33d29e22019-04-01 11:30:06 +0200428 return -1;
429 }
430
431 return 0;
432}
433
William Lallemand9a37fd02019-04-12 16:09:24 +0200434int cli_socket_setenv()
435{
436 if (listeners_setenv(global.stats_fe, "HAPROXY_CLI") < 0)
437 return -1;
438 if (listeners_setenv(mworker_proxy, "HAPROXY_MASTER_CLI") < 0)
439 return -1;
440
441 return 0;
442}
443
William Lallemand33d29e22019-04-01 11:30:06 +0200444REGISTER_CONFIG_POSTPARSER("cli", cli_socket_setenv);
445
Willy Tarreaude57a572016-11-23 17:01:39 +0100446/* Verifies that the CLI at least has a level at least as high as <level>
447 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
448 * failure, an error message is prepared and the appctx's state is adjusted
449 * to print it so that a return 1 is enough to abort any processing.
450 */
451int cli_has_level(struct appctx *appctx, int level)
452{
Willy Tarreaude57a572016-11-23 17:01:39 +0100453
William Lallemandf630d012018-12-13 09:05:44 +0100454 if ((appctx->cli_level & ACCESS_LVL_MASK) < level) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200455 cli_err(appctx, stats_permission_denied_msg);
Willy Tarreaude57a572016-11-23 17:01:39 +0100456 return 0;
457 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100458 return 1;
459}
460
William Lallemandb7ea1412018-12-13 09:05:47 +0100461/* same as cli_has_level but for the CLI proxy and without error message */
462int pcli_has_level(struct stream *s, int level)
463{
464 if ((s->pcli_flags & ACCESS_LVL_MASK) < level) {
465 return 0;
466 }
467 return 1;
468}
469
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200470/* Returns severity_output for the current session if set, or default for the socket */
471static int cli_get_severity_output(struct appctx *appctx)
472{
473 if (appctx->cli_severity_output)
474 return appctx->cli_severity_output;
475 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
476}
William Lallemand74c24fb2016-11-21 17:18:36 +0100477
Willy Tarreau41908562016-11-24 16:23:38 +0100478/* Processes the CLI interpreter on the stats socket. This function is called
479 * from the CLI's IO handler running in an appctx context. The function returns 1
480 * if the request was understood, otherwise zero. It is called with appctx->st0
481 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
482 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
483 * have its own I/O handler called again. Most of the time, parsers will only
484 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100485 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
486 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100487 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200488static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100489{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200490 char *args[MAX_STATS_ARGS + 1], *p, *end, *payload = NULL;
491 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100492 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100493
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200494 appctx->st2 = 0;
495 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
William Lallemand74c24fb2016-11-21 17:18:36 +0100496
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200497 p = appctx->chunk->area;
498 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100499
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200500 /*
501 * Get the payload start if there is one.
502 * For the sake of simplicity, the payload pattern is looked up
503 * everywhere from the start of the input but it can only be found
504 * at the end of the first line if APPCTX_CLI_ST1_PAYLOAD is set.
505 *
506 * The input string was zero terminated so it is safe to use
507 * the str*() functions throughout the parsing
508 */
509 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
510 payload = strstr(p, PAYLOAD_PATTERN);
511 end = payload;
512 /* skip the pattern */
513 payload += strlen(PAYLOAD_PATTERN);
514 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100515
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200516 /*
517 * Get pointers on words.
518 * One extra slot is reserved to store a pointer on a null byte.
519 */
520 while (i < MAX_STATS_ARGS && p < end) {
521 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100522
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200523 /* skip leading spaces/tabs */
524 p += strspn(p, " \t");
525 if (!*p)
526 break;
William Lallemand74c24fb2016-11-21 17:18:36 +0100527
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200528 args[i] = p;
Yves Lafonb08c6d02020-06-08 16:08:06 +0200529 while (1) {
530 p += strcspn(p, " \t\\");
531 /* escaped chars using backlashes (\) */
532 if (*p == '\\') {
533 if (!*++p)
534 break;
535 if (!*++p)
536 break;
537 } else {
538 break;
539 }
540 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200541 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100542
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200543 /* unescape backslashes (\) */
544 for (j = 0, k = 0; args[i][k]; k++) {
545 if (args[i][k] == '\\') {
546 if (args[i][k + 1] == '\\')
547 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100548 else
549 continue;
550 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200551 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100552 j++;
553 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200554 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100555
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200556 i++;
557 }
558 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200559 p = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200560 for (; i < MAX_STATS_ARGS + 1; i++)
561 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100562
563 kw = cli_find_kw(args);
Willy Tarreaueaffde32016-12-16 17:59:25 +0100564 if (!kw)
Willy Tarreau41908562016-11-24 16:23:38 +0100565 return 0;
566
William Lallemand14721be2018-10-26 14:47:37 +0200567 /* in a worker or normal process, don't display master only commands */
568 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
569 return 0;
570
571 /* in master don't displays if we don't have the master bits */
572 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
573 return 0;
574
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200575 /* only accept expert commands in expert mode */
576 if ((kw->level & ~appctx->cli_level) & ACCESS_EXPERT)
577 return 0;
578
Willy Tarreau41908562016-11-24 16:23:38 +0100579 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200580 appctx->io_release = kw->io_release;
William Lallemand90b098c2019-10-25 21:10:14 +0200581
582 if (kw->parse && kw->parse(args, payload, appctx, kw->private) != 0)
583 goto fail;
584
585 /* kw->parse could set its own io_handler or io_release handler */
586 if (!appctx->io_handler)
587 goto fail;
588
589 appctx->st0 = CLI_ST_CALLBACK;
590 return 1;
591fail:
592 appctx->io_handler = NULL;
593 appctx->io_release = NULL;
Willy Tarreau41908562016-11-24 16:23:38 +0100594 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100595}
596
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200597/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
598static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
599{
Willy Tarreau83061a82018-07-13 11:56:34 +0200600 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200601
602 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200603 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200604
605 tmp = get_trash_chunk();
606 chunk_reset(tmp);
607
608 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100609 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200610 chunk_printf(tmp, "[%d]: ", severity);
611 }
612 else {
613 switch (severity_output) {
614 case CLI_SEVERITY_NUMBER:
615 chunk_printf(tmp, "[%d]: ", severity);
616 break;
617 case CLI_SEVERITY_STRING:
618 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
619 break;
620 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100621 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200622 }
623 }
624 chunk_appendf(tmp, "%s", msg);
625
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200626 return ci_putblk(chn, tmp->area, strlen(tmp->area));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200627}
628
William Lallemand74c24fb2016-11-21 17:18:36 +0100629/* This I/O handler runs as an applet embedded in a stream interface. It is
630 * used to processes I/O from/to the stats unix socket. The system relies on a
631 * state machine handling requests and various responses. We read a request,
632 * then we process it and send the response, and we possibly display a prompt.
633 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100634 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100635 * or not.
636 */
637static void cli_io_handler(struct appctx *appctx)
638{
639 struct stream_interface *si = appctx->owner;
640 struct channel *req = si_oc(si);
641 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200642 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100643 int reql;
644 int len;
645
646 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
647 goto out;
648
Joseph Herlant008b3ce2018-11-25 12:51:45 -0800649 /* Check if the input buffer is available. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200650 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +0100651 /* buf.size==0 means we failed to get a buffer and were
652 * already subscribed to a wait list to get a buffer.
653 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100654 goto out;
655 }
656
William Lallemand74c24fb2016-11-21 17:18:36 +0100657 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100658 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100659 /* Stats output not initialized yet */
660 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200661 /* reset severity to default at init */
662 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100663 appctx->st0 = CLI_ST_GETREQ;
William Lallemandf630d012018-12-13 09:05:44 +0100664 appctx->cli_level = bind_conf->level;
William Lallemand74c24fb2016-11-21 17:18:36 +0100665 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100666 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100667 /* Let's close for real now. We just close the request
668 * side, the conditions below will complete if needed.
669 */
670 si_shutw(si);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200671 free_trash_chunk(appctx->chunk);
William Lallemand74c24fb2016-11-21 17:18:36 +0100672 break;
673 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100674 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200675 char *str;
676
677 /* use a trash chunk to store received data */
678 if (!appctx->chunk) {
679 appctx->chunk = alloc_trash_chunk();
680 if (!appctx->chunk) {
681 appctx->st0 = CLI_ST_END;
682 continue;
683 }
684 }
685
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200686 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200687
William Lallemand74c24fb2016-11-21 17:18:36 +0100688 /* ensure we have some output room left in the event we
689 * would want to return some info right after parsing.
690 */
691 if (buffer_almost_full(si_ib(si))) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100692 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100693 break;
694 }
695
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200696 /* '- 1' is to ensure a null byte can always be inserted at the end */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200697 reql = co_getline(si_oc(si), str,
698 appctx->chunk->size - appctx->chunk->data - 1);
William Lallemand74c24fb2016-11-21 17:18:36 +0100699 if (reql <= 0) { /* closed or EOL not found */
700 if (reql == 0)
701 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100702 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100703 continue;
704 }
705
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200706 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
707 /* seek for a possible unescaped semi-colon. If we find
708 * one, we replace it with an LF and skip only this part.
709 */
710 for (len = 0; len < reql; len++) {
711 if (str[len] == '\\') {
712 len++;
713 continue;
714 }
715 if (str[len] == ';') {
716 str[len] = '\n';
717 reql = len + 1;
718 break;
719 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100720 }
721 }
722
723 /* now it is time to check that we have a full line,
724 * remove the trailing \n and possibly \r, then cut the
725 * line.
726 */
727 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200728 if (str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100729 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100730 continue;
731 }
732
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200733 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100734 len--;
735
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200736 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200737 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200738
739 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200740 appctx->chunk->area[appctx->chunk->data] = '\n';
741 appctx->chunk->area[appctx->chunk->data + 1] = 0;
742 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200743 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100744
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100745 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200746
747 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
748 /* empty line */
749 if (!len) {
750 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200751 appctx->chunk->data -= 2;
752 appctx->chunk->area[appctx->chunk->data] = 0;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200753
754 if (!cli_parse_request(appctx))
755 cli_gen_usage_msg(appctx);
756
757 chunk_reset(appctx->chunk);
758 /* NB: cli_sock_parse_request() may have put
759 * another CLI_ST_O_* into appctx->st0.
760 */
761
762 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +0100763 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100764 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200765 else {
766 /*
767 * Look for the "payload start" pattern at the end of a line
768 * Its location is not remembered here, this is just to switch
769 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +0100770 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200771 if (!strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200772 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200773 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200774 /* no payload, the command is complete: parse the request */
775 if (!cli_parse_request(appctx))
776 cli_gen_usage_msg(appctx);
777
778 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200779 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100780 }
781
782 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200783 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100784 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
785 }
786 else { /* output functions */
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200787 const char *msg;
788 int sev;
789
William Lallemand74c24fb2016-11-21 17:18:36 +0100790 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100791 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100792 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200793 case CLI_ST_PRINT: /* print const message in msg */
794 case CLI_ST_PRINT_ERR: /* print const error in msg */
795 case CLI_ST_PRINT_DYN: /* print dyn message in msg, free */
796 case CLI_ST_PRINT_FREE: /* print dyn error in err, free */
797 if (appctx->st0 == CLI_ST_PRINT || appctx->st0 == CLI_ST_PRINT_ERR) {
798 sev = appctx->st0 == CLI_ST_PRINT_ERR ?
799 LOG_ERR : appctx->ctx.cli.severity;
800 msg = appctx->ctx.cli.msg;
801 }
802 else if (appctx->st0 == CLI_ST_PRINT_DYN || appctx->st0 == CLI_ST_PRINT_FREE) {
803 sev = appctx->st0 == CLI_ST_PRINT_FREE ?
804 LOG_ERR : appctx->ctx.cli.severity;
805 msg = appctx->ctx.cli.err;
806 if (!msg) {
807 sev = LOG_ERR;
808 msg = "Out of memory.\n";
809 }
810 }
811 else {
812 sev = LOG_ERR;
813 msg = "Internal error.\n";
814 }
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200815
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200816 if (cli_output_msg(res, msg, sev, cli_get_severity_output(appctx)) != -1) {
817 if (appctx->st0 == CLI_ST_PRINT_FREE ||
818 appctx->st0 == CLI_ST_PRINT_DYN) {
819 free(appctx->ctx.cli.err);
820 appctx->ctx.cli.err = NULL;
821 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100822 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100823 }
824 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100825 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100826 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200827
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100828 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100829 if (appctx->io_handler)
830 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100831 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100832 if (appctx->io_release) {
833 appctx->io_release(appctx);
834 appctx->io_release = NULL;
835 }
836 }
837 break;
838 default: /* abnormal state */
839 si->flags |= SI_FL_ERR;
840 break;
841 }
842
843 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100844 if (appctx->st0 == CLI_ST_PROMPT) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200845 const char *prompt = "";
846
847 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
848 /*
849 * when entering a payload with interactive mode, change the prompt
850 * to emphasize that more data can still be sent
851 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200852 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200853 prompt = "+ ";
854 else
855 prompt = "\n> ";
856 }
857 else {
William Lallemandad032882019-07-01 10:56:15 +0200858 if (!(appctx->st1 & (APPCTX_CLI_ST1_PAYLOAD|APPCTX_CLI_ST1_NOLF)))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200859 prompt = "\n";
860 }
861
862 if (ci_putstr(si_ic(si), prompt) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100863 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100864 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100865 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100866 }
867
868 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100869 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100870 break;
871
872 /* Now we close the output if one of the writers did so,
873 * or if we're not in interactive mode and the request
874 * buffer is empty. This still allows pipelined requests
875 * to be sent in non-interactive mode.
876 */
William Lallemand3de09d52018-12-11 16:10:56 +0100877 if (((res->flags & (CF_SHUTW|CF_SHUTW_NOW))) ||
878 (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req) && (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)))) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100879 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100880 continue;
881 }
882
883 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100884 appctx->st0 = CLI_ST_GETREQ;
William Lallemandad032882019-07-01 10:56:15 +0200885 /* reactivate the \n at the end of the response for the next command */
886 appctx->st1 &= ~APPCTX_CLI_ST1_NOLF;
William Lallemand74c24fb2016-11-21 17:18:36 +0100887 }
888 }
889
890 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
891 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
892 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
893 /* Other side has closed, let's abort if we have no more processing to do
894 * and nothing more to consume. This is comparable to a broken pipe, so
895 * we forward the close to the request side so that it flows upstream to
896 * the client.
897 */
898 si_shutw(si);
899 }
900
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100901 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100902 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
903 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
904 /* We have no more processing to do, and nothing more to send, and
905 * the client side has closed. So we'll forward this state downstream
906 * on the response buffer.
907 */
908 si_shutr(si);
909 res->flags |= CF_READ_NULL;
910 }
911
912 out:
Christopher Faulet45073512018-07-20 10:16:29 +0200913 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 +0100914 __FUNCTION__, __LINE__,
Christopher Faulet45073512018-07-20 10:16:29 +0200915 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 +0100916}
917
William Lallemand74c24fb2016-11-21 17:18:36 +0100918/* This is called when the stream interface is closed. For instance, upon an
919 * external abort, we won't call the i/o handler anymore so we may need to
920 * remove back references to the stream currently being dumped.
921 */
922static void cli_release_handler(struct appctx *appctx)
923{
924 if (appctx->io_release) {
925 appctx->io_release(appctx);
926 appctx->io_release = NULL;
927 }
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200928 else if (appctx->st0 == CLI_ST_PRINT_FREE || appctx->st0 == CLI_ST_PRINT_DYN) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100929 free(appctx->ctx.cli.err);
930 appctx->ctx.cli.err = NULL;
931 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100932}
933
934/* This function dumps all environmnent variables to the buffer. It returns 0
935 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +0100936 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
937 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +0100938 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100939static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100940{
Willy Tarreau0a739292016-11-22 20:21:23 +0100941 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100942 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100943
944 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
945 return 1;
946
947 chunk_reset(&trash);
948
949 /* we have two inner loops here, one for the proxy, the other one for
950 * the buffer.
951 */
Willy Tarreauf6710f82016-12-16 17:45:44 +0100952 while (*var) {
953 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +0100954
Willy Tarreau06d80a92017-10-19 14:32:15 +0200955 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100956 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100957 return 0;
958 }
959 if (appctx->st2 == STAT_ST_END)
960 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100961 var++;
962 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +0100963 }
964
965 /* dump complete */
966 return 1;
967}
968
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200969/* This function dumps all file descriptors states (or the requested one) to
970 * the buffer. It returns 0 if the output buffer is full and it needs to be
971 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
972 * It uses cli.i0 as the fd number to restart from.
973 */
974static int cli_io_handler_show_fd(struct appctx *appctx)
975{
976 struct stream_interface *si = appctx->owner;
977 int fd = appctx->ctx.cli.i0;
Willy Tarreauca1b1572018-12-18 15:45:11 +0100978 int ret = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200979
980 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
Willy Tarreauca1b1572018-12-18 15:45:11 +0100981 goto end;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200982
983 chunk_reset(&trash);
984
Willy Tarreauca1b1572018-12-18 15:45:11 +0100985 /* isolate the threads once per round. We're limited to a buffer worth
986 * of output anyway, it cannot last very long.
987 */
988 thread_isolate();
989
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200990 /* we have two inner loops here, one for the proxy, the other one for
991 * the buffer.
992 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +0100993 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200994 struct fdtab fdt;
Willy Tarreau286ec682017-08-09 16:35:44 +0200995 struct listener *li = NULL;
996 struct server *sv = NULL;
997 struct proxy *px = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +0200998 const struct mux_ops *mux = NULL;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200999 void *ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +02001000 uint32_t conn_flags = 0;
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001001 int is_back = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001002
1003 fdt = fdtab[fd];
1004
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001005 /* When DEBUG_FD is set, we also report closed FDs that have a
1006 * non-null event count to detect stuck ones.
1007 */
Willy Tarreau13c1a012020-06-29 14:23:31 +02001008 if (!fdt.owner) {
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001009#ifdef DEBUG_FD
Willy Tarreau13c1a012020-06-29 14:23:31 +02001010 if (!fdt.event_count)
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001011#endif
Willy Tarreau13c1a012020-06-29 14:23:31 +02001012 goto skip; // closed
1013 }
1014 else if (fdt.iocb == conn_fd_handler) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001015 conn_flags = ((struct connection *)fdt.owner)->flags;
Willy Tarreau35b1b482018-03-28 18:41:30 +02001016 mux = ((struct connection *)fdt.owner)->mux;
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001017 ctx = ((struct connection *)fdt.owner)->ctx;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001018 li = objt_listener(((struct connection *)fdt.owner)->target);
1019 sv = objt_server(((struct connection *)fdt.owner)->target);
1020 px = objt_proxy(((struct connection *)fdt.owner)->target);
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001021 is_back = conn_is_back((struct connection *)fdt.owner);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001022 }
1023 else if (fdt.iocb == listener_accept)
1024 li = fdt.owner;
1025
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001026 chunk_printf(&trash,
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001027 " %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 +02001028 fd,
1029 fdt.state,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001030 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
1031 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001032 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
1033 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
1034 fdt.ev,
1035 (fdt.ev & FD_POLL_HUP) ? 'H' : 'h',
1036 (fdt.ev & FD_POLL_ERR) ? 'E' : 'e',
1037 (fdt.ev & FD_POLL_OUT) ? 'O' : 'o',
1038 (fdt.ev & FD_POLL_PRI) ? 'P' : 'p',
1039 (fdt.ev & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001040 fdt.linger_risk ? 'L' : 'l',
1041 fdt.cloned ? 'C' : 'c',
Willy Tarreauc754b342018-03-30 15:00:15 +02001042 fdt.thread_mask, fdt.update_mask,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001043 fdt.owner,
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001044 fdt.iocb);
1045 resolve_sym_name(&trash, NULL, fdt.iocb);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001046
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001047 if (!fdt.owner) {
1048 chunk_appendf(&trash, ")");
1049 }
1050 else if (fdt.iocb == conn_fd_handler) {
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001051 chunk_appendf(&trash, ") back=%d cflg=0x%08x", is_back, conn_flags);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001052 if (px)
1053 chunk_appendf(&trash, " px=%s", px->id);
1054 else if (sv)
1055 chunk_appendf(&trash, " sv=%s/%s", sv->id, sv->proxy->id);
1056 else if (li)
1057 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +02001058
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001059 if (mux) {
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001060 chunk_appendf(&trash, " mux=%s ctx=%p", mux->name, ctx);
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001061 if (mux->show_fd)
1062 mux->show_fd(&trash, fdt.owner);
1063 }
Willy Tarreau35b1b482018-03-28 18:41:30 +02001064 else
1065 chunk_appendf(&trash, " nomux");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001066 }
1067 else if (fdt.iocb == listener_accept) {
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001068 chunk_appendf(&trash, ") l.st=%s fe=%s",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001069 listener_state_str(li),
1070 li->bind_conf->frontend->id);
1071 }
1072
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001073#ifdef DEBUG_FD
1074 chunk_appendf(&trash, " evcnt=%u", fdtab[fd].event_count);
1075#endif
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001076 chunk_appendf(&trash, ")\n");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001077
Willy Tarreau06d80a92017-10-19 14:32:15 +02001078 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001079 si_rx_room_blk(si);
Willy Tarreauca1b1572018-12-18 15:45:11 +01001080 appctx->ctx.cli.i0 = fd;
1081 ret = 0;
1082 break;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001083 }
1084 skip:
1085 if (appctx->st2 == STAT_ST_END)
1086 break;
1087
1088 fd++;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001089 }
1090
Willy Tarreauca1b1572018-12-18 15:45:11 +01001091 end:
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001092 /* dump complete */
Willy Tarreauca1b1572018-12-18 15:45:11 +01001093
1094 thread_release();
1095 return ret;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001096}
1097
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001098/* This function dumps some activity counters used by developers and support to
1099 * rule out some hypothesis during bug reports. It returns 0 if the output
1100 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
1101 * everything at once in the buffer and is not designed to do it in multiple
1102 * passes.
1103 */
1104static int cli_io_handler_show_activity(struct appctx *appctx)
1105{
1106 struct stream_interface *si = appctx->owner;
1107 int thr;
1108
1109 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1110 return 1;
1111
1112 chunk_reset(&trash);
1113
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001114#undef SHOW_TOT
1115#define SHOW_TOT(t, x) \
Willy Tarreaua0211b82019-05-28 15:09:08 +02001116 do { \
1117 unsigned int _v[MAX_THREADS]; \
1118 unsigned int _tot; \
1119 const unsigned int _nbt = global.nbthread; \
1120 for (_tot = t = 0; t < _nbt; t++) \
1121 _tot += _v[t] = (x); \
1122 if (_nbt == 1) { \
1123 chunk_appendf(&trash, " %u\n", _tot); \
1124 break; \
1125 } \
1126 chunk_appendf(&trash, " %u [", _tot); \
1127 for (t = 0; t < _nbt; t++) \
1128 chunk_appendf(&trash, " %u", _v[t]); \
1129 chunk_appendf(&trash, " ]\n"); \
1130 } while (0)
1131
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001132#undef SHOW_AVG
1133#define SHOW_AVG(t, x) \
1134 do { \
1135 unsigned int _v[MAX_THREADS]; \
1136 unsigned int _tot; \
1137 const unsigned int _nbt = global.nbthread; \
1138 for (_tot = t = 0; t < _nbt; t++) \
1139 _tot += _v[t] = (x); \
1140 if (_nbt == 1) { \
1141 chunk_appendf(&trash, " %u\n", _tot); \
1142 break; \
1143 } \
1144 chunk_appendf(&trash, " %u [", (_tot + _nbt/2) / _nbt); \
1145 for (t = 0; t < _nbt; t++) \
1146 chunk_appendf(&trash, " %u", _v[t]); \
1147 chunk_appendf(&trash, " ]\n"); \
1148 } while (0)
1149
Willy Tarreaua0211b82019-05-28 15:09:08 +02001150 chunk_appendf(&trash, "thread_id: %u (%u..%u)\n", tid + 1, 1, global.nbthread);
1151 chunk_appendf(&trash, "date_now: %lu.%06lu\n", (long)now.tv_sec, (long)now.tv_usec);
Willy Tarreaua00cf9b2020-06-17 20:44:28 +02001152 chunk_appendf(&trash, "ctxsw:"); SHOW_TOT(thr, activity[thr].ctxsw);
1153 chunk_appendf(&trash, "tasksw:"); SHOW_TOT(thr, activity[thr].tasksw);
1154 chunk_appendf(&trash, "empty_rq:"); SHOW_TOT(thr, activity[thr].empty_rq);
1155 chunk_appendf(&trash, "long_rq:"); SHOW_TOT(thr, activity[thr].long_rq);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001156 chunk_appendf(&trash, "loops:"); SHOW_TOT(thr, activity[thr].loops);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001157 chunk_appendf(&trash, "wake_tasks:"); SHOW_TOT(thr, activity[thr].wake_tasks);
1158 chunk_appendf(&trash, "wake_signal:"); SHOW_TOT(thr, activity[thr].wake_signal);
Willy Tarreaue5451532020-06-17 20:25:18 +02001159 chunk_appendf(&trash, "poll_io:"); SHOW_TOT(thr, activity[thr].poll_io);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001160 chunk_appendf(&trash, "poll_exp:"); SHOW_TOT(thr, activity[thr].poll_exp);
Willy Tarreaue4063862020-06-17 20:35:33 +02001161 chunk_appendf(&trash, "poll_drop_fd:"); SHOW_TOT(thr, activity[thr].poll_drop_fd);
1162 chunk_appendf(&trash, "poll_dead_fd:"); SHOW_TOT(thr, activity[thr].poll_dead_fd);
1163 chunk_appendf(&trash, "poll_skip_fd:"); SHOW_TOT(thr, activity[thr].poll_skip_fd);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001164 chunk_appendf(&trash, "conn_dead:"); SHOW_TOT(thr, activity[thr].conn_dead);
Willy Tarreau7af4fa92020-06-17 20:49:49 +02001165 chunk_appendf(&trash, "stream_calls:"); SHOW_TOT(thr, activity[thr].stream_calls);
Willy Tarreaua8b2ce02019-05-28 17:04:16 +02001166 chunk_appendf(&trash, "pool_fail:"); SHOW_TOT(thr, activity[thr].pool_fail);
1167 chunk_appendf(&trash, "buf_wait:"); SHOW_TOT(thr, activity[thr].buf_wait);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001168 chunk_appendf(&trash, "cpust_ms_tot:"); SHOW_TOT(thr, activity[thr].cpust_total / 2);
1169 chunk_appendf(&trash, "cpust_ms_1s:"); SHOW_TOT(thr, read_freq_ctr(&activity[thr].cpust_1s) / 2);
1170 chunk_appendf(&trash, "cpust_ms_15s:"); SHOW_TOT(thr, read_freq_ctr_period(&activity[thr].cpust_15s, 15000) / 2);
1171 chunk_appendf(&trash, "avg_loop_us:"); SHOW_AVG(thr, swrate_avg(activity[thr].avg_loop_us, TIME_STATS_SAMPLES));
1172 chunk_appendf(&trash, "accepted:"); SHOW_TOT(thr, activity[thr].accepted);
1173 chunk_appendf(&trash, "accq_pushed:"); SHOW_TOT(thr, activity[thr].accq_pushed);
1174 chunk_appendf(&trash, "accq_full:"); SHOW_TOT(thr, activity[thr].accq_full);
Willy Tarreaue6182842019-04-15 18:54:10 +02001175#ifdef USE_THREAD
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001176 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 +02001177 chunk_appendf(&trash, "fd_takeover:"); SHOW_TOT(thr, activity[thr].fd_takeover);
Willy Tarreaue6182842019-04-15 18:54:10 +02001178#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001179
Willy Tarreaud6a78502019-05-27 07:03:38 +02001180#if defined(DEBUG_DEV)
1181 /* keep these ones at the end */
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001182 chunk_appendf(&trash, "ctr0:"); SHOW_TOT(thr, activity[thr].ctr0);
1183 chunk_appendf(&trash, "ctr1:"); SHOW_TOT(thr, activity[thr].ctr1);
1184 chunk_appendf(&trash, "ctr2:"); SHOW_TOT(thr, activity[thr].ctr2);
Willy Tarreaud6a78502019-05-27 07:03:38 +02001185#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001186
1187 if (ci_putchk(si_ic(si), &trash) == -1) {
1188 chunk_reset(&trash);
1189 chunk_printf(&trash, "[output too large, cannot dump]\n");
Willy Tarreaudb398432018-11-15 11:08:52 +01001190 si_rx_room_blk(si);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001191 }
1192
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001193#undef SHOW_AVG
1194#undef SHOW_TOT
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001195 /* dump complete */
1196 return 1;
1197}
1198
William Lallemandeceddf72016-12-15 18:06:44 +01001199/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001200 * CLI IO handler for `show cli sockets`.
1201 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +01001202 */
1203static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1204{
1205 struct bind_conf *bind_conf;
1206 struct stream_interface *si = appctx->owner;
1207
1208 chunk_reset(&trash);
1209
1210 switch (appctx->st2) {
1211 case STAT_ST_INIT:
1212 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +02001213 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001214 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001215 return 0;
1216 }
William Lallemandeceddf72016-12-15 18:06:44 +01001217 appctx->st2 = STAT_ST_LIST;
Tim Duesterhus588b3142020-05-29 14:35:51 +02001218 /* fall through */
William Lallemandeceddf72016-12-15 18:06:44 +01001219
1220 case STAT_ST_LIST:
1221 if (global.stats_fe) {
1222 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
1223 struct listener *l;
1224
1225 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001226 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +01001227 * if the current node is the first of the list
1228 */
1229
Willy Tarreau3af9d832016-12-16 12:58:09 +01001230 if (appctx->ctx.cli.p0 &&
1231 &bind_conf->by_fe == (&global.stats_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +01001232 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +01001233 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +01001234 continue;
1235 }
1236
1237 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
1238
1239 char addr[46];
1240 char port[6];
1241
Willy Tarreau37159062020-08-27 07:48:42 +02001242 if (l->rx.addr.ss_family == AF_UNIX) {
William Lallemandeceddf72016-12-15 18:06:44 +01001243 const struct sockaddr_un *un;
1244
Willy Tarreau37159062020-08-27 07:48:42 +02001245 un = (struct sockaddr_un *)&l->rx.addr;
William Lallemande58915f2019-04-01 11:30:05 +02001246 if (un->sun_path[0] == '\0') {
William Lallemand75812a72019-04-01 11:30:04 +02001247 chunk_appendf(&trash, "abns@%s ", un->sun_path+1);
William Lallemande58915f2019-04-01 11:30:05 +02001248 } else {
1249 chunk_appendf(&trash, "unix@%s ", un->sun_path);
1250 }
Willy Tarreau37159062020-08-27 07:48:42 +02001251 } else if (l->rx.addr.ss_family == AF_INET) {
1252 addr_to_str(&l->rx.addr, addr, sizeof(addr));
1253 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001254 chunk_appendf(&trash, "ipv4@%s:%s ", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +02001255 } else if (l->rx.addr.ss_family == AF_INET6) {
1256 addr_to_str(&l->rx.addr, addr, sizeof(addr));
1257 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001258 chunk_appendf(&trash, "ipv6@[%s]:%s ", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +02001259 } else if (l->rx.addr.ss_family == AF_CUST_SOCKPAIR) {
1260 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->rx.addr)->sin_addr.s_addr);
William Lallemandeceddf72016-12-15 18:06:44 +01001261 } else
William Lallemand26314342018-10-26 14:47:41 +02001262 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001263
William Lallemand07a62f72017-05-24 00:57:40 +02001264 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +01001265 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +02001266 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1267 chunk_appendf(&trash, "operator ");
1268 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1269 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +01001270 else
1271 chunk_appendf(&trash, " ");
1272
Willy Tarreaue26993c2020-09-03 07:18:55 +02001273 if (bind_conf->settings.bind_proc != 0) {
William Lallemandeceddf72016-12-15 18:06:44 +01001274 int pos;
Willy Tarreaue26993c2020-09-03 07:18:55 +02001275 for (pos = 0; pos < 8 * sizeof(bind_conf->settings.bind_proc); pos++) {
1276 if (bind_conf->settings.bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +01001277 chunk_appendf(&trash, "%d,", pos+1);
1278 }
1279 }
1280 /* replace the latest comma by a newline */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001281 trash.area[trash.data-1] = '\n';
William Lallemandeceddf72016-12-15 18:06:44 +01001282
1283 } else {
1284 chunk_appendf(&trash, "all\n");
1285 }
1286
Willy Tarreau06d80a92017-10-19 14:32:15 +02001287 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001288 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001289 return 0;
1290 }
1291 }
Willy Tarreau3af9d832016-12-16 12:58:09 +01001292 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001293 }
1294 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02001295 /* fall through */
William Lallemandeceddf72016-12-15 18:06:44 +01001296 default:
1297 appctx->st2 = STAT_ST_FIN;
1298 return 1;
1299 }
1300}
1301
1302
Willy Tarreau0a739292016-11-22 20:21:23 +01001303/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001304 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1305 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001306 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001307static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001308{
1309 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001310 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001311
1312 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1313 return 1;
1314
Willy Tarreauf6710f82016-12-16 17:45:44 +01001315 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001316
1317 if (*args[2]) {
1318 int len = strlen(args[2]);
1319
Willy Tarreauf6710f82016-12-16 17:45:44 +01001320 for (; *var; var++) {
1321 if (strncmp(*var, args[2], len) == 0 &&
1322 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001323 break;
1324 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001325 if (!*var)
1326 return cli_err(appctx, "Variable not found\n");
1327
Willy Tarreau0a739292016-11-22 20:21:23 +01001328 appctx->st2 = STAT_ST_END;
1329 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001330 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001331 return 0;
1332}
1333
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001334/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1335 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1336 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1337 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001338static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001339{
1340 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1341 return 1;
1342
1343 appctx->ctx.cli.i0 = 0;
1344
1345 if (*args[2]) {
1346 appctx->ctx.cli.i0 = atoi(args[2]);
1347 appctx->st2 = STAT_ST_END;
1348 }
1349 return 0;
1350}
1351
Willy Tarreau599852e2016-11-22 20:33:32 +01001352/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001353static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001354{
1355 struct stream_interface *si = appctx->owner;
1356 struct stream *s = si_strm(si);
1357
1358 if (strcmp(args[2], "cli") == 0) {
1359 unsigned timeout;
1360 const char *res;
1361
Willy Tarreau9d008692019-08-09 11:21:01 +02001362 if (!*args[3])
1363 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001364
1365 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
Willy Tarreau9d008692019-08-09 11:21:01 +02001366 if (res || timeout < 1)
1367 return cli_err(appctx, "Invalid timeout value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001368
1369 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1370 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1371 return 1;
1372 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001373
1374 return cli_err(appctx, "'set timeout' only supports 'cli'.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001375}
1376
Willy Tarreau2af99412016-11-23 11:10:59 +01001377/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001378static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001379{
1380 int v;
1381
1382 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1383 return 1;
1384
Willy Tarreau9d008692019-08-09 11:21:01 +02001385 if (!*args[3])
1386 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001387
1388 v = atoi(args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001389 if (v > global.hardmaxconn)
1390 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001391
1392 /* check for unlimited values */
1393 if (v <= 0)
1394 v = global.hardmaxconn;
1395
1396 global.maxconn = v;
1397
1398 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001399 dequeue_all_listeners();
Willy Tarreau2af99412016-11-23 11:10:59 +01001400
1401 return 1;
1402}
1403
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001404static int set_severity_output(int *target, char *argument)
1405{
1406 if (!strcmp(argument, "none")) {
1407 *target = CLI_SEVERITY_NONE;
1408 return 1;
1409 }
1410 else if (!strcmp(argument, "number")) {
1411 *target = CLI_SEVERITY_NUMBER;
1412 return 1;
1413 }
1414 else if (!strcmp(argument, "string")) {
1415 *target = CLI_SEVERITY_STRING;
1416 return 1;
1417 }
1418 return 0;
1419}
1420
1421/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001422static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001423{
1424 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1425 return 0;
1426
Willy Tarreau9d008692019-08-09 11:21:01 +02001427 return cli_err(appctx, "one of 'none', 'number', 'string' is a required argument\n");
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001428}
William Lallemandeceddf72016-12-15 18:06:44 +01001429
William Lallemand67a234f2018-12-13 09:05:45 +01001430
1431/* show the level of the current CLI session */
1432static int cli_parse_show_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1433{
William Lallemand67a234f2018-12-13 09:05:45 +01001434 if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
Willy Tarreau9d008692019-08-09 11:21:01 +02001435 return cli_msg(appctx, LOG_INFO, "admin\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001436 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001437 return cli_msg(appctx, LOG_INFO, "operator\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001438 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001439 return cli_msg(appctx, LOG_INFO, "user\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001440 else
Willy Tarreau9d008692019-08-09 11:21:01 +02001441 return cli_msg(appctx, LOG_INFO, "unknown\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001442}
1443
1444/* parse and set the CLI level dynamically */
1445static int cli_parse_set_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1446{
William Lallemandad032882019-07-01 10:56:15 +02001447 /* this will ask the applet to not output a \n after the command */
1448 if (!strcmp(args[1], "-"))
1449 appctx->st1 |= APPCTX_CLI_ST1_NOLF;
1450
William Lallemand67a234f2018-12-13 09:05:45 +01001451 if (!strcmp(args[0], "operator")) {
1452 if (!cli_has_level(appctx, ACCESS_LVL_OPER)) {
1453 return 1;
1454 }
1455 appctx->cli_level &= ~ACCESS_LVL_MASK;
1456 appctx->cli_level |= ACCESS_LVL_OPER;
1457
1458 } else if (!strcmp(args[0], "user")) {
1459 if (!cli_has_level(appctx, ACCESS_LVL_USER)) {
1460 return 1;
1461 }
1462 appctx->cli_level &= ~ACCESS_LVL_MASK;
1463 appctx->cli_level |= ACCESS_LVL_USER;
1464 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001465 appctx->cli_level &= ~ACCESS_EXPERT;
1466 return 1;
1467}
1468
1469
1470/* parse and set the CLI expert-mode dynamically */
1471static int cli_parse_expert_mode(char **args, char *payload, struct appctx *appctx, void *private)
1472{
1473 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1474 return 1;
1475
1476 if (!*args[1])
1477 return (appctx->cli_level & ACCESS_EXPERT)
1478 ? cli_msg(appctx, LOG_INFO, "expert-mode is ON\n")
1479 : cli_msg(appctx, LOG_INFO, "expert-mode is OFF\n");
1480
1481 appctx->cli_level &= ~ACCESS_EXPERT;
1482 if (strcmp(args[1], "on") == 0)
1483 appctx->cli_level |= ACCESS_EXPERT;
William Lallemand67a234f2018-12-13 09:05:45 +01001484 return 1;
1485}
1486
William Lallemanda57b7e32018-12-14 21:11:31 +01001487
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001488int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001489{
1490 return 0;
1491}
1492
Willy Tarreau45c742b2016-11-24 14:51:17 +01001493/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001494static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001495{
1496 int v;
1497 int *res;
1498 int mul = 1;
1499
1500 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1501 return 1;
1502
1503 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1504 res = &global.cps_lim;
1505 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1506 res = &global.sps_lim;
1507#ifdef USE_OPENSSL
1508 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1509 res = &global.ssl_lim;
1510#endif
1511 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1512 res = &global.comp_rate_lim;
1513 mul = 1024;
1514 }
1515 else {
Willy Tarreau9d008692019-08-09 11:21:01 +02001516 return cli_err(appctx,
Willy Tarreau45c742b2016-11-24 14:51:17 +01001517 "'set rate-limit' only supports :\n"
1518 " - 'connections global' to set the per-process maximum connection rate\n"
1519 " - 'sessions global' to set the per-process maximum session rate\n"
1520#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001521 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001522#endif
Willy Tarreau9d008692019-08-09 11:21:01 +02001523 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001524 }
1525
Willy Tarreau9d008692019-08-09 11:21:01 +02001526 if (!*args[4])
1527 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001528
1529 v = atoi(args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001530 if (v < 0)
1531 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001532
1533 *res = v * mul;
1534
1535 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001536 dequeue_all_listeners();
Willy Tarreau45c742b2016-11-24 14:51:17 +01001537
1538 return 1;
1539}
1540
William Lallemandf6975e92017-05-26 17:42:10 +02001541/* parse the "expose-fd" argument on the bind lines */
1542static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1543{
1544 if (!*args[cur_arg + 1]) {
1545 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1546 return ERR_ALERT | ERR_FATAL;
1547 }
1548 if (!strcmp(args[cur_arg+1], "listeners")) {
1549 conf->level |= ACCESS_FD_LISTENERS;
1550 } else {
1551 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1552 args[cur_arg], args[cur_arg+1]);
1553 return ERR_ALERT | ERR_FATAL;
1554 }
1555
1556 return 0;
1557}
1558
William Lallemand74c24fb2016-11-21 17:18:36 +01001559/* parse the "level" argument on the bind lines */
1560static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1561{
1562 if (!*args[cur_arg + 1]) {
1563 memprintf(err, "'%s' : missing level", args[cur_arg]);
1564 return ERR_ALERT | ERR_FATAL;
1565 }
1566
William Lallemand07a62f72017-05-24 00:57:40 +02001567 if (!strcmp(args[cur_arg+1], "user")) {
1568 conf->level &= ~ACCESS_LVL_MASK;
1569 conf->level |= ACCESS_LVL_USER;
1570 } else if (!strcmp(args[cur_arg+1], "operator")) {
1571 conf->level &= ~ACCESS_LVL_MASK;
1572 conf->level |= ACCESS_LVL_OPER;
1573 } else if (!strcmp(args[cur_arg+1], "admin")) {
1574 conf->level &= ~ACCESS_LVL_MASK;
1575 conf->level |= ACCESS_LVL_ADMIN;
1576 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001577 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1578 args[cur_arg], args[cur_arg+1]);
1579 return ERR_ALERT | ERR_FATAL;
1580 }
1581
1582 return 0;
1583}
1584
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001585static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1586{
1587 if (!*args[cur_arg + 1]) {
1588 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1589 return ERR_ALERT | ERR_FATAL;
1590 }
1591
1592 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1593 return 0;
1594 else {
1595 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1596 args[cur_arg], args[cur_arg+1]);
1597 return ERR_ALERT | ERR_FATAL;
1598 }
1599}
1600
Olivier Houchardf886e342017-04-05 22:24:59 +02001601/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001602static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02001603{
1604 char *cmsgbuf = NULL;
1605 unsigned char *tmpbuf = NULL;
1606 struct cmsghdr *cmsg;
1607 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001608 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001609 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001610 struct msghdr msghdr;
1611 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001612 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001613 const char *ns_name, *if_name;
1614 unsigned char ns_nlen, if_nlen;
1615 int nb_queued;
1616 int cur_fd = 0;
Olivier Houchardf886e342017-04-05 22:24:59 +02001617 int *tmpfd;
1618 int tot_fd_nb = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001619 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001620 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001621 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001622 int ret;
1623
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001624 if (!remote) {
1625 ha_warning("Only works on real connections\n");
1626 goto out;
1627 }
1628
1629 fd = remote->handle.fd;
1630
Olivier Houchardf886e342017-04-05 22:24:59 +02001631 /* Temporary set the FD in blocking mode, that will make our life easier */
1632 old_fcntl = fcntl(fd, F_GETFL);
1633 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001634 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001635 goto out;
1636 }
1637 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1638 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001639 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001640 goto out;
1641 }
1642 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001643 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001644 goto out;
1645 }
Olivier Houchard54740872017-04-06 14:45:14 +02001646 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001647 iov.iov_base = &tot_fd_nb;
1648 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001649 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001650 goto out;
1651 memset(&msghdr, 0, sizeof(msghdr));
1652 /*
1653 * First, calculates the total number of FD, so that we can let
Jackie Tapia749f74c2020-07-22 18:59:40 -05001654 * the caller know how much it should expect.
Olivier Houchardf886e342017-04-05 22:24:59 +02001655 */
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001656 for (cur_fd = 0;cur_fd < global.maxsock; cur_fd++)
1657 tot_fd_nb += fdtab[cur_fd].exported;
William Lallemand5fd3b282020-01-16 15:32:08 +01001658
Olivier Houchardf886e342017-04-05 22:24:59 +02001659 if (tot_fd_nb == 0)
1660 goto out;
1661
1662 /* First send the total number of file descriptors, so that the
1663 * receiving end knows what to expect.
1664 */
1665 msghdr.msg_iov = &iov;
1666 msghdr.msg_iovlen = 1;
1667 ret = sendmsg(fd, &msghdr, 0);
1668 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001669 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001670 goto out;
1671 }
1672
1673 /* Now send the fds */
1674 msghdr.msg_control = cmsgbuf;
1675 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1676 cmsg = CMSG_FIRSTHDR(&msghdr);
1677 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1678 cmsg->cmsg_level = SOL_SOCKET;
1679 cmsg->cmsg_type = SCM_RIGHTS;
1680 tmpfd = (int *)CMSG_DATA(cmsg);
1681
Olivier Houchardf886e342017-04-05 22:24:59 +02001682 /* For each socket, e message is sent, containing the following :
1683 * Size of the namespace name (or 0 if none), as an unsigned char.
1684 * The namespace name, if any
1685 * Size of the interface name (or 0 if none), as an unsigned char
1686 * The interface name, if any
Willy Tarreaucf1f1932020-08-26 10:30:09 +02001687 * 32 bits of zeroes (used to be listener options).
Olivier Houchardf886e342017-04-05 22:24:59 +02001688 */
1689 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
Ilya Shipitsind4259502020-04-08 01:07:56 +05001690 * buffer big enough to store the socket information.
Olivier Houchardf886e342017-04-05 22:24:59 +02001691 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001692 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001693 if (tmpbuf == NULL) {
Ilya Shipitsind4259502020-04-08 01:07:56 +05001694 ha_warning("Failed to allocate memory to transfer socket information\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001695 goto out;
1696 }
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001697
1698 nb_queued = 0;
Olivier Houchardf886e342017-04-05 22:24:59 +02001699 iov.iov_base = tmpbuf;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001700 for (cur_fd = 0; cur_fd < global.maxsock; cur_fd++) {
1701 if (!(fdtab[cur_fd].exported))
1702 continue;
1703
1704 ns_name = if_name = "";
1705 ns_nlen = if_nlen = 0;
1706
1707 /* for now we can only retrieve namespaces and interfaces from
1708 * pure listeners.
1709 */
1710 if (fdtab[cur_fd].iocb == listener_accept) {
1711 const struct listener *l = fdtab[cur_fd].owner;
1712
Willy Tarreau818a92e2020-09-03 07:50:19 +02001713 if (l->rx.settings->interface) {
1714 if_name = l->rx.settings->interface;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001715 if_nlen = strlen(if_name);
1716 }
1717
1718#ifdef USE_NS
Willy Tarreau818a92e2020-09-03 07:50:19 +02001719 if (l->rx.settings->netns) {
1720 ns_name = l->rx.settings->netns->node.key;
1721 ns_nlen = l->rx.settings->netns->name_len;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001722 }
1723#endif
1724 }
1725
1726 /* put the FD into the CMSG_DATA */
1727 tmpfd[nb_queued++] = cur_fd;
1728
1729 /* first block is <ns_name_len> <ns_name> */
1730 tmpbuf[curoff++] = ns_nlen;
1731 if (ns_nlen)
1732 memcpy(tmpbuf + curoff, ns_name, ns_nlen);
1733 curoff += ns_nlen;
1734
1735 /* second block is <if_name_len> <if_name> */
1736 tmpbuf[curoff++] = if_nlen;
1737 if (if_nlen)
1738 memcpy(tmpbuf + curoff, if_name, if_nlen);
1739 curoff += if_nlen;
1740
1741 /* we used to send the listener options here before 2.3 */
1742 memset(tmpbuf + curoff, 0, sizeof(int));
1743 curoff += sizeof(int);
1744
1745 /* there's a limit to how many FDs may be sent at once */
1746 if (nb_queued == MAX_SEND_FD) {
1747 iov.iov_len = curoff;
1748 if (sendmsg(fd, &msghdr, 0) != curoff) {
1749 ha_warning("Failed to transfer sockets\n");
1750 return -1;
1751 }
1752
1753 /* Wait for an ack */
1754 do {
1755 ret = recv(fd, &tot_fd_nb, sizeof(tot_fd_nb), 0);
1756 } while (ret == -1 && errno == EINTR);
1757
1758 if (ret <= 0) {
1759 ha_warning("Unexpected error while transferring sockets\n");
1760 return -1;
1761 }
1762 curoff = 0;
1763 nb_queued = 0;
1764 }
William Lallemand5fd3b282020-01-16 15:32:08 +01001765 }
1766
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001767 /* flush pending stuff */
1768 if (nb_queued) {
Olivier Houchardf886e342017-04-05 22:24:59 +02001769 iov.iov_len = curoff;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001770 cmsg->cmsg_len = CMSG_LEN(nb_queued * sizeof(int));
1771 msghdr.msg_controllen = CMSG_SPACE(nb_queued * sizeof(int));
Olivier Houchardf886e342017-04-05 22:24:59 +02001772 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001773 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001774 goto out;
1775 }
1776 }
1777
1778out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001779 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001780 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001781 goto out;
1782 }
1783 appctx->st0 = CLI_ST_END;
1784 free(cmsgbuf);
1785 free(tmpbuf);
1786 return 1;
1787}
1788
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001789static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
1790{
1791 if (*args[0] == 'h')
1792 /* help */
1793 cli_gen_usage_msg(appctx);
1794 else if (*args[0] == 'p')
1795 /* prompt */
1796 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
1797 else if (*args[0] == 'q')
1798 /* quit */
1799 appctx->st0 = CLI_ST_END;
1800
1801 return 1;
1802}
Olivier Houchardf886e342017-04-05 22:24:59 +02001803
William Lallemand2f4ce202018-10-26 14:47:47 +02001804void pcli_write_prompt(struct stream *s)
1805{
1806 struct buffer *msg = get_trash_chunk();
1807 struct channel *oc = si_oc(&s->si[0]);
1808
William Lallemanddc12c2e2018-12-13 09:05:46 +01001809 if (!(s->pcli_flags & PCLI_F_PROMPT))
William Lallemand5b80fa22018-12-11 16:10:54 +01001810 return;
1811
William Lallemanddc12c2e2018-12-13 09:05:46 +01001812 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01001813 chunk_appendf(msg, "+ ");
1814 } else {
1815 if (s->pcli_next_pid == 0)
Willy Tarreau52880f92018-12-15 13:30:03 +01001816 chunk_appendf(msg, "master%s> ",
1817 (global.mode & MODE_MWORKER_WAIT) ? "[ReloadFailed]" : "");
William Lallemandebf61802018-12-11 16:10:57 +01001818 else
1819 chunk_appendf(msg, "%d> ", s->pcli_next_pid);
1820 }
William Lallemand2f4ce202018-10-26 14:47:47 +02001821 co_inject(oc, msg->area, msg->data);
1822}
1823
William Lallemand291810d2018-10-26 14:47:38 +02001824
William Lallemandcf62f7e2018-10-26 14:47:40 +02001825/* The pcli_* functions are used for the CLI proxy in the master */
1826
William Lallemanddeeaa592018-10-26 14:47:48 +02001827void pcli_reply_and_close(struct stream *s, const char *msg)
1828{
1829 struct buffer *buf = get_trash_chunk();
1830
1831 chunk_initstr(buf, msg);
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001832 si_retnclose(&s->si[0], buf);
William Lallemanddeeaa592018-10-26 14:47:48 +02001833}
1834
William Lallemand291810d2018-10-26 14:47:38 +02001835static enum obj_type *pcli_pid_to_server(int proc_pid)
1836{
1837 struct mworker_proc *child;
1838
William Lallemandbddd33a2018-12-11 16:10:53 +01001839 /* return the CLI applet of the master */
1840 if (proc_pid == 0)
1841 return &cli_applet.obj_type;
1842
William Lallemand291810d2018-10-26 14:47:38 +02001843 list_for_each_entry(child, &proc_list, list) {
1844 if (child->pid == proc_pid){
1845 return &child->srv->obj_type;
1846 }
1847 }
1848 return NULL;
1849}
1850
1851/* Take a CLI prefix in argument (eg: @!1234 @master @1)
1852 * Return:
1853 * 0: master
1854 * > 0: pid of a worker
1855 * < 0: didn't find a worker
1856 */
1857static int pcli_prefix_to_pid(const char *prefix)
1858{
1859 int proc_pid;
1860 struct mworker_proc *child;
1861 char *errtol = NULL;
1862
1863 if (*prefix != '@') /* not a prefix, should not happen */
1864 return -1;
1865
1866 prefix++;
1867 if (!*prefix) /* sent @ alone, return the master */
1868 return 0;
1869
1870 if (strcmp("master", prefix) == 0) {
1871 return 0;
1872 } else if (*prefix == '!') {
1873 prefix++;
1874 if (!*prefix)
1875 return -1;
1876
1877 proc_pid = strtol(prefix, &errtol, 10);
1878 if (*errtol != '\0')
1879 return -1;
1880 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001881 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001882 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001883 if (child->pid == proc_pid){
1884 return child->pid;
1885 }
1886 }
1887 } else {
1888 struct mworker_proc *chosen = NULL;
1889 /* this is a relative pid */
1890
1891 proc_pid = strtol(prefix, &errtol, 10);
1892 if (*errtol != '\0')
1893 return -1;
1894
1895 if (proc_pid == 0) /* return the master */
1896 return 0;
1897
1898 /* chose the right process, the current one is the one with the
1899 least number of reloads */
1900 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001901 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001902 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001903 if (child->relative_pid == proc_pid){
1904 if (child->reloads == 0)
1905 return child->pid;
1906 else if (chosen == NULL || child->reloads < chosen->reloads)
1907 chosen = child;
1908 }
1909 }
1910 if (chosen)
1911 return chosen->pid;
1912 }
1913 return -1;
1914}
1915
William Lallemandbddd33a2018-12-11 16:10:53 +01001916/* Return::
1917 * >= 0 : number of words to escape
1918 * = -1 : error
1919 */
1920
1921int pcli_find_and_exec_kw(struct stream *s, char **args, int argl, char **errmsg, int *next_pid)
1922{
1923 if (argl < 1)
1924 return 0;
1925
1926 /* there is a prefix */
1927 if (args[0][0] == '@') {
1928 int target_pid = pcli_prefix_to_pid(args[0]);
1929
1930 if (target_pid == -1) {
1931 memprintf(errmsg, "Can't find the target PID matching the prefix '%s'\n", args[0]);
1932 return -1;
1933 }
1934
1935 /* if the prefix is alone, define a default target */
1936 if (argl == 1)
1937 s->pcli_next_pid = target_pid;
1938 else
1939 *next_pid = target_pid;
1940 return 1;
William Lallemand5b80fa22018-12-11 16:10:54 +01001941 } else if (!strcmp("prompt", args[0])) {
William Lallemanddc12c2e2018-12-13 09:05:46 +01001942 s->pcli_flags ^= PCLI_F_PROMPT;
William Lallemand5b80fa22018-12-11 16:10:54 +01001943 return argl; /* return the number of elements in the array */
William Lallemand5f610682018-12-11 16:10:55 +01001944
1945 } else if (!strcmp("quit", args[0])) {
1946 channel_shutr_now(&s->req);
1947 channel_shutw_now(&s->res);
1948 return argl; /* return the number of elements in the array */
William Lallemandb7ea1412018-12-13 09:05:47 +01001949 } else if (!strcmp(args[0], "operator")) {
1950 if (!pcli_has_level(s, ACCESS_LVL_OPER)) {
1951 memprintf(errmsg, "Permission denied!\n");
1952 return -1;
1953 }
1954 s->pcli_flags &= ~ACCESS_LVL_MASK;
1955 s->pcli_flags |= ACCESS_LVL_OPER;
1956 return argl;
1957
1958 } else if (!strcmp(args[0], "user")) {
1959 if (!pcli_has_level(s, ACCESS_LVL_USER)) {
1960 memprintf(errmsg, "Permission denied!\n");
1961 return -1;
1962 }
1963 s->pcli_flags &= ~ACCESS_LVL_MASK;
1964 s->pcli_flags |= ACCESS_LVL_USER;
1965 return argl;
William Lallemandbddd33a2018-12-11 16:10:53 +01001966 }
1967
1968 return 0;
1969}
1970
1971/*
1972 * Parse the CLI request:
1973 * - It does basically the same as the cli_io_handler, but as a proxy
1974 * - It can exec a command and strip non forwardable commands
William Lallemandcf62f7e2018-10-26 14:47:40 +02001975 *
1976 * Return:
William Lallemandbddd33a2018-12-11 16:10:53 +01001977 * - the number of characters to forward or
1978 * - 1 if there is an error or not enough data
William Lallemandcf62f7e2018-10-26 14:47:40 +02001979 */
William Lallemandbddd33a2018-12-11 16:10:53 +01001980int pcli_parse_request(struct stream *s, struct channel *req, char **errmsg, int *next_pid)
William Lallemandcf62f7e2018-10-26 14:47:40 +02001981{
William Lallemandbddd33a2018-12-11 16:10:53 +01001982 char *str = (char *)ci_head(req);
1983 char *end = (char *)ci_stop(req);
1984 char *args[MAX_STATS_ARGS + 1]; /* +1 for storing a NULL */
1985 int argl; /* number of args */
1986 char *p;
1987 char *trim = NULL;
William Lallemandebf61802018-12-11 16:10:57 +01001988 char *payload = NULL;
William Lallemandbddd33a2018-12-11 16:10:53 +01001989 int wtrim = 0; /* number of words to trim */
1990 int reql = 0;
William Lallemandb7ea1412018-12-13 09:05:47 +01001991 int ret;
William Lallemandbddd33a2018-12-11 16:10:53 +01001992 int i = 0;
1993
1994 p = str;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001995
William Lallemanddc12c2e2018-12-13 09:05:46 +01001996 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01001997
1998 /* Looks for the end of one command */
1999 while (p+reql < end) {
2000 /* handle escaping */
2001 if (p[reql] == '\\') {
William Lallemand02c255e2020-06-18 18:45:04 +02002002 reql+=2;
William Lallemandebf61802018-12-11 16:10:57 +01002003 continue;
2004 }
2005 if (p[reql] == ';' || p[reql] == '\n') {
2006 /* found the end of the command */
2007 p[reql] = '\n';
2008 reql++;
2009 break;
2010 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002011 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002012 }
William Lallemandebf61802018-12-11 16:10:57 +01002013 } else {
2014 while (p+reql < end) {
2015 if (p[reql] == '\n') {
2016 /* found the end of the line */
2017 reql++;
2018 break;
2019 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002020 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002021 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002022 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002023
William Lallemandbddd33a2018-12-11 16:10:53 +01002024 /* set end to first byte after the end of the command */
2025 end = p + reql;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002026
William Lallemandbddd33a2018-12-11 16:10:53 +01002027 /* there is no end to this command, need more to parse ! */
2028 if (*(end-1) != '\n') {
2029 return -1;
2030 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002031
William Lallemand3301f3e2018-12-13 09:05:48 +01002032 if (s->pcli_flags & PCLI_F_PAYLOAD) {
2033 if (reql == 1) /* last line of the payload */
2034 s->pcli_flags &= ~PCLI_F_PAYLOAD;
William Lallemandebf61802018-12-11 16:10:57 +01002035 return reql;
2036 }
2037
William Lallemandbddd33a2018-12-11 16:10:53 +01002038 *(end-1) = '\0';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002039
William Lallemandbddd33a2018-12-11 16:10:53 +01002040 /* splits the command in words */
2041 while (i < MAX_STATS_ARGS && p < end) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002042 /* skip leading spaces/tabs */
2043 p += strspn(p, " \t");
2044 if (!*p)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002045 break;
2046
William Lallemandbddd33a2018-12-11 16:10:53 +01002047 args[i] = p;
William Lallemandfe249c32020-06-18 18:03:57 +02002048 while (1) {
2049 p += strcspn(p, " \t\\");
2050 /* escaped chars using backlashes (\) */
2051 if (*p == '\\') {
2052 if (!*++p)
2053 break;
2054 if (!*++p)
2055 break;
2056 } else {
2057 break;
William Lallemandbddd33a2018-12-11 16:10:53 +01002058 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002059 }
William Lallemandfe249c32020-06-18 18:03:57 +02002060 *p++ = 0;
William Lallemandbddd33a2018-12-11 16:10:53 +01002061 i++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002062 }
2063
William Lallemandbddd33a2018-12-11 16:10:53 +01002064 argl = i;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002065
William Lallemandbddd33a2018-12-11 16:10:53 +01002066 for (; i < MAX_STATS_ARGS + 1; i++)
2067 args[i] = NULL;
2068
2069 wtrim = pcli_find_and_exec_kw(s, args, argl, errmsg, next_pid);
2070
2071 /* End of words are ending by \0, we need to replace the \0s by spaces
20721 before forwarding them */
2073 p = str;
William Lallemand3301f3e2018-12-13 09:05:48 +01002074 while (p < end-1) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002075 if (*p == '\0')
2076 *p = ' ';
2077 p++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002078 }
2079
William Lallemand3301f3e2018-12-13 09:05:48 +01002080 payload = strstr(str, PAYLOAD_PATTERN);
2081 if ((end - 1) == (payload + strlen(PAYLOAD_PATTERN))) {
2082 /* if the payload pattern is at the end */
2083 s->pcli_flags |= PCLI_F_PAYLOAD;
2084 ret = reql;
2085 }
2086
William Lallemandbddd33a2018-12-11 16:10:53 +01002087 *(end-1) = '\n';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002088
William Lallemandbddd33a2018-12-11 16:10:53 +01002089 if (wtrim > 0) {
2090 trim = &args[wtrim][0];
2091 if (trim == NULL) /* if this was the last word in the table */
2092 trim = end;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002093
William Lallemandbddd33a2018-12-11 16:10:53 +01002094 b_del(&req->buf, trim - str);
2095
William Lallemandb7ea1412018-12-13 09:05:47 +01002096 ret = end - trim;
William Lallemandbddd33a2018-12-11 16:10:53 +01002097 } else if (wtrim < 0) {
2098 /* parsing error */
2099 return -1;
William Lallemandb7ea1412018-12-13 09:05:47 +01002100 } else {
2101 /* the whole string */
2102 ret = end - str;
William Lallemandbddd33a2018-12-11 16:10:53 +01002103 }
2104
William Lallemandb7ea1412018-12-13 09:05:47 +01002105 if (ret > 1) {
2106 if (pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2107 goto end;
2108 } else if (pcli_has_level(s, ACCESS_LVL_OPER)) {
William Lallemandad032882019-07-01 10:56:15 +02002109 ci_insert_line2(req, 0, "operator -", strlen("operator -"));
2110 ret += strlen("operator -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002111 } else if (pcli_has_level(s, ACCESS_LVL_USER)) {
William Lallemandad032882019-07-01 10:56:15 +02002112 ci_insert_line2(req, 0, "user -", strlen("user -"));
2113 ret += strlen("user -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002114 }
2115 }
2116end:
William Lallemandbddd33a2018-12-11 16:10:53 +01002117
William Lallemandb7ea1412018-12-13 09:05:47 +01002118 return ret;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002119}
2120
2121int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
2122{
William Lallemandbddd33a2018-12-11 16:10:53 +01002123 int next_pid = -1;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002124 int to_forward;
William Lallemandbddd33a2018-12-11 16:10:53 +01002125 char *errmsg = NULL;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002126
William Lallemandb7ea1412018-12-13 09:05:47 +01002127 if ((s->pcli_flags & ACCESS_LVL_MASK) == ACCESS_LVL_NONE)
2128 s->pcli_flags |= strm_li(s)->bind_conf->level & ACCESS_LVL_MASK;
2129
William Lallemandcf62f7e2018-10-26 14:47:40 +02002130read_again:
2131 /* if the channel is closed for read, we won't receive any more data
2132 from the client, but we don't want to forward this close to the
2133 server */
2134 channel_dont_close(req);
2135
2136 /* We don't know yet to which server we will connect */
2137 channel_dont_connect(req);
2138
2139
2140 /* we are not waiting for a response, there is no more request and we
2141 * receive a close from the client, we can leave */
2142 if (!(ci_data(req)) && req->flags & CF_SHUTR) {
2143 channel_shutw_now(&s->res);
2144 s->req.analysers &= ~AN_REQ_WAIT_CLI;
2145 return 1;
2146 }
2147
2148 req->flags |= CF_READ_DONTWAIT;
2149
2150 /* need more data */
2151 if (!ci_data(req))
2152 return 0;
2153
2154 /* If there is data available for analysis, log the end of the idle time. */
2155 if (c_data(req) && s->logs.t_idle == -1)
2156 s->logs.t_idle = tv_ms_elapsed(&s->logs.tv_accept, &now) - s->logs.t_handshake;
2157
William Lallemandbddd33a2018-12-11 16:10:53 +01002158 to_forward = pcli_parse_request(s, req, &errmsg, &next_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002159 if (to_forward > 0) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002160 int target_pid;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002161 /* enough data */
2162
William Lallemandcf62f7e2018-10-26 14:47:40 +02002163 /* forward only 1 command */
2164 channel_forward(req, to_forward);
William Lallemandebf61802018-12-11 16:10:57 +01002165
William Lallemanddc12c2e2018-12-13 09:05:46 +01002166 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002167 /* we send only 1 command per request, and we write close after it */
2168 channel_shutw_now(req);
2169 } else {
2170 pcli_write_prompt(s);
2171 }
2172
2173 s->res.flags |= CF_WAKE_ONCE; /* need to be called again */
William Lallemandcf62f7e2018-10-26 14:47:40 +02002174
2175 /* remove the XFER_DATA analysers, which forwards all
2176 * the data, we don't want to forward the next requests
2177 * We need to add CF_FLT_ANALYZE to abort the forward too.
2178 */
2179 req->analysers &= ~(AN_REQ_FLT_XFER_DATA|AN_REQ_WAIT_CLI);
2180 req->analysers |= AN_REQ_FLT_END|CF_FLT_ANALYZE;
2181 s->res.analysers |= AN_RES_WAIT_CLI;
2182
William Lallemandebf61802018-12-11 16:10:57 +01002183 if (!(s->flags & SF_ASSIGNED)) {
2184 if (next_pid > -1)
2185 target_pid = next_pid;
2186 else
2187 target_pid = s->pcli_next_pid;
2188 /* we can connect now */
2189 s->target = pcli_pid_to_server(target_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002190
William Lallemandebf61802018-12-11 16:10:57 +01002191 s->flags |= (SF_DIRECT | SF_ASSIGNED);
2192 channel_auto_connect(req);
2193 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002194
2195 } else if (to_forward == 0) {
William Lallemandcf62f7e2018-10-26 14:47:40 +02002196 /* we trimmed things but we might have other commands to consume */
William Lallemandbddd33a2018-12-11 16:10:53 +01002197 pcli_write_prompt(s);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002198 goto read_again;
William Lallemandbddd33a2018-12-11 16:10:53 +01002199 } else if (to_forward == -1 && errmsg) {
2200 /* there was an error during the parsing */
2201 pcli_reply_and_close(s, errmsg);
2202 return 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002203 } else if (to_forward == -1 && channel_full(req, global.tune.maxrewrite)) {
2204 /* buffer is full and we didn't catch the end of a command */
2205 goto send_help;
2206 }
2207
2208 return 0;
2209
2210send_help:
2211 b_reset(&req->buf);
2212 b_putblk(&req->buf, "help\n", 5);
2213 goto read_again;
2214}
2215
2216int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
2217{
2218 struct proxy *fe = strm_fe(s);
2219 struct proxy *be = s->be;
2220
William Lallemand6b7cd0a2018-11-06 17:37:11 +01002221 if (rep->flags & CF_READ_ERROR) {
2222 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
2223 s->res.analysers &= ~AN_RES_WAIT_CLI;
2224 return 0;
2225 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002226 rep->flags |= CF_READ_DONTWAIT; /* try to get back here ASAP */
2227 rep->flags |= CF_NEVER_WAIT;
2228
2229 /* don't forward the close */
2230 channel_dont_close(&s->res);
2231 channel_dont_close(&s->req);
2232
William Lallemanddc12c2e2018-12-13 09:05:46 +01002233 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002234 s->req.analysers |= AN_REQ_WAIT_CLI;
2235 s->res.analysers &= ~AN_RES_WAIT_CLI;
2236 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2237 return 0;
2238 }
2239
William Lallemandcf62f7e2018-10-26 14:47:40 +02002240 /* forward the data */
2241 if (ci_data(rep)) {
2242 c_adv(rep, ci_data(rep));
2243 return 0;
2244 }
2245
2246 if ((rep->flags & (CF_SHUTR|CF_READ_NULL))) {
2247 /* stream cleanup */
2248
William Lallemand2f4ce202018-10-26 14:47:47 +02002249 pcli_write_prompt(s);
2250
William Lallemandcf62f7e2018-10-26 14:47:40 +02002251 s->si[1].flags |= SI_FL_NOLINGER | SI_FL_NOHALF;
2252 si_shutr(&s->si[1]);
2253 si_shutw(&s->si[1]);
2254
2255 /*
2256 * starting from there this the same code as
2257 * http_end_txn_clean_session().
2258 *
2259 * It allows to do frontend keepalive while reconnecting to a
2260 * new server for each request.
2261 */
2262
2263 if (s->flags & SF_BE_ASSIGNED) {
2264 HA_ATOMIC_SUB(&be->beconn, 1);
2265 if (unlikely(s->srv_conn))
2266 sess_change_server(s, NULL);
2267 }
2268
2269 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2270 stream_process_counters(s);
2271
2272 /* don't count other requests' data */
2273 s->logs.bytes_in -= ci_data(&s->req);
2274 s->logs.bytes_out -= ci_data(&s->res);
2275
2276 /* we may need to know the position in the queue */
2277 pendconn_free(s);
2278
2279 /* let's do a final log if we need it */
2280 if (!LIST_ISEMPTY(&fe->logformat) && s->logs.logwait &&
2281 !(s->flags & SF_MONITOR) &&
2282 (!(fe->options & PR_O_NULLNOLOG) || s->req.total)) {
2283 s->do_log(s);
2284 }
2285
2286 /* stop tracking content-based counters */
2287 stream_stop_content_counters(s);
2288 stream_update_time_stats(s);
2289
2290 s->logs.accept_date = date; /* user-visible date for logging */
2291 s->logs.tv_accept = now; /* corrected date for internal use */
2292 s->logs.t_handshake = 0; /* There are no handshake in keep alive connection. */
2293 s->logs.t_idle = -1;
2294 tv_zero(&s->logs.tv_request);
2295 s->logs.t_queue = -1;
2296 s->logs.t_connect = -1;
2297 s->logs.t_data = -1;
2298 s->logs.t_close = 0;
2299 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
2300 s->logs.srv_queue_pos = 0; /* we will get this number soon */
2301
2302 s->logs.bytes_in = s->req.total = ci_data(&s->req);
2303 s->logs.bytes_out = s->res.total = ci_data(&s->res);
2304
2305 stream_del_srv_conn(s);
2306 if (objt_server(s->target)) {
2307 if (s->flags & SF_CURR_SESS) {
2308 s->flags &= ~SF_CURR_SESS;
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002309 HA_ATOMIC_SUB(&__objt_server(s->target)->cur_sess, 1);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002310 }
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002311 if (may_dequeue_tasks(__objt_server(s->target), be))
2312 process_srv_queue(__objt_server(s->target));
William Lallemandcf62f7e2018-10-26 14:47:40 +02002313 }
2314
2315 s->target = NULL;
2316
2317 /* only release our endpoint if we don't intend to reuse the
2318 * connection.
2319 */
2320 if (!si_conn_ready(&s->si[1])) {
2321 si_release_endpoint(&s->si[1]);
2322 s->srv_conn = NULL;
2323 }
2324
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002325 sockaddr_free(&s->target_addr);
2326
William Lallemandcf62f7e2018-10-26 14:47:40 +02002327 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
2328 s->si[1].err_type = SI_ET_NONE;
2329 s->si[1].conn_retries = 0; /* used for logging too */
2330 s->si[1].exp = TICK_ETERNITY;
2331 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 +02002332 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 +02002333 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 +02002334 s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_ADDR_SET|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
2335 s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
2336 s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
2337 /* reinitialise the current rule list pointer to NULL. We are sure that
2338 * any rulelist match the NULL pointer.
2339 */
2340 s->current_rule_list = NULL;
2341
2342 s->be = strm_fe(s);
2343 s->logs.logwait = strm_fe(s)->to_log;
2344 s->logs.level = 0;
2345 stream_del_srv_conn(s);
2346 s->target = NULL;
2347 /* re-init store persistence */
2348 s->store_count = 0;
2349 s->uniq_id = global.req_count++;
2350
2351 s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */
2352
2353 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2354
2355 s->req.analysers |= AN_REQ_WAIT_CLI;
2356 s->res.analysers &= ~AN_RES_WAIT_CLI;
2357
2358 /* We must trim any excess data from the response buffer, because we
2359 * may have blocked an invalid response from a server that we don't
Ilya Shipitsind4259502020-04-08 01:07:56 +05002360 * want to accidentally forward once we disable the analysers, nor do
William Lallemandcf62f7e2018-10-26 14:47:40 +02002361 * we want those data to come along with next response. A typical
2362 * example of such data would be from a buggy server responding to
2363 * a HEAD with some data, or sending more than the advertised
2364 * content-length.
2365 */
2366 if (unlikely(ci_data(&s->res)))
2367 b_set_data(&s->res.buf, co_data(&s->res));
2368
2369 /* Now we can realign the response buffer */
2370 c_realign_if_empty(&s->res);
2371
2372 s->req.rto = strm_fe(s)->timeout.client;
2373 s->req.wto = TICK_ETERNITY;
2374
2375 s->res.rto = TICK_ETERNITY;
2376 s->res.wto = strm_fe(s)->timeout.client;
2377
2378 s->req.rex = TICK_ETERNITY;
2379 s->req.wex = TICK_ETERNITY;
2380 s->req.analyse_exp = TICK_ETERNITY;
2381 s->res.rex = TICK_ETERNITY;
2382 s->res.wex = TICK_ETERNITY;
2383 s->res.analyse_exp = TICK_ETERNITY;
2384 s->si[1].hcto = TICK_ETERNITY;
2385
2386 /* we're removing the analysers, we MUST re-enable events detection.
2387 * We don't enable close on the response channel since it's either
2388 * already closed, or in keep-alive with an idle connection handler.
2389 */
2390 channel_auto_read(&s->req);
2391 channel_auto_close(&s->req);
2392 channel_auto_read(&s->res);
2393
2394
2395 return 1;
2396 }
2397 return 0;
2398}
2399
William Lallemand8a022572018-10-26 14:47:35 +02002400/*
2401 * The mworker functions are used to initialize the CLI in the master process
2402 */
2403
William Lallemand309dc9a2018-10-26 14:47:45 +02002404 /*
2405 * Stop the mworker proxy
2406 */
2407void mworker_cli_proxy_stop()
2408{
William Lallemand550db6d2018-11-06 17:37:12 +01002409 if (mworker_proxy)
2410 stop_proxy(mworker_proxy);
William Lallemand309dc9a2018-10-26 14:47:45 +02002411}
2412
William Lallemand8a022572018-10-26 14:47:35 +02002413/*
2414 * Create the mworker CLI proxy
2415 */
2416int mworker_cli_proxy_create()
2417{
2418 struct mworker_proc *child;
William Lallemand744a0892018-11-22 16:46:51 +01002419 char *msg = NULL;
2420 char *errmsg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002421
2422 mworker_proxy = calloc(1, sizeof(*mworker_proxy));
2423 if (!mworker_proxy)
2424 return -1;
2425
2426 init_new_proxy(mworker_proxy);
2427 mworker_proxy->next = proxies_list;
2428 proxies_list = mworker_proxy;
2429 mworker_proxy->id = strdup("MASTER");
William Lallemandcf62f7e2018-10-26 14:47:40 +02002430 mworker_proxy->mode = PR_MODE_CLI;
William Lallemand8a022572018-10-26 14:47:35 +02002431 mworker_proxy->state = PR_STNEW;
2432 mworker_proxy->last_change = now.tv_sec;
2433 mworker_proxy->cap = PR_CAP_LISTEN; /* this is a listen section */
2434 mworker_proxy->maxconn = 10; /* default to 10 concurrent connections */
2435 mworker_proxy->timeout.client = 0; /* no timeout */
2436 mworker_proxy->conf.file = strdup("MASTER");
2437 mworker_proxy->conf.line = 0;
2438 mworker_proxy->accept = frontend_accept;
2439 mworker_proxy-> lbprm.algo = BE_LB_ALGO_NONE;
2440
2441 /* Does not init the default target the CLI applet, but must be done in
2442 * the request parsing code */
2443 mworker_proxy->default_target = NULL;
2444
2445 /* the check_config_validity() will get an ID for the proxy */
2446 mworker_proxy->uuid = -1;
2447
2448 proxy_store_name(mworker_proxy);
2449
2450 /* create all servers using the mworker_proc list */
2451 list_for_each_entry(child, &proc_list, list) {
William Lallemand8a022572018-10-26 14:47:35 +02002452 struct server *newsrv = NULL;
2453 struct sockaddr_storage *sk;
2454 int port1, port2, port;
2455 struct protocol *proto;
William Lallemand8a022572018-10-26 14:47:35 +02002456
William Lallemanda31b09e2020-01-14 15:25:02 +01002457 /* only the workers support the master CLI */
2458 if (!(child->options & PROC_O_TYPE_WORKER))
2459 continue;
2460
William Lallemand8a022572018-10-26 14:47:35 +02002461 newsrv = new_server(mworker_proxy);
2462 if (!newsrv)
William Lallemand744a0892018-11-22 16:46:51 +01002463 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002464
2465 /* we don't know the new pid yet */
2466 if (child->pid == -1)
2467 memprintf(&msg, "cur-%d", child->relative_pid);
2468 else
2469 memprintf(&msg, "old-%d", child->pid);
2470
2471 newsrv->next = mworker_proxy->srv;
2472 mworker_proxy->srv = newsrv;
2473 newsrv->conf.file = strdup(msg);
2474 newsrv->id = strdup(msg);
2475 newsrv->conf.line = 0;
2476
2477 memprintf(&msg, "sockpair@%d", child->ipc_fd[0]);
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002478 if ((sk = str2sa_range(msg, &port, &port1, &port2, &errmsg, NULL, NULL, 0)) == 0) {
William Lallemand744a0892018-11-22 16:46:51 +01002479 goto error;
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002480 }
2481 free(msg);
2482 msg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002483
2484 proto = protocol_by_family(sk->ss_family);
2485 if (!proto || !proto->connect) {
William Lallemand744a0892018-11-22 16:46:51 +01002486 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002487 }
2488
2489 /* no port specified */
2490 newsrv->flags |= SRV_F_MAPPORTS;
2491 newsrv->addr = *sk;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002492 /* don't let the server participate to load balancing */
2493 newsrv->iweight = 0;
2494 newsrv->uweight = 0;
William Lallemand8a022572018-10-26 14:47:35 +02002495 srv_lb_commit_status(newsrv);
William Lallemand291810d2018-10-26 14:47:38 +02002496
2497 child->srv = newsrv;
William Lallemand8a022572018-10-26 14:47:35 +02002498 }
2499 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002500
2501error:
2502 ha_alert("%s\n", errmsg);
2503
2504 list_for_each_entry(child, &proc_list, list) {
2505 free((char *)child->srv->conf.file); /* cast because of const char * */
2506 free(child->srv->id);
2507 free(child->srv);
2508 child->srv = NULL;
2509 }
2510 free(mworker_proxy->id);
2511 free(mworker_proxy->conf.file);
2512 free(mworker_proxy);
2513 mworker_proxy = NULL;
2514 free(errmsg);
2515 free(msg);
2516
2517 return -1;
William Lallemand8a022572018-10-26 14:47:35 +02002518}
Olivier Houchardf886e342017-04-05 22:24:59 +02002519
William Lallemandce83b4a2018-10-26 14:47:30 +02002520/*
William Lallemande7361152018-10-26 14:47:36 +02002521 * Create a new listener for the master CLI proxy
2522 */
2523int mworker_cli_proxy_new_listener(char *line)
2524{
2525 struct bind_conf *bind_conf;
2526 struct listener *l;
2527 char *err = NULL;
2528 char *args[MAX_LINE_ARGS + 1];
2529 int arg;
2530 int cur_arg;
2531
William Lallemand2e945c82019-11-25 09:58:37 +01002532 arg = 1;
William Lallemande7361152018-10-26 14:47:36 +02002533 args[0] = line;
2534
2535 /* args is a bind configuration with spaces replaced by commas */
2536 while (*line && arg < MAX_LINE_ARGS) {
2537
2538 if (*line == ',') {
2539 *line++ = '\0';
2540 while (*line == ',')
2541 line++;
William Lallemand2e945c82019-11-25 09:58:37 +01002542 args[arg++] = line;
William Lallemande7361152018-10-26 14:47:36 +02002543 }
2544 line++;
2545 }
2546
William Lallemand2e945c82019-11-25 09:58:37 +01002547 args[arg] = "\0";
William Lallemande7361152018-10-26 14:47:36 +02002548
2549 bind_conf = bind_conf_alloc(mworker_proxy, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002550 if (!bind_conf)
2551 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002552
2553 bind_conf->level &= ~ACCESS_LVL_MASK;
2554 bind_conf->level |= ACCESS_LVL_ADMIN;
2555
2556 if (!str2listener(args[0], mworker_proxy, bind_conf, "master-socket", 0, &err)) {
2557 ha_alert("Cannot create the listener of the master CLI\n");
William Lallemand744a0892018-11-22 16:46:51 +01002558 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002559 }
2560
2561 cur_arg = 1;
2562
2563 while (*args[cur_arg]) {
2564 static int bind_dumped;
2565 struct bind_kw *kw;
2566
2567 kw = bind_find_kw(args[cur_arg]);
2568 if (kw) {
2569 if (!kw->parse) {
2570 memprintf(&err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
2571 args[0], args[1], args[cur_arg]);
2572 goto err;
2573 }
2574
2575 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, &err) != 0) {
2576 if (err)
2577 memprintf(&err, "'%s %s' : '%s'", args[0], args[1], err);
2578 else
2579 memprintf(&err, "'%s %s' : error encountered while processing '%s'",
2580 args[0], args[1], args[cur_arg]);
2581 goto err;
2582 }
2583
2584 cur_arg += 1 + kw->skip;
2585 continue;
2586 }
2587
2588 if (!bind_dumped) {
2589 bind_dump_kws(&err);
2590 indent_msg(&err, 4);
2591 bind_dumped = 1;
2592 }
2593
2594 memprintf(&err, "'%s %s' : unknown keyword '%s'.%s%s",
2595 args[0], args[1], args[cur_arg],
2596 err ? " Registered keywords :" : "", err ? err : "");
2597 goto err;
2598 }
2599
2600
2601 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemande7361152018-10-26 14:47:36 +02002602 l->accept = session_accept_fd;
2603 l->default_target = mworker_proxy->default_target;
2604 /* don't make the peers subject to global limits and don't close it in the master */
2605 l->options |= (LI_O_UNLIMITED|LI_O_MWORKER); /* we are keeping this FD in the master */
2606 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002607 global.maxsock++; /* for the listening socket */
William Lallemande7361152018-10-26 14:47:36 +02002608 }
Willy Tarreau18215cb2019-02-27 16:25:28 +01002609 global.maxsock += mworker_proxy->maxconn;
William Lallemande7361152018-10-26 14:47:36 +02002610
2611 return 0;
2612
2613err:
2614 ha_alert("%s\n", err);
William Lallemand744a0892018-11-22 16:46:51 +01002615 free(err);
2616 free(bind_conf);
William Lallemande7361152018-10-26 14:47:36 +02002617 return -1;
2618
2619}
2620
2621/*
William Lallemandce83b4a2018-10-26 14:47:30 +02002622 * Create a new CLI socket using a socketpair for a worker process
2623 * <mworker_proc> is the process structure, and <proc> is the process number
2624 */
2625int mworker_cli_sockpair_new(struct mworker_proc *mworker_proc, int proc)
2626{
2627 struct bind_conf *bind_conf;
2628 struct listener *l;
2629 char *path = NULL;
2630 char *err = NULL;
2631
2632 /* master pipe to ensure the master is still alive */
2633 if (socketpair(AF_UNIX, SOCK_STREAM, 0, mworker_proc->ipc_fd) < 0) {
2634 ha_alert("Cannot create worker socketpair.\n");
2635 return -1;
2636 }
2637
2638 /* XXX: we might want to use a separate frontend at some point */
2639 if (!global.stats_fe) {
2640 if ((global.stats_fe = alloc_stats_fe("GLOBAL", "master-socket", 0)) == NULL) {
2641 ha_alert("out of memory trying to allocate the stats frontend");
William Lallemand744a0892018-11-22 16:46:51 +01002642 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002643 }
2644 }
2645
2646 bind_conf = bind_conf_alloc(global.stats_fe, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002647 if (!bind_conf)
2648 goto error;
2649
William Lallemandce83b4a2018-10-26 14:47:30 +02002650 bind_conf->level &= ~ACCESS_LVL_MASK;
2651 bind_conf->level |= ACCESS_LVL_ADMIN; /* TODO: need to lower the rights with a CLI keyword*/
2652
Willy Tarreaue26993c2020-09-03 07:18:55 +02002653 bind_conf->settings.bind_proc = 1UL << proc;
William Lallemandce83b4a2018-10-26 14:47:30 +02002654 global.stats_fe->bind_proc = 0; /* XXX: we should be careful with that, it can be removed by configuration */
2655
2656 if (!memprintf(&path, "sockpair@%d", mworker_proc->ipc_fd[1])) {
2657 ha_alert("Cannot allocate listener.\n");
William Lallemand744a0892018-11-22 16:46:51 +01002658 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002659 }
2660
2661 if (!str2listener(path, global.stats_fe, bind_conf, "master-socket", 0, &err)) {
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002662 free(path);
William Lallemandce83b4a2018-10-26 14:47:30 +02002663 ha_alert("Cannot create a CLI sockpair listener for process #%d\n", proc);
William Lallemand744a0892018-11-22 16:46:51 +01002664 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002665 }
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002666 free(path);
2667 path = NULL;
William Lallemandce83b4a2018-10-26 14:47:30 +02002668
2669 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemandce83b4a2018-10-26 14:47:30 +02002670 l->accept = session_accept_fd;
2671 l->default_target = global.stats_fe->default_target;
William Lallemanda3372292018-11-16 16:57:22 +01002672 l->options |= (LI_O_UNLIMITED | LI_O_NOSTOP);
William Lallemandce83b4a2018-10-26 14:47:30 +02002673 /* it's a sockpair but we don't want to keep the fd in the master */
Willy Tarreau43046fa2020-09-01 15:41:59 +02002674 l->rx.flags &= ~RX_F_INHERITED;
William Lallemandce83b4a2018-10-26 14:47:30 +02002675 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002676 global.maxsock++; /* for the listening socket */
William Lallemandce83b4a2018-10-26 14:47:30 +02002677 }
2678
2679 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002680
2681error:
2682 close(mworker_proc->ipc_fd[0]);
2683 close(mworker_proc->ipc_fd[1]);
2684 free(err);
2685
2686 return -1;
William Lallemandce83b4a2018-10-26 14:47:30 +02002687}
2688
William Lallemand74c24fb2016-11-21 17:18:36 +01002689static struct applet cli_applet = {
2690 .obj_type = OBJ_TYPE_APPLET,
2691 .name = "<CLI>", /* used for logging */
2692 .fct = cli_io_handler,
2693 .release = cli_release_handler,
2694};
2695
Willy Tarreau0a739292016-11-22 20:21:23 +01002696/* register cli keywords */
2697static struct cli_kw_list cli_kws = {{ },{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002698 { { "help", NULL }, NULL, cli_parse_simple, NULL },
2699 { { "prompt", NULL }, NULL, cli_parse_simple, NULL },
2700 { { "quit", NULL }, NULL, cli_parse_simple, NULL },
Willy Tarreau2af99412016-11-23 11:10:59 +01002701 { { "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 +01002702 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002703 { { "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 +01002704 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002705 { { "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 +02002706 { { "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 +01002707 { { "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 +02002708 { { "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 +01002709 { { "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 +01002710 { { "operator", NULL }, "operator : lower the level of the current CLI session to operator", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
2711 { { "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 +02002712 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02002713 { { "expert-mode", NULL }, NULL, cli_parse_expert_mode, NULL }, // not listed
Willy Tarreau0a739292016-11-22 20:21:23 +01002714 {{},}
2715}};
2716
Willy Tarreau0108d902018-11-25 19:14:37 +01002717INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
2718
William Lallemand74c24fb2016-11-21 17:18:36 +01002719static struct cfg_kw_list cfg_kws = {ILH, {
2720 { CFG_GLOBAL, "stats", stats_parse_global },
2721 { 0, NULL, NULL },
2722}};
2723
Willy Tarreau0108d902018-11-25 19:14:37 +01002724INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
2725
William Lallemand74c24fb2016-11-21 17:18:36 +01002726static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02002727 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
2728 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002729 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01002730 { NULL, NULL, 0 },
2731}};
2732
Willy Tarreau0108d902018-11-25 19:14:37 +01002733INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01002734
2735/*
2736 * Local variables:
2737 * c-indent-level: 8
2738 * c-basic-offset: 8
2739 * End:
2740 */