blob: 76164a18f5185673c1f503865724bfc9267a135c [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 Tarreau92fbbcc2021-05-09 21:45:29 +020087static int cmp_kw_entries(const void *a, const void *b)
88{
89 const struct cli_kw *l = *(const struct cli_kw **)a;
90 const struct cli_kw *r = *(const struct cli_kw **)b;
91
92 return strcmp(l->usage ? l->usage : "", r->usage ? r->usage : "");
93}
94
Willy Tarreaub96a74c2021-03-12 17:13:28 +010095/* This will show the help message and list the commands supported at the
96 * current level that match all of the first words of <args> if args is not
97 * NULL, or all args if none matches or if args is null.
98 */
99static char *cli_gen_usage_msg(struct appctx *appctx, char * const *args)
William Lallemand74c24fb2016-11-21 17:18:36 +0100100{
Willy Tarreau92fbbcc2021-05-09 21:45:29 +0200101 struct cli_kw *entries[CLI_MAX_HELP_ENTRIES];
William Lallemand74c24fb2016-11-21 17:18:36 +0100102 struct cli_kw_list *kw_list;
103 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +0200104 struct buffer *tmp = get_trash_chunk();
105 struct buffer out;
Willy Tarreaub7364582021-03-12 18:24:46 +0100106 struct { struct cli_kw *kw; int dist; } matches[CLI_MAX_MATCHES], swp;
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100107 int idx;
Willy Tarreau0b1b8302021-05-09 20:59:23 +0200108 int ishelp = 0;
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100109 int length = 0;
Willy Tarreau92fbbcc2021-05-09 21:45:29 +0200110 int help_entries = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100111
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100112 ha_free(&dynamic_usage_msg);
William Lallemand74c24fb2016-11-21 17:18:36 +0100113
Willy Tarreau0b1b8302021-05-09 20:59:23 +0200114 if (args && *args && strcmp(*args, "help") == 0) {
115 args++;
116 ishelp = 1;
117 }
118
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100119 /* first, let's measure the longest match */
120 list_for_each_entry(kw_list, &cli_keywords.list, list) {
121 for (kw = &kw_list->kw[0]; kw->str_kw[0]; kw++) {
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100122 if (kw->level & ~appctx->cli_level & (ACCESS_MASTER_ONLY|ACCESS_EXPERT|ACCESS_EXPERIMENTAL))
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100123 continue;
124 if ((appctx->cli_level & ~kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)) ==
125 (ACCESS_MASTER_ONLY|ACCESS_MASTER))
126 continue;
127
128 /* OK this command is visible */
129 for (idx = 0; idx < CLI_PREFIX_KW_NB; idx++) {
130 if (!kw->str_kw[idx])
131 break; // end of keyword
132 if (!args || !args[idx] || !*args[idx])
133 break; // end of command line
134 if (strcmp(kw->str_kw[idx], args[idx]) != 0)
135 break;
136 if (idx + 1 > length)
137 length = idx + 1;
138 }
139 }
140 }
141
Willy Tarreaub7364582021-03-12 18:24:46 +0100142 /* now <length> equals the number of exactly matching words */
William Lallemand74c24fb2016-11-21 17:18:36 +0100143 chunk_reset(tmp);
Willy Tarreau0b1b8302021-05-09 20:59:23 +0200144 if (ishelp) // this is the help message.
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100145 chunk_strcat(tmp, "The following commands are valid at this level:\n");
Willy Tarreau5db446d2021-05-10 07:47:05 +0200146 else if (!length && (!args || !*args || !**args)) // no match
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100147 chunk_strcat(tmp, "Unknown command. Please enter one of the following commands only:\n");
148 else // partial match
149 chunk_strcat(tmp, "Unknown command, but maybe one of the following ones is a better match:\n");
150
Willy Tarreaub7364582021-03-12 18:24:46 +0100151 for (idx = 0; idx < CLI_MAX_MATCHES; idx++) {
152 matches[idx].kw = NULL;
153 matches[idx].dist = INT_MAX;
154 }
155
156 /* In case of partial match we'll look for the best matching entries
157 * starting from position <length>
158 */
Willy Tarreau9c187472021-03-13 12:25:43 +0100159 if (args && args[length] && *args[length]) {
Willy Tarreaub7364582021-03-12 18:24:46 +0100160 list_for_each_entry(kw_list, &cli_keywords.list, list) {
161 for (kw = &kw_list->kw[0]; kw->str_kw[0]; kw++) {
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100162 if (kw->level & ~appctx->cli_level & (ACCESS_MASTER_ONLY|ACCESS_EXPERT|ACCESS_EXPERIMENTAL))
Willy Tarreaub7364582021-03-12 18:24:46 +0100163 continue;
164 if ((appctx->cli_level & ~kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)) ==
165 (ACCESS_MASTER_ONLY|ACCESS_MASTER))
166 continue;
167
168 for (idx = 0; idx < length; idx++) {
169 if (!kw->str_kw[idx])
170 break; // end of keyword
171 if (!args || !args[idx] || !*args[idx])
172 break; // end of command line
173 if (strcmp(kw->str_kw[idx], args[idx]) != 0)
174 break;
175 }
176
177 /* extra non-matching words are fuzzy-matched */
178 if (kw->usage && idx == length && args[idx] && *args[idx]) {
179 uint8_t word_sig[1024];
180 uint8_t list_sig[1024];
181 int dist = 0;
182 int totlen = 0;
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100183 int i;
Willy Tarreaub7364582021-03-12 18:24:46 +0100184
185 /* this one matches, let's compute the distance between the two
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100186 * on the remaining words. For this we're computing the signature
187 * of everything that remains and the cumulated length of the
188 * strings.
Willy Tarreaub7364582021-03-12 18:24:46 +0100189 */
Willy Tarreauc57dcfe2021-03-12 19:01:59 +0100190 memset(word_sig, 0, sizeof(word_sig));
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100191 for (i = idx; i < CLI_PREFIX_KW_NB && args[i] && *args[i]; i++) {
192 update_word_fingerprint(word_sig, args[i]);
193 totlen += strlen(args[i]);
194 }
Willy Tarreauc57dcfe2021-03-12 19:01:59 +0100195
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100196 memset(list_sig, 0, sizeof(list_sig));
197 for (i = idx; i < CLI_PREFIX_KW_NB && kw->str_kw[i]; i++) {
198 update_word_fingerprint(list_sig, kw->str_kw[i]);
199 totlen += strlen(kw->str_kw[i]);
Willy Tarreaub7364582021-03-12 18:24:46 +0100200 }
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100201
Willy Tarreauc57dcfe2021-03-12 19:01:59 +0100202 dist = word_fingerprint_distance(word_sig, list_sig);
Willy Tarreaub7364582021-03-12 18:24:46 +0100203
204 /* insert this one at its place if relevant, in order to keep only
205 * the best matches.
206 */
207 swp.kw = kw; swp.dist = dist;
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100208 if (dist < 5*totlen/2 && dist < matches[CLI_MAX_MATCHES-1].dist) {
Willy Tarreaub7364582021-03-12 18:24:46 +0100209 matches[CLI_MAX_MATCHES-1] = swp;
210 for (idx = CLI_MAX_MATCHES - 1; --idx >= 0;) {
211 if (matches[idx+1].dist >= matches[idx].dist)
212 break;
213 matches[idx+1] = matches[idx];
214 matches[idx] = swp;
215 }
216 }
217 }
218 }
219 }
220 }
221
Willy Tarreauec197e82021-03-15 10:35:04 +0100222 if (matches[0].kw) {
223 /* we have fuzzy matches, let's propose them */
224 for (idx = 0; idx < CLI_MAX_MATCHES; idx++) {
225 kw = matches[idx].kw;
226 if (!kw)
227 break;
228
229 /* stop the dump if some words look very unlikely candidates */
230 if (matches[idx].dist > 5*matches[0].dist/2)
231 break;
232
Willy Tarreau92fbbcc2021-05-09 21:45:29 +0200233 if (help_entries < CLI_MAX_HELP_ENTRIES)
234 entries[help_entries++] = kw;
Willy Tarreauec197e82021-03-15 10:35:04 +0100235 }
236 }
237
William Lallemand74c24fb2016-11-21 17:18:36 +0100238 list_for_each_entry(kw_list, &cli_keywords.list, list) {
Willy Tarreauec197e82021-03-15 10:35:04 +0100239 /* no full dump if we've already found nice candidates */
240 if (matches[0].kw)
241 break;
242
Willy Tarreau91bc3592021-03-12 15:20:39 +0100243 for (kw = &kw_list->kw[0]; kw->str_kw[0]; kw++) {
William Lallemand14721be2018-10-26 14:47:37 +0200244
Willy Tarreau91bc3592021-03-12 15:20:39 +0100245 /* in a worker or normal process, don't display master-only commands
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100246 * nor expert/experimental mode commands if not in this mode.
Willy Tarreau91bc3592021-03-12 15:20:39 +0100247 */
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100248 if (kw->level & ~appctx->cli_level & (ACCESS_MASTER_ONLY|ACCESS_EXPERT|ACCESS_EXPERIMENTAL))
Willy Tarreau91bc3592021-03-12 15:20:39 +0100249 continue;
William Lallemand14721be2018-10-26 14:47:37 +0200250
Willy Tarreau91bc3592021-03-12 15:20:39 +0100251 /* in master don't display commands that have neither the master bit
252 * nor the master-only bit.
253 */
254 if ((appctx->cli_level & ~kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)) ==
255 (ACCESS_MASTER_ONLY|ACCESS_MASTER))
256 continue;
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200257
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100258 for (idx = 0; idx < length; idx++) {
259 if (!kw->str_kw[idx])
260 break; // end of keyword
261 if (!args || !args[idx] || !*args[idx])
262 break; // end of command line
263 if (strcmp(kw->str_kw[idx], args[idx]) != 0)
264 break;
265 }
266
Willy Tarreau92fbbcc2021-05-09 21:45:29 +0200267 if (kw->usage && idx == length && help_entries < CLI_MAX_HELP_ENTRIES)
268 entries[help_entries++] = kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100269 }
270 }
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100271
Willy Tarreau92fbbcc2021-05-09 21:45:29 +0200272 qsort(entries, help_entries, sizeof(*entries), cmp_kw_entries);
273
274 for (idx = 0; idx < help_entries; idx++)
275 chunk_appendf(tmp, " %s\n", entries[idx]->usage);
276
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100277 /* always show the prompt/help/quit commands */
278 chunk_strcat(tmp,
Willy Tarreau0b1b8302021-05-09 20:59:23 +0200279 " help [<command>] : list matching or all commands\n"
Willy Tarreaub205bfd2021-05-07 11:38:37 +0200280 " prompt : toggle interactive mode with prompt\n"
281 " quit : disconnect\n");
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100282
William Lallemand74c24fb2016-11-21 17:18:36 +0100283 chunk_init(&out, NULL, 0);
284 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200285 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200286
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100287 appctx->ctx.cli.severity = LOG_INFO;
288 appctx->ctx.cli.msg = dynamic_usage_msg;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200289 appctx->st0 = CLI_ST_PRINT;
290
William Lallemand74c24fb2016-11-21 17:18:36 +0100291 return dynamic_usage_msg;
292}
293
294struct cli_kw* cli_find_kw(char **args)
295{
296 struct cli_kw_list *kw_list;
297 struct cli_kw *kw;/* current cli_kw */
298 char **tmp_args;
299 const char **tmp_str_kw;
300 int found = 0;
301
302 if (LIST_ISEMPTY(&cli_keywords.list))
303 return NULL;
304
305 list_for_each_entry(kw_list, &cli_keywords.list, list) {
306 kw = &kw_list->kw[0];
307 while (*kw->str_kw) {
308 tmp_args = args;
309 tmp_str_kw = kw->str_kw;
310 while (*tmp_str_kw) {
311 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
312 found = 1;
313 } else {
314 found = 0;
315 break;
316 }
317 tmp_args++;
318 tmp_str_kw++;
319 }
320 if (found)
321 return (kw);
322 kw++;
323 }
324 }
325 return NULL;
326}
327
Thierry Fourniera51a1fd2020-11-28 20:10:08 +0100328struct cli_kw* cli_find_kw_exact(char **args)
329{
330 struct cli_kw_list *kw_list;
331 int found = 0;
332 int i;
333 int j;
334
335 if (LIST_ISEMPTY(&cli_keywords.list))
336 return NULL;
337
338 list_for_each_entry(kw_list, &cli_keywords.list, list) {
339 for (i = 0; kw_list->kw[i].str_kw[0]; i++) {
340 found = 1;
341 for (j = 0; j < CLI_PREFIX_KW_NB; j++) {
342 if (args[j] == NULL && kw_list->kw[i].str_kw[j] == NULL) {
343 break;
344 }
345 if (args[j] == NULL || kw_list->kw[i].str_kw[j] == NULL) {
346 found = 0;
347 break;
348 }
349 if (strcmp(args[j], kw_list->kw[i].str_kw[j]) != 0) {
350 found = 0;
351 break;
352 }
353 }
354 if (found)
355 return &kw_list->kw[i];
356 }
357 }
358 return NULL;
359}
360
William Lallemand74c24fb2016-11-21 17:18:36 +0100361void cli_register_kw(struct cli_kw_list *kw_list)
362{
Willy Tarreau2b718102021-04-21 07:32:39 +0200363 LIST_APPEND(&cli_keywords.list, &kw_list->list);
William Lallemand74c24fb2016-11-21 17:18:36 +0100364}
365
366
367/* allocate a new stats frontend named <name>, and return it
368 * (or NULL in case of lack of memory).
369 */
Willy Tarreau4975d142021-03-13 11:00:33 +0100370static struct proxy *cli_alloc_fe(const char *name, const char *file, int line)
William Lallemand74c24fb2016-11-21 17:18:36 +0100371{
372 struct proxy *fe;
373
374 fe = calloc(1, sizeof(*fe));
375 if (!fe)
376 return NULL;
377
378 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100379 fe->next = proxies_list;
380 proxies_list = fe;
William Lallemand74c24fb2016-11-21 17:18:36 +0100381 fe->last_change = now.tv_sec;
382 fe->id = strdup("GLOBAL");
383 fe->cap = PR_CAP_FE;
384 fe->maxconn = 10; /* default to 10 concurrent connections */
385 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
386 fe->conf.file = strdup(file);
387 fe->conf.line = line;
388 fe->accept = frontend_accept;
389 fe->default_target = &cli_applet.obj_type;
390
391 /* the stats frontend is the only one able to assign ID #0 */
392 fe->conf.id.key = fe->uuid = 0;
393 eb32_insert(&used_proxy_id, &fe->conf.id);
394 return fe;
395}
396
397/* This function parses a "stats" statement in the "global" section. It returns
398 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
399 * error message into the <err> buffer which will be preallocated. The trailing
400 * '\n' must not be written. The function must be called with <args> pointing to
401 * the first word after "stats".
402 */
Willy Tarreau4975d142021-03-13 11:00:33 +0100403static int cli_parse_global(char **args, int section_type, struct proxy *curpx,
404 const struct proxy *defpx, const char *file, int line,
405 char **err)
William Lallemand74c24fb2016-11-21 17:18:36 +0100406{
407 struct bind_conf *bind_conf;
408 struct listener *l;
409
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100410 if (strcmp(args[1], "socket") == 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100411 int cur_arg;
412
413 if (*args[2] == 0) {
414 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
415 return -1;
416 }
417
Willy Tarreau4975d142021-03-13 11:00:33 +0100418 if (!global.cli_fe) {
419 if ((global.cli_fe = cli_alloc_fe("GLOBAL", file, line)) == NULL) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100420 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
421 return -1;
422 }
423 }
424
Willy Tarreau4975d142021-03-13 11:00:33 +0100425 bind_conf = bind_conf_alloc(global.cli_fe, file, line, args[2], xprt_get(XPRT_RAW));
Christopher Faulet0c6d1dc2021-04-12 16:56:37 +0200426 if (!bind_conf) {
427 memprintf(err, "'%s %s' : out of memory trying to allocate a bind_conf", args[0], args[1]);
428 return -1;
429 }
William Lallemand07a62f72017-05-24 00:57:40 +0200430 bind_conf->level &= ~ACCESS_LVL_MASK;
431 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100432
Willy Tarreau4975d142021-03-13 11:00:33 +0100433 if (!str2listener(args[2], global.cli_fe, bind_conf, file, line, err)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100434 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
435 file, line, args[0], args[1], err && *err ? *err : "error");
436 return -1;
437 }
438
439 cur_arg = 3;
440 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100441 struct bind_kw *kw;
Willy Tarreau433b05f2021-03-12 10:14:07 +0100442 const char *best;
William Lallemand74c24fb2016-11-21 17:18:36 +0100443
444 kw = bind_find_kw(args[cur_arg]);
445 if (kw) {
446 if (!kw->parse) {
447 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
448 args[0], args[1], args[cur_arg]);
449 return -1;
450 }
451
Willy Tarreau4975d142021-03-13 11:00:33 +0100452 if (kw->parse(args, cur_arg, global.cli_fe, bind_conf, err) != 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100453 if (err && *err)
454 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
455 else
456 memprintf(err, "'%s %s' : error encountered while processing '%s'",
457 args[0], args[1], args[cur_arg]);
458 return -1;
459 }
460
461 cur_arg += 1 + kw->skip;
462 continue;
463 }
464
Willy Tarreau433b05f2021-03-12 10:14:07 +0100465 best = bind_find_best_kw(args[cur_arg]);
466 if (best)
467 memprintf(err, "'%s %s' : unknown keyword '%s'. Did you mean '%s' maybe ?",
468 args[0], args[1], args[cur_arg], best);
469 else
470 memprintf(err, "'%s %s' : unknown keyword '%s'.",
471 args[0], args[1], args[cur_arg]);
William Lallemand74c24fb2016-11-21 17:18:36 +0100472 return -1;
473 }
474
475 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100476 l->accept = session_accept_fd;
Willy Tarreau4975d142021-03-13 11:00:33 +0100477 l->default_target = global.cli_fe->default_target;
William Lallemand74c24fb2016-11-21 17:18:36 +0100478 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
479 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100480 global.maxsock++; /* for the listening socket */
William Lallemand74c24fb2016-11-21 17:18:36 +0100481 }
482 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100483 else if (strcmp(args[1], "timeout") == 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100484 unsigned timeout;
485 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
486
Willy Tarreau9faebe32019-06-07 19:00:37 +0200487 if (res == PARSE_TIME_OVER) {
488 memprintf(err, "timer overflow in argument '%s' to '%s %s' (maximum value is 2147483647 ms or ~24.8 days)",
489 args[2], args[0], args[1]);
490 return -1;
491 }
492 else if (res == PARSE_TIME_UNDER) {
493 memprintf(err, "timer underflow in argument '%s' to '%s %s' (minimum non-null value is 1 ms)",
494 args[2], args[0], args[1]);
495 return -1;
496 }
497 else if (res) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100498 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
499 return -1;
500 }
501
502 if (!timeout) {
503 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
504 return -1;
505 }
Willy Tarreau4975d142021-03-13 11:00:33 +0100506 if (!global.cli_fe) {
507 if ((global.cli_fe = cli_alloc_fe("GLOBAL", file, line)) == NULL) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100508 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
509 return -1;
510 }
511 }
Willy Tarreau4975d142021-03-13 11:00:33 +0100512 global.cli_fe->timeout.client = MS_TO_TICKS(timeout);
William Lallemand74c24fb2016-11-21 17:18:36 +0100513 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100514 else if (strcmp(args[1], "maxconn") == 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100515 int maxconn = atol(args[2]);
516
517 if (maxconn <= 0) {
518 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
519 return -1;
520 }
521
Willy Tarreau4975d142021-03-13 11:00:33 +0100522 if (!global.cli_fe) {
523 if ((global.cli_fe = cli_alloc_fe("GLOBAL", file, line)) == NULL) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100524 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
525 return -1;
526 }
527 }
Willy Tarreau4975d142021-03-13 11:00:33 +0100528 global.cli_fe->maxconn = maxconn;
William Lallemand74c24fb2016-11-21 17:18:36 +0100529 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100530 else if (strcmp(args[1], "bind-process") == 0) { /* enable the socket only on some processes */
William Lallemand74c24fb2016-11-21 17:18:36 +0100531 int cur_arg = 2;
532 unsigned long set = 0;
533
Willy Tarreau4975d142021-03-13 11:00:33 +0100534 if (!global.cli_fe) {
535 if ((global.cli_fe = cli_alloc_fe("GLOBAL", file, line)) == NULL) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100536 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
537 return -1;
538 }
539 }
540
541 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100542 if (strcmp(args[cur_arg], "all") == 0) {
543 set = 0;
544 break;
545 }
Willy Tarreauff9c9142019-02-07 10:39:36 +0100546 if (parse_process_number(args[cur_arg], &set, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +0100547 memprintf(err, "'%s %s' : %s", args[0], args[1], *err);
William Lallemand74c24fb2016-11-21 17:18:36 +0100548 return -1;
549 }
550 cur_arg++;
551 }
Willy Tarreau4975d142021-03-13 11:00:33 +0100552 global.cli_fe->bind_proc = set;
William Lallemand74c24fb2016-11-21 17:18:36 +0100553 }
554 else {
555 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
556 return -1;
557 }
558 return 0;
559}
560
William Lallemand33d29e22019-04-01 11:30:06 +0200561/*
William Lallemand9a37fd02019-04-12 16:09:24 +0200562 * This function exports the bound addresses of a <frontend> in the environment
563 * variable <varname>. Those addresses are separated by semicolons and prefixed
564 * with their type (abns@, unix@, sockpair@ etc)
565 * Return -1 upon error, 0 otherwise
William Lallemand33d29e22019-04-01 11:30:06 +0200566 */
William Lallemand9a37fd02019-04-12 16:09:24 +0200567int listeners_setenv(struct proxy *frontend, const char *varname)
William Lallemand33d29e22019-04-01 11:30:06 +0200568{
569 struct buffer *trash = get_trash_chunk();
570 struct bind_conf *bind_conf;
571
William Lallemand9a37fd02019-04-12 16:09:24 +0200572 if (frontend) {
573 list_for_each_entry(bind_conf, &frontend->conf.bind, by_fe) {
William Lallemand33d29e22019-04-01 11:30:06 +0200574 struct listener *l;
575
576 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
577 char addr[46];
578 char port[6];
579
William Lallemand620072b2019-04-12 16:09:25 +0200580 /* separate listener by semicolons */
581 if (trash->data)
582 chunk_appendf(trash, ";");
583
Willy Tarreau37159062020-08-27 07:48:42 +0200584 if (l->rx.addr.ss_family == AF_UNIX) {
William Lallemand33d29e22019-04-01 11:30:06 +0200585 const struct sockaddr_un *un;
586
Willy Tarreau37159062020-08-27 07:48:42 +0200587 un = (struct sockaddr_un *)&l->rx.addr;
William Lallemand33d29e22019-04-01 11:30:06 +0200588 if (un->sun_path[0] == '\0') {
589 chunk_appendf(trash, "abns@%s", un->sun_path+1);
590 } else {
591 chunk_appendf(trash, "unix@%s", un->sun_path);
592 }
Willy Tarreau37159062020-08-27 07:48:42 +0200593 } else if (l->rx.addr.ss_family == AF_INET) {
594 addr_to_str(&l->rx.addr, addr, sizeof(addr));
595 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemand33d29e22019-04-01 11:30:06 +0200596 chunk_appendf(trash, "ipv4@%s:%s", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +0200597 } else if (l->rx.addr.ss_family == AF_INET6) {
598 addr_to_str(&l->rx.addr, addr, sizeof(addr));
599 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemand33d29e22019-04-01 11:30:06 +0200600 chunk_appendf(trash, "ipv6@[%s]:%s", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +0200601 } else if (l->rx.addr.ss_family == AF_CUST_SOCKPAIR) {
602 chunk_appendf(trash, "sockpair@%d", ((struct sockaddr_in *)&l->rx.addr)->sin_addr.s_addr);
William Lallemand33d29e22019-04-01 11:30:06 +0200603 }
William Lallemand33d29e22019-04-01 11:30:06 +0200604 }
605 }
606 trash->area[trash->data++] = '\0';
William Lallemand9a37fd02019-04-12 16:09:24 +0200607 if (setenv(varname, trash->area, 1) < 0)
William Lallemand33d29e22019-04-01 11:30:06 +0200608 return -1;
609 }
610
611 return 0;
612}
613
William Lallemand9a37fd02019-04-12 16:09:24 +0200614int cli_socket_setenv()
615{
Willy Tarreau4975d142021-03-13 11:00:33 +0100616 if (listeners_setenv(global.cli_fe, "HAPROXY_CLI") < 0)
William Lallemand9a37fd02019-04-12 16:09:24 +0200617 return -1;
618 if (listeners_setenv(mworker_proxy, "HAPROXY_MASTER_CLI") < 0)
619 return -1;
620
621 return 0;
622}
623
William Lallemand33d29e22019-04-01 11:30:06 +0200624REGISTER_CONFIG_POSTPARSER("cli", cli_socket_setenv);
625
Willy Tarreaude57a572016-11-23 17:01:39 +0100626/* Verifies that the CLI at least has a level at least as high as <level>
627 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
628 * failure, an error message is prepared and the appctx's state is adjusted
629 * to print it so that a return 1 is enough to abort any processing.
630 */
631int cli_has_level(struct appctx *appctx, int level)
632{
Willy Tarreaude57a572016-11-23 17:01:39 +0100633
William Lallemandf630d012018-12-13 09:05:44 +0100634 if ((appctx->cli_level & ACCESS_LVL_MASK) < level) {
Willy Tarreau4975d142021-03-13 11:00:33 +0100635 cli_err(appctx, cli_permission_denied_msg);
Willy Tarreaude57a572016-11-23 17:01:39 +0100636 return 0;
637 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100638 return 1;
639}
640
William Lallemandb7ea1412018-12-13 09:05:47 +0100641/* same as cli_has_level but for the CLI proxy and without error message */
642int pcli_has_level(struct stream *s, int level)
643{
644 if ((s->pcli_flags & ACCESS_LVL_MASK) < level) {
645 return 0;
646 }
647 return 1;
648}
649
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200650/* Returns severity_output for the current session if set, or default for the socket */
651static int cli_get_severity_output(struct appctx *appctx)
652{
653 if (appctx->cli_severity_output)
654 return appctx->cli_severity_output;
655 return strm_li(si_strm(appctx->owner))->bind_conf->severity_output;
656}
William Lallemand74c24fb2016-11-21 17:18:36 +0100657
Willy Tarreau41908562016-11-24 16:23:38 +0100658/* Processes the CLI interpreter on the stats socket. This function is called
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100659 * from the CLI's IO handler running in an appctx context. The function returns
660 * 1 if the request was understood, otherwise zero (in which case an error
661 * message will be displayed). It is called with appctx->st0
Willy Tarreau41908562016-11-24 16:23:38 +0100662 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
663 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
664 * have its own I/O handler called again. Most of the time, parsers will only
665 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100666 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
667 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100668 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200669static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100670{
Willy Tarreauf14c7572021-03-13 10:59:23 +0100671 char *args[MAX_CLI_ARGS + 1], *p, *end, *payload = NULL;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200672 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100673 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100674
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200675 appctx->st2 = 0;
676 memset(&appctx->ctx.cli, 0, sizeof(appctx->ctx.cli));
William Lallemand74c24fb2016-11-21 17:18:36 +0100677
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200678 p = appctx->chunk->area;
679 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100680
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200681 /*
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200682 * Get pointers on words.
683 * One extra slot is reserved to store a pointer on a null byte.
684 */
Willy Tarreauf14c7572021-03-13 10:59:23 +0100685 while (i < MAX_CLI_ARGS && p < end) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200686 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100687
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200688 /* skip leading spaces/tabs */
689 p += strspn(p, " \t");
690 if (!*p)
691 break;
Willy Tarreauc5c170a2021-09-17 11:07:45 +0200692
693 if (strcmp(p, PAYLOAD_PATTERN) == 0) {
694 /* payload pattern recognized here, this is not an arg anymore,
695 * the payload starts at the first byte that follows the zero
696 * after the pattern.
697 */
698 payload = p + strlen(PAYLOAD_PATTERN) + 1;
699 break;
700 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100701
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200702 args[i] = p;
Yves Lafonb08c6d02020-06-08 16:08:06 +0200703 while (1) {
704 p += strcspn(p, " \t\\");
705 /* escaped chars using backlashes (\) */
706 if (*p == '\\') {
707 if (!*++p)
708 break;
709 if (!*++p)
710 break;
711 } else {
712 break;
713 }
714 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200715 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100716
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200717 /* unescape backslashes (\) */
718 for (j = 0, k = 0; args[i][k]; k++) {
719 if (args[i][k] == '\\') {
720 if (args[i][k + 1] == '\\')
721 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100722 else
723 continue;
724 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200725 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100726 j++;
727 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200728 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100729
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200730 i++;
731 }
732 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200733 p = appctx->chunk->area + appctx->chunk->data;
Willy Tarreauf14c7572021-03-13 10:59:23 +0100734 for (; i < MAX_CLI_ARGS + 1; i++)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200735 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100736
737 kw = cli_find_kw(args);
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100738 if (!kw ||
739 (kw->level & ~appctx->cli_level & ACCESS_MASTER_ONLY) ||
740 (appctx->cli_level & ~kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)) == (ACCESS_MASTER_ONLY|ACCESS_MASTER)) {
741 /* keyword not found in this mode */
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100742 cli_gen_usage_msg(appctx, args);
Willy Tarreau41908562016-11-24 16:23:38 +0100743 return 0;
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100744 }
William Lallemand14721be2018-10-26 14:47:37 +0200745
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100746 /* don't handle expert mode commands if not in this mode. */
747 if (kw->level & ~appctx->cli_level & ACCESS_EXPERT) {
748 cli_err(appctx, "This command is restricted to expert mode only.\n");
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200749 return 0;
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100750 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200751
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100752 if (kw->level & ~appctx->cli_level & ACCESS_EXPERIMENTAL) {
753 cli_err(appctx, "This command is restricted to experimental mode only.\n");
754 return 0;
755 }
756
Amaury Denoyellef4929922021-05-05 16:29:23 +0200757 if (kw->level == ACCESS_EXPERT)
758 mark_tainted(TAINTED_CLI_EXPERT_MODE);
759 else if (kw->level == ACCESS_EXPERIMENTAL)
760 mark_tainted(TAINTED_CLI_EXPERIMENTAL_MODE);
761
Willy Tarreau41908562016-11-24 16:23:38 +0100762 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200763 appctx->io_release = kw->io_release;
William Lallemand90b098c2019-10-25 21:10:14 +0200764
765 if (kw->parse && kw->parse(args, payload, appctx, kw->private) != 0)
766 goto fail;
767
768 /* kw->parse could set its own io_handler or io_release handler */
769 if (!appctx->io_handler)
770 goto fail;
771
772 appctx->st0 = CLI_ST_CALLBACK;
773 return 1;
774fail:
775 appctx->io_handler = NULL;
776 appctx->io_release = NULL;
Willy Tarreau41908562016-11-24 16:23:38 +0100777 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100778}
779
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200780/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
781static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
782{
Willy Tarreau83061a82018-07-13 11:56:34 +0200783 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200784
785 if (likely(severity_output == CLI_SEVERITY_NONE))
Willy Tarreau06d80a92017-10-19 14:32:15 +0200786 return ci_putblk(chn, msg, strlen(msg));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200787
788 tmp = get_trash_chunk();
789 chunk_reset(tmp);
790
791 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100792 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200793 chunk_printf(tmp, "[%d]: ", severity);
794 }
795 else {
796 switch (severity_output) {
797 case CLI_SEVERITY_NUMBER:
798 chunk_printf(tmp, "[%d]: ", severity);
799 break;
800 case CLI_SEVERITY_STRING:
801 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
802 break;
803 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100804 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200805 }
806 }
807 chunk_appendf(tmp, "%s", msg);
808
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200809 return ci_putblk(chn, tmp->area, strlen(tmp->area));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200810}
811
William Lallemand74c24fb2016-11-21 17:18:36 +0100812/* This I/O handler runs as an applet embedded in a stream interface. It is
813 * used to processes I/O from/to the stats unix socket. The system relies on a
814 * state machine handling requests and various responses. We read a request,
815 * then we process it and send the response, and we possibly display a prompt.
816 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100817 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100818 * or not.
819 */
820static void cli_io_handler(struct appctx *appctx)
821{
822 struct stream_interface *si = appctx->owner;
823 struct channel *req = si_oc(si);
824 struct channel *res = si_ic(si);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200825 struct bind_conf *bind_conf = strm_li(si_strm(si))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100826 int reql;
827 int len;
828
829 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
830 goto out;
831
Joseph Herlant008b3ce2018-11-25 12:51:45 -0800832 /* Check if the input buffer is available. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200833 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +0100834 /* buf.size==0 means we failed to get a buffer and were
835 * already subscribed to a wait list to get a buffer.
836 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100837 goto out;
838 }
839
William Lallemand74c24fb2016-11-21 17:18:36 +0100840 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100841 if (appctx->st0 == CLI_ST_INIT) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100842 /* Stats output not initialized yet */
843 memset(&appctx->ctx.stats, 0, sizeof(appctx->ctx.stats));
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200844 /* reset severity to default at init */
845 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100846 appctx->st0 = CLI_ST_GETREQ;
William Lallemandf630d012018-12-13 09:05:44 +0100847 appctx->cli_level = bind_conf->level;
William Lallemand74c24fb2016-11-21 17:18:36 +0100848 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100849 else if (appctx->st0 == CLI_ST_END) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100850 /* Let's close for real now. We just close the request
851 * side, the conditions below will complete if needed.
852 */
853 si_shutw(si);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200854 free_trash_chunk(appctx->chunk);
Willy Tarreau18b2a9d2021-05-04 16:27:45 +0200855 appctx->chunk = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +0100856 break;
857 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100858 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200859 char *str;
860
861 /* use a trash chunk to store received data */
862 if (!appctx->chunk) {
863 appctx->chunk = alloc_trash_chunk();
864 if (!appctx->chunk) {
865 appctx->st0 = CLI_ST_END;
866 continue;
867 }
868 }
869
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200870 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200871
William Lallemand74c24fb2016-11-21 17:18:36 +0100872 /* ensure we have some output room left in the event we
873 * would want to return some info right after parsing.
874 */
875 if (buffer_almost_full(si_ib(si))) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100876 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +0100877 break;
878 }
879
Willy Tarreau02a73302022-01-19 17:23:52 +0100880 /* payload doesn't take escapes nor does it end on semi-colons, so
881 * we use the regular getline. Normal mode however must stop on
882 * LFs and semi-colons that are not prefixed by a backslash. Note
883 * that we reserve one byte at the end to insert a trailing nul byte.
884 */
885
886 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
887 reql = co_getline(si_oc(si), str,
888 appctx->chunk->size - appctx->chunk->data - 1);
889 else
890 reql = co_getdelim(si_oc(si), str,
891 appctx->chunk->size - appctx->chunk->data - 1,
892 "\n;", '\\');
893
William Lallemand74c24fb2016-11-21 17:18:36 +0100894 if (reql <= 0) { /* closed or EOL not found */
895 if (reql == 0)
896 break;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100897 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100898 continue;
899 }
900
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200901 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
902 /* seek for a possible unescaped semi-colon. If we find
903 * one, we replace it with an LF and skip only this part.
904 */
905 for (len = 0; len < reql; len++) {
906 if (str[len] == '\\') {
907 len++;
908 continue;
909 }
910 if (str[len] == ';') {
911 str[len] = '\n';
912 reql = len + 1;
913 break;
914 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100915 }
916 }
917
918 /* now it is time to check that we have a full line,
919 * remove the trailing \n and possibly \r, then cut the
920 * line.
921 */
922 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200923 if (str[len] != '\n') {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100924 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100925 continue;
926 }
927
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200928 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100929 len--;
930
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200931 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200932 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200933
934 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200935 appctx->chunk->area[appctx->chunk->data] = '\n';
936 appctx->chunk->area[appctx->chunk->data + 1] = 0;
937 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200938 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100939
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100940 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200941
942 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
943 /* empty line */
944 if (!len) {
945 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200946 appctx->chunk->data -= 2;
947 appctx->chunk->area[appctx->chunk->data] = 0;
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100948 cli_parse_request(appctx);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200949 chunk_reset(appctx->chunk);
950 /* NB: cli_sock_parse_request() may have put
951 * another CLI_ST_O_* into appctx->st0.
952 */
953
954 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +0100955 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100956 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200957 else {
958 /*
959 * Look for the "payload start" pattern at the end of a line
960 * Its location is not remembered here, this is just to switch
961 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +0100962 */
Willy Tarreauc5c170a2021-09-17 11:07:45 +0200963 if (strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN) == 0) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200964 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Willy Tarreauc5c170a2021-09-17 11:07:45 +0200965 appctx->chunk->data++; // keep the trailing \0 after '<<'
966 }
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200967 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200968 /* no payload, the command is complete: parse the request */
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100969 cli_parse_request(appctx);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200970 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200971 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100972 }
973
974 /* re-adjust req buffer */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200975 co_skip(si_oc(si), reql);
William Lallemand74c24fb2016-11-21 17:18:36 +0100976 req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
977 }
978 else { /* output functions */
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200979 const char *msg;
980 int sev;
981
William Lallemand74c24fb2016-11-21 17:18:36 +0100982 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100983 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +0100984 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +0200985 case CLI_ST_PRINT: /* print const message in msg */
986 case CLI_ST_PRINT_ERR: /* print const error in msg */
987 case CLI_ST_PRINT_DYN: /* print dyn message in msg, free */
988 case CLI_ST_PRINT_FREE: /* print dyn error in err, free */
989 if (appctx->st0 == CLI_ST_PRINT || appctx->st0 == CLI_ST_PRINT_ERR) {
990 sev = appctx->st0 == CLI_ST_PRINT_ERR ?
991 LOG_ERR : appctx->ctx.cli.severity;
992 msg = appctx->ctx.cli.msg;
993 }
994 else if (appctx->st0 == CLI_ST_PRINT_DYN || appctx->st0 == CLI_ST_PRINT_FREE) {
995 sev = appctx->st0 == CLI_ST_PRINT_FREE ?
996 LOG_ERR : appctx->ctx.cli.severity;
997 msg = appctx->ctx.cli.err;
998 if (!msg) {
999 sev = LOG_ERR;
1000 msg = "Out of memory.\n";
1001 }
1002 }
1003 else {
1004 sev = LOG_ERR;
1005 msg = "Internal error.\n";
1006 }
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +02001007
Willy Tarreaud50c7fe2019-08-09 09:57:36 +02001008 if (cli_output_msg(res, msg, sev, cli_get_severity_output(appctx)) != -1) {
1009 if (appctx->st0 == CLI_ST_PRINT_FREE ||
1010 appctx->st0 == CLI_ST_PRINT_DYN) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01001011 ha_free(&appctx->ctx.cli.err);
Willy Tarreaud50c7fe2019-08-09 09:57:36 +02001012 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001013 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +01001014 }
1015 else
Willy Tarreaudb398432018-11-15 11:08:52 +01001016 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +01001017 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +02001018
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001019 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +01001020 if (appctx->io_handler)
1021 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001022 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +01001023 if (appctx->io_release) {
1024 appctx->io_release(appctx);
1025 appctx->io_release = NULL;
1026 }
1027 }
1028 break;
1029 default: /* abnormal state */
1030 si->flags |= SI_FL_ERR;
1031 break;
1032 }
1033
1034 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001035 if (appctx->st0 == CLI_ST_PROMPT) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001036 const char *prompt = "";
1037
1038 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
1039 /*
1040 * when entering a payload with interactive mode, change the prompt
1041 * to emphasize that more data can still be sent
1042 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001043 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001044 prompt = "+ ";
1045 else
1046 prompt = "\n> ";
1047 }
1048 else {
William Lallemandad032882019-07-01 10:56:15 +02001049 if (!(appctx->st1 & (APPCTX_CLI_ST1_PAYLOAD|APPCTX_CLI_ST1_NOLF)))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001050 prompt = "\n";
1051 }
1052
1053 if (ci_putstr(si_ic(si), prompt) != -1)
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001054 appctx->st0 = CLI_ST_GETREQ;
William Lallemand74c24fb2016-11-21 17:18:36 +01001055 else
Willy Tarreaudb398432018-11-15 11:08:52 +01001056 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +01001057 }
1058
1059 /* If the output functions are still there, it means they require more room. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001060 if (appctx->st0 >= CLI_ST_OUTPUT)
William Lallemand74c24fb2016-11-21 17:18:36 +01001061 break;
1062
1063 /* Now we close the output if one of the writers did so,
1064 * or if we're not in interactive mode and the request
1065 * buffer is empty. This still allows pipelined requests
1066 * to be sent in non-interactive mode.
1067 */
William Lallemand3de09d52018-12-11 16:10:56 +01001068 if (((res->flags & (CF_SHUTW|CF_SHUTW_NOW))) ||
1069 (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req) && (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)))) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001070 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +01001071 continue;
1072 }
1073
1074 /* switch state back to GETREQ to read next requests */
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001075 appctx->st0 = CLI_ST_GETREQ;
William Lallemandad032882019-07-01 10:56:15 +02001076 /* reactivate the \n at the end of the response for the next command */
1077 appctx->st1 &= ~APPCTX_CLI_ST1_NOLF;
Willy Tarreaua767d352022-01-19 17:11:36 +01001078
1079 /* this forces us to yield between pipelined commands and
1080 * avoid extremely long latencies (e.g. "del map" etc). In
1081 * addition this increases the likelihood that the stream
1082 * refills the buffer with new bytes in non-interactive
1083 * mode, avoiding to close on apparently empty commands.
1084 */
1085 if (co_data(si_oc(si))) {
1086 appctx_wakeup(appctx);
1087 goto out;
1088 }
William Lallemand74c24fb2016-11-21 17:18:36 +01001089 }
1090 }
1091
1092 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST)) {
1093 DPRINTF(stderr, "%s@%d: si to buf closed. req=%08x, res=%08x, st=%d\n",
1094 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
1095 /* Other side has closed, let's abort if we have no more processing to do
1096 * and nothing more to consume. This is comparable to a broken pipe, so
1097 * we forward the close to the request side so that it flows upstream to
1098 * the client.
1099 */
1100 si_shutw(si);
1101 }
1102
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001103 if ((req->flags & CF_SHUTW) && (si->state == SI_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
William Lallemand74c24fb2016-11-21 17:18:36 +01001104 DPRINTF(stderr, "%s@%d: buf to si closed. req=%08x, res=%08x, st=%d\n",
1105 __FUNCTION__, __LINE__, req->flags, res->flags, si->state);
1106 /* We have no more processing to do, and nothing more to send, and
1107 * the client side has closed. So we'll forward this state downstream
1108 * on the response buffer.
1109 */
1110 si_shutr(si);
1111 res->flags |= CF_READ_NULL;
1112 }
1113
1114 out:
Christopher Faulet45073512018-07-20 10:16:29 +02001115 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 +01001116 __FUNCTION__, __LINE__,
Christopher Faulet45073512018-07-20 10:16:29 +02001117 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 +01001118}
1119
William Lallemand74c24fb2016-11-21 17:18:36 +01001120/* This is called when the stream interface is closed. For instance, upon an
1121 * external abort, we won't call the i/o handler anymore so we may need to
1122 * remove back references to the stream currently being dumped.
1123 */
1124static void cli_release_handler(struct appctx *appctx)
1125{
Willy Tarreau18b2a9d2021-05-04 16:27:45 +02001126 free_trash_chunk(appctx->chunk);
1127 appctx->chunk = NULL;
1128
William Lallemand74c24fb2016-11-21 17:18:36 +01001129 if (appctx->io_release) {
1130 appctx->io_release(appctx);
1131 appctx->io_release = NULL;
1132 }
Willy Tarreaud50c7fe2019-08-09 09:57:36 +02001133 else if (appctx->st0 == CLI_ST_PRINT_FREE || appctx->st0 == CLI_ST_PRINT_DYN) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01001134 ha_free(&appctx->ctx.cli.err);
William Lallemand74c24fb2016-11-21 17:18:36 +01001135 }
William Lallemand74c24fb2016-11-21 17:18:36 +01001136}
1137
1138/* This function dumps all environmnent variables to the buffer. It returns 0
1139 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreauf6710f82016-12-16 17:45:44 +01001140 * non-zero. Dumps only one entry if st2 == STAT_ST_END. It uses cli.p0 as the
1141 * pointer to the current variable.
William Lallemand74c24fb2016-11-21 17:18:36 +01001142 */
Willy Tarreau0a739292016-11-22 20:21:23 +01001143static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +01001144{
Willy Tarreau0a739292016-11-22 20:21:23 +01001145 struct stream_interface *si = appctx->owner;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001146 char **var = appctx->ctx.cli.p0;
William Lallemand74c24fb2016-11-21 17:18:36 +01001147
1148 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1149 return 1;
1150
1151 chunk_reset(&trash);
1152
1153 /* we have two inner loops here, one for the proxy, the other one for
1154 * the buffer.
1155 */
Willy Tarreauf6710f82016-12-16 17:45:44 +01001156 while (*var) {
1157 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +01001158
Willy Tarreau06d80a92017-10-19 14:32:15 +02001159 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001160 si_rx_room_blk(si);
William Lallemand74c24fb2016-11-21 17:18:36 +01001161 return 0;
1162 }
1163 if (appctx->st2 == STAT_ST_END)
1164 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001165 var++;
1166 appctx->ctx.cli.p0 = var;
William Lallemand74c24fb2016-11-21 17:18:36 +01001167 }
1168
1169 /* dump complete */
1170 return 1;
1171}
1172
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001173/* This function dumps all file descriptors states (or the requested one) to
1174 * the buffer. It returns 0 if the output buffer is full and it needs to be
1175 * called again, otherwise non-zero. Dumps only one entry if st2 == STAT_ST_END.
1176 * It uses cli.i0 as the fd number to restart from.
1177 */
1178static int cli_io_handler_show_fd(struct appctx *appctx)
1179{
1180 struct stream_interface *si = appctx->owner;
1181 int fd = appctx->ctx.cli.i0;
Willy Tarreauca1b1572018-12-18 15:45:11 +01001182 int ret = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001183
1184 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
Willy Tarreauca1b1572018-12-18 15:45:11 +01001185 goto end;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001186
1187 chunk_reset(&trash);
1188
Willy Tarreauca1b1572018-12-18 15:45:11 +01001189 /* isolate the threads once per round. We're limited to a buffer worth
1190 * of output anyway, it cannot last very long.
1191 */
1192 thread_isolate();
1193
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001194 /* we have two inner loops here, one for the proxy, the other one for
1195 * the buffer.
1196 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +01001197 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001198 struct fdtab fdt;
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001199 const struct listener *li = NULL;
1200 const struct server *sv = NULL;
1201 const struct proxy *px = NULL;
1202 const struct connection *conn = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +02001203 const struct mux_ops *mux = NULL;
Willy Tarreau37be9532021-01-20 14:40:04 +01001204 const struct xprt_ops *xprt = NULL;
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001205 const void *ctx = NULL;
Willy Tarreau37be9532021-01-20 14:40:04 +01001206 const void *xprt_ctx = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +02001207 uint32_t conn_flags = 0;
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001208 int is_back = 0;
Willy Tarreau8050efe2021-01-21 08:26:06 +01001209 int suspicious = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001210
1211 fdt = fdtab[fd];
1212
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001213 /* When DEBUG_FD is set, we also report closed FDs that have a
1214 * non-null event count to detect stuck ones.
1215 */
Willy Tarreau13c1a012020-06-29 14:23:31 +02001216 if (!fdt.owner) {
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001217#ifdef DEBUG_FD
Willy Tarreau13c1a012020-06-29 14:23:31 +02001218 if (!fdt.event_count)
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001219#endif
Willy Tarreau13c1a012020-06-29 14:23:31 +02001220 goto skip; // closed
1221 }
Willy Tarreau586f71b2020-12-11 15:54:36 +01001222 else if (fdt.iocb == sock_conn_iocb) {
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001223 conn = (const struct connection *)fdt.owner;
1224 conn_flags = conn->flags;
1225 mux = conn->mux;
1226 ctx = conn->ctx;
Willy Tarreau37be9532021-01-20 14:40:04 +01001227 xprt = conn->xprt;
1228 xprt_ctx = conn->xprt_ctx;
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001229 li = objt_listener(conn->target);
1230 sv = objt_server(conn->target);
1231 px = objt_proxy(conn->target);
1232 is_back = conn_is_back(conn);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001233 if (atleast2(fdt.thread_mask))
1234 suspicious = 1;
1235 if (conn->handle.fd != fd)
1236 suspicious = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001237 }
Willy Tarreaua74cb382020-10-15 21:29:49 +02001238 else if (fdt.iocb == sock_accept_iocb)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001239 li = fdt.owner;
1240
Willy Tarreaudacfde42021-01-21 09:07:29 +01001241 if (!fdt.thread_mask)
1242 suspicious = 1;
1243
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001244 chunk_printf(&trash,
Willy Tarreau184b2122021-04-07 08:48:12 +02001245 " %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 +02001246 fd,
1247 fdt.state,
Willy Tarreau184b2122021-04-07 08:48:12 +02001248 (fdt.state & FD_CLONED) ? 'C' : 'c',
1249 (fdt.state & FD_LINGER_RISK) ? 'L' : 'l',
Willy Tarreauf5090652021-04-06 17:23:40 +02001250 (fdt.state & FD_POLL_HUP) ? 'H' : 'h',
1251 (fdt.state & FD_POLL_ERR) ? 'E' : 'e',
1252 (fdt.state & FD_POLL_OUT) ? 'O' : 'o',
1253 (fdt.state & FD_POLL_PRI) ? 'P' : 'p',
1254 (fdt.state & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau184b2122021-04-07 08:48:12 +02001255 (fdt.state & FD_EV_SHUT_W) ? 'S' : 's',
1256 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
1257 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
1258 (fdt.state & FD_EV_SHUT_R) ? 'S' : 's',
1259 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
1260 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
Willy Tarreauc754b342018-03-30 15:00:15 +02001261 fdt.thread_mask, fdt.update_mask,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001262 fdt.owner,
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001263 fdt.iocb);
1264 resolve_sym_name(&trash, NULL, fdt.iocb);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001265
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001266 if (!fdt.owner) {
1267 chunk_appendf(&trash, ")");
1268 }
Willy Tarreau586f71b2020-12-11 15:54:36 +01001269 else if (fdt.iocb == sock_conn_iocb) {
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001270 chunk_appendf(&trash, ") back=%d cflg=0x%08x", is_back, conn_flags);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001271
1272 if (conn->handle.fd != fd) {
1273 chunk_appendf(&trash, " fd=%d(BOGUS)", conn->handle.fd);
1274 suspicious = 1;
Willy Tarreaued989202021-02-05 10:54:52 +01001275 } else {
1276 struct sockaddr_storage sa;
1277 socklen_t salen;
1278
1279 salen = sizeof(sa);
1280 if (getsockname(fd, (struct sockaddr *)&sa, &salen) != -1) {
1281 if (sa.ss_family == AF_INET)
1282 chunk_appendf(&trash, " fam=ipv4 lport=%d", ntohs(((const struct sockaddr_in *)&sa)->sin_port));
1283 else if (sa.ss_family == AF_INET6)
1284 chunk_appendf(&trash, " fam=ipv6 lport=%d", ntohs(((const struct sockaddr_in6 *)&sa)->sin6_port));
1285 else if (sa.ss_family == AF_UNIX)
1286 chunk_appendf(&trash, " fam=unix");
1287 }
1288
1289 salen = sizeof(sa);
1290 if (getpeername(fd, (struct sockaddr *)&sa, &salen) != -1) {
1291 if (sa.ss_family == AF_INET)
1292 chunk_appendf(&trash, " rport=%d", ntohs(((const struct sockaddr_in *)&sa)->sin_port));
1293 else if (sa.ss_family == AF_INET6)
1294 chunk_appendf(&trash, " rport=%d", ntohs(((const struct sockaddr_in6 *)&sa)->sin6_port));
1295 }
Willy Tarreaudacfde42021-01-21 09:07:29 +01001296 }
1297
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001298 if (px)
1299 chunk_appendf(&trash, " px=%s", px->id);
1300 else if (sv)
Willy Tarreauab407922021-07-06 11:41:10 +02001301 chunk_appendf(&trash, " sv=%s/%s", sv->proxy->id, sv->id);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001302 else if (li)
1303 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +02001304
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001305 if (mux) {
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001306 chunk_appendf(&trash, " mux=%s ctx=%p", mux->name, ctx);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001307 if (!ctx)
1308 suspicious = 1;
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001309 if (mux->show_fd)
Willy Tarreau8050efe2021-01-21 08:26:06 +01001310 suspicious |= mux->show_fd(&trash, fdt.owner);
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001311 }
Willy Tarreau35b1b482018-03-28 18:41:30 +02001312 else
1313 chunk_appendf(&trash, " nomux");
Willy Tarreau37be9532021-01-20 14:40:04 +01001314
1315 chunk_appendf(&trash, " xprt=%s", xprt ? xprt->name : "");
Willy Tarreau108a2712021-01-20 15:30:56 +01001316 if (xprt) {
1317 if (xprt_ctx || xprt->show_fd)
1318 chunk_appendf(&trash, " xprt_ctx=%p", xprt_ctx);
1319 if (xprt->show_fd)
Willy Tarreau8050efe2021-01-21 08:26:06 +01001320 suspicious |= xprt->show_fd(&trash, conn, xprt_ctx);
Willy Tarreau108a2712021-01-20 15:30:56 +01001321 }
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001322 }
Willy Tarreaua74cb382020-10-15 21:29:49 +02001323 else if (fdt.iocb == sock_accept_iocb) {
Willy Tarreaued989202021-02-05 10:54:52 +01001324 struct sockaddr_storage sa;
1325 socklen_t salen;
1326
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001327 chunk_appendf(&trash, ") l.st=%s fe=%s",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001328 listener_state_str(li),
1329 li->bind_conf->frontend->id);
Willy Tarreaued989202021-02-05 10:54:52 +01001330
1331 salen = sizeof(sa);
1332 if (getsockname(fd, (struct sockaddr *)&sa, &salen) != -1) {
1333 if (sa.ss_family == AF_INET)
1334 chunk_appendf(&trash, " fam=ipv4 lport=%d", ntohs(((const struct sockaddr_in *)&sa)->sin_port));
1335 else if (sa.ss_family == AF_INET6)
1336 chunk_appendf(&trash, " fam=ipv6 lport=%d", ntohs(((const struct sockaddr_in6 *)&sa)->sin6_port));
1337 else if (sa.ss_family == AF_UNIX)
1338 chunk_appendf(&trash, " fam=unix");
1339 }
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001340 }
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001341 else
1342 chunk_appendf(&trash, ")");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001343
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001344#ifdef DEBUG_FD
1345 chunk_appendf(&trash, " evcnt=%u", fdtab[fd].event_count);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001346 if (fdtab[fd].event_count >= 1000000)
1347 suspicious = 1;
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001348#endif
Willy Tarreau8050efe2021-01-21 08:26:06 +01001349 chunk_appendf(&trash, "%s\n", suspicious ? " !" : "");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001350
Willy Tarreau06d80a92017-10-19 14:32:15 +02001351 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001352 si_rx_room_blk(si);
Willy Tarreauca1b1572018-12-18 15:45:11 +01001353 appctx->ctx.cli.i0 = fd;
1354 ret = 0;
1355 break;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001356 }
1357 skip:
1358 if (appctx->st2 == STAT_ST_END)
1359 break;
1360
1361 fd++;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001362 }
1363
Willy Tarreauca1b1572018-12-18 15:45:11 +01001364 end:
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001365 /* dump complete */
Willy Tarreauca1b1572018-12-18 15:45:11 +01001366
1367 thread_release();
1368 return ret;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001369}
1370
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001371/* This function dumps some activity counters used by developers and support to
1372 * rule out some hypothesis during bug reports. It returns 0 if the output
1373 * buffer is full and it needs to be called again, otherwise non-zero. It dumps
1374 * everything at once in the buffer and is not designed to do it in multiple
1375 * passes.
1376 */
1377static int cli_io_handler_show_activity(struct appctx *appctx)
1378{
1379 struct stream_interface *si = appctx->owner;
1380 int thr;
1381
1382 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
1383 return 1;
1384
1385 chunk_reset(&trash);
1386
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001387#undef SHOW_TOT
1388#define SHOW_TOT(t, x) \
Willy Tarreaua0211b82019-05-28 15:09:08 +02001389 do { \
1390 unsigned int _v[MAX_THREADS]; \
1391 unsigned int _tot; \
1392 const unsigned int _nbt = global.nbthread; \
Willy Tarreaub9aac362021-11-20 19:17:38 +01001393 _tot = t = 0; \
1394 do { \
Willy Tarreaua0211b82019-05-28 15:09:08 +02001395 _tot += _v[t] = (x); \
Willy Tarreaub9aac362021-11-20 19:17:38 +01001396 } while (++t < _nbt); \
Willy Tarreaua0211b82019-05-28 15:09:08 +02001397 if (_nbt == 1) { \
1398 chunk_appendf(&trash, " %u\n", _tot); \
1399 break; \
1400 } \
1401 chunk_appendf(&trash, " %u [", _tot); \
1402 for (t = 0; t < _nbt; t++) \
1403 chunk_appendf(&trash, " %u", _v[t]); \
1404 chunk_appendf(&trash, " ]\n"); \
1405 } while (0)
1406
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001407#undef SHOW_AVG
1408#define SHOW_AVG(t, x) \
1409 do { \
1410 unsigned int _v[MAX_THREADS]; \
1411 unsigned int _tot; \
1412 const unsigned int _nbt = global.nbthread; \
Willy Tarreaub9aac362021-11-20 19:17:38 +01001413 _tot = t = 0; \
1414 do { \
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001415 _tot += _v[t] = (x); \
Willy Tarreaub9aac362021-11-20 19:17:38 +01001416 } while (++t < _nbt); \
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001417 if (_nbt == 1) { \
1418 chunk_appendf(&trash, " %u\n", _tot); \
1419 break; \
1420 } \
1421 chunk_appendf(&trash, " %u [", (_tot + _nbt/2) / _nbt); \
1422 for (t = 0; t < _nbt; t++) \
1423 chunk_appendf(&trash, " %u", _v[t]); \
1424 chunk_appendf(&trash, " ]\n"); \
1425 } while (0)
1426
Willy Tarreaua0211b82019-05-28 15:09:08 +02001427 chunk_appendf(&trash, "thread_id: %u (%u..%u)\n", tid + 1, 1, global.nbthread);
1428 chunk_appendf(&trash, "date_now: %lu.%06lu\n", (long)now.tv_sec, (long)now.tv_usec);
Willy Tarreaua00cf9b2020-06-17 20:44:28 +02001429 chunk_appendf(&trash, "ctxsw:"); SHOW_TOT(thr, activity[thr].ctxsw);
1430 chunk_appendf(&trash, "tasksw:"); SHOW_TOT(thr, activity[thr].tasksw);
1431 chunk_appendf(&trash, "empty_rq:"); SHOW_TOT(thr, activity[thr].empty_rq);
1432 chunk_appendf(&trash, "long_rq:"); SHOW_TOT(thr, activity[thr].long_rq);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001433 chunk_appendf(&trash, "loops:"); SHOW_TOT(thr, activity[thr].loops);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001434 chunk_appendf(&trash, "wake_tasks:"); SHOW_TOT(thr, activity[thr].wake_tasks);
1435 chunk_appendf(&trash, "wake_signal:"); SHOW_TOT(thr, activity[thr].wake_signal);
Willy Tarreaue5451532020-06-17 20:25:18 +02001436 chunk_appendf(&trash, "poll_io:"); SHOW_TOT(thr, activity[thr].poll_io);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001437 chunk_appendf(&trash, "poll_exp:"); SHOW_TOT(thr, activity[thr].poll_exp);
Willy Tarreaue4063862020-06-17 20:35:33 +02001438 chunk_appendf(&trash, "poll_drop_fd:"); SHOW_TOT(thr, activity[thr].poll_drop_fd);
1439 chunk_appendf(&trash, "poll_dead_fd:"); SHOW_TOT(thr, activity[thr].poll_dead_fd);
1440 chunk_appendf(&trash, "poll_skip_fd:"); SHOW_TOT(thr, activity[thr].poll_skip_fd);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001441 chunk_appendf(&trash, "conn_dead:"); SHOW_TOT(thr, activity[thr].conn_dead);
Willy Tarreau7af4fa92020-06-17 20:49:49 +02001442 chunk_appendf(&trash, "stream_calls:"); SHOW_TOT(thr, activity[thr].stream_calls);
Willy Tarreaua8b2ce02019-05-28 17:04:16 +02001443 chunk_appendf(&trash, "pool_fail:"); SHOW_TOT(thr, activity[thr].pool_fail);
1444 chunk_appendf(&trash, "buf_wait:"); SHOW_TOT(thr, activity[thr].buf_wait);
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001445 chunk_appendf(&trash, "cpust_ms_tot:"); SHOW_TOT(thr, activity[thr].cpust_total / 2);
1446 chunk_appendf(&trash, "cpust_ms_1s:"); SHOW_TOT(thr, read_freq_ctr(&activity[thr].cpust_1s) / 2);
1447 chunk_appendf(&trash, "cpust_ms_15s:"); SHOW_TOT(thr, read_freq_ctr_period(&activity[thr].cpust_15s, 15000) / 2);
1448 chunk_appendf(&trash, "avg_loop_us:"); SHOW_AVG(thr, swrate_avg(activity[thr].avg_loop_us, TIME_STATS_SAMPLES));
1449 chunk_appendf(&trash, "accepted:"); SHOW_TOT(thr, activity[thr].accepted);
1450 chunk_appendf(&trash, "accq_pushed:"); SHOW_TOT(thr, activity[thr].accq_pushed);
1451 chunk_appendf(&trash, "accq_full:"); SHOW_TOT(thr, activity[thr].accq_full);
Willy Tarreaue6182842019-04-15 18:54:10 +02001452#ifdef USE_THREAD
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001453 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 +02001454 chunk_appendf(&trash, "fd_takeover:"); SHOW_TOT(thr, activity[thr].fd_takeover);
Willy Tarreaue6182842019-04-15 18:54:10 +02001455#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001456
Willy Tarreaud6a78502019-05-27 07:03:38 +02001457#if defined(DEBUG_DEV)
1458 /* keep these ones at the end */
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001459 chunk_appendf(&trash, "ctr0:"); SHOW_TOT(thr, activity[thr].ctr0);
1460 chunk_appendf(&trash, "ctr1:"); SHOW_TOT(thr, activity[thr].ctr1);
1461 chunk_appendf(&trash, "ctr2:"); SHOW_TOT(thr, activity[thr].ctr2);
Willy Tarreaud6a78502019-05-27 07:03:38 +02001462#endif
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001463
1464 if (ci_putchk(si_ic(si), &trash) == -1) {
1465 chunk_reset(&trash);
1466 chunk_printf(&trash, "[output too large, cannot dump]\n");
Willy Tarreaudb398432018-11-15 11:08:52 +01001467 si_rx_room_blk(si);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001468 }
1469
Willy Tarreaud78d08f2019-05-28 16:32:06 +02001470#undef SHOW_AVG
1471#undef SHOW_TOT
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001472 /* dump complete */
1473 return 1;
1474}
1475
William Lallemandeceddf72016-12-15 18:06:44 +01001476/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001477 * CLI IO handler for `show cli sockets`.
1478 * Uses ctx.cli.p0 to store the restart pointer.
William Lallemandeceddf72016-12-15 18:06:44 +01001479 */
1480static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1481{
1482 struct bind_conf *bind_conf;
1483 struct stream_interface *si = appctx->owner;
1484
1485 chunk_reset(&trash);
1486
1487 switch (appctx->st2) {
1488 case STAT_ST_INIT:
1489 chunk_printf(&trash, "# socket lvl processes\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +02001490 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001491 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001492 return 0;
1493 }
William Lallemandeceddf72016-12-15 18:06:44 +01001494 appctx->st2 = STAT_ST_LIST;
Tim Duesterhus588b3142020-05-29 14:35:51 +02001495 /* fall through */
William Lallemandeceddf72016-12-15 18:06:44 +01001496
1497 case STAT_ST_LIST:
Willy Tarreau4975d142021-03-13 11:00:33 +01001498 if (global.cli_fe) {
1499 list_for_each_entry(bind_conf, &global.cli_fe->conf.bind, by_fe) {
William Lallemandeceddf72016-12-15 18:06:44 +01001500 struct listener *l;
1501
1502 /*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001503 * get the latest dumped node in appctx->ctx.cli.p0
William Lallemandeceddf72016-12-15 18:06:44 +01001504 * if the current node is the first of the list
1505 */
1506
Willy Tarreau3af9d832016-12-16 12:58:09 +01001507 if (appctx->ctx.cli.p0 &&
Willy Tarreau4975d142021-03-13 11:00:33 +01001508 &bind_conf->by_fe == (&global.cli_fe->conf.bind)->n) {
William Lallemandeceddf72016-12-15 18:06:44 +01001509 /* change the current node to the latest dumped and continue the loop */
Willy Tarreau3af9d832016-12-16 12:58:09 +01001510 bind_conf = LIST_ELEM(appctx->ctx.cli.p0, typeof(bind_conf), by_fe);
William Lallemandeceddf72016-12-15 18:06:44 +01001511 continue;
1512 }
1513
1514 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
1515
1516 char addr[46];
1517 char port[6];
1518
Willy Tarreau37159062020-08-27 07:48:42 +02001519 if (l->rx.addr.ss_family == AF_UNIX) {
William Lallemandeceddf72016-12-15 18:06:44 +01001520 const struct sockaddr_un *un;
1521
Willy Tarreau37159062020-08-27 07:48:42 +02001522 un = (struct sockaddr_un *)&l->rx.addr;
William Lallemande58915f2019-04-01 11:30:05 +02001523 if (un->sun_path[0] == '\0') {
William Lallemand75812a72019-04-01 11:30:04 +02001524 chunk_appendf(&trash, "abns@%s ", un->sun_path+1);
William Lallemande58915f2019-04-01 11:30:05 +02001525 } else {
1526 chunk_appendf(&trash, "unix@%s ", un->sun_path);
1527 }
Willy Tarreau37159062020-08-27 07:48:42 +02001528 } else if (l->rx.addr.ss_family == AF_INET) {
1529 addr_to_str(&l->rx.addr, addr, sizeof(addr));
1530 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001531 chunk_appendf(&trash, "ipv4@%s:%s ", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +02001532 } else if (l->rx.addr.ss_family == AF_INET6) {
1533 addr_to_str(&l->rx.addr, addr, sizeof(addr));
1534 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemande58915f2019-04-01 11:30:05 +02001535 chunk_appendf(&trash, "ipv6@[%s]:%s ", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +02001536 } else if (l->rx.addr.ss_family == AF_CUST_SOCKPAIR) {
1537 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->rx.addr)->sin_addr.s_addr);
William Lallemandeceddf72016-12-15 18:06:44 +01001538 } else
William Lallemand26314342018-10-26 14:47:41 +02001539 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001540
William Lallemand07a62f72017-05-24 00:57:40 +02001541 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
William Lallemandeceddf72016-12-15 18:06:44 +01001542 chunk_appendf(&trash, "admin ");
William Lallemand07a62f72017-05-24 00:57:40 +02001543 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1544 chunk_appendf(&trash, "operator ");
1545 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1546 chunk_appendf(&trash, "user ");
William Lallemandeceddf72016-12-15 18:06:44 +01001547 else
1548 chunk_appendf(&trash, " ");
1549
Willy Tarreaue26993c2020-09-03 07:18:55 +02001550 if (bind_conf->settings.bind_proc != 0) {
William Lallemandeceddf72016-12-15 18:06:44 +01001551 int pos;
Willy Tarreaue26993c2020-09-03 07:18:55 +02001552 for (pos = 0; pos < 8 * sizeof(bind_conf->settings.bind_proc); pos++) {
1553 if (bind_conf->settings.bind_proc & (1UL << pos)) {
William Lallemandeceddf72016-12-15 18:06:44 +01001554 chunk_appendf(&trash, "%d,", pos+1);
1555 }
1556 }
1557 /* replace the latest comma by a newline */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001558 trash.area[trash.data-1] = '\n';
William Lallemandeceddf72016-12-15 18:06:44 +01001559
1560 } else {
1561 chunk_appendf(&trash, "all\n");
1562 }
1563
Willy Tarreau06d80a92017-10-19 14:32:15 +02001564 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001565 si_rx_room_blk(si);
William Lallemandeceddf72016-12-15 18:06:44 +01001566 return 0;
1567 }
1568 }
Willy Tarreau3af9d832016-12-16 12:58:09 +01001569 appctx->ctx.cli.p0 = &bind_conf->by_fe; /* store the latest list node dumped */
William Lallemandeceddf72016-12-15 18:06:44 +01001570 }
1571 }
Tim Duesterhus588b3142020-05-29 14:35:51 +02001572 /* fall through */
William Lallemandeceddf72016-12-15 18:06:44 +01001573 default:
1574 appctx->st2 = STAT_ST_FIN;
1575 return 1;
1576 }
1577}
1578
1579
Willy Tarreau0a739292016-11-22 20:21:23 +01001580/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreauf6710f82016-12-16 17:45:44 +01001581 * wants to stop here. It puts the variable to be dumped into cli.p0 if a single
1582 * variable is requested otherwise puts environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001583 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001584static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001585{
1586 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001587 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001588
1589 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1590 return 1;
1591
Willy Tarreauf6710f82016-12-16 17:45:44 +01001592 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001593
1594 if (*args[2]) {
1595 int len = strlen(args[2]);
1596
Willy Tarreauf6710f82016-12-16 17:45:44 +01001597 for (; *var; var++) {
1598 if (strncmp(*var, args[2], len) == 0 &&
1599 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001600 break;
1601 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001602 if (!*var)
1603 return cli_err(appctx, "Variable not found\n");
1604
Willy Tarreau0a739292016-11-22 20:21:23 +01001605 appctx->st2 = STAT_ST_END;
1606 }
Willy Tarreauf6710f82016-12-16 17:45:44 +01001607 appctx->ctx.cli.p0 = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001608 return 0;
1609}
1610
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001611/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
1612 * wants to stop here. It puts the FD number into cli.i0 if a specific FD is
1613 * requested and sets st2 to STAT_ST_END, otherwise leaves 0 in i0.
1614 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001615static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001616{
1617 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1618 return 1;
1619
1620 appctx->ctx.cli.i0 = 0;
1621
1622 if (*args[2]) {
1623 appctx->ctx.cli.i0 = atoi(args[2]);
1624 appctx->st2 = STAT_ST_END;
1625 }
1626 return 0;
1627}
1628
Willy Tarreau599852e2016-11-22 20:33:32 +01001629/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001630static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001631{
1632 struct stream_interface *si = appctx->owner;
1633 struct stream *s = si_strm(si);
1634
1635 if (strcmp(args[2], "cli") == 0) {
1636 unsigned timeout;
1637 const char *res;
1638
Willy Tarreau9d008692019-08-09 11:21:01 +02001639 if (!*args[3])
1640 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001641
1642 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
Willy Tarreau9d008692019-08-09 11:21:01 +02001643 if (res || timeout < 1)
1644 return cli_err(appctx, "Invalid timeout value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001645
1646 s->req.rto = s->res.wto = 1 + MS_TO_TICKS(timeout*1000);
1647 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1648 return 1;
1649 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001650
1651 return cli_err(appctx, "'set timeout' only supports 'cli'.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001652}
1653
Willy Tarreau2af99412016-11-23 11:10:59 +01001654/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001655static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001656{
1657 int v;
1658
1659 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1660 return 1;
1661
Willy Tarreau9d008692019-08-09 11:21:01 +02001662 if (!*args[3])
1663 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001664
1665 v = atoi(args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001666 if (v > global.hardmaxconn)
1667 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001668
1669 /* check for unlimited values */
1670 if (v <= 0)
1671 v = global.hardmaxconn;
1672
1673 global.maxconn = v;
1674
1675 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001676 dequeue_all_listeners();
Willy Tarreau2af99412016-11-23 11:10:59 +01001677
1678 return 1;
1679}
1680
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001681static int set_severity_output(int *target, char *argument)
1682{
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001683 if (strcmp(argument, "none") == 0) {
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001684 *target = CLI_SEVERITY_NONE;
1685 return 1;
1686 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001687 else if (strcmp(argument, "number") == 0) {
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001688 *target = CLI_SEVERITY_NUMBER;
1689 return 1;
1690 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001691 else if (strcmp(argument, "string") == 0) {
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001692 *target = CLI_SEVERITY_STRING;
1693 return 1;
1694 }
1695 return 0;
1696}
1697
1698/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001699static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001700{
1701 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1702 return 0;
1703
Willy Tarreau9d008692019-08-09 11:21:01 +02001704 return cli_err(appctx, "one of 'none', 'number', 'string' is a required argument\n");
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001705}
William Lallemandeceddf72016-12-15 18:06:44 +01001706
William Lallemand67a234f2018-12-13 09:05:45 +01001707
1708/* show the level of the current CLI session */
1709static int cli_parse_show_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1710{
William Lallemand67a234f2018-12-13 09:05:45 +01001711 if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
Willy Tarreau9d008692019-08-09 11:21:01 +02001712 return cli_msg(appctx, LOG_INFO, "admin\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001713 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001714 return cli_msg(appctx, LOG_INFO, "operator\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001715 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001716 return cli_msg(appctx, LOG_INFO, "user\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001717 else
Willy Tarreau9d008692019-08-09 11:21:01 +02001718 return cli_msg(appctx, LOG_INFO, "unknown\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001719}
1720
1721/* parse and set the CLI level dynamically */
1722static int cli_parse_set_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1723{
William Lallemandad032882019-07-01 10:56:15 +02001724 /* this will ask the applet to not output a \n after the command */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001725 if (strcmp(args[1], "-") == 0)
William Lallemandad032882019-07-01 10:56:15 +02001726 appctx->st1 |= APPCTX_CLI_ST1_NOLF;
1727
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001728 if (strcmp(args[0], "operator") == 0) {
William Lallemand67a234f2018-12-13 09:05:45 +01001729 if (!cli_has_level(appctx, ACCESS_LVL_OPER)) {
1730 return 1;
1731 }
1732 appctx->cli_level &= ~ACCESS_LVL_MASK;
1733 appctx->cli_level |= ACCESS_LVL_OPER;
1734
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001735 } else if (strcmp(args[0], "user") == 0) {
William Lallemand67a234f2018-12-13 09:05:45 +01001736 if (!cli_has_level(appctx, ACCESS_LVL_USER)) {
1737 return 1;
1738 }
1739 appctx->cli_level &= ~ACCESS_LVL_MASK;
1740 appctx->cli_level |= ACCESS_LVL_USER;
1741 }
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001742 appctx->cli_level &= ~(ACCESS_EXPERT|ACCESS_EXPERIMENTAL);
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001743 return 1;
1744}
1745
1746
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001747/* parse and set the CLI expert/experimental-mode dynamically */
1748static int cli_parse_expert_experimental_mode(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001749{
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001750 int level;
1751 char *level_str;
1752 char *output = NULL;
1753
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001754 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1755 return 1;
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001756
1757 if (!strcmp(args[0], "expert-mode")) {
1758 level = ACCESS_EXPERT;
1759 level_str = "expert-mode";
1760 }
1761 else if (!strcmp(args[0], "experimental-mode")) {
1762 level = ACCESS_EXPERIMENTAL;
1763 level_str = "experimental-mode";
1764 }
1765 else {
1766 return 1;
1767 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001768
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001769 if (!*args[1]) {
1770 memprintf(&output, "%s is %s\n", level_str,
1771 (appctx->cli_level & level) ? "ON" : "OFF");
1772 return cli_dynmsg(appctx, LOG_INFO, output);
1773 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001774
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001775 appctx->cli_level &= ~level;
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001776 if (strcmp(args[1], "on") == 0)
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001777 appctx->cli_level |= level;
William Lallemand67a234f2018-12-13 09:05:45 +01001778 return 1;
1779}
1780
William Lallemand7ceae112021-12-14 15:22:29 +01001781/* shows HAProxy version */
1782static int cli_parse_show_version(char **args, char *payload, struct appctx *appctx, void *private)
1783{
1784 char *msg = NULL;
1785
1786 return cli_dynmsg(appctx, LOG_INFO, memprintf(&msg, "%s\n", haproxy_version));
1787}
1788
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001789int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001790{
1791 return 0;
1792}
1793
Willy Tarreau45c742b2016-11-24 14:51:17 +01001794/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001795static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001796{
1797 int v;
1798 int *res;
1799 int mul = 1;
1800
1801 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1802 return 1;
1803
1804 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1805 res = &global.cps_lim;
1806 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1807 res = &global.sps_lim;
1808#ifdef USE_OPENSSL
1809 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1810 res = &global.ssl_lim;
1811#endif
1812 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1813 res = &global.comp_rate_lim;
1814 mul = 1024;
1815 }
1816 else {
Willy Tarreau9d008692019-08-09 11:21:01 +02001817 return cli_err(appctx,
Willy Tarreau45c742b2016-11-24 14:51:17 +01001818 "'set rate-limit' only supports :\n"
1819 " - 'connections global' to set the per-process maximum connection rate\n"
1820 " - 'sessions global' to set the per-process maximum session rate\n"
1821#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001822 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001823#endif
Willy Tarreau9d008692019-08-09 11:21:01 +02001824 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001825 }
1826
Willy Tarreau9d008692019-08-09 11:21:01 +02001827 if (!*args[4])
1828 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001829
1830 v = atoi(args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001831 if (v < 0)
1832 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001833
1834 *res = v * mul;
1835
1836 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001837 dequeue_all_listeners();
Willy Tarreau45c742b2016-11-24 14:51:17 +01001838
1839 return 1;
1840}
1841
William Lallemandf6975e92017-05-26 17:42:10 +02001842/* parse the "expose-fd" argument on the bind lines */
1843static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1844{
1845 if (!*args[cur_arg + 1]) {
1846 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1847 return ERR_ALERT | ERR_FATAL;
1848 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001849 if (strcmp(args[cur_arg + 1], "listeners") == 0) {
William Lallemandf6975e92017-05-26 17:42:10 +02001850 conf->level |= ACCESS_FD_LISTENERS;
1851 } else {
1852 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1853 args[cur_arg], args[cur_arg+1]);
1854 return ERR_ALERT | ERR_FATAL;
1855 }
1856
1857 return 0;
1858}
1859
William Lallemand74c24fb2016-11-21 17:18:36 +01001860/* parse the "level" argument on the bind lines */
1861static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1862{
1863 if (!*args[cur_arg + 1]) {
1864 memprintf(err, "'%s' : missing level", args[cur_arg]);
1865 return ERR_ALERT | ERR_FATAL;
1866 }
1867
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001868 if (strcmp(args[cur_arg + 1], "user") == 0) {
William Lallemand07a62f72017-05-24 00:57:40 +02001869 conf->level &= ~ACCESS_LVL_MASK;
1870 conf->level |= ACCESS_LVL_USER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001871 } else if (strcmp(args[cur_arg + 1], "operator") == 0) {
William Lallemand07a62f72017-05-24 00:57:40 +02001872 conf->level &= ~ACCESS_LVL_MASK;
1873 conf->level |= ACCESS_LVL_OPER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001874 } else if (strcmp(args[cur_arg + 1], "admin") == 0) {
William Lallemand07a62f72017-05-24 00:57:40 +02001875 conf->level &= ~ACCESS_LVL_MASK;
1876 conf->level |= ACCESS_LVL_ADMIN;
1877 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001878 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1879 args[cur_arg], args[cur_arg+1]);
1880 return ERR_ALERT | ERR_FATAL;
1881 }
1882
1883 return 0;
1884}
1885
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001886static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1887{
1888 if (!*args[cur_arg + 1]) {
1889 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
1890 return ERR_ALERT | ERR_FATAL;
1891 }
1892
1893 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
1894 return 0;
1895 else {
1896 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
1897 args[cur_arg], args[cur_arg+1]);
1898 return ERR_ALERT | ERR_FATAL;
1899 }
1900}
1901
Olivier Houchardf886e342017-04-05 22:24:59 +02001902/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001903static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02001904{
1905 char *cmsgbuf = NULL;
1906 unsigned char *tmpbuf = NULL;
1907 struct cmsghdr *cmsg;
1908 struct stream_interface *si = appctx->owner;
William Lallemandf6975e92017-05-26 17:42:10 +02001909 struct stream *s = si_strm(si);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001910 struct connection *remote = cs_conn(objt_cs(si_opposite(si)->end));
Olivier Houchardf886e342017-04-05 22:24:59 +02001911 struct msghdr msghdr;
1912 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02001913 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001914 const char *ns_name, *if_name;
1915 unsigned char ns_nlen, if_nlen;
1916 int nb_queued;
1917 int cur_fd = 0;
Olivier Houchardf886e342017-04-05 22:24:59 +02001918 int *tmpfd;
1919 int tot_fd_nb = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001920 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001921 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001922 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02001923 int ret;
1924
Willy Tarreauc2b7f802018-09-20 11:22:29 +02001925 if (!remote) {
1926 ha_warning("Only works on real connections\n");
1927 goto out;
1928 }
1929
1930 fd = remote->handle.fd;
1931
Olivier Houchardf886e342017-04-05 22:24:59 +02001932 /* Temporary set the FD in blocking mode, that will make our life easier */
1933 old_fcntl = fcntl(fd, F_GETFL);
1934 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001935 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001936 goto out;
1937 }
1938 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
1939 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001940 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001941 goto out;
1942 }
1943 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001944 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001945 goto out;
1946 }
Olivier Houchard54740872017-04-06 14:45:14 +02001947 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02001948 iov.iov_base = &tot_fd_nb;
1949 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02001950 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02001951 goto out;
1952 memset(&msghdr, 0, sizeof(msghdr));
1953 /*
1954 * First, calculates the total number of FD, so that we can let
Jackie Tapia749f74c2020-07-22 18:59:40 -05001955 * the caller know how much it should expect.
Olivier Houchardf886e342017-04-05 22:24:59 +02001956 */
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001957 for (cur_fd = 0;cur_fd < global.maxsock; cur_fd++)
Willy Tarreau9063a662021-04-06 18:09:06 +02001958 tot_fd_nb += !!(fdtab[cur_fd].state & FD_EXPORTED);
William Lallemand5fd3b282020-01-16 15:32:08 +01001959
Olivier Houchardf886e342017-04-05 22:24:59 +02001960 if (tot_fd_nb == 0)
1961 goto out;
1962
1963 /* First send the total number of file descriptors, so that the
1964 * receiving end knows what to expect.
1965 */
1966 msghdr.msg_iov = &iov;
1967 msghdr.msg_iovlen = 1;
1968 ret = sendmsg(fd, &msghdr, 0);
1969 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001970 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001971 goto out;
1972 }
1973
1974 /* Now send the fds */
1975 msghdr.msg_control = cmsgbuf;
1976 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
1977 cmsg = CMSG_FIRSTHDR(&msghdr);
1978 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
1979 cmsg->cmsg_level = SOL_SOCKET;
1980 cmsg->cmsg_type = SCM_RIGHTS;
1981 tmpfd = (int *)CMSG_DATA(cmsg);
1982
Olivier Houchardf886e342017-04-05 22:24:59 +02001983 /* For each socket, e message is sent, containing the following :
1984 * Size of the namespace name (or 0 if none), as an unsigned char.
1985 * The namespace name, if any
1986 * Size of the interface name (or 0 if none), as an unsigned char
1987 * The interface name, if any
Willy Tarreaucf1f1932020-08-26 10:30:09 +02001988 * 32 bits of zeroes (used to be listener options).
Olivier Houchardf886e342017-04-05 22:24:59 +02001989 */
1990 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
Ilya Shipitsind4259502020-04-08 01:07:56 +05001991 * buffer big enough to store the socket information.
Olivier Houchardf886e342017-04-05 22:24:59 +02001992 */
Olivier Houchardf143b802017-11-04 15:13:01 +01001993 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02001994 if (tmpbuf == NULL) {
Ilya Shipitsind4259502020-04-08 01:07:56 +05001995 ha_warning("Failed to allocate memory to transfer socket information\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02001996 goto out;
1997 }
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02001998
1999 nb_queued = 0;
Olivier Houchardf886e342017-04-05 22:24:59 +02002000 iov.iov_base = tmpbuf;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002001 for (cur_fd = 0; cur_fd < global.maxsock; cur_fd++) {
Willy Tarreau9063a662021-04-06 18:09:06 +02002002 if (!(fdtab[cur_fd].state & FD_EXPORTED))
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002003 continue;
2004
2005 ns_name = if_name = "";
2006 ns_nlen = if_nlen = 0;
2007
2008 /* for now we can only retrieve namespaces and interfaces from
2009 * pure listeners.
2010 */
Willy Tarreaua74cb382020-10-15 21:29:49 +02002011 if (fdtab[cur_fd].iocb == sock_accept_iocb) {
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002012 const struct listener *l = fdtab[cur_fd].owner;
2013
Willy Tarreau818a92e2020-09-03 07:50:19 +02002014 if (l->rx.settings->interface) {
2015 if_name = l->rx.settings->interface;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002016 if_nlen = strlen(if_name);
2017 }
2018
2019#ifdef USE_NS
Willy Tarreau818a92e2020-09-03 07:50:19 +02002020 if (l->rx.settings->netns) {
2021 ns_name = l->rx.settings->netns->node.key;
2022 ns_nlen = l->rx.settings->netns->name_len;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002023 }
2024#endif
2025 }
2026
2027 /* put the FD into the CMSG_DATA */
2028 tmpfd[nb_queued++] = cur_fd;
2029
2030 /* first block is <ns_name_len> <ns_name> */
2031 tmpbuf[curoff++] = ns_nlen;
2032 if (ns_nlen)
2033 memcpy(tmpbuf + curoff, ns_name, ns_nlen);
2034 curoff += ns_nlen;
2035
2036 /* second block is <if_name_len> <if_name> */
2037 tmpbuf[curoff++] = if_nlen;
2038 if (if_nlen)
2039 memcpy(tmpbuf + curoff, if_name, if_nlen);
2040 curoff += if_nlen;
2041
2042 /* we used to send the listener options here before 2.3 */
2043 memset(tmpbuf + curoff, 0, sizeof(int));
2044 curoff += sizeof(int);
2045
2046 /* there's a limit to how many FDs may be sent at once */
2047 if (nb_queued == MAX_SEND_FD) {
2048 iov.iov_len = curoff;
2049 if (sendmsg(fd, &msghdr, 0) != curoff) {
2050 ha_warning("Failed to transfer sockets\n");
2051 return -1;
2052 }
2053
2054 /* Wait for an ack */
2055 do {
2056 ret = recv(fd, &tot_fd_nb, sizeof(tot_fd_nb), 0);
2057 } while (ret == -1 && errno == EINTR);
2058
2059 if (ret <= 0) {
2060 ha_warning("Unexpected error while transferring sockets\n");
2061 return -1;
2062 }
2063 curoff = 0;
2064 nb_queued = 0;
2065 }
William Lallemand5fd3b282020-01-16 15:32:08 +01002066 }
2067
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002068 /* flush pending stuff */
2069 if (nb_queued) {
Olivier Houchardf886e342017-04-05 22:24:59 +02002070 iov.iov_len = curoff;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002071 cmsg->cmsg_len = CMSG_LEN(nb_queued * sizeof(int));
2072 msghdr.msg_controllen = CMSG_SPACE(nb_queued * sizeof(int));
Olivier Houchardf886e342017-04-05 22:24:59 +02002073 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002074 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02002075 goto out;
2076 }
2077 }
2078
2079out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02002080 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002081 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02002082 goto out;
2083 }
2084 appctx->st0 = CLI_ST_END;
2085 free(cmsgbuf);
2086 free(tmpbuf);
2087 return 1;
2088}
2089
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002090static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
2091{
2092 if (*args[0] == 'h')
2093 /* help */
Willy Tarreau0b1b8302021-05-09 20:59:23 +02002094 cli_gen_usage_msg(appctx, args);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002095 else if (*args[0] == 'p')
2096 /* prompt */
2097 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
2098 else if (*args[0] == 'q')
2099 /* quit */
2100 appctx->st0 = CLI_ST_END;
2101
2102 return 1;
2103}
Olivier Houchardf886e342017-04-05 22:24:59 +02002104
William Lallemand2f4ce202018-10-26 14:47:47 +02002105void pcli_write_prompt(struct stream *s)
2106{
2107 struct buffer *msg = get_trash_chunk();
2108 struct channel *oc = si_oc(&s->si[0]);
2109
William Lallemanddc12c2e2018-12-13 09:05:46 +01002110 if (!(s->pcli_flags & PCLI_F_PROMPT))
William Lallemand5b80fa22018-12-11 16:10:54 +01002111 return;
2112
William Lallemanddc12c2e2018-12-13 09:05:46 +01002113 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002114 chunk_appendf(msg, "+ ");
2115 } else {
2116 if (s->pcli_next_pid == 0)
Willy Tarreau52880f92018-12-15 13:30:03 +01002117 chunk_appendf(msg, "master%s> ",
2118 (global.mode & MODE_MWORKER_WAIT) ? "[ReloadFailed]" : "");
William Lallemandebf61802018-12-11 16:10:57 +01002119 else
2120 chunk_appendf(msg, "%d> ", s->pcli_next_pid);
2121 }
William Lallemand2f4ce202018-10-26 14:47:47 +02002122 co_inject(oc, msg->area, msg->data);
2123}
2124
William Lallemand291810d2018-10-26 14:47:38 +02002125
William Lallemandcf62f7e2018-10-26 14:47:40 +02002126/* The pcli_* functions are used for the CLI proxy in the master */
2127
William Lallemanddeeaa592018-10-26 14:47:48 +02002128void pcli_reply_and_close(struct stream *s, const char *msg)
2129{
2130 struct buffer *buf = get_trash_chunk();
2131
2132 chunk_initstr(buf, msg);
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01002133 si_retnclose(&s->si[0], buf);
William Lallemanddeeaa592018-10-26 14:47:48 +02002134}
2135
William Lallemand291810d2018-10-26 14:47:38 +02002136static enum obj_type *pcli_pid_to_server(int proc_pid)
2137{
2138 struct mworker_proc *child;
2139
William Lallemand99e0bb92020-11-05 10:28:53 +01002140 /* return the mCLI applet of the master */
William Lallemandbddd33a2018-12-11 16:10:53 +01002141 if (proc_pid == 0)
William Lallemand99e0bb92020-11-05 10:28:53 +01002142 return &mcli_applet.obj_type;
William Lallemandbddd33a2018-12-11 16:10:53 +01002143
William Lallemand291810d2018-10-26 14:47:38 +02002144 list_for_each_entry(child, &proc_list, list) {
2145 if (child->pid == proc_pid){
2146 return &child->srv->obj_type;
2147 }
2148 }
2149 return NULL;
2150}
2151
2152/* Take a CLI prefix in argument (eg: @!1234 @master @1)
2153 * Return:
2154 * 0: master
2155 * > 0: pid of a worker
2156 * < 0: didn't find a worker
2157 */
2158static int pcli_prefix_to_pid(const char *prefix)
2159{
2160 int proc_pid;
2161 struct mworker_proc *child;
2162 char *errtol = NULL;
2163
2164 if (*prefix != '@') /* not a prefix, should not happen */
2165 return -1;
2166
2167 prefix++;
2168 if (!*prefix) /* sent @ alone, return the master */
2169 return 0;
2170
2171 if (strcmp("master", prefix) == 0) {
2172 return 0;
2173 } else if (*prefix == '!') {
2174 prefix++;
2175 if (!*prefix)
2176 return -1;
2177
2178 proc_pid = strtol(prefix, &errtol, 10);
2179 if (*errtol != '\0')
2180 return -1;
2181 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02002182 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01002183 continue;
William Lallemand291810d2018-10-26 14:47:38 +02002184 if (child->pid == proc_pid){
2185 return child->pid;
2186 }
2187 }
2188 } else {
2189 struct mworker_proc *chosen = NULL;
2190 /* this is a relative pid */
2191
2192 proc_pid = strtol(prefix, &errtol, 10);
2193 if (*errtol != '\0')
2194 return -1;
2195
2196 if (proc_pid == 0) /* return the master */
2197 return 0;
2198
2199 /* chose the right process, the current one is the one with the
2200 least number of reloads */
2201 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02002202 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01002203 continue;
William Lallemand291810d2018-10-26 14:47:38 +02002204 if (child->relative_pid == proc_pid){
2205 if (child->reloads == 0)
2206 return child->pid;
2207 else if (chosen == NULL || child->reloads < chosen->reloads)
2208 chosen = child;
2209 }
2210 }
2211 if (chosen)
2212 return chosen->pid;
2213 }
2214 return -1;
2215}
2216
William Lallemandbddd33a2018-12-11 16:10:53 +01002217/* Return::
2218 * >= 0 : number of words to escape
2219 * = -1 : error
2220 */
2221
2222int pcli_find_and_exec_kw(struct stream *s, char **args, int argl, char **errmsg, int *next_pid)
2223{
2224 if (argl < 1)
2225 return 0;
2226
2227 /* there is a prefix */
2228 if (args[0][0] == '@') {
2229 int target_pid = pcli_prefix_to_pid(args[0]);
2230
2231 if (target_pid == -1) {
2232 memprintf(errmsg, "Can't find the target PID matching the prefix '%s'\n", args[0]);
2233 return -1;
2234 }
2235
2236 /* if the prefix is alone, define a default target */
2237 if (argl == 1)
2238 s->pcli_next_pid = target_pid;
2239 else
2240 *next_pid = target_pid;
2241 return 1;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002242 } else if (strcmp("prompt", args[0]) == 0) {
William Lallemanddc12c2e2018-12-13 09:05:46 +01002243 s->pcli_flags ^= PCLI_F_PROMPT;
William Lallemand5b80fa22018-12-11 16:10:54 +01002244 return argl; /* return the number of elements in the array */
William Lallemand5f610682018-12-11 16:10:55 +01002245
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002246 } else if (strcmp("quit", args[0]) == 0) {
William Lallemand5f610682018-12-11 16:10:55 +01002247 channel_shutr_now(&s->req);
2248 channel_shutw_now(&s->res);
2249 return argl; /* return the number of elements in the array */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002250 } else if (strcmp(args[0], "operator") == 0) {
William Lallemandb7ea1412018-12-13 09:05:47 +01002251 if (!pcli_has_level(s, ACCESS_LVL_OPER)) {
2252 memprintf(errmsg, "Permission denied!\n");
2253 return -1;
2254 }
2255 s->pcli_flags &= ~ACCESS_LVL_MASK;
2256 s->pcli_flags |= ACCESS_LVL_OPER;
2257 return argl;
2258
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002259 } else if (strcmp(args[0], "user") == 0) {
William Lallemandb7ea1412018-12-13 09:05:47 +01002260 if (!pcli_has_level(s, ACCESS_LVL_USER)) {
2261 memprintf(errmsg, "Permission denied!\n");
2262 return -1;
2263 }
2264 s->pcli_flags &= ~ACCESS_LVL_MASK;
2265 s->pcli_flags |= ACCESS_LVL_USER;
2266 return argl;
William Lallemandbddd33a2018-12-11 16:10:53 +01002267 }
2268
2269 return 0;
2270}
2271
2272/*
2273 * Parse the CLI request:
2274 * - It does basically the same as the cli_io_handler, but as a proxy
2275 * - It can exec a command and strip non forwardable commands
William Lallemandcf62f7e2018-10-26 14:47:40 +02002276 *
2277 * Return:
William Lallemandbddd33a2018-12-11 16:10:53 +01002278 * - the number of characters to forward or
2279 * - 1 if there is an error or not enough data
William Lallemandcf62f7e2018-10-26 14:47:40 +02002280 */
William Lallemandbddd33a2018-12-11 16:10:53 +01002281int pcli_parse_request(struct stream *s, struct channel *req, char **errmsg, int *next_pid)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002282{
Willy Tarreauad5bf142022-01-20 08:47:35 +01002283 char *str;
2284 char *end;
Willy Tarreauf14c7572021-03-13 10:59:23 +01002285 char *args[MAX_CLI_ARGS + 1]; /* +1 for storing a NULL */
William Lallemandbddd33a2018-12-11 16:10:53 +01002286 int argl; /* number of args */
2287 char *p;
2288 char *trim = NULL;
William Lallemandebf61802018-12-11 16:10:57 +01002289 char *payload = NULL;
William Lallemandbddd33a2018-12-11 16:10:53 +01002290 int wtrim = 0; /* number of words to trim */
2291 int reql = 0;
William Lallemandb7ea1412018-12-13 09:05:47 +01002292 int ret;
William Lallemandbddd33a2018-12-11 16:10:53 +01002293 int i = 0;
2294
Willy Tarreauad5bf142022-01-20 08:47:35 +01002295 /* we cannot deal with a wrapping buffer, so let's take care of this
2296 * first.
2297 */
2298 if (b_head(&req->buf) + b_data(&req->buf) > b_wrap(&req->buf))
2299 b_slow_realign(&req->buf, trash.area, co_data(req));
2300
2301 str = (char *)ci_head(req);
2302 end = (char *)ci_stop(req);
2303
William Lallemandbddd33a2018-12-11 16:10:53 +01002304 p = str;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002305
William Lallemanddc12c2e2018-12-13 09:05:46 +01002306 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002307
2308 /* Looks for the end of one command */
2309 while (p+reql < end) {
2310 /* handle escaping */
2311 if (p[reql] == '\\') {
William Lallemand02c255e2020-06-18 18:45:04 +02002312 reql+=2;
William Lallemandebf61802018-12-11 16:10:57 +01002313 continue;
2314 }
2315 if (p[reql] == ';' || p[reql] == '\n') {
2316 /* found the end of the command */
2317 p[reql] = '\n';
2318 reql++;
2319 break;
2320 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002321 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002322 }
William Lallemandebf61802018-12-11 16:10:57 +01002323 } else {
2324 while (p+reql < end) {
2325 if (p[reql] == '\n') {
2326 /* found the end of the line */
2327 reql++;
2328 break;
2329 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002330 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002331 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002332 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002333
William Lallemandbddd33a2018-12-11 16:10:53 +01002334 /* set end to first byte after the end of the command */
2335 end = p + reql;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002336
William Lallemandbddd33a2018-12-11 16:10:53 +01002337 /* there is no end to this command, need more to parse ! */
Willy Tarreau9b736eb2022-01-20 08:31:50 +01002338 if (!reql || *(end-1) != '\n') {
William Lallemandbddd33a2018-12-11 16:10:53 +01002339 return -1;
2340 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002341
William Lallemand3301f3e2018-12-13 09:05:48 +01002342 if (s->pcli_flags & PCLI_F_PAYLOAD) {
2343 if (reql == 1) /* last line of the payload */
2344 s->pcli_flags &= ~PCLI_F_PAYLOAD;
William Lallemandebf61802018-12-11 16:10:57 +01002345 return reql;
2346 }
2347
William Lallemandbddd33a2018-12-11 16:10:53 +01002348 *(end-1) = '\0';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002349
William Lallemandbddd33a2018-12-11 16:10:53 +01002350 /* splits the command in words */
Willy Tarreauf14c7572021-03-13 10:59:23 +01002351 while (i < MAX_CLI_ARGS && p < end) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002352 /* skip leading spaces/tabs */
2353 p += strspn(p, " \t");
2354 if (!*p)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002355 break;
2356
William Lallemandbddd33a2018-12-11 16:10:53 +01002357 args[i] = p;
William Lallemandfe249c32020-06-18 18:03:57 +02002358 while (1) {
2359 p += strcspn(p, " \t\\");
2360 /* escaped chars using backlashes (\) */
2361 if (*p == '\\') {
2362 if (!*++p)
2363 break;
2364 if (!*++p)
2365 break;
2366 } else {
2367 break;
William Lallemandbddd33a2018-12-11 16:10:53 +01002368 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002369 }
William Lallemandfe249c32020-06-18 18:03:57 +02002370 *p++ = 0;
William Lallemandbddd33a2018-12-11 16:10:53 +01002371 i++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002372 }
2373
William Lallemandbddd33a2018-12-11 16:10:53 +01002374 argl = i;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002375
Willy Tarreauf14c7572021-03-13 10:59:23 +01002376 for (; i < MAX_CLI_ARGS + 1; i++)
William Lallemandbddd33a2018-12-11 16:10:53 +01002377 args[i] = NULL;
2378
2379 wtrim = pcli_find_and_exec_kw(s, args, argl, errmsg, next_pid);
2380
2381 /* End of words are ending by \0, we need to replace the \0s by spaces
23821 before forwarding them */
2383 p = str;
William Lallemand3301f3e2018-12-13 09:05:48 +01002384 while (p < end-1) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002385 if (*p == '\0')
2386 *p = ' ';
2387 p++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002388 }
2389
William Lallemand3301f3e2018-12-13 09:05:48 +01002390 payload = strstr(str, PAYLOAD_PATTERN);
2391 if ((end - 1) == (payload + strlen(PAYLOAD_PATTERN))) {
2392 /* if the payload pattern is at the end */
2393 s->pcli_flags |= PCLI_F_PAYLOAD;
William Lallemand3301f3e2018-12-13 09:05:48 +01002394 }
2395
William Lallemandbddd33a2018-12-11 16:10:53 +01002396 *(end-1) = '\n';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002397
William Lallemandbddd33a2018-12-11 16:10:53 +01002398 if (wtrim > 0) {
2399 trim = &args[wtrim][0];
2400 if (trim == NULL) /* if this was the last word in the table */
2401 trim = end;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002402
William Lallemandbddd33a2018-12-11 16:10:53 +01002403 b_del(&req->buf, trim - str);
2404
William Lallemandb7ea1412018-12-13 09:05:47 +01002405 ret = end - trim;
William Lallemandbddd33a2018-12-11 16:10:53 +01002406 } else if (wtrim < 0) {
2407 /* parsing error */
2408 return -1;
William Lallemandb7ea1412018-12-13 09:05:47 +01002409 } else {
2410 /* the whole string */
2411 ret = end - str;
William Lallemandbddd33a2018-12-11 16:10:53 +01002412 }
2413
William Lallemandb7ea1412018-12-13 09:05:47 +01002414 if (ret > 1) {
2415 if (pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2416 goto end;
2417 } else if (pcli_has_level(s, ACCESS_LVL_OPER)) {
William Lallemandad032882019-07-01 10:56:15 +02002418 ci_insert_line2(req, 0, "operator -", strlen("operator -"));
2419 ret += strlen("operator -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002420 } else if (pcli_has_level(s, ACCESS_LVL_USER)) {
William Lallemandad032882019-07-01 10:56:15 +02002421 ci_insert_line2(req, 0, "user -", strlen("user -"));
2422 ret += strlen("user -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002423 }
2424 }
2425end:
William Lallemandbddd33a2018-12-11 16:10:53 +01002426
William Lallemandb7ea1412018-12-13 09:05:47 +01002427 return ret;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002428}
2429
2430int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
2431{
William Lallemandbddd33a2018-12-11 16:10:53 +01002432 int next_pid = -1;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002433 int to_forward;
William Lallemandbddd33a2018-12-11 16:10:53 +01002434 char *errmsg = NULL;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002435
Christopher Fauletbe416712021-10-18 14:52:49 +02002436 /* Don't read the next command if still processing the reponse of the
2437 * current one. Just wait. At this stage, errors should be handled by
2438 * the response analyzer.
2439 */
2440 if (s->res.analysers & AN_RES_WAIT_CLI)
2441 return 0;
2442
William Lallemandb7ea1412018-12-13 09:05:47 +01002443 if ((s->pcli_flags & ACCESS_LVL_MASK) == ACCESS_LVL_NONE)
2444 s->pcli_flags |= strm_li(s)->bind_conf->level & ACCESS_LVL_MASK;
2445
William Lallemandcf62f7e2018-10-26 14:47:40 +02002446read_again:
2447 /* if the channel is closed for read, we won't receive any more data
2448 from the client, but we don't want to forward this close to the
2449 server */
2450 channel_dont_close(req);
2451
2452 /* We don't know yet to which server we will connect */
2453 channel_dont_connect(req);
2454
William Lallemandcf62f7e2018-10-26 14:47:40 +02002455 req->flags |= CF_READ_DONTWAIT;
2456
2457 /* need more data */
2458 if (!ci_data(req))
Christopher Fauletc8c4e3f2022-01-18 08:44:23 +01002459 goto missing_data;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002460
2461 /* If there is data available for analysis, log the end of the idle time. */
2462 if (c_data(req) && s->logs.t_idle == -1)
2463 s->logs.t_idle = tv_ms_elapsed(&s->logs.tv_accept, &now) - s->logs.t_handshake;
2464
William Lallemandbddd33a2018-12-11 16:10:53 +01002465 to_forward = pcli_parse_request(s, req, &errmsg, &next_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002466 if (to_forward > 0) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002467 int target_pid;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002468 /* enough data */
2469
William Lallemandcf62f7e2018-10-26 14:47:40 +02002470 /* forward only 1 command */
2471 channel_forward(req, to_forward);
William Lallemandebf61802018-12-11 16:10:57 +01002472
William Lallemanddc12c2e2018-12-13 09:05:46 +01002473 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002474 /* we send only 1 command per request, and we write close after it */
2475 channel_shutw_now(req);
2476 } else {
2477 pcli_write_prompt(s);
2478 }
2479
2480 s->res.flags |= CF_WAKE_ONCE; /* need to be called again */
William Lallemandcf62f7e2018-10-26 14:47:40 +02002481 s->res.analysers |= AN_RES_WAIT_CLI;
2482
William Lallemandebf61802018-12-11 16:10:57 +01002483 if (!(s->flags & SF_ASSIGNED)) {
2484 if (next_pid > -1)
2485 target_pid = next_pid;
2486 else
2487 target_pid = s->pcli_next_pid;
2488 /* we can connect now */
2489 s->target = pcli_pid_to_server(target_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002490
William Lallemanddd29e892021-12-10 14:14:53 +01002491 if (!s->target)
2492 goto server_disconnect;
2493
William Lallemandebf61802018-12-11 16:10:57 +01002494 s->flags |= (SF_DIRECT | SF_ASSIGNED);
2495 channel_auto_connect(req);
2496 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002497
2498 } else if (to_forward == 0) {
William Lallemandcf62f7e2018-10-26 14:47:40 +02002499 /* we trimmed things but we might have other commands to consume */
William Lallemandbddd33a2018-12-11 16:10:53 +01002500 pcli_write_prompt(s);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002501 goto read_again;
Christopher Fauletc8c4e3f2022-01-18 08:44:23 +01002502 } else if (to_forward == -1) {
2503 if (errmsg) {
2504 /* there was an error during the parsing */
2505 pcli_reply_and_close(s, errmsg);
2506 s->req.analysers &= ~AN_REQ_WAIT_CLI;
2507 return 0;
2508 }
2509 goto missing_data;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002510 }
2511
2512 return 0;
2513
2514send_help:
2515 b_reset(&req->buf);
2516 b_putblk(&req->buf, "help\n", 5);
2517 goto read_again;
William Lallemanddd29e892021-12-10 14:14:53 +01002518
Christopher Fauletc8c4e3f2022-01-18 08:44:23 +01002519missing_data:
2520 if (req->flags & CF_SHUTR) {
2521 /* There is no more request or a only a partial one and we
2522 * receive a close from the client, we can leave */
2523 channel_shutw_now(&s->res);
2524 s->req.analysers &= ~AN_REQ_WAIT_CLI;
2525 return 1;
2526 }
2527 else if (channel_full(req, global.tune.maxrewrite)) {
2528 /* buffer is full and we didn't catch the end of a command */
2529 goto send_help;
2530 }
2531 return 0;
2532
William Lallemanddd29e892021-12-10 14:14:53 +01002533server_disconnect:
2534 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
2535 return 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002536}
2537
2538int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
2539{
2540 struct proxy *fe = strm_fe(s);
2541 struct proxy *be = s->be;
2542
William Lallemand6b7cd0a2018-11-06 17:37:11 +01002543 if (rep->flags & CF_READ_ERROR) {
2544 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
Christopher Fauletbe416712021-10-18 14:52:49 +02002545 s->req.analysers &= ~AN_REQ_WAIT_CLI;
William Lallemand6b7cd0a2018-11-06 17:37:11 +01002546 s->res.analysers &= ~AN_RES_WAIT_CLI;
2547 return 0;
2548 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002549 rep->flags |= CF_READ_DONTWAIT; /* try to get back here ASAP */
2550 rep->flags |= CF_NEVER_WAIT;
2551
2552 /* don't forward the close */
2553 channel_dont_close(&s->res);
2554 channel_dont_close(&s->req);
2555
William Lallemanddc12c2e2018-12-13 09:05:46 +01002556 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002557 s->res.analysers &= ~AN_RES_WAIT_CLI;
2558 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2559 return 0;
2560 }
2561
William Lallemandcf62f7e2018-10-26 14:47:40 +02002562 /* forward the data */
2563 if (ci_data(rep)) {
2564 c_adv(rep, ci_data(rep));
2565 return 0;
2566 }
2567
2568 if ((rep->flags & (CF_SHUTR|CF_READ_NULL))) {
2569 /* stream cleanup */
2570
William Lallemand2f4ce202018-10-26 14:47:47 +02002571 pcli_write_prompt(s);
2572
William Lallemandcf62f7e2018-10-26 14:47:40 +02002573 s->si[1].flags |= SI_FL_NOLINGER | SI_FL_NOHALF;
2574 si_shutr(&s->si[1]);
2575 si_shutw(&s->si[1]);
2576
2577 /*
2578 * starting from there this the same code as
2579 * http_end_txn_clean_session().
2580 *
2581 * It allows to do frontend keepalive while reconnecting to a
2582 * new server for each request.
2583 */
2584
2585 if (s->flags & SF_BE_ASSIGNED) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002586 HA_ATOMIC_DEC(&be->beconn);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002587 if (unlikely(s->srv_conn))
2588 sess_change_server(s, NULL);
2589 }
2590
2591 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2592 stream_process_counters(s);
2593
2594 /* don't count other requests' data */
2595 s->logs.bytes_in -= ci_data(&s->req);
2596 s->logs.bytes_out -= ci_data(&s->res);
2597
2598 /* we may need to know the position in the queue */
2599 pendconn_free(s);
2600
2601 /* let's do a final log if we need it */
2602 if (!LIST_ISEMPTY(&fe->logformat) && s->logs.logwait &&
2603 !(s->flags & SF_MONITOR) &&
2604 (!(fe->options & PR_O_NULLNOLOG) || s->req.total)) {
2605 s->do_log(s);
2606 }
2607
2608 /* stop tracking content-based counters */
2609 stream_stop_content_counters(s);
2610 stream_update_time_stats(s);
2611
2612 s->logs.accept_date = date; /* user-visible date for logging */
2613 s->logs.tv_accept = now; /* corrected date for internal use */
2614 s->logs.t_handshake = 0; /* There are no handshake in keep alive connection. */
2615 s->logs.t_idle = -1;
2616 tv_zero(&s->logs.tv_request);
2617 s->logs.t_queue = -1;
2618 s->logs.t_connect = -1;
2619 s->logs.t_data = -1;
2620 s->logs.t_close = 0;
2621 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
2622 s->logs.srv_queue_pos = 0; /* we will get this number soon */
2623
2624 s->logs.bytes_in = s->req.total = ci_data(&s->req);
2625 s->logs.bytes_out = s->res.total = ci_data(&s->res);
2626
2627 stream_del_srv_conn(s);
2628 if (objt_server(s->target)) {
2629 if (s->flags & SF_CURR_SESS) {
2630 s->flags &= ~SF_CURR_SESS;
Willy Tarreau4781b152021-04-06 13:53:36 +02002631 HA_ATOMIC_DEC(&__objt_server(s->target)->cur_sess);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002632 }
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002633 if (may_dequeue_tasks(__objt_server(s->target), be))
Amaury Denoyellecaaafd02021-06-18 11:11:36 +02002634 process_srv_queue(__objt_server(s->target), 0);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002635 }
2636
2637 s->target = NULL;
2638
2639 /* only release our endpoint if we don't intend to reuse the
2640 * connection.
2641 */
2642 if (!si_conn_ready(&s->si[1])) {
2643 si_release_endpoint(&s->si[1]);
2644 s->srv_conn = NULL;
2645 }
2646
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002647 sockaddr_free(&s->target_addr);
2648
William Lallemandcf62f7e2018-10-26 14:47:40 +02002649 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
2650 s->si[1].err_type = SI_ET_NONE;
2651 s->si[1].conn_retries = 0; /* used for logging too */
2652 s->si[1].exp = TICK_ETERNITY;
2653 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 +02002654 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 +02002655 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 +02002656 s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_ADDR_SET|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
2657 s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
2658 s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
2659 /* reinitialise the current rule list pointer to NULL. We are sure that
2660 * any rulelist match the NULL pointer.
2661 */
2662 s->current_rule_list = NULL;
2663
2664 s->be = strm_fe(s);
2665 s->logs.logwait = strm_fe(s)->to_log;
2666 s->logs.level = 0;
2667 stream_del_srv_conn(s);
2668 s->target = NULL;
2669 /* re-init store persistence */
2670 s->store_count = 0;
2671 s->uniq_id = global.req_count++;
2672
2673 s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */
2674
2675 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2676
William Lallemandcf62f7e2018-10-26 14:47:40 +02002677 s->res.analysers &= ~AN_RES_WAIT_CLI;
2678
2679 /* We must trim any excess data from the response buffer, because we
2680 * may have blocked an invalid response from a server that we don't
Ilya Shipitsind4259502020-04-08 01:07:56 +05002681 * want to accidentally forward once we disable the analysers, nor do
William Lallemandcf62f7e2018-10-26 14:47:40 +02002682 * we want those data to come along with next response. A typical
2683 * example of such data would be from a buggy server responding to
2684 * a HEAD with some data, or sending more than the advertised
2685 * content-length.
2686 */
2687 if (unlikely(ci_data(&s->res)))
2688 b_set_data(&s->res.buf, co_data(&s->res));
2689
2690 /* Now we can realign the response buffer */
2691 c_realign_if_empty(&s->res);
2692
2693 s->req.rto = strm_fe(s)->timeout.client;
2694 s->req.wto = TICK_ETERNITY;
2695
2696 s->res.rto = TICK_ETERNITY;
2697 s->res.wto = strm_fe(s)->timeout.client;
2698
2699 s->req.rex = TICK_ETERNITY;
2700 s->req.wex = TICK_ETERNITY;
2701 s->req.analyse_exp = TICK_ETERNITY;
2702 s->res.rex = TICK_ETERNITY;
2703 s->res.wex = TICK_ETERNITY;
2704 s->res.analyse_exp = TICK_ETERNITY;
2705 s->si[1].hcto = TICK_ETERNITY;
2706
2707 /* we're removing the analysers, we MUST re-enable events detection.
2708 * We don't enable close on the response channel since it's either
2709 * already closed, or in keep-alive with an idle connection handler.
2710 */
2711 channel_auto_read(&s->req);
2712 channel_auto_close(&s->req);
2713 channel_auto_read(&s->res);
2714
2715
2716 return 1;
2717 }
2718 return 0;
2719}
2720
William Lallemand8a022572018-10-26 14:47:35 +02002721/*
2722 * The mworker functions are used to initialize the CLI in the master process
2723 */
2724
William Lallemand309dc9a2018-10-26 14:47:45 +02002725 /*
2726 * Stop the mworker proxy
2727 */
2728void mworker_cli_proxy_stop()
2729{
William Lallemand550db6d2018-11-06 17:37:12 +01002730 if (mworker_proxy)
2731 stop_proxy(mworker_proxy);
William Lallemand309dc9a2018-10-26 14:47:45 +02002732}
2733
William Lallemand8a022572018-10-26 14:47:35 +02002734/*
2735 * Create the mworker CLI proxy
2736 */
2737int mworker_cli_proxy_create()
2738{
2739 struct mworker_proc *child;
William Lallemand744a0892018-11-22 16:46:51 +01002740 char *msg = NULL;
2741 char *errmsg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002742
2743 mworker_proxy = calloc(1, sizeof(*mworker_proxy));
2744 if (!mworker_proxy)
2745 return -1;
2746
2747 init_new_proxy(mworker_proxy);
2748 mworker_proxy->next = proxies_list;
2749 proxies_list = mworker_proxy;
2750 mworker_proxy->id = strdup("MASTER");
William Lallemandcf62f7e2018-10-26 14:47:40 +02002751 mworker_proxy->mode = PR_MODE_CLI;
William Lallemand8a022572018-10-26 14:47:35 +02002752 mworker_proxy->last_change = now.tv_sec;
2753 mworker_proxy->cap = PR_CAP_LISTEN; /* this is a listen section */
2754 mworker_proxy->maxconn = 10; /* default to 10 concurrent connections */
2755 mworker_proxy->timeout.client = 0; /* no timeout */
2756 mworker_proxy->conf.file = strdup("MASTER");
2757 mworker_proxy->conf.line = 0;
2758 mworker_proxy->accept = frontend_accept;
2759 mworker_proxy-> lbprm.algo = BE_LB_ALGO_NONE;
2760
2761 /* Does not init the default target the CLI applet, but must be done in
2762 * the request parsing code */
2763 mworker_proxy->default_target = NULL;
2764
2765 /* the check_config_validity() will get an ID for the proxy */
2766 mworker_proxy->uuid = -1;
2767
2768 proxy_store_name(mworker_proxy);
2769
2770 /* create all servers using the mworker_proc list */
2771 list_for_each_entry(child, &proc_list, list) {
William Lallemand8a022572018-10-26 14:47:35 +02002772 struct server *newsrv = NULL;
2773 struct sockaddr_storage *sk;
2774 int port1, port2, port;
2775 struct protocol *proto;
William Lallemand8a022572018-10-26 14:47:35 +02002776
William Lallemanda31b09e2020-01-14 15:25:02 +01002777 /* only the workers support the master CLI */
2778 if (!(child->options & PROC_O_TYPE_WORKER))
2779 continue;
2780
William Lallemand8a022572018-10-26 14:47:35 +02002781 newsrv = new_server(mworker_proxy);
2782 if (!newsrv)
William Lallemand744a0892018-11-22 16:46:51 +01002783 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002784
2785 /* we don't know the new pid yet */
2786 if (child->pid == -1)
2787 memprintf(&msg, "cur-%d", child->relative_pid);
2788 else
2789 memprintf(&msg, "old-%d", child->pid);
2790
2791 newsrv->next = mworker_proxy->srv;
2792 mworker_proxy->srv = newsrv;
2793 newsrv->conf.file = strdup(msg);
2794 newsrv->id = strdup(msg);
2795 newsrv->conf.line = 0;
2796
2797 memprintf(&msg, "sockpair@%d", child->ipc_fd[0]);
Willy Tarreau5fc93282020-09-16 18:25:03 +02002798 if ((sk = str2sa_range(msg, &port, &port1, &port2, NULL, &proto,
Willy Tarreaua93e5c72020-09-15 14:01:16 +02002799 &errmsg, NULL, NULL, PA_O_STREAM)) == 0) {
William Lallemand744a0892018-11-22 16:46:51 +01002800 goto error;
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002801 }
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002802 ha_free(&msg);
William Lallemand8a022572018-10-26 14:47:35 +02002803
Willy Tarreau5fc93282020-09-16 18:25:03 +02002804 if (!proto->connect) {
William Lallemand744a0892018-11-22 16:46:51 +01002805 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02002806 }
2807
2808 /* no port specified */
2809 newsrv->flags |= SRV_F_MAPPORTS;
2810 newsrv->addr = *sk;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002811 /* don't let the server participate to load balancing */
2812 newsrv->iweight = 0;
2813 newsrv->uweight = 0;
William Lallemand8a022572018-10-26 14:47:35 +02002814 srv_lb_commit_status(newsrv);
William Lallemand291810d2018-10-26 14:47:38 +02002815
2816 child->srv = newsrv;
William Lallemand8a022572018-10-26 14:47:35 +02002817 }
2818 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002819
2820error:
2821 ha_alert("%s\n", errmsg);
2822
2823 list_for_each_entry(child, &proc_list, list) {
2824 free((char *)child->srv->conf.file); /* cast because of const char * */
2825 free(child->srv->id);
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002826 ha_free(&child->srv);
William Lallemand744a0892018-11-22 16:46:51 +01002827 }
2828 free(mworker_proxy->id);
2829 free(mworker_proxy->conf.file);
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002830 ha_free(&mworker_proxy);
William Lallemand744a0892018-11-22 16:46:51 +01002831 free(errmsg);
2832 free(msg);
2833
2834 return -1;
William Lallemand8a022572018-10-26 14:47:35 +02002835}
Olivier Houchardf886e342017-04-05 22:24:59 +02002836
William Lallemandce83b4a2018-10-26 14:47:30 +02002837/*
William Lallemande7361152018-10-26 14:47:36 +02002838 * Create a new listener for the master CLI proxy
2839 */
2840int mworker_cli_proxy_new_listener(char *line)
2841{
2842 struct bind_conf *bind_conf;
2843 struct listener *l;
2844 char *err = NULL;
2845 char *args[MAX_LINE_ARGS + 1];
2846 int arg;
2847 int cur_arg;
2848
William Lallemand2e945c82019-11-25 09:58:37 +01002849 arg = 1;
William Lallemande7361152018-10-26 14:47:36 +02002850 args[0] = line;
2851
2852 /* args is a bind configuration with spaces replaced by commas */
2853 while (*line && arg < MAX_LINE_ARGS) {
2854
2855 if (*line == ',') {
2856 *line++ = '\0';
2857 while (*line == ',')
2858 line++;
William Lallemand2e945c82019-11-25 09:58:37 +01002859 args[arg++] = line;
William Lallemande7361152018-10-26 14:47:36 +02002860 }
2861 line++;
2862 }
2863
William Lallemand2e945c82019-11-25 09:58:37 +01002864 args[arg] = "\0";
William Lallemande7361152018-10-26 14:47:36 +02002865
2866 bind_conf = bind_conf_alloc(mworker_proxy, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002867 if (!bind_conf)
2868 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002869
2870 bind_conf->level &= ~ACCESS_LVL_MASK;
2871 bind_conf->level |= ACCESS_LVL_ADMIN;
Willy Tarreaue283ee62021-03-12 15:00:57 +01002872 bind_conf->level |= ACCESS_MASTER | ACCESS_MASTER_ONLY;
William Lallemande7361152018-10-26 14:47:36 +02002873
2874 if (!str2listener(args[0], mworker_proxy, bind_conf, "master-socket", 0, &err)) {
2875 ha_alert("Cannot create the listener of the master CLI\n");
William Lallemand744a0892018-11-22 16:46:51 +01002876 goto err;
William Lallemande7361152018-10-26 14:47:36 +02002877 }
2878
2879 cur_arg = 1;
2880
2881 while (*args[cur_arg]) {
William Lallemande7361152018-10-26 14:47:36 +02002882 struct bind_kw *kw;
Willy Tarreau433b05f2021-03-12 10:14:07 +01002883 const char *best;
William Lallemande7361152018-10-26 14:47:36 +02002884
2885 kw = bind_find_kw(args[cur_arg]);
2886 if (kw) {
2887 if (!kw->parse) {
2888 memprintf(&err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
2889 args[0], args[1], args[cur_arg]);
2890 goto err;
2891 }
2892
Willy Tarreau4975d142021-03-13 11:00:33 +01002893 if (kw->parse(args, cur_arg, global.cli_fe, bind_conf, &err) != 0) {
William Lallemande7361152018-10-26 14:47:36 +02002894 if (err)
2895 memprintf(&err, "'%s %s' : '%s'", args[0], args[1], err);
2896 else
2897 memprintf(&err, "'%s %s' : error encountered while processing '%s'",
2898 args[0], args[1], args[cur_arg]);
2899 goto err;
2900 }
2901
2902 cur_arg += 1 + kw->skip;
2903 continue;
2904 }
2905
Willy Tarreau433b05f2021-03-12 10:14:07 +01002906 best = bind_find_best_kw(args[cur_arg]);
2907 if (best)
2908 memprintf(&err, "'%s %s' : unknown keyword '%s'. Did you mean '%s' maybe ?",
2909 args[0], args[1], args[cur_arg], best);
2910 else
2911 memprintf(&err, "'%s %s' : unknown keyword '%s'.",
2912 args[0], args[1], args[cur_arg]);
William Lallemande7361152018-10-26 14:47:36 +02002913 goto err;
2914 }
2915
2916
2917 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemande7361152018-10-26 14:47:36 +02002918 l->accept = session_accept_fd;
2919 l->default_target = mworker_proxy->default_target;
2920 /* don't make the peers subject to global limits and don't close it in the master */
Willy Tarreau18c20d22020-10-09 16:11:46 +02002921 l->options |= LI_O_UNLIMITED;
2922 l->rx.flags |= RX_F_MWORKER; /* we are keeping this FD in the master */
William Lallemande7361152018-10-26 14:47:36 +02002923 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002924 global.maxsock++; /* for the listening socket */
William Lallemande7361152018-10-26 14:47:36 +02002925 }
Willy Tarreau18215cb2019-02-27 16:25:28 +01002926 global.maxsock += mworker_proxy->maxconn;
William Lallemande7361152018-10-26 14:47:36 +02002927
2928 return 0;
2929
2930err:
2931 ha_alert("%s\n", err);
William Lallemand744a0892018-11-22 16:46:51 +01002932 free(err);
2933 free(bind_conf);
William Lallemande7361152018-10-26 14:47:36 +02002934 return -1;
2935
2936}
2937
2938/*
William Lallemandce83b4a2018-10-26 14:47:30 +02002939 * Create a new CLI socket using a socketpair for a worker process
2940 * <mworker_proc> is the process structure, and <proc> is the process number
2941 */
2942int mworker_cli_sockpair_new(struct mworker_proc *mworker_proc, int proc)
2943{
2944 struct bind_conf *bind_conf;
2945 struct listener *l;
2946 char *path = NULL;
2947 char *err = NULL;
2948
2949 /* master pipe to ensure the master is still alive */
2950 if (socketpair(AF_UNIX, SOCK_STREAM, 0, mworker_proc->ipc_fd) < 0) {
2951 ha_alert("Cannot create worker socketpair.\n");
2952 return -1;
2953 }
2954
2955 /* XXX: we might want to use a separate frontend at some point */
Willy Tarreau4975d142021-03-13 11:00:33 +01002956 if (!global.cli_fe) {
2957 if ((global.cli_fe = cli_alloc_fe("GLOBAL", "master-socket", 0)) == NULL) {
William Lallemandce83b4a2018-10-26 14:47:30 +02002958 ha_alert("out of memory trying to allocate the stats frontend");
William Lallemand744a0892018-11-22 16:46:51 +01002959 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002960 }
2961 }
2962
Willy Tarreau4975d142021-03-13 11:00:33 +01002963 bind_conf = bind_conf_alloc(global.cli_fe, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01002964 if (!bind_conf)
2965 goto error;
2966
William Lallemandce83b4a2018-10-26 14:47:30 +02002967 bind_conf->level &= ~ACCESS_LVL_MASK;
2968 bind_conf->level |= ACCESS_LVL_ADMIN; /* TODO: need to lower the rights with a CLI keyword*/
2969
Willy Tarreaue26993c2020-09-03 07:18:55 +02002970 bind_conf->settings.bind_proc = 1UL << proc;
Willy Tarreau4975d142021-03-13 11:00:33 +01002971 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 +02002972
2973 if (!memprintf(&path, "sockpair@%d", mworker_proc->ipc_fd[1])) {
2974 ha_alert("Cannot allocate listener.\n");
William Lallemand744a0892018-11-22 16:46:51 +01002975 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002976 }
2977
Willy Tarreau4975d142021-03-13 11:00:33 +01002978 if (!str2listener(path, global.cli_fe, bind_conf, "master-socket", 0, &err)) {
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01002979 free(path);
William Lallemandce83b4a2018-10-26 14:47:30 +02002980 ha_alert("Cannot create a CLI sockpair listener for process #%d\n", proc);
William Lallemand744a0892018-11-22 16:46:51 +01002981 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02002982 }
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002983 ha_free(&path);
William Lallemandce83b4a2018-10-26 14:47:30 +02002984
2985 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
William Lallemandce83b4a2018-10-26 14:47:30 +02002986 l->accept = session_accept_fd;
Willy Tarreau4975d142021-03-13 11:00:33 +01002987 l->default_target = global.cli_fe->default_target;
William Lallemanda3372292018-11-16 16:57:22 +01002988 l->options |= (LI_O_UNLIMITED | LI_O_NOSTOP);
Willy Tarreau4781b152021-04-06 13:53:36 +02002989 HA_ATOMIC_INC(&unstoppable_jobs);
William Lallemandce83b4a2018-10-26 14:47:30 +02002990 /* it's a sockpair but we don't want to keep the fd in the master */
Willy Tarreau43046fa2020-09-01 15:41:59 +02002991 l->rx.flags &= ~RX_F_INHERITED;
William Lallemandce83b4a2018-10-26 14:47:30 +02002992 l->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau18215cb2019-02-27 16:25:28 +01002993 global.maxsock++; /* for the listening socket */
William Lallemandce83b4a2018-10-26 14:47:30 +02002994 }
2995
2996 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01002997
2998error:
2999 close(mworker_proc->ipc_fd[0]);
3000 close(mworker_proc->ipc_fd[1]);
3001 free(err);
3002
3003 return -1;
William Lallemandce83b4a2018-10-26 14:47:30 +02003004}
3005
William Lallemand74c24fb2016-11-21 17:18:36 +01003006static struct applet cli_applet = {
3007 .obj_type = OBJ_TYPE_APPLET,
3008 .name = "<CLI>", /* used for logging */
3009 .fct = cli_io_handler,
3010 .release = cli_release_handler,
3011};
3012
William Lallemand99e0bb92020-11-05 10:28:53 +01003013/* master CLI */
3014static struct applet mcli_applet = {
3015 .obj_type = OBJ_TYPE_APPLET,
3016 .name = "<MCLI>", /* used for logging */
3017 .fct = cli_io_handler,
3018 .release = cli_release_handler,
3019};
3020
Willy Tarreau0a739292016-11-22 20:21:23 +01003021/* register cli keywords */
3022static struct cli_kw_list cli_kws = {{ },{
Willy Tarreaub205bfd2021-05-07 11:38:37 +02003023 { { "help", NULL }, NULL, cli_parse_simple, NULL, NULL, NULL, ACCESS_MASTER },
3024 { { "prompt", NULL }, NULL, cli_parse_simple, NULL, NULL, NULL, ACCESS_MASTER },
3025 { { "quit", NULL }, NULL, cli_parse_simple, NULL, NULL, NULL, ACCESS_MASTER },
3026 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
3027 { { "expert-mode", NULL }, NULL, cli_parse_expert_experimental_mode, NULL }, // not listed
3028 { { "experimental-mode", NULL }, NULL, cli_parse_expert_experimental_mode, NULL }, // not listed
3029 { { "set", "maxconn", "global", NULL }, "set maxconn global <value> : change the per-process maxconn setting", cli_parse_set_maxconn_global, NULL },
3030 { { "set", "rate-limit", NULL }, "set rate-limit <setting> <value> : change a rate limiting value", cli_parse_set_ratelimit, NULL },
3031 { { "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 },
3032 { { "set", "timeout", NULL }, "set timeout [cli] <delay> : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
3033 { { "show", "env", NULL }, "show env [var] : dump environment variables known to the process", cli_parse_show_env, cli_io_handler_show_env, NULL },
3034 { { "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 },
3035 { { "show", "cli", "level", NULL }, "show cli level : display the level of the current CLI session", cli_parse_show_lvl, NULL, NULL, NULL, ACCESS_MASTER},
3036 { { "show", "fd", NULL }, "show fd [num] : dump list of file descriptors in use or a specific one", cli_parse_show_fd, cli_io_handler_show_fd, NULL },
3037 { { "show", "activity", NULL }, "show activity : show per-thread activity stats (for support/developers)", cli_parse_default, cli_io_handler_show_activity, NULL },
William Lallemand7ceae112021-12-14 15:22:29 +01003038 { { "show", "version", NULL }, "show version : show version of the current process", cli_parse_show_version, NULL, NULL, NULL, ACCESS_MASTER },
Willy Tarreaub205bfd2021-05-07 11:38:37 +02003039 { { "operator", NULL }, "operator : lower the level of the current CLI session to operator", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
3040 { { "user", NULL }, "user : lower the level of the current CLI session to user", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
Willy Tarreau0a739292016-11-22 20:21:23 +01003041 {{},}
3042}};
3043
Willy Tarreau0108d902018-11-25 19:14:37 +01003044INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3045
William Lallemand74c24fb2016-11-21 17:18:36 +01003046static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau4975d142021-03-13 11:00:33 +01003047 { CFG_GLOBAL, "stats", cli_parse_global },
William Lallemand74c24fb2016-11-21 17:18:36 +01003048 { 0, NULL, NULL },
3049}};
3050
Willy Tarreau0108d902018-11-25 19:14:37 +01003051INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
3052
William Lallemand74c24fb2016-11-21 17:18:36 +01003053static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02003054 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
3055 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02003056 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01003057 { NULL, NULL, 0 },
3058}};
3059
Willy Tarreau0108d902018-11-25 19:14:37 +01003060INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01003061
3062/*
3063 * Local variables:
3064 * c-indent-level: 8
3065 * c-basic-offset: 8
3066 * End:
3067 */