blob: 86cc92503e70736429b24280d32fffdf8e019060 [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 Tarreau4c7e4b72020-05-27 12:58:42 +020029#include <haproxy/api.h>
Christopher Faulet6b0a0fb2022-04-04 11:29:28 +020030#include <haproxy/applet.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020031#include <haproxy/base64.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020032#include <haproxy/cfgparse.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020033#include <haproxy/channel.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020034#include <haproxy/check.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020035#include <haproxy/cli.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020036#include <haproxy/compression.h>
Willy Tarreaueb92deb2020-06-04 10:53:16 +020037#include <haproxy/dns-t.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020038#include <haproxy/errors.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020039#include <haproxy/fd.h>
40#include <haproxy/freq_ctr.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020041#include <haproxy/frontend.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020042#include <haproxy/global.h>
Willy Tarreau853b2972020-05-27 18:01:47 +020043#include <haproxy/list.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020044#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020045#include <haproxy/log.h>
William Lallemand3ba7c7b2021-11-10 10:57:18 +010046#include <haproxy/mworker.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 Tarreaufe0ba0e2023-05-11 17:06:22 +020053#include <haproxy/quic_sock.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020054#include <haproxy/sample-t.h>
Willy Tarreau5edca2f2022-05-27 09:25:10 +020055#include <haproxy/sc_strm.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020056#include <haproxy/server.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020057#include <haproxy/session.h>
Willy Tarreaua74cb382020-10-15 21:29:49 +020058#include <haproxy/sock.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020059#include <haproxy/stats-t.h>
Willy Tarreaucb086c62022-05-27 09:47:12 +020060#include <haproxy/stconn.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020061#include <haproxy/stream.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020062#include <haproxy/task.h>
Willy Tarreauc2f7c582020-06-02 18:15:32 +020063#include <haproxy/ticks.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020064#include <haproxy/time.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020065#include <haproxy/tools.h>
Willy Tarreaud6788052020-05-27 15:59:00 +020066#include <haproxy/version.h>
William Lallemand74c24fb2016-11-21 17:18:36 +010067
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020068#define PAYLOAD_PATTERN "<<"
69
William Lallemand74c24fb2016-11-21 17:18:36 +010070static struct applet cli_applet;
William Lallemand99e0bb92020-11-05 10:28:53 +010071static struct applet mcli_applet;
William Lallemand74c24fb2016-11-21 17:18:36 +010072
Willy Tarreau4975d142021-03-13 11:00:33 +010073static const char cli_permission_denied_msg[] =
William Lallemand74c24fb2016-11-21 17:18:36 +010074 "Permission denied\n"
75 "";
76
77
Christopher Faulet1bc04c72017-10-29 20:14:08 +010078static THREAD_LOCAL char *dynamic_usage_msg = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +010079
80/* List head of cli keywords */
81static struct cli_kw_list cli_keywords = {
82 .list = LIST_HEAD_INIT(cli_keywords.list)
83};
84
85extern const char *stat_status_codes[];
86
Eric Salama1b8dacc2021-03-16 15:12:17 +010087struct proxy *mworker_proxy; /* CLI proxy of the master */
William Lallemand56f73b22022-09-24 15:56:25 +020088struct bind_conf *mcli_reload_bind_conf;
William Lallemand8a022572018-10-26 14:47:35 +020089
Willy Tarreau307dbb32022-05-05 17:45:52 +020090/* CLI context for the "show env" command */
91struct show_env_ctx {
92 char **var; /* first variable to show */
93 int show_one; /* stop after showing the first one */
94};
95
Willy Tarreau741a5a92022-05-05 17:56:58 +020096/* CLI context for the "show fd" command */
Willy Tarreau1cb041a2023-03-31 16:33:53 +020097/* flags for show_fd_ctx->show_mask */
98#define CLI_SHOWFD_F_PI 0x00000001 /* pipes */
99#define CLI_SHOWFD_F_LI 0x00000002 /* listeners */
100#define CLI_SHOWFD_F_FE 0x00000004 /* frontend conns */
101#define CLI_SHOWFD_F_SV 0x00000010 /* server-only conns */
102#define CLI_SHOWFD_F_PX 0x00000020 /* proxy-only conns */
103#define CLI_SHOWFD_F_BE 0x00000030 /* backend: srv+px */
104#define CLI_SHOWFD_F_CO 0x00000034 /* conn: be+fe */
105#define CLI_SHOWFD_F_ANY 0x0000003f /* any type */
106
Willy Tarreau741a5a92022-05-05 17:56:58 +0200107struct show_fd_ctx {
108 int fd; /* first FD to show */
109 int show_one; /* stop after showing one FD */
Willy Tarreau1cb041a2023-03-31 16:33:53 +0200110 uint show_mask; /* CLI_SHOWFD_F_xxx */
Willy Tarreau741a5a92022-05-05 17:56:58 +0200111};
112
Willy Tarreaub128f492022-05-05 19:11:05 +0200113/* CLI context for the "show cli sockets" command */
114struct show_sock_ctx {
115 struct bind_conf *bind_conf;
116 struct listener *listener;
117};
118
Willy Tarreau92fbbcc2021-05-09 21:45:29 +0200119static int cmp_kw_entries(const void *a, const void *b)
120{
121 const struct cli_kw *l = *(const struct cli_kw **)a;
122 const struct cli_kw *r = *(const struct cli_kw **)b;
123
124 return strcmp(l->usage ? l->usage : "", r->usage ? r->usage : "");
125}
126
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100127/* This will show the help message and list the commands supported at the
128 * current level that match all of the first words of <args> if args is not
129 * NULL, or all args if none matches or if args is null.
130 */
131static char *cli_gen_usage_msg(struct appctx *appctx, char * const *args)
William Lallemand74c24fb2016-11-21 17:18:36 +0100132{
Willy Tarreau92fbbcc2021-05-09 21:45:29 +0200133 struct cli_kw *entries[CLI_MAX_HELP_ENTRIES];
William Lallemand74c24fb2016-11-21 17:18:36 +0100134 struct cli_kw_list *kw_list;
135 struct cli_kw *kw;
Willy Tarreau83061a82018-07-13 11:56:34 +0200136 struct buffer *tmp = get_trash_chunk();
137 struct buffer out;
Willy Tarreaub7364582021-03-12 18:24:46 +0100138 struct { struct cli_kw *kw; int dist; } matches[CLI_MAX_MATCHES], swp;
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100139 int idx;
Willy Tarreau0b1b8302021-05-09 20:59:23 +0200140 int ishelp = 0;
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100141 int length = 0;
Willy Tarreau92fbbcc2021-05-09 21:45:29 +0200142 int help_entries = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100143
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100144 ha_free(&dynamic_usage_msg);
William Lallemand74c24fb2016-11-21 17:18:36 +0100145
Willy Tarreau0b1b8302021-05-09 20:59:23 +0200146 if (args && *args && strcmp(*args, "help") == 0) {
147 args++;
148 ishelp = 1;
149 }
150
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100151 /* first, let's measure the longest match */
152 list_for_each_entry(kw_list, &cli_keywords.list, list) {
153 for (kw = &kw_list->kw[0]; kw->str_kw[0]; kw++) {
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100154 if (kw->level & ~appctx->cli_level & (ACCESS_MASTER_ONLY|ACCESS_EXPERT|ACCESS_EXPERIMENTAL))
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100155 continue;
William Lallemand2a171912022-02-02 11:43:20 +0100156 if (!(appctx->cli_level & ACCESS_MCLI_DEBUG) &&
157 (appctx->cli_level & ~kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)) ==
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100158 (ACCESS_MASTER_ONLY|ACCESS_MASTER))
159 continue;
160
161 /* OK this command is visible */
162 for (idx = 0; idx < CLI_PREFIX_KW_NB; idx++) {
163 if (!kw->str_kw[idx])
164 break; // end of keyword
165 if (!args || !args[idx] || !*args[idx])
166 break; // end of command line
167 if (strcmp(kw->str_kw[idx], args[idx]) != 0)
168 break;
169 if (idx + 1 > length)
170 length = idx + 1;
171 }
172 }
173 }
174
Willy Tarreaub7364582021-03-12 18:24:46 +0100175 /* now <length> equals the number of exactly matching words */
William Lallemand74c24fb2016-11-21 17:18:36 +0100176 chunk_reset(tmp);
Willy Tarreau0b1b8302021-05-09 20:59:23 +0200177 if (ishelp) // this is the help message.
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100178 chunk_strcat(tmp, "The following commands are valid at this level:\n");
Abhijeet Rastogic8601502022-11-17 04:42:38 -0800179 else {
180 chunk_strcat(tmp, "Unknown command: '");
181 if (args && *args)
182 chunk_strcat(tmp, *args);
183 chunk_strcat(tmp, "'");
184
185 if (!length && (!args || !*args || !**args)) // no match
186 chunk_strcat(tmp, ". Please enter one of the following commands only:\n");
187 else // partial match
188 chunk_strcat(tmp, ", but maybe one of the following ones is a better match:\n");
189 }
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100190
Willy Tarreaub7364582021-03-12 18:24:46 +0100191 for (idx = 0; idx < CLI_MAX_MATCHES; idx++) {
192 matches[idx].kw = NULL;
193 matches[idx].dist = INT_MAX;
194 }
195
196 /* In case of partial match we'll look for the best matching entries
197 * starting from position <length>
198 */
Willy Tarreau9c187472021-03-13 12:25:43 +0100199 if (args && args[length] && *args[length]) {
Willy Tarreaub7364582021-03-12 18:24:46 +0100200 list_for_each_entry(kw_list, &cli_keywords.list, list) {
201 for (kw = &kw_list->kw[0]; kw->str_kw[0]; kw++) {
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100202 if (kw->level & ~appctx->cli_level & (ACCESS_MASTER_ONLY|ACCESS_EXPERT|ACCESS_EXPERIMENTAL))
Willy Tarreaub7364582021-03-12 18:24:46 +0100203 continue;
William Lallemand2a171912022-02-02 11:43:20 +0100204 if (!(appctx->cli_level & ACCESS_MCLI_DEBUG) &&
205 ((appctx->cli_level & ~kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)) ==
206 (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
Willy Tarreaub7364582021-03-12 18:24:46 +0100207 continue;
208
209 for (idx = 0; idx < length; idx++) {
210 if (!kw->str_kw[idx])
211 break; // end of keyword
212 if (!args || !args[idx] || !*args[idx])
213 break; // end of command line
214 if (strcmp(kw->str_kw[idx], args[idx]) != 0)
215 break;
216 }
217
218 /* extra non-matching words are fuzzy-matched */
219 if (kw->usage && idx == length && args[idx] && *args[idx]) {
220 uint8_t word_sig[1024];
221 uint8_t list_sig[1024];
222 int dist = 0;
223 int totlen = 0;
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100224 int i;
Willy Tarreaub7364582021-03-12 18:24:46 +0100225
226 /* this one matches, let's compute the distance between the two
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100227 * on the remaining words. For this we're computing the signature
228 * of everything that remains and the cumulated length of the
229 * strings.
Willy Tarreaub7364582021-03-12 18:24:46 +0100230 */
Willy Tarreauc57dcfe2021-03-12 19:01:59 +0100231 memset(word_sig, 0, sizeof(word_sig));
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100232 for (i = idx; i < CLI_PREFIX_KW_NB && args[i] && *args[i]; i++) {
233 update_word_fingerprint(word_sig, args[i]);
234 totlen += strlen(args[i]);
235 }
Willy Tarreauc57dcfe2021-03-12 19:01:59 +0100236
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100237 memset(list_sig, 0, sizeof(list_sig));
238 for (i = idx; i < CLI_PREFIX_KW_NB && kw->str_kw[i]; i++) {
239 update_word_fingerprint(list_sig, kw->str_kw[i]);
240 totlen += strlen(kw->str_kw[i]);
Willy Tarreaub7364582021-03-12 18:24:46 +0100241 }
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100242
Willy Tarreauc57dcfe2021-03-12 19:01:59 +0100243 dist = word_fingerprint_distance(word_sig, list_sig);
Willy Tarreaub7364582021-03-12 18:24:46 +0100244
245 /* insert this one at its place if relevant, in order to keep only
246 * the best matches.
247 */
248 swp.kw = kw; swp.dist = dist;
Willy Tarreaua9aa6282021-03-15 10:00:29 +0100249 if (dist < 5*totlen/2 && dist < matches[CLI_MAX_MATCHES-1].dist) {
Willy Tarreaub7364582021-03-12 18:24:46 +0100250 matches[CLI_MAX_MATCHES-1] = swp;
251 for (idx = CLI_MAX_MATCHES - 1; --idx >= 0;) {
252 if (matches[idx+1].dist >= matches[idx].dist)
253 break;
254 matches[idx+1] = matches[idx];
255 matches[idx] = swp;
256 }
257 }
258 }
259 }
260 }
261 }
262
Willy Tarreauec197e82021-03-15 10:35:04 +0100263 if (matches[0].kw) {
264 /* we have fuzzy matches, let's propose them */
265 for (idx = 0; idx < CLI_MAX_MATCHES; idx++) {
266 kw = matches[idx].kw;
267 if (!kw)
268 break;
269
270 /* stop the dump if some words look very unlikely candidates */
271 if (matches[idx].dist > 5*matches[0].dist/2)
272 break;
273
Willy Tarreau92fbbcc2021-05-09 21:45:29 +0200274 if (help_entries < CLI_MAX_HELP_ENTRIES)
275 entries[help_entries++] = kw;
Willy Tarreauec197e82021-03-15 10:35:04 +0100276 }
277 }
278
William Lallemand74c24fb2016-11-21 17:18:36 +0100279 list_for_each_entry(kw_list, &cli_keywords.list, list) {
Willy Tarreauec197e82021-03-15 10:35:04 +0100280 /* no full dump if we've already found nice candidates */
281 if (matches[0].kw)
282 break;
283
Willy Tarreau91bc3592021-03-12 15:20:39 +0100284 for (kw = &kw_list->kw[0]; kw->str_kw[0]; kw++) {
William Lallemand14721be2018-10-26 14:47:37 +0200285
Willy Tarreau91bc3592021-03-12 15:20:39 +0100286 /* in a worker or normal process, don't display master-only commands
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100287 * nor expert/experimental mode commands if not in this mode.
Willy Tarreau91bc3592021-03-12 15:20:39 +0100288 */
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100289 if (kw->level & ~appctx->cli_level & (ACCESS_MASTER_ONLY|ACCESS_EXPERT|ACCESS_EXPERIMENTAL))
Willy Tarreau91bc3592021-03-12 15:20:39 +0100290 continue;
William Lallemand14721be2018-10-26 14:47:37 +0200291
William Lallemand2a171912022-02-02 11:43:20 +0100292 /* in master, if the CLI don't have the
293 * ACCESS_MCLI_DEBUG don't display commands that have
294 * neither the master bit nor the master-only bit.
Willy Tarreau91bc3592021-03-12 15:20:39 +0100295 */
William Lallemand2a171912022-02-02 11:43:20 +0100296 if (!(appctx->cli_level & ACCESS_MCLI_DEBUG) &&
297 ((appctx->cli_level & ~kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)) ==
298 (ACCESS_MASTER_ONLY|ACCESS_MASTER)))
Willy Tarreau91bc3592021-03-12 15:20:39 +0100299 continue;
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200300
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100301 for (idx = 0; idx < length; idx++) {
302 if (!kw->str_kw[idx])
303 break; // end of keyword
304 if (!args || !args[idx] || !*args[idx])
305 break; // end of command line
306 if (strcmp(kw->str_kw[idx], args[idx]) != 0)
307 break;
308 }
309
Willy Tarreau92fbbcc2021-05-09 21:45:29 +0200310 if (kw->usage && idx == length && help_entries < CLI_MAX_HELP_ENTRIES)
311 entries[help_entries++] = kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100312 }
313 }
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100314
Willy Tarreau92fbbcc2021-05-09 21:45:29 +0200315 qsort(entries, help_entries, sizeof(*entries), cmp_kw_entries);
316
317 for (idx = 0; idx < help_entries; idx++)
318 chunk_appendf(tmp, " %s\n", entries[idx]->usage);
319
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100320 /* always show the prompt/help/quit commands */
321 chunk_strcat(tmp,
Willy Tarreau0b1b8302021-05-09 20:59:23 +0200322 " help [<command>] : list matching or all commands\n"
Willy Tarreau22555572023-05-04 14:22:36 +0200323 " prompt [timed] : toggle interactive mode with prompt\n"
Willy Tarreaub205bfd2021-05-07 11:38:37 +0200324 " quit : disconnect\n");
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100325
William Lallemand74c24fb2016-11-21 17:18:36 +0100326 chunk_init(&out, NULL, 0);
327 chunk_dup(&out, tmp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200328 dynamic_usage_msg = out.area;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200329
Willy Tarreau1c0715b2022-05-06 17:16:35 +0200330 cli_msg(appctx, LOG_INFO, dynamic_usage_msg);
William Lallemand74c24fb2016-11-21 17:18:36 +0100331 return dynamic_usage_msg;
332}
333
334struct cli_kw* cli_find_kw(char **args)
335{
336 struct cli_kw_list *kw_list;
337 struct cli_kw *kw;/* current cli_kw */
338 char **tmp_args;
339 const char **tmp_str_kw;
340 int found = 0;
341
342 if (LIST_ISEMPTY(&cli_keywords.list))
343 return NULL;
344
345 list_for_each_entry(kw_list, &cli_keywords.list, list) {
346 kw = &kw_list->kw[0];
347 while (*kw->str_kw) {
348 tmp_args = args;
349 tmp_str_kw = kw->str_kw;
350 while (*tmp_str_kw) {
351 if (strcmp(*tmp_str_kw, *tmp_args) == 0) {
352 found = 1;
353 } else {
354 found = 0;
355 break;
356 }
357 tmp_args++;
358 tmp_str_kw++;
359 }
360 if (found)
361 return (kw);
362 kw++;
363 }
364 }
365 return NULL;
366}
367
Thierry Fourniera51a1fd2020-11-28 20:10:08 +0100368struct cli_kw* cli_find_kw_exact(char **args)
369{
370 struct cli_kw_list *kw_list;
371 int found = 0;
372 int i;
373 int j;
374
375 if (LIST_ISEMPTY(&cli_keywords.list))
376 return NULL;
377
378 list_for_each_entry(kw_list, &cli_keywords.list, list) {
379 for (i = 0; kw_list->kw[i].str_kw[0]; i++) {
380 found = 1;
381 for (j = 0; j < CLI_PREFIX_KW_NB; j++) {
382 if (args[j] == NULL && kw_list->kw[i].str_kw[j] == NULL) {
383 break;
384 }
385 if (args[j] == NULL || kw_list->kw[i].str_kw[j] == NULL) {
386 found = 0;
387 break;
388 }
389 if (strcmp(args[j], kw_list->kw[i].str_kw[j]) != 0) {
390 found = 0;
391 break;
392 }
393 }
394 if (found)
395 return &kw_list->kw[i];
396 }
397 }
398 return NULL;
399}
400
William Lallemand74c24fb2016-11-21 17:18:36 +0100401void cli_register_kw(struct cli_kw_list *kw_list)
402{
Willy Tarreau2b718102021-04-21 07:32:39 +0200403 LIST_APPEND(&cli_keywords.list, &kw_list->list);
William Lallemand74c24fb2016-11-21 17:18:36 +0100404}
405
Willy Tarreau06d0e2e2022-03-29 15:25:30 +0200406/* list all known keywords on stdout, one per line */
407void cli_list_keywords(void)
408{
409 struct cli_kw_list *kw_list;
Willy Tarreau44651712022-03-30 12:02:35 +0200410 struct cli_kw *kwp, *kwn, *kw;
Willy Tarreau06d0e2e2022-03-29 15:25:30 +0200411 int idx;
412
Willy Tarreau44651712022-03-30 12:02:35 +0200413 for (kwn = kwp = NULL;; kwp = kwn) {
414 list_for_each_entry(kw_list, &cli_keywords.list, list) {
415 /* note: we sort based on the usage message when available,
416 * otherwise we fall back to the first keyword.
417 */
418 for (kw = &kw_list->kw[0]; kw->str_kw[0]; kw++) {
419 if (strordered(kwp ? kwp->usage ? kwp->usage : kwp->str_kw[0] : NULL,
420 kw->usage ? kw->usage : kw->str_kw[0],
421 kwn != kwp ? kwn->usage ? kwn->usage : kwn->str_kw[0] : NULL))
422 kwn = kw;
Willy Tarreau06d0e2e2022-03-29 15:25:30 +0200423 }
Willy Tarreau44651712022-03-30 12:02:35 +0200424 }
425
426 if (kwn == kwp)
427 break;
428
429 for (idx = 0; kwn->str_kw[idx]; idx++) {
430 printf("%s ", kwn->str_kw[idx]);
Willy Tarreau06d0e2e2022-03-29 15:25:30 +0200431 }
Willy Tarreau44651712022-03-30 12:02:35 +0200432 if (kwn->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER))
433 printf("[MASTER] ");
434 if (!(kwn->level & ACCESS_MASTER_ONLY))
435 printf("[WORKER] ");
436 if (kwn->level & ACCESS_EXPERT)
437 printf("[EXPERT] ");
438 if (kwn->level & ACCESS_EXPERIMENTAL)
439 printf("[EXPERIM] ");
440 printf("\n");
Willy Tarreau06d0e2e2022-03-29 15:25:30 +0200441 }
442}
William Lallemand74c24fb2016-11-21 17:18:36 +0100443
444/* allocate a new stats frontend named <name>, and return it
445 * (or NULL in case of lack of memory).
446 */
Willy Tarreau4975d142021-03-13 11:00:33 +0100447static struct proxy *cli_alloc_fe(const char *name, const char *file, int line)
William Lallemand74c24fb2016-11-21 17:18:36 +0100448{
449 struct proxy *fe;
450
451 fe = calloc(1, sizeof(*fe));
452 if (!fe)
453 return NULL;
454
455 init_new_proxy(fe);
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100456 fe->next = proxies_list;
457 proxies_list = fe;
Willy Tarreau69530f52023-04-28 09:16:15 +0200458 fe->last_change = ns_to_sec(now_ns);
William Lallemand74c24fb2016-11-21 17:18:36 +0100459 fe->id = strdup("GLOBAL");
William Lallemand6640dbb2021-08-13 15:31:33 +0200460 fe->cap = PR_CAP_FE|PR_CAP_INT;
William Lallemand74c24fb2016-11-21 17:18:36 +0100461 fe->maxconn = 10; /* default to 10 concurrent connections */
462 fe->timeout.client = MS_TO_TICKS(10000); /* default timeout of 10 seconds */
463 fe->conf.file = strdup(file);
464 fe->conf.line = line;
465 fe->accept = frontend_accept;
466 fe->default_target = &cli_applet.obj_type;
467
468 /* the stats frontend is the only one able to assign ID #0 */
469 fe->conf.id.key = fe->uuid = 0;
470 eb32_insert(&used_proxy_id, &fe->conf.id);
471 return fe;
472}
473
474/* This function parses a "stats" statement in the "global" section. It returns
475 * -1 if there is any error, otherwise zero. If it returns -1, it will write an
476 * error message into the <err> buffer which will be preallocated. The trailing
477 * '\n' must not be written. The function must be called with <args> pointing to
478 * the first word after "stats".
479 */
Willy Tarreau4975d142021-03-13 11:00:33 +0100480static int cli_parse_global(char **args, int section_type, struct proxy *curpx,
481 const struct proxy *defpx, const char *file, int line,
482 char **err)
William Lallemand74c24fb2016-11-21 17:18:36 +0100483{
484 struct bind_conf *bind_conf;
485 struct listener *l;
486
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100487 if (strcmp(args[1], "socket") == 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100488 int cur_arg;
489
490 if (*args[2] == 0) {
491 memprintf(err, "'%s %s' in global section expects an address or a path to a UNIX socket", args[0], args[1]);
492 return -1;
493 }
494
Willy Tarreau4975d142021-03-13 11:00:33 +0100495 if (!global.cli_fe) {
496 if ((global.cli_fe = cli_alloc_fe("GLOBAL", file, line)) == NULL) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100497 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
498 return -1;
499 }
500 }
501
Willy Tarreau4975d142021-03-13 11:00:33 +0100502 bind_conf = bind_conf_alloc(global.cli_fe, file, line, args[2], xprt_get(XPRT_RAW));
Christopher Faulet0c6d1dc2021-04-12 16:56:37 +0200503 if (!bind_conf) {
504 memprintf(err, "'%s %s' : out of memory trying to allocate a bind_conf", args[0], args[1]);
505 return -1;
506 }
William Lallemand07a62f72017-05-24 00:57:40 +0200507 bind_conf->level &= ~ACCESS_LVL_MASK;
508 bind_conf->level |= ACCESS_LVL_OPER; /* default access level */
William Lallemand74c24fb2016-11-21 17:18:36 +0100509
Willy Tarreau4975d142021-03-13 11:00:33 +0100510 if (!str2listener(args[2], global.cli_fe, bind_conf, file, line, err)) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100511 memprintf(err, "parsing [%s:%d] : '%s %s' : %s\n",
512 file, line, args[0], args[1], err && *err ? *err : "error");
513 return -1;
514 }
515
516 cur_arg = 3;
517 while (*args[cur_arg]) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100518 struct bind_kw *kw;
Willy Tarreau433b05f2021-03-12 10:14:07 +0100519 const char *best;
Willy Tarreau0a1e1cb2021-11-20 20:10:41 +0100520 int code;
William Lallemand74c24fb2016-11-21 17:18:36 +0100521
522 kw = bind_find_kw(args[cur_arg]);
523 if (kw) {
524 if (!kw->parse) {
525 memprintf(err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
526 args[0], args[1], args[cur_arg]);
527 return -1;
528 }
529
Willy Tarreau0a1e1cb2021-11-20 20:10:41 +0100530 code = kw->parse(args, cur_arg, global.cli_fe, bind_conf, err);
531
532 /* FIXME: this is ugly, we don't have a way to collect warnings,
533 * yet some important bind keywords may report warnings that we
534 * must display.
535 */
536 if (((code & (ERR_WARN|ERR_FATAL|ERR_ALERT)) == ERR_WARN) && err && *err) {
537 indent_msg(err, 2);
538 ha_warning("parsing [%s:%d] : '%s %s' : %s\n", file, line, args[0], args[1], *err);
539 ha_free(err);
540 }
541
542 if (code & ~ERR_WARN) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100543 if (err && *err)
544 memprintf(err, "'%s %s' : '%s'", args[0], args[1], *err);
545 else
546 memprintf(err, "'%s %s' : error encountered while processing '%s'",
547 args[0], args[1], args[cur_arg]);
548 return -1;
549 }
550
551 cur_arg += 1 + kw->skip;
552 continue;
553 }
554
Willy Tarreau433b05f2021-03-12 10:14:07 +0100555 best = bind_find_best_kw(args[cur_arg]);
556 if (best)
557 memprintf(err, "'%s %s' : unknown keyword '%s'. Did you mean '%s' maybe ?",
558 args[0], args[1], args[cur_arg], best);
559 else
560 memprintf(err, "'%s %s' : unknown keyword '%s'.",
561 args[0], args[1], args[cur_arg]);
William Lallemand74c24fb2016-11-21 17:18:36 +0100562 return -1;
563 }
564
Willy Tarreau30836152023-01-12 19:10:17 +0100565 bind_conf->accept = session_accept_fd;
Willy Tarreau7dbd4182023-01-12 19:32:45 +0100566 bind_conf->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau17146802023-01-12 19:58:42 +0100567 bind_conf->options |= BC_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreaud5983ce2023-01-12 19:18:34 +0100568
William Lallemand74c24fb2016-11-21 17:18:36 +0100569 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
Willy Tarreau18215cb2019-02-27 16:25:28 +0100570 global.maxsock++; /* for the listening socket */
William Lallemand74c24fb2016-11-21 17:18:36 +0100571 }
572 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100573 else if (strcmp(args[1], "timeout") == 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100574 unsigned timeout;
575 const char *res = parse_time_err(args[2], &timeout, TIME_UNIT_MS);
576
Willy Tarreau9faebe32019-06-07 19:00:37 +0200577 if (res == PARSE_TIME_OVER) {
578 memprintf(err, "timer overflow in argument '%s' to '%s %s' (maximum value is 2147483647 ms or ~24.8 days)",
579 args[2], args[0], args[1]);
580 return -1;
581 }
582 else if (res == PARSE_TIME_UNDER) {
583 memprintf(err, "timer underflow in argument '%s' to '%s %s' (minimum non-null value is 1 ms)",
584 args[2], args[0], args[1]);
585 return -1;
586 }
587 else if (res) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100588 memprintf(err, "'%s %s' : unexpected character '%c'", args[0], args[1], *res);
589 return -1;
590 }
591
592 if (!timeout) {
593 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
594 return -1;
595 }
Willy Tarreau4975d142021-03-13 11:00:33 +0100596 if (!global.cli_fe) {
597 if ((global.cli_fe = cli_alloc_fe("GLOBAL", file, line)) == NULL) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100598 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
599 return -1;
600 }
601 }
Willy Tarreau4975d142021-03-13 11:00:33 +0100602 global.cli_fe->timeout.client = MS_TO_TICKS(timeout);
William Lallemand74c24fb2016-11-21 17:18:36 +0100603 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100604 else if (strcmp(args[1], "maxconn") == 0) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100605 int maxconn = atol(args[2]);
606
607 if (maxconn <= 0) {
608 memprintf(err, "'%s %s' expects a positive value", args[0], args[1]);
609 return -1;
610 }
611
Willy Tarreau4975d142021-03-13 11:00:33 +0100612 if (!global.cli_fe) {
613 if ((global.cli_fe = cli_alloc_fe("GLOBAL", file, line)) == NULL) {
William Lallemand74c24fb2016-11-21 17:18:36 +0100614 memprintf(err, "'%s %s' : out of memory trying to allocate a frontend", args[0], args[1]);
615 return -1;
616 }
617 }
Willy Tarreau4975d142021-03-13 11:00:33 +0100618 global.cli_fe->maxconn = maxconn;
William Lallemand74c24fb2016-11-21 17:18:36 +0100619 }
Willy Tarreau94f763b2022-07-15 17:14:40 +0200620 else if (strcmp(args[1], "bind-process") == 0) {
Willy Tarreau023c3112023-04-23 09:40:56 +0200621 memprintf(err, "'%s %s' is not supported anymore.", args[0], args[1]);
Willy Tarreau94f763b2022-07-15 17:14:40 +0200622 return -1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100623 }
624 else {
625 memprintf(err, "'%s' only supports 'socket', 'maxconn', 'bind-process' and 'timeout' (got '%s')", args[0], args[1]);
626 return -1;
627 }
628 return 0;
629}
630
William Lallemand33d29e22019-04-01 11:30:06 +0200631/*
William Lallemand9a37fd02019-04-12 16:09:24 +0200632 * This function exports the bound addresses of a <frontend> in the environment
633 * variable <varname>. Those addresses are separated by semicolons and prefixed
634 * with their type (abns@, unix@, sockpair@ etc)
635 * Return -1 upon error, 0 otherwise
William Lallemand33d29e22019-04-01 11:30:06 +0200636 */
William Lallemand9a37fd02019-04-12 16:09:24 +0200637int listeners_setenv(struct proxy *frontend, const char *varname)
William Lallemand33d29e22019-04-01 11:30:06 +0200638{
639 struct buffer *trash = get_trash_chunk();
640 struct bind_conf *bind_conf;
641
William Lallemand9a37fd02019-04-12 16:09:24 +0200642 if (frontend) {
643 list_for_each_entry(bind_conf, &frontend->conf.bind, by_fe) {
William Lallemand33d29e22019-04-01 11:30:06 +0200644 struct listener *l;
645
646 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
647 char addr[46];
648 char port[6];
649
William Lallemand620072b2019-04-12 16:09:25 +0200650 /* separate listener by semicolons */
651 if (trash->data)
652 chunk_appendf(trash, ";");
653
Willy Tarreau37159062020-08-27 07:48:42 +0200654 if (l->rx.addr.ss_family == AF_UNIX) {
William Lallemand33d29e22019-04-01 11:30:06 +0200655 const struct sockaddr_un *un;
656
Willy Tarreau37159062020-08-27 07:48:42 +0200657 un = (struct sockaddr_un *)&l->rx.addr;
William Lallemand33d29e22019-04-01 11:30:06 +0200658 if (un->sun_path[0] == '\0') {
659 chunk_appendf(trash, "abns@%s", un->sun_path+1);
660 } else {
661 chunk_appendf(trash, "unix@%s", un->sun_path);
662 }
Willy Tarreau37159062020-08-27 07:48:42 +0200663 } else if (l->rx.addr.ss_family == AF_INET) {
664 addr_to_str(&l->rx.addr, addr, sizeof(addr));
665 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemand33d29e22019-04-01 11:30:06 +0200666 chunk_appendf(trash, "ipv4@%s:%s", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +0200667 } else if (l->rx.addr.ss_family == AF_INET6) {
668 addr_to_str(&l->rx.addr, addr, sizeof(addr));
669 port_to_str(&l->rx.addr, port, sizeof(port));
William Lallemand33d29e22019-04-01 11:30:06 +0200670 chunk_appendf(trash, "ipv6@[%s]:%s", addr, port);
Willy Tarreau37159062020-08-27 07:48:42 +0200671 } else if (l->rx.addr.ss_family == AF_CUST_SOCKPAIR) {
672 chunk_appendf(trash, "sockpair@%d", ((struct sockaddr_in *)&l->rx.addr)->sin_addr.s_addr);
William Lallemand33d29e22019-04-01 11:30:06 +0200673 }
William Lallemand33d29e22019-04-01 11:30:06 +0200674 }
675 }
676 trash->area[trash->data++] = '\0';
William Lallemand9a37fd02019-04-12 16:09:24 +0200677 if (setenv(varname, trash->area, 1) < 0)
William Lallemand33d29e22019-04-01 11:30:06 +0200678 return -1;
679 }
680
681 return 0;
682}
683
William Lallemand9a37fd02019-04-12 16:09:24 +0200684int cli_socket_setenv()
685{
Willy Tarreau4975d142021-03-13 11:00:33 +0100686 if (listeners_setenv(global.cli_fe, "HAPROXY_CLI") < 0)
William Lallemand9a37fd02019-04-12 16:09:24 +0200687 return -1;
688 if (listeners_setenv(mworker_proxy, "HAPROXY_MASTER_CLI") < 0)
689 return -1;
690
691 return 0;
692}
693
William Lallemand33d29e22019-04-01 11:30:06 +0200694REGISTER_CONFIG_POSTPARSER("cli", cli_socket_setenv);
695
Willy Tarreaude57a572016-11-23 17:01:39 +0100696/* Verifies that the CLI at least has a level at least as high as <level>
697 * (typically ACCESS_LVL_ADMIN). Returns 1 if OK, otherwise 0. In case of
698 * failure, an error message is prepared and the appctx's state is adjusted
699 * to print it so that a return 1 is enough to abort any processing.
700 */
701int cli_has_level(struct appctx *appctx, int level)
702{
Willy Tarreaude57a572016-11-23 17:01:39 +0100703
William Lallemandf630d012018-12-13 09:05:44 +0100704 if ((appctx->cli_level & ACCESS_LVL_MASK) < level) {
Willy Tarreau4975d142021-03-13 11:00:33 +0100705 cli_err(appctx, cli_permission_denied_msg);
Willy Tarreaude57a572016-11-23 17:01:39 +0100706 return 0;
707 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100708 return 1;
709}
710
William Lallemandb7ea1412018-12-13 09:05:47 +0100711/* same as cli_has_level but for the CLI proxy and without error message */
712int pcli_has_level(struct stream *s, int level)
713{
714 if ((s->pcli_flags & ACCESS_LVL_MASK) < level) {
715 return 0;
716 }
717 return 1;
718}
719
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200720/* Returns severity_output for the current session if set, or default for the socket */
721static int cli_get_severity_output(struct appctx *appctx)
722{
723 if (appctx->cli_severity_output)
724 return appctx->cli_severity_output;
Willy Tarreau0698c802022-05-11 14:09:57 +0200725 return strm_li(appctx_strm(appctx))->bind_conf->severity_output;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200726}
William Lallemand74c24fb2016-11-21 17:18:36 +0100727
Willy Tarreau41908562016-11-24 16:23:38 +0100728/* Processes the CLI interpreter on the stats socket. This function is called
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100729 * from the CLI's IO handler running in an appctx context. The function returns
730 * 1 if the request was understood, otherwise zero (in which case an error
731 * message will be displayed). It is called with appctx->st0
Willy Tarreau41908562016-11-24 16:23:38 +0100732 * set to CLI_ST_GETREQ and presets ->st2 to 0 so that parsers don't have to do
733 * it. It will possilbly leave st0 to CLI_ST_CALLBACK if the keyword needs to
734 * have its own I/O handler called again. Most of the time, parsers will only
735 * set st0 to CLI_ST_PRINT and put their message to be displayed into cli.msg.
Willy Tarreaueaffde32016-12-16 17:59:25 +0100736 * If a keyword parser is NULL and an I/O handler is declared, the I/O handler
737 * will automatically be used.
William Lallemand74c24fb2016-11-21 17:18:36 +0100738 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200739static int cli_parse_request(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +0100740{
Willy Tarreauf14c7572021-03-13 10:59:23 +0100741 char *args[MAX_CLI_ARGS + 1], *p, *end, *payload = NULL;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200742 int i = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100743 struct cli_kw *kw;
William Lallemand74c24fb2016-11-21 17:18:36 +0100744
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200745 p = appctx->chunk->area;
746 end = p + appctx->chunk->data;
William Lallemand74c24fb2016-11-21 17:18:36 +0100747
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200748 /*
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200749 * Get pointers on words.
750 * One extra slot is reserved to store a pointer on a null byte.
751 */
Willy Tarreauf14c7572021-03-13 10:59:23 +0100752 while (i < MAX_CLI_ARGS && p < end) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200753 int j, k;
William Lallemand74c24fb2016-11-21 17:18:36 +0100754
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200755 /* skip leading spaces/tabs */
756 p += strspn(p, " \t");
757 if (!*p)
758 break;
Willy Tarreauf2dda522021-09-17 11:07:45 +0200759
760 if (strcmp(p, PAYLOAD_PATTERN) == 0) {
761 /* payload pattern recognized here, this is not an arg anymore,
762 * the payload starts at the first byte that follows the zero
763 * after the pattern.
764 */
765 payload = p + strlen(PAYLOAD_PATTERN) + 1;
766 break;
767 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100768
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200769 args[i] = p;
Yves Lafonb08c6d02020-06-08 16:08:06 +0200770 while (1) {
771 p += strcspn(p, " \t\\");
772 /* escaped chars using backlashes (\) */
773 if (*p == '\\') {
774 if (!*++p)
775 break;
776 if (!*++p)
777 break;
778 } else {
779 break;
780 }
781 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200782 *p++ = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100783
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200784 /* unescape backslashes (\) */
785 for (j = 0, k = 0; args[i][k]; k++) {
786 if (args[i][k] == '\\') {
787 if (args[i][k + 1] == '\\')
788 k++;
Dragan Dosena1c35ab2016-11-24 11:33:12 +0100789 else
790 continue;
791 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200792 args[i][j] = args[i][k];
William Lallemand74c24fb2016-11-21 17:18:36 +0100793 j++;
794 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200795 args[i][j] = 0;
William Lallemand74c24fb2016-11-21 17:18:36 +0100796
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200797 i++;
798 }
799 /* fill unused slots */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200800 p = appctx->chunk->area + appctx->chunk->data;
Willy Tarreauf14c7572021-03-13 10:59:23 +0100801 for (; i < MAX_CLI_ARGS + 1; i++)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200802 args[i] = p;
Willy Tarreau41908562016-11-24 16:23:38 +0100803
Willy Tarreau21d71252023-05-11 16:32:56 +0200804 if (!**args)
805 return 0;
806
Willy Tarreau41908562016-11-24 16:23:38 +0100807 kw = cli_find_kw(args);
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100808 if (!kw ||
809 (kw->level & ~appctx->cli_level & ACCESS_MASTER_ONLY) ||
William Lallemand2a171912022-02-02 11:43:20 +0100810 (!(appctx->cli_level & ACCESS_MCLI_DEBUG) &&
811 (appctx->cli_level & ~kw->level & (ACCESS_MASTER_ONLY|ACCESS_MASTER)) == (ACCESS_MASTER_ONLY|ACCESS_MASTER))) {
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100812 /* keyword not found in this mode */
Willy Tarreaub96a74c2021-03-12 17:13:28 +0100813 cli_gen_usage_msg(appctx, args);
Willy Tarreau41908562016-11-24 16:23:38 +0100814 return 0;
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100815 }
William Lallemand14721be2018-10-26 14:47:37 +0200816
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100817 /* don't handle expert mode commands if not in this mode. */
818 if (kw->level & ~appctx->cli_level & ACCESS_EXPERT) {
819 cli_err(appctx, "This command is restricted to expert mode only.\n");
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200820 return 0;
Willy Tarreauf3697dd2021-03-12 15:57:47 +0100821 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +0200822
Amaury Denoyelle18487fb2021-03-18 15:32:53 +0100823 if (kw->level & ~appctx->cli_level & ACCESS_EXPERIMENTAL) {
824 cli_err(appctx, "This command is restricted to experimental mode only.\n");
825 return 0;
826 }
827
Amaury Denoyellef4929922021-05-05 16:29:23 +0200828 if (kw->level == ACCESS_EXPERT)
829 mark_tainted(TAINTED_CLI_EXPERT_MODE);
830 else if (kw->level == ACCESS_EXPERIMENTAL)
831 mark_tainted(TAINTED_CLI_EXPERIMENTAL_MODE);
832
Willy Tarreau41908562016-11-24 16:23:38 +0100833 appctx->io_handler = kw->io_handler;
Emeric Brund6871f72017-06-29 19:54:13 +0200834 appctx->io_release = kw->io_release;
William Lallemand90b098c2019-10-25 21:10:14 +0200835
836 if (kw->parse && kw->parse(args, payload, appctx, kw->private) != 0)
837 goto fail;
838
839 /* kw->parse could set its own io_handler or io_release handler */
840 if (!appctx->io_handler)
841 goto fail;
842
843 appctx->st0 = CLI_ST_CALLBACK;
844 return 1;
845fail:
846 appctx->io_handler = NULL;
847 appctx->io_release = NULL;
Willy Tarreau41908562016-11-24 16:23:38 +0100848 return 1;
William Lallemand74c24fb2016-11-21 17:18:36 +0100849}
850
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200851/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
Christopher Faulete8ee27b2023-05-05 10:56:00 +0200852static int cli_output_msg(struct appctx *appctx, const char *msg, int severity, int severity_output)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200853{
Willy Tarreau83061a82018-07-13 11:56:34 +0200854 struct buffer *tmp;
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200855
856 if (likely(severity_output == CLI_SEVERITY_NONE))
Christopher Faulete8ee27b2023-05-05 10:56:00 +0200857 return applet_putstr(appctx, msg);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200858
859 tmp = get_trash_chunk();
860 chunk_reset(tmp);
861
862 if (severity < 0 || severity > 7) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100863 ha_warning("socket command feedback with invalid severity %d", severity);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200864 chunk_printf(tmp, "[%d]: ", severity);
865 }
866 else {
867 switch (severity_output) {
868 case CLI_SEVERITY_NUMBER:
869 chunk_printf(tmp, "[%d]: ", severity);
870 break;
871 case CLI_SEVERITY_STRING:
872 chunk_printf(tmp, "[%s]: ", log_levels[severity]);
873 break;
874 default:
Christopher Faulet767a84b2017-11-24 16:50:31 +0100875 ha_warning("Unrecognized severity output %d", severity_output);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200876 }
877 }
878 chunk_appendf(tmp, "%s", msg);
879
Christopher Faulete8ee27b2023-05-05 10:56:00 +0200880 return applet_putchk(appctx, tmp);
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200881}
882
Willy Tarreau4596fe22022-05-17 19:07:51 +0200883/* This I/O handler runs as an applet embedded in a stream connector. It is
William Lallemand74c24fb2016-11-21 17:18:36 +0100884 * used to processes I/O from/to the stats unix socket. The system relies on a
885 * state machine handling requests and various responses. We read a request,
886 * then we process it and send the response, and we possibly display a prompt.
887 * Then we can read again. The state is stored in appctx->st0 and is one of the
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100888 * CLI_ST_* constants. appctx->st1 is used to indicate whether prompt is enabled
William Lallemand74c24fb2016-11-21 17:18:36 +0100889 * or not.
890 */
891static void cli_io_handler(struct appctx *appctx)
892{
Willy Tarreauc12b3212022-05-27 11:08:15 +0200893 struct stconn *sc = appctx_sc(appctx);
Willy Tarreau475e4632022-05-27 10:26:46 +0200894 struct channel *req = sc_oc(sc);
895 struct channel *res = sc_ic(sc);
896 struct bind_conf *bind_conf = strm_li(__sc_strm(sc))->bind_conf;
William Lallemand74c24fb2016-11-21 17:18:36 +0100897 int reql;
898 int len;
899
Christopher Faulet1fb97e42023-04-07 18:07:51 +0200900 if (unlikely(se_fl_test(appctx->sedesc, (SE_FL_EOS|SE_FL_ERROR|SE_FL_SHR|SE_FL_SHW)))) {
901 co_skip(sc_oc(sc), co_data(sc_oc(sc)));
William Lallemand74c24fb2016-11-21 17:18:36 +0100902 goto out;
Christopher Faulet1fb97e42023-04-07 18:07:51 +0200903 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100904
Joseph Herlant008b3ce2018-11-25 12:51:45 -0800905 /* Check if the input buffer is available. */
Christopher Faulet2fd0c762023-03-31 10:25:07 +0200906 if (!b_size(&res->buf)) {
Christopher Faulet7b3d38a2023-05-05 11:28:45 +0200907 sc_need_room(sc, 0);
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100908 goto out;
909 }
910
William Lallemand74c24fb2016-11-21 17:18:36 +0100911 while (1) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100912 if (appctx->st0 == CLI_ST_INIT) {
Andjelko Iharosc4df59e2017-07-20 11:59:48 +0200913 /* reset severity to default at init */
914 appctx->cli_severity_output = bind_conf->severity_output;
Willy Tarreau1addf8b2022-08-18 18:04:37 +0200915 applet_reset_svcctx(appctx);
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100916 appctx->st0 = CLI_ST_GETREQ;
William Lallemandf630d012018-12-13 09:05:44 +0100917 appctx->cli_level = bind_conf->level;
William Lallemand74c24fb2016-11-21 17:18:36 +0100918 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100919 else if (appctx->st0 == CLI_ST_END) {
Christopher Faulet2fd0c762023-03-31 10:25:07 +0200920 se_fl_set(appctx->sedesc, SE_FL_EOS);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200921 free_trash_chunk(appctx->chunk);
Willy Tarreau18b2a9d2021-05-04 16:27:45 +0200922 appctx->chunk = NULL;
William Lallemand74c24fb2016-11-21 17:18:36 +0100923 break;
924 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100925 else if (appctx->st0 == CLI_ST_GETREQ) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200926 char *str;
927
928 /* use a trash chunk to store received data */
929 if (!appctx->chunk) {
930 appctx->chunk = alloc_trash_chunk();
931 if (!appctx->chunk) {
Christopher Faulet2fd0c762023-03-31 10:25:07 +0200932 se_fl_set(appctx->sedesc, SE_FL_ERROR);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200933 appctx->st0 = CLI_ST_END;
934 continue;
935 }
936 }
937
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200938 str = appctx->chunk->area + appctx->chunk->data;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200939
William Lallemand74c24fb2016-11-21 17:18:36 +0100940 /* ensure we have some output room left in the event we
941 * would want to return some info right after parsing.
942 */
Willy Tarreau475e4632022-05-27 10:26:46 +0200943 if (buffer_almost_full(sc_ib(sc))) {
Christopher Faulet7b3d38a2023-05-05 11:28:45 +0200944 sc_need_room(sc, b_size(&res->buf) / 2);
William Lallemand74c24fb2016-11-21 17:18:36 +0100945 break;
946 }
947
Willy Tarreau0011c252022-01-19 17:23:52 +0100948 /* payload doesn't take escapes nor does it end on semi-colons, so
949 * we use the regular getline. Normal mode however must stop on
950 * LFs and semi-colons that are not prefixed by a backslash. Note
951 * that we reserve one byte at the end to insert a trailing nul byte.
952 */
953
954 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Willy Tarreau475e4632022-05-27 10:26:46 +0200955 reql = co_getline(sc_oc(sc), str,
Willy Tarreau0011c252022-01-19 17:23:52 +0100956 appctx->chunk->size - appctx->chunk->data - 1);
957 else
Willy Tarreau475e4632022-05-27 10:26:46 +0200958 reql = co_getdelim(sc_oc(sc), str,
Willy Tarreau0011c252022-01-19 17:23:52 +0100959 appctx->chunk->size - appctx->chunk->data - 1,
960 "\n;", '\\');
961
William Lallemand74c24fb2016-11-21 17:18:36 +0100962 if (reql <= 0) { /* closed or EOL not found */
963 if (reql == 0)
964 break;
Christopher Faulet2fd0c762023-03-31 10:25:07 +0200965 se_fl_set(appctx->sedesc, SE_FL_ERROR);
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100966 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100967 continue;
968 }
969
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200970 if (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)) {
971 /* seek for a possible unescaped semi-colon. If we find
972 * one, we replace it with an LF and skip only this part.
973 */
974 for (len = 0; len < reql; len++) {
975 if (str[len] == '\\') {
976 len++;
977 continue;
978 }
979 if (str[len] == ';') {
980 str[len] = '\n';
981 reql = len + 1;
982 break;
983 }
William Lallemand74c24fb2016-11-21 17:18:36 +0100984 }
985 }
986
987 /* now it is time to check that we have a full line,
988 * remove the trailing \n and possibly \r, then cut the
989 * line.
990 */
991 len = reql - 1;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200992 if (str[len] != '\n') {
Christopher Faulet2fd0c762023-03-31 10:25:07 +0200993 se_fl_set(appctx->sedesc, SE_FL_ERROR);
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100994 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +0100995 continue;
996 }
997
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200998 if (len && str[len-1] == '\r')
William Lallemand74c24fb2016-11-21 17:18:36 +0100999 len--;
1000
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001001 str[len] = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001002 appctx->chunk->data += len;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001003
1004 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001005 appctx->chunk->area[appctx->chunk->data] = '\n';
1006 appctx->chunk->area[appctx->chunk->data + 1] = 0;
1007 appctx->chunk->data++;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001008 }
William Lallemand74c24fb2016-11-21 17:18:36 +01001009
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001010 appctx->st0 = CLI_ST_PROMPT;
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001011
1012 if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD) {
1013 /* empty line */
1014 if (!len) {
1015 /* remove the last two \n */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001016 appctx->chunk->data -= 2;
1017 appctx->chunk->area[appctx->chunk->data] = 0;
Willy Tarreauf3697dd2021-03-12 15:57:47 +01001018 cli_parse_request(appctx);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001019 chunk_reset(appctx->chunk);
1020 /* NB: cli_sock_parse_request() may have put
1021 * another CLI_ST_O_* into appctx->st0.
1022 */
1023
1024 appctx->st1 &= ~APPCTX_CLI_ST1_PAYLOAD;
William Lallemand74c24fb2016-11-21 17:18:36 +01001025 }
William Lallemand74c24fb2016-11-21 17:18:36 +01001026 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001027 else {
1028 /*
1029 * Look for the "payload start" pattern at the end of a line
1030 * Its location is not remembered here, this is just to switch
1031 * to a gathering mode.
William Lallemand74c24fb2016-11-21 17:18:36 +01001032 */
Willy Tarreauf2dda522021-09-17 11:07:45 +02001033 if (strcmp(appctx->chunk->area + appctx->chunk->data - strlen(PAYLOAD_PATTERN), PAYLOAD_PATTERN) == 0) {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001034 appctx->st1 |= APPCTX_CLI_ST1_PAYLOAD;
Willy Tarreauf2dda522021-09-17 11:07:45 +02001035 appctx->chunk->data++; // keep the trailing \0 after '<<'
1036 }
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001037 else {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001038 /* no payload, the command is complete: parse the request */
Willy Tarreauf3697dd2021-03-12 15:57:47 +01001039 cli_parse_request(appctx);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001040 chunk_reset(appctx->chunk);
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02001041 }
William Lallemand74c24fb2016-11-21 17:18:36 +01001042 }
1043
1044 /* re-adjust req buffer */
Willy Tarreau475e4632022-05-27 10:26:46 +02001045 co_skip(sc_oc(sc), reql);
Christopher Faulet9a790f62023-03-16 14:40:03 +01001046 sc_opposite(sc)->flags |= SC_FL_RCV_ONCE; /* we plan to read small requests */
William Lallemand74c24fb2016-11-21 17:18:36 +01001047 }
1048 else { /* output functions */
Willy Tarreau1c0715b2022-05-06 17:16:35 +02001049 struct cli_print_ctx *ctx;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +02001050 const char *msg;
1051 int sev;
1052
William Lallemand74c24fb2016-11-21 17:18:36 +01001053 switch (appctx->st0) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001054 case CLI_ST_PROMPT:
William Lallemand74c24fb2016-11-21 17:18:36 +01001055 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +02001056 case CLI_ST_PRINT: /* print const message in msg */
1057 case CLI_ST_PRINT_ERR: /* print const error in msg */
1058 case CLI_ST_PRINT_DYN: /* print dyn message in msg, free */
Amaury Denoyelle56f50a02022-11-10 11:47:36 +01001059 case CLI_ST_PRINT_DYNERR: /* print dyn error in err, free */
Amaury Denoyelle24e99612022-11-10 14:24:51 +01001060 case CLI_ST_PRINT_UMSG: /* print usermsgs_ctx and reset it */
1061 case CLI_ST_PRINT_UMSGERR: /* print usermsgs_ctx as error and reset it */
Willy Tarreau1c0715b2022-05-06 17:16:35 +02001062 /* the message is in the svcctx */
1063 ctx = applet_reserve_svcctx(appctx, sizeof(*ctx));
Willy Tarreaud50c7fe2019-08-09 09:57:36 +02001064 if (appctx->st0 == CLI_ST_PRINT || appctx->st0 == CLI_ST_PRINT_ERR) {
1065 sev = appctx->st0 == CLI_ST_PRINT_ERR ?
Willy Tarreau1c0715b2022-05-06 17:16:35 +02001066 LOG_ERR : ctx->severity;
1067 msg = ctx->msg;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +02001068 }
Amaury Denoyelle56f50a02022-11-10 11:47:36 +01001069 else if (appctx->st0 == CLI_ST_PRINT_DYN || appctx->st0 == CLI_ST_PRINT_DYNERR) {
1070 sev = appctx->st0 == CLI_ST_PRINT_DYNERR ?
Willy Tarreau1c0715b2022-05-06 17:16:35 +02001071 LOG_ERR : ctx->severity;
1072 msg = ctx->err;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +02001073 if (!msg) {
1074 sev = LOG_ERR;
1075 msg = "Out of memory.\n";
1076 }
1077 }
Amaury Denoyelle24e99612022-11-10 14:24:51 +01001078 else if (appctx->st0 == CLI_ST_PRINT_UMSG ||
1079 appctx->st0 == CLI_ST_PRINT_UMSGERR) {
1080 sev = appctx->st0 == CLI_ST_PRINT_UMSGERR ?
1081 LOG_ERR : ctx->severity;
1082 msg = usermsgs_str();
1083 }
Willy Tarreaud50c7fe2019-08-09 09:57:36 +02001084 else {
1085 sev = LOG_ERR;
1086 msg = "Internal error.\n";
1087 }
Aurélien Nephtalic511b7c2018-04-16 18:50:19 +02001088
Christopher Faulete8ee27b2023-05-05 10:56:00 +02001089 if (cli_output_msg(appctx, msg, sev, cli_get_severity_output(appctx)) != -1) {
Amaury Denoyelle56f50a02022-11-10 11:47:36 +01001090 if (appctx->st0 == CLI_ST_PRINT_DYN ||
1091 appctx->st0 == CLI_ST_PRINT_DYNERR) {
Willy Tarreau1c0715b2022-05-06 17:16:35 +02001092 ha_free(&ctx->err);
Willy Tarreaud50c7fe2019-08-09 09:57:36 +02001093 }
Amaury Denoyelle24e99612022-11-10 14:24:51 +01001094 else if (appctx->st0 == CLI_ST_PRINT_UMSG ||
1095 appctx->st0 == CLI_ST_PRINT_UMSGERR) {
1096 usermsgs_clr(NULL);
1097 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001098 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +01001099 }
William Lallemand74c24fb2016-11-21 17:18:36 +01001100 break;
Willy Tarreaud50c7fe2019-08-09 09:57:36 +02001101
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001102 case CLI_ST_CALLBACK: /* use custom pointer */
William Lallemand74c24fb2016-11-21 17:18:36 +01001103 if (appctx->io_handler)
1104 if (appctx->io_handler(appctx)) {
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001105 appctx->st0 = CLI_ST_PROMPT;
William Lallemand74c24fb2016-11-21 17:18:36 +01001106 if (appctx->io_release) {
1107 appctx->io_release(appctx);
1108 appctx->io_release = NULL;
1109 }
1110 }
1111 break;
1112 default: /* abnormal state */
Willy Tarreaud869e132022-05-17 18:05:31 +02001113 se_fl_set(appctx->sedesc, SE_FL_ERROR);
William Lallemand74c24fb2016-11-21 17:18:36 +01001114 break;
1115 }
1116
1117 /* The post-command prompt is either LF alone or LF + '> ' in interactive mode */
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001118 if (appctx->st0 == CLI_ST_PROMPT) {
Willy Tarreau22555572023-05-04 14:22:36 +02001119 char prompt_buf[20];
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001120 const char *prompt = "";
1121
1122 if (appctx->st1 & APPCTX_CLI_ST1_PROMPT) {
1123 /*
1124 * when entering a payload with interactive mode, change the prompt
1125 * to emphasize that more data can still be sent
1126 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001127 if (appctx->chunk->data && appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001128 prompt = "+ ";
Willy Tarreau22555572023-05-04 14:22:36 +02001129 else if (appctx->st1 & APPCTX_CLI_ST1_TIMED) {
1130 uint up = ns_to_sec(now_ns - start_time_ns);
1131 snprintf(prompt_buf, sizeof(prompt_buf),
1132 "\n[%u:%02u:%02u:%02u]> ",
1133 (up / 86400), (up / 3600) % 24, (up / 60) % 60, up % 60);
1134 prompt = prompt_buf;
1135 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001136 else
1137 prompt = "\n> ";
1138 }
1139 else {
William Lallemandad032882019-07-01 10:56:15 +02001140 if (!(appctx->st1 & (APPCTX_CLI_ST1_PAYLOAD|APPCTX_CLI_ST1_NOLF)))
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001141 prompt = "\n";
1142 }
1143
Willy Tarreau1addf8b2022-08-18 18:04:37 +02001144 if (applet_putstr(appctx, prompt) != -1) {
1145 applet_reset_svcctx(appctx);
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001146 appctx->st0 = CLI_ST_GETREQ;
Willy Tarreau1addf8b2022-08-18 18:04:37 +02001147 }
William Lallemand74c24fb2016-11-21 17:18:36 +01001148 }
1149
1150 /* If the output functions are still there, it means they require more room. */
Christopher Faulet4167e052022-06-01 17:25:42 +02001151 if (appctx->st0 >= CLI_ST_OUTPUT) {
1152 applet_wont_consume(appctx);
William Lallemand74c24fb2016-11-21 17:18:36 +01001153 break;
Christopher Faulet4167e052022-06-01 17:25:42 +02001154 }
William Lallemand74c24fb2016-11-21 17:18:36 +01001155
Christopher Faulet2fd0c762023-03-31 10:25:07 +02001156 /* Now we close the output if we're not in interactive
1157 * mode and the request buffer is empty. This still
1158 * allows pipelined requests to be sent in
1159 * non-interactive mode.
William Lallemand74c24fb2016-11-21 17:18:36 +01001160 */
Christopher Faulet2fd0c762023-03-31 10:25:07 +02001161 if (!(appctx->st1 & APPCTX_CLI_ST1_PROMPT) && !co_data(req) && (!(appctx->st1 & APPCTX_CLI_ST1_PAYLOAD))) {
1162 se_fl_set(appctx->sedesc, SE_FL_EOI);
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001163 appctx->st0 = CLI_ST_END;
William Lallemand74c24fb2016-11-21 17:18:36 +01001164 continue;
1165 }
1166
1167 /* switch state back to GETREQ to read next requests */
Willy Tarreau1addf8b2022-08-18 18:04:37 +02001168 applet_reset_svcctx(appctx);
Willy Tarreau3b6e5472016-11-24 15:53:53 +01001169 appctx->st0 = CLI_ST_GETREQ;
Christopher Faulet4167e052022-06-01 17:25:42 +02001170 applet_will_consume(appctx);
1171
William Lallemandad032882019-07-01 10:56:15 +02001172 /* reactivate the \n at the end of the response for the next command */
1173 appctx->st1 &= ~APPCTX_CLI_ST1_NOLF;
Willy Tarreaufa7b4f62022-01-19 17:11:36 +01001174
1175 /* this forces us to yield between pipelined commands and
1176 * avoid extremely long latencies (e.g. "del map" etc). In
1177 * addition this increases the likelihood that the stream
1178 * refills the buffer with new bytes in non-interactive
1179 * mode, avoiding to close on apparently empty commands.
1180 */
Willy Tarreau475e4632022-05-27 10:26:46 +02001181 if (co_data(sc_oc(sc))) {
Willy Tarreaufa7b4f62022-01-19 17:11:36 +01001182 appctx_wakeup(appctx);
1183 goto out;
1184 }
William Lallemand74c24fb2016-11-21 17:18:36 +01001185 }
1186 }
1187
William Lallemand74c24fb2016-11-21 17:18:36 +01001188 out:
Christopher Faulet845f7c42023-04-18 18:36:43 +02001189 return;
William Lallemand74c24fb2016-11-21 17:18:36 +01001190}
1191
Willy Tarreau4596fe22022-05-17 19:07:51 +02001192/* This is called when the stream connector is closed. For instance, upon an
William Lallemand74c24fb2016-11-21 17:18:36 +01001193 * external abort, we won't call the i/o handler anymore so we may need to
1194 * remove back references to the stream currently being dumped.
1195 */
1196static void cli_release_handler(struct appctx *appctx)
1197{
Willy Tarreau18b2a9d2021-05-04 16:27:45 +02001198 free_trash_chunk(appctx->chunk);
1199 appctx->chunk = NULL;
1200
William Lallemand74c24fb2016-11-21 17:18:36 +01001201 if (appctx->io_release) {
1202 appctx->io_release(appctx);
1203 appctx->io_release = NULL;
1204 }
Amaury Denoyelle56f50a02022-11-10 11:47:36 +01001205 else if (appctx->st0 == CLI_ST_PRINT_DYN || appctx->st0 == CLI_ST_PRINT_DYNERR) {
Willy Tarreau1c0715b2022-05-06 17:16:35 +02001206 struct cli_print_ctx *ctx = applet_reserve_svcctx(appctx, sizeof(*ctx));
1207
1208 ha_free(&ctx->err);
William Lallemand74c24fb2016-11-21 17:18:36 +01001209 }
Amaury Denoyelle24e99612022-11-10 14:24:51 +01001210 else if (appctx->st0 == CLI_ST_PRINT_UMSG || appctx->st0 == CLI_ST_PRINT_UMSGERR) {
1211 usermsgs_clr(NULL);
1212 }
William Lallemand74c24fb2016-11-21 17:18:36 +01001213}
1214
1215/* This function dumps all environmnent variables to the buffer. It returns 0
1216 * if the output buffer is full and it needs to be called again, otherwise
Willy Tarreau307dbb32022-05-05 17:45:52 +02001217 * non-zero. It takes its context from the show_env_ctx in svcctx, and will
1218 * start from ->var and dump only one variable if ->show_one is set.
William Lallemand74c24fb2016-11-21 17:18:36 +01001219 */
Willy Tarreau0a739292016-11-22 20:21:23 +01001220static int cli_io_handler_show_env(struct appctx *appctx)
William Lallemand74c24fb2016-11-21 17:18:36 +01001221{
Willy Tarreau307dbb32022-05-05 17:45:52 +02001222 struct show_env_ctx *ctx = appctx->svcctx;
Willy Tarreauc12b3212022-05-27 11:08:15 +02001223 struct stconn *sc = appctx_sc(appctx);
Willy Tarreau307dbb32022-05-05 17:45:52 +02001224 char **var = ctx->var;
William Lallemand74c24fb2016-11-21 17:18:36 +01001225
Christopher Faulet87633c32023-04-03 18:32:50 +02001226 /* FIXME: Don't watch the other side !*/
Christopher Faulet208c7122023-04-13 16:16:15 +02001227 if (unlikely(sc_opposite(sc)->flags & SC_FL_SHUT_DONE))
William Lallemand74c24fb2016-11-21 17:18:36 +01001228 return 1;
1229
1230 chunk_reset(&trash);
1231
1232 /* we have two inner loops here, one for the proxy, the other one for
1233 * the buffer.
1234 */
Willy Tarreauf6710f82016-12-16 17:45:44 +01001235 while (*var) {
1236 chunk_printf(&trash, "%s\n", *var);
William Lallemand74c24fb2016-11-21 17:18:36 +01001237
Willy Tarreaud0a06d52022-05-18 15:07:19 +02001238 if (applet_putchk(appctx, &trash) == -1)
William Lallemand74c24fb2016-11-21 17:18:36 +01001239 return 0;
Willy Tarreaud0a06d52022-05-18 15:07:19 +02001240
Willy Tarreau307dbb32022-05-05 17:45:52 +02001241 if (ctx->show_one)
William Lallemand74c24fb2016-11-21 17:18:36 +01001242 break;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001243 var++;
Willy Tarreau307dbb32022-05-05 17:45:52 +02001244 ctx->var = var;
William Lallemand74c24fb2016-11-21 17:18:36 +01001245 }
1246
1247 /* dump complete */
1248 return 1;
1249}
1250
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001251/* This function dumps all file descriptors states (or the requested one) to
1252 * the buffer. It returns 0 if the output buffer is full and it needs to be
Willy Tarreau741a5a92022-05-05 17:56:58 +02001253 * called again, otherwise non-zero. It takes its context from the show_fd_ctx
1254 * in svcctx, only dumps one entry if ->show_one is non-zero, and (re)starts
1255 * from ->fd.
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001256 */
1257static int cli_io_handler_show_fd(struct appctx *appctx)
1258{
Willy Tarreauc12b3212022-05-27 11:08:15 +02001259 struct stconn *sc = appctx_sc(appctx);
Willy Tarreau741a5a92022-05-05 17:56:58 +02001260 struct show_fd_ctx *fdctx = appctx->svcctx;
Willy Tarreau1cb041a2023-03-31 16:33:53 +02001261 uint match = fdctx->show_mask;
Willy Tarreau741a5a92022-05-05 17:56:58 +02001262 int fd = fdctx->fd;
Willy Tarreauca1b1572018-12-18 15:45:11 +01001263 int ret = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001264
Christopher Faulet87633c32023-04-03 18:32:50 +02001265 /* FIXME: Don't watch the other side !*/
Christopher Faulet208c7122023-04-13 16:16:15 +02001266 if (unlikely(sc_opposite(sc)->flags & SC_FL_SHUT_DONE))
Willy Tarreauca1b1572018-12-18 15:45:11 +01001267 goto end;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001268
1269 chunk_reset(&trash);
1270
Willy Tarreauca1b1572018-12-18 15:45:11 +01001271 /* isolate the threads once per round. We're limited to a buffer worth
1272 * of output anyway, it cannot last very long.
1273 */
1274 thread_isolate();
1275
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001276 /* we have two inner loops here, one for the proxy, the other one for
1277 * the buffer.
1278 */
Aurélien Nephtali498a1152018-03-09 18:51:16 +01001279 while (fd >= 0 && fd < global.maxsock) {
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001280 struct fdtab fdt;
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001281 const struct listener *li = NULL;
1282 const struct server *sv = NULL;
1283 const struct proxy *px = NULL;
1284 const struct connection *conn = NULL;
Willy Tarreaua833cd92018-03-29 13:19:37 +02001285 const struct mux_ops *mux = NULL;
Willy Tarreau37be9532021-01-20 14:40:04 +01001286 const struct xprt_ops *xprt = NULL;
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001287 const void *ctx = NULL;
Willy Tarreau37be9532021-01-20 14:40:04 +01001288 const void *xprt_ctx = NULL;
Willy Tarreaufe0ba0e2023-05-11 17:06:22 +02001289 const struct quic_conn *qc = NULL;
Willy Tarreau286ec682017-08-09 16:35:44 +02001290 uint32_t conn_flags = 0;
Christopher Fauletd52f2ad2023-03-14 15:48:06 +01001291 uint8_t conn_err = 0;
Willy Tarreaue9ca8072018-12-19 18:40:58 +01001292 int is_back = 0;
Willy Tarreau8050efe2021-01-21 08:26:06 +01001293 int suspicious = 0;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001294
1295 fdt = fdtab[fd];
1296
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001297 /* When DEBUG_FD is set, we also report closed FDs that have a
1298 * non-null event count to detect stuck ones.
1299 */
Willy Tarreau13c1a012020-06-29 14:23:31 +02001300 if (!fdt.owner) {
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001301#ifdef DEBUG_FD
Willy Tarreau13c1a012020-06-29 14:23:31 +02001302 if (!fdt.event_count)
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001303#endif
Willy Tarreau13c1a012020-06-29 14:23:31 +02001304 goto skip; // closed
1305 }
Willy Tarreau586f71b2020-12-11 15:54:36 +01001306 else if (fdt.iocb == sock_conn_iocb) {
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001307 conn = (const struct connection *)fdt.owner;
1308 conn_flags = conn->flags;
Christopher Fauletd52f2ad2023-03-14 15:48:06 +01001309 conn_err = conn->err_code;
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001310 mux = conn->mux;
1311 ctx = conn->ctx;
Willy Tarreau37be9532021-01-20 14:40:04 +01001312 xprt = conn->xprt;
1313 xprt_ctx = conn->xprt_ctx;
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001314 li = objt_listener(conn->target);
1315 sv = objt_server(conn->target);
1316 px = objt_proxy(conn->target);
1317 is_back = conn_is_back(conn);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001318 if (atleast2(fdt.thread_mask))
1319 suspicious = 1;
1320 if (conn->handle.fd != fd)
1321 suspicious = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001322 }
Willy Tarreaufe0ba0e2023-05-11 17:06:22 +02001323#if defined(USE_QUIC)
1324 else if (fdt.iocb == quic_conn_sock_fd_iocb) {
1325 qc = fdtab[fd].owner;
1326 li = qc ? qc->li : NULL;
1327 xprt_ctx = qc ? qc->xprt_ctx : NULL;
1328 conn = qc ? qc->conn : NULL;
1329 xprt = conn ? conn->xprt : NULL; // in fact it's &ssl_quic
1330 mux = conn ? conn->mux : NULL;
1331 /* quic_conns don't always have a connection but they
1332 * always have an xprt_ctx.
1333 */
1334 }
1335 else if (fdt.iocb == quic_lstnr_sock_fd_iocb) {
1336 li = objt_listener(fdtab[fd].owner);
1337 }
1338#endif
Willy Tarreaua74cb382020-10-15 21:29:49 +02001339 else if (fdt.iocb == sock_accept_iocb)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001340 li = fdt.owner;
1341
Willy Tarreaufe0ba0e2023-05-11 17:06:22 +02001342 if (!(((conn || xprt_ctx) &&
Willy Tarreau1cb041a2023-03-31 16:33:53 +02001343 ((match & CLI_SHOWFD_F_SV && sv) ||
1344 (match & CLI_SHOWFD_F_PX && px) ||
1345 (match & CLI_SHOWFD_F_FE && li))) ||
1346 (!conn &&
1347 ((match & CLI_SHOWFD_F_LI && li) ||
1348 (match & CLI_SHOWFD_F_PI && !li /* only pipes match this */))))) {
1349 /* not a desired type */
1350 goto skip;
1351 }
1352
Willy Tarreaudacfde42021-01-21 09:07:29 +01001353 if (!fdt.thread_mask)
1354 suspicious = 1;
1355
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001356 chunk_printf(&trash,
Willy Tarreau677c0062023-03-02 15:05:31 +01001357 " %5d : st=0x%06x(%c%c %c%c%c%c%c W:%c%c%c R:%c%c%c) ref=%#x gid=%d tmask=0x%lx umask=0x%lx prmsk=0x%lx pwmsk=0x%lx owner=%p iocb=%p(",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001358 fd,
1359 fdt.state,
Willy Tarreau184b2122021-04-07 08:48:12 +02001360 (fdt.state & FD_CLONED) ? 'C' : 'c',
1361 (fdt.state & FD_LINGER_RISK) ? 'L' : 'l',
Willy Tarreauf5090652021-04-06 17:23:40 +02001362 (fdt.state & FD_POLL_HUP) ? 'H' : 'h',
1363 (fdt.state & FD_POLL_ERR) ? 'E' : 'e',
1364 (fdt.state & FD_POLL_OUT) ? 'O' : 'o',
1365 (fdt.state & FD_POLL_PRI) ? 'P' : 'p',
1366 (fdt.state & FD_POLL_IN) ? 'I' : 'i',
Willy Tarreau184b2122021-04-07 08:48:12 +02001367 (fdt.state & FD_EV_SHUT_W) ? 'S' : 's',
1368 (fdt.state & FD_EV_READY_W) ? 'R' : 'r',
1369 (fdt.state & FD_EV_ACTIVE_W) ? 'A' : 'a',
1370 (fdt.state & FD_EV_SHUT_R) ? 'S' : 's',
1371 (fdt.state & FD_EV_READY_R) ? 'R' : 'r',
1372 (fdt.state & FD_EV_ACTIVE_R) ? 'A' : 'a',
Willy Tarreauc2431822022-07-08 10:23:01 +02001373 (fdt.refc_tgid >> 4) & 0xffff,
1374 (fdt.refc_tgid) & 0xffff,
Willy Tarreauc754b342018-03-30 15:00:15 +02001375 fdt.thread_mask, fdt.update_mask,
Willy Tarreau677c0062023-03-02 15:05:31 +01001376 polled_mask[fd].poll_recv,
1377 polled_mask[fd].poll_send,
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001378 fdt.owner,
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001379 fdt.iocb);
1380 resolve_sym_name(&trash, NULL, fdt.iocb);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001381
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001382 if (!fdt.owner) {
1383 chunk_appendf(&trash, ")");
1384 }
Willy Tarreaufe0ba0e2023-05-11 17:06:22 +02001385 else if (conn) {
Christopher Fauletd52f2ad2023-03-14 15:48:06 +01001386 chunk_appendf(&trash, ") back=%d cflg=0x%08x cerr=%d", is_back, conn_flags, conn_err);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001387
Willy Tarreaufe0ba0e2023-05-11 17:06:22 +02001388 if (!(conn->flags & CO_FL_FDLESS) && conn->handle.fd != fd) {
Willy Tarreaudacfde42021-01-21 09:07:29 +01001389 chunk_appendf(&trash, " fd=%d(BOGUS)", conn->handle.fd);
1390 suspicious = 1;
Willy Tarreaufe0ba0e2023-05-11 17:06:22 +02001391 } else if ((conn->flags & CO_FL_FDLESS) && (qc != conn->handle.qc)) {
1392 chunk_appendf(&trash, " qc=%p(BOGUS)", conn->handle.qc);
1393 suspicious = 1;
Willy Tarreaued989202021-02-05 10:54:52 +01001394 } else {
1395 struct sockaddr_storage sa;
1396 socklen_t salen;
1397
1398 salen = sizeof(sa);
1399 if (getsockname(fd, (struct sockaddr *)&sa, &salen) != -1) {
1400 if (sa.ss_family == AF_INET)
1401 chunk_appendf(&trash, " fam=ipv4 lport=%d", ntohs(((const struct sockaddr_in *)&sa)->sin_port));
1402 else if (sa.ss_family == AF_INET6)
1403 chunk_appendf(&trash, " fam=ipv6 lport=%d", ntohs(((const struct sockaddr_in6 *)&sa)->sin6_port));
1404 else if (sa.ss_family == AF_UNIX)
1405 chunk_appendf(&trash, " fam=unix");
1406 }
1407
1408 salen = sizeof(sa);
1409 if (getpeername(fd, (struct sockaddr *)&sa, &salen) != -1) {
1410 if (sa.ss_family == AF_INET)
1411 chunk_appendf(&trash, " rport=%d", ntohs(((const struct sockaddr_in *)&sa)->sin_port));
1412 else if (sa.ss_family == AF_INET6)
1413 chunk_appendf(&trash, " rport=%d", ntohs(((const struct sockaddr_in6 *)&sa)->sin6_port));
1414 }
Willy Tarreaudacfde42021-01-21 09:07:29 +01001415 }
1416
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001417 if (px)
1418 chunk_appendf(&trash, " px=%s", px->id);
1419 else if (sv)
Willy Tarreaudfb34a82021-07-06 11:41:10 +02001420 chunk_appendf(&trash, " sv=%s/%s", sv->proxy->id, sv->id);
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001421 else if (li)
1422 chunk_appendf(&trash, " fe=%s", li->bind_conf->frontend->id);
Willy Tarreau35b1b482018-03-28 18:41:30 +02001423
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001424 if (mux) {
Willy Tarreau3d2ee552018-12-19 14:12:10 +01001425 chunk_appendf(&trash, " mux=%s ctx=%p", mux->name, ctx);
Willy Tarreaufe0ba0e2023-05-11 17:06:22 +02001426 if (!ctx && !qc)
Willy Tarreaudacfde42021-01-21 09:07:29 +01001427 suspicious = 1;
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001428 if (mux->show_fd)
Willy Tarreau8050efe2021-01-21 08:26:06 +01001429 suspicious |= mux->show_fd(&trash, fdt.owner);
Willy Tarreaub011d8f2018-03-30 14:41:19 +02001430 }
Willy Tarreau35b1b482018-03-28 18:41:30 +02001431 else
1432 chunk_appendf(&trash, " nomux");
Willy Tarreau37be9532021-01-20 14:40:04 +01001433
1434 chunk_appendf(&trash, " xprt=%s", xprt ? xprt->name : "");
Willy Tarreau108a2712021-01-20 15:30:56 +01001435 if (xprt) {
1436 if (xprt_ctx || xprt->show_fd)
1437 chunk_appendf(&trash, " xprt_ctx=%p", xprt_ctx);
1438 if (xprt->show_fd)
Willy Tarreau8050efe2021-01-21 08:26:06 +01001439 suspicious |= xprt->show_fd(&trash, conn, xprt_ctx);
Willy Tarreau108a2712021-01-20 15:30:56 +01001440 }
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001441 }
Willy Tarreaufe0ba0e2023-05-11 17:06:22 +02001442 else if (li && !xprt_ctx) {
Willy Tarreaued989202021-02-05 10:54:52 +01001443 struct sockaddr_storage sa;
1444 socklen_t salen;
1445
Willy Tarreaucf12f2e2020-03-03 17:29:58 +01001446 chunk_appendf(&trash, ") l.st=%s fe=%s",
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001447 listener_state_str(li),
1448 li->bind_conf->frontend->id);
Willy Tarreaued989202021-02-05 10:54:52 +01001449
1450 salen = sizeof(sa);
1451 if (getsockname(fd, (struct sockaddr *)&sa, &salen) != -1) {
1452 if (sa.ss_family == AF_INET)
1453 chunk_appendf(&trash, " fam=ipv4 lport=%d", ntohs(((const struct sockaddr_in *)&sa)->sin_port));
1454 else if (sa.ss_family == AF_INET6)
1455 chunk_appendf(&trash, " fam=ipv6 lport=%d", ntohs(((const struct sockaddr_in6 *)&sa)->sin6_port));
1456 else if (sa.ss_family == AF_UNIX)
1457 chunk_appendf(&trash, " fam=unix");
1458 }
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001459 }
Willy Tarreaueb0595d2021-01-20 14:13:46 +01001460 else
1461 chunk_appendf(&trash, ")");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001462
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001463#ifdef DEBUG_FD
1464 chunk_appendf(&trash, " evcnt=%u", fdtab[fd].event_count);
Willy Tarreaudacfde42021-01-21 09:07:29 +01001465 if (fdtab[fd].event_count >= 1000000)
1466 suspicious = 1;
Willy Tarreau38e8a1c2020-06-23 10:04:54 +02001467#endif
Willy Tarreau8050efe2021-01-21 08:26:06 +01001468 chunk_appendf(&trash, "%s\n", suspicious ? " !" : "");
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001469
Willy Tarreaud0a06d52022-05-18 15:07:19 +02001470 if (applet_putchk(appctx, &trash) == -1) {
Willy Tarreau741a5a92022-05-05 17:56:58 +02001471 fdctx->fd = fd;
Willy Tarreauca1b1572018-12-18 15:45:11 +01001472 ret = 0;
1473 break;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001474 }
1475 skip:
Willy Tarreau741a5a92022-05-05 17:56:58 +02001476 if (fdctx->show_one)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001477 break;
1478
1479 fd++;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001480 }
1481
Willy Tarreauca1b1572018-12-18 15:45:11 +01001482 end:
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001483 /* dump complete */
Willy Tarreauca1b1572018-12-18 15:45:11 +01001484
1485 thread_release();
1486 return ret;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001487}
1488
William Lallemandeceddf72016-12-15 18:06:44 +01001489/*
Willy Tarreau3af9d832016-12-16 12:58:09 +01001490 * CLI IO handler for `show cli sockets`.
Willy Tarreaub128f492022-05-05 19:11:05 +02001491 * Uses the svcctx as a show_sock_ctx to store/retrieve the bind_conf and the
1492 * listener pointers.
William Lallemandeceddf72016-12-15 18:06:44 +01001493 */
1494static int cli_io_handler_show_cli_sock(struct appctx *appctx)
1495{
Willy Tarreaub128f492022-05-05 19:11:05 +02001496 struct show_sock_ctx *ctx = applet_reserve_svcctx(appctx, sizeof(*ctx));
1497 struct bind_conf *bind_conf = ctx->bind_conf;
William Lallemandeceddf72016-12-15 18:06:44 +01001498
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001499 if (!global.cli_fe)
1500 goto done;
William Lallemandeceddf72016-12-15 18:06:44 +01001501
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001502 chunk_reset(&trash);
William Lallemandeceddf72016-12-15 18:06:44 +01001503
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001504 if (!bind_conf) {
1505 /* first call */
Willy Tarreaud0a06d52022-05-18 15:07:19 +02001506 if (applet_putstr(appctx, "# socket lvl processes\n") == -1)
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001507 goto full;
1508 bind_conf = LIST_ELEM(global.cli_fe->conf.bind.n, typeof(bind_conf), by_fe);
1509 }
William Lallemandeceddf72016-12-15 18:06:44 +01001510
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001511 list_for_each_entry_from(bind_conf, &global.cli_fe->conf.bind, by_fe) {
Willy Tarreaub128f492022-05-05 19:11:05 +02001512 struct listener *l = ctx->listener;
William Lallemandeceddf72016-12-15 18:06:44 +01001513
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001514 if (!l)
1515 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
William Lallemandeceddf72016-12-15 18:06:44 +01001516
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001517 list_for_each_entry_from(l, &bind_conf->listeners, by_bind) {
1518 char addr[46];
1519 char port[6];
William Lallemandeceddf72016-12-15 18:06:44 +01001520
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001521 if (l->rx.addr.ss_family == AF_UNIX) {
1522 const struct sockaddr_un *un;
William Lallemandeceddf72016-12-15 18:06:44 +01001523
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001524 un = (struct sockaddr_un *)&l->rx.addr;
1525 if (un->sun_path[0] == '\0') {
1526 chunk_appendf(&trash, "abns@%s ", un->sun_path+1);
1527 } else {
1528 chunk_appendf(&trash, "unix@%s ", un->sun_path);
1529 }
1530 } else if (l->rx.addr.ss_family == AF_INET) {
1531 addr_to_str(&l->rx.addr, addr, sizeof(addr));
1532 port_to_str(&l->rx.addr, port, sizeof(port));
1533 chunk_appendf(&trash, "ipv4@%s:%s ", addr, port);
1534 } else if (l->rx.addr.ss_family == AF_INET6) {
1535 addr_to_str(&l->rx.addr, addr, sizeof(addr));
1536 port_to_str(&l->rx.addr, port, sizeof(port));
1537 chunk_appendf(&trash, "ipv6@[%s]:%s ", addr, port);
1538 } else if (l->rx.addr.ss_family == AF_CUST_SOCKPAIR) {
1539 chunk_appendf(&trash, "sockpair@%d ", ((struct sockaddr_in *)&l->rx.addr)->sin_addr.s_addr);
1540 } else
1541 chunk_appendf(&trash, "unknown ");
William Lallemandeceddf72016-12-15 18:06:44 +01001542
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001543 if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
1544 chunk_appendf(&trash, "admin ");
1545 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
1546 chunk_appendf(&trash, "operator ");
1547 else if ((bind_conf->level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
1548 chunk_appendf(&trash, "user ");
1549 else
1550 chunk_appendf(&trash, " ");
William Lallemandeceddf72016-12-15 18:06:44 +01001551
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001552 chunk_appendf(&trash, "all\n");
William Lallemandeceddf72016-12-15 18:06:44 +01001553
Willy Tarreaud0a06d52022-05-18 15:07:19 +02001554 if (applet_putchk(appctx, &trash) == -1) {
Willy Tarreaub128f492022-05-05 19:11:05 +02001555 ctx->bind_conf = bind_conf;
1556 ctx->listener = l;
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001557 goto full;
William Lallemandeceddf72016-12-15 18:06:44 +01001558 }
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001559 }
William Lallemandeceddf72016-12-15 18:06:44 +01001560 }
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001561 done:
1562 return 1;
1563 full:
Willy Tarreau4df54eb2022-05-05 18:52:36 +02001564 return 0;
William Lallemandeceddf72016-12-15 18:06:44 +01001565}
1566
Willy Tarreau9a7fa902022-07-15 16:51:16 +02001567
Willy Tarreau0a739292016-11-22 20:21:23 +01001568/* parse a "show env" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreau307dbb32022-05-05 17:45:52 +02001569 * wants to stop here. It reserves a sohw_env_ctx where it puts the variable to
1570 * be dumped as well as a flag if a single variable is requested, otherwise puts
1571 * environ there.
Willy Tarreau0a739292016-11-22 20:21:23 +01001572 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001573static int cli_parse_show_env(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau0a739292016-11-22 20:21:23 +01001574{
Willy Tarreau307dbb32022-05-05 17:45:52 +02001575 struct show_env_ctx *ctx = applet_reserve_svcctx(appctx, sizeof(*ctx));
Willy Tarreau0a739292016-11-22 20:21:23 +01001576 extern char **environ;
Willy Tarreauf6710f82016-12-16 17:45:44 +01001577 char **var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001578
1579 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1580 return 1;
1581
Willy Tarreauf6710f82016-12-16 17:45:44 +01001582 var = environ;
Willy Tarreau0a739292016-11-22 20:21:23 +01001583
1584 if (*args[2]) {
1585 int len = strlen(args[2]);
1586
Willy Tarreauf6710f82016-12-16 17:45:44 +01001587 for (; *var; var++) {
1588 if (strncmp(*var, args[2], len) == 0 &&
1589 (*var)[len] == '=')
Willy Tarreau0a739292016-11-22 20:21:23 +01001590 break;
1591 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001592 if (!*var)
1593 return cli_err(appctx, "Variable not found\n");
1594
Willy Tarreau307dbb32022-05-05 17:45:52 +02001595 ctx->show_one = 1;
Willy Tarreau0a739292016-11-22 20:21:23 +01001596 }
Willy Tarreau307dbb32022-05-05 17:45:52 +02001597 ctx->var = var;
Willy Tarreau0a739292016-11-22 20:21:23 +01001598 return 0;
1599}
1600
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001601/* parse a "show fd" CLI request. Returns 0 if it needs to continue, 1 if it
Willy Tarreau741a5a92022-05-05 17:56:58 +02001602 * wants to stop here. It sets a show_fd_ctx context where, if a specific fd is
1603 * requested, it puts the FD number into ->fd and sets ->show_one to 1.
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001604 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001605static int cli_parse_show_fd(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001606{
Willy Tarreau741a5a92022-05-05 17:56:58 +02001607 struct show_fd_ctx *ctx = applet_reserve_svcctx(appctx, sizeof(*ctx));
Willy Tarreau1cb041a2023-03-31 16:33:53 +02001608 const char *c;
1609 int arg;
Willy Tarreau741a5a92022-05-05 17:56:58 +02001610
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001611 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
1612 return 1;
1613
Willy Tarreau1cb041a2023-03-31 16:33:53 +02001614 arg = 2;
1615
1616 /* when starting with an inversion we preset every flag */
1617 if (*args[arg] == '!' || *args[arg] == '-')
1618 ctx->show_mask = CLI_SHOWFD_F_ANY;
1619
1620 while (*args[arg] && !isdigit((uchar)*args[arg])) {
1621 uint flag = 0, inv = 0;
1622 c = args[arg];
1623 while (*c) {
1624 switch (*c) {
1625 case '!': inv = !inv; break;
1626 case '-': inv = !inv; break;
1627 case 'p': flag = CLI_SHOWFD_F_PI; break;
1628 case 'l': flag = CLI_SHOWFD_F_LI; break;
1629 case 'c': flag = CLI_SHOWFD_F_CO; break;
1630 case 'f': flag = CLI_SHOWFD_F_FE; break;
1631 case 'b': flag = CLI_SHOWFD_F_BE; break;
1632 case 's': flag = CLI_SHOWFD_F_SV; break;
1633 case 'd': flag = CLI_SHOWFD_F_PX; break;
1634 default: return cli_err(appctx, "Invalid FD type\n");
1635 }
1636 c++;
1637 if (!inv)
1638 ctx->show_mask |= flag;
1639 else
1640 ctx->show_mask &= ~flag;
1641 }
1642 arg++;
1643 }
1644
1645 /* default mask is to show everything */
1646 if (!ctx->show_mask)
1647 ctx->show_mask = CLI_SHOWFD_F_ANY;
1648
1649 if (*args[arg]) {
Willy Tarreau741a5a92022-05-05 17:56:58 +02001650 ctx->fd = atoi(args[2]);
1651 ctx->show_one = 1;
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001652 }
Willy Tarreau1cb041a2023-03-31 16:33:53 +02001653
Willy Tarreau7a4a0ac2017-07-25 19:32:50 +02001654 return 0;
1655}
1656
Willy Tarreau599852e2016-11-22 20:33:32 +01001657/* parse a "set timeout" CLI request. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001658static int cli_parse_set_timeout(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau599852e2016-11-22 20:33:32 +01001659{
Willy Tarreau0698c802022-05-11 14:09:57 +02001660 struct stream *s = appctx_strm(appctx);
Willy Tarreau599852e2016-11-22 20:33:32 +01001661
1662 if (strcmp(args[2], "cli") == 0) {
1663 unsigned timeout;
1664 const char *res;
1665
Willy Tarreau9d008692019-08-09 11:21:01 +02001666 if (!*args[3])
1667 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001668
1669 res = parse_time_err(args[3], &timeout, TIME_UNIT_S);
Willy Tarreau9d008692019-08-09 11:21:01 +02001670 if (res || timeout < 1)
1671 return cli_err(appctx, "Invalid timeout value.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001672
Christopher Faulet5aaacfb2023-02-15 08:13:33 +01001673 s->scf->ioto = 1 + MS_TO_TICKS(timeout*1000);
Willy Tarreau599852e2016-11-22 20:33:32 +01001674 task_wakeup(s->task, TASK_WOKEN_MSG); // recompute timeouts
1675 return 1;
1676 }
Willy Tarreau9d008692019-08-09 11:21:01 +02001677
1678 return cli_err(appctx, "'set timeout' only supports 'cli'.\n");
Willy Tarreau599852e2016-11-22 20:33:32 +01001679}
1680
Willy Tarreau2af99412016-11-23 11:10:59 +01001681/* parse a "set maxconn global" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001682static int cli_parse_set_maxconn_global(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2af99412016-11-23 11:10:59 +01001683{
1684 int v;
1685
1686 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1687 return 1;
1688
Willy Tarreau9d008692019-08-09 11:21:01 +02001689 if (!*args[3])
1690 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001691
1692 v = atoi(args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001693 if (v > global.hardmaxconn)
1694 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau2af99412016-11-23 11:10:59 +01001695
1696 /* check for unlimited values */
1697 if (v <= 0)
1698 v = global.hardmaxconn;
1699
1700 global.maxconn = v;
1701
1702 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001703 dequeue_all_listeners();
Willy Tarreau2af99412016-11-23 11:10:59 +01001704
1705 return 1;
1706}
1707
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001708static int set_severity_output(int *target, char *argument)
1709{
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001710 if (strcmp(argument, "none") == 0) {
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001711 *target = CLI_SEVERITY_NONE;
1712 return 1;
1713 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001714 else if (strcmp(argument, "number") == 0) {
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001715 *target = CLI_SEVERITY_NUMBER;
1716 return 1;
1717 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001718 else if (strcmp(argument, "string") == 0) {
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001719 *target = CLI_SEVERITY_STRING;
1720 return 1;
1721 }
1722 return 0;
1723}
1724
1725/* parse a "set severity-output" command. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001726static int cli_parse_set_severity_output(char **args, char *payload, struct appctx *appctx, void *private)
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001727{
1728 if (*args[2] && set_severity_output(&appctx->cli_severity_output, args[2]))
1729 return 0;
1730
Willy Tarreau9d008692019-08-09 11:21:01 +02001731 return cli_err(appctx, "one of 'none', 'number', 'string' is a required argument\n");
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02001732}
William Lallemandeceddf72016-12-15 18:06:44 +01001733
William Lallemand67a234f2018-12-13 09:05:45 +01001734
1735/* show the level of the current CLI session */
1736static int cli_parse_show_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1737{
William Lallemand67a234f2018-12-13 09:05:45 +01001738 if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_ADMIN)
Willy Tarreau9d008692019-08-09 11:21:01 +02001739 return cli_msg(appctx, LOG_INFO, "admin\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001740 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_OPER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001741 return cli_msg(appctx, LOG_INFO, "operator\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001742 else if ((appctx->cli_level & ACCESS_LVL_MASK) == ACCESS_LVL_USER)
Willy Tarreau9d008692019-08-09 11:21:01 +02001743 return cli_msg(appctx, LOG_INFO, "user\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001744 else
Willy Tarreau9d008692019-08-09 11:21:01 +02001745 return cli_msg(appctx, LOG_INFO, "unknown\n");
William Lallemand67a234f2018-12-13 09:05:45 +01001746}
1747
1748/* parse and set the CLI level dynamically */
1749static int cli_parse_set_lvl(char **args, char *payload, struct appctx *appctx, void *private)
1750{
William Lallemandad032882019-07-01 10:56:15 +02001751 /* this will ask the applet to not output a \n after the command */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001752 if (strcmp(args[1], "-") == 0)
William Lallemandad032882019-07-01 10:56:15 +02001753 appctx->st1 |= APPCTX_CLI_ST1_NOLF;
1754
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001755 if (strcmp(args[0], "operator") == 0) {
William Lallemand67a234f2018-12-13 09:05:45 +01001756 if (!cli_has_level(appctx, ACCESS_LVL_OPER)) {
1757 return 1;
1758 }
1759 appctx->cli_level &= ~ACCESS_LVL_MASK;
1760 appctx->cli_level |= ACCESS_LVL_OPER;
1761
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001762 } else if (strcmp(args[0], "user") == 0) {
William Lallemand67a234f2018-12-13 09:05:45 +01001763 if (!cli_has_level(appctx, ACCESS_LVL_USER)) {
1764 return 1;
1765 }
1766 appctx->cli_level &= ~ACCESS_LVL_MASK;
1767 appctx->cli_level |= ACCESS_LVL_USER;
1768 }
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001769 appctx->cli_level &= ~(ACCESS_EXPERT|ACCESS_EXPERIMENTAL);
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001770 return 1;
1771}
1772
1773
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001774/* parse and set the CLI expert/experimental-mode dynamically */
1775static int cli_parse_expert_experimental_mode(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001776{
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001777 int level;
1778 char *level_str;
1779 char *output = NULL;
1780
William Lallemand7267f782022-02-01 16:08:50 +01001781 /* this will ask the applet to not output a \n after the command */
1782 if (*args[1] && *args[2] && strcmp(args[2], "-") == 0)
1783 appctx->st1 |= APPCTX_CLI_ST1_NOLF;
1784
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001785 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1786 return 1;
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001787
Tim Duesterhusc5aa1132021-10-16 17:48:15 +02001788 if (strcmp(args[0], "expert-mode") == 0) {
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001789 level = ACCESS_EXPERT;
1790 level_str = "expert-mode";
1791 }
Tim Duesterhusc5aa1132021-10-16 17:48:15 +02001792 else if (strcmp(args[0], "experimental-mode") == 0) {
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001793 level = ACCESS_EXPERIMENTAL;
1794 level_str = "experimental-mode";
1795 }
William Lallemand2a171912022-02-02 11:43:20 +01001796 else if (strcmp(args[0], "mcli-debug-mode") == 0) {
1797 level = ACCESS_MCLI_DEBUG;
1798 level_str = "mcli-debug-mode";
1799 }
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001800 else {
1801 return 1;
1802 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001803
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001804 if (!*args[1]) {
1805 memprintf(&output, "%s is %s\n", level_str,
1806 (appctx->cli_level & level) ? "ON" : "OFF");
1807 return cli_dynmsg(appctx, LOG_INFO, output);
1808 }
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001809
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001810 appctx->cli_level &= ~level;
Willy Tarreauabb9f9b2019-10-24 17:55:53 +02001811 if (strcmp(args[1], "on") == 0)
Amaury Denoyelle18487fb2021-03-18 15:32:53 +01001812 appctx->cli_level |= level;
William Lallemand67a234f2018-12-13 09:05:45 +01001813 return 1;
1814}
1815
William Lallemand740629e2021-12-14 15:22:29 +01001816/* shows HAProxy version */
1817static int cli_parse_show_version(char **args, char *payload, struct appctx *appctx, void *private)
1818{
1819 char *msg = NULL;
1820
1821 return cli_dynmsg(appctx, LOG_INFO, memprintf(&msg, "%s\n", haproxy_version));
1822}
1823
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001824int cli_parse_default(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandeceddf72016-12-15 18:06:44 +01001825{
1826 return 0;
1827}
1828
Erwan Le Goas54966df2022-09-14 17:24:22 +02001829/* enable or disable the anonymized mode, it returns 1 when it works or displays an error message if it doesn't. */
1830static int cli_parse_set_anon(char **args, char *payload, struct appctx *appctx, void *private)
1831{
1832 uint32_t tmp;
1833 long long key;
1834
1835 if (strcmp(args[2], "on") == 0) {
Erwan Le Goas3f4ae612022-09-28 17:04:29 +02001836
1837 if (*args[3]) {
1838 key = atoll(args[3]);
1839 if (key < 1 || key > UINT_MAX)
1840 return cli_err(appctx, "Value out of range (1 to 4294967295 expected).\n");
1841 appctx->cli_anon_key = key;
1842 }
Erwan Le Goas54966df2022-09-14 17:24:22 +02001843 else {
Erwan Le Goas3f4ae612022-09-28 17:04:29 +02001844 tmp = HA_ATOMIC_LOAD(&global.anon_key);
1845 if (tmp != 0)
1846 appctx->cli_anon_key = tmp;
1847 else
1848 appctx->cli_anon_key = ha_random32();
Erwan Le Goas54966df2022-09-14 17:24:22 +02001849 }
1850 }
1851 else if (strcmp(args[2], "off") == 0) {
Erwan Le Goas3f4ae612022-09-28 17:04:29 +02001852
1853 if (*args[3]) {
Erwan Le Goas54966df2022-09-14 17:24:22 +02001854 return cli_err(appctx, "Key can't be added while disabling anonymized mode\n");
1855 }
1856 else {
1857 appctx->cli_anon_key = 0;
1858 }
1859 }
1860 else {
1861 return cli_err(appctx,
1862 "'set anon' only supports :\n"
1863 " - 'on' [key] to enable the anonymized mode\n"
1864 " - 'off' to disable the anonymized mode");
1865 }
1866 return 1;
1867}
1868
Erwan Le Goasfad9da82022-09-14 17:24:22 +02001869/* This function set the global anonyzing key, restricted to level 'admin' */
1870static int cli_parse_set_global_key(char **args, char *payload, struct appctx *appctx, void *private)
1871{
1872 long long key;
1873
1874 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1875 return cli_err(appctx, "Permission denied\n");
1876 if (!*args[2])
1877 return cli_err(appctx, "Expects an integer value.\n");
1878
1879 key = atoll(args[2]);
1880 if (key < 0 || key > UINT_MAX)
1881 return cli_err(appctx, "Value out of range (0 to 4294967295 expected).\n");
1882
1883 HA_ATOMIC_STORE(&global.anon_key, key);
1884 return 1;
1885}
1886
Erwan Le Goas54966df2022-09-14 17:24:22 +02001887/* shows the anonymized mode state to everyone, and the key except for users, it always returns 1. */
1888static int cli_parse_show_anon(char **args, char *payload, struct appctx *appctx, void *private)
1889{
1890 char *msg = NULL;
1891 char *anon_mode = NULL;
1892 uint32_t c_key = appctx->cli_anon_key;
1893
1894 if (!c_key)
1895 anon_mode = "Anonymized mode disabled";
1896 else
1897 anon_mode = "Anonymized mode enabled";
1898
1899 if ( !((appctx->cli_level & ACCESS_LVL_MASK) < ACCESS_LVL_OPER) && c_key != 0) {
1900 cli_dynmsg(appctx, LOG_INFO, memprintf(&msg, "%s\nKey : %u\n", anon_mode, c_key));
1901 }
1902 else {
1903 cli_dynmsg(appctx, LOG_INFO, memprintf(&msg, "%s\n", anon_mode));
1904 }
1905
1906 return 1;
1907}
1908
Willy Tarreau45c742b2016-11-24 14:51:17 +01001909/* parse a "set rate-limit" command. It always returns 1. */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001910static int cli_parse_set_ratelimit(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau45c742b2016-11-24 14:51:17 +01001911{
1912 int v;
1913 int *res;
1914 int mul = 1;
1915
1916 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1917 return 1;
1918
1919 if (strcmp(args[2], "connections") == 0 && strcmp(args[3], "global") == 0)
1920 res = &global.cps_lim;
1921 else if (strcmp(args[2], "sessions") == 0 && strcmp(args[3], "global") == 0)
1922 res = &global.sps_lim;
1923#ifdef USE_OPENSSL
1924 else if (strcmp(args[2], "ssl-sessions") == 0 && strcmp(args[3], "global") == 0)
1925 res = &global.ssl_lim;
1926#endif
1927 else if (strcmp(args[2], "http-compression") == 0 && strcmp(args[3], "global") == 0) {
1928 res = &global.comp_rate_lim;
1929 mul = 1024;
1930 }
1931 else {
Willy Tarreau9d008692019-08-09 11:21:01 +02001932 return cli_err(appctx,
Willy Tarreau45c742b2016-11-24 14:51:17 +01001933 "'set rate-limit' only supports :\n"
1934 " - 'connections global' to set the per-process maximum connection rate\n"
1935 " - 'sessions global' to set the per-process maximum session rate\n"
1936#ifdef USE_OPENSSL
Aurélien Nephtalib53e2082018-03-11 16:55:02 +01001937 " - 'ssl-sessions global' to set the per-process maximum SSL session rate\n"
Willy Tarreau45c742b2016-11-24 14:51:17 +01001938#endif
Willy Tarreau9d008692019-08-09 11:21:01 +02001939 " - 'http-compression global' to set the per-process maximum compression speed in kB/s\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001940 }
1941
Willy Tarreau9d008692019-08-09 11:21:01 +02001942 if (!*args[4])
1943 return cli_err(appctx, "Expects an integer value.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001944
1945 v = atoi(args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02001946 if (v < 0)
1947 return cli_err(appctx, "Value out of range.\n");
Willy Tarreau45c742b2016-11-24 14:51:17 +01001948
1949 *res = v * mul;
1950
1951 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001952 dequeue_all_listeners();
Willy Tarreau45c742b2016-11-24 14:51:17 +01001953
1954 return 1;
1955}
1956
William Lallemandf6975e92017-05-26 17:42:10 +02001957/* parse the "expose-fd" argument on the bind lines */
1958static int bind_parse_expose_fd(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1959{
1960 if (!*args[cur_arg + 1]) {
1961 memprintf(err, "'%s' : missing fd type", args[cur_arg]);
1962 return ERR_ALERT | ERR_FATAL;
1963 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001964 if (strcmp(args[cur_arg + 1], "listeners") == 0) {
William Lallemandf6975e92017-05-26 17:42:10 +02001965 conf->level |= ACCESS_FD_LISTENERS;
1966 } else {
1967 memprintf(err, "'%s' only supports 'listeners' (got '%s')",
1968 args[cur_arg], args[cur_arg+1]);
1969 return ERR_ALERT | ERR_FATAL;
1970 }
1971
1972 return 0;
1973}
1974
William Lallemand74c24fb2016-11-21 17:18:36 +01001975/* parse the "level" argument on the bind lines */
1976static int bind_parse_level(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1977{
1978 if (!*args[cur_arg + 1]) {
1979 memprintf(err, "'%s' : missing level", args[cur_arg]);
1980 return ERR_ALERT | ERR_FATAL;
1981 }
1982
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001983 if (strcmp(args[cur_arg + 1], "user") == 0) {
William Lallemand07a62f72017-05-24 00:57:40 +02001984 conf->level &= ~ACCESS_LVL_MASK;
1985 conf->level |= ACCESS_LVL_USER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001986 } else if (strcmp(args[cur_arg + 1], "operator") == 0) {
William Lallemand07a62f72017-05-24 00:57:40 +02001987 conf->level &= ~ACCESS_LVL_MASK;
1988 conf->level |= ACCESS_LVL_OPER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001989 } else if (strcmp(args[cur_arg + 1], "admin") == 0) {
William Lallemand07a62f72017-05-24 00:57:40 +02001990 conf->level &= ~ACCESS_LVL_MASK;
1991 conf->level |= ACCESS_LVL_ADMIN;
1992 } else {
William Lallemand74c24fb2016-11-21 17:18:36 +01001993 memprintf(err, "'%s' only supports 'user', 'operator', and 'admin' (got '%s')",
1994 args[cur_arg], args[cur_arg+1]);
1995 return ERR_ALERT | ERR_FATAL;
1996 }
1997
1998 return 0;
1999}
2000
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02002001static int bind_parse_severity_output(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
2002{
2003 if (!*args[cur_arg + 1]) {
2004 memprintf(err, "'%s' : missing severity format", args[cur_arg]);
2005 return ERR_ALERT | ERR_FATAL;
2006 }
2007
2008 if (set_severity_output(&conf->severity_output, args[cur_arg+1]))
2009 return 0;
2010 else {
2011 memprintf(err, "'%s' only supports 'none', 'number', and 'string' (got '%s')",
2012 args[cur_arg], args[cur_arg+1]);
2013 return ERR_ALERT | ERR_FATAL;
2014 }
2015}
2016
Olivier Houchardf886e342017-04-05 22:24:59 +02002017/* Send all the bound sockets, always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002018static int _getsocks(char **args, char *payload, struct appctx *appctx, void *private)
Olivier Houchardf886e342017-04-05 22:24:59 +02002019{
William Lallemandb5d062d2022-07-28 15:33:41 +02002020 static int already_sent = 0;
Olivier Houchardf886e342017-04-05 22:24:59 +02002021 char *cmsgbuf = NULL;
2022 unsigned char *tmpbuf = NULL;
2023 struct cmsghdr *cmsg;
Willy Tarreauc12b3212022-05-27 11:08:15 +02002024 struct stconn *sc = appctx_sc(appctx);
Willy Tarreau475e4632022-05-27 10:26:46 +02002025 struct stream *s = __sc_strm(sc);
2026 struct connection *remote = sc_conn(sc_opposite(sc));
Olivier Houchardf886e342017-04-05 22:24:59 +02002027 struct msghdr msghdr;
2028 struct iovec iov;
Olivier Houchard54740872017-04-06 14:45:14 +02002029 struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002030 const char *ns_name, *if_name;
2031 unsigned char ns_nlen, if_nlen;
2032 int nb_queued;
2033 int cur_fd = 0;
Olivier Houchardf886e342017-04-05 22:24:59 +02002034 int *tmpfd;
2035 int tot_fd_nb = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02002036 int fd = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02002037 int curoff = 0;
Willy Tarreauc2b7f802018-09-20 11:22:29 +02002038 int old_fcntl = -1;
Olivier Houchardf886e342017-04-05 22:24:59 +02002039 int ret;
2040
Willy Tarreauc2b7f802018-09-20 11:22:29 +02002041 if (!remote) {
2042 ha_warning("Only works on real connections\n");
2043 goto out;
2044 }
2045
2046 fd = remote->handle.fd;
2047
Olivier Houchardf886e342017-04-05 22:24:59 +02002048 /* Temporary set the FD in blocking mode, that will make our life easier */
2049 old_fcntl = fcntl(fd, F_GETFL);
2050 if (old_fcntl < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002051 ha_warning("Couldn't get the flags for the unix socket\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02002052 goto out;
2053 }
2054 cmsgbuf = malloc(CMSG_SPACE(sizeof(int) * MAX_SEND_FD));
2055 if (!cmsgbuf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002056 ha_warning("Failed to allocate memory to send sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02002057 goto out;
2058 }
2059 if (fcntl(fd, F_SETFL, old_fcntl &~ O_NONBLOCK) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002060 ha_warning("Cannot make the unix socket blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02002061 goto out;
2062 }
Olivier Houchard54740872017-04-06 14:45:14 +02002063 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
Olivier Houchardf886e342017-04-05 22:24:59 +02002064 iov.iov_base = &tot_fd_nb;
2065 iov.iov_len = sizeof(tot_fd_nb);
William Lallemandf6975e92017-05-26 17:42:10 +02002066 if (!(strm_li(s)->bind_conf->level & ACCESS_FD_LISTENERS))
Olivier Houchardf886e342017-04-05 22:24:59 +02002067 goto out;
2068 memset(&msghdr, 0, sizeof(msghdr));
2069 /*
2070 * First, calculates the total number of FD, so that we can let
Jackie Tapia749f74c2020-07-22 18:59:40 -05002071 * the caller know how much it should expect.
Olivier Houchardf886e342017-04-05 22:24:59 +02002072 */
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002073 for (cur_fd = 0;cur_fd < global.maxsock; cur_fd++)
Willy Tarreau9063a662021-04-06 18:09:06 +02002074 tot_fd_nb += !!(fdtab[cur_fd].state & FD_EXPORTED);
William Lallemand5fd3b282020-01-16 15:32:08 +01002075
William Lallemandb5d062d2022-07-28 15:33:41 +02002076 if (tot_fd_nb == 0) {
2077 if (already_sent)
2078 ha_warning("_getsocks: attempt to get sockets but they were already sent and closed in this process!\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02002079 goto out;
William Lallemandb5d062d2022-07-28 15:33:41 +02002080 }
Olivier Houchardf886e342017-04-05 22:24:59 +02002081
2082 /* First send the total number of file descriptors, so that the
2083 * receiving end knows what to expect.
2084 */
2085 msghdr.msg_iov = &iov;
2086 msghdr.msg_iovlen = 1;
2087 ret = sendmsg(fd, &msghdr, 0);
2088 if (ret != sizeof(tot_fd_nb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002089 ha_warning("Failed to send the number of sockets to send\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02002090 goto out;
2091 }
2092
2093 /* Now send the fds */
2094 msghdr.msg_control = cmsgbuf;
2095 msghdr.msg_controllen = CMSG_SPACE(sizeof(int) * MAX_SEND_FD);
2096 cmsg = CMSG_FIRSTHDR(&msghdr);
2097 cmsg->cmsg_len = CMSG_LEN(MAX_SEND_FD * sizeof(int));
2098 cmsg->cmsg_level = SOL_SOCKET;
2099 cmsg->cmsg_type = SCM_RIGHTS;
2100 tmpfd = (int *)CMSG_DATA(cmsg);
2101
Olivier Houchardf886e342017-04-05 22:24:59 +02002102 /* For each socket, e message is sent, containing the following :
2103 * Size of the namespace name (or 0 if none), as an unsigned char.
2104 * The namespace name, if any
2105 * Size of the interface name (or 0 if none), as an unsigned char
2106 * The interface name, if any
Willy Tarreaucf1f1932020-08-26 10:30:09 +02002107 * 32 bits of zeroes (used to be listener options).
Olivier Houchardf886e342017-04-05 22:24:59 +02002108 */
2109 /* We will send sockets MAX_SEND_FD per MAX_SEND_FD, allocate a
Ilya Shipitsind4259502020-04-08 01:07:56 +05002110 * buffer big enough to store the socket information.
Olivier Houchardf886e342017-04-05 22:24:59 +02002111 */
Olivier Houchardf143b802017-11-04 15:13:01 +01002112 tmpbuf = malloc(MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
Olivier Houchardf886e342017-04-05 22:24:59 +02002113 if (tmpbuf == NULL) {
Ilya Shipitsind4259502020-04-08 01:07:56 +05002114 ha_warning("Failed to allocate memory to transfer socket information\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02002115 goto out;
2116 }
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002117
2118 nb_queued = 0;
Olivier Houchardf886e342017-04-05 22:24:59 +02002119 iov.iov_base = tmpbuf;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002120 for (cur_fd = 0; cur_fd < global.maxsock; cur_fd++) {
Willy Tarreau9063a662021-04-06 18:09:06 +02002121 if (!(fdtab[cur_fd].state & FD_EXPORTED))
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002122 continue;
2123
2124 ns_name = if_name = "";
2125 ns_nlen = if_nlen = 0;
2126
2127 /* for now we can only retrieve namespaces and interfaces from
2128 * pure listeners.
2129 */
Willy Tarreaua74cb382020-10-15 21:29:49 +02002130 if (fdtab[cur_fd].iocb == sock_accept_iocb) {
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002131 const struct listener *l = fdtab[cur_fd].owner;
2132
Willy Tarreau818a92e2020-09-03 07:50:19 +02002133 if (l->rx.settings->interface) {
2134 if_name = l->rx.settings->interface;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002135 if_nlen = strlen(if_name);
2136 }
2137
2138#ifdef USE_NS
Willy Tarreau818a92e2020-09-03 07:50:19 +02002139 if (l->rx.settings->netns) {
2140 ns_name = l->rx.settings->netns->node.key;
2141 ns_nlen = l->rx.settings->netns->name_len;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002142 }
2143#endif
2144 }
2145
2146 /* put the FD into the CMSG_DATA */
2147 tmpfd[nb_queued++] = cur_fd;
2148
2149 /* first block is <ns_name_len> <ns_name> */
2150 tmpbuf[curoff++] = ns_nlen;
2151 if (ns_nlen)
2152 memcpy(tmpbuf + curoff, ns_name, ns_nlen);
2153 curoff += ns_nlen;
2154
2155 /* second block is <if_name_len> <if_name> */
2156 tmpbuf[curoff++] = if_nlen;
2157 if (if_nlen)
2158 memcpy(tmpbuf + curoff, if_name, if_nlen);
2159 curoff += if_nlen;
2160
2161 /* we used to send the listener options here before 2.3 */
2162 memset(tmpbuf + curoff, 0, sizeof(int));
2163 curoff += sizeof(int);
2164
2165 /* there's a limit to how many FDs may be sent at once */
2166 if (nb_queued == MAX_SEND_FD) {
2167 iov.iov_len = curoff;
2168 if (sendmsg(fd, &msghdr, 0) != curoff) {
2169 ha_warning("Failed to transfer sockets\n");
2170 return -1;
2171 }
2172
2173 /* Wait for an ack */
2174 do {
2175 ret = recv(fd, &tot_fd_nb, sizeof(tot_fd_nb), 0);
2176 } while (ret == -1 && errno == EINTR);
2177
2178 if (ret <= 0) {
2179 ha_warning("Unexpected error while transferring sockets\n");
2180 return -1;
2181 }
2182 curoff = 0;
2183 nb_queued = 0;
2184 }
William Lallemand5fd3b282020-01-16 15:32:08 +01002185 }
2186
William Lallemandb5d062d2022-07-28 15:33:41 +02002187 already_sent = 1;
2188
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002189 /* flush pending stuff */
2190 if (nb_queued) {
Olivier Houchardf886e342017-04-05 22:24:59 +02002191 iov.iov_len = curoff;
Willy Tarreaub5a1f9e2020-08-19 17:03:55 +02002192 cmsg->cmsg_len = CMSG_LEN(nb_queued * sizeof(int));
2193 msghdr.msg_controllen = CMSG_SPACE(nb_queued * sizeof(int));
Olivier Houchardf886e342017-04-05 22:24:59 +02002194 if (sendmsg(fd, &msghdr, 0) != curoff) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002195 ha_warning("Failed to transfer sockets\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02002196 goto out;
2197 }
2198 }
2199
2200out:
Willy Tarreauc2b7f802018-09-20 11:22:29 +02002201 if (fd >= 0 && old_fcntl >= 0 && fcntl(fd, F_SETFL, old_fcntl) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002202 ha_warning("Cannot make the unix socket non-blocking\n");
Olivier Houchardf886e342017-04-05 22:24:59 +02002203 goto out;
2204 }
Christopher Faulet33af9962023-04-07 17:58:21 +02002205 se_fl_set(appctx->sedesc, SE_FL_EOI);
Olivier Houchardf886e342017-04-05 22:24:59 +02002206 appctx->st0 = CLI_ST_END;
2207 free(cmsgbuf);
2208 free(tmpbuf);
2209 return 1;
2210}
2211
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002212static int cli_parse_simple(char **args, char *payload, struct appctx *appctx, void *private)
2213{
2214 if (*args[0] == 'h')
2215 /* help */
Willy Tarreau0b1b8302021-05-09 20:59:23 +02002216 cli_gen_usage_msg(appctx, args);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002217 else if (*args[0] == 'p')
2218 /* prompt */
Willy Tarreau22555572023-05-04 14:22:36 +02002219 if (strcmp(args[1], "timed") == 0) {
2220 appctx->st1 |= APPCTX_CLI_ST1_PROMPT;
2221 appctx->st1 ^= APPCTX_CLI_ST1_TIMED;
2222 }
2223 else
2224 appctx->st1 ^= APPCTX_CLI_ST1_PROMPT;
Christopher Faulet33af9962023-04-07 17:58:21 +02002225 else if (*args[0] == 'q') {
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002226 /* quit */
Christopher Faulet33af9962023-04-07 17:58:21 +02002227 se_fl_set(appctx->sedesc, SE_FL_EOI);
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002228 appctx->st0 = CLI_ST_END;
Christopher Faulet33af9962023-04-07 17:58:21 +02002229 }
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02002230
2231 return 1;
2232}
Olivier Houchardf886e342017-04-05 22:24:59 +02002233
William Lallemand2f4ce202018-10-26 14:47:47 +02002234void pcli_write_prompt(struct stream *s)
2235{
2236 struct buffer *msg = get_trash_chunk();
Willy Tarreau40a9c322022-05-18 15:55:18 +02002237 struct channel *oc = sc_oc(s->scf);
William Lallemand2f4ce202018-10-26 14:47:47 +02002238
William Lallemanddc12c2e2018-12-13 09:05:46 +01002239 if (!(s->pcli_flags & PCLI_F_PROMPT))
William Lallemand5b80fa22018-12-11 16:10:54 +01002240 return;
2241
William Lallemanddc12c2e2018-12-13 09:05:46 +01002242 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002243 chunk_appendf(msg, "+ ");
2244 } else {
Willy Tarreauea077152023-05-11 16:14:02 +02002245 if (s->pcli_next_pid == 0) {
2246 /* master's prompt */
2247 if (s->pcli_flags & PCLI_F_TIMED) {
2248 uint up = ns_to_sec(now_ns - start_time_ns);
2249 chunk_appendf(msg, "[%u:%02u:%02u:%02u] ",
2250 (up / 86400), (up / 3600) % 24, (up / 60) % 60, up % 60);
2251 }
2252
William Lallemanddae12c72022-02-02 14:13:54 +01002253 chunk_appendf(msg, "master%s",
William Lallemand3ba7c7b2021-11-10 10:57:18 +01002254 (proc_self->failedreloads > 0) ? "[ReloadFailed]" : "");
Willy Tarreauea077152023-05-11 16:14:02 +02002255 }
2256 else {
2257 /* worker's prompt */
2258 if (s->pcli_flags & PCLI_F_TIMED) {
2259 const struct mworker_proc *tmp, *proc;
2260 uint up;
2261
2262 /* set proc to the worker corresponding to pcli_next_pid or NULL */
2263 proc = NULL;
2264 list_for_each_entry(tmp, &proc_list, list) {
2265 if (!(tmp->options & PROC_O_TYPE_WORKER))
2266 continue;
2267 if (tmp->pid == s->pcli_next_pid) {
2268 proc = tmp;
2269 break;
2270 }
2271 }
2272
2273 if (!proc)
2274 chunk_appendf(msg, "[gone] ");
2275 else {
2276 up = date.tv_sec - proc->timestamp;
2277 if ((int)up < 0) /* must never be negative because of clock drift */
2278 up = 0;
2279 chunk_appendf(msg, "[%u:%02u:%02u:%02u] ",
2280 (up / 86400), (up / 3600) % 24, (up / 60) % 60, up % 60);
2281 }
2282 }
William Lallemanddae12c72022-02-02 14:13:54 +01002283 chunk_appendf(msg, "%d", s->pcli_next_pid);
Willy Tarreauea077152023-05-11 16:14:02 +02002284 }
William Lallemanddae12c72022-02-02 14:13:54 +01002285
2286 if (s->pcli_flags & (ACCESS_EXPERIMENTAL|ACCESS_EXPERT|ACCESS_MCLI_DEBUG)) {
2287 chunk_appendf(msg, "(");
2288
2289 if (s->pcli_flags & ACCESS_EXPERIMENTAL)
2290 chunk_appendf(msg, "x");
2291
2292 if (s->pcli_flags & ACCESS_EXPERT)
2293 chunk_appendf(msg, "e");
2294
2295 if (s->pcli_flags & ACCESS_MCLI_DEBUG)
2296 chunk_appendf(msg, "d");
2297
2298 chunk_appendf(msg, ")");
2299 }
2300
2301 chunk_appendf(msg, "> ");
2302
2303
William Lallemandebf61802018-12-11 16:10:57 +01002304 }
William Lallemand2f4ce202018-10-26 14:47:47 +02002305 co_inject(oc, msg->area, msg->data);
2306}
2307
William Lallemand291810d2018-10-26 14:47:38 +02002308
William Lallemandcf62f7e2018-10-26 14:47:40 +02002309/* The pcli_* functions are used for the CLI proxy in the master */
2310
William Lallemanddeeaa592018-10-26 14:47:48 +02002311void pcli_reply_and_close(struct stream *s, const char *msg)
2312{
2313 struct buffer *buf = get_trash_chunk();
2314
2315 chunk_initstr(buf, msg);
Christopher Faulet9125f3c2022-03-31 09:47:24 +02002316 stream_retnclose(s, buf);
William Lallemanddeeaa592018-10-26 14:47:48 +02002317}
2318
William Lallemand291810d2018-10-26 14:47:38 +02002319static enum obj_type *pcli_pid_to_server(int proc_pid)
2320{
2321 struct mworker_proc *child;
2322
William Lallemand99e0bb92020-11-05 10:28:53 +01002323 /* return the mCLI applet of the master */
William Lallemandbddd33a2018-12-11 16:10:53 +01002324 if (proc_pid == 0)
William Lallemand99e0bb92020-11-05 10:28:53 +01002325 return &mcli_applet.obj_type;
William Lallemandbddd33a2018-12-11 16:10:53 +01002326
William Lallemand291810d2018-10-26 14:47:38 +02002327 list_for_each_entry(child, &proc_list, list) {
2328 if (child->pid == proc_pid){
2329 return &child->srv->obj_type;
2330 }
2331 }
2332 return NULL;
2333}
2334
2335/* Take a CLI prefix in argument (eg: @!1234 @master @1)
2336 * Return:
2337 * 0: master
2338 * > 0: pid of a worker
2339 * < 0: didn't find a worker
2340 */
2341static int pcli_prefix_to_pid(const char *prefix)
2342{
2343 int proc_pid;
2344 struct mworker_proc *child;
2345 char *errtol = NULL;
2346
2347 if (*prefix != '@') /* not a prefix, should not happen */
2348 return -1;
2349
2350 prefix++;
2351 if (!*prefix) /* sent @ alone, return the master */
2352 return 0;
2353
2354 if (strcmp("master", prefix) == 0) {
2355 return 0;
2356 } else if (*prefix == '!') {
2357 prefix++;
2358 if (!*prefix)
2359 return -1;
2360
2361 proc_pid = strtol(prefix, &errtol, 10);
2362 if (*errtol != '\0')
2363 return -1;
2364 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02002365 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01002366 continue;
William Lallemand291810d2018-10-26 14:47:38 +02002367 if (child->pid == proc_pid){
2368 return child->pid;
2369 }
2370 }
2371 } else {
2372 struct mworker_proc *chosen = NULL;
2373 /* this is a relative pid */
2374
2375 proc_pid = strtol(prefix, &errtol, 10);
2376 if (*errtol != '\0')
2377 return -1;
2378
2379 if (proc_pid == 0) /* return the master */
2380 return 0;
2381
William Lallemandbac3a822022-07-20 14:30:56 +02002382 if (proc_pid != 1) /* only the "@1" relative PID is supported */
2383 return -1;
2384
William Lallemand291810d2018-10-26 14:47:38 +02002385 /* chose the right process, the current one is the one with the
2386 least number of reloads */
2387 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +02002388 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand16dd1b32018-11-19 18:46:18 +01002389 continue;
Willy Tarreaue8422bf2021-06-15 09:08:18 +02002390 if (child->reloads == 0)
2391 return child->pid;
2392 else if (chosen == NULL || child->reloads < chosen->reloads)
2393 chosen = child;
William Lallemand291810d2018-10-26 14:47:38 +02002394 }
2395 if (chosen)
2396 return chosen->pid;
2397 }
2398 return -1;
2399}
2400
William Lallemandbddd33a2018-12-11 16:10:53 +01002401/* Return::
2402 * >= 0 : number of words to escape
2403 * = -1 : error
2404 */
2405
2406int pcli_find_and_exec_kw(struct stream *s, char **args, int argl, char **errmsg, int *next_pid)
2407{
2408 if (argl < 1)
2409 return 0;
2410
2411 /* there is a prefix */
2412 if (args[0][0] == '@') {
2413 int target_pid = pcli_prefix_to_pid(args[0]);
2414
2415 if (target_pid == -1) {
2416 memprintf(errmsg, "Can't find the target PID matching the prefix '%s'\n", args[0]);
2417 return -1;
2418 }
2419
2420 /* if the prefix is alone, define a default target */
2421 if (argl == 1)
2422 s->pcli_next_pid = target_pid;
2423 else
2424 *next_pid = target_pid;
2425 return 1;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002426 } else if (strcmp("prompt", args[0]) == 0) {
Willy Tarreauea077152023-05-11 16:14:02 +02002427 if (argl >= 2 && strcmp(args[1], "timed") == 0) {
2428 s->pcli_flags |= PCLI_F_PROMPT;
2429 s->pcli_flags ^= PCLI_F_TIMED;
2430 }
2431 else
2432 s->pcli_flags ^= PCLI_F_PROMPT;
William Lallemand5b80fa22018-12-11 16:10:54 +01002433 return argl; /* return the number of elements in the array */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002434 } else if (strcmp("quit", args[0]) == 0) {
Christopher Faulet12762f02023-04-13 15:40:10 +02002435 sc_schedule_abort(s->scf);
Christopher Fauletdf7cd712023-04-13 15:56:26 +02002436 sc_schedule_shutdown(s->scf);
William Lallemand5f610682018-12-11 16:10:55 +01002437 return argl; /* return the number of elements in the array */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002438 } else if (strcmp(args[0], "operator") == 0) {
William Lallemandb7ea1412018-12-13 09:05:47 +01002439 if (!pcli_has_level(s, ACCESS_LVL_OPER)) {
2440 memprintf(errmsg, "Permission denied!\n");
2441 return -1;
2442 }
2443 s->pcli_flags &= ~ACCESS_LVL_MASK;
2444 s->pcli_flags |= ACCESS_LVL_OPER;
2445 return argl;
2446
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002447 } else if (strcmp(args[0], "user") == 0) {
William Lallemandb7ea1412018-12-13 09:05:47 +01002448 if (!pcli_has_level(s, ACCESS_LVL_USER)) {
2449 memprintf(errmsg, "Permission denied!\n");
2450 return -1;
2451 }
2452 s->pcli_flags &= ~ACCESS_LVL_MASK;
2453 s->pcli_flags |= ACCESS_LVL_USER;
2454 return argl;
William Lallemand7267f782022-02-01 16:08:50 +01002455
2456 } else if (strcmp(args[0], "expert-mode") == 0) {
2457 if (!pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2458 memprintf(errmsg, "Permission denied!\n");
2459 return -1;
2460 }
2461
2462 s->pcli_flags &= ~ACCESS_EXPERT;
2463 if ((argl > 1) && (strcmp(args[1], "on") == 0))
2464 s->pcli_flags |= ACCESS_EXPERT;
2465 return argl;
2466
2467 } else if (strcmp(args[0], "experimental-mode") == 0) {
2468 if (!pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2469 memprintf(errmsg, "Permission denied!\n");
2470 return -1;
2471 }
2472 s->pcli_flags &= ~ACCESS_EXPERIMENTAL;
2473 if ((argl > 1) && (strcmp(args[1], "on") == 0))
2474 s->pcli_flags |= ACCESS_EXPERIMENTAL;
2475 return argl;
William Lallemand2a171912022-02-02 11:43:20 +01002476 } else if (strcmp(args[0], "mcli-debug-mode") == 0) {
2477 if (!pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2478 memprintf(errmsg, "Permission denied!\n");
2479 return -1;
2480 }
2481 s->pcli_flags &= ~ACCESS_MCLI_DEBUG;
2482 if ((argl > 1) && (strcmp(args[1], "on") == 0))
2483 s->pcli_flags |= ACCESS_MCLI_DEBUG;
2484 return argl;
William Lallemandbddd33a2018-12-11 16:10:53 +01002485 }
2486
2487 return 0;
2488}
2489
2490/*
2491 * Parse the CLI request:
2492 * - It does basically the same as the cli_io_handler, but as a proxy
2493 * - It can exec a command and strip non forwardable commands
William Lallemandcf62f7e2018-10-26 14:47:40 +02002494 *
2495 * Return:
William Lallemandbddd33a2018-12-11 16:10:53 +01002496 * - the number of characters to forward or
2497 * - 1 if there is an error or not enough data
William Lallemandcf62f7e2018-10-26 14:47:40 +02002498 */
William Lallemandbddd33a2018-12-11 16:10:53 +01002499int pcli_parse_request(struct stream *s, struct channel *req, char **errmsg, int *next_pid)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002500{
Willy Tarreaua4e4d662022-01-20 08:47:35 +01002501 char *str;
2502 char *end;
Willy Tarreauf14c7572021-03-13 10:59:23 +01002503 char *args[MAX_CLI_ARGS + 1]; /* +1 for storing a NULL */
William Lallemandbddd33a2018-12-11 16:10:53 +01002504 int argl; /* number of args */
2505 char *p;
2506 char *trim = NULL;
William Lallemandebf61802018-12-11 16:10:57 +01002507 char *payload = NULL;
William Lallemandbddd33a2018-12-11 16:10:53 +01002508 int wtrim = 0; /* number of words to trim */
2509 int reql = 0;
William Lallemandb7ea1412018-12-13 09:05:47 +01002510 int ret;
William Lallemandbddd33a2018-12-11 16:10:53 +01002511 int i = 0;
2512
Willy Tarreaua4e4d662022-01-20 08:47:35 +01002513 /* we cannot deal with a wrapping buffer, so let's take care of this
2514 * first.
2515 */
2516 if (b_head(&req->buf) + b_data(&req->buf) > b_wrap(&req->buf))
2517 b_slow_realign(&req->buf, trash.area, co_data(req));
2518
2519 str = (char *)ci_head(req);
2520 end = (char *)ci_stop(req);
2521
William Lallemandbddd33a2018-12-11 16:10:53 +01002522 p = str;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002523
William Lallemanddc12c2e2018-12-13 09:05:46 +01002524 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002525
2526 /* Looks for the end of one command */
2527 while (p+reql < end) {
2528 /* handle escaping */
2529 if (p[reql] == '\\') {
William Lallemand02c255e2020-06-18 18:45:04 +02002530 reql+=2;
William Lallemandebf61802018-12-11 16:10:57 +01002531 continue;
2532 }
2533 if (p[reql] == ';' || p[reql] == '\n') {
2534 /* found the end of the command */
2535 p[reql] = '\n';
2536 reql++;
2537 break;
2538 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002539 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002540 }
William Lallemandebf61802018-12-11 16:10:57 +01002541 } else {
2542 while (p+reql < end) {
2543 if (p[reql] == '\n') {
2544 /* found the end of the line */
2545 reql++;
2546 break;
2547 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002548 reql++;
William Lallemandbddd33a2018-12-11 16:10:53 +01002549 }
William Lallemandbddd33a2018-12-11 16:10:53 +01002550 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002551
William Lallemandbddd33a2018-12-11 16:10:53 +01002552 /* set end to first byte after the end of the command */
2553 end = p + reql;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002554
William Lallemandbddd33a2018-12-11 16:10:53 +01002555 /* there is no end to this command, need more to parse ! */
Willy Tarreau6cd93f52022-01-20 08:31:50 +01002556 if (!reql || *(end-1) != '\n') {
William Lallemandbddd33a2018-12-11 16:10:53 +01002557 return -1;
2558 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002559
William Lallemand3301f3e2018-12-13 09:05:48 +01002560 if (s->pcli_flags & PCLI_F_PAYLOAD) {
2561 if (reql == 1) /* last line of the payload */
2562 s->pcli_flags &= ~PCLI_F_PAYLOAD;
William Lallemandebf61802018-12-11 16:10:57 +01002563 return reql;
2564 }
2565
William Lallemandbddd33a2018-12-11 16:10:53 +01002566 *(end-1) = '\0';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002567
William Lallemandbddd33a2018-12-11 16:10:53 +01002568 /* splits the command in words */
Willy Tarreauf14c7572021-03-13 10:59:23 +01002569 while (i < MAX_CLI_ARGS && p < end) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002570 /* skip leading spaces/tabs */
2571 p += strspn(p, " \t");
2572 if (!*p)
William Lallemandcf62f7e2018-10-26 14:47:40 +02002573 break;
2574
William Lallemandbddd33a2018-12-11 16:10:53 +01002575 args[i] = p;
William Lallemandfe249c32020-06-18 18:03:57 +02002576 while (1) {
2577 p += strcspn(p, " \t\\");
2578 /* escaped chars using backlashes (\) */
2579 if (*p == '\\') {
2580 if (!*++p)
2581 break;
2582 if (!*++p)
2583 break;
2584 } else {
2585 break;
William Lallemandbddd33a2018-12-11 16:10:53 +01002586 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002587 }
William Lallemandfe249c32020-06-18 18:03:57 +02002588 *p++ = 0;
William Lallemandbddd33a2018-12-11 16:10:53 +01002589 i++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002590 }
2591
William Lallemandbddd33a2018-12-11 16:10:53 +01002592 argl = i;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002593
Willy Tarreauf14c7572021-03-13 10:59:23 +01002594 for (; i < MAX_CLI_ARGS + 1; i++)
William Lallemandbddd33a2018-12-11 16:10:53 +01002595 args[i] = NULL;
2596
2597 wtrim = pcli_find_and_exec_kw(s, args, argl, errmsg, next_pid);
2598
2599 /* End of words are ending by \0, we need to replace the \0s by spaces
William Lallemandfe618fb2022-02-02 14:07:08 +01002600 before forwarding them */
William Lallemandbddd33a2018-12-11 16:10:53 +01002601 p = str;
William Lallemand3301f3e2018-12-13 09:05:48 +01002602 while (p < end-1) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002603 if (*p == '\0')
2604 *p = ' ';
2605 p++;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002606 }
2607
William Lallemand3301f3e2018-12-13 09:05:48 +01002608 payload = strstr(str, PAYLOAD_PATTERN);
2609 if ((end - 1) == (payload + strlen(PAYLOAD_PATTERN))) {
2610 /* if the payload pattern is at the end */
2611 s->pcli_flags |= PCLI_F_PAYLOAD;
William Lallemand3301f3e2018-12-13 09:05:48 +01002612 }
2613
William Lallemandbddd33a2018-12-11 16:10:53 +01002614 *(end-1) = '\n';
William Lallemandcf62f7e2018-10-26 14:47:40 +02002615
William Lallemandbddd33a2018-12-11 16:10:53 +01002616 if (wtrim > 0) {
2617 trim = &args[wtrim][0];
2618 if (trim == NULL) /* if this was the last word in the table */
2619 trim = end;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002620
William Lallemandbddd33a2018-12-11 16:10:53 +01002621 b_del(&req->buf, trim - str);
2622
William Lallemandb7ea1412018-12-13 09:05:47 +01002623 ret = end - trim;
William Lallemandbddd33a2018-12-11 16:10:53 +01002624 } else if (wtrim < 0) {
2625 /* parsing error */
2626 return -1;
William Lallemandb7ea1412018-12-13 09:05:47 +01002627 } else {
2628 /* the whole string */
2629 ret = end - str;
William Lallemandbddd33a2018-12-11 16:10:53 +01002630 }
2631
William Lallemandb7ea1412018-12-13 09:05:47 +01002632 if (ret > 1) {
William Lallemand2a171912022-02-02 11:43:20 +01002633
2634 /* the mcli-debug-mode is only sent to the applet of the master */
2635 if ((s->pcli_flags & ACCESS_MCLI_DEBUG) && *next_pid <= 0) {
2636 ci_insert_line2(req, 0, "mcli-debug-mode on -", strlen("mcli-debug-mode on -"));
2637 ret += strlen("mcli-debug-mode on -") + 2;
2638 }
William Lallemand7267f782022-02-01 16:08:50 +01002639 if (s->pcli_flags & ACCESS_EXPERIMENTAL) {
2640 ci_insert_line2(req, 0, "experimental-mode on -", strlen("experimental-mode on -"));
2641 ret += strlen("experimental-mode on -") + 2;
2642 }
2643 if (s->pcli_flags & ACCESS_EXPERT) {
2644 ci_insert_line2(req, 0, "expert-mode on -", strlen("expert-mode on -"));
2645 ret += strlen("expert-mode on -") + 2;
2646 }
2647
William Lallemandb7ea1412018-12-13 09:05:47 +01002648 if (pcli_has_level(s, ACCESS_LVL_ADMIN)) {
2649 goto end;
2650 } else if (pcli_has_level(s, ACCESS_LVL_OPER)) {
William Lallemandad032882019-07-01 10:56:15 +02002651 ci_insert_line2(req, 0, "operator -", strlen("operator -"));
2652 ret += strlen("operator -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002653 } else if (pcli_has_level(s, ACCESS_LVL_USER)) {
William Lallemandad032882019-07-01 10:56:15 +02002654 ci_insert_line2(req, 0, "user -", strlen("user -"));
2655 ret += strlen("user -") + 2;
William Lallemandb7ea1412018-12-13 09:05:47 +01002656 }
2657 }
2658end:
William Lallemandbddd33a2018-12-11 16:10:53 +01002659
William Lallemandb7ea1412018-12-13 09:05:47 +01002660 return ret;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002661}
2662
2663int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
2664{
William Lallemandbddd33a2018-12-11 16:10:53 +01002665 int next_pid = -1;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002666 int to_forward;
William Lallemandbddd33a2018-12-11 16:10:53 +01002667 char *errmsg = NULL;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002668
Ilya Shipitsin5e87bcf2021-12-25 11:45:52 +05002669 /* Don't read the next command if still processing the response of the
Christopher Fauletd98da3b2021-10-18 14:52:49 +02002670 * current one. Just wait. At this stage, errors should be handled by
2671 * the response analyzer.
2672 */
2673 if (s->res.analysers & AN_RES_WAIT_CLI)
2674 return 0;
2675
William Lallemandb7ea1412018-12-13 09:05:47 +01002676 if ((s->pcli_flags & ACCESS_LVL_MASK) == ACCESS_LVL_NONE)
2677 s->pcli_flags |= strm_li(s)->bind_conf->level & ACCESS_LVL_MASK;
2678
William Lallemand0a0512f2022-09-24 16:14:50 +02002679 /* stream that comes from the reload listener only responses the reload
2680 * status and quits */
2681 if (!(s->pcli_flags & PCLI_F_RELOAD)
2682 && strm_li(s)->bind_conf == mcli_reload_bind_conf)
2683 goto send_status;
2684
2685
William Lallemandcf62f7e2018-10-26 14:47:40 +02002686read_again:
2687 /* if the channel is closed for read, we won't receive any more data
2688 from the client, but we don't want to forward this close to the
2689 server */
2690 channel_dont_close(req);
2691
2692 /* We don't know yet to which server we will connect */
2693 channel_dont_connect(req);
2694
Christopher Faulet9a790f62023-03-16 14:40:03 +01002695 s->scf->flags |= SC_FL_RCV_ONCE;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002696
2697 /* need more data */
2698 if (!ci_data(req))
Christopher Faulet0f727da2022-01-18 08:44:23 +01002699 goto missing_data;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002700
2701 /* If there is data available for analysis, log the end of the idle time. */
2702 if (c_data(req) && s->logs.t_idle == -1)
Willy Tarreau69530f52023-04-28 09:16:15 +02002703 s->logs.t_idle = ns_to_ms(now_ns - s->logs.accept_ts) - s->logs.t_handshake;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002704
William Lallemandbddd33a2018-12-11 16:10:53 +01002705 to_forward = pcli_parse_request(s, req, &errmsg, &next_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002706 if (to_forward > 0) {
William Lallemandbddd33a2018-12-11 16:10:53 +01002707 int target_pid;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002708 /* enough data */
2709
William Lallemandcf62f7e2018-10-26 14:47:40 +02002710 /* forward only 1 command */
2711 channel_forward(req, to_forward);
William Lallemandebf61802018-12-11 16:10:57 +01002712
William Lallemanddc12c2e2018-12-13 09:05:46 +01002713 if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
William Lallemandebf61802018-12-11 16:10:57 +01002714 /* we send only 1 command per request, and we write close after it */
Christopher Fauletdf7cd712023-04-13 15:56:26 +02002715 sc_schedule_shutdown(s->scb);
William Lallemandebf61802018-12-11 16:10:57 +01002716 } else {
2717 pcli_write_prompt(s);
2718 }
2719
2720 s->res.flags |= CF_WAKE_ONCE; /* need to be called again */
William Lallemandcf62f7e2018-10-26 14:47:40 +02002721 s->res.analysers |= AN_RES_WAIT_CLI;
2722
William Lallemandebf61802018-12-11 16:10:57 +01002723 if (!(s->flags & SF_ASSIGNED)) {
2724 if (next_pid > -1)
2725 target_pid = next_pid;
2726 else
2727 target_pid = s->pcli_next_pid;
2728 /* we can connect now */
2729 s->target = pcli_pid_to_server(target_pid);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002730
William Lallemanddcbe7b92021-12-10 14:14:53 +01002731 if (!s->target)
2732 goto server_disconnect;
2733
William Lallemandebf61802018-12-11 16:10:57 +01002734 s->flags |= (SF_DIRECT | SF_ASSIGNED);
2735 channel_auto_connect(req);
2736 }
William Lallemandcf62f7e2018-10-26 14:47:40 +02002737
2738 } else if (to_forward == 0) {
William Lallemandcf62f7e2018-10-26 14:47:40 +02002739 /* we trimmed things but we might have other commands to consume */
William Lallemandbddd33a2018-12-11 16:10:53 +01002740 pcli_write_prompt(s);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002741 goto read_again;
Christopher Faulet0f727da2022-01-18 08:44:23 +01002742 } else if (to_forward == -1) {
2743 if (errmsg) {
2744 /* there was an error during the parsing */
2745 pcli_reply_and_close(s, errmsg);
2746 s->req.analysers &= ~AN_REQ_WAIT_CLI;
2747 return 0;
2748 }
2749 goto missing_data;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002750 }
2751
2752 return 0;
2753
2754send_help:
2755 b_reset(&req->buf);
2756 b_putblk(&req->buf, "help\n", 5);
2757 goto read_again;
William Lallemanddcbe7b92021-12-10 14:14:53 +01002758
William Lallemand0a0512f2022-09-24 16:14:50 +02002759send_status:
2760 s->pcli_flags |= PCLI_F_RELOAD;
Willy Tarreaudd9f9212023-05-07 07:07:44 +02002761 /* don't use ci_putblk here because SHUT_DONE could have been sent */
William Lallemand0a0512f2022-09-24 16:14:50 +02002762 b_reset(&req->buf);
2763 b_putblk(&req->buf, "_loadstatus;quit\n", 17);
2764 goto read_again;
2765
Christopher Faulet0f727da2022-01-18 08:44:23 +01002766missing_data:
Christopher Fauletca5309a2023-04-17 16:17:32 +02002767 if (s->scf->flags & (SC_FL_ABRT_DONE|SC_FL_EOS)) {
Christopher Faulet0f727da2022-01-18 08:44:23 +01002768 /* There is no more request or a only a partial one and we
2769 * receive a close from the client, we can leave */
Christopher Fauletdf7cd712023-04-13 15:56:26 +02002770 sc_schedule_shutdown(s->scf);
Christopher Faulet0f727da2022-01-18 08:44:23 +01002771 s->req.analysers &= ~AN_REQ_WAIT_CLI;
2772 return 1;
2773 }
2774 else if (channel_full(req, global.tune.maxrewrite)) {
2775 /* buffer is full and we didn't catch the end of a command */
2776 goto send_help;
2777 }
2778 return 0;
2779
William Lallemanddcbe7b92021-12-10 14:14:53 +01002780server_disconnect:
2781 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
2782 return 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002783}
2784
2785int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
2786{
2787 struct proxy *fe = strm_fe(s);
2788 struct proxy *be = s->be;
2789
Christopher Fauletd7bac882023-04-14 12:05:55 +02002790 if ((s->scb->flags & SC_FL_ERROR) || (rep->flags & (CF_READ_TIMEOUT|CF_WRITE_TIMEOUT)) ||
Christopher Faulet64350bb2023-04-13 16:37:37 +02002791 ((s->scf->flags & SC_FL_SHUT_DONE) && (rep->to_forward || co_data(rep)))) {
William Lallemand6b7cd0a2018-11-06 17:37:11 +01002792 pcli_reply_and_close(s, "Can't connect to the target CLI!\n");
Christopher Fauletd98da3b2021-10-18 14:52:49 +02002793 s->req.analysers &= ~AN_REQ_WAIT_CLI;
William Lallemand6b7cd0a2018-11-06 17:37:11 +01002794 s->res.analysers &= ~AN_RES_WAIT_CLI;
2795 return 0;
2796 }
Christopher Faulet9a790f62023-03-16 14:40:03 +01002797 s->scb->flags |= SC_FL_RCV_ONCE; /* try to get back here ASAP */
Christopher Faulet68ef2182023-03-17 15:38:18 +01002798 s->scf->flags |= SC_FL_SND_NEVERWAIT;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002799
2800 /* don't forward the close */
2801 channel_dont_close(&s->res);
2802 channel_dont_close(&s->req);
2803
William Lallemanddc12c2e2018-12-13 09:05:46 +01002804 if (s->pcli_flags & PCLI_F_PAYLOAD) {
William Lallemandebf61802018-12-11 16:10:57 +01002805 s->res.analysers &= ~AN_RES_WAIT_CLI;
2806 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2807 return 0;
2808 }
2809
William Lallemandcf62f7e2018-10-26 14:47:40 +02002810 /* forward the data */
2811 if (ci_data(rep)) {
2812 c_adv(rep, ci_data(rep));
2813 return 0;
2814 }
2815
Christopher Fauletca5309a2023-04-17 16:17:32 +02002816 if (s->scb->flags & (SC_FL_ABRT_DONE|SC_FL_EOS)) {
William Lallemandcf62f7e2018-10-26 14:47:40 +02002817 /* stream cleanup */
2818
William Lallemand2f4ce202018-10-26 14:47:47 +02002819 pcli_write_prompt(s);
2820
Willy Tarreaucb041662022-05-17 19:44:42 +02002821 s->scb->flags |= SC_FL_NOLINGER | SC_FL_NOHALF;
Christopher Fauletcfc11c02023-04-13 16:10:23 +02002822 sc_abort(s->scb);
Christopher Fauletb2b1c3a2023-04-13 16:23:48 +02002823 sc_shutdown(s->scb);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002824
2825 /*
2826 * starting from there this the same code as
2827 * http_end_txn_clean_session().
2828 *
2829 * It allows to do frontend keepalive while reconnecting to a
2830 * new server for each request.
2831 */
2832
2833 if (s->flags & SF_BE_ASSIGNED) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002834 HA_ATOMIC_DEC(&be->beconn);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002835 if (unlikely(s->srv_conn))
2836 sess_change_server(s, NULL);
2837 }
2838
Willy Tarreau69530f52023-04-28 09:16:15 +02002839 s->logs.t_close = ns_to_ms(now_ns - s->logs.accept_ts);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002840 stream_process_counters(s);
2841
2842 /* don't count other requests' data */
2843 s->logs.bytes_in -= ci_data(&s->req);
2844 s->logs.bytes_out -= ci_data(&s->res);
2845
2846 /* we may need to know the position in the queue */
2847 pendconn_free(s);
2848
2849 /* let's do a final log if we need it */
2850 if (!LIST_ISEMPTY(&fe->logformat) && s->logs.logwait &&
2851 !(s->flags & SF_MONITOR) &&
2852 (!(fe->options & PR_O_NULLNOLOG) || s->req.total)) {
2853 s->do_log(s);
2854 }
2855
2856 /* stop tracking content-based counters */
2857 stream_stop_content_counters(s);
2858 stream_update_time_stats(s);
2859
2860 s->logs.accept_date = date; /* user-visible date for logging */
Willy Tarreau69530f52023-04-28 09:16:15 +02002861 s->logs.accept_ts = now_ns; /* corrected date for internal use */
William Lallemandcf62f7e2018-10-26 14:47:40 +02002862 s->logs.t_handshake = 0; /* There are no handshake in keep alive connection. */
2863 s->logs.t_idle = -1;
Willy Tarreauad5a5f62023-04-27 09:46:02 +02002864 s->logs.request_ts = 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002865 s->logs.t_queue = -1;
2866 s->logs.t_connect = -1;
2867 s->logs.t_data = -1;
2868 s->logs.t_close = 0;
2869 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
2870 s->logs.srv_queue_pos = 0; /* we will get this number soon */
2871
2872 s->logs.bytes_in = s->req.total = ci_data(&s->req);
2873 s->logs.bytes_out = s->res.total = ci_data(&s->res);
2874
2875 stream_del_srv_conn(s);
2876 if (objt_server(s->target)) {
2877 if (s->flags & SF_CURR_SESS) {
2878 s->flags &= ~SF_CURR_SESS;
Willy Tarreau4781b152021-04-06 13:53:36 +02002879 HA_ATOMIC_DEC(&__objt_server(s->target)->cur_sess);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002880 }
Willy Tarreaub54c40a2018-12-02 19:28:41 +01002881 if (may_dequeue_tasks(__objt_server(s->target), be))
Willy Tarreau9ab78292021-06-22 18:47:51 +02002882 process_srv_queue(__objt_server(s->target));
William Lallemandcf62f7e2018-10-26 14:47:40 +02002883 }
2884
2885 s->target = NULL;
2886
2887 /* only release our endpoint if we don't intend to reuse the
2888 * connection.
2889 */
Willy Tarreau462b9892022-05-18 18:06:53 +02002890 if (!sc_conn_ready(s->scb)) {
William Lallemandcf62f7e2018-10-26 14:47:40 +02002891 s->srv_conn = NULL;
Willy Tarreau19c65a92022-05-27 08:49:24 +02002892 if (sc_reset_endp(s->scb) < 0) {
Christopher Faulet50264b42022-03-30 19:39:30 +02002893 if (!s->conn_err_type)
2894 s->conn_err_type = STRM_ET_CONN_OTHER;
Christopher Faulet9ec2f4d2022-03-23 15:15:29 +01002895 if (s->srv_error)
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02002896 s->srv_error(s, s->scb);
Christopher Faulet9ec2f4d2022-03-23 15:15:29 +01002897 return 1;
2898 }
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02002899 se_fl_clr(s->scb->sedesc, ~SE_FL_DETACHED);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002900 }
2901
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02002902 sockaddr_free(&s->scb->dst);
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002903
Willy Tarreau74568cf2022-05-27 09:03:30 +02002904 sc_set_state(s->scb, SC_ST_INI);
Christopher Fauleta1d14a72023-04-14 10:42:08 +02002905 s->scb->flags &= ~(SC_FL_ERROR|SC_FL_SHUT_DONE|SC_FL_SHUT_WANTED);
Willy Tarreaucb041662022-05-17 19:44:42 +02002906 s->scb->flags &= SC_FL_ISBACK | SC_FL_DONT_WAKE; /* we're in the context of process_stream */
Christopher Faulet87633c32023-04-03 18:32:50 +02002907
2908 s->req.flags &= ~(CF_AUTO_CONNECT|CF_STREAMER|CF_STREAMER_FAST|CF_WROTE_DATA);
2909 s->res.flags &= ~(CF_STREAMER|CF_STREAMER_FAST|CF_WRITE_EVENT|CF_WROTE_DATA|CF_READ_EVENT);
Willy Tarreau03bd3952022-05-02 16:36:47 +02002910 s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002911 s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
2912 s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
Christopher Faulet909f3182022-03-29 15:42:09 +02002913 s->conn_retries = 0; /* used for logging too */
Christopher Fauletae024ce2022-03-29 19:02:31 +02002914 s->conn_exp = TICK_ETERNITY;
Christopher Faulet50264b42022-03-30 19:39:30 +02002915 s->conn_err_type = STRM_ET_NONE;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002916 /* reinitialise the current rule list pointer to NULL. We are sure that
2917 * any rulelist match the NULL pointer.
2918 */
2919 s->current_rule_list = NULL;
2920
2921 s->be = strm_fe(s);
2922 s->logs.logwait = strm_fe(s)->to_log;
2923 s->logs.level = 0;
2924 stream_del_srv_conn(s);
2925 s->target = NULL;
2926 /* re-init store persistence */
2927 s->store_count = 0;
2928 s->uniq_id = global.req_count++;
2929
Christopher Fauletca5309a2023-04-17 16:17:32 +02002930 s->scf->flags &= ~(SC_FL_EOS|SC_FL_ERROR|SC_FL_ABRT_DONE|SC_FL_ABRT_WANTED);
Christopher Faulet68ef2182023-03-17 15:38:18 +01002931 s->scf->flags &= ~SC_FL_SND_NEVERWAIT;
Christopher Faulet9a790f62023-03-16 14:40:03 +01002932 s->scf->flags |= SC_FL_RCV_ONCE; /* one read is usually enough */
William Lallemandcf62f7e2018-10-26 14:47:40 +02002933
2934 s->req.flags |= CF_WAKE_ONCE; /* need to be called again if there is some command left in the request */
2935
William Lallemandcf62f7e2018-10-26 14:47:40 +02002936 s->res.analysers &= ~AN_RES_WAIT_CLI;
2937
2938 /* We must trim any excess data from the response buffer, because we
2939 * may have blocked an invalid response from a server that we don't
Ilya Shipitsind4259502020-04-08 01:07:56 +05002940 * want to accidentally forward once we disable the analysers, nor do
William Lallemandcf62f7e2018-10-26 14:47:40 +02002941 * we want those data to come along with next response. A typical
2942 * example of such data would be from a buggy server responding to
2943 * a HEAD with some data, or sending more than the advertised
2944 * content-length.
2945 */
2946 if (unlikely(ci_data(&s->res)))
2947 b_set_data(&s->res.buf, co_data(&s->res));
2948
2949 /* Now we can realign the response buffer */
2950 c_realign_if_empty(&s->res);
2951
Christopher Faulet5aaacfb2023-02-15 08:13:33 +01002952 s->scf->ioto = strm_fe(s)->timeout.client;
2953 s->scb->ioto = TICK_ETERNITY;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002954
William Lallemandcf62f7e2018-10-26 14:47:40 +02002955 s->req.analyse_exp = TICK_ETERNITY;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002956 s->res.analyse_exp = TICK_ETERNITY;
Christopher Faulet15315d62023-02-20 08:23:51 +01002957
William Lallemandcf62f7e2018-10-26 14:47:40 +02002958 /* we're removing the analysers, we MUST re-enable events detection.
2959 * We don't enable close on the response channel since it's either
2960 * already closed, or in keep-alive with an idle connection handler.
2961 */
2962 channel_auto_read(&s->req);
2963 channel_auto_close(&s->req);
2964 channel_auto_read(&s->res);
2965
2966
2967 return 1;
2968 }
2969 return 0;
2970}
2971
William Lallemand8a022572018-10-26 14:47:35 +02002972/*
2973 * The mworker functions are used to initialize the CLI in the master process
2974 */
2975
William Lallemand309dc9a2018-10-26 14:47:45 +02002976 /*
2977 * Stop the mworker proxy
2978 */
2979void mworker_cli_proxy_stop()
2980{
William Lallemand550db6d2018-11-06 17:37:12 +01002981 if (mworker_proxy)
2982 stop_proxy(mworker_proxy);
William Lallemand309dc9a2018-10-26 14:47:45 +02002983}
2984
William Lallemand8a022572018-10-26 14:47:35 +02002985/*
2986 * Create the mworker CLI proxy
2987 */
2988int mworker_cli_proxy_create()
2989{
2990 struct mworker_proc *child;
William Lallemand744a0892018-11-22 16:46:51 +01002991 char *msg = NULL;
2992 char *errmsg = NULL;
William Lallemand8a022572018-10-26 14:47:35 +02002993
William Lallemandae787ba2021-07-29 15:13:22 +02002994 mworker_proxy = alloc_new_proxy("MASTER", PR_CAP_LISTEN|PR_CAP_INT, &errmsg);
William Lallemand8a022572018-10-26 14:47:35 +02002995 if (!mworker_proxy)
William Lallemandae787ba2021-07-29 15:13:22 +02002996 goto error_proxy;
William Lallemand8a022572018-10-26 14:47:35 +02002997
William Lallemandcf62f7e2018-10-26 14:47:40 +02002998 mworker_proxy->mode = PR_MODE_CLI;
William Lallemand8a022572018-10-26 14:47:35 +02002999 mworker_proxy->maxconn = 10; /* default to 10 concurrent connections */
3000 mworker_proxy->timeout.client = 0; /* no timeout */
3001 mworker_proxy->conf.file = strdup("MASTER");
3002 mworker_proxy->conf.line = 0;
3003 mworker_proxy->accept = frontend_accept;
3004 mworker_proxy-> lbprm.algo = BE_LB_ALGO_NONE;
3005
3006 /* Does not init the default target the CLI applet, but must be done in
3007 * the request parsing code */
3008 mworker_proxy->default_target = NULL;
3009
William Lallemand8a022572018-10-26 14:47:35 +02003010 /* create all servers using the mworker_proc list */
3011 list_for_each_entry(child, &proc_list, list) {
William Lallemand8a022572018-10-26 14:47:35 +02003012 struct server *newsrv = NULL;
3013 struct sockaddr_storage *sk;
3014 int port1, port2, port;
3015 struct protocol *proto;
William Lallemand8a022572018-10-26 14:47:35 +02003016
William Lallemanda31b09e2020-01-14 15:25:02 +01003017 /* only the workers support the master CLI */
3018 if (!(child->options & PROC_O_TYPE_WORKER))
3019 continue;
3020
William Lallemand8a022572018-10-26 14:47:35 +02003021 newsrv = new_server(mworker_proxy);
3022 if (!newsrv)
William Lallemand744a0892018-11-22 16:46:51 +01003023 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02003024
3025 /* we don't know the new pid yet */
3026 if (child->pid == -1)
Willy Tarreaue8422bf2021-06-15 09:08:18 +02003027 memprintf(&msg, "cur-%d", 1);
William Lallemand8a022572018-10-26 14:47:35 +02003028 else
3029 memprintf(&msg, "old-%d", child->pid);
3030
3031 newsrv->next = mworker_proxy->srv;
3032 mworker_proxy->srv = newsrv;
3033 newsrv->conf.file = strdup(msg);
3034 newsrv->id = strdup(msg);
3035 newsrv->conf.line = 0;
3036
3037 memprintf(&msg, "sockpair@%d", child->ipc_fd[0]);
Willy Tarreau5fc93282020-09-16 18:25:03 +02003038 if ((sk = str2sa_range(msg, &port, &port1, &port2, NULL, &proto,
Willy Tarreaua93e5c72020-09-15 14:01:16 +02003039 &errmsg, NULL, NULL, PA_O_STREAM)) == 0) {
William Lallemand744a0892018-11-22 16:46:51 +01003040 goto error;
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01003041 }
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003042 ha_free(&msg);
William Lallemand8a022572018-10-26 14:47:35 +02003043
Willy Tarreau5fc93282020-09-16 18:25:03 +02003044 if (!proto->connect) {
William Lallemand744a0892018-11-22 16:46:51 +01003045 goto error;
William Lallemand8a022572018-10-26 14:47:35 +02003046 }
3047
3048 /* no port specified */
3049 newsrv->flags |= SRV_F_MAPPORTS;
3050 newsrv->addr = *sk;
William Lallemandcf62f7e2018-10-26 14:47:40 +02003051 /* don't let the server participate to load balancing */
3052 newsrv->iweight = 0;
3053 newsrv->uweight = 0;
William Lallemand8a022572018-10-26 14:47:35 +02003054 srv_lb_commit_status(newsrv);
William Lallemand291810d2018-10-26 14:47:38 +02003055
3056 child->srv = newsrv;
William Lallemand8a022572018-10-26 14:47:35 +02003057 }
William Lallemandae787ba2021-07-29 15:13:22 +02003058
3059 mworker_proxy->next = proxies_list;
3060 proxies_list = mworker_proxy;
3061
William Lallemand8a022572018-10-26 14:47:35 +02003062 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01003063
3064error:
William Lallemand744a0892018-11-22 16:46:51 +01003065
3066 list_for_each_entry(child, &proc_list, list) {
3067 free((char *)child->srv->conf.file); /* cast because of const char * */
3068 free(child->srv->id);
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003069 ha_free(&child->srv);
William Lallemand744a0892018-11-22 16:46:51 +01003070 }
William Lallemandae787ba2021-07-29 15:13:22 +02003071 free_proxy(mworker_proxy);
William Lallemand744a0892018-11-22 16:46:51 +01003072 free(msg);
3073
William Lallemandae787ba2021-07-29 15:13:22 +02003074error_proxy:
3075 ha_alert("%s\n", errmsg);
3076 free(errmsg);
3077
William Lallemand744a0892018-11-22 16:46:51 +01003078 return -1;
William Lallemand8a022572018-10-26 14:47:35 +02003079}
Olivier Houchardf886e342017-04-05 22:24:59 +02003080
William Lallemandce83b4a2018-10-26 14:47:30 +02003081/*
William Lallemande7361152018-10-26 14:47:36 +02003082 * Create a new listener for the master CLI proxy
3083 */
William Lallemand21623b52022-09-24 15:51:27 +02003084struct bind_conf *mworker_cli_proxy_new_listener(char *line)
William Lallemande7361152018-10-26 14:47:36 +02003085{
3086 struct bind_conf *bind_conf;
3087 struct listener *l;
3088 char *err = NULL;
3089 char *args[MAX_LINE_ARGS + 1];
3090 int arg;
3091 int cur_arg;
3092
William Lallemand2e945c82019-11-25 09:58:37 +01003093 arg = 1;
William Lallemande7361152018-10-26 14:47:36 +02003094 args[0] = line;
3095
3096 /* args is a bind configuration with spaces replaced by commas */
3097 while (*line && arg < MAX_LINE_ARGS) {
3098
3099 if (*line == ',') {
3100 *line++ = '\0';
3101 while (*line == ',')
3102 line++;
William Lallemand2e945c82019-11-25 09:58:37 +01003103 args[arg++] = line;
William Lallemande7361152018-10-26 14:47:36 +02003104 }
3105 line++;
3106 }
3107
William Lallemand2e945c82019-11-25 09:58:37 +01003108 args[arg] = "\0";
William Lallemande7361152018-10-26 14:47:36 +02003109
3110 bind_conf = bind_conf_alloc(mworker_proxy, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01003111 if (!bind_conf)
3112 goto err;
William Lallemande7361152018-10-26 14:47:36 +02003113
3114 bind_conf->level &= ~ACCESS_LVL_MASK;
3115 bind_conf->level |= ACCESS_LVL_ADMIN;
Willy Tarreaue283ee62021-03-12 15:00:57 +01003116 bind_conf->level |= ACCESS_MASTER | ACCESS_MASTER_ONLY;
William Lallemande7361152018-10-26 14:47:36 +02003117
3118 if (!str2listener(args[0], mworker_proxy, bind_conf, "master-socket", 0, &err)) {
3119 ha_alert("Cannot create the listener of the master CLI\n");
William Lallemand744a0892018-11-22 16:46:51 +01003120 goto err;
William Lallemande7361152018-10-26 14:47:36 +02003121 }
3122
3123 cur_arg = 1;
3124
3125 while (*args[cur_arg]) {
William Lallemande7361152018-10-26 14:47:36 +02003126 struct bind_kw *kw;
Willy Tarreau433b05f2021-03-12 10:14:07 +01003127 const char *best;
William Lallemande7361152018-10-26 14:47:36 +02003128
3129 kw = bind_find_kw(args[cur_arg]);
3130 if (kw) {
3131 if (!kw->parse) {
3132 memprintf(&err, "'%s %s' : '%s' option is not implemented in this version (check build options).",
3133 args[0], args[1], args[cur_arg]);
3134 goto err;
3135 }
3136
Willy Tarreau4975d142021-03-13 11:00:33 +01003137 if (kw->parse(args, cur_arg, global.cli_fe, bind_conf, &err) != 0) {
William Lallemande7361152018-10-26 14:47:36 +02003138 if (err)
3139 memprintf(&err, "'%s %s' : '%s'", args[0], args[1], err);
3140 else
3141 memprintf(&err, "'%s %s' : error encountered while processing '%s'",
3142 args[0], args[1], args[cur_arg]);
3143 goto err;
3144 }
3145
3146 cur_arg += 1 + kw->skip;
3147 continue;
3148 }
3149
Willy Tarreau433b05f2021-03-12 10:14:07 +01003150 best = bind_find_best_kw(args[cur_arg]);
3151 if (best)
3152 memprintf(&err, "'%s %s' : unknown keyword '%s'. Did you mean '%s' maybe ?",
3153 args[0], args[1], args[cur_arg], best);
3154 else
3155 memprintf(&err, "'%s %s' : unknown keyword '%s'.",
3156 args[0], args[1], args[cur_arg]);
William Lallemande7361152018-10-26 14:47:36 +02003157 goto err;
3158 }
3159
3160
Willy Tarreau30836152023-01-12 19:10:17 +01003161 bind_conf->accept = session_accept_fd;
Willy Tarreau7dbd4182023-01-12 19:32:45 +01003162 bind_conf->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau17146802023-01-12 19:58:42 +01003163 bind_conf->options |= BC_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreaud5983ce2023-01-12 19:18:34 +01003164
William Lallemande7361152018-10-26 14:47:36 +02003165 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
Willy Tarreau18c20d22020-10-09 16:11:46 +02003166 l->rx.flags |= RX_F_MWORKER; /* we are keeping this FD in the master */
Willy Tarreau18215cb2019-02-27 16:25:28 +01003167 global.maxsock++; /* for the listening socket */
William Lallemande7361152018-10-26 14:47:36 +02003168 }
Willy Tarreau18215cb2019-02-27 16:25:28 +01003169 global.maxsock += mworker_proxy->maxconn;
William Lallemande7361152018-10-26 14:47:36 +02003170
William Lallemand21623b52022-09-24 15:51:27 +02003171 return bind_conf;
William Lallemande7361152018-10-26 14:47:36 +02003172
3173err:
3174 ha_alert("%s\n", err);
William Lallemand744a0892018-11-22 16:46:51 +01003175 free(err);
3176 free(bind_conf);
William Lallemand21623b52022-09-24 15:51:27 +02003177 return NULL;
William Lallemande7361152018-10-26 14:47:36 +02003178
3179}
3180
3181/*
William Lallemandce83b4a2018-10-26 14:47:30 +02003182 * Create a new CLI socket using a socketpair for a worker process
3183 * <mworker_proc> is the process structure, and <proc> is the process number
3184 */
3185int mworker_cli_sockpair_new(struct mworker_proc *mworker_proc, int proc)
3186{
3187 struct bind_conf *bind_conf;
3188 struct listener *l;
3189 char *path = NULL;
3190 char *err = NULL;
3191
3192 /* master pipe to ensure the master is still alive */
3193 if (socketpair(AF_UNIX, SOCK_STREAM, 0, mworker_proc->ipc_fd) < 0) {
3194 ha_alert("Cannot create worker socketpair.\n");
3195 return -1;
3196 }
3197
3198 /* XXX: we might want to use a separate frontend at some point */
Willy Tarreau4975d142021-03-13 11:00:33 +01003199 if (!global.cli_fe) {
3200 if ((global.cli_fe = cli_alloc_fe("GLOBAL", "master-socket", 0)) == NULL) {
William Lallemandce83b4a2018-10-26 14:47:30 +02003201 ha_alert("out of memory trying to allocate the stats frontend");
William Lallemand744a0892018-11-22 16:46:51 +01003202 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02003203 }
3204 }
3205
Willy Tarreau4975d142021-03-13 11:00:33 +01003206 bind_conf = bind_conf_alloc(global.cli_fe, "master-socket", 0, "", xprt_get(XPRT_RAW));
William Lallemand744a0892018-11-22 16:46:51 +01003207 if (!bind_conf)
3208 goto error;
3209
William Lallemandce83b4a2018-10-26 14:47:30 +02003210 bind_conf->level &= ~ACCESS_LVL_MASK;
3211 bind_conf->level |= ACCESS_LVL_ADMIN; /* TODO: need to lower the rights with a CLI keyword*/
William Lallemand2be557f2021-11-24 18:45:37 +01003212 bind_conf->level |= ACCESS_FD_LISTENERS;
William Lallemandce83b4a2018-10-26 14:47:30 +02003213
William Lallemandce83b4a2018-10-26 14:47:30 +02003214 if (!memprintf(&path, "sockpair@%d", mworker_proc->ipc_fd[1])) {
3215 ha_alert("Cannot allocate listener.\n");
William Lallemand744a0892018-11-22 16:46:51 +01003216 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02003217 }
3218
Willy Tarreau4975d142021-03-13 11:00:33 +01003219 if (!str2listener(path, global.cli_fe, bind_conf, "master-socket", 0, &err)) {
Tim Duesterhus4cae3b22018-11-22 16:46:50 +01003220 free(path);
William Lallemandce83b4a2018-10-26 14:47:30 +02003221 ha_alert("Cannot create a CLI sockpair listener for process #%d\n", proc);
William Lallemand744a0892018-11-22 16:46:51 +01003222 goto error;
William Lallemandce83b4a2018-10-26 14:47:30 +02003223 }
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003224 ha_free(&path);
William Lallemandce83b4a2018-10-26 14:47:30 +02003225
Willy Tarreau30836152023-01-12 19:10:17 +01003226 bind_conf->accept = session_accept_fd;
Willy Tarreau7dbd4182023-01-12 19:32:45 +01003227 bind_conf->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau17146802023-01-12 19:58:42 +01003228 bind_conf->options |= BC_O_UNLIMITED | BC_O_NOSTOP;
Willy Tarreaud5983ce2023-01-12 19:18:34 +01003229
William Lallemandce83b4a2018-10-26 14:47:30 +02003230 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
Willy Tarreau4781b152021-04-06 13:53:36 +02003231 HA_ATOMIC_INC(&unstoppable_jobs);
William Lallemandce83b4a2018-10-26 14:47:30 +02003232 /* it's a sockpair but we don't want to keep the fd in the master */
Willy Tarreau43046fa2020-09-01 15:41:59 +02003233 l->rx.flags &= ~RX_F_INHERITED;
Willy Tarreau18215cb2019-02-27 16:25:28 +01003234 global.maxsock++; /* for the listening socket */
William Lallemandce83b4a2018-10-26 14:47:30 +02003235 }
3236
3237 return 0;
William Lallemand744a0892018-11-22 16:46:51 +01003238
3239error:
3240 close(mworker_proc->ipc_fd[0]);
3241 close(mworker_proc->ipc_fd[1]);
3242 free(err);
3243
3244 return -1;
William Lallemandce83b4a2018-10-26 14:47:30 +02003245}
3246
William Lallemand74c24fb2016-11-21 17:18:36 +01003247static struct applet cli_applet = {
3248 .obj_type = OBJ_TYPE_APPLET,
3249 .name = "<CLI>", /* used for logging */
3250 .fct = cli_io_handler,
3251 .release = cli_release_handler,
3252};
3253
William Lallemand99e0bb92020-11-05 10:28:53 +01003254/* master CLI */
3255static struct applet mcli_applet = {
3256 .obj_type = OBJ_TYPE_APPLET,
3257 .name = "<MCLI>", /* used for logging */
3258 .fct = cli_io_handler,
3259 .release = cli_release_handler,
3260};
3261
Willy Tarreau0a739292016-11-22 20:21:23 +01003262/* register cli keywords */
3263static struct cli_kw_list cli_kws = {{ },{
Willy Tarreaub205bfd2021-05-07 11:38:37 +02003264 { { "help", NULL }, NULL, cli_parse_simple, NULL, NULL, NULL, ACCESS_MASTER },
3265 { { "prompt", NULL }, NULL, cli_parse_simple, NULL, NULL, NULL, ACCESS_MASTER },
3266 { { "quit", NULL }, NULL, cli_parse_simple, NULL, NULL, NULL, ACCESS_MASTER },
3267 { { "_getsocks", NULL }, NULL, _getsocks, NULL },
William Lallemandd9c28072022-02-02 11:23:58 +01003268 { { "expert-mode", NULL }, NULL, cli_parse_expert_experimental_mode, NULL, NULL, NULL, ACCESS_MASTER }, // not listed
3269 { { "experimental-mode", NULL }, NULL, cli_parse_expert_experimental_mode, NULL, NULL, NULL, ACCESS_MASTER }, // not listed
William Lallemand2a171912022-02-02 11:43:20 +01003270 { { "mcli-debug-mode", NULL }, NULL, cli_parse_expert_experimental_mode, NULL, NULL, NULL, ACCESS_MASTER_ONLY }, // not listed
Amaury Denoyelledd3a33f2023-03-03 17:11:10 +01003271 { { "set", "anon", "on" }, "set anon on [value] : activate the anonymized mode", cli_parse_set_anon, NULL, NULL },
3272 { { "set", "anon", "off" }, "set anon off : deactivate the anonymized mode", cli_parse_set_anon, NULL, NULL },
Erwan Le Goasd7869312022-09-29 10:36:11 +02003273 { { "set", "anon", "global-key", NULL }, "set anon global-key <value> : change the global anonymizing key", cli_parse_set_global_key, NULL, NULL },
Willy Tarreaub205bfd2021-05-07 11:38:37 +02003274 { { "set", "maxconn", "global", NULL }, "set maxconn global <value> : change the per-process maxconn setting", cli_parse_set_maxconn_global, NULL },
3275 { { "set", "rate-limit", NULL }, "set rate-limit <setting> <value> : change a rate limiting value", cli_parse_set_ratelimit, NULL },
3276 { { "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 },
3277 { { "set", "timeout", NULL }, "set timeout [cli] <delay> : change a timeout setting", cli_parse_set_timeout, NULL, NULL },
Erwan Le Goas54966df2022-09-14 17:24:22 +02003278 { { "show", "anon", NULL }, "show anon : display the current state of anonymized mode", cli_parse_show_anon, NULL },
Willy Tarreaub205bfd2021-05-07 11:38:37 +02003279 { { "show", "env", NULL }, "show env [var] : dump environment variables known to the process", cli_parse_show_env, cli_io_handler_show_env, NULL },
3280 { { "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 },
3281 { { "show", "cli", "level", NULL }, "show cli level : display the level of the current CLI session", cli_parse_show_lvl, NULL, NULL, NULL, ACCESS_MASTER},
Willy Tarreau1cb041a2023-03-31 16:33:53 +02003282 { { "show", "fd", NULL }, "show fd [-!plcfbsd]* [num] : dump list of file descriptors in use or a specific one", cli_parse_show_fd, cli_io_handler_show_fd, NULL },
William Lallemand740629e2021-12-14 15:22:29 +01003283 { { "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 +02003284 { { "operator", NULL }, "operator : lower the level of the current CLI session to operator", cli_parse_set_lvl, NULL, NULL, NULL, ACCESS_MASTER},
3285 { { "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 +01003286 {{},}
3287}};
3288
Willy Tarreau0108d902018-11-25 19:14:37 +01003289INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3290
William Lallemand74c24fb2016-11-21 17:18:36 +01003291static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau4975d142021-03-13 11:00:33 +01003292 { CFG_GLOBAL, "stats", cli_parse_global },
William Lallemand74c24fb2016-11-21 17:18:36 +01003293 { 0, NULL, NULL },
3294}};
3295
Willy Tarreau0108d902018-11-25 19:14:37 +01003296INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
3297
William Lallemand74c24fb2016-11-21 17:18:36 +01003298static struct bind_kw_list bind_kws = { "STAT", { }, {
William Lallemandf6975e92017-05-26 17:42:10 +02003299 { "level", bind_parse_level, 1 }, /* set the unix socket admin level */
3300 { "expose-fd", bind_parse_expose_fd, 1 }, /* set the unix socket expose fd rights */
Andjelko Iharosc4df59e2017-07-20 11:59:48 +02003301 { "severity-output", bind_parse_severity_output, 1 }, /* set the severity output format */
William Lallemand74c24fb2016-11-21 17:18:36 +01003302 { NULL, NULL, 0 },
3303}};
3304
Willy Tarreau0108d902018-11-25 19:14:37 +01003305INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
William Lallemand74c24fb2016-11-21 17:18:36 +01003306
3307/*
3308 * Local variables:
3309 * c-indent-level: 8
3310 * c-basic-offset: 8
3311 * End:
3312 */