blob: a1923bc4e71719c2bc0a2220f41fb31a5136dd4b [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
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100437 /* unescape '\' */
William Lallemand74c24fb2016-11-21 17:18:36 +0100438 arg = 0;
439 while (*args[arg] != '\0') {
440 j = 0;
441 for (i=0; args[arg][i] != '\0'; i++) {
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100442 if (args[arg][i] == '\\') {
443 if (args[arg][i+1] == '\\')
444 i++;
445 else
446 continue;
447 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100448 args[arg][j] = args[arg][i];
449 j++;
450 }
451 args[arg][j] = '\0';
452 arg++;
453 }
454
455 appctx->ctx.stats.scope_str = 0;
456 appctx->ctx.stats.scope_len = 0;
457 appctx->ctx.stats.flags = 0;
Willy Tarreau41908562016-11-24 16:23:38 +0100458 appctx->st2 = 0;
459
460 kw = cli_find_kw(args);
461 if (!kw || !kw->parse)
462 return 0;
463
464 appctx->io_handler = kw->io_handler;
465 if (kw->parse(args, appctx, kw->private) == 0 && appctx->io_handler) {
466 appctx->st0 = CLI_ST_CALLBACK;
467 appctx->io_release = kw->io_release;
William Lallemand74c24fb2016-11-21 17:18:36 +0100468 }
Willy Tarreau41908562016-11-24 16:23:38 +0100469 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100470}
471
472/* This I/O handler runs as an applet embedded in a stream interface. It is
473 * used to processes I/O from/to the stats unix socket. The system relies on a
474 * state machine handling requests and various responses. We read a request,
475 * then we process it and send the response, and we possibly display a prompt.
476 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100477 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100478 * or not.
479 */
480static void cli_io_handler(struct appctx *appctx)
481{
482 struct stream_interface *si = appctx->owner;
483 struct channel *req = si_oc(si);
484 struct channel *res = si_ic(si);
485 int reql;
486 int len;
487
488 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
489 goto out;
490
491 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100492 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100493 /* Stats output not initialized yet */
494 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100495 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100496 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100497 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100498 /* Let's close for real now. We just close the request
499 * side, the conditions below will complete if needed.
500 */
501 si_shutw(si);
502 break;
503 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100504 else if (appctx->st0 == CLI_ST_GETREQ) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100505 /* ensure we have some output room left in the event we
506 * would want to return some info right after parsing.
507 */
508 if (buffer_almost_full(si_ib(si))) {
509 si_applet_cant_put(si);
510 break;
511 }
512
513 reql = bo_getline(si_oc(si), trash.str, trash.size);
514 if (reql <= 0) { /* closed or EOL not found */
515 if (reql == 0)
516 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100517 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100518 continue;
519 }
520
521 /* seek for a possible unescaped semi-colon. If we find
522 * one, we replace it with an LF and skip only this part.
523 */
524 for (len = 0; len < reql; len++) {
525 if (trash.str[len] == '\\') {
526 len++;
527 continue;
528 }
529 if (trash.str[len] == ';') {
530 trash.str[len] = '\n';
531 reql = len + 1;
532 break;
533 }
534 }
535
536 /* now it is time to check that we have a full line,
537 * remove the trailing \n and possibly \r, then cut the
538 * line.
539 */
540 len = reql - 1;
541 if (trash.str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100542 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100543 continue;
544 }
545
546 if (len && trash.str[len-1] == '\r')
547 len--;
548
549 trash.str[len] = '\0';
550
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100551 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100552 if (len) {
553 if (strcmp(trash.str, "quit") == 0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100554 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100555 continue;
556 }
557 else if (strcmp(trash.str, "prompt") == 0)
558 appctx->st1 = !appctx->st1;
559 else if (strcmp(trash.str, "help") == 0 ||
Willy Tarreau41908562016-11-24 16:23:38 +0100560 !cli_parse_request(appctx, trash.str)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100561 cli_gen_usage_msg();
562 if (dynamic_usage_msg)
563 appctx->ctx.cli.msg = dynamic_usage_msg;
564 else
565 appctx->ctx.cli.msg = stats_sock_usage_msg;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100566 appctx->st0 = CLI_ST_PRINT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100567 }
568 /* NB: stats_sock_parse_request() may have put
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100569 * another CLI_ST_O_* into appctx->st0.
William Lallemand74c24fb2016-11-21 17:18:36 +0100570 */
571 }
572 else if (!appctx->st1) {
573 /* if prompt is disabled, print help on empty lines,
574 * so that the user at least knows how to enable
575 * prompt and find help.
576 */
577 cli_gen_usage_msg();
578 if (dynamic_usage_msg)
579 appctx->ctx.cli.msg = dynamic_usage_msg;
580 else
581 appctx->ctx.cli.msg = stats_sock_usage_msg;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100582 appctx->st0 = CLI_ST_PRINT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100583 }
584
585 /* re-adjust req buffer */
586 bo_skip(si_oc(si), reql);
587 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
588 }
589 else { /* output functions */
590 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100591 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100592 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100593 case CLI_ST_PRINT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100594 if (bi_putstr(si_ic(si), appctx->ctx.cli.msg) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100595 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100596 else
597 si_applet_cant_put(si);
598 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100599 case CLI_ST_PRINT_FREE:
William Lallemand74c24fb2016-11-21 17:18:36 +0100600 if (bi_putstr(si_ic(si), appctx->ctx.cli.err) != -1) {
601 free(appctx->ctx.cli.err);
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100602 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100603 }
604 else
605 si_applet_cant_put(si);
606 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100607 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100608 if (appctx->io_handler)
609 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100610 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100611 if (appctx->io_release) {
612 appctx->io_release(appctx);
613 appctx->io_release = NULL;
614 }
615 }
616 break;
617 default: /* abnormal state */
618 si->flags |= SI_FL_ERR;
619 break;
620 }
621
622 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100623 if (appctx->st0 == CLI_ST_PROMPT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100624 if (bi_putstr(si_ic(si), appctx->st1 ? "\n> " : "\n") != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100625 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100626 else
627 si_applet_cant_put(si);
628 }
629
630 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100631 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100632 break;
633
634 /* Now we close the output if one of the writers did so,
635 * or if we're not in interactive mode and the request
636 * buffer is empty. This still allows pipelined requests
637 * to be sent in non-interactive mode.
638 */
639 if ((res->flags & (CF_SHUTW|CF_SHUTW_NOW)) || (!appctx->st1 && !req->buf->o)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100640 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100641 continue;
642 }
643
644 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100645 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100646 }
647 }
648
649 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
650 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
651 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
652 /* Other side has closed, let's abort if we have no more processing to do
653 * and nothing more to consume. This is comparable to a broken pipe, so
654 * we forward the close to the request side so that it flows upstream to
655 * the client.
656 */
657 si_shutw(si);
658 }
659
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100660 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100661 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
662 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
663 /* We have no more processing to do, and nothing more to send, and
664 * the client side has closed. So we'll forward this state downstream
665 * on the response buffer.
666 */
667 si_shutr(si);
668 res->flags |= CF_READ_NULL;
669 }
670
671 out:
672 DPRINTF(stderr, "%s@%d: st=%d, rqf=%x, rpf=%x, rqh=%d, rqs=%d, rh=%d, rs=%d\n",
673 __FUNCTION__, __LINE__,
674 si->state, req->flags, res->flags, req->buf->i, req->buf->o, res->buf->i, res->buf->o);
675}
676
William Lallemand74c24fb2016-11-21 17:18:36 +0100677/* This is called when the stream interface is closed. For instance, upon an
678 * external abort, we won't call the i/o handler anymore so we may need to
679 * remove back references to the stream currently being dumped.
680 */
681static void cli_release_handler(struct appctx *appctx)
682{
683 if (appctx->io_release) {
684 appctx->io_release(appctx);
685 appctx->io_release = NULL;
686 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100687 else if (appctx->st0 == CLI_ST_PRINT_FREE) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100688 free(appctx->ctx.cli.err);
689 appctx->ctx.cli.err = NULL;
690 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100691}
692
693/* This function dumps all environmnent variables to the buffer. It returns 0
694 * if the output buffer is full and it needs to be called again, otherwise
695 * non-zero. Dumps only one entry if st2 == STAT_ST_END.
696 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100697static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100698{
Willy Tarreau0a739292016-11-22 20:21:23 +0100699 struct stream_interface *si = appctx->owner;
William Lallemand74c24fb2016-11-21 17:18:36 +0100700
701 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
702 return 1;
703
704 chunk_reset(&trash);
705
706 /* we have two inner loops here, one for the proxy, the other one for
707 * the buffer.
708 */
709 while (*appctx->ctx.env.var) {
710 chunk_printf(&trash, "%s\n", *appctx->ctx.env.var);
711
712 if (bi_putchk(si_ic(si), &trash) == -1) {
713 si_applet_cant_put(si);
714 return 0;
715 }
716 if (appctx->st2 == STAT_ST_END)
717 break;
718 appctx->ctx.env.var++;
719 }
720
721 /* dump complete */
722 return 1;
723}
724
Willy Tarreau0a739292016-11-22 20:21:23 +0100725/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
726 * wants to stop here.
727 */
728static int cli_parse_show_env(char **args, struct appctx *appctx, void *private)
729{
730 extern char **environ;
731
732 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
733 return 1;
734
735 appctx->ctx.env.var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +0100736
737 if (*args[2]) {
738 int len = strlen(args[2]);
739
740 for (; *appctx->ctx.env.var; appctx->ctx.env.var++) {
741 if (strncmp(*appctx->ctx.env.var, args[2], len) == 0 &&
742 (*appctx->ctx.env.var)[len] == '=')
743 break;
744 }
745 if (!*appctx->ctx.env.var) {
746 appctx->ctx.cli.msg = "Variable not found\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100747 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau0a739292016-11-22 20:21:23 +0100748 return 1;
749 }
750 appctx->st2 = STAT_ST_END;
751 }
752 return 0;
753}
754
Willy Tarreau599852e2016-11-22 20:33:32 +0100755/* parse a "set timeout" CLI request. It always returns 1. */
756static int cli_parse_set_timeout(char **args, struct appctx *appctx, void *private)
757{
758 struct stream_interface *si = appctx->owner;
759 struct stream *s = si_strm(si);
760
761 if (strcmp(args[2], "cli") == 0) {
762 unsigned timeout;
763 const char *res;
764
765 if (!*args[3]) {
766 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100767 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +0100768 return 1;
769 }
770
771 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
772 if (res || timeout < 1) {
773 appctx->ctx.cli.msg = "Invalid timeout value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100774 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +0100775 return 1;
776 }
777
778 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
779 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
780 return 1;
781 }
782 else {
783 appctx->ctx.cli.msg = "'set timeout' only supports 'cli'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100784 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +0100785 return 1;
786 }
787}
788
Willy Tarreau2af99412016-11-23 11:10:59 +0100789/* parse a "set maxconn global" command. It always returns 1. */
790static int cli_parse_set_maxconn_global(char **args, struct appctx *appctx, void *private)
791{
792 int v;
793
794 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
795 return 1;
796
797 if (!*args[3]) {
798 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100799 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +0100800 return 1;
801 }
802
803 v = atoi(args[3]);
804 if (v > global.hardmaxconn) {
805 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100806 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +0100807 return 1;
808 }
809
810 /* check for unlimited values */
811 if (v <= 0)
812 v = global.hardmaxconn;
813
814 global.maxconn = v;
815
816 /* Dequeues all of the listeners waiting for a resource */
817 if (!LIST_ISEMPTY(&global_listener_queue))
818 dequeue_all_listeners(&global_listener_queue);
819
820 return 1;
821}
822
Willy Tarreau45c742b2016-11-24 14:51:17 +0100823/* parse a "set rate-limit" command. It always returns 1. */
824static int cli_parse_set_ratelimit(char **args, struct appctx *appctx, void *private)
825{
826 int v;
827 int *res;
828 int mul = 1;
829
830 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
831 return 1;
832
833 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
834 res = &global.cps_lim;
835 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
836 res = &global.sps_lim;
837#ifdef USE_OPENSSL
838 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
839 res = &global.ssl_lim;
840#endif
841 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
842 res = &global.comp_rate_lim;
843 mul = 1024;
844 }
845 else {
846 appctx->ctx.cli.msg =
847 "'set rate-limit' only supports :\n"
848 " - 'connections global' to set the per-process maximum connection rate\n"
849 " - 'sessions global' to set the per-process maximum session rate\n"
850#ifdef USE_OPENSSL
851 " - 'ssl-session global' to set the per-process maximum SSL session rate\n"
852#endif
853 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100854 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +0100855 return 1;
856 }
857
858 if (!*args[4]) {
859 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100860 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +0100861 return 1;
862 }
863
864 v = atoi(args[4]);
865 if (v < 0) {
866 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100867 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +0100868 return 1;
869 }
870
871 *res = v * mul;
872
873 /* Dequeues all of the listeners waiting for a resource */
874 if (!LIST_ISEMPTY(&global_listener_queue))
875 dequeue_all_listeners(&global_listener_queue);
876
877 return 1;
878}
879
William Lallemand74c24fb2016-11-21 17:18:36 +0100880/* parse the "level" argument on the bind lines */
881static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
882{
883 if (!*args[cur_arg + 1]) {
884 memprintf(err, "'%s' : missing level", args[cur_arg]);
885 return ERR_ALERT | ERR_FATAL;
886 }
887
888 if (!strcmp(args[cur_arg+1], "user"))
889 conf->level = ACCESS_LVL_USER;
890 else if (!strcmp(args[cur_arg+1], "operator"))
891 conf->level = ACCESS_LVL_OPER;
892 else if (!strcmp(args[cur_arg+1], "admin"))
893 conf->level = ACCESS_LVL_ADMIN;
894 else {
895 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
896 args[cur_arg], args[cur_arg+1]);
897 return ERR_ALERT | ERR_FATAL;
898 }
899
900 return 0;
901}
902
903static struct applet cli_applet = {
904 .obj_type = OBJ_TYPE_APPLET,
905 .name = "<CLI>", /* used for logging */
906 .fct = cli_io_handler,
907 .release = cli_release_handler,
908};
909
Willy Tarreau0a739292016-11-22 20:21:23 +0100910/* register cli keywords */
911static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau2af99412016-11-23 11:10:59 +0100912 { { "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 +0100913 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Willy Tarreau599852e2016-11-22 20:33:32 +0100914 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +0100915 { { "show", "env", NULL }, "show env [var] : dump environment variables known to the process", cli_parse_show_env, cli_io_handler_show_env, NULL },
916 {{},}
917}};
918
William Lallemand74c24fb2016-11-21 17:18:36 +0100919static struct cfg_kw_list cfg_kws = {ILH, {
920 { CFG_GLOBAL, "stats", stats_parse_global },
921 { 0, NULL, NULL },
922}};
923
924static struct bind_kw_list bind_kws = { "STAT", { }, {
925 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
926 { NULL, NULL, 0 },
927}};
928
929__attribute__((constructor))
930static void __dumpstats_module_init(void)
931{
932 cfg_register_keywords(&cfg_kws);
Willy Tarreau0a739292016-11-22 20:21:23 +0100933 cli_register_kw(&cli_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +0100934 bind_register_keywords(&bind_kws);
935}
936
937/*
938 * Local variables:
939 * c-indent-level: 8
940 * c-basic-offset: 8
941 * End:
942 */