blob: 54c67433a7ff6a08125bd995fe745070fdd4050f [file] [log] [blame]
William Lallemand74c24fb2016-11-21 17:18:36 +01001/*
2 * Functions dedicated to statistics output and the stats socket
3 *
4 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
5 * Copyright 2007-2009 Krzysztof Piotr Oledzki <ole@ans.pl>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 */
13
14#include <ctype.h>
15#include <errno.h>
16#include <fcntl.h>
17#include <stdio.h>
18#include <stdlib.h>
19#include <string.h>
20#include <pwd.h>
21#include <grp.h>
22
23#include <sys/socket.h>
24#include <sys/stat.h>
25#include <sys/types.h>
26
Olivier Houchardf886e342017-04-05 22:24:59 +020027#include <net/if.h>
28
William Lallemand74c24fb2016-11-21 17:18:36 +010029#include <common/cfgparse.h>
30#include <common/compat.h>
31#include <common/config.h>
32#include <common/debug.h>
Willy Tarreau0108d902018-11-25 19:14:37 +010033#include <common/initcall.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010034#include <common/memory.h>
35#include <common/mini-clist.h>
36#include <common/standard.h>
37#include <common/ticks.h>
38#include <common/time.h>
39#include <common/uri_auth.h>
40#include <common/version.h>
41#include <common/base64.h>
42
43#include <types/applet.h>
William Lallemand9ed62032016-11-21 17:49:11 +010044#include <types/cli.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010045#include <types/global.h>
46#include <types/dns.h>
William Lallemand9ed62032016-11-21 17:49:11 +010047#include <types/stats.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010048
Willy Tarreau609aad92018-11-22 08:31:09 +010049#include <proto/activity.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010050#include <proto/backend.h>
51#include <proto/channel.h>
52#include <proto/checks.h>
53#include <proto/compression.h>
William Lallemand9ed62032016-11-21 17:49:11 +010054#include <proto/stats.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010055#include <proto/fd.h>
56#include <proto/freq_ctr.h>
57#include <proto/frontend.h>
58#include <proto/log.h>
59#include <proto/pattern.h>
60#include <proto/pipe.h>
William Lallemandce83b4a2018-10-26 14:47:30 +020061#include <proto/protocol.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010062#include <proto/listener.h>
63#include <proto/map.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010064#include <proto/proxy.h>
65#include <proto/sample.h>
66#include <proto/session.h>
67#include <proto/stream.h>
68#include <proto/server.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010069#include <proto/stream_interface.h>
70#include <proto/task.h>
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +020071#include <proto/proto_udp.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010072
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020073#define PAYLOAD_PATTERN "<<"
74
William Lallemand74c24fb2016-11-21 17:18:36 +010075static struct applet cli_applet;
76
77static const char stats_sock_usage_msg[] =
78 "Unknown command. Please enter one of the following commands only :\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010079 " help : this message\n"
80 " prompt : toggle interactive mode with prompt\n"
81 " quit : disconnect\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010082 "";
83
84static const char stats_permission_denied_msg[] =
85 "Permission denied\n"
86 "";
87
88
Christopher Faulet1bc04c72017-10-29 20:14:08 +010089static THREAD_LOCAL char *dynamic_usage_msg = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +010090
91/* List head of cli keywords */
92static struct cli_kw_list cli_keywords = {
93 .list = LIST_HEAD_INIT(cli_keywords.list)
94};
95
96extern const char *stat_status_codes[];
97
William Lallemand8a022572018-10-26 14:47:35 +020098static struct proxy *mworker_proxy; /* CLI proxy of the master */
99
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200100static char *cli_gen_usage_msg(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100101{
102 struct cli_kw_list *kw_list;
103 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +0200104 struct buffer *tmp = get_trash_chunk();
105 struct buffer out;
William Lallemand74c24fb2016-11-21 17:18:36 +0100106
107 free(dynamic_usage_msg);
108 dynamic_usage_msg = NULL;
109
110 if (LIST_ISEMPTY(&cli_keywords.list))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200111 goto end;
William Lallemand74c24fb2016-11-21 17:18:36 +0100112
113 chunk_reset(tmp);
114 chunk_strcat(tmp, stats_sock_usage_msg);
115 list_for_each_entry(kw_list, &cli_keywords.list, list) {
116 kw = &kw_list->kw[0];
William Lallemand0154edc2018-05-15 11:50:04 +0200117 while (kw->str_kw[0]) {
William Lallemand14721be2018-10-26 14:47:37 +0200118
119 /* in a worker or normal process, don't display master only commands */
120 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
121 goto next_kw;
122
123 /* in master don't displays if we don't have the master bits */
124 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
125 goto next_kw;
126
William Lallemand0154edc2018-05-15 11:50:04 +0200127 if (kw->usage)
128 chunk_appendf(tmp, " %s\n", kw->usage);
William Lallemand14721be2018-10-26 14:47:37 +0200129
130next_kw:
131
William Lallemand74c24fb2016-11-21 17:18:36 +0100132 kw++;
133 }
134 }
135 chunk_init(&out, NULL, 0);
136 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200137 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200138
139end:
140 if (dynamic_usage_msg) {
141 appctx->ctx.cli.severity = LOG_INFO;
142 appctx->ctx.cli.msg = dynamic_usage_msg;
143 }
144 else {
145 appctx->ctx.cli.severity = LOG_INFO;
146 appctx->ctx.cli.msg = stats_sock_usage_msg;
147 }
148 appctx->st0 = CLI_ST_PRINT;
149
William Lallemand74c24fb2016-11-21 17:18:36 +0100150 return dynamic_usage_msg;
151}
152
153struct cli_kw* cli_find_kw(char **args)
154{
155 struct cli_kw_list *kw_list;
156 struct cli_kw *kw;/* current cli_kw */
157 char **tmp_args;
158 const char **tmp_str_kw;
159 int found = 0;
160
161 if (LIST_ISEMPTY(&cli_keywords.list))
162 return NULL;
163
164 list_for_each_entry(kw_list, &cli_keywords.list, list) {
165 kw = &kw_list->kw[0];
166 while (*kw->str_kw) {
167 tmp_args = args;
168 tmp_str_kw = kw->str_kw;
169 while (*tmp_str_kw) {
170 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
171 found = 1;
172 } else {
173 found = 0;
174 break;
175 }
176 tmp_args++;
177 tmp_str_kw++;
178 }
179 if (found)
180 return (kw);
181 kw++;
182 }
183 }
184 return NULL;
185}
186
187void cli_register_kw(struct cli_kw_list *kw_list)
188{
189 LIST_ADDQ(&cli_keywords.list, &kw_list->list);
190}
191
192
193/* allocate a new stats frontend named <name>, and return it
194 * (or NULL in case of lack of memory).
195 */
196static struct proxy *alloc_stats_fe(const char *name, const char *file, int line)
197{
198 struct proxy *fe;
199
200 fe = calloc(1, sizeof(*fe));
201 if (!fe)
202 return NULL;
203
204 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100205 fe->next = proxies_list;
206 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100207 fe->last_change = now.tv_sec;
208 fe->id = strdup("GLOBAL");
209 fe->cap = PR_CAP_FE;
210 fe->maxconn = 10; /* default to 10 concurrent connections */
211 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
212 fe->conf.file = strdup(file);
213 fe->conf.line = line;
214 fe->accept = frontend_accept;
215 fe->default_target = &cli_applet.obj_type;
216
217 /* the stats frontend is the only one able to assign ID #0 */
218 fe->conf.id.key = fe->uuid = 0;
219 eb32_insert(&used_proxy_id, &fe->conf.id);
220 return fe;
221}
222
223/* This function parses a "stats" statement in the "global" section. It returns
224 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
225 * error message into the <err> buffer which will be preallocated. The trailing
226 * '\n' must not be written. The function must be called with <args> pointing to
227 * the first word after "stats".
228 */
229static int stats_parse_global(char **args, int section_type, struct proxy *curpx,
230 struct proxy *defpx, const char *file, int line,
231 char **err)
232{
233 struct bind_conf *bind_conf;
234 struct listener *l;
235
236 if (!strcmp(args[1], "socket")) {
237 int cur_arg;
238
239 if (*args[2] == 0) {
240 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
241 return -1;
242 }
243
244 if (!global.stats_fe) {
245 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
246 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
247 return -1;
248 }
249 }
250
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100251 bind_conf = bind_conf_alloc(global.stats_fe, file, line, args[2], xprt_get(XPRT_RAW));
William Lallemand07a62f72017-05-24 00:57:40 +0200252 bind_conf->level &= ~ACCESS_LVL_MASK;
253 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100254
255 if (!str2listener(args[2], global.stats_fe, bind_conf, file, line, err)) {
256 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
257 file, line, args[0], args[1], err && *err ? *err : "error");
258 return -1;
259 }
260
261 cur_arg = 3;
262 while (*args[cur_arg]) {
263 static int bind_dumped;
264 struct bind_kw *kw;
265
266 kw = bind_find_kw(args[cur_arg]);
267 if (kw) {
268 if (!kw->parse) {
269 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
270 args[0], args[1], args[cur_arg]);
271 return -1;
272 }
273
274 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, err) != 0) {
275 if (err && *err)
276 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
277 else
278 memprintf(err, "'%s %s' : error encountered while processing '%s'",
279 args[0], args[1], args[cur_arg]);
280 return -1;
281 }
282
283 cur_arg += 1 + kw->skip;
284 continue;
285 }
286
287 if (!bind_dumped) {
288 bind_dump_kws(err);
289 indent_msg(err, 4);
290 bind_dumped = 1;
291 }
292
293 memprintf(err, "'%s %s' : unknown keyword '%s'.%s%s",
294 args[0], args[1], args[cur_arg],
295 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
296 return -1;
297 }
298
299 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100300 l->accept = session_accept_fd;
William Lallemand74c24fb2016-11-21 17:18:36 +0100301 l->default_target = global.stats_fe->default_target;
302 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
303 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100304 global.maxsock++; /* for the listening socket */
William Lallemand74c24fb2016-11-21 17:18:36 +0100305 }
306 }
307 else if (!strcmp(args[1], "timeout")) {
308 unsigned timeout;
309 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
310
311 if (res) {
312 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
313 return -1;
314 }
315
316 if (!timeout) {
317 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
318 return -1;
319 }
320 if (!global.stats_fe) {
321 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
322 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
323 return -1;
324 }
325 }
326 global.stats_fe->timeout.client = MS_TO_TICKS(timeout);
327 }
328 else if (!strcmp(args[1], "maxconn")) {
329 int maxconn = atol(args[2]);
330
331 if (maxconn <= 0) {
332 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
333 return -1;
334 }
335
336 if (!global.stats_fe) {
337 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
338 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
339 return -1;
340 }
341 }
342 global.stats_fe->maxconn = maxconn;
343 }
344 else if (!strcmp(args[1], "bind-process")) { /* enable the socket only on some processes */
345 int cur_arg = 2;
346 unsigned long set = 0;
347
348 if (!global.stats_fe) {
349 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
350 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
351 return -1;
352 }
353 }
354
355 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100356 if (strcmp(args[cur_arg], "all") == 0) {
357 set = 0;
358 break;
359 }
Willy Tarreauff9c9142019-02-07 10:39:36 +0100360 if (parse_process_number(args[cur_arg], &set, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100361 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100362 return -1;
363 }
364 cur_arg++;
365 }
366 global.stats_fe->bind_proc = set;
367 }
368 else {
369 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
370 return -1;
371 }
372 return 0;
373}
374
William Lallemand33d29e22019-04-01 11:30:06 +0200375/*
376 * This function put a list of stats socket separated by a semicolon in the
377 * "HAPROXY_CLI" environment variable
378 */
379int cli_socket_setenv()
380{
381 struct buffer *trash = get_trash_chunk();
382 struct bind_conf *bind_conf;
383
384 if (global.stats_fe) {
385 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
386 struct listener *l;
387
388 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
389 char addr[46];
390 char port[6];
391
392 if (l->addr.ss_family == AF_UNIX) {
393 const struct sockaddr_un *un;
394
395 un = (struct sockaddr_un *)&l->addr;
396 if (un->sun_path[0] == '\0') {
397 chunk_appendf(trash, "abns@%s", un->sun_path+1);
398 } else {
399 chunk_appendf(trash, "unix@%s", un->sun_path);
400 }
401 } else if (l->addr.ss_family == AF_INET) {
402 addr_to_str(&l->addr, addr, sizeof(addr));
403 port_to_str(&l->addr, port, sizeof(port));
404 chunk_appendf(trash, "ipv4@%s:%s", addr, port);
405 } else if (l->addr.ss_family == AF_INET6) {
406 addr_to_str(&l->addr, addr, sizeof(addr));
407 port_to_str(&l->addr, port, sizeof(port));
408 chunk_appendf(trash, "ipv6@[%s]:%s", addr, port);
409 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
410 chunk_appendf(trash, "sockpair@%d", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
411 }
412 /* separate listener by semicolons */
413 trash->area[trash->data++] = ';';
414 }
415 }
416 trash->area[trash->data++] = '\0';
417 if (setenv("HAPROXY_CLI", trash->area, 1) < 0)
418 return -1;
419 }
420
421 return 0;
422}
423
424REGISTER_CONFIG_POSTPARSER("cli", cli_socket_setenv);
425
Willy Tarreaude57a572016-11-23 17:01:39 +0100426/* Verifies that the CLI at least has a level at least as high as <level>
427 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
428 * failure, an error message is prepared and the appctx's state is adjusted
429 * to print it so that a return 1 is enough to abort any processing.
430 */
431int cli_has_level(struct appctx *appctx, int level)
432{
Willy Tarreaude57a572016-11-23 17:01:39 +0100433
William Lallemandf630d012018-12-13 09:05:44 +0100434 if ((appctx->cli_level & ACCESS_LVL_MASK) < level) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200435 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreaude57a572016-11-23 17:01:39 +0100436 appctx->ctx.cli.msg = stats_permission_denied_msg;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100437 appctx->st0 = CLI_ST_PRINT;
Willy Tarreaude57a572016-11-23 17:01:39 +0100438 return 0;
439 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100440 return 1;
441}
442
William Lallemandb7ea1412018-12-13 09:05:47 +0100443/* same as cli_has_level but for the CLI proxy and without error message */
444int pcli_has_level(struct stream *s, int level)
445{
446 if ((s->pcli_flags & ACCESS_LVL_MASK) < level) {
447 return 0;
448 }
449 return 1;
450}
451
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200452/* Returns severity_output for the current session if set, or default for the socket */
453static int cli_get_severity_output(struct appctx *appctx)
454{
455 if (appctx->cli_severity_output)
456 return appctx->cli_severity_output;
457 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
458}
William Lallemand74c24fb2016-11-21 17:18:36 +0100459
Willy Tarreau41908562016-11-24 16:23:38 +0100460/* Processes the CLI interpreter on the stats socket. This function is called
461 * from the CLI's IO handler running in an appctx context. The function returns 1
462 * if the request was understood, otherwise zero. It is called with appctx->st0
463 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
464 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
465 * have its own I/O handler called again. Most of the time, parsers will only
466 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100467 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
468 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100469 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200470static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100471{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200472 char *args[MAX_STATS_ARGS + 1], *p, *end, *payload = NULL;
473 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100474 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100475
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200476 appctx->st2 = 0;
477 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
William Lallemand74c24fb2016-11-21 17:18:36 +0100478
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200479 p = appctx->chunk->area;
480 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100481
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200482 /*
483 * Get the payload start if there is one.
484 * For the sake of simplicity, the payload pattern is looked up
485 * everywhere from the start of the input but it can only be found
486 * at the end of the first line if APPCTX_CLI_ST1_PAYLOAD is set.
487 *
488 * The input string was zero terminated so it is safe to use
489 * the str*() functions throughout the parsing
490 */
491 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
492 payload = strstr(p, PAYLOAD_PATTERN);
493 end = payload;
494 /* skip the pattern */
495 payload += strlen(PAYLOAD_PATTERN);
496 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100497
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200498 /*
499 * Get pointers on words.
500 * One extra slot is reserved to store a pointer on a null byte.
501 */
502 while (i < MAX_STATS_ARGS && p < end) {
503 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100504
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200505 /* skip leading spaces/tabs */
506 p += strspn(p, " \t");
507 if (!*p)
508 break;
William Lallemand74c24fb2016-11-21 17:18:36 +0100509
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200510 args[i] = p;
511 p += strcspn(p, " \t");
512 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100513
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200514 /* unescape backslashes (\) */
515 for (j = 0, k = 0; args[i][k]; k++) {
516 if (args[i][k] == '\\') {
517 if (args[i][k + 1] == '\\')
518 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100519 else
520 continue;
521 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200522 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100523 j++;
524 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200525 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100526
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200527 i++;
528 }
529 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200530 p = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200531 for (; i < MAX_STATS_ARGS + 1; i++)
532 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100533
534 kw = cli_find_kw(args);
Willy Tarreaueaffde32016-12-16 17:59:25 +0100535 if (!kw)
Willy Tarreau41908562016-11-24 16:23:38 +0100536 return 0;
537
William Lallemand14721be2018-10-26 14:47:37 +0200538 /* in a worker or normal process, don't display master only commands */
539 if (master == 0 && (kw->level & ACCESS_MASTER_ONLY))
540 return 0;
541
542 /* in master don't displays if we don't have the master bits */
543 if (master == 1 && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
544 return 0;
545
Willy Tarreau41908562016-11-24 16:23:38 +0100546 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200547 appctx->io_release = kw->io_release;
548 /* kw->parse could set its own io_handler or ip_release handler */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200549 if ((!kw->parse || kw->parse(args, payload, appctx, kw->private) == 0) && appctx->io_handler) {
Willy Tarreau41908562016-11-24 16:23:38 +0100550 appctx->st0 = CLI_ST_CALLBACK;
William Lallemand74c24fb2016-11-21 17:18:36 +0100551 }
Willy Tarreau41908562016-11-24 16:23:38 +0100552 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100553}
554
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200555/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
556static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
557{
Willy Tarreau83061a82018-07-13 11:56:34 +0200558 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200559
560 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200561 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200562
563 tmp = get_trash_chunk();
564 chunk_reset(tmp);
565
566 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100567 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200568 chunk_printf(tmp, "[%d]: ", severity);
569 }
570 else {
571 switch (severity_output) {
572 case CLI_SEVERITY_NUMBER:
573 chunk_printf(tmp, "[%d]: ", severity);
574 break;
575 case CLI_SEVERITY_STRING:
576 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
577 break;
578 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100579 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200580 }
581 }
582 chunk_appendf(tmp, "%s", msg);
583
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200584 return ci_putblk(chn, tmp->area, strlen(tmp->area));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200585}
586
William Lallemand74c24fb2016-11-21 17:18:36 +0100587/* This I/O handler runs as an applet embedded in a stream interface. It is
588 * used to processes I/O from/to the stats unix socket. The system relies on a
589 * state machine handling requests and various responses. We read a request,
590 * then we process it and send the response, and we possibly display a prompt.
591 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100592 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100593 * or not.
594 */
595static void cli_io_handler(struct appctx *appctx)
596{
597 struct stream_interface *si = appctx->owner;
598 struct channel *req = si_oc(si);
599 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200600 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100601 int reql;
602 int len;
603
604 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
605 goto out;
606
Joseph Herlant008b3ce2018-11-25 12:51:45 -0800607 /* Check if the input buffer is available. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200608 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +0100609 /* buf.size==0 means we failed to get a buffer and were
610 * already subscribed to a wait list to get a buffer.
611 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100612 goto out;
613 }
614
William Lallemand74c24fb2016-11-21 17:18:36 +0100615 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100616 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100617 /* Stats output not initialized yet */
618 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200619 /* reset severity to default at init */
620 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100621 appctx->st0 = CLI_ST_GETREQ;
William Lallemandf630d012018-12-13 09:05:44 +0100622 appctx->cli_level = bind_conf->level;
William Lallemand74c24fb2016-11-21 17:18:36 +0100623 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100624 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100625 /* Let's close for real now. We just close the request
626 * side, the conditions below will complete if needed.
627 */
628 si_shutw(si);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200629 free_trash_chunk(appctx->chunk);
William Lallemand74c24fb2016-11-21 17:18:36 +0100630 break;
631 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100632 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200633 char *str;
634
635 /* use a trash chunk to store received data */
636 if (!appctx->chunk) {
637 appctx->chunk = alloc_trash_chunk();
638 if (!appctx->chunk) {
639 appctx->st0 = CLI_ST_END;
640 continue;
641 }
642 }
643
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200644 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200645
William Lallemand74c24fb2016-11-21 17:18:36 +0100646 /* ensure we have some output room left in the event we
647 * would want to return some info right after parsing.
648 */
649 if (buffer_almost_full(si_ib(si))) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100650 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100651 break;
652 }
653
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200654 /* '- 1' is to ensure a null byte can always be inserted at the end */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200655 reql = co_getline(si_oc(si), str,
656 appctx->chunk->size - appctx->chunk->data - 1);
William Lallemand74c24fb2016-11-21 17:18:36 +0100657 if (reql <= 0) { /* closed or EOL not found */
658 if (reql == 0)
659 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100660 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100661 continue;
662 }
663
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200664 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
665 /* seek for a possible unescaped semi-colon. If we find
666 * one, we replace it with an LF and skip only this part.
667 */
668 for (len = 0; len < reql; len++) {
669 if (str[len] == '\\') {
670 len++;
671 continue;
672 }
673 if (str[len] == ';') {
674 str[len] = '\n';
675 reql = len + 1;
676 break;
677 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100678 }
679 }
680
681 /* now it is time to check that we have a full line,
682 * remove the trailing \n and possibly \r, then cut the
683 * line.
684 */
685 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200686 if (str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100687 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100688 continue;
689 }
690
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200691 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100692 len--;
693
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200694 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200695 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200696
697 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200698 appctx->chunk->area[appctx->chunk->data] = '\n';
699 appctx->chunk->area[appctx->chunk->data + 1] = 0;
700 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200701 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100702
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100703 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200704
705 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
706 /* empty line */
707 if (!len) {
708 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200709 appctx->chunk->data -= 2;
710 appctx->chunk->area[appctx->chunk->data] = 0;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200711
712 if (!cli_parse_request(appctx))
713 cli_gen_usage_msg(appctx);
714
715 chunk_reset(appctx->chunk);
716 /* NB: cli_sock_parse_request() may have put
717 * another CLI_ST_O_* into appctx->st0.
718 */
719
720 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +0100721 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100722 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200723 else {
724 /*
725 * Look for the "payload start" pattern at the end of a line
726 * Its location is not remembered here, this is just to switch
727 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +0100728 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200729 if (!strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200730 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200731 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200732 /* no payload, the command is complete: parse the request */
733 if (!cli_parse_request(appctx))
734 cli_gen_usage_msg(appctx);
735
736 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200737 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100738 }
739
740 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200741 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100742 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
743 }
744 else { /* output functions */
745 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100746 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100747 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100748 case CLI_ST_PRINT:
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200749 if (cli_output_msg(res, appctx->ctx.cli.msg, appctx->ctx.cli.severity,
750 cli_get_severity_output(appctx)) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100751 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100752 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100753 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100754 break;
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200755 case CLI_ST_PRINT_FREE: {
756 const char *msg = appctx->ctx.cli.err;
757
758 if (!msg)
759 msg = "Out of memory.\n";
760
761 if (cli_output_msg(res, msg, LOG_ERR, cli_get_severity_output(appctx)) != -1) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100762 free(appctx->ctx.cli.err);
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100763 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100764 }
765 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100766 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100767 break;
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200768 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100769 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100770 if (appctx->io_handler)
771 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100772 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100773 if (appctx->io_release) {
774 appctx->io_release(appctx);
775 appctx->io_release = NULL;
776 }
777 }
778 break;
779 default: /* abnormal state */
780 si->flags |= SI_FL_ERR;
781 break;
782 }
783
784 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100785 if (appctx->st0 == CLI_ST_PROMPT) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200786 const char *prompt = "";
787
788 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
789 /*
790 * when entering a payload with interactive mode, change the prompt
791 * to emphasize that more data can still be sent
792 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200793 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200794 prompt = "+ ";
795 else
796 prompt = "\n> ";
797 }
798 else {
799 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD))
800 prompt = "\n";
801 }
802
803 if (ci_putstr(si_ic(si), prompt) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100804 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100805 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100806 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100807 }
808
809 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100810 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100811 break;
812
813 /* Now we close the output if one of the writers did so,
814 * or if we're not in interactive mode and the request
815 * buffer is empty. This still allows pipelined requests
816 * to be sent in non-interactive mode.
817 */
William Lallemand3de09d52018-12-11 16:10:56 +0100818 if (((res->flags & (CF_SHUTW|CF_SHUTW_NOW))) ||
819 (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req) && (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)))) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100820 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100821 continue;
822 }
823
824 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100825 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100826 }
827 }
828
829 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
830 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
831 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
832 /* Other side has closed, let's abort if we have no more processing to do
833 * and nothing more to consume. This is comparable to a broken pipe, so
834 * we forward the close to the request side so that it flows upstream to
835 * the client.
836 */
837 si_shutw(si);
838 }
839
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100840 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100841 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
842 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
843 /* We have no more processing to do, and nothing more to send, and
844 * the client side has closed. So we'll forward this state downstream
845 * on the response buffer.
846 */
847 si_shutr(si);
848 res->flags |= CF_READ_NULL;
849 }
850
851 out:
Christopher Faulet45073512018-07-20 10:16:29 +0200852 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 +0100853 __FUNCTION__, __LINE__,
Christopher Faulet45073512018-07-20 10:16:29 +0200854 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 +0100855}
856
William Lallemand74c24fb2016-11-21 17:18:36 +0100857/* This is called when the stream interface is closed. For instance, upon an
858 * external abort, we won't call the i/o handler anymore so we may need to
859 * remove back references to the stream currently being dumped.
860 */
861static void cli_release_handler(struct appctx *appctx)
862{
863 if (appctx->io_release) {
864 appctx->io_release(appctx);
865 appctx->io_release = NULL;
866 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100867 else if (appctx->st0 == CLI_ST_PRINT_FREE) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100868 free(appctx->ctx.cli.err);
869 appctx->ctx.cli.err = NULL;
870 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100871}
872
873/* This function dumps all environmnent variables to the buffer. It returns 0
874 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +0100875 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
876 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +0100877 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100878static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100879{
Willy Tarreau0a739292016-11-22 20:21:23 +0100880 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100881 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100882
883 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
884 return 1;
885
886 chunk_reset(&trash);
887
888 /* we have two inner loops here, one for the proxy, the other one for
889 * the buffer.
890 */
Willy Tarreauf6710f82016-12-16 17:45:44 +0100891 while (*var) {
892 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +0100893
Willy Tarreau06d80a92017-10-19 14:32:15 +0200894 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100895 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100896 return 0;
897 }
898 if (appctx->st2 == STAT_ST_END)
899 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100900 var++;
901 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +0100902 }
903
904 /* dump complete */
905 return 1;
906}
907
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200908/* This function dumps all file descriptors states (or the requested one) to
909 * the buffer. It returns 0 if the output buffer is full and it needs to be
910 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
911 * It uses cli.i0 as the fd number to restart from.
912 */
913static int cli_io_handler_show_fd(struct appctx *appctx)
914{
915 struct stream_interface *si = appctx->owner;
916 int fd = appctx->ctx.cli.i0;
Willy Tarreauca1b1572018-12-18 15:45:11 +0100917 int ret = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200918
919 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
Willy Tarreauca1b1572018-12-18 15:45:11 +0100920 goto end;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200921
922 chunk_reset(&trash);
923
Willy Tarreauca1b1572018-12-18 15:45:11 +0100924 /* isolate the threads once per round. We're limited to a buffer worth
925 * of output anyway, it cannot last very long.
926 */
927 thread_isolate();
928
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200929 /* we have two inner loops here, one for the proxy, the other one for
930 * the buffer.
931 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +0100932 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200933 struct fdtab fdt;
Willy Tarreau286ec682017-08-09 16:35:44 +0200934 struct listener *li = NULL;
935 struct server *sv = NULL;
936 struct proxy *px = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +0200937 const struct mux_ops *mux = NULL;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200938 void *ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +0200939 uint32_t conn_flags = 0;
Willy Tarreaue9ca8072018-12-19 18:40:58 +0100940 int is_back = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200941
942 fdt = fdtab[fd];
943
Willy Tarreauca1b1572018-12-18 15:45:11 +0100944 if (!fdt.owner)
Willy Tarreau017af242017-10-04 20:24:54 +0200945 goto skip; // closed
946
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200947 if (fdt.iocb == conn_fd_handler) {
948 conn_flags = ((struct connection *)fdt.owner)->flags;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200949 mux = ((struct connection *)fdt.owner)->mux;
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100950 ctx = ((struct connection *)fdt.owner)->ctx;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200951 li = objt_listener(((struct connection *)fdt.owner)->target);
952 sv = objt_server(((struct connection *)fdt.owner)->target);
953 px = objt_proxy(((struct connection *)fdt.owner)->target);
Willy Tarreaue9ca8072018-12-19 18:40:58 +0100954 is_back = conn_is_back((struct connection *)fdt.owner);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200955 }
956 else if (fdt.iocb == listener_accept)
957 li = fdt.owner;
958
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200959 chunk_printf(&trash,
Willy Tarreauc754b342018-03-30 15:00:15 +0200960 " %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 +0200961 fd,
962 fdt.state,
963 (fdt.state & FD_EV_POLLED_R) ? 'P' : 'p',
964 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
965 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
966 (fdt.state & FD_EV_POLLED_W) ? 'P' : 'p',
967 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
968 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
969 fdt.ev,
970 (fdt.ev & FD_POLL_HUP) ? 'H' : 'h',
971 (fdt.ev & FD_POLL_ERR) ? 'E' : 'e',
972 (fdt.ev & FD_POLL_OUT) ? 'O' : 'o',
973 (fdt.ev & FD_POLL_PRI) ? 'P' : 'p',
974 (fdt.ev & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200975 fdt.linger_risk ? 'L' : 'l',
976 fdt.cloned ? 'C' : 'c',
Willy Tarreauc754b342018-03-30 15:00:15 +0200977 fdt.cache.next,
978 fdt.cache.prev,
979 fdt.thread_mask, fdt.update_mask,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200980 fdt.owner,
981 fdt.iocb,
982 (fdt.iocb == conn_fd_handler) ? "conn_fd_handler" :
983 (fdt.iocb == dgram_fd_handler) ? "dgram_fd_handler" :
984 (fdt.iocb == listener_accept) ? "listener_accept" :
Olivier Houchard79321b92018-07-26 17:55:11 +0200985 (fdt.iocb == poller_pipe_io_handler) ? "poller_pipe_io_handler" :
William Lallemanddb6bdfb2018-11-20 17:36:51 +0100986 (fdt.iocb == mworker_accept_wrapper) ? "mworker_accept_wrapper" :
Willy Tarreauc754b342018-03-30 15:00:15 +0200987 "unknown");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200988
989 if (fdt.iocb == conn_fd_handler) {
Willy Tarreaue9ca8072018-12-19 18:40:58 +0100990 chunk_appendf(&trash, " back=%d cflg=0x%08x", is_back, conn_flags);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200991 if (px)
992 chunk_appendf(&trash, " px=%s", px->id);
993 else if (sv)
994 chunk_appendf(&trash, " sv=%s/%s", sv->id, sv->proxy->id);
995 else if (li)
996 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +0200997
Willy Tarreaub011d8f2018-03-30 14:41:19 +0200998 if (mux) {
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100999 chunk_appendf(&trash, " mux=%s ctx=%p", mux->name, ctx);
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001000 if (mux->show_fd)
1001 mux->show_fd(&trash, fdt.owner);
1002 }
Willy Tarreau35b1b482018-03-28 18:41:30 +02001003 else
1004 chunk_appendf(&trash, " nomux");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001005 }
1006 else if (fdt.iocb == listener_accept) {
1007 chunk_appendf(&trash, " l.st=%s fe=%s",
1008 listener_state_str(li),
1009 li->bind_conf->frontend->id);
1010 }
1011
1012 chunk_appendf(&trash, "\n");
1013
Willy Tarreau06d80a92017-10-19 14:32:15 +02001014 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001015 si_rx_room_blk(si);
Willy Tarreauca1b1572018-12-18 15:45:11 +01001016 appctx->ctx.cli.i0 = fd;
1017 ret = 0;
1018 break;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001019 }
1020 skip:
1021 if (appctx->st2 == STAT_ST_END)
1022 break;
1023
1024 fd++;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001025 }
1026
Willy Tarreauca1b1572018-12-18 15:45:11 +01001027 end:
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001028 /* dump complete */
Willy Tarreauca1b1572018-12-18 15:45:11 +01001029
1030 thread_release();
1031 return ret;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001032}
1033
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001034/* This function dumps some activity counters used by developers and support to
1035 * rule out some hypothesis during bug reports. It returns 0 if the output
1036 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
1037 * everything at once in the buffer and is not designed to do it in multiple
1038 * passes.
1039 */
1040static int cli_io_handler_show_activity(struct appctx *appctx)
1041{
1042 struct stream_interface *si = appctx->owner;
1043 int thr;
1044
1045 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1046 return 1;
1047
1048 chunk_reset(&trash);
1049
1050 chunk_appendf(&trash, "thread_id: %u", tid);
1051 chunk_appendf(&trash, "\ndate_now: %lu.%06lu", (long)now.tv_sec, (long)now.tv_usec);
1052 chunk_appendf(&trash, "\nloops:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].loops);
1053 chunk_appendf(&trash, "\nwake_cache:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_cache);
1054 chunk_appendf(&trash, "\nwake_tasks:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_tasks);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001055 chunk_appendf(&trash, "\nwake_signal:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_signal);
1056 chunk_appendf(&trash, "\npoll_exp:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_exp);
1057 chunk_appendf(&trash, "\npoll_drop:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_drop);
1058 chunk_appendf(&trash, "\npoll_dead:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_dead);
1059 chunk_appendf(&trash, "\npoll_skip:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_skip);
1060 chunk_appendf(&trash, "\nfd_skip:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_skip);
1061 chunk_appendf(&trash, "\nfd_lock:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_lock);
1062 chunk_appendf(&trash, "\nfd_del:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_del);
1063 chunk_appendf(&trash, "\nconn_dead:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].conn_dead);
1064 chunk_appendf(&trash, "\nstream:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].stream);
1065 chunk_appendf(&trash, "\nempty_rq:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].empty_rq);
1066 chunk_appendf(&trash, "\nlong_rq:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].long_rq);
Willy Tarreau4f93e0c2018-11-22 16:13:17 +01001067 chunk_appendf(&trash, "\ncpust_ms_tot:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].cpust_total/2);
1068 chunk_appendf(&trash, "\ncpust_ms_1s:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", read_freq_ctr(&activity[thr].cpust_1s)/2);
1069 chunk_appendf(&trash, "\ncpust_ms_15s:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", read_freq_ctr_period(&activity[thr].cpust_15s, 15000)/2);
Willy Tarreaubaba82f2018-11-22 08:42:42 +01001070 chunk_appendf(&trash, "\navg_loop_us:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", swrate_avg(activity[thr].avg_loop_us, TIME_STATS_SAMPLES));
Willy Tarreau64a9c052019-04-12 15:27:17 +02001071 chunk_appendf(&trash, "\naccepted:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].accepted);
Willy Tarreau8a034082019-02-27 10:45:55 +01001072 chunk_appendf(&trash, "\naccq_pushed:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].accq_pushed);
1073 chunk_appendf(&trash, "\naccq_full:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].accq_full);
Willy Tarreaue6182842019-04-15 18:54:10 +02001074#ifdef USE_THREAD
Willy Tarreaua8f57d52019-04-12 15:29:23 +02001075 chunk_appendf(&trash, "\naccq_ring:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", (accept_queue_rings[thr].tail - accept_queue_rings[thr].head + ACCEPT_QUEUE_SIZE)%ACCEPT_QUEUE_SIZE);
Willy Tarreaue6182842019-04-15 18:54:10 +02001076#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001077
1078 chunk_appendf(&trash, "\n");
1079
1080 if (ci_putchk(si_ic(si), &trash) == -1) {
1081 chunk_reset(&trash);
1082 chunk_printf(&trash, "[output too large, cannot dump]\n");
Willy Tarreaudb398432018-11-15 11:08:52 +01001083 si_rx_room_blk(si);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001084 }
1085
1086 /* dump complete */
1087 return 1;
1088}
1089
William Lallemandeceddf72016-12-15 18:06:44 +01001090/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001091 * CLI IO handler for `show cli sockets`.
1092 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +01001093 */
1094static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1095{
1096 struct bind_conf *bind_conf;
1097 struct stream_interface *si = appctx->owner;
1098
1099 chunk_reset(&trash);
1100
1101 switch (appctx->st2) {
1102 case STAT_ST_INIT:
1103 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +02001104 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001105 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001106 return 0;
1107 }
William Lallemandeceddf72016-12-15 18:06:44 +01001108 appctx->st2 = STAT_ST_LIST;
1109
1110 case STAT_ST_LIST:
1111 if (global.stats_fe) {
1112 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
1113 struct listener *l;
1114
1115 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001116 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +01001117 * if the current node is the first of the list
1118 */
1119
Willy Tarreau3af9d832016-12-16 12:58:09 +01001120 if (appctx->ctx.cli.p0 &&
1121 &bind_conf->by_fe == (&global.stats_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +01001122 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +01001123 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +01001124 continue;
1125 }
1126
1127 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
1128
1129 char addr[46];
1130 char port[6];
1131
1132 if (l->addr.ss_family == AF_UNIX) {
1133 const struct sockaddr_un *un;
1134
1135 un = (struct sockaddr_un *)&l->addr;
William Lallemande58915f2019-04-01 11:30:05 +02001136 if (un->sun_path[0] == '\0') {
William Lallemand75812a72019-04-01 11:30:04 +02001137 chunk_appendf(&trash, "abns@%s ", un->sun_path+1);
William Lallemande58915f2019-04-01 11:30:05 +02001138 } else {
1139 chunk_appendf(&trash, "unix@%s ", un->sun_path);
1140 }
William Lallemandeceddf72016-12-15 18:06:44 +01001141 } else if (l->addr.ss_family == AF_INET) {
1142 addr_to_str(&l->addr, addr, sizeof(addr));
1143 port_to_str(&l->addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001144 chunk_appendf(&trash, "ipv4@%s:%s ", addr, port);
William Lallemandeceddf72016-12-15 18:06:44 +01001145 } else if (l->addr.ss_family == AF_INET6) {
1146 addr_to_str(&l->addr, addr, sizeof(addr));
1147 port_to_str(&l->addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001148 chunk_appendf(&trash, "ipv6@[%s]:%s ", addr, port);
William Lallemand26314342018-10-26 14:47:41 +02001149 } else if (l->addr.ss_family == AF_CUST_SOCKPAIR) {
1150 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->addr)->sin_addr.s_addr);
William Lallemandeceddf72016-12-15 18:06:44 +01001151 } else
William Lallemand26314342018-10-26 14:47:41 +02001152 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001153
William Lallemand07a62f72017-05-24 00:57:40 +02001154 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +01001155 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +02001156 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1157 chunk_appendf(&trash, "operator ");
1158 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1159 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +01001160 else
1161 chunk_appendf(&trash, " ");
1162
1163 if (bind_conf->bind_proc != 0) {
1164 int pos;
Willy Tarreau20c5e522016-12-16 12:50:55 +01001165 for (pos = 0; pos < 8 * sizeof(bind_conf->bind_proc); pos++) {
Willy Tarreau4305ac72016-12-16 12:56:31 +01001166 if (bind_conf->bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +01001167 chunk_appendf(&trash, "%d,", pos+1);
1168 }
1169 }
1170 /* replace the latest comma by a newline */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001171 trash.area[trash.data-1] = '\n';
William Lallemandeceddf72016-12-15 18:06:44 +01001172
1173 } else {
1174 chunk_appendf(&trash, "all\n");
1175 }
1176
Willy Tarreau06d80a92017-10-19 14:32:15 +02001177 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001178 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001179 return 0;
1180 }
1181 }
Willy Tarreau3af9d832016-12-16 12:58:09 +01001182 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001183 }
1184 }
1185 default:
1186 appctx->st2 = STAT_ST_FIN;
1187 return 1;
1188 }
1189}
1190
1191
Willy Tarreau0a739292016-11-22 20:21:23 +01001192/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001193 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1194 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001195 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001196static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001197{
1198 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001199 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001200
1201 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1202 return 1;
1203
Willy Tarreauf6710f82016-12-16 17:45:44 +01001204 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001205
1206 if (*args[2]) {
1207 int len = strlen(args[2]);
1208
Willy Tarreauf6710f82016-12-16 17:45:44 +01001209 for (; *var; var++) {
1210 if (strncmp(*var, args[2], len) == 0 &&
1211 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001212 break;
1213 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001214 if (!*var) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001215 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau0a739292016-11-22 20:21:23 +01001216 appctx->ctx.cli.msg = "Variable not found\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001217 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau0a739292016-11-22 20:21:23 +01001218 return 1;
1219 }
1220 appctx->st2 = STAT_ST_END;
1221 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001222 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001223 return 0;
1224}
1225
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001226/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1227 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1228 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1229 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001230static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001231{
1232 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1233 return 1;
1234
1235 appctx->ctx.cli.i0 = 0;
1236
1237 if (*args[2]) {
1238 appctx->ctx.cli.i0 = atoi(args[2]);
1239 appctx->st2 = STAT_ST_END;
1240 }
1241 return 0;
1242}
1243
Willy Tarreau599852e2016-11-22 20:33:32 +01001244/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001245static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001246{
1247 struct stream_interface *si = appctx->owner;
1248 struct stream *s = si_strm(si);
1249
1250 if (strcmp(args[2], "cli") == 0) {
1251 unsigned timeout;
1252 const char *res;
1253
1254 if (!*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001255 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001256 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001257 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001258 return 1;
1259 }
1260
1261 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
1262 if (res || timeout < 1) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001263 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001264 appctx->ctx.cli.msg = "Invalid timeout value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001265 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001266 return 1;
1267 }
1268
1269 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1270 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1271 return 1;
1272 }
1273 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001274 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001275 appctx->ctx.cli.msg = "'set timeout' only supports 'cli'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001276 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001277 return 1;
1278 }
1279}
1280
Willy Tarreau2af99412016-11-23 11:10:59 +01001281/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001282static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001283{
1284 int v;
1285
1286 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1287 return 1;
1288
1289 if (!*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001290 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau2af99412016-11-23 11:10:59 +01001291 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001292 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +01001293 return 1;
1294 }
1295
1296 v = atoi(args[3]);
1297 if (v > global.hardmaxconn) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001298 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau2af99412016-11-23 11:10:59 +01001299 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001300 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +01001301 return 1;
1302 }
1303
1304 /* check for unlimited values */
1305 if (v <= 0)
1306 v = global.hardmaxconn;
1307
1308 global.maxconn = v;
1309
1310 /* Dequeues all of the listeners waiting for a resource */
1311 if (!LIST_ISEMPTY(&global_listener_queue))
1312 dequeue_all_listeners(&global_listener_queue);
1313
1314 return 1;
1315}
1316
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001317static int set_severity_output(int *target, char *argument)
1318{
1319 if (!strcmp(argument, "none")) {
1320 *target = CLI_SEVERITY_NONE;
1321 return 1;
1322 }
1323 else if (!strcmp(argument, "number")) {
1324 *target = CLI_SEVERITY_NUMBER;
1325 return 1;
1326 }
1327 else if (!strcmp(argument, "string")) {
1328 *target = CLI_SEVERITY_STRING;
1329 return 1;
1330 }
1331 return 0;
1332}
1333
1334/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001335static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001336{
1337 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1338 return 0;
1339
1340 appctx->ctx.cli.severity = LOG_ERR;
Aurélien Nephtali6e8a41d2018-03-15 21:48:50 +01001341 appctx->ctx.cli.msg = "one of 'none', 'number', 'string' is a required argument\n";
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001342 appctx->st0 = CLI_ST_PRINT;
1343 return 1;
1344}
William Lallemandeceddf72016-12-15 18:06:44 +01001345
William Lallemand67a234f2018-12-13 09:05:45 +01001346
1347/* show the level of the current CLI session */
1348static int cli_parse_show_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1349{
1350
1351 appctx->ctx.cli.severity = LOG_INFO;
1352 if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
1353 appctx->ctx.cli.msg = "admin\n";
1354 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1355 appctx->ctx.cli.msg = "operator\n";
1356 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1357 appctx->ctx.cli.msg = "user\n";
1358 else
1359 appctx->ctx.cli.msg = "unknown\n";
1360
1361 appctx->st0 = CLI_ST_PRINT;
1362 return 1;
1363
1364}
1365
1366/* parse and set the CLI level dynamically */
1367static int cli_parse_set_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1368{
1369 if (!strcmp(args[0], "operator")) {
1370 if (!cli_has_level(appctx, ACCESS_LVL_OPER)) {
1371 return 1;
1372 }
1373 appctx->cli_level &= ~ACCESS_LVL_MASK;
1374 appctx->cli_level |= ACCESS_LVL_OPER;
1375
1376 } else if (!strcmp(args[0], "user")) {
1377 if (!cli_has_level(appctx, ACCESS_LVL_USER)) {
1378 return 1;
1379 }
1380 appctx->cli_level &= ~ACCESS_LVL_MASK;
1381 appctx->cli_level |= ACCESS_LVL_USER;
1382 }
1383 return 1;
1384}
1385
William Lallemanda57b7e32018-12-14 21:11:31 +01001386
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001387int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001388{
1389 return 0;
1390}
1391
Willy Tarreau45c742b2016-11-24 14:51:17 +01001392/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001393static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001394{
1395 int v;
1396 int *res;
1397 int mul = 1;
1398
1399 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1400 return 1;
1401
1402 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1403 res = &global.cps_lim;
1404 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1405 res = &global.sps_lim;
1406#ifdef USE_OPENSSL
1407 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1408 res = &global.ssl_lim;
1409#endif
1410 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1411 res = &global.comp_rate_lim;
1412 mul = 1024;
1413 }
1414 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001415 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001416 appctx->ctx.cli.msg =
1417 "'set rate-limit' only supports :\n"
1418 " - 'connections global' to set the per-process maximum connection rate\n"
1419 " - 'sessions global' to set the per-process maximum session rate\n"
1420#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001421 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001422#endif
1423 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001424 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001425 return 1;
1426 }
1427
1428 if (!*args[4]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001429 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001430 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001431 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001432 return 1;
1433 }
1434
1435 v = atoi(args[4]);
1436 if (v < 0) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001437 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001438 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001439 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001440 return 1;
1441 }
1442
1443 *res = v * mul;
1444
1445 /* Dequeues all of the listeners waiting for a resource */
1446 if (!LIST_ISEMPTY(&global_listener_queue))
1447 dequeue_all_listeners(&global_listener_queue);
1448
1449 return 1;
1450}
1451
William Lallemandf6975e92017-05-26 17:42:10 +02001452/* parse the "expose-fd" argument on the bind lines */
1453static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1454{
1455 if (!*args[cur_arg + 1]) {
1456 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1457 return ERR_ALERT | ERR_FATAL;
1458 }
1459 if (!strcmp(args[cur_arg+1], "listeners")) {
1460 conf->level |= ACCESS_FD_LISTENERS;
1461 } else {
1462 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1463 args[cur_arg], args[cur_arg+1]);
1464 return ERR_ALERT | ERR_FATAL;
1465 }
1466
1467 return 0;
1468}
1469
William Lallemand74c24fb2016-11-21 17:18:36 +01001470/* parse the "level" argument on the bind lines */
1471static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1472{
1473 if (!*args[cur_arg + 1]) {
1474 memprintf(err, "'%s' : missing level", args[cur_arg]);
1475 return ERR_ALERT | ERR_FATAL;
1476 }
1477
William Lallemand07a62f72017-05-24 00:57:40 +02001478 if (!strcmp(args[cur_arg+1], "user")) {
1479 conf->level &= ~ACCESS_LVL_MASK;
1480 conf->level |= ACCESS_LVL_USER;
1481 } else if (!strcmp(args[cur_arg+1], "operator")) {
1482 conf->level &= ~ACCESS_LVL_MASK;
1483 conf->level |= ACCESS_LVL_OPER;
1484 } else if (!strcmp(args[cur_arg+1], "admin")) {
1485 conf->level &= ~ACCESS_LVL_MASK;
1486 conf->level |= ACCESS_LVL_ADMIN;
1487 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001488 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1489 args[cur_arg], args[cur_arg+1]);
1490 return ERR_ALERT | ERR_FATAL;
1491 }
1492
1493 return 0;
1494}
1495
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001496static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1497{
1498 if (!*args[cur_arg + 1]) {
1499 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1500 return ERR_ALERT | ERR_FATAL;
1501 }
1502
1503 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1504 return 0;
1505 else {
1506 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1507 args[cur_arg], args[cur_arg+1]);
1508 return ERR_ALERT | ERR_FATAL;
1509 }
1510}
1511
William Lallemand16dd1b32018-11-19 18:46:18 +01001512
William Lallemandb9f9e3b2018-10-26 14:47:39 +02001513
Olivier Houchardf886e342017-04-05 22:24:59 +02001514/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001515static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02001516{
1517 char *cmsgbuf = NULL;
1518 unsigned char *tmpbuf = NULL;
1519 struct cmsghdr *cmsg;
1520 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001521 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001522 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001523 struct msghdr msghdr;
1524 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001525 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Olivier Houchardf886e342017-04-05 22:24:59 +02001526 int *tmpfd;
1527 int tot_fd_nb = 0;
1528 struct proxy *px;
1529 int i = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001530 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001531 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001532 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001533 int ret;
1534
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001535 if (!remote) {
1536 ha_warning("Only works on real connections\n");
1537 goto out;
1538 }
1539
1540 fd = remote->handle.fd;
1541
Olivier Houchardf886e342017-04-05 22:24:59 +02001542 /* Temporary set the FD in blocking mode, that will make our life easier */
1543 old_fcntl = fcntl(fd, F_GETFL);
1544 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001545 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001546 goto out;
1547 }
1548 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1549 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001550 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001551 goto out;
1552 }
1553 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001554 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001555 goto out;
1556 }
Olivier Houchard54740872017-04-06 14:45:14 +02001557 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001558 iov.iov_base = &tot_fd_nb;
1559 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001560 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001561 goto out;
1562 memset(&msghdr, 0, sizeof(msghdr));
1563 /*
1564 * First, calculates the total number of FD, so that we can let
1565 * the caller know how much he should expects.
1566 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001567 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001568 while (px) {
1569 struct listener *l;
1570
1571 list_for_each_entry(l, &px->conf.listeners, by_fe) {
Olivier Houchard1fc05162017-04-06 01:05:05 +02001572 /* Only transfer IPv4/IPv6/UNIX sockets */
1573 if (l->state >= LI_ZOMBIE &&
1574 (l->proto->sock_family == AF_INET ||
Olivier Houchardf886e342017-04-05 22:24:59 +02001575 l->proto->sock_family == AF_INET6 ||
Olivier Houchard1fc05162017-04-06 01:05:05 +02001576 l->proto->sock_family == AF_UNIX))
Olivier Houchardf886e342017-04-05 22:24:59 +02001577 tot_fd_nb++;
1578 }
1579 px = px->next;
1580 }
1581 if (tot_fd_nb == 0)
1582 goto out;
1583
1584 /* First send the total number of file descriptors, so that the
1585 * receiving end knows what to expect.
1586 */
1587 msghdr.msg_iov = &iov;
1588 msghdr.msg_iovlen = 1;
1589 ret = sendmsg(fd, &msghdr, 0);
1590 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001591 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001592 goto out;
1593 }
1594
1595 /* Now send the fds */
1596 msghdr.msg_control = cmsgbuf;
1597 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1598 cmsg = CMSG_FIRSTHDR(&msghdr);
1599 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1600 cmsg->cmsg_level = SOL_SOCKET;
1601 cmsg->cmsg_type = SCM_RIGHTS;
1602 tmpfd = (int *)CMSG_DATA(cmsg);
1603
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001604 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001605 /* For each socket, e message is sent, containing the following :
1606 * Size of the namespace name (or 0 if none), as an unsigned char.
1607 * The namespace name, if any
1608 * Size of the interface name (or 0 if none), as an unsigned char
1609 * The interface name, if any
1610 * Listener options, as an int.
1611 */
1612 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
1613 * buffer big enough to store the socket informations.
1614 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001615 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001616 if (tmpbuf == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001617 ha_warning("Failed to allocate memory to transfer socket informations\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001618 goto out;
1619 }
1620 iov.iov_base = tmpbuf;
1621 while (px) {
1622 struct listener *l;
1623
1624 list_for_each_entry(l, &px->conf.listeners, by_fe) {
1625 int ret;
1626 /* Only transfer IPv4/IPv6 sockets */
Olivier Houchard1fc05162017-04-06 01:05:05 +02001627 if (l->state >= LI_ZOMBIE &&
Olivier Houchardf886e342017-04-05 22:24:59 +02001628 (l->proto->sock_family == AF_INET ||
1629 l->proto->sock_family == AF_INET6 ||
1630 l->proto->sock_family == AF_UNIX)) {
1631 memcpy(&tmpfd[i % MAX_SEND_FD], &l->fd, sizeof(l->fd));
1632 if (!l->netns)
1633 tmpbuf[curoff++] = 0;
1634#ifdef CONFIG_HAP_NS
1635 else {
1636 char *name = l->netns->node.key;
1637 unsigned char len = l->netns->name_len;
1638 tmpbuf[curoff++] = len;
1639 memcpy(tmpbuf + curoff, name, len);
1640 curoff += len;
1641 }
1642#endif
1643 if (l->interface) {
1644 unsigned char len = strlen(l->interface);
1645 tmpbuf[curoff++] = len;
1646 memcpy(tmpbuf + curoff, l->interface, len);
1647 curoff += len;
1648 } else
1649 tmpbuf[curoff++] = 0;
1650 memcpy(tmpbuf + curoff, &l->options,
1651 sizeof(l->options));
1652 curoff += sizeof(l->options);
1653
1654
1655 i++;
1656 } else
1657 continue;
1658 if ((!(i % MAX_SEND_FD))) {
1659 iov.iov_len = curoff;
1660 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001661 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001662 goto out;
1663 }
1664 /* Wait for an ack */
1665 do {
1666 ret = recv(fd, &tot_fd_nb,
1667 sizeof(tot_fd_nb), 0);
1668 } while (ret == -1 && errno == EINTR);
1669 if (ret <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001670 ha_warning("Unexpected error while transferring sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001671 goto out;
1672 }
1673 curoff = 0;
1674 }
1675
1676 }
1677 px = px->next;
1678 }
1679 if (i % MAX_SEND_FD) {
1680 iov.iov_len = curoff;
1681 cmsg->cmsg_len = CMSG_LEN((i % MAX_SEND_FD) * sizeof(int));
1682 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * (i % MAX_SEND_FD));
1683 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001684 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001685 goto out;
1686 }
1687 }
1688
1689out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001690 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001691 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001692 goto out;
1693 }
1694 appctx->st0 = CLI_ST_END;
1695 free(cmsgbuf);
1696 free(tmpbuf);
1697 return 1;
1698}
1699
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001700static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
1701{
1702 if (*args[0] == 'h')
1703 /* help */
1704 cli_gen_usage_msg(appctx);
1705 else if (*args[0] == 'p')
1706 /* prompt */
1707 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
1708 else if (*args[0] == 'q')
1709 /* quit */
1710 appctx->st0 = CLI_ST_END;
1711
1712 return 1;
1713}
Olivier Houchardf886e342017-04-05 22:24:59 +02001714
William Lallemand2f4ce202018-10-26 14:47:47 +02001715void pcli_write_prompt(struct stream *s)
1716{
1717 struct buffer *msg = get_trash_chunk();
1718 struct channel *oc = si_oc(&s->si[0]);
1719
William Lallemanddc12c2e2018-12-13 09:05:46 +01001720 if (!(s->pcli_flags & PCLI_F_PROMPT))
William Lallemand5b80fa22018-12-11 16:10:54 +01001721 return;
1722
William Lallemanddc12c2e2018-12-13 09:05:46 +01001723 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01001724 chunk_appendf(msg, "+ ");
1725 } else {
1726 if (s->pcli_next_pid == 0)
Willy Tarreau52880f92018-12-15 13:30:03 +01001727 chunk_appendf(msg, "master%s> ",
1728 (global.mode & MODE_MWORKER_WAIT) ? "[ReloadFailed]" : "");
William Lallemandebf61802018-12-11 16:10:57 +01001729 else
1730 chunk_appendf(msg, "%d> ", s->pcli_next_pid);
1731 }
William Lallemand2f4ce202018-10-26 14:47:47 +02001732 co_inject(oc, msg->area, msg->data);
1733}
1734
William Lallemand291810d2018-10-26 14:47:38 +02001735
William Lallemandcf62f7e2018-10-26 14:47:40 +02001736/* The pcli_* functions are used for the CLI proxy in the master */
1737
William Lallemanddeeaa592018-10-26 14:47:48 +02001738void pcli_reply_and_close(struct stream *s, const char *msg)
1739{
1740 struct buffer *buf = get_trash_chunk();
1741
1742 chunk_initstr(buf, msg);
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001743 si_retnclose(&s->si[0], buf);
William Lallemanddeeaa592018-10-26 14:47:48 +02001744}
1745
William Lallemand291810d2018-10-26 14:47:38 +02001746static enum obj_type *pcli_pid_to_server(int proc_pid)
1747{
1748 struct mworker_proc *child;
1749
William Lallemandbddd33a2018-12-11 16:10:53 +01001750 /* return the CLI applet of the master */
1751 if (proc_pid == 0)
1752 return &cli_applet.obj_type;
1753
William Lallemand291810d2018-10-26 14:47:38 +02001754 list_for_each_entry(child, &proc_list, list) {
1755 if (child->pid == proc_pid){
1756 return &child->srv->obj_type;
1757 }
1758 }
1759 return NULL;
1760}
1761
1762/* Take a CLI prefix in argument (eg: @!1234 @master @1)
1763 * Return:
1764 * 0: master
1765 * > 0: pid of a worker
1766 * < 0: didn't find a worker
1767 */
1768static int pcli_prefix_to_pid(const char *prefix)
1769{
1770 int proc_pid;
1771 struct mworker_proc *child;
1772 char *errtol = NULL;
1773
1774 if (*prefix != '@') /* not a prefix, should not happen */
1775 return -1;
1776
1777 prefix++;
1778 if (!*prefix) /* sent @ alone, return the master */
1779 return 0;
1780
1781 if (strcmp("master", prefix) == 0) {
1782 return 0;
1783 } else if (*prefix == '!') {
1784 prefix++;
1785 if (!*prefix)
1786 return -1;
1787
1788 proc_pid = strtol(prefix, &errtol, 10);
1789 if (*errtol != '\0')
1790 return -1;
1791 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001792 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001793 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001794 if (child->pid == proc_pid){
1795 return child->pid;
1796 }
1797 }
1798 } else {
1799 struct mworker_proc *chosen = NULL;
1800 /* this is a relative pid */
1801
1802 proc_pid = strtol(prefix, &errtol, 10);
1803 if (*errtol != '\0')
1804 return -1;
1805
1806 if (proc_pid == 0) /* return the master */
1807 return 0;
1808
1809 /* chose the right process, the current one is the one with the
1810 least number of reloads */
1811 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001812 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001813 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001814 if (child->relative_pid == proc_pid){
1815 if (child->reloads == 0)
1816 return child->pid;
1817 else if (chosen == NULL || child->reloads < chosen->reloads)
1818 chosen = child;
1819 }
1820 }
1821 if (chosen)
1822 return chosen->pid;
1823 }
1824 return -1;
1825}
1826
William Lallemandbddd33a2018-12-11 16:10:53 +01001827/* Return::
1828 * >= 0 : number of words to escape
1829 * = -1 : error
1830 */
1831
1832int pcli_find_and_exec_kw(struct stream *s, char **args, int argl, char **errmsg, int *next_pid)
1833{
1834 if (argl < 1)
1835 return 0;
1836
1837 /* there is a prefix */
1838 if (args[0][0] == '@') {
1839 int target_pid = pcli_prefix_to_pid(args[0]);
1840
1841 if (target_pid == -1) {
1842 memprintf(errmsg, "Can't find the target PID matching the prefix '%s'\n", args[0]);
1843 return -1;
1844 }
1845
1846 /* if the prefix is alone, define a default target */
1847 if (argl == 1)
1848 s->pcli_next_pid = target_pid;
1849 else
1850 *next_pid = target_pid;
1851 return 1;
William Lallemand5b80fa22018-12-11 16:10:54 +01001852 } else if (!strcmp("prompt", args[0])) {
William Lallemanddc12c2e2018-12-13 09:05:46 +01001853 s->pcli_flags ^= PCLI_F_PROMPT;
William Lallemand5b80fa22018-12-11 16:10:54 +01001854 return argl; /* return the number of elements in the array */
William Lallemand5f610682018-12-11 16:10:55 +01001855
1856 } else if (!strcmp("quit", args[0])) {
1857 channel_shutr_now(&s->req);
1858 channel_shutw_now(&s->res);
1859 return argl; /* return the number of elements in the array */
William Lallemandb7ea1412018-12-13 09:05:47 +01001860 } else if (!strcmp(args[0], "operator")) {
1861 if (!pcli_has_level(s, ACCESS_LVL_OPER)) {
1862 memprintf(errmsg, "Permission denied!\n");
1863 return -1;
1864 }
1865 s->pcli_flags &= ~ACCESS_LVL_MASK;
1866 s->pcli_flags |= ACCESS_LVL_OPER;
1867 return argl;
1868
1869 } else if (!strcmp(args[0], "user")) {
1870 if (!pcli_has_level(s, ACCESS_LVL_USER)) {
1871 memprintf(errmsg, "Permission denied!\n");
1872 return -1;
1873 }
1874 s->pcli_flags &= ~ACCESS_LVL_MASK;
1875 s->pcli_flags |= ACCESS_LVL_USER;
1876 return argl;
William Lallemandbddd33a2018-12-11 16:10:53 +01001877 }
1878
1879 return 0;
1880}
1881
1882/*
1883 * Parse the CLI request:
1884 * - It does basically the same as the cli_io_handler, but as a proxy
1885 * - It can exec a command and strip non forwardable commands
William Lallemandcf62f7e2018-10-26 14:47:40 +02001886 *
1887 * Return:
William Lallemandbddd33a2018-12-11 16:10:53 +01001888 * - the number of characters to forward or
1889 * - 1 if there is an error or not enough data
William Lallemandcf62f7e2018-10-26 14:47:40 +02001890 */
William Lallemandbddd33a2018-12-11 16:10:53 +01001891int pcli_parse_request(struct stream *s, struct channel *req, char **errmsg, int *next_pid)
William Lallemandcf62f7e2018-10-26 14:47:40 +02001892{
William Lallemandbddd33a2018-12-11 16:10:53 +01001893 char *str = (char *)ci_head(req);
1894 char *end = (char *)ci_stop(req);
1895 char *args[MAX_STATS_ARGS + 1]; /* +1 for storing a NULL */
1896 int argl; /* number of args */
1897 char *p;
1898 char *trim = NULL;
William Lallemandebf61802018-12-11 16:10:57 +01001899 char *payload = NULL;
William Lallemandbddd33a2018-12-11 16:10:53 +01001900 int wtrim = 0; /* number of words to trim */
1901 int reql = 0;
William Lallemandb7ea1412018-12-13 09:05:47 +01001902 int ret;
William Lallemandbddd33a2018-12-11 16:10:53 +01001903 int i = 0;
1904
1905 p = str;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001906
William Lallemanddc12c2e2018-12-13 09:05:46 +01001907 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01001908
1909 /* Looks for the end of one command */
1910 while (p+reql < end) {
1911 /* handle escaping */
1912 if (p[reql] == '\\') {
1913 reql++;
1914 continue;
1915 }
1916 if (p[reql] == ';' || p[reql] == '\n') {
1917 /* found the end of the command */
1918 p[reql] = '\n';
1919 reql++;
1920 break;
1921 }
William Lallemandbddd33a2018-12-11 16:10:53 +01001922 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01001923 }
William Lallemandebf61802018-12-11 16:10:57 +01001924 } else {
1925 while (p+reql < end) {
1926 if (p[reql] == '\n') {
1927 /* found the end of the line */
1928 reql++;
1929 break;
1930 }
William Lallemandbddd33a2018-12-11 16:10:53 +01001931 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01001932 }
William Lallemandbddd33a2018-12-11 16:10:53 +01001933 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02001934
William Lallemandbddd33a2018-12-11 16:10:53 +01001935 /* set end to first byte after the end of the command */
1936 end = p + reql;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001937
William Lallemandbddd33a2018-12-11 16:10:53 +01001938 /* there is no end to this command, need more to parse ! */
1939 if (*(end-1) != '\n') {
1940 return -1;
1941 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02001942
William Lallemand3301f3e2018-12-13 09:05:48 +01001943 if (s->pcli_flags & PCLI_F_PAYLOAD) {
1944 if (reql == 1) /* last line of the payload */
1945 s->pcli_flags &= ~PCLI_F_PAYLOAD;
William Lallemandebf61802018-12-11 16:10:57 +01001946 return reql;
1947 }
1948
William Lallemandbddd33a2018-12-11 16:10:53 +01001949 *(end-1) = '\0';
William Lallemandcf62f7e2018-10-26 14:47:40 +02001950
William Lallemandbddd33a2018-12-11 16:10:53 +01001951 /* splits the command in words */
1952 while (i < MAX_STATS_ARGS && p < end) {
1953 int j, k;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001954
William Lallemandbddd33a2018-12-11 16:10:53 +01001955 /* skip leading spaces/tabs */
1956 p += strspn(p, " \t");
1957 if (!*p)
William Lallemandcf62f7e2018-10-26 14:47:40 +02001958 break;
1959
William Lallemandbddd33a2018-12-11 16:10:53 +01001960 args[i] = p;
1961 p += strcspn(p, " \t");
1962 *p++ = 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001963
William Lallemandbddd33a2018-12-11 16:10:53 +01001964 /* unescape backslashes (\) */
1965 for (j = 0, k = 0; args[i][k]; k++) {
1966 if (args[i][k] == '\\') {
1967 if (args[i][k + 1] == '\\')
1968 k++;
1969 else
1970 continue;
1971 }
1972 args[i][j] = args[i][k];
1973 j++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001974 }
William Lallemandbddd33a2018-12-11 16:10:53 +01001975 args[i][j] = 0;
1976 i++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001977 }
1978
William Lallemandbddd33a2018-12-11 16:10:53 +01001979 argl = i;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001980
William Lallemandbddd33a2018-12-11 16:10:53 +01001981 for (; i < MAX_STATS_ARGS + 1; i++)
1982 args[i] = NULL;
1983
1984 wtrim = pcli_find_and_exec_kw(s, args, argl, errmsg, next_pid);
1985
1986 /* End of words are ending by \0, we need to replace the \0s by spaces
19871 before forwarding them */
1988 p = str;
William Lallemand3301f3e2018-12-13 09:05:48 +01001989 while (p < end-1) {
William Lallemandbddd33a2018-12-11 16:10:53 +01001990 if (*p == '\0')
1991 *p = ' ';
1992 p++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02001993 }
1994
William Lallemand3301f3e2018-12-13 09:05:48 +01001995 payload = strstr(str, PAYLOAD_PATTERN);
1996 if ((end - 1) == (payload + strlen(PAYLOAD_PATTERN))) {
1997 /* if the payload pattern is at the end */
1998 s->pcli_flags |= PCLI_F_PAYLOAD;
1999 ret = reql;
2000 }
2001
William Lallemandbddd33a2018-12-11 16:10:53 +01002002 *(end-1) = '\n';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002003
William Lallemandbddd33a2018-12-11 16:10:53 +01002004 if (wtrim > 0) {
2005 trim = &args[wtrim][0];
2006 if (trim == NULL) /* if this was the last word in the table */
2007 trim = end;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002008
William Lallemandbddd33a2018-12-11 16:10:53 +01002009 b_del(&req->buf, trim - str);
2010
William Lallemandb7ea1412018-12-13 09:05:47 +01002011 ret = end - trim;
William Lallemandbddd33a2018-12-11 16:10:53 +01002012 } else if (wtrim < 0) {
2013 /* parsing error */
2014 return -1;
William Lallemandb7ea1412018-12-13 09:05:47 +01002015 } else {
2016 /* the whole string */
2017 ret = end - str;
William Lallemandbddd33a2018-12-11 16:10:53 +01002018 }
2019
William Lallemandb7ea1412018-12-13 09:05:47 +01002020 if (ret > 1) {
2021 if (pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2022 goto end;
2023 } else if (pcli_has_level(s, ACCESS_LVL_OPER)) {
2024 ci_insert_line2(req, 0, "operator", strlen("operator"));
2025 ret += strlen("operator") + 2;
2026 } else if (pcli_has_level(s, ACCESS_LVL_USER)) {
2027 ci_insert_line2(req, 0, "user", strlen("user"));
2028 ret += strlen("user") + 2;
2029 }
2030 }
2031end:
William Lallemandbddd33a2018-12-11 16:10:53 +01002032
William Lallemandb7ea1412018-12-13 09:05:47 +01002033 return ret;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002034}
2035
2036int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
2037{
William Lallemandbddd33a2018-12-11 16:10:53 +01002038 int next_pid = -1;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002039 int to_forward;
William Lallemandbddd33a2018-12-11 16:10:53 +01002040 char *errmsg = NULL;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002041
William Lallemandb7ea1412018-12-13 09:05:47 +01002042 if ((s->pcli_flags & ACCESS_LVL_MASK) == ACCESS_LVL_NONE)
2043 s->pcli_flags |= strm_li(s)->bind_conf->level & ACCESS_LVL_MASK;
2044
William Lallemandcf62f7e2018-10-26 14:47:40 +02002045read_again:
2046 /* if the channel is closed for read, we won't receive any more data
2047 from the client, but we don't want to forward this close to the
2048 server */
2049 channel_dont_close(req);
2050
2051 /* We don't know yet to which server we will connect */
2052 channel_dont_connect(req);
2053
2054
2055 /* we are not waiting for a response, there is no more request and we
2056 * receive a close from the client, we can leave */
2057 if (!(ci_data(req)) && req->flags & CF_SHUTR) {
2058 channel_shutw_now(&s->res);
2059 s->req.analysers &= ~AN_REQ_WAIT_CLI;
2060 return 1;
2061 }
2062
2063 req->flags |= CF_READ_DONTWAIT;
2064
2065 /* need more data */
2066 if (!ci_data(req))
2067 return 0;
2068
2069 /* If there is data available for analysis, log the end of the idle time. */
2070 if (c_data(req) && s->logs.t_idle == -1)
2071 s->logs.t_idle = tv_ms_elapsed(&s->logs.tv_accept, &now) - s->logs.t_handshake;
2072
William Lallemandbddd33a2018-12-11 16:10:53 +01002073 to_forward = pcli_parse_request(s, req, &errmsg, &next_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002074 if (to_forward > 0) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002075 int target_pid;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002076 /* enough data */
2077
William Lallemandcf62f7e2018-10-26 14:47:40 +02002078 /* forward only 1 command */
2079 channel_forward(req, to_forward);
William Lallemandebf61802018-12-11 16:10:57 +01002080
William Lallemanddc12c2e2018-12-13 09:05:46 +01002081 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002082 /* we send only 1 command per request, and we write close after it */
2083 channel_shutw_now(req);
2084 } else {
2085 pcli_write_prompt(s);
2086 }
2087
2088 s->res.flags |= CF_WAKE_ONCE; /* need to be called again */
William Lallemandcf62f7e2018-10-26 14:47:40 +02002089
2090 /* remove the XFER_DATA analysers, which forwards all
2091 * the data, we don't want to forward the next requests
2092 * We need to add CF_FLT_ANALYZE to abort the forward too.
2093 */
2094 req->analysers &= ~(AN_REQ_FLT_XFER_DATA|AN_REQ_WAIT_CLI);
2095 req->analysers |= AN_REQ_FLT_END|CF_FLT_ANALYZE;
2096 s->res.analysers |= AN_RES_WAIT_CLI;
2097
William Lallemandebf61802018-12-11 16:10:57 +01002098 if (!(s->flags & SF_ASSIGNED)) {
2099 if (next_pid > -1)
2100 target_pid = next_pid;
2101 else
2102 target_pid = s->pcli_next_pid;
2103 /* we can connect now */
2104 s->target = pcli_pid_to_server(target_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002105
William Lallemandebf61802018-12-11 16:10:57 +01002106 s->flags |= (SF_DIRECT | SF_ASSIGNED);
2107 channel_auto_connect(req);
2108 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002109
2110 } else if (to_forward == 0) {
William Lallemandcf62f7e2018-10-26 14:47:40 +02002111 /* we trimmed things but we might have other commands to consume */
William Lallemandbddd33a2018-12-11 16:10:53 +01002112 pcli_write_prompt(s);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002113 goto read_again;
William Lallemandbddd33a2018-12-11 16:10:53 +01002114 } else if (to_forward == -1 && errmsg) {
2115 /* there was an error during the parsing */
2116 pcli_reply_and_close(s, errmsg);
2117 return 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002118 } else if (to_forward == -1 && channel_full(req, global.tune.maxrewrite)) {
2119 /* buffer is full and we didn't catch the end of a command */
2120 goto send_help;
2121 }
2122
2123 return 0;
2124
2125send_help:
2126 b_reset(&req->buf);
2127 b_putblk(&req->buf, "help\n", 5);
2128 goto read_again;
2129}
2130
2131int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
2132{
2133 struct proxy *fe = strm_fe(s);
2134 struct proxy *be = s->be;
2135
William Lallemand6b7cd0a2018-11-06 17:37:11 +01002136 if (rep->flags & CF_READ_ERROR) {
2137 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
2138 s->res.analysers &= ~AN_RES_WAIT_CLI;
2139 return 0;
2140 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002141 rep->flags |= CF_READ_DONTWAIT; /* try to get back here ASAP */
2142 rep->flags |= CF_NEVER_WAIT;
2143
2144 /* don't forward the close */
2145 channel_dont_close(&s->res);
2146 channel_dont_close(&s->req);
2147
William Lallemanddc12c2e2018-12-13 09:05:46 +01002148 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002149 s->req.analysers |= AN_REQ_WAIT_CLI;
2150 s->res.analysers &= ~AN_RES_WAIT_CLI;
2151 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2152 return 0;
2153 }
2154
William Lallemandcf62f7e2018-10-26 14:47:40 +02002155 /* forward the data */
2156 if (ci_data(rep)) {
2157 c_adv(rep, ci_data(rep));
2158 return 0;
2159 }
2160
2161 if ((rep->flags & (CF_SHUTR|CF_READ_NULL))) {
2162 /* stream cleanup */
2163
William Lallemand2f4ce202018-10-26 14:47:47 +02002164 pcli_write_prompt(s);
2165
William Lallemandcf62f7e2018-10-26 14:47:40 +02002166 s->si[1].flags |= SI_FL_NOLINGER | SI_FL_NOHALF;
2167 si_shutr(&s->si[1]);
2168 si_shutw(&s->si[1]);
2169
2170 /*
2171 * starting from there this the same code as
2172 * http_end_txn_clean_session().
2173 *
2174 * It allows to do frontend keepalive while reconnecting to a
2175 * new server for each request.
2176 */
2177
2178 if (s->flags & SF_BE_ASSIGNED) {
2179 HA_ATOMIC_SUB(&be->beconn, 1);
2180 if (unlikely(s->srv_conn))
2181 sess_change_server(s, NULL);
2182 }
2183
2184 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2185 stream_process_counters(s);
2186
2187 /* don't count other requests' data */
2188 s->logs.bytes_in -= ci_data(&s->req);
2189 s->logs.bytes_out -= ci_data(&s->res);
2190
2191 /* we may need to know the position in the queue */
2192 pendconn_free(s);
2193
2194 /* let's do a final log if we need it */
2195 if (!LIST_ISEMPTY(&fe->logformat) && s->logs.logwait &&
2196 !(s->flags & SF_MONITOR) &&
2197 (!(fe->options & PR_O_NULLNOLOG) || s->req.total)) {
2198 s->do_log(s);
2199 }
2200
2201 /* stop tracking content-based counters */
2202 stream_stop_content_counters(s);
2203 stream_update_time_stats(s);
2204
2205 s->logs.accept_date = date; /* user-visible date for logging */
2206 s->logs.tv_accept = now; /* corrected date for internal use */
2207 s->logs.t_handshake = 0; /* There are no handshake in keep alive connection. */
2208 s->logs.t_idle = -1;
2209 tv_zero(&s->logs.tv_request);
2210 s->logs.t_queue = -1;
2211 s->logs.t_connect = -1;
2212 s->logs.t_data = -1;
2213 s->logs.t_close = 0;
2214 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
2215 s->logs.srv_queue_pos = 0; /* we will get this number soon */
2216
2217 s->logs.bytes_in = s->req.total = ci_data(&s->req);
2218 s->logs.bytes_out = s->res.total = ci_data(&s->res);
2219
2220 stream_del_srv_conn(s);
2221 if (objt_server(s->target)) {
2222 if (s->flags & SF_CURR_SESS) {
2223 s->flags &= ~SF_CURR_SESS;
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002224 HA_ATOMIC_SUB(&__objt_server(s->target)->cur_sess, 1);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002225 }
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002226 if (may_dequeue_tasks(__objt_server(s->target), be))
2227 process_srv_queue(__objt_server(s->target));
William Lallemandcf62f7e2018-10-26 14:47:40 +02002228 }
2229
2230 s->target = NULL;
2231
2232 /* only release our endpoint if we don't intend to reuse the
2233 * connection.
2234 */
2235 if (!si_conn_ready(&s->si[1])) {
2236 si_release_endpoint(&s->si[1]);
2237 s->srv_conn = NULL;
2238 }
2239
2240 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
2241 s->si[1].err_type = SI_ET_NONE;
2242 s->si[1].conn_retries = 0; /* used for logging too */
2243 s->si[1].exp = TICK_ETERNITY;
2244 s->si[1].flags &= SI_FL_ISBACK | SI_FL_DONT_WAKE; /* we're in the context of process_stream */
2245 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);
2246 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);
2247 s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_ADDR_SET|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
2248 s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
2249 s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
2250 /* reinitialise the current rule list pointer to NULL. We are sure that
2251 * any rulelist match the NULL pointer.
2252 */
2253 s->current_rule_list = NULL;
2254
2255 s->be = strm_fe(s);
2256 s->logs.logwait = strm_fe(s)->to_log;
2257 s->logs.level = 0;
2258 stream_del_srv_conn(s);
2259 s->target = NULL;
2260 /* re-init store persistence */
2261 s->store_count = 0;
2262 s->uniq_id = global.req_count++;
2263
2264 s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */
2265
2266 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2267
2268 s->req.analysers |= AN_REQ_WAIT_CLI;
2269 s->res.analysers &= ~AN_RES_WAIT_CLI;
2270
2271 /* We must trim any excess data from the response buffer, because we
2272 * may have blocked an invalid response from a server that we don't
Joseph Herlant008b3ce2018-11-25 12:51:45 -08002273 * want to accidently forward once we disable the analysers, nor do
William Lallemandcf62f7e2018-10-26 14:47:40 +02002274 * we want those data to come along with next response. A typical
2275 * example of such data would be from a buggy server responding to
2276 * a HEAD with some data, or sending more than the advertised
2277 * content-length.
2278 */
2279 if (unlikely(ci_data(&s->res)))
2280 b_set_data(&s->res.buf, co_data(&s->res));
2281
2282 /* Now we can realign the response buffer */
2283 c_realign_if_empty(&s->res);
2284
2285 s->req.rto = strm_fe(s)->timeout.client;
2286 s->req.wto = TICK_ETERNITY;
2287
2288 s->res.rto = TICK_ETERNITY;
2289 s->res.wto = strm_fe(s)->timeout.client;
2290
2291 s->req.rex = TICK_ETERNITY;
2292 s->req.wex = TICK_ETERNITY;
2293 s->req.analyse_exp = TICK_ETERNITY;
2294 s->res.rex = TICK_ETERNITY;
2295 s->res.wex = TICK_ETERNITY;
2296 s->res.analyse_exp = TICK_ETERNITY;
2297 s->si[1].hcto = TICK_ETERNITY;
2298
2299 /* we're removing the analysers, we MUST re-enable events detection.
2300 * We don't enable close on the response channel since it's either
2301 * already closed, or in keep-alive with an idle connection handler.
2302 */
2303 channel_auto_read(&s->req);
2304 channel_auto_close(&s->req);
2305 channel_auto_read(&s->res);
2306
2307
2308 return 1;
2309 }
2310 return 0;
2311}
2312
William Lallemand8a022572018-10-26 14:47:35 +02002313/*
2314 * The mworker functions are used to initialize the CLI in the master process
2315 */
2316
William Lallemand309dc9a2018-10-26 14:47:45 +02002317 /*
2318 * Stop the mworker proxy
2319 */
2320void mworker_cli_proxy_stop()
2321{
William Lallemand550db6d2018-11-06 17:37:12 +01002322 if (mworker_proxy)
2323 stop_proxy(mworker_proxy);
William Lallemand309dc9a2018-10-26 14:47:45 +02002324}
2325
William Lallemand8a022572018-10-26 14:47:35 +02002326/*
2327 * Create the mworker CLI proxy
2328 */
2329int mworker_cli_proxy_create()
2330{
2331 struct mworker_proc *child;
William Lallemand744a0892018-11-22 16:46:51 +01002332 char *msg = NULL;
2333 char *errmsg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002334
2335 mworker_proxy = calloc(1, sizeof(*mworker_proxy));
2336 if (!mworker_proxy)
2337 return -1;
2338
2339 init_new_proxy(mworker_proxy);
2340 mworker_proxy->next = proxies_list;
2341 proxies_list = mworker_proxy;
2342 mworker_proxy->id = strdup("MASTER");
William Lallemandcf62f7e2018-10-26 14:47:40 +02002343 mworker_proxy->mode = PR_MODE_CLI;
William Lallemand8a022572018-10-26 14:47:35 +02002344 mworker_proxy->state = PR_STNEW;
2345 mworker_proxy->last_change = now.tv_sec;
2346 mworker_proxy->cap = PR_CAP_LISTEN; /* this is a listen section */
2347 mworker_proxy->maxconn = 10; /* default to 10 concurrent connections */
2348 mworker_proxy->timeout.client = 0; /* no timeout */
2349 mworker_proxy->conf.file = strdup("MASTER");
2350 mworker_proxy->conf.line = 0;
2351 mworker_proxy->accept = frontend_accept;
2352 mworker_proxy-> lbprm.algo = BE_LB_ALGO_NONE;
2353
2354 /* Does not init the default target the CLI applet, but must be done in
2355 * the request parsing code */
2356 mworker_proxy->default_target = NULL;
2357
2358 /* the check_config_validity() will get an ID for the proxy */
2359 mworker_proxy->uuid = -1;
2360
2361 proxy_store_name(mworker_proxy);
2362
2363 /* create all servers using the mworker_proc list */
2364 list_for_each_entry(child, &proc_list, list) {
William Lallemand8a022572018-10-26 14:47:35 +02002365 struct server *newsrv = NULL;
2366 struct sockaddr_storage *sk;
2367 int port1, port2, port;
2368 struct protocol *proto;
William Lallemand8a022572018-10-26 14:47:35 +02002369
2370 newsrv = new_server(mworker_proxy);
2371 if (!newsrv)
William Lallemand744a0892018-11-22 16:46:51 +01002372 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002373
2374 /* we don't know the new pid yet */
2375 if (child->pid == -1)
2376 memprintf(&msg, "cur-%d", child->relative_pid);
2377 else
2378 memprintf(&msg, "old-%d", child->pid);
2379
2380 newsrv->next = mworker_proxy->srv;
2381 mworker_proxy->srv = newsrv;
2382 newsrv->conf.file = strdup(msg);
2383 newsrv->id = strdup(msg);
2384 newsrv->conf.line = 0;
2385
2386 memprintf(&msg, "sockpair@%d", child->ipc_fd[0]);
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002387 if ((sk = str2sa_range(msg, &port, &port1, &port2, &errmsg, NULL, NULL, 0)) == 0) {
William Lallemand744a0892018-11-22 16:46:51 +01002388 goto error;
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002389 }
2390 free(msg);
2391 msg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002392
2393 proto = protocol_by_family(sk->ss_family);
2394 if (!proto || !proto->connect) {
William Lallemand744a0892018-11-22 16:46:51 +01002395 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002396 }
2397
2398 /* no port specified */
2399 newsrv->flags |= SRV_F_MAPPORTS;
2400 newsrv->addr = *sk;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002401 /* don't let the server participate to load balancing */
2402 newsrv->iweight = 0;
2403 newsrv->uweight = 0;
William Lallemand8a022572018-10-26 14:47:35 +02002404 srv_lb_commit_status(newsrv);
William Lallemand291810d2018-10-26 14:47:38 +02002405
2406 child->srv = newsrv;
William Lallemand8a022572018-10-26 14:47:35 +02002407 }
2408 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002409
2410error:
2411 ha_alert("%s\n", errmsg);
2412
2413 list_for_each_entry(child, &proc_list, list) {
2414 free((char *)child->srv->conf.file); /* cast because of const char * */
2415 free(child->srv->id);
2416 free(child->srv);
2417 child->srv = NULL;
2418 }
2419 free(mworker_proxy->id);
2420 free(mworker_proxy->conf.file);
2421 free(mworker_proxy);
2422 mworker_proxy = NULL;
2423 free(errmsg);
2424 free(msg);
2425
2426 return -1;
William Lallemand8a022572018-10-26 14:47:35 +02002427}
Olivier Houchardf886e342017-04-05 22:24:59 +02002428
William Lallemandce83b4a2018-10-26 14:47:30 +02002429/*
William Lallemande7361152018-10-26 14:47:36 +02002430 * Create a new listener for the master CLI proxy
2431 */
2432int mworker_cli_proxy_new_listener(char *line)
2433{
2434 struct bind_conf *bind_conf;
2435 struct listener *l;
2436 char *err = NULL;
2437 char *args[MAX_LINE_ARGS + 1];
2438 int arg;
2439 int cur_arg;
2440
2441 arg = 0;
2442 args[0] = line;
2443
2444 /* args is a bind configuration with spaces replaced by commas */
2445 while (*line && arg < MAX_LINE_ARGS) {
2446
2447 if (*line == ',') {
2448 *line++ = '\0';
2449 while (*line == ',')
2450 line++;
2451 args[++arg] = line;
2452 }
2453 line++;
2454 }
2455
2456 args[++arg] = "\0";
2457
2458 bind_conf = bind_conf_alloc(mworker_proxy, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002459 if (!bind_conf)
2460 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002461
2462 bind_conf->level &= ~ACCESS_LVL_MASK;
2463 bind_conf->level |= ACCESS_LVL_ADMIN;
2464
2465 if (!str2listener(args[0], mworker_proxy, bind_conf, "master-socket", 0, &err)) {
2466 ha_alert("Cannot create the listener of the master CLI\n");
William Lallemand744a0892018-11-22 16:46:51 +01002467 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002468 }
2469
2470 cur_arg = 1;
2471
2472 while (*args[cur_arg]) {
2473 static int bind_dumped;
2474 struct bind_kw *kw;
2475
2476 kw = bind_find_kw(args[cur_arg]);
2477 if (kw) {
2478 if (!kw->parse) {
2479 memprintf(&err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
2480 args[0], args[1], args[cur_arg]);
2481 goto err;
2482 }
2483
2484 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, &err) != 0) {
2485 if (err)
2486 memprintf(&err, "'%s %s' : '%s'", args[0], args[1], err);
2487 else
2488 memprintf(&err, "'%s %s' : error encountered while processing '%s'",
2489 args[0], args[1], args[cur_arg]);
2490 goto err;
2491 }
2492
2493 cur_arg += 1 + kw->skip;
2494 continue;
2495 }
2496
2497 if (!bind_dumped) {
2498 bind_dump_kws(&err);
2499 indent_msg(&err, 4);
2500 bind_dumped = 1;
2501 }
2502
2503 memprintf(&err, "'%s %s' : unknown keyword '%s'.%s%s",
2504 args[0], args[1], args[cur_arg],
2505 err ? " Registered keywords :" : "", err ? err : "");
2506 goto err;
2507 }
2508
2509
2510 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemande7361152018-10-26 14:47:36 +02002511 l->accept = session_accept_fd;
2512 l->default_target = mworker_proxy->default_target;
2513 /* don't make the peers subject to global limits and don't close it in the master */
2514 l->options |= (LI_O_UNLIMITED|LI_O_MWORKER); /* we are keeping this FD in the master */
2515 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002516 global.maxsock++; /* for the listening socket */
William Lallemande7361152018-10-26 14:47:36 +02002517 }
Willy Tarreau18215cb2019-02-27 16:25:28 +01002518 global.maxsock += mworker_proxy->maxconn;
William Lallemande7361152018-10-26 14:47:36 +02002519
2520 return 0;
2521
2522err:
2523 ha_alert("%s\n", err);
William Lallemand744a0892018-11-22 16:46:51 +01002524 free(err);
2525 free(bind_conf);
William Lallemande7361152018-10-26 14:47:36 +02002526 return -1;
2527
2528}
2529
2530/*
William Lallemandce83b4a2018-10-26 14:47:30 +02002531 * Create a new CLI socket using a socketpair for a worker process
2532 * <mworker_proc> is the process structure, and <proc> is the process number
2533 */
2534int mworker_cli_sockpair_new(struct mworker_proc *mworker_proc, int proc)
2535{
2536 struct bind_conf *bind_conf;
2537 struct listener *l;
2538 char *path = NULL;
2539 char *err = NULL;
2540
2541 /* master pipe to ensure the master is still alive */
2542 if (socketpair(AF_UNIX, SOCK_STREAM, 0, mworker_proc->ipc_fd) < 0) {
2543 ha_alert("Cannot create worker socketpair.\n");
2544 return -1;
2545 }
2546
2547 /* XXX: we might want to use a separate frontend at some point */
2548 if (!global.stats_fe) {
2549 if ((global.stats_fe = alloc_stats_fe("GLOBAL", "master-socket", 0)) == NULL) {
2550 ha_alert("out of memory trying to allocate the stats frontend");
William Lallemand744a0892018-11-22 16:46:51 +01002551 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002552 }
2553 }
2554
2555 bind_conf = bind_conf_alloc(global.stats_fe, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002556 if (!bind_conf)
2557 goto error;
2558
William Lallemandce83b4a2018-10-26 14:47:30 +02002559 bind_conf->level &= ~ACCESS_LVL_MASK;
2560 bind_conf->level |= ACCESS_LVL_ADMIN; /* TODO: need to lower the rights with a CLI keyword*/
2561
2562 bind_conf->bind_proc = 1UL << proc;
2563 global.stats_fe->bind_proc = 0; /* XXX: we should be careful with that, it can be removed by configuration */
2564
2565 if (!memprintf(&path, "sockpair@%d", mworker_proc->ipc_fd[1])) {
2566 ha_alert("Cannot allocate listener.\n");
William Lallemand744a0892018-11-22 16:46:51 +01002567 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002568 }
2569
2570 if (!str2listener(path, global.stats_fe, bind_conf, "master-socket", 0, &err)) {
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002571 free(path);
William Lallemandce83b4a2018-10-26 14:47:30 +02002572 ha_alert("Cannot create a CLI sockpair listener for process #%d\n", proc);
William Lallemand744a0892018-11-22 16:46:51 +01002573 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002574 }
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002575 free(path);
2576 path = NULL;
William Lallemandce83b4a2018-10-26 14:47:30 +02002577
2578 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemandce83b4a2018-10-26 14:47:30 +02002579 l->accept = session_accept_fd;
2580 l->default_target = global.stats_fe->default_target;
William Lallemanda3372292018-11-16 16:57:22 +01002581 l->options |= (LI_O_UNLIMITED | LI_O_NOSTOP);
William Lallemandce83b4a2018-10-26 14:47:30 +02002582 /* it's a sockpair but we don't want to keep the fd in the master */
2583 l->options &= ~LI_O_INHERITED;
2584 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002585 global.maxsock++; /* for the listening socket */
William Lallemandce83b4a2018-10-26 14:47:30 +02002586 }
2587
2588 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002589
2590error:
2591 close(mworker_proc->ipc_fd[0]);
2592 close(mworker_proc->ipc_fd[1]);
2593 free(err);
2594
2595 return -1;
William Lallemandce83b4a2018-10-26 14:47:30 +02002596}
2597
William Lallemand74c24fb2016-11-21 17:18:36 +01002598static struct applet cli_applet = {
2599 .obj_type = OBJ_TYPE_APPLET,
2600 .name = "<CLI>", /* used for logging */
2601 .fct = cli_io_handler,
2602 .release = cli_release_handler,
2603};
2604
Willy Tarreau0a739292016-11-22 20:21:23 +01002605/* register cli keywords */
2606static struct cli_kw_list cli_kws = {{ },{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002607 { { "help", NULL }, NULL, cli_parse_simple, NULL },
2608 { { "prompt", NULL }, NULL, cli_parse_simple, NULL },
2609 { { "quit", NULL }, NULL, cli_parse_simple, NULL },
Willy Tarreau2af99412016-11-23 11:10:59 +01002610 { { "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 +01002611 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002612 { { "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 +01002613 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002614 { { "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 +02002615 { { "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 +01002616 { { "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 +02002617 { { "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 +01002618 { { "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 +01002619 { { "operator", NULL }, "operator : lower the level of the current CLI session to operator", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
2620 { { "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 +02002621 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002622 {{},}
2623}};
2624
Willy Tarreau0108d902018-11-25 19:14:37 +01002625INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
2626
William Lallemand74c24fb2016-11-21 17:18:36 +01002627static struct cfg_kw_list cfg_kws = {ILH, {
2628 { CFG_GLOBAL, "stats", stats_parse_global },
2629 { 0, NULL, NULL },
2630}};
2631
Willy Tarreau0108d902018-11-25 19:14:37 +01002632INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
2633
William Lallemand74c24fb2016-11-21 17:18:36 +01002634static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02002635 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
2636 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002637 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01002638 { NULL, NULL, 0 },
2639}};
2640
Willy Tarreau0108d902018-11-25 19:14:37 +01002641INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01002642
2643/*
2644 * Local variables:
2645 * c-indent-level: 8
2646 * c-basic-offset: 8
2647 * End:
2648 */