blob: e91e33b315f929c76df821e555b0638057bce77f [file] [log] [blame]
William Lallemand74c24fb2016-11-21 17:18:36 +01001/*
2 * Functions dedicated to statistics output and the stats socket
3 *
4 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
5 * Copyright 2007-2009 Krzysztof Piotr Oledzki <ole@ans.pl>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 */
13
14#include <ctype.h>
15#include <errno.h>
16#include <fcntl.h>
17#include <stdio.h>
18#include <stdlib.h>
19#include <string.h>
20#include <pwd.h>
21#include <grp.h>
22
23#include <sys/socket.h>
24#include <sys/stat.h>
25#include <sys/types.h>
26
Olivier Houchardf886e342017-04-05 22:24:59 +020027#include <net/if.h>
28
William Lallemand74c24fb2016-11-21 17:18:36 +010029#include <common/cfgparse.h>
30#include <common/compat.h>
31#include <common/config.h>
32#include <common/debug.h>
Willy Tarreau0108d902018-11-25 19:14:37 +010033#include <common/initcall.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010034#include <common/memory.h>
35#include <common/mini-clist.h>
36#include <common/standard.h>
37#include <common/ticks.h>
38#include <common/time.h>
39#include <common/uri_auth.h>
40#include <common/version.h>
41#include <common/base64.h>
42
43#include <types/applet.h>
William Lallemand9ed62032016-11-21 17:49:11 +010044#include <types/cli.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010045#include <types/global.h>
46#include <types/dns.h>
William Lallemand9ed62032016-11-21 17:49:11 +010047#include <types/stats.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010048
Willy Tarreau609aad92018-11-22 08:31:09 +010049#include <proto/activity.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010050#include <proto/backend.h>
51#include <proto/channel.h>
52#include <proto/checks.h>
53#include <proto/compression.h>
William Lallemand9ed62032016-11-21 17:49:11 +010054#include <proto/stats.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010055#include <proto/fd.h>
56#include <proto/freq_ctr.h>
57#include <proto/frontend.h>
58#include <proto/log.h>
59#include <proto/pattern.h>
60#include <proto/pipe.h>
William Lallemandce83b4a2018-10-26 14:47:30 +020061#include <proto/protocol.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010062#include <proto/listener.h>
63#include <proto/map.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010064#include <proto/proxy.h>
65#include <proto/sample.h>
66#include <proto/session.h>
67#include <proto/stream.h>
68#include <proto/server.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010069#include <proto/stream_interface.h>
70#include <proto/task.h>
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +020071#include <proto/proto_udp.h>
Emeric Brund0e095c2019-04-19 17:15:28 +020072#ifdef USE_OPENSSL
73#include <proto/ssl_sock.h>
74#endif
William Lallemand74c24fb2016-11-21 17:18:36 +010075
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020076#define PAYLOAD_PATTERN "<<"
77
William Lallemand74c24fb2016-11-21 17:18:36 +010078static struct applet cli_applet;
79
80static const char stats_sock_usage_msg[] =
81 "Unknown command. Please enter one of the following commands only :\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010082 " help : this message\n"
83 " prompt : toggle interactive mode with prompt\n"
84 " quit : disconnect\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010085 "";
86
87static const char stats_permission_denied_msg[] =
88 "Permission denied\n"
89 "";
90
91
Christopher Faulet1bc04c72017-10-29 20:14:08 +010092static THREAD_LOCAL char *dynamic_usage_msg = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +010093
94/* List head of cli keywords */
95static struct cli_kw_list cli_keywords = {
96 .list = LIST_HEAD_INIT(cli_keywords.list)
97};
98
99extern const char *stat_status_codes[];
100
William Lallemand8a022572018-10-26 14:47:35 +0200101static struct proxy *mworker_proxy; /* CLI proxy of the master */
102
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200103static char *cli_gen_usage_msg(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100104{
105 struct cli_kw_list *kw_list;
106 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +0200107 struct buffer *tmp = get_trash_chunk();
108 struct buffer out;
William Lallemand74c24fb2016-11-21 17:18:36 +0100109
110 free(dynamic_usage_msg);
111 dynamic_usage_msg = NULL;
112
113 if (LIST_ISEMPTY(&cli_keywords.list))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200114 goto end;
William Lallemand74c24fb2016-11-21 17:18:36 +0100115
116 chunk_reset(tmp);
117 chunk_strcat(tmp, stats_sock_usage_msg);
118 list_for_each_entry(kw_list, &cli_keywords.list, list) {
119 kw = &kw_list->kw[0];
William Lallemand0154edc2018-05-15 11:50:04 +0200120 while (kw->str_kw[0]) {
William Lallemand14721be2018-10-26 14:47:37 +0200121
122 /* in a worker or normal process, don't display master only commands */
123 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
124 goto next_kw;
125
126 /* in master don't displays if we don't have the master bits */
127 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
128 goto next_kw;
129
William Lallemand0154edc2018-05-15 11:50:04 +0200130 if (kw->usage)
131 chunk_appendf(tmp, " %s\n", kw->usage);
William Lallemand14721be2018-10-26 14:47:37 +0200132
133next_kw:
134
William Lallemand74c24fb2016-11-21 17:18:36 +0100135 kw++;
136 }
137 }
138 chunk_init(&out, NULL, 0);
139 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200140 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200141
142end:
143 if (dynamic_usage_msg) {
144 appctx->ctx.cli.severity = LOG_INFO;
145 appctx->ctx.cli.msg = dynamic_usage_msg;
146 }
147 else {
148 appctx->ctx.cli.severity = LOG_INFO;
149 appctx->ctx.cli.msg = stats_sock_usage_msg;
150 }
151 appctx->st0 = CLI_ST_PRINT;
152
William Lallemand74c24fb2016-11-21 17:18:36 +0100153 return dynamic_usage_msg;
154}
155
156struct cli_kw* cli_find_kw(char **args)
157{
158 struct cli_kw_list *kw_list;
159 struct cli_kw *kw;/* current cli_kw */
160 char **tmp_args;
161 const char **tmp_str_kw;
162 int found = 0;
163
164 if (LIST_ISEMPTY(&cli_keywords.list))
165 return NULL;
166
167 list_for_each_entry(kw_list, &cli_keywords.list, list) {
168 kw = &kw_list->kw[0];
169 while (*kw->str_kw) {
170 tmp_args = args;
171 tmp_str_kw = kw->str_kw;
172 while (*tmp_str_kw) {
173 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
174 found = 1;
175 } else {
176 found = 0;
177 break;
178 }
179 tmp_args++;
180 tmp_str_kw++;
181 }
182 if (found)
183 return (kw);
184 kw++;
185 }
186 }
187 return NULL;
188}
189
190void cli_register_kw(struct cli_kw_list *kw_list)
191{
192 LIST_ADDQ(&cli_keywords.list, &kw_list->list);
193}
194
195
196/* allocate a new stats frontend named <name>, and return it
197 * (or NULL in case of lack of memory).
198 */
199static struct proxy *alloc_stats_fe(const char *name, const char *file, int line)
200{
201 struct proxy *fe;
202
203 fe = calloc(1, sizeof(*fe));
204 if (!fe)
205 return NULL;
206
207 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100208 fe->next = proxies_list;
209 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100210 fe->last_change = now.tv_sec;
211 fe->id = strdup("GLOBAL");
212 fe->cap = PR_CAP_FE;
213 fe->maxconn = 10; /* default to 10 concurrent connections */
214 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
215 fe->conf.file = strdup(file);
216 fe->conf.line = line;
217 fe->accept = frontend_accept;
218 fe->default_target = &cli_applet.obj_type;
219
220 /* the stats frontend is the only one able to assign ID #0 */
221 fe->conf.id.key = fe->uuid = 0;
222 eb32_insert(&used_proxy_id, &fe->conf.id);
223 return fe;
224}
225
226/* This function parses a "stats" statement in the "global" section. It returns
227 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
228 * error message into the <err> buffer which will be preallocated. The trailing
229 * '\n' must not be written. The function must be called with <args> pointing to
230 * the first word after "stats".
231 */
232static int stats_parse_global(char **args, int section_type, struct proxy *curpx,
233 struct proxy *defpx, const char *file, int line,
234 char **err)
235{
236 struct bind_conf *bind_conf;
237 struct listener *l;
238
239 if (!strcmp(args[1], "socket")) {
240 int cur_arg;
241
242 if (*args[2] == 0) {
243 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
244 return -1;
245 }
246
247 if (!global.stats_fe) {
248 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
249 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
250 return -1;
251 }
252 }
253
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100254 bind_conf = bind_conf_alloc(global.stats_fe, file, line, args[2], xprt_get(XPRT_RAW));
William Lallemand07a62f72017-05-24 00:57:40 +0200255 bind_conf->level &= ~ACCESS_LVL_MASK;
256 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100257
258 if (!str2listener(args[2], global.stats_fe, bind_conf, file, line, err)) {
259 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
260 file, line, args[0], args[1], err && *err ? *err : "error");
261 return -1;
262 }
263
264 cur_arg = 3;
265 while (*args[cur_arg]) {
266 static int bind_dumped;
267 struct bind_kw *kw;
268
269 kw = bind_find_kw(args[cur_arg]);
270 if (kw) {
271 if (!kw->parse) {
272 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
273 args[0], args[1], args[cur_arg]);
274 return -1;
275 }
276
277 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, err) != 0) {
278 if (err && *err)
279 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
280 else
281 memprintf(err, "'%s %s' : error encountered while processing '%s'",
282 args[0], args[1], args[cur_arg]);
283 return -1;
284 }
285
286 cur_arg += 1 + kw->skip;
287 continue;
288 }
289
290 if (!bind_dumped) {
291 bind_dump_kws(err);
292 indent_msg(err, 4);
293 bind_dumped = 1;
294 }
295
296 memprintf(err, "'%s %s' : unknown keyword '%s'.%s%s",
297 args[0], args[1], args[cur_arg],
298 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
299 return -1;
300 }
301
302 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100303 l->accept = session_accept_fd;
William Lallemand74c24fb2016-11-21 17:18:36 +0100304 l->default_target = global.stats_fe->default_target;
305 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
306 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100307 global.maxsock++; /* for the listening socket */
William Lallemand74c24fb2016-11-21 17:18:36 +0100308 }
309 }
310 else if (!strcmp(args[1], "timeout")) {
311 unsigned timeout;
312 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
313
314 if (res) {
315 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
316 return -1;
317 }
318
319 if (!timeout) {
320 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
321 return -1;
322 }
323 if (!global.stats_fe) {
324 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
325 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
326 return -1;
327 }
328 }
329 global.stats_fe->timeout.client = MS_TO_TICKS(timeout);
330 }
331 else if (!strcmp(args[1], "maxconn")) {
332 int maxconn = atol(args[2]);
333
334 if (maxconn <= 0) {
335 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
336 return -1;
337 }
338
339 if (!global.stats_fe) {
340 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
341 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
342 return -1;
343 }
344 }
345 global.stats_fe->maxconn = maxconn;
346 }
347 else if (!strcmp(args[1], "bind-process")) { /* enable the socket only on some processes */
348 int cur_arg = 2;
349 unsigned long set = 0;
350
351 if (!global.stats_fe) {
352 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
353 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
354 return -1;
355 }
356 }
357
358 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100359 if (strcmp(args[cur_arg], "all") == 0) {
360 set = 0;
361 break;
362 }
Willy Tarreauff9c9142019-02-07 10:39:36 +0100363 if (parse_process_number(args[cur_arg], &set, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100364 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100365 return -1;
366 }
367 cur_arg++;
368 }
369 global.stats_fe->bind_proc = set;
370 }
371 else {
372 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
373 return -1;
374 }
375 return 0;
376}
377
William Lallemand33d29e22019-04-01 11:30:06 +0200378/*
William Lallemand9a37fd02019-04-12 16:09:24 +0200379 * This function exports the bound addresses of a <frontend> in the environment
380 * variable <varname>. Those addresses are separated by semicolons and prefixed
381 * with their type (abns@, unix@, sockpair@ etc)
382 * Return -1 upon error, 0 otherwise
William Lallemand33d29e22019-04-01 11:30:06 +0200383 */
William Lallemand9a37fd02019-04-12 16:09:24 +0200384int listeners_setenv(struct proxy *frontend, const char *varname)
William Lallemand33d29e22019-04-01 11:30:06 +0200385{
386 struct buffer *trash = get_trash_chunk();
387 struct bind_conf *bind_conf;
388
William Lallemand9a37fd02019-04-12 16:09:24 +0200389 if (frontend) {
390 list_for_each_entry(bind_conf, &frontend->conf.bind, by_fe) {
William Lallemand33d29e22019-04-01 11:30:06 +0200391 struct listener *l;
392
393 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
394 char addr[46];
395 char port[6];
396
William Lallemand620072b2019-04-12 16:09:25 +0200397 /* separate listener by semicolons */
398 if (trash->data)
399 chunk_appendf(trash, ";");
400
William Lallemand33d29e22019-04-01 11:30:06 +0200401 if (l->addr.ss_family == AF_UNIX) {
402 const struct sockaddr_un *un;
403
404 un = (struct sockaddr_un *)&l->addr;
405 if (un->sun_path[0] == '\0') {
406 chunk_appendf(trash, "abns@%s", un->sun_path+1);
407 } else {
408 chunk_appendf(trash, "unix@%s", un->sun_path);
409 }
410 } else if (l->addr.ss_family == AF_INET) {
411 addr_to_str(&l->addr, addr, sizeof(addr));
412 port_to_str(&l->addr, port, sizeof(port));
413 chunk_appendf(trash, "ipv4@%s:%s", addr, port);
414 } else if (l->addr.ss_family == AF_INET6) {
415 addr_to_str(&l->addr, addr, sizeof(addr));
416 port_to_str(&l->addr, port, sizeof(port));
417 chunk_appendf(trash, "ipv6@[%s]:%s", addr, port);
418 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
419 chunk_appendf(trash, "sockpair@%d", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
420 }
William Lallemand33d29e22019-04-01 11:30:06 +0200421 }
422 }
423 trash->area[trash->data++] = '\0';
William Lallemand9a37fd02019-04-12 16:09:24 +0200424 if (setenv(varname, trash->area, 1) < 0)
William Lallemand33d29e22019-04-01 11:30:06 +0200425 return -1;
426 }
427
428 return 0;
429}
430
William Lallemand9a37fd02019-04-12 16:09:24 +0200431int cli_socket_setenv()
432{
433 if (listeners_setenv(global.stats_fe, "HAPROXY_CLI") < 0)
434 return -1;
435 if (listeners_setenv(mworker_proxy, "HAPROXY_MASTER_CLI") < 0)
436 return -1;
437
438 return 0;
439}
440
William Lallemand33d29e22019-04-01 11:30:06 +0200441REGISTER_CONFIG_POSTPARSER("cli", cli_socket_setenv);
442
Willy Tarreaude57a572016-11-23 17:01:39 +0100443/* Verifies that the CLI at least has a level at least as high as <level>
444 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
445 * failure, an error message is prepared and the appctx's state is adjusted
446 * to print it so that a return 1 is enough to abort any processing.
447 */
448int cli_has_level(struct appctx *appctx, int level)
449{
Willy Tarreaude57a572016-11-23 17:01:39 +0100450
William Lallemandf630d012018-12-13 09:05:44 +0100451 if ((appctx->cli_level & ACCESS_LVL_MASK) < level) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200452 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreaude57a572016-11-23 17:01:39 +0100453 appctx->ctx.cli.msg = stats_permission_denied_msg;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100454 appctx->st0 = CLI_ST_PRINT;
Willy Tarreaude57a572016-11-23 17:01:39 +0100455 return 0;
456 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100457 return 1;
458}
459
William Lallemandb7ea1412018-12-13 09:05:47 +0100460/* same as cli_has_level but for the CLI proxy and without error message */
461int pcli_has_level(struct stream *s, int level)
462{
463 if ((s->pcli_flags & ACCESS_LVL_MASK) < level) {
464 return 0;
465 }
466 return 1;
467}
468
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200469/* Returns severity_output for the current session if set, or default for the socket */
470static int cli_get_severity_output(struct appctx *appctx)
471{
472 if (appctx->cli_severity_output)
473 return appctx->cli_severity_output;
474 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
475}
William Lallemand74c24fb2016-11-21 17:18:36 +0100476
Willy Tarreau41908562016-11-24 16:23:38 +0100477/* Processes the CLI interpreter on the stats socket. This function is called
478 * from the CLI's IO handler running in an appctx context. The function returns 1
479 * if the request was understood, otherwise zero. It is called with appctx->st0
480 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
481 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
482 * have its own I/O handler called again. Most of the time, parsers will only
483 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100484 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
485 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100486 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200487static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100488{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200489 char *args[MAX_STATS_ARGS + 1], *p, *end, *payload = NULL;
490 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100491 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100492
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200493 appctx->st2 = 0;
494 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
William Lallemand74c24fb2016-11-21 17:18:36 +0100495
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200496 p = appctx->chunk->area;
497 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100498
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200499 /*
500 * Get the payload start if there is one.
501 * For the sake of simplicity, the payload pattern is looked up
502 * everywhere from the start of the input but it can only be found
503 * at the end of the first line if APPCTX_CLI_ST1_PAYLOAD is set.
504 *
505 * The input string was zero terminated so it is safe to use
506 * the str*() functions throughout the parsing
507 */
508 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
509 payload = strstr(p, PAYLOAD_PATTERN);
510 end = payload;
511 /* skip the pattern */
512 payload += strlen(PAYLOAD_PATTERN);
513 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100514
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200515 /*
516 * Get pointers on words.
517 * One extra slot is reserved to store a pointer on a null byte.
518 */
519 while (i < MAX_STATS_ARGS && p < end) {
520 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100521
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200522 /* skip leading spaces/tabs */
523 p += strspn(p, " \t");
524 if (!*p)
525 break;
William Lallemand74c24fb2016-11-21 17:18:36 +0100526
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200527 args[i] = p;
528 p += strcspn(p, " \t");
529 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100530
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200531 /* unescape backslashes (\) */
532 for (j = 0, k = 0; args[i][k]; k++) {
533 if (args[i][k] == '\\') {
534 if (args[i][k + 1] == '\\')
535 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100536 else
537 continue;
538 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200539 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100540 j++;
541 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200542 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100543
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200544 i++;
545 }
546 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200547 p = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200548 for (; i < MAX_STATS_ARGS + 1; i++)
549 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100550
551 kw = cli_find_kw(args);
Willy Tarreaueaffde32016-12-16 17:59:25 +0100552 if (!kw)
Willy Tarreau41908562016-11-24 16:23:38 +0100553 return 0;
554
William Lallemand14721be2018-10-26 14:47:37 +0200555 /* in a worker or normal process, don't display master only commands */
556 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
557 return 0;
558
559 /* in master don't displays if we don't have the master bits */
560 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
561 return 0;
562
Willy Tarreau41908562016-11-24 16:23:38 +0100563 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200564 appctx->io_release = kw->io_release;
565 /* kw->parse could set its own io_handler or ip_release handler */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200566 if ((!kw->parse || kw->parse(args, payload, appctx, kw->private) == 0) && appctx->io_handler) {
Willy Tarreau41908562016-11-24 16:23:38 +0100567 appctx->st0 = CLI_ST_CALLBACK;
William Lallemand74c24fb2016-11-21 17:18:36 +0100568 }
Willy Tarreau41908562016-11-24 16:23:38 +0100569 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100570}
571
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200572/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
573static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
574{
Willy Tarreau83061a82018-07-13 11:56:34 +0200575 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200576
577 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200578 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200579
580 tmp = get_trash_chunk();
581 chunk_reset(tmp);
582
583 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100584 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200585 chunk_printf(tmp, "[%d]: ", severity);
586 }
587 else {
588 switch (severity_output) {
589 case CLI_SEVERITY_NUMBER:
590 chunk_printf(tmp, "[%d]: ", severity);
591 break;
592 case CLI_SEVERITY_STRING:
593 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
594 break;
595 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100596 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200597 }
598 }
599 chunk_appendf(tmp, "%s", msg);
600
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200601 return ci_putblk(chn, tmp->area, strlen(tmp->area));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200602}
603
William Lallemand74c24fb2016-11-21 17:18:36 +0100604/* This I/O handler runs as an applet embedded in a stream interface. It is
605 * used to processes I/O from/to the stats unix socket. The system relies on a
606 * state machine handling requests and various responses. We read a request,
607 * then we process it and send the response, and we possibly display a prompt.
608 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100609 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100610 * or not.
611 */
612static void cli_io_handler(struct appctx *appctx)
613{
614 struct stream_interface *si = appctx->owner;
615 struct channel *req = si_oc(si);
616 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200617 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100618 int reql;
619 int len;
620
621 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
622 goto out;
623
Joseph Herlant008b3ce2018-11-25 12:51:45 -0800624 /* Check if the input buffer is available. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200625 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +0100626 /* buf.size==0 means we failed to get a buffer and were
627 * already subscribed to a wait list to get a buffer.
628 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100629 goto out;
630 }
631
William Lallemand74c24fb2016-11-21 17:18:36 +0100632 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100633 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100634 /* Stats output not initialized yet */
635 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200636 /* reset severity to default at init */
637 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100638 appctx->st0 = CLI_ST_GETREQ;
William Lallemandf630d012018-12-13 09:05:44 +0100639 appctx->cli_level = bind_conf->level;
William Lallemand74c24fb2016-11-21 17:18:36 +0100640 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100641 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100642 /* Let's close for real now. We just close the request
643 * side, the conditions below will complete if needed.
644 */
645 si_shutw(si);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200646 free_trash_chunk(appctx->chunk);
William Lallemand74c24fb2016-11-21 17:18:36 +0100647 break;
648 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100649 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200650 char *str;
651
652 /* use a trash chunk to store received data */
653 if (!appctx->chunk) {
654 appctx->chunk = alloc_trash_chunk();
655 if (!appctx->chunk) {
656 appctx->st0 = CLI_ST_END;
657 continue;
658 }
659 }
660
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200661 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200662
William Lallemand74c24fb2016-11-21 17:18:36 +0100663 /* ensure we have some output room left in the event we
664 * would want to return some info right after parsing.
665 */
666 if (buffer_almost_full(si_ib(si))) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100667 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100668 break;
669 }
670
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200671 /* '- 1' is to ensure a null byte can always be inserted at the end */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200672 reql = co_getline(si_oc(si), str,
673 appctx->chunk->size - appctx->chunk->data - 1);
William Lallemand74c24fb2016-11-21 17:18:36 +0100674 if (reql <= 0) { /* closed or EOL not found */
675 if (reql == 0)
676 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100677 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100678 continue;
679 }
680
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200681 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
682 /* seek for a possible unescaped semi-colon. If we find
683 * one, we replace it with an LF and skip only this part.
684 */
685 for (len = 0; len < reql; len++) {
686 if (str[len] == '\\') {
687 len++;
688 continue;
689 }
690 if (str[len] == ';') {
691 str[len] = '\n';
692 reql = len + 1;
693 break;
694 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100695 }
696 }
697
698 /* now it is time to check that we have a full line,
699 * remove the trailing \n and possibly \r, then cut the
700 * line.
701 */
702 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200703 if (str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100704 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100705 continue;
706 }
707
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200708 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100709 len--;
710
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200711 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200712 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200713
714 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200715 appctx->chunk->area[appctx->chunk->data] = '\n';
716 appctx->chunk->area[appctx->chunk->data + 1] = 0;
717 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200718 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100719
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100720 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200721
722 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
723 /* empty line */
724 if (!len) {
725 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200726 appctx->chunk->data -= 2;
727 appctx->chunk->area[appctx->chunk->data] = 0;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200728
729 if (!cli_parse_request(appctx))
730 cli_gen_usage_msg(appctx);
731
732 chunk_reset(appctx->chunk);
733 /* NB: cli_sock_parse_request() may have put
734 * another CLI_ST_O_* into appctx->st0.
735 */
736
737 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +0100738 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100739 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200740 else {
741 /*
742 * Look for the "payload start" pattern at the end of a line
743 * Its location is not remembered here, this is just to switch
744 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +0100745 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200746 if (!strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200747 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200748 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200749 /* no payload, the command is complete: parse the request */
750 if (!cli_parse_request(appctx))
751 cli_gen_usage_msg(appctx);
752
753 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200754 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100755 }
756
757 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200758 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100759 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
760 }
761 else { /* output functions */
762 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100763 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100764 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100765 case CLI_ST_PRINT:
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200766 if (cli_output_msg(res, appctx->ctx.cli.msg, appctx->ctx.cli.severity,
767 cli_get_severity_output(appctx)) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100768 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100769 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100770 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100771 break;
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200772 case CLI_ST_PRINT_FREE: {
773 const char *msg = appctx->ctx.cli.err;
774
775 if (!msg)
776 msg = "Out of memory.\n";
777
778 if (cli_output_msg(res, msg, LOG_ERR, cli_get_severity_output(appctx)) != -1) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100779 free(appctx->ctx.cli.err);
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100780 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100781 }
782 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100783 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100784 break;
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200785 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100786 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100787 if (appctx->io_handler)
788 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100789 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100790 if (appctx->io_release) {
791 appctx->io_release(appctx);
792 appctx->io_release = NULL;
793 }
794 }
795 break;
796 default: /* abnormal state */
797 si->flags |= SI_FL_ERR;
798 break;
799 }
800
801 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100802 if (appctx->st0 == CLI_ST_PROMPT) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200803 const char *prompt = "";
804
805 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
806 /*
807 * when entering a payload with interactive mode, change the prompt
808 * to emphasize that more data can still be sent
809 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200810 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200811 prompt = "+ ";
812 else
813 prompt = "\n> ";
814 }
815 else {
816 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD))
817 prompt = "\n";
818 }
819
820 if (ci_putstr(si_ic(si), prompt) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100821 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100822 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100823 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100824 }
825
826 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100827 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100828 break;
829
830 /* Now we close the output if one of the writers did so,
831 * or if we're not in interactive mode and the request
832 * buffer is empty. This still allows pipelined requests
833 * to be sent in non-interactive mode.
834 */
William Lallemand3de09d52018-12-11 16:10:56 +0100835 if (((res->flags & (CF_SHUTW|CF_SHUTW_NOW))) ||
836 (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req) && (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)))) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100837 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100838 continue;
839 }
840
841 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100842 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100843 }
844 }
845
846 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
847 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
848 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
849 /* Other side has closed, let's abort if we have no more processing to do
850 * and nothing more to consume. This is comparable to a broken pipe, so
851 * we forward the close to the request side so that it flows upstream to
852 * the client.
853 */
854 si_shutw(si);
855 }
856
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100857 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100858 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
859 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
860 /* We have no more processing to do, and nothing more to send, and
861 * the client side has closed. So we'll forward this state downstream
862 * on the response buffer.
863 */
864 si_shutr(si);
865 res->flags |= CF_READ_NULL;
866 }
867
868 out:
Christopher Faulet45073512018-07-20 10:16:29 +0200869 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 +0100870 __FUNCTION__, __LINE__,
Christopher Faulet45073512018-07-20 10:16:29 +0200871 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 +0100872}
873
William Lallemand74c24fb2016-11-21 17:18:36 +0100874/* This is called when the stream interface is closed. For instance, upon an
875 * external abort, we won't call the i/o handler anymore so we may need to
876 * remove back references to the stream currently being dumped.
877 */
878static void cli_release_handler(struct appctx *appctx)
879{
880 if (appctx->io_release) {
881 appctx->io_release(appctx);
882 appctx->io_release = NULL;
883 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100884 else if (appctx->st0 == CLI_ST_PRINT_FREE) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100885 free(appctx->ctx.cli.err);
886 appctx->ctx.cli.err = NULL;
887 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100888}
889
890/* This function dumps all environmnent variables to the buffer. It returns 0
891 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +0100892 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
893 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +0100894 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100895static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100896{
Willy Tarreau0a739292016-11-22 20:21:23 +0100897 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100898 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100899
900 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
901 return 1;
902
903 chunk_reset(&trash);
904
905 /* we have two inner loops here, one for the proxy, the other one for
906 * the buffer.
907 */
Willy Tarreauf6710f82016-12-16 17:45:44 +0100908 while (*var) {
909 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +0100910
Willy Tarreau06d80a92017-10-19 14:32:15 +0200911 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100912 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100913 return 0;
914 }
915 if (appctx->st2 == STAT_ST_END)
916 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100917 var++;
918 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +0100919 }
920
921 /* dump complete */
922 return 1;
923}
924
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200925/* This function dumps all file descriptors states (or the requested one) to
926 * the buffer. It returns 0 if the output buffer is full and it needs to be
927 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
928 * It uses cli.i0 as the fd number to restart from.
929 */
930static int cli_io_handler_show_fd(struct appctx *appctx)
931{
932 struct stream_interface *si = appctx->owner;
933 int fd = appctx->ctx.cli.i0;
Willy Tarreauca1b1572018-12-18 15:45:11 +0100934 int ret = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200935
936 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
Willy Tarreauca1b1572018-12-18 15:45:11 +0100937 goto end;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200938
939 chunk_reset(&trash);
940
Willy Tarreauca1b1572018-12-18 15:45:11 +0100941 /* isolate the threads once per round. We're limited to a buffer worth
942 * of output anyway, it cannot last very long.
943 */
944 thread_isolate();
945
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200946 /* we have two inner loops here, one for the proxy, the other one for
947 * the buffer.
948 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +0100949 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200950 struct fdtab fdt;
Willy Tarreau286ec682017-08-09 16:35:44 +0200951 struct listener *li = NULL;
952 struct server *sv = NULL;
953 struct proxy *px = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +0200954 const struct mux_ops *mux = NULL;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200955 void *ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +0200956 uint32_t conn_flags = 0;
Willy Tarreaue9ca8072018-12-19 18:40:58 +0100957 int is_back = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200958
959 fdt = fdtab[fd];
960
Willy Tarreauca1b1572018-12-18 15:45:11 +0100961 if (!fdt.owner)
Willy Tarreau017af242017-10-04 20:24:54 +0200962 goto skip; // closed
963
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200964 if (fdt.iocb == conn_fd_handler) {
965 conn_flags = ((struct connection *)fdt.owner)->flags;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200966 mux = ((struct connection *)fdt.owner)->mux;
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100967 ctx = ((struct connection *)fdt.owner)->ctx;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200968 li = objt_listener(((struct connection *)fdt.owner)->target);
969 sv = objt_server(((struct connection *)fdt.owner)->target);
970 px = objt_proxy(((struct connection *)fdt.owner)->target);
Willy Tarreaue9ca8072018-12-19 18:40:58 +0100971 is_back = conn_is_back((struct connection *)fdt.owner);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200972 }
973 else if (fdt.iocb == listener_accept)
974 li = fdt.owner;
975
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200976 chunk_printf(&trash,
Willy Tarreauc754b342018-03-30 15:00:15 +0200977 " %5d : st=0x%02x(R:%c%c%c W:%c%c%c) ev=0x%02x(%c%c%c%c%c) [%c%c] cnext=%d cprev=%d tmask=0x%lx umask=0x%lx owner=%p iocb=%p(%s)",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200978 fd,
979 fdt.state,
980 (fdt.state & FD_EV_POLLED_R) ? 'P' : 'p',
981 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
982 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
983 (fdt.state & FD_EV_POLLED_W) ? 'P' : 'p',
984 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
985 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
986 fdt.ev,
987 (fdt.ev & FD_POLL_HUP) ? 'H' : 'h',
988 (fdt.ev & FD_POLL_ERR) ? 'E' : 'e',
989 (fdt.ev & FD_POLL_OUT) ? 'O' : 'o',
990 (fdt.ev & FD_POLL_PRI) ? 'P' : 'p',
991 (fdt.ev & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200992 fdt.linger_risk ? 'L' : 'l',
993 fdt.cloned ? 'C' : 'c',
Willy Tarreauc754b342018-03-30 15:00:15 +0200994 fdt.cache.next,
995 fdt.cache.prev,
996 fdt.thread_mask, fdt.update_mask,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200997 fdt.owner,
998 fdt.iocb,
999 (fdt.iocb == conn_fd_handler) ? "conn_fd_handler" :
1000 (fdt.iocb == dgram_fd_handler) ? "dgram_fd_handler" :
1001 (fdt.iocb == listener_accept) ? "listener_accept" :
Olivier Houchard79321b92018-07-26 17:55:11 +02001002 (fdt.iocb == poller_pipe_io_handler) ? "poller_pipe_io_handler" :
William Lallemanddb6bdfb2018-11-20 17:36:51 +01001003 (fdt.iocb == mworker_accept_wrapper) ? "mworker_accept_wrapper" :
Emeric Brund0e095c2019-04-19 17:15:28 +02001004#ifdef USE_OPENSSL
Ilya Shipitsin54832b92019-05-05 23:27:54 +05001005#if (OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC) && !defined(LIBRESSL_VERSION_NUMBER)
Emeric Brund0e095c2019-04-19 17:15:28 +02001006 (fdt.iocb == ssl_async_fd_free) ? "ssl_async_fd_free" :
1007 (fdt.iocb == ssl_async_fd_handler) ? "ssl_async_fd_handler" :
1008#endif
1009#endif
Willy Tarreauc754b342018-03-30 15:00:15 +02001010 "unknown");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001011
1012 if (fdt.iocb == conn_fd_handler) {
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001013 chunk_appendf(&trash, " back=%d cflg=0x%08x", is_back, conn_flags);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001014 if (px)
1015 chunk_appendf(&trash, " px=%s", px->id);
1016 else if (sv)
1017 chunk_appendf(&trash, " sv=%s/%s", sv->id, sv->proxy->id);
1018 else if (li)
1019 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +02001020
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001021 if (mux) {
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001022 chunk_appendf(&trash, " mux=%s ctx=%p", mux->name, ctx);
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001023 if (mux->show_fd)
1024 mux->show_fd(&trash, fdt.owner);
1025 }
Willy Tarreau35b1b482018-03-28 18:41:30 +02001026 else
1027 chunk_appendf(&trash, " nomux");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001028 }
1029 else if (fdt.iocb == listener_accept) {
1030 chunk_appendf(&trash, " l.st=%s fe=%s",
1031 listener_state_str(li),
1032 li->bind_conf->frontend->id);
1033 }
1034
1035 chunk_appendf(&trash, "\n");
1036
Willy Tarreau06d80a92017-10-19 14:32:15 +02001037 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001038 si_rx_room_blk(si);
Willy Tarreauca1b1572018-12-18 15:45:11 +01001039 appctx->ctx.cli.i0 = fd;
1040 ret = 0;
1041 break;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001042 }
1043 skip:
1044 if (appctx->st2 == STAT_ST_END)
1045 break;
1046
1047 fd++;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001048 }
1049
Willy Tarreauca1b1572018-12-18 15:45:11 +01001050 end:
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001051 /* dump complete */
Willy Tarreauca1b1572018-12-18 15:45:11 +01001052
1053 thread_release();
1054 return ret;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001055}
1056
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001057/* This function dumps some activity counters used by developers and support to
1058 * rule out some hypothesis during bug reports. It returns 0 if the output
1059 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
1060 * everything at once in the buffer and is not designed to do it in multiple
1061 * passes.
1062 */
1063static int cli_io_handler_show_activity(struct appctx *appctx)
1064{
1065 struct stream_interface *si = appctx->owner;
1066 int thr;
1067
1068 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1069 return 1;
1070
1071 chunk_reset(&trash);
1072
1073 chunk_appendf(&trash, "thread_id: %u", tid);
1074 chunk_appendf(&trash, "\ndate_now: %lu.%06lu", (long)now.tv_sec, (long)now.tv_usec);
1075 chunk_appendf(&trash, "\nloops:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].loops);
1076 chunk_appendf(&trash, "\nwake_cache:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_cache);
1077 chunk_appendf(&trash, "\nwake_tasks:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_tasks);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001078 chunk_appendf(&trash, "\nwake_signal:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_signal);
1079 chunk_appendf(&trash, "\npoll_exp:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_exp);
1080 chunk_appendf(&trash, "\npoll_drop:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_drop);
1081 chunk_appendf(&trash, "\npoll_dead:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_dead);
1082 chunk_appendf(&trash, "\npoll_skip:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_skip);
1083 chunk_appendf(&trash, "\nfd_skip:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_skip);
1084 chunk_appendf(&trash, "\nfd_lock:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_lock);
1085 chunk_appendf(&trash, "\nfd_del:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_del);
1086 chunk_appendf(&trash, "\nconn_dead:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].conn_dead);
1087 chunk_appendf(&trash, "\nstream:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].stream);
1088 chunk_appendf(&trash, "\nempty_rq:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].empty_rq);
1089 chunk_appendf(&trash, "\nlong_rq:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].long_rq);
Willy Tarreaubc13bec2019-04-30 14:55:18 +02001090 chunk_appendf(&trash, "\nctxsw:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].ctxsw);
1091 chunk_appendf(&trash, "\ntasksw:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].tasksw);
Willy Tarreau4f93e0c2018-11-22 16:13:17 +01001092 chunk_appendf(&trash, "\ncpust_ms_tot:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].cpust_total/2);
1093 chunk_appendf(&trash, "\ncpust_ms_1s:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", read_freq_ctr(&activity[thr].cpust_1s)/2);
1094 chunk_appendf(&trash, "\ncpust_ms_15s:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", read_freq_ctr_period(&activity[thr].cpust_15s, 15000)/2);
Willy Tarreaubaba82f2018-11-22 08:42:42 +01001095 chunk_appendf(&trash, "\navg_loop_us:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", swrate_avg(activity[thr].avg_loop_us, TIME_STATS_SAMPLES));
Willy Tarreau64a9c052019-04-12 15:27:17 +02001096 chunk_appendf(&trash, "\naccepted:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].accepted);
Willy Tarreau8a034082019-02-27 10:45:55 +01001097 chunk_appendf(&trash, "\naccq_pushed:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].accq_pushed);
1098 chunk_appendf(&trash, "\naccq_full:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].accq_full);
Willy Tarreaue6182842019-04-15 18:54:10 +02001099#ifdef USE_THREAD
Willy Tarreaua8f57d52019-04-12 15:29:23 +02001100 chunk_appendf(&trash, "\naccq_ring:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", (accept_queue_rings[thr].tail - accept_queue_rings[thr].head + ACCEPT_QUEUE_SIZE)%ACCEPT_QUEUE_SIZE);
Willy Tarreaue6182842019-04-15 18:54:10 +02001101#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001102
1103 chunk_appendf(&trash, "\n");
1104
1105 if (ci_putchk(si_ic(si), &trash) == -1) {
1106 chunk_reset(&trash);
1107 chunk_printf(&trash, "[output too large, cannot dump]\n");
Willy Tarreaudb398432018-11-15 11:08:52 +01001108 si_rx_room_blk(si);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001109 }
1110
1111 /* dump complete */
1112 return 1;
1113}
1114
William Lallemandeceddf72016-12-15 18:06:44 +01001115/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001116 * CLI IO handler for `show cli sockets`.
1117 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +01001118 */
1119static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1120{
1121 struct bind_conf *bind_conf;
1122 struct stream_interface *si = appctx->owner;
1123
1124 chunk_reset(&trash);
1125
1126 switch (appctx->st2) {
1127 case STAT_ST_INIT:
1128 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +02001129 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001130 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001131 return 0;
1132 }
William Lallemandeceddf72016-12-15 18:06:44 +01001133 appctx->st2 = STAT_ST_LIST;
1134
1135 case STAT_ST_LIST:
1136 if (global.stats_fe) {
1137 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
1138 struct listener *l;
1139
1140 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001141 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +01001142 * if the current node is the first of the list
1143 */
1144
Willy Tarreau3af9d832016-12-16 12:58:09 +01001145 if (appctx->ctx.cli.p0 &&
1146 &bind_conf->by_fe == (&global.stats_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +01001147 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +01001148 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +01001149 continue;
1150 }
1151
1152 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
1153
1154 char addr[46];
1155 char port[6];
1156
1157 if (l->addr.ss_family == AF_UNIX) {
1158 const struct sockaddr_un *un;
1159
1160 un = (struct sockaddr_un *)&l->addr;
William Lallemande58915f2019-04-01 11:30:05 +02001161 if (un->sun_path[0] == '\0') {
William Lallemand75812a72019-04-01 11:30:04 +02001162 chunk_appendf(&trash, "abns@%s ", un->sun_path+1);
William Lallemande58915f2019-04-01 11:30:05 +02001163 } else {
1164 chunk_appendf(&trash, "unix@%s ", un->sun_path);
1165 }
William Lallemandeceddf72016-12-15 18:06:44 +01001166 } else if (l->addr.ss_family == AF_INET) {
1167 addr_to_str(&l->addr, addr, sizeof(addr));
1168 port_to_str(&l->addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001169 chunk_appendf(&trash, "ipv4@%s:%s ", addr, port);
William Lallemandeceddf72016-12-15 18:06:44 +01001170 } else if (l->addr.ss_family == AF_INET6) {
1171 addr_to_str(&l->addr, addr, sizeof(addr));
1172 port_to_str(&l->addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001173 chunk_appendf(&trash, "ipv6@[%s]:%s ", addr, port);
William Lallemand26314342018-10-26 14:47:41 +02001174 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
1175 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
William Lallemandeceddf72016-12-15 18:06:44 +01001176 } else
William Lallemand26314342018-10-26 14:47:41 +02001177 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001178
William Lallemand07a62f72017-05-24 00:57:40 +02001179 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +01001180 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +02001181 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1182 chunk_appendf(&trash, "operator ");
1183 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1184 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +01001185 else
1186 chunk_appendf(&trash, " ");
1187
1188 if (bind_conf->bind_proc != 0) {
1189 int pos;
Willy Tarreau20c5e522016-12-16 12:50:55 +01001190 for (pos = 0; pos < 8 * sizeof(bind_conf->bind_proc); pos++) {
Willy Tarreau4305ac72016-12-16 12:56:31 +01001191 if (bind_conf->bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +01001192 chunk_appendf(&trash, "%d,", pos+1);
1193 }
1194 }
1195 /* replace the latest comma by a newline */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001196 trash.area[trash.data-1] = '\n';
William Lallemandeceddf72016-12-15 18:06:44 +01001197
1198 } else {
1199 chunk_appendf(&trash, "all\n");
1200 }
1201
Willy Tarreau06d80a92017-10-19 14:32:15 +02001202 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001203 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001204 return 0;
1205 }
1206 }
Willy Tarreau3af9d832016-12-16 12:58:09 +01001207 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001208 }
1209 }
1210 default:
1211 appctx->st2 = STAT_ST_FIN;
1212 return 1;
1213 }
1214}
1215
1216
Willy Tarreau0a739292016-11-22 20:21:23 +01001217/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001218 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1219 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001220 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001221static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001222{
1223 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001224 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001225
1226 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1227 return 1;
1228
Willy Tarreauf6710f82016-12-16 17:45:44 +01001229 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001230
1231 if (*args[2]) {
1232 int len = strlen(args[2]);
1233
Willy Tarreauf6710f82016-12-16 17:45:44 +01001234 for (; *var; var++) {
1235 if (strncmp(*var, args[2], len) == 0 &&
1236 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001237 break;
1238 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001239 if (!*var) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001240 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau0a739292016-11-22 20:21:23 +01001241 appctx->ctx.cli.msg = "Variable not found\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001242 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau0a739292016-11-22 20:21:23 +01001243 return 1;
1244 }
1245 appctx->st2 = STAT_ST_END;
1246 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001247 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001248 return 0;
1249}
1250
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001251/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1252 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1253 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1254 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001255static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001256{
1257 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1258 return 1;
1259
1260 appctx->ctx.cli.i0 = 0;
1261
1262 if (*args[2]) {
1263 appctx->ctx.cli.i0 = atoi(args[2]);
1264 appctx->st2 = STAT_ST_END;
1265 }
1266 return 0;
1267}
1268
Willy Tarreau599852e2016-11-22 20:33:32 +01001269/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001270static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001271{
1272 struct stream_interface *si = appctx->owner;
1273 struct stream *s = si_strm(si);
1274
1275 if (strcmp(args[2], "cli") == 0) {
1276 unsigned timeout;
1277 const char *res;
1278
1279 if (!*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001280 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001281 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001282 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001283 return 1;
1284 }
1285
1286 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
1287 if (res || timeout < 1) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001288 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001289 appctx->ctx.cli.msg = "Invalid timeout value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001290 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001291 return 1;
1292 }
1293
1294 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1295 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1296 return 1;
1297 }
1298 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001299 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001300 appctx->ctx.cli.msg = "'set timeout' only supports 'cli'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001301 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001302 return 1;
1303 }
1304}
1305
Willy Tarreau2af99412016-11-23 11:10:59 +01001306/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001307static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001308{
1309 int v;
1310
1311 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1312 return 1;
1313
1314 if (!*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001315 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau2af99412016-11-23 11:10:59 +01001316 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001317 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +01001318 return 1;
1319 }
1320
1321 v = atoi(args[3]);
1322 if (v > global.hardmaxconn) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001323 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau2af99412016-11-23 11:10:59 +01001324 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001325 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +01001326 return 1;
1327 }
1328
1329 /* check for unlimited values */
1330 if (v <= 0)
1331 v = global.hardmaxconn;
1332
1333 global.maxconn = v;
1334
1335 /* Dequeues all of the listeners waiting for a resource */
1336 if (!LIST_ISEMPTY(&global_listener_queue))
1337 dequeue_all_listeners(&global_listener_queue);
1338
1339 return 1;
1340}
1341
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001342static int set_severity_output(int *target, char *argument)
1343{
1344 if (!strcmp(argument, "none")) {
1345 *target = CLI_SEVERITY_NONE;
1346 return 1;
1347 }
1348 else if (!strcmp(argument, "number")) {
1349 *target = CLI_SEVERITY_NUMBER;
1350 return 1;
1351 }
1352 else if (!strcmp(argument, "string")) {
1353 *target = CLI_SEVERITY_STRING;
1354 return 1;
1355 }
1356 return 0;
1357}
1358
1359/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001360static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001361{
1362 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1363 return 0;
1364
1365 appctx->ctx.cli.severity = LOG_ERR;
Aurélien Nephtali6e8a41d2018-03-15 21:48:50 +01001366 appctx->ctx.cli.msg = "one of 'none', 'number', 'string' is a required argument\n";
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001367 appctx->st0 = CLI_ST_PRINT;
1368 return 1;
1369}
William Lallemandeceddf72016-12-15 18:06:44 +01001370
William Lallemand67a234f2018-12-13 09:05:45 +01001371
1372/* show the level of the current CLI session */
1373static int cli_parse_show_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1374{
1375
1376 appctx->ctx.cli.severity = LOG_INFO;
1377 if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
1378 appctx->ctx.cli.msg = "admin\n";
1379 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1380 appctx->ctx.cli.msg = "operator\n";
1381 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1382 appctx->ctx.cli.msg = "user\n";
1383 else
1384 appctx->ctx.cli.msg = "unknown\n";
1385
1386 appctx->st0 = CLI_ST_PRINT;
1387 return 1;
1388
1389}
1390
1391/* parse and set the CLI level dynamically */
1392static int cli_parse_set_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1393{
1394 if (!strcmp(args[0], "operator")) {
1395 if (!cli_has_level(appctx, ACCESS_LVL_OPER)) {
1396 return 1;
1397 }
1398 appctx->cli_level &= ~ACCESS_LVL_MASK;
1399 appctx->cli_level |= ACCESS_LVL_OPER;
1400
1401 } else if (!strcmp(args[0], "user")) {
1402 if (!cli_has_level(appctx, ACCESS_LVL_USER)) {
1403 return 1;
1404 }
1405 appctx->cli_level &= ~ACCESS_LVL_MASK;
1406 appctx->cli_level |= ACCESS_LVL_USER;
1407 }
1408 return 1;
1409}
1410
William Lallemanda57b7e32018-12-14 21:11:31 +01001411
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001412int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001413{
1414 return 0;
1415}
1416
Willy Tarreau45c742b2016-11-24 14:51:17 +01001417/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001418static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001419{
1420 int v;
1421 int *res;
1422 int mul = 1;
1423
1424 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1425 return 1;
1426
1427 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1428 res = &global.cps_lim;
1429 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1430 res = &global.sps_lim;
1431#ifdef USE_OPENSSL
1432 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1433 res = &global.ssl_lim;
1434#endif
1435 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1436 res = &global.comp_rate_lim;
1437 mul = 1024;
1438 }
1439 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001440 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001441 appctx->ctx.cli.msg =
1442 "'set rate-limit' only supports :\n"
1443 " - 'connections global' to set the per-process maximum connection rate\n"
1444 " - 'sessions global' to set the per-process maximum session rate\n"
1445#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001446 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001447#endif
1448 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001449 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001450 return 1;
1451 }
1452
1453 if (!*args[4]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001454 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001455 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001456 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001457 return 1;
1458 }
1459
1460 v = atoi(args[4]);
1461 if (v < 0) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001462 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001463 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001464 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001465 return 1;
1466 }
1467
1468 *res = v * mul;
1469
1470 /* Dequeues all of the listeners waiting for a resource */
1471 if (!LIST_ISEMPTY(&global_listener_queue))
1472 dequeue_all_listeners(&global_listener_queue);
1473
1474 return 1;
1475}
1476
William Lallemandf6975e92017-05-26 17:42:10 +02001477/* parse the "expose-fd" argument on the bind lines */
1478static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1479{
1480 if (!*args[cur_arg + 1]) {
1481 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1482 return ERR_ALERT | ERR_FATAL;
1483 }
1484 if (!strcmp(args[cur_arg+1], "listeners")) {
1485 conf->level |= ACCESS_FD_LISTENERS;
1486 } else {
1487 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1488 args[cur_arg], args[cur_arg+1]);
1489 return ERR_ALERT | ERR_FATAL;
1490 }
1491
1492 return 0;
1493}
1494
William Lallemand74c24fb2016-11-21 17:18:36 +01001495/* parse the "level" argument on the bind lines */
1496static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1497{
1498 if (!*args[cur_arg + 1]) {
1499 memprintf(err, "'%s' : missing level", args[cur_arg]);
1500 return ERR_ALERT | ERR_FATAL;
1501 }
1502
William Lallemand07a62f72017-05-24 00:57:40 +02001503 if (!strcmp(args[cur_arg+1], "user")) {
1504 conf->level &= ~ACCESS_LVL_MASK;
1505 conf->level |= ACCESS_LVL_USER;
1506 } else if (!strcmp(args[cur_arg+1], "operator")) {
1507 conf->level &= ~ACCESS_LVL_MASK;
1508 conf->level |= ACCESS_LVL_OPER;
1509 } else if (!strcmp(args[cur_arg+1], "admin")) {
1510 conf->level &= ~ACCESS_LVL_MASK;
1511 conf->level |= ACCESS_LVL_ADMIN;
1512 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001513 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1514 args[cur_arg], args[cur_arg+1]);
1515 return ERR_ALERT | ERR_FATAL;
1516 }
1517
1518 return 0;
1519}
1520
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001521static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1522{
1523 if (!*args[cur_arg + 1]) {
1524 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1525 return ERR_ALERT | ERR_FATAL;
1526 }
1527
1528 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1529 return 0;
1530 else {
1531 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1532 args[cur_arg], args[cur_arg+1]);
1533 return ERR_ALERT | ERR_FATAL;
1534 }
1535}
1536
William Lallemand16dd1b32018-11-19 18:46:18 +01001537
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001538
Olivier Houchardf886e342017-04-05 22:24:59 +02001539/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001540static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02001541{
1542 char *cmsgbuf = NULL;
1543 unsigned char *tmpbuf = NULL;
1544 struct cmsghdr *cmsg;
1545 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001546 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001547 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001548 struct msghdr msghdr;
1549 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001550 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Olivier Houchardf886e342017-04-05 22:24:59 +02001551 int *tmpfd;
1552 int tot_fd_nb = 0;
1553 struct proxy *px;
1554 int i = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001555 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001556 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001557 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001558 int ret;
1559
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001560 if (!remote) {
1561 ha_warning("Only works on real connections\n");
1562 goto out;
1563 }
1564
1565 fd = remote->handle.fd;
1566
Olivier Houchardf886e342017-04-05 22:24:59 +02001567 /* Temporary set the FD in blocking mode, that will make our life easier */
1568 old_fcntl = fcntl(fd, F_GETFL);
1569 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001570 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001571 goto out;
1572 }
1573 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1574 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001575 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001576 goto out;
1577 }
1578 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001579 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001580 goto out;
1581 }
Olivier Houchard54740872017-04-06 14:45:14 +02001582 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001583 iov.iov_base = &tot_fd_nb;
1584 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001585 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001586 goto out;
1587 memset(&msghdr, 0, sizeof(msghdr));
1588 /*
1589 * First, calculates the total number of FD, so that we can let
1590 * the caller know how much he should expects.
1591 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001592 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001593 while (px) {
1594 struct listener *l;
1595
1596 list_for_each_entry(l, &px->conf.listeners, by_fe) {
Olivier Houchard1fc05162017-04-06 01:05:05 +02001597 /* Only transfer IPv4/IPv6/UNIX sockets */
1598 if (l->state >= LI_ZOMBIE &&
1599 (l->proto->sock_family == AF_INET ||
Olivier Houchardf886e342017-04-05 22:24:59 +02001600 l->proto->sock_family == AF_INET6 ||
Olivier Houchard1fc05162017-04-06 01:05:05 +02001601 l->proto->sock_family == AF_UNIX))
Olivier Houchardf886e342017-04-05 22:24:59 +02001602 tot_fd_nb++;
1603 }
1604 px = px->next;
1605 }
1606 if (tot_fd_nb == 0)
1607 goto out;
1608
1609 /* First send the total number of file descriptors, so that the
1610 * receiving end knows what to expect.
1611 */
1612 msghdr.msg_iov = &iov;
1613 msghdr.msg_iovlen = 1;
1614 ret = sendmsg(fd, &msghdr, 0);
1615 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001616 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001617 goto out;
1618 }
1619
1620 /* Now send the fds */
1621 msghdr.msg_control = cmsgbuf;
1622 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1623 cmsg = CMSG_FIRSTHDR(&msghdr);
1624 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1625 cmsg->cmsg_level = SOL_SOCKET;
1626 cmsg->cmsg_type = SCM_RIGHTS;
1627 tmpfd = (int *)CMSG_DATA(cmsg);
1628
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001629 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001630 /* For each socket, e message is sent, containing the following :
1631 * Size of the namespace name (or 0 if none), as an unsigned char.
1632 * The namespace name, if any
1633 * Size of the interface name (or 0 if none), as an unsigned char
1634 * The interface name, if any
1635 * Listener options, as an int.
1636 */
1637 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
1638 * buffer big enough to store the socket informations.
1639 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001640 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001641 if (tmpbuf == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001642 ha_warning("Failed to allocate memory to transfer socket informations\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001643 goto out;
1644 }
1645 iov.iov_base = tmpbuf;
1646 while (px) {
1647 struct listener *l;
1648
1649 list_for_each_entry(l, &px->conf.listeners, by_fe) {
1650 int ret;
1651 /* Only transfer IPv4/IPv6 sockets */
Olivier Houchard1fc05162017-04-06 01:05:05 +02001652 if (l->state >= LI_ZOMBIE &&
Olivier Houchardf886e342017-04-05 22:24:59 +02001653 (l->proto->sock_family == AF_INET ||
1654 l->proto->sock_family == AF_INET6 ||
1655 l->proto->sock_family == AF_UNIX)) {
1656 memcpy(&tmpfd[i % MAX_SEND_FD], &l->fd, sizeof(l->fd));
1657 if (!l->netns)
1658 tmpbuf[curoff++] = 0;
1659#ifdef CONFIG_HAP_NS
1660 else {
1661 char *name = l->netns->node.key;
1662 unsigned char len = l->netns->name_len;
1663 tmpbuf[curoff++] = len;
1664 memcpy(tmpbuf + curoff, name, len);
1665 curoff += len;
1666 }
1667#endif
1668 if (l->interface) {
1669 unsigned char len = strlen(l->interface);
1670 tmpbuf[curoff++] = len;
1671 memcpy(tmpbuf + curoff, l->interface, len);
1672 curoff += len;
1673 } else
1674 tmpbuf[curoff++] = 0;
1675 memcpy(tmpbuf + curoff, &l->options,
1676 sizeof(l->options));
1677 curoff += sizeof(l->options);
1678
1679
1680 i++;
1681 } else
1682 continue;
1683 if ((!(i % MAX_SEND_FD))) {
1684 iov.iov_len = curoff;
1685 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001686 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001687 goto out;
1688 }
1689 /* Wait for an ack */
1690 do {
1691 ret = recv(fd, &tot_fd_nb,
1692 sizeof(tot_fd_nb), 0);
1693 } while (ret == -1 && errno == EINTR);
1694 if (ret <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001695 ha_warning("Unexpected error while transferring sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001696 goto out;
1697 }
1698 curoff = 0;
1699 }
1700
1701 }
1702 px = px->next;
1703 }
1704 if (i % MAX_SEND_FD) {
1705 iov.iov_len = curoff;
1706 cmsg->cmsg_len = CMSG_LEN((i % MAX_SEND_FD) * sizeof(int));
1707 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * (i % MAX_SEND_FD));
1708 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001709 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001710 goto out;
1711 }
1712 }
1713
1714out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001715 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001716 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001717 goto out;
1718 }
1719 appctx->st0 = CLI_ST_END;
1720 free(cmsgbuf);
1721 free(tmpbuf);
1722 return 1;
1723}
1724
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001725static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
1726{
1727 if (*args[0] == 'h')
1728 /* help */
1729 cli_gen_usage_msg(appctx);
1730 else if (*args[0] == 'p')
1731 /* prompt */
1732 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
1733 else if (*args[0] == 'q')
1734 /* quit */
1735 appctx->st0 = CLI_ST_END;
1736
1737 return 1;
1738}
Olivier Houchardf886e342017-04-05 22:24:59 +02001739
William Lallemand2f4ce202018-10-26 14:47:47 +02001740void pcli_write_prompt(struct stream *s)
1741{
1742 struct buffer *msg = get_trash_chunk();
1743 struct channel *oc = si_oc(&s->si[0]);
1744
William Lallemanddc12c2e2018-12-13 09:05:46 +01001745 if (!(s->pcli_flags & PCLI_F_PROMPT))
William Lallemand5b80fa22018-12-11 16:10:54 +01001746 return;
1747
William Lallemanddc12c2e2018-12-13 09:05:46 +01001748 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01001749 chunk_appendf(msg, "+ ");
1750 } else {
1751 if (s->pcli_next_pid == 0)
Willy Tarreau52880f92018-12-15 13:30:03 +01001752 chunk_appendf(msg, "master%s> ",
1753 (global.mode & MODE_MWORKER_WAIT) ? "[ReloadFailed]" : "");
William Lallemandebf61802018-12-11 16:10:57 +01001754 else
1755 chunk_appendf(msg, "%d> ", s->pcli_next_pid);
1756 }
William Lallemand2f4ce202018-10-26 14:47:47 +02001757 co_inject(oc, msg->area, msg->data);
1758}
1759
William Lallemand291810d2018-10-26 14:47:38 +02001760
William Lallemandcf62f7e2018-10-26 14:47:40 +02001761/* The pcli_* functions are used for the CLI proxy in the master */
1762
William Lallemanddeeaa592018-10-26 14:47:48 +02001763void pcli_reply_and_close(struct stream *s, const char *msg)
1764{
1765 struct buffer *buf = get_trash_chunk();
1766
1767 chunk_initstr(buf, msg);
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001768 si_retnclose(&s->si[0], buf);
William Lallemanddeeaa592018-10-26 14:47:48 +02001769}
1770
William Lallemand291810d2018-10-26 14:47:38 +02001771static enum obj_type *pcli_pid_to_server(int proc_pid)
1772{
1773 struct mworker_proc *child;
1774
William Lallemandbddd33a2018-12-11 16:10:53 +01001775 /* return the CLI applet of the master */
1776 if (proc_pid == 0)
1777 return &cli_applet.obj_type;
1778
William Lallemand291810d2018-10-26 14:47:38 +02001779 list_for_each_entry(child, &proc_list, list) {
1780 if (child->pid == proc_pid){
1781 return &child->srv->obj_type;
1782 }
1783 }
1784 return NULL;
1785}
1786
1787/* Take a CLI prefix in argument (eg: @!1234 @master @1)
1788 * Return:
1789 * 0: master
1790 * > 0: pid of a worker
1791 * < 0: didn't find a worker
1792 */
1793static int pcli_prefix_to_pid(const char *prefix)
1794{
1795 int proc_pid;
1796 struct mworker_proc *child;
1797 char *errtol = NULL;
1798
1799 if (*prefix != '@') /* not a prefix, should not happen */
1800 return -1;
1801
1802 prefix++;
1803 if (!*prefix) /* sent @ alone, return the master */
1804 return 0;
1805
1806 if (strcmp("master", prefix) == 0) {
1807 return 0;
1808 } else if (*prefix == '!') {
1809 prefix++;
1810 if (!*prefix)
1811 return -1;
1812
1813 proc_pid = strtol(prefix, &errtol, 10);
1814 if (*errtol != '\0')
1815 return -1;
1816 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001817 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001818 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001819 if (child->pid == proc_pid){
1820 return child->pid;
1821 }
1822 }
1823 } else {
1824 struct mworker_proc *chosen = NULL;
1825 /* this is a relative pid */
1826
1827 proc_pid = strtol(prefix, &errtol, 10);
1828 if (*errtol != '\0')
1829 return -1;
1830
1831 if (proc_pid == 0) /* return the master */
1832 return 0;
1833
1834 /* chose the right process, the current one is the one with the
1835 least number of reloads */
1836 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001837 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001838 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001839 if (child->relative_pid == proc_pid){
1840 if (child->reloads == 0)
1841 return child->pid;
1842 else if (chosen == NULL || child->reloads < chosen->reloads)
1843 chosen = child;
1844 }
1845 }
1846 if (chosen)
1847 return chosen->pid;
1848 }
1849 return -1;
1850}
1851
William Lallemandbddd33a2018-12-11 16:10:53 +01001852/* Return::
1853 * >= 0 : number of words to escape
1854 * = -1 : error
1855 */
1856
1857int pcli_find_and_exec_kw(struct stream *s, char **args, int argl, char **errmsg, int *next_pid)
1858{
1859 if (argl < 1)
1860 return 0;
1861
1862 /* there is a prefix */
1863 if (args[0][0] == '@') {
1864 int target_pid = pcli_prefix_to_pid(args[0]);
1865
1866 if (target_pid == -1) {
1867 memprintf(errmsg, "Can't find the target PID matching the prefix '%s'\n", args[0]);
1868 return -1;
1869 }
1870
1871 /* if the prefix is alone, define a default target */
1872 if (argl == 1)
1873 s->pcli_next_pid = target_pid;
1874 else
1875 *next_pid = target_pid;
1876 return 1;
William Lallemand5b80fa22018-12-11 16:10:54 +01001877 } else if (!strcmp("prompt", args[0])) {
William Lallemanddc12c2e2018-12-13 09:05:46 +01001878 s->pcli_flags ^= PCLI_F_PROMPT;
William Lallemand5b80fa22018-12-11 16:10:54 +01001879 return argl; /* return the number of elements in the array */
William Lallemand5f610682018-12-11 16:10:55 +01001880
1881 } else if (!strcmp("quit", args[0])) {
1882 channel_shutr_now(&s->req);
1883 channel_shutw_now(&s->res);
1884 return argl; /* return the number of elements in the array */
William Lallemandb7ea1412018-12-13 09:05:47 +01001885 } else if (!strcmp(args[0], "operator")) {
1886 if (!pcli_has_level(s, ACCESS_LVL_OPER)) {
1887 memprintf(errmsg, "Permission denied!\n");
1888 return -1;
1889 }
1890 s->pcli_flags &= ~ACCESS_LVL_MASK;
1891 s->pcli_flags |= ACCESS_LVL_OPER;
1892 return argl;
1893
1894 } else if (!strcmp(args[0], "user")) {
1895 if (!pcli_has_level(s, ACCESS_LVL_USER)) {
1896 memprintf(errmsg, "Permission denied!\n");
1897 return -1;
1898 }
1899 s->pcli_flags &= ~ACCESS_LVL_MASK;
1900 s->pcli_flags |= ACCESS_LVL_USER;
1901 return argl;
William Lallemandbddd33a2018-12-11 16:10:53 +01001902 }
1903
1904 return 0;
1905}
1906
1907/*
1908 * Parse the CLI request:
1909 * - It does basically the same as the cli_io_handler, but as a proxy
1910 * - It can exec a command and strip non forwardable commands
William Lallemandcf62f7e2018-10-26 14:47:40 +02001911 *
1912 * Return:
William Lallemandbddd33a2018-12-11 16:10:53 +01001913 * - the number of characters to forward or
1914 * - 1 if there is an error or not enough data
William Lallemandcf62f7e2018-10-26 14:47:40 +02001915 */
William Lallemandbddd33a2018-12-11 16:10:53 +01001916int pcli_parse_request(struct stream *s, struct channel *req, char **errmsg, int *next_pid)
William Lallemandcf62f7e2018-10-26 14:47:40 +02001917{
William Lallemandbddd33a2018-12-11 16:10:53 +01001918 char *str = (char *)ci_head(req);
1919 char *end = (char *)ci_stop(req);
1920 char *args[MAX_STATS_ARGS + 1]; /* +1 for storing a NULL */
1921 int argl; /* number of args */
1922 char *p;
1923 char *trim = NULL;
William Lallemandebf61802018-12-11 16:10:57 +01001924 char *payload = NULL;
William Lallemandbddd33a2018-12-11 16:10:53 +01001925 int wtrim = 0; /* number of words to trim */
1926 int reql = 0;
William Lallemandb7ea1412018-12-13 09:05:47 +01001927 int ret;
William Lallemandbddd33a2018-12-11 16:10:53 +01001928 int i = 0;
1929
1930 p = str;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001931
William Lallemanddc12c2e2018-12-13 09:05:46 +01001932 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01001933
1934 /* Looks for the end of one command */
1935 while (p+reql < end) {
1936 /* handle escaping */
1937 if (p[reql] == '\\') {
1938 reql++;
1939 continue;
1940 }
1941 if (p[reql] == ';' || p[reql] == '\n') {
1942 /* found the end of the command */
1943 p[reql] = '\n';
1944 reql++;
1945 break;
1946 }
William Lallemandbddd33a2018-12-11 16:10:53 +01001947 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01001948 }
William Lallemandebf61802018-12-11 16:10:57 +01001949 } else {
1950 while (p+reql < end) {
1951 if (p[reql] == '\n') {
1952 /* found the end of the line */
1953 reql++;
1954 break;
1955 }
William Lallemandbddd33a2018-12-11 16:10:53 +01001956 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01001957 }
William Lallemandbddd33a2018-12-11 16:10:53 +01001958 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02001959
William Lallemandbddd33a2018-12-11 16:10:53 +01001960 /* set end to first byte after the end of the command */
1961 end = p + reql;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001962
William Lallemandbddd33a2018-12-11 16:10:53 +01001963 /* there is no end to this command, need more to parse ! */
1964 if (*(end-1) != '\n') {
1965 return -1;
1966 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02001967
William Lallemand3301f3e2018-12-13 09:05:48 +01001968 if (s->pcli_flags & PCLI_F_PAYLOAD) {
1969 if (reql == 1) /* last line of the payload */
1970 s->pcli_flags &= ~PCLI_F_PAYLOAD;
William Lallemandebf61802018-12-11 16:10:57 +01001971 return reql;
1972 }
1973
William Lallemandbddd33a2018-12-11 16:10:53 +01001974 *(end-1) = '\0';
William Lallemandcf62f7e2018-10-26 14:47:40 +02001975
William Lallemandbddd33a2018-12-11 16:10:53 +01001976 /* splits the command in words */
1977 while (i < MAX_STATS_ARGS && p < end) {
1978 int j, k;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001979
William Lallemandbddd33a2018-12-11 16:10:53 +01001980 /* skip leading spaces/tabs */
1981 p += strspn(p, " \t");
1982 if (!*p)
William Lallemandcf62f7e2018-10-26 14:47:40 +02001983 break;
1984
William Lallemandbddd33a2018-12-11 16:10:53 +01001985 args[i] = p;
1986 p += strcspn(p, " \t");
1987 *p++ = 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001988
William Lallemandbddd33a2018-12-11 16:10:53 +01001989 /* unescape backslashes (\) */
1990 for (j = 0, k = 0; args[i][k]; k++) {
1991 if (args[i][k] == '\\') {
1992 if (args[i][k + 1] == '\\')
1993 k++;
1994 else
1995 continue;
1996 }
1997 args[i][j] = args[i][k];
1998 j++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001999 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002000 args[i][j] = 0;
2001 i++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002002 }
2003
William Lallemandbddd33a2018-12-11 16:10:53 +01002004 argl = i;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002005
William Lallemandbddd33a2018-12-11 16:10:53 +01002006 for (; i < MAX_STATS_ARGS + 1; i++)
2007 args[i] = NULL;
2008
2009 wtrim = pcli_find_and_exec_kw(s, args, argl, errmsg, next_pid);
2010
2011 /* End of words are ending by \0, we need to replace the \0s by spaces
20121 before forwarding them */
2013 p = str;
William Lallemand3301f3e2018-12-13 09:05:48 +01002014 while (p < end-1) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002015 if (*p == '\0')
2016 *p = ' ';
2017 p++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002018 }
2019
William Lallemand3301f3e2018-12-13 09:05:48 +01002020 payload = strstr(str, PAYLOAD_PATTERN);
2021 if ((end - 1) == (payload + strlen(PAYLOAD_PATTERN))) {
2022 /* if the payload pattern is at the end */
2023 s->pcli_flags |= PCLI_F_PAYLOAD;
2024 ret = reql;
2025 }
2026
William Lallemandbddd33a2018-12-11 16:10:53 +01002027 *(end-1) = '\n';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002028
William Lallemandbddd33a2018-12-11 16:10:53 +01002029 if (wtrim > 0) {
2030 trim = &args[wtrim][0];
2031 if (trim == NULL) /* if this was the last word in the table */
2032 trim = end;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002033
William Lallemandbddd33a2018-12-11 16:10:53 +01002034 b_del(&req->buf, trim - str);
2035
William Lallemandb7ea1412018-12-13 09:05:47 +01002036 ret = end - trim;
William Lallemandbddd33a2018-12-11 16:10:53 +01002037 } else if (wtrim < 0) {
2038 /* parsing error */
2039 return -1;
William Lallemandb7ea1412018-12-13 09:05:47 +01002040 } else {
2041 /* the whole string */
2042 ret = end - str;
William Lallemandbddd33a2018-12-11 16:10:53 +01002043 }
2044
William Lallemandb7ea1412018-12-13 09:05:47 +01002045 if (ret > 1) {
2046 if (pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2047 goto end;
2048 } else if (pcli_has_level(s, ACCESS_LVL_OPER)) {
2049 ci_insert_line2(req, 0, "operator", strlen("operator"));
2050 ret += strlen("operator") + 2;
2051 } else if (pcli_has_level(s, ACCESS_LVL_USER)) {
2052 ci_insert_line2(req, 0, "user", strlen("user"));
2053 ret += strlen("user") + 2;
2054 }
2055 }
2056end:
William Lallemandbddd33a2018-12-11 16:10:53 +01002057
William Lallemandb7ea1412018-12-13 09:05:47 +01002058 return ret;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002059}
2060
2061int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
2062{
William Lallemandbddd33a2018-12-11 16:10:53 +01002063 int next_pid = -1;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002064 int to_forward;
William Lallemandbddd33a2018-12-11 16:10:53 +01002065 char *errmsg = NULL;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002066
William Lallemandb7ea1412018-12-13 09:05:47 +01002067 if ((s->pcli_flags & ACCESS_LVL_MASK) == ACCESS_LVL_NONE)
2068 s->pcli_flags |= strm_li(s)->bind_conf->level & ACCESS_LVL_MASK;
2069
William Lallemandcf62f7e2018-10-26 14:47:40 +02002070read_again:
2071 /* if the channel is closed for read, we won't receive any more data
2072 from the client, but we don't want to forward this close to the
2073 server */
2074 channel_dont_close(req);
2075
2076 /* We don't know yet to which server we will connect */
2077 channel_dont_connect(req);
2078
2079
2080 /* we are not waiting for a response, there is no more request and we
2081 * receive a close from the client, we can leave */
2082 if (!(ci_data(req)) && req->flags & CF_SHUTR) {
2083 channel_shutw_now(&s->res);
2084 s->req.analysers &= ~AN_REQ_WAIT_CLI;
2085 return 1;
2086 }
2087
2088 req->flags |= CF_READ_DONTWAIT;
2089
2090 /* need more data */
2091 if (!ci_data(req))
2092 return 0;
2093
2094 /* If there is data available for analysis, log the end of the idle time. */
2095 if (c_data(req) && s->logs.t_idle == -1)
2096 s->logs.t_idle = tv_ms_elapsed(&s->logs.tv_accept, &now) - s->logs.t_handshake;
2097
William Lallemandbddd33a2018-12-11 16:10:53 +01002098 to_forward = pcli_parse_request(s, req, &errmsg, &next_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002099 if (to_forward > 0) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002100 int target_pid;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002101 /* enough data */
2102
William Lallemandcf62f7e2018-10-26 14:47:40 +02002103 /* forward only 1 command */
2104 channel_forward(req, to_forward);
William Lallemandebf61802018-12-11 16:10:57 +01002105
William Lallemanddc12c2e2018-12-13 09:05:46 +01002106 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002107 /* we send only 1 command per request, and we write close after it */
2108 channel_shutw_now(req);
2109 } else {
2110 pcli_write_prompt(s);
2111 }
2112
2113 s->res.flags |= CF_WAKE_ONCE; /* need to be called again */
William Lallemandcf62f7e2018-10-26 14:47:40 +02002114
2115 /* remove the XFER_DATA analysers, which forwards all
2116 * the data, we don't want to forward the next requests
2117 * We need to add CF_FLT_ANALYZE to abort the forward too.
2118 */
2119 req->analysers &= ~(AN_REQ_FLT_XFER_DATA|AN_REQ_WAIT_CLI);
2120 req->analysers |= AN_REQ_FLT_END|CF_FLT_ANALYZE;
2121 s->res.analysers |= AN_RES_WAIT_CLI;
2122
William Lallemandebf61802018-12-11 16:10:57 +01002123 if (!(s->flags & SF_ASSIGNED)) {
2124 if (next_pid > -1)
2125 target_pid = next_pid;
2126 else
2127 target_pid = s->pcli_next_pid;
2128 /* we can connect now */
2129 s->target = pcli_pid_to_server(target_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002130
William Lallemandebf61802018-12-11 16:10:57 +01002131 s->flags |= (SF_DIRECT | SF_ASSIGNED);
2132 channel_auto_connect(req);
2133 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002134
2135 } else if (to_forward == 0) {
William Lallemandcf62f7e2018-10-26 14:47:40 +02002136 /* we trimmed things but we might have other commands to consume */
William Lallemandbddd33a2018-12-11 16:10:53 +01002137 pcli_write_prompt(s);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002138 goto read_again;
William Lallemandbddd33a2018-12-11 16:10:53 +01002139 } else if (to_forward == -1 && errmsg) {
2140 /* there was an error during the parsing */
2141 pcli_reply_and_close(s, errmsg);
2142 return 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002143 } else if (to_forward == -1 && channel_full(req, global.tune.maxrewrite)) {
2144 /* buffer is full and we didn't catch the end of a command */
2145 goto send_help;
2146 }
2147
2148 return 0;
2149
2150send_help:
2151 b_reset(&req->buf);
2152 b_putblk(&req->buf, "help\n", 5);
2153 goto read_again;
2154}
2155
2156int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
2157{
2158 struct proxy *fe = strm_fe(s);
2159 struct proxy *be = s->be;
2160
William Lallemand6b7cd0a2018-11-06 17:37:11 +01002161 if (rep->flags & CF_READ_ERROR) {
2162 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
2163 s->res.analysers &= ~AN_RES_WAIT_CLI;
2164 return 0;
2165 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002166 rep->flags |= CF_READ_DONTWAIT; /* try to get back here ASAP */
2167 rep->flags |= CF_NEVER_WAIT;
2168
2169 /* don't forward the close */
2170 channel_dont_close(&s->res);
2171 channel_dont_close(&s->req);
2172
William Lallemanddc12c2e2018-12-13 09:05:46 +01002173 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002174 s->req.analysers |= AN_REQ_WAIT_CLI;
2175 s->res.analysers &= ~AN_RES_WAIT_CLI;
2176 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2177 return 0;
2178 }
2179
William Lallemandcf62f7e2018-10-26 14:47:40 +02002180 /* forward the data */
2181 if (ci_data(rep)) {
2182 c_adv(rep, ci_data(rep));
2183 return 0;
2184 }
2185
2186 if ((rep->flags & (CF_SHUTR|CF_READ_NULL))) {
2187 /* stream cleanup */
2188
William Lallemand2f4ce202018-10-26 14:47:47 +02002189 pcli_write_prompt(s);
2190
William Lallemandcf62f7e2018-10-26 14:47:40 +02002191 s->si[1].flags |= SI_FL_NOLINGER | SI_FL_NOHALF;
2192 si_shutr(&s->si[1]);
2193 si_shutw(&s->si[1]);
2194
2195 /*
2196 * starting from there this the same code as
2197 * http_end_txn_clean_session().
2198 *
2199 * It allows to do frontend keepalive while reconnecting to a
2200 * new server for each request.
2201 */
2202
2203 if (s->flags & SF_BE_ASSIGNED) {
2204 HA_ATOMIC_SUB(&be->beconn, 1);
2205 if (unlikely(s->srv_conn))
2206 sess_change_server(s, NULL);
2207 }
2208
2209 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2210 stream_process_counters(s);
2211
2212 /* don't count other requests' data */
2213 s->logs.bytes_in -= ci_data(&s->req);
2214 s->logs.bytes_out -= ci_data(&s->res);
2215
2216 /* we may need to know the position in the queue */
2217 pendconn_free(s);
2218
2219 /* let's do a final log if we need it */
2220 if (!LIST_ISEMPTY(&fe->logformat) && s->logs.logwait &&
2221 !(s->flags & SF_MONITOR) &&
2222 (!(fe->options & PR_O_NULLNOLOG) || s->req.total)) {
2223 s->do_log(s);
2224 }
2225
2226 /* stop tracking content-based counters */
2227 stream_stop_content_counters(s);
2228 stream_update_time_stats(s);
2229
2230 s->logs.accept_date = date; /* user-visible date for logging */
2231 s->logs.tv_accept = now; /* corrected date for internal use */
2232 s->logs.t_handshake = 0; /* There are no handshake in keep alive connection. */
2233 s->logs.t_idle = -1;
2234 tv_zero(&s->logs.tv_request);
2235 s->logs.t_queue = -1;
2236 s->logs.t_connect = -1;
2237 s->logs.t_data = -1;
2238 s->logs.t_close = 0;
2239 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
2240 s->logs.srv_queue_pos = 0; /* we will get this number soon */
2241
2242 s->logs.bytes_in = s->req.total = ci_data(&s->req);
2243 s->logs.bytes_out = s->res.total = ci_data(&s->res);
2244
2245 stream_del_srv_conn(s);
2246 if (objt_server(s->target)) {
2247 if (s->flags & SF_CURR_SESS) {
2248 s->flags &= ~SF_CURR_SESS;
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002249 HA_ATOMIC_SUB(&__objt_server(s->target)->cur_sess, 1);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002250 }
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002251 if (may_dequeue_tasks(__objt_server(s->target), be))
2252 process_srv_queue(__objt_server(s->target));
William Lallemandcf62f7e2018-10-26 14:47:40 +02002253 }
2254
2255 s->target = NULL;
2256
2257 /* only release our endpoint if we don't intend to reuse the
2258 * connection.
2259 */
2260 if (!si_conn_ready(&s->si[1])) {
2261 si_release_endpoint(&s->si[1]);
2262 s->srv_conn = NULL;
2263 }
2264
2265 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
2266 s->si[1].err_type = SI_ET_NONE;
2267 s->si[1].conn_retries = 0; /* used for logging too */
2268 s->si[1].exp = TICK_ETERNITY;
2269 s->si[1].flags &= SI_FL_ISBACK | SI_FL_DONT_WAKE; /* we're in the context of process_stream */
2270 s->req.flags &= ~(CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CONNECT|CF_WRITE_ERROR|CF_STREAMER|CF_STREAMER_FAST|CF_NEVER_WAIT|CF_WAKE_CONNECT|CF_WROTE_DATA);
2271 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);
2272 s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_ADDR_SET|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
2273 s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
2274 s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
2275 /* reinitialise the current rule list pointer to NULL. We are sure that
2276 * any rulelist match the NULL pointer.
2277 */
2278 s->current_rule_list = NULL;
2279
2280 s->be = strm_fe(s);
2281 s->logs.logwait = strm_fe(s)->to_log;
2282 s->logs.level = 0;
2283 stream_del_srv_conn(s);
2284 s->target = NULL;
2285 /* re-init store persistence */
2286 s->store_count = 0;
2287 s->uniq_id = global.req_count++;
2288
2289 s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */
2290
2291 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2292
2293 s->req.analysers |= AN_REQ_WAIT_CLI;
2294 s->res.analysers &= ~AN_RES_WAIT_CLI;
2295
2296 /* We must trim any excess data from the response buffer, because we
2297 * may have blocked an invalid response from a server that we don't
Joseph Herlant008b3ce2018-11-25 12:51:45 -08002298 * want to accidently forward once we disable the analysers, nor do
William Lallemandcf62f7e2018-10-26 14:47:40 +02002299 * we want those data to come along with next response. A typical
2300 * example of such data would be from a buggy server responding to
2301 * a HEAD with some data, or sending more than the advertised
2302 * content-length.
2303 */
2304 if (unlikely(ci_data(&s->res)))
2305 b_set_data(&s->res.buf, co_data(&s->res));
2306
2307 /* Now we can realign the response buffer */
2308 c_realign_if_empty(&s->res);
2309
2310 s->req.rto = strm_fe(s)->timeout.client;
2311 s->req.wto = TICK_ETERNITY;
2312
2313 s->res.rto = TICK_ETERNITY;
2314 s->res.wto = strm_fe(s)->timeout.client;
2315
2316 s->req.rex = TICK_ETERNITY;
2317 s->req.wex = TICK_ETERNITY;
2318 s->req.analyse_exp = TICK_ETERNITY;
2319 s->res.rex = TICK_ETERNITY;
2320 s->res.wex = TICK_ETERNITY;
2321 s->res.analyse_exp = TICK_ETERNITY;
2322 s->si[1].hcto = TICK_ETERNITY;
2323
2324 /* we're removing the analysers, we MUST re-enable events detection.
2325 * We don't enable close on the response channel since it's either
2326 * already closed, or in keep-alive with an idle connection handler.
2327 */
2328 channel_auto_read(&s->req);
2329 channel_auto_close(&s->req);
2330 channel_auto_read(&s->res);
2331
2332
2333 return 1;
2334 }
2335 return 0;
2336}
2337
William Lallemand8a022572018-10-26 14:47:35 +02002338/*
2339 * The mworker functions are used to initialize the CLI in the master process
2340 */
2341
William Lallemand309dc9a2018-10-26 14:47:45 +02002342 /*
2343 * Stop the mworker proxy
2344 */
2345void mworker_cli_proxy_stop()
2346{
William Lallemand550db6d2018-11-06 17:37:12 +01002347 if (mworker_proxy)
2348 stop_proxy(mworker_proxy);
William Lallemand309dc9a2018-10-26 14:47:45 +02002349}
2350
William Lallemand8a022572018-10-26 14:47:35 +02002351/*
2352 * Create the mworker CLI proxy
2353 */
2354int mworker_cli_proxy_create()
2355{
2356 struct mworker_proc *child;
William Lallemand744a0892018-11-22 16:46:51 +01002357 char *msg = NULL;
2358 char *errmsg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002359
2360 mworker_proxy = calloc(1, sizeof(*mworker_proxy));
2361 if (!mworker_proxy)
2362 return -1;
2363
2364 init_new_proxy(mworker_proxy);
2365 mworker_proxy->next = proxies_list;
2366 proxies_list = mworker_proxy;
2367 mworker_proxy->id = strdup("MASTER");
William Lallemandcf62f7e2018-10-26 14:47:40 +02002368 mworker_proxy->mode = PR_MODE_CLI;
William Lallemand8a022572018-10-26 14:47:35 +02002369 mworker_proxy->state = PR_STNEW;
2370 mworker_proxy->last_change = now.tv_sec;
2371 mworker_proxy->cap = PR_CAP_LISTEN; /* this is a listen section */
2372 mworker_proxy->maxconn = 10; /* default to 10 concurrent connections */
2373 mworker_proxy->timeout.client = 0; /* no timeout */
2374 mworker_proxy->conf.file = strdup("MASTER");
2375 mworker_proxy->conf.line = 0;
2376 mworker_proxy->accept = frontend_accept;
2377 mworker_proxy-> lbprm.algo = BE_LB_ALGO_NONE;
2378
2379 /* Does not init the default target the CLI applet, but must be done in
2380 * the request parsing code */
2381 mworker_proxy->default_target = NULL;
2382
2383 /* the check_config_validity() will get an ID for the proxy */
2384 mworker_proxy->uuid = -1;
2385
2386 proxy_store_name(mworker_proxy);
2387
2388 /* create all servers using the mworker_proc list */
2389 list_for_each_entry(child, &proc_list, list) {
William Lallemand8a022572018-10-26 14:47:35 +02002390 struct server *newsrv = NULL;
2391 struct sockaddr_storage *sk;
2392 int port1, port2, port;
2393 struct protocol *proto;
William Lallemand8a022572018-10-26 14:47:35 +02002394
2395 newsrv = new_server(mworker_proxy);
2396 if (!newsrv)
William Lallemand744a0892018-11-22 16:46:51 +01002397 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002398
2399 /* we don't know the new pid yet */
2400 if (child->pid == -1)
2401 memprintf(&msg, "cur-%d", child->relative_pid);
2402 else
2403 memprintf(&msg, "old-%d", child->pid);
2404
2405 newsrv->next = mworker_proxy->srv;
2406 mworker_proxy->srv = newsrv;
2407 newsrv->conf.file = strdup(msg);
2408 newsrv->id = strdup(msg);
2409 newsrv->conf.line = 0;
2410
2411 memprintf(&msg, "sockpair@%d", child->ipc_fd[0]);
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002412 if ((sk = str2sa_range(msg, &port, &port1, &port2, &errmsg, NULL, NULL, 0)) == 0) {
William Lallemand744a0892018-11-22 16:46:51 +01002413 goto error;
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002414 }
2415 free(msg);
2416 msg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002417
2418 proto = protocol_by_family(sk->ss_family);
2419 if (!proto || !proto->connect) {
William Lallemand744a0892018-11-22 16:46:51 +01002420 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002421 }
2422
2423 /* no port specified */
2424 newsrv->flags |= SRV_F_MAPPORTS;
2425 newsrv->addr = *sk;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002426 /* don't let the server participate to load balancing */
2427 newsrv->iweight = 0;
2428 newsrv->uweight = 0;
William Lallemand8a022572018-10-26 14:47:35 +02002429 srv_lb_commit_status(newsrv);
William Lallemand291810d2018-10-26 14:47:38 +02002430
2431 child->srv = newsrv;
William Lallemand8a022572018-10-26 14:47:35 +02002432 }
2433 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002434
2435error:
2436 ha_alert("%s\n", errmsg);
2437
2438 list_for_each_entry(child, &proc_list, list) {
2439 free((char *)child->srv->conf.file); /* cast because of const char * */
2440 free(child->srv->id);
2441 free(child->srv);
2442 child->srv = NULL;
2443 }
2444 free(mworker_proxy->id);
2445 free(mworker_proxy->conf.file);
2446 free(mworker_proxy);
2447 mworker_proxy = NULL;
2448 free(errmsg);
2449 free(msg);
2450
2451 return -1;
William Lallemand8a022572018-10-26 14:47:35 +02002452}
Olivier Houchardf886e342017-04-05 22:24:59 +02002453
William Lallemandce83b4a2018-10-26 14:47:30 +02002454/*
William Lallemande7361152018-10-26 14:47:36 +02002455 * Create a new listener for the master CLI proxy
2456 */
2457int mworker_cli_proxy_new_listener(char *line)
2458{
2459 struct bind_conf *bind_conf;
2460 struct listener *l;
2461 char *err = NULL;
2462 char *args[MAX_LINE_ARGS + 1];
2463 int arg;
2464 int cur_arg;
2465
2466 arg = 0;
2467 args[0] = line;
2468
2469 /* args is a bind configuration with spaces replaced by commas */
2470 while (*line && arg < MAX_LINE_ARGS) {
2471
2472 if (*line == ',') {
2473 *line++ = '\0';
2474 while (*line == ',')
2475 line++;
2476 args[++arg] = line;
2477 }
2478 line++;
2479 }
2480
2481 args[++arg] = "\0";
2482
2483 bind_conf = bind_conf_alloc(mworker_proxy, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002484 if (!bind_conf)
2485 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002486
2487 bind_conf->level &= ~ACCESS_LVL_MASK;
2488 bind_conf->level |= ACCESS_LVL_ADMIN;
2489
2490 if (!str2listener(args[0], mworker_proxy, bind_conf, "master-socket", 0, &err)) {
2491 ha_alert("Cannot create the listener of the master CLI\n");
William Lallemand744a0892018-11-22 16:46:51 +01002492 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002493 }
2494
2495 cur_arg = 1;
2496
2497 while (*args[cur_arg]) {
2498 static int bind_dumped;
2499 struct bind_kw *kw;
2500
2501 kw = bind_find_kw(args[cur_arg]);
2502 if (kw) {
2503 if (!kw->parse) {
2504 memprintf(&err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
2505 args[0], args[1], args[cur_arg]);
2506 goto err;
2507 }
2508
2509 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, &err) != 0) {
2510 if (err)
2511 memprintf(&err, "'%s %s' : '%s'", args[0], args[1], err);
2512 else
2513 memprintf(&err, "'%s %s' : error encountered while processing '%s'",
2514 args[0], args[1], args[cur_arg]);
2515 goto err;
2516 }
2517
2518 cur_arg += 1 + kw->skip;
2519 continue;
2520 }
2521
2522 if (!bind_dumped) {
2523 bind_dump_kws(&err);
2524 indent_msg(&err, 4);
2525 bind_dumped = 1;
2526 }
2527
2528 memprintf(&err, "'%s %s' : unknown keyword '%s'.%s%s",
2529 args[0], args[1], args[cur_arg],
2530 err ? " Registered keywords :" : "", err ? err : "");
2531 goto err;
2532 }
2533
2534
2535 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemande7361152018-10-26 14:47:36 +02002536 l->accept = session_accept_fd;
2537 l->default_target = mworker_proxy->default_target;
2538 /* don't make the peers subject to global limits and don't close it in the master */
2539 l->options |= (LI_O_UNLIMITED|LI_O_MWORKER); /* we are keeping this FD in the master */
2540 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002541 global.maxsock++; /* for the listening socket */
William Lallemande7361152018-10-26 14:47:36 +02002542 }
Willy Tarreau18215cb2019-02-27 16:25:28 +01002543 global.maxsock += mworker_proxy->maxconn;
William Lallemande7361152018-10-26 14:47:36 +02002544
2545 return 0;
2546
2547err:
2548 ha_alert("%s\n", err);
William Lallemand744a0892018-11-22 16:46:51 +01002549 free(err);
2550 free(bind_conf);
William Lallemande7361152018-10-26 14:47:36 +02002551 return -1;
2552
2553}
2554
2555/*
William Lallemandce83b4a2018-10-26 14:47:30 +02002556 * Create a new CLI socket using a socketpair for a worker process
2557 * <mworker_proc> is the process structure, and <proc> is the process number
2558 */
2559int mworker_cli_sockpair_new(struct mworker_proc *mworker_proc, int proc)
2560{
2561 struct bind_conf *bind_conf;
2562 struct listener *l;
2563 char *path = NULL;
2564 char *err = NULL;
2565
2566 /* master pipe to ensure the master is still alive */
2567 if (socketpair(AF_UNIX, SOCK_STREAM, 0, mworker_proc->ipc_fd) < 0) {
2568 ha_alert("Cannot create worker socketpair.\n");
2569 return -1;
2570 }
2571
2572 /* XXX: we might want to use a separate frontend at some point */
2573 if (!global.stats_fe) {
2574 if ((global.stats_fe = alloc_stats_fe("GLOBAL", "master-socket", 0)) == NULL) {
2575 ha_alert("out of memory trying to allocate the stats frontend");
William Lallemand744a0892018-11-22 16:46:51 +01002576 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002577 }
2578 }
2579
2580 bind_conf = bind_conf_alloc(global.stats_fe, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002581 if (!bind_conf)
2582 goto error;
2583
William Lallemandce83b4a2018-10-26 14:47:30 +02002584 bind_conf->level &= ~ACCESS_LVL_MASK;
2585 bind_conf->level |= ACCESS_LVL_ADMIN; /* TODO: need to lower the rights with a CLI keyword*/
2586
2587 bind_conf->bind_proc = 1UL << proc;
2588 global.stats_fe->bind_proc = 0; /* XXX: we should be careful with that, it can be removed by configuration */
2589
2590 if (!memprintf(&path, "sockpair@%d", mworker_proc->ipc_fd[1])) {
2591 ha_alert("Cannot allocate listener.\n");
William Lallemand744a0892018-11-22 16:46:51 +01002592 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002593 }
2594
2595 if (!str2listener(path, global.stats_fe, bind_conf, "master-socket", 0, &err)) {
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002596 free(path);
William Lallemandce83b4a2018-10-26 14:47:30 +02002597 ha_alert("Cannot create a CLI sockpair listener for process #%d\n", proc);
William Lallemand744a0892018-11-22 16:46:51 +01002598 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002599 }
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002600 free(path);
2601 path = NULL;
William Lallemandce83b4a2018-10-26 14:47:30 +02002602
2603 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemandce83b4a2018-10-26 14:47:30 +02002604 l->accept = session_accept_fd;
2605 l->default_target = global.stats_fe->default_target;
William Lallemanda3372292018-11-16 16:57:22 +01002606 l->options |= (LI_O_UNLIMITED | LI_O_NOSTOP);
William Lallemandce83b4a2018-10-26 14:47:30 +02002607 /* it's a sockpair but we don't want to keep the fd in the master */
2608 l->options &= ~LI_O_INHERITED;
2609 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002610 global.maxsock++; /* for the listening socket */
William Lallemandce83b4a2018-10-26 14:47:30 +02002611 }
2612
2613 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002614
2615error:
2616 close(mworker_proc->ipc_fd[0]);
2617 close(mworker_proc->ipc_fd[1]);
2618 free(err);
2619
2620 return -1;
William Lallemandce83b4a2018-10-26 14:47:30 +02002621}
2622
William Lallemand74c24fb2016-11-21 17:18:36 +01002623static struct applet cli_applet = {
2624 .obj_type = OBJ_TYPE_APPLET,
2625 .name = "<CLI>", /* used for logging */
2626 .fct = cli_io_handler,
2627 .release = cli_release_handler,
2628};
2629
Willy Tarreau0a739292016-11-22 20:21:23 +01002630/* register cli keywords */
2631static struct cli_kw_list cli_kws = {{ },{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002632 { { "help", NULL }, NULL, cli_parse_simple, NULL },
2633 { { "prompt", NULL }, NULL, cli_parse_simple, NULL },
2634 { { "quit", NULL }, NULL, cli_parse_simple, NULL },
Willy Tarreau2af99412016-11-23 11:10:59 +01002635 { { "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 +01002636 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002637 { { "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 +01002638 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002639 { { "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 +02002640 { { "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 +01002641 { { "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 +02002642 { { "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 +01002643 { { "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 +01002644 { { "operator", NULL }, "operator : lower the level of the current CLI session to operator", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
2645 { { "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 +02002646 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002647 {{},}
2648}};
2649
Willy Tarreau0108d902018-11-25 19:14:37 +01002650INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
2651
William Lallemand74c24fb2016-11-21 17:18:36 +01002652static struct cfg_kw_list cfg_kws = {ILH, {
2653 { CFG_GLOBAL, "stats", stats_parse_global },
2654 { 0, NULL, NULL },
2655}};
2656
Willy Tarreau0108d902018-11-25 19:14:37 +01002657INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
2658
William Lallemand74c24fb2016-11-21 17:18:36 +01002659static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02002660 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
2661 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002662 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01002663 { NULL, NULL, 0 },
2664}};
2665
Willy Tarreau0108d902018-11-25 19:14:37 +01002666INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01002667
2668/*
2669 * Local variables:
2670 * c-indent-level: 8
2671 * c-basic-offset: 8
2672 * End:
2673 */