blob: 04c4e7a1962bdcdc70cd12bc62c607ec376ddae0 [file] [log] [blame]
William Lallemand74c24fb2016-11-21 17:18:36 +01001/*
2 * Functions dedicated to statistics output and the stats socket
3 *
4 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
5 * Copyright 2007-2009 Krzysztof Piotr Oledzki <ole@ans.pl>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 */
13
14#include <ctype.h>
15#include <errno.h>
16#include <fcntl.h>
17#include <stdio.h>
18#include <stdlib.h>
19#include <string.h>
20#include <pwd.h>
21#include <grp.h>
22
23#include <sys/socket.h>
24#include <sys/stat.h>
25#include <sys/types.h>
26
Olivier Houchardf886e342017-04-05 22:24:59 +020027#include <net/if.h>
28
Willy Tarreaub2551052020-06-09 09:07:15 +020029#include <haproxy/activity.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020030#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020031#include <haproxy/applet-t.h>
32#include <haproxy/base64.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020033#include <haproxy/cfgparse.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020034#include <haproxy/channel.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020035#include <haproxy/check.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020036#include <haproxy/cli.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020037#include <haproxy/compression.h>
Willy Tarreaueb92deb2020-06-04 10:53:16 +020038#include <haproxy/dns-t.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020039#include <haproxy/errors.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020040#include <haproxy/fd.h>
41#include <haproxy/freq_ctr.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020042#include <haproxy/frontend.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020043#include <haproxy/global.h>
Willy Tarreau853b2972020-05-27 18:01:47 +020044#include <haproxy/list.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020045#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020046#include <haproxy/log.h>
Willy Tarreaub5abe5b2020-06-04 14:07:37 +020047#include <haproxy/mworker-t.h>
Willy Tarreau225a90a2020-06-04 15:06:28 +020048#include <haproxy/pattern-t.h>
Willy Tarreau3c2a7c22020-06-04 18:38:21 +020049#include <haproxy/peers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020050#include <haproxy/pipe.h>
51#include <haproxy/protocol.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020052#include <haproxy/proxy.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020053#include <haproxy/sample-t.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020054#include <haproxy/server.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020055#include <haproxy/session.h>
Willy Tarreaua74cb382020-10-15 21:29:49 +020056#include <haproxy/sock.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020057#include <haproxy/stats-t.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020058#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020059#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020060#include <haproxy/task.h>
Willy Tarreauc2f7c582020-06-02 18:15:32 +020061#include <haproxy/ticks.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020062#include <haproxy/time.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020063#include <haproxy/tools.h>
Willy Tarreaud6788052020-05-27 15:59:00 +020064#include <haproxy/version.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010065
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020066#define PAYLOAD_PATTERN "<<"
67
William Lallemand74c24fb2016-11-21 17:18:36 +010068static struct applet cli_applet;
William Lallemand99e0bb92020-11-05 10:28:53 +010069static struct applet mcli_applet;
William Lallemand74c24fb2016-11-21 17:18:36 +010070
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
Christopher Faulet1bc04c72017-10-29 20:14:08 +010083static THREAD_LOCAL char *dynamic_usage_msg = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +010084
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
William Lallemand8a022572018-10-26 14:47:35 +020092static struct proxy *mworker_proxy; /* CLI proxy of the master */
93
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020094static char *cli_gen_usage_msg(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +010095{
96 struct cli_kw_list *kw_list;
97 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +020098 struct buffer *tmp = get_trash_chunk();
99 struct buffer out;
William Lallemand74c24fb2016-11-21 17:18:36 +0100100
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100101 ha_free(&dynamic_usage_msg);
William Lallemand74c24fb2016-11-21 17:18:36 +0100102
103 if (LIST_ISEMPTY(&cli_keywords.list))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200104 goto end;
William Lallemand74c24fb2016-11-21 17:18:36 +0100105
106 chunk_reset(tmp);
107 chunk_strcat(tmp, stats_sock_usage_msg);
108 list_for_each_entry(kw_list, &cli_keywords.list, list) {
109 kw = &kw_list->kw[0];
William Lallemand0154edc2018-05-15 11:50:04 +0200110 while (kw->str_kw[0]) {
William Lallemand14721be2018-10-26 14:47:37 +0200111
112 /* in a worker or normal process, don't display master only commands */
William Lallemand99e0bb92020-11-05 10:28:53 +0100113 if (appctx->applet == &cli_applet && (kw->level & ACCESS_MASTER_ONLY))
William Lallemand14721be2018-10-26 14:47:37 +0200114 goto next_kw;
115
116 /* in master don't displays if we don't have the master bits */
William Lallemand99e0bb92020-11-05 10:28:53 +0100117 if (appctx->applet == &mcli_applet && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
William Lallemand14721be2018-10-26 14:47:37 +0200118 goto next_kw;
119
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200120 /* only show expert commands in expert mode */
121 if ((kw->level & ~appctx->cli_level) & ACCESS_EXPERT)
122 goto next_kw;
123
William Lallemand0154edc2018-05-15 11:50:04 +0200124 if (kw->usage)
125 chunk_appendf(tmp, " %s\n", kw->usage);
William Lallemand14721be2018-10-26 14:47:37 +0200126
127next_kw:
128
William Lallemand74c24fb2016-11-21 17:18:36 +0100129 kw++;
130 }
131 }
132 chunk_init(&out, NULL, 0);
133 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200134 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200135
136end:
137 if (dynamic_usage_msg) {
138 appctx->ctx.cli.severity = LOG_INFO;
139 appctx->ctx.cli.msg = dynamic_usage_msg;
140 }
141 else {
142 appctx->ctx.cli.severity = LOG_INFO;
143 appctx->ctx.cli.msg = stats_sock_usage_msg;
144 }
145 appctx->st0 = CLI_ST_PRINT;
146
William Lallemand74c24fb2016-11-21 17:18:36 +0100147 return dynamic_usage_msg;
148}
149
150struct cli_kw* cli_find_kw(char **args)
151{
152 struct cli_kw_list *kw_list;
153 struct cli_kw *kw;/* current cli_kw */
154 char **tmp_args;
155 const char **tmp_str_kw;
156 int found = 0;
157
158 if (LIST_ISEMPTY(&cli_keywords.list))
159 return NULL;
160
161 list_for_each_entry(kw_list, &cli_keywords.list, list) {
162 kw = &kw_list->kw[0];
163 while (*kw->str_kw) {
164 tmp_args = args;
165 tmp_str_kw = kw->str_kw;
166 while (*tmp_str_kw) {
167 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
168 found = 1;
169 } else {
170 found = 0;
171 break;
172 }
173 tmp_args++;
174 tmp_str_kw++;
175 }
176 if (found)
177 return (kw);
178 kw++;
179 }
180 }
181 return NULL;
182}
183
Thierry Fourniera51a1fd2020-11-28 20:10:08 +0100184struct cli_kw* cli_find_kw_exact(char **args)
185{
186 struct cli_kw_list *kw_list;
187 int found = 0;
188 int i;
189 int j;
190
191 if (LIST_ISEMPTY(&cli_keywords.list))
192 return NULL;
193
194 list_for_each_entry(kw_list, &cli_keywords.list, list) {
195 for (i = 0; kw_list->kw[i].str_kw[0]; i++) {
196 found = 1;
197 for (j = 0; j < CLI_PREFIX_KW_NB; j++) {
198 if (args[j] == NULL && kw_list->kw[i].str_kw[j] == NULL) {
199 break;
200 }
201 if (args[j] == NULL || kw_list->kw[i].str_kw[j] == NULL) {
202 found = 0;
203 break;
204 }
205 if (strcmp(args[j], kw_list->kw[i].str_kw[j]) != 0) {
206 found = 0;
207 break;
208 }
209 }
210 if (found)
211 return &kw_list->kw[i];
212 }
213 }
214 return NULL;
215}
216
William Lallemand74c24fb2016-11-21 17:18:36 +0100217void cli_register_kw(struct cli_kw_list *kw_list)
218{
219 LIST_ADDQ(&cli_keywords.list, &kw_list->list);
220}
221
222
223/* allocate a new stats frontend named <name>, and return it
224 * (or NULL in case of lack of memory).
225 */
226static struct proxy *alloc_stats_fe(const char *name, const char *file, int line)
227{
228 struct proxy *fe;
229
230 fe = calloc(1, sizeof(*fe));
231 if (!fe)
232 return NULL;
233
234 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100235 fe->next = proxies_list;
236 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100237 fe->last_change = now.tv_sec;
238 fe->id = strdup("GLOBAL");
239 fe->cap = PR_CAP_FE;
240 fe->maxconn = 10; /* default to 10 concurrent connections */
241 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
242 fe->conf.file = strdup(file);
243 fe->conf.line = line;
244 fe->accept = frontend_accept;
245 fe->default_target = &cli_applet.obj_type;
246
247 /* the stats frontend is the only one able to assign ID #0 */
248 fe->conf.id.key = fe->uuid = 0;
249 eb32_insert(&used_proxy_id, &fe->conf.id);
250 return fe;
251}
252
253/* This function parses a "stats" statement in the "global" section. It returns
254 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
255 * error message into the <err> buffer which will be preallocated. The trailing
256 * '\n' must not be written. The function must be called with <args> pointing to
257 * the first word after "stats".
258 */
259static int stats_parse_global(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +0100260 const struct proxy *defpx, const char *file, int line,
William Lallemand74c24fb2016-11-21 17:18:36 +0100261 char **err)
262{
263 struct bind_conf *bind_conf;
264 struct listener *l;
265
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100266 if (strcmp(args[1], "socket") == 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100267 int cur_arg;
268
269 if (*args[2] == 0) {
270 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
271 return -1;
272 }
273
274 if (!global.stats_fe) {
275 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
276 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
277 return -1;
278 }
279 }
280
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100281 bind_conf = bind_conf_alloc(global.stats_fe, file, line, args[2], xprt_get(XPRT_RAW));
William Lallemand07a62f72017-05-24 00:57:40 +0200282 bind_conf->level &= ~ACCESS_LVL_MASK;
283 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100284
285 if (!str2listener(args[2], global.stats_fe, bind_conf, file, line, err)) {
286 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
287 file, line, args[0], args[1], err && *err ? *err : "error");
288 return -1;
289 }
290
291 cur_arg = 3;
292 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100293 struct bind_kw *kw;
Willy Tarreau433b05f2021-03-12 10:14:07 +0100294 const char *best;
William Lallemand74c24fb2016-11-21 17:18:36 +0100295
296 kw = bind_find_kw(args[cur_arg]);
297 if (kw) {
298 if (!kw->parse) {
299 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
300 args[0], args[1], args[cur_arg]);
301 return -1;
302 }
303
304 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, err) != 0) {
305 if (err && *err)
306 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
307 else
308 memprintf(err, "'%s %s' : error encountered while processing '%s'",
309 args[0], args[1], args[cur_arg]);
310 return -1;
311 }
312
313 cur_arg += 1 + kw->skip;
314 continue;
315 }
316
Willy Tarreau433b05f2021-03-12 10:14:07 +0100317 best = bind_find_best_kw(args[cur_arg]);
318 if (best)
319 memprintf(err, "'%s %s' : unknown keyword '%s'. Did you mean '%s' maybe ?",
320 args[0], args[1], args[cur_arg], best);
321 else
322 memprintf(err, "'%s %s' : unknown keyword '%s'.",
323 args[0], args[1], args[cur_arg]);
William Lallemand74c24fb2016-11-21 17:18:36 +0100324 return -1;
325 }
326
327 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100328 l->accept = session_accept_fd;
William Lallemand74c24fb2016-11-21 17:18:36 +0100329 l->default_target = global.stats_fe->default_target;
330 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
331 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100332 global.maxsock++; /* for the listening socket */
William Lallemand74c24fb2016-11-21 17:18:36 +0100333 }
334 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100335 else if (strcmp(args[1], "timeout") == 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100336 unsigned timeout;
337 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
338
Willy Tarreau9faebe32019-06-07 19:00:37 +0200339 if (res == PARSE_TIME_OVER) {
340 memprintf(err, "timer overflow in argument '%s' to '%s %s' (maximum value is 2147483647 ms or ~24.8 days)",
341 args[2], args[0], args[1]);
342 return -1;
343 }
344 else if (res == PARSE_TIME_UNDER) {
345 memprintf(err, "timer underflow in argument '%s' to '%s %s' (minimum non-null value is 1 ms)",
346 args[2], args[0], args[1]);
347 return -1;
348 }
349 else if (res) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100350 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
351 return -1;
352 }
353
354 if (!timeout) {
355 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
356 return -1;
357 }
358 if (!global.stats_fe) {
359 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
360 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
361 return -1;
362 }
363 }
364 global.stats_fe->timeout.client = MS_TO_TICKS(timeout);
365 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100366 else if (strcmp(args[1], "maxconn") == 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100367 int maxconn = atol(args[2]);
368
369 if (maxconn <= 0) {
370 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
371 return -1;
372 }
373
374 if (!global.stats_fe) {
375 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
376 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
377 return -1;
378 }
379 }
380 global.stats_fe->maxconn = maxconn;
381 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100382 else if (strcmp(args[1], "bind-process") == 0) { /* enable the socket only on some processes */
William Lallemand74c24fb2016-11-21 17:18:36 +0100383 int cur_arg = 2;
384 unsigned long set = 0;
385
386 if (!global.stats_fe) {
387 if ((global.stats_fe = alloc_stats_fe("GLOBAL", file, line)) == NULL) {
388 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
389 return -1;
390 }
391 }
392
393 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100394 if (strcmp(args[cur_arg], "all") == 0) {
395 set = 0;
396 break;
397 }
Willy Tarreauff9c9142019-02-07 10:39:36 +0100398 if (parse_process_number(args[cur_arg], &set, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100399 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100400 return -1;
401 }
402 cur_arg++;
403 }
404 global.stats_fe->bind_proc = set;
405 }
406 else {
407 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
408 return -1;
409 }
410 return 0;
411}
412
William Lallemand33d29e22019-04-01 11:30:06 +0200413/*
William Lallemand9a37fd02019-04-12 16:09:24 +0200414 * This function exports the bound addresses of a <frontend> in the environment
415 * variable <varname>. Those addresses are separated by semicolons and prefixed
416 * with their type (abns@, unix@, sockpair@ etc)
417 * Return -1 upon error, 0 otherwise
William Lallemand33d29e22019-04-01 11:30:06 +0200418 */
William Lallemand9a37fd02019-04-12 16:09:24 +0200419int listeners_setenv(struct proxy *frontend, const char *varname)
William Lallemand33d29e22019-04-01 11:30:06 +0200420{
421 struct buffer *trash = get_trash_chunk();
422 struct bind_conf *bind_conf;
423
William Lallemand9a37fd02019-04-12 16:09:24 +0200424 if (frontend) {
425 list_for_each_entry(bind_conf, &frontend->conf.bind, by_fe) {
William Lallemand33d29e22019-04-01 11:30:06 +0200426 struct listener *l;
427
428 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
429 char addr[46];
430 char port[6];
431
William Lallemand620072b2019-04-12 16:09:25 +0200432 /* separate listener by semicolons */
433 if (trash->data)
434 chunk_appendf(trash, ";");
435
Willy Tarreau37159062020-08-27 07:48:42 +0200436 if (l->rx.addr.ss_family == AF_UNIX) {
William Lallemand33d29e22019-04-01 11:30:06 +0200437 const struct sockaddr_un *un;
438
Willy Tarreau37159062020-08-27 07:48:42 +0200439 un = (struct sockaddr_un *)&l->rx.addr;
William Lallemand33d29e22019-04-01 11:30:06 +0200440 if (un->sun_path[0] == '\0') {
441 chunk_appendf(trash, "abns@%s", un->sun_path+1);
442 } else {
443 chunk_appendf(trash, "unix@%s", un->sun_path);
444 }
Willy Tarreau37159062020-08-27 07:48:42 +0200445 } else if (l->rx.addr.ss_family == AF_INET) {
446 addr_to_str(&l->rx.addr, addr, sizeof(addr));
447 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemand33d29e22019-04-01 11:30:06 +0200448 chunk_appendf(trash, "ipv4@%s:%s", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +0200449 } else if (l->rx.addr.ss_family == AF_INET6) {
450 addr_to_str(&l->rx.addr, addr, sizeof(addr));
451 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemand33d29e22019-04-01 11:30:06 +0200452 chunk_appendf(trash, "ipv6@[%s]:%s", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +0200453 } else if (l->rx.addr.ss_family == AF_CUST_SOCKPAIR) {
454 chunk_appendf(trash, "sockpair@%d", ((struct sockaddr_in *)&l->rx.addr)->sin_addr.s_addr);
William Lallemand33d29e22019-04-01 11:30:06 +0200455 }
William Lallemand33d29e22019-04-01 11:30:06 +0200456 }
457 }
458 trash->area[trash->data++] = '\0';
William Lallemand9a37fd02019-04-12 16:09:24 +0200459 if (setenv(varname, trash->area, 1) < 0)
William Lallemand33d29e22019-04-01 11:30:06 +0200460 return -1;
461 }
462
463 return 0;
464}
465
William Lallemand9a37fd02019-04-12 16:09:24 +0200466int cli_socket_setenv()
467{
468 if (listeners_setenv(global.stats_fe, "HAPROXY_CLI") < 0)
469 return -1;
470 if (listeners_setenv(mworker_proxy, "HAPROXY_MASTER_CLI") < 0)
471 return -1;
472
473 return 0;
474}
475
William Lallemand33d29e22019-04-01 11:30:06 +0200476REGISTER_CONFIG_POSTPARSER("cli", cli_socket_setenv);
477
Willy Tarreaude57a572016-11-23 17:01:39 +0100478/* Verifies that the CLI at least has a level at least as high as <level>
479 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
480 * failure, an error message is prepared and the appctx's state is adjusted
481 * to print it so that a return 1 is enough to abort any processing.
482 */
483int cli_has_level(struct appctx *appctx, int level)
484{
Willy Tarreaude57a572016-11-23 17:01:39 +0100485
William Lallemandf630d012018-12-13 09:05:44 +0100486 if ((appctx->cli_level & ACCESS_LVL_MASK) < level) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200487 cli_err(appctx, stats_permission_denied_msg);
Willy Tarreaude57a572016-11-23 17:01:39 +0100488 return 0;
489 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100490 return 1;
491}
492
William Lallemandb7ea1412018-12-13 09:05:47 +0100493/* same as cli_has_level but for the CLI proxy and without error message */
494int pcli_has_level(struct stream *s, int level)
495{
496 if ((s->pcli_flags & ACCESS_LVL_MASK) < level) {
497 return 0;
498 }
499 return 1;
500}
501
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200502/* Returns severity_output for the current session if set, or default for the socket */
503static int cli_get_severity_output(struct appctx *appctx)
504{
505 if (appctx->cli_severity_output)
506 return appctx->cli_severity_output;
507 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
508}
William Lallemand74c24fb2016-11-21 17:18:36 +0100509
Willy Tarreau41908562016-11-24 16:23:38 +0100510/* Processes the CLI interpreter on the stats socket. This function is called
511 * from the CLI's IO handler running in an appctx context. The function returns 1
512 * if the request was understood, otherwise zero. It is called with appctx->st0
513 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
514 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
515 * have its own I/O handler called again. Most of the time, parsers will only
516 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100517 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
518 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100519 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200520static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100521{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200522 char *args[MAX_STATS_ARGS + 1], *p, *end, *payload = NULL;
523 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100524 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100525
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200526 appctx->st2 = 0;
527 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
William Lallemand74c24fb2016-11-21 17:18:36 +0100528
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200529 p = appctx->chunk->area;
530 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100531
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200532 /*
533 * Get the payload start if there is one.
534 * For the sake of simplicity, the payload pattern is looked up
535 * everywhere from the start of the input but it can only be found
536 * at the end of the first line if APPCTX_CLI_ST1_PAYLOAD is set.
537 *
538 * The input string was zero terminated so it is safe to use
539 * the str*() functions throughout the parsing
540 */
541 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
542 payload = strstr(p, PAYLOAD_PATTERN);
543 end = payload;
544 /* skip the pattern */
545 payload += strlen(PAYLOAD_PATTERN);
546 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100547
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200548 /*
549 * Get pointers on words.
550 * One extra slot is reserved to store a pointer on a null byte.
551 */
552 while (i < MAX_STATS_ARGS && p < end) {
553 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100554
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200555 /* skip leading spaces/tabs */
556 p += strspn(p, " \t");
557 if (!*p)
558 break;
William Lallemand74c24fb2016-11-21 17:18:36 +0100559
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200560 args[i] = p;
Yves Lafonb08c6d02020-06-08 16:08:06 +0200561 while (1) {
562 p += strcspn(p, " \t\\");
563 /* escaped chars using backlashes (\) */
564 if (*p == '\\') {
565 if (!*++p)
566 break;
567 if (!*++p)
568 break;
569 } else {
570 break;
571 }
572 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200573 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100574
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200575 /* unescape backslashes (\) */
576 for (j = 0, k = 0; args[i][k]; k++) {
577 if (args[i][k] == '\\') {
578 if (args[i][k + 1] == '\\')
579 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100580 else
581 continue;
582 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200583 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100584 j++;
585 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200586 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100587
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200588 i++;
589 }
590 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200591 p = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200592 for (; i < MAX_STATS_ARGS + 1; i++)
593 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100594
595 kw = cli_find_kw(args);
Willy Tarreaueaffde32016-12-16 17:59:25 +0100596 if (!kw)
Willy Tarreau41908562016-11-24 16:23:38 +0100597 return 0;
598
William Lallemand14721be2018-10-26 14:47:37 +0200599 /* in a worker or normal process, don't display master only commands */
William Lallemand99e0bb92020-11-05 10:28:53 +0100600 if (appctx->applet == &cli_applet && (kw->level & ACCESS_MASTER_ONLY))
William Lallemand14721be2018-10-26 14:47:37 +0200601 return 0;
602
603 /* in master don't displays if we don't have the master bits */
William Lallemand99e0bb92020-11-05 10:28:53 +0100604 if (appctx->applet == &mcli_applet && !(kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
William Lallemand14721be2018-10-26 14:47:37 +0200605 return 0;
606
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200607 /* only accept expert commands in expert mode */
608 if ((kw->level & ~appctx->cli_level) & ACCESS_EXPERT)
609 return 0;
610
Willy Tarreau41908562016-11-24 16:23:38 +0100611 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200612 appctx->io_release = kw->io_release;
William Lallemand90b098c2019-10-25 21:10:14 +0200613
614 if (kw->parse && kw->parse(args, payload, appctx, kw->private) != 0)
615 goto fail;
616
617 /* kw->parse could set its own io_handler or io_release handler */
618 if (!appctx->io_handler)
619 goto fail;
620
621 appctx->st0 = CLI_ST_CALLBACK;
622 return 1;
623fail:
624 appctx->io_handler = NULL;
625 appctx->io_release = NULL;
Willy Tarreau41908562016-11-24 16:23:38 +0100626 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100627}
628
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200629/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
630static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
631{
Willy Tarreau83061a82018-07-13 11:56:34 +0200632 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200633
634 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200635 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200636
637 tmp = get_trash_chunk();
638 chunk_reset(tmp);
639
640 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100641 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200642 chunk_printf(tmp, "[%d]: ", severity);
643 }
644 else {
645 switch (severity_output) {
646 case CLI_SEVERITY_NUMBER:
647 chunk_printf(tmp, "[%d]: ", severity);
648 break;
649 case CLI_SEVERITY_STRING:
650 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
651 break;
652 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100653 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200654 }
655 }
656 chunk_appendf(tmp, "%s", msg);
657
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200658 return ci_putblk(chn, tmp->area, strlen(tmp->area));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200659}
660
William Lallemand74c24fb2016-11-21 17:18:36 +0100661/* This I/O handler runs as an applet embedded in a stream interface. It is
662 * used to processes I/O from/to the stats unix socket. The system relies on a
663 * state machine handling requests and various responses. We read a request,
664 * then we process it and send the response, and we possibly display a prompt.
665 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100666 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100667 * or not.
668 */
669static void cli_io_handler(struct appctx *appctx)
670{
671 struct stream_interface *si = appctx->owner;
672 struct channel *req = si_oc(si);
673 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200674 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100675 int reql;
676 int len;
677
678 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
679 goto out;
680
Joseph Herlant008b3ce2018-11-25 12:51:45 -0800681 /* Check if the input buffer is available. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200682 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +0100683 /* buf.size==0 means we failed to get a buffer and were
684 * already subscribed to a wait list to get a buffer.
685 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100686 goto out;
687 }
688
William Lallemand74c24fb2016-11-21 17:18:36 +0100689 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100690 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100691 /* Stats output not initialized yet */
692 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200693 /* reset severity to default at init */
694 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100695 appctx->st0 = CLI_ST_GETREQ;
William Lallemandf630d012018-12-13 09:05:44 +0100696 appctx->cli_level = bind_conf->level;
William Lallemand74c24fb2016-11-21 17:18:36 +0100697 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100698 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100699 /* Let's close for real now. We just close the request
700 * side, the conditions below will complete if needed.
701 */
702 si_shutw(si);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200703 free_trash_chunk(appctx->chunk);
William Lallemand74c24fb2016-11-21 17:18:36 +0100704 break;
705 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100706 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200707 char *str;
708
709 /* use a trash chunk to store received data */
710 if (!appctx->chunk) {
711 appctx->chunk = alloc_trash_chunk();
712 if (!appctx->chunk) {
713 appctx->st0 = CLI_ST_END;
714 continue;
715 }
716 }
717
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200718 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200719
William Lallemand74c24fb2016-11-21 17:18:36 +0100720 /* ensure we have some output room left in the event we
721 * would want to return some info right after parsing.
722 */
723 if (buffer_almost_full(si_ib(si))) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100724 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100725 break;
726 }
727
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200728 /* '- 1' is to ensure a null byte can always be inserted at the end */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200729 reql = co_getline(si_oc(si), str,
730 appctx->chunk->size - appctx->chunk->data - 1);
William Lallemand74c24fb2016-11-21 17:18:36 +0100731 if (reql <= 0) { /* closed or EOL not found */
732 if (reql == 0)
733 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100734 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100735 continue;
736 }
737
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200738 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
739 /* seek for a possible unescaped semi-colon. If we find
740 * one, we replace it with an LF and skip only this part.
741 */
742 for (len = 0; len < reql; len++) {
743 if (str[len] == '\\') {
744 len++;
745 continue;
746 }
747 if (str[len] == ';') {
748 str[len] = '\n';
749 reql = len + 1;
750 break;
751 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100752 }
753 }
754
755 /* now it is time to check that we have a full line,
756 * remove the trailing \n and possibly \r, then cut the
757 * line.
758 */
759 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200760 if (str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100761 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100762 continue;
763 }
764
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200765 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100766 len--;
767
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200768 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200769 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200770
771 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200772 appctx->chunk->area[appctx->chunk->data] = '\n';
773 appctx->chunk->area[appctx->chunk->data + 1] = 0;
774 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200775 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100776
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100777 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200778
779 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
780 /* empty line */
781 if (!len) {
782 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200783 appctx->chunk->data -= 2;
784 appctx->chunk->area[appctx->chunk->data] = 0;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200785
786 if (!cli_parse_request(appctx))
787 cli_gen_usage_msg(appctx);
788
789 chunk_reset(appctx->chunk);
790 /* NB: cli_sock_parse_request() may have put
791 * another CLI_ST_O_* into appctx->st0.
792 */
793
794 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +0100795 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100796 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200797 else {
798 /*
799 * Look for the "payload start" pattern at the end of a line
800 * Its location is not remembered here, this is just to switch
801 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +0100802 */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100803 if (strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN) == 0)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200804 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200805 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200806 /* no payload, the command is complete: parse the request */
807 if (!cli_parse_request(appctx))
808 cli_gen_usage_msg(appctx);
809
810 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200811 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100812 }
813
814 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200815 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100816 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
817 }
818 else { /* output functions */
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200819 const char *msg;
820 int sev;
821
William Lallemand74c24fb2016-11-21 17:18:36 +0100822 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100823 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100824 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200825 case CLI_ST_PRINT: /* print const message in msg */
826 case CLI_ST_PRINT_ERR: /* print const error in msg */
827 case CLI_ST_PRINT_DYN: /* print dyn message in msg, free */
828 case CLI_ST_PRINT_FREE: /* print dyn error in err, free */
829 if (appctx->st0 == CLI_ST_PRINT || appctx->st0 == CLI_ST_PRINT_ERR) {
830 sev = appctx->st0 == CLI_ST_PRINT_ERR ?
831 LOG_ERR : appctx->ctx.cli.severity;
832 msg = appctx->ctx.cli.msg;
833 }
834 else if (appctx->st0 == CLI_ST_PRINT_DYN || appctx->st0 == CLI_ST_PRINT_FREE) {
835 sev = appctx->st0 == CLI_ST_PRINT_FREE ?
836 LOG_ERR : appctx->ctx.cli.severity;
837 msg = appctx->ctx.cli.err;
838 if (!msg) {
839 sev = LOG_ERR;
840 msg = "Out of memory.\n";
841 }
842 }
843 else {
844 sev = LOG_ERR;
845 msg = "Internal error.\n";
846 }
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200847
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200848 if (cli_output_msg(res, msg, sev, cli_get_severity_output(appctx)) != -1) {
849 if (appctx->st0 == CLI_ST_PRINT_FREE ||
850 appctx->st0 == CLI_ST_PRINT_DYN) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100851 ha_free(&appctx->ctx.cli.err);
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200852 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100853 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100854 }
855 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100856 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100857 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200858
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100859 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100860 if (appctx->io_handler)
861 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100862 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100863 if (appctx->io_release) {
864 appctx->io_release(appctx);
865 appctx->io_release = NULL;
866 }
867 }
868 break;
869 default: /* abnormal state */
870 si->flags |= SI_FL_ERR;
871 break;
872 }
873
874 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100875 if (appctx->st0 == CLI_ST_PROMPT) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200876 const char *prompt = "";
877
878 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
879 /*
880 * when entering a payload with interactive mode, change the prompt
881 * to emphasize that more data can still be sent
882 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200883 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200884 prompt = "+ ";
885 else
886 prompt = "\n> ";
887 }
888 else {
William Lallemandad032882019-07-01 10:56:15 +0200889 if (!(appctx->st1 & (APPCTX_CLI_ST1_PAYLOAD|APPCTX_CLI_ST1_NOLF)))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200890 prompt = "\n";
891 }
892
893 if (ci_putstr(si_ic(si), prompt) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100894 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +0100895 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100896 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100897 }
898
899 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100900 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +0100901 break;
902
903 /* Now we close the output if one of the writers did so,
904 * or if we're not in interactive mode and the request
905 * buffer is empty. This still allows pipelined requests
906 * to be sent in non-interactive mode.
907 */
William Lallemand3de09d52018-12-11 16:10:56 +0100908 if (((res->flags & (CF_SHUTW|CF_SHUTW_NOW))) ||
909 (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req) && (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)))) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100910 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100911 continue;
912 }
913
914 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100915 appctx->st0 = CLI_ST_GETREQ;
William Lallemandad032882019-07-01 10:56:15 +0200916 /* reactivate the \n at the end of the response for the next command */
917 appctx->st1 &= ~APPCTX_CLI_ST1_NOLF;
William Lallemand74c24fb2016-11-21 17:18:36 +0100918 }
919 }
920
921 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
922 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
923 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
924 /* Other side has closed, let's abort if we have no more processing to do
925 * and nothing more to consume. This is comparable to a broken pipe, so
926 * we forward the close to the request side so that it flows upstream to
927 * the client.
928 */
929 si_shutw(si);
930 }
931
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100932 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100933 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
934 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
935 /* We have no more processing to do, and nothing more to send, and
936 * the client side has closed. So we'll forward this state downstream
937 * on the response buffer.
938 */
939 si_shutr(si);
940 res->flags |= CF_READ_NULL;
941 }
942
943 out:
Christopher Faulet45073512018-07-20 10:16:29 +0200944 DPRINTF(stderr, "%s@%d: st=%d, rqf=%x, rpf=%x, rqh=%lu, rqs=%lu, rh=%lu, rs=%lu\n",
William Lallemand74c24fb2016-11-21 17:18:36 +0100945 __FUNCTION__, __LINE__,
Christopher Faulet45073512018-07-20 10:16:29 +0200946 si->state, req->flags, res->flags, ci_data(req), co_data(req), ci_data(res), co_data(res));
William Lallemand74c24fb2016-11-21 17:18:36 +0100947}
948
William Lallemand74c24fb2016-11-21 17:18:36 +0100949/* This is called when the stream interface is closed. For instance, upon an
950 * external abort, we won't call the i/o handler anymore so we may need to
951 * remove back references to the stream currently being dumped.
952 */
953static void cli_release_handler(struct appctx *appctx)
954{
955 if (appctx->io_release) {
956 appctx->io_release(appctx);
957 appctx->io_release = NULL;
958 }
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200959 else if (appctx->st0 == CLI_ST_PRINT_FREE || appctx->st0 == CLI_ST_PRINT_DYN) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100960 ha_free(&appctx->ctx.cli.err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100961 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100962}
963
964/* This function dumps all environmnent variables to the buffer. It returns 0
965 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +0100966 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
967 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +0100968 */
Willy Tarreau0a739292016-11-22 20:21:23 +0100969static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100970{
Willy Tarreau0a739292016-11-22 20:21:23 +0100971 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100972 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100973
974 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
975 return 1;
976
977 chunk_reset(&trash);
978
979 /* we have two inner loops here, one for the proxy, the other one for
980 * the buffer.
981 */
Willy Tarreauf6710f82016-12-16 17:45:44 +0100982 while (*var) {
983 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +0100984
Willy Tarreau06d80a92017-10-19 14:32:15 +0200985 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100986 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100987 return 0;
988 }
989 if (appctx->st2 == STAT_ST_END)
990 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +0100991 var++;
992 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +0100993 }
994
995 /* dump complete */
996 return 1;
997}
998
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +0200999/* This function dumps all file descriptors states (or the requested one) to
1000 * the buffer. It returns 0 if the output buffer is full and it needs to be
1001 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
1002 * It uses cli.i0 as the fd number to restart from.
1003 */
1004static int cli_io_handler_show_fd(struct appctx *appctx)
1005{
1006 struct stream_interface *si = appctx->owner;
1007 int fd = appctx->ctx.cli.i0;
Willy Tarreauca1b1572018-12-18 15:45:11 +01001008 int ret = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001009
1010 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
Willy Tarreauca1b1572018-12-18 15:45:11 +01001011 goto end;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001012
1013 chunk_reset(&trash);
1014
Willy Tarreauca1b1572018-12-18 15:45:11 +01001015 /* isolate the threads once per round. We're limited to a buffer worth
1016 * of output anyway, it cannot last very long.
1017 */
1018 thread_isolate();
1019
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001020 /* we have two inner loops here, one for the proxy, the other one for
1021 * the buffer.
1022 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +01001023 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001024 struct fdtab fdt;
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001025 const struct listener *li = NULL;
1026 const struct server *sv = NULL;
1027 const struct proxy *px = NULL;
1028 const struct connection *conn = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +02001029 const struct mux_ops *mux = NULL;
Willy Tarreau37be9532021-01-20 14:40:04 +01001030 const struct xprt_ops *xprt = NULL;
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001031 const void *ctx = NULL;
Willy Tarreau37be9532021-01-20 14:40:04 +01001032 const void *xprt_ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +02001033 uint32_t conn_flags = 0;
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001034 int is_back = 0;
Willy Tarreau8050efe2021-01-21 08:26:06 +01001035 int suspicious = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001036
1037 fdt = fdtab[fd];
1038
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001039 /* When DEBUG_FD is set, we also report closed FDs that have a
1040 * non-null event count to detect stuck ones.
1041 */
Willy Tarreau13c1a012020-06-29 14:23:31 +02001042 if (!fdt.owner) {
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001043#ifdef DEBUG_FD
Willy Tarreau13c1a012020-06-29 14:23:31 +02001044 if (!fdt.event_count)
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001045#endif
Willy Tarreau13c1a012020-06-29 14:23:31 +02001046 goto skip; // closed
1047 }
Willy Tarreau586f71b2020-12-11 15:54:36 +01001048 else if (fdt.iocb == sock_conn_iocb) {
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001049 conn = (const struct connection *)fdt.owner;
1050 conn_flags = conn->flags;
1051 mux = conn->mux;
1052 ctx = conn->ctx;
Willy Tarreau37be9532021-01-20 14:40:04 +01001053 xprt = conn->xprt;
1054 xprt_ctx = conn->xprt_ctx;
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001055 li = objt_listener(conn->target);
1056 sv = objt_server(conn->target);
1057 px = objt_proxy(conn->target);
1058 is_back = conn_is_back(conn);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001059 if (atleast2(fdt.thread_mask))
1060 suspicious = 1;
1061 if (conn->handle.fd != fd)
1062 suspicious = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001063 }
Willy Tarreaua74cb382020-10-15 21:29:49 +02001064 else if (fdt.iocb == sock_accept_iocb)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001065 li = fdt.owner;
1066
Willy Tarreaudacfde42021-01-21 09:07:29 +01001067 if (!fdt.thread_mask)
1068 suspicious = 1;
1069
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001070 chunk_printf(&trash,
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001071 " %5d : st=0x%02x(R:%c%c W:%c%c) ev=0x%02x(%c%c%c%c%c) [%c%c] tmask=0x%lx umask=0x%lx owner=%p iocb=%p(",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001072 fd,
1073 fdt.state,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001074 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
1075 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001076 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
1077 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
1078 fdt.ev,
1079 (fdt.ev & FD_POLL_HUP) ? 'H' : 'h',
1080 (fdt.ev & FD_POLL_ERR) ? 'E' : 'e',
1081 (fdt.ev & FD_POLL_OUT) ? 'O' : 'o',
1082 (fdt.ev & FD_POLL_PRI) ? 'P' : 'p',
1083 (fdt.ev & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001084 fdt.linger_risk ? 'L' : 'l',
1085 fdt.cloned ? 'C' : 'c',
Willy Tarreauc754b342018-03-30 15:00:15 +02001086 fdt.thread_mask, fdt.update_mask,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001087 fdt.owner,
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001088 fdt.iocb);
1089 resolve_sym_name(&trash, NULL, fdt.iocb);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001090
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001091 if (!fdt.owner) {
1092 chunk_appendf(&trash, ")");
1093 }
Willy Tarreau586f71b2020-12-11 15:54:36 +01001094 else if (fdt.iocb == sock_conn_iocb) {
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001095 chunk_appendf(&trash, ") back=%d cflg=0x%08x", is_back, conn_flags);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001096
1097 if (conn->handle.fd != fd) {
1098 chunk_appendf(&trash, " fd=%d(BOGUS)", conn->handle.fd);
1099 suspicious = 1;
Willy Tarreaued989202021-02-05 10:54:52 +01001100 } else {
1101 struct sockaddr_storage sa;
1102 socklen_t salen;
1103
1104 salen = sizeof(sa);
1105 if (getsockname(fd, (struct sockaddr *)&sa, &salen) != -1) {
1106 if (sa.ss_family == AF_INET)
1107 chunk_appendf(&trash, " fam=ipv4 lport=%d", ntohs(((const struct sockaddr_in *)&sa)->sin_port));
1108 else if (sa.ss_family == AF_INET6)
1109 chunk_appendf(&trash, " fam=ipv6 lport=%d", ntohs(((const struct sockaddr_in6 *)&sa)->sin6_port));
1110 else if (sa.ss_family == AF_UNIX)
1111 chunk_appendf(&trash, " fam=unix");
1112 }
1113
1114 salen = sizeof(sa);
1115 if (getpeername(fd, (struct sockaddr *)&sa, &salen) != -1) {
1116 if (sa.ss_family == AF_INET)
1117 chunk_appendf(&trash, " rport=%d", ntohs(((const struct sockaddr_in *)&sa)->sin_port));
1118 else if (sa.ss_family == AF_INET6)
1119 chunk_appendf(&trash, " rport=%d", ntohs(((const struct sockaddr_in6 *)&sa)->sin6_port));
1120 }
Willy Tarreaudacfde42021-01-21 09:07:29 +01001121 }
1122
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001123 if (px)
1124 chunk_appendf(&trash, " px=%s", px->id);
1125 else if (sv)
1126 chunk_appendf(&trash, " sv=%s/%s", sv->id, sv->proxy->id);
1127 else if (li)
1128 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +02001129
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001130 if (mux) {
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001131 chunk_appendf(&trash, " mux=%s ctx=%p", mux->name, ctx);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001132 if (!ctx)
1133 suspicious = 1;
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001134 if (mux->show_fd)
Willy Tarreau8050efe2021-01-21 08:26:06 +01001135 suspicious |= mux->show_fd(&trash, fdt.owner);
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001136 }
Willy Tarreau35b1b482018-03-28 18:41:30 +02001137 else
1138 chunk_appendf(&trash, " nomux");
Willy Tarreau37be9532021-01-20 14:40:04 +01001139
1140 chunk_appendf(&trash, " xprt=%s", xprt ? xprt->name : "");
Willy Tarreau108a2712021-01-20 15:30:56 +01001141 if (xprt) {
1142 if (xprt_ctx || xprt->show_fd)
1143 chunk_appendf(&trash, " xprt_ctx=%p", xprt_ctx);
1144 if (xprt->show_fd)
Willy Tarreau8050efe2021-01-21 08:26:06 +01001145 suspicious |= xprt->show_fd(&trash, conn, xprt_ctx);
Willy Tarreau108a2712021-01-20 15:30:56 +01001146 }
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001147 }
Willy Tarreaua74cb382020-10-15 21:29:49 +02001148 else if (fdt.iocb == sock_accept_iocb) {
Willy Tarreaued989202021-02-05 10:54:52 +01001149 struct sockaddr_storage sa;
1150 socklen_t salen;
1151
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001152 chunk_appendf(&trash, ") l.st=%s fe=%s",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001153 listener_state_str(li),
1154 li->bind_conf->frontend->id);
Willy Tarreaued989202021-02-05 10:54:52 +01001155
1156 salen = sizeof(sa);
1157 if (getsockname(fd, (struct sockaddr *)&sa, &salen) != -1) {
1158 if (sa.ss_family == AF_INET)
1159 chunk_appendf(&trash, " fam=ipv4 lport=%d", ntohs(((const struct sockaddr_in *)&sa)->sin_port));
1160 else if (sa.ss_family == AF_INET6)
1161 chunk_appendf(&trash, " fam=ipv6 lport=%d", ntohs(((const struct sockaddr_in6 *)&sa)->sin6_port));
1162 else if (sa.ss_family == AF_UNIX)
1163 chunk_appendf(&trash, " fam=unix");
1164 }
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001165 }
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001166 else
1167 chunk_appendf(&trash, ")");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001168
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001169#ifdef DEBUG_FD
1170 chunk_appendf(&trash, " evcnt=%u", fdtab[fd].event_count);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001171 if (fdtab[fd].event_count >= 1000000)
1172 suspicious = 1;
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001173#endif
Willy Tarreau8050efe2021-01-21 08:26:06 +01001174 chunk_appendf(&trash, "%s\n", suspicious ? " !" : "");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001175
Willy Tarreau06d80a92017-10-19 14:32:15 +02001176 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001177 si_rx_room_blk(si);
Willy Tarreauca1b1572018-12-18 15:45:11 +01001178 appctx->ctx.cli.i0 = fd;
1179 ret = 0;
1180 break;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001181 }
1182 skip:
1183 if (appctx->st2 == STAT_ST_END)
1184 break;
1185
1186 fd++;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001187 }
1188
Willy Tarreauca1b1572018-12-18 15:45:11 +01001189 end:
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001190 /* dump complete */
Willy Tarreauca1b1572018-12-18 15:45:11 +01001191
1192 thread_release();
1193 return ret;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001194}
1195
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001196/* This function dumps some activity counters used by developers and support to
1197 * rule out some hypothesis during bug reports. It returns 0 if the output
1198 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
1199 * everything at once in the buffer and is not designed to do it in multiple
1200 * passes.
1201 */
1202static int cli_io_handler_show_activity(struct appctx *appctx)
1203{
1204 struct stream_interface *si = appctx->owner;
1205 int thr;
1206
1207 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1208 return 1;
1209
1210 chunk_reset(&trash);
1211
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001212#undef SHOW_TOT
1213#define SHOW_TOT(t, x) \
Willy Tarreaua0211b82019-05-28 15:09:08 +02001214 do { \
1215 unsigned int _v[MAX_THREADS]; \
1216 unsigned int _tot; \
1217 const unsigned int _nbt = global.nbthread; \
1218 for (_tot = t = 0; t < _nbt; t++) \
1219 _tot += _v[t] = (x); \
1220 if (_nbt == 1) { \
1221 chunk_appendf(&trash, " %u\n", _tot); \
1222 break; \
1223 } \
1224 chunk_appendf(&trash, " %u [", _tot); \
1225 for (t = 0; t < _nbt; t++) \
1226 chunk_appendf(&trash, " %u", _v[t]); \
1227 chunk_appendf(&trash, " ]\n"); \
1228 } while (0)
1229
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001230#undef SHOW_AVG
1231#define SHOW_AVG(t, x) \
1232 do { \
1233 unsigned int _v[MAX_THREADS]; \
1234 unsigned int _tot; \
1235 const unsigned int _nbt = global.nbthread; \
1236 for (_tot = t = 0; t < _nbt; t++) \
1237 _tot += _v[t] = (x); \
1238 if (_nbt == 1) { \
1239 chunk_appendf(&trash, " %u\n", _tot); \
1240 break; \
1241 } \
1242 chunk_appendf(&trash, " %u [", (_tot + _nbt/2) / _nbt); \
1243 for (t = 0; t < _nbt; t++) \
1244 chunk_appendf(&trash, " %u", _v[t]); \
1245 chunk_appendf(&trash, " ]\n"); \
1246 } while (0)
1247
Willy Tarreaua0211b82019-05-28 15:09:08 +02001248 chunk_appendf(&trash, "thread_id: %u (%u..%u)\n", tid + 1, 1, global.nbthread);
1249 chunk_appendf(&trash, "date_now: %lu.%06lu\n", (long)now.tv_sec, (long)now.tv_usec);
Willy Tarreaua00cf9b2020-06-17 20:44:28 +02001250 chunk_appendf(&trash, "ctxsw:"); SHOW_TOT(thr, activity[thr].ctxsw);
1251 chunk_appendf(&trash, "tasksw:"); SHOW_TOT(thr, activity[thr].tasksw);
1252 chunk_appendf(&trash, "empty_rq:"); SHOW_TOT(thr, activity[thr].empty_rq);
1253 chunk_appendf(&trash, "long_rq:"); SHOW_TOT(thr, activity[thr].long_rq);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001254 chunk_appendf(&trash, "loops:"); SHOW_TOT(thr, activity[thr].loops);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001255 chunk_appendf(&trash, "wake_tasks:"); SHOW_TOT(thr, activity[thr].wake_tasks);
1256 chunk_appendf(&trash, "wake_signal:"); SHOW_TOT(thr, activity[thr].wake_signal);
Willy Tarreaue5451532020-06-17 20:25:18 +02001257 chunk_appendf(&trash, "poll_io:"); SHOW_TOT(thr, activity[thr].poll_io);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001258 chunk_appendf(&trash, "poll_exp:"); SHOW_TOT(thr, activity[thr].poll_exp);
Willy Tarreaue4063862020-06-17 20:35:33 +02001259 chunk_appendf(&trash, "poll_drop_fd:"); SHOW_TOT(thr, activity[thr].poll_drop_fd);
1260 chunk_appendf(&trash, "poll_dead_fd:"); SHOW_TOT(thr, activity[thr].poll_dead_fd);
1261 chunk_appendf(&trash, "poll_skip_fd:"); SHOW_TOT(thr, activity[thr].poll_skip_fd);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001262 chunk_appendf(&trash, "conn_dead:"); SHOW_TOT(thr, activity[thr].conn_dead);
Willy Tarreau7af4fa92020-06-17 20:49:49 +02001263 chunk_appendf(&trash, "stream_calls:"); SHOW_TOT(thr, activity[thr].stream_calls);
Willy Tarreaua8b2ce02019-05-28 17:04:16 +02001264 chunk_appendf(&trash, "pool_fail:"); SHOW_TOT(thr, activity[thr].pool_fail);
1265 chunk_appendf(&trash, "buf_wait:"); SHOW_TOT(thr, activity[thr].buf_wait);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001266 chunk_appendf(&trash, "cpust_ms_tot:"); SHOW_TOT(thr, activity[thr].cpust_total / 2);
1267 chunk_appendf(&trash, "cpust_ms_1s:"); SHOW_TOT(thr, read_freq_ctr(&activity[thr].cpust_1s) / 2);
1268 chunk_appendf(&trash, "cpust_ms_15s:"); SHOW_TOT(thr, read_freq_ctr_period(&activity[thr].cpust_15s, 15000) / 2);
1269 chunk_appendf(&trash, "avg_loop_us:"); SHOW_AVG(thr, swrate_avg(activity[thr].avg_loop_us, TIME_STATS_SAMPLES));
1270 chunk_appendf(&trash, "accepted:"); SHOW_TOT(thr, activity[thr].accepted);
1271 chunk_appendf(&trash, "accq_pushed:"); SHOW_TOT(thr, activity[thr].accq_pushed);
1272 chunk_appendf(&trash, "accq_full:"); SHOW_TOT(thr, activity[thr].accq_full);
Willy Tarreaue6182842019-04-15 18:54:10 +02001273#ifdef USE_THREAD
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001274 chunk_appendf(&trash, "accq_ring:"); SHOW_TOT(thr, (accept_queue_rings[thr].tail - accept_queue_rings[thr].head + ACCEPT_QUEUE_SIZE) % ACCEPT_QUEUE_SIZE);
Willy Tarreaub1591322020-06-29 14:17:59 +02001275 chunk_appendf(&trash, "fd_takeover:"); SHOW_TOT(thr, activity[thr].fd_takeover);
Willy Tarreaue6182842019-04-15 18:54:10 +02001276#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001277
Willy Tarreaud6a78502019-05-27 07:03:38 +02001278#if defined(DEBUG_DEV)
1279 /* keep these ones at the end */
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001280 chunk_appendf(&trash, "ctr0:"); SHOW_TOT(thr, activity[thr].ctr0);
1281 chunk_appendf(&trash, "ctr1:"); SHOW_TOT(thr, activity[thr].ctr1);
1282 chunk_appendf(&trash, "ctr2:"); SHOW_TOT(thr, activity[thr].ctr2);
Willy Tarreaud6a78502019-05-27 07:03:38 +02001283#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001284
1285 if (ci_putchk(si_ic(si), &trash) == -1) {
1286 chunk_reset(&trash);
1287 chunk_printf(&trash, "[output too large, cannot dump]\n");
Willy Tarreaudb398432018-11-15 11:08:52 +01001288 si_rx_room_blk(si);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001289 }
1290
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001291#undef SHOW_AVG
1292#undef SHOW_TOT
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001293 /* dump complete */
1294 return 1;
1295}
1296
William Lallemandeceddf72016-12-15 18:06:44 +01001297/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001298 * CLI IO handler for `show cli sockets`.
1299 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +01001300 */
1301static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1302{
1303 struct bind_conf *bind_conf;
1304 struct stream_interface *si = appctx->owner;
1305
1306 chunk_reset(&trash);
1307
1308 switch (appctx->st2) {
1309 case STAT_ST_INIT:
1310 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +02001311 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001312 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001313 return 0;
1314 }
William Lallemandeceddf72016-12-15 18:06:44 +01001315 appctx->st2 = STAT_ST_LIST;
Tim Duesterhus588b3142020-05-29 14:35:51 +02001316 /* fall through */
William Lallemandeceddf72016-12-15 18:06:44 +01001317
1318 case STAT_ST_LIST:
1319 if (global.stats_fe) {
1320 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
1321 struct listener *l;
1322
1323 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001324 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +01001325 * if the current node is the first of the list
1326 */
1327
Willy Tarreau3af9d832016-12-16 12:58:09 +01001328 if (appctx->ctx.cli.p0 &&
1329 &bind_conf->by_fe == (&global.stats_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +01001330 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +01001331 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +01001332 continue;
1333 }
1334
1335 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
1336
1337 char addr[46];
1338 char port[6];
1339
Willy Tarreau37159062020-08-27 07:48:42 +02001340 if (l->rx.addr.ss_family == AF_UNIX) {
William Lallemandeceddf72016-12-15 18:06:44 +01001341 const struct sockaddr_un *un;
1342
Willy Tarreau37159062020-08-27 07:48:42 +02001343 un = (struct sockaddr_un *)&l->rx.addr;
William Lallemande58915f2019-04-01 11:30:05 +02001344 if (un->sun_path[0] == '\0') {
William Lallemand75812a72019-04-01 11:30:04 +02001345 chunk_appendf(&trash, "abns@%s ", un->sun_path+1);
William Lallemande58915f2019-04-01 11:30:05 +02001346 } else {
1347 chunk_appendf(&trash, "unix@%s ", un->sun_path);
1348 }
Willy Tarreau37159062020-08-27 07:48:42 +02001349 } else if (l->rx.addr.ss_family == AF_INET) {
1350 addr_to_str(&l->rx.addr, addr, sizeof(addr));
1351 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001352 chunk_appendf(&trash, "ipv4@%s:%s ", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +02001353 } else if (l->rx.addr.ss_family == AF_INET6) {
1354 addr_to_str(&l->rx.addr, addr, sizeof(addr));
1355 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001356 chunk_appendf(&trash, "ipv6@[%s]:%s ", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +02001357 } else if (l->rx.addr.ss_family == AF_CUST_SOCKPAIR) {
1358 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->rx.addr)->sin_addr.s_addr);
William Lallemandeceddf72016-12-15 18:06:44 +01001359 } else
William Lallemand26314342018-10-26 14:47:41 +02001360 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001361
William Lallemand07a62f72017-05-24 00:57:40 +02001362 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +01001363 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +02001364 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1365 chunk_appendf(&trash, "operator ");
1366 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1367 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +01001368 else
1369 chunk_appendf(&trash, " ");
1370
Willy Tarreaue26993c2020-09-03 07:18:55 +02001371 if (bind_conf->settings.bind_proc != 0) {
William Lallemandeceddf72016-12-15 18:06:44 +01001372 int pos;
Willy Tarreaue26993c2020-09-03 07:18:55 +02001373 for (pos = 0; pos < 8 * sizeof(bind_conf->settings.bind_proc); pos++) {
1374 if (bind_conf->settings.bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +01001375 chunk_appendf(&trash, "%d,", pos+1);
1376 }
1377 }
1378 /* replace the latest comma by a newline */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001379 trash.area[trash.data-1] = '\n';
William Lallemandeceddf72016-12-15 18:06:44 +01001380
1381 } else {
1382 chunk_appendf(&trash, "all\n");
1383 }
1384
Willy Tarreau06d80a92017-10-19 14:32:15 +02001385 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001386 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001387 return 0;
1388 }
1389 }
Willy Tarreau3af9d832016-12-16 12:58:09 +01001390 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001391 }
1392 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02001393 /* fall through */
William Lallemandeceddf72016-12-15 18:06:44 +01001394 default:
1395 appctx->st2 = STAT_ST_FIN;
1396 return 1;
1397 }
1398}
1399
1400
Willy Tarreau0a739292016-11-22 20:21:23 +01001401/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001402 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1403 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001404 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001405static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001406{
1407 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001408 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001409
1410 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1411 return 1;
1412
Willy Tarreauf6710f82016-12-16 17:45:44 +01001413 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001414
1415 if (*args[2]) {
1416 int len = strlen(args[2]);
1417
Willy Tarreauf6710f82016-12-16 17:45:44 +01001418 for (; *var; var++) {
1419 if (strncmp(*var, args[2], len) == 0 &&
1420 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001421 break;
1422 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001423 if (!*var)
1424 return cli_err(appctx, "Variable not found\n");
1425
Willy Tarreau0a739292016-11-22 20:21:23 +01001426 appctx->st2 = STAT_ST_END;
1427 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001428 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001429 return 0;
1430}
1431
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001432/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1433 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1434 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1435 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001436static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001437{
1438 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1439 return 1;
1440
1441 appctx->ctx.cli.i0 = 0;
1442
1443 if (*args[2]) {
1444 appctx->ctx.cli.i0 = atoi(args[2]);
1445 appctx->st2 = STAT_ST_END;
1446 }
1447 return 0;
1448}
1449
Willy Tarreau599852e2016-11-22 20:33:32 +01001450/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001451static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001452{
1453 struct stream_interface *si = appctx->owner;
1454 struct stream *s = si_strm(si);
1455
1456 if (strcmp(args[2], "cli") == 0) {
1457 unsigned timeout;
1458 const char *res;
1459
Willy Tarreau9d008692019-08-09 11:21:01 +02001460 if (!*args[3])
1461 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001462
1463 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
Willy Tarreau9d008692019-08-09 11:21:01 +02001464 if (res || timeout < 1)
1465 return cli_err(appctx, "Invalid timeout value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001466
1467 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1468 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1469 return 1;
1470 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001471
1472 return cli_err(appctx, "'set timeout' only supports 'cli'.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001473}
1474
Willy Tarreau2af99412016-11-23 11:10:59 +01001475/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001476static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001477{
1478 int v;
1479
1480 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1481 return 1;
1482
Willy Tarreau9d008692019-08-09 11:21:01 +02001483 if (!*args[3])
1484 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001485
1486 v = atoi(args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001487 if (v > global.hardmaxconn)
1488 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001489
1490 /* check for unlimited values */
1491 if (v <= 0)
1492 v = global.hardmaxconn;
1493
1494 global.maxconn = v;
1495
1496 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001497 dequeue_all_listeners();
Willy Tarreau2af99412016-11-23 11:10:59 +01001498
1499 return 1;
1500}
1501
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001502static int set_severity_output(int *target, char *argument)
1503{
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001504 if (strcmp(argument, "none") == 0) {
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001505 *target = CLI_SEVERITY_NONE;
1506 return 1;
1507 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001508 else if (strcmp(argument, "number") == 0) {
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001509 *target = CLI_SEVERITY_NUMBER;
1510 return 1;
1511 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001512 else if (strcmp(argument, "string") == 0) {
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001513 *target = CLI_SEVERITY_STRING;
1514 return 1;
1515 }
1516 return 0;
1517}
1518
1519/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001520static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001521{
1522 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1523 return 0;
1524
Willy Tarreau9d008692019-08-09 11:21:01 +02001525 return cli_err(appctx, "one of 'none', 'number', 'string' is a required argument\n");
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001526}
William Lallemandeceddf72016-12-15 18:06:44 +01001527
William Lallemand67a234f2018-12-13 09:05:45 +01001528
1529/* show the level of the current CLI session */
1530static int cli_parse_show_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1531{
William Lallemand67a234f2018-12-13 09:05:45 +01001532 if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
Willy Tarreau9d008692019-08-09 11:21:01 +02001533 return cli_msg(appctx, LOG_INFO, "admin\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001534 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001535 return cli_msg(appctx, LOG_INFO, "operator\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001536 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001537 return cli_msg(appctx, LOG_INFO, "user\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001538 else
Willy Tarreau9d008692019-08-09 11:21:01 +02001539 return cli_msg(appctx, LOG_INFO, "unknown\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001540}
1541
1542/* parse and set the CLI level dynamically */
1543static int cli_parse_set_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1544{
William Lallemandad032882019-07-01 10:56:15 +02001545 /* this will ask the applet to not output a \n after the command */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001546 if (strcmp(args[1], "-") == 0)
William Lallemandad032882019-07-01 10:56:15 +02001547 appctx->st1 |= APPCTX_CLI_ST1_NOLF;
1548
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001549 if (strcmp(args[0], "operator") == 0) {
William Lallemand67a234f2018-12-13 09:05:45 +01001550 if (!cli_has_level(appctx, ACCESS_LVL_OPER)) {
1551 return 1;
1552 }
1553 appctx->cli_level &= ~ACCESS_LVL_MASK;
1554 appctx->cli_level |= ACCESS_LVL_OPER;
1555
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001556 } else if (strcmp(args[0], "user") == 0) {
William Lallemand67a234f2018-12-13 09:05:45 +01001557 if (!cli_has_level(appctx, ACCESS_LVL_USER)) {
1558 return 1;
1559 }
1560 appctx->cli_level &= ~ACCESS_LVL_MASK;
1561 appctx->cli_level |= ACCESS_LVL_USER;
1562 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001563 appctx->cli_level &= ~ACCESS_EXPERT;
1564 return 1;
1565}
1566
1567
1568/* parse and set the CLI expert-mode dynamically */
1569static int cli_parse_expert_mode(char **args, char *payload, struct appctx *appctx, void *private)
1570{
1571 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1572 return 1;
1573
1574 if (!*args[1])
1575 return (appctx->cli_level & ACCESS_EXPERT)
1576 ? cli_msg(appctx, LOG_INFO, "expert-mode is ON\n")
1577 : cli_msg(appctx, LOG_INFO, "expert-mode is OFF\n");
1578
1579 appctx->cli_level &= ~ACCESS_EXPERT;
1580 if (strcmp(args[1], "on") == 0)
1581 appctx->cli_level |= ACCESS_EXPERT;
William Lallemand67a234f2018-12-13 09:05:45 +01001582 return 1;
1583}
1584
William Lallemanda57b7e32018-12-14 21:11:31 +01001585
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001586int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001587{
1588 return 0;
1589}
1590
Willy Tarreau45c742b2016-11-24 14:51:17 +01001591/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001592static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001593{
1594 int v;
1595 int *res;
1596 int mul = 1;
1597
1598 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1599 return 1;
1600
1601 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1602 res = &global.cps_lim;
1603 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1604 res = &global.sps_lim;
1605#ifdef USE_OPENSSL
1606 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1607 res = &global.ssl_lim;
1608#endif
1609 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1610 res = &global.comp_rate_lim;
1611 mul = 1024;
1612 }
1613 else {
Willy Tarreau9d008692019-08-09 11:21:01 +02001614 return cli_err(appctx,
Willy Tarreau45c742b2016-11-24 14:51:17 +01001615 "'set rate-limit' only supports :\n"
1616 " - 'connections global' to set the per-process maximum connection rate\n"
1617 " - 'sessions global' to set the per-process maximum session rate\n"
1618#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001619 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001620#endif
Willy Tarreau9d008692019-08-09 11:21:01 +02001621 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001622 }
1623
Willy Tarreau9d008692019-08-09 11:21:01 +02001624 if (!*args[4])
1625 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001626
1627 v = atoi(args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001628 if (v < 0)
1629 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001630
1631 *res = v * mul;
1632
1633 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001634 dequeue_all_listeners();
Willy Tarreau45c742b2016-11-24 14:51:17 +01001635
1636 return 1;
1637}
1638
William Lallemandf6975e92017-05-26 17:42:10 +02001639/* parse the "expose-fd" argument on the bind lines */
1640static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1641{
1642 if (!*args[cur_arg + 1]) {
1643 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1644 return ERR_ALERT | ERR_FATAL;
1645 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001646 if (strcmp(args[cur_arg + 1], "listeners") == 0) {
William Lallemandf6975e92017-05-26 17:42:10 +02001647 conf->level |= ACCESS_FD_LISTENERS;
1648 } else {
1649 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1650 args[cur_arg], args[cur_arg+1]);
1651 return ERR_ALERT | ERR_FATAL;
1652 }
1653
1654 return 0;
1655}
1656
William Lallemand74c24fb2016-11-21 17:18:36 +01001657/* parse the "level" argument on the bind lines */
1658static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1659{
1660 if (!*args[cur_arg + 1]) {
1661 memprintf(err, "'%s' : missing level", args[cur_arg]);
1662 return ERR_ALERT | ERR_FATAL;
1663 }
1664
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001665 if (strcmp(args[cur_arg + 1], "user") == 0) {
William Lallemand07a62f72017-05-24 00:57:40 +02001666 conf->level &= ~ACCESS_LVL_MASK;
1667 conf->level |= ACCESS_LVL_USER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001668 } else if (strcmp(args[cur_arg + 1], "operator") == 0) {
William Lallemand07a62f72017-05-24 00:57:40 +02001669 conf->level &= ~ACCESS_LVL_MASK;
1670 conf->level |= ACCESS_LVL_OPER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001671 } else if (strcmp(args[cur_arg + 1], "admin") == 0) {
William Lallemand07a62f72017-05-24 00:57:40 +02001672 conf->level &= ~ACCESS_LVL_MASK;
1673 conf->level |= ACCESS_LVL_ADMIN;
1674 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001675 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1676 args[cur_arg], args[cur_arg+1]);
1677 return ERR_ALERT | ERR_FATAL;
1678 }
1679
1680 return 0;
1681}
1682
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001683static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1684{
1685 if (!*args[cur_arg + 1]) {
1686 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1687 return ERR_ALERT | ERR_FATAL;
1688 }
1689
1690 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1691 return 0;
1692 else {
1693 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1694 args[cur_arg], args[cur_arg+1]);
1695 return ERR_ALERT | ERR_FATAL;
1696 }
1697}
1698
Olivier Houchardf886e342017-04-05 22:24:59 +02001699/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001700static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02001701{
1702 char *cmsgbuf = NULL;
1703 unsigned char *tmpbuf = NULL;
1704 struct cmsghdr *cmsg;
1705 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001706 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001707 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001708 struct msghdr msghdr;
1709 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001710 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001711 const char *ns_name, *if_name;
1712 unsigned char ns_nlen, if_nlen;
1713 int nb_queued;
1714 int cur_fd = 0;
Olivier Houchardf886e342017-04-05 22:24:59 +02001715 int *tmpfd;
1716 int tot_fd_nb = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001717 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001718 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001719 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001720 int ret;
1721
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001722 if (!remote) {
1723 ha_warning("Only works on real connections\n");
1724 goto out;
1725 }
1726
1727 fd = remote->handle.fd;
1728
Olivier Houchardf886e342017-04-05 22:24:59 +02001729 /* Temporary set the FD in blocking mode, that will make our life easier */
1730 old_fcntl = fcntl(fd, F_GETFL);
1731 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001732 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001733 goto out;
1734 }
1735 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1736 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001737 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001738 goto out;
1739 }
1740 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001741 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001742 goto out;
1743 }
Olivier Houchard54740872017-04-06 14:45:14 +02001744 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001745 iov.iov_base = &tot_fd_nb;
1746 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001747 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001748 goto out;
1749 memset(&msghdr, 0, sizeof(msghdr));
1750 /*
1751 * First, calculates the total number of FD, so that we can let
Jackie Tapia749f74c2020-07-22 18:59:40 -05001752 * the caller know how much it should expect.
Olivier Houchardf886e342017-04-05 22:24:59 +02001753 */
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001754 for (cur_fd = 0;cur_fd < global.maxsock; cur_fd++)
1755 tot_fd_nb += fdtab[cur_fd].exported;
William Lallemand5fd3b282020-01-16 15:32:08 +01001756
Olivier Houchardf886e342017-04-05 22:24:59 +02001757 if (tot_fd_nb == 0)
1758 goto out;
1759
1760 /* First send the total number of file descriptors, so that the
1761 * receiving end knows what to expect.
1762 */
1763 msghdr.msg_iov = &iov;
1764 msghdr.msg_iovlen = 1;
1765 ret = sendmsg(fd, &msghdr, 0);
1766 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001767 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001768 goto out;
1769 }
1770
1771 /* Now send the fds */
1772 msghdr.msg_control = cmsgbuf;
1773 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1774 cmsg = CMSG_FIRSTHDR(&msghdr);
1775 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1776 cmsg->cmsg_level = SOL_SOCKET;
1777 cmsg->cmsg_type = SCM_RIGHTS;
1778 tmpfd = (int *)CMSG_DATA(cmsg);
1779
Olivier Houchardf886e342017-04-05 22:24:59 +02001780 /* For each socket, e message is sent, containing the following :
1781 * Size of the namespace name (or 0 if none), as an unsigned char.
1782 * The namespace name, if any
1783 * Size of the interface name (or 0 if none), as an unsigned char
1784 * The interface name, if any
Willy Tarreaucf1f1932020-08-26 10:30:09 +02001785 * 32 bits of zeroes (used to be listener options).
Olivier Houchardf886e342017-04-05 22:24:59 +02001786 */
1787 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
Ilya Shipitsind4259502020-04-08 01:07:56 +05001788 * buffer big enough to store the socket information.
Olivier Houchardf886e342017-04-05 22:24:59 +02001789 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001790 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001791 if (tmpbuf == NULL) {
Ilya Shipitsind4259502020-04-08 01:07:56 +05001792 ha_warning("Failed to allocate memory to transfer socket information\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001793 goto out;
1794 }
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001795
1796 nb_queued = 0;
Olivier Houchardf886e342017-04-05 22:24:59 +02001797 iov.iov_base = tmpbuf;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001798 for (cur_fd = 0; cur_fd < global.maxsock; cur_fd++) {
1799 if (!(fdtab[cur_fd].exported))
1800 continue;
1801
1802 ns_name = if_name = "";
1803 ns_nlen = if_nlen = 0;
1804
1805 /* for now we can only retrieve namespaces and interfaces from
1806 * pure listeners.
1807 */
Willy Tarreaua74cb382020-10-15 21:29:49 +02001808 if (fdtab[cur_fd].iocb == sock_accept_iocb) {
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001809 const struct listener *l = fdtab[cur_fd].owner;
1810
Willy Tarreau818a92e2020-09-03 07:50:19 +02001811 if (l->rx.settings->interface) {
1812 if_name = l->rx.settings->interface;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001813 if_nlen = strlen(if_name);
1814 }
1815
1816#ifdef USE_NS
Willy Tarreau818a92e2020-09-03 07:50:19 +02001817 if (l->rx.settings->netns) {
1818 ns_name = l->rx.settings->netns->node.key;
1819 ns_nlen = l->rx.settings->netns->name_len;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001820 }
1821#endif
1822 }
1823
1824 /* put the FD into the CMSG_DATA */
1825 tmpfd[nb_queued++] = cur_fd;
1826
1827 /* first block is <ns_name_len> <ns_name> */
1828 tmpbuf[curoff++] = ns_nlen;
1829 if (ns_nlen)
1830 memcpy(tmpbuf + curoff, ns_name, ns_nlen);
1831 curoff += ns_nlen;
1832
1833 /* second block is <if_name_len> <if_name> */
1834 tmpbuf[curoff++] = if_nlen;
1835 if (if_nlen)
1836 memcpy(tmpbuf + curoff, if_name, if_nlen);
1837 curoff += if_nlen;
1838
1839 /* we used to send the listener options here before 2.3 */
1840 memset(tmpbuf + curoff, 0, sizeof(int));
1841 curoff += sizeof(int);
1842
1843 /* there's a limit to how many FDs may be sent at once */
1844 if (nb_queued == MAX_SEND_FD) {
1845 iov.iov_len = curoff;
1846 if (sendmsg(fd, &msghdr, 0) != curoff) {
1847 ha_warning("Failed to transfer sockets\n");
1848 return -1;
1849 }
1850
1851 /* Wait for an ack */
1852 do {
1853 ret = recv(fd, &tot_fd_nb, sizeof(tot_fd_nb), 0);
1854 } while (ret == -1 && errno == EINTR);
1855
1856 if (ret <= 0) {
1857 ha_warning("Unexpected error while transferring sockets\n");
1858 return -1;
1859 }
1860 curoff = 0;
1861 nb_queued = 0;
1862 }
William Lallemand5fd3b282020-01-16 15:32:08 +01001863 }
1864
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001865 /* flush pending stuff */
1866 if (nb_queued) {
Olivier Houchardf886e342017-04-05 22:24:59 +02001867 iov.iov_len = curoff;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001868 cmsg->cmsg_len = CMSG_LEN(nb_queued * sizeof(int));
1869 msghdr.msg_controllen = CMSG_SPACE(nb_queued * sizeof(int));
Olivier Houchardf886e342017-04-05 22:24:59 +02001870 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001871 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001872 goto out;
1873 }
1874 }
1875
1876out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001877 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001878 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001879 goto out;
1880 }
1881 appctx->st0 = CLI_ST_END;
1882 free(cmsgbuf);
1883 free(tmpbuf);
1884 return 1;
1885}
1886
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001887static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
1888{
1889 if (*args[0] == 'h')
1890 /* help */
1891 cli_gen_usage_msg(appctx);
1892 else if (*args[0] == 'p')
1893 /* prompt */
1894 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
1895 else if (*args[0] == 'q')
1896 /* quit */
1897 appctx->st0 = CLI_ST_END;
1898
1899 return 1;
1900}
Olivier Houchardf886e342017-04-05 22:24:59 +02001901
William Lallemand2f4ce202018-10-26 14:47:47 +02001902void pcli_write_prompt(struct stream *s)
1903{
1904 struct buffer *msg = get_trash_chunk();
1905 struct channel *oc = si_oc(&s->si[0]);
1906
William Lallemanddc12c2e2018-12-13 09:05:46 +01001907 if (!(s->pcli_flags & PCLI_F_PROMPT))
William Lallemand5b80fa22018-12-11 16:10:54 +01001908 return;
1909
William Lallemanddc12c2e2018-12-13 09:05:46 +01001910 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01001911 chunk_appendf(msg, "+ ");
1912 } else {
1913 if (s->pcli_next_pid == 0)
Willy Tarreau52880f92018-12-15 13:30:03 +01001914 chunk_appendf(msg, "master%s> ",
1915 (global.mode & MODE_MWORKER_WAIT) ? "[ReloadFailed]" : "");
William Lallemandebf61802018-12-11 16:10:57 +01001916 else
1917 chunk_appendf(msg, "%d> ", s->pcli_next_pid);
1918 }
William Lallemand2f4ce202018-10-26 14:47:47 +02001919 co_inject(oc, msg->area, msg->data);
1920}
1921
William Lallemand291810d2018-10-26 14:47:38 +02001922
William Lallemandcf62f7e2018-10-26 14:47:40 +02001923/* The pcli_* functions are used for the CLI proxy in the master */
1924
William Lallemanddeeaa592018-10-26 14:47:48 +02001925void pcli_reply_and_close(struct stream *s, const char *msg)
1926{
1927 struct buffer *buf = get_trash_chunk();
1928
1929 chunk_initstr(buf, msg);
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001930 si_retnclose(&s->si[0], buf);
William Lallemanddeeaa592018-10-26 14:47:48 +02001931}
1932
William Lallemand291810d2018-10-26 14:47:38 +02001933static enum obj_type *pcli_pid_to_server(int proc_pid)
1934{
1935 struct mworker_proc *child;
1936
William Lallemand99e0bb92020-11-05 10:28:53 +01001937 /* return the mCLI applet of the master */
William Lallemandbddd33a2018-12-11 16:10:53 +01001938 if (proc_pid == 0)
William Lallemand99e0bb92020-11-05 10:28:53 +01001939 return &mcli_applet.obj_type;
William Lallemandbddd33a2018-12-11 16:10:53 +01001940
William Lallemand291810d2018-10-26 14:47:38 +02001941 list_for_each_entry(child, &proc_list, list) {
1942 if (child->pid == proc_pid){
1943 return &child->srv->obj_type;
1944 }
1945 }
1946 return NULL;
1947}
1948
1949/* Take a CLI prefix in argument (eg: @!1234 @master @1)
1950 * Return:
1951 * 0: master
1952 * > 0: pid of a worker
1953 * < 0: didn't find a worker
1954 */
1955static int pcli_prefix_to_pid(const char *prefix)
1956{
1957 int proc_pid;
1958 struct mworker_proc *child;
1959 char *errtol = NULL;
1960
1961 if (*prefix != '@') /* not a prefix, should not happen */
1962 return -1;
1963
1964 prefix++;
1965 if (!*prefix) /* sent @ alone, return the master */
1966 return 0;
1967
1968 if (strcmp("master", prefix) == 0) {
1969 return 0;
1970 } else if (*prefix == '!') {
1971 prefix++;
1972 if (!*prefix)
1973 return -1;
1974
1975 proc_pid = strtol(prefix, &errtol, 10);
1976 if (*errtol != '\0')
1977 return -1;
1978 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001979 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01001980 continue;
William Lallemand291810d2018-10-26 14:47:38 +02001981 if (child->pid == proc_pid){
1982 return child->pid;
1983 }
1984 }
1985 } else {
1986 struct mworker_proc *chosen = NULL;
1987 /* this is a relative pid */
1988
1989 proc_pid = strtol(prefix, &errtol, 10);
1990 if (*errtol != '\0')
1991 return -1;
1992
1993 if (proc_pid == 0) /* return the master */
1994 return 0;
1995
1996 /* chose the right process, the current one is the one with the
1997 least number of reloads */
1998 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02001999 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01002000 continue;
William Lallemand291810d2018-10-26 14:47:38 +02002001 if (child->relative_pid == proc_pid){
2002 if (child->reloads == 0)
2003 return child->pid;
2004 else if (chosen == NULL || child->reloads < chosen->reloads)
2005 chosen = child;
2006 }
2007 }
2008 if (chosen)
2009 return chosen->pid;
2010 }
2011 return -1;
2012}
2013
William Lallemandbddd33a2018-12-11 16:10:53 +01002014/* Return::
2015 * >= 0 : number of words to escape
2016 * = -1 : error
2017 */
2018
2019int pcli_find_and_exec_kw(struct stream *s, char **args, int argl, char **errmsg, int *next_pid)
2020{
2021 if (argl < 1)
2022 return 0;
2023
2024 /* there is a prefix */
2025 if (args[0][0] == '@') {
2026 int target_pid = pcli_prefix_to_pid(args[0]);
2027
2028 if (target_pid == -1) {
2029 memprintf(errmsg, "Can't find the target PID matching the prefix '%s'\n", args[0]);
2030 return -1;
2031 }
2032
2033 /* if the prefix is alone, define a default target */
2034 if (argl == 1)
2035 s->pcli_next_pid = target_pid;
2036 else
2037 *next_pid = target_pid;
2038 return 1;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002039 } else if (strcmp("prompt", args[0]) == 0) {
William Lallemanddc12c2e2018-12-13 09:05:46 +01002040 s->pcli_flags ^= PCLI_F_PROMPT;
William Lallemand5b80fa22018-12-11 16:10:54 +01002041 return argl; /* return the number of elements in the array */
William Lallemand5f610682018-12-11 16:10:55 +01002042
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002043 } else if (strcmp("quit", args[0]) == 0) {
William Lallemand5f610682018-12-11 16:10:55 +01002044 channel_shutr_now(&s->req);
2045 channel_shutw_now(&s->res);
2046 return argl; /* return the number of elements in the array */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002047 } else if (strcmp(args[0], "operator") == 0) {
William Lallemandb7ea1412018-12-13 09:05:47 +01002048 if (!pcli_has_level(s, ACCESS_LVL_OPER)) {
2049 memprintf(errmsg, "Permission denied!\n");
2050 return -1;
2051 }
2052 s->pcli_flags &= ~ACCESS_LVL_MASK;
2053 s->pcli_flags |= ACCESS_LVL_OPER;
2054 return argl;
2055
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002056 } else if (strcmp(args[0], "user") == 0) {
William Lallemandb7ea1412018-12-13 09:05:47 +01002057 if (!pcli_has_level(s, ACCESS_LVL_USER)) {
2058 memprintf(errmsg, "Permission denied!\n");
2059 return -1;
2060 }
2061 s->pcli_flags &= ~ACCESS_LVL_MASK;
2062 s->pcli_flags |= ACCESS_LVL_USER;
2063 return argl;
William Lallemandbddd33a2018-12-11 16:10:53 +01002064 }
2065
2066 return 0;
2067}
2068
2069/*
2070 * Parse the CLI request:
2071 * - It does basically the same as the cli_io_handler, but as a proxy
2072 * - It can exec a command and strip non forwardable commands
William Lallemandcf62f7e2018-10-26 14:47:40 +02002073 *
2074 * Return:
William Lallemandbddd33a2018-12-11 16:10:53 +01002075 * - the number of characters to forward or
2076 * - 1 if there is an error or not enough data
William Lallemandcf62f7e2018-10-26 14:47:40 +02002077 */
William Lallemandbddd33a2018-12-11 16:10:53 +01002078int pcli_parse_request(struct stream *s, struct channel *req, char **errmsg, int *next_pid)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002079{
William Lallemandbddd33a2018-12-11 16:10:53 +01002080 char *str = (char *)ci_head(req);
2081 char *end = (char *)ci_stop(req);
2082 char *args[MAX_STATS_ARGS + 1]; /* +1 for storing a NULL */
2083 int argl; /* number of args */
2084 char *p;
2085 char *trim = NULL;
William Lallemandebf61802018-12-11 16:10:57 +01002086 char *payload = NULL;
William Lallemandbddd33a2018-12-11 16:10:53 +01002087 int wtrim = 0; /* number of words to trim */
2088 int reql = 0;
William Lallemandb7ea1412018-12-13 09:05:47 +01002089 int ret;
William Lallemandbddd33a2018-12-11 16:10:53 +01002090 int i = 0;
2091
2092 p = str;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002093
William Lallemanddc12c2e2018-12-13 09:05:46 +01002094 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002095
2096 /* Looks for the end of one command */
2097 while (p+reql < end) {
2098 /* handle escaping */
2099 if (p[reql] == '\\') {
William Lallemand02c255e2020-06-18 18:45:04 +02002100 reql+=2;
William Lallemandebf61802018-12-11 16:10:57 +01002101 continue;
2102 }
2103 if (p[reql] == ';' || p[reql] == '\n') {
2104 /* found the end of the command */
2105 p[reql] = '\n';
2106 reql++;
2107 break;
2108 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002109 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002110 }
William Lallemandebf61802018-12-11 16:10:57 +01002111 } else {
2112 while (p+reql < end) {
2113 if (p[reql] == '\n') {
2114 /* found the end of the line */
2115 reql++;
2116 break;
2117 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002118 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002119 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002120 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002121
William Lallemandbddd33a2018-12-11 16:10:53 +01002122 /* set end to first byte after the end of the command */
2123 end = p + reql;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002124
William Lallemandbddd33a2018-12-11 16:10:53 +01002125 /* there is no end to this command, need more to parse ! */
2126 if (*(end-1) != '\n') {
2127 return -1;
2128 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002129
William Lallemand3301f3e2018-12-13 09:05:48 +01002130 if (s->pcli_flags & PCLI_F_PAYLOAD) {
2131 if (reql == 1) /* last line of the payload */
2132 s->pcli_flags &= ~PCLI_F_PAYLOAD;
William Lallemandebf61802018-12-11 16:10:57 +01002133 return reql;
2134 }
2135
William Lallemandbddd33a2018-12-11 16:10:53 +01002136 *(end-1) = '\0';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002137
William Lallemandbddd33a2018-12-11 16:10:53 +01002138 /* splits the command in words */
2139 while (i < MAX_STATS_ARGS && p < end) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002140 /* skip leading spaces/tabs */
2141 p += strspn(p, " \t");
2142 if (!*p)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002143 break;
2144
William Lallemandbddd33a2018-12-11 16:10:53 +01002145 args[i] = p;
William Lallemandfe249c32020-06-18 18:03:57 +02002146 while (1) {
2147 p += strcspn(p, " \t\\");
2148 /* escaped chars using backlashes (\) */
2149 if (*p == '\\') {
2150 if (!*++p)
2151 break;
2152 if (!*++p)
2153 break;
2154 } else {
2155 break;
William Lallemandbddd33a2018-12-11 16:10:53 +01002156 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002157 }
William Lallemandfe249c32020-06-18 18:03:57 +02002158 *p++ = 0;
William Lallemandbddd33a2018-12-11 16:10:53 +01002159 i++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002160 }
2161
William Lallemandbddd33a2018-12-11 16:10:53 +01002162 argl = i;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002163
William Lallemandbddd33a2018-12-11 16:10:53 +01002164 for (; i < MAX_STATS_ARGS + 1; i++)
2165 args[i] = NULL;
2166
2167 wtrim = pcli_find_and_exec_kw(s, args, argl, errmsg, next_pid);
2168
2169 /* End of words are ending by \0, we need to replace the \0s by spaces
21701 before forwarding them */
2171 p = str;
William Lallemand3301f3e2018-12-13 09:05:48 +01002172 while (p < end-1) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002173 if (*p == '\0')
2174 *p = ' ';
2175 p++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002176 }
2177
William Lallemand3301f3e2018-12-13 09:05:48 +01002178 payload = strstr(str, PAYLOAD_PATTERN);
2179 if ((end - 1) == (payload + strlen(PAYLOAD_PATTERN))) {
2180 /* if the payload pattern is at the end */
2181 s->pcli_flags |= PCLI_F_PAYLOAD;
William Lallemand3301f3e2018-12-13 09:05:48 +01002182 }
2183
William Lallemandbddd33a2018-12-11 16:10:53 +01002184 *(end-1) = '\n';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002185
William Lallemandbddd33a2018-12-11 16:10:53 +01002186 if (wtrim > 0) {
2187 trim = &args[wtrim][0];
2188 if (trim == NULL) /* if this was the last word in the table */
2189 trim = end;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002190
William Lallemandbddd33a2018-12-11 16:10:53 +01002191 b_del(&req->buf, trim - str);
2192
William Lallemandb7ea1412018-12-13 09:05:47 +01002193 ret = end - trim;
William Lallemandbddd33a2018-12-11 16:10:53 +01002194 } else if (wtrim < 0) {
2195 /* parsing error */
2196 return -1;
William Lallemandb7ea1412018-12-13 09:05:47 +01002197 } else {
2198 /* the whole string */
2199 ret = end - str;
William Lallemandbddd33a2018-12-11 16:10:53 +01002200 }
2201
William Lallemandb7ea1412018-12-13 09:05:47 +01002202 if (ret > 1) {
2203 if (pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2204 goto end;
2205 } else if (pcli_has_level(s, ACCESS_LVL_OPER)) {
William Lallemandad032882019-07-01 10:56:15 +02002206 ci_insert_line2(req, 0, "operator -", strlen("operator -"));
2207 ret += strlen("operator -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002208 } else if (pcli_has_level(s, ACCESS_LVL_USER)) {
William Lallemandad032882019-07-01 10:56:15 +02002209 ci_insert_line2(req, 0, "user -", strlen("user -"));
2210 ret += strlen("user -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002211 }
2212 }
2213end:
William Lallemandbddd33a2018-12-11 16:10:53 +01002214
William Lallemandb7ea1412018-12-13 09:05:47 +01002215 return ret;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002216}
2217
2218int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
2219{
William Lallemandbddd33a2018-12-11 16:10:53 +01002220 int next_pid = -1;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002221 int to_forward;
William Lallemandbddd33a2018-12-11 16:10:53 +01002222 char *errmsg = NULL;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002223
William Lallemandb7ea1412018-12-13 09:05:47 +01002224 if ((s->pcli_flags & ACCESS_LVL_MASK) == ACCESS_LVL_NONE)
2225 s->pcli_flags |= strm_li(s)->bind_conf->level & ACCESS_LVL_MASK;
2226
William Lallemandcf62f7e2018-10-26 14:47:40 +02002227read_again:
2228 /* if the channel is closed for read, we won't receive any more data
2229 from the client, but we don't want to forward this close to the
2230 server */
2231 channel_dont_close(req);
2232
2233 /* We don't know yet to which server we will connect */
2234 channel_dont_connect(req);
2235
2236
2237 /* we are not waiting for a response, there is no more request and we
2238 * receive a close from the client, we can leave */
2239 if (!(ci_data(req)) && req->flags & CF_SHUTR) {
2240 channel_shutw_now(&s->res);
2241 s->req.analysers &= ~AN_REQ_WAIT_CLI;
2242 return 1;
2243 }
2244
2245 req->flags |= CF_READ_DONTWAIT;
2246
2247 /* need more data */
2248 if (!ci_data(req))
2249 return 0;
2250
2251 /* If there is data available for analysis, log the end of the idle time. */
2252 if (c_data(req) && s->logs.t_idle == -1)
2253 s->logs.t_idle = tv_ms_elapsed(&s->logs.tv_accept, &now) - s->logs.t_handshake;
2254
William Lallemandbddd33a2018-12-11 16:10:53 +01002255 to_forward = pcli_parse_request(s, req, &errmsg, &next_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002256 if (to_forward > 0) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002257 int target_pid;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002258 /* enough data */
2259
William Lallemandcf62f7e2018-10-26 14:47:40 +02002260 /* forward only 1 command */
2261 channel_forward(req, to_forward);
William Lallemandebf61802018-12-11 16:10:57 +01002262
William Lallemanddc12c2e2018-12-13 09:05:46 +01002263 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002264 /* we send only 1 command per request, and we write close after it */
2265 channel_shutw_now(req);
2266 } else {
2267 pcli_write_prompt(s);
2268 }
2269
2270 s->res.flags |= CF_WAKE_ONCE; /* need to be called again */
William Lallemandcf62f7e2018-10-26 14:47:40 +02002271
2272 /* remove the XFER_DATA analysers, which forwards all
2273 * the data, we don't want to forward the next requests
2274 * We need to add CF_FLT_ANALYZE to abort the forward too.
2275 */
2276 req->analysers &= ~(AN_REQ_FLT_XFER_DATA|AN_REQ_WAIT_CLI);
2277 req->analysers |= AN_REQ_FLT_END|CF_FLT_ANALYZE;
2278 s->res.analysers |= AN_RES_WAIT_CLI;
2279
William Lallemandebf61802018-12-11 16:10:57 +01002280 if (!(s->flags & SF_ASSIGNED)) {
2281 if (next_pid > -1)
2282 target_pid = next_pid;
2283 else
2284 target_pid = s->pcli_next_pid;
2285 /* we can connect now */
2286 s->target = pcli_pid_to_server(target_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002287
William Lallemandebf61802018-12-11 16:10:57 +01002288 s->flags |= (SF_DIRECT | SF_ASSIGNED);
2289 channel_auto_connect(req);
2290 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002291
2292 } else if (to_forward == 0) {
William Lallemandcf62f7e2018-10-26 14:47:40 +02002293 /* we trimmed things but we might have other commands to consume */
William Lallemandbddd33a2018-12-11 16:10:53 +01002294 pcli_write_prompt(s);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002295 goto read_again;
William Lallemandbddd33a2018-12-11 16:10:53 +01002296 } else if (to_forward == -1 && errmsg) {
2297 /* there was an error during the parsing */
2298 pcli_reply_and_close(s, errmsg);
2299 return 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002300 } else if (to_forward == -1 && channel_full(req, global.tune.maxrewrite)) {
2301 /* buffer is full and we didn't catch the end of a command */
2302 goto send_help;
2303 }
2304
2305 return 0;
2306
2307send_help:
2308 b_reset(&req->buf);
2309 b_putblk(&req->buf, "help\n", 5);
2310 goto read_again;
2311}
2312
2313int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
2314{
2315 struct proxy *fe = strm_fe(s);
2316 struct proxy *be = s->be;
2317
William Lallemand6b7cd0a2018-11-06 17:37:11 +01002318 if (rep->flags & CF_READ_ERROR) {
2319 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
2320 s->res.analysers &= ~AN_RES_WAIT_CLI;
2321 return 0;
2322 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002323 rep->flags |= CF_READ_DONTWAIT; /* try to get back here ASAP */
2324 rep->flags |= CF_NEVER_WAIT;
2325
2326 /* don't forward the close */
2327 channel_dont_close(&s->res);
2328 channel_dont_close(&s->req);
2329
William Lallemanddc12c2e2018-12-13 09:05:46 +01002330 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002331 s->req.analysers |= AN_REQ_WAIT_CLI;
2332 s->res.analysers &= ~AN_RES_WAIT_CLI;
2333 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2334 return 0;
2335 }
2336
William Lallemandcf62f7e2018-10-26 14:47:40 +02002337 /* forward the data */
2338 if (ci_data(rep)) {
2339 c_adv(rep, ci_data(rep));
2340 return 0;
2341 }
2342
2343 if ((rep->flags & (CF_SHUTR|CF_READ_NULL))) {
2344 /* stream cleanup */
2345
William Lallemand2f4ce202018-10-26 14:47:47 +02002346 pcli_write_prompt(s);
2347
William Lallemandcf62f7e2018-10-26 14:47:40 +02002348 s->si[1].flags |= SI_FL_NOLINGER | SI_FL_NOHALF;
2349 si_shutr(&s->si[1]);
2350 si_shutw(&s->si[1]);
2351
2352 /*
2353 * starting from there this the same code as
2354 * http_end_txn_clean_session().
2355 *
2356 * It allows to do frontend keepalive while reconnecting to a
2357 * new server for each request.
2358 */
2359
2360 if (s->flags & SF_BE_ASSIGNED) {
2361 HA_ATOMIC_SUB(&be->beconn, 1);
2362 if (unlikely(s->srv_conn))
2363 sess_change_server(s, NULL);
2364 }
2365
2366 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2367 stream_process_counters(s);
2368
2369 /* don't count other requests' data */
2370 s->logs.bytes_in -= ci_data(&s->req);
2371 s->logs.bytes_out -= ci_data(&s->res);
2372
2373 /* we may need to know the position in the queue */
2374 pendconn_free(s);
2375
2376 /* let's do a final log if we need it */
2377 if (!LIST_ISEMPTY(&fe->logformat) && s->logs.logwait &&
2378 !(s->flags & SF_MONITOR) &&
2379 (!(fe->options & PR_O_NULLNOLOG) || s->req.total)) {
2380 s->do_log(s);
2381 }
2382
2383 /* stop tracking content-based counters */
2384 stream_stop_content_counters(s);
2385 stream_update_time_stats(s);
2386
2387 s->logs.accept_date = date; /* user-visible date for logging */
2388 s->logs.tv_accept = now; /* corrected date for internal use */
2389 s->logs.t_handshake = 0; /* There are no handshake in keep alive connection. */
2390 s->logs.t_idle = -1;
2391 tv_zero(&s->logs.tv_request);
2392 s->logs.t_queue = -1;
2393 s->logs.t_connect = -1;
2394 s->logs.t_data = -1;
2395 s->logs.t_close = 0;
2396 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
2397 s->logs.srv_queue_pos = 0; /* we will get this number soon */
2398
2399 s->logs.bytes_in = s->req.total = ci_data(&s->req);
2400 s->logs.bytes_out = s->res.total = ci_data(&s->res);
2401
2402 stream_del_srv_conn(s);
2403 if (objt_server(s->target)) {
2404 if (s->flags & SF_CURR_SESS) {
2405 s->flags &= ~SF_CURR_SESS;
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002406 HA_ATOMIC_SUB(&__objt_server(s->target)->cur_sess, 1);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002407 }
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002408 if (may_dequeue_tasks(__objt_server(s->target), be))
2409 process_srv_queue(__objt_server(s->target));
William Lallemandcf62f7e2018-10-26 14:47:40 +02002410 }
2411
2412 s->target = NULL;
2413
2414 /* only release our endpoint if we don't intend to reuse the
2415 * connection.
2416 */
2417 if (!si_conn_ready(&s->si[1])) {
2418 si_release_endpoint(&s->si[1]);
2419 s->srv_conn = NULL;
2420 }
2421
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002422 sockaddr_free(&s->target_addr);
2423
William Lallemandcf62f7e2018-10-26 14:47:40 +02002424 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
2425 s->si[1].err_type = SI_ET_NONE;
2426 s->si[1].conn_retries = 0; /* used for logging too */
2427 s->si[1].exp = TICK_ETERNITY;
2428 s->si[1].flags &= SI_FL_ISBACK | SI_FL_DONT_WAKE; /* we're in the context of process_stream */
Christopher Faulet22dc2482019-07-16 14:43:08 +02002429 s->req.flags &= ~(CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CONNECT|CF_WRITE_ERROR|CF_STREAMER|CF_STREAMER_FAST|CF_NEVER_WAIT|CF_WROTE_DATA);
William Lallemand19338012019-06-25 18:00:19 +02002430 s->res.flags &= ~(CF_SHUTR|CF_SHUTR_NOW|CF_READ_ATTACHED|CF_READ_ERROR|CF_READ_NOEXP|CF_STREAMER|CF_STREAMER_FAST|CF_WRITE_PARTIAL|CF_NEVER_WAIT|CF_WROTE_DATA|CF_READ_NULL);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002431 s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_ADDR_SET|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
2432 s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
2433 s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
2434 /* reinitialise the current rule list pointer to NULL. We are sure that
2435 * any rulelist match the NULL pointer.
2436 */
2437 s->current_rule_list = NULL;
2438
2439 s->be = strm_fe(s);
2440 s->logs.logwait = strm_fe(s)->to_log;
2441 s->logs.level = 0;
2442 stream_del_srv_conn(s);
2443 s->target = NULL;
2444 /* re-init store persistence */
2445 s->store_count = 0;
2446 s->uniq_id = global.req_count++;
2447
2448 s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */
2449
2450 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2451
2452 s->req.analysers |= AN_REQ_WAIT_CLI;
2453 s->res.analysers &= ~AN_RES_WAIT_CLI;
2454
2455 /* We must trim any excess data from the response buffer, because we
2456 * may have blocked an invalid response from a server that we don't
Ilya Shipitsind4259502020-04-08 01:07:56 +05002457 * want to accidentally forward once we disable the analysers, nor do
William Lallemandcf62f7e2018-10-26 14:47:40 +02002458 * we want those data to come along with next response. A typical
2459 * example of such data would be from a buggy server responding to
2460 * a HEAD with some data, or sending more than the advertised
2461 * content-length.
2462 */
2463 if (unlikely(ci_data(&s->res)))
2464 b_set_data(&s->res.buf, co_data(&s->res));
2465
2466 /* Now we can realign the response buffer */
2467 c_realign_if_empty(&s->res);
2468
2469 s->req.rto = strm_fe(s)->timeout.client;
2470 s->req.wto = TICK_ETERNITY;
2471
2472 s->res.rto = TICK_ETERNITY;
2473 s->res.wto = strm_fe(s)->timeout.client;
2474
2475 s->req.rex = TICK_ETERNITY;
2476 s->req.wex = TICK_ETERNITY;
2477 s->req.analyse_exp = TICK_ETERNITY;
2478 s->res.rex = TICK_ETERNITY;
2479 s->res.wex = TICK_ETERNITY;
2480 s->res.analyse_exp = TICK_ETERNITY;
2481 s->si[1].hcto = TICK_ETERNITY;
2482
2483 /* we're removing the analysers, we MUST re-enable events detection.
2484 * We don't enable close on the response channel since it's either
2485 * already closed, or in keep-alive with an idle connection handler.
2486 */
2487 channel_auto_read(&s->req);
2488 channel_auto_close(&s->req);
2489 channel_auto_read(&s->res);
2490
2491
2492 return 1;
2493 }
2494 return 0;
2495}
2496
William Lallemand8a022572018-10-26 14:47:35 +02002497/*
2498 * The mworker functions are used to initialize the CLI in the master process
2499 */
2500
William Lallemand309dc9a2018-10-26 14:47:45 +02002501 /*
2502 * Stop the mworker proxy
2503 */
2504void mworker_cli_proxy_stop()
2505{
William Lallemand550db6d2018-11-06 17:37:12 +01002506 if (mworker_proxy)
2507 stop_proxy(mworker_proxy);
William Lallemand309dc9a2018-10-26 14:47:45 +02002508}
2509
William Lallemand8a022572018-10-26 14:47:35 +02002510/*
2511 * Create the mworker CLI proxy
2512 */
2513int mworker_cli_proxy_create()
2514{
2515 struct mworker_proc *child;
William Lallemand744a0892018-11-22 16:46:51 +01002516 char *msg = NULL;
2517 char *errmsg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002518
2519 mworker_proxy = calloc(1, sizeof(*mworker_proxy));
2520 if (!mworker_proxy)
2521 return -1;
2522
2523 init_new_proxy(mworker_proxy);
2524 mworker_proxy->next = proxies_list;
2525 proxies_list = mworker_proxy;
2526 mworker_proxy->id = strdup("MASTER");
William Lallemandcf62f7e2018-10-26 14:47:40 +02002527 mworker_proxy->mode = PR_MODE_CLI;
William Lallemand8a022572018-10-26 14:47:35 +02002528 mworker_proxy->last_change = now.tv_sec;
2529 mworker_proxy->cap = PR_CAP_LISTEN; /* this is a listen section */
2530 mworker_proxy->maxconn = 10; /* default to 10 concurrent connections */
2531 mworker_proxy->timeout.client = 0; /* no timeout */
2532 mworker_proxy->conf.file = strdup("MASTER");
2533 mworker_proxy->conf.line = 0;
2534 mworker_proxy->accept = frontend_accept;
2535 mworker_proxy-> lbprm.algo = BE_LB_ALGO_NONE;
2536
2537 /* Does not init the default target the CLI applet, but must be done in
2538 * the request parsing code */
2539 mworker_proxy->default_target = NULL;
2540
2541 /* the check_config_validity() will get an ID for the proxy */
2542 mworker_proxy->uuid = -1;
2543
2544 proxy_store_name(mworker_proxy);
2545
2546 /* create all servers using the mworker_proc list */
2547 list_for_each_entry(child, &proc_list, list) {
William Lallemand8a022572018-10-26 14:47:35 +02002548 struct server *newsrv = NULL;
2549 struct sockaddr_storage *sk;
2550 int port1, port2, port;
2551 struct protocol *proto;
William Lallemand8a022572018-10-26 14:47:35 +02002552
William Lallemanda31b09e2020-01-14 15:25:02 +01002553 /* only the workers support the master CLI */
2554 if (!(child->options & PROC_O_TYPE_WORKER))
2555 continue;
2556
William Lallemand8a022572018-10-26 14:47:35 +02002557 newsrv = new_server(mworker_proxy);
2558 if (!newsrv)
William Lallemand744a0892018-11-22 16:46:51 +01002559 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002560
2561 /* we don't know the new pid yet */
2562 if (child->pid == -1)
2563 memprintf(&msg, "cur-%d", child->relative_pid);
2564 else
2565 memprintf(&msg, "old-%d", child->pid);
2566
2567 newsrv->next = mworker_proxy->srv;
2568 mworker_proxy->srv = newsrv;
2569 newsrv->conf.file = strdup(msg);
2570 newsrv->id = strdup(msg);
2571 newsrv->conf.line = 0;
2572
2573 memprintf(&msg, "sockpair@%d", child->ipc_fd[0]);
Willy Tarreau5fc93282020-09-16 18:25:03 +02002574 if ((sk = str2sa_range(msg, &port, &port1, &port2, NULL, &proto,
Willy Tarreaua93e5c72020-09-15 14:01:16 +02002575 &errmsg, NULL, NULL, PA_O_STREAM)) == 0) {
William Lallemand744a0892018-11-22 16:46:51 +01002576 goto error;
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002577 }
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002578 ha_free(&msg);
William Lallemand8a022572018-10-26 14:47:35 +02002579
Willy Tarreau5fc93282020-09-16 18:25:03 +02002580 if (!proto->connect) {
William Lallemand744a0892018-11-22 16:46:51 +01002581 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002582 }
2583
2584 /* no port specified */
2585 newsrv->flags |= SRV_F_MAPPORTS;
2586 newsrv->addr = *sk;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002587 /* don't let the server participate to load balancing */
2588 newsrv->iweight = 0;
2589 newsrv->uweight = 0;
William Lallemand8a022572018-10-26 14:47:35 +02002590 srv_lb_commit_status(newsrv);
William Lallemand291810d2018-10-26 14:47:38 +02002591
2592 child->srv = newsrv;
William Lallemand8a022572018-10-26 14:47:35 +02002593 }
2594 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002595
2596error:
2597 ha_alert("%s\n", errmsg);
2598
2599 list_for_each_entry(child, &proc_list, list) {
2600 free((char *)child->srv->conf.file); /* cast because of const char * */
2601 free(child->srv->id);
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002602 ha_free(&child->srv);
William Lallemand744a0892018-11-22 16:46:51 +01002603 }
2604 free(mworker_proxy->id);
2605 free(mworker_proxy->conf.file);
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002606 ha_free(&mworker_proxy);
William Lallemand744a0892018-11-22 16:46:51 +01002607 free(errmsg);
2608 free(msg);
2609
2610 return -1;
William Lallemand8a022572018-10-26 14:47:35 +02002611}
Olivier Houchardf886e342017-04-05 22:24:59 +02002612
William Lallemandce83b4a2018-10-26 14:47:30 +02002613/*
William Lallemande7361152018-10-26 14:47:36 +02002614 * Create a new listener for the master CLI proxy
2615 */
2616int mworker_cli_proxy_new_listener(char *line)
2617{
2618 struct bind_conf *bind_conf;
2619 struct listener *l;
2620 char *err = NULL;
2621 char *args[MAX_LINE_ARGS + 1];
2622 int arg;
2623 int cur_arg;
2624
William Lallemand2e945c82019-11-25 09:58:37 +01002625 arg = 1;
William Lallemande7361152018-10-26 14:47:36 +02002626 args[0] = line;
2627
2628 /* args is a bind configuration with spaces replaced by commas */
2629 while (*line && arg < MAX_LINE_ARGS) {
2630
2631 if (*line == ',') {
2632 *line++ = '\0';
2633 while (*line == ',')
2634 line++;
William Lallemand2e945c82019-11-25 09:58:37 +01002635 args[arg++] = line;
William Lallemande7361152018-10-26 14:47:36 +02002636 }
2637 line++;
2638 }
2639
William Lallemand2e945c82019-11-25 09:58:37 +01002640 args[arg] = "\0";
William Lallemande7361152018-10-26 14:47:36 +02002641
2642 bind_conf = bind_conf_alloc(mworker_proxy, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002643 if (!bind_conf)
2644 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002645
2646 bind_conf->level &= ~ACCESS_LVL_MASK;
2647 bind_conf->level |= ACCESS_LVL_ADMIN;
2648
2649 if (!str2listener(args[0], mworker_proxy, bind_conf, "master-socket", 0, &err)) {
2650 ha_alert("Cannot create the listener of the master CLI\n");
William Lallemand744a0892018-11-22 16:46:51 +01002651 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002652 }
2653
2654 cur_arg = 1;
2655
2656 while (*args[cur_arg]) {
William Lallemande7361152018-10-26 14:47:36 +02002657 struct bind_kw *kw;
Willy Tarreau433b05f2021-03-12 10:14:07 +01002658 const char *best;
William Lallemande7361152018-10-26 14:47:36 +02002659
2660 kw = bind_find_kw(args[cur_arg]);
2661 if (kw) {
2662 if (!kw->parse) {
2663 memprintf(&err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
2664 args[0], args[1], args[cur_arg]);
2665 goto err;
2666 }
2667
2668 if (kw->parse(args, cur_arg, global.stats_fe, bind_conf, &err) != 0) {
2669 if (err)
2670 memprintf(&err, "'%s %s' : '%s'", args[0], args[1], err);
2671 else
2672 memprintf(&err, "'%s %s' : error encountered while processing '%s'",
2673 args[0], args[1], args[cur_arg]);
2674 goto err;
2675 }
2676
2677 cur_arg += 1 + kw->skip;
2678 continue;
2679 }
2680
Willy Tarreau433b05f2021-03-12 10:14:07 +01002681 best = bind_find_best_kw(args[cur_arg]);
2682 if (best)
2683 memprintf(&err, "'%s %s' : unknown keyword '%s'. Did you mean '%s' maybe ?",
2684 args[0], args[1], args[cur_arg], best);
2685 else
2686 memprintf(&err, "'%s %s' : unknown keyword '%s'.",
2687 args[0], args[1], args[cur_arg]);
William Lallemande7361152018-10-26 14:47:36 +02002688 goto err;
2689 }
2690
2691
2692 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemande7361152018-10-26 14:47:36 +02002693 l->accept = session_accept_fd;
2694 l->default_target = mworker_proxy->default_target;
2695 /* don't make the peers subject to global limits and don't close it in the master */
Willy Tarreau18c20d22020-10-09 16:11:46 +02002696 l->options |= LI_O_UNLIMITED;
2697 l->rx.flags |= RX_F_MWORKER; /* we are keeping this FD in the master */
William Lallemande7361152018-10-26 14:47:36 +02002698 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002699 global.maxsock++; /* for the listening socket */
William Lallemande7361152018-10-26 14:47:36 +02002700 }
Willy Tarreau18215cb2019-02-27 16:25:28 +01002701 global.maxsock += mworker_proxy->maxconn;
William Lallemande7361152018-10-26 14:47:36 +02002702
2703 return 0;
2704
2705err:
2706 ha_alert("%s\n", err);
William Lallemand744a0892018-11-22 16:46:51 +01002707 free(err);
2708 free(bind_conf);
William Lallemande7361152018-10-26 14:47:36 +02002709 return -1;
2710
2711}
2712
2713/*
William Lallemandce83b4a2018-10-26 14:47:30 +02002714 * Create a new CLI socket using a socketpair for a worker process
2715 * <mworker_proc> is the process structure, and <proc> is the process number
2716 */
2717int mworker_cli_sockpair_new(struct mworker_proc *mworker_proc, int proc)
2718{
2719 struct bind_conf *bind_conf;
2720 struct listener *l;
2721 char *path = NULL;
2722 char *err = NULL;
2723
2724 /* master pipe to ensure the master is still alive */
2725 if (socketpair(AF_UNIX, SOCK_STREAM, 0, mworker_proc->ipc_fd) < 0) {
2726 ha_alert("Cannot create worker socketpair.\n");
2727 return -1;
2728 }
2729
2730 /* XXX: we might want to use a separate frontend at some point */
2731 if (!global.stats_fe) {
2732 if ((global.stats_fe = alloc_stats_fe("GLOBAL", "master-socket", 0)) == NULL) {
2733 ha_alert("out of memory trying to allocate the stats frontend");
William Lallemand744a0892018-11-22 16:46:51 +01002734 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002735 }
2736 }
2737
2738 bind_conf = bind_conf_alloc(global.stats_fe, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002739 if (!bind_conf)
2740 goto error;
2741
William Lallemandce83b4a2018-10-26 14:47:30 +02002742 bind_conf->level &= ~ACCESS_LVL_MASK;
2743 bind_conf->level |= ACCESS_LVL_ADMIN; /* TODO: need to lower the rights with a CLI keyword*/
2744
Willy Tarreaue26993c2020-09-03 07:18:55 +02002745 bind_conf->settings.bind_proc = 1UL << proc;
William Lallemandce83b4a2018-10-26 14:47:30 +02002746 global.stats_fe->bind_proc = 0; /* XXX: we should be careful with that, it can be removed by configuration */
2747
2748 if (!memprintf(&path, "sockpair@%d", mworker_proc->ipc_fd[1])) {
2749 ha_alert("Cannot allocate listener.\n");
William Lallemand744a0892018-11-22 16:46:51 +01002750 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002751 }
2752
2753 if (!str2listener(path, global.stats_fe, bind_conf, "master-socket", 0, &err)) {
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002754 free(path);
William Lallemandce83b4a2018-10-26 14:47:30 +02002755 ha_alert("Cannot create a CLI sockpair listener for process #%d\n", proc);
William Lallemand744a0892018-11-22 16:46:51 +01002756 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002757 }
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002758 ha_free(&path);
William Lallemandce83b4a2018-10-26 14:47:30 +02002759
2760 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemandce83b4a2018-10-26 14:47:30 +02002761 l->accept = session_accept_fd;
2762 l->default_target = global.stats_fe->default_target;
William Lallemanda3372292018-11-16 16:57:22 +01002763 l->options |= (LI_O_UNLIMITED | LI_O_NOSTOP);
Willy Tarreau455585e2020-10-09 18:25:14 +02002764 HA_ATOMIC_ADD(&unstoppable_jobs, 1);
William Lallemandce83b4a2018-10-26 14:47:30 +02002765 /* it's a sockpair but we don't want to keep the fd in the master */
Willy Tarreau43046fa2020-09-01 15:41:59 +02002766 l->rx.flags &= ~RX_F_INHERITED;
William Lallemandce83b4a2018-10-26 14:47:30 +02002767 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002768 global.maxsock++; /* for the listening socket */
William Lallemandce83b4a2018-10-26 14:47:30 +02002769 }
2770
2771 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002772
2773error:
2774 close(mworker_proc->ipc_fd[0]);
2775 close(mworker_proc->ipc_fd[1]);
2776 free(err);
2777
2778 return -1;
William Lallemandce83b4a2018-10-26 14:47:30 +02002779}
2780
William Lallemand74c24fb2016-11-21 17:18:36 +01002781static struct applet cli_applet = {
2782 .obj_type = OBJ_TYPE_APPLET,
2783 .name = "<CLI>", /* used for logging */
2784 .fct = cli_io_handler,
2785 .release = cli_release_handler,
2786};
2787
William Lallemand99e0bb92020-11-05 10:28:53 +01002788/* master CLI */
2789static struct applet mcli_applet = {
2790 .obj_type = OBJ_TYPE_APPLET,
2791 .name = "<MCLI>", /* used for logging */
2792 .fct = cli_io_handler,
2793 .release = cli_release_handler,
2794};
2795
Willy Tarreau0a739292016-11-22 20:21:23 +01002796/* register cli keywords */
2797static struct cli_kw_list cli_kws = {{ },{
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002798 { { "help", NULL }, NULL, cli_parse_simple, NULL },
2799 { { "prompt", NULL }, NULL, cli_parse_simple, NULL },
2800 { { "quit", NULL }, NULL, cli_parse_simple, NULL },
Willy Tarreau2af99412016-11-23 11:10:59 +01002801 { { "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 +01002802 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002803 { { "set", "severity-output", NULL }, "set severity-output [none|number|string] : set presence of severity level in feedback information", cli_parse_set_severity_output, NULL, NULL },
Willy Tarreau599852e2016-11-22 20:33:32 +01002804 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002805 { { "show", "env", NULL }, "show env [var] : dump environment variables known to the process", cli_parse_show_env, cli_io_handler_show_env, NULL },
William Lallemand35851fb2018-10-26 14:47:42 +02002806 { { "show", "cli", "sockets", NULL }, "show cli sockets : dump list of cli sockets", cli_parse_default, cli_io_handler_show_cli_sock, NULL, NULL, ACCESS_MASTER },
William Lallemand67a234f2018-12-13 09:05:45 +01002807 { { "show", "cli", "level", NULL }, "show cli level : display the level of the current CLI session", cli_parse_show_lvl, NULL, NULL, NULL, ACCESS_MASTER},
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02002808 { { "show", "fd", NULL }, "show fd [num] : dump list of file descriptors in use", cli_parse_show_fd, cli_io_handler_show_fd, NULL },
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01002809 { { "show", "activity", NULL }, "show activity : show per-thread activity stats (for support/developers)", cli_parse_default, cli_io_handler_show_activity, NULL },
William Lallemand67a234f2018-12-13 09:05:45 +01002810 { { "operator", NULL }, "operator : lower the level of the current CLI session to operator", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
2811 { { "user", NULL }, "user : lower the level of the current CLI session to user", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
Olivier Houchardf886e342017-04-05 22:24:59 +02002812 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02002813 { { "expert-mode", NULL }, NULL, cli_parse_expert_mode, NULL }, // not listed
Willy Tarreau0a739292016-11-22 20:21:23 +01002814 {{},}
2815}};
2816
Willy Tarreau0108d902018-11-25 19:14:37 +01002817INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
2818
William Lallemand74c24fb2016-11-21 17:18:36 +01002819static struct cfg_kw_list cfg_kws = {ILH, {
2820 { CFG_GLOBAL, "stats", stats_parse_global },
2821 { 0, NULL, NULL },
2822}};
2823
Willy Tarreau0108d902018-11-25 19:14:37 +01002824INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
2825
William Lallemand74c24fb2016-11-21 17:18:36 +01002826static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02002827 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
2828 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002829 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01002830 { NULL, NULL, 0 },
2831}};
2832
Willy Tarreau0108d902018-11-25 19:14:37 +01002833INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01002834
2835/*
2836 * Local variables:
2837 * c-indent-level: 8
2838 * c-basic-offset: 8
2839 * End:
2840 */