blob: 239a505ad97a0cf3309c586c300c383ca39f3c4a [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
27#include <common/cfgparse.h>
28#include <common/compat.h>
29#include <common/config.h>
30#include <common/debug.h>
31#include <common/memory.h>
32#include <common/mini-clist.h>
33#include <common/standard.h>
34#include <common/ticks.h>
35#include <common/time.h>
36#include <common/uri_auth.h>
37#include <common/version.h>
38#include <common/base64.h>
39
40#include <types/applet.h>
William Lallemand9ed62032016-11-21 17:49:11 +010041#include <types/cli.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010042#include <types/global.h>
43#include <types/dns.h>
William Lallemand9ed62032016-11-21 17:49:11 +010044#include <types/stats.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010045
46#include <proto/backend.h>
47#include <proto/channel.h>
48#include <proto/checks.h>
49#include <proto/compression.h>
William Lallemand9ed62032016-11-21 17:49:11 +010050#include <proto/stats.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010051#include <proto/fd.h>
52#include <proto/freq_ctr.h>
53#include <proto/frontend.h>
54#include <proto/log.h>
55#include <proto/pattern.h>
56#include <proto/pipe.h>
57#include <proto/listener.h>
58#include <proto/map.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010059#include <proto/proto_uxst.h>
60#include <proto/proxy.h>
61#include <proto/sample.h>
62#include <proto/session.h>
63#include <proto/stream.h>
64#include <proto/server.h>
65#include <proto/raw_sock.h>
66#include <proto/stream_interface.h>
67#include <proto/task.h>
68
William Lallemand74c24fb2016-11-21 17:18:36 +010069static struct applet cli_applet;
70
71static const char stats_sock_usage_msg[] =
72 "Unknown command. Please enter one of the following commands only :\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010073 " help : this message\n"
74 " prompt : toggle interactive mode with prompt\n"
75 " quit : disconnect\n"
William Lallemand74c24fb2016-11-21 17:18:36 +010076 "";
77
78static const char stats_permission_denied_msg[] =
79 "Permission denied\n"
80 "";
81
82
83static char *dynamic_usage_msg = NULL;
84
85/* List head of cli keywords */
86static struct cli_kw_list cli_keywords = {
87 .list = LIST_HEAD_INIT(cli_keywords.list)
88};
89
90extern const char *stat_status_codes[];
91
92char *cli_gen_usage_msg()
93{
94 struct cli_kw_list *kw_list;
95 struct cli_kw *kw;
96 struct chunk *tmp = get_trash_chunk();
97 struct chunk out;
98
99 free(dynamic_usage_msg);
100 dynamic_usage_msg = NULL;
101
102 if (LIST_ISEMPTY(&cli_keywords.list))
103 return NULL;
104
105 chunk_reset(tmp);
106 chunk_strcat(tmp, stats_sock_usage_msg);
107 list_for_each_entry(kw_list, &cli_keywords.list, list) {
108 kw = &kw_list->kw[0];
109 while (kw->usage) {
110 chunk_appendf(tmp, " %s\n", kw->usage);
111 kw++;
112 }
113 }
114 chunk_init(&out, NULL, 0);
115 chunk_dup(&out, tmp);
116 dynamic_usage_msg = out.str;
117 return dynamic_usage_msg;
118}
119
120struct cli_kw* cli_find_kw(char **args)
121{
122 struct cli_kw_list *kw_list;
123 struct cli_kw *kw;/* current cli_kw */
124 char **tmp_args;
125 const char **tmp_str_kw;
126 int found = 0;
127
128 if (LIST_ISEMPTY(&cli_keywords.list))
129 return NULL;
130
131 list_for_each_entry(kw_list, &cli_keywords.list, list) {
132 kw = &kw_list->kw[0];
133 while (*kw->str_kw) {
134 tmp_args = args;
135 tmp_str_kw = kw->str_kw;
136 while (*tmp_str_kw) {
137 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
138 found = 1;
139 } else {
140 found = 0;
141 break;
142 }
143 tmp_args++;
144 tmp_str_kw++;
145 }
146 if (found)
147 return (kw);
148 kw++;
149 }
150 }
151 return NULL;
152}
153
154void cli_register_kw(struct cli_kw_list *kw_list)
155{
156 LIST_ADDQ(&cli_keywords.list, &kw_list->list);
157}
158
159
160/* allocate a new stats frontend named <name>, and return it
161 * (or NULL in case of lack of memory).
162 */
163static struct proxy *alloc_stats_fe(const char *name, const char *file, int line)
164{
165 struct proxy *fe;
166
167 fe = calloc(1, sizeof(*fe));
168 if (!fe)
169 return NULL;
170
171 init_new_proxy(fe);
172 fe->next = proxy;
173 proxy = fe;
174 fe->last_change = now.tv_sec;
175 fe->id = strdup("GLOBAL");
176 fe->cap = PR_CAP_FE;
177 fe->maxconn = 10; /* default to 10 concurrent connections */
178 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
179 fe->conf.file = strdup(file);
180 fe->conf.line = line;
181 fe->accept = frontend_accept;
182 fe->default_target = &cli_applet.obj_type;
183
184 /* the stats frontend is the only one able to assign ID #0 */
185 fe->conf.id.key = fe->uuid = 0;
186 eb32_insert(&used_proxy_id, &fe->conf.id);
187 return fe;
188}
189
190/* This function parses a "stats" statement in the "global" section. It returns
191 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
192 * error message into the <err> buffer which will be preallocated. The trailing
193 * '\n' must not be written. The function must be called with <args> pointing to
194 * the first word after "stats".
195 */
196static int stats_parse_global(char **args, int section_type, struct proxy *curpx,
197 struct proxy *defpx, const char *file, int line,
198 char **err)
199{
200 struct bind_conf *bind_conf;
201 struct listener *l;
202
203 if (!strcmp(args[1], "socket")) {
204 int cur_arg;
205
206 if (*args[2] == 0) {
207 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
208 return -1;
209 }
210
211 if (!global.stats_fe) {
212 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
213 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
214 return -1;
215 }
216 }
217
218 bind_conf = bind_conf_alloc(&global.stats_fe->conf.bind, file, line, args[2]);
219 bind_conf->level = ACCESS_LVL_OPER; /* default access level */
220
221 if (!str2listener(args[2], global.stats_fe, bind_conf, file, line, err)) {
222 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
223 file, line, args[0], args[1], err && *err ? *err : "error");
224 return -1;
225 }
226
227 cur_arg = 3;
228 while (*args[cur_arg]) {
229 static int bind_dumped;
230 struct bind_kw *kw;
231
232 kw = bind_find_kw(args[cur_arg]);
233 if (kw) {
234 if (!kw->parse) {
235 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
236 args[0], args[1], args[cur_arg]);
237 return -1;
238 }
239
240 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, err) != 0) {
241 if (err && *err)
242 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
243 else
244 memprintf(err, "'%s %s' : error encountered while processing '%s'",
245 args[0], args[1], args[cur_arg]);
246 return -1;
247 }
248
249 cur_arg += 1 + kw->skip;
250 continue;
251 }
252
253 if (!bind_dumped) {
254 bind_dump_kws(err);
255 indent_msg(err, 4);
256 bind_dumped = 1;
257 }
258
259 memprintf(err, "'%s %s' : unknown keyword '%s'.%s%s",
260 args[0], args[1], args[cur_arg],
261 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
262 return -1;
263 }
264
265 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
266 l->maxconn = global.stats_fe->maxconn;
267 l->backlog = global.stats_fe->backlog;
268 l->accept = session_accept_fd;
269 l->handler = process_stream;
270 l->default_target = global.stats_fe->default_target;
271 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
272 l->nice = -64; /* we want to boost priority for local stats */
273 global.maxsock += l->maxconn;
274 }
275 }
276 else if (!strcmp(args[1], "timeout")) {
277 unsigned timeout;
278 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
279
280 if (res) {
281 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
282 return -1;
283 }
284
285 if (!timeout) {
286 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
287 return -1;
288 }
289 if (!global.stats_fe) {
290 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
291 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
292 return -1;
293 }
294 }
295 global.stats_fe->timeout.client = MS_TO_TICKS(timeout);
296 }
297 else if (!strcmp(args[1], "maxconn")) {
298 int maxconn = atol(args[2]);
299
300 if (maxconn <= 0) {
301 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
302 return -1;
303 }
304
305 if (!global.stats_fe) {
306 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
307 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
308 return -1;
309 }
310 }
311 global.stats_fe->maxconn = maxconn;
312 }
313 else if (!strcmp(args[1], "bind-process")) { /* enable the socket only on some processes */
314 int cur_arg = 2;
315 unsigned long set = 0;
316
317 if (!global.stats_fe) {
318 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
319 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
320 return -1;
321 }
322 }
323
324 while (*args[cur_arg]) {
325 unsigned int low, high;
326
327 if (strcmp(args[cur_arg], "all") == 0) {
328 set = 0;
329 break;
330 }
331 else if (strcmp(args[cur_arg], "odd") == 0) {
332 set |= ~0UL/3UL; /* 0x555....555 */
333 }
334 else if (strcmp(args[cur_arg], "even") == 0) {
335 set |= (~0UL/3UL) << 1; /* 0xAAA...AAA */
336 }
337 else if (isdigit((int)*args[cur_arg])) {
338 char *dash = strchr(args[cur_arg], '-');
339
340 low = high = str2uic(args[cur_arg]);
341 if (dash)
342 high = str2uic(dash + 1);
343
344 if (high < low) {
345 unsigned int swap = low;
346 low = high;
347 high = swap;
348 }
349
350 if (low < 1 || high > LONGBITS) {
351 memprintf(err, "'%s %s' supports process numbers from 1 to %d.\n",
352 args[0], args[1], LONGBITS);
353 return -1;
354 }
355 while (low <= high)
356 set |= 1UL << (low++ - 1);
357 }
358 else {
359 memprintf(err,
360 "'%s %s' expects 'all', 'odd', 'even', or a list of process ranges with numbers from 1 to %d.\n",
361 args[0], args[1], LONGBITS);
362 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
Willy Tarreaude57a572016-11-23 17:01:39 +0100375/* Verifies that the CLI at least has a level at least as high as <level>
376 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
377 * failure, an error message is prepared and the appctx's state is adjusted
378 * to print it so that a return 1 is enough to abort any processing.
379 */
380int cli_has_level(struct appctx *appctx, int level)
381{
382 struct stream_interface *si = appctx->owner;
383 struct stream *s = si_strm(si);
384
385 if (strm_li(s)->bind_conf->level < level) {
386 appctx->ctx.cli.msg = stats_permission_denied_msg;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100387 appctx->st0 = CLI_ST_PRINT;
Willy Tarreaude57a572016-11-23 17:01:39 +0100388 return 0;
389 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100390 return 1;
391}
392
William Lallemand74c24fb2016-11-21 17:18:36 +0100393
Willy Tarreau41908562016-11-24 16:23:38 +0100394/* Processes the CLI interpreter on the stats socket. This function is called
395 * from the CLI's IO handler running in an appctx context. The function returns 1
396 * if the request was understood, otherwise zero. It is called with appctx->st0
397 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
398 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
399 * have its own I/O handler called again. Most of the time, parsers will only
400 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
William Lallemand74c24fb2016-11-21 17:18:36 +0100401 */
Willy Tarreau41908562016-11-24 16:23:38 +0100402static int cli_parse_request(struct appctx *appctx, char *line)
William Lallemand74c24fb2016-11-21 17:18:36 +0100403{
William Lallemand74c24fb2016-11-21 17:18:36 +0100404 char *args[MAX_STATS_ARGS + 1];
405 struct cli_kw *kw;
406 int arg;
407 int i, j;
408
409 while (isspace((unsigned char)*line))
410 line++;
411
412 arg = 0;
413 args[arg] = line;
414
415 while (*line && arg < MAX_STATS_ARGS) {
416 if (*line == '\\') {
417 line++;
418 if (*line == '\0')
419 break;
420 }
421 else if (isspace((unsigned char)*line)) {
422 *line++ = '\0';
423
424 while (isspace((unsigned char)*line))
425 line++;
426
427 args[++arg] = line;
428 continue;
429 }
430
431 line++;
432 }
433
434 while (++arg <= MAX_STATS_ARGS)
435 args[arg] = line;
436
437 /* remove \ */
438 arg = 0;
439 while (*args[arg] != '\0') {
440 j = 0;
441 for (i=0; args[arg][i] != '\0'; i++) {
442 if (args[arg][i] == '\\')
443 continue;
444 args[arg][j] = args[arg][i];
445 j++;
446 }
447 args[arg][j] = '\0';
448 arg++;
449 }
450
451 appctx->ctx.stats.scope_str = 0;
452 appctx->ctx.stats.scope_len = 0;
453 appctx->ctx.stats.flags = 0;
Willy Tarreau41908562016-11-24 16:23:38 +0100454 appctx->st2 = 0;
455
456 kw = cli_find_kw(args);
457 if (!kw || !kw->parse)
458 return 0;
459
460 appctx->io_handler = kw->io_handler;
461 if (kw->parse(args, appctx, kw->private) == 0 && appctx->io_handler) {
462 appctx->st0 = CLI_ST_CALLBACK;
463 appctx->io_release = kw->io_release;
William Lallemand74c24fb2016-11-21 17:18:36 +0100464 }
Willy Tarreau41908562016-11-24 16:23:38 +0100465 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100466}
467
468/* This I/O handler runs as an applet embedded in a stream interface. It is
469 * used to processes I/O from/to the stats unix socket. The system relies on a
470 * state machine handling requests and various responses. We read a request,
471 * then we process it and send the response, and we possibly display a prompt.
472 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100473 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100474 * or not.
475 */
476static void cli_io_handler(struct appctx *appctx)
477{
478 struct stream_interface *si = appctx->owner;
479 struct channel *req = si_oc(si);
480 struct channel *res = si_ic(si);
481 int reql;
482 int len;
483
484 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
485 goto out;
486
487 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100488 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100489 /* Stats output not initialized yet */
490 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100491 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100492 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100493 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100494 /* Let's close for real now. We just close the request
495 * side, the conditions below will complete if needed.
496 */
497 si_shutw(si);
498 break;
499 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100500 else if (appctx->st0 == CLI_ST_GETREQ) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100501 /* ensure we have some output room left in the event we
502 * would want to return some info right after parsing.
503 */
504 if (buffer_almost_full(si_ib(si))) {
505 si_applet_cant_put(si);
506 break;
507 }
508
509 reql = bo_getline(si_oc(si), trash.str, trash.size);
510 if (reql <= 0) { /* closed or EOL not found */
511 if (reql == 0)
512 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100513 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100514 continue;
515 }
516
517 /* seek for a possible unescaped semi-colon. If we find
518 * one, we replace it with an LF and skip only this part.
519 */
520 for (len = 0; len < reql; len++) {
521 if (trash.str[len] == '\\') {
522 len++;
523 continue;
524 }
525 if (trash.str[len] == ';') {
526 trash.str[len] = '\n';
527 reql = len + 1;
528 break;
529 }
530 }
531
532 /* now it is time to check that we have a full line,
533 * remove the trailing \n and possibly \r, then cut the
534 * line.
535 */
536 len = reql - 1;
537 if (trash.str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100538 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100539 continue;
540 }
541
542 if (len && trash.str[len-1] == '\r')
543 len--;
544
545 trash.str[len] = '\0';
546
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100547 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100548 if (len) {
549 if (strcmp(trash.str, "quit") == 0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100550 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100551 continue;
552 }
553 else if (strcmp(trash.str, "prompt") == 0)
554 appctx->st1 = !appctx->st1;
555 else if (strcmp(trash.str, "help") == 0 ||
Willy Tarreau41908562016-11-24 16:23:38 +0100556 !cli_parse_request(appctx, trash.str)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100557 cli_gen_usage_msg();
558 if (dynamic_usage_msg)
559 appctx->ctx.cli.msg = dynamic_usage_msg;
560 else
561 appctx->ctx.cli.msg = stats_sock_usage_msg;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100562 appctx->st0 = CLI_ST_PRINT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100563 }
564 /* NB: stats_sock_parse_request() may have put
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100565 * another CLI_ST_O_* into appctx->st0.
William Lallemand74c24fb2016-11-21 17:18:36 +0100566 */
567 }
568 else if (!appctx->st1) {
569 /* if prompt is disabled, print help on empty lines,
570 * so that the user at least knows how to enable
571 * prompt and find help.
572 */
573 cli_gen_usage_msg();
574 if (dynamic_usage_msg)
575 appctx->ctx.cli.msg = dynamic_usage_msg;
576 else
577 appctx->ctx.cli.msg = stats_sock_usage_msg;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100578 appctx->st0 = CLI_ST_PRINT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100579 }
580
581 /* re-adjust req buffer */
582 bo_skip(si_oc(si), reql);
583 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
584 }
585 else { /* output functions */
586 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100587 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100588 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100589 case CLI_ST_PRINT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100590 if (bi_putstr(si_ic(si), appctx->ctx.cli.msg) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100591 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100592 else
593 si_applet_cant_put(si);
594 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100595 case CLI_ST_PRINT_FREE:
William Lallemand74c24fb2016-11-21 17:18:36 +0100596 if (bi_putstr(si_ic(si), appctx->ctx.cli.err) != -1) {
597 free(appctx->ctx.cli.err);
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100598 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100599 }
600 else
601 si_applet_cant_put(si);
602 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100603 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100604 if (appctx->io_handler)
605 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100606 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100607 if (appctx->io_release) {
608 appctx->io_release(appctx);
609 appctx->io_release = NULL;
610 }
611 }
612 break;
613 default: /* abnormal state */
614 si->flags |= SI_FL_ERR;
615 break;
616 }
617
618 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100619 if (appctx->st0 == CLI_ST_PROMPT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100620 if (bi_putstr(si_ic(si), appctx->st1 ? "\n> " : "\n") != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100621 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100622 else
623 si_applet_cant_put(si);
624 }
625
626 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100627 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100628 break;
629
630 /* Now we close the output if one of the writers did so,
631 * or if we're not in interactive mode and the request
632 * buffer is empty. This still allows pipelined requests
633 * to be sent in non-interactive mode.
634 */
635 if ((res->flags & (CF_SHUTW|CF_SHUTW_NOW)) || (!appctx->st1 && !req->buf->o)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100636 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100637 continue;
638 }
639
640 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100641 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100642 }
643 }
644
645 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
646 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
647 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
648 /* Other side has closed, let's abort if we have no more processing to do
649 * and nothing more to consume. This is comparable to a broken pipe, so
650 * we forward the close to the request side so that it flows upstream to
651 * the client.
652 */
653 si_shutw(si);
654 }
655
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100656 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100657 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
658 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
659 /* We have no more processing to do, and nothing more to send, and
660 * the client side has closed. So we'll forward this state downstream
661 * on the response buffer.
662 */
663 si_shutr(si);
664 res->flags |= CF_READ_NULL;
665 }
666
667 out:
668 DPRINTF(stderr, "%s@%d: st=%d, rqf=%x, rpf=%x, rqh=%d, rqs=%d, rh=%d, rs=%d\n",
669 __FUNCTION__, __LINE__,
670 si->state, req->flags, res->flags, req->buf->i, req->buf->o, res->buf->i, res->buf->o);
671}
672
William Lallemand74c24fb2016-11-21 17:18:36 +0100673/* This is called when the stream interface is closed. For instance, upon an
674 * external abort, we won't call the i/o handler anymore so we may need to
675 * remove back references to the stream currently being dumped.
676 */
677static void cli_release_handler(struct appctx *appctx)
678{
679 if (appctx->io_release) {
680 appctx->io_release(appctx);
681 appctx->io_release = NULL;
682 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100683 else if (appctx->st0 == CLI_ST_PRINT_FREE) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100684 free(appctx->ctx.cli.err);
685 appctx->ctx.cli.err = NULL;
686 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100687}
688
689/* This function dumps all environmnent variables to the buffer. It returns 0
690 * if the output buffer is full and it needs to be called again, otherwise
691 * non-zero. Dumps only one entry if st2 == STAT_ST_END.
692 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100693static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100694{
Willy Tarreau0a739292016-11-22 20:21:23 +0100695 struct stream_interface *si = appctx->owner;
William Lallemand74c24fb2016-11-21 17:18:36 +0100696
697 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
698 return 1;
699
700 chunk_reset(&trash);
701
702 /* we have two inner loops here, one for the proxy, the other one for
703 * the buffer.
704 */
705 while (*appctx->ctx.env.var) {
706 chunk_printf(&trash, "%s\n", *appctx->ctx.env.var);
707
708 if (bi_putchk(si_ic(si), &trash) == -1) {
709 si_applet_cant_put(si);
710 return 0;
711 }
712 if (appctx->st2 == STAT_ST_END)
713 break;
714 appctx->ctx.env.var++;
715 }
716
717 /* dump complete */
718 return 1;
719}
720
Willy Tarreau0a739292016-11-22 20:21:23 +0100721/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
722 * wants to stop here.
723 */
724static int cli_parse_show_env(char **args, struct appctx *appctx, void *private)
725{
726 extern char **environ;
727
728 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
729 return 1;
730
731 appctx->ctx.env.var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +0100732
733 if (*args[2]) {
734 int len = strlen(args[2]);
735
736 for (; *appctx->ctx.env.var; appctx->ctx.env.var++) {
737 if (strncmp(*appctx->ctx.env.var, args[2], len) == 0 &&
738 (*appctx->ctx.env.var)[len] == '=')
739 break;
740 }
741 if (!*appctx->ctx.env.var) {
742 appctx->ctx.cli.msg = "Variable not found\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100743 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau0a739292016-11-22 20:21:23 +0100744 return 1;
745 }
746 appctx->st2 = STAT_ST_END;
747 }
748 return 0;
749}
750
Willy Tarreau599852e2016-11-22 20:33:32 +0100751/* parse a "set timeout" CLI request. It always returns 1. */
752static int cli_parse_set_timeout(char **args, struct appctx *appctx, void *private)
753{
754 struct stream_interface *si = appctx->owner;
755 struct stream *s = si_strm(si);
756
757 if (strcmp(args[2], "cli") == 0) {
758 unsigned timeout;
759 const char *res;
760
761 if (!*args[3]) {
762 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100763 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +0100764 return 1;
765 }
766
767 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
768 if (res || timeout < 1) {
769 appctx->ctx.cli.msg = "Invalid timeout value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100770 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +0100771 return 1;
772 }
773
774 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
775 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
776 return 1;
777 }
778 else {
779 appctx->ctx.cli.msg = "'set timeout' only supports 'cli'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100780 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +0100781 return 1;
782 }
783}
784
Willy Tarreau2af99412016-11-23 11:10:59 +0100785/* parse a "set maxconn global" command. It always returns 1. */
786static int cli_parse_set_maxconn_global(char **args, struct appctx *appctx, void *private)
787{
788 int v;
789
790 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
791 return 1;
792
793 if (!*args[3]) {
794 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100795 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +0100796 return 1;
797 }
798
799 v = atoi(args[3]);
800 if (v > global.hardmaxconn) {
801 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100802 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +0100803 return 1;
804 }
805
806 /* check for unlimited values */
807 if (v <= 0)
808 v = global.hardmaxconn;
809
810 global.maxconn = v;
811
812 /* Dequeues all of the listeners waiting for a resource */
813 if (!LIST_ISEMPTY(&global_listener_queue))
814 dequeue_all_listeners(&global_listener_queue);
815
816 return 1;
817}
818
Willy Tarreau45c742b2016-11-24 14:51:17 +0100819/* parse a "set rate-limit" command. It always returns 1. */
820static int cli_parse_set_ratelimit(char **args, struct appctx *appctx, void *private)
821{
822 int v;
823 int *res;
824 int mul = 1;
825
826 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
827 return 1;
828
829 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
830 res = &global.cps_lim;
831 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
832 res = &global.sps_lim;
833#ifdef USE_OPENSSL
834 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
835 res = &global.ssl_lim;
836#endif
837 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
838 res = &global.comp_rate_lim;
839 mul = 1024;
840 }
841 else {
842 appctx->ctx.cli.msg =
843 "'set rate-limit' only supports :\n"
844 " - 'connections global' to set the per-process maximum connection rate\n"
845 " - 'sessions global' to set the per-process maximum session rate\n"
846#ifdef USE_OPENSSL
847 " - 'ssl-session global' to set the per-process maximum SSL session rate\n"
848#endif
849 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100850 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +0100851 return 1;
852 }
853
854 if (!*args[4]) {
855 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100856 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +0100857 return 1;
858 }
859
860 v = atoi(args[4]);
861 if (v < 0) {
862 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100863 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +0100864 return 1;
865 }
866
867 *res = v * mul;
868
869 /* Dequeues all of the listeners waiting for a resource */
870 if (!LIST_ISEMPTY(&global_listener_queue))
871 dequeue_all_listeners(&global_listener_queue);
872
873 return 1;
874}
875
William Lallemand74c24fb2016-11-21 17:18:36 +0100876/* parse the "level" argument on the bind lines */
877static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
878{
879 if (!*args[cur_arg + 1]) {
880 memprintf(err, "'%s' : missing level", args[cur_arg]);
881 return ERR_ALERT | ERR_FATAL;
882 }
883
884 if (!strcmp(args[cur_arg+1], "user"))
885 conf->level = ACCESS_LVL_USER;
886 else if (!strcmp(args[cur_arg+1], "operator"))
887 conf->level = ACCESS_LVL_OPER;
888 else if (!strcmp(args[cur_arg+1], "admin"))
889 conf->level = ACCESS_LVL_ADMIN;
890 else {
891 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
892 args[cur_arg], args[cur_arg+1]);
893 return ERR_ALERT | ERR_FATAL;
894 }
895
896 return 0;
897}
898
899static struct applet cli_applet = {
900 .obj_type = OBJ_TYPE_APPLET,
901 .name = "<CLI>", /* used for logging */
902 .fct = cli_io_handler,
903 .release = cli_release_handler,
904};
905
Willy Tarreau0a739292016-11-22 20:21:23 +0100906/* register cli keywords */
907static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau2af99412016-11-23 11:10:59 +0100908 { { "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 +0100909 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Willy Tarreau599852e2016-11-22 20:33:32 +0100910 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +0100911 { { "show", "env", NULL }, "show env [var] : dump environment variables known to the process", cli_parse_show_env, cli_io_handler_show_env, NULL },
912 {{},}
913}};
914
William Lallemand74c24fb2016-11-21 17:18:36 +0100915static struct cfg_kw_list cfg_kws = {ILH, {
916 { CFG_GLOBAL, "stats", stats_parse_global },
917 { 0, NULL, NULL },
918}};
919
920static struct bind_kw_list bind_kws = { "STAT", { }, {
921 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
922 { NULL, NULL, 0 },
923}};
924
925__attribute__((constructor))
926static void __dumpstats_module_init(void)
927{
928 cfg_register_keywords(&cfg_kws);
Willy Tarreau0a739292016-11-22 20:21:23 +0100929 cli_register_kw(&cli_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +0100930 bind_register_keywords(&bind_kws);
931}
932
933/*
934 * Local variables:
935 * c-indent-level: 8
936 * c-basic-offset: 8
937 * End:
938 */