blob: afb42b590cbd0b18ba3a78347b3fcdc7840ef9f3 [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 Tarreau4c7e4b72020-05-27 12:58:42 +020029#include <haproxy/api.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010030#include <common/cfgparse.h>
Willy Tarreau853b2972020-05-27 18:01:47 +020031#include <haproxy/list.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020032#include <haproxy/tools.h>
Willy Tarreauc2f7c582020-06-02 18:15:32 +020033#include <haproxy/ticks.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020034#include <haproxy/time.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010035#include <common/uri_auth.h>
Willy Tarreaud6788052020-05-27 15:59:00 +020036#include <haproxy/version.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020037#include <haproxy/base64.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010038
39#include <types/applet.h>
40#include <types/global.h>
41#include <types/dns.h>
William Lallemand9ed62032016-11-21 17:49:11 +010042#include <types/stats.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010043
Willy Tarreaua04ded52020-06-02 10:29:48 +020044#include <haproxy/activity.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010045#include <proto/backend.h>
46#include <proto/channel.h>
47#include <proto/checks.h>
Willy Tarreau9d008692019-08-09 11:21:01 +020048#include <proto/cli.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010049#include <proto/compression.h>
William Lallemand9ed62032016-11-21 17:49:11 +010050#include <proto/stats.h>
Willy Tarreau0f6ffd62020-06-03 19:33:00 +020051#include <haproxy/fd.h>
Willy Tarreau66347942020-06-01 12:18:08 +020052#include <haproxy/freq_ctr.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010053#include <proto/frontend.h>
54#include <proto/log.h>
55#include <proto/pattern.h>
Willy Tarreau551271d2020-06-04 08:32:23 +020056#include <haproxy/pipe.h>
Willy Tarreau2dd7c352020-06-03 15:26:55 +020057#include <haproxy/protocol.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010058#include <proto/listener.h>
59#include <proto/map.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010060#include <proto/proxy.h>
61#include <proto/sample.h>
62#include <proto/session.h>
63#include <proto/stream.h>
64#include <proto/server.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010065#include <proto/stream_interface.h>
66#include <proto/task.h>
67
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020068#define PAYLOAD_PATTERN "<<"
69
William Lallemand74c24fb2016-11-21 17:18:36 +010070static struct applet cli_applet;
71
72static const char stats_sock_usage_msg[] =
73 "Unknown command. Please enter one of the following commands only :\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010074 " help : this message\n"
75 " prompt : toggle interactive mode with prompt\n"
76 " quit : disconnect\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010077 "";
78
79static const char stats_permission_denied_msg[] =
80 "Permission denied\n"
81 "";
82
83
Christopher Faulet1bc04c72017-10-29 20:14:08 +010084static THREAD_LOCAL char *dynamic_usage_msg = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +010085
86/* List head of cli keywords */
87static struct cli_kw_list cli_keywords = {
88 .list = LIST_HEAD_INIT(cli_keywords.list)
89};
90
91extern const char *stat_status_codes[];
92
William Lallemand8a022572018-10-26 14:47:35 +020093static struct proxy *mworker_proxy; /* CLI proxy of the master */
94
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020095static char *cli_gen_usage_msg(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +010096{
97 struct cli_kw_list *kw_list;
98 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +020099 struct buffer *tmp = get_trash_chunk();
100 struct buffer out;
William Lallemand74c24fb2016-11-21 17:18:36 +0100101
102 free(dynamic_usage_msg);
103 dynamic_usage_msg = NULL;
104
105 if (LIST_ISEMPTY(&cli_keywords.list))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200106 goto end;
William Lallemand74c24fb2016-11-21 17:18:36 +0100107
108 chunk_reset(tmp);
109 chunk_strcat(tmp, stats_sock_usage_msg);
110 list_for_each_entry(kw_list, &cli_keywords.list, list) {
111 kw = &kw_list->kw[0];
William Lallemand0154edc2018-05-15 11:50:04 +0200112 while (kw->str_kw[0]) {
William Lallemand14721be2018-10-26 14:47:37 +0200113
114 /* in a worker or normal process, don't display master only commands */
115 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
116 goto next_kw;
117
118 /* in master don't displays if we don't have the master bits */
119 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
120 goto next_kw;
121
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200122 /* only show expert commands in expert mode */
123 if ((kw->level & ~appctx->cli_level) & ACCESS_EXPERT)
124 goto next_kw;
125
William Lallemand0154edc2018-05-15 11:50:04 +0200126 if (kw->usage)
127 chunk_appendf(tmp, " %s\n", kw->usage);
William Lallemand14721be2018-10-26 14:47:37 +0200128
129next_kw:
130
William Lallemand74c24fb2016-11-21 17:18:36 +0100131 kw++;
132 }
133 }
134 chunk_init(&out, NULL, 0);
135 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200136 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200137
138end:
139 if (dynamic_usage_msg) {
140 appctx->ctx.cli.severity = LOG_INFO;
141 appctx->ctx.cli.msg = dynamic_usage_msg;
142 }
143 else {
144 appctx->ctx.cli.severity = LOG_INFO;
145 appctx->ctx.cli.msg = stats_sock_usage_msg;
146 }
147 appctx->st0 = CLI_ST_PRINT;
148
William Lallemand74c24fb2016-11-21 17:18:36 +0100149 return dynamic_usage_msg;
150}
151
152struct cli_kw* cli_find_kw(char **args)
153{
154 struct cli_kw_list *kw_list;
155 struct cli_kw *kw;/* current cli_kw */
156 char **tmp_args;
157 const char **tmp_str_kw;
158 int found = 0;
159
160 if (LIST_ISEMPTY(&cli_keywords.list))
161 return NULL;
162
163 list_for_each_entry(kw_list, &cli_keywords.list, list) {
164 kw = &kw_list->kw[0];
165 while (*kw->str_kw) {
166 tmp_args = args;
167 tmp_str_kw = kw->str_kw;
168 while (*tmp_str_kw) {
169 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
170 found = 1;
171 } else {
172 found = 0;
173 break;
174 }
175 tmp_args++;
176 tmp_str_kw++;
177 }
178 if (found)
179 return (kw);
180 kw++;
181 }
182 }
183 return NULL;
184}
185
186void cli_register_kw(struct cli_kw_list *kw_list)
187{
188 LIST_ADDQ(&cli_keywords.list, &kw_list->list);
189}
190
191
192/* allocate a new stats frontend named <name>, and return it
193 * (or NULL in case of lack of memory).
194 */
195static struct proxy *alloc_stats_fe(const char *name, const char *file, int line)
196{
197 struct proxy *fe;
198
199 fe = calloc(1, sizeof(*fe));
200 if (!fe)
201 return NULL;
202
203 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100204 fe->next = proxies_list;
205 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100206 fe->last_change = now.tv_sec;
207 fe->id = strdup("GLOBAL");
208 fe->cap = PR_CAP_FE;
209 fe->maxconn = 10; /* default to 10 concurrent connections */
210 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
211 fe->conf.file = strdup(file);
212 fe->conf.line = line;
213 fe->accept = frontend_accept;
214 fe->default_target = &cli_applet.obj_type;
215
216 /* the stats frontend is the only one able to assign ID #0 */
217 fe->conf.id.key = fe->uuid = 0;
218 eb32_insert(&used_proxy_id, &fe->conf.id);
219 return fe;
220}
221
222/* This function parses a "stats" statement in the "global" section. It returns
223 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
224 * error message into the <err> buffer which will be preallocated. The trailing
225 * '\n' must not be written. The function must be called with <args> pointing to
226 * the first word after "stats".
227 */
228static int stats_parse_global(char **args, int section_type, struct proxy *curpx,
229 struct proxy *defpx, const char *file, int line,
230 char **err)
231{
232 struct bind_conf *bind_conf;
233 struct listener *l;
234
235 if (!strcmp(args[1], "socket")) {
236 int cur_arg;
237
238 if (*args[2] == 0) {
239 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
240 return -1;
241 }
242
243 if (!global.stats_fe) {
244 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
245 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
246 return -1;
247 }
248 }
249
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100250 bind_conf = bind_conf_alloc(global.stats_fe, file, line, args[2], xprt_get(XPRT_RAW));
William Lallemand07a62f72017-05-24 00:57:40 +0200251 bind_conf->level &= ~ACCESS_LVL_MASK;
252 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100253
254 if (!str2listener(args[2], global.stats_fe, bind_conf, file, line, err)) {
255 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
256 file, line, args[0], args[1], err && *err ? *err : "error");
257 return -1;
258 }
259
260 cur_arg = 3;
261 while (*args[cur_arg]) {
262 static int bind_dumped;
263 struct bind_kw *kw;
264
265 kw = bind_find_kw(args[cur_arg]);
266 if (kw) {
267 if (!kw->parse) {
268 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
269 args[0], args[1], args[cur_arg]);
270 return -1;
271 }
272
273 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, err) != 0) {
274 if (err && *err)
275 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
276 else
277 memprintf(err, "'%s %s' : error encountered while processing '%s'",
278 args[0], args[1], args[cur_arg]);
279 return -1;
280 }
281
282 cur_arg += 1 + kw->skip;
283 continue;
284 }
285
286 if (!bind_dumped) {
287 bind_dump_kws(err);
288 indent_msg(err, 4);
289 bind_dumped = 1;
290 }
291
292 memprintf(err, "'%s %s' : unknown keyword '%s'.%s%s",
293 args[0], args[1], args[cur_arg],
294 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
295 return -1;
296 }
297
298 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100299 l->accept = session_accept_fd;
William Lallemand74c24fb2016-11-21 17:18:36 +0100300 l->default_target = global.stats_fe->default_target;
301 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
302 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100303 global.maxsock++; /* for the listening socket */
William Lallemand74c24fb2016-11-21 17:18:36 +0100304 }
305 }
306 else if (!strcmp(args[1], "timeout")) {
307 unsigned timeout;
308 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
309
Willy Tarreau9faebe32019-06-07 19:00:37 +0200310 if (res == PARSE_TIME_OVER) {
311 memprintf(err, "timer overflow in argument '%s' to '%s %s' (maximum value is 2147483647 ms or ~24.8 days)",
312 args[2], args[0], args[1]);
313 return -1;
314 }
315 else if (res == PARSE_TIME_UNDER) {
316 memprintf(err, "timer underflow in argument '%s' to '%s %s' (minimum non-null value is 1 ms)",
317 args[2], args[0], args[1]);
318 return -1;
319 }
320 else if (res) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100321 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
322 return -1;
323 }
324
325 if (!timeout) {
326 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
327 return -1;
328 }
329 if (!global.stats_fe) {
330 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
331 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
332 return -1;
333 }
334 }
335 global.stats_fe->timeout.client = MS_TO_TICKS(timeout);
336 }
337 else if (!strcmp(args[1], "maxconn")) {
338 int maxconn = atol(args[2]);
339
340 if (maxconn <= 0) {
341 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
342 return -1;
343 }
344
345 if (!global.stats_fe) {
346 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
347 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
348 return -1;
349 }
350 }
351 global.stats_fe->maxconn = maxconn;
352 }
353 else if (!strcmp(args[1], "bind-process")) { /* enable the socket only on some processes */
354 int cur_arg = 2;
355 unsigned long set = 0;
356
357 if (!global.stats_fe) {
358 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
359 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
360 return -1;
361 }
362 }
363
364 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100365 if (strcmp(args[cur_arg], "all") == 0) {
366 set = 0;
367 break;
368 }
Willy Tarreauff9c9142019-02-07 10:39:36 +0100369 if (parse_process_number(args[cur_arg], &set, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100370 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100371 return -1;
372 }
373 cur_arg++;
374 }
375 global.stats_fe->bind_proc = set;
376 }
377 else {
378 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
379 return -1;
380 }
381 return 0;
382}
383
William Lallemand33d29e22019-04-01 11:30:06 +0200384/*
William Lallemand9a37fd02019-04-12 16:09:24 +0200385 * This function exports the bound addresses of a <frontend> in the environment
386 * variable <varname>. Those addresses are separated by semicolons and prefixed
387 * with their type (abns@, unix@, sockpair@ etc)
388 * Return -1 upon error, 0 otherwise
William Lallemand33d29e22019-04-01 11:30:06 +0200389 */
William Lallemand9a37fd02019-04-12 16:09:24 +0200390int listeners_setenv(struct proxy *frontend, const char *varname)
William Lallemand33d29e22019-04-01 11:30:06 +0200391{
392 struct buffer *trash = get_trash_chunk();
393 struct bind_conf *bind_conf;
394
William Lallemand9a37fd02019-04-12 16:09:24 +0200395 if (frontend) {
396 list_for_each_entry(bind_conf, &frontend->conf.bind, by_fe) {
William Lallemand33d29e22019-04-01 11:30:06 +0200397 struct listener *l;
398
399 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
400 char addr[46];
401 char port[6];
402
William Lallemand620072b2019-04-12 16:09:25 +0200403 /* separate listener by semicolons */
404 if (trash->data)
405 chunk_appendf(trash, ";");
406
William Lallemand33d29e22019-04-01 11:30:06 +0200407 if (l->addr.ss_family == AF_UNIX) {
408 const struct sockaddr_un *un;
409
410 un = (struct sockaddr_un *)&l->addr;
411 if (un->sun_path[0] == '\0') {
412 chunk_appendf(trash, "abns@%s", un->sun_path+1);
413 } else {
414 chunk_appendf(trash, "unix@%s", un->sun_path);
415 }
416 } else if (l->addr.ss_family == AF_INET) {
417 addr_to_str(&l->addr, addr, sizeof(addr));
418 port_to_str(&l->addr, port, sizeof(port));
419 chunk_appendf(trash, "ipv4@%s:%s", addr, port);
420 } else if (l->addr.ss_family == AF_INET6) {
421 addr_to_str(&l->addr, addr, sizeof(addr));
422 port_to_str(&l->addr, port, sizeof(port));
423 chunk_appendf(trash, "ipv6@[%s]:%s", addr, port);
424 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
425 chunk_appendf(trash, "sockpair@%d", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
426 }
William Lallemand33d29e22019-04-01 11:30:06 +0200427 }
428 }
429 trash->area[trash->data++] = '\0';
William Lallemand9a37fd02019-04-12 16:09:24 +0200430 if (setenv(varname, trash->area, 1) < 0)
William Lallemand33d29e22019-04-01 11:30:06 +0200431 return -1;
432 }
433
434 return 0;
435}
436
William Lallemand9a37fd02019-04-12 16:09:24 +0200437int cli_socket_setenv()
438{
439 if (listeners_setenv(global.stats_fe, "HAPROXY_CLI") < 0)
440 return -1;
441 if (listeners_setenv(mworker_proxy, "HAPROXY_MASTER_CLI") < 0)
442 return -1;
443
444 return 0;
445}
446
William Lallemand33d29e22019-04-01 11:30:06 +0200447REGISTER_CONFIG_POSTPARSER("cli", cli_socket_setenv);
448
Willy Tarreaude57a572016-11-23 17:01:39 +0100449/* Verifies that the CLI at least has a level at least as high as <level>
450 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
451 * failure, an error message is prepared and the appctx's state is adjusted
452 * to print it so that a return 1 is enough to abort any processing.
453 */
454int cli_has_level(struct appctx *appctx, int level)
455{
Willy Tarreaude57a572016-11-23 17:01:39 +0100456
William Lallemandf630d012018-12-13 09:05:44 +0100457 if ((appctx->cli_level & ACCESS_LVL_MASK) < level) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200458 cli_err(appctx, stats_permission_denied_msg);
Willy Tarreaude57a572016-11-23 17:01:39 +0100459 return 0;
460 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100461 return 1;
462}
463
William Lallemandb7ea1412018-12-13 09:05:47 +0100464/* same as cli_has_level but for the CLI proxy and without error message */
465int pcli_has_level(struct stream *s, int level)
466{
467 if ((s->pcli_flags & ACCESS_LVL_MASK) < level) {
468 return 0;
469 }
470 return 1;
471}
472
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200473/* Returns severity_output for the current session if set, or default for the socket */
474static int cli_get_severity_output(struct appctx *appctx)
475{
476 if (appctx->cli_severity_output)
477 return appctx->cli_severity_output;
478 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
479}
William Lallemand74c24fb2016-11-21 17:18:36 +0100480
Willy Tarreau41908562016-11-24 16:23:38 +0100481/* Processes the CLI interpreter on the stats socket. This function is called
482 * from the CLI's IO handler running in an appctx context. The function returns 1
483 * if the request was understood, otherwise zero. It is called with appctx->st0
484 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
485 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
486 * have its own I/O handler called again. Most of the time, parsers will only
487 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100488 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
489 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100490 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200491static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100492{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200493 char *args[MAX_STATS_ARGS + 1], *p, *end, *payload = NULL;
494 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100495 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100496
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200497 appctx->st2 = 0;
498 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
William Lallemand74c24fb2016-11-21 17:18:36 +0100499
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200500 p = appctx->chunk->area;
501 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100502
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200503 /*
504 * Get the payload start if there is one.
505 * For the sake of simplicity, the payload pattern is looked up
506 * everywhere from the start of the input but it can only be found
507 * at the end of the first line if APPCTX_CLI_ST1_PAYLOAD is set.
508 *
509 * The input string was zero terminated so it is safe to use
510 * the str*() functions throughout the parsing
511 */
512 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
513 payload = strstr(p, PAYLOAD_PATTERN);
514 end = payload;
515 /* skip the pattern */
516 payload += strlen(PAYLOAD_PATTERN);
517 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100518
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200519 /*
520 * Get pointers on words.
521 * One extra slot is reserved to store a pointer on a null byte.
522 */
523 while (i < MAX_STATS_ARGS && p < end) {
524 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100525
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200526 /* skip leading spaces/tabs */
527 p += strspn(p, " \t");
528 if (!*p)
529 break;
William Lallemand74c24fb2016-11-21 17:18:36 +0100530
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200531 args[i] = p;
532 p += strcspn(p, " \t");
533 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100534
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200535 /* unescape backslashes (\) */
536 for (j = 0, k = 0; args[i][k]; k++) {
537 if (args[i][k] == '\\') {
538 if (args[i][k + 1] == '\\')
539 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100540 else
541 continue;
542 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200543 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100544 j++;
545 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200546 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100547
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200548 i++;
549 }
550 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200551 p = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200552 for (; i < MAX_STATS_ARGS + 1; i++)
553 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100554
555 kw = cli_find_kw(args);
Willy Tarreaueaffde32016-12-16 17:59:25 +0100556 if (!kw)
Willy Tarreau41908562016-11-24 16:23:38 +0100557 return 0;
558
William Lallemand14721be2018-10-26 14:47:37 +0200559 /* in a worker or normal process, don't display master only commands */
560 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
561 return 0;
562
563 /* in master don't displays if we don't have the master bits */
564 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
565 return 0;
566
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200567 /* only accept expert commands in expert mode */
568 if ((kw->level & ~appctx->cli_level) & ACCESS_EXPERT)
569 return 0;
570
Willy Tarreau41908562016-11-24 16:23:38 +0100571 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200572 appctx->io_release = kw->io_release;
William Lallemand90b098c2019-10-25 21:10:14 +0200573
574 if (kw->parse && kw->parse(args, payload, appctx, kw->private) != 0)
575 goto fail;
576
577 /* kw->parse could set its own io_handler or io_release handler */
578 if (!appctx->io_handler)
579 goto fail;
580
581 appctx->st0 = CLI_ST_CALLBACK;
582 return 1;
583fail:
584 appctx->io_handler = NULL;
585 appctx->io_release = NULL;
Willy Tarreau41908562016-11-24 16:23:38 +0100586 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100587}
588
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200589/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
590static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
591{
Willy Tarreau83061a82018-07-13 11:56:34 +0200592 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200593
594 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200595 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200596
597 tmp = get_trash_chunk();
598 chunk_reset(tmp);
599
600 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100601 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200602 chunk_printf(tmp, "[%d]: ", severity);
603 }
604 else {
605 switch (severity_output) {
606 case CLI_SEVERITY_NUMBER:
607 chunk_printf(tmp, "[%d]: ", severity);
608 break;
609 case CLI_SEVERITY_STRING:
610 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
611 break;
612 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100613 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200614 }
615 }
616 chunk_appendf(tmp, "%s", msg);
617
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200618 return ci_putblk(chn, tmp->area, strlen(tmp->area));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200619}
620
William Lallemand74c24fb2016-11-21 17:18:36 +0100621/* This I/O handler runs as an applet embedded in a stream interface. It is
622 * used to processes I/O from/to the stats unix socket. The system relies on a
623 * state machine handling requests and various responses. We read a request,
624 * then we process it and send the response, and we possibly display a prompt.
625 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100626 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100627 * or not.
628 */
629static void cli_io_handler(struct appctx *appctx)
630{
631 struct stream_interface *si = appctx->owner;
632 struct channel *req = si_oc(si);
633 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200634 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100635 int reql;
636 int len;
637
638 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
639 goto out;
640
Joseph Herlant008b3ce2018-11-25 12:51:45 -0800641 /* Check if the input buffer is available. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200642 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +0100643 /* buf.size==0 means we failed to get a buffer and were
644 * already subscribed to a wait list to get a buffer.
645 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100646 goto out;
647 }
648
William Lallemand74c24fb2016-11-21 17:18:36 +0100649 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100650 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100651 /* Stats output not initialized yet */
652 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200653 /* reset severity to default at init */
654 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100655 appctx->st0 = CLI_ST_GETREQ;
William Lallemandf630d012018-12-13 09:05:44 +0100656 appctx->cli_level = bind_conf->level;
William Lallemand74c24fb2016-11-21 17:18:36 +0100657 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100658 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100659 /* Let's close for real now. We just close the request
660 * side, the conditions below will complete if needed.
661 */
662 si_shutw(si);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200663 free_trash_chunk(appctx->chunk);
William Lallemand74c24fb2016-11-21 17:18:36 +0100664 break;
665 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100666 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200667 char *str;
668
669 /* use a trash chunk to store received data */
670 if (!appctx->chunk) {
671 appctx->chunk = alloc_trash_chunk();
672 if (!appctx->chunk) {
673 appctx->st0 = CLI_ST_END;
674 continue;
675 }
676 }
677
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200678 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200679
William Lallemand74c24fb2016-11-21 17:18:36 +0100680 /* ensure we have some output room left in the event we
681 * would want to return some info right after parsing.
682 */
683 if (buffer_almost_full(si_ib(si))) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100684 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100685 break;
686 }
687
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200688 /* '- 1' is to ensure a null byte can always be inserted at the end */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200689 reql = co_getline(si_oc(si), str,
690 appctx->chunk->size - appctx->chunk->data - 1);
William Lallemand74c24fb2016-11-21 17:18:36 +0100691 if (reql <= 0) { /* closed or EOL not found */
692 if (reql == 0)
693 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100694 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100695 continue;
696 }
697
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200698 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
699 /* seek for a possible unescaped semi-colon. If we find
700 * one, we replace it with an LF and skip only this part.
701 */
702 for (len = 0; len < reql; len++) {
703 if (str[len] == '\\') {
704 len++;
705 continue;
706 }
707 if (str[len] == ';') {
708 str[len] = '\n';
709 reql = len + 1;
710 break;
711 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100712 }
713 }
714
715 /* now it is time to check that we have a full line,
716 * remove the trailing \n and possibly \r, then cut the
717 * line.
718 */
719 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200720 if (str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100721 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100722 continue;
723 }
724
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200725 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100726 len--;
727
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200728 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200729 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200730
731 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200732 appctx->chunk->area[appctx->chunk->data] = '\n';
733 appctx->chunk->area[appctx->chunk->data + 1] = 0;
734 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200735 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100736
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100737 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200738
739 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
740 /* empty line */
741 if (!len) {
742 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200743 appctx->chunk->data -= 2;
744 appctx->chunk->area[appctx->chunk->data] = 0;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200745
746 if (!cli_parse_request(appctx))
747 cli_gen_usage_msg(appctx);
748
749 chunk_reset(appctx->chunk);
750 /* NB: cli_sock_parse_request() may have put
751 * another CLI_ST_O_* into appctx->st0.
752 */
753
754 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +0100755 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100756 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200757 else {
758 /*
759 * Look for the "payload start" pattern at the end of a line
760 * Its location is not remembered here, this is just to switch
761 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +0100762 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200763 if (!strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200764 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200765 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200766 /* no payload, the command is complete: parse the request */
767 if (!cli_parse_request(appctx))
768 cli_gen_usage_msg(appctx);
769
770 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200771 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100772 }
773
774 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200775 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100776 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
777 }
778 else { /* output functions */
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200779 const char *msg;
780 int sev;
781
William Lallemand74c24fb2016-11-21 17:18:36 +0100782 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100783 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100784 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200785 case CLI_ST_PRINT: /* print const message in msg */
786 case CLI_ST_PRINT_ERR: /* print const error in msg */
787 case CLI_ST_PRINT_DYN: /* print dyn message in msg, free */
788 case CLI_ST_PRINT_FREE: /* print dyn error in err, free */
789 if (appctx->st0 == CLI_ST_PRINT || appctx->st0 == CLI_ST_PRINT_ERR) {
790 sev = appctx->st0 == CLI_ST_PRINT_ERR ?
791 LOG_ERR : appctx->ctx.cli.severity;
792 msg = appctx->ctx.cli.msg;
793 }
794 else if (appctx->st0 == CLI_ST_PRINT_DYN || appctx->st0 == CLI_ST_PRINT_FREE) {
795 sev = appctx->st0 == CLI_ST_PRINT_FREE ?
796 LOG_ERR : appctx->ctx.cli.severity;
797 msg = appctx->ctx.cli.err;
798 if (!msg) {
799 sev = LOG_ERR;
800 msg = "Out of memory.\n";
801 }
802 }
803 else {
804 sev = LOG_ERR;
805 msg = "Internal error.\n";
806 }
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200807
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200808 if (cli_output_msg(res, msg, sev, cli_get_severity_output(appctx)) != -1) {
809 if (appctx->st0 == CLI_ST_PRINT_FREE ||
810 appctx->st0 == CLI_ST_PRINT_DYN) {
811 free(appctx->ctx.cli.err);
812 appctx->ctx.cli.err = NULL;
813 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100814 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100815 }
816 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100817 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100818 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200819
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100820 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100821 if (appctx->io_handler)
822 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100823 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100824 if (appctx->io_release) {
825 appctx->io_release(appctx);
826 appctx->io_release = NULL;
827 }
828 }
829 break;
830 default: /* abnormal state */
831 si->flags |= SI_FL_ERR;
832 break;
833 }
834
835 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100836 if (appctx->st0 == CLI_ST_PROMPT) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200837 const char *prompt = "";
838
839 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
840 /*
841 * when entering a payload with interactive mode, change the prompt
842 * to emphasize that more data can still be sent
843 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200844 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200845 prompt = "+ ";
846 else
847 prompt = "\n> ";
848 }
849 else {
William Lallemandad032882019-07-01 10:56:15 +0200850 if (!(appctx->st1 & (APPCTX_CLI_ST1_PAYLOAD|APPCTX_CLI_ST1_NOLF)))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200851 prompt = "\n";
852 }
853
854 if (ci_putstr(si_ic(si), prompt) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100855 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100856 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100857 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100858 }
859
860 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100861 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100862 break;
863
864 /* Now we close the output if one of the writers did so,
865 * or if we're not in interactive mode and the request
866 * buffer is empty. This still allows pipelined requests
867 * to be sent in non-interactive mode.
868 */
William Lallemand3de09d52018-12-11 16:10:56 +0100869 if (((res->flags & (CF_SHUTW|CF_SHUTW_NOW))) ||
870 (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req) && (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)))) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100871 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100872 continue;
873 }
874
875 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100876 appctx->st0 = CLI_ST_GETREQ;
William Lallemandad032882019-07-01 10:56:15 +0200877 /* reactivate the \n at the end of the response for the next command */
878 appctx->st1 &= ~APPCTX_CLI_ST1_NOLF;
William Lallemand74c24fb2016-11-21 17:18:36 +0100879 }
880 }
881
882 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
883 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
884 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
885 /* Other side has closed, let's abort if we have no more processing to do
886 * and nothing more to consume. This is comparable to a broken pipe, so
887 * we forward the close to the request side so that it flows upstream to
888 * the client.
889 */
890 si_shutw(si);
891 }
892
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100893 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100894 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
895 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
896 /* We have no more processing to do, and nothing more to send, and
897 * the client side has closed. So we'll forward this state downstream
898 * on the response buffer.
899 */
900 si_shutr(si);
901 res->flags |= CF_READ_NULL;
902 }
903
904 out:
Christopher Faulet45073512018-07-20 10:16:29 +0200905 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 +0100906 __FUNCTION__, __LINE__,
Christopher Faulet45073512018-07-20 10:16:29 +0200907 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 +0100908}
909
William Lallemand74c24fb2016-11-21 17:18:36 +0100910/* This is called when the stream interface is closed. For instance, upon an
911 * external abort, we won't call the i/o handler anymore so we may need to
912 * remove back references to the stream currently being dumped.
913 */
914static void cli_release_handler(struct appctx *appctx)
915{
916 if (appctx->io_release) {
917 appctx->io_release(appctx);
918 appctx->io_release = NULL;
919 }
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200920 else if (appctx->st0 == CLI_ST_PRINT_FREE || appctx->st0 == CLI_ST_PRINT_DYN) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100921 free(appctx->ctx.cli.err);
922 appctx->ctx.cli.err = NULL;
923 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100924}
925
926/* This function dumps all environmnent variables to the buffer. It returns 0
927 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +0100928 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
929 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +0100930 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100931static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100932{
Willy Tarreau0a739292016-11-22 20:21:23 +0100933 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100934 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100935
936 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
937 return 1;
938
939 chunk_reset(&trash);
940
941 /* we have two inner loops here, one for the proxy, the other one for
942 * the buffer.
943 */
Willy Tarreauf6710f82016-12-16 17:45:44 +0100944 while (*var) {
945 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +0100946
Willy Tarreau06d80a92017-10-19 14:32:15 +0200947 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100948 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100949 return 0;
950 }
951 if (appctx->st2 == STAT_ST_END)
952 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100953 var++;
954 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +0100955 }
956
957 /* dump complete */
958 return 1;
959}
960
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200961/* This function dumps all file descriptors states (or the requested one) to
962 * the buffer. It returns 0 if the output buffer is full and it needs to be
963 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
964 * It uses cli.i0 as the fd number to restart from.
965 */
966static int cli_io_handler_show_fd(struct appctx *appctx)
967{
968 struct stream_interface *si = appctx->owner;
969 int fd = appctx->ctx.cli.i0;
Willy Tarreauca1b1572018-12-18 15:45:11 +0100970 int ret = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200971
972 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
Willy Tarreauca1b1572018-12-18 15:45:11 +0100973 goto end;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200974
975 chunk_reset(&trash);
976
Willy Tarreauca1b1572018-12-18 15:45:11 +0100977 /* isolate the threads once per round. We're limited to a buffer worth
978 * of output anyway, it cannot last very long.
979 */
980 thread_isolate();
981
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200982 /* we have two inner loops here, one for the proxy, the other one for
983 * the buffer.
984 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +0100985 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200986 struct fdtab fdt;
Willy Tarreau286ec682017-08-09 16:35:44 +0200987 struct listener *li = NULL;
988 struct server *sv = NULL;
989 struct proxy *px = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +0200990 const struct mux_ops *mux = NULL;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200991 void *ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +0200992 uint32_t conn_flags = 0;
Willy Tarreaue9ca8072018-12-19 18:40:58 +0100993 int is_back = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200994
995 fdt = fdtab[fd];
996
Willy Tarreauca1b1572018-12-18 15:45:11 +0100997 if (!fdt.owner)
Willy Tarreau017af242017-10-04 20:24:54 +0200998 goto skip; // closed
999
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001000 if (fdt.iocb == conn_fd_handler) {
1001 conn_flags = ((struct connection *)fdt.owner)->flags;
Willy Tarreau35b1b482018-03-28 18:41:30 +02001002 mux = ((struct connection *)fdt.owner)->mux;
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001003 ctx = ((struct connection *)fdt.owner)->ctx;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001004 li = objt_listener(((struct connection *)fdt.owner)->target);
1005 sv = objt_server(((struct connection *)fdt.owner)->target);
1006 px = objt_proxy(((struct connection *)fdt.owner)->target);
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001007 is_back = conn_is_back((struct connection *)fdt.owner);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001008 }
1009 else if (fdt.iocb == listener_accept)
1010 li = fdt.owner;
1011
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001012 chunk_printf(&trash,
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001013 " %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 +02001014 fd,
1015 fdt.state,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001016 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
1017 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001018 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
1019 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
1020 fdt.ev,
1021 (fdt.ev & FD_POLL_HUP) ? 'H' : 'h',
1022 (fdt.ev & FD_POLL_ERR) ? 'E' : 'e',
1023 (fdt.ev & FD_POLL_OUT) ? 'O' : 'o',
1024 (fdt.ev & FD_POLL_PRI) ? 'P' : 'p',
1025 (fdt.ev & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001026 fdt.linger_risk ? 'L' : 'l',
1027 fdt.cloned ? 'C' : 'c',
Willy Tarreauc754b342018-03-30 15:00:15 +02001028 fdt.thread_mask, fdt.update_mask,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001029 fdt.owner,
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001030 fdt.iocb);
1031 resolve_sym_name(&trash, NULL, fdt.iocb);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001032
1033 if (fdt.iocb == conn_fd_handler) {
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001034 chunk_appendf(&trash, ") back=%d cflg=0x%08x", is_back, conn_flags);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001035 if (px)
1036 chunk_appendf(&trash, " px=%s", px->id);
1037 else if (sv)
1038 chunk_appendf(&trash, " sv=%s/%s", sv->id, sv->proxy->id);
1039 else if (li)
1040 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +02001041
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001042 if (mux) {
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001043 chunk_appendf(&trash, " mux=%s ctx=%p", mux->name, ctx);
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001044 if (mux->show_fd)
1045 mux->show_fd(&trash, fdt.owner);
1046 }
Willy Tarreau35b1b482018-03-28 18:41:30 +02001047 else
1048 chunk_appendf(&trash, " nomux");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001049 }
1050 else if (fdt.iocb == listener_accept) {
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001051 chunk_appendf(&trash, ") l.st=%s fe=%s",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001052 listener_state_str(li),
1053 li->bind_conf->frontend->id);
1054 }
1055
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001056 chunk_appendf(&trash, ")\n");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001057
Willy Tarreau06d80a92017-10-19 14:32:15 +02001058 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001059 si_rx_room_blk(si);
Willy Tarreauca1b1572018-12-18 15:45:11 +01001060 appctx->ctx.cli.i0 = fd;
1061 ret = 0;
1062 break;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001063 }
1064 skip:
1065 if (appctx->st2 == STAT_ST_END)
1066 break;
1067
1068 fd++;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001069 }
1070
Willy Tarreauca1b1572018-12-18 15:45:11 +01001071 end:
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001072 /* dump complete */
Willy Tarreauca1b1572018-12-18 15:45:11 +01001073
1074 thread_release();
1075 return ret;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001076}
1077
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001078/* This function dumps some activity counters used by developers and support to
1079 * rule out some hypothesis during bug reports. It returns 0 if the output
1080 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
1081 * everything at once in the buffer and is not designed to do it in multiple
1082 * passes.
1083 */
1084static int cli_io_handler_show_activity(struct appctx *appctx)
1085{
1086 struct stream_interface *si = appctx->owner;
1087 int thr;
1088
1089 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1090 return 1;
1091
1092 chunk_reset(&trash);
1093
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001094#undef SHOW_TOT
1095#define SHOW_TOT(t, x) \
Willy Tarreaua0211b82019-05-28 15:09:08 +02001096 do { \
1097 unsigned int _v[MAX_THREADS]; \
1098 unsigned int _tot; \
1099 const unsigned int _nbt = global.nbthread; \
1100 for (_tot = t = 0; t < _nbt; t++) \
1101 _tot += _v[t] = (x); \
1102 if (_nbt == 1) { \
1103 chunk_appendf(&trash, " %u\n", _tot); \
1104 break; \
1105 } \
1106 chunk_appendf(&trash, " %u [", _tot); \
1107 for (t = 0; t < _nbt; t++) \
1108 chunk_appendf(&trash, " %u", _v[t]); \
1109 chunk_appendf(&trash, " ]\n"); \
1110 } while (0)
1111
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001112#undef SHOW_AVG
1113#define SHOW_AVG(t, x) \
1114 do { \
1115 unsigned int _v[MAX_THREADS]; \
1116 unsigned int _tot; \
1117 const unsigned int _nbt = global.nbthread; \
1118 for (_tot = t = 0; t < _nbt; t++) \
1119 _tot += _v[t] = (x); \
1120 if (_nbt == 1) { \
1121 chunk_appendf(&trash, " %u\n", _tot); \
1122 break; \
1123 } \
1124 chunk_appendf(&trash, " %u [", (_tot + _nbt/2) / _nbt); \
1125 for (t = 0; t < _nbt; t++) \
1126 chunk_appendf(&trash, " %u", _v[t]); \
1127 chunk_appendf(&trash, " ]\n"); \
1128 } while (0)
1129
Willy Tarreaua0211b82019-05-28 15:09:08 +02001130 chunk_appendf(&trash, "thread_id: %u (%u..%u)\n", tid + 1, 1, global.nbthread);
1131 chunk_appendf(&trash, "date_now: %lu.%06lu\n", (long)now.tv_sec, (long)now.tv_usec);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001132 chunk_appendf(&trash, "loops:"); SHOW_TOT(thr, activity[thr].loops);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001133 chunk_appendf(&trash, "wake_tasks:"); SHOW_TOT(thr, activity[thr].wake_tasks);
1134 chunk_appendf(&trash, "wake_signal:"); SHOW_TOT(thr, activity[thr].wake_signal);
1135 chunk_appendf(&trash, "poll_exp:"); SHOW_TOT(thr, activity[thr].poll_exp);
1136 chunk_appendf(&trash, "poll_drop:"); SHOW_TOT(thr, activity[thr].poll_drop);
1137 chunk_appendf(&trash, "poll_dead:"); SHOW_TOT(thr, activity[thr].poll_dead);
1138 chunk_appendf(&trash, "poll_skip:"); SHOW_TOT(thr, activity[thr].poll_skip);
1139 chunk_appendf(&trash, "fd_lock:"); SHOW_TOT(thr, activity[thr].fd_lock);
1140 chunk_appendf(&trash, "conn_dead:"); SHOW_TOT(thr, activity[thr].conn_dead);
1141 chunk_appendf(&trash, "stream:"); SHOW_TOT(thr, activity[thr].stream);
Willy Tarreaua8b2ce02019-05-28 17:04:16 +02001142 chunk_appendf(&trash, "pool_fail:"); SHOW_TOT(thr, activity[thr].pool_fail);
1143 chunk_appendf(&trash, "buf_wait:"); SHOW_TOT(thr, activity[thr].buf_wait);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001144 chunk_appendf(&trash, "empty_rq:"); SHOW_TOT(thr, activity[thr].empty_rq);
1145 chunk_appendf(&trash, "long_rq:"); SHOW_TOT(thr, activity[thr].long_rq);
1146 chunk_appendf(&trash, "ctxsw:"); SHOW_TOT(thr, activity[thr].ctxsw);
1147 chunk_appendf(&trash, "tasksw:"); SHOW_TOT(thr, activity[thr].tasksw);
1148 chunk_appendf(&trash, "cpust_ms_tot:"); SHOW_TOT(thr, activity[thr].cpust_total / 2);
1149 chunk_appendf(&trash, "cpust_ms_1s:"); SHOW_TOT(thr, read_freq_ctr(&activity[thr].cpust_1s) / 2);
1150 chunk_appendf(&trash, "cpust_ms_15s:"); SHOW_TOT(thr, read_freq_ctr_period(&activity[thr].cpust_15s, 15000) / 2);
1151 chunk_appendf(&trash, "avg_loop_us:"); SHOW_AVG(thr, swrate_avg(activity[thr].avg_loop_us, TIME_STATS_SAMPLES));
1152 chunk_appendf(&trash, "accepted:"); SHOW_TOT(thr, activity[thr].accepted);
1153 chunk_appendf(&trash, "accq_pushed:"); SHOW_TOT(thr, activity[thr].accq_pushed);
1154 chunk_appendf(&trash, "accq_full:"); SHOW_TOT(thr, activity[thr].accq_full);
Willy Tarreaue6182842019-04-15 18:54:10 +02001155#ifdef USE_THREAD
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001156 chunk_appendf(&trash, "accq_ring:"); SHOW_TOT(thr, (accept_queue_rings[thr].tail - accept_queue_rings[thr].head + ACCEPT_QUEUE_SIZE) % ACCEPT_QUEUE_SIZE);
Willy Tarreaue6182842019-04-15 18:54:10 +02001157#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001158
Willy Tarreaud6a78502019-05-27 07:03:38 +02001159#if defined(DEBUG_DEV)
1160 /* keep these ones at the end */
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001161 chunk_appendf(&trash, "ctr0:"); SHOW_TOT(thr, activity[thr].ctr0);
1162 chunk_appendf(&trash, "ctr1:"); SHOW_TOT(thr, activity[thr].ctr1);
1163 chunk_appendf(&trash, "ctr2:"); SHOW_TOT(thr, activity[thr].ctr2);
Willy Tarreaud6a78502019-05-27 07:03:38 +02001164#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001165
1166 if (ci_putchk(si_ic(si), &trash) == -1) {
1167 chunk_reset(&trash);
1168 chunk_printf(&trash, "[output too large, cannot dump]\n");
Willy Tarreaudb398432018-11-15 11:08:52 +01001169 si_rx_room_blk(si);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001170 }
1171
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001172#undef SHOW_AVG
1173#undef SHOW_TOT
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001174 /* dump complete */
1175 return 1;
1176}
1177
William Lallemandeceddf72016-12-15 18:06:44 +01001178/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001179 * CLI IO handler for `show cli sockets`.
1180 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +01001181 */
1182static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1183{
1184 struct bind_conf *bind_conf;
1185 struct stream_interface *si = appctx->owner;
1186
1187 chunk_reset(&trash);
1188
1189 switch (appctx->st2) {
1190 case STAT_ST_INIT:
1191 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +02001192 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001193 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001194 return 0;
1195 }
William Lallemandeceddf72016-12-15 18:06:44 +01001196 appctx->st2 = STAT_ST_LIST;
1197
1198 case STAT_ST_LIST:
1199 if (global.stats_fe) {
1200 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
1201 struct listener *l;
1202
1203 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001204 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +01001205 * if the current node is the first of the list
1206 */
1207
Willy Tarreau3af9d832016-12-16 12:58:09 +01001208 if (appctx->ctx.cli.p0 &&
1209 &bind_conf->by_fe == (&global.stats_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +01001210 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +01001211 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +01001212 continue;
1213 }
1214
1215 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
1216
1217 char addr[46];
1218 char port[6];
1219
1220 if (l->addr.ss_family == AF_UNIX) {
1221 const struct sockaddr_un *un;
1222
1223 un = (struct sockaddr_un *)&l->addr;
William Lallemande58915f2019-04-01 11:30:05 +02001224 if (un->sun_path[0] == '\0') {
William Lallemand75812a72019-04-01 11:30:04 +02001225 chunk_appendf(&trash, "abns@%s ", un->sun_path+1);
William Lallemande58915f2019-04-01 11:30:05 +02001226 } else {
1227 chunk_appendf(&trash, "unix@%s ", un->sun_path);
1228 }
William Lallemandeceddf72016-12-15 18:06:44 +01001229 } else if (l->addr.ss_family == AF_INET) {
1230 addr_to_str(&l->addr, addr, sizeof(addr));
1231 port_to_str(&l->addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001232 chunk_appendf(&trash, "ipv4@%s:%s ", addr, port);
William Lallemandeceddf72016-12-15 18:06:44 +01001233 } else if (l->addr.ss_family == AF_INET6) {
1234 addr_to_str(&l->addr, addr, sizeof(addr));
1235 port_to_str(&l->addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001236 chunk_appendf(&trash, "ipv6@[%s]:%s ", addr, port);
William Lallemand26314342018-10-26 14:47:41 +02001237 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
1238 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
William Lallemandeceddf72016-12-15 18:06:44 +01001239 } else
William Lallemand26314342018-10-26 14:47:41 +02001240 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001241
William Lallemand07a62f72017-05-24 00:57:40 +02001242 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +01001243 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +02001244 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1245 chunk_appendf(&trash, "operator ");
1246 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1247 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +01001248 else
1249 chunk_appendf(&trash, " ");
1250
1251 if (bind_conf->bind_proc != 0) {
1252 int pos;
Willy Tarreau20c5e522016-12-16 12:50:55 +01001253 for (pos = 0; pos < 8 * sizeof(bind_conf->bind_proc); pos++) {
Willy Tarreau4305ac72016-12-16 12:56:31 +01001254 if (bind_conf->bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +01001255 chunk_appendf(&trash, "%d,", pos+1);
1256 }
1257 }
1258 /* replace the latest comma by a newline */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001259 trash.area[trash.data-1] = '\n';
William Lallemandeceddf72016-12-15 18:06:44 +01001260
1261 } else {
1262 chunk_appendf(&trash, "all\n");
1263 }
1264
Willy Tarreau06d80a92017-10-19 14:32:15 +02001265 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001266 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001267 return 0;
1268 }
1269 }
Willy Tarreau3af9d832016-12-16 12:58:09 +01001270 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001271 }
1272 }
1273 default:
1274 appctx->st2 = STAT_ST_FIN;
1275 return 1;
1276 }
1277}
1278
1279
Willy Tarreau0a739292016-11-22 20:21:23 +01001280/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001281 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1282 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001283 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001284static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001285{
1286 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001287 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001288
1289 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1290 return 1;
1291
Willy Tarreauf6710f82016-12-16 17:45:44 +01001292 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001293
1294 if (*args[2]) {
1295 int len = strlen(args[2]);
1296
Willy Tarreauf6710f82016-12-16 17:45:44 +01001297 for (; *var; var++) {
1298 if (strncmp(*var, args[2], len) == 0 &&
1299 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001300 break;
1301 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001302 if (!*var)
1303 return cli_err(appctx, "Variable not found\n");
1304
Willy Tarreau0a739292016-11-22 20:21:23 +01001305 appctx->st2 = STAT_ST_END;
1306 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001307 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001308 return 0;
1309}
1310
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001311/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1312 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1313 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1314 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001315static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001316{
1317 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1318 return 1;
1319
1320 appctx->ctx.cli.i0 = 0;
1321
1322 if (*args[2]) {
1323 appctx->ctx.cli.i0 = atoi(args[2]);
1324 appctx->st2 = STAT_ST_END;
1325 }
1326 return 0;
1327}
1328
Willy Tarreau599852e2016-11-22 20:33:32 +01001329/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001330static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001331{
1332 struct stream_interface *si = appctx->owner;
1333 struct stream *s = si_strm(si);
1334
1335 if (strcmp(args[2], "cli") == 0) {
1336 unsigned timeout;
1337 const char *res;
1338
Willy Tarreau9d008692019-08-09 11:21:01 +02001339 if (!*args[3])
1340 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001341
1342 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
Willy Tarreau9d008692019-08-09 11:21:01 +02001343 if (res || timeout < 1)
1344 return cli_err(appctx, "Invalid timeout value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001345
1346 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1347 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1348 return 1;
1349 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001350
1351 return cli_err(appctx, "'set timeout' only supports 'cli'.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001352}
1353
Willy Tarreau2af99412016-11-23 11:10:59 +01001354/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001355static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001356{
1357 int v;
1358
1359 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1360 return 1;
1361
Willy Tarreau9d008692019-08-09 11:21:01 +02001362 if (!*args[3])
1363 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001364
1365 v = atoi(args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001366 if (v > global.hardmaxconn)
1367 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001368
1369 /* check for unlimited values */
1370 if (v <= 0)
1371 v = global.hardmaxconn;
1372
1373 global.maxconn = v;
1374
1375 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001376 dequeue_all_listeners();
Willy Tarreau2af99412016-11-23 11:10:59 +01001377
1378 return 1;
1379}
1380
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001381static int set_severity_output(int *target, char *argument)
1382{
1383 if (!strcmp(argument, "none")) {
1384 *target = CLI_SEVERITY_NONE;
1385 return 1;
1386 }
1387 else if (!strcmp(argument, "number")) {
1388 *target = CLI_SEVERITY_NUMBER;
1389 return 1;
1390 }
1391 else if (!strcmp(argument, "string")) {
1392 *target = CLI_SEVERITY_STRING;
1393 return 1;
1394 }
1395 return 0;
1396}
1397
1398/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001399static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001400{
1401 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1402 return 0;
1403
Willy Tarreau9d008692019-08-09 11:21:01 +02001404 return cli_err(appctx, "one of 'none', 'number', 'string' is a required argument\n");
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001405}
William Lallemandeceddf72016-12-15 18:06:44 +01001406
William Lallemand67a234f2018-12-13 09:05:45 +01001407
1408/* show the level of the current CLI session */
1409static int cli_parse_show_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1410{
William Lallemand67a234f2018-12-13 09:05:45 +01001411 if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
Willy Tarreau9d008692019-08-09 11:21:01 +02001412 return cli_msg(appctx, LOG_INFO, "admin\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001413 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001414 return cli_msg(appctx, LOG_INFO, "operator\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001415 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001416 return cli_msg(appctx, LOG_INFO, "user\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001417 else
Willy Tarreau9d008692019-08-09 11:21:01 +02001418 return cli_msg(appctx, LOG_INFO, "unknown\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001419}
1420
1421/* parse and set the CLI level dynamically */
1422static int cli_parse_set_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1423{
William Lallemandad032882019-07-01 10:56:15 +02001424 /* this will ask the applet to not output a \n after the command */
1425 if (!strcmp(args[1], "-"))
1426 appctx->st1 |= APPCTX_CLI_ST1_NOLF;
1427
William Lallemand67a234f2018-12-13 09:05:45 +01001428 if (!strcmp(args[0], "operator")) {
1429 if (!cli_has_level(appctx, ACCESS_LVL_OPER)) {
1430 return 1;
1431 }
1432 appctx->cli_level &= ~ACCESS_LVL_MASK;
1433 appctx->cli_level |= ACCESS_LVL_OPER;
1434
1435 } else if (!strcmp(args[0], "user")) {
1436 if (!cli_has_level(appctx, ACCESS_LVL_USER)) {
1437 return 1;
1438 }
1439 appctx->cli_level &= ~ACCESS_LVL_MASK;
1440 appctx->cli_level |= ACCESS_LVL_USER;
1441 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001442 appctx->cli_level &= ~ACCESS_EXPERT;
1443 return 1;
1444}
1445
1446
1447/* parse and set the CLI expert-mode dynamically */
1448static int cli_parse_expert_mode(char **args, char *payload, struct appctx *appctx, void *private)
1449{
1450 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1451 return 1;
1452
1453 if (!*args[1])
1454 return (appctx->cli_level & ACCESS_EXPERT)
1455 ? cli_msg(appctx, LOG_INFO, "expert-mode is ON\n")
1456 : cli_msg(appctx, LOG_INFO, "expert-mode is OFF\n");
1457
1458 appctx->cli_level &= ~ACCESS_EXPERT;
1459 if (strcmp(args[1], "on") == 0)
1460 appctx->cli_level |= ACCESS_EXPERT;
William Lallemand67a234f2018-12-13 09:05:45 +01001461 return 1;
1462}
1463
William Lallemanda57b7e32018-12-14 21:11:31 +01001464
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001465int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001466{
1467 return 0;
1468}
1469
Willy Tarreau45c742b2016-11-24 14:51:17 +01001470/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001471static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001472{
1473 int v;
1474 int *res;
1475 int mul = 1;
1476
1477 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1478 return 1;
1479
1480 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1481 res = &global.cps_lim;
1482 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1483 res = &global.sps_lim;
1484#ifdef USE_OPENSSL
1485 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1486 res = &global.ssl_lim;
1487#endif
1488 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1489 res = &global.comp_rate_lim;
1490 mul = 1024;
1491 }
1492 else {
Willy Tarreau9d008692019-08-09 11:21:01 +02001493 return cli_err(appctx,
Willy Tarreau45c742b2016-11-24 14:51:17 +01001494 "'set rate-limit' only supports :\n"
1495 " - 'connections global' to set the per-process maximum connection rate\n"
1496 " - 'sessions global' to set the per-process maximum session rate\n"
1497#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001498 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001499#endif
Willy Tarreau9d008692019-08-09 11:21:01 +02001500 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001501 }
1502
Willy Tarreau9d008692019-08-09 11:21:01 +02001503 if (!*args[4])
1504 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001505
1506 v = atoi(args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001507 if (v < 0)
1508 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001509
1510 *res = v * mul;
1511
1512 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001513 dequeue_all_listeners();
Willy Tarreau45c742b2016-11-24 14:51:17 +01001514
1515 return 1;
1516}
1517
William Lallemandf6975e92017-05-26 17:42:10 +02001518/* parse the "expose-fd" argument on the bind lines */
1519static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1520{
1521 if (!*args[cur_arg + 1]) {
1522 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1523 return ERR_ALERT | ERR_FATAL;
1524 }
1525 if (!strcmp(args[cur_arg+1], "listeners")) {
1526 conf->level |= ACCESS_FD_LISTENERS;
1527 } else {
1528 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1529 args[cur_arg], args[cur_arg+1]);
1530 return ERR_ALERT | ERR_FATAL;
1531 }
1532
1533 return 0;
1534}
1535
William Lallemand74c24fb2016-11-21 17:18:36 +01001536/* parse the "level" argument on the bind lines */
1537static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1538{
1539 if (!*args[cur_arg + 1]) {
1540 memprintf(err, "'%s' : missing level", args[cur_arg]);
1541 return ERR_ALERT | ERR_FATAL;
1542 }
1543
William Lallemand07a62f72017-05-24 00:57:40 +02001544 if (!strcmp(args[cur_arg+1], "user")) {
1545 conf->level &= ~ACCESS_LVL_MASK;
1546 conf->level |= ACCESS_LVL_USER;
1547 } else if (!strcmp(args[cur_arg+1], "operator")) {
1548 conf->level &= ~ACCESS_LVL_MASK;
1549 conf->level |= ACCESS_LVL_OPER;
1550 } else if (!strcmp(args[cur_arg+1], "admin")) {
1551 conf->level &= ~ACCESS_LVL_MASK;
1552 conf->level |= ACCESS_LVL_ADMIN;
1553 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001554 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1555 args[cur_arg], args[cur_arg+1]);
1556 return ERR_ALERT | ERR_FATAL;
1557 }
1558
1559 return 0;
1560}
1561
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001562static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1563{
1564 if (!*args[cur_arg + 1]) {
1565 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1566 return ERR_ALERT | ERR_FATAL;
1567 }
1568
1569 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1570 return 0;
1571 else {
1572 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1573 args[cur_arg], args[cur_arg+1]);
1574 return ERR_ALERT | ERR_FATAL;
1575 }
1576}
1577
William Lallemandd308c5e2020-01-16 16:26:41 +01001578/*
1579 * For one proxy, fill the iov and send the msghdr. Also update fd_it and offset.
1580 * Return -1 upon error, otherwise 0.
1581 *
1582 * This function is only meant to deduplicate the code between the peers and
1583 * the proxy list in _getsocks(), not to be used anywhere else.
1584 */
1585inline static int _getsocks_gen_send(struct proxy *px, int sendfd, int *tmpfd, struct iovec *iov,
1586 int tot_fd_nb, int *fd_it, int *offset, struct msghdr *msghdr)
1587{
1588 int i = *fd_it;
1589 int curoff = *offset;
1590 struct listener *l;
1591 unsigned char *tmpbuf = iov->iov_base;
1592
1593 list_for_each_entry(l, &px->conf.listeners, by_fe) {
1594 int ret;
1595 /* Only transfer IPv4/IPv6 sockets */
1596 if (l->state >= LI_ZOMBIE &&
1597 (l->proto->sock_family == AF_INET ||
1598 l->proto->sock_family == AF_INET6 ||
1599 l->proto->sock_family == AF_UNIX)) {
1600 memcpy(&tmpfd[i % MAX_SEND_FD], &l->fd, sizeof(l->fd));
1601 if (!l->netns)
1602 tmpbuf[curoff++] = 0;
1603#ifdef USE_NS
1604 else {
1605 char *name = l->netns->node.key;
1606 unsigned char len = l->netns->name_len;
1607 tmpbuf[curoff++] = len;
1608 memcpy(tmpbuf + curoff, name, len);
1609 curoff += len;
1610 }
1611#endif
1612 if (l->interface) {
1613 unsigned char len = strlen(l->interface);
1614 tmpbuf[curoff++] = len;
1615 memcpy(tmpbuf + curoff, l->interface, len);
1616 curoff += len;
1617 } else
1618 tmpbuf[curoff++] = 0;
1619 memcpy(tmpbuf + curoff, &l->options,
1620 sizeof(l->options));
1621 curoff += sizeof(l->options);
1622
1623 i++;
1624 } else
1625 continue;
1626 /* if it reaches the max number of fd per msghdr */
1627 if ((!(i % MAX_SEND_FD))) {
1628 iov->iov_len = curoff;
1629 if (sendmsg(sendfd, msghdr, 0) != curoff) {
1630 ha_warning("Failed to transfer sockets\n");
1631 return -1;
1632 }
1633 /* Wait for an ack */
1634 do {
1635 ret = recv(sendfd, &tot_fd_nb,
1636 sizeof(tot_fd_nb), 0);
1637 } while (ret == -1 && errno == EINTR);
1638 if (ret <= 0) {
1639 ha_warning("Unexpected error while transferring sockets\n");
1640 return -1;
1641 }
1642 curoff = 0;
1643 }
1644 }
1645
1646 *fd_it = i;
1647 *offset = curoff;
1648
1649 return 0;
1650}
William Lallemand16dd1b32018-11-19 18:46:18 +01001651
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001652
Olivier Houchardf886e342017-04-05 22:24:59 +02001653/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001654static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02001655{
1656 char *cmsgbuf = NULL;
1657 unsigned char *tmpbuf = NULL;
1658 struct cmsghdr *cmsg;
1659 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001660 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001661 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001662 struct msghdr msghdr;
1663 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001664 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Olivier Houchardf886e342017-04-05 22:24:59 +02001665 int *tmpfd;
1666 int tot_fd_nb = 0;
1667 struct proxy *px;
William Lallemand5fd3b282020-01-16 15:32:08 +01001668 struct peers *prs;
Olivier Houchardf886e342017-04-05 22:24:59 +02001669 int i = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001670 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001671 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001672 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001673 int ret;
1674
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001675 if (!remote) {
1676 ha_warning("Only works on real connections\n");
1677 goto out;
1678 }
1679
1680 fd = remote->handle.fd;
1681
Olivier Houchardf886e342017-04-05 22:24:59 +02001682 /* Temporary set the FD in blocking mode, that will make our life easier */
1683 old_fcntl = fcntl(fd, F_GETFL);
1684 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001685 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001686 goto out;
1687 }
1688 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1689 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001690 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001691 goto out;
1692 }
1693 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001694 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001695 goto out;
1696 }
Olivier Houchard54740872017-04-06 14:45:14 +02001697 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001698 iov.iov_base = &tot_fd_nb;
1699 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001700 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001701 goto out;
1702 memset(&msghdr, 0, sizeof(msghdr));
1703 /*
1704 * First, calculates the total number of FD, so that we can let
1705 * the caller know how much he should expects.
1706 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001707 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001708 while (px) {
1709 struct listener *l;
1710
1711 list_for_each_entry(l, &px->conf.listeners, by_fe) {
Olivier Houchard1fc05162017-04-06 01:05:05 +02001712 /* Only transfer IPv4/IPv6/UNIX sockets */
1713 if (l->state >= LI_ZOMBIE &&
1714 (l->proto->sock_family == AF_INET ||
Olivier Houchardf886e342017-04-05 22:24:59 +02001715 l->proto->sock_family == AF_INET6 ||
Olivier Houchard1fc05162017-04-06 01:05:05 +02001716 l->proto->sock_family == AF_UNIX))
Olivier Houchardf886e342017-04-05 22:24:59 +02001717 tot_fd_nb++;
1718 }
1719 px = px->next;
1720 }
William Lallemand5fd3b282020-01-16 15:32:08 +01001721 prs = cfg_peers;
1722 while (prs) {
1723 if (prs->peers_fe) {
1724 struct listener *l;
1725
1726 list_for_each_entry(l, &prs->peers_fe->conf.listeners, by_fe) {
1727 /* Only transfer IPv4/IPv6/UNIX sockets */
1728 if (l->state >= LI_ZOMBIE &&
1729 (l->proto->sock_family == AF_INET ||
1730 l->proto->sock_family == AF_INET6 ||
1731 l->proto->sock_family == AF_UNIX))
1732 tot_fd_nb++;
1733 }
1734 }
1735 prs = prs->next;
1736 }
Olivier Houchardf886e342017-04-05 22:24:59 +02001737 if (tot_fd_nb == 0)
1738 goto out;
1739
1740 /* First send the total number of file descriptors, so that the
1741 * receiving end knows what to expect.
1742 */
1743 msghdr.msg_iov = &iov;
1744 msghdr.msg_iovlen = 1;
1745 ret = sendmsg(fd, &msghdr, 0);
1746 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001747 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001748 goto out;
1749 }
1750
1751 /* Now send the fds */
1752 msghdr.msg_control = cmsgbuf;
1753 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1754 cmsg = CMSG_FIRSTHDR(&msghdr);
1755 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1756 cmsg->cmsg_level = SOL_SOCKET;
1757 cmsg->cmsg_type = SCM_RIGHTS;
1758 tmpfd = (int *)CMSG_DATA(cmsg);
1759
Olivier Houchardf886e342017-04-05 22:24:59 +02001760 /* For each socket, e message is sent, containing the following :
1761 * Size of the namespace name (or 0 if none), as an unsigned char.
1762 * The namespace name, if any
1763 * Size of the interface name (or 0 if none), as an unsigned char
1764 * The interface name, if any
1765 * Listener options, as an int.
1766 */
1767 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
Ilya Shipitsind4259502020-04-08 01:07:56 +05001768 * buffer big enough to store the socket information.
Olivier Houchardf886e342017-04-05 22:24:59 +02001769 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001770 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001771 if (tmpbuf == NULL) {
Ilya Shipitsind4259502020-04-08 01:07:56 +05001772 ha_warning("Failed to allocate memory to transfer socket information\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001773 goto out;
1774 }
1775 iov.iov_base = tmpbuf;
William Lallemand5fd3b282020-01-16 15:32:08 +01001776 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001777 while (px) {
William Lallemandd308c5e2020-01-16 16:26:41 +01001778 if (_getsocks_gen_send(px, fd, tmpfd, &iov,
1779 tot_fd_nb, &i, &curoff, &msghdr) < 0)
1780 goto out;
Olivier Houchardf886e342017-04-05 22:24:59 +02001781 px = px->next;
1782 }
William Lallemand5fd3b282020-01-16 15:32:08 +01001783 /* should be done for peers too */
1784 prs = cfg_peers;
1785 while (prs) {
William Lallemandd308c5e2020-01-16 16:26:41 +01001786 if (prs->peers_fe)
1787 if (_getsocks_gen_send(prs->peers_fe, fd, tmpfd, &iov,
1788 tot_fd_nb, &i, &curoff, &msghdr) < 0)
1789 goto out;
William Lallemand5fd3b282020-01-16 15:32:08 +01001790 prs = prs->next;
1791 }
1792
Olivier Houchardf886e342017-04-05 22:24:59 +02001793 if (i % MAX_SEND_FD) {
1794 iov.iov_len = curoff;
1795 cmsg->cmsg_len = CMSG_LEN((i % MAX_SEND_FD) * sizeof(int));
1796 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * (i % MAX_SEND_FD));
1797 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001798 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001799 goto out;
1800 }
1801 }
1802
1803out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001804 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001805 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001806 goto out;
1807 }
1808 appctx->st0 = CLI_ST_END;
1809 free(cmsgbuf);
1810 free(tmpbuf);
1811 return 1;
1812}
1813
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001814static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
1815{
1816 if (*args[0] == 'h')
1817 /* help */
1818 cli_gen_usage_msg(appctx);
1819 else if (*args[0] == 'p')
1820 /* prompt */
1821 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
1822 else if (*args[0] == 'q')
1823 /* quit */
1824 appctx->st0 = CLI_ST_END;
1825
1826 return 1;
1827}
Olivier Houchardf886e342017-04-05 22:24:59 +02001828
William Lallemand2f4ce202018-10-26 14:47:47 +02001829void pcli_write_prompt(struct stream *s)
1830{
1831 struct buffer *msg = get_trash_chunk();
1832 struct channel *oc = si_oc(&s->si[0]);
1833
William Lallemanddc12c2e2018-12-13 09:05:46 +01001834 if (!(s->pcli_flags & PCLI_F_PROMPT))
William Lallemand5b80fa22018-12-11 16:10:54 +01001835 return;
1836
William Lallemanddc12c2e2018-12-13 09:05:46 +01001837 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01001838 chunk_appendf(msg, "+ ");
1839 } else {
1840 if (s->pcli_next_pid == 0)
Willy Tarreau52880f92018-12-15 13:30:03 +01001841 chunk_appendf(msg, "master%s> ",
1842 (global.mode & MODE_MWORKER_WAIT) ? "[ReloadFailed]" : "");
William Lallemandebf61802018-12-11 16:10:57 +01001843 else
1844 chunk_appendf(msg, "%d> ", s->pcli_next_pid);
1845 }
William Lallemand2f4ce202018-10-26 14:47:47 +02001846 co_inject(oc, msg->area, msg->data);
1847}
1848
William Lallemand291810d2018-10-26 14:47:38 +02001849
William Lallemandcf62f7e2018-10-26 14:47:40 +02001850/* The pcli_* functions are used for the CLI proxy in the master */
1851
William Lallemanddeeaa592018-10-26 14:47:48 +02001852void pcli_reply_and_close(struct stream *s, const char *msg)
1853{
1854 struct buffer *buf = get_trash_chunk();
1855
1856 chunk_initstr(buf, msg);
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001857 si_retnclose(&s->si[0], buf);
William Lallemanddeeaa592018-10-26 14:47:48 +02001858}
1859
William Lallemand291810d2018-10-26 14:47:38 +02001860static enum obj_type *pcli_pid_to_server(int proc_pid)
1861{
1862 struct mworker_proc *child;
1863
William Lallemandbddd33a2018-12-11 16:10:53 +01001864 /* return the CLI applet of the master */
1865 if (proc_pid == 0)
1866 return &cli_applet.obj_type;
1867
William Lallemand291810d2018-10-26 14:47:38 +02001868 list_for_each_entry(child, &proc_list, list) {
1869 if (child->pid == proc_pid){
1870 return &child->srv->obj_type;
1871 }
1872 }
1873 return NULL;
1874}
1875
1876/* Take a CLI prefix in argument (eg: @!1234 @master @1)
1877 * Return:
1878 * 0: master
1879 * > 0: pid of a worker
1880 * < 0: didn't find a worker
1881 */
1882static int pcli_prefix_to_pid(const char *prefix)
1883{
1884 int proc_pid;
1885 struct mworker_proc *child;
1886 char *errtol = NULL;
1887
1888 if (*prefix != '@') /* not a prefix, should not happen */
1889 return -1;
1890
1891 prefix++;
1892 if (!*prefix) /* sent @ alone, return the master */
1893 return 0;
1894
1895 if (strcmp("master", prefix) == 0) {
1896 return 0;
1897 } else if (*prefix == '!') {
1898 prefix++;
1899 if (!*prefix)
1900 return -1;
1901
1902 proc_pid = strtol(prefix, &errtol, 10);
1903 if (*errtol != '\0')
1904 return -1;
1905 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001906 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001907 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001908 if (child->pid == proc_pid){
1909 return child->pid;
1910 }
1911 }
1912 } else {
1913 struct mworker_proc *chosen = NULL;
1914 /* this is a relative pid */
1915
1916 proc_pid = strtol(prefix, &errtol, 10);
1917 if (*errtol != '\0')
1918 return -1;
1919
1920 if (proc_pid == 0) /* return the master */
1921 return 0;
1922
1923 /* chose the right process, the current one is the one with the
1924 least number of reloads */
1925 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001926 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001927 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001928 if (child->relative_pid == proc_pid){
1929 if (child->reloads == 0)
1930 return child->pid;
1931 else if (chosen == NULL || child->reloads < chosen->reloads)
1932 chosen = child;
1933 }
1934 }
1935 if (chosen)
1936 return chosen->pid;
1937 }
1938 return -1;
1939}
1940
William Lallemandbddd33a2018-12-11 16:10:53 +01001941/* Return::
1942 * >= 0 : number of words to escape
1943 * = -1 : error
1944 */
1945
1946int pcli_find_and_exec_kw(struct stream *s, char **args, int argl, char **errmsg, int *next_pid)
1947{
1948 if (argl < 1)
1949 return 0;
1950
1951 /* there is a prefix */
1952 if (args[0][0] == '@') {
1953 int target_pid = pcli_prefix_to_pid(args[0]);
1954
1955 if (target_pid == -1) {
1956 memprintf(errmsg, "Can't find the target PID matching the prefix '%s'\n", args[0]);
1957 return -1;
1958 }
1959
1960 /* if the prefix is alone, define a default target */
1961 if (argl == 1)
1962 s->pcli_next_pid = target_pid;
1963 else
1964 *next_pid = target_pid;
1965 return 1;
William Lallemand5b80fa22018-12-11 16:10:54 +01001966 } else if (!strcmp("prompt", args[0])) {
William Lallemanddc12c2e2018-12-13 09:05:46 +01001967 s->pcli_flags ^= PCLI_F_PROMPT;
William Lallemand5b80fa22018-12-11 16:10:54 +01001968 return argl; /* return the number of elements in the array */
William Lallemand5f610682018-12-11 16:10:55 +01001969
1970 } else if (!strcmp("quit", args[0])) {
1971 channel_shutr_now(&s->req);
1972 channel_shutw_now(&s->res);
1973 return argl; /* return the number of elements in the array */
William Lallemandb7ea1412018-12-13 09:05:47 +01001974 } else if (!strcmp(args[0], "operator")) {
1975 if (!pcli_has_level(s, ACCESS_LVL_OPER)) {
1976 memprintf(errmsg, "Permission denied!\n");
1977 return -1;
1978 }
1979 s->pcli_flags &= ~ACCESS_LVL_MASK;
1980 s->pcli_flags |= ACCESS_LVL_OPER;
1981 return argl;
1982
1983 } else if (!strcmp(args[0], "user")) {
1984 if (!pcli_has_level(s, ACCESS_LVL_USER)) {
1985 memprintf(errmsg, "Permission denied!\n");
1986 return -1;
1987 }
1988 s->pcli_flags &= ~ACCESS_LVL_MASK;
1989 s->pcli_flags |= ACCESS_LVL_USER;
1990 return argl;
William Lallemandbddd33a2018-12-11 16:10:53 +01001991 }
1992
1993 return 0;
1994}
1995
1996/*
1997 * Parse the CLI request:
1998 * - It does basically the same as the cli_io_handler, but as a proxy
1999 * - It can exec a command and strip non forwardable commands
William Lallemandcf62f7e2018-10-26 14:47:40 +02002000 *
2001 * Return:
William Lallemandbddd33a2018-12-11 16:10:53 +01002002 * - the number of characters to forward or
2003 * - 1 if there is an error or not enough data
William Lallemandcf62f7e2018-10-26 14:47:40 +02002004 */
William Lallemandbddd33a2018-12-11 16:10:53 +01002005int pcli_parse_request(struct stream *s, struct channel *req, char **errmsg, int *next_pid)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002006{
William Lallemandbddd33a2018-12-11 16:10:53 +01002007 char *str = (char *)ci_head(req);
2008 char *end = (char *)ci_stop(req);
2009 char *args[MAX_STATS_ARGS + 1]; /* +1 for storing a NULL */
2010 int argl; /* number of args */
2011 char *p;
2012 char *trim = NULL;
William Lallemandebf61802018-12-11 16:10:57 +01002013 char *payload = NULL;
William Lallemandbddd33a2018-12-11 16:10:53 +01002014 int wtrim = 0; /* number of words to trim */
2015 int reql = 0;
William Lallemandb7ea1412018-12-13 09:05:47 +01002016 int ret;
William Lallemandbddd33a2018-12-11 16:10:53 +01002017 int i = 0;
2018
2019 p = str;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002020
William Lallemanddc12c2e2018-12-13 09:05:46 +01002021 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002022
2023 /* Looks for the end of one command */
2024 while (p+reql < end) {
2025 /* handle escaping */
2026 if (p[reql] == '\\') {
2027 reql++;
2028 continue;
2029 }
2030 if (p[reql] == ';' || p[reql] == '\n') {
2031 /* found the end of the command */
2032 p[reql] = '\n';
2033 reql++;
2034 break;
2035 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002036 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002037 }
William Lallemandebf61802018-12-11 16:10:57 +01002038 } else {
2039 while (p+reql < end) {
2040 if (p[reql] == '\n') {
2041 /* found the end of the line */
2042 reql++;
2043 break;
2044 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002045 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002046 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002047 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002048
William Lallemandbddd33a2018-12-11 16:10:53 +01002049 /* set end to first byte after the end of the command */
2050 end = p + reql;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002051
William Lallemandbddd33a2018-12-11 16:10:53 +01002052 /* there is no end to this command, need more to parse ! */
2053 if (*(end-1) != '\n') {
2054 return -1;
2055 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002056
William Lallemand3301f3e2018-12-13 09:05:48 +01002057 if (s->pcli_flags & PCLI_F_PAYLOAD) {
2058 if (reql == 1) /* last line of the payload */
2059 s->pcli_flags &= ~PCLI_F_PAYLOAD;
William Lallemandebf61802018-12-11 16:10:57 +01002060 return reql;
2061 }
2062
William Lallemandbddd33a2018-12-11 16:10:53 +01002063 *(end-1) = '\0';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002064
William Lallemandbddd33a2018-12-11 16:10:53 +01002065 /* splits the command in words */
2066 while (i < MAX_STATS_ARGS && p < end) {
2067 int j, k;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002068
William Lallemandbddd33a2018-12-11 16:10:53 +01002069 /* skip leading spaces/tabs */
2070 p += strspn(p, " \t");
2071 if (!*p)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002072 break;
2073
William Lallemandbddd33a2018-12-11 16:10:53 +01002074 args[i] = p;
2075 p += strcspn(p, " \t");
2076 *p++ = 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002077
William Lallemandbddd33a2018-12-11 16:10:53 +01002078 /* unescape backslashes (\) */
2079 for (j = 0, k = 0; args[i][k]; k++) {
2080 if (args[i][k] == '\\') {
2081 if (args[i][k + 1] == '\\')
2082 k++;
2083 else
2084 continue;
2085 }
2086 args[i][j] = args[i][k];
2087 j++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002088 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002089 args[i][j] = 0;
2090 i++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002091 }
2092
William Lallemandbddd33a2018-12-11 16:10:53 +01002093 argl = i;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002094
William Lallemandbddd33a2018-12-11 16:10:53 +01002095 for (; i < MAX_STATS_ARGS + 1; i++)
2096 args[i] = NULL;
2097
2098 wtrim = pcli_find_and_exec_kw(s, args, argl, errmsg, next_pid);
2099
2100 /* End of words are ending by \0, we need to replace the \0s by spaces
21011 before forwarding them */
2102 p = str;
William Lallemand3301f3e2018-12-13 09:05:48 +01002103 while (p < end-1) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002104 if (*p == '\0')
2105 *p = ' ';
2106 p++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002107 }
2108
William Lallemand3301f3e2018-12-13 09:05:48 +01002109 payload = strstr(str, PAYLOAD_PATTERN);
2110 if ((end - 1) == (payload + strlen(PAYLOAD_PATTERN))) {
2111 /* if the payload pattern is at the end */
2112 s->pcli_flags |= PCLI_F_PAYLOAD;
2113 ret = reql;
2114 }
2115
William Lallemandbddd33a2018-12-11 16:10:53 +01002116 *(end-1) = '\n';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002117
William Lallemandbddd33a2018-12-11 16:10:53 +01002118 if (wtrim > 0) {
2119 trim = &args[wtrim][0];
2120 if (trim == NULL) /* if this was the last word in the table */
2121 trim = end;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002122
William Lallemandbddd33a2018-12-11 16:10:53 +01002123 b_del(&req->buf, trim - str);
2124
William Lallemandb7ea1412018-12-13 09:05:47 +01002125 ret = end - trim;
William Lallemandbddd33a2018-12-11 16:10:53 +01002126 } else if (wtrim < 0) {
2127 /* parsing error */
2128 return -1;
William Lallemandb7ea1412018-12-13 09:05:47 +01002129 } else {
2130 /* the whole string */
2131 ret = end - str;
William Lallemandbddd33a2018-12-11 16:10:53 +01002132 }
2133
William Lallemandb7ea1412018-12-13 09:05:47 +01002134 if (ret > 1) {
2135 if (pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2136 goto end;
2137 } else if (pcli_has_level(s, ACCESS_LVL_OPER)) {
William Lallemandad032882019-07-01 10:56:15 +02002138 ci_insert_line2(req, 0, "operator -", strlen("operator -"));
2139 ret += strlen("operator -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002140 } else if (pcli_has_level(s, ACCESS_LVL_USER)) {
William Lallemandad032882019-07-01 10:56:15 +02002141 ci_insert_line2(req, 0, "user -", strlen("user -"));
2142 ret += strlen("user -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002143 }
2144 }
2145end:
William Lallemandbddd33a2018-12-11 16:10:53 +01002146
William Lallemandb7ea1412018-12-13 09:05:47 +01002147 return ret;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002148}
2149
2150int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
2151{
William Lallemandbddd33a2018-12-11 16:10:53 +01002152 int next_pid = -1;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002153 int to_forward;
William Lallemandbddd33a2018-12-11 16:10:53 +01002154 char *errmsg = NULL;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002155
William Lallemandb7ea1412018-12-13 09:05:47 +01002156 if ((s->pcli_flags & ACCESS_LVL_MASK) == ACCESS_LVL_NONE)
2157 s->pcli_flags |= strm_li(s)->bind_conf->level & ACCESS_LVL_MASK;
2158
William Lallemandcf62f7e2018-10-26 14:47:40 +02002159read_again:
2160 /* if the channel is closed for read, we won't receive any more data
2161 from the client, but we don't want to forward this close to the
2162 server */
2163 channel_dont_close(req);
2164
2165 /* We don't know yet to which server we will connect */
2166 channel_dont_connect(req);
2167
2168
2169 /* we are not waiting for a response, there is no more request and we
2170 * receive a close from the client, we can leave */
2171 if (!(ci_data(req)) && req->flags & CF_SHUTR) {
2172 channel_shutw_now(&s->res);
2173 s->req.analysers &= ~AN_REQ_WAIT_CLI;
2174 return 1;
2175 }
2176
2177 req->flags |= CF_READ_DONTWAIT;
2178
2179 /* need more data */
2180 if (!ci_data(req))
2181 return 0;
2182
2183 /* If there is data available for analysis, log the end of the idle time. */
2184 if (c_data(req) && s->logs.t_idle == -1)
2185 s->logs.t_idle = tv_ms_elapsed(&s->logs.tv_accept, &now) - s->logs.t_handshake;
2186
William Lallemandbddd33a2018-12-11 16:10:53 +01002187 to_forward = pcli_parse_request(s, req, &errmsg, &next_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002188 if (to_forward > 0) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002189 int target_pid;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002190 /* enough data */
2191
William Lallemandcf62f7e2018-10-26 14:47:40 +02002192 /* forward only 1 command */
2193 channel_forward(req, to_forward);
William Lallemandebf61802018-12-11 16:10:57 +01002194
William Lallemanddc12c2e2018-12-13 09:05:46 +01002195 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002196 /* we send only 1 command per request, and we write close after it */
2197 channel_shutw_now(req);
2198 } else {
2199 pcli_write_prompt(s);
2200 }
2201
2202 s->res.flags |= CF_WAKE_ONCE; /* need to be called again */
William Lallemandcf62f7e2018-10-26 14:47:40 +02002203
2204 /* remove the XFER_DATA analysers, which forwards all
2205 * the data, we don't want to forward the next requests
2206 * We need to add CF_FLT_ANALYZE to abort the forward too.
2207 */
2208 req->analysers &= ~(AN_REQ_FLT_XFER_DATA|AN_REQ_WAIT_CLI);
2209 req->analysers |= AN_REQ_FLT_END|CF_FLT_ANALYZE;
2210 s->res.analysers |= AN_RES_WAIT_CLI;
2211
William Lallemandebf61802018-12-11 16:10:57 +01002212 if (!(s->flags & SF_ASSIGNED)) {
2213 if (next_pid > -1)
2214 target_pid = next_pid;
2215 else
2216 target_pid = s->pcli_next_pid;
2217 /* we can connect now */
2218 s->target = pcli_pid_to_server(target_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002219
William Lallemandebf61802018-12-11 16:10:57 +01002220 s->flags |= (SF_DIRECT | SF_ASSIGNED);
2221 channel_auto_connect(req);
2222 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002223
2224 } else if (to_forward == 0) {
William Lallemandcf62f7e2018-10-26 14:47:40 +02002225 /* we trimmed things but we might have other commands to consume */
William Lallemandbddd33a2018-12-11 16:10:53 +01002226 pcli_write_prompt(s);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002227 goto read_again;
William Lallemandbddd33a2018-12-11 16:10:53 +01002228 } else if (to_forward == -1 && errmsg) {
2229 /* there was an error during the parsing */
2230 pcli_reply_and_close(s, errmsg);
2231 return 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002232 } else if (to_forward == -1 && channel_full(req, global.tune.maxrewrite)) {
2233 /* buffer is full and we didn't catch the end of a command */
2234 goto send_help;
2235 }
2236
2237 return 0;
2238
2239send_help:
2240 b_reset(&req->buf);
2241 b_putblk(&req->buf, "help\n", 5);
2242 goto read_again;
2243}
2244
2245int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
2246{
2247 struct proxy *fe = strm_fe(s);
2248 struct proxy *be = s->be;
2249
William Lallemand6b7cd0a2018-11-06 17:37:11 +01002250 if (rep->flags & CF_READ_ERROR) {
2251 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
2252 s->res.analysers &= ~AN_RES_WAIT_CLI;
2253 return 0;
2254 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002255 rep->flags |= CF_READ_DONTWAIT; /* try to get back here ASAP */
2256 rep->flags |= CF_NEVER_WAIT;
2257
2258 /* don't forward the close */
2259 channel_dont_close(&s->res);
2260 channel_dont_close(&s->req);
2261
William Lallemanddc12c2e2018-12-13 09:05:46 +01002262 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002263 s->req.analysers |= AN_REQ_WAIT_CLI;
2264 s->res.analysers &= ~AN_RES_WAIT_CLI;
2265 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2266 return 0;
2267 }
2268
William Lallemandcf62f7e2018-10-26 14:47:40 +02002269 /* forward the data */
2270 if (ci_data(rep)) {
2271 c_adv(rep, ci_data(rep));
2272 return 0;
2273 }
2274
2275 if ((rep->flags & (CF_SHUTR|CF_READ_NULL))) {
2276 /* stream cleanup */
2277
William Lallemand2f4ce202018-10-26 14:47:47 +02002278 pcli_write_prompt(s);
2279
William Lallemandcf62f7e2018-10-26 14:47:40 +02002280 s->si[1].flags |= SI_FL_NOLINGER | SI_FL_NOHALF;
2281 si_shutr(&s->si[1]);
2282 si_shutw(&s->si[1]);
2283
2284 /*
2285 * starting from there this the same code as
2286 * http_end_txn_clean_session().
2287 *
2288 * It allows to do frontend keepalive while reconnecting to a
2289 * new server for each request.
2290 */
2291
2292 if (s->flags & SF_BE_ASSIGNED) {
2293 HA_ATOMIC_SUB(&be->beconn, 1);
2294 if (unlikely(s->srv_conn))
2295 sess_change_server(s, NULL);
2296 }
2297
2298 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2299 stream_process_counters(s);
2300
2301 /* don't count other requests' data */
2302 s->logs.bytes_in -= ci_data(&s->req);
2303 s->logs.bytes_out -= ci_data(&s->res);
2304
2305 /* we may need to know the position in the queue */
2306 pendconn_free(s);
2307
2308 /* let's do a final log if we need it */
2309 if (!LIST_ISEMPTY(&fe->logformat) && s->logs.logwait &&
2310 !(s->flags & SF_MONITOR) &&
2311 (!(fe->options & PR_O_NULLNOLOG) || s->req.total)) {
2312 s->do_log(s);
2313 }
2314
2315 /* stop tracking content-based counters */
2316 stream_stop_content_counters(s);
2317 stream_update_time_stats(s);
2318
2319 s->logs.accept_date = date; /* user-visible date for logging */
2320 s->logs.tv_accept = now; /* corrected date for internal use */
2321 s->logs.t_handshake = 0; /* There are no handshake in keep alive connection. */
2322 s->logs.t_idle = -1;
2323 tv_zero(&s->logs.tv_request);
2324 s->logs.t_queue = -1;
2325 s->logs.t_connect = -1;
2326 s->logs.t_data = -1;
2327 s->logs.t_close = 0;
2328 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
2329 s->logs.srv_queue_pos = 0; /* we will get this number soon */
2330
2331 s->logs.bytes_in = s->req.total = ci_data(&s->req);
2332 s->logs.bytes_out = s->res.total = ci_data(&s->res);
2333
2334 stream_del_srv_conn(s);
2335 if (objt_server(s->target)) {
2336 if (s->flags & SF_CURR_SESS) {
2337 s->flags &= ~SF_CURR_SESS;
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002338 HA_ATOMIC_SUB(&__objt_server(s->target)->cur_sess, 1);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002339 }
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002340 if (may_dequeue_tasks(__objt_server(s->target), be))
2341 process_srv_queue(__objt_server(s->target));
William Lallemandcf62f7e2018-10-26 14:47:40 +02002342 }
2343
2344 s->target = NULL;
2345
2346 /* only release our endpoint if we don't intend to reuse the
2347 * connection.
2348 */
2349 if (!si_conn_ready(&s->si[1])) {
2350 si_release_endpoint(&s->si[1]);
2351 s->srv_conn = NULL;
2352 }
2353
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002354 sockaddr_free(&s->target_addr);
2355
William Lallemandcf62f7e2018-10-26 14:47:40 +02002356 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
2357 s->si[1].err_type = SI_ET_NONE;
2358 s->si[1].conn_retries = 0; /* used for logging too */
2359 s->si[1].exp = TICK_ETERNITY;
2360 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 +02002361 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 +02002362 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 +02002363 s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_ADDR_SET|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
2364 s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
2365 s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
2366 /* reinitialise the current rule list pointer to NULL. We are sure that
2367 * any rulelist match the NULL pointer.
2368 */
2369 s->current_rule_list = NULL;
2370
2371 s->be = strm_fe(s);
2372 s->logs.logwait = strm_fe(s)->to_log;
2373 s->logs.level = 0;
2374 stream_del_srv_conn(s);
2375 s->target = NULL;
2376 /* re-init store persistence */
2377 s->store_count = 0;
2378 s->uniq_id = global.req_count++;
2379
2380 s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */
2381
2382 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2383
2384 s->req.analysers |= AN_REQ_WAIT_CLI;
2385 s->res.analysers &= ~AN_RES_WAIT_CLI;
2386
2387 /* We must trim any excess data from the response buffer, because we
2388 * may have blocked an invalid response from a server that we don't
Ilya Shipitsind4259502020-04-08 01:07:56 +05002389 * want to accidentally forward once we disable the analysers, nor do
William Lallemandcf62f7e2018-10-26 14:47:40 +02002390 * we want those data to come along with next response. A typical
2391 * example of such data would be from a buggy server responding to
2392 * a HEAD with some data, or sending more than the advertised
2393 * content-length.
2394 */
2395 if (unlikely(ci_data(&s->res)))
2396 b_set_data(&s->res.buf, co_data(&s->res));
2397
2398 /* Now we can realign the response buffer */
2399 c_realign_if_empty(&s->res);
2400
2401 s->req.rto = strm_fe(s)->timeout.client;
2402 s->req.wto = TICK_ETERNITY;
2403
2404 s->res.rto = TICK_ETERNITY;
2405 s->res.wto = strm_fe(s)->timeout.client;
2406
2407 s->req.rex = TICK_ETERNITY;
2408 s->req.wex = TICK_ETERNITY;
2409 s->req.analyse_exp = TICK_ETERNITY;
2410 s->res.rex = TICK_ETERNITY;
2411 s->res.wex = TICK_ETERNITY;
2412 s->res.analyse_exp = TICK_ETERNITY;
2413 s->si[1].hcto = TICK_ETERNITY;
2414
2415 /* we're removing the analysers, we MUST re-enable events detection.
2416 * We don't enable close on the response channel since it's either
2417 * already closed, or in keep-alive with an idle connection handler.
2418 */
2419 channel_auto_read(&s->req);
2420 channel_auto_close(&s->req);
2421 channel_auto_read(&s->res);
2422
2423
2424 return 1;
2425 }
2426 return 0;
2427}
2428
William Lallemand8a022572018-10-26 14:47:35 +02002429/*
2430 * The mworker functions are used to initialize the CLI in the master process
2431 */
2432
William Lallemand309dc9a2018-10-26 14:47:45 +02002433 /*
2434 * Stop the mworker proxy
2435 */
2436void mworker_cli_proxy_stop()
2437{
William Lallemand550db6d2018-11-06 17:37:12 +01002438 if (mworker_proxy)
2439 stop_proxy(mworker_proxy);
William Lallemand309dc9a2018-10-26 14:47:45 +02002440}
2441
William Lallemand8a022572018-10-26 14:47:35 +02002442/*
2443 * Create the mworker CLI proxy
2444 */
2445int mworker_cli_proxy_create()
2446{
2447 struct mworker_proc *child;
William Lallemand744a0892018-11-22 16:46:51 +01002448 char *msg = NULL;
2449 char *errmsg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002450
2451 mworker_proxy = calloc(1, sizeof(*mworker_proxy));
2452 if (!mworker_proxy)
2453 return -1;
2454
2455 init_new_proxy(mworker_proxy);
2456 mworker_proxy->next = proxies_list;
2457 proxies_list = mworker_proxy;
2458 mworker_proxy->id = strdup("MASTER");
William Lallemandcf62f7e2018-10-26 14:47:40 +02002459 mworker_proxy->mode = PR_MODE_CLI;
William Lallemand8a022572018-10-26 14:47:35 +02002460 mworker_proxy->state = PR_STNEW;
2461 mworker_proxy->last_change = now.tv_sec;
2462 mworker_proxy->cap = PR_CAP_LISTEN; /* this is a listen section */
2463 mworker_proxy->maxconn = 10; /* default to 10 concurrent connections */
2464 mworker_proxy->timeout.client = 0; /* no timeout */
2465 mworker_proxy->conf.file = strdup("MASTER");
2466 mworker_proxy->conf.line = 0;
2467 mworker_proxy->accept = frontend_accept;
2468 mworker_proxy-> lbprm.algo = BE_LB_ALGO_NONE;
2469
2470 /* Does not init the default target the CLI applet, but must be done in
2471 * the request parsing code */
2472 mworker_proxy->default_target = NULL;
2473
2474 /* the check_config_validity() will get an ID for the proxy */
2475 mworker_proxy->uuid = -1;
2476
2477 proxy_store_name(mworker_proxy);
2478
2479 /* create all servers using the mworker_proc list */
2480 list_for_each_entry(child, &proc_list, list) {
William Lallemand8a022572018-10-26 14:47:35 +02002481 struct server *newsrv = NULL;
2482 struct sockaddr_storage *sk;
2483 int port1, port2, port;
2484 struct protocol *proto;
William Lallemand8a022572018-10-26 14:47:35 +02002485
William Lallemanda31b09e2020-01-14 15:25:02 +01002486 /* only the workers support the master CLI */
2487 if (!(child->options & PROC_O_TYPE_WORKER))
2488 continue;
2489
William Lallemand8a022572018-10-26 14:47:35 +02002490 newsrv = new_server(mworker_proxy);
2491 if (!newsrv)
William Lallemand744a0892018-11-22 16:46:51 +01002492 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002493
2494 /* we don't know the new pid yet */
2495 if (child->pid == -1)
2496 memprintf(&msg, "cur-%d", child->relative_pid);
2497 else
2498 memprintf(&msg, "old-%d", child->pid);
2499
2500 newsrv->next = mworker_proxy->srv;
2501 mworker_proxy->srv = newsrv;
2502 newsrv->conf.file = strdup(msg);
2503 newsrv->id = strdup(msg);
2504 newsrv->conf.line = 0;
2505
2506 memprintf(&msg, "sockpair@%d", child->ipc_fd[0]);
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002507 if ((sk = str2sa_range(msg, &port, &port1, &port2, &errmsg, NULL, NULL, 0)) == 0) {
William Lallemand744a0892018-11-22 16:46:51 +01002508 goto error;
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002509 }
2510 free(msg);
2511 msg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002512
2513 proto = protocol_by_family(sk->ss_family);
2514 if (!proto || !proto->connect) {
William Lallemand744a0892018-11-22 16:46:51 +01002515 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002516 }
2517
2518 /* no port specified */
2519 newsrv->flags |= SRV_F_MAPPORTS;
2520 newsrv->addr = *sk;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002521 /* don't let the server participate to load balancing */
2522 newsrv->iweight = 0;
2523 newsrv->uweight = 0;
William Lallemand8a022572018-10-26 14:47:35 +02002524 srv_lb_commit_status(newsrv);
William Lallemand291810d2018-10-26 14:47:38 +02002525
2526 child->srv = newsrv;
William Lallemand8a022572018-10-26 14:47:35 +02002527 }
2528 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002529
2530error:
2531 ha_alert("%s\n", errmsg);
2532
2533 list_for_each_entry(child, &proc_list, list) {
2534 free((char *)child->srv->conf.file); /* cast because of const char * */
2535 free(child->srv->id);
2536 free(child->srv);
2537 child->srv = NULL;
2538 }
2539 free(mworker_proxy->id);
2540 free(mworker_proxy->conf.file);
2541 free(mworker_proxy);
2542 mworker_proxy = NULL;
2543 free(errmsg);
2544 free(msg);
2545
2546 return -1;
William Lallemand8a022572018-10-26 14:47:35 +02002547}
Olivier Houchardf886e342017-04-05 22:24:59 +02002548
William Lallemandce83b4a2018-10-26 14:47:30 +02002549/*
William Lallemande7361152018-10-26 14:47:36 +02002550 * Create a new listener for the master CLI proxy
2551 */
2552int mworker_cli_proxy_new_listener(char *line)
2553{
2554 struct bind_conf *bind_conf;
2555 struct listener *l;
2556 char *err = NULL;
2557 char *args[MAX_LINE_ARGS + 1];
2558 int arg;
2559 int cur_arg;
2560
William Lallemand2e945c82019-11-25 09:58:37 +01002561 arg = 1;
William Lallemande7361152018-10-26 14:47:36 +02002562 args[0] = line;
2563
2564 /* args is a bind configuration with spaces replaced by commas */
2565 while (*line && arg < MAX_LINE_ARGS) {
2566
2567 if (*line == ',') {
2568 *line++ = '\0';
2569 while (*line == ',')
2570 line++;
William Lallemand2e945c82019-11-25 09:58:37 +01002571 args[arg++] = line;
William Lallemande7361152018-10-26 14:47:36 +02002572 }
2573 line++;
2574 }
2575
William Lallemand2e945c82019-11-25 09:58:37 +01002576 args[arg] = "\0";
William Lallemande7361152018-10-26 14:47:36 +02002577
2578 bind_conf = bind_conf_alloc(mworker_proxy, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002579 if (!bind_conf)
2580 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002581
2582 bind_conf->level &= ~ACCESS_LVL_MASK;
2583 bind_conf->level |= ACCESS_LVL_ADMIN;
2584
2585 if (!str2listener(args[0], mworker_proxy, bind_conf, "master-socket", 0, &err)) {
2586 ha_alert("Cannot create the listener of the master CLI\n");
William Lallemand744a0892018-11-22 16:46:51 +01002587 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002588 }
2589
2590 cur_arg = 1;
2591
2592 while (*args[cur_arg]) {
2593 static int bind_dumped;
2594 struct bind_kw *kw;
2595
2596 kw = bind_find_kw(args[cur_arg]);
2597 if (kw) {
2598 if (!kw->parse) {
2599 memprintf(&err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
2600 args[0], args[1], args[cur_arg]);
2601 goto err;
2602 }
2603
2604 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, &err) != 0) {
2605 if (err)
2606 memprintf(&err, "'%s %s' : '%s'", args[0], args[1], err);
2607 else
2608 memprintf(&err, "'%s %s' : error encountered while processing '%s'",
2609 args[0], args[1], args[cur_arg]);
2610 goto err;
2611 }
2612
2613 cur_arg += 1 + kw->skip;
2614 continue;
2615 }
2616
2617 if (!bind_dumped) {
2618 bind_dump_kws(&err);
2619 indent_msg(&err, 4);
2620 bind_dumped = 1;
2621 }
2622
2623 memprintf(&err, "'%s %s' : unknown keyword '%s'.%s%s",
2624 args[0], args[1], args[cur_arg],
2625 err ? " Registered keywords :" : "", err ? err : "");
2626 goto err;
2627 }
2628
2629
2630 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemande7361152018-10-26 14:47:36 +02002631 l->accept = session_accept_fd;
2632 l->default_target = mworker_proxy->default_target;
2633 /* don't make the peers subject to global limits and don't close it in the master */
2634 l->options |= (LI_O_UNLIMITED|LI_O_MWORKER); /* we are keeping this FD in the master */
2635 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002636 global.maxsock++; /* for the listening socket */
William Lallemande7361152018-10-26 14:47:36 +02002637 }
Willy Tarreau18215cb2019-02-27 16:25:28 +01002638 global.maxsock += mworker_proxy->maxconn;
William Lallemande7361152018-10-26 14:47:36 +02002639
2640 return 0;
2641
2642err:
2643 ha_alert("%s\n", err);
William Lallemand744a0892018-11-22 16:46:51 +01002644 free(err);
2645 free(bind_conf);
William Lallemande7361152018-10-26 14:47:36 +02002646 return -1;
2647
2648}
2649
2650/*
William Lallemandce83b4a2018-10-26 14:47:30 +02002651 * Create a new CLI socket using a socketpair for a worker process
2652 * <mworker_proc> is the process structure, and <proc> is the process number
2653 */
2654int mworker_cli_sockpair_new(struct mworker_proc *mworker_proc, int proc)
2655{
2656 struct bind_conf *bind_conf;
2657 struct listener *l;
2658 char *path = NULL;
2659 char *err = NULL;
2660
2661 /* master pipe to ensure the master is still alive */
2662 if (socketpair(AF_UNIX, SOCK_STREAM, 0, mworker_proc->ipc_fd) < 0) {
2663 ha_alert("Cannot create worker socketpair.\n");
2664 return -1;
2665 }
2666
2667 /* XXX: we might want to use a separate frontend at some point */
2668 if (!global.stats_fe) {
2669 if ((global.stats_fe = alloc_stats_fe("GLOBAL", "master-socket", 0)) == NULL) {
2670 ha_alert("out of memory trying to allocate the stats frontend");
William Lallemand744a0892018-11-22 16:46:51 +01002671 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002672 }
2673 }
2674
2675 bind_conf = bind_conf_alloc(global.stats_fe, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002676 if (!bind_conf)
2677 goto error;
2678
William Lallemandce83b4a2018-10-26 14:47:30 +02002679 bind_conf->level &= ~ACCESS_LVL_MASK;
2680 bind_conf->level |= ACCESS_LVL_ADMIN; /* TODO: need to lower the rights with a CLI keyword*/
2681
2682 bind_conf->bind_proc = 1UL << proc;
2683 global.stats_fe->bind_proc = 0; /* XXX: we should be careful with that, it can be removed by configuration */
2684
2685 if (!memprintf(&path, "sockpair@%d", mworker_proc->ipc_fd[1])) {
2686 ha_alert("Cannot allocate listener.\n");
William Lallemand744a0892018-11-22 16:46:51 +01002687 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002688 }
2689
2690 if (!str2listener(path, global.stats_fe, bind_conf, "master-socket", 0, &err)) {
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002691 free(path);
William Lallemandce83b4a2018-10-26 14:47:30 +02002692 ha_alert("Cannot create a CLI sockpair listener for process #%d\n", proc);
William Lallemand744a0892018-11-22 16:46:51 +01002693 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002694 }
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002695 free(path);
2696 path = NULL;
William Lallemandce83b4a2018-10-26 14:47:30 +02002697
2698 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemandce83b4a2018-10-26 14:47:30 +02002699 l->accept = session_accept_fd;
2700 l->default_target = global.stats_fe->default_target;
William Lallemanda3372292018-11-16 16:57:22 +01002701 l->options |= (LI_O_UNLIMITED | LI_O_NOSTOP);
William Lallemandce83b4a2018-10-26 14:47:30 +02002702 /* it's a sockpair but we don't want to keep the fd in the master */
2703 l->options &= ~LI_O_INHERITED;
2704 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002705 global.maxsock++; /* for the listening socket */
William Lallemandce83b4a2018-10-26 14:47:30 +02002706 }
2707
2708 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002709
2710error:
2711 close(mworker_proc->ipc_fd[0]);
2712 close(mworker_proc->ipc_fd[1]);
2713 free(err);
2714
2715 return -1;
William Lallemandce83b4a2018-10-26 14:47:30 +02002716}
2717
William Lallemand74c24fb2016-11-21 17:18:36 +01002718static struct applet cli_applet = {
2719 .obj_type = OBJ_TYPE_APPLET,
2720 .name = "<CLI>", /* used for logging */
2721 .fct = cli_io_handler,
2722 .release = cli_release_handler,
2723};
2724
Willy Tarreau0a739292016-11-22 20:21:23 +01002725/* register cli keywords */
2726static struct cli_kw_list cli_kws = {{ },{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002727 { { "help", NULL }, NULL, cli_parse_simple, NULL },
2728 { { "prompt", NULL }, NULL, cli_parse_simple, NULL },
2729 { { "quit", NULL }, NULL, cli_parse_simple, NULL },
Willy Tarreau2af99412016-11-23 11:10:59 +01002730 { { "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 +01002731 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002732 { { "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 +01002733 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002734 { { "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 +02002735 { { "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 +01002736 { { "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 +02002737 { { "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 +01002738 { { "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 +01002739 { { "operator", NULL }, "operator : lower the level of the current CLI session to operator", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
2740 { { "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 +02002741 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02002742 { { "expert-mode", NULL }, NULL, cli_parse_expert_mode, NULL }, // not listed
Willy Tarreau0a739292016-11-22 20:21:23 +01002743 {{},}
2744}};
2745
Willy Tarreau0108d902018-11-25 19:14:37 +01002746INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
2747
William Lallemand74c24fb2016-11-21 17:18:36 +01002748static struct cfg_kw_list cfg_kws = {ILH, {
2749 { CFG_GLOBAL, "stats", stats_parse_global },
2750 { 0, NULL, NULL },
2751}};
2752
Willy Tarreau0108d902018-11-25 19:14:37 +01002753INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
2754
William Lallemand74c24fb2016-11-21 17:18:36 +01002755static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02002756 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
2757 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002758 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01002759 { NULL, NULL, 0 },
2760}};
2761
Willy Tarreau0108d902018-11-25 19:14:37 +01002762INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01002763
2764/*
2765 * Local variables:
2766 * c-indent-level: 8
2767 * c-basic-offset: 8
2768 * End:
2769 */