blob: b7d428d8a73a3e0a801c77c195dc297a73033293 [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>
33#include <common/memory.h>
34#include <common/mini-clist.h>
35#include <common/standard.h>
36#include <common/ticks.h>
37#include <common/time.h>
38#include <common/uri_auth.h>
39#include <common/version.h>
40#include <common/base64.h>
41
42#include <types/applet.h>
William Lallemand9ed62032016-11-21 17:49:11 +010043#include <types/cli.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010044#include <types/global.h>
45#include <types/dns.h>
William Lallemand9ed62032016-11-21 17:49:11 +010046#include <types/stats.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010047
48#include <proto/backend.h>
49#include <proto/channel.h>
50#include <proto/checks.h>
51#include <proto/compression.h>
William Lallemand9ed62032016-11-21 17:49:11 +010052#include <proto/stats.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010053#include <proto/fd.h>
54#include <proto/freq_ctr.h>
55#include <proto/frontend.h>
56#include <proto/log.h>
57#include <proto/pattern.h>
58#include <proto/pipe.h>
59#include <proto/listener.h>
60#include <proto/map.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010061#include <proto/proxy.h>
62#include <proto/sample.h>
63#include <proto/session.h>
64#include <proto/stream.h>
65#include <proto/server.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010066#include <proto/stream_interface.h>
67#include <proto/task.h>
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +020068#include <proto/proto_udp.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010069
William Lallemand74c24fb2016-11-21 17:18:36 +010070static struct applet cli_applet;
71
72static const char stats_sock_usage_msg[] =
73 "Unknown command. Please enter one of the following commands only :\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010074 " help : this message\n"
75 " prompt : toggle interactive mode with prompt\n"
76 " quit : disconnect\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010077 "";
78
79static const char stats_permission_denied_msg[] =
80 "Permission denied\n"
81 "";
82
83
Christopher Faulet1bc04c72017-10-29 20:14:08 +010084static THREAD_LOCAL char *dynamic_usage_msg = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +010085
86/* List head of cli keywords */
87static struct cli_kw_list cli_keywords = {
88 .list = LIST_HEAD_INIT(cli_keywords.list)
89};
90
91extern const char *stat_status_codes[];
92
93char *cli_gen_usage_msg()
94{
95 struct cli_kw_list *kw_list;
96 struct cli_kw *kw;
97 struct chunk *tmp = get_trash_chunk();
98 struct chunk out;
99
100 free(dynamic_usage_msg);
101 dynamic_usage_msg = NULL;
102
103 if (LIST_ISEMPTY(&cli_keywords.list))
104 return NULL;
105
106 chunk_reset(tmp);
107 chunk_strcat(tmp, stats_sock_usage_msg);
108 list_for_each_entry(kw_list, &cli_keywords.list, list) {
109 kw = &kw_list->kw[0];
110 while (kw->usage) {
111 chunk_appendf(tmp, " %s\n", kw->usage);
112 kw++;
113 }
114 }
115 chunk_init(&out, NULL, 0);
116 chunk_dup(&out, tmp);
117 dynamic_usage_msg = out.str;
118 return dynamic_usage_msg;
119}
120
121struct cli_kw* cli_find_kw(char **args)
122{
123 struct cli_kw_list *kw_list;
124 struct cli_kw *kw;/* current cli_kw */
125 char **tmp_args;
126 const char **tmp_str_kw;
127 int found = 0;
128
129 if (LIST_ISEMPTY(&cli_keywords.list))
130 return NULL;
131
132 list_for_each_entry(kw_list, &cli_keywords.list, list) {
133 kw = &kw_list->kw[0];
134 while (*kw->str_kw) {
135 tmp_args = args;
136 tmp_str_kw = kw->str_kw;
137 while (*tmp_str_kw) {
138 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
139 found = 1;
140 } else {
141 found = 0;
142 break;
143 }
144 tmp_args++;
145 tmp_str_kw++;
146 }
147 if (found)
148 return (kw);
149 kw++;
150 }
151 }
152 return NULL;
153}
154
155void cli_register_kw(struct cli_kw_list *kw_list)
156{
157 LIST_ADDQ(&cli_keywords.list, &kw_list->list);
158}
159
160
161/* allocate a new stats frontend named <name>, and return it
162 * (or NULL in case of lack of memory).
163 */
164static struct proxy *alloc_stats_fe(const char *name, const char *file, int line)
165{
166 struct proxy *fe;
167
168 fe = calloc(1, sizeof(*fe));
169 if (!fe)
170 return NULL;
171
172 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100173 fe->next = proxies_list;
174 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100175 fe->last_change = now.tv_sec;
176 fe->id = strdup("GLOBAL");
177 fe->cap = PR_CAP_FE;
178 fe->maxconn = 10; /* default to 10 concurrent connections */
179 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
180 fe->conf.file = strdup(file);
181 fe->conf.line = line;
182 fe->accept = frontend_accept;
183 fe->default_target = &cli_applet.obj_type;
184
185 /* the stats frontend is the only one able to assign ID #0 */
186 fe->conf.id.key = fe->uuid = 0;
187 eb32_insert(&used_proxy_id, &fe->conf.id);
188 return fe;
189}
190
191/* This function parses a "stats" statement in the "global" section. It returns
192 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
193 * error message into the <err> buffer which will be preallocated. The trailing
194 * '\n' must not be written. The function must be called with <args> pointing to
195 * the first word after "stats".
196 */
197static int stats_parse_global(char **args, int section_type, struct proxy *curpx,
198 struct proxy *defpx, const char *file, int line,
199 char **err)
200{
201 struct bind_conf *bind_conf;
202 struct listener *l;
203
204 if (!strcmp(args[1], "socket")) {
205 int cur_arg;
206
207 if (*args[2] == 0) {
208 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
209 return -1;
210 }
211
212 if (!global.stats_fe) {
213 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
214 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
215 return -1;
216 }
217 }
218
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100219 bind_conf = bind_conf_alloc(global.stats_fe, file, line, args[2], xprt_get(XPRT_RAW));
William Lallemand07a62f72017-05-24 00:57:40 +0200220 bind_conf->level &= ~ACCESS_LVL_MASK;
221 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100222
223 if (!str2listener(args[2], global.stats_fe, bind_conf, file, line, err)) {
224 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
225 file, line, args[0], args[1], err && *err ? *err : "error");
226 return -1;
227 }
228
229 cur_arg = 3;
230 while (*args[cur_arg]) {
231 static int bind_dumped;
232 struct bind_kw *kw;
233
234 kw = bind_find_kw(args[cur_arg]);
235 if (kw) {
236 if (!kw->parse) {
237 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
238 args[0], args[1], args[cur_arg]);
239 return -1;
240 }
241
242 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, err) != 0) {
243 if (err && *err)
244 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
245 else
246 memprintf(err, "'%s %s' : error encountered while processing '%s'",
247 args[0], args[1], args[cur_arg]);
248 return -1;
249 }
250
251 cur_arg += 1 + kw->skip;
252 continue;
253 }
254
255 if (!bind_dumped) {
256 bind_dump_kws(err);
257 indent_msg(err, 4);
258 bind_dumped = 1;
259 }
260
261 memprintf(err, "'%s %s' : unknown keyword '%s'.%s%s",
262 args[0], args[1], args[cur_arg],
263 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
264 return -1;
265 }
266
267 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
268 l->maxconn = global.stats_fe->maxconn;
269 l->backlog = global.stats_fe->backlog;
270 l->accept = session_accept_fd;
William Lallemand74c24fb2016-11-21 17:18:36 +0100271 l->default_target = global.stats_fe->default_target;
272 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
273 l->nice = -64; /* we want to boost priority for local stats */
274 global.maxsock += l->maxconn;
275 }
276 }
277 else if (!strcmp(args[1], "timeout")) {
278 unsigned timeout;
279 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
280
281 if (res) {
282 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
283 return -1;
284 }
285
286 if (!timeout) {
287 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
288 return -1;
289 }
290 if (!global.stats_fe) {
291 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
292 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
293 return -1;
294 }
295 }
296 global.stats_fe->timeout.client = MS_TO_TICKS(timeout);
297 }
298 else if (!strcmp(args[1], "maxconn")) {
299 int maxconn = atol(args[2]);
300
301 if (maxconn <= 0) {
302 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
303 return -1;
304 }
305
306 if (!global.stats_fe) {
307 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
308 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
309 return -1;
310 }
311 }
312 global.stats_fe->maxconn = maxconn;
313 }
314 else if (!strcmp(args[1], "bind-process")) { /* enable the socket only on some processes */
315 int cur_arg = 2;
316 unsigned long set = 0;
317
318 if (!global.stats_fe) {
319 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
320 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
321 return -1;
322 }
323 }
324
325 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100326 if (strcmp(args[cur_arg], "all") == 0) {
327 set = 0;
328 break;
329 }
Christopher Faulet26028f62017-11-22 15:01:51 +0100330 if (parse_process_number(args[cur_arg], &set, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100331 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100332 return -1;
333 }
334 cur_arg++;
335 }
336 global.stats_fe->bind_proc = set;
337 }
338 else {
339 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
340 return -1;
341 }
342 return 0;
343}
344
Willy Tarreaude57a572016-11-23 17:01:39 +0100345/* Verifies that the CLI at least has a level at least as high as <level>
346 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
347 * failure, an error message is prepared and the appctx's state is adjusted
348 * to print it so that a return 1 is enough to abort any processing.
349 */
350int cli_has_level(struct appctx *appctx, int level)
351{
352 struct stream_interface *si = appctx->owner;
353 struct stream *s = si_strm(si);
354
William Lallemand07a62f72017-05-24 00:57:40 +0200355 if ((strm_li(s)->bind_conf->level & ACCESS_LVL_MASK) < level) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200356 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreaude57a572016-11-23 17:01:39 +0100357 appctx->ctx.cli.msg = stats_permission_denied_msg;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100358 appctx->st0 = CLI_ST_PRINT;
Willy Tarreaude57a572016-11-23 17:01:39 +0100359 return 0;
360 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100361 return 1;
362}
363
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200364/* Returns severity_output for the current session if set, or default for the socket */
365static int cli_get_severity_output(struct appctx *appctx)
366{
367 if (appctx->cli_severity_output)
368 return appctx->cli_severity_output;
369 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
370}
William Lallemand74c24fb2016-11-21 17:18:36 +0100371
Willy Tarreau41908562016-11-24 16:23:38 +0100372/* Processes the CLI interpreter on the stats socket. This function is called
373 * from the CLI's IO handler running in an appctx context. The function returns 1
374 * if the request was understood, otherwise zero. It is called with appctx->st0
375 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
376 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
377 * have its own I/O handler called again. Most of the time, parsers will only
378 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100379 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
380 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100381 */
Willy Tarreau41908562016-11-24 16:23:38 +0100382static int cli_parse_request(struct appctx *appctx, char *line)
William Lallemand74c24fb2016-11-21 17:18:36 +0100383{
William Lallemand74c24fb2016-11-21 17:18:36 +0100384 char *args[MAX_STATS_ARGS + 1];
385 struct cli_kw *kw;
386 int arg;
387 int i, j;
388
389 while (isspace((unsigned char)*line))
390 line++;
391
392 arg = 0;
393 args[arg] = line;
394
395 while (*line && arg < MAX_STATS_ARGS) {
396 if (*line == '\\') {
397 line++;
398 if (*line == '\0')
399 break;
400 }
401 else if (isspace((unsigned char)*line)) {
402 *line++ = '\0';
403
404 while (isspace((unsigned char)*line))
405 line++;
406
407 args[++arg] = line;
408 continue;
409 }
410
411 line++;
412 }
413
414 while (++arg <= MAX_STATS_ARGS)
415 args[arg] = line;
416
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100417 /* unescape '\' */
William Lallemand74c24fb2016-11-21 17:18:36 +0100418 arg = 0;
Aurélien Nephtali6a61e962018-03-16 10:11:06 +0100419 while (arg <= MAX_STATS_ARGS && *args[arg] != '\0') {
William Lallemand74c24fb2016-11-21 17:18:36 +0100420 j = 0;
421 for (i=0; args[arg][i] != '\0'; i++) {
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100422 if (args[arg][i] == '\\') {
423 if (args[arg][i+1] == '\\')
424 i++;
425 else
426 continue;
427 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100428 args[arg][j] = args[arg][i];
429 j++;
430 }
431 args[arg][j] = '\0';
432 arg++;
433 }
434
Willy Tarreau41908562016-11-24 16:23:38 +0100435 appctx->st2 = 0;
Willy Tarreaua2d58722016-12-16 12:37:03 +0100436 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
Willy Tarreau41908562016-11-24 16:23:38 +0100437
438 kw = cli_find_kw(args);
Willy Tarreaueaffde32016-12-16 17:59:25 +0100439 if (!kw)
Willy Tarreau41908562016-11-24 16:23:38 +0100440 return 0;
441
442 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200443 appctx->io_release = kw->io_release;
444 /* kw->parse could set its own io_handler or ip_release handler */
Willy Tarreaueaffde32016-12-16 17:59:25 +0100445 if ((!kw->parse || kw->parse(args, appctx, kw->private) == 0) && appctx->io_handler) {
Willy Tarreau41908562016-11-24 16:23:38 +0100446 appctx->st0 = CLI_ST_CALLBACK;
William Lallemand74c24fb2016-11-21 17:18:36 +0100447 }
Willy Tarreau41908562016-11-24 16:23:38 +0100448 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100449}
450
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200451/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
452static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
453{
454 struct chunk *tmp;
455
456 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200457 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200458
459 tmp = get_trash_chunk();
460 chunk_reset(tmp);
461
462 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100463 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200464 chunk_printf(tmp, "[%d]: ", severity);
465 }
466 else {
467 switch (severity_output) {
468 case CLI_SEVERITY_NUMBER:
469 chunk_printf(tmp, "[%d]: ", severity);
470 break;
471 case CLI_SEVERITY_STRING:
472 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
473 break;
474 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100475 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200476 }
477 }
478 chunk_appendf(tmp, "%s", msg);
479
Willy Tarreau06d80a92017-10-19 14:32:15 +0200480 return ci_putblk(chn, tmp->str, strlen(tmp->str));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200481}
482
William Lallemand74c24fb2016-11-21 17:18:36 +0100483/* This I/O handler runs as an applet embedded in a stream interface. It is
484 * used to processes I/O from/to the stats unix socket. The system relies on a
485 * state machine handling requests and various responses. We read a request,
486 * then we process it and send the response, and we possibly display a prompt.
487 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100488 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100489 * or not.
490 */
491static void cli_io_handler(struct appctx *appctx)
492{
493 struct stream_interface *si = appctx->owner;
494 struct channel *req = si_oc(si);
495 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200496 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100497 int reql;
498 int len;
499
500 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
501 goto out;
502
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100503 /* Check if the input buffer is avalaible. */
504 if (res->buf->size == 0) {
505 si_applet_cant_put(si);
506 goto out;
507 }
508
William Lallemand74c24fb2016-11-21 17:18:36 +0100509 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100510 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100511 /* Stats output not initialized yet */
512 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200513 /* reset severity to default at init */
514 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100515 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100516 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100517 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100518 /* Let's close for real now. We just close the request
519 * side, the conditions below will complete if needed.
520 */
521 si_shutw(si);
522 break;
523 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100524 else if (appctx->st0 == CLI_ST_GETREQ) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100525 /* ensure we have some output room left in the event we
526 * would want to return some info right after parsing.
527 */
528 if (buffer_almost_full(si_ib(si))) {
529 si_applet_cant_put(si);
530 break;
531 }
532
Willy Tarreau06d80a92017-10-19 14:32:15 +0200533 reql = co_getline(si_oc(si), trash.str, trash.size);
William Lallemand74c24fb2016-11-21 17:18:36 +0100534 if (reql <= 0) { /* closed or EOL not found */
535 if (reql == 0)
536 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100537 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100538 continue;
539 }
540
541 /* seek for a possible unescaped semi-colon. If we find
542 * one, we replace it with an LF and skip only this part.
543 */
544 for (len = 0; len < reql; len++) {
545 if (trash.str[len] == '\\') {
546 len++;
547 continue;
548 }
549 if (trash.str[len] == ';') {
550 trash.str[len] = '\n';
551 reql = len + 1;
552 break;
553 }
554 }
555
556 /* now it is time to check that we have a full line,
557 * remove the trailing \n and possibly \r, then cut the
558 * line.
559 */
560 len = reql - 1;
561 if (trash.str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100562 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100563 continue;
564 }
565
566 if (len && trash.str[len-1] == '\r')
567 len--;
568
569 trash.str[len] = '\0';
570
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100571 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100572 if (len) {
573 if (strcmp(trash.str, "quit") == 0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100574 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100575 continue;
576 }
577 else if (strcmp(trash.str, "prompt") == 0)
578 appctx->st1 = !appctx->st1;
579 else if (strcmp(trash.str, "help") == 0 ||
Willy Tarreau41908562016-11-24 16:23:38 +0100580 !cli_parse_request(appctx, trash.str)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100581 cli_gen_usage_msg();
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200582 if (dynamic_usage_msg) {
583 appctx->ctx.cli.severity = LOG_INFO;
William Lallemand74c24fb2016-11-21 17:18:36 +0100584 appctx->ctx.cli.msg = dynamic_usage_msg;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200585 }
586 else {
587 appctx->ctx.cli.severity = LOG_INFO;
William Lallemand74c24fb2016-11-21 17:18:36 +0100588 appctx->ctx.cli.msg = stats_sock_usage_msg;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200589 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100590 appctx->st0 = CLI_ST_PRINT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100591 }
592 /* NB: stats_sock_parse_request() may have put
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100593 * another CLI_ST_O_* into appctx->st0.
William Lallemand74c24fb2016-11-21 17:18:36 +0100594 */
595 }
596 else if (!appctx->st1) {
597 /* if prompt is disabled, print help on empty lines,
598 * so that the user at least knows how to enable
599 * prompt and find help.
600 */
601 cli_gen_usage_msg();
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200602 if (dynamic_usage_msg) {
603 appctx->ctx.cli.severity = LOG_INFO;
William Lallemand74c24fb2016-11-21 17:18:36 +0100604 appctx->ctx.cli.msg = dynamic_usage_msg;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200605 }
606 else {
607 appctx->ctx.cli.severity = LOG_INFO;
William Lallemand74c24fb2016-11-21 17:18:36 +0100608 appctx->ctx.cli.msg = stats_sock_usage_msg;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200609 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100610 appctx->st0 = CLI_ST_PRINT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100611 }
612
613 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200614 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100615 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
616 }
617 else { /* output functions */
618 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100619 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100620 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100621 case CLI_ST_PRINT:
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200622 if (cli_output_msg(res, appctx->ctx.cli.msg, appctx->ctx.cli.severity,
623 cli_get_severity_output(appctx)) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100624 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100625 else
626 si_applet_cant_put(si);
627 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100628 case CLI_ST_PRINT_FREE:
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200629 if (cli_output_msg(res, appctx->ctx.cli.err, LOG_ERR, cli_get_severity_output(appctx)) != -1) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100630 free(appctx->ctx.cli.err);
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100631 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100632 }
633 else
634 si_applet_cant_put(si);
635 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100636 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100637 if (appctx->io_handler)
638 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100639 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100640 if (appctx->io_release) {
641 appctx->io_release(appctx);
642 appctx->io_release = NULL;
643 }
644 }
645 break;
646 default: /* abnormal state */
647 si->flags |= SI_FL_ERR;
648 break;
649 }
650
651 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100652 if (appctx->st0 == CLI_ST_PROMPT) {
Willy Tarreau06d80a92017-10-19 14:32:15 +0200653 if (ci_putstr(si_ic(si), appctx->st1 ? "\n> " : "\n") != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100654 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100655 else
656 si_applet_cant_put(si);
657 }
658
659 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100660 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100661 break;
662
663 /* Now we close the output if one of the writers did so,
664 * or if we're not in interactive mode and the request
665 * buffer is empty. This still allows pipelined requests
666 * to be sent in non-interactive mode.
667 */
668 if ((res->flags & (CF_SHUTW|CF_SHUTW_NOW)) || (!appctx->st1 && !req->buf->o)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100669 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100670 continue;
671 }
672
673 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100674 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100675 }
676 }
677
678 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
679 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
680 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
681 /* Other side has closed, let's abort if we have no more processing to do
682 * and nothing more to consume. This is comparable to a broken pipe, so
683 * we forward the close to the request side so that it flows upstream to
684 * the client.
685 */
686 si_shutw(si);
687 }
688
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100689 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100690 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
691 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
692 /* We have no more processing to do, and nothing more to send, and
693 * the client side has closed. So we'll forward this state downstream
694 * on the response buffer.
695 */
696 si_shutr(si);
697 res->flags |= CF_READ_NULL;
698 }
699
700 out:
701 DPRINTF(stderr, "%s@%d: st=%d, rqf=%x, rpf=%x, rqh=%d, rqs=%d, rh=%d, rs=%d\n",
702 __FUNCTION__, __LINE__,
703 si->state, req->flags, res->flags, req->buf->i, req->buf->o, res->buf->i, res->buf->o);
704}
705
William Lallemand74c24fb2016-11-21 17:18:36 +0100706/* This is called when the stream interface is closed. For instance, upon an
707 * external abort, we won't call the i/o handler anymore so we may need to
708 * remove back references to the stream currently being dumped.
709 */
710static void cli_release_handler(struct appctx *appctx)
711{
712 if (appctx->io_release) {
713 appctx->io_release(appctx);
714 appctx->io_release = NULL;
715 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100716 else if (appctx->st0 == CLI_ST_PRINT_FREE) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100717 free(appctx->ctx.cli.err);
718 appctx->ctx.cli.err = NULL;
719 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100720}
721
722/* This function dumps all environmnent variables to the buffer. It returns 0
723 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +0100724 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
725 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +0100726 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100727static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100728{
Willy Tarreau0a739292016-11-22 20:21:23 +0100729 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100730 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100731
732 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
733 return 1;
734
735 chunk_reset(&trash);
736
737 /* we have two inner loops here, one for the proxy, the other one for
738 * the buffer.
739 */
Willy Tarreauf6710f82016-12-16 17:45:44 +0100740 while (*var) {
741 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +0100742
Willy Tarreau06d80a92017-10-19 14:32:15 +0200743 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100744 si_applet_cant_put(si);
745 return 0;
746 }
747 if (appctx->st2 == STAT_ST_END)
748 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100749 var++;
750 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +0100751 }
752
753 /* dump complete */
754 return 1;
755}
756
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200757/* This function dumps all file descriptors states (or the requested one) to
758 * the buffer. It returns 0 if the output buffer is full and it needs to be
759 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
760 * It uses cli.i0 as the fd number to restart from.
761 */
762static int cli_io_handler_show_fd(struct appctx *appctx)
763{
764 struct stream_interface *si = appctx->owner;
765 int fd = appctx->ctx.cli.i0;
766
767 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
768 return 1;
769
770 chunk_reset(&trash);
771
772 /* we have two inner loops here, one for the proxy, the other one for
773 * the buffer.
774 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +0100775 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200776 struct fdtab fdt;
Willy Tarreau286ec682017-08-09 16:35:44 +0200777 struct listener *li = NULL;
778 struct server *sv = NULL;
779 struct proxy *px = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +0200780 const struct mux_ops *mux = NULL;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200781 void *ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +0200782 uint32_t conn_flags = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200783
784 fdt = fdtab[fd];
785
Willy Tarreau017af242017-10-04 20:24:54 +0200786 if (!fdt.owner)
787 goto skip; // closed
788
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200789 if (fdt.iocb == conn_fd_handler) {
790 conn_flags = ((struct connection *)fdt.owner)->flags;
Willy Tarreau35b1b482018-03-28 18:41:30 +0200791 mux = ((struct connection *)fdt.owner)->mux;
792 ctx = ((struct connection *)fdt.owner)->mux_ctx;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200793 li = objt_listener(((struct connection *)fdt.owner)->target);
794 sv = objt_server(((struct connection *)fdt.owner)->target);
795 px = objt_proxy(((struct connection *)fdt.owner)->target);
796 }
797 else if (fdt.iocb == listener_accept)
798 li = fdt.owner;
799
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200800 chunk_printf(&trash,
Willy Tarreau745c60e2018-01-20 23:59:40 +0100801 " %5d : st=0x%02x(R:%c%c%c W:%c%c%c) ev=0x%02x(%c%c%c%c%c) [%c%c] cache=%u owner=%p iocb=%p(%s) tmask=0x%lx umask=0x%lx",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200802 fd,
803 fdt.state,
804 (fdt.state & FD_EV_POLLED_R) ? 'P' : 'p',
805 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
806 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
807 (fdt.state & FD_EV_POLLED_W) ? 'P' : 'p',
808 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
809 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
810 fdt.ev,
811 (fdt.ev & FD_POLL_HUP) ? 'H' : 'h',
812 (fdt.ev & FD_POLL_ERR) ? 'E' : 'e',
813 (fdt.ev & FD_POLL_OUT) ? 'O' : 'o',
814 (fdt.ev & FD_POLL_PRI) ? 'P' : 'p',
815 (fdt.ev & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200816 fdt.linger_risk ? 'L' : 'l',
817 fdt.cloned ? 'C' : 'c',
Olivier Houchard12568362018-01-31 18:07:29 +0100818 fdt.cache.next >= -2 ? 1 : 0,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200819 fdt.owner,
820 fdt.iocb,
821 (fdt.iocb == conn_fd_handler) ? "conn_fd_handler" :
822 (fdt.iocb == dgram_fd_handler) ? "dgram_fd_handler" :
823 (fdt.iocb == listener_accept) ? "listener_accept" :
Willy Tarreau4037a3f2018-03-28 18:06:47 +0200824 (fdt.iocb == thread_sync_io_handler) ? "thread_sync_io_handler" :
Willy Tarreau5d9846f2017-11-10 16:53:09 +0100825 "unknown",
Willy Tarreauebc78d72018-01-20 23:53:50 +0100826 fdt.thread_mask, fdt.update_mask);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200827
828 if (fdt.iocb == conn_fd_handler) {
829 chunk_appendf(&trash, " cflg=0x%08x", conn_flags);
830 if (px)
831 chunk_appendf(&trash, " px=%s", px->id);
832 else if (sv)
833 chunk_appendf(&trash, " sv=%s/%s", sv->id, sv->proxy->id);
834 else if (li)
835 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +0200836
837 if (mux)
838 chunk_appendf(&trash, " mux=%s mux_ctx=%p", mux->name, ctx);
839 else
840 chunk_appendf(&trash, " nomux");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200841 }
842 else if (fdt.iocb == listener_accept) {
843 chunk_appendf(&trash, " l.st=%s fe=%s",
844 listener_state_str(li),
845 li->bind_conf->frontend->id);
846 }
847
848 chunk_appendf(&trash, "\n");
849
Willy Tarreau06d80a92017-10-19 14:32:15 +0200850 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200851 si_applet_cant_put(si);
852 return 0;
853 }
854 skip:
855 if (appctx->st2 == STAT_ST_END)
856 break;
857
858 fd++;
859 appctx->ctx.cli.i0 = fd;
860 }
861
862 /* dump complete */
863 return 1;
864}
865
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100866/* This function dumps some activity counters used by developers and support to
867 * rule out some hypothesis during bug reports. It returns 0 if the output
868 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
869 * everything at once in the buffer and is not designed to do it in multiple
870 * passes.
871 */
872static int cli_io_handler_show_activity(struct appctx *appctx)
873{
874 struct stream_interface *si = appctx->owner;
875 int thr;
876
877 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
878 return 1;
879
880 chunk_reset(&trash);
881
882 chunk_appendf(&trash, "thread_id: %u", tid);
883 chunk_appendf(&trash, "\ndate_now: %lu.%06lu", (long)now.tv_sec, (long)now.tv_usec);
884 chunk_appendf(&trash, "\nloops:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].loops);
885 chunk_appendf(&trash, "\nwake_cache:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_cache);
886 chunk_appendf(&trash, "\nwake_tasks:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_tasks);
887 chunk_appendf(&trash, "\nwake_applets:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_applets);
888 chunk_appendf(&trash, "\nwake_signal:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].wake_signal);
889 chunk_appendf(&trash, "\npoll_exp:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_exp);
890 chunk_appendf(&trash, "\npoll_drop:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_drop);
891 chunk_appendf(&trash, "\npoll_dead:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_dead);
892 chunk_appendf(&trash, "\npoll_skip:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].poll_skip);
893 chunk_appendf(&trash, "\nfd_skip:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_skip);
894 chunk_appendf(&trash, "\nfd_lock:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_lock);
895 chunk_appendf(&trash, "\nfd_del:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].fd_del);
896 chunk_appendf(&trash, "\nconn_dead:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].conn_dead);
897 chunk_appendf(&trash, "\nstream:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].stream);
898 chunk_appendf(&trash, "\nempty_rq:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].empty_rq);
899 chunk_appendf(&trash, "\nlong_rq:"); for (thr = 0; thr < global.nbthread; thr++) chunk_appendf(&trash, " %u", activity[thr].long_rq);
900
901 chunk_appendf(&trash, "\n");
902
903 if (ci_putchk(si_ic(si), &trash) == -1) {
904 chunk_reset(&trash);
905 chunk_printf(&trash, "[output too large, cannot dump]\n");
906 si_applet_cant_put(si);
907 }
908
909 /* dump complete */
910 return 1;
911}
912
William Lallemandeceddf72016-12-15 18:06:44 +0100913/*
Willy Tarreau3af9d832016-12-16 12:58:09 +0100914 * CLI IO handler for `show cli sockets`.
915 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +0100916 */
917static int cli_io_handler_show_cli_sock(struct appctx *appctx)
918{
919 struct bind_conf *bind_conf;
920 struct stream_interface *si = appctx->owner;
921
922 chunk_reset(&trash);
923
924 switch (appctx->st2) {
925 case STAT_ST_INIT:
926 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +0200927 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandeceddf72016-12-15 18:06:44 +0100928 si_applet_cant_put(si);
929 return 0;
930 }
William Lallemandeceddf72016-12-15 18:06:44 +0100931 appctx->st2 = STAT_ST_LIST;
932
933 case STAT_ST_LIST:
934 if (global.stats_fe) {
935 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
936 struct listener *l;
937
938 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +0100939 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +0100940 * if the current node is the first of the list
941 */
942
Willy Tarreau3af9d832016-12-16 12:58:09 +0100943 if (appctx->ctx.cli.p0 &&
944 &bind_conf->by_fe == (&global.stats_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +0100945 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +0100946 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +0100947 continue;
948 }
949
950 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
951
952 char addr[46];
953 char port[6];
954
955 if (l->addr.ss_family == AF_UNIX) {
956 const struct sockaddr_un *un;
957
958 un = (struct sockaddr_un *)&l->addr;
959 chunk_appendf(&trash, "%s ", un->sun_path);
960 } else if (l->addr.ss_family == AF_INET) {
961 addr_to_str(&l->addr, addr, sizeof(addr));
962 port_to_str(&l->addr, port, sizeof(port));
963 chunk_appendf(&trash, "%s:%s ", addr, port);
964 } else if (l->addr.ss_family == AF_INET6) {
965 addr_to_str(&l->addr, addr, sizeof(addr));
966 port_to_str(&l->addr, port, sizeof(port));
967 chunk_appendf(&trash, "[%s]:%s ", addr, port);
968 } else
969 continue;
970
William Lallemand07a62f72017-05-24 00:57:40 +0200971 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +0100972 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +0200973 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
974 chunk_appendf(&trash, "operator ");
975 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
976 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +0100977 else
978 chunk_appendf(&trash, " ");
979
980 if (bind_conf->bind_proc != 0) {
981 int pos;
Willy Tarreau20c5e522016-12-16 12:50:55 +0100982 for (pos = 0; pos < 8 * sizeof(bind_conf->bind_proc); pos++) {
Willy Tarreau4305ac72016-12-16 12:56:31 +0100983 if (bind_conf->bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +0100984 chunk_appendf(&trash, "%d,", pos+1);
985 }
986 }
987 /* replace the latest comma by a newline */
988 trash.str[trash.len-1] = '\n';
989
990 } else {
991 chunk_appendf(&trash, "all\n");
992 }
993
Willy Tarreau06d80a92017-10-19 14:32:15 +0200994 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandeceddf72016-12-15 18:06:44 +0100995 si_applet_cant_put(si);
996 return 0;
997 }
998 }
Willy Tarreau3af9d832016-12-16 12:58:09 +0100999 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001000 }
1001 }
1002 default:
1003 appctx->st2 = STAT_ST_FIN;
1004 return 1;
1005 }
1006}
1007
1008
Willy Tarreau0a739292016-11-22 20:21:23 +01001009/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001010 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1011 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001012 */
1013static int cli_parse_show_env(char **args, struct appctx *appctx, void *private)
1014{
1015 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001016 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001017
1018 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1019 return 1;
1020
Willy Tarreauf6710f82016-12-16 17:45:44 +01001021 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001022
1023 if (*args[2]) {
1024 int len = strlen(args[2]);
1025
Willy Tarreauf6710f82016-12-16 17:45:44 +01001026 for (; *var; var++) {
1027 if (strncmp(*var, args[2], len) == 0 &&
1028 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001029 break;
1030 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001031 if (!*var) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001032 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau0a739292016-11-22 20:21:23 +01001033 appctx->ctx.cli.msg = "Variable not found\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001034 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau0a739292016-11-22 20:21:23 +01001035 return 1;
1036 }
1037 appctx->st2 = STAT_ST_END;
1038 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001039 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001040 return 0;
1041}
1042
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001043/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1044 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1045 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1046 */
1047static int cli_parse_show_fd(char **args, struct appctx *appctx, void *private)
1048{
1049 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1050 return 1;
1051
1052 appctx->ctx.cli.i0 = 0;
1053
1054 if (*args[2]) {
1055 appctx->ctx.cli.i0 = atoi(args[2]);
1056 appctx->st2 = STAT_ST_END;
1057 }
1058 return 0;
1059}
1060
Willy Tarreau599852e2016-11-22 20:33:32 +01001061/* parse a "set timeout" CLI request. It always returns 1. */
1062static int cli_parse_set_timeout(char **args, struct appctx *appctx, void *private)
1063{
1064 struct stream_interface *si = appctx->owner;
1065 struct stream *s = si_strm(si);
1066
1067 if (strcmp(args[2], "cli") == 0) {
1068 unsigned timeout;
1069 const char *res;
1070
1071 if (!*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001072 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001073 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001074 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001075 return 1;
1076 }
1077
1078 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
1079 if (res || timeout < 1) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001080 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001081 appctx->ctx.cli.msg = "Invalid timeout value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001082 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001083 return 1;
1084 }
1085
1086 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1087 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1088 return 1;
1089 }
1090 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001091 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau599852e2016-11-22 20:33:32 +01001092 appctx->ctx.cli.msg = "'set timeout' only supports 'cli'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001093 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +01001094 return 1;
1095 }
1096}
1097
Willy Tarreau2af99412016-11-23 11:10:59 +01001098/* parse a "set maxconn global" command. It always returns 1. */
1099static int cli_parse_set_maxconn_global(char **args, struct appctx *appctx, void *private)
1100{
1101 int v;
1102
1103 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1104 return 1;
1105
1106 if (!*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001107 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau2af99412016-11-23 11:10:59 +01001108 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001109 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +01001110 return 1;
1111 }
1112
1113 v = atoi(args[3]);
1114 if (v > global.hardmaxconn) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001115 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau2af99412016-11-23 11:10:59 +01001116 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001117 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +01001118 return 1;
1119 }
1120
1121 /* check for unlimited values */
1122 if (v <= 0)
1123 v = global.hardmaxconn;
1124
1125 global.maxconn = v;
1126
1127 /* Dequeues all of the listeners waiting for a resource */
1128 if (!LIST_ISEMPTY(&global_listener_queue))
1129 dequeue_all_listeners(&global_listener_queue);
1130
1131 return 1;
1132}
1133
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001134static int set_severity_output(int *target, char *argument)
1135{
1136 if (!strcmp(argument, "none")) {
1137 *target = CLI_SEVERITY_NONE;
1138 return 1;
1139 }
1140 else if (!strcmp(argument, "number")) {
1141 *target = CLI_SEVERITY_NUMBER;
1142 return 1;
1143 }
1144 else if (!strcmp(argument, "string")) {
1145 *target = CLI_SEVERITY_STRING;
1146 return 1;
1147 }
1148 return 0;
1149}
1150
1151/* parse a "set severity-output" command. */
1152static int cli_parse_set_severity_output(char **args, struct appctx *appctx, void *private)
1153{
1154 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1155 return 0;
1156
1157 appctx->ctx.cli.severity = LOG_ERR;
Aurélien Nephtali6e8a41d2018-03-15 21:48:50 +01001158 appctx->ctx.cli.msg = "one of 'none', 'number', 'string' is a required argument\n";
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001159 appctx->st0 = CLI_ST_PRINT;
1160 return 1;
1161}
William Lallemandeceddf72016-12-15 18:06:44 +01001162
1163int cli_parse_default(char **args, struct appctx *appctx, void *private)
1164{
1165 return 0;
1166}
1167
Willy Tarreau45c742b2016-11-24 14:51:17 +01001168/* parse a "set rate-limit" command. It always returns 1. */
1169static int cli_parse_set_ratelimit(char **args, struct appctx *appctx, void *private)
1170{
1171 int v;
1172 int *res;
1173 int mul = 1;
1174
1175 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1176 return 1;
1177
1178 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1179 res = &global.cps_lim;
1180 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1181 res = &global.sps_lim;
1182#ifdef USE_OPENSSL
1183 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1184 res = &global.ssl_lim;
1185#endif
1186 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1187 res = &global.comp_rate_lim;
1188 mul = 1024;
1189 }
1190 else {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001191 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001192 appctx->ctx.cli.msg =
1193 "'set rate-limit' only supports :\n"
1194 " - 'connections global' to set the per-process maximum connection rate\n"
1195 " - 'sessions global' to set the per-process maximum session rate\n"
1196#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001197 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001198#endif
1199 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001200 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001201 return 1;
1202 }
1203
1204 if (!*args[4]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001205 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001206 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001207 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001208 return 1;
1209 }
1210
1211 v = atoi(args[4]);
1212 if (v < 0) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001213 appctx->ctx.cli.severity = LOG_ERR;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001214 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001215 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +01001216 return 1;
1217 }
1218
1219 *res = v * mul;
1220
1221 /* Dequeues all of the listeners waiting for a resource */
1222 if (!LIST_ISEMPTY(&global_listener_queue))
1223 dequeue_all_listeners(&global_listener_queue);
1224
1225 return 1;
1226}
1227
William Lallemandf6975e92017-05-26 17:42:10 +02001228/* parse the "expose-fd" argument on the bind lines */
1229static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1230{
1231 if (!*args[cur_arg + 1]) {
1232 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1233 return ERR_ALERT | ERR_FATAL;
1234 }
1235 if (!strcmp(args[cur_arg+1], "listeners")) {
1236 conf->level |= ACCESS_FD_LISTENERS;
1237 } else {
1238 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1239 args[cur_arg], args[cur_arg+1]);
1240 return ERR_ALERT | ERR_FATAL;
1241 }
1242
1243 return 0;
1244}
1245
William Lallemand74c24fb2016-11-21 17:18:36 +01001246/* parse the "level" argument on the bind lines */
1247static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1248{
1249 if (!*args[cur_arg + 1]) {
1250 memprintf(err, "'%s' : missing level", args[cur_arg]);
1251 return ERR_ALERT | ERR_FATAL;
1252 }
1253
William Lallemand07a62f72017-05-24 00:57:40 +02001254 if (!strcmp(args[cur_arg+1], "user")) {
1255 conf->level &= ~ACCESS_LVL_MASK;
1256 conf->level |= ACCESS_LVL_USER;
1257 } else if (!strcmp(args[cur_arg+1], "operator")) {
1258 conf->level &= ~ACCESS_LVL_MASK;
1259 conf->level |= ACCESS_LVL_OPER;
1260 } else if (!strcmp(args[cur_arg+1], "admin")) {
1261 conf->level &= ~ACCESS_LVL_MASK;
1262 conf->level |= ACCESS_LVL_ADMIN;
1263 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001264 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1265 args[cur_arg], args[cur_arg+1]);
1266 return ERR_ALERT | ERR_FATAL;
1267 }
1268
1269 return 0;
1270}
1271
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001272static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1273{
1274 if (!*args[cur_arg + 1]) {
1275 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1276 return ERR_ALERT | ERR_FATAL;
1277 }
1278
1279 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1280 return 0;
1281 else {
1282 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1283 args[cur_arg], args[cur_arg+1]);
1284 return ERR_ALERT | ERR_FATAL;
1285 }
1286}
1287
Olivier Houchardf886e342017-04-05 22:24:59 +02001288/* Send all the bound sockets, always returns 1 */
1289static int _getsocks(char **args, struct appctx *appctx, void *private)
1290{
1291 char *cmsgbuf = NULL;
1292 unsigned char *tmpbuf = NULL;
1293 struct cmsghdr *cmsg;
1294 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001295 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001296 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001297 struct msghdr msghdr;
1298 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001299 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Olivier Houchardf886e342017-04-05 22:24:59 +02001300 int *tmpfd;
1301 int tot_fd_nb = 0;
1302 struct proxy *px;
1303 int i = 0;
Willy Tarreau585744b2017-08-24 14:31:19 +02001304 int fd = remote->handle.fd;
Olivier Houchardf886e342017-04-05 22:24:59 +02001305 int curoff = 0;
1306 int old_fcntl;
1307 int ret;
1308
1309 /* Temporary set the FD in blocking mode, that will make our life easier */
1310 old_fcntl = fcntl(fd, F_GETFL);
1311 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001312 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001313 goto out;
1314 }
1315 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1316 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001317 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001318 goto out;
1319 }
1320 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001321 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001322 goto out;
1323 }
Olivier Houchard54740872017-04-06 14:45:14 +02001324 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001325 iov.iov_base = &tot_fd_nb;
1326 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001327 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001328 goto out;
1329 memset(&msghdr, 0, sizeof(msghdr));
1330 /*
1331 * First, calculates the total number of FD, so that we can let
1332 * the caller know how much he should expects.
1333 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001334 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001335 while (px) {
1336 struct listener *l;
1337
1338 list_for_each_entry(l, &px->conf.listeners, by_fe) {
Olivier Houchard1fc05162017-04-06 01:05:05 +02001339 /* Only transfer IPv4/IPv6/UNIX sockets */
1340 if (l->state >= LI_ZOMBIE &&
1341 (l->proto->sock_family == AF_INET ||
Olivier Houchardf886e342017-04-05 22:24:59 +02001342 l->proto->sock_family == AF_INET6 ||
Olivier Houchard1fc05162017-04-06 01:05:05 +02001343 l->proto->sock_family == AF_UNIX))
Olivier Houchardf886e342017-04-05 22:24:59 +02001344 tot_fd_nb++;
1345 }
1346 px = px->next;
1347 }
1348 if (tot_fd_nb == 0)
1349 goto out;
1350
1351 /* First send the total number of file descriptors, so that the
1352 * receiving end knows what to expect.
1353 */
1354 msghdr.msg_iov = &iov;
1355 msghdr.msg_iovlen = 1;
1356 ret = sendmsg(fd, &msghdr, 0);
1357 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001358 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001359 goto out;
1360 }
1361
1362 /* Now send the fds */
1363 msghdr.msg_control = cmsgbuf;
1364 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1365 cmsg = CMSG_FIRSTHDR(&msghdr);
1366 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1367 cmsg->cmsg_level = SOL_SOCKET;
1368 cmsg->cmsg_type = SCM_RIGHTS;
1369 tmpfd = (int *)CMSG_DATA(cmsg);
1370
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001371 px = proxies_list;
Olivier Houchardf886e342017-04-05 22:24:59 +02001372 /* For each socket, e message is sent, containing the following :
1373 * Size of the namespace name (or 0 if none), as an unsigned char.
1374 * The namespace name, if any
1375 * Size of the interface name (or 0 if none), as an unsigned char
1376 * The interface name, if any
1377 * Listener options, as an int.
1378 */
1379 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
1380 * buffer big enough to store the socket informations.
1381 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001382 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001383 if (tmpbuf == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001384 ha_warning("Failed to allocate memory to transfer socket informations\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001385 goto out;
1386 }
1387 iov.iov_base = tmpbuf;
1388 while (px) {
1389 struct listener *l;
1390
1391 list_for_each_entry(l, &px->conf.listeners, by_fe) {
1392 int ret;
1393 /* Only transfer IPv4/IPv6 sockets */
Olivier Houchard1fc05162017-04-06 01:05:05 +02001394 if (l->state >= LI_ZOMBIE &&
Olivier Houchardf886e342017-04-05 22:24:59 +02001395 (l->proto->sock_family == AF_INET ||
1396 l->proto->sock_family == AF_INET6 ||
1397 l->proto->sock_family == AF_UNIX)) {
1398 memcpy(&tmpfd[i % MAX_SEND_FD], &l->fd, sizeof(l->fd));
1399 if (!l->netns)
1400 tmpbuf[curoff++] = 0;
1401#ifdef CONFIG_HAP_NS
1402 else {
1403 char *name = l->netns->node.key;
1404 unsigned char len = l->netns->name_len;
1405 tmpbuf[curoff++] = len;
1406 memcpy(tmpbuf + curoff, name, len);
1407 curoff += len;
1408 }
1409#endif
1410 if (l->interface) {
1411 unsigned char len = strlen(l->interface);
1412 tmpbuf[curoff++] = len;
1413 memcpy(tmpbuf + curoff, l->interface, len);
1414 curoff += len;
1415 } else
1416 tmpbuf[curoff++] = 0;
1417 memcpy(tmpbuf + curoff, &l->options,
1418 sizeof(l->options));
1419 curoff += sizeof(l->options);
1420
1421
1422 i++;
1423 } else
1424 continue;
1425 if ((!(i % MAX_SEND_FD))) {
1426 iov.iov_len = curoff;
1427 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001428 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001429 goto out;
1430 }
1431 /* Wait for an ack */
1432 do {
1433 ret = recv(fd, &tot_fd_nb,
1434 sizeof(tot_fd_nb), 0);
1435 } while (ret == -1 && errno == EINTR);
1436 if (ret <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001437 ha_warning("Unexpected error while transferring sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001438 goto out;
1439 }
1440 curoff = 0;
1441 }
1442
1443 }
1444 px = px->next;
1445 }
1446 if (i % MAX_SEND_FD) {
1447 iov.iov_len = curoff;
1448 cmsg->cmsg_len = CMSG_LEN((i % MAX_SEND_FD) * sizeof(int));
1449 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * (i % MAX_SEND_FD));
1450 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001451 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001452 goto out;
1453 }
1454 }
1455
1456out:
1457 if (old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001458 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001459 goto out;
1460 }
1461 appctx->st0 = CLI_ST_END;
1462 free(cmsgbuf);
1463 free(tmpbuf);
1464 return 1;
1465}
1466
1467
1468
William Lallemand74c24fb2016-11-21 17:18:36 +01001469static struct applet cli_applet = {
1470 .obj_type = OBJ_TYPE_APPLET,
1471 .name = "<CLI>", /* used for logging */
1472 .fct = cli_io_handler,
1473 .release = cli_release_handler,
1474};
1475
Willy Tarreau0a739292016-11-22 20:21:23 +01001476/* register cli keywords */
1477static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau2af99412016-11-23 11:10:59 +01001478 { { "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 +01001479 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001480 { { "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 +01001481 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01001482 { { "show", "env", NULL }, "show env [var] : dump environment variables known to the process", cli_parse_show_env, cli_io_handler_show_env, NULL },
William Lallemandeceddf72016-12-15 18:06:44 +01001483 { { "show", "cli", "sockets", NULL }, "show cli sockets : dump list of cli sockets", cli_parse_default, cli_io_handler_show_cli_sock, NULL },
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001484 { { "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 +01001485 { { "show", "activity", NULL }, "show activity : show per-thread activity stats (for support/developers)", cli_parse_default, cli_io_handler_show_activity, NULL },
Olivier Houchardf886e342017-04-05 22:24:59 +02001486 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01001487 {{},}
1488}};
1489
William Lallemand74c24fb2016-11-21 17:18:36 +01001490static struct cfg_kw_list cfg_kws = {ILH, {
1491 { CFG_GLOBAL, "stats", stats_parse_global },
1492 { 0, NULL, NULL },
1493}};
1494
1495static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02001496 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
1497 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001498 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01001499 { NULL, NULL, 0 },
1500}};
1501
1502__attribute__((constructor))
1503static void __dumpstats_module_init(void)
1504{
1505 cfg_register_keywords(&cfg_kws);
Willy Tarreau0a739292016-11-22 20:21:23 +01001506 cli_register_kw(&cli_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01001507 bind_register_keywords(&bind_kws);
1508}
1509
1510/*
1511 * Local variables:
1512 * c-indent-level: 8
1513 * c-basic-offset: 8
1514 * End:
1515 */