blob: 162daa62d297c01dc97c8e60b9bb33ff0249c0d0 [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
Willy Tarreau4975d142021-03-13 11:00:33 +010071static const char cli_permission_denied_msg[] =
William Lallemand74c24fb2016-11-21 17:18:36 +010072 "Permission denied\n"
73 "";
74
75
Christopher Faulet1bc04c72017-10-29 20:14:08 +010076static THREAD_LOCAL char *dynamic_usage_msg = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +010077
78/* List head of cli keywords */
79static struct cli_kw_list cli_keywords = {
80 .list = LIST_HEAD_INIT(cli_keywords.list)
81};
82
83extern const char *stat_status_codes[];
84
Eric Salama1b8dacc2021-03-16 15:12:17 +010085struct proxy *mworker_proxy; /* CLI proxy of the master */
William Lallemand8a022572018-10-26 14:47:35 +020086
Willy Tarreaub96a74c2021-03-12 17:13:28 +010087/* This will show the help message and list the commands supported at the
88 * current level that match all of the first words of <args> if args is not
89 * NULL, or all args if none matches or if args is null.
90 */
91static char *cli_gen_usage_msg(struct appctx *appctx, char * const *args)
William Lallemand74c24fb2016-11-21 17:18:36 +010092{
93 struct cli_kw_list *kw_list;
94 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +020095 struct buffer *tmp = get_trash_chunk();
96 struct buffer out;
Willy Tarreaub7364582021-03-12 18:24:46 +010097 struct { struct cli_kw *kw; int dist; } matches[CLI_MAX_MATCHES], swp;
Willy Tarreaub96a74c2021-03-12 17:13:28 +010098 int idx;
99 int length = 0;
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
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100103 /* first, let's measure the longest match */
104 list_for_each_entry(kw_list, &cli_keywords.list, list) {
105 for (kw = &kw_list->kw[0]; kw->str_kw[0]; kw++) {
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100106 if (kw->level & ~appctx->cli_level & (ACCESS_MASTER_ONLY|ACCESS_EXPERT|ACCESS_EXPERIMENTAL))
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100107 continue;
108 if ((appctx->cli_level & ~kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)) ==
109 (ACCESS_MASTER_ONLY|ACCESS_MASTER))
110 continue;
111
112 /* OK this command is visible */
113 for (idx = 0; idx < CLI_PREFIX_KW_NB; idx++) {
114 if (!kw->str_kw[idx])
115 break; // end of keyword
116 if (!args || !args[idx] || !*args[idx])
117 break; // end of command line
118 if (strcmp(kw->str_kw[idx], args[idx]) != 0)
119 break;
120 if (idx + 1 > length)
121 length = idx + 1;
122 }
123 }
124 }
125
Willy Tarreaub7364582021-03-12 18:24:46 +0100126 /* now <length> equals the number of exactly matching words */
William Lallemand74c24fb2016-11-21 17:18:36 +0100127 chunk_reset(tmp);
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100128 if (!args) // this is the help message.
129 chunk_strcat(tmp, "The following commands are valid at this level:\n");
Willy Tarreaub7364582021-03-12 18:24:46 +0100130 else if (!length && (!*args || !**args)) // no match
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100131 chunk_strcat(tmp, "Unknown command. Please enter one of the following commands only:\n");
132 else // partial match
133 chunk_strcat(tmp, "Unknown command, but maybe one of the following ones is a better match:\n");
134
Willy Tarreaub7364582021-03-12 18:24:46 +0100135 for (idx = 0; idx < CLI_MAX_MATCHES; idx++) {
136 matches[idx].kw = NULL;
137 matches[idx].dist = INT_MAX;
138 }
139
140 /* In case of partial match we'll look for the best matching entries
141 * starting from position <length>
142 */
Willy Tarreau9c187472021-03-13 12:25:43 +0100143 if (args && args[length] && *args[length]) {
Willy Tarreaub7364582021-03-12 18:24:46 +0100144 list_for_each_entry(kw_list, &cli_keywords.list, list) {
145 for (kw = &kw_list->kw[0]; kw->str_kw[0]; kw++) {
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100146 if (kw->level & ~appctx->cli_level & (ACCESS_MASTER_ONLY|ACCESS_EXPERT|ACCESS_EXPERIMENTAL))
Willy Tarreaub7364582021-03-12 18:24:46 +0100147 continue;
148 if ((appctx->cli_level & ~kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)) ==
149 (ACCESS_MASTER_ONLY|ACCESS_MASTER))
150 continue;
151
152 for (idx = 0; idx < length; idx++) {
153 if (!kw->str_kw[idx])
154 break; // end of keyword
155 if (!args || !args[idx] || !*args[idx])
156 break; // end of command line
157 if (strcmp(kw->str_kw[idx], args[idx]) != 0)
158 break;
159 }
160
161 /* extra non-matching words are fuzzy-matched */
162 if (kw->usage && idx == length && args[idx] && *args[idx]) {
163 uint8_t word_sig[1024];
164 uint8_t list_sig[1024];
165 int dist = 0;
166 int totlen = 0;
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100167 int i;
Willy Tarreaub7364582021-03-12 18:24:46 +0100168
169 /* this one matches, let's compute the distance between the two
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100170 * on the remaining words. For this we're computing the signature
171 * of everything that remains and the cumulated length of the
172 * strings.
Willy Tarreaub7364582021-03-12 18:24:46 +0100173 */
Willy Tarreauc57dcfe2021-03-12 19:01:59 +0100174 memset(word_sig, 0, sizeof(word_sig));
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100175 for (i = idx; i < CLI_PREFIX_KW_NB && args[i] && *args[i]; i++) {
176 update_word_fingerprint(word_sig, args[i]);
177 totlen += strlen(args[i]);
178 }
Willy Tarreauc57dcfe2021-03-12 19:01:59 +0100179
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100180 memset(list_sig, 0, sizeof(list_sig));
181 for (i = idx; i < CLI_PREFIX_KW_NB && kw->str_kw[i]; i++) {
182 update_word_fingerprint(list_sig, kw->str_kw[i]);
183 totlen += strlen(kw->str_kw[i]);
Willy Tarreaub7364582021-03-12 18:24:46 +0100184 }
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100185
Willy Tarreauc57dcfe2021-03-12 19:01:59 +0100186 dist = word_fingerprint_distance(word_sig, list_sig);
Willy Tarreaub7364582021-03-12 18:24:46 +0100187
188 /* insert this one at its place if relevant, in order to keep only
189 * the best matches.
190 */
191 swp.kw = kw; swp.dist = dist;
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100192 if (dist < 5*totlen/2 && dist < matches[CLI_MAX_MATCHES-1].dist) {
Willy Tarreaub7364582021-03-12 18:24:46 +0100193 matches[CLI_MAX_MATCHES-1] = swp;
194 for (idx = CLI_MAX_MATCHES - 1; --idx >= 0;) {
195 if (matches[idx+1].dist >= matches[idx].dist)
196 break;
197 matches[idx+1] = matches[idx];
198 matches[idx] = swp;
199 }
200 }
201 }
202 }
203 }
204 }
205
Willy Tarreauec197e82021-03-15 10:35:04 +0100206 if (matches[0].kw) {
207 /* we have fuzzy matches, let's propose them */
208 for (idx = 0; idx < CLI_MAX_MATCHES; idx++) {
209 kw = matches[idx].kw;
210 if (!kw)
211 break;
212
213 /* stop the dump if some words look very unlikely candidates */
214 if (matches[idx].dist > 5*matches[0].dist/2)
215 break;
216
217 chunk_appendf(tmp, " %s\n", kw->usage);
218 }
219 }
220
William Lallemand74c24fb2016-11-21 17:18:36 +0100221 list_for_each_entry(kw_list, &cli_keywords.list, list) {
Willy Tarreauec197e82021-03-15 10:35:04 +0100222 /* no full dump if we've already found nice candidates */
223 if (matches[0].kw)
224 break;
225
Willy Tarreau91bc3592021-03-12 15:20:39 +0100226 for (kw = &kw_list->kw[0]; kw->str_kw[0]; kw++) {
William Lallemand14721be2018-10-26 14:47:37 +0200227
Willy Tarreau91bc3592021-03-12 15:20:39 +0100228 /* in a worker or normal process, don't display master-only commands
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100229 * nor expert/experimental mode commands if not in this mode.
Willy Tarreau91bc3592021-03-12 15:20:39 +0100230 */
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100231 if (kw->level & ~appctx->cli_level & (ACCESS_MASTER_ONLY|ACCESS_EXPERT|ACCESS_EXPERIMENTAL))
Willy Tarreau91bc3592021-03-12 15:20:39 +0100232 continue;
William Lallemand14721be2018-10-26 14:47:37 +0200233
Willy Tarreau91bc3592021-03-12 15:20:39 +0100234 /* in master don't display commands that have neither the master bit
235 * nor the master-only bit.
236 */
237 if ((appctx->cli_level & ~kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)) ==
238 (ACCESS_MASTER_ONLY|ACCESS_MASTER))
239 continue;
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200240
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100241 for (idx = 0; idx < length; idx++) {
242 if (!kw->str_kw[idx])
243 break; // end of keyword
244 if (!args || !args[idx] || !*args[idx])
245 break; // end of command line
246 if (strcmp(kw->str_kw[idx], args[idx]) != 0)
247 break;
248 }
249
Willy Tarreauec197e82021-03-15 10:35:04 +0100250 if (kw->usage && idx == length)
251 chunk_appendf(tmp, " %s\n", kw->usage);
William Lallemand74c24fb2016-11-21 17:18:36 +0100252 }
253 }
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100254
255 /* always show the prompt/help/quit commands */
256 chunk_strcat(tmp,
257 " help : full commands list\n"
258 " prompt : toggle interactive mode with prompt\n"
259 " quit : disconnect\n");
260
William Lallemand74c24fb2016-11-21 17:18:36 +0100261 chunk_init(&out, NULL, 0);
262 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200263 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200264
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100265 appctx->ctx.cli.severity = LOG_INFO;
266 appctx->ctx.cli.msg = dynamic_usage_msg;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200267 appctx->st0 = CLI_ST_PRINT;
268
William Lallemand74c24fb2016-11-21 17:18:36 +0100269 return dynamic_usage_msg;
270}
271
272struct cli_kw* cli_find_kw(char **args)
273{
274 struct cli_kw_list *kw_list;
275 struct cli_kw *kw;/* current cli_kw */
276 char **tmp_args;
277 const char **tmp_str_kw;
278 int found = 0;
279
280 if (LIST_ISEMPTY(&cli_keywords.list))
281 return NULL;
282
283 list_for_each_entry(kw_list, &cli_keywords.list, list) {
284 kw = &kw_list->kw[0];
285 while (*kw->str_kw) {
286 tmp_args = args;
287 tmp_str_kw = kw->str_kw;
288 while (*tmp_str_kw) {
289 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
290 found = 1;
291 } else {
292 found = 0;
293 break;
294 }
295 tmp_args++;
296 tmp_str_kw++;
297 }
298 if (found)
299 return (kw);
300 kw++;
301 }
302 }
303 return NULL;
304}
305
Thierry Fourniera51a1fd2020-11-28 20:10:08 +0100306struct cli_kw* cli_find_kw_exact(char **args)
307{
308 struct cli_kw_list *kw_list;
309 int found = 0;
310 int i;
311 int j;
312
313 if (LIST_ISEMPTY(&cli_keywords.list))
314 return NULL;
315
316 list_for_each_entry(kw_list, &cli_keywords.list, list) {
317 for (i = 0; kw_list->kw[i].str_kw[0]; i++) {
318 found = 1;
319 for (j = 0; j < CLI_PREFIX_KW_NB; j++) {
320 if (args[j] == NULL && kw_list->kw[i].str_kw[j] == NULL) {
321 break;
322 }
323 if (args[j] == NULL || kw_list->kw[i].str_kw[j] == NULL) {
324 found = 0;
325 break;
326 }
327 if (strcmp(args[j], kw_list->kw[i].str_kw[j]) != 0) {
328 found = 0;
329 break;
330 }
331 }
332 if (found)
333 return &kw_list->kw[i];
334 }
335 }
336 return NULL;
337}
338
William Lallemand74c24fb2016-11-21 17:18:36 +0100339void cli_register_kw(struct cli_kw_list *kw_list)
340{
Willy Tarreau2b718102021-04-21 07:32:39 +0200341 LIST_APPEND(&cli_keywords.list, &kw_list->list);
William Lallemand74c24fb2016-11-21 17:18:36 +0100342}
343
344
345/* allocate a new stats frontend named <name>, and return it
346 * (or NULL in case of lack of memory).
347 */
Willy Tarreau4975d142021-03-13 11:00:33 +0100348static struct proxy *cli_alloc_fe(const char *name, const char *file, int line)
William Lallemand74c24fb2016-11-21 17:18:36 +0100349{
350 struct proxy *fe;
351
352 fe = calloc(1, sizeof(*fe));
353 if (!fe)
354 return NULL;
355
356 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100357 fe->next = proxies_list;
358 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100359 fe->last_change = now.tv_sec;
360 fe->id = strdup("GLOBAL");
361 fe->cap = PR_CAP_FE;
362 fe->maxconn = 10; /* default to 10 concurrent connections */
363 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
364 fe->conf.file = strdup(file);
365 fe->conf.line = line;
366 fe->accept = frontend_accept;
367 fe->default_target = &cli_applet.obj_type;
368
369 /* the stats frontend is the only one able to assign ID #0 */
370 fe->conf.id.key = fe->uuid = 0;
371 eb32_insert(&used_proxy_id, &fe->conf.id);
372 return fe;
373}
374
375/* This function parses a "stats" statement in the "global" section. It returns
376 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
377 * error message into the <err> buffer which will be preallocated. The trailing
378 * '\n' must not be written. The function must be called with <args> pointing to
379 * the first word after "stats".
380 */
Willy Tarreau4975d142021-03-13 11:00:33 +0100381static int cli_parse_global(char **args, int section_type, struct proxy *curpx,
382 const struct proxy *defpx, const char *file, int line,
383 char **err)
William Lallemand74c24fb2016-11-21 17:18:36 +0100384{
385 struct bind_conf *bind_conf;
386 struct listener *l;
387
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100388 if (strcmp(args[1], "socket") == 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100389 int cur_arg;
390
391 if (*args[2] == 0) {
392 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
393 return -1;
394 }
395
Willy Tarreau4975d142021-03-13 11:00:33 +0100396 if (!global.cli_fe) {
397 if ((global.cli_fe = cli_alloc_fe("GLOBAL", file, line)) == NULL) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100398 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
399 return -1;
400 }
401 }
402
Willy Tarreau4975d142021-03-13 11:00:33 +0100403 bind_conf = bind_conf_alloc(global.cli_fe, file, line, args[2], xprt_get(XPRT_RAW));
Christopher Faulet0c6d1dc2021-04-12 16:56:37 +0200404 if (!bind_conf) {
405 memprintf(err, "'%s %s' : out of memory trying to allocate a bind_conf", args[0], args[1]);
406 return -1;
407 }
William Lallemand07a62f72017-05-24 00:57:40 +0200408 bind_conf->level &= ~ACCESS_LVL_MASK;
409 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100410
Willy Tarreau4975d142021-03-13 11:00:33 +0100411 if (!str2listener(args[2], global.cli_fe, bind_conf, file, line, err)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100412 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
413 file, line, args[0], args[1], err && *err ? *err : "error");
414 return -1;
415 }
416
417 cur_arg = 3;
418 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100419 struct bind_kw *kw;
Willy Tarreau433b05f2021-03-12 10:14:07 +0100420 const char *best;
William Lallemand74c24fb2016-11-21 17:18:36 +0100421
422 kw = bind_find_kw(args[cur_arg]);
423 if (kw) {
424 if (!kw->parse) {
425 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
426 args[0], args[1], args[cur_arg]);
427 return -1;
428 }
429
Willy Tarreau4975d142021-03-13 11:00:33 +0100430 if (kw->parse(args, cur_arg, global.cli_fe, bind_conf, err) != 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100431 if (err && *err)
432 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
433 else
434 memprintf(err, "'%s %s' : error encountered while processing '%s'",
435 args[0], args[1], args[cur_arg]);
436 return -1;
437 }
438
439 cur_arg += 1 + kw->skip;
440 continue;
441 }
442
Willy Tarreau433b05f2021-03-12 10:14:07 +0100443 best = bind_find_best_kw(args[cur_arg]);
444 if (best)
445 memprintf(err, "'%s %s' : unknown keyword '%s'. Did you mean '%s' maybe ?",
446 args[0], args[1], args[cur_arg], best);
447 else
448 memprintf(err, "'%s %s' : unknown keyword '%s'.",
449 args[0], args[1], args[cur_arg]);
William Lallemand74c24fb2016-11-21 17:18:36 +0100450 return -1;
451 }
452
453 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100454 l->accept = session_accept_fd;
Willy Tarreau4975d142021-03-13 11:00:33 +0100455 l->default_target = global.cli_fe->default_target;
William Lallemand74c24fb2016-11-21 17:18:36 +0100456 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
457 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100458 global.maxsock++; /* for the listening socket */
William Lallemand74c24fb2016-11-21 17:18:36 +0100459 }
460 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100461 else if (strcmp(args[1], "timeout") == 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100462 unsigned timeout;
463 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
464
Willy Tarreau9faebe32019-06-07 19:00:37 +0200465 if (res == PARSE_TIME_OVER) {
466 memprintf(err, "timer overflow in argument '%s' to '%s %s' (maximum value is 2147483647 ms or ~24.8 days)",
467 args[2], args[0], args[1]);
468 return -1;
469 }
470 else if (res == PARSE_TIME_UNDER) {
471 memprintf(err, "timer underflow in argument '%s' to '%s %s' (minimum non-null value is 1 ms)",
472 args[2], args[0], args[1]);
473 return -1;
474 }
475 else if (res) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100476 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
477 return -1;
478 }
479
480 if (!timeout) {
481 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
482 return -1;
483 }
Willy Tarreau4975d142021-03-13 11:00:33 +0100484 if (!global.cli_fe) {
485 if ((global.cli_fe = cli_alloc_fe("GLOBAL", file, line)) == NULL) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100486 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
487 return -1;
488 }
489 }
Willy Tarreau4975d142021-03-13 11:00:33 +0100490 global.cli_fe->timeout.client = MS_TO_TICKS(timeout);
William Lallemand74c24fb2016-11-21 17:18:36 +0100491 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100492 else if (strcmp(args[1], "maxconn") == 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100493 int maxconn = atol(args[2]);
494
495 if (maxconn <= 0) {
496 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
497 return -1;
498 }
499
Willy Tarreau4975d142021-03-13 11:00:33 +0100500 if (!global.cli_fe) {
501 if ((global.cli_fe = cli_alloc_fe("GLOBAL", file, line)) == NULL) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100502 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
503 return -1;
504 }
505 }
Willy Tarreau4975d142021-03-13 11:00:33 +0100506 global.cli_fe->maxconn = maxconn;
William Lallemand74c24fb2016-11-21 17:18:36 +0100507 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100508 else if (strcmp(args[1], "bind-process") == 0) { /* enable the socket only on some processes */
William Lallemand74c24fb2016-11-21 17:18:36 +0100509 int cur_arg = 2;
510 unsigned long set = 0;
511
Willy Tarreau4975d142021-03-13 11:00:33 +0100512 if (!global.cli_fe) {
513 if ((global.cli_fe = cli_alloc_fe("GLOBAL", file, line)) == NULL) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100514 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
515 return -1;
516 }
517 }
518
519 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100520 if (strcmp(args[cur_arg], "all") == 0) {
521 set = 0;
522 break;
523 }
Willy Tarreauff9c9142019-02-07 10:39:36 +0100524 if (parse_process_number(args[cur_arg], &set, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100525 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100526 return -1;
527 }
528 cur_arg++;
529 }
Willy Tarreau4975d142021-03-13 11:00:33 +0100530 global.cli_fe->bind_proc = set;
William Lallemand74c24fb2016-11-21 17:18:36 +0100531 }
532 else {
533 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
534 return -1;
535 }
536 return 0;
537}
538
William Lallemand33d29e22019-04-01 11:30:06 +0200539/*
William Lallemand9a37fd02019-04-12 16:09:24 +0200540 * This function exports the bound addresses of a <frontend> in the environment
541 * variable <varname>. Those addresses are separated by semicolons and prefixed
542 * with their type (abns@, unix@, sockpair@ etc)
543 * Return -1 upon error, 0 otherwise
William Lallemand33d29e22019-04-01 11:30:06 +0200544 */
William Lallemand9a37fd02019-04-12 16:09:24 +0200545int listeners_setenv(struct proxy *frontend, const char *varname)
William Lallemand33d29e22019-04-01 11:30:06 +0200546{
547 struct buffer *trash = get_trash_chunk();
548 struct bind_conf *bind_conf;
549
William Lallemand9a37fd02019-04-12 16:09:24 +0200550 if (frontend) {
551 list_for_each_entry(bind_conf, &frontend->conf.bind, by_fe) {
William Lallemand33d29e22019-04-01 11:30:06 +0200552 struct listener *l;
553
554 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
555 char addr[46];
556 char port[6];
557
William Lallemand620072b2019-04-12 16:09:25 +0200558 /* separate listener by semicolons */
559 if (trash->data)
560 chunk_appendf(trash, ";");
561
Willy Tarreau37159062020-08-27 07:48:42 +0200562 if (l->rx.addr.ss_family == AF_UNIX) {
William Lallemand33d29e22019-04-01 11:30:06 +0200563 const struct sockaddr_un *un;
564
Willy Tarreau37159062020-08-27 07:48:42 +0200565 un = (struct sockaddr_un *)&l->rx.addr;
William Lallemand33d29e22019-04-01 11:30:06 +0200566 if (un->sun_path[0] == '\0') {
567 chunk_appendf(trash, "abns@%s", un->sun_path+1);
568 } else {
569 chunk_appendf(trash, "unix@%s", un->sun_path);
570 }
Willy Tarreau37159062020-08-27 07:48:42 +0200571 } else if (l->rx.addr.ss_family == AF_INET) {
572 addr_to_str(&l->rx.addr, addr, sizeof(addr));
573 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemand33d29e22019-04-01 11:30:06 +0200574 chunk_appendf(trash, "ipv4@%s:%s", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +0200575 } else if (l->rx.addr.ss_family == AF_INET6) {
576 addr_to_str(&l->rx.addr, addr, sizeof(addr));
577 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemand33d29e22019-04-01 11:30:06 +0200578 chunk_appendf(trash, "ipv6@[%s]:%s", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +0200579 } else if (l->rx.addr.ss_family == AF_CUST_SOCKPAIR) {
580 chunk_appendf(trash, "sockpair@%d", ((struct sockaddr_in *)&l->rx.addr)->sin_addr.s_addr);
William Lallemand33d29e22019-04-01 11:30:06 +0200581 }
William Lallemand33d29e22019-04-01 11:30:06 +0200582 }
583 }
584 trash->area[trash->data++] = '\0';
William Lallemand9a37fd02019-04-12 16:09:24 +0200585 if (setenv(varname, trash->area, 1) < 0)
William Lallemand33d29e22019-04-01 11:30:06 +0200586 return -1;
587 }
588
589 return 0;
590}
591
William Lallemand9a37fd02019-04-12 16:09:24 +0200592int cli_socket_setenv()
593{
Willy Tarreau4975d142021-03-13 11:00:33 +0100594 if (listeners_setenv(global.cli_fe, "HAPROXY_CLI") < 0)
William Lallemand9a37fd02019-04-12 16:09:24 +0200595 return -1;
596 if (listeners_setenv(mworker_proxy, "HAPROXY_MASTER_CLI") < 0)
597 return -1;
598
599 return 0;
600}
601
William Lallemand33d29e22019-04-01 11:30:06 +0200602REGISTER_CONFIG_POSTPARSER("cli", cli_socket_setenv);
603
Willy Tarreaude57a572016-11-23 17:01:39 +0100604/* Verifies that the CLI at least has a level at least as high as <level>
605 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
606 * failure, an error message is prepared and the appctx's state is adjusted
607 * to print it so that a return 1 is enough to abort any processing.
608 */
609int cli_has_level(struct appctx *appctx, int level)
610{
Willy Tarreaude57a572016-11-23 17:01:39 +0100611
William Lallemandf630d012018-12-13 09:05:44 +0100612 if ((appctx->cli_level & ACCESS_LVL_MASK) < level) {
Willy Tarreau4975d142021-03-13 11:00:33 +0100613 cli_err(appctx, cli_permission_denied_msg);
Willy Tarreaude57a572016-11-23 17:01:39 +0100614 return 0;
615 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100616 return 1;
617}
618
William Lallemandb7ea1412018-12-13 09:05:47 +0100619/* same as cli_has_level but for the CLI proxy and without error message */
620int pcli_has_level(struct stream *s, int level)
621{
622 if ((s->pcli_flags & ACCESS_LVL_MASK) < level) {
623 return 0;
624 }
625 return 1;
626}
627
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200628/* Returns severity_output for the current session if set, or default for the socket */
629static int cli_get_severity_output(struct appctx *appctx)
630{
631 if (appctx->cli_severity_output)
632 return appctx->cli_severity_output;
633 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
634}
William Lallemand74c24fb2016-11-21 17:18:36 +0100635
Willy Tarreau41908562016-11-24 16:23:38 +0100636/* Processes the CLI interpreter on the stats socket. This function is called
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100637 * from the CLI's IO handler running in an appctx context. The function returns
638 * 1 if the request was understood, otherwise zero (in which case an error
639 * message will be displayed). It is called with appctx->st0
Willy Tarreau41908562016-11-24 16:23:38 +0100640 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
641 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
642 * have its own I/O handler called again. Most of the time, parsers will only
643 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100644 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
645 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100646 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200647static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100648{
Willy Tarreauf14c7572021-03-13 10:59:23 +0100649 char *args[MAX_CLI_ARGS + 1], *p, *end, *payload = NULL;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200650 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100651 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100652
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200653 appctx->st2 = 0;
654 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
William Lallemand74c24fb2016-11-21 17:18:36 +0100655
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200656 p = appctx->chunk->area;
657 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100658
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200659 /*
660 * Get the payload start if there is one.
661 * For the sake of simplicity, the payload pattern is looked up
662 * everywhere from the start of the input but it can only be found
663 * at the end of the first line if APPCTX_CLI_ST1_PAYLOAD is set.
664 *
665 * The input string was zero terminated so it is safe to use
666 * the str*() functions throughout the parsing
667 */
668 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
669 payload = strstr(p, PAYLOAD_PATTERN);
670 end = payload;
671 /* skip the pattern */
672 payload += strlen(PAYLOAD_PATTERN);
673 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100674
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200675 /*
676 * Get pointers on words.
677 * One extra slot is reserved to store a pointer on a null byte.
678 */
Willy Tarreauf14c7572021-03-13 10:59:23 +0100679 while (i < MAX_CLI_ARGS && p < end) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200680 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100681
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200682 /* skip leading spaces/tabs */
683 p += strspn(p, " \t");
684 if (!*p)
685 break;
William Lallemand74c24fb2016-11-21 17:18:36 +0100686
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200687 args[i] = p;
Yves Lafonb08c6d02020-06-08 16:08:06 +0200688 while (1) {
689 p += strcspn(p, " \t\\");
690 /* escaped chars using backlashes (\) */
691 if (*p == '\\') {
692 if (!*++p)
693 break;
694 if (!*++p)
695 break;
696 } else {
697 break;
698 }
699 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200700 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100701
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200702 /* unescape backslashes (\) */
703 for (j = 0, k = 0; args[i][k]; k++) {
704 if (args[i][k] == '\\') {
705 if (args[i][k + 1] == '\\')
706 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100707 else
708 continue;
709 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200710 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100711 j++;
712 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200713 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100714
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200715 i++;
716 }
717 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200718 p = appctx->chunk->area + appctx->chunk->data;
Willy Tarreauf14c7572021-03-13 10:59:23 +0100719 for (; i < MAX_CLI_ARGS + 1; i++)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200720 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100721
722 kw = cli_find_kw(args);
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100723 if (!kw ||
724 (kw->level & ~appctx->cli_level & ACCESS_MASTER_ONLY) ||
725 (appctx->cli_level & ~kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)) == (ACCESS_MASTER_ONLY|ACCESS_MASTER)) {
726 /* keyword not found in this mode */
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100727 cli_gen_usage_msg(appctx, args);
Willy Tarreau41908562016-11-24 16:23:38 +0100728 return 0;
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100729 }
William Lallemand14721be2018-10-26 14:47:37 +0200730
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100731 /* don't handle expert mode commands if not in this mode. */
732 if (kw->level & ~appctx->cli_level & ACCESS_EXPERT) {
733 cli_err(appctx, "This command is restricted to expert mode only.\n");
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200734 return 0;
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100735 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200736
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100737 if (kw->level & ~appctx->cli_level & ACCESS_EXPERIMENTAL) {
738 cli_err(appctx, "This command is restricted to experimental mode only.\n");
739 return 0;
740 }
741
Willy Tarreau41908562016-11-24 16:23:38 +0100742 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200743 appctx->io_release = kw->io_release;
William Lallemand90b098c2019-10-25 21:10:14 +0200744
745 if (kw->parse && kw->parse(args, payload, appctx, kw->private) != 0)
746 goto fail;
747
748 /* kw->parse could set its own io_handler or io_release handler */
749 if (!appctx->io_handler)
750 goto fail;
751
752 appctx->st0 = CLI_ST_CALLBACK;
753 return 1;
754fail:
755 appctx->io_handler = NULL;
756 appctx->io_release = NULL;
Willy Tarreau41908562016-11-24 16:23:38 +0100757 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100758}
759
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200760/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
761static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
762{
Willy Tarreau83061a82018-07-13 11:56:34 +0200763 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200764
765 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200766 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200767
768 tmp = get_trash_chunk();
769 chunk_reset(tmp);
770
771 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100772 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200773 chunk_printf(tmp, "[%d]: ", severity);
774 }
775 else {
776 switch (severity_output) {
777 case CLI_SEVERITY_NUMBER:
778 chunk_printf(tmp, "[%d]: ", severity);
779 break;
780 case CLI_SEVERITY_STRING:
781 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
782 break;
783 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100784 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200785 }
786 }
787 chunk_appendf(tmp, "%s", msg);
788
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200789 return ci_putblk(chn, tmp->area, strlen(tmp->area));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200790}
791
William Lallemand74c24fb2016-11-21 17:18:36 +0100792/* This I/O handler runs as an applet embedded in a stream interface. It is
793 * used to processes I/O from/to the stats unix socket. The system relies on a
794 * state machine handling requests and various responses. We read a request,
795 * then we process it and send the response, and we possibly display a prompt.
796 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100797 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100798 * or not.
799 */
800static void cli_io_handler(struct appctx *appctx)
801{
802 struct stream_interface *si = appctx->owner;
803 struct channel *req = si_oc(si);
804 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200805 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100806 int reql;
807 int len;
808
809 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
810 goto out;
811
Joseph Herlant008b3ce2018-11-25 12:51:45 -0800812 /* Check if the input buffer is available. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200813 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +0100814 /* buf.size==0 means we failed to get a buffer and were
815 * already subscribed to a wait list to get a buffer.
816 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100817 goto out;
818 }
819
William Lallemand74c24fb2016-11-21 17:18:36 +0100820 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100821 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100822 /* Stats output not initialized yet */
823 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200824 /* reset severity to default at init */
825 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100826 appctx->st0 = CLI_ST_GETREQ;
William Lallemandf630d012018-12-13 09:05:44 +0100827 appctx->cli_level = bind_conf->level;
William Lallemand74c24fb2016-11-21 17:18:36 +0100828 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100829 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100830 /* Let's close for real now. We just close the request
831 * side, the conditions below will complete if needed.
832 */
833 si_shutw(si);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200834 free_trash_chunk(appctx->chunk);
William Lallemand74c24fb2016-11-21 17:18:36 +0100835 break;
836 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100837 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200838 char *str;
839
840 /* use a trash chunk to store received data */
841 if (!appctx->chunk) {
842 appctx->chunk = alloc_trash_chunk();
843 if (!appctx->chunk) {
844 appctx->st0 = CLI_ST_END;
845 continue;
846 }
847 }
848
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200849 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200850
William Lallemand74c24fb2016-11-21 17:18:36 +0100851 /* ensure we have some output room left in the event we
852 * would want to return some info right after parsing.
853 */
854 if (buffer_almost_full(si_ib(si))) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100855 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100856 break;
857 }
858
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200859 /* '- 1' is to ensure a null byte can always be inserted at the end */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200860 reql = co_getline(si_oc(si), str,
861 appctx->chunk->size - appctx->chunk->data - 1);
William Lallemand74c24fb2016-11-21 17:18:36 +0100862 if (reql <= 0) { /* closed or EOL not found */
863 if (reql == 0)
864 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100865 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100866 continue;
867 }
868
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200869 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
870 /* seek for a possible unescaped semi-colon. If we find
871 * one, we replace it with an LF and skip only this part.
872 */
873 for (len = 0; len < reql; len++) {
874 if (str[len] == '\\') {
875 len++;
876 continue;
877 }
878 if (str[len] == ';') {
879 str[len] = '\n';
880 reql = len + 1;
881 break;
882 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100883 }
884 }
885
886 /* now it is time to check that we have a full line,
887 * remove the trailing \n and possibly \r, then cut the
888 * line.
889 */
890 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200891 if (str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100892 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100893 continue;
894 }
895
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200896 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100897 len--;
898
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200899 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200900 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200901
902 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200903 appctx->chunk->area[appctx->chunk->data] = '\n';
904 appctx->chunk->area[appctx->chunk->data + 1] = 0;
905 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200906 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100907
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100908 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200909
910 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
911 /* empty line */
912 if (!len) {
913 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200914 appctx->chunk->data -= 2;
915 appctx->chunk->area[appctx->chunk->data] = 0;
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100916 cli_parse_request(appctx);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200917 chunk_reset(appctx->chunk);
918 /* NB: cli_sock_parse_request() may have put
919 * another CLI_ST_O_* into appctx->st0.
920 */
921
922 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +0100923 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100924 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200925 else {
926 /*
927 * Look for the "payload start" pattern at the end of a line
928 * Its location is not remembered here, this is just to switch
929 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +0100930 */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100931 if (strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN) == 0)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200932 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200933 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200934 /* no payload, the command is complete: parse the request */
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100935 cli_parse_request(appctx);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200936 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200937 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100938 }
939
940 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200941 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100942 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
943 }
944 else { /* output functions */
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200945 const char *msg;
946 int sev;
947
William Lallemand74c24fb2016-11-21 17:18:36 +0100948 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100949 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100950 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200951 case CLI_ST_PRINT: /* print const message in msg */
952 case CLI_ST_PRINT_ERR: /* print const error in msg */
953 case CLI_ST_PRINT_DYN: /* print dyn message in msg, free */
954 case CLI_ST_PRINT_FREE: /* print dyn error in err, free */
955 if (appctx->st0 == CLI_ST_PRINT || appctx->st0 == CLI_ST_PRINT_ERR) {
956 sev = appctx->st0 == CLI_ST_PRINT_ERR ?
957 LOG_ERR : appctx->ctx.cli.severity;
958 msg = appctx->ctx.cli.msg;
959 }
960 else if (appctx->st0 == CLI_ST_PRINT_DYN || appctx->st0 == CLI_ST_PRINT_FREE) {
961 sev = appctx->st0 == CLI_ST_PRINT_FREE ?
962 LOG_ERR : appctx->ctx.cli.severity;
963 msg = appctx->ctx.cli.err;
964 if (!msg) {
965 sev = LOG_ERR;
966 msg = "Out of memory.\n";
967 }
968 }
969 else {
970 sev = LOG_ERR;
971 msg = "Internal error.\n";
972 }
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +0200973
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200974 if (cli_output_msg(res, msg, sev, cli_get_severity_output(appctx)) != -1) {
975 if (appctx->st0 == CLI_ST_PRINT_FREE ||
976 appctx->st0 == CLI_ST_PRINT_DYN) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100977 ha_free(&appctx->ctx.cli.err);
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200978 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100979 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100980 }
981 else
Willy Tarreaudb398432018-11-15 11:08:52 +0100982 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100983 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200984
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100985 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +0100986 if (appctx->io_handler)
987 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100988 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100989 if (appctx->io_release) {
990 appctx->io_release(appctx);
991 appctx->io_release = NULL;
992 }
993 }
994 break;
995 default: /* abnormal state */
996 si->flags |= SI_FL_ERR;
997 break;
998 }
999
1000 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001001 if (appctx->st0 == CLI_ST_PROMPT) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001002 const char *prompt = "";
1003
1004 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
1005 /*
1006 * when entering a payload with interactive mode, change the prompt
1007 * to emphasize that more data can still be sent
1008 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001009 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001010 prompt = "+ ";
1011 else
1012 prompt = "\n> ";
1013 }
1014 else {
William Lallemandad032882019-07-01 10:56:15 +02001015 if (!(appctx->st1 & (APPCTX_CLI_ST1_PAYLOAD|APPCTX_CLI_ST1_NOLF)))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001016 prompt = "\n";
1017 }
1018
1019 if (ci_putstr(si_ic(si), prompt) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001020 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +01001021 else
Willy Tarreaudb398432018-11-15 11:08:52 +01001022 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +01001023 }
1024
1025 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001026 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +01001027 break;
1028
1029 /* Now we close the output if one of the writers did so,
1030 * or if we're not in interactive mode and the request
1031 * buffer is empty. This still allows pipelined requests
1032 * to be sent in non-interactive mode.
1033 */
William Lallemand3de09d52018-12-11 16:10:56 +01001034 if (((res->flags & (CF_SHUTW|CF_SHUTW_NOW))) ||
1035 (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req) && (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)))) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001036 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +01001037 continue;
1038 }
1039
1040 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001041 appctx->st0 = CLI_ST_GETREQ;
William Lallemandad032882019-07-01 10:56:15 +02001042 /* reactivate the \n at the end of the response for the next command */
1043 appctx->st1 &= ~APPCTX_CLI_ST1_NOLF;
William Lallemand74c24fb2016-11-21 17:18:36 +01001044 }
1045 }
1046
1047 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
1048 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
1049 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
1050 /* Other side has closed, let's abort if we have no more processing to do
1051 * and nothing more to consume. This is comparable to a broken pipe, so
1052 * we forward the close to the request side so that it flows upstream to
1053 * the client.
1054 */
1055 si_shutw(si);
1056 }
1057
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001058 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +01001059 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
1060 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
1061 /* We have no more processing to do, and nothing more to send, and
1062 * the client side has closed. So we'll forward this state downstream
1063 * on the response buffer.
1064 */
1065 si_shutr(si);
1066 res->flags |= CF_READ_NULL;
1067 }
1068
1069 out:
Christopher Faulet45073512018-07-20 10:16:29 +02001070 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 +01001071 __FUNCTION__, __LINE__,
Christopher Faulet45073512018-07-20 10:16:29 +02001072 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 +01001073}
1074
William Lallemand74c24fb2016-11-21 17:18:36 +01001075/* This is called when the stream interface is closed. For instance, upon an
1076 * external abort, we won't call the i/o handler anymore so we may need to
1077 * remove back references to the stream currently being dumped.
1078 */
1079static void cli_release_handler(struct appctx *appctx)
1080{
1081 if (appctx->io_release) {
1082 appctx->io_release(appctx);
1083 appctx->io_release = NULL;
1084 }
Willy Tarreaud50c7fe2019-08-09 09:57:36 +02001085 else if (appctx->st0 == CLI_ST_PRINT_FREE || appctx->st0 == CLI_ST_PRINT_DYN) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01001086 ha_free(&appctx->ctx.cli.err);
William Lallemand74c24fb2016-11-21 17:18:36 +01001087 }
William Lallemand74c24fb2016-11-21 17:18:36 +01001088}
1089
1090/* This function dumps all environmnent variables to the buffer. It returns 0
1091 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +01001092 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
1093 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +01001094 */
Willy Tarreau0a739292016-11-22 20:21:23 +01001095static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +01001096{
Willy Tarreau0a739292016-11-22 20:21:23 +01001097 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001098 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +01001099
1100 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1101 return 1;
1102
1103 chunk_reset(&trash);
1104
1105 /* we have two inner loops here, one for the proxy, the other one for
1106 * the buffer.
1107 */
Willy Tarreauf6710f82016-12-16 17:45:44 +01001108 while (*var) {
1109 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +01001110
Willy Tarreau06d80a92017-10-19 14:32:15 +02001111 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001112 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +01001113 return 0;
1114 }
1115 if (appctx->st2 == STAT_ST_END)
1116 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001117 var++;
1118 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +01001119 }
1120
1121 /* dump complete */
1122 return 1;
1123}
1124
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001125/* This function dumps all file descriptors states (or the requested one) to
1126 * the buffer. It returns 0 if the output buffer is full and it needs to be
1127 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
1128 * It uses cli.i0 as the fd number to restart from.
1129 */
1130static int cli_io_handler_show_fd(struct appctx *appctx)
1131{
1132 struct stream_interface *si = appctx->owner;
1133 int fd = appctx->ctx.cli.i0;
Willy Tarreauca1b1572018-12-18 15:45:11 +01001134 int ret = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001135
1136 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
Willy Tarreauca1b1572018-12-18 15:45:11 +01001137 goto end;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001138
1139 chunk_reset(&trash);
1140
Willy Tarreauca1b1572018-12-18 15:45:11 +01001141 /* isolate the threads once per round. We're limited to a buffer worth
1142 * of output anyway, it cannot last very long.
1143 */
1144 thread_isolate();
1145
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001146 /* we have two inner loops here, one for the proxy, the other one for
1147 * the buffer.
1148 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +01001149 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001150 struct fdtab fdt;
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001151 const struct listener *li = NULL;
1152 const struct server *sv = NULL;
1153 const struct proxy *px = NULL;
1154 const struct connection *conn = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +02001155 const struct mux_ops *mux = NULL;
Willy Tarreau37be9532021-01-20 14:40:04 +01001156 const struct xprt_ops *xprt = NULL;
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001157 const void *ctx = NULL;
Willy Tarreau37be9532021-01-20 14:40:04 +01001158 const void *xprt_ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +02001159 uint32_t conn_flags = 0;
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001160 int is_back = 0;
Willy Tarreau8050efe2021-01-21 08:26:06 +01001161 int suspicious = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001162
1163 fdt = fdtab[fd];
1164
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001165 /* When DEBUG_FD is set, we also report closed FDs that have a
1166 * non-null event count to detect stuck ones.
1167 */
Willy Tarreau13c1a012020-06-29 14:23:31 +02001168 if (!fdt.owner) {
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001169#ifdef DEBUG_FD
Willy Tarreau13c1a012020-06-29 14:23:31 +02001170 if (!fdt.event_count)
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001171#endif
Willy Tarreau13c1a012020-06-29 14:23:31 +02001172 goto skip; // closed
1173 }
Willy Tarreau586f71b2020-12-11 15:54:36 +01001174 else if (fdt.iocb == sock_conn_iocb) {
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001175 conn = (const struct connection *)fdt.owner;
1176 conn_flags = conn->flags;
1177 mux = conn->mux;
1178 ctx = conn->ctx;
Willy Tarreau37be9532021-01-20 14:40:04 +01001179 xprt = conn->xprt;
1180 xprt_ctx = conn->xprt_ctx;
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001181 li = objt_listener(conn->target);
1182 sv = objt_server(conn->target);
1183 px = objt_proxy(conn->target);
1184 is_back = conn_is_back(conn);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001185 if (atleast2(fdt.thread_mask))
1186 suspicious = 1;
1187 if (conn->handle.fd != fd)
1188 suspicious = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001189 }
Willy Tarreaua74cb382020-10-15 21:29:49 +02001190 else if (fdt.iocb == sock_accept_iocb)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001191 li = fdt.owner;
1192
Willy Tarreaudacfde42021-01-21 09:07:29 +01001193 if (!fdt.thread_mask)
1194 suspicious = 1;
1195
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001196 chunk_printf(&trash,
Willy Tarreau184b2122021-04-07 08:48:12 +02001197 " %5d : st=0x%06x(%c%c %c%c%c%c%c W:%c%c%c R:%c%c%c) tmask=0x%lx umask=0x%lx owner=%p iocb=%p(",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001198 fd,
1199 fdt.state,
Willy Tarreau184b2122021-04-07 08:48:12 +02001200 (fdt.state & FD_CLONED) ? 'C' : 'c',
1201 (fdt.state & FD_LINGER_RISK) ? 'L' : 'l',
Willy Tarreauf5090652021-04-06 17:23:40 +02001202 (fdt.state & FD_POLL_HUP) ? 'H' : 'h',
1203 (fdt.state & FD_POLL_ERR) ? 'E' : 'e',
1204 (fdt.state & FD_POLL_OUT) ? 'O' : 'o',
1205 (fdt.state & FD_POLL_PRI) ? 'P' : 'p',
1206 (fdt.state & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau184b2122021-04-07 08:48:12 +02001207 (fdt.state & FD_EV_SHUT_W) ? 'S' : 's',
1208 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
1209 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
1210 (fdt.state & FD_EV_SHUT_R) ? 'S' : 's',
1211 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
1212 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
Willy Tarreauc754b342018-03-30 15:00:15 +02001213 fdt.thread_mask, fdt.update_mask,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001214 fdt.owner,
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001215 fdt.iocb);
1216 resolve_sym_name(&trash, NULL, fdt.iocb);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001217
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001218 if (!fdt.owner) {
1219 chunk_appendf(&trash, ")");
1220 }
Willy Tarreau586f71b2020-12-11 15:54:36 +01001221 else if (fdt.iocb == sock_conn_iocb) {
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001222 chunk_appendf(&trash, ") back=%d cflg=0x%08x", is_back, conn_flags);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001223
1224 if (conn->handle.fd != fd) {
1225 chunk_appendf(&trash, " fd=%d(BOGUS)", conn->handle.fd);
1226 suspicious = 1;
Willy Tarreaued989202021-02-05 10:54:52 +01001227 } else {
1228 struct sockaddr_storage sa;
1229 socklen_t salen;
1230
1231 salen = sizeof(sa);
1232 if (getsockname(fd, (struct sockaddr *)&sa, &salen) != -1) {
1233 if (sa.ss_family == AF_INET)
1234 chunk_appendf(&trash, " fam=ipv4 lport=%d", ntohs(((const struct sockaddr_in *)&sa)->sin_port));
1235 else if (sa.ss_family == AF_INET6)
1236 chunk_appendf(&trash, " fam=ipv6 lport=%d", ntohs(((const struct sockaddr_in6 *)&sa)->sin6_port));
1237 else if (sa.ss_family == AF_UNIX)
1238 chunk_appendf(&trash, " fam=unix");
1239 }
1240
1241 salen = sizeof(sa);
1242 if (getpeername(fd, (struct sockaddr *)&sa, &salen) != -1) {
1243 if (sa.ss_family == AF_INET)
1244 chunk_appendf(&trash, " rport=%d", ntohs(((const struct sockaddr_in *)&sa)->sin_port));
1245 else if (sa.ss_family == AF_INET6)
1246 chunk_appendf(&trash, " rport=%d", ntohs(((const struct sockaddr_in6 *)&sa)->sin6_port));
1247 }
Willy Tarreaudacfde42021-01-21 09:07:29 +01001248 }
1249
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001250 if (px)
1251 chunk_appendf(&trash, " px=%s", px->id);
1252 else if (sv)
1253 chunk_appendf(&trash, " sv=%s/%s", sv->id, sv->proxy->id);
1254 else if (li)
1255 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +02001256
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001257 if (mux) {
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001258 chunk_appendf(&trash, " mux=%s ctx=%p", mux->name, ctx);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001259 if (!ctx)
1260 suspicious = 1;
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001261 if (mux->show_fd)
Willy Tarreau8050efe2021-01-21 08:26:06 +01001262 suspicious |= mux->show_fd(&trash, fdt.owner);
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001263 }
Willy Tarreau35b1b482018-03-28 18:41:30 +02001264 else
1265 chunk_appendf(&trash, " nomux");
Willy Tarreau37be9532021-01-20 14:40:04 +01001266
1267 chunk_appendf(&trash, " xprt=%s", xprt ? xprt->name : "");
Willy Tarreau108a2712021-01-20 15:30:56 +01001268 if (xprt) {
1269 if (xprt_ctx || xprt->show_fd)
1270 chunk_appendf(&trash, " xprt_ctx=%p", xprt_ctx);
1271 if (xprt->show_fd)
Willy Tarreau8050efe2021-01-21 08:26:06 +01001272 suspicious |= xprt->show_fd(&trash, conn, xprt_ctx);
Willy Tarreau108a2712021-01-20 15:30:56 +01001273 }
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001274 }
Willy Tarreaua74cb382020-10-15 21:29:49 +02001275 else if (fdt.iocb == sock_accept_iocb) {
Willy Tarreaued989202021-02-05 10:54:52 +01001276 struct sockaddr_storage sa;
1277 socklen_t salen;
1278
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001279 chunk_appendf(&trash, ") l.st=%s fe=%s",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001280 listener_state_str(li),
1281 li->bind_conf->frontend->id);
Willy Tarreaued989202021-02-05 10:54:52 +01001282
1283 salen = sizeof(sa);
1284 if (getsockname(fd, (struct sockaddr *)&sa, &salen) != -1) {
1285 if (sa.ss_family == AF_INET)
1286 chunk_appendf(&trash, " fam=ipv4 lport=%d", ntohs(((const struct sockaddr_in *)&sa)->sin_port));
1287 else if (sa.ss_family == AF_INET6)
1288 chunk_appendf(&trash, " fam=ipv6 lport=%d", ntohs(((const struct sockaddr_in6 *)&sa)->sin6_port));
1289 else if (sa.ss_family == AF_UNIX)
1290 chunk_appendf(&trash, " fam=unix");
1291 }
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001292 }
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001293 else
1294 chunk_appendf(&trash, ")");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001295
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001296#ifdef DEBUG_FD
1297 chunk_appendf(&trash, " evcnt=%u", fdtab[fd].event_count);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001298 if (fdtab[fd].event_count >= 1000000)
1299 suspicious = 1;
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001300#endif
Willy Tarreau8050efe2021-01-21 08:26:06 +01001301 chunk_appendf(&trash, "%s\n", suspicious ? " !" : "");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001302
Willy Tarreau06d80a92017-10-19 14:32:15 +02001303 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001304 si_rx_room_blk(si);
Willy Tarreauca1b1572018-12-18 15:45:11 +01001305 appctx->ctx.cli.i0 = fd;
1306 ret = 0;
1307 break;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001308 }
1309 skip:
1310 if (appctx->st2 == STAT_ST_END)
1311 break;
1312
1313 fd++;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001314 }
1315
Willy Tarreauca1b1572018-12-18 15:45:11 +01001316 end:
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001317 /* dump complete */
Willy Tarreauca1b1572018-12-18 15:45:11 +01001318
1319 thread_release();
1320 return ret;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001321}
1322
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001323/* This function dumps some activity counters used by developers and support to
1324 * rule out some hypothesis during bug reports. It returns 0 if the output
1325 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
1326 * everything at once in the buffer and is not designed to do it in multiple
1327 * passes.
1328 */
1329static int cli_io_handler_show_activity(struct appctx *appctx)
1330{
1331 struct stream_interface *si = appctx->owner;
1332 int thr;
1333
1334 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1335 return 1;
1336
1337 chunk_reset(&trash);
1338
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001339#undef SHOW_TOT
1340#define SHOW_TOT(t, x) \
Willy Tarreaua0211b82019-05-28 15:09:08 +02001341 do { \
1342 unsigned int _v[MAX_THREADS]; \
1343 unsigned int _tot; \
1344 const unsigned int _nbt = global.nbthread; \
1345 for (_tot = t = 0; t < _nbt; t++) \
1346 _tot += _v[t] = (x); \
1347 if (_nbt == 1) { \
1348 chunk_appendf(&trash, " %u\n", _tot); \
1349 break; \
1350 } \
1351 chunk_appendf(&trash, " %u [", _tot); \
1352 for (t = 0; t < _nbt; t++) \
1353 chunk_appendf(&trash, " %u", _v[t]); \
1354 chunk_appendf(&trash, " ]\n"); \
1355 } while (0)
1356
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001357#undef SHOW_AVG
1358#define SHOW_AVG(t, x) \
1359 do { \
1360 unsigned int _v[MAX_THREADS]; \
1361 unsigned int _tot; \
1362 const unsigned int _nbt = global.nbthread; \
1363 for (_tot = t = 0; t < _nbt; t++) \
1364 _tot += _v[t] = (x); \
1365 if (_nbt == 1) { \
1366 chunk_appendf(&trash, " %u\n", _tot); \
1367 break; \
1368 } \
1369 chunk_appendf(&trash, " %u [", (_tot + _nbt/2) / _nbt); \
1370 for (t = 0; t < _nbt; t++) \
1371 chunk_appendf(&trash, " %u", _v[t]); \
1372 chunk_appendf(&trash, " ]\n"); \
1373 } while (0)
1374
Willy Tarreaua0211b82019-05-28 15:09:08 +02001375 chunk_appendf(&trash, "thread_id: %u (%u..%u)\n", tid + 1, 1, global.nbthread);
1376 chunk_appendf(&trash, "date_now: %lu.%06lu\n", (long)now.tv_sec, (long)now.tv_usec);
Willy Tarreaua00cf9b2020-06-17 20:44:28 +02001377 chunk_appendf(&trash, "ctxsw:"); SHOW_TOT(thr, activity[thr].ctxsw);
1378 chunk_appendf(&trash, "tasksw:"); SHOW_TOT(thr, activity[thr].tasksw);
1379 chunk_appendf(&trash, "empty_rq:"); SHOW_TOT(thr, activity[thr].empty_rq);
1380 chunk_appendf(&trash, "long_rq:"); SHOW_TOT(thr, activity[thr].long_rq);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001381 chunk_appendf(&trash, "loops:"); SHOW_TOT(thr, activity[thr].loops);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001382 chunk_appendf(&trash, "wake_tasks:"); SHOW_TOT(thr, activity[thr].wake_tasks);
1383 chunk_appendf(&trash, "wake_signal:"); SHOW_TOT(thr, activity[thr].wake_signal);
Willy Tarreaue5451532020-06-17 20:25:18 +02001384 chunk_appendf(&trash, "poll_io:"); SHOW_TOT(thr, activity[thr].poll_io);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001385 chunk_appendf(&trash, "poll_exp:"); SHOW_TOT(thr, activity[thr].poll_exp);
Willy Tarreaue4063862020-06-17 20:35:33 +02001386 chunk_appendf(&trash, "poll_drop_fd:"); SHOW_TOT(thr, activity[thr].poll_drop_fd);
1387 chunk_appendf(&trash, "poll_dead_fd:"); SHOW_TOT(thr, activity[thr].poll_dead_fd);
1388 chunk_appendf(&trash, "poll_skip_fd:"); SHOW_TOT(thr, activity[thr].poll_skip_fd);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001389 chunk_appendf(&trash, "conn_dead:"); SHOW_TOT(thr, activity[thr].conn_dead);
Willy Tarreau7af4fa92020-06-17 20:49:49 +02001390 chunk_appendf(&trash, "stream_calls:"); SHOW_TOT(thr, activity[thr].stream_calls);
Willy Tarreaua8b2ce02019-05-28 17:04:16 +02001391 chunk_appendf(&trash, "pool_fail:"); SHOW_TOT(thr, activity[thr].pool_fail);
1392 chunk_appendf(&trash, "buf_wait:"); SHOW_TOT(thr, activity[thr].buf_wait);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001393 chunk_appendf(&trash, "cpust_ms_tot:"); SHOW_TOT(thr, activity[thr].cpust_total / 2);
1394 chunk_appendf(&trash, "cpust_ms_1s:"); SHOW_TOT(thr, read_freq_ctr(&activity[thr].cpust_1s) / 2);
1395 chunk_appendf(&trash, "cpust_ms_15s:"); SHOW_TOT(thr, read_freq_ctr_period(&activity[thr].cpust_15s, 15000) / 2);
1396 chunk_appendf(&trash, "avg_loop_us:"); SHOW_AVG(thr, swrate_avg(activity[thr].avg_loop_us, TIME_STATS_SAMPLES));
1397 chunk_appendf(&trash, "accepted:"); SHOW_TOT(thr, activity[thr].accepted);
1398 chunk_appendf(&trash, "accq_pushed:"); SHOW_TOT(thr, activity[thr].accq_pushed);
1399 chunk_appendf(&trash, "accq_full:"); SHOW_TOT(thr, activity[thr].accq_full);
Willy Tarreaue6182842019-04-15 18:54:10 +02001400#ifdef USE_THREAD
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001401 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 +02001402 chunk_appendf(&trash, "fd_takeover:"); SHOW_TOT(thr, activity[thr].fd_takeover);
Willy Tarreaue6182842019-04-15 18:54:10 +02001403#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001404
Willy Tarreaud6a78502019-05-27 07:03:38 +02001405#if defined(DEBUG_DEV)
1406 /* keep these ones at the end */
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001407 chunk_appendf(&trash, "ctr0:"); SHOW_TOT(thr, activity[thr].ctr0);
1408 chunk_appendf(&trash, "ctr1:"); SHOW_TOT(thr, activity[thr].ctr1);
1409 chunk_appendf(&trash, "ctr2:"); SHOW_TOT(thr, activity[thr].ctr2);
Willy Tarreaud6a78502019-05-27 07:03:38 +02001410#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001411
1412 if (ci_putchk(si_ic(si), &trash) == -1) {
1413 chunk_reset(&trash);
1414 chunk_printf(&trash, "[output too large, cannot dump]\n");
Willy Tarreaudb398432018-11-15 11:08:52 +01001415 si_rx_room_blk(si);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001416 }
1417
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001418#undef SHOW_AVG
1419#undef SHOW_TOT
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001420 /* dump complete */
1421 return 1;
1422}
1423
William Lallemandeceddf72016-12-15 18:06:44 +01001424/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001425 * CLI IO handler for `show cli sockets`.
1426 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +01001427 */
1428static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1429{
1430 struct bind_conf *bind_conf;
1431 struct stream_interface *si = appctx->owner;
1432
1433 chunk_reset(&trash);
1434
1435 switch (appctx->st2) {
1436 case STAT_ST_INIT:
1437 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +02001438 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001439 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001440 return 0;
1441 }
William Lallemandeceddf72016-12-15 18:06:44 +01001442 appctx->st2 = STAT_ST_LIST;
Tim Duesterhus588b3142020-05-29 14:35:51 +02001443 /* fall through */
William Lallemandeceddf72016-12-15 18:06:44 +01001444
1445 case STAT_ST_LIST:
Willy Tarreau4975d142021-03-13 11:00:33 +01001446 if (global.cli_fe) {
1447 list_for_each_entry(bind_conf, &global.cli_fe->conf.bind, by_fe) {
William Lallemandeceddf72016-12-15 18:06:44 +01001448 struct listener *l;
1449
1450 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001451 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +01001452 * if the current node is the first of the list
1453 */
1454
Willy Tarreau3af9d832016-12-16 12:58:09 +01001455 if (appctx->ctx.cli.p0 &&
Willy Tarreau4975d142021-03-13 11:00:33 +01001456 &bind_conf->by_fe == (&global.cli_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +01001457 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +01001458 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +01001459 continue;
1460 }
1461
1462 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
1463
1464 char addr[46];
1465 char port[6];
1466
Willy Tarreau37159062020-08-27 07:48:42 +02001467 if (l->rx.addr.ss_family == AF_UNIX) {
William Lallemandeceddf72016-12-15 18:06:44 +01001468 const struct sockaddr_un *un;
1469
Willy Tarreau37159062020-08-27 07:48:42 +02001470 un = (struct sockaddr_un *)&l->rx.addr;
William Lallemande58915f2019-04-01 11:30:05 +02001471 if (un->sun_path[0] == '\0') {
William Lallemand75812a72019-04-01 11:30:04 +02001472 chunk_appendf(&trash, "abns@%s ", un->sun_path+1);
William Lallemande58915f2019-04-01 11:30:05 +02001473 } else {
1474 chunk_appendf(&trash, "unix@%s ", un->sun_path);
1475 }
Willy Tarreau37159062020-08-27 07:48:42 +02001476 } else if (l->rx.addr.ss_family == AF_INET) {
1477 addr_to_str(&l->rx.addr, addr, sizeof(addr));
1478 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001479 chunk_appendf(&trash, "ipv4@%s:%s ", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +02001480 } else if (l->rx.addr.ss_family == AF_INET6) {
1481 addr_to_str(&l->rx.addr, addr, sizeof(addr));
1482 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001483 chunk_appendf(&trash, "ipv6@[%s]:%s ", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +02001484 } else if (l->rx.addr.ss_family == AF_CUST_SOCKPAIR) {
1485 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->rx.addr)->sin_addr.s_addr);
William Lallemandeceddf72016-12-15 18:06:44 +01001486 } else
William Lallemand26314342018-10-26 14:47:41 +02001487 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001488
William Lallemand07a62f72017-05-24 00:57:40 +02001489 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +01001490 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +02001491 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1492 chunk_appendf(&trash, "operator ");
1493 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1494 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +01001495 else
1496 chunk_appendf(&trash, " ");
1497
Willy Tarreaue26993c2020-09-03 07:18:55 +02001498 if (bind_conf->settings.bind_proc != 0) {
William Lallemandeceddf72016-12-15 18:06:44 +01001499 int pos;
Willy Tarreaue26993c2020-09-03 07:18:55 +02001500 for (pos = 0; pos < 8 * sizeof(bind_conf->settings.bind_proc); pos++) {
1501 if (bind_conf->settings.bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +01001502 chunk_appendf(&trash, "%d,", pos+1);
1503 }
1504 }
1505 /* replace the latest comma by a newline */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001506 trash.area[trash.data-1] = '\n';
William Lallemandeceddf72016-12-15 18:06:44 +01001507
1508 } else {
1509 chunk_appendf(&trash, "all\n");
1510 }
1511
Willy Tarreau06d80a92017-10-19 14:32:15 +02001512 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001513 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001514 return 0;
1515 }
1516 }
Willy Tarreau3af9d832016-12-16 12:58:09 +01001517 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001518 }
1519 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02001520 /* fall through */
William Lallemandeceddf72016-12-15 18:06:44 +01001521 default:
1522 appctx->st2 = STAT_ST_FIN;
1523 return 1;
1524 }
1525}
1526
1527
Willy Tarreau0a739292016-11-22 20:21:23 +01001528/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001529 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1530 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001531 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001532static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001533{
1534 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001535 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001536
1537 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1538 return 1;
1539
Willy Tarreauf6710f82016-12-16 17:45:44 +01001540 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001541
1542 if (*args[2]) {
1543 int len = strlen(args[2]);
1544
Willy Tarreauf6710f82016-12-16 17:45:44 +01001545 for (; *var; var++) {
1546 if (strncmp(*var, args[2], len) == 0 &&
1547 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001548 break;
1549 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001550 if (!*var)
1551 return cli_err(appctx, "Variable not found\n");
1552
Willy Tarreau0a739292016-11-22 20:21:23 +01001553 appctx->st2 = STAT_ST_END;
1554 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001555 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001556 return 0;
1557}
1558
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001559/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1560 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1561 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1562 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001563static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001564{
1565 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1566 return 1;
1567
1568 appctx->ctx.cli.i0 = 0;
1569
1570 if (*args[2]) {
1571 appctx->ctx.cli.i0 = atoi(args[2]);
1572 appctx->st2 = STAT_ST_END;
1573 }
1574 return 0;
1575}
1576
Willy Tarreau599852e2016-11-22 20:33:32 +01001577/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001578static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001579{
1580 struct stream_interface *si = appctx->owner;
1581 struct stream *s = si_strm(si);
1582
1583 if (strcmp(args[2], "cli") == 0) {
1584 unsigned timeout;
1585 const char *res;
1586
Willy Tarreau9d008692019-08-09 11:21:01 +02001587 if (!*args[3])
1588 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001589
1590 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
Willy Tarreau9d008692019-08-09 11:21:01 +02001591 if (res || timeout < 1)
1592 return cli_err(appctx, "Invalid timeout value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001593
1594 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1595 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1596 return 1;
1597 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001598
1599 return cli_err(appctx, "'set timeout' only supports 'cli'.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001600}
1601
Willy Tarreau2af99412016-11-23 11:10:59 +01001602/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001603static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001604{
1605 int v;
1606
1607 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1608 return 1;
1609
Willy Tarreau9d008692019-08-09 11:21:01 +02001610 if (!*args[3])
1611 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001612
1613 v = atoi(args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001614 if (v > global.hardmaxconn)
1615 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001616
1617 /* check for unlimited values */
1618 if (v <= 0)
1619 v = global.hardmaxconn;
1620
1621 global.maxconn = v;
1622
1623 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001624 dequeue_all_listeners();
Willy Tarreau2af99412016-11-23 11:10:59 +01001625
1626 return 1;
1627}
1628
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001629static int set_severity_output(int *target, char *argument)
1630{
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001631 if (strcmp(argument, "none") == 0) {
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001632 *target = CLI_SEVERITY_NONE;
1633 return 1;
1634 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001635 else if (strcmp(argument, "number") == 0) {
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001636 *target = CLI_SEVERITY_NUMBER;
1637 return 1;
1638 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001639 else if (strcmp(argument, "string") == 0) {
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001640 *target = CLI_SEVERITY_STRING;
1641 return 1;
1642 }
1643 return 0;
1644}
1645
1646/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001647static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001648{
1649 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1650 return 0;
1651
Willy Tarreau9d008692019-08-09 11:21:01 +02001652 return cli_err(appctx, "one of 'none', 'number', 'string' is a required argument\n");
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001653}
William Lallemandeceddf72016-12-15 18:06:44 +01001654
William Lallemand67a234f2018-12-13 09:05:45 +01001655
1656/* show the level of the current CLI session */
1657static int cli_parse_show_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1658{
William Lallemand67a234f2018-12-13 09:05:45 +01001659 if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
Willy Tarreau9d008692019-08-09 11:21:01 +02001660 return cli_msg(appctx, LOG_INFO, "admin\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001661 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001662 return cli_msg(appctx, LOG_INFO, "operator\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001663 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001664 return cli_msg(appctx, LOG_INFO, "user\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001665 else
Willy Tarreau9d008692019-08-09 11:21:01 +02001666 return cli_msg(appctx, LOG_INFO, "unknown\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001667}
1668
1669/* parse and set the CLI level dynamically */
1670static int cli_parse_set_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1671{
William Lallemandad032882019-07-01 10:56:15 +02001672 /* this will ask the applet to not output a \n after the command */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001673 if (strcmp(args[1], "-") == 0)
William Lallemandad032882019-07-01 10:56:15 +02001674 appctx->st1 |= APPCTX_CLI_ST1_NOLF;
1675
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001676 if (strcmp(args[0], "operator") == 0) {
William Lallemand67a234f2018-12-13 09:05:45 +01001677 if (!cli_has_level(appctx, ACCESS_LVL_OPER)) {
1678 return 1;
1679 }
1680 appctx->cli_level &= ~ACCESS_LVL_MASK;
1681 appctx->cli_level |= ACCESS_LVL_OPER;
1682
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001683 } else if (strcmp(args[0], "user") == 0) {
William Lallemand67a234f2018-12-13 09:05:45 +01001684 if (!cli_has_level(appctx, ACCESS_LVL_USER)) {
1685 return 1;
1686 }
1687 appctx->cli_level &= ~ACCESS_LVL_MASK;
1688 appctx->cli_level |= ACCESS_LVL_USER;
1689 }
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001690 appctx->cli_level &= ~(ACCESS_EXPERT|ACCESS_EXPERIMENTAL);
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001691 return 1;
1692}
1693
1694
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001695/* parse and set the CLI expert/experimental-mode dynamically */
1696static int cli_parse_expert_experimental_mode(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001697{
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001698 int level;
1699 char *level_str;
1700 char *output = NULL;
1701
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001702 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1703 return 1;
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001704
1705 if (!strcmp(args[0], "expert-mode")) {
1706 level = ACCESS_EXPERT;
1707 level_str = "expert-mode";
1708 }
1709 else if (!strcmp(args[0], "experimental-mode")) {
1710 level = ACCESS_EXPERIMENTAL;
1711 level_str = "experimental-mode";
1712 }
1713 else {
1714 return 1;
1715 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001716
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001717 if (!*args[1]) {
1718 memprintf(&output, "%s is %s\n", level_str,
1719 (appctx->cli_level & level) ? "ON" : "OFF");
1720 return cli_dynmsg(appctx, LOG_INFO, output);
1721 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001722
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001723 appctx->cli_level &= ~level;
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001724 if (strcmp(args[1], "on") == 0)
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001725 appctx->cli_level |= level;
William Lallemand67a234f2018-12-13 09:05:45 +01001726 return 1;
1727}
1728
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001729int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001730{
1731 return 0;
1732}
1733
Willy Tarreau45c742b2016-11-24 14:51:17 +01001734/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001735static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001736{
1737 int v;
1738 int *res;
1739 int mul = 1;
1740
1741 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1742 return 1;
1743
1744 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1745 res = &global.cps_lim;
1746 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1747 res = &global.sps_lim;
1748#ifdef USE_OPENSSL
1749 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1750 res = &global.ssl_lim;
1751#endif
1752 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1753 res = &global.comp_rate_lim;
1754 mul = 1024;
1755 }
1756 else {
Willy Tarreau9d008692019-08-09 11:21:01 +02001757 return cli_err(appctx,
Willy Tarreau45c742b2016-11-24 14:51:17 +01001758 "'set rate-limit' only supports :\n"
1759 " - 'connections global' to set the per-process maximum connection rate\n"
1760 " - 'sessions global' to set the per-process maximum session rate\n"
1761#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001762 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001763#endif
Willy Tarreau9d008692019-08-09 11:21:01 +02001764 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001765 }
1766
Willy Tarreau9d008692019-08-09 11:21:01 +02001767 if (!*args[4])
1768 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001769
1770 v = atoi(args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001771 if (v < 0)
1772 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001773
1774 *res = v * mul;
1775
1776 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001777 dequeue_all_listeners();
Willy Tarreau45c742b2016-11-24 14:51:17 +01001778
1779 return 1;
1780}
1781
William Lallemandf6975e92017-05-26 17:42:10 +02001782/* parse the "expose-fd" argument on the bind lines */
1783static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1784{
1785 if (!*args[cur_arg + 1]) {
1786 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1787 return ERR_ALERT | ERR_FATAL;
1788 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001789 if (strcmp(args[cur_arg + 1], "listeners") == 0) {
William Lallemandf6975e92017-05-26 17:42:10 +02001790 conf->level |= ACCESS_FD_LISTENERS;
1791 } else {
1792 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1793 args[cur_arg], args[cur_arg+1]);
1794 return ERR_ALERT | ERR_FATAL;
1795 }
1796
1797 return 0;
1798}
1799
William Lallemand74c24fb2016-11-21 17:18:36 +01001800/* parse the "level" argument on the bind lines */
1801static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1802{
1803 if (!*args[cur_arg + 1]) {
1804 memprintf(err, "'%s' : missing level", args[cur_arg]);
1805 return ERR_ALERT | ERR_FATAL;
1806 }
1807
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001808 if (strcmp(args[cur_arg + 1], "user") == 0) {
William Lallemand07a62f72017-05-24 00:57:40 +02001809 conf->level &= ~ACCESS_LVL_MASK;
1810 conf->level |= ACCESS_LVL_USER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001811 } else if (strcmp(args[cur_arg + 1], "operator") == 0) {
William Lallemand07a62f72017-05-24 00:57:40 +02001812 conf->level &= ~ACCESS_LVL_MASK;
1813 conf->level |= ACCESS_LVL_OPER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001814 } else if (strcmp(args[cur_arg + 1], "admin") == 0) {
William Lallemand07a62f72017-05-24 00:57:40 +02001815 conf->level &= ~ACCESS_LVL_MASK;
1816 conf->level |= ACCESS_LVL_ADMIN;
1817 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001818 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1819 args[cur_arg], args[cur_arg+1]);
1820 return ERR_ALERT | ERR_FATAL;
1821 }
1822
1823 return 0;
1824}
1825
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001826static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1827{
1828 if (!*args[cur_arg + 1]) {
1829 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1830 return ERR_ALERT | ERR_FATAL;
1831 }
1832
1833 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1834 return 0;
1835 else {
1836 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1837 args[cur_arg], args[cur_arg+1]);
1838 return ERR_ALERT | ERR_FATAL;
1839 }
1840}
1841
Olivier Houchardf886e342017-04-05 22:24:59 +02001842/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001843static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02001844{
1845 char *cmsgbuf = NULL;
1846 unsigned char *tmpbuf = NULL;
1847 struct cmsghdr *cmsg;
1848 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001849 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001850 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001851 struct msghdr msghdr;
1852 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001853 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001854 const char *ns_name, *if_name;
1855 unsigned char ns_nlen, if_nlen;
1856 int nb_queued;
1857 int cur_fd = 0;
Olivier Houchardf886e342017-04-05 22:24:59 +02001858 int *tmpfd;
1859 int tot_fd_nb = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001860 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001861 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001862 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001863 int ret;
1864
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001865 if (!remote) {
1866 ha_warning("Only works on real connections\n");
1867 goto out;
1868 }
1869
1870 fd = remote->handle.fd;
1871
Olivier Houchardf886e342017-04-05 22:24:59 +02001872 /* Temporary set the FD in blocking mode, that will make our life easier */
1873 old_fcntl = fcntl(fd, F_GETFL);
1874 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001875 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001876 goto out;
1877 }
1878 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1879 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001880 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001881 goto out;
1882 }
1883 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001884 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001885 goto out;
1886 }
Olivier Houchard54740872017-04-06 14:45:14 +02001887 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001888 iov.iov_base = &tot_fd_nb;
1889 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001890 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001891 goto out;
1892 memset(&msghdr, 0, sizeof(msghdr));
1893 /*
1894 * First, calculates the total number of FD, so that we can let
Jackie Tapia749f74c2020-07-22 18:59:40 -05001895 * the caller know how much it should expect.
Olivier Houchardf886e342017-04-05 22:24:59 +02001896 */
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001897 for (cur_fd = 0;cur_fd < global.maxsock; cur_fd++)
Willy Tarreau9063a662021-04-06 18:09:06 +02001898 tot_fd_nb += !!(fdtab[cur_fd].state & FD_EXPORTED);
William Lallemand5fd3b282020-01-16 15:32:08 +01001899
Olivier Houchardf886e342017-04-05 22:24:59 +02001900 if (tot_fd_nb == 0)
1901 goto out;
1902
1903 /* First send the total number of file descriptors, so that the
1904 * receiving end knows what to expect.
1905 */
1906 msghdr.msg_iov = &iov;
1907 msghdr.msg_iovlen = 1;
1908 ret = sendmsg(fd, &msghdr, 0);
1909 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001910 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001911 goto out;
1912 }
1913
1914 /* Now send the fds */
1915 msghdr.msg_control = cmsgbuf;
1916 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1917 cmsg = CMSG_FIRSTHDR(&msghdr);
1918 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1919 cmsg->cmsg_level = SOL_SOCKET;
1920 cmsg->cmsg_type = SCM_RIGHTS;
1921 tmpfd = (int *)CMSG_DATA(cmsg);
1922
Olivier Houchardf886e342017-04-05 22:24:59 +02001923 /* For each socket, e message is sent, containing the following :
1924 * Size of the namespace name (or 0 if none), as an unsigned char.
1925 * The namespace name, if any
1926 * Size of the interface name (or 0 if none), as an unsigned char
1927 * The interface name, if any
Willy Tarreaucf1f1932020-08-26 10:30:09 +02001928 * 32 bits of zeroes (used to be listener options).
Olivier Houchardf886e342017-04-05 22:24:59 +02001929 */
1930 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
Ilya Shipitsind4259502020-04-08 01:07:56 +05001931 * buffer big enough to store the socket information.
Olivier Houchardf886e342017-04-05 22:24:59 +02001932 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001933 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001934 if (tmpbuf == NULL) {
Ilya Shipitsind4259502020-04-08 01:07:56 +05001935 ha_warning("Failed to allocate memory to transfer socket information\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001936 goto out;
1937 }
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001938
1939 nb_queued = 0;
Olivier Houchardf886e342017-04-05 22:24:59 +02001940 iov.iov_base = tmpbuf;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001941 for (cur_fd = 0; cur_fd < global.maxsock; cur_fd++) {
Willy Tarreau9063a662021-04-06 18:09:06 +02001942 if (!(fdtab[cur_fd].state & FD_EXPORTED))
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001943 continue;
1944
1945 ns_name = if_name = "";
1946 ns_nlen = if_nlen = 0;
1947
1948 /* for now we can only retrieve namespaces and interfaces from
1949 * pure listeners.
1950 */
Willy Tarreaua74cb382020-10-15 21:29:49 +02001951 if (fdtab[cur_fd].iocb == sock_accept_iocb) {
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001952 const struct listener *l = fdtab[cur_fd].owner;
1953
Willy Tarreau818a92e2020-09-03 07:50:19 +02001954 if (l->rx.settings->interface) {
1955 if_name = l->rx.settings->interface;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001956 if_nlen = strlen(if_name);
1957 }
1958
1959#ifdef USE_NS
Willy Tarreau818a92e2020-09-03 07:50:19 +02001960 if (l->rx.settings->netns) {
1961 ns_name = l->rx.settings->netns->node.key;
1962 ns_nlen = l->rx.settings->netns->name_len;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001963 }
1964#endif
1965 }
1966
1967 /* put the FD into the CMSG_DATA */
1968 tmpfd[nb_queued++] = cur_fd;
1969
1970 /* first block is <ns_name_len> <ns_name> */
1971 tmpbuf[curoff++] = ns_nlen;
1972 if (ns_nlen)
1973 memcpy(tmpbuf + curoff, ns_name, ns_nlen);
1974 curoff += ns_nlen;
1975
1976 /* second block is <if_name_len> <if_name> */
1977 tmpbuf[curoff++] = if_nlen;
1978 if (if_nlen)
1979 memcpy(tmpbuf + curoff, if_name, if_nlen);
1980 curoff += if_nlen;
1981
1982 /* we used to send the listener options here before 2.3 */
1983 memset(tmpbuf + curoff, 0, sizeof(int));
1984 curoff += sizeof(int);
1985
1986 /* there's a limit to how many FDs may be sent at once */
1987 if (nb_queued == MAX_SEND_FD) {
1988 iov.iov_len = curoff;
1989 if (sendmsg(fd, &msghdr, 0) != curoff) {
1990 ha_warning("Failed to transfer sockets\n");
1991 return -1;
1992 }
1993
1994 /* Wait for an ack */
1995 do {
1996 ret = recv(fd, &tot_fd_nb, sizeof(tot_fd_nb), 0);
1997 } while (ret == -1 && errno == EINTR);
1998
1999 if (ret <= 0) {
2000 ha_warning("Unexpected error while transferring sockets\n");
2001 return -1;
2002 }
2003 curoff = 0;
2004 nb_queued = 0;
2005 }
William Lallemand5fd3b282020-01-16 15:32:08 +01002006 }
2007
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002008 /* flush pending stuff */
2009 if (nb_queued) {
Olivier Houchardf886e342017-04-05 22:24:59 +02002010 iov.iov_len = curoff;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002011 cmsg->cmsg_len = CMSG_LEN(nb_queued * sizeof(int));
2012 msghdr.msg_controllen = CMSG_SPACE(nb_queued * sizeof(int));
Olivier Houchardf886e342017-04-05 22:24:59 +02002013 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002014 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02002015 goto out;
2016 }
2017 }
2018
2019out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02002020 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002021 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02002022 goto out;
2023 }
2024 appctx->st0 = CLI_ST_END;
2025 free(cmsgbuf);
2026 free(tmpbuf);
2027 return 1;
2028}
2029
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002030static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
2031{
2032 if (*args[0] == 'h')
2033 /* help */
Willy Tarreaub96a74c2021-03-12 17:13:28 +01002034 cli_gen_usage_msg(appctx, NULL);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002035 else if (*args[0] == 'p')
2036 /* prompt */
2037 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
2038 else if (*args[0] == 'q')
2039 /* quit */
2040 appctx->st0 = CLI_ST_END;
2041
2042 return 1;
2043}
Olivier Houchardf886e342017-04-05 22:24:59 +02002044
William Lallemand2f4ce202018-10-26 14:47:47 +02002045void pcli_write_prompt(struct stream *s)
2046{
2047 struct buffer *msg = get_trash_chunk();
2048 struct channel *oc = si_oc(&s->si[0]);
2049
William Lallemanddc12c2e2018-12-13 09:05:46 +01002050 if (!(s->pcli_flags & PCLI_F_PROMPT))
William Lallemand5b80fa22018-12-11 16:10:54 +01002051 return;
2052
William Lallemanddc12c2e2018-12-13 09:05:46 +01002053 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002054 chunk_appendf(msg, "+ ");
2055 } else {
2056 if (s->pcli_next_pid == 0)
Willy Tarreau52880f92018-12-15 13:30:03 +01002057 chunk_appendf(msg, "master%s> ",
2058 (global.mode & MODE_MWORKER_WAIT) ? "[ReloadFailed]" : "");
William Lallemandebf61802018-12-11 16:10:57 +01002059 else
2060 chunk_appendf(msg, "%d> ", s->pcli_next_pid);
2061 }
William Lallemand2f4ce202018-10-26 14:47:47 +02002062 co_inject(oc, msg->area, msg->data);
2063}
2064
William Lallemand291810d2018-10-26 14:47:38 +02002065
William Lallemandcf62f7e2018-10-26 14:47:40 +02002066/* The pcli_* functions are used for the CLI proxy in the master */
2067
William Lallemanddeeaa592018-10-26 14:47:48 +02002068void pcli_reply_and_close(struct stream *s, const char *msg)
2069{
2070 struct buffer *buf = get_trash_chunk();
2071
2072 chunk_initstr(buf, msg);
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01002073 si_retnclose(&s->si[0], buf);
William Lallemanddeeaa592018-10-26 14:47:48 +02002074}
2075
William Lallemand291810d2018-10-26 14:47:38 +02002076static enum obj_type *pcli_pid_to_server(int proc_pid)
2077{
2078 struct mworker_proc *child;
2079
William Lallemand99e0bb92020-11-05 10:28:53 +01002080 /* return the mCLI applet of the master */
William Lallemandbddd33a2018-12-11 16:10:53 +01002081 if (proc_pid == 0)
William Lallemand99e0bb92020-11-05 10:28:53 +01002082 return &mcli_applet.obj_type;
William Lallemandbddd33a2018-12-11 16:10:53 +01002083
William Lallemand291810d2018-10-26 14:47:38 +02002084 list_for_each_entry(child, &proc_list, list) {
2085 if (child->pid == proc_pid){
2086 return &child->srv->obj_type;
2087 }
2088 }
2089 return NULL;
2090}
2091
2092/* Take a CLI prefix in argument (eg: @!1234 @master @1)
2093 * Return:
2094 * 0: master
2095 * > 0: pid of a worker
2096 * < 0: didn't find a worker
2097 */
2098static int pcli_prefix_to_pid(const char *prefix)
2099{
2100 int proc_pid;
2101 struct mworker_proc *child;
2102 char *errtol = NULL;
2103
2104 if (*prefix != '@') /* not a prefix, should not happen */
2105 return -1;
2106
2107 prefix++;
2108 if (!*prefix) /* sent @ alone, return the master */
2109 return 0;
2110
2111 if (strcmp("master", prefix) == 0) {
2112 return 0;
2113 } else if (*prefix == '!') {
2114 prefix++;
2115 if (!*prefix)
2116 return -1;
2117
2118 proc_pid = strtol(prefix, &errtol, 10);
2119 if (*errtol != '\0')
2120 return -1;
2121 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02002122 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01002123 continue;
William Lallemand291810d2018-10-26 14:47:38 +02002124 if (child->pid == proc_pid){
2125 return child->pid;
2126 }
2127 }
2128 } else {
2129 struct mworker_proc *chosen = NULL;
2130 /* this is a relative pid */
2131
2132 proc_pid = strtol(prefix, &errtol, 10);
2133 if (*errtol != '\0')
2134 return -1;
2135
2136 if (proc_pid == 0) /* return the master */
2137 return 0;
2138
2139 /* chose the right process, the current one is the one with the
2140 least number of reloads */
2141 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02002142 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01002143 continue;
William Lallemand291810d2018-10-26 14:47:38 +02002144 if (child->relative_pid == proc_pid){
2145 if (child->reloads == 0)
2146 return child->pid;
2147 else if (chosen == NULL || child->reloads < chosen->reloads)
2148 chosen = child;
2149 }
2150 }
2151 if (chosen)
2152 return chosen->pid;
2153 }
2154 return -1;
2155}
2156
William Lallemandbddd33a2018-12-11 16:10:53 +01002157/* Return::
2158 * >= 0 : number of words to escape
2159 * = -1 : error
2160 */
2161
2162int pcli_find_and_exec_kw(struct stream *s, char **args, int argl, char **errmsg, int *next_pid)
2163{
2164 if (argl < 1)
2165 return 0;
2166
2167 /* there is a prefix */
2168 if (args[0][0] == '@') {
2169 int target_pid = pcli_prefix_to_pid(args[0]);
2170
2171 if (target_pid == -1) {
2172 memprintf(errmsg, "Can't find the target PID matching the prefix '%s'\n", args[0]);
2173 return -1;
2174 }
2175
2176 /* if the prefix is alone, define a default target */
2177 if (argl == 1)
2178 s->pcli_next_pid = target_pid;
2179 else
2180 *next_pid = target_pid;
2181 return 1;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002182 } else if (strcmp("prompt", args[0]) == 0) {
William Lallemanddc12c2e2018-12-13 09:05:46 +01002183 s->pcli_flags ^= PCLI_F_PROMPT;
William Lallemand5b80fa22018-12-11 16:10:54 +01002184 return argl; /* return the number of elements in the array */
William Lallemand5f610682018-12-11 16:10:55 +01002185
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002186 } else if (strcmp("quit", args[0]) == 0) {
William Lallemand5f610682018-12-11 16:10:55 +01002187 channel_shutr_now(&s->req);
2188 channel_shutw_now(&s->res);
2189 return argl; /* return the number of elements in the array */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002190 } else if (strcmp(args[0], "operator") == 0) {
William Lallemandb7ea1412018-12-13 09:05:47 +01002191 if (!pcli_has_level(s, ACCESS_LVL_OPER)) {
2192 memprintf(errmsg, "Permission denied!\n");
2193 return -1;
2194 }
2195 s->pcli_flags &= ~ACCESS_LVL_MASK;
2196 s->pcli_flags |= ACCESS_LVL_OPER;
2197 return argl;
2198
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002199 } else if (strcmp(args[0], "user") == 0) {
William Lallemandb7ea1412018-12-13 09:05:47 +01002200 if (!pcli_has_level(s, ACCESS_LVL_USER)) {
2201 memprintf(errmsg, "Permission denied!\n");
2202 return -1;
2203 }
2204 s->pcli_flags &= ~ACCESS_LVL_MASK;
2205 s->pcli_flags |= ACCESS_LVL_USER;
2206 return argl;
William Lallemandbddd33a2018-12-11 16:10:53 +01002207 }
2208
2209 return 0;
2210}
2211
2212/*
2213 * Parse the CLI request:
2214 * - It does basically the same as the cli_io_handler, but as a proxy
2215 * - It can exec a command and strip non forwardable commands
William Lallemandcf62f7e2018-10-26 14:47:40 +02002216 *
2217 * Return:
William Lallemandbddd33a2018-12-11 16:10:53 +01002218 * - the number of characters to forward or
2219 * - 1 if there is an error or not enough data
William Lallemandcf62f7e2018-10-26 14:47:40 +02002220 */
William Lallemandbddd33a2018-12-11 16:10:53 +01002221int pcli_parse_request(struct stream *s, struct channel *req, char **errmsg, int *next_pid)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002222{
William Lallemandbddd33a2018-12-11 16:10:53 +01002223 char *str = (char *)ci_head(req);
2224 char *end = (char *)ci_stop(req);
Willy Tarreauf14c7572021-03-13 10:59:23 +01002225 char *args[MAX_CLI_ARGS + 1]; /* +1 for storing a NULL */
William Lallemandbddd33a2018-12-11 16:10:53 +01002226 int argl; /* number of args */
2227 char *p;
2228 char *trim = NULL;
William Lallemandebf61802018-12-11 16:10:57 +01002229 char *payload = NULL;
William Lallemandbddd33a2018-12-11 16:10:53 +01002230 int wtrim = 0; /* number of words to trim */
2231 int reql = 0;
William Lallemandb7ea1412018-12-13 09:05:47 +01002232 int ret;
William Lallemandbddd33a2018-12-11 16:10:53 +01002233 int i = 0;
2234
2235 p = str;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002236
William Lallemanddc12c2e2018-12-13 09:05:46 +01002237 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002238
2239 /* Looks for the end of one command */
2240 while (p+reql < end) {
2241 /* handle escaping */
2242 if (p[reql] == '\\') {
William Lallemand02c255e2020-06-18 18:45:04 +02002243 reql+=2;
William Lallemandebf61802018-12-11 16:10:57 +01002244 continue;
2245 }
2246 if (p[reql] == ';' || p[reql] == '\n') {
2247 /* found the end of the command */
2248 p[reql] = '\n';
2249 reql++;
2250 break;
2251 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002252 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002253 }
William Lallemandebf61802018-12-11 16:10:57 +01002254 } else {
2255 while (p+reql < end) {
2256 if (p[reql] == '\n') {
2257 /* found the end of the line */
2258 reql++;
2259 break;
2260 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002261 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002262 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002263 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002264
William Lallemandbddd33a2018-12-11 16:10:53 +01002265 /* set end to first byte after the end of the command */
2266 end = p + reql;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002267
William Lallemandbddd33a2018-12-11 16:10:53 +01002268 /* there is no end to this command, need more to parse ! */
2269 if (*(end-1) != '\n') {
2270 return -1;
2271 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002272
William Lallemand3301f3e2018-12-13 09:05:48 +01002273 if (s->pcli_flags & PCLI_F_PAYLOAD) {
2274 if (reql == 1) /* last line of the payload */
2275 s->pcli_flags &= ~PCLI_F_PAYLOAD;
William Lallemandebf61802018-12-11 16:10:57 +01002276 return reql;
2277 }
2278
William Lallemandbddd33a2018-12-11 16:10:53 +01002279 *(end-1) = '\0';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002280
William Lallemandbddd33a2018-12-11 16:10:53 +01002281 /* splits the command in words */
Willy Tarreauf14c7572021-03-13 10:59:23 +01002282 while (i < MAX_CLI_ARGS && p < end) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002283 /* skip leading spaces/tabs */
2284 p += strspn(p, " \t");
2285 if (!*p)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002286 break;
2287
William Lallemandbddd33a2018-12-11 16:10:53 +01002288 args[i] = p;
William Lallemandfe249c32020-06-18 18:03:57 +02002289 while (1) {
2290 p += strcspn(p, " \t\\");
2291 /* escaped chars using backlashes (\) */
2292 if (*p == '\\') {
2293 if (!*++p)
2294 break;
2295 if (!*++p)
2296 break;
2297 } else {
2298 break;
William Lallemandbddd33a2018-12-11 16:10:53 +01002299 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002300 }
William Lallemandfe249c32020-06-18 18:03:57 +02002301 *p++ = 0;
William Lallemandbddd33a2018-12-11 16:10:53 +01002302 i++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002303 }
2304
William Lallemandbddd33a2018-12-11 16:10:53 +01002305 argl = i;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002306
Willy Tarreauf14c7572021-03-13 10:59:23 +01002307 for (; i < MAX_CLI_ARGS + 1; i++)
William Lallemandbddd33a2018-12-11 16:10:53 +01002308 args[i] = NULL;
2309
2310 wtrim = pcli_find_and_exec_kw(s, args, argl, errmsg, next_pid);
2311
2312 /* End of words are ending by \0, we need to replace the \0s by spaces
23131 before forwarding them */
2314 p = str;
William Lallemand3301f3e2018-12-13 09:05:48 +01002315 while (p < end-1) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002316 if (*p == '\0')
2317 *p = ' ';
2318 p++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002319 }
2320
William Lallemand3301f3e2018-12-13 09:05:48 +01002321 payload = strstr(str, PAYLOAD_PATTERN);
2322 if ((end - 1) == (payload + strlen(PAYLOAD_PATTERN))) {
2323 /* if the payload pattern is at the end */
2324 s->pcli_flags |= PCLI_F_PAYLOAD;
William Lallemand3301f3e2018-12-13 09:05:48 +01002325 }
2326
William Lallemandbddd33a2018-12-11 16:10:53 +01002327 *(end-1) = '\n';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002328
William Lallemandbddd33a2018-12-11 16:10:53 +01002329 if (wtrim > 0) {
2330 trim = &args[wtrim][0];
2331 if (trim == NULL) /* if this was the last word in the table */
2332 trim = end;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002333
William Lallemandbddd33a2018-12-11 16:10:53 +01002334 b_del(&req->buf, trim - str);
2335
William Lallemandb7ea1412018-12-13 09:05:47 +01002336 ret = end - trim;
William Lallemandbddd33a2018-12-11 16:10:53 +01002337 } else if (wtrim < 0) {
2338 /* parsing error */
2339 return -1;
William Lallemandb7ea1412018-12-13 09:05:47 +01002340 } else {
2341 /* the whole string */
2342 ret = end - str;
William Lallemandbddd33a2018-12-11 16:10:53 +01002343 }
2344
William Lallemandb7ea1412018-12-13 09:05:47 +01002345 if (ret > 1) {
2346 if (pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2347 goto end;
2348 } else if (pcli_has_level(s, ACCESS_LVL_OPER)) {
William Lallemandad032882019-07-01 10:56:15 +02002349 ci_insert_line2(req, 0, "operator -", strlen("operator -"));
2350 ret += strlen("operator -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002351 } else if (pcli_has_level(s, ACCESS_LVL_USER)) {
William Lallemandad032882019-07-01 10:56:15 +02002352 ci_insert_line2(req, 0, "user -", strlen("user -"));
2353 ret += strlen("user -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002354 }
2355 }
2356end:
William Lallemandbddd33a2018-12-11 16:10:53 +01002357
William Lallemandb7ea1412018-12-13 09:05:47 +01002358 return ret;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002359}
2360
2361int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
2362{
William Lallemandbddd33a2018-12-11 16:10:53 +01002363 int next_pid = -1;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002364 int to_forward;
William Lallemandbddd33a2018-12-11 16:10:53 +01002365 char *errmsg = NULL;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002366
William Lallemandb7ea1412018-12-13 09:05:47 +01002367 if ((s->pcli_flags & ACCESS_LVL_MASK) == ACCESS_LVL_NONE)
2368 s->pcli_flags |= strm_li(s)->bind_conf->level & ACCESS_LVL_MASK;
2369
William Lallemandcf62f7e2018-10-26 14:47:40 +02002370read_again:
2371 /* if the channel is closed for read, we won't receive any more data
2372 from the client, but we don't want to forward this close to the
2373 server */
2374 channel_dont_close(req);
2375
2376 /* We don't know yet to which server we will connect */
2377 channel_dont_connect(req);
2378
2379
2380 /* we are not waiting for a response, there is no more request and we
2381 * receive a close from the client, we can leave */
2382 if (!(ci_data(req)) && req->flags & CF_SHUTR) {
2383 channel_shutw_now(&s->res);
2384 s->req.analysers &= ~AN_REQ_WAIT_CLI;
2385 return 1;
2386 }
2387
2388 req->flags |= CF_READ_DONTWAIT;
2389
2390 /* need more data */
2391 if (!ci_data(req))
2392 return 0;
2393
2394 /* If there is data available for analysis, log the end of the idle time. */
2395 if (c_data(req) && s->logs.t_idle == -1)
2396 s->logs.t_idle = tv_ms_elapsed(&s->logs.tv_accept, &now) - s->logs.t_handshake;
2397
William Lallemandbddd33a2018-12-11 16:10:53 +01002398 to_forward = pcli_parse_request(s, req, &errmsg, &next_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002399 if (to_forward > 0) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002400 int target_pid;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002401 /* enough data */
2402
William Lallemandcf62f7e2018-10-26 14:47:40 +02002403 /* forward only 1 command */
2404 channel_forward(req, to_forward);
William Lallemandebf61802018-12-11 16:10:57 +01002405
William Lallemanddc12c2e2018-12-13 09:05:46 +01002406 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002407 /* we send only 1 command per request, and we write close after it */
2408 channel_shutw_now(req);
2409 } else {
2410 pcli_write_prompt(s);
2411 }
2412
2413 s->res.flags |= CF_WAKE_ONCE; /* need to be called again */
William Lallemandcf62f7e2018-10-26 14:47:40 +02002414
2415 /* remove the XFER_DATA analysers, which forwards all
2416 * the data, we don't want to forward the next requests
2417 * We need to add CF_FLT_ANALYZE to abort the forward too.
2418 */
2419 req->analysers &= ~(AN_REQ_FLT_XFER_DATA|AN_REQ_WAIT_CLI);
2420 req->analysers |= AN_REQ_FLT_END|CF_FLT_ANALYZE;
2421 s->res.analysers |= AN_RES_WAIT_CLI;
2422
William Lallemandebf61802018-12-11 16:10:57 +01002423 if (!(s->flags & SF_ASSIGNED)) {
2424 if (next_pid > -1)
2425 target_pid = next_pid;
2426 else
2427 target_pid = s->pcli_next_pid;
2428 /* we can connect now */
2429 s->target = pcli_pid_to_server(target_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002430
William Lallemandebf61802018-12-11 16:10:57 +01002431 s->flags |= (SF_DIRECT | SF_ASSIGNED);
2432 channel_auto_connect(req);
2433 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002434
2435 } else if (to_forward == 0) {
William Lallemandcf62f7e2018-10-26 14:47:40 +02002436 /* we trimmed things but we might have other commands to consume */
William Lallemandbddd33a2018-12-11 16:10:53 +01002437 pcli_write_prompt(s);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002438 goto read_again;
William Lallemandbddd33a2018-12-11 16:10:53 +01002439 } else if (to_forward == -1 && errmsg) {
2440 /* there was an error during the parsing */
2441 pcli_reply_and_close(s, errmsg);
2442 return 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002443 } else if (to_forward == -1 && channel_full(req, global.tune.maxrewrite)) {
2444 /* buffer is full and we didn't catch the end of a command */
2445 goto send_help;
2446 }
2447
2448 return 0;
2449
2450send_help:
2451 b_reset(&req->buf);
2452 b_putblk(&req->buf, "help\n", 5);
2453 goto read_again;
2454}
2455
2456int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
2457{
2458 struct proxy *fe = strm_fe(s);
2459 struct proxy *be = s->be;
2460
William Lallemand6b7cd0a2018-11-06 17:37:11 +01002461 if (rep->flags & CF_READ_ERROR) {
2462 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
2463 s->res.analysers &= ~AN_RES_WAIT_CLI;
2464 return 0;
2465 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002466 rep->flags |= CF_READ_DONTWAIT; /* try to get back here ASAP */
2467 rep->flags |= CF_NEVER_WAIT;
2468
2469 /* don't forward the close */
2470 channel_dont_close(&s->res);
2471 channel_dont_close(&s->req);
2472
William Lallemanddc12c2e2018-12-13 09:05:46 +01002473 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002474 s->req.analysers |= AN_REQ_WAIT_CLI;
2475 s->res.analysers &= ~AN_RES_WAIT_CLI;
2476 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2477 return 0;
2478 }
2479
William Lallemandcf62f7e2018-10-26 14:47:40 +02002480 /* forward the data */
2481 if (ci_data(rep)) {
2482 c_adv(rep, ci_data(rep));
2483 return 0;
2484 }
2485
2486 if ((rep->flags & (CF_SHUTR|CF_READ_NULL))) {
2487 /* stream cleanup */
2488
William Lallemand2f4ce202018-10-26 14:47:47 +02002489 pcli_write_prompt(s);
2490
William Lallemandcf62f7e2018-10-26 14:47:40 +02002491 s->si[1].flags |= SI_FL_NOLINGER | SI_FL_NOHALF;
2492 si_shutr(&s->si[1]);
2493 si_shutw(&s->si[1]);
2494
2495 /*
2496 * starting from there this the same code as
2497 * http_end_txn_clean_session().
2498 *
2499 * It allows to do frontend keepalive while reconnecting to a
2500 * new server for each request.
2501 */
2502
2503 if (s->flags & SF_BE_ASSIGNED) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002504 HA_ATOMIC_DEC(&be->beconn);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002505 if (unlikely(s->srv_conn))
2506 sess_change_server(s, NULL);
2507 }
2508
2509 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2510 stream_process_counters(s);
2511
2512 /* don't count other requests' data */
2513 s->logs.bytes_in -= ci_data(&s->req);
2514 s->logs.bytes_out -= ci_data(&s->res);
2515
2516 /* we may need to know the position in the queue */
2517 pendconn_free(s);
2518
2519 /* let's do a final log if we need it */
2520 if (!LIST_ISEMPTY(&fe->logformat) && s->logs.logwait &&
2521 !(s->flags & SF_MONITOR) &&
2522 (!(fe->options & PR_O_NULLNOLOG) || s->req.total)) {
2523 s->do_log(s);
2524 }
2525
2526 /* stop tracking content-based counters */
2527 stream_stop_content_counters(s);
2528 stream_update_time_stats(s);
2529
2530 s->logs.accept_date = date; /* user-visible date for logging */
2531 s->logs.tv_accept = now; /* corrected date for internal use */
2532 s->logs.t_handshake = 0; /* There are no handshake in keep alive connection. */
2533 s->logs.t_idle = -1;
2534 tv_zero(&s->logs.tv_request);
2535 s->logs.t_queue = -1;
2536 s->logs.t_connect = -1;
2537 s->logs.t_data = -1;
2538 s->logs.t_close = 0;
2539 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
2540 s->logs.srv_queue_pos = 0; /* we will get this number soon */
2541
2542 s->logs.bytes_in = s->req.total = ci_data(&s->req);
2543 s->logs.bytes_out = s->res.total = ci_data(&s->res);
2544
2545 stream_del_srv_conn(s);
2546 if (objt_server(s->target)) {
2547 if (s->flags & SF_CURR_SESS) {
2548 s->flags &= ~SF_CURR_SESS;
Willy Tarreau4781b152021-04-06 13:53:36 +02002549 HA_ATOMIC_DEC(&__objt_server(s->target)->cur_sess);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002550 }
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002551 if (may_dequeue_tasks(__objt_server(s->target), be))
2552 process_srv_queue(__objt_server(s->target));
William Lallemandcf62f7e2018-10-26 14:47:40 +02002553 }
2554
2555 s->target = NULL;
2556
2557 /* only release our endpoint if we don't intend to reuse the
2558 * connection.
2559 */
2560 if (!si_conn_ready(&s->si[1])) {
2561 si_release_endpoint(&s->si[1]);
2562 s->srv_conn = NULL;
2563 }
2564
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002565 sockaddr_free(&s->target_addr);
2566
William Lallemandcf62f7e2018-10-26 14:47:40 +02002567 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
2568 s->si[1].err_type = SI_ET_NONE;
2569 s->si[1].conn_retries = 0; /* used for logging too */
2570 s->si[1].exp = TICK_ETERNITY;
2571 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 +02002572 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 +02002573 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 +02002574 s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_ADDR_SET|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
2575 s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
2576 s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
2577 /* reinitialise the current rule list pointer to NULL. We are sure that
2578 * any rulelist match the NULL pointer.
2579 */
2580 s->current_rule_list = NULL;
2581
2582 s->be = strm_fe(s);
2583 s->logs.logwait = strm_fe(s)->to_log;
2584 s->logs.level = 0;
2585 stream_del_srv_conn(s);
2586 s->target = NULL;
2587 /* re-init store persistence */
2588 s->store_count = 0;
2589 s->uniq_id = global.req_count++;
2590
2591 s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */
2592
2593 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2594
2595 s->req.analysers |= AN_REQ_WAIT_CLI;
2596 s->res.analysers &= ~AN_RES_WAIT_CLI;
2597
2598 /* We must trim any excess data from the response buffer, because we
2599 * may have blocked an invalid response from a server that we don't
Ilya Shipitsind4259502020-04-08 01:07:56 +05002600 * want to accidentally forward once we disable the analysers, nor do
William Lallemandcf62f7e2018-10-26 14:47:40 +02002601 * we want those data to come along with next response. A typical
2602 * example of such data would be from a buggy server responding to
2603 * a HEAD with some data, or sending more than the advertised
2604 * content-length.
2605 */
2606 if (unlikely(ci_data(&s->res)))
2607 b_set_data(&s->res.buf, co_data(&s->res));
2608
2609 /* Now we can realign the response buffer */
2610 c_realign_if_empty(&s->res);
2611
2612 s->req.rto = strm_fe(s)->timeout.client;
2613 s->req.wto = TICK_ETERNITY;
2614
2615 s->res.rto = TICK_ETERNITY;
2616 s->res.wto = strm_fe(s)->timeout.client;
2617
2618 s->req.rex = TICK_ETERNITY;
2619 s->req.wex = TICK_ETERNITY;
2620 s->req.analyse_exp = TICK_ETERNITY;
2621 s->res.rex = TICK_ETERNITY;
2622 s->res.wex = TICK_ETERNITY;
2623 s->res.analyse_exp = TICK_ETERNITY;
2624 s->si[1].hcto = TICK_ETERNITY;
2625
2626 /* we're removing the analysers, we MUST re-enable events detection.
2627 * We don't enable close on the response channel since it's either
2628 * already closed, or in keep-alive with an idle connection handler.
2629 */
2630 channel_auto_read(&s->req);
2631 channel_auto_close(&s->req);
2632 channel_auto_read(&s->res);
2633
2634
2635 return 1;
2636 }
2637 return 0;
2638}
2639
William Lallemand8a022572018-10-26 14:47:35 +02002640/*
2641 * The mworker functions are used to initialize the CLI in the master process
2642 */
2643
William Lallemand309dc9a2018-10-26 14:47:45 +02002644 /*
2645 * Stop the mworker proxy
2646 */
2647void mworker_cli_proxy_stop()
2648{
William Lallemand550db6d2018-11-06 17:37:12 +01002649 if (mworker_proxy)
2650 stop_proxy(mworker_proxy);
William Lallemand309dc9a2018-10-26 14:47:45 +02002651}
2652
William Lallemand8a022572018-10-26 14:47:35 +02002653/*
2654 * Create the mworker CLI proxy
2655 */
2656int mworker_cli_proxy_create()
2657{
2658 struct mworker_proc *child;
William Lallemand744a0892018-11-22 16:46:51 +01002659 char *msg = NULL;
2660 char *errmsg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002661
2662 mworker_proxy = calloc(1, sizeof(*mworker_proxy));
2663 if (!mworker_proxy)
2664 return -1;
2665
2666 init_new_proxy(mworker_proxy);
2667 mworker_proxy->next = proxies_list;
2668 proxies_list = mworker_proxy;
2669 mworker_proxy->id = strdup("MASTER");
William Lallemandcf62f7e2018-10-26 14:47:40 +02002670 mworker_proxy->mode = PR_MODE_CLI;
William Lallemand8a022572018-10-26 14:47:35 +02002671 mworker_proxy->last_change = now.tv_sec;
2672 mworker_proxy->cap = PR_CAP_LISTEN; /* this is a listen section */
2673 mworker_proxy->maxconn = 10; /* default to 10 concurrent connections */
2674 mworker_proxy->timeout.client = 0; /* no timeout */
2675 mworker_proxy->conf.file = strdup("MASTER");
2676 mworker_proxy->conf.line = 0;
2677 mworker_proxy->accept = frontend_accept;
2678 mworker_proxy-> lbprm.algo = BE_LB_ALGO_NONE;
2679
2680 /* Does not init the default target the CLI applet, but must be done in
2681 * the request parsing code */
2682 mworker_proxy->default_target = NULL;
2683
2684 /* the check_config_validity() will get an ID for the proxy */
2685 mworker_proxy->uuid = -1;
2686
2687 proxy_store_name(mworker_proxy);
2688
2689 /* create all servers using the mworker_proc list */
2690 list_for_each_entry(child, &proc_list, list) {
William Lallemand8a022572018-10-26 14:47:35 +02002691 struct server *newsrv = NULL;
2692 struct sockaddr_storage *sk;
2693 int port1, port2, port;
2694 struct protocol *proto;
William Lallemand8a022572018-10-26 14:47:35 +02002695
William Lallemanda31b09e2020-01-14 15:25:02 +01002696 /* only the workers support the master CLI */
2697 if (!(child->options & PROC_O_TYPE_WORKER))
2698 continue;
2699
William Lallemand8a022572018-10-26 14:47:35 +02002700 newsrv = new_server(mworker_proxy);
2701 if (!newsrv)
William Lallemand744a0892018-11-22 16:46:51 +01002702 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002703
2704 /* we don't know the new pid yet */
2705 if (child->pid == -1)
2706 memprintf(&msg, "cur-%d", child->relative_pid);
2707 else
2708 memprintf(&msg, "old-%d", child->pid);
2709
2710 newsrv->next = mworker_proxy->srv;
2711 mworker_proxy->srv = newsrv;
2712 newsrv->conf.file = strdup(msg);
2713 newsrv->id = strdup(msg);
2714 newsrv->conf.line = 0;
2715
2716 memprintf(&msg, "sockpair@%d", child->ipc_fd[0]);
Willy Tarreau5fc93282020-09-16 18:25:03 +02002717 if ((sk = str2sa_range(msg, &port, &port1, &port2, NULL, &proto,
Willy Tarreaua93e5c72020-09-15 14:01:16 +02002718 &errmsg, NULL, NULL, PA_O_STREAM)) == 0) {
William Lallemand744a0892018-11-22 16:46:51 +01002719 goto error;
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002720 }
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002721 ha_free(&msg);
William Lallemand8a022572018-10-26 14:47:35 +02002722
Willy Tarreau5fc93282020-09-16 18:25:03 +02002723 if (!proto->connect) {
William Lallemand744a0892018-11-22 16:46:51 +01002724 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002725 }
2726
2727 /* no port specified */
2728 newsrv->flags |= SRV_F_MAPPORTS;
2729 newsrv->addr = *sk;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002730 /* don't let the server participate to load balancing */
2731 newsrv->iweight = 0;
2732 newsrv->uweight = 0;
William Lallemand8a022572018-10-26 14:47:35 +02002733 srv_lb_commit_status(newsrv);
William Lallemand291810d2018-10-26 14:47:38 +02002734
2735 child->srv = newsrv;
William Lallemand8a022572018-10-26 14:47:35 +02002736 }
2737 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002738
2739error:
2740 ha_alert("%s\n", errmsg);
2741
2742 list_for_each_entry(child, &proc_list, list) {
2743 free((char *)child->srv->conf.file); /* cast because of const char * */
2744 free(child->srv->id);
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002745 ha_free(&child->srv);
William Lallemand744a0892018-11-22 16:46:51 +01002746 }
2747 free(mworker_proxy->id);
2748 free(mworker_proxy->conf.file);
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002749 ha_free(&mworker_proxy);
William Lallemand744a0892018-11-22 16:46:51 +01002750 free(errmsg);
2751 free(msg);
2752
2753 return -1;
William Lallemand8a022572018-10-26 14:47:35 +02002754}
Olivier Houchardf886e342017-04-05 22:24:59 +02002755
William Lallemandce83b4a2018-10-26 14:47:30 +02002756/*
William Lallemande7361152018-10-26 14:47:36 +02002757 * Create a new listener for the master CLI proxy
2758 */
2759int mworker_cli_proxy_new_listener(char *line)
2760{
2761 struct bind_conf *bind_conf;
2762 struct listener *l;
2763 char *err = NULL;
2764 char *args[MAX_LINE_ARGS + 1];
2765 int arg;
2766 int cur_arg;
2767
William Lallemand2e945c82019-11-25 09:58:37 +01002768 arg = 1;
William Lallemande7361152018-10-26 14:47:36 +02002769 args[0] = line;
2770
2771 /* args is a bind configuration with spaces replaced by commas */
2772 while (*line && arg < MAX_LINE_ARGS) {
2773
2774 if (*line == ',') {
2775 *line++ = '\0';
2776 while (*line == ',')
2777 line++;
William Lallemand2e945c82019-11-25 09:58:37 +01002778 args[arg++] = line;
William Lallemande7361152018-10-26 14:47:36 +02002779 }
2780 line++;
2781 }
2782
William Lallemand2e945c82019-11-25 09:58:37 +01002783 args[arg] = "\0";
William Lallemande7361152018-10-26 14:47:36 +02002784
2785 bind_conf = bind_conf_alloc(mworker_proxy, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002786 if (!bind_conf)
2787 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002788
2789 bind_conf->level &= ~ACCESS_LVL_MASK;
2790 bind_conf->level |= ACCESS_LVL_ADMIN;
Willy Tarreaue283ee62021-03-12 15:00:57 +01002791 bind_conf->level |= ACCESS_MASTER | ACCESS_MASTER_ONLY;
William Lallemande7361152018-10-26 14:47:36 +02002792
2793 if (!str2listener(args[0], mworker_proxy, bind_conf, "master-socket", 0, &err)) {
2794 ha_alert("Cannot create the listener of the master CLI\n");
William Lallemand744a0892018-11-22 16:46:51 +01002795 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002796 }
2797
2798 cur_arg = 1;
2799
2800 while (*args[cur_arg]) {
William Lallemande7361152018-10-26 14:47:36 +02002801 struct bind_kw *kw;
Willy Tarreau433b05f2021-03-12 10:14:07 +01002802 const char *best;
William Lallemande7361152018-10-26 14:47:36 +02002803
2804 kw = bind_find_kw(args[cur_arg]);
2805 if (kw) {
2806 if (!kw->parse) {
2807 memprintf(&err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
2808 args[0], args[1], args[cur_arg]);
2809 goto err;
2810 }
2811
Willy Tarreau4975d142021-03-13 11:00:33 +01002812 if (kw->parse(args, cur_arg, global.cli_fe, bind_conf, &err) != 0) {
William Lallemande7361152018-10-26 14:47:36 +02002813 if (err)
2814 memprintf(&err, "'%s %s' : '%s'", args[0], args[1], err);
2815 else
2816 memprintf(&err, "'%s %s' : error encountered while processing '%s'",
2817 args[0], args[1], args[cur_arg]);
2818 goto err;
2819 }
2820
2821 cur_arg += 1 + kw->skip;
2822 continue;
2823 }
2824
Willy Tarreau433b05f2021-03-12 10:14:07 +01002825 best = bind_find_best_kw(args[cur_arg]);
2826 if (best)
2827 memprintf(&err, "'%s %s' : unknown keyword '%s'. Did you mean '%s' maybe ?",
2828 args[0], args[1], args[cur_arg], best);
2829 else
2830 memprintf(&err, "'%s %s' : unknown keyword '%s'.",
2831 args[0], args[1], args[cur_arg]);
William Lallemande7361152018-10-26 14:47:36 +02002832 goto err;
2833 }
2834
2835
2836 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemande7361152018-10-26 14:47:36 +02002837 l->accept = session_accept_fd;
2838 l->default_target = mworker_proxy->default_target;
2839 /* don't make the peers subject to global limits and don't close it in the master */
Willy Tarreau18c20d22020-10-09 16:11:46 +02002840 l->options |= LI_O_UNLIMITED;
2841 l->rx.flags |= RX_F_MWORKER; /* we are keeping this FD in the master */
William Lallemande7361152018-10-26 14:47:36 +02002842 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002843 global.maxsock++; /* for the listening socket */
William Lallemande7361152018-10-26 14:47:36 +02002844 }
Willy Tarreau18215cb2019-02-27 16:25:28 +01002845 global.maxsock += mworker_proxy->maxconn;
William Lallemande7361152018-10-26 14:47:36 +02002846
2847 return 0;
2848
2849err:
2850 ha_alert("%s\n", err);
William Lallemand744a0892018-11-22 16:46:51 +01002851 free(err);
2852 free(bind_conf);
William Lallemande7361152018-10-26 14:47:36 +02002853 return -1;
2854
2855}
2856
2857/*
William Lallemandce83b4a2018-10-26 14:47:30 +02002858 * Create a new CLI socket using a socketpair for a worker process
2859 * <mworker_proc> is the process structure, and <proc> is the process number
2860 */
2861int mworker_cli_sockpair_new(struct mworker_proc *mworker_proc, int proc)
2862{
2863 struct bind_conf *bind_conf;
2864 struct listener *l;
2865 char *path = NULL;
2866 char *err = NULL;
2867
2868 /* master pipe to ensure the master is still alive */
2869 if (socketpair(AF_UNIX, SOCK_STREAM, 0, mworker_proc->ipc_fd) < 0) {
2870 ha_alert("Cannot create worker socketpair.\n");
2871 return -1;
2872 }
2873
2874 /* XXX: we might want to use a separate frontend at some point */
Willy Tarreau4975d142021-03-13 11:00:33 +01002875 if (!global.cli_fe) {
2876 if ((global.cli_fe = cli_alloc_fe("GLOBAL", "master-socket", 0)) == NULL) {
William Lallemandce83b4a2018-10-26 14:47:30 +02002877 ha_alert("out of memory trying to allocate the stats frontend");
William Lallemand744a0892018-11-22 16:46:51 +01002878 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002879 }
2880 }
2881
Willy Tarreau4975d142021-03-13 11:00:33 +01002882 bind_conf = bind_conf_alloc(global.cli_fe, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002883 if (!bind_conf)
2884 goto error;
2885
William Lallemandce83b4a2018-10-26 14:47:30 +02002886 bind_conf->level &= ~ACCESS_LVL_MASK;
2887 bind_conf->level |= ACCESS_LVL_ADMIN; /* TODO: need to lower the rights with a CLI keyword*/
2888
Willy Tarreaue26993c2020-09-03 07:18:55 +02002889 bind_conf->settings.bind_proc = 1UL << proc;
Willy Tarreau4975d142021-03-13 11:00:33 +01002890 global.cli_fe->bind_proc = 0; /* XXX: we should be careful with that, it can be removed by configuration */
William Lallemandce83b4a2018-10-26 14:47:30 +02002891
2892 if (!memprintf(&path, "sockpair@%d", mworker_proc->ipc_fd[1])) {
2893 ha_alert("Cannot allocate listener.\n");
William Lallemand744a0892018-11-22 16:46:51 +01002894 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002895 }
2896
Willy Tarreau4975d142021-03-13 11:00:33 +01002897 if (!str2listener(path, global.cli_fe, bind_conf, "master-socket", 0, &err)) {
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002898 free(path);
William Lallemandce83b4a2018-10-26 14:47:30 +02002899 ha_alert("Cannot create a CLI sockpair listener for process #%d\n", proc);
William Lallemand744a0892018-11-22 16:46:51 +01002900 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002901 }
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002902 ha_free(&path);
William Lallemandce83b4a2018-10-26 14:47:30 +02002903
2904 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemandce83b4a2018-10-26 14:47:30 +02002905 l->accept = session_accept_fd;
Willy Tarreau4975d142021-03-13 11:00:33 +01002906 l->default_target = global.cli_fe->default_target;
William Lallemanda3372292018-11-16 16:57:22 +01002907 l->options |= (LI_O_UNLIMITED | LI_O_NOSTOP);
Willy Tarreau4781b152021-04-06 13:53:36 +02002908 HA_ATOMIC_INC(&unstoppable_jobs);
William Lallemandce83b4a2018-10-26 14:47:30 +02002909 /* it's a sockpair but we don't want to keep the fd in the master */
Willy Tarreau43046fa2020-09-01 15:41:59 +02002910 l->rx.flags &= ~RX_F_INHERITED;
William Lallemandce83b4a2018-10-26 14:47:30 +02002911 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002912 global.maxsock++; /* for the listening socket */
William Lallemandce83b4a2018-10-26 14:47:30 +02002913 }
2914
2915 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002916
2917error:
2918 close(mworker_proc->ipc_fd[0]);
2919 close(mworker_proc->ipc_fd[1]);
2920 free(err);
2921
2922 return -1;
William Lallemandce83b4a2018-10-26 14:47:30 +02002923}
2924
William Lallemand74c24fb2016-11-21 17:18:36 +01002925static struct applet cli_applet = {
2926 .obj_type = OBJ_TYPE_APPLET,
2927 .name = "<CLI>", /* used for logging */
2928 .fct = cli_io_handler,
2929 .release = cli_release_handler,
2930};
2931
William Lallemand99e0bb92020-11-05 10:28:53 +01002932/* master CLI */
2933static struct applet mcli_applet = {
2934 .obj_type = OBJ_TYPE_APPLET,
2935 .name = "<MCLI>", /* used for logging */
2936 .fct = cli_io_handler,
2937 .release = cli_release_handler,
2938};
2939
Willy Tarreau0a739292016-11-22 20:21:23 +01002940/* register cli keywords */
2941static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau0609c9b2021-03-12 17:03:33 +01002942 { { "help", NULL }, NULL, cli_parse_simple, NULL, NULL, NULL, ACCESS_MASTER },
2943 { { "prompt", NULL }, NULL, cli_parse_simple, NULL, NULL, NULL, ACCESS_MASTER },
2944 { { "quit", NULL }, NULL, cli_parse_simple, NULL, NULL, NULL, ACCESS_MASTER },
Willy Tarreau2af99412016-11-23 11:10:59 +01002945 { { "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 +01002946 { { "set", "rate-limit", NULL }, "set rate-limit : change a rate limiting value", cli_parse_set_ratelimit, NULL },
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002947 { { "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 +01002948 { { "set", "timeout", NULL }, "set timeout : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Willy Tarreau0a739292016-11-22 20:21:23 +01002949 { { "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 +02002950 { { "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 +01002951 { { "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 +02002952 { { "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 +01002953 { { "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 +01002954 { { "operator", NULL }, "operator : lower the level of the current CLI session to operator", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
2955 { { "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 +02002956 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01002957 { { "expert-mode", NULL }, NULL, cli_parse_expert_experimental_mode, NULL }, // not listed
2958 { { "experimental-mode", NULL }, NULL, cli_parse_expert_experimental_mode, NULL }, // not listed
Willy Tarreau0a739292016-11-22 20:21:23 +01002959 {{},}
2960}};
2961
Willy Tarreau0108d902018-11-25 19:14:37 +01002962INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
2963
William Lallemand74c24fb2016-11-21 17:18:36 +01002964static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau4975d142021-03-13 11:00:33 +01002965 { CFG_GLOBAL, "stats", cli_parse_global },
William Lallemand74c24fb2016-11-21 17:18:36 +01002966 { 0, NULL, NULL },
2967}};
2968
Willy Tarreau0108d902018-11-25 19:14:37 +01002969INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
2970
William Lallemand74c24fb2016-11-21 17:18:36 +01002971static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02002972 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
2973 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002974 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01002975 { NULL, NULL, 0 },
2976}};
2977
Willy Tarreau0108d902018-11-25 19:14:37 +01002978INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01002979
2980/*
2981 * Local variables:
2982 * c-indent-level: 8
2983 * c-basic-offset: 8
2984 * End:
2985 */