blob: 9a9f80f9056e1b145e493155032d4584e85de341 [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>
Willy Tarreauc125cef2019-05-10 09:58:43 +020069#include <proto/ssl_sock.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010070#include <proto/stream_interface.h>
71#include <proto/task.h>
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +020072#include <proto/proto_udp.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010073
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020074#define PAYLOAD_PATTERN "<<"
75
William Lallemand74c24fb2016-11-21 17:18:36 +010076static struct applet cli_applet;
77
78static const char stats_sock_usage_msg[] =
79 "Unknown command. Please enter one of the following commands only :\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010080 " help : this message\n"
81 " prompt : toggle interactive mode with prompt\n"
82 " quit : disconnect\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010083 "";
84
85static const char stats_permission_denied_msg[] =
86 "Permission denied\n"
87 "";
88
89
Christopher Faulet1bc04c72017-10-29 20:14:08 +010090static THREAD_LOCAL char *dynamic_usage_msg = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +010091
92/* List head of cli keywords */
93static struct cli_kw_list cli_keywords = {
94 .list = LIST_HEAD_INIT(cli_keywords.list)
95};
96
97extern const char *stat_status_codes[];
98
William Lallemand8a022572018-10-26 14:47:35 +020099static struct proxy *mworker_proxy; /* CLI proxy of the master */
100
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200101static char *cli_gen_usage_msg(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100102{
103 struct cli_kw_list *kw_list;
104 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +0200105 struct buffer *tmp = get_trash_chunk();
106 struct buffer out;
William Lallemand74c24fb2016-11-21 17:18:36 +0100107
108 free(dynamic_usage_msg);
109 dynamic_usage_msg = NULL;
110
111 if (LIST_ISEMPTY(&cli_keywords.list))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200112 goto end;
William Lallemand74c24fb2016-11-21 17:18:36 +0100113
114 chunk_reset(tmp);
115 chunk_strcat(tmp, stats_sock_usage_msg);
116 list_for_each_entry(kw_list, &cli_keywords.list, list) {
117 kw = &kw_list->kw[0];
William Lallemand0154edc2018-05-15 11:50:04 +0200118 while (kw->str_kw[0]) {
William Lallemand14721be2018-10-26 14:47:37 +0200119
120 /* in a worker or normal process, don't display master only commands */
121 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
122 goto next_kw;
123
124 /* in master don't displays if we don't have the master bits */
125 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
126 goto next_kw;
127
William Lallemand0154edc2018-05-15 11:50:04 +0200128 if (kw->usage)
129 chunk_appendf(tmp, " %s\n", kw->usage);
William Lallemand14721be2018-10-26 14:47:37 +0200130
131next_kw:
132
William Lallemand74c24fb2016-11-21 17:18:36 +0100133 kw++;
134 }
135 }
136 chunk_init(&out, NULL, 0);
137 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200138 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200139
140end:
141 if (dynamic_usage_msg) {
142 appctx->ctx.cli.severity = LOG_INFO;
143 appctx->ctx.cli.msg = dynamic_usage_msg;
144 }
145 else {
146 appctx->ctx.cli.severity = LOG_INFO;
147 appctx->ctx.cli.msg = stats_sock_usage_msg;
148 }
149 appctx->st0 = CLI_ST_PRINT;
150
William Lallemand74c24fb2016-11-21 17:18:36 +0100151 return dynamic_usage_msg;
152}
153
154struct cli_kw* cli_find_kw(char **args)
155{
156 struct cli_kw_list *kw_list;
157 struct cli_kw *kw;/* current cli_kw */
158 char **tmp_args;
159 const char **tmp_str_kw;
160 int found = 0;
161
162 if (LIST_ISEMPTY(&cli_keywords.list))
163 return NULL;
164
165 list_for_each_entry(kw_list, &cli_keywords.list, list) {
166 kw = &kw_list->kw[0];
167 while (*kw->str_kw) {
168 tmp_args = args;
169 tmp_str_kw = kw->str_kw;
170 while (*tmp_str_kw) {
171 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
172 found = 1;
173 } else {
174 found = 0;
175 break;
176 }
177 tmp_args++;
178 tmp_str_kw++;
179 }
180 if (found)
181 return (kw);
182 kw++;
183 }
184 }
185 return NULL;
186}
187
188void cli_register_kw(struct cli_kw_list *kw_list)
189{
190 LIST_ADDQ(&cli_keywords.list, &kw_list->list);
191}
192
193
194/* allocate a new stats frontend named <name>, and return it
195 * (or NULL in case of lack of memory).
196 */
197static struct proxy *alloc_stats_fe(const char *name, const char *file, int line)
198{
199 struct proxy *fe;
200
201 fe = calloc(1, sizeof(*fe));
202 if (!fe)
203 return NULL;
204
205 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100206 fe->next = proxies_list;
207 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100208 fe->last_change = now.tv_sec;
209 fe->id = strdup("GLOBAL");
210 fe->cap = PR_CAP_FE;
211 fe->maxconn = 10; /* default to 10 concurrent connections */
212 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
213 fe->conf.file = strdup(file);
214 fe->conf.line = line;
215 fe->accept = frontend_accept;
216 fe->default_target = &cli_applet.obj_type;
217
218 /* the stats frontend is the only one able to assign ID #0 */
219 fe->conf.id.key = fe->uuid = 0;
220 eb32_insert(&used_proxy_id, &fe->conf.id);
221 return fe;
222}
223
224/* This function parses a "stats" statement in the "global" section. It returns
225 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
226 * error message into the <err> buffer which will be preallocated. The trailing
227 * '\n' must not be written. The function must be called with <args> pointing to
228 * the first word after "stats".
229 */
230static int stats_parse_global(char **args, int section_type, struct proxy *curpx,
231 struct proxy *defpx, const char *file, int line,
232 char **err)
233{
234 struct bind_conf *bind_conf;
235 struct listener *l;
236
237 if (!strcmp(args[1], "socket")) {
238 int cur_arg;
239
240 if (*args[2] == 0) {
241 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
242 return -1;
243 }
244
245 if (!global.stats_fe) {
246 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
247 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
248 return -1;
249 }
250 }
251
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100252 bind_conf = bind_conf_alloc(global.stats_fe, file, line, args[2], xprt_get(XPRT_RAW));
William Lallemand07a62f72017-05-24 00:57:40 +0200253 bind_conf->level &= ~ACCESS_LVL_MASK;
254 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100255
256 if (!str2listener(args[2], global.stats_fe, bind_conf, file, line, err)) {
257 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
258 file, line, args[0], args[1], err && *err ? *err : "error");
259 return -1;
260 }
261
262 cur_arg = 3;
263 while (*args[cur_arg]) {
264 static int bind_dumped;
265 struct bind_kw *kw;
266
267 kw = bind_find_kw(args[cur_arg]);
268 if (kw) {
269 if (!kw->parse) {
270 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
271 args[0], args[1], args[cur_arg]);
272 return -1;
273 }
274
275 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, err) != 0) {
276 if (err && *err)
277 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
278 else
279 memprintf(err, "'%s %s' : error encountered while processing '%s'",
280 args[0], args[1], args[cur_arg]);
281 return -1;
282 }
283
284 cur_arg += 1 + kw->skip;
285 continue;
286 }
287
288 if (!bind_dumped) {
289 bind_dump_kws(err);
290 indent_msg(err, 4);
291 bind_dumped = 1;
292 }
293
294 memprintf(err, "'%s %s' : unknown keyword '%s'.%s%s",
295 args[0], args[1], args[cur_arg],
296 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
297 return -1;
298 }
299
300 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100301 l->accept = session_accept_fd;
William Lallemand74c24fb2016-11-21 17:18:36 +0100302 l->default_target = global.stats_fe->default_target;
303 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
304 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100305 global.maxsock++; /* for the listening socket */
William Lallemand74c24fb2016-11-21 17:18:36 +0100306 }
307 }
308 else if (!strcmp(args[1], "timeout")) {
309 unsigned timeout;
310 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
311
Willy Tarreau9faebe32019-06-07 19:00:37 +0200312 if (res == PARSE_TIME_OVER) {
313 memprintf(err, "timer overflow in argument '%s' to '%s %s' (maximum value is 2147483647 ms or ~24.8 days)",
314 args[2], args[0], args[1]);
315 return -1;
316 }
317 else if (res == PARSE_TIME_UNDER) {
318 memprintf(err, "timer underflow in argument '%s' to '%s %s' (minimum non-null value is 1 ms)",
319 args[2], args[0], args[1]);
320 return -1;
321 }
322 else if (res) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100323 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
324 return -1;
325 }
326
327 if (!timeout) {
328 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
329 return -1;
330 }
331 if (!global.stats_fe) {
332 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
333 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
334 return -1;
335 }
336 }
337 global.stats_fe->timeout.client = MS_TO_TICKS(timeout);
338 }
339 else if (!strcmp(args[1], "maxconn")) {
340 int maxconn = atol(args[2]);
341
342 if (maxconn <= 0) {
343 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
344 return -1;
345 }
346
347 if (!global.stats_fe) {
348 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
349 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
350 return -1;
351 }
352 }
353 global.stats_fe->maxconn = maxconn;
354 }
355 else if (!strcmp(args[1], "bind-process")) { /* enable the socket only on some processes */
356 int cur_arg = 2;
357 unsigned long set = 0;
358
359 if (!global.stats_fe) {
360 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
361 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
362 return -1;
363 }
364 }
365
366 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100367 if (strcmp(args[cur_arg], "all") == 0) {
368 set = 0;
369 break;
370 }
Willy Tarreauff9c9142019-02-07 10:39:36 +0100371 if (parse_process_number(args[cur_arg], &set, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100372 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100373 return -1;
374 }
375 cur_arg++;
376 }
377 global.stats_fe->bind_proc = set;
378 }
379 else {
380 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
381 return -1;
382 }
383 return 0;
384}
385
William Lallemand33d29e22019-04-01 11:30:06 +0200386/*
William Lallemand9a37fd02019-04-12 16:09:24 +0200387 * This function exports the bound addresses of a <frontend> in the environment
388 * variable <varname>. Those addresses are separated by semicolons and prefixed
389 * with their type (abns@, unix@, sockpair@ etc)
390 * Return -1 upon error, 0 otherwise
William Lallemand33d29e22019-04-01 11:30:06 +0200391 */
William Lallemand9a37fd02019-04-12 16:09:24 +0200392int listeners_setenv(struct proxy *frontend, const char *varname)
William Lallemand33d29e22019-04-01 11:30:06 +0200393{
394 struct buffer *trash = get_trash_chunk();
395 struct bind_conf *bind_conf;
396
William Lallemand9a37fd02019-04-12 16:09:24 +0200397 if (frontend) {
398 list_for_each_entry(bind_conf, &frontend->conf.bind, by_fe) {
William Lallemand33d29e22019-04-01 11:30:06 +0200399 struct listener *l;
400
401 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
402 char addr[46];
403 char port[6];
404
William Lallemand620072b2019-04-12 16:09:25 +0200405 /* separate listener by semicolons */
406 if (trash->data)
407 chunk_appendf(trash, ";");
408
William Lallemand33d29e22019-04-01 11:30:06 +0200409 if (l->addr.ss_family == AF_UNIX) {
410 const struct sockaddr_un *un;
411
412 un = (struct sockaddr_un *)&l->addr;
413 if (un->sun_path[0] == '\0') {
414 chunk_appendf(trash, "abns@%s", un->sun_path+1);
415 } else {
416 chunk_appendf(trash, "unix@%s", un->sun_path);
417 }
418 } else if (l->addr.ss_family == AF_INET) {
419 addr_to_str(&l->addr, addr, sizeof(addr));
420 port_to_str(&l->addr, port, sizeof(port));
421 chunk_appendf(trash, "ipv4@%s:%s", addr, port);
422 } else if (l->addr.ss_family == AF_INET6) {
423 addr_to_str(&l->addr, addr, sizeof(addr));
424 port_to_str(&l->addr, port, sizeof(port));
425 chunk_appendf(trash, "ipv6@[%s]:%s", addr, port);
426 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
427 chunk_appendf(trash, "sockpair@%d", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
428 }
William Lallemand33d29e22019-04-01 11:30:06 +0200429 }
430 }
431 trash->area[trash->data++] = '\0';
William Lallemand9a37fd02019-04-12 16:09:24 +0200432 if (setenv(varname, trash->area, 1) < 0)
William Lallemand33d29e22019-04-01 11:30:06 +0200433 return -1;
434 }
435
436 return 0;
437}
438
William Lallemand9a37fd02019-04-12 16:09:24 +0200439int cli_socket_setenv()
440{
441 if (listeners_setenv(global.stats_fe, "HAPROXY_CLI") < 0)
442 return -1;
443 if (listeners_setenv(mworker_proxy, "HAPROXY_MASTER_CLI") < 0)
444 return -1;
445
446 return 0;
447}
448
William Lallemand33d29e22019-04-01 11:30:06 +0200449REGISTER_CONFIG_POSTPARSER("cli", cli_socket_setenv);
450
Willy Tarreaude57a572016-11-23 17:01:39 +0100451/* Verifies that the CLI at least has a level at least as high as <level>
452 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
453 * failure, an error message is prepared and the appctx's state is adjusted
454 * to print it so that a return 1 is enough to abort any processing.
455 */
456int cli_has_level(struct appctx *appctx, int level)
457{
Willy Tarreaude57a572016-11-23 17:01:39 +0100458
William Lallemandf630d012018-12-13 09:05:44 +0100459 if ((appctx->cli_level & ACCESS_LVL_MASK) < level) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200460 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreaude57a572016-11-23 17:01:39 +0100461 appctx->ctx.cli.msg = stats_permission_denied_msg;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100462 appctx->st0 = CLI_ST_PRINT;
Willy Tarreaude57a572016-11-23 17:01:39 +0100463 return 0;
464 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100465 return 1;
466}
467
William Lallemandb7ea1412018-12-13 09:05:47 +0100468/* same as cli_has_level but for the CLI proxy and without error message */
469int pcli_has_level(struct stream *s, int level)
470{
471 if ((s->pcli_flags & ACCESS_LVL_MASK) < level) {
472 return 0;
473 }
474 return 1;
475}
476
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200477/* Returns severity_output for the current session if set, or default for the socket */
478static int cli_get_severity_output(struct appctx *appctx)
479{
480 if (appctx->cli_severity_output)
481 return appctx->cli_severity_output;
482 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
483}
William Lallemand74c24fb2016-11-21 17:18:36 +0100484
Willy Tarreau41908562016-11-24 16:23:38 +0100485/* Processes the CLI interpreter on the stats socket. This function is called
486 * from the CLI's IO handler running in an appctx context. The function returns 1
487 * if the request was understood, otherwise zero. It is called with appctx->st0
488 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
489 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
490 * have its own I/O handler called again. Most of the time, parsers will only
491 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100492 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
493 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100494 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200495static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100496{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200497 char *args[MAX_STATS_ARGS + 1], *p, *end, *payload = NULL;
498 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100499 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100500
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200501 appctx->st2 = 0;
502 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
William Lallemand74c24fb2016-11-21 17:18:36 +0100503
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200504 p = appctx->chunk->area;
505 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100506
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200507 /*
508 * Get the payload start if there is one.
509 * For the sake of simplicity, the payload pattern is looked up
510 * everywhere from the start of the input but it can only be found
511 * at the end of the first line if APPCTX_CLI_ST1_PAYLOAD is set.
512 *
513 * The input string was zero terminated so it is safe to use
514 * the str*() functions throughout the parsing
515 */
516 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
517 payload = strstr(p, PAYLOAD_PATTERN);
518 end = payload;
519 /* skip the pattern */
520 payload += strlen(PAYLOAD_PATTERN);
521 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100522
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200523 /*
524 * Get pointers on words.
525 * One extra slot is reserved to store a pointer on a null byte.
526 */
527 while (i < MAX_STATS_ARGS && p < end) {
528 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100529
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200530 /* skip leading spaces/tabs */
531 p += strspn(p, " \t");
532 if (!*p)
533 break;
William Lallemand74c24fb2016-11-21 17:18:36 +0100534
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200535 args[i] = p;
536 p += strcspn(p, " \t");
537 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100538
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200539 /* unescape backslashes (\) */
540 for (j = 0, k = 0; args[i][k]; k++) {
541 if (args[i][k] == '\\') {
542 if (args[i][k + 1] == '\\')
543 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100544 else
545 continue;
546 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200547 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100548 j++;
549 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200550 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100551
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200552 i++;
553 }
554 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200555 p = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200556 for (; i < MAX_STATS_ARGS + 1; i++)
557 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100558
559 kw = cli_find_kw(args);
Willy Tarreaueaffde32016-12-16 17:59:25 +0100560 if (!kw)
Willy Tarreau41908562016-11-24 16:23:38 +0100561 return 0;
562
William Lallemand14721be2018-10-26 14:47:37 +0200563 /* in a worker or normal process, don't display master only commands */
564 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
565 return 0;
566
567 /* in master don't displays if we don't have the master bits */
568 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
569 return 0;
570
Willy Tarreau41908562016-11-24 16:23:38 +0100571 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200572 appctx->io_release = kw->io_release;
573 /* kw->parse could set its own io_handler or ip_release handler */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200574 if ((!kw->parse || kw->parse(args, payload, appctx, kw->private) == 0) && appctx->io_handler) {
Willy Tarreau41908562016-11-24 16:23:38 +0100575 appctx->st0 = CLI_ST_CALLBACK;
William Lallemand74c24fb2016-11-21 17:18:36 +0100576 }
Willy Tarreau41908562016-11-24 16:23:38 +0100577 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100578}
579
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200580/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
581static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
582{
Willy Tarreau83061a82018-07-13 11:56:34 +0200583 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200584
585 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200586 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200587
588 tmp = get_trash_chunk();
589 chunk_reset(tmp);
590
591 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100592 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200593 chunk_printf(tmp, "[%d]: ", severity);
594 }
595 else {
596 switch (severity_output) {
597 case CLI_SEVERITY_NUMBER:
598 chunk_printf(tmp, "[%d]: ", severity);
599 break;
600 case CLI_SEVERITY_STRING:
601 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
602 break;
603 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100604 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200605 }
606 }
607 chunk_appendf(tmp, "%s", msg);
608
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200609 return ci_putblk(chn, tmp->area, strlen(tmp->area));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200610}
611
William Lallemand74c24fb2016-11-21 17:18:36 +0100612/* This I/O handler runs as an applet embedded in a stream interface. It is
613 * used to processes I/O from/to the stats unix socket. The system relies on a
614 * state machine handling requests and various responses. We read a request,
615 * then we process it and send the response, and we possibly display a prompt.
616 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100617 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100618 * or not.
619 */
620static void cli_io_handler(struct appctx *appctx)
621{
622 struct stream_interface *si = appctx->owner;
623 struct channel *req = si_oc(si);
624 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200625 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100626 int reql;
627 int len;
628
629 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
630 goto out;
631
Joseph Herlant008b3ce2018-11-25 12:51:45 -0800632 /* Check if the input buffer is available. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200633 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +0100634 /* buf.size==0 means we failed to get a buffer and were
635 * already subscribed to a wait list to get a buffer.
636 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100637 goto out;
638 }
639
William Lallemand74c24fb2016-11-21 17:18:36 +0100640 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100641 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100642 /* Stats output not initialized yet */
643 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200644 /* reset severity to default at init */
645 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100646 appctx->st0 = CLI_ST_GETREQ;
William Lallemandf630d012018-12-13 09:05:44 +0100647 appctx->cli_level = bind_conf->level;
William Lallemand74c24fb2016-11-21 17:18:36 +0100648 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100649 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100650 /* Let's close for real now. We just close the request
651 * side, the conditions below will complete if needed.
652 */
653 si_shutw(si);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200654 free_trash_chunk(appctx->chunk);
William Lallemand74c24fb2016-11-21 17:18:36 +0100655 break;
656 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100657 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200658 char *str;
659
660 /* use a trash chunk to store received data */
661 if (!appctx->chunk) {
662 appctx->chunk = alloc_trash_chunk();
663 if (!appctx->chunk) {
664 appctx->st0 = CLI_ST_END;
665 continue;
666 }
667 }
668
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200669 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200670
William Lallemand74c24fb2016-11-21 17:18:36 +0100671 /* ensure we have some output room left in the event we
672 * would want to return some info right after parsing.
673 */
674 if (buffer_almost_full(si_ib(si))) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100675 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100676 break;
677 }
678
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200679 /* '- 1' is to ensure a null byte can always be inserted at the end */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200680 reql = co_getline(si_oc(si), str,
681 appctx->chunk->size - appctx->chunk->data - 1);
William Lallemand74c24fb2016-11-21 17:18:36 +0100682 if (reql <= 0) { /* closed or EOL not found */
683 if (reql == 0)
684 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100685 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100686 continue;
687 }
688
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200689 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
690 /* seek for a possible unescaped semi-colon. If we find
691 * one, we replace it with an LF and skip only this part.
692 */
693 for (len = 0; len < reql; len++) {
694 if (str[len] == '\\') {
695 len++;
696 continue;
697 }
698 if (str[len] == ';') {
699 str[len] = '\n';
700 reql = len + 1;
701 break;
702 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100703 }
704 }
705
706 /* now it is time to check that we have a full line,
707 * remove the trailing \n and possibly \r, then cut the
708 * line.
709 */
710 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200711 if (str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100712 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100713 continue;
714 }
715
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200716 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100717 len--;
718
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200719 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200720 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200721
722 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200723 appctx->chunk->area[appctx->chunk->data] = '\n';
724 appctx->chunk->area[appctx->chunk->data + 1] = 0;
725 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200726 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100727
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100728 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200729
730 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
731 /* empty line */
732 if (!len) {
733 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200734 appctx->chunk->data -= 2;
735 appctx->chunk->area[appctx->chunk->data] = 0;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200736
737 if (!cli_parse_request(appctx))
738 cli_gen_usage_msg(appctx);
739
740 chunk_reset(appctx->chunk);
741 /* NB: cli_sock_parse_request() may have put
742 * another CLI_ST_O_* into appctx->st0.
743 */
744
745 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +0100746 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100747 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200748 else {
749 /*
750 * Look for the "payload start" pattern at the end of a line
751 * Its location is not remembered here, this is just to switch
752 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +0100753 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200754 if (!strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200755 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200756 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200757 /* no payload, the command is complete: parse the request */
758 if (!cli_parse_request(appctx))
759 cli_gen_usage_msg(appctx);
760
761 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200762 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100763 }
764
765 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200766 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100767 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
768 }
769 else { /* output functions */
770 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100771 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100772 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100773 case CLI_ST_PRINT:
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200774 if (cli_output_msg(res, appctx->ctx.cli.msg, appctx->ctx.cli.severity,
775 cli_get_severity_output(appctx)) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100776 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100777 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100778 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100779 break;
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200780 case CLI_ST_PRINT_FREE: {
781 const char *msg = appctx->ctx.cli.err;
782
783 if (!msg)
784 msg = "Out of memory.\n";
785
786 if (cli_output_msg(res, msg, LOG_ERR, cli_get_severity_output(appctx)) != -1) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100787 free(appctx->ctx.cli.err);
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100788 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100789 }
790 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100791 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100792 break;
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200793 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100794 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100795 if (appctx->io_handler)
796 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100797 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100798 if (appctx->io_release) {
799 appctx->io_release(appctx);
800 appctx->io_release = NULL;
801 }
802 }
803 break;
804 default: /* abnormal state */
805 si->flags |= SI_FL_ERR;
806 break;
807 }
808
809 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100810 if (appctx->st0 == CLI_ST_PROMPT) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200811 const char *prompt = "";
812
813 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
814 /*
815 * when entering a payload with interactive mode, change the prompt
816 * to emphasize that more data can still be sent
817 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200818 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200819 prompt = "+ ";
820 else
821 prompt = "\n> ";
822 }
823 else {
William Lallemandad032882019-07-01 10:56:15 +0200824 if (!(appctx->st1 & (APPCTX_CLI_ST1_PAYLOAD|APPCTX_CLI_ST1_NOLF)))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200825 prompt = "\n";
826 }
827
828 if (ci_putstr(si_ic(si), prompt) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100829 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100830 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100831 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100832 }
833
834 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100835 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100836 break;
837
838 /* Now we close the output if one of the writers did so,
839 * or if we're not in interactive mode and the request
840 * buffer is empty. This still allows pipelined requests
841 * to be sent in non-interactive mode.
842 */
William Lallemand3de09d52018-12-11 16:10:56 +0100843 if (((res->flags & (CF_SHUTW|CF_SHUTW_NOW))) ||
844 (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req) && (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)))) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100845 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100846 continue;
847 }
848
849 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100850 appctx->st0 = CLI_ST_GETREQ;
William Lallemandad032882019-07-01 10:56:15 +0200851 /* reactivate the \n at the end of the response for the next command */
852 appctx->st1 &= ~APPCTX_CLI_ST1_NOLF;
William Lallemand74c24fb2016-11-21 17:18:36 +0100853 }
854 }
855
856 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
857 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
858 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
859 /* Other side has closed, let's abort if we have no more processing to do
860 * and nothing more to consume. This is comparable to a broken pipe, so
861 * we forward the close to the request side so that it flows upstream to
862 * the client.
863 */
864 si_shutw(si);
865 }
866
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100867 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100868 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
869 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
870 /* We have no more processing to do, and nothing more to send, and
871 * the client side has closed. So we'll forward this state downstream
872 * on the response buffer.
873 */
874 si_shutr(si);
875 res->flags |= CF_READ_NULL;
876 }
877
878 out:
Christopher Faulet45073512018-07-20 10:16:29 +0200879 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 +0100880 __FUNCTION__, __LINE__,
Christopher Faulet45073512018-07-20 10:16:29 +0200881 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 +0100882}
883
William Lallemand74c24fb2016-11-21 17:18:36 +0100884/* This is called when the stream interface is closed. For instance, upon an
885 * external abort, we won't call the i/o handler anymore so we may need to
886 * remove back references to the stream currently being dumped.
887 */
888static void cli_release_handler(struct appctx *appctx)
889{
890 if (appctx->io_release) {
891 appctx->io_release(appctx);
892 appctx->io_release = NULL;
893 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100894 else if (appctx->st0 == CLI_ST_PRINT_FREE) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100895 free(appctx->ctx.cli.err);
896 appctx->ctx.cli.err = NULL;
897 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100898}
899
900/* This function dumps all environmnent variables to the buffer. It returns 0
901 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +0100902 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
903 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +0100904 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100905static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100906{
Willy Tarreau0a739292016-11-22 20:21:23 +0100907 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100908 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100909
910 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
911 return 1;
912
913 chunk_reset(&trash);
914
915 /* we have two inner loops here, one for the proxy, the other one for
916 * the buffer.
917 */
Willy Tarreauf6710f82016-12-16 17:45:44 +0100918 while (*var) {
919 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +0100920
Willy Tarreau06d80a92017-10-19 14:32:15 +0200921 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100922 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100923 return 0;
924 }
925 if (appctx->st2 == STAT_ST_END)
926 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100927 var++;
928 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +0100929 }
930
931 /* dump complete */
932 return 1;
933}
934
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200935/* This function dumps all file descriptors states (or the requested one) to
936 * the buffer. It returns 0 if the output buffer is full and it needs to be
937 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
938 * It uses cli.i0 as the fd number to restart from.
939 */
940static int cli_io_handler_show_fd(struct appctx *appctx)
941{
942 struct stream_interface *si = appctx->owner;
943 int fd = appctx->ctx.cli.i0;
Willy Tarreauca1b1572018-12-18 15:45:11 +0100944 int ret = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200945
946 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
Willy Tarreauca1b1572018-12-18 15:45:11 +0100947 goto end;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200948
949 chunk_reset(&trash);
950
Willy Tarreauca1b1572018-12-18 15:45:11 +0100951 /* isolate the threads once per round. We're limited to a buffer worth
952 * of output anyway, it cannot last very long.
953 */
954 thread_isolate();
955
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200956 /* we have two inner loops here, one for the proxy, the other one for
957 * the buffer.
958 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +0100959 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200960 struct fdtab fdt;
Willy Tarreau286ec682017-08-09 16:35:44 +0200961 struct listener *li = NULL;
962 struct server *sv = NULL;
963 struct proxy *px = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +0200964 const struct mux_ops *mux = NULL;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200965 void *ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +0200966 uint32_t conn_flags = 0;
Willy Tarreaue9ca8072018-12-19 18:40:58 +0100967 int is_back = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200968
969 fdt = fdtab[fd];
970
Willy Tarreauca1b1572018-12-18 15:45:11 +0100971 if (!fdt.owner)
Willy Tarreau017af242017-10-04 20:24:54 +0200972 goto skip; // closed
973
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200974 if (fdt.iocb == conn_fd_handler) {
975 conn_flags = ((struct connection *)fdt.owner)->flags;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200976 mux = ((struct connection *)fdt.owner)->mux;
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100977 ctx = ((struct connection *)fdt.owner)->ctx;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200978 li = objt_listener(((struct connection *)fdt.owner)->target);
979 sv = objt_server(((struct connection *)fdt.owner)->target);
980 px = objt_proxy(((struct connection *)fdt.owner)->target);
Willy Tarreaue9ca8072018-12-19 18:40:58 +0100981 is_back = conn_is_back((struct connection *)fdt.owner);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200982 }
983 else if (fdt.iocb == listener_accept)
984 li = fdt.owner;
985
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200986 chunk_printf(&trash,
Willy Tarreauc754b342018-03-30 15:00:15 +0200987 " %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 +0200988 fd,
989 fdt.state,
990 (fdt.state & FD_EV_POLLED_R) ? 'P' : 'p',
991 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
992 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
993 (fdt.state & FD_EV_POLLED_W) ? 'P' : 'p',
994 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
995 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
996 fdt.ev,
997 (fdt.ev & FD_POLL_HUP) ? 'H' : 'h',
998 (fdt.ev & FD_POLL_ERR) ? 'E' : 'e',
999 (fdt.ev & FD_POLL_OUT) ? 'O' : 'o',
1000 (fdt.ev & FD_POLL_PRI) ? 'P' : 'p',
1001 (fdt.ev & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001002 fdt.linger_risk ? 'L' : 'l',
1003 fdt.cloned ? 'C' : 'c',
Willy Tarreauc754b342018-03-30 15:00:15 +02001004 fdt.cache.next,
1005 fdt.cache.prev,
1006 fdt.thread_mask, fdt.update_mask,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001007 fdt.owner,
1008 fdt.iocb,
1009 (fdt.iocb == conn_fd_handler) ? "conn_fd_handler" :
1010 (fdt.iocb == dgram_fd_handler) ? "dgram_fd_handler" :
1011 (fdt.iocb == listener_accept) ? "listener_accept" :
Olivier Houchard79321b92018-07-26 17:55:11 +02001012 (fdt.iocb == poller_pipe_io_handler) ? "poller_pipe_io_handler" :
William Lallemanddb6bdfb2018-11-20 17:36:51 +01001013 (fdt.iocb == mworker_accept_wrapper) ? "mworker_accept_wrapper" :
Emeric Brund0e095c2019-04-19 17:15:28 +02001014#ifdef USE_OPENSSL
Willy Tarreau5db847a2019-05-09 14:13:35 +02001015#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brund0e095c2019-04-19 17:15:28 +02001016 (fdt.iocb == ssl_async_fd_free) ? "ssl_async_fd_free" :
1017 (fdt.iocb == ssl_async_fd_handler) ? "ssl_async_fd_handler" :
1018#endif
1019#endif
Willy Tarreauc754b342018-03-30 15:00:15 +02001020 "unknown");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001021
1022 if (fdt.iocb == conn_fd_handler) {
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001023 chunk_appendf(&trash, " back=%d cflg=0x%08x", is_back, conn_flags);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001024 if (px)
1025 chunk_appendf(&trash, " px=%s", px->id);
1026 else if (sv)
1027 chunk_appendf(&trash, " sv=%s/%s", sv->id, sv->proxy->id);
1028 else if (li)
1029 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +02001030
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001031 if (mux) {
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001032 chunk_appendf(&trash, " mux=%s ctx=%p", mux->name, ctx);
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001033 if (mux->show_fd)
1034 mux->show_fd(&trash, fdt.owner);
1035 }
Willy Tarreau35b1b482018-03-28 18:41:30 +02001036 else
1037 chunk_appendf(&trash, " nomux");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001038 }
1039 else if (fdt.iocb == listener_accept) {
1040 chunk_appendf(&trash, " l.st=%s fe=%s",
1041 listener_state_str(li),
1042 li->bind_conf->frontend->id);
1043 }
1044
1045 chunk_appendf(&trash, "\n");
1046
Willy Tarreau06d80a92017-10-19 14:32:15 +02001047 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001048 si_rx_room_blk(si);
Willy Tarreauca1b1572018-12-18 15:45:11 +01001049 appctx->ctx.cli.i0 = fd;
1050 ret = 0;
1051 break;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001052 }
1053 skip:
1054 if (appctx->st2 == STAT_ST_END)
1055 break;
1056
1057 fd++;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001058 }
1059
Willy Tarreauca1b1572018-12-18 15:45:11 +01001060 end:
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001061 /* dump complete */
Willy Tarreauca1b1572018-12-18 15:45:11 +01001062
1063 thread_release();
1064 return ret;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001065}
1066
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001067/* This function dumps some activity counters used by developers and support to
1068 * rule out some hypothesis during bug reports. It returns 0 if the output
1069 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
1070 * everything at once in the buffer and is not designed to do it in multiple
1071 * passes.
1072 */
1073static int cli_io_handler_show_activity(struct appctx *appctx)
1074{
1075 struct stream_interface *si = appctx->owner;
1076 int thr;
1077
1078 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1079 return 1;
1080
1081 chunk_reset(&trash);
1082
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001083#undef SHOW_TOT
1084#define SHOW_TOT(t, x) \
Willy Tarreaua0211b82019-05-28 15:09:08 +02001085 do { \
1086 unsigned int _v[MAX_THREADS]; \
1087 unsigned int _tot; \
1088 const unsigned int _nbt = global.nbthread; \
1089 for (_tot = t = 0; t < _nbt; t++) \
1090 _tot += _v[t] = (x); \
1091 if (_nbt == 1) { \
1092 chunk_appendf(&trash, " %u\n", _tot); \
1093 break; \
1094 } \
1095 chunk_appendf(&trash, " %u [", _tot); \
1096 for (t = 0; t < _nbt; t++) \
1097 chunk_appendf(&trash, " %u", _v[t]); \
1098 chunk_appendf(&trash, " ]\n"); \
1099 } while (0)
1100
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001101#undef SHOW_AVG
1102#define SHOW_AVG(t, x) \
1103 do { \
1104 unsigned int _v[MAX_THREADS]; \
1105 unsigned int _tot; \
1106 const unsigned int _nbt = global.nbthread; \
1107 for (_tot = t = 0; t < _nbt; t++) \
1108 _tot += _v[t] = (x); \
1109 if (_nbt == 1) { \
1110 chunk_appendf(&trash, " %u\n", _tot); \
1111 break; \
1112 } \
1113 chunk_appendf(&trash, " %u [", (_tot + _nbt/2) / _nbt); \
1114 for (t = 0; t < _nbt; t++) \
1115 chunk_appendf(&trash, " %u", _v[t]); \
1116 chunk_appendf(&trash, " ]\n"); \
1117 } while (0)
1118
Willy Tarreaua0211b82019-05-28 15:09:08 +02001119 chunk_appendf(&trash, "thread_id: %u (%u..%u)\n", tid + 1, 1, global.nbthread);
1120 chunk_appendf(&trash, "date_now: %lu.%06lu\n", (long)now.tv_sec, (long)now.tv_usec);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001121 chunk_appendf(&trash, "loops:"); SHOW_TOT(thr, activity[thr].loops);
1122 chunk_appendf(&trash, "wake_cache:"); SHOW_TOT(thr, activity[thr].wake_cache);
1123 chunk_appendf(&trash, "wake_tasks:"); SHOW_TOT(thr, activity[thr].wake_tasks);
1124 chunk_appendf(&trash, "wake_signal:"); SHOW_TOT(thr, activity[thr].wake_signal);
1125 chunk_appendf(&trash, "poll_exp:"); SHOW_TOT(thr, activity[thr].poll_exp);
1126 chunk_appendf(&trash, "poll_drop:"); SHOW_TOT(thr, activity[thr].poll_drop);
1127 chunk_appendf(&trash, "poll_dead:"); SHOW_TOT(thr, activity[thr].poll_dead);
1128 chunk_appendf(&trash, "poll_skip:"); SHOW_TOT(thr, activity[thr].poll_skip);
1129 chunk_appendf(&trash, "fd_lock:"); SHOW_TOT(thr, activity[thr].fd_lock);
1130 chunk_appendf(&trash, "conn_dead:"); SHOW_TOT(thr, activity[thr].conn_dead);
1131 chunk_appendf(&trash, "stream:"); SHOW_TOT(thr, activity[thr].stream);
Willy Tarreaua8b2ce02019-05-28 17:04:16 +02001132 chunk_appendf(&trash, "pool_fail:"); SHOW_TOT(thr, activity[thr].pool_fail);
1133 chunk_appendf(&trash, "buf_wait:"); SHOW_TOT(thr, activity[thr].buf_wait);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001134 chunk_appendf(&trash, "empty_rq:"); SHOW_TOT(thr, activity[thr].empty_rq);
1135 chunk_appendf(&trash, "long_rq:"); SHOW_TOT(thr, activity[thr].long_rq);
1136 chunk_appendf(&trash, "ctxsw:"); SHOW_TOT(thr, activity[thr].ctxsw);
1137 chunk_appendf(&trash, "tasksw:"); SHOW_TOT(thr, activity[thr].tasksw);
1138 chunk_appendf(&trash, "cpust_ms_tot:"); SHOW_TOT(thr, activity[thr].cpust_total / 2);
1139 chunk_appendf(&trash, "cpust_ms_1s:"); SHOW_TOT(thr, read_freq_ctr(&activity[thr].cpust_1s) / 2);
1140 chunk_appendf(&trash, "cpust_ms_15s:"); SHOW_TOT(thr, read_freq_ctr_period(&activity[thr].cpust_15s, 15000) / 2);
1141 chunk_appendf(&trash, "avg_loop_us:"); SHOW_AVG(thr, swrate_avg(activity[thr].avg_loop_us, TIME_STATS_SAMPLES));
1142 chunk_appendf(&trash, "accepted:"); SHOW_TOT(thr, activity[thr].accepted);
1143 chunk_appendf(&trash, "accq_pushed:"); SHOW_TOT(thr, activity[thr].accq_pushed);
1144 chunk_appendf(&trash, "accq_full:"); SHOW_TOT(thr, activity[thr].accq_full);
Willy Tarreaue6182842019-04-15 18:54:10 +02001145#ifdef USE_THREAD
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001146 chunk_appendf(&trash, "accq_ring:"); SHOW_TOT(thr, (accept_queue_rings[thr].tail - accept_queue_rings[thr].head + ACCEPT_QUEUE_SIZE) % ACCEPT_QUEUE_SIZE);
Willy Tarreaue6182842019-04-15 18:54:10 +02001147#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001148
Willy Tarreaud6a78502019-05-27 07:03:38 +02001149#if defined(DEBUG_DEV)
1150 /* keep these ones at the end */
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001151 chunk_appendf(&trash, "ctr0:"); SHOW_TOT(thr, activity[thr].ctr0);
1152 chunk_appendf(&trash, "ctr1:"); SHOW_TOT(thr, activity[thr].ctr1);
1153 chunk_appendf(&trash, "ctr2:"); SHOW_TOT(thr, activity[thr].ctr2);
Willy Tarreaud6a78502019-05-27 07:03:38 +02001154#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001155
1156 if (ci_putchk(si_ic(si), &trash) == -1) {
1157 chunk_reset(&trash);
1158 chunk_printf(&trash, "[output too large, cannot dump]\n");
Willy Tarreaudb398432018-11-15 11:08:52 +01001159 si_rx_room_blk(si);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001160 }
1161
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001162#undef SHOW_AVG
1163#undef SHOW_TOT
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001164 /* dump complete */
1165 return 1;
1166}
1167
William Lallemandeceddf72016-12-15 18:06:44 +01001168/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001169 * CLI IO handler for `show cli sockets`.
1170 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +01001171 */
1172static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1173{
1174 struct bind_conf *bind_conf;
1175 struct stream_interface *si = appctx->owner;
1176
1177 chunk_reset(&trash);
1178
1179 switch (appctx->st2) {
1180 case STAT_ST_INIT:
1181 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +02001182 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001183 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001184 return 0;
1185 }
William Lallemandeceddf72016-12-15 18:06:44 +01001186 appctx->st2 = STAT_ST_LIST;
1187
1188 case STAT_ST_LIST:
1189 if (global.stats_fe) {
1190 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
1191 struct listener *l;
1192
1193 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001194 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +01001195 * if the current node is the first of the list
1196 */
1197
Willy Tarreau3af9d832016-12-16 12:58:09 +01001198 if (appctx->ctx.cli.p0 &&
1199 &bind_conf->by_fe == (&global.stats_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +01001200 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +01001201 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +01001202 continue;
1203 }
1204
1205 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
1206
1207 char addr[46];
1208 char port[6];
1209
1210 if (l->addr.ss_family == AF_UNIX) {
1211 const struct sockaddr_un *un;
1212
1213 un = (struct sockaddr_un *)&l->addr;
William Lallemande58915f2019-04-01 11:30:05 +02001214 if (un->sun_path[0] == '\0') {
William Lallemand75812a72019-04-01 11:30:04 +02001215 chunk_appendf(&trash, "abns@%s ", un->sun_path+1);
William Lallemande58915f2019-04-01 11:30:05 +02001216 } else {
1217 chunk_appendf(&trash, "unix@%s ", un->sun_path);
1218 }
William Lallemandeceddf72016-12-15 18:06:44 +01001219 } else if (l->addr.ss_family == AF_INET) {
1220 addr_to_str(&l->addr, addr, sizeof(addr));
1221 port_to_str(&l->addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001222 chunk_appendf(&trash, "ipv4@%s:%s ", addr, port);
William Lallemandeceddf72016-12-15 18:06:44 +01001223 } else if (l->addr.ss_family == AF_INET6) {
1224 addr_to_str(&l->addr, addr, sizeof(addr));
1225 port_to_str(&l->addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001226 chunk_appendf(&trash, "ipv6@[%s]:%s ", addr, port);
William Lallemand26314342018-10-26 14:47:41 +02001227 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
1228 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
William Lallemandeceddf72016-12-15 18:06:44 +01001229 } else
William Lallemand26314342018-10-26 14:47:41 +02001230 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001231
William Lallemand07a62f72017-05-24 00:57:40 +02001232 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +01001233 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +02001234 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1235 chunk_appendf(&trash, "operator ");
1236 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1237 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +01001238 else
1239 chunk_appendf(&trash, " ");
1240
1241 if (bind_conf->bind_proc != 0) {
1242 int pos;
Willy Tarreau20c5e522016-12-16 12:50:55 +01001243 for (pos = 0; pos < 8 * sizeof(bind_conf->bind_proc); pos++) {
Willy Tarreau4305ac72016-12-16 12:56:31 +01001244 if (bind_conf->bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +01001245 chunk_appendf(&trash, "%d,", pos+1);
1246 }
1247 }
1248 /* replace the latest comma by a newline */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001249 trash.area[trash.data-1] = '\n';
William Lallemandeceddf72016-12-15 18:06:44 +01001250
1251 } else {
1252 chunk_appendf(&trash, "all\n");
1253 }
1254
Willy Tarreau06d80a92017-10-19 14:32:15 +02001255 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001256 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001257 return 0;
1258 }
1259 }
Willy Tarreau3af9d832016-12-16 12:58:09 +01001260 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001261 }
1262 }
1263 default:
1264 appctx->st2 = STAT_ST_FIN;
1265 return 1;
1266 }
1267}
1268
1269
Willy Tarreau0a739292016-11-22 20:21:23 +01001270/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001271 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1272 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001273 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001274static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001275{
1276 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001277 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001278
1279 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1280 return 1;
1281
Willy Tarreauf6710f82016-12-16 17:45:44 +01001282 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001283
1284 if (*args[2]) {
1285 int len = strlen(args[2]);
1286
Willy Tarreauf6710f82016-12-16 17:45:44 +01001287 for (; *var; var++) {
1288 if (strncmp(*var, args[2], len) == 0 &&
1289 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001290 break;
1291 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001292 if (!*var) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001293 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau0a739292016-11-22 20:21:23 +01001294 appctx->ctx.cli.msg = "Variable not found\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001295 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau0a739292016-11-22 20:21:23 +01001296 return 1;
1297 }
1298 appctx->st2 = STAT_ST_END;
1299 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001300 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001301 return 0;
1302}
1303
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001304/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1305 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1306 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1307 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001308static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001309{
1310 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1311 return 1;
1312
1313 appctx->ctx.cli.i0 = 0;
1314
1315 if (*args[2]) {
1316 appctx->ctx.cli.i0 = atoi(args[2]);
1317 appctx->st2 = STAT_ST_END;
1318 }
1319 return 0;
1320}
1321
Willy Tarreau599852e2016-11-22 20:33:32 +01001322/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001323static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001324{
1325 struct stream_interface *si = appctx->owner;
1326 struct stream *s = si_strm(si);
1327
1328 if (strcmp(args[2], "cli") == 0) {
1329 unsigned timeout;
1330 const char *res;
1331
1332 if (!*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001333 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001334 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001335 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001336 return 1;
1337 }
1338
1339 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
1340 if (res || timeout < 1) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001341 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001342 appctx->ctx.cli.msg = "Invalid timeout value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001343 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001344 return 1;
1345 }
1346
1347 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1348 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1349 return 1;
1350 }
1351 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001352 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001353 appctx->ctx.cli.msg = "'set timeout' only supports 'cli'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001354 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001355 return 1;
1356 }
1357}
1358
Willy Tarreau2af99412016-11-23 11:10:59 +01001359/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001360static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001361{
1362 int v;
1363
1364 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1365 return 1;
1366
1367 if (!*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001368 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau2af99412016-11-23 11:10:59 +01001369 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001370 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +01001371 return 1;
1372 }
1373
1374 v = atoi(args[3]);
1375 if (v > global.hardmaxconn) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001376 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau2af99412016-11-23 11:10:59 +01001377 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001378 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +01001379 return 1;
1380 }
1381
1382 /* check for unlimited values */
1383 if (v <= 0)
1384 v = global.hardmaxconn;
1385
1386 global.maxconn = v;
1387
1388 /* Dequeues all of the listeners waiting for a resource */
1389 if (!LIST_ISEMPTY(&global_listener_queue))
1390 dequeue_all_listeners(&global_listener_queue);
1391
1392 return 1;
1393}
1394
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001395static int set_severity_output(int *target, char *argument)
1396{
1397 if (!strcmp(argument, "none")) {
1398 *target = CLI_SEVERITY_NONE;
1399 return 1;
1400 }
1401 else if (!strcmp(argument, "number")) {
1402 *target = CLI_SEVERITY_NUMBER;
1403 return 1;
1404 }
1405 else if (!strcmp(argument, "string")) {
1406 *target = CLI_SEVERITY_STRING;
1407 return 1;
1408 }
1409 return 0;
1410}
1411
1412/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001413static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001414{
1415 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1416 return 0;
1417
1418 appctx->ctx.cli.severity = LOG_ERR;
Aurélien Nephtali6e8a41d2018-03-15 21:48:50 +01001419 appctx->ctx.cli.msg = "one of 'none', 'number', 'string' is a required argument\n";
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001420 appctx->st0 = CLI_ST_PRINT;
1421 return 1;
1422}
William Lallemandeceddf72016-12-15 18:06:44 +01001423
William Lallemand67a234f2018-12-13 09:05:45 +01001424
1425/* show the level of the current CLI session */
1426static int cli_parse_show_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1427{
1428
1429 appctx->ctx.cli.severity = LOG_INFO;
1430 if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
1431 appctx->ctx.cli.msg = "admin\n";
1432 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1433 appctx->ctx.cli.msg = "operator\n";
1434 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1435 appctx->ctx.cli.msg = "user\n";
1436 else
1437 appctx->ctx.cli.msg = "unknown\n";
1438
1439 appctx->st0 = CLI_ST_PRINT;
1440 return 1;
1441
1442}
1443
1444/* parse and set the CLI level dynamically */
1445static int cli_parse_set_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1446{
William Lallemandad032882019-07-01 10:56:15 +02001447 /* this will ask the applet to not output a \n after the command */
1448 if (!strcmp(args[1], "-"))
1449 appctx->st1 |= APPCTX_CLI_ST1_NOLF;
1450
William Lallemand67a234f2018-12-13 09:05:45 +01001451 if (!strcmp(args[0], "operator")) {
1452 if (!cli_has_level(appctx, ACCESS_LVL_OPER)) {
1453 return 1;
1454 }
1455 appctx->cli_level &= ~ACCESS_LVL_MASK;
1456 appctx->cli_level |= ACCESS_LVL_OPER;
1457
1458 } else if (!strcmp(args[0], "user")) {
1459 if (!cli_has_level(appctx, ACCESS_LVL_USER)) {
1460 return 1;
1461 }
1462 appctx->cli_level &= ~ACCESS_LVL_MASK;
1463 appctx->cli_level |= ACCESS_LVL_USER;
1464 }
1465 return 1;
1466}
1467
William Lallemanda57b7e32018-12-14 21:11:31 +01001468
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001469int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001470{
1471 return 0;
1472}
1473
Willy Tarreau45c742b2016-11-24 14:51:17 +01001474/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001475static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001476{
1477 int v;
1478 int *res;
1479 int mul = 1;
1480
1481 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1482 return 1;
1483
1484 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1485 res = &global.cps_lim;
1486 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1487 res = &global.sps_lim;
1488#ifdef USE_OPENSSL
1489 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1490 res = &global.ssl_lim;
1491#endif
1492 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1493 res = &global.comp_rate_lim;
1494 mul = 1024;
1495 }
1496 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001497 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001498 appctx->ctx.cli.msg =
1499 "'set rate-limit' only supports :\n"
1500 " - 'connections global' to set the per-process maximum connection rate\n"
1501 " - 'sessions global' to set the per-process maximum session rate\n"
1502#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001503 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001504#endif
1505 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001506 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001507 return 1;
1508 }
1509
1510 if (!*args[4]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001511 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001512 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001513 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001514 return 1;
1515 }
1516
1517 v = atoi(args[4]);
1518 if (v < 0) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001519 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001520 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001521 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001522 return 1;
1523 }
1524
1525 *res = v * mul;
1526
1527 /* Dequeues all of the listeners waiting for a resource */
1528 if (!LIST_ISEMPTY(&global_listener_queue))
1529 dequeue_all_listeners(&global_listener_queue);
1530
1531 return 1;
1532}
1533
William Lallemandf6975e92017-05-26 17:42:10 +02001534/* parse the "expose-fd" argument on the bind lines */
1535static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1536{
1537 if (!*args[cur_arg + 1]) {
1538 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1539 return ERR_ALERT | ERR_FATAL;
1540 }
1541 if (!strcmp(args[cur_arg+1], "listeners")) {
1542 conf->level |= ACCESS_FD_LISTENERS;
1543 } else {
1544 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1545 args[cur_arg], args[cur_arg+1]);
1546 return ERR_ALERT | ERR_FATAL;
1547 }
1548
1549 return 0;
1550}
1551
William Lallemand74c24fb2016-11-21 17:18:36 +01001552/* parse the "level" argument on the bind lines */
1553static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1554{
1555 if (!*args[cur_arg + 1]) {
1556 memprintf(err, "'%s' : missing level", args[cur_arg]);
1557 return ERR_ALERT | ERR_FATAL;
1558 }
1559
William Lallemand07a62f72017-05-24 00:57:40 +02001560 if (!strcmp(args[cur_arg+1], "user")) {
1561 conf->level &= ~ACCESS_LVL_MASK;
1562 conf->level |= ACCESS_LVL_USER;
1563 } else if (!strcmp(args[cur_arg+1], "operator")) {
1564 conf->level &= ~ACCESS_LVL_MASK;
1565 conf->level |= ACCESS_LVL_OPER;
1566 } else if (!strcmp(args[cur_arg+1], "admin")) {
1567 conf->level &= ~ACCESS_LVL_MASK;
1568 conf->level |= ACCESS_LVL_ADMIN;
1569 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001570 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1571 args[cur_arg], args[cur_arg+1]);
1572 return ERR_ALERT | ERR_FATAL;
1573 }
1574
1575 return 0;
1576}
1577
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001578static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1579{
1580 if (!*args[cur_arg + 1]) {
1581 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1582 return ERR_ALERT | ERR_FATAL;
1583 }
1584
1585 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1586 return 0;
1587 else {
1588 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1589 args[cur_arg], args[cur_arg+1]);
1590 return ERR_ALERT | ERR_FATAL;
1591 }
1592}
1593
William Lallemand16dd1b32018-11-19 18:46:18 +01001594
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001595
Olivier Houchardf886e342017-04-05 22:24:59 +02001596/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001597static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02001598{
1599 char *cmsgbuf = NULL;
1600 unsigned char *tmpbuf = NULL;
1601 struct cmsghdr *cmsg;
1602 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001603 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001604 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001605 struct msghdr msghdr;
1606 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001607 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Olivier Houchardf886e342017-04-05 22:24:59 +02001608 int *tmpfd;
1609 int tot_fd_nb = 0;
1610 struct proxy *px;
1611 int i = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001612 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001613 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001614 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001615 int ret;
1616
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001617 if (!remote) {
1618 ha_warning("Only works on real connections\n");
1619 goto out;
1620 }
1621
1622 fd = remote->handle.fd;
1623
Olivier Houchardf886e342017-04-05 22:24:59 +02001624 /* Temporary set the FD in blocking mode, that will make our life easier */
1625 old_fcntl = fcntl(fd, F_GETFL);
1626 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001627 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001628 goto out;
1629 }
1630 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1631 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001632 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001633 goto out;
1634 }
1635 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001636 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001637 goto out;
1638 }
Olivier Houchard54740872017-04-06 14:45:14 +02001639 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001640 iov.iov_base = &tot_fd_nb;
1641 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001642 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001643 goto out;
1644 memset(&msghdr, 0, sizeof(msghdr));
1645 /*
1646 * First, calculates the total number of FD, so that we can let
1647 * the caller know how much he should expects.
1648 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001649 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001650 while (px) {
1651 struct listener *l;
1652
1653 list_for_each_entry(l, &px->conf.listeners, by_fe) {
Olivier Houchard1fc05162017-04-06 01:05:05 +02001654 /* Only transfer IPv4/IPv6/UNIX sockets */
1655 if (l->state >= LI_ZOMBIE &&
1656 (l->proto->sock_family == AF_INET ||
Olivier Houchardf886e342017-04-05 22:24:59 +02001657 l->proto->sock_family == AF_INET6 ||
Olivier Houchard1fc05162017-04-06 01:05:05 +02001658 l->proto->sock_family == AF_UNIX))
Olivier Houchardf886e342017-04-05 22:24:59 +02001659 tot_fd_nb++;
1660 }
1661 px = px->next;
1662 }
1663 if (tot_fd_nb == 0)
1664 goto out;
1665
1666 /* First send the total number of file descriptors, so that the
1667 * receiving end knows what to expect.
1668 */
1669 msghdr.msg_iov = &iov;
1670 msghdr.msg_iovlen = 1;
1671 ret = sendmsg(fd, &msghdr, 0);
1672 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001673 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001674 goto out;
1675 }
1676
1677 /* Now send the fds */
1678 msghdr.msg_control = cmsgbuf;
1679 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1680 cmsg = CMSG_FIRSTHDR(&msghdr);
1681 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1682 cmsg->cmsg_level = SOL_SOCKET;
1683 cmsg->cmsg_type = SCM_RIGHTS;
1684 tmpfd = (int *)CMSG_DATA(cmsg);
1685
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001686 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001687 /* For each socket, e message is sent, containing the following :
1688 * Size of the namespace name (or 0 if none), as an unsigned char.
1689 * The namespace name, if any
1690 * Size of the interface name (or 0 if none), as an unsigned char
1691 * The interface name, if any
1692 * Listener options, as an int.
1693 */
1694 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
1695 * buffer big enough to store the socket informations.
1696 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001697 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001698 if (tmpbuf == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001699 ha_warning("Failed to allocate memory to transfer socket informations\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001700 goto out;
1701 }
1702 iov.iov_base = tmpbuf;
1703 while (px) {
1704 struct listener *l;
1705
1706 list_for_each_entry(l, &px->conf.listeners, by_fe) {
1707 int ret;
1708 /* Only transfer IPv4/IPv6 sockets */
Olivier Houchard1fc05162017-04-06 01:05:05 +02001709 if (l->state >= LI_ZOMBIE &&
Olivier Houchardf886e342017-04-05 22:24:59 +02001710 (l->proto->sock_family == AF_INET ||
1711 l->proto->sock_family == AF_INET6 ||
1712 l->proto->sock_family == AF_UNIX)) {
1713 memcpy(&tmpfd[i % MAX_SEND_FD], &l->fd, sizeof(l->fd));
1714 if (!l->netns)
1715 tmpbuf[curoff++] = 0;
Willy Tarreaue5733232019-05-22 19:24:06 +02001716#ifdef USE_NS
Olivier Houchardf886e342017-04-05 22:24:59 +02001717 else {
1718 char *name = l->netns->node.key;
1719 unsigned char len = l->netns->name_len;
1720 tmpbuf[curoff++] = len;
1721 memcpy(tmpbuf + curoff, name, len);
1722 curoff += len;
1723 }
1724#endif
1725 if (l->interface) {
1726 unsigned char len = strlen(l->interface);
1727 tmpbuf[curoff++] = len;
1728 memcpy(tmpbuf + curoff, l->interface, len);
1729 curoff += len;
1730 } else
1731 tmpbuf[curoff++] = 0;
1732 memcpy(tmpbuf + curoff, &l->options,
1733 sizeof(l->options));
1734 curoff += sizeof(l->options);
1735
1736
1737 i++;
1738 } else
1739 continue;
1740 if ((!(i % MAX_SEND_FD))) {
1741 iov.iov_len = curoff;
1742 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001743 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001744 goto out;
1745 }
1746 /* Wait for an ack */
1747 do {
1748 ret = recv(fd, &tot_fd_nb,
1749 sizeof(tot_fd_nb), 0);
1750 } while (ret == -1 && errno == EINTR);
1751 if (ret <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001752 ha_warning("Unexpected error while transferring sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001753 goto out;
1754 }
1755 curoff = 0;
1756 }
1757
1758 }
1759 px = px->next;
1760 }
1761 if (i % MAX_SEND_FD) {
1762 iov.iov_len = curoff;
1763 cmsg->cmsg_len = CMSG_LEN((i % MAX_SEND_FD) * sizeof(int));
1764 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * (i % MAX_SEND_FD));
1765 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001766 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001767 goto out;
1768 }
1769 }
1770
1771out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001772 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001773 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001774 goto out;
1775 }
1776 appctx->st0 = CLI_ST_END;
1777 free(cmsgbuf);
1778 free(tmpbuf);
1779 return 1;
1780}
1781
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001782static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
1783{
1784 if (*args[0] == 'h')
1785 /* help */
1786 cli_gen_usage_msg(appctx);
1787 else if (*args[0] == 'p')
1788 /* prompt */
1789 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
1790 else if (*args[0] == 'q')
1791 /* quit */
1792 appctx->st0 = CLI_ST_END;
1793
1794 return 1;
1795}
Olivier Houchardf886e342017-04-05 22:24:59 +02001796
William Lallemand2f4ce202018-10-26 14:47:47 +02001797void pcli_write_prompt(struct stream *s)
1798{
1799 struct buffer *msg = get_trash_chunk();
1800 struct channel *oc = si_oc(&s->si[0]);
1801
William Lallemanddc12c2e2018-12-13 09:05:46 +01001802 if (!(s->pcli_flags & PCLI_F_PROMPT))
William Lallemand5b80fa22018-12-11 16:10:54 +01001803 return;
1804
William Lallemanddc12c2e2018-12-13 09:05:46 +01001805 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01001806 chunk_appendf(msg, "+ ");
1807 } else {
1808 if (s->pcli_next_pid == 0)
Willy Tarreau52880f92018-12-15 13:30:03 +01001809 chunk_appendf(msg, "master%s> ",
1810 (global.mode & MODE_MWORKER_WAIT) ? "[ReloadFailed]" : "");
William Lallemandebf61802018-12-11 16:10:57 +01001811 else
1812 chunk_appendf(msg, "%d> ", s->pcli_next_pid);
1813 }
William Lallemand2f4ce202018-10-26 14:47:47 +02001814 co_inject(oc, msg->area, msg->data);
1815}
1816
William Lallemand291810d2018-10-26 14:47:38 +02001817
William Lallemandcf62f7e2018-10-26 14:47:40 +02001818/* The pcli_* functions are used for the CLI proxy in the master */
1819
William Lallemanddeeaa592018-10-26 14:47:48 +02001820void pcli_reply_and_close(struct stream *s, const char *msg)
1821{
1822 struct buffer *buf = get_trash_chunk();
1823
1824 chunk_initstr(buf, msg);
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001825 si_retnclose(&s->si[0], buf);
William Lallemanddeeaa592018-10-26 14:47:48 +02001826}
1827
William Lallemand291810d2018-10-26 14:47:38 +02001828static enum obj_type *pcli_pid_to_server(int proc_pid)
1829{
1830 struct mworker_proc *child;
1831
William Lallemandbddd33a2018-12-11 16:10:53 +01001832 /* return the CLI applet of the master */
1833 if (proc_pid == 0)
1834 return &cli_applet.obj_type;
1835
William Lallemand291810d2018-10-26 14:47:38 +02001836 list_for_each_entry(child, &proc_list, list) {
1837 if (child->pid == proc_pid){
1838 return &child->srv->obj_type;
1839 }
1840 }
1841 return NULL;
1842}
1843
1844/* Take a CLI prefix in argument (eg: @!1234 @master @1)
1845 * Return:
1846 * 0: master
1847 * > 0: pid of a worker
1848 * < 0: didn't find a worker
1849 */
1850static int pcli_prefix_to_pid(const char *prefix)
1851{
1852 int proc_pid;
1853 struct mworker_proc *child;
1854 char *errtol = NULL;
1855
1856 if (*prefix != '@') /* not a prefix, should not happen */
1857 return -1;
1858
1859 prefix++;
1860 if (!*prefix) /* sent @ alone, return the master */
1861 return 0;
1862
1863 if (strcmp("master", prefix) == 0) {
1864 return 0;
1865 } else if (*prefix == '!') {
1866 prefix++;
1867 if (!*prefix)
1868 return -1;
1869
1870 proc_pid = strtol(prefix, &errtol, 10);
1871 if (*errtol != '\0')
1872 return -1;
1873 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001874 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001875 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001876 if (child->pid == proc_pid){
1877 return child->pid;
1878 }
1879 }
1880 } else {
1881 struct mworker_proc *chosen = NULL;
1882 /* this is a relative pid */
1883
1884 proc_pid = strtol(prefix, &errtol, 10);
1885 if (*errtol != '\0')
1886 return -1;
1887
1888 if (proc_pid == 0) /* return the master */
1889 return 0;
1890
1891 /* chose the right process, the current one is the one with the
1892 least number of reloads */
1893 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001894 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001895 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001896 if (child->relative_pid == proc_pid){
1897 if (child->reloads == 0)
1898 return child->pid;
1899 else if (chosen == NULL || child->reloads < chosen->reloads)
1900 chosen = child;
1901 }
1902 }
1903 if (chosen)
1904 return chosen->pid;
1905 }
1906 return -1;
1907}
1908
William Lallemandbddd33a2018-12-11 16:10:53 +01001909/* Return::
1910 * >= 0 : number of words to escape
1911 * = -1 : error
1912 */
1913
1914int pcli_find_and_exec_kw(struct stream *s, char **args, int argl, char **errmsg, int *next_pid)
1915{
1916 if (argl < 1)
1917 return 0;
1918
1919 /* there is a prefix */
1920 if (args[0][0] == '@') {
1921 int target_pid = pcli_prefix_to_pid(args[0]);
1922
1923 if (target_pid == -1) {
1924 memprintf(errmsg, "Can't find the target PID matching the prefix '%s'\n", args[0]);
1925 return -1;
1926 }
1927
1928 /* if the prefix is alone, define a default target */
1929 if (argl == 1)
1930 s->pcli_next_pid = target_pid;
1931 else
1932 *next_pid = target_pid;
1933 return 1;
William Lallemand5b80fa22018-12-11 16:10:54 +01001934 } else if (!strcmp("prompt", args[0])) {
William Lallemanddc12c2e2018-12-13 09:05:46 +01001935 s->pcli_flags ^= PCLI_F_PROMPT;
William Lallemand5b80fa22018-12-11 16:10:54 +01001936 return argl; /* return the number of elements in the array */
William Lallemand5f610682018-12-11 16:10:55 +01001937
1938 } else if (!strcmp("quit", args[0])) {
1939 channel_shutr_now(&s->req);
1940 channel_shutw_now(&s->res);
1941 return argl; /* return the number of elements in the array */
William Lallemandb7ea1412018-12-13 09:05:47 +01001942 } else if (!strcmp(args[0], "operator")) {
1943 if (!pcli_has_level(s, ACCESS_LVL_OPER)) {
1944 memprintf(errmsg, "Permission denied!\n");
1945 return -1;
1946 }
1947 s->pcli_flags &= ~ACCESS_LVL_MASK;
1948 s->pcli_flags |= ACCESS_LVL_OPER;
1949 return argl;
1950
1951 } else if (!strcmp(args[0], "user")) {
1952 if (!pcli_has_level(s, ACCESS_LVL_USER)) {
1953 memprintf(errmsg, "Permission denied!\n");
1954 return -1;
1955 }
1956 s->pcli_flags &= ~ACCESS_LVL_MASK;
1957 s->pcli_flags |= ACCESS_LVL_USER;
1958 return argl;
William Lallemandbddd33a2018-12-11 16:10:53 +01001959 }
1960
1961 return 0;
1962}
1963
1964/*
1965 * Parse the CLI request:
1966 * - It does basically the same as the cli_io_handler, but as a proxy
1967 * - It can exec a command and strip non forwardable commands
William Lallemandcf62f7e2018-10-26 14:47:40 +02001968 *
1969 * Return:
William Lallemandbddd33a2018-12-11 16:10:53 +01001970 * - the number of characters to forward or
1971 * - 1 if there is an error or not enough data
William Lallemandcf62f7e2018-10-26 14:47:40 +02001972 */
William Lallemandbddd33a2018-12-11 16:10:53 +01001973int pcli_parse_request(struct stream *s, struct channel *req, char **errmsg, int *next_pid)
William Lallemandcf62f7e2018-10-26 14:47:40 +02001974{
William Lallemandbddd33a2018-12-11 16:10:53 +01001975 char *str = (char *)ci_head(req);
1976 char *end = (char *)ci_stop(req);
1977 char *args[MAX_STATS_ARGS + 1]; /* +1 for storing a NULL */
1978 int argl; /* number of args */
1979 char *p;
1980 char *trim = NULL;
William Lallemandebf61802018-12-11 16:10:57 +01001981 char *payload = NULL;
William Lallemandbddd33a2018-12-11 16:10:53 +01001982 int wtrim = 0; /* number of words to trim */
1983 int reql = 0;
William Lallemandb7ea1412018-12-13 09:05:47 +01001984 int ret;
William Lallemandbddd33a2018-12-11 16:10:53 +01001985 int i = 0;
1986
1987 p = str;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001988
William Lallemanddc12c2e2018-12-13 09:05:46 +01001989 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01001990
1991 /* Looks for the end of one command */
1992 while (p+reql < end) {
1993 /* handle escaping */
1994 if (p[reql] == '\\') {
1995 reql++;
1996 continue;
1997 }
1998 if (p[reql] == ';' || p[reql] == '\n') {
1999 /* found the end of the command */
2000 p[reql] = '\n';
2001 reql++;
2002 break;
2003 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002004 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002005 }
William Lallemandebf61802018-12-11 16:10:57 +01002006 } else {
2007 while (p+reql < end) {
2008 if (p[reql] == '\n') {
2009 /* found the end of the line */
2010 reql++;
2011 break;
2012 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002013 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002014 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002015 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002016
William Lallemandbddd33a2018-12-11 16:10:53 +01002017 /* set end to first byte after the end of the command */
2018 end = p + reql;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002019
William Lallemandbddd33a2018-12-11 16:10:53 +01002020 /* there is no end to this command, need more to parse ! */
2021 if (*(end-1) != '\n') {
2022 return -1;
2023 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002024
William Lallemand3301f3e2018-12-13 09:05:48 +01002025 if (s->pcli_flags & PCLI_F_PAYLOAD) {
2026 if (reql == 1) /* last line of the payload */
2027 s->pcli_flags &= ~PCLI_F_PAYLOAD;
William Lallemandebf61802018-12-11 16:10:57 +01002028 return reql;
2029 }
2030
William Lallemandbddd33a2018-12-11 16:10:53 +01002031 *(end-1) = '\0';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002032
William Lallemandbddd33a2018-12-11 16:10:53 +01002033 /* splits the command in words */
2034 while (i < MAX_STATS_ARGS && p < end) {
2035 int j, k;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002036
William Lallemandbddd33a2018-12-11 16:10:53 +01002037 /* skip leading spaces/tabs */
2038 p += strspn(p, " \t");
2039 if (!*p)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002040 break;
2041
William Lallemandbddd33a2018-12-11 16:10:53 +01002042 args[i] = p;
2043 p += strcspn(p, " \t");
2044 *p++ = 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002045
William Lallemandbddd33a2018-12-11 16:10:53 +01002046 /* unescape backslashes (\) */
2047 for (j = 0, k = 0; args[i][k]; k++) {
2048 if (args[i][k] == '\\') {
2049 if (args[i][k + 1] == '\\')
2050 k++;
2051 else
2052 continue;
2053 }
2054 args[i][j] = args[i][k];
2055 j++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002056 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002057 args[i][j] = 0;
2058 i++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002059 }
2060
William Lallemandbddd33a2018-12-11 16:10:53 +01002061 argl = i;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002062
William Lallemandbddd33a2018-12-11 16:10:53 +01002063 for (; i < MAX_STATS_ARGS + 1; i++)
2064 args[i] = NULL;
2065
2066 wtrim = pcli_find_and_exec_kw(s, args, argl, errmsg, next_pid);
2067
2068 /* End of words are ending by \0, we need to replace the \0s by spaces
20691 before forwarding them */
2070 p = str;
William Lallemand3301f3e2018-12-13 09:05:48 +01002071 while (p < end-1) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002072 if (*p == '\0')
2073 *p = ' ';
2074 p++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002075 }
2076
William Lallemand3301f3e2018-12-13 09:05:48 +01002077 payload = strstr(str, PAYLOAD_PATTERN);
2078 if ((end - 1) == (payload + strlen(PAYLOAD_PATTERN))) {
2079 /* if the payload pattern is at the end */
2080 s->pcli_flags |= PCLI_F_PAYLOAD;
2081 ret = reql;
2082 }
2083
William Lallemandbddd33a2018-12-11 16:10:53 +01002084 *(end-1) = '\n';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002085
William Lallemandbddd33a2018-12-11 16:10:53 +01002086 if (wtrim > 0) {
2087 trim = &args[wtrim][0];
2088 if (trim == NULL) /* if this was the last word in the table */
2089 trim = end;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002090
William Lallemandbddd33a2018-12-11 16:10:53 +01002091 b_del(&req->buf, trim - str);
2092
William Lallemandb7ea1412018-12-13 09:05:47 +01002093 ret = end - trim;
William Lallemandbddd33a2018-12-11 16:10:53 +01002094 } else if (wtrim < 0) {
2095 /* parsing error */
2096 return -1;
William Lallemandb7ea1412018-12-13 09:05:47 +01002097 } else {
2098 /* the whole string */
2099 ret = end - str;
William Lallemandbddd33a2018-12-11 16:10:53 +01002100 }
2101
William Lallemandb7ea1412018-12-13 09:05:47 +01002102 if (ret > 1) {
2103 if (pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2104 goto end;
2105 } else if (pcli_has_level(s, ACCESS_LVL_OPER)) {
William Lallemandad032882019-07-01 10:56:15 +02002106 ci_insert_line2(req, 0, "operator -", strlen("operator -"));
2107 ret += strlen("operator -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002108 } else if (pcli_has_level(s, ACCESS_LVL_USER)) {
William Lallemandad032882019-07-01 10:56:15 +02002109 ci_insert_line2(req, 0, "user -", strlen("user -"));
2110 ret += strlen("user -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002111 }
2112 }
2113end:
William Lallemandbddd33a2018-12-11 16:10:53 +01002114
William Lallemandb7ea1412018-12-13 09:05:47 +01002115 return ret;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002116}
2117
2118int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
2119{
William Lallemandbddd33a2018-12-11 16:10:53 +01002120 int next_pid = -1;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002121 int to_forward;
William Lallemandbddd33a2018-12-11 16:10:53 +01002122 char *errmsg = NULL;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002123
William Lallemandb7ea1412018-12-13 09:05:47 +01002124 if ((s->pcli_flags & ACCESS_LVL_MASK) == ACCESS_LVL_NONE)
2125 s->pcli_flags |= strm_li(s)->bind_conf->level & ACCESS_LVL_MASK;
2126
William Lallemandcf62f7e2018-10-26 14:47:40 +02002127read_again:
2128 /* if the channel is closed for read, we won't receive any more data
2129 from the client, but we don't want to forward this close to the
2130 server */
2131 channel_dont_close(req);
2132
2133 /* We don't know yet to which server we will connect */
2134 channel_dont_connect(req);
2135
2136
2137 /* we are not waiting for a response, there is no more request and we
2138 * receive a close from the client, we can leave */
2139 if (!(ci_data(req)) && req->flags & CF_SHUTR) {
2140 channel_shutw_now(&s->res);
2141 s->req.analysers &= ~AN_REQ_WAIT_CLI;
2142 return 1;
2143 }
2144
2145 req->flags |= CF_READ_DONTWAIT;
2146
2147 /* need more data */
2148 if (!ci_data(req))
2149 return 0;
2150
2151 /* If there is data available for analysis, log the end of the idle time. */
2152 if (c_data(req) && s->logs.t_idle == -1)
2153 s->logs.t_idle = tv_ms_elapsed(&s->logs.tv_accept, &now) - s->logs.t_handshake;
2154
William Lallemandbddd33a2018-12-11 16:10:53 +01002155 to_forward = pcli_parse_request(s, req, &errmsg, &next_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002156 if (to_forward > 0) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002157 int target_pid;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002158 /* enough data */
2159
William Lallemandcf62f7e2018-10-26 14:47:40 +02002160 /* forward only 1 command */
2161 channel_forward(req, to_forward);
William Lallemandebf61802018-12-11 16:10:57 +01002162
William Lallemanddc12c2e2018-12-13 09:05:46 +01002163 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002164 /* we send only 1 command per request, and we write close after it */
2165 channel_shutw_now(req);
2166 } else {
2167 pcli_write_prompt(s);
2168 }
2169
2170 s->res.flags |= CF_WAKE_ONCE; /* need to be called again */
William Lallemandcf62f7e2018-10-26 14:47:40 +02002171
2172 /* remove the XFER_DATA analysers, which forwards all
2173 * the data, we don't want to forward the next requests
2174 * We need to add CF_FLT_ANALYZE to abort the forward too.
2175 */
2176 req->analysers &= ~(AN_REQ_FLT_XFER_DATA|AN_REQ_WAIT_CLI);
2177 req->analysers |= AN_REQ_FLT_END|CF_FLT_ANALYZE;
2178 s->res.analysers |= AN_RES_WAIT_CLI;
2179
William Lallemandebf61802018-12-11 16:10:57 +01002180 if (!(s->flags & SF_ASSIGNED)) {
2181 if (next_pid > -1)
2182 target_pid = next_pid;
2183 else
2184 target_pid = s->pcli_next_pid;
2185 /* we can connect now */
2186 s->target = pcli_pid_to_server(target_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002187
William Lallemandebf61802018-12-11 16:10:57 +01002188 s->flags |= (SF_DIRECT | SF_ASSIGNED);
2189 channel_auto_connect(req);
2190 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002191
2192 } else if (to_forward == 0) {
William Lallemandcf62f7e2018-10-26 14:47:40 +02002193 /* we trimmed things but we might have other commands to consume */
William Lallemandbddd33a2018-12-11 16:10:53 +01002194 pcli_write_prompt(s);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002195 goto read_again;
William Lallemandbddd33a2018-12-11 16:10:53 +01002196 } else if (to_forward == -1 && errmsg) {
2197 /* there was an error during the parsing */
2198 pcli_reply_and_close(s, errmsg);
2199 return 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002200 } else if (to_forward == -1 && channel_full(req, global.tune.maxrewrite)) {
2201 /* buffer is full and we didn't catch the end of a command */
2202 goto send_help;
2203 }
2204
2205 return 0;
2206
2207send_help:
2208 b_reset(&req->buf);
2209 b_putblk(&req->buf, "help\n", 5);
2210 goto read_again;
2211}
2212
2213int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
2214{
2215 struct proxy *fe = strm_fe(s);
2216 struct proxy *be = s->be;
2217
William Lallemand6b7cd0a2018-11-06 17:37:11 +01002218 if (rep->flags & CF_READ_ERROR) {
2219 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
2220 s->res.analysers &= ~AN_RES_WAIT_CLI;
2221 return 0;
2222 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002223 rep->flags |= CF_READ_DONTWAIT; /* try to get back here ASAP */
2224 rep->flags |= CF_NEVER_WAIT;
2225
2226 /* don't forward the close */
2227 channel_dont_close(&s->res);
2228 channel_dont_close(&s->req);
2229
William Lallemanddc12c2e2018-12-13 09:05:46 +01002230 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002231 s->req.analysers |= AN_REQ_WAIT_CLI;
2232 s->res.analysers &= ~AN_RES_WAIT_CLI;
2233 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2234 return 0;
2235 }
2236
William Lallemandcf62f7e2018-10-26 14:47:40 +02002237 /* forward the data */
2238 if (ci_data(rep)) {
2239 c_adv(rep, ci_data(rep));
2240 return 0;
2241 }
2242
2243 if ((rep->flags & (CF_SHUTR|CF_READ_NULL))) {
2244 /* stream cleanup */
2245
William Lallemand2f4ce202018-10-26 14:47:47 +02002246 pcli_write_prompt(s);
2247
William Lallemandcf62f7e2018-10-26 14:47:40 +02002248 s->si[1].flags |= SI_FL_NOLINGER | SI_FL_NOHALF;
2249 si_shutr(&s->si[1]);
2250 si_shutw(&s->si[1]);
2251
2252 /*
2253 * starting from there this the same code as
2254 * http_end_txn_clean_session().
2255 *
2256 * It allows to do frontend keepalive while reconnecting to a
2257 * new server for each request.
2258 */
2259
2260 if (s->flags & SF_BE_ASSIGNED) {
2261 HA_ATOMIC_SUB(&be->beconn, 1);
2262 if (unlikely(s->srv_conn))
2263 sess_change_server(s, NULL);
2264 }
2265
2266 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2267 stream_process_counters(s);
2268
2269 /* don't count other requests' data */
2270 s->logs.bytes_in -= ci_data(&s->req);
2271 s->logs.bytes_out -= ci_data(&s->res);
2272
2273 /* we may need to know the position in the queue */
2274 pendconn_free(s);
2275
2276 /* let's do a final log if we need it */
2277 if (!LIST_ISEMPTY(&fe->logformat) && s->logs.logwait &&
2278 !(s->flags & SF_MONITOR) &&
2279 (!(fe->options & PR_O_NULLNOLOG) || s->req.total)) {
2280 s->do_log(s);
2281 }
2282
2283 /* stop tracking content-based counters */
2284 stream_stop_content_counters(s);
2285 stream_update_time_stats(s);
2286
2287 s->logs.accept_date = date; /* user-visible date for logging */
2288 s->logs.tv_accept = now; /* corrected date for internal use */
2289 s->logs.t_handshake = 0; /* There are no handshake in keep alive connection. */
2290 s->logs.t_idle = -1;
2291 tv_zero(&s->logs.tv_request);
2292 s->logs.t_queue = -1;
2293 s->logs.t_connect = -1;
2294 s->logs.t_data = -1;
2295 s->logs.t_close = 0;
2296 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
2297 s->logs.srv_queue_pos = 0; /* we will get this number soon */
2298
2299 s->logs.bytes_in = s->req.total = ci_data(&s->req);
2300 s->logs.bytes_out = s->res.total = ci_data(&s->res);
2301
2302 stream_del_srv_conn(s);
2303 if (objt_server(s->target)) {
2304 if (s->flags & SF_CURR_SESS) {
2305 s->flags &= ~SF_CURR_SESS;
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002306 HA_ATOMIC_SUB(&__objt_server(s->target)->cur_sess, 1);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002307 }
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002308 if (may_dequeue_tasks(__objt_server(s->target), be))
2309 process_srv_queue(__objt_server(s->target));
William Lallemandcf62f7e2018-10-26 14:47:40 +02002310 }
2311
2312 s->target = NULL;
2313
2314 /* only release our endpoint if we don't intend to reuse the
2315 * connection.
2316 */
2317 if (!si_conn_ready(&s->si[1])) {
2318 si_release_endpoint(&s->si[1]);
2319 s->srv_conn = NULL;
2320 }
2321
2322 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
2323 s->si[1].err_type = SI_ET_NONE;
2324 s->si[1].conn_retries = 0; /* used for logging too */
2325 s->si[1].exp = TICK_ETERNITY;
2326 s->si[1].flags &= SI_FL_ISBACK | SI_FL_DONT_WAKE; /* we're in the context of process_stream */
2327 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);
William Lallemand19338012019-06-25 18:00:19 +02002328 s->res.flags &= ~(CF_SHUTR|CF_SHUTR_NOW|CF_READ_ATTACHED|CF_READ_ERROR|CF_READ_NOEXP|CF_STREAMER|CF_STREAMER_FAST|CF_WRITE_PARTIAL|CF_NEVER_WAIT|CF_WROTE_DATA|CF_READ_NULL);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002329 s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_ADDR_SET|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
2330 s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
2331 s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
2332 /* reinitialise the current rule list pointer to NULL. We are sure that
2333 * any rulelist match the NULL pointer.
2334 */
2335 s->current_rule_list = NULL;
2336
2337 s->be = strm_fe(s);
2338 s->logs.logwait = strm_fe(s)->to_log;
2339 s->logs.level = 0;
2340 stream_del_srv_conn(s);
2341 s->target = NULL;
2342 /* re-init store persistence */
2343 s->store_count = 0;
2344 s->uniq_id = global.req_count++;
2345
2346 s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */
2347
2348 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2349
2350 s->req.analysers |= AN_REQ_WAIT_CLI;
2351 s->res.analysers &= ~AN_RES_WAIT_CLI;
2352
2353 /* We must trim any excess data from the response buffer, because we
2354 * may have blocked an invalid response from a server that we don't
Joseph Herlant008b3ce2018-11-25 12:51:45 -08002355 * want to accidently forward once we disable the analysers, nor do
William Lallemandcf62f7e2018-10-26 14:47:40 +02002356 * we want those data to come along with next response. A typical
2357 * example of such data would be from a buggy server responding to
2358 * a HEAD with some data, or sending more than the advertised
2359 * content-length.
2360 */
2361 if (unlikely(ci_data(&s->res)))
2362 b_set_data(&s->res.buf, co_data(&s->res));
2363
2364 /* Now we can realign the response buffer */
2365 c_realign_if_empty(&s->res);
2366
2367 s->req.rto = strm_fe(s)->timeout.client;
2368 s->req.wto = TICK_ETERNITY;
2369
2370 s->res.rto = TICK_ETERNITY;
2371 s->res.wto = strm_fe(s)->timeout.client;
2372
2373 s->req.rex = TICK_ETERNITY;
2374 s->req.wex = TICK_ETERNITY;
2375 s->req.analyse_exp = TICK_ETERNITY;
2376 s->res.rex = TICK_ETERNITY;
2377 s->res.wex = TICK_ETERNITY;
2378 s->res.analyse_exp = TICK_ETERNITY;
2379 s->si[1].hcto = TICK_ETERNITY;
2380
2381 /* we're removing the analysers, we MUST re-enable events detection.
2382 * We don't enable close on the response channel since it's either
2383 * already closed, or in keep-alive with an idle connection handler.
2384 */
2385 channel_auto_read(&s->req);
2386 channel_auto_close(&s->req);
2387 channel_auto_read(&s->res);
2388
2389
2390 return 1;
2391 }
2392 return 0;
2393}
2394
William Lallemand8a022572018-10-26 14:47:35 +02002395/*
2396 * The mworker functions are used to initialize the CLI in the master process
2397 */
2398
William Lallemand309dc9a2018-10-26 14:47:45 +02002399 /*
2400 * Stop the mworker proxy
2401 */
2402void mworker_cli_proxy_stop()
2403{
William Lallemand550db6d2018-11-06 17:37:12 +01002404 if (mworker_proxy)
2405 stop_proxy(mworker_proxy);
William Lallemand309dc9a2018-10-26 14:47:45 +02002406}
2407
William Lallemand8a022572018-10-26 14:47:35 +02002408/*
2409 * Create the mworker CLI proxy
2410 */
2411int mworker_cli_proxy_create()
2412{
2413 struct mworker_proc *child;
William Lallemand744a0892018-11-22 16:46:51 +01002414 char *msg = NULL;
2415 char *errmsg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002416
2417 mworker_proxy = calloc(1, sizeof(*mworker_proxy));
2418 if (!mworker_proxy)
2419 return -1;
2420
2421 init_new_proxy(mworker_proxy);
2422 mworker_proxy->next = proxies_list;
2423 proxies_list = mworker_proxy;
2424 mworker_proxy->id = strdup("MASTER");
William Lallemandcf62f7e2018-10-26 14:47:40 +02002425 mworker_proxy->mode = PR_MODE_CLI;
William Lallemand8a022572018-10-26 14:47:35 +02002426 mworker_proxy->state = PR_STNEW;
2427 mworker_proxy->last_change = now.tv_sec;
2428 mworker_proxy->cap = PR_CAP_LISTEN; /* this is a listen section */
2429 mworker_proxy->maxconn = 10; /* default to 10 concurrent connections */
2430 mworker_proxy->timeout.client = 0; /* no timeout */
2431 mworker_proxy->conf.file = strdup("MASTER");
2432 mworker_proxy->conf.line = 0;
2433 mworker_proxy->accept = frontend_accept;
2434 mworker_proxy-> lbprm.algo = BE_LB_ALGO_NONE;
2435
2436 /* Does not init the default target the CLI applet, but must be done in
2437 * the request parsing code */
2438 mworker_proxy->default_target = NULL;
2439
2440 /* the check_config_validity() will get an ID for the proxy */
2441 mworker_proxy->uuid = -1;
2442
2443 proxy_store_name(mworker_proxy);
2444
2445 /* create all servers using the mworker_proc list */
2446 list_for_each_entry(child, &proc_list, list) {
William Lallemand8a022572018-10-26 14:47:35 +02002447 struct server *newsrv = NULL;
2448 struct sockaddr_storage *sk;
2449 int port1, port2, port;
2450 struct protocol *proto;
William Lallemand8a022572018-10-26 14:47:35 +02002451
2452 newsrv = new_server(mworker_proxy);
2453 if (!newsrv)
William Lallemand744a0892018-11-22 16:46:51 +01002454 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002455
2456 /* we don't know the new pid yet */
2457 if (child->pid == -1)
2458 memprintf(&msg, "cur-%d", child->relative_pid);
2459 else
2460 memprintf(&msg, "old-%d", child->pid);
2461
2462 newsrv->next = mworker_proxy->srv;
2463 mworker_proxy->srv = newsrv;
2464 newsrv->conf.file = strdup(msg);
2465 newsrv->id = strdup(msg);
2466 newsrv->conf.line = 0;
2467
2468 memprintf(&msg, "sockpair@%d", child->ipc_fd[0]);
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002469 if ((sk = str2sa_range(msg, &port, &port1, &port2, &errmsg, NULL, NULL, 0)) == 0) {
William Lallemand744a0892018-11-22 16:46:51 +01002470 goto error;
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002471 }
2472 free(msg);
2473 msg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002474
2475 proto = protocol_by_family(sk->ss_family);
2476 if (!proto || !proto->connect) {
William Lallemand744a0892018-11-22 16:46:51 +01002477 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002478 }
2479
2480 /* no port specified */
2481 newsrv->flags |= SRV_F_MAPPORTS;
2482 newsrv->addr = *sk;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002483 /* don't let the server participate to load balancing */
2484 newsrv->iweight = 0;
2485 newsrv->uweight = 0;
William Lallemand8a022572018-10-26 14:47:35 +02002486 srv_lb_commit_status(newsrv);
William Lallemand291810d2018-10-26 14:47:38 +02002487
2488 child->srv = newsrv;
William Lallemand8a022572018-10-26 14:47:35 +02002489 }
2490 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002491
2492error:
2493 ha_alert("%s\n", errmsg);
2494
2495 list_for_each_entry(child, &proc_list, list) {
2496 free((char *)child->srv->conf.file); /* cast because of const char * */
2497 free(child->srv->id);
2498 free(child->srv);
2499 child->srv = NULL;
2500 }
2501 free(mworker_proxy->id);
2502 free(mworker_proxy->conf.file);
2503 free(mworker_proxy);
2504 mworker_proxy = NULL;
2505 free(errmsg);
2506 free(msg);
2507
2508 return -1;
William Lallemand8a022572018-10-26 14:47:35 +02002509}
Olivier Houchardf886e342017-04-05 22:24:59 +02002510
William Lallemandce83b4a2018-10-26 14:47:30 +02002511/*
William Lallemande7361152018-10-26 14:47:36 +02002512 * Create a new listener for the master CLI proxy
2513 */
2514int mworker_cli_proxy_new_listener(char *line)
2515{
2516 struct bind_conf *bind_conf;
2517 struct listener *l;
2518 char *err = NULL;
2519 char *args[MAX_LINE_ARGS + 1];
2520 int arg;
2521 int cur_arg;
2522
2523 arg = 0;
2524 args[0] = line;
2525
2526 /* args is a bind configuration with spaces replaced by commas */
2527 while (*line && arg < MAX_LINE_ARGS) {
2528
2529 if (*line == ',') {
2530 *line++ = '\0';
2531 while (*line == ',')
2532 line++;
2533 args[++arg] = line;
2534 }
2535 line++;
2536 }
2537
2538 args[++arg] = "\0";
2539
2540 bind_conf = bind_conf_alloc(mworker_proxy, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002541 if (!bind_conf)
2542 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002543
2544 bind_conf->level &= ~ACCESS_LVL_MASK;
2545 bind_conf->level |= ACCESS_LVL_ADMIN;
2546
2547 if (!str2listener(args[0], mworker_proxy, bind_conf, "master-socket", 0, &err)) {
2548 ha_alert("Cannot create the listener of the master CLI\n");
William Lallemand744a0892018-11-22 16:46:51 +01002549 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002550 }
2551
2552 cur_arg = 1;
2553
2554 while (*args[cur_arg]) {
2555 static int bind_dumped;
2556 struct bind_kw *kw;
2557
2558 kw = bind_find_kw(args[cur_arg]);
2559 if (kw) {
2560 if (!kw->parse) {
2561 memprintf(&err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
2562 args[0], args[1], args[cur_arg]);
2563 goto err;
2564 }
2565
2566 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, &err) != 0) {
2567 if (err)
2568 memprintf(&err, "'%s %s' : '%s'", args[0], args[1], err);
2569 else
2570 memprintf(&err, "'%s %s' : error encountered while processing '%s'",
2571 args[0], args[1], args[cur_arg]);
2572 goto err;
2573 }
2574
2575 cur_arg += 1 + kw->skip;
2576 continue;
2577 }
2578
2579 if (!bind_dumped) {
2580 bind_dump_kws(&err);
2581 indent_msg(&err, 4);
2582 bind_dumped = 1;
2583 }
2584
2585 memprintf(&err, "'%s %s' : unknown keyword '%s'.%s%s",
2586 args[0], args[1], args[cur_arg],
2587 err ? " Registered keywords :" : "", err ? err : "");
2588 goto err;
2589 }
2590
2591
2592 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemande7361152018-10-26 14:47:36 +02002593 l->accept = session_accept_fd;
2594 l->default_target = mworker_proxy->default_target;
2595 /* don't make the peers subject to global limits and don't close it in the master */
2596 l->options |= (LI_O_UNLIMITED|LI_O_MWORKER); /* we are keeping this FD in the master */
2597 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002598 global.maxsock++; /* for the listening socket */
William Lallemande7361152018-10-26 14:47:36 +02002599 }
Willy Tarreau18215cb2019-02-27 16:25:28 +01002600 global.maxsock += mworker_proxy->maxconn;
William Lallemande7361152018-10-26 14:47:36 +02002601
2602 return 0;
2603
2604err:
2605 ha_alert("%s\n", err);
William Lallemand744a0892018-11-22 16:46:51 +01002606 free(err);
2607 free(bind_conf);
William Lallemande7361152018-10-26 14:47:36 +02002608 return -1;
2609
2610}
2611
2612/*
William Lallemandce83b4a2018-10-26 14:47:30 +02002613 * Create a new CLI socket using a socketpair for a worker process
2614 * <mworker_proc> is the process structure, and <proc> is the process number
2615 */
2616int mworker_cli_sockpair_new(struct mworker_proc *mworker_proc, int proc)
2617{
2618 struct bind_conf *bind_conf;
2619 struct listener *l;
2620 char *path = NULL;
2621 char *err = NULL;
2622
2623 /* master pipe to ensure the master is still alive */
2624 if (socketpair(AF_UNIX, SOCK_STREAM, 0, mworker_proc->ipc_fd) < 0) {
2625 ha_alert("Cannot create worker socketpair.\n");
2626 return -1;
2627 }
2628
2629 /* XXX: we might want to use a separate frontend at some point */
2630 if (!global.stats_fe) {
2631 if ((global.stats_fe = alloc_stats_fe("GLOBAL", "master-socket", 0)) == NULL) {
2632 ha_alert("out of memory trying to allocate the stats frontend");
William Lallemand744a0892018-11-22 16:46:51 +01002633 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002634 }
2635 }
2636
2637 bind_conf = bind_conf_alloc(global.stats_fe, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002638 if (!bind_conf)
2639 goto error;
2640
William Lallemandce83b4a2018-10-26 14:47:30 +02002641 bind_conf->level &= ~ACCESS_LVL_MASK;
2642 bind_conf->level |= ACCESS_LVL_ADMIN; /* TODO: need to lower the rights with a CLI keyword*/
2643
2644 bind_conf->bind_proc = 1UL << proc;
2645 global.stats_fe->bind_proc = 0; /* XXX: we should be careful with that, it can be removed by configuration */
2646
2647 if (!memprintf(&path, "sockpair@%d", mworker_proc->ipc_fd[1])) {
2648 ha_alert("Cannot allocate listener.\n");
William Lallemand744a0892018-11-22 16:46:51 +01002649 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002650 }
2651
2652 if (!str2listener(path, global.stats_fe, bind_conf, "master-socket", 0, &err)) {
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002653 free(path);
William Lallemandce83b4a2018-10-26 14:47:30 +02002654 ha_alert("Cannot create a CLI sockpair listener for process #%d\n", proc);
William Lallemand744a0892018-11-22 16:46:51 +01002655 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002656 }
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002657 free(path);
2658 path = NULL;
William Lallemandce83b4a2018-10-26 14:47:30 +02002659
2660 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemandce83b4a2018-10-26 14:47:30 +02002661 l->accept = session_accept_fd;
2662 l->default_target = global.stats_fe->default_target;
William Lallemanda3372292018-11-16 16:57:22 +01002663 l->options |= (LI_O_UNLIMITED | LI_O_NOSTOP);
William Lallemandce83b4a2018-10-26 14:47:30 +02002664 /* it's a sockpair but we don't want to keep the fd in the master */
2665 l->options &= ~LI_O_INHERITED;
2666 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002667 global.maxsock++; /* for the listening socket */
William Lallemandce83b4a2018-10-26 14:47:30 +02002668 }
2669
2670 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002671
2672error:
2673 close(mworker_proc->ipc_fd[0]);
2674 close(mworker_proc->ipc_fd[1]);
2675 free(err);
2676
2677 return -1;
William Lallemandce83b4a2018-10-26 14:47:30 +02002678}
2679
William Lallemand74c24fb2016-11-21 17:18:36 +01002680static struct applet cli_applet = {
2681 .obj_type = OBJ_TYPE_APPLET,
2682 .name = "<CLI>", /* used for logging */
2683 .fct = cli_io_handler,
2684 .release = cli_release_handler,
2685};
2686
Willy Tarreau0a739292016-11-22 20:21:23 +01002687/* register cli keywords */
2688static struct cli_kw_list cli_kws = {{ },{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002689 { { "help", NULL }, NULL, cli_parse_simple, NULL },
2690 { { "prompt", NULL }, NULL, cli_parse_simple, NULL },
2691 { { "quit", NULL }, NULL, cli_parse_simple, NULL },
Willy Tarreau2af99412016-11-23 11:10:59 +01002692 { { "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 +01002693 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002694 { { "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 +01002695 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002696 { { "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 +02002697 { { "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 +01002698 { { "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 +02002699 { { "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 +01002700 { { "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 +01002701 { { "operator", NULL }, "operator : lower the level of the current CLI session to operator", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
2702 { { "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 +02002703 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002704 {{},}
2705}};
2706
Willy Tarreau0108d902018-11-25 19:14:37 +01002707INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
2708
William Lallemand74c24fb2016-11-21 17:18:36 +01002709static struct cfg_kw_list cfg_kws = {ILH, {
2710 { CFG_GLOBAL, "stats", stats_parse_global },
2711 { 0, NULL, NULL },
2712}};
2713
Willy Tarreau0108d902018-11-25 19:14:37 +01002714INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
2715
William Lallemand74c24fb2016-11-21 17:18:36 +01002716static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02002717 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
2718 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002719 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01002720 { NULL, NULL, 0 },
2721}};
2722
Willy Tarreau0108d902018-11-25 19:14:37 +01002723INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01002724
2725/*
2726 * Local variables:
2727 * c-indent-level: 8
2728 * c-basic-offset: 8
2729 * End:
2730 */