blob: 12556bc1160c680876467826f3d82b76e176fc7c [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.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100401 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
402 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100403 */
Willy Tarreau41908562016-11-24 16:23:38 +0100404static int cli_parse_request(struct appctx *appctx, char *line)
William Lallemand74c24fb2016-11-21 17:18:36 +0100405{
William Lallemand74c24fb2016-11-21 17:18:36 +0100406 char *args[MAX_STATS_ARGS + 1];
407 struct cli_kw *kw;
408 int arg;
409 int i, j;
410
411 while (isspace((unsigned char)*line))
412 line++;
413
414 arg = 0;
415 args[arg] = line;
416
417 while (*line && arg < MAX_STATS_ARGS) {
418 if (*line == '\\') {
419 line++;
420 if (*line == '\0')
421 break;
422 }
423 else if (isspace((unsigned char)*line)) {
424 *line++ = '\0';
425
426 while (isspace((unsigned char)*line))
427 line++;
428
429 args[++arg] = line;
430 continue;
431 }
432
433 line++;
434 }
435
436 while (++arg <= MAX_STATS_ARGS)
437 args[arg] = line;
438
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100439 /* unescape '\' */
William Lallemand74c24fb2016-11-21 17:18:36 +0100440 arg = 0;
441 while (*args[arg] != '\0') {
442 j = 0;
443 for (i=0; args[arg][i] != '\0'; i++) {
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100444 if (args[arg][i] == '\\') {
445 if (args[arg][i+1] == '\\')
446 i++;
447 else
448 continue;
449 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100450 args[arg][j] = args[arg][i];
451 j++;
452 }
453 args[arg][j] = '\0';
454 arg++;
455 }
456
457 appctx->ctx.stats.scope_str = 0;
458 appctx->ctx.stats.scope_len = 0;
459 appctx->ctx.stats.flags = 0;
Willy Tarreau41908562016-11-24 16:23:38 +0100460 appctx->st2 = 0;
461
462 kw = cli_find_kw(args);
Willy Tarreaueaffde32016-12-16 17:59:25 +0100463 if (!kw)
Willy Tarreau41908562016-11-24 16:23:38 +0100464 return 0;
465
466 appctx->io_handler = kw->io_handler;
Willy Tarreaueaffde32016-12-16 17:59:25 +0100467 if ((!kw->parse || kw->parse(args, appctx, kw->private) == 0) && appctx->io_handler) {
Willy Tarreau41908562016-11-24 16:23:38 +0100468 appctx->st0 = CLI_ST_CALLBACK;
469 appctx->io_release = kw->io_release;
William Lallemand74c24fb2016-11-21 17:18:36 +0100470 }
Willy Tarreau41908562016-11-24 16:23:38 +0100471 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100472}
473
474/* This I/O handler runs as an applet embedded in a stream interface. It is
475 * used to processes I/O from/to the stats unix socket. The system relies on a
476 * state machine handling requests and various responses. We read a request,
477 * then we process it and send the response, and we possibly display a prompt.
478 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100479 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100480 * or not.
481 */
482static void cli_io_handler(struct appctx *appctx)
483{
484 struct stream_interface *si = appctx->owner;
485 struct channel *req = si_oc(si);
486 struct channel *res = si_ic(si);
487 int reql;
488 int len;
489
490 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
491 goto out;
492
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100493 /* Check if the input buffer is avalaible. */
494 if (res->buf->size == 0) {
495 si_applet_cant_put(si);
496 goto out;
497 }
498
William Lallemand74c24fb2016-11-21 17:18:36 +0100499 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100500 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100501 /* Stats output not initialized yet */
502 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100503 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100504 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100505 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100506 /* Let's close for real now. We just close the request
507 * side, the conditions below will complete if needed.
508 */
509 si_shutw(si);
510 break;
511 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100512 else if (appctx->st0 == CLI_ST_GETREQ) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100513 /* ensure we have some output room left in the event we
514 * would want to return some info right after parsing.
515 */
516 if (buffer_almost_full(si_ib(si))) {
517 si_applet_cant_put(si);
518 break;
519 }
520
521 reql = bo_getline(si_oc(si), trash.str, trash.size);
522 if (reql <= 0) { /* closed or EOL not found */
523 if (reql == 0)
524 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100525 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100526 continue;
527 }
528
529 /* seek for a possible unescaped semi-colon. If we find
530 * one, we replace it with an LF and skip only this part.
531 */
532 for (len = 0; len < reql; len++) {
533 if (trash.str[len] == '\\') {
534 len++;
535 continue;
536 }
537 if (trash.str[len] == ';') {
538 trash.str[len] = '\n';
539 reql = len + 1;
540 break;
541 }
542 }
543
544 /* now it is time to check that we have a full line,
545 * remove the trailing \n and possibly \r, then cut the
546 * line.
547 */
548 len = reql - 1;
549 if (trash.str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100550 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100551 continue;
552 }
553
554 if (len && trash.str[len-1] == '\r')
555 len--;
556
557 trash.str[len] = '\0';
558
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100559 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100560 if (len) {
561 if (strcmp(trash.str, "quit") == 0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100562 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100563 continue;
564 }
565 else if (strcmp(trash.str, "prompt") == 0)
566 appctx->st1 = !appctx->st1;
567 else if (strcmp(trash.str, "help") == 0 ||
Willy Tarreau41908562016-11-24 16:23:38 +0100568 !cli_parse_request(appctx, trash.str)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100569 cli_gen_usage_msg();
570 if (dynamic_usage_msg)
571 appctx->ctx.cli.msg = dynamic_usage_msg;
572 else
573 appctx->ctx.cli.msg = stats_sock_usage_msg;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100574 appctx->st0 = CLI_ST_PRINT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100575 }
576 /* NB: stats_sock_parse_request() may have put
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100577 * another CLI_ST_O_* into appctx->st0.
William Lallemand74c24fb2016-11-21 17:18:36 +0100578 */
579 }
580 else if (!appctx->st1) {
581 /* if prompt is disabled, print help on empty lines,
582 * so that the user at least knows how to enable
583 * prompt and find help.
584 */
585 cli_gen_usage_msg();
586 if (dynamic_usage_msg)
587 appctx->ctx.cli.msg = dynamic_usage_msg;
588 else
589 appctx->ctx.cli.msg = stats_sock_usage_msg;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100590 appctx->st0 = CLI_ST_PRINT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100591 }
592
593 /* re-adjust req buffer */
594 bo_skip(si_oc(si), reql);
595 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
596 }
597 else { /* output functions */
598 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100599 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100600 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100601 case CLI_ST_PRINT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100602 if (bi_putstr(si_ic(si), appctx->ctx.cli.msg) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100603 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100604 else
605 si_applet_cant_put(si);
606 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100607 case CLI_ST_PRINT_FREE:
William Lallemand74c24fb2016-11-21 17:18:36 +0100608 if (bi_putstr(si_ic(si), appctx->ctx.cli.err) != -1) {
609 free(appctx->ctx.cli.err);
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100610 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100611 }
612 else
613 si_applet_cant_put(si);
614 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100615 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100616 if (appctx->io_handler)
617 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100618 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100619 if (appctx->io_release) {
620 appctx->io_release(appctx);
621 appctx->io_release = NULL;
622 }
623 }
624 break;
625 default: /* abnormal state */
626 si->flags |= SI_FL_ERR;
627 break;
628 }
629
630 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100631 if (appctx->st0 == CLI_ST_PROMPT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100632 if (bi_putstr(si_ic(si), appctx->st1 ? "\n> " : "\n") != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100633 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100634 else
635 si_applet_cant_put(si);
636 }
637
638 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100639 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100640 break;
641
642 /* Now we close the output if one of the writers did so,
643 * or if we're not in interactive mode and the request
644 * buffer is empty. This still allows pipelined requests
645 * to be sent in non-interactive mode.
646 */
647 if ((res->flags & (CF_SHUTW|CF_SHUTW_NOW)) || (!appctx->st1 && !req->buf->o)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100648 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100649 continue;
650 }
651
652 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100653 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100654 }
655 }
656
657 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
658 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
659 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
660 /* Other side has closed, let's abort if we have no more processing to do
661 * and nothing more to consume. This is comparable to a broken pipe, so
662 * we forward the close to the request side so that it flows upstream to
663 * the client.
664 */
665 si_shutw(si);
666 }
667
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100668 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100669 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
670 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
671 /* We have no more processing to do, and nothing more to send, and
672 * the client side has closed. So we'll forward this state downstream
673 * on the response buffer.
674 */
675 si_shutr(si);
676 res->flags |= CF_READ_NULL;
677 }
678
679 out:
680 DPRINTF(stderr, "%s@%d: st=%d, rqf=%x, rpf=%x, rqh=%d, rqs=%d, rh=%d, rs=%d\n",
681 __FUNCTION__, __LINE__,
682 si->state, req->flags, res->flags, req->buf->i, req->buf->o, res->buf->i, res->buf->o);
683}
684
William Lallemand74c24fb2016-11-21 17:18:36 +0100685/* This is called when the stream interface is closed. For instance, upon an
686 * external abort, we won't call the i/o handler anymore so we may need to
687 * remove back references to the stream currently being dumped.
688 */
689static void cli_release_handler(struct appctx *appctx)
690{
691 if (appctx->io_release) {
692 appctx->io_release(appctx);
693 appctx->io_release = NULL;
694 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100695 else if (appctx->st0 == CLI_ST_PRINT_FREE) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100696 free(appctx->ctx.cli.err);
697 appctx->ctx.cli.err = NULL;
698 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100699}
700
701/* This function dumps all environmnent variables to the buffer. It returns 0
702 * if the output buffer is full and it needs to be called again, otherwise
703 * non-zero. Dumps only one entry if st2 == STAT_ST_END.
704 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100705static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100706{
Willy Tarreau0a739292016-11-22 20:21:23 +0100707 struct stream_interface *si = appctx->owner;
William Lallemand74c24fb2016-11-21 17:18:36 +0100708
709 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
710 return 1;
711
712 chunk_reset(&trash);
713
714 /* we have two inner loops here, one for the proxy, the other one for
715 * the buffer.
716 */
717 while (*appctx->ctx.env.var) {
718 chunk_printf(&trash, "%s\n", *appctx->ctx.env.var);
719
720 if (bi_putchk(si_ic(si), &trash) == -1) {
721 si_applet_cant_put(si);
722 return 0;
723 }
724 if (appctx->st2 == STAT_ST_END)
725 break;
726 appctx->ctx.env.var++;
727 }
728
729 /* dump complete */
730 return 1;
731}
732
William Lallemandeceddf72016-12-15 18:06:44 +0100733/*
734 * CLI IO handler for `show cli sockets`
735 */
736static int cli_io_handler_show_cli_sock(struct appctx *appctx)
737{
738 struct bind_conf *bind_conf;
739 struct stream_interface *si = appctx->owner;
740
741 chunk_reset(&trash);
742
743 switch (appctx->st2) {
744 case STAT_ST_INIT:
745 chunk_printf(&trash, "# socket lvl processes\n");
746 if (bi_putchk(si_ic(si), &trash) == -1) {
747 si_applet_cant_put(si);
748 return 0;
749 }
750 appctx->ctx.cli_socket = NULL;
751 appctx->st2 = STAT_ST_LIST;
752
753 case STAT_ST_LIST:
754 if (global.stats_fe) {
755 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
756 struct listener *l;
757
758 /*
759 * get the latest dumped node in appctx->ctx.cli_socket
760 * if the current node is the first of the list
761 */
762
763 if (appctx->ctx.cli_socket &&
764 &bind_conf->by_fe == (&global.stats_fe->conf.bind)->n
765 ) {
766 /* change the current node to the latest dumped and continue the loop */
767 bind_conf = LIST_ELEM(appctx->ctx.cli_socket, typeof(bind_conf), by_fe);
768 continue;
769 }
770
771 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
772
773 char addr[46];
774 char port[6];
775
776 if (l->addr.ss_family == AF_UNIX) {
777 const struct sockaddr_un *un;
778
779 un = (struct sockaddr_un *)&l->addr;
780 chunk_appendf(&trash, "%s ", un->sun_path);
781 } else if (l->addr.ss_family == AF_INET) {
782 addr_to_str(&l->addr, addr, sizeof(addr));
783 port_to_str(&l->addr, port, sizeof(port));
784 chunk_appendf(&trash, "%s:%s ", addr, port);
785 } else if (l->addr.ss_family == AF_INET6) {
786 addr_to_str(&l->addr, addr, sizeof(addr));
787 port_to_str(&l->addr, port, sizeof(port));
788 chunk_appendf(&trash, "[%s]:%s ", addr, port);
789 } else
790 continue;
791
792 if (bind_conf->level == ACCESS_LVL_USER)
793 chunk_appendf(&trash, "user ");
794 else if (bind_conf->level == ACCESS_LVL_OPER)
795 chunk_appendf(&trash, "operator ");
796 else if (bind_conf->level == ACCESS_LVL_ADMIN)
797 chunk_appendf(&trash, "admin ");
798 else
799 chunk_appendf(&trash, " ");
800
801 if (bind_conf->bind_proc != 0) {
802 int pos;
Willy Tarreau20c5e522016-12-16 12:50:55 +0100803 for (pos = 0; pos < 8 * sizeof(bind_conf->bind_proc); pos++) {
Willy Tarreau4305ac72016-12-16 12:56:31 +0100804 if (bind_conf->bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +0100805 chunk_appendf(&trash, "%d,", pos+1);
806 }
807 }
808 /* replace the latest comma by a newline */
809 trash.str[trash.len-1] = '\n';
810
811 } else {
812 chunk_appendf(&trash, "all\n");
813 }
814
815 if (bi_putchk(si_ic(si), &trash) == -1) {
816 si_applet_cant_put(si);
817 return 0;
818 }
819 }
820 appctx->ctx.cli_socket = &bind_conf->by_fe; /* store the latest list node dumped */
821 }
822 }
823 default:
824 appctx->st2 = STAT_ST_FIN;
825 return 1;
826 }
827}
828
829
Willy Tarreau0a739292016-11-22 20:21:23 +0100830/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
831 * wants to stop here.
832 */
833static int cli_parse_show_env(char **args, struct appctx *appctx, void *private)
834{
835 extern char **environ;
836
837 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
838 return 1;
839
840 appctx->ctx.env.var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +0100841
842 if (*args[2]) {
843 int len = strlen(args[2]);
844
845 for (; *appctx->ctx.env.var; appctx->ctx.env.var++) {
846 if (strncmp(*appctx->ctx.env.var, args[2], len) == 0 &&
847 (*appctx->ctx.env.var)[len] == '=')
848 break;
849 }
850 if (!*appctx->ctx.env.var) {
851 appctx->ctx.cli.msg = "Variable not found\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100852 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau0a739292016-11-22 20:21:23 +0100853 return 1;
854 }
855 appctx->st2 = STAT_ST_END;
856 }
857 return 0;
858}
859
Willy Tarreau599852e2016-11-22 20:33:32 +0100860/* parse a "set timeout" CLI request. It always returns 1. */
861static int cli_parse_set_timeout(char **args, struct appctx *appctx, void *private)
862{
863 struct stream_interface *si = appctx->owner;
864 struct stream *s = si_strm(si);
865
866 if (strcmp(args[2], "cli") == 0) {
867 unsigned timeout;
868 const char *res;
869
870 if (!*args[3]) {
871 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100872 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +0100873 return 1;
874 }
875
876 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
877 if (res || timeout < 1) {
878 appctx->ctx.cli.msg = "Invalid timeout value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100879 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +0100880 return 1;
881 }
882
883 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
884 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
885 return 1;
886 }
887 else {
888 appctx->ctx.cli.msg = "'set timeout' only supports 'cli'.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100889 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau599852e2016-11-22 20:33:32 +0100890 return 1;
891 }
892}
893
Willy Tarreau2af99412016-11-23 11:10:59 +0100894/* parse a "set maxconn global" command. It always returns 1. */
895static int cli_parse_set_maxconn_global(char **args, struct appctx *appctx, void *private)
896{
897 int v;
898
899 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
900 return 1;
901
902 if (!*args[3]) {
903 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100904 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +0100905 return 1;
906 }
907
908 v = atoi(args[3]);
909 if (v > global.hardmaxconn) {
910 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100911 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau2af99412016-11-23 11:10:59 +0100912 return 1;
913 }
914
915 /* check for unlimited values */
916 if (v <= 0)
917 v = global.hardmaxconn;
918
919 global.maxconn = v;
920
921 /* Dequeues all of the listeners waiting for a resource */
922 if (!LIST_ISEMPTY(&global_listener_queue))
923 dequeue_all_listeners(&global_listener_queue);
924
925 return 1;
926}
927
William Lallemandeceddf72016-12-15 18:06:44 +0100928
929int cli_parse_default(char **args, struct appctx *appctx, void *private)
930{
931 return 0;
932}
933
Willy Tarreau45c742b2016-11-24 14:51:17 +0100934/* parse a "set rate-limit" command. It always returns 1. */
935static int cli_parse_set_ratelimit(char **args, struct appctx *appctx, void *private)
936{
937 int v;
938 int *res;
939 int mul = 1;
940
941 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
942 return 1;
943
944 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
945 res = &global.cps_lim;
946 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
947 res = &global.sps_lim;
948#ifdef USE_OPENSSL
949 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
950 res = &global.ssl_lim;
951#endif
952 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
953 res = &global.comp_rate_lim;
954 mul = 1024;
955 }
956 else {
957 appctx->ctx.cli.msg =
958 "'set rate-limit' only supports :\n"
959 " - 'connections global' to set the per-process maximum connection rate\n"
960 " - 'sessions global' to set the per-process maximum session rate\n"
961#ifdef USE_OPENSSL
962 " - 'ssl-session global' to set the per-process maximum SSL session rate\n"
963#endif
964 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100965 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +0100966 return 1;
967 }
968
969 if (!*args[4]) {
970 appctx->ctx.cli.msg = "Expects an integer value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100971 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +0100972 return 1;
973 }
974
975 v = atoi(args[4]);
976 if (v < 0) {
977 appctx->ctx.cli.msg = "Value out of range.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100978 appctx->st0 = CLI_ST_PRINT;
Willy Tarreau45c742b2016-11-24 14:51:17 +0100979 return 1;
980 }
981
982 *res = v * mul;
983
984 /* Dequeues all of the listeners waiting for a resource */
985 if (!LIST_ISEMPTY(&global_listener_queue))
986 dequeue_all_listeners(&global_listener_queue);
987
988 return 1;
989}
990
William Lallemand74c24fb2016-11-21 17:18:36 +0100991/* parse the "level" argument on the bind lines */
992static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
993{
994 if (!*args[cur_arg + 1]) {
995 memprintf(err, "'%s' : missing level", args[cur_arg]);
996 return ERR_ALERT | ERR_FATAL;
997 }
998
999 if (!strcmp(args[cur_arg+1], "user"))
1000 conf->level = ACCESS_LVL_USER;
1001 else if (!strcmp(args[cur_arg+1], "operator"))
1002 conf->level = ACCESS_LVL_OPER;
1003 else if (!strcmp(args[cur_arg+1], "admin"))
1004 conf->level = ACCESS_LVL_ADMIN;
1005 else {
1006 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1007 args[cur_arg], args[cur_arg+1]);
1008 return ERR_ALERT | ERR_FATAL;
1009 }
1010
1011 return 0;
1012}
1013
1014static struct applet cli_applet = {
1015 .obj_type = OBJ_TYPE_APPLET,
1016 .name = "<CLI>", /* used for logging */
1017 .fct = cli_io_handler,
1018 .release = cli_release_handler,
1019};
1020
Willy Tarreau0a739292016-11-22 20:21:23 +01001021/* register cli keywords */
1022static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau2af99412016-11-23 11:10:59 +01001023 { { "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 +01001024 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Willy Tarreau599852e2016-11-22 20:33:32 +01001025 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01001026 { { "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 +01001027 { { "show", "cli", "sockets", NULL }, "show cli sockets : dump list of cli sockets", cli_parse_default, cli_io_handler_show_cli_sock, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01001028 {{},}
1029}};
1030
William Lallemand74c24fb2016-11-21 17:18:36 +01001031static struct cfg_kw_list cfg_kws = {ILH, {
1032 { CFG_GLOBAL, "stats", stats_parse_global },
1033 { 0, NULL, NULL },
1034}};
1035
1036static struct bind_kw_list bind_kws = { "STAT", { }, {
1037 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
1038 { NULL, NULL, 0 },
1039}};
1040
1041__attribute__((constructor))
1042static void __dumpstats_module_init(void)
1043{
1044 cfg_register_keywords(&cfg_kws);
Willy Tarreau0a739292016-11-22 20:21:23 +01001045 cli_register_kw(&cli_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01001046 bind_register_keywords(&bind_kws);
1047}
1048
1049/*
1050 * Local variables:
1051 * c-indent-level: 8
1052 * c-basic-offset: 8
1053 * End:
1054 */