blob: 84c8cfa0cc5aebdc23ace930709603fcf46b8513 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Configuration parser
3 *
Willy Tarreauff011f22011-01-06 17:51:27 +01004 * Copyright 2000-2011 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreau2e644722022-08-07 16:55:07 +020013/* This is to have crypt() and sched_setaffinity() defined on Linux */
Cyril Bonté1a0191d2014-08-29 20:20:02 +020014#define _GNU_SOURCE
15
Willy Tarreau2e644722022-08-07 16:55:07 +020016#ifdef USE_LIBCRYPT
Willy Tarreaue5733232019-05-22 19:24:06 +020017#ifdef USE_CRYPT_H
Cyril Bonté1a0191d2014-08-29 20:20:02 +020018/* some platforms such as Solaris need this */
19#include <crypt.h>
20#endif
Willy Tarreaue5733232019-05-22 19:24:06 +020021#endif /* USE_LIBCRYPT */
Cyril Bonté1a0191d2014-08-29 20:20:02 +020022
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +010023#include <dirent.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020024#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <netdb.h>
28#include <ctype.h>
Willy Tarreau95c20ac2007-03-25 15:39:23 +020029#include <pwd.h>
30#include <grp.h>
Willy Tarreau0b4ed902007-03-26 00:18:40 +020031#include <errno.h>
Willy Tarreau2e644722022-08-07 16:55:07 +020032#ifdef USE_CPU_AFFINITY
33#include <sched.h>
34#endif
Willy Tarreau3f49b302007-06-11 00:29:26 +020035#include <sys/types.h>
36#include <sys/stat.h>
Willy Tarreau3f49b302007-06-11 00:29:26 +020037#include <unistd.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020038
Willy Tarreaudcc048a2020-06-04 19:11:43 +020039#include <haproxy/acl.h>
Christopher Faulet42c6cf92021-03-25 17:19:04 +010040#include <haproxy/action.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020041#include <haproxy/api.h>
Willy Tarreau732525f2021-05-06 15:49:04 +020042#include <haproxy/arg.h>
Willy Tarreauac13aea2020-06-04 10:36:03 +020043#include <haproxy/auth.h>
Willy Tarreau49801602020-06-04 22:50:02 +020044#include <haproxy/backend.h>
Willy Tarreau278161c2020-06-04 11:18:28 +020045#include <haproxy/capture.h>
Willy Tarreau66243b42021-07-16 15:39:28 +020046#include <haproxy/cfgcond.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020047#include <haproxy/cfgparse.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020048#include <haproxy/channel.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020049#include <haproxy/check.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020050#include <haproxy/chunk.h>
Willy Tarreau55542642021-10-08 09:33:24 +020051#include <haproxy/clock.h>
Amaury Denoyellea6f9c5d2021-04-23 16:58:08 +020052#ifdef USE_CPU_AFFINITY
Amaury Denoyellec90932b2021-04-14 16:16:03 +020053#include <haproxy/cpuset.h>
Amaury Denoyellea6f9c5d2021-04-23 16:58:08 +020054#endif
Willy Tarreau7ea393d2020-06-04 18:02:10 +020055#include <haproxy/connection.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020056#include <haproxy/errors.h>
Willy Tarreauc7babd82020-06-04 21:29:29 +020057#include <haproxy/filters.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020058#include <haproxy/frontend.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020059#include <haproxy/global.h>
Willy Tarreauc2b1ff02020-06-04 21:21:03 +020060#include <haproxy/http_ana.h>
Willy Tarreauc761f842020-06-04 11:40:28 +020061#include <haproxy/http_rules.h>
Willy Tarreaufbe8da32020-06-04 14:34:27 +020062#include <haproxy/lb_chash.h>
Willy Tarreaub5fc3bf2020-06-04 14:37:38 +020063#include <haproxy/lb_fas.h>
Willy Tarreau02549412020-06-04 14:41:04 +020064#include <haproxy/lb_fwlc.h>
Willy Tarreau546ba422020-06-04 14:45:03 +020065#include <haproxy/lb_fwrr.h>
Willy Tarreau28671592020-06-04 20:22:59 +020066#include <haproxy/lb_map.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020067#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020068#include <haproxy/log.h>
Emeric Brund6e581d2022-09-13 16:16:30 +020069#include <haproxy/sink.h>
Willy Tarreaucee013e2020-06-05 11:40:38 +020070#include <haproxy/mailers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020071#include <haproxy/namespace.h>
Amaury Denoyelleb59b8892022-01-25 17:48:47 +010072#include <haproxy/quic_sock.h>
Willy Tarreau8efbdfb2020-06-04 11:29:21 +020073#include <haproxy/obj_type-t.h>
Willy Tarreaube336622023-04-19 10:41:55 +020074#include <haproxy/openssl-compat.h>
Willy Tarreau3c2a7c22020-06-04 18:38:21 +020075#include <haproxy/peers-t.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020076#include <haproxy/peers.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020077#include <haproxy/pool.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020078#include <haproxy/protocol.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020079#include <haproxy/proxy.h>
Emeric Brunc9437992021-02-12 19:42:55 +010080#include <haproxy/resolvers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020081#include <haproxy/sample.h>
82#include <haproxy/server.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020083#include <haproxy/session.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020084#include <haproxy/stats-t.h>
Willy Tarreau872f2ea2020-06-04 18:46:44 +020085#include <haproxy/stick_table.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020086#include <haproxy/stream.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020087#include <haproxy/task.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020088#include <haproxy/tcp_rules.h>
Amaury Denoyellef2c27a52021-07-23 15:46:46 +020089#include <haproxy/tcpcheck.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020090#include <haproxy/thread.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020091#include <haproxy/tools.h>
92#include <haproxy/uri_auth-t.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020093
94
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +010095/* Used to chain configuration sections definitions. This list
96 * stores struct cfg_section
97 */
98struct list sections = LIST_HEAD_INIT(sections);
99
William Lallemand48b4bb42017-10-23 14:36:34 +0200100struct list postparsers = LIST_HEAD_INIT(postparsers);
101
Eric Salama1b8dacc2021-03-16 15:12:17 +0100102extern struct proxy *mworker_proxy;
103
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100104char *cursection = NULL;
Willy Tarreauc8d5b952019-02-27 17:25:52 +0100105int cfg_maxpconn = 0; /* # of simultaneous connections per proxy (-N) */
Willy Tarreau5af24ef2009-03-15 15:23:16 +0100106int cfg_maxconn = 0; /* # of simultaneous connections, (-n) */
Christopher Faulet79bdef32016-11-04 22:36:15 +0100107char *cfg_scope = NULL; /* the current scope during the configuration parsing */
Christopher Faulet037e3f82022-11-18 15:46:06 +0100108int non_global_section_parsed = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200109
Willy Tarreau8a022d52021-04-27 20:29:11 +0200110/* how to handle default paths */
111static enum default_path_mode {
112 DEFAULT_PATH_CURRENT = 0, /* "current": paths are relative to CWD (this is the default) */
113 DEFAULT_PATH_CONFIG, /* "config": paths are relative to config file */
114 DEFAULT_PATH_PARENT, /* "parent": paths are relative to config file's ".." */
115 DEFAULT_PATH_ORIGIN, /* "origin": paths are relative to default_path_origin */
116} default_path_mode;
117
118static char initial_cwd[PATH_MAX];
119static char current_cwd[PATH_MAX];
120
Willy Tarreau5b2c3362008-07-09 19:39:06 +0200121/* List head of all known configuration keywords */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100122struct cfg_kw_list cfg_keywords = {
Willy Tarreau5b2c3362008-07-09 19:39:06 +0200123 .list = LIST_HEAD_INIT(cfg_keywords.list)
124};
125
Willy Tarreaubaaee002006-06-26 02:48:02 +0200126/*
127 * converts <str> to a list of listeners which are dynamically allocated.
128 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
129 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
130 * - <port> is a numerical port from 1 to 65535 ;
131 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
132 * This can be repeated as many times as necessary, separated by a coma.
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200133 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
134 * not NULL, it must be a valid pointer to either NULL or a freeable area that
135 * will be replaced with an error message.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200136 */
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200137int str2listener(char *str, struct proxy *curproxy, struct bind_conf *bind_conf, const char *file, int line, char **err)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200138{
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200139 struct protocol *proto;
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100140 char *next, *dupstr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200141 int port, end;
142
143 next = dupstr = strdup(str);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200144
Willy Tarreaubaaee002006-06-26 02:48:02 +0200145 while (next && *next) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200146 struct sockaddr_storage *ss2;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100147 int fd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200148
149 str = next;
150 /* 1) look for the end of the first address */
Krzysztof Piotr Oledzki52d522b2009-01-27 16:57:08 +0100151 if ((next = strchr(str, ',')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200152 *next++ = 0;
153 }
154
Willy Tarreau5fc93282020-09-16 18:25:03 +0200155 ss2 = str2sa_range(str, NULL, &port, &end, &fd, &proto, err,
Eric Salama1b8dacc2021-03-16 15:12:17 +0100156 (curproxy == global.cli_fe || curproxy == mworker_proxy) ? NULL : global.unix_bind.prefix,
Willy Tarreau32819932020-09-04 15:53:16 +0200157 NULL, PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_PORT_RANGE |
Willy Tarreau5e1779a2020-09-16 16:28:08 +0200158 PA_O_SOCKET_FD | PA_O_STREAM | PA_O_XPRT);
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100159 if (!ss2)
160 goto fail;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200161
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100162 /* OK the address looks correct */
Willy Tarreau91b780a2022-05-20 16:15:01 +0200163 if (proto->proto_type == PROTO_TYPE_DGRAM)
164 bind_conf->options |= BC_O_USE_SOCK_DGRAM;
165 else
166 bind_conf->options |= BC_O_USE_SOCK_STREAM;
167
168 if (proto->xprt_type == PROTO_TYPE_DGRAM)
169 bind_conf->options |= BC_O_USE_XPRT_DGRAM;
170 else
171 bind_conf->options |= BC_O_USE_XPRT_STREAM;
Frédéric Lécaille884f2e92020-11-23 14:23:21 +0100172
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200173 if (!create_listeners(bind_conf, ss2, port, end, fd, proto, err)) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200174 memprintf(err, "%s for address '%s'.\n", *err, str);
175 goto fail;
176 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200177 } /* end while(next) */
178 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200179 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200180 fail:
181 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200182 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200183}
184
William Lallemand6e62fb62015-04-28 16:55:23 +0200185/*
Willy Tarreauaa333122020-09-16 15:13:04 +0200186 * converts <str> to a list of datagram-oriented listeners which are dynamically
187 * allocated.
188 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
189 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
190 * - <port> is a numerical port from 1 to 65535 ;
191 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
192 * This can be repeated as many times as necessary, separated by a coma.
193 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
194 * not NULL, it must be a valid pointer to either NULL or a freeable area that
195 * will be replaced with an error message.
196 */
197int str2receiver(char *str, struct proxy *curproxy, struct bind_conf *bind_conf, const char *file, int line, char **err)
198{
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200199 struct protocol *proto;
Willy Tarreauaa333122020-09-16 15:13:04 +0200200 char *next, *dupstr;
201 int port, end;
202
203 next = dupstr = strdup(str);
204
205 while (next && *next) {
206 struct sockaddr_storage *ss2;
207 int fd = -1;
208
209 str = next;
210 /* 1) look for the end of the first address */
211 if ((next = strchr(str, ',')) != NULL) {
212 *next++ = 0;
213 }
214
Willy Tarreau5fc93282020-09-16 18:25:03 +0200215 ss2 = str2sa_range(str, NULL, &port, &end, &fd, &proto, err,
Willy Tarreau4975d142021-03-13 11:00:33 +0100216 curproxy == global.cli_fe ? NULL : global.unix_bind.prefix,
Willy Tarreauaa333122020-09-16 15:13:04 +0200217 NULL, PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_PORT_RANGE |
218 PA_O_SOCKET_FD | PA_O_DGRAM | PA_O_XPRT);
219 if (!ss2)
220 goto fail;
221
222 /* OK the address looks correct */
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200223 if (!create_listeners(bind_conf, ss2, port, end, fd, proto, err)) {
Willy Tarreauaa333122020-09-16 15:13:04 +0200224 memprintf(err, "%s for address '%s'.\n", *err, str);
225 goto fail;
226 }
227 } /* end while(next) */
228 free(dupstr);
229 return 1;
230 fail:
231 free(dupstr);
232 return 0;
233}
234
235/*
Willy Tarreau08138612021-05-08 19:58:37 +0200236 * Sends a warning if proxy <proxy> does not have at least one of the
237 * capabilities in <cap>. An optional <hint> may be added at the end
238 * of the warning to help the user. Returns 1 if a warning was emitted
239 * or 0 if the condition is valid.
240 */
241int warnifnotcap(struct proxy *proxy, int cap, const char *file, int line, const char *arg, const char *hint)
242{
243 char *msg;
244
245 switch (cap) {
246 case PR_CAP_BE: msg = "no backend"; break;
247 case PR_CAP_FE: msg = "no frontend"; break;
248 case PR_CAP_BE|PR_CAP_FE: msg = "neither frontend nor backend"; break;
249 default: msg = "not enough"; break;
250 }
251
252 if (!(proxy->cap & cap)) {
253 ha_warning("parsing [%s:%d] : '%s' ignored because %s '%s' has %s capability.%s\n",
254 file, line, arg, proxy_type_str(proxy), proxy->id, msg, hint ? hint : "");
255 return 1;
256 }
257 return 0;
258}
259
260/*
261 * Sends an alert if proxy <proxy> does not have at least one of the
262 * capabilities in <cap>. An optional <hint> may be added at the end
263 * of the alert to help the user. Returns 1 if an alert was emitted
264 * or 0 if the condition is valid.
265 */
266int failifnotcap(struct proxy *proxy, int cap, const char *file, int line, const char *arg, const char *hint)
267{
268 char *msg;
269
270 switch (cap) {
271 case PR_CAP_BE: msg = "no backend"; break;
272 case PR_CAP_FE: msg = "no frontend"; break;
273 case PR_CAP_BE|PR_CAP_FE: msg = "neither frontend nor backend"; break;
274 default: msg = "not enough"; break;
275 }
276
277 if (!(proxy->cap & cap)) {
278 ha_alert("parsing [%s:%d] : '%s' not allowed because %s '%s' has %s capability.%s\n",
279 file, line, arg, proxy_type_str(proxy), proxy->id, msg, hint ? hint : "");
280 return 1;
281 }
282 return 0;
283}
284
285/*
Willy Tarreauece9b072016-12-21 22:41:44 +0100286 * Report an error in <msg> when there are too many arguments. This version is
287 * intended to be used by keyword parsers so that the message will be included
288 * into the general error message. The index is the current keyword in args.
289 * Return 0 if the number of argument is correct, otherwise build a message and
290 * return 1. Fill err_code with an ERR_ALERT and an ERR_FATAL if not null. The
291 * message may also be null, it will simply not be produced (useful to check only).
292 * <msg> and <err_code> are only affected on error.
293 */
294int too_many_args_idx(int maxarg, int index, char **args, char **msg, int *err_code)
295{
296 int i;
297
298 if (!*args[index + maxarg + 1])
299 return 0;
300
301 if (msg) {
302 *msg = NULL;
303 memprintf(msg, "%s", args[0]);
304 for (i = 1; i <= index; i++)
305 memprintf(msg, "%s %s", *msg, args[i]);
306
307 memprintf(msg, "'%s' cannot handle unexpected argument '%s'.", *msg, args[index + maxarg + 1]);
308 }
309 if (err_code)
310 *err_code |= ERR_ALERT | ERR_FATAL;
311
312 return 1;
313}
314
315/*
316 * same as too_many_args_idx with a 0 index
317 */
318int too_many_args(int maxarg, char **args, char **msg, int *err_code)
319{
320 return too_many_args_idx(maxarg, 0, args, msg, err_code);
321}
322
323/*
William Lallemand6e62fb62015-04-28 16:55:23 +0200324 * Report a fatal Alert when there is too much arguments
325 * The index is the current keyword in args
326 * Return 0 if the number of argument is correct, otherwise emit an alert and return 1
327 * Fill err_code with an ERR_ALERT and an ERR_FATAL
328 */
329int alertif_too_many_args_idx(int maxarg, int index, const char *file, int linenum, char **args, int *err_code)
330{
331 char *kw = NULL;
332 int i;
333
334 if (!*args[index + maxarg + 1])
335 return 0;
336
337 memprintf(&kw, "%s", args[0]);
338 for (i = 1; i <= index; i++) {
339 memprintf(&kw, "%s %s", kw, args[i]);
340 }
341
Christopher Faulet767a84b2017-11-24 16:50:31 +0100342 ha_alert("parsing [%s:%d] : '%s' cannot handle unexpected argument '%s'.\n", file, linenum, kw, args[index + maxarg + 1]);
William Lallemand6e62fb62015-04-28 16:55:23 +0200343 free(kw);
344 *err_code |= ERR_ALERT | ERR_FATAL;
345 return 1;
346}
347
348/*
349 * same as alertif_too_many_args_idx with a 0 index
350 */
351int alertif_too_many_args(int maxarg, const char *file, int linenum, char **args, int *err_code)
352{
353 return alertif_too_many_args_idx(maxarg, 0, file, linenum, args, err_code);
354}
355
Willy Tarreau61d18892009-03-31 10:49:21 +0200356
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100357/* Report it if a request ACL condition uses some keywords that are incompatible
358 * with the place where the ACL is used. It returns either 0 or ERR_WARN so that
359 * its result can be or'ed with err_code. Note that <cond> may be NULL and then
360 * will be ignored.
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100361 */
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100362int warnif_cond_conflicts(const struct acl_cond *cond, unsigned int where, const char *file, int line)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100363{
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100364 const struct acl *acl;
Willy Tarreau93fddf12013-03-31 22:59:32 +0200365 const char *kw;
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100366
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100367 if (!cond)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100368 return 0;
369
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100370 acl = acl_cond_conflicts(cond, where);
371 if (acl) {
372 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100373 ha_warning("parsing [%s:%d] : acl '%s' will never match because it only involves keywords that are incompatible with '%s'\n",
374 file, line, acl->name, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100375 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100376 ha_warning("parsing [%s:%d] : anonymous acl will never match because it uses keyword '%s' which is incompatible with '%s'\n",
377 file, line, LIST_ELEM(acl->expr.n, struct acl_expr *, list)->kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100378 return ERR_WARN;
379 }
380 if (!acl_cond_kw_conflicts(cond, where, &acl, &kw))
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100381 return 0;
382
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100383 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100384 ha_warning("parsing [%s:%d] : acl '%s' involves keywords '%s' which is incompatible with '%s'\n",
385 file, line, acl->name, kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100386 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100387 ha_warning("parsing [%s:%d] : anonymous acl involves keyword '%s' which is incompatible with '%s'\n",
388 file, line, kw, sample_ckp_names(where));
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100389 return ERR_WARN;
390}
391
Christopher Faulet581db2b2021-03-26 10:02:46 +0100392/* Report it if an ACL uses a L6 sample fetch from an HTTP proxy. It returns
393 * either 0 or ERR_WARN so that its result can be or'ed with err_code. Note that
394 * <cond> may be NULL and then will be ignored.
395*/
396int warnif_tcp_http_cond(const struct proxy *px, const struct acl_cond *cond)
397{
398 if (!cond || px->mode != PR_MODE_HTTP)
399 return 0;
400
401 if (cond->use & (SMP_USE_L6REQ|SMP_USE_L6RES)) {
402 ha_warning("Proxy '%s': L6 sample fetches ignored on HTTP proxies (declared at %s:%d).\n",
403 px->id, cond->file, cond->line);
404 return ERR_WARN;
405 }
406 return 0;
407}
408
Willy Tarreaue2afcc42021-03-12 09:08:04 +0100409/* try to find in <list> the word that looks closest to <word> by counting
410 * transitions between letters, digits and other characters. Will return the
411 * best matching word if found, otherwise NULL. An optional array of extra
412 * words to compare may be passed in <extra>, but it must then be terminated
413 * by a NULL entry. If unused it may be NULL.
414 */
415const char *cfg_find_best_match(const char *word, const struct list *list, int section, const char **extra)
416{
417 uint8_t word_sig[1024]; // 0..25=letter, 26=digit, 27=other, 28=begin, 29=end
418 uint8_t list_sig[1024];
419 const struct cfg_kw_list *kwl;
420 int index;
421 const char *best_ptr = NULL;
422 int dist, best_dist = INT_MAX;
423
424 make_word_fingerprint(word_sig, word);
425 list_for_each_entry(kwl, list, list) {
426 for (index = 0; kwl->kw[index].kw != NULL; index++) {
427 if (kwl->kw[index].section != section)
428 continue;
429
430 make_word_fingerprint(list_sig, kwl->kw[index].kw);
431 dist = word_fingerprint_distance(word_sig, list_sig);
432 if (dist < best_dist) {
433 best_dist = dist;
434 best_ptr = kwl->kw[index].kw;
435 }
436 }
437 }
438
439 while (extra && *extra) {
440 make_word_fingerprint(list_sig, *extra);
441 dist = word_fingerprint_distance(word_sig, list_sig);
442 if (dist < best_dist) {
443 best_dist = dist;
444 best_ptr = *extra;
445 }
446 extra++;
447 }
448
449 if (best_dist > 2 * strlen(word) || (best_ptr && best_dist > 2 * strlen(best_ptr)))
450 best_ptr = NULL;
451 return best_ptr;
452}
453
Christopher Faulet62519022017-10-16 15:49:32 +0200454/* Parse a string representing a process number or a set of processes. It must
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100455 * be "all", "odd", "even", a number between 1 and <max> or a range with
Christopher Faulet5ab51772017-11-22 11:21:58 +0100456 * two such numbers delimited by a dash ('-'). On success, it returns
457 * 0. otherwise it returns 1 with an error message in <err>.
Christopher Faulet62519022017-10-16 15:49:32 +0200458 *
459 * Note: this function can also be used to parse a thread number or a set of
460 * threads.
461 */
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100462int parse_process_number(const char *arg, unsigned long *proc, int max, int *autoinc, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200463{
Christopher Faulet26028f62017-11-22 15:01:51 +0100464 if (autoinc) {
465 *autoinc = 0;
466 if (strncmp(arg, "auto:", 5) == 0) {
467 arg += 5;
468 *autoinc = 1;
469 }
470 }
471
Christopher Faulet62519022017-10-16 15:49:32 +0200472 if (strcmp(arg, "all") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100473 *proc |= ~0UL;
Christopher Faulet62519022017-10-16 15:49:32 +0200474 else if (strcmp(arg, "odd") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100475 *proc |= ~0UL/3UL; /* 0x555....555 */
Christopher Faulet62519022017-10-16 15:49:32 +0200476 else if (strcmp(arg, "even") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100477 *proc |= (~0UL/3UL) << 1; /* 0xAAA...AAA */
Christopher Faulet62519022017-10-16 15:49:32 +0200478 else {
Christopher Faulet18cca782019-02-07 16:29:41 +0100479 const char *p, *dash = NULL;
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100480 unsigned int low, high;
481
Christopher Faulet18cca782019-02-07 16:29:41 +0100482 for (p = arg; *p; p++) {
483 if (*p == '-' && !dash)
484 dash = p;
Willy Tarreau90807112020-02-25 08:16:33 +0100485 else if (!isdigit((unsigned char)*p)) {
Christopher Faulet18cca782019-02-07 16:29:41 +0100486 memprintf(err, "'%s' is not a valid number/range.", arg);
487 return -1;
488 }
Christopher Faulet5ab51772017-11-22 11:21:58 +0100489 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100490
491 low = high = str2uic(arg);
Christopher Faulet18cca782019-02-07 16:29:41 +0100492 if (dash)
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100493 high = ((!*(dash+1)) ? max : str2uic(dash + 1));
Christopher Fauletff4121f2017-11-22 16:38:49 +0100494
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100495 if (high < low) {
496 unsigned int swap = low;
497 low = high;
498 high = swap;
499 }
500
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100501 if (low < 1 || low > max || high > max) {
Christopher Fauletcb6a9452017-11-22 16:50:41 +0100502 memprintf(err, "'%s' is not a valid number/range."
503 " It supports numbers from 1 to %d.\n",
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100504 arg, max);
Christopher Faulet5ab51772017-11-22 11:21:58 +0100505 return 1;
506 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100507
508 for (;low <= high; low++)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100509 *proc |= 1UL << (low-1);
Christopher Faulet62519022017-10-16 15:49:32 +0200510 }
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100511 *proc &= ~0UL >> (LONGBITS - max);
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100512
Christopher Faulet5ab51772017-11-22 11:21:58 +0100513 return 0;
Christopher Faulet62519022017-10-16 15:49:32 +0200514}
515
David Carlier7e351ee2017-12-01 09:14:02 +0000516#ifdef USE_CPU_AFFINITY
Christopher Faulet62519022017-10-16 15:49:32 +0200517/* Parse cpu sets. Each CPU set is either a unique number between 0 and
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200518 * ha_cpuset_size() - 1 or a range with two such numbers delimited by a dash
Willy Tarreau615c3012023-05-05 16:10:05 +0200519 * ('-'). Each CPU set can be a list of unique numbers or ranges separated by
520 * a comma. It is also possible to specify multiple cpu numbers or ranges in
521 * distinct argument in <args>. On success, it returns 0, otherwise it returns
522 * 1 with an error message in <err>.
Christopher Faulet62519022017-10-16 15:49:32 +0200523 */
Willy Tarreau615c3012023-05-05 16:10:05 +0200524unsigned long parse_cpu_set(const char **args, struct hap_cpuset *cpu_set, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200525{
526 int cur_arg = 0;
Amaury Denoyellea8082352021-04-06 16:46:15 +0200527 const char *arg;
Christopher Faulet62519022017-10-16 15:49:32 +0200528
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200529 ha_cpuset_zero(cpu_set);
530
Amaury Denoyellea8082352021-04-06 16:46:15 +0200531 arg = args[cur_arg];
532 while (*arg) {
533 const char *dash, *comma;
Christopher Faulet62519022017-10-16 15:49:32 +0200534 unsigned int low, high;
535
Willy Tarreau90807112020-02-25 08:16:33 +0100536 if (!isdigit((unsigned char)*args[cur_arg])) {
Amaury Denoyellea8082352021-04-06 16:46:15 +0200537 memprintf(err, "'%s' is not a CPU range.", arg);
Christopher Faulet62519022017-10-16 15:49:32 +0200538 return -1;
539 }
540
Amaury Denoyellea8082352021-04-06 16:46:15 +0200541 low = high = str2uic(arg);
542
Willy Tarreau615c3012023-05-05 16:10:05 +0200543 comma = strchr(arg, ',');
Amaury Denoyellea8082352021-04-06 16:46:15 +0200544 dash = strchr(arg, '-');
545
546 if (dash && (!comma || dash < comma))
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200547 high = *(dash+1) ? str2uic(dash + 1) : ha_cpuset_size() - 1;
Christopher Faulet62519022017-10-16 15:49:32 +0200548
549 if (high < low) {
550 unsigned int swap = low;
551 low = high;
552 high = swap;
553 }
554
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200555 if (high >= ha_cpuset_size()) {
556 memprintf(err, "supports CPU numbers from 0 to %d.",
557 ha_cpuset_size() - 1);
Christopher Faulet62519022017-10-16 15:49:32 +0200558 return 1;
559 }
560
561 while (low <= high)
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200562 ha_cpuset_set(cpu_set, low++);
Christopher Faulet62519022017-10-16 15:49:32 +0200563
Amaury Denoyellea8082352021-04-06 16:46:15 +0200564 /* if a comma is present, parse the rest of the arg, else
565 * skip to the next arg */
566 arg = comma ? comma + 1 : args[++cur_arg];
Christopher Faulet62519022017-10-16 15:49:32 +0200567 }
568 return 0;
569}
David Carlier7e351ee2017-12-01 09:14:02 +0000570#endif
571
Frédéric Lécaille18251032019-01-11 11:07:15 +0100572/* Allocate and initialize the frontend of a "peers" section found in
Christopher Faulet244331f2022-07-25 15:10:44 +0200573 * file <file> at line <linenum> with <id> as ID.
Frédéric Lécaille18251032019-01-11 11:07:15 +0100574 * Return 0 if succeeded, -1 if not.
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200575 * Note that this function may be called from "default-server"
576 * or "peer" lines.
Frédéric Lécaille18251032019-01-11 11:07:15 +0100577 */
Christopher Faulet244331f2022-07-25 15:10:44 +0200578static int init_peers_frontend(const char *file, int linenum,
579 const char *id, struct peers *peers)
Frédéric Lécaille18251032019-01-11 11:07:15 +0100580{
581 struct proxy *p;
582
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200583 if (peers->peers_fe) {
584 p = peers->peers_fe;
585 goto out;
586 }
Frédéric Lécaille9492c4e2019-01-11 11:47:12 +0100587
Frédéric Lécaille18251032019-01-11 11:07:15 +0100588 p = calloc(1, sizeof *p);
589 if (!p) {
590 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
591 return -1;
592 }
593
594 init_new_proxy(p);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200595 peers_setup_frontend(p);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100596 p->parent = peers;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200597 /* Finally store this frontend. */
598 peers->peers_fe = p;
599
600 out:
Christopher Faulet244331f2022-07-25 15:10:44 +0200601 if (id && !p->id)
602 p->id = strdup(id);
Frédéric Lécaille1055e682018-04-26 14:35:21 +0200603 free(p->conf.file);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100604 p->conf.args.file = p->conf.file = strdup(file);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100605 if (linenum != -1)
606 p->conf.args.line = p->conf.line = linenum;
Frédéric Lécaille18251032019-01-11 11:07:15 +0100607
608 return 0;
609}
Willy Tarreauade5ec42010-01-28 19:33:49 +0100610
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100611/* Only change ->file, ->line and ->arg struct bind_conf member values
612 * if already present.
613 */
614static struct bind_conf *bind_conf_uniq_alloc(struct proxy *p,
615 const char *file, int line,
616 const char *arg, struct xprt_ops *xprt)
617{
618 struct bind_conf *bind_conf;
619
620 if (!LIST_ISEMPTY(&p->conf.bind)) {
621 bind_conf = LIST_ELEM((&p->conf.bind)->n, typeof(bind_conf), by_fe);
Emeric Brun49f6f4b2022-05-25 10:12:07 +0200622 /*
623 * We keep bind_conf->file and bind_conf->line unchanged
624 * to make them available for error messages
625 */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100626 if (arg) {
627 free(bind_conf->arg);
628 bind_conf->arg = strdup(arg);
629 }
630 }
631 else {
632 bind_conf = bind_conf_alloc(p, file, line, arg, xprt);
633 }
634
635 return bind_conf;
636}
637
638/*
639 * Allocate a new struct peer parsed at line <linenum> in file <file>
640 * to be added to <peers>.
641 * Returns the new allocated structure if succeeded, NULL if not.
642 */
643static struct peer *cfg_peers_add_peer(struct peers *peers,
644 const char *file, int linenum,
645 const char *id, int local)
646{
647 struct peer *p;
648
649 p = calloc(1, sizeof *p);
650 if (!p) {
651 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
652 return NULL;
653 }
654
655 /* the peers are linked backwards first */
656 peers->count++;
Christopher Faulet387e7972022-05-12 14:47:52 +0200657 p->peers = peers;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100658 p->next = peers->remote;
659 peers->remote = p;
660 p->conf.file = strdup(file);
661 p->conf.line = linenum;
Willy Tarreau69530f52023-04-28 09:16:15 +0200662 p->last_change = ns_to_sec(now_ns);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100663 p->xprt = xprt_get(XPRT_RAW);
664 p->sock_init_arg = NULL;
665 HA_SPIN_INIT(&p->lock);
666 if (id)
667 p->id = strdup(id);
668 if (local) {
669 p->local = 1;
670 peers->local = p;
671 }
672
673 return p;
674}
675
Willy Tarreaubaaee002006-06-26 02:48:02 +0200676/*
William Lallemand51097192015-04-14 16:35:22 +0200677 * Parse a line in a <listen>, <frontend> or <backend> section.
Willy Tarreau93893792009-07-23 13:19:11 +0200678 * Returns the error code, 0 if OK, or any combination of :
679 * - ERR_ABORT: must abort ASAP
680 * - ERR_FATAL: we can continue parsing but not start the service
681 * - ERR_WARN: a warning has been emitted
682 * - ERR_ALERT: an alert has been emitted
683 * Only the two first ones can stop processing, the two others are just
684 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200685 */
Emeric Brun32da3c42010-09-23 18:39:19 +0200686int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
687{
688 static struct peers *curpeers = NULL;
Frédéric Lécaille36d15652022-10-17 14:58:19 +0200689 static int nb_shards = 0;
Emeric Brun32da3c42010-09-23 18:39:19 +0200690 struct peer *newpeer = NULL;
691 const char *err;
Willy Tarreau4348fad2012-09-20 16:48:07 +0200692 struct bind_conf *bind_conf;
Emeric Brun32da3c42010-09-23 18:39:19 +0200693 int err_code = 0;
Willy Tarreau902636f2013-03-10 19:44:48 +0100694 char *errmsg = NULL;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100695 static int bind_line, peer_line;
696
697 if (strcmp(args[0], "bind") == 0 || strcmp(args[0], "default-bind") == 0) {
698 int cur_arg;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100699 struct bind_conf *bind_conf;
Willy Tarreau55f0f7b2022-05-20 15:44:17 +0200700 int ret;
Emeric Brun32da3c42010-09-23 18:39:19 +0200701
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100702 cur_arg = 1;
703
Christopher Faulet244331f2022-07-25 15:10:44 +0200704 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200705 err_code |= ERR_ALERT | ERR_ABORT;
706 goto out;
707 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100708
709 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum,
Willy Tarreau8d158132022-07-05 15:54:09 +0200710 args[1], xprt_get(XPRT_RAW));
William Lallemand1d932172022-07-06 14:30:23 +0200711 if (!bind_conf) {
712 ha_alert("parsing [%s:%d] : '%s %s' : cannot allocate memory.\n", file, linenum, args[0], args[1]);
713 err_code |= ERR_FATAL;
714 goto out;
715 }
Willy Tarreau882f2482023-01-12 18:52:23 +0100716
717 bind_conf->maxaccept = 1;
Willy Tarreau30836152023-01-12 19:10:17 +0100718 bind_conf->accept = session_accept_fd;
Willy Tarreau17146802023-01-12 19:58:42 +0100719 bind_conf->options |= BC_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau882f2482023-01-12 18:52:23 +0100720
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100721 if (*args[0] == 'b') {
722 struct listener *l;
723
724 if (peer_line) {
725 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
726 err_code |= ERR_ALERT | ERR_FATAL;
727 goto out;
728 }
729
Emeric Brun49f6f4b2022-05-25 10:12:07 +0200730 if (!LIST_ISEMPTY(&bind_conf->listeners)) {
731 ha_alert("parsing [%s:%d] : One listener per \"peers\" section is authorized but another is already configured at [%s:%d].\n", file, linenum, bind_conf->file, bind_conf->line);
732 err_code |= ERR_FATAL;
733 }
734
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100735 if (!str2listener(args[1], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
736 if (errmsg && *errmsg) {
737 indent_msg(&errmsg, 2);
738 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
739 }
740 else
741 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
Willy Tarreau0d044102022-05-20 15:19:48 +0200742 file, linenum, args[0], args[1], args[1]);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100743 err_code |= ERR_FATAL;
744 goto out;
745 }
Willy Tarreau17146802023-01-12 19:58:42 +0100746
Emeric Brunca825782022-05-25 10:25:45 +0200747 /*
748 * Newly allocated listener is at the end of the list
749 */
750 l = LIST_ELEM(bind_conf->listeners.p, typeof(l), by_bind);
Willy Tarreau17146802023-01-12 19:58:42 +0100751
Willy Tarreau18215cb2019-02-27 16:25:28 +0100752 global.maxsock++; /* for the listening socket */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100753
754 bind_line = 1;
755 if (cfg_peers->local) {
756 newpeer = cfg_peers->local;
757 }
758 else {
759 /* This peer is local.
760 * Note that we do not set the peer ID. This latter is initialized
761 * when parsing "peer" or "server" line.
762 */
763 newpeer = cfg_peers_add_peer(curpeers, file, linenum, NULL, 1);
764 if (!newpeer) {
765 err_code |= ERR_ALERT | ERR_ABORT;
766 goto out;
767 }
768 }
Willy Tarreau37159062020-08-27 07:48:42 +0200769 newpeer->addr = l->rx.addr;
Willy Tarreau5fc93282020-09-16 18:25:03 +0200770 newpeer->proto = l->rx.proto;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100771 cur_arg++;
772 }
773
Willy Tarreau55f0f7b2022-05-20 15:44:17 +0200774 ret = bind_parse_args_list(bind_conf, args, cur_arg, cursection, file, linenum);
775 err_code |= ret;
776 if (ret != 0)
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100777 goto out;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100778 }
779 else if (strcmp(args[0], "default-server") == 0) {
Christopher Faulet244331f2022-07-25 15:10:44 +0200780 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100781 err_code |= ERR_ALERT | ERR_ABORT;
782 goto out;
783 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +0100784 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL,
785 SRV_PARSE_DEFAULT_SERVER|SRV_PARSE_IN_PEER_SECTION|SRV_PARSE_INITIAL_RESOLVE);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200786 }
Frédéric Lécailleb6f759b2019-11-05 09:57:45 +0100787 else if (strcmp(args[0], "log") == 0) {
Christopher Faulet244331f2022-07-25 15:10:44 +0200788 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
Frédéric Lécailleb6f759b2019-11-05 09:57:45 +0100789 err_code |= ERR_ALERT | ERR_ABORT;
790 goto out;
791 }
Emeric Brun9533a702021-04-02 10:13:43 +0200792 if (!parse_logsrv(args, &curpeers->peers_fe->logsrvs, (kwm == KWM_NO), file, linenum, &errmsg)) {
Frédéric Lécailleb6f759b2019-11-05 09:57:45 +0100793 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
794 err_code |= ERR_ALERT | ERR_FATAL;
795 goto out;
796 }
797 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200798 else if (strcmp(args[0], "peers") == 0) { /* new peers section */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100799 /* Initialize these static variables when entering a new "peers" section*/
800 bind_line = peer_line = 0;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100801 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100802 ha_alert("parsing [%s:%d] : missing name for peers section.\n", file, linenum);
Willy Tarreau54984722014-02-16 08:20:13 +0100803 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100804 goto out;
805 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200806
William Lallemand6e62fb62015-04-28 16:55:23 +0200807 if (alertif_too_many_args(1, file, linenum, args, &err_code))
808 goto out;
809
Emeric Brun32da3c42010-09-23 18:39:19 +0200810 err = invalid_char(args[1]);
811 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100812 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
813 file, linenum, *err, args[0], args[1]);
Willy Tarreau54984722014-02-16 08:20:13 +0100814 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100815 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200816 }
817
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200818 for (curpeers = cfg_peers; curpeers != NULL; curpeers = curpeers->next) {
Emeric Brun32da3c42010-09-23 18:39:19 +0200819 /*
820 * If there are two proxies with the same name only following
821 * combinations are allowed:
822 */
823 if (strcmp(curpeers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100824 ha_alert("Parsing [%s:%d]: peers section '%s' has the same name as another peers section declared at %s:%d.\n",
825 file, linenum, args[1], curpeers->conf.file, curpeers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +0200826 err_code |= ERR_ALERT | ERR_FATAL;
Emeric Brun32da3c42010-09-23 18:39:19 +0200827 }
828 }
829
Vincent Bernat02779b62016-04-03 13:48:43 +0200830 if ((curpeers = calloc(1, sizeof(*curpeers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100831 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Emeric Brun32da3c42010-09-23 18:39:19 +0200832 err_code |= ERR_ALERT | ERR_ABORT;
833 goto out;
834 }
835
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200836 curpeers->next = cfg_peers;
837 cfg_peers = curpeers;
Willy Tarreau8113a5d2012-10-04 08:01:43 +0200838 curpeers->conf.file = strdup(file);
Emeric Brun32da3c42010-09-23 18:39:19 +0200839 curpeers->conf.line = linenum;
Willy Tarreau69530f52023-04-28 09:16:15 +0200840 curpeers->last_change = ns_to_sec(now_ns);
Emeric Brun32da3c42010-09-23 18:39:19 +0200841 curpeers->id = strdup(args[1]);
Willy Tarreau1ad64ac2020-09-24 08:48:08 +0200842 curpeers->disabled = 0;
Emeric Brun32da3c42010-09-23 18:39:19 +0200843 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200844 else if (strcmp(args[0], "peer") == 0 ||
845 strcmp(args[0], "server") == 0) { /* peer or server definition */
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100846 int local_peer, peer;
Amaury Denoyelle30c05372021-03-08 16:36:46 +0100847 int parse_addr = 0;
Emeric Brun32da3c42010-09-23 18:39:19 +0200848
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100849 peer = *args[0] == 'p';
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100850 local_peer = strcmp(args[1], localpeer) == 0;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100851 /* The local peer may have already partially been parsed on a "bind" line. */
852 if (*args[0] == 'p') {
853 if (bind_line) {
854 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
855 err_code |= ERR_ALERT | ERR_FATAL;
856 goto out;
857 }
858 peer_line = 1;
859 }
860 if (cfg_peers->local && !cfg_peers->local->id && local_peer) {
861 /* The local peer has already been initialized on a "bind" line.
862 * Let's use it and store its ID.
863 */
864 newpeer = cfg_peers->local;
865 newpeer->id = strdup(localpeer);
866 }
867 else {
868 if (local_peer && cfg_peers->local) {
869 ha_alert("parsing [%s:%d] : '%s %s' : local peer name already referenced at %s:%d. %s\n",
870 file, linenum, args[0], args[1],
871 curpeers->peers_fe->conf.file, curpeers->peers_fe->conf.line, cfg_peers->local->id);
872 err_code |= ERR_FATAL;
873 goto out;
874 }
875 newpeer = cfg_peers_add_peer(curpeers, file, linenum, args[1], local_peer);
876 if (!newpeer) {
877 err_code |= ERR_ALERT | ERR_ABORT;
878 goto out;
879 }
880 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200881
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100882 /* Line number and peer ID are updated only if this peer is the local one. */
883 if (init_peers_frontend(file,
884 newpeer->local ? linenum: -1,
Christopher Faulet244331f2022-07-25 15:10:44 +0200885 newpeer->local ? newpeer->id : NULL,
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100886 curpeers) != 0) {
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200887 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreaub36487e2013-03-10 18:37:42 +0100888 goto out;
889 }
Willy Tarreau2aa38802013-02-20 19:20:59 +0100890
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100891 /* This initializes curpeer->peers->peers_fe->srv.
892 * The server address is parsed only if we are parsing a "peer" line,
893 * or if we are parsing a "server" line and the current peer is not the local one.
894 */
Amaury Denoyelle30c05372021-03-08 16:36:46 +0100895 parse_addr = (peer || !local_peer) ? SRV_PARSE_PARSE_ADDR : 0;
896 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL,
897 SRV_PARSE_IN_PEER_SECTION|parse_addr|SRV_PARSE_INITIAL_RESOLVE);
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200898 if (!curpeers->peers_fe->srv) {
899 /* Remove the newly allocated peer. */
900 if (newpeer != curpeers->local) {
901 struct peer *p;
902
903 p = curpeers->remote;
904 curpeers->remote = curpeers->remote->next;
905 free(p->id);
906 free(p);
907 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200908 goto out;
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200909 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200910
Frédéric Lécaille36d15652022-10-17 14:58:19 +0200911 if (nb_shards && curpeers->peers_fe->srv->shard > nb_shards) {
912 ha_warning("parsing [%s:%d] : '%s %s' : %d peer shard greater value than %d shards value is ignored.\n",
913 file, linenum, args[0], args[1], curpeers->peers_fe->srv->shard, nb_shards);
914 curpeers->peers_fe->srv->shard = 0;
915 err_code |= ERR_WARN;
916 }
917
Willy Tarreau824c8c52022-05-31 09:42:44 +0200918 if (curpeers->peers_fe->srv->init_addr_methods || curpeers->peers_fe->srv->resolvers_id ||
919 curpeers->peers_fe->srv->do_check || curpeers->peers_fe->srv->do_agent) {
920 ha_warning("parsing [%s:%d] : '%s %s' : init_addr, resolvers, check and agent are ignored for peers.\n", file, linenum, args[0], args[1]);
921 err_code |= ERR_WARN;
922 }
923
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100924 /* If the peer address has just been parsed, let's copy it to <newpeer>
925 * and initializes ->proto.
926 */
927 if (peer || !local_peer) {
928 newpeer->addr = curpeers->peers_fe->srv->addr;
Willy Tarreau14e7f292021-10-27 17:41:07 +0200929 newpeer->proto = protocol_lookup(newpeer->addr.ss_family, PROTO_TYPE_STREAM, 0);
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100930 }
931
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100932 newpeer->xprt = xprt_get(XPRT_RAW);
Willy Tarreaud02394b2012-05-11 18:32:18 +0200933 newpeer->sock_init_arg = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100934 HA_SPIN_INIT(&newpeer->lock);
Willy Tarreau26d8c592012-05-07 18:12:14 +0200935
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100936 newpeer->srv = curpeers->peers_fe->srv;
937 if (!newpeer->local)
Frédéric Lécaille6617e762018-04-25 15:13:38 +0200938 goto out;
939
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100940 /* The lines above are reserved to "peer" lines. */
941 if (*args[0] == 's')
Frédéric Lécaille4ba51982018-04-25 15:32:18 +0200942 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200943
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100944 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum, args[2], xprt_get(XPRT_RAW));
William Lallemand1d932172022-07-06 14:30:23 +0200945 if (!bind_conf) {
946 ha_alert("parsing [%s:%d] : '%s %s' : Cannot allocate memory.\n", file, linenum, args[0], args[1]);
947 err_code |= ERR_FATAL;
948 goto out;
949 }
Frédéric Lécaille16e49102019-01-11 11:27:16 +0100950
Willy Tarreau882f2482023-01-12 18:52:23 +0100951 bind_conf->maxaccept = 1;
Willy Tarreau30836152023-01-12 19:10:17 +0100952 bind_conf->accept = session_accept_fd;
Willy Tarreau17146802023-01-12 19:58:42 +0100953 bind_conf->options |= BC_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau882f2482023-01-12 18:52:23 +0100954
Emeric Brun49f6f4b2022-05-25 10:12:07 +0200955 if (!LIST_ISEMPTY(&bind_conf->listeners)) {
956 ha_alert("parsing [%s:%d] : One listener per \"peers\" section is authorized but another is already configured at [%s:%d].\n", file, linenum, bind_conf->file, bind_conf->line);
957 err_code |= ERR_FATAL;
958 }
959
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100960 if (!str2listener(args[2], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
961 if (errmsg && *errmsg) {
962 indent_msg(&errmsg, 2);
963 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Frédéric Lécaille16e49102019-01-11 11:27:16 +0100964 }
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100965 else
966 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
967 file, linenum, args[0], args[1], args[2]);
968 err_code |= ERR_FATAL;
969 goto out;
970 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100971
Willy Tarreau18215cb2019-02-27 16:25:28 +0100972 global.maxsock++; /* for the listening socket */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100973 }
Frédéric Lécaille36d15652022-10-17 14:58:19 +0200974 else if (strcmp(args[0], "shards") == 0) {
975 char *endptr;
976
977 if (!*args[1]) {
978 ha_alert("parsing [%s:%d] : '%s' : missing value\n", file, linenum, args[0]);
979 err_code |= ERR_FATAL;
980 goto out;
981 }
982
983 curpeers->nb_shards = strtol(args[1], &endptr, 10);
984 if (*endptr != '\0') {
985 ha_alert("parsing [%s:%d] : '%s' : expects an integer argument, found '%s'\n",
986 file, linenum, args[0], args[1]);
987 err_code |= ERR_FATAL;
988 goto out;
989 }
990
991 if (!curpeers->nb_shards) {
992 ha_alert("parsing [%s:%d] : '%s' : expects a strictly positive integer argument\n",
993 file, linenum, args[0]);
994 err_code |= ERR_FATAL;
995 goto out;
996 }
997
998 nb_shards = curpeers->nb_shards;
999 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001000 else if (strcmp(args[0], "table") == 0) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001001 struct stktable *t, *other;
1002 char *id;
Frédéric Lécaillec02766a2019-03-20 15:06:55 +01001003 size_t prefix_len;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001004
1005 /* Line number and peer ID are updated only if this peer is the local one. */
Christopher Faulet244331f2022-07-25 15:10:44 +02001006 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001007 err_code |= ERR_ALERT | ERR_ABORT;
1008 goto out;
1009 }
1010
1011 other = stktable_find_by_name(args[1]);
1012 if (other) {
1013 ha_alert("parsing [%s:%d] : stick-table name '%s' conflicts with table declared in %s '%s' at %s:%d.\n",
1014 file, linenum, args[1],
1015 other->proxy ? proxy_cap_str(other->proxy->cap) : "peers",
1016 other->proxy ? other->id : other->peers.p->id,
1017 other->conf.file, other->conf.line);
1018 err_code |= ERR_ALERT | ERR_FATAL;
1019 goto out;
1020 }
1021
Frédéric Lécaillec02766a2019-03-20 15:06:55 +01001022 /* Build the stick-table name, concatenating the "peers" section name
1023 * followed by a '/' character and the table name argument.
1024 */
1025 chunk_reset(&trash);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +01001026 if (!chunk_strcpy(&trash, curpeers->id)) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +01001027 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
1028 file, linenum, args[0], args[1]);
1029 err_code |= ERR_ALERT | ERR_FATAL;
1030 goto out;
1031 }
1032
1033 prefix_len = trash.data;
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +01001034 if (!chunk_memcat(&trash, "/", 1) || !chunk_strcat(&trash, args[1])) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +01001035 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
1036 file, linenum, args[0], args[1]);
1037 err_code |= ERR_ALERT | ERR_FATAL;
1038 goto out;
1039 }
1040
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001041 t = calloc(1, sizeof *t);
Frédéric Lécaillec02766a2019-03-20 15:06:55 +01001042 id = strdup(trash.area);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001043 if (!t || !id) {
1044 ha_alert("parsing [%s:%d]: '%s %s' : memory allocation failed\n",
1045 file, linenum, args[0], args[1]);
Eric Salama1aab9112020-09-18 11:55:17 +02001046 free(t);
1047 free(id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001048 err_code |= ERR_ALERT | ERR_FATAL;
1049 goto out;
1050 }
1051
Frédéric Lécaillec02766a2019-03-20 15:06:55 +01001052 err_code |= parse_stick_table(file, linenum, args, t, id, id + prefix_len, curpeers);
Eric Salama1aab9112020-09-18 11:55:17 +02001053 if (err_code & ERR_FATAL) {
1054 free(t);
1055 free(id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001056 goto out;
Eric Salama1aab9112020-09-18 11:55:17 +02001057 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001058
1059 stktable_store_name(t);
1060 t->next = stktables_list;
1061 stktables_list = t;
1062 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001063 else if (strcmp(args[0], "disabled") == 0) { /* disables this peers section */
Christopher Fauletdfd10ab2021-10-06 14:24:19 +02001064 curpeers->disabled |= PR_FL_DISABLED;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02001065 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001066 else if (strcmp(args[0], "enabled") == 0) { /* enables this peers section (used to revert a disabled default) */
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02001067 curpeers->disabled = 0;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02001068 }
Emeric Brun32da3c42010-09-23 18:39:19 +02001069 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001070 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Emeric Brun32da3c42010-09-23 18:39:19 +02001071 err_code |= ERR_ALERT | ERR_FATAL;
1072 goto out;
1073 }
1074
1075out:
Willy Tarreau902636f2013-03-10 19:44:48 +01001076 free(errmsg);
Emeric Brun32da3c42010-09-23 18:39:19 +02001077 return err_code;
1078}
1079
Baptiste Assmann325137d2015-04-13 23:40:55 +02001080/*
William Lallemand51097192015-04-14 16:35:22 +02001081 * Parse a line in a <listen>, <frontend> or <backend> section.
Simon Horman0d16a402015-01-30 11:22:58 +09001082 * Returns the error code, 0 if OK, or any combination of :
1083 * - ERR_ABORT: must abort ASAP
1084 * - ERR_FATAL: we can continue parsing but not start the service
1085 * - ERR_WARN: a warning has been emitted
1086 * - ERR_ALERT: an alert has been emitted
1087 * Only the two first ones can stop processing, the two others are just
1088 * indicators.
1089 */
1090int cfg_parse_mailers(const char *file, int linenum, char **args, int kwm)
1091{
1092 static struct mailers *curmailers = NULL;
1093 struct mailer *newmailer = NULL;
1094 const char *err;
1095 int err_code = 0;
1096 char *errmsg = NULL;
1097
1098 if (strcmp(args[0], "mailers") == 0) { /* new mailers section */
1099 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001100 ha_alert("parsing [%s:%d] : missing name for mailers section.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001101 err_code |= ERR_ALERT | ERR_ABORT;
1102 goto out;
1103 }
1104
1105 err = invalid_char(args[1]);
1106 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001107 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
1108 file, linenum, *err, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001109 err_code |= ERR_ALERT | ERR_ABORT;
1110 goto out;
1111 }
1112
1113 for (curmailers = mailers; curmailers != NULL; curmailers = curmailers->next) {
1114 /*
1115 * If there are two proxies with the same name only following
1116 * combinations are allowed:
1117 */
1118 if (strcmp(curmailers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001119 ha_alert("Parsing [%s:%d]: mailers section '%s' has the same name as another mailers section declared at %s:%d.\n",
1120 file, linenum, args[1], curmailers->conf.file, curmailers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +02001121 err_code |= ERR_ALERT | ERR_FATAL;
Simon Horman0d16a402015-01-30 11:22:58 +09001122 }
1123 }
1124
Vincent Bernat02779b62016-04-03 13:48:43 +02001125 if ((curmailers = calloc(1, sizeof(*curmailers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001126 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001127 err_code |= ERR_ALERT | ERR_ABORT;
1128 goto out;
1129 }
1130
1131 curmailers->next = mailers;
1132 mailers = curmailers;
1133 curmailers->conf.file = strdup(file);
1134 curmailers->conf.line = linenum;
1135 curmailers->id = strdup(args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001136 curmailers->timeout.mail = DEF_MAILALERTTIME;/* XXX: Would like to Skip to the next alert, if any, ASAP.
1137 * But need enough time so that timeouts don't occur
1138 * during tcp procssing. For now just us an arbitrary default. */
Simon Horman0d16a402015-01-30 11:22:58 +09001139 }
1140 else if (strcmp(args[0], "mailer") == 0) { /* mailer definition */
1141 struct sockaddr_storage *sk;
1142 int port1, port2;
1143 struct protocol *proto;
1144
1145 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001146 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1147 file, linenum, args[0]);
Simon Horman0d16a402015-01-30 11:22:58 +09001148 err_code |= ERR_ALERT | ERR_FATAL;
1149 goto out;
1150 }
1151
1152 err = invalid_char(args[1]);
1153 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001154 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1155 file, linenum, *err, args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001156 err_code |= ERR_ALERT | ERR_FATAL;
1157 goto out;
1158 }
1159
Vincent Bernat02779b62016-04-03 13:48:43 +02001160 if ((newmailer = calloc(1, sizeof(*newmailer))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001161 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001162 err_code |= ERR_ALERT | ERR_ABORT;
1163 goto out;
1164 }
1165
1166 /* the mailers are linked backwards first */
1167 curmailers->count++;
1168 newmailer->next = curmailers->mailer_list;
1169 curmailers->mailer_list = newmailer;
1170 newmailer->mailers = curmailers;
1171 newmailer->conf.file = strdup(file);
1172 newmailer->conf.line = linenum;
1173
1174 newmailer->id = strdup(args[1]);
1175
Willy Tarreau5fc93282020-09-16 18:25:03 +02001176 sk = str2sa_range(args[2], NULL, &port1, &port2, NULL, &proto,
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001177 &errmsg, NULL, NULL,
1178 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_STREAM | PA_O_XPRT | PA_O_CONNECT);
Simon Horman0d16a402015-01-30 11:22:58 +09001179 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001180 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Simon Horman0d16a402015-01-30 11:22:58 +09001181 err_code |= ERR_ALERT | ERR_FATAL;
1182 goto out;
1183 }
1184
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001185 if (proto->sock_prot != IPPROTO_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001186 ha_alert("parsing [%s:%d] : '%s %s' : TCP not supported for this address family.\n",
1187 file, linenum, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001188 err_code |= ERR_ALERT | ERR_FATAL;
1189 goto out;
1190 }
1191
Simon Horman0d16a402015-01-30 11:22:58 +09001192 newmailer->addr = *sk;
1193 newmailer->proto = proto;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01001194 newmailer->xprt = xprt_get(XPRT_RAW);
Simon Horman0d16a402015-01-30 11:22:58 +09001195 newmailer->sock_init_arg = NULL;
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001196 }
1197 else if (strcmp(args[0], "timeout") == 0) {
1198 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001199 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments.\n",
1200 file, linenum, args[0]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001201 err_code |= ERR_ALERT | ERR_FATAL;
1202 goto out;
1203 }
1204 else if (strcmp(args[1], "mail") == 0) {
1205 const char *res;
1206 unsigned int timeout_mail;
1207 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001208 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1209 file, linenum, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001210 err_code |= ERR_ALERT | ERR_FATAL;
1211 goto out;
1212 }
1213 res = parse_time_err(args[2], &timeout_mail, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001214 if (res == PARSE_TIME_OVER) {
1215 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1216 file, linenum, args[2], args[0], args[1]);
1217 err_code |= ERR_ALERT | ERR_FATAL;
1218 goto out;
1219 }
1220 else if (res == PARSE_TIME_UNDER) {
1221 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1222 file, linenum, args[2], args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001223 err_code |= ERR_ALERT | ERR_FATAL;
1224 goto out;
1225 }
Willy Tarreau9faebe32019-06-07 19:00:37 +02001226 else if (res) {
1227 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1228 file, linenum, *res, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001229 err_code |= ERR_ALERT | ERR_FATAL;
1230 goto out;
1231 }
1232 curmailers->timeout.mail = timeout_mail;
1233 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001234 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments got '%s'.\n",
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001235 file, linenum, args[0], args[1]);
1236 err_code |= ERR_ALERT | ERR_FATAL;
1237 goto out;
1238 }
1239 }
Simon Horman0d16a402015-01-30 11:22:58 +09001240 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001241 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Simon Horman0d16a402015-01-30 11:22:58 +09001242 err_code |= ERR_ALERT | ERR_FATAL;
1243 goto out;
1244 }
1245
1246out:
1247 free(errmsg);
1248 return err_code;
1249}
1250
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +01001251void free_email_alert(struct proxy *p)
Simon Horman9dc49962015-01-30 11:22:59 +09001252{
Willy Tarreau61cfdf42021-02-20 10:46:51 +01001253 ha_free(&p->email_alert.mailers.name);
1254 ha_free(&p->email_alert.from);
1255 ha_free(&p->email_alert.to);
1256 ha_free(&p->email_alert.myhostname);
Simon Horman9dc49962015-01-30 11:22:59 +09001257}
1258
Willy Tarreaubaaee002006-06-26 02:48:02 +02001259
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001260int
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001261cfg_parse_netns(const char *file, int linenum, char **args, int kwm)
1262{
Willy Tarreaue5733232019-05-22 19:24:06 +02001263#ifdef USE_NS
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001264 const char *err;
1265 const char *item = args[0];
1266
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001267 if (strcmp(item, "namespace_list") == 0) {
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001268 return 0;
1269 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001270 else if (strcmp(item, "namespace") == 0) {
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001271 size_t idx = 1;
1272 const char *current;
1273 while (*(current = args[idx++])) {
1274 err = invalid_char(current);
1275 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001276 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1277 file, linenum, *err, item, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001278 return ERR_ALERT | ERR_FATAL;
1279 }
1280
1281 if (netns_store_lookup(current, strlen(current))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001282 ha_alert("parsing [%s:%d]: Namespace '%s' is already added.\n",
1283 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001284 return ERR_ALERT | ERR_FATAL;
1285 }
1286 if (!netns_store_insert(current)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001287 ha_alert("parsing [%s:%d]: Cannot open namespace '%s'.\n",
1288 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001289 return ERR_ALERT | ERR_FATAL;
1290 }
1291 }
1292 }
1293
1294 return 0;
1295#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001296 ha_alert("parsing [%s:%d]: namespace support is not compiled in.",
1297 file, linenum);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001298 return ERR_ALERT | ERR_FATAL;
1299#endif
1300}
1301
1302int
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001303cfg_parse_users(const char *file, int linenum, char **args, int kwm)
1304{
1305
1306 int err_code = 0;
1307 const char *err;
1308
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001309 if (strcmp(args[0], "userlist") == 0) { /* new userlist */
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001310 struct userlist *newul;
1311
1312 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001313 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1314 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001315 err_code |= ERR_ALERT | ERR_FATAL;
1316 goto out;
1317 }
William Lallemand6e62fb62015-04-28 16:55:23 +02001318 if (alertif_too_many_args(1, file, linenum, args, &err_code))
1319 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001320
1321 err = invalid_char(args[1]);
1322 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001323 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1324 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001325 err_code |= ERR_ALERT | ERR_FATAL;
1326 goto out;
1327 }
1328
1329 for (newul = userlist; newul; newul = newul->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001330 if (strcmp(newul->name, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001331 ha_warning("parsing [%s:%d]: ignoring duplicated userlist '%s'.\n",
1332 file, linenum, args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001333 err_code |= ERR_WARN;
1334 goto out;
1335 }
1336
Vincent Bernat02779b62016-04-03 13:48:43 +02001337 newul = calloc(1, sizeof(*newul));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001338 if (!newul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001339 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001340 err_code |= ERR_ALERT | ERR_ABORT;
1341 goto out;
1342 }
1343
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001344 newul->name = strdup(args[1]);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001345 if (!newul->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001346 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001347 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier97880bb2016-04-08 10:35:26 +01001348 free(newul);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001349 goto out;
1350 }
1351
1352 newul->next = userlist;
1353 userlist = newul;
1354
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001355 } else if (strcmp(args[0], "group") == 0) { /* new group */
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001356 int cur_arg;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001357 const char *err;
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001358 struct auth_groups *ag;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001359
1360 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001361 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1362 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001363 err_code |= ERR_ALERT | ERR_FATAL;
1364 goto out;
1365 }
1366
1367 err = invalid_char(args[1]);
1368 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001369 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1370 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001371 err_code |= ERR_ALERT | ERR_FATAL;
1372 goto out;
1373 }
1374
William Lallemand4ac9f542015-05-28 18:03:51 +02001375 if (!userlist)
1376 goto out;
1377
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001378 for (ag = userlist->groups; ag; ag = ag->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001379 if (strcmp(ag->name, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001380 ha_warning("parsing [%s:%d]: ignoring duplicated group '%s' in userlist '%s'.\n",
1381 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001382 err_code |= ERR_ALERT;
1383 goto out;
1384 }
1385
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001386 ag = calloc(1, sizeof(*ag));
1387 if (!ag) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001388 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001389 err_code |= ERR_ALERT | ERR_ABORT;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001390 goto out;
1391 }
1392
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001393 ag->name = strdup(args[1]);
David Carlier70d60452016-08-22 23:27:42 +01001394 if (!ag->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001395 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001396 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier70d60452016-08-22 23:27:42 +01001397 free(ag);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001398 goto out;
1399 }
1400
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001401 cur_arg = 2;
1402
1403 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001404 if (strcmp(args[cur_arg], "users") == 0) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001405 ag->groupusers = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001406 cur_arg += 2;
1407 continue;
1408 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001409 ha_alert("parsing [%s:%d]: '%s' only supports 'users' option.\n",
1410 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001411 err_code |= ERR_ALERT | ERR_FATAL;
David Carlier70d60452016-08-22 23:27:42 +01001412 free(ag->groupusers);
1413 free(ag->name);
1414 free(ag);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001415 goto out;
1416 }
1417 }
1418
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001419 ag->next = userlist->groups;
1420 userlist->groups = ag;
1421
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001422 } else if (strcmp(args[0], "user") == 0) { /* new user */
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001423 struct auth_users *newuser;
1424 int cur_arg;
1425
1426 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001427 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1428 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001429 err_code |= ERR_ALERT | ERR_FATAL;
1430 goto out;
1431 }
William Lallemand4ac9f542015-05-28 18:03:51 +02001432 if (!userlist)
1433 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001434
1435 for (newuser = userlist->users; newuser; newuser = newuser->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001436 if (strcmp(newuser->user, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001437 ha_warning("parsing [%s:%d]: ignoring duplicated user '%s' in userlist '%s'.\n",
1438 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001439 err_code |= ERR_ALERT;
1440 goto out;
1441 }
1442
Vincent Bernat02779b62016-04-03 13:48:43 +02001443 newuser = calloc(1, sizeof(*newuser));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001444 if (!newuser) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001445 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001446 err_code |= ERR_ALERT | ERR_ABORT;
1447 goto out;
1448 }
1449
1450 newuser->user = strdup(args[1]);
1451
1452 newuser->next = userlist->users;
1453 userlist->users = newuser;
1454
1455 cur_arg = 2;
1456
1457 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001458 if (strcmp(args[cur_arg], "password") == 0) {
Willy Tarreaue5733232019-05-22 19:24:06 +02001459#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001460 if (!crypt("", args[cur_arg + 1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001461 ha_alert("parsing [%s:%d]: the encrypted password used for user '%s' is not supported by crypt(3).\n",
1462 file, linenum, newuser->user);
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001463 err_code |= ERR_ALERT | ERR_FATAL;
1464 goto out;
1465 }
1466#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001467 ha_warning("parsing [%s:%d]: no crypt(3) support compiled, encrypted passwords will not work.\n",
1468 file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001469 err_code |= ERR_ALERT;
1470#endif
1471 newuser->pass = strdup(args[cur_arg + 1]);
1472 cur_arg += 2;
1473 continue;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001474 } else if (strcmp(args[cur_arg], "insecure-password") == 0) {
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001475 newuser->pass = strdup(args[cur_arg + 1]);
1476 newuser->flags |= AU_O_INSECURE;
1477 cur_arg += 2;
1478 continue;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001479 } else if (strcmp(args[cur_arg], "groups") == 0) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001480 newuser->u.groups_names = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001481 cur_arg += 2;
1482 continue;
1483 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001484 ha_alert("parsing [%s:%d]: '%s' only supports 'password', 'insecure-password' and 'groups' options.\n",
1485 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001486 err_code |= ERR_ALERT | ERR_FATAL;
1487 goto out;
1488 }
1489 }
1490 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001491 ha_alert("parsing [%s:%d]: unknown keyword '%s' in '%s' section\n", file, linenum, args[0], "users");
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001492 err_code |= ERR_ALERT | ERR_FATAL;
1493 }
1494
1495out:
1496 return err_code;
1497}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001498
Christopher Faulet79bdef32016-11-04 22:36:15 +01001499int
1500cfg_parse_scope(const char *file, int linenum, char *line)
1501{
1502 char *beg, *end, *scope = NULL;
1503 int err_code = 0;
1504 const char *err;
1505
1506 beg = line + 1;
1507 end = strchr(beg, ']');
1508
1509 /* Detect end of scope declaration */
1510 if (!end || end == beg) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001511 ha_alert("parsing [%s:%d] : empty scope name is forbidden.\n",
1512 file, linenum);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001513 err_code |= ERR_ALERT | ERR_FATAL;
1514 goto out;
1515 }
1516
1517 /* Get scope name and check its validity */
1518 scope = my_strndup(beg, end-beg);
1519 err = invalid_char(scope);
1520 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001521 ha_alert("parsing [%s:%d] : character '%c' is not permitted in a scope name.\n",
1522 file, linenum, *err);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001523 err_code |= ERR_ALERT | ERR_ABORT;
1524 goto out;
1525 }
1526
1527 /* Be sure to have a scope declaration alone on its line */
1528 line = end+1;
1529 while (isspace((unsigned char)*line))
1530 line++;
1531 if (*line && *line != '#' && *line != '\n' && *line != '\r') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001532 ha_alert("parsing [%s:%d] : character '%c' is not permitted after scope declaration.\n",
1533 file, linenum, *line);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001534 err_code |= ERR_ALERT | ERR_ABORT;
1535 goto out;
1536 }
1537
1538 /* We have a valid scope declaration, save it */
1539 free(cfg_scope);
1540 cfg_scope = scope;
1541 scope = NULL;
1542
1543 out:
1544 free(scope);
1545 return err_code;
1546}
1547
Frédéric Lécaillea41d5312018-01-29 12:05:07 +01001548int
1549cfg_parse_track_sc_num(unsigned int *track_sc_num,
1550 const char *arg, const char *end, char **errmsg)
1551{
1552 const char *p;
1553 unsigned int num;
1554
1555 p = arg;
1556 num = read_uint64(&arg, end);
1557
1558 if (arg != end) {
1559 memprintf(errmsg, "Wrong track-sc number '%s'", p);
1560 return -1;
1561 }
1562
Willy Tarreau6c011712023-01-06 16:09:58 +01001563 if (num >= global.tune.nb_stk_ctr) {
1564 if (!global.tune.nb_stk_ctr)
1565 memprintf(errmsg, "%u track-sc number not usable, stick-counters "
1566 "are disabled by tune.stick-counters", num);
1567 else
1568 memprintf(errmsg, "%u track-sc number exceeding "
1569 "%d (tune.stick-counters-1) value", num, global.tune.nb_stk_ctr - 1);
Frédéric Lécaillea41d5312018-01-29 12:05:07 +01001570 return -1;
1571 }
1572
1573 *track_sc_num = num;
1574 return 0;
1575}
1576
Willy Tarreaubaaee002006-06-26 02:48:02 +02001577/*
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001578 * Detect a global section after a non-global one and output a diagnostic
1579 * warning.
1580 */
Christopher Faulet037e3f82022-11-18 15:46:06 +01001581static void check_section_position(char *section_name, const char *file, int linenum)
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001582{
Tim Duesterhusc5aa1132021-10-16 17:48:15 +02001583 if (strcmp(section_name, "global") == 0) {
Christopher Faulet037e3f82022-11-18 15:46:06 +01001584 if ((global.mode & MODE_DIAG) && non_global_section_parsed == 1)
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001585 _ha_diag_warning("parsing [%s:%d] : global section detected after a non-global one, the prevalence of their statements is unspecified\n", file, linenum);
1586 }
Christopher Faulet037e3f82022-11-18 15:46:06 +01001587 else if (non_global_section_parsed == 0) {
1588 non_global_section_parsed = 1;
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001589 }
1590}
1591
Willy Tarreau8a022d52021-04-27 20:29:11 +02001592/* apply the current default_path setting for config file <file>, and
1593 * optionally replace the current path to <origin> if not NULL while the
1594 * default-path mode is set to "origin". Errors are returned into an
1595 * allocated string passed to <err> if it's not NULL. Returns 0 on failure
1596 * or non-zero on success.
1597 */
1598static int cfg_apply_default_path(const char *file, const char *origin, char **err)
1599{
1600 const char *beg, *end;
1601
1602 /* make path start at <beg> and end before <end>, and switch it to ""
1603 * if no slash was passed.
1604 */
1605 beg = file;
1606 end = strrchr(beg, '/');
1607 if (!end)
1608 end = beg;
1609
1610 if (!*initial_cwd) {
1611 if (getcwd(initial_cwd, sizeof(initial_cwd)) == NULL) {
1612 if (err)
1613 memprintf(err, "Impossible to retrieve startup directory name: %s", strerror(errno));
1614 return 0;
1615 }
1616 }
1617 else if (chdir(initial_cwd) == -1) {
1618 if (err)
1619 memprintf(err, "Impossible to get back to initial directory '%s': %s", initial_cwd, strerror(errno));
1620 return 0;
1621 }
1622
1623 /* OK now we're (back) to initial_cwd */
1624
1625 switch (default_path_mode) {
1626 case DEFAULT_PATH_CURRENT:
1627 /* current_cwd never set, nothing to do */
1628 return 1;
1629
1630 case DEFAULT_PATH_ORIGIN:
1631 /* current_cwd set in the config */
1632 if (origin &&
1633 snprintf(current_cwd, sizeof(current_cwd), "%s", origin) > sizeof(current_cwd)) {
1634 if (err)
1635 memprintf(err, "Absolute path too long: '%s'", origin);
1636 return 0;
1637 }
1638 break;
1639
1640 case DEFAULT_PATH_CONFIG:
1641 if (end - beg >= sizeof(current_cwd)) {
1642 if (err)
1643 memprintf(err, "Config file path too long, cannot use for relative paths: '%s'", file);
1644 return 0;
1645 }
1646 memcpy(current_cwd, beg, end - beg);
1647 current_cwd[end - beg] = 0;
1648 break;
1649
1650 case DEFAULT_PATH_PARENT:
1651 if (end - beg + 3 >= sizeof(current_cwd)) {
1652 if (err)
1653 memprintf(err, "Config file path too long, cannot use for relative paths: '%s'", file);
1654 return 0;
1655 }
1656 memcpy(current_cwd, beg, end - beg);
1657 if (end > beg)
1658 memcpy(current_cwd + (end - beg), "/..\0", 4);
1659 else
1660 memcpy(current_cwd + (end - beg), "..\0", 3);
1661 break;
1662 }
1663
1664 if (*current_cwd && chdir(current_cwd) == -1) {
1665 if (err)
1666 memprintf(err, "Impossible to get back to directory '%s': %s", initial_cwd, strerror(errno));
1667 return 0;
1668 }
1669
1670 return 1;
1671}
1672
1673/* parses a global "default-path" directive. */
1674static int cfg_parse_global_def_path(char **args, int section_type, struct proxy *curpx,
1675 const struct proxy *defpx, const char *file, int line,
1676 char **err)
1677{
1678 int ret = -1;
1679
1680 /* "current", "config", "parent", "origin <path>" */
1681
1682 if (strcmp(args[1], "current") == 0)
1683 default_path_mode = DEFAULT_PATH_CURRENT;
1684 else if (strcmp(args[1], "config") == 0)
1685 default_path_mode = DEFAULT_PATH_CONFIG;
1686 else if (strcmp(args[1], "parent") == 0)
1687 default_path_mode = DEFAULT_PATH_PARENT;
1688 else if (strcmp(args[1], "origin") == 0)
1689 default_path_mode = DEFAULT_PATH_ORIGIN;
1690 else {
1691 memprintf(err, "%s default-path mode '%s' for '%s', supported modes include 'current', 'config', 'parent', and 'origin'.", *args[1] ? "unsupported" : "missing", args[1], args[0]);
1692 goto end;
1693 }
1694
1695 if (default_path_mode == DEFAULT_PATH_ORIGIN) {
1696 if (!*args[2]) {
1697 memprintf(err, "'%s %s' expects a directory as an argument.", args[0], args[1]);
1698 goto end;
1699 }
1700 if (!cfg_apply_default_path(file, args[2], err)) {
1701 memprintf(err, "couldn't set '%s' to origin '%s': %s.", args[0], args[2], *err);
1702 goto end;
1703 }
1704 }
1705 else if (!cfg_apply_default_path(file, NULL, err)) {
1706 memprintf(err, "couldn't set '%s' to '%s': %s.", args[0], args[1], *err);
1707 goto end;
1708 }
1709
1710 /* note that once applied, the path is immediately updated */
1711
1712 ret = 0;
1713 end:
1714 return ret;
1715}
1716
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001717/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02001718 * This function reads and parses the configuration file given in the argument.
Willy Tarreauda543e12021-04-27 18:30:28 +02001719 * Returns the error code, 0 if OK, -1 if the config file couldn't be opened,
1720 * or any combination of :
Willy Tarreau058e9072009-07-20 09:30:05 +02001721 * - ERR_ABORT: must abort ASAP
1722 * - ERR_FATAL: we can continue parsing but not start the service
1723 * - ERR_WARN: a warning has been emitted
1724 * - ERR_ALERT: an alert has been emitted
1725 * Only the two first ones can stop processing, the two others are just
1726 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001727 */
Willy Tarreaub17916e2006-10-15 15:17:57 +02001728int readcfgfile(const char *file)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001729{
Willy Tarreauda543e12021-04-27 18:30:28 +02001730 char *thisline = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02001731 int linesize = LINESIZE;
Willy Tarreauda543e12021-04-27 18:30:28 +02001732 FILE *f = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001733 int linenum = 0;
Willy Tarreau058e9072009-07-20 09:30:05 +02001734 int err_code = 0;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001735 struct cfg_section *cs = NULL, *pcs = NULL;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001736 struct cfg_section *ics;
William Lallemand64e84512015-05-12 14:25:37 +02001737 int readbytes = 0;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001738 char *outline = NULL;
1739 size_t outlen = 0;
1740 size_t outlinesize = 0;
Willy Tarreau32234e72020-06-16 17:14:33 +02001741 int fatal = 0;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001742 int missing_lf = -1;
Willy Tarreau4b103022021-02-12 17:59:10 +01001743 int nested_cond_lvl = 0;
1744 enum nested_cond_state nested_conds[MAXNESTEDCONDS];
Willy Tarreau8a022d52021-04-27 20:29:11 +02001745 char *errmsg = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02001746
Willy Tarreau51508052021-05-06 10:04:45 +02001747 global.cfg_curr_line = 0;
1748 global.cfg_curr_file = file;
1749
William Lallemand64e84512015-05-12 14:25:37 +02001750 if ((thisline = malloc(sizeof(*thisline) * linesize)) == NULL) {
Willy Tarreauda543e12021-04-27 18:30:28 +02001751 ha_alert("Out of memory trying to allocate a buffer for a configuration line.\n");
1752 err_code = -1;
1753 goto err;
William Lallemand64e84512015-05-12 14:25:37 +02001754 }
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001755
Willy Tarreauda543e12021-04-27 18:30:28 +02001756 if ((f = fopen(file,"r")) == NULL) {
1757 err_code = -1;
1758 goto err;
David Carlier97880bb2016-04-08 10:35:26 +01001759 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001760
Willy Tarreau8a022d52021-04-27 20:29:11 +02001761 /* change to the new dir if required */
1762 if (!cfg_apply_default_path(file, NULL, &errmsg)) {
1763 ha_alert("parsing [%s:%d]: failed to apply default-path: %s.\n", file, linenum, errmsg);
1764 free(errmsg);
1765 err_code = -1;
1766 goto err;
1767 }
1768
William Lallemandb2f07452015-05-12 14:27:13 +02001769next_line:
William Lallemand64e84512015-05-12 14:25:37 +02001770 while (fgets(thisline + readbytes, linesize - readbytes, f) != NULL) {
Willy Tarreau3842f002009-06-14 11:39:52 +02001771 int arg, kwm = KWM_STD;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001772 char *end;
1773 char *args[MAX_LINE_ARGS + 1];
1774 char *line = thisline;
1775
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001776 if (missing_lf != -1) {
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001777 ha_alert("parsing [%s:%d]: Stray NUL character at position %d.\n",
1778 file, linenum, (missing_lf + 1));
1779 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001780 missing_lf = -1;
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001781 break;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001782 }
1783
Willy Tarreaubaaee002006-06-26 02:48:02 +02001784 linenum++;
Willy Tarreau51508052021-05-06 10:04:45 +02001785 global.cfg_curr_line = linenum;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001786
Willy Tarreau32234e72020-06-16 17:14:33 +02001787 if (fatal >= 50) {
1788 ha_alert("parsing [%s:%d]: too many fatal errors (%d), stopping now.\n", file, linenum, fatal);
1789 break;
1790 }
1791
Willy Tarreaubaaee002006-06-26 02:48:02 +02001792 end = line + strlen(line);
1793
William Lallemand64e84512015-05-12 14:25:37 +02001794 if (end-line == linesize-1 && *(end-1) != '\n') {
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001795 /* Check if we reached the limit and the last char is not \n.
1796 * Watch out for the last line without the terminating '\n'!
1797 */
William Lallemand64e84512015-05-12 14:25:37 +02001798 char *newline;
1799 int newlinesize = linesize * 2;
1800
1801 newline = realloc(thisline, sizeof(*thisline) * newlinesize);
1802 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001803 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1804 file, linenum);
William Lallemand64e84512015-05-12 14:25:37 +02001805 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001806 fatal++;
Willy Tarreau40cb26f2020-06-25 09:37:54 +02001807 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001808 continue;
1809 }
1810
1811 readbytes = linesize - 1;
1812 linesize = newlinesize;
1813 thisline = newline;
Willy Tarreau40cb26f2020-06-25 09:37:54 +02001814 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001815 continue;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001816 }
1817
William Lallemand64e84512015-05-12 14:25:37 +02001818 readbytes = 0;
1819
Willy Tarreau08488f62020-06-26 17:24:54 +02001820 if (end > line && *(end-1) == '\n') {
Tim Duesterhus70f58992020-06-22 22:57:44 +02001821 /* kill trailing LF */
1822 *(end - 1) = 0;
1823 }
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001824 else {
1825 /* mark this line as truncated */
1826 missing_lf = end - line;
1827 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001828
Willy Tarreaubaaee002006-06-26 02:48:02 +02001829 /* skip leading spaces */
Willy Tarreau8f8e6452007-06-17 21:51:38 +02001830 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001831 line++;
William Lallemandf9873ba2015-05-05 17:37:14 +02001832
Joseph Herlanta14c03e2018-11-15 14:04:19 -08001833 if (*line == '[') {/* This is the beginning if a scope */
Christopher Faulet79bdef32016-11-04 22:36:15 +01001834 err_code |= cfg_parse_scope(file, linenum, line);
1835 goto next_line;
1836 }
1837
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001838 while (1) {
1839 uint32_t err;
Maximilian Mader29c6cd72021-06-06 00:50:21 +02001840 const char *errptr;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001841
Tim Duesterhusb3168b32021-06-06 00:50:20 +02001842 arg = sizeof(args) / sizeof(*args);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001843 outlen = outlinesize;
1844 err = parse_line(line, outline, &outlen, args, &arg,
1845 PARSE_OPT_ENV | PARSE_OPT_DQUOTE | PARSE_OPT_SQUOTE |
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02001846 PARSE_OPT_BKSLASH | PARSE_OPT_SHARP | PARSE_OPT_WORD_EXPAND,
1847 &errptr);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001848
1849 if (err & PARSE_ERR_QUOTE) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001850 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1851
1852 ha_alert("parsing [%s:%d]: unmatched quote at position %d:\n"
1853 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001854 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001855 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001856 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001857 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001858
1859 if (err & PARSE_ERR_BRACE) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001860 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1861
1862 ha_alert("parsing [%s:%d]: unmatched brace in environment variable name at position %d:\n"
1863 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001864 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001865 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001866 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001867 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001868
1869 if (err & PARSE_ERR_VARNAME) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001870 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1871
1872 ha_alert("parsing [%s:%d]: forbidden first char in environment variable name at position %d:\n"
1873 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001874 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001875 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001876 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001877 }
William Lallemandb2f07452015-05-12 14:27:13 +02001878
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001879 if (err & PARSE_ERR_HEX) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001880 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1881
1882 ha_alert("parsing [%s:%d]: truncated or invalid hexadecimal sequence at position %d:\n"
1883 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001884 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus9f658a52020-06-16 18:14:21 +02001885 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001886 goto next_line;
1887 }
William Lallemandb2f07452015-05-12 14:27:13 +02001888
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02001889 if (err & PARSE_ERR_WRONG_EXPAND) {
1890 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1891
1892 ha_alert("parsing [%s:%d]: truncated or invalid word expansion sequence at position %d:\n"
1893 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
1894 err_code |= ERR_ALERT | ERR_FATAL;
1895 fatal++;
1896 goto next_line;
1897 }
1898
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001899 if (err & (PARSE_ERR_TOOLARGE|PARSE_ERR_OVERLAP)) {
1900 outlinesize = (outlen + 1023) & -1024;
Ilya Shipitsin76837bc2021-01-07 22:45:13 +05001901 outline = my_realloc2(outline, outlinesize);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001902 if (outline == NULL) {
1903 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1904 file, linenum);
Willy Tarreau8ec9c812022-05-20 09:13:38 +02001905 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
Willy Tarreau32234e72020-06-16 17:14:33 +02001906 fatal++;
Christopher Fauletdfe32c72022-05-18 16:22:43 +02001907 outlinesize = 0;
Willy Tarreau8ec9c812022-05-20 09:13:38 +02001908 goto err;
William Lallemandb2f07452015-05-12 14:27:13 +02001909 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001910 /* try again */
1911 continue;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001912 }
Willy Tarreau07d47062020-06-25 07:41:22 +02001913
1914 if (err & PARSE_ERR_TOOMANY) {
1915 /* only check this *after* being sure the output is allocated */
1916 ha_alert("parsing [%s:%d]: too many words, truncating after word %d, position %ld: <%s>.\n",
1917 file, linenum, MAX_LINE_ARGS, (long)(args[MAX_LINE_ARGS-1] - outline + 1), args[MAX_LINE_ARGS-1]);
1918 err_code |= ERR_ALERT | ERR_FATAL;
1919 fatal++;
1920 goto next_line;
1921 }
1922
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001923 /* everything's OK */
1924 break;
William Lallemandf9873ba2015-05-05 17:37:14 +02001925 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001926
Erwan Le Goasb0c05012022-09-14 17:51:55 +02001927 /* dump cfg */
1928 if (global.mode & MODE_DUMP_CFG) {
1929 if (args[0] != NULL) {
1930 struct cfg_section *sect;
1931 int is_sect = 0;
1932 int i = 0;
1933 uint32_t g_key = HA_ATOMIC_LOAD(&global.anon_key);
1934
Erwan Le Goasf30c5d72022-09-29 10:34:04 +02001935 if (global.mode & MODE_DUMP_NB_L)
1936 qfprintf(stdout, "%d\t", linenum);
Erwan Le Goasb0c05012022-09-14 17:51:55 +02001937
1938 /* if a word is in sections list, is_sect = 1 */
1939 list_for_each_entry(sect, &sections, list) {
1940 if (strcmp(args[0], sect->section_name) == 0) {
1941 is_sect = 1;
1942 break;
1943 }
1944 }
1945
1946 if (g_key == 0) {
1947 /* no anonymizing needed, dump the config as-is (but without comments).
1948 * Note: tabs were lost during tokenizing, so we reinsert for non-section
1949 * keywords.
1950 */
1951 if (!is_sect)
1952 qfprintf(stdout, "\t");
1953
1954 for (i = 0; i < arg; i++) {
1955 qfprintf(stdout, "%s ", args[i]);
1956 }
1957 qfprintf(stdout, "\n");
1958 continue;
1959 }
1960
1961 /* We're anonymizing */
1962
1963 if (is_sect) {
1964 /* new sections are optionally followed by an identifier */
1965 if (arg >= 2) {
1966 qfprintf(stdout, "%s %s\n", args[0], HA_ANON_ID(g_key, args[1]));
1967 }
1968 else {
1969 qfprintf(stdout, "%s\n", args[0]);
1970 }
1971 continue;
1972 }
1973
1974 /* non-section keywords start indented */
1975 qfprintf(stdout, "\t");
1976
1977 /* some keywords deserve special treatment */
1978 if (!*args[0]) {
1979 qfprintf(stdout, "\n");
1980 }
1981
1982 else if (strcmp(args[0], "anonkey") == 0) {
1983 qfprintf(stdout, "%s [...]\n", args[0]);
1984 }
1985
1986 else if (strcmp(args[0], "maxconn") == 0) {
1987 qfprintf(stdout, "%s %s\n", args[0], args[1]);
1988 }
1989
1990 else if (strcmp(args[0], "stats") == 0 &&
1991 (strcmp(args[1], "timeout") == 0 || strcmp(args[1], "maxconn") == 0)) {
1992 qfprintf(stdout, "%s %s %s\n", args[0], args[1], args[2]);
1993 }
1994
1995 else if (strcmp(args[0], "stats") == 0 && strcmp(args[1], "socket") == 0) {
1996 qfprintf(stdout, "%s %s ", args[0], args[1]);
1997
Erwan Le Goasbe5ed922022-09-29 10:30:00 +02001998 if (arg > 2) {
Erwan Le Goas5eef1582022-09-29 10:25:31 +02001999 qfprintf(stdout, "%s ", hash_ipanon(g_key, args[2], 1));
Erwan Le Goasb0c05012022-09-14 17:51:55 +02002000
Erwan Le Goasbe5ed922022-09-29 10:30:00 +02002001 if (arg > 3) {
Erwan Le Goasb0c05012022-09-14 17:51:55 +02002002 qfprintf(stdout, "[...]\n");
2003 }
2004 else {
2005 qfprintf(stdout, "\n");
2006 }
2007 }
2008 else {
2009 qfprintf(stdout, "\n");
2010 }
2011 }
2012
2013 else if (strcmp(args[0], "timeout") == 0) {
2014 qfprintf(stdout, "%s %s %s\n", args[0], args[1], args[2]);
2015 }
2016
2017 else if (strcmp(args[0], "mode") == 0) {
2018 qfprintf(stdout, "%s %s\n", args[0], args[1]);
2019 }
2020
Ilya Shipitsin4a689da2022-10-29 09:34:32 +05002021 /* It concerns user in global section and in userlist */
Erwan Le Goasb0c05012022-09-14 17:51:55 +02002022 else if (strcmp(args[0], "user") == 0) {
2023 qfprintf(stdout, "%s %s ", args[0], HA_ANON_ID(g_key, args[1]));
2024
2025 if (arg > 2) {
2026 qfprintf(stdout, "[...]\n");
2027 }
2028 else {
2029 qfprintf(stdout, "\n");
2030 }
2031 }
2032
2033 else if (strcmp(args[0], "bind") == 0) {
2034 qfprintf(stdout, "%s ", args[0]);
Erwan Le Goas5eef1582022-09-29 10:25:31 +02002035 qfprintf(stdout, "%s ", hash_ipanon(g_key, args[1], 1));
Erwan Le Goasb0c05012022-09-14 17:51:55 +02002036 if (arg > 2) {
2037 qfprintf(stdout, "[...]\n");
2038 }
2039 else {
2040 qfprintf(stdout, "\n");
2041 }
2042 }
2043
2044 else if (strcmp(args[0], "server") == 0) {
Erwan Le Goas059d05f2022-09-29 10:31:18 +02002045 qfprintf(stdout, "%s %s ", args[0], HA_ANON_ID(g_key, args[1]));
Erwan Le Goasb0c05012022-09-14 17:51:55 +02002046
Erwan Le Goasb0c05012022-09-14 17:51:55 +02002047 if (arg > 2) {
Erwan Le Goas5eef1582022-09-29 10:25:31 +02002048 qfprintf(stdout, "%s ", hash_ipanon(g_key, args[2], 1));
Erwan Le Goasb0c05012022-09-14 17:51:55 +02002049 }
2050 if (arg > 3) {
2051 qfprintf(stdout, "[...]\n");
2052 }
2053 else {
2054 qfprintf(stdout, "\n");
2055 }
2056 }
2057
2058 else if (strcmp(args[0], "redirect") == 0) {
2059 qfprintf(stdout, "%s %s ", args[0], args[1]);
2060
2061 if (strcmp(args[1], "prefix") == 0 || strcmp(args[1], "location") == 0) {
2062 qfprintf(stdout, "%s ", HA_ANON_PATH(g_key, args[2]));
2063 }
2064 else {
2065 qfprintf(stdout, "%s ", args[2]);
2066 }
2067 if (arg > 3) {
2068 qfprintf(stdout, "[...]");
2069 }
2070 qfprintf(stdout, "\n");
2071 }
2072
2073 else if (strcmp(args[0], "acl") == 0) {
2074 qfprintf(stdout, "%s %s %s ", args[0], HA_ANON_ID(g_key, args[1]), args[2]);
2075
2076 if (arg > 3) {
2077 qfprintf(stdout, "[...]");
2078 }
2079 qfprintf(stdout, "\n");
2080 }
2081
2082 else if (strcmp(args[0], "log") == 0) {
2083 qfprintf(stdout, "log ");
2084
2085 if (strcmp(args[1], "global") == 0) {
2086 qfprintf(stdout, "%s ", args[1]);
2087 }
2088 else {
Erwan Le Goas5eef1582022-09-29 10:25:31 +02002089 qfprintf(stdout, "%s ", hash_ipanon(g_key, args[1], 1));
Erwan Le Goasb0c05012022-09-14 17:51:55 +02002090 }
2091 if (arg > 2) {
2092 qfprintf(stdout, "[...]");
2093 }
2094 qfprintf(stdout, "\n");
2095 }
2096
2097 else if (strcmp(args[0], "peer") == 0) {
2098 qfprintf(stdout, "%s %s ", args[0], HA_ANON_ID(g_key, args[1]));
Erwan Le Goas5eef1582022-09-29 10:25:31 +02002099 qfprintf(stdout, "%s ", hash_ipanon(g_key, args[2], 1));
Erwan Le Goasb0c05012022-09-14 17:51:55 +02002100
2101 if (arg > 3) {
2102 qfprintf(stdout, "[...]");
2103 }
2104 qfprintf(stdout, "\n");
2105 }
2106
2107 else if (strcmp(args[0], "use_backend") == 0) {
2108 qfprintf(stdout, "%s %s ", args[0], HA_ANON_ID(g_key, args[1]));
2109
2110 if (arg > 2) {
2111 qfprintf(stdout, "[...]");
2112 }
2113 qfprintf(stdout, "\n");
2114 }
2115
2116 else if (strcmp(args[0], "default_backend") == 0) {
2117 qfprintf(stdout, "%s %s\n", args[0], HA_ANON_ID(g_key, args[1]));
2118 }
2119
Erwan Le Goas059d05f2022-09-29 10:31:18 +02002120 else if (strcmp(args[0], "source") == 0) {
2121 qfprintf(stdout, "%s %s ", args[0], hash_ipanon(g_key, args[1], 1));
2122
2123 if (arg > 2) {
2124 qfprintf(stdout, "[...]");
2125 }
2126 qfprintf(stdout, "\n");
2127 }
2128
2129 else if (strcmp(args[0], "nameserver") == 0) {
2130 qfprintf(stdout, "%s %s %s ", args[0],
2131 HA_ANON_ID(g_key, args[1]), hash_ipanon(g_key, args[2], 1));
2132 if (arg > 3) {
2133 qfprintf(stdout, "[...]");
2134 }
2135 qfprintf(stdout, "\n");
2136 }
2137
2138 else if (strcmp(args[0], "http-request") == 0) {
2139 qfprintf(stdout, "%s %s ", args[0], args[1]);
2140 if (arg > 2)
2141 qfprintf(stdout, "[...]");
2142 qfprintf(stdout, "\n");
2143 }
2144
2145 else if (strcmp(args[0], "http-response") == 0) {
2146 qfprintf(stdout, "%s %s ", args[0], args[1]);
2147 if (arg > 2)
2148 qfprintf(stdout, "[...]");
2149 qfprintf(stdout, "\n");
2150 }
2151
2152 else if (strcmp(args[0], "http-after-response") == 0) {
2153 qfprintf(stdout, "%s %s ", args[0], args[1]);
2154 if (arg > 2)
2155 qfprintf(stdout, "[...]");
2156 qfprintf(stdout, "\n");
2157 }
2158
2159 else if (strcmp(args[0], "filter") == 0) {
2160 qfprintf(stdout, "%s %s ", args[0], args[1]);
2161 if (arg > 2)
2162 qfprintf(stdout, "[...]");
2163 qfprintf(stdout, "\n");
2164 }
2165
2166 else if (strcmp(args[0], "errorfile") == 0) {
2167 qfprintf(stdout, "%s %s %s\n", args[0], args[1], HA_ANON_PATH(g_key, args[2]));
2168 }
2169
2170 else if (strcmp(args[0], "cookie") == 0) {
2171 qfprintf(stdout, "%s %s ", args[0], HA_ANON_ID(g_key, args[1]));
2172 if (arg > 2)
2173 qfprintf(stdout, "%s ", args[2]);
2174 if (arg > 3)
2175 qfprintf(stdout, "[...]");
2176 qfprintf(stdout, "\n");
2177 }
2178
2179 else if (strcmp(args[0], "stats") == 0 && strcmp(args[1], "auth") == 0) {
2180 qfprintf(stdout, "%s %s %s\n", args[0], args[1], HA_ANON_STR(g_key, args[2]));
2181 }
2182
Erwan Le Goasb0c05012022-09-14 17:51:55 +02002183 else {
2184 /* display up to 3 words and mask the rest which might be confidential */
2185 for (i = 0; i < MIN(arg, 3); i++) {
2186 qfprintf(stdout, "%s ", args[i]);
2187 }
2188 if (arg > 3) {
2189 qfprintf(stdout, "[...]");
2190 }
2191 qfprintf(stdout, "\n");
2192 }
2193 }
2194 continue;
2195 }
2196 /* end of config dump */
2197
Willy Tarreaubaaee002006-06-26 02:48:02 +02002198 /* empty line */
2199 if (!**args)
2200 continue;
2201
Willy Tarreau4b103022021-02-12 17:59:10 +01002202 /* check for config macros */
2203 if (*args[0] == '.') {
2204 if (strcmp(args[0], ".if") == 0) {
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002205 const char *errptr = NULL;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002206 char *errmsg = NULL;
2207 int cond;
Willy Tarreauc8194c32021-07-16 16:38:58 +02002208 char *w;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002209
Willy Tarreauc8194c32021-07-16 16:38:58 +02002210 /* remerge all words into a single expression */
2211 for (w = *args; (w += strlen(w)) < outline + outlen - 1; *w = ' ')
2212 ;
Tim Duesterhus5546c8b2021-05-26 17:45:33 +02002213
Willy Tarreau4b103022021-02-12 17:59:10 +01002214 nested_cond_lvl++;
2215 if (nested_cond_lvl >= MAXNESTEDCONDS) {
2216 ha_alert("parsing [%s:%d]: too many nested '.if', max is %d.\n", file, linenum, MAXNESTEDCONDS);
2217 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2218 goto err;
2219 }
2220
Willy Tarreau6e647c92021-05-06 08:46:11 +02002221 if (nested_cond_lvl > 1 &&
2222 (nested_conds[nested_cond_lvl - 1] == NESTED_COND_IF_DROP ||
2223 nested_conds[nested_cond_lvl - 1] == NESTED_COND_IF_SKIP ||
2224 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELIF_DROP ||
2225 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELIF_SKIP ||
2226 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELSE_DROP)) {
Willy Tarreau4b103022021-02-12 17:59:10 +01002227 nested_conds[nested_cond_lvl] = NESTED_COND_IF_SKIP;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002228 goto next_line;
2229 }
2230
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002231 cond = cfg_eval_condition(args + 1, &errmsg, &errptr);
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002232 if (cond < 0) {
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002233 size_t newpos = sanitize_for_printing(args[1], errptr - args[1], 76);
2234
2235 ha_alert("parsing [%s:%d]: %s in '.if' at position %d:\n .if %s\n %*s\n",
2236 file, linenum, errmsg,
2237 (int)(errptr-args[1]+1), args[1], (int)(newpos+5), "^");
2238
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002239 free(errmsg);
Willy Tarreau4b103022021-02-12 17:59:10 +01002240 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2241 goto err;
2242 }
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002243
2244 if (cond)
2245 nested_conds[nested_cond_lvl] = NESTED_COND_IF_TAKE;
2246 else
2247 nested_conds[nested_cond_lvl] = NESTED_COND_IF_DROP;
2248
Willy Tarreau4b103022021-02-12 17:59:10 +01002249 goto next_line;
2250 }
2251 else if (strcmp(args[0], ".elif") == 0) {
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002252 const char *errptr = NULL;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002253 char *errmsg = NULL;
2254 int cond;
Willy Tarreauc8194c32021-07-16 16:38:58 +02002255 char *w;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002256
Willy Tarreauc8194c32021-07-16 16:38:58 +02002257 /* remerge all words into a single expression */
2258 for (w = *args; (w += strlen(w)) < outline + outlen - 1; *w = ' ')
2259 ;
Tim Duesterhus5546c8b2021-05-26 17:45:33 +02002260
Willy Tarreau4b103022021-02-12 17:59:10 +01002261 if (!nested_cond_lvl) {
2262 ha_alert("parsing [%s:%d]: lone '.elif' with no matching '.if'.\n", file, linenum);
2263 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2264 goto err;
2265 }
2266
2267 if (nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_TAKE ||
2268 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP) {
2269 ha_alert("parsing [%s:%d]: '.elif' after '.else' is not permitted.\n", file, linenum);
2270 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2271 goto err;
2272 }
2273
2274 if (nested_conds[nested_cond_lvl] == NESTED_COND_IF_TAKE ||
2275 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
Willy Tarreauf67ff022021-05-06 08:48:09 +02002276 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_TAKE ||
Willy Tarreau4b103022021-02-12 17:59:10 +01002277 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP) {
2278 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_SKIP;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002279 goto next_line;
2280 }
2281
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002282 cond = cfg_eval_condition(args + 1, &errmsg, &errptr);
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002283 if (cond < 0) {
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002284 size_t newpos = sanitize_for_printing(args[1], errptr - args[1], 74);
2285
2286 ha_alert("parsing [%s:%d]: %s in '.elif' at position %d:\n .elif %s\n %*s\n",
2287 file, linenum, errmsg,
2288 (int)(errptr-args[1]+1), args[1], (int)(newpos+7), "^");
2289
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002290 free(errmsg);
Willy Tarreau4b103022021-02-12 17:59:10 +01002291 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2292 goto err;
2293 }
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002294
2295 if (cond)
2296 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_TAKE;
2297 else
2298 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_DROP;
2299
Willy Tarreau4b103022021-02-12 17:59:10 +01002300 goto next_line;
2301 }
2302 else if (strcmp(args[0], ".else") == 0) {
Tim Duesterhus5546c8b2021-05-26 17:45:33 +02002303 if (*args[1]) {
Ilya Shipitsin213bb992021-06-12 15:55:27 +05002304 ha_alert("parsing [%s:%d]: Unexpected argument '%s' for '%s'.\n",
Tim Duesterhus5546c8b2021-05-26 17:45:33 +02002305 file, linenum, args[1], args[0]);
2306 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2307 break;
2308 }
2309
Willy Tarreau4b103022021-02-12 17:59:10 +01002310 if (!nested_cond_lvl) {
2311 ha_alert("parsing [%s:%d]: lone '.else' with no matching '.if'.\n", file, linenum);
2312 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2313 goto err;
2314 }
2315
2316 if (nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_TAKE ||
2317 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP) {
2318 ha_alert("parsing [%s:%d]: '.else' after '.else' is not permitted.\n", file, linenum);
2319 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2320 goto err;
2321 }
2322
2323 if (nested_conds[nested_cond_lvl] == NESTED_COND_IF_TAKE ||
2324 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
2325 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_TAKE ||
2326 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP) {
2327 nested_conds[nested_cond_lvl] = NESTED_COND_ELSE_DROP;
2328 } else {
2329 /* otherwise we take the "else" */
2330 nested_conds[nested_cond_lvl] = NESTED_COND_ELSE_TAKE;
2331 }
2332 goto next_line;
2333 }
2334 else if (strcmp(args[0], ".endif") == 0) {
Tim Duesterhus5546c8b2021-05-26 17:45:33 +02002335 if (*args[1]) {
Ilya Shipitsin213bb992021-06-12 15:55:27 +05002336 ha_alert("parsing [%s:%d]: Unexpected argument '%s' for '%s'.\n",
Tim Duesterhus5546c8b2021-05-26 17:45:33 +02002337 file, linenum, args[1], args[0]);
2338 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2339 break;
2340 }
2341
Willy Tarreau4b103022021-02-12 17:59:10 +01002342 if (!nested_cond_lvl) {
2343 ha_alert("parsing [%s:%d]: lone '.endif' with no matching '.if'.\n", file, linenum);
Tim Duesterhus5546c8b2021-05-26 17:45:33 +02002344 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
Willy Tarreau4b103022021-02-12 17:59:10 +01002345 break;
2346 }
2347 nested_cond_lvl--;
2348 goto next_line;
2349 }
2350 }
2351
2352 if (nested_cond_lvl &&
2353 (nested_conds[nested_cond_lvl] == NESTED_COND_IF_DROP ||
2354 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
2355 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_DROP ||
2356 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP ||
2357 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP)) {
2358 /* The current block is masked out by the conditions */
2359 goto next_line;
2360 }
2361
Willy Tarreau7190b982021-05-07 08:59:50 +02002362 /* .warning/.error/.notice/.diag */
Willy Tarreau4b103022021-02-12 17:59:10 +01002363 if (*args[0] == '.') {
2364 if (strcmp(args[0], ".alert") == 0) {
Tim Duesterhus5546c8b2021-05-26 17:45:33 +02002365 if (*args[2]) {
2366 ha_alert("parsing [%s:%d]: Unexpected argument '%s' for '%s'. Use quotes if the message should contain spaces.\n",
2367 file, linenum, args[2], args[0]);
2368 err_code |= ERR_ALERT | ERR_FATAL;
2369 goto next_line;
2370 }
2371
Willy Tarreau4b103022021-02-12 17:59:10 +01002372 ha_alert("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
2373 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2374 goto err;
2375 }
2376 else if (strcmp(args[0], ".warning") == 0) {
Tim Duesterhus5546c8b2021-05-26 17:45:33 +02002377 if (*args[2]) {
2378 ha_alert("parsing [%s:%d]: Unexpected argument '%s' for '%s'. Use quotes if the message should contain spaces.\n",
2379 file, linenum, args[2], args[0]);
2380 err_code |= ERR_ALERT | ERR_FATAL;
2381 goto next_line;
2382 }
2383
Willy Tarreau4b103022021-02-12 17:59:10 +01002384 ha_warning("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
2385 err_code |= ERR_WARN;
2386 goto next_line;
2387 }
2388 else if (strcmp(args[0], ".notice") == 0) {
Tim Duesterhus5546c8b2021-05-26 17:45:33 +02002389 if (*args[2]) {
2390 ha_alert("parsing [%s:%d]: Unexpected argument '%s' for '%s'. Use quotes if the message should contain spaces.\n",
2391 file, linenum, args[2], args[0]);
2392 err_code |= ERR_ALERT | ERR_FATAL;
2393 goto next_line;
2394 }
2395
Willy Tarreau4b103022021-02-12 17:59:10 +01002396 ha_notice("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
2397 goto next_line;
2398 }
Willy Tarreau7190b982021-05-07 08:59:50 +02002399 else if (strcmp(args[0], ".diag") == 0) {
Tim Duesterhus5546c8b2021-05-26 17:45:33 +02002400 if (*args[2]) {
2401 ha_alert("parsing [%s:%d]: Unexpected argument '%s' for '%s'. Use quotes if the message should contain spaces.\n",
2402 file, linenum, args[2], args[0]);
2403 err_code |= ERR_ALERT | ERR_FATAL;
2404 goto next_line;
2405 }
2406
Willy Tarreau7190b982021-05-07 08:59:50 +02002407 ha_diag_warning("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
2408 goto next_line;
2409 }
Willy Tarreau4b103022021-02-12 17:59:10 +01002410 else {
2411 ha_alert("parsing [%s:%d]: unknown directive '%s'.\n", file, linenum, args[0]);
2412 err_code |= ERR_ALERT | ERR_FATAL;
2413 fatal++;
2414 break;
2415 }
2416 }
2417
Willy Tarreau3842f002009-06-14 11:39:52 +02002418 /* check for keyword modifiers "no" and "default" */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002419 if (strcmp(args[0], "no") == 0) {
William Lallemand0f99e342011-10-12 17:50:54 +02002420 char *tmp;
2421
Willy Tarreau3842f002009-06-14 11:39:52 +02002422 kwm = KWM_NO;
William Lallemand0f99e342011-10-12 17:50:54 +02002423 tmp = args[0];
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002424 for (arg=0; *args[arg+1]; arg++)
2425 args[arg] = args[arg+1]; // shift args after inversion
William Lallemand0f99e342011-10-12 17:50:54 +02002426 *tmp = '\0'; // fix the next arg to \0
2427 args[arg] = tmp;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002428 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002429 else if (strcmp(args[0], "default") == 0) {
Willy Tarreau3842f002009-06-14 11:39:52 +02002430 kwm = KWM_DEF;
2431 for (arg=0; *args[arg+1]; arg++)
2432 args[arg] = args[arg+1]; // shift args after inversion
2433 }
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002434
William Dauchyec730982019-10-27 20:08:10 +01002435 if (kwm != KWM_STD && strcmp(args[0], "option") != 0 &&
2436 strcmp(args[0], "log") != 0 && strcmp(args[0], "busy-polling") != 0 &&
Willy Tarreaud96f1122019-12-03 07:07:36 +01002437 strcmp(args[0], "set-dumpable") != 0 && strcmp(args[0], "strict-limits") != 0 &&
Amaury Denoyelle0f50cb92021-03-26 18:50:33 +01002438 strcmp(args[0], "insecure-fork-wanted") != 0 &&
2439 strcmp(args[0], "numa-cpu-mapping") != 0) {
William Dauchyec730982019-10-27 20:08:10 +01002440 ha_alert("parsing [%s:%d]: negation/default currently "
William Dauchy0fec3ab2019-10-27 20:08:11 +01002441 "supported only for options, log, busy-polling, "
Amaury Denoyelle0f50cb92021-03-26 18:50:33 +01002442 "set-dumpable, strict-limits, insecure-fork-wanted "
2443 "and numa-cpu-mapping.\n", file, linenum);
Willy Tarreau058e9072009-07-20 09:30:05 +02002444 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02002445 fatal++;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002446 }
2447
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002448 /* detect section start */
2449 list_for_each_entry(ics, &sections, list) {
2450 if (strcmp(args[0], ics->section_name) == 0) {
2451 cursection = ics->section_name;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002452 pcs = cs;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002453 cs = ics;
Willy Tarreau51508052021-05-06 10:04:45 +02002454 free(global.cfg_curr_section);
2455 global.cfg_curr_section = strdup(*args[1] ? args[1] : args[0]);
Christopher Faulet037e3f82022-11-18 15:46:06 +01002456 check_section_position(args[0], file, linenum);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002457 break;
2458 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002459 }
2460
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002461 if (pcs && pcs->post_section_parser) {
Willy Tarreau32234e72020-06-16 17:14:33 +02002462 int status;
2463
2464 status = pcs->post_section_parser();
2465 err_code |= status;
2466 if (status & ERR_FATAL)
2467 fatal++;
2468
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002469 if (err_code & ERR_ABORT)
2470 goto err;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002471 }
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002472 pcs = NULL;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002473
William Lallemandd2ff56d2017-10-16 11:06:50 +02002474 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002475 ha_alert("parsing [%s:%d]: unknown keyword '%s' out of section.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02002476 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02002477 fatal++;
William Lallemandd2ff56d2017-10-16 11:06:50 +02002478 } else {
Willy Tarreau32234e72020-06-16 17:14:33 +02002479 int status;
2480
2481 status = cs->section_parser(file, linenum, args, kwm);
2482 err_code |= status;
2483 if (status & ERR_FATAL)
2484 fatal++;
2485
William Lallemandd2ff56d2017-10-16 11:06:50 +02002486 if (err_code & ERR_ABORT)
2487 goto err;
2488 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002489 }
William Lallemandd2ff56d2017-10-16 11:06:50 +02002490
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02002491 if (missing_lf != -1) {
Tim Duesterhusf92afb72020-08-18 22:00:04 +02002492 ha_alert("parsing [%s:%d]: Missing LF on last line, file might have been truncated at position %d.\n",
2493 file, linenum, (missing_lf + 1));
2494 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02002495 }
2496
Willy Tarreau51508052021-05-06 10:04:45 +02002497 ha_free(&global.cfg_curr_section);
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002498 if (cs && cs->post_section_parser)
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002499 err_code |= cs->post_section_parser();
William Lallemandd2ff56d2017-10-16 11:06:50 +02002500
Willy Tarreau4b103022021-02-12 17:59:10 +01002501 if (nested_cond_lvl) {
2502 ha_alert("parsing [%s:%d]: non-terminated '.if' block.\n", file, linenum);
2503 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2504 }
Willy Tarreau8a022d52021-04-27 20:29:11 +02002505
2506 if (*initial_cwd && chdir(initial_cwd) == -1) {
2507 ha_alert("Impossible to get back to initial directory '%s' : %s\n", initial_cwd, strerror(errno));
2508 err_code |= ERR_ALERT | ERR_FATAL;
2509 }
2510
William Lallemandd2ff56d2017-10-16 11:06:50 +02002511err:
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002512 ha_free(&cfg_scope);
Willy Tarreau6daf3432008-01-22 16:44:08 +01002513 cursection = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02002514 free(thisline);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002515 free(outline);
Willy Tarreau51508052021-05-06 10:04:45 +02002516 global.cfg_curr_line = 0;
2517 global.cfg_curr_file = NULL;
2518
Willy Tarreauda543e12021-04-27 18:30:28 +02002519 if (f)
2520 fclose(f);
2521
Willy Tarreau058e9072009-07-20 09:30:05 +02002522 return err_code;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002523}
2524
Amaury Denoyelleb09f4472021-12-15 09:48:39 +01002525#if defined(USE_THREAD) && defined USE_CPU_AFFINITY
2526#if defined(__linux__)
2527
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002528/* filter directory name of the pattern node<X> */
2529static int numa_filter(const struct dirent *dir)
2530{
2531 char *endptr;
2532
2533 /* dir name must start with "node" prefix */
2534 if (strncmp(dir->d_name, "node", 4))
2535 return 0;
2536
2537 /* dir name must be at least 5 characters long */
2538 if (!dir->d_name[4])
2539 return 0;
2540
2541 /* dir name must end with a numeric id */
2542 if (strtol(&dir->d_name[4], &endptr, 10) < 0 || *endptr)
2543 return 0;
2544
2545 /* all tests succeeded */
2546 return 1;
2547}
2548
2549/* Parse a linux cpu map string representing to a numeric cpu mask map
2550 * The cpu map string is a list of 4-byte hex strings separated by commas, with
2551 * most-significant byte first, one bit per cpu number.
2552 */
2553static void parse_cpumap(char *cpumap_str, struct hap_cpuset *cpu_set)
2554{
2555 unsigned long cpumap;
2556 char *start, *endptr, *comma;
2557 int i, j;
2558
2559 ha_cpuset_zero(cpu_set);
2560
2561 i = 0;
2562 do {
2563 /* reverse-search for a comma, parse the string after the comma
2564 * or at the beginning if no comma found
2565 */
2566 comma = strrchr(cpumap_str, ',');
2567 start = comma ? comma + 1 : cpumap_str;
2568
2569 cpumap = strtoul(start, &endptr, 16);
2570 for (j = 0; cpumap; cpumap >>= 1, ++j) {
2571 if (cpumap & 0x1)
2572 ha_cpuset_set(cpu_set, j + i * 32);
2573 }
2574
2575 if (comma)
2576 *comma = '\0';
2577 ++i;
2578 } while (comma);
2579}
2580
2581/* Read the first line of a file from <path> into the trash buffer.
2582 * Returns 0 on success, otherwise non-zero.
2583 */
2584static int read_file_to_trash(const char *path)
2585{
2586 FILE *file;
2587 int ret = 1;
2588
2589 file = fopen(path, "r");
2590 if (file) {
2591 if (fgets(trash.area, trash.size, file))
2592 ret = 0;
2593
2594 fclose(file);
2595 }
2596
2597 return ret;
2598}
2599
2600/* Inspect the cpu topology of the machine on startup. If a multi-socket
2601 * machine is detected, try to bind on the first node with active cpu. This is
2602 * done to prevent an impact on the overall performance when the topology of
2603 * the machine is unknown. This function is not called if one of the conditions
2604 * is met :
2605 * - a non-null nbthread directive is active
2606 * - a restrictive cpu-map directive is active
2607 * - a restrictive affinity is already applied, for example via taskset
2608 *
2609 * Returns the count of cpus selected. If no automatic binding was required or
2610 * an error occurred and the topology is unknown, 0 is returned.
2611 */
2612static int numa_detect_topology()
2613{
2614 struct dirent **node_dirlist;
2615 int node_dirlist_size;
2616
2617 struct hap_cpuset active_cpus, node_cpu_set;
2618 const char *parse_cpu_set_args[2];
2619 char cpumap_path[PATH_MAX];
2620 char *err = NULL;
2621
2622 /* node_cpu_set count is used as return value */
2623 ha_cpuset_zero(&node_cpu_set);
2624
2625 /* 1. count the sysfs node<X> directories */
Willy Tarreau07bf21c2021-04-23 19:09:16 +02002626 node_dirlist = NULL;
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002627 node_dirlist_size = scandir(NUMA_DETECT_SYSTEM_SYSFS_PATH"/node", &node_dirlist, numa_filter, alphasort);
2628 if (node_dirlist_size <= 1)
2629 goto free_scandir_entries;
2630
2631 /* 2. read and parse the list of currently online cpu */
2632 if (read_file_to_trash(NUMA_DETECT_SYSTEM_SYSFS_PATH"/cpu/online")) {
2633 ha_notice("Cannot read online CPUs list, will not try to refine binding\n");
2634 goto free_scandir_entries;
2635 }
2636
2637 parse_cpu_set_args[0] = trash.area;
2638 parse_cpu_set_args[1] = "\0";
Willy Tarreau615c3012023-05-05 16:10:05 +02002639 if (parse_cpu_set(parse_cpu_set_args, &active_cpus, &err)) {
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002640 ha_notice("Cannot read online CPUs list: '%s'. Will not try to refine binding\n", err);
2641 free(err);
2642 goto free_scandir_entries;
2643 }
2644
2645 /* 3. loop through nodes dirs and find the first one with active cpus */
2646 while (node_dirlist_size--) {
2647 const char *node = node_dirlist[node_dirlist_size]->d_name;
2648 ha_cpuset_zero(&node_cpu_set);
2649
2650 snprintf(cpumap_path, PATH_MAX, "%s/node/%s/cpumap",
2651 NUMA_DETECT_SYSTEM_SYSFS_PATH, node);
2652
2653 if (read_file_to_trash(cpumap_path)) {
2654 ha_notice("Cannot read CPUs list of '%s', will not select them to refine binding\n", node);
2655 free(node_dirlist[node_dirlist_size]);
2656 continue;
2657 }
2658
2659 parse_cpumap(trash.area, &node_cpu_set);
2660 ha_cpuset_and(&node_cpu_set, &active_cpus);
2661
2662 /* 5. set affinity on the first found node with active cpus */
2663 if (!ha_cpuset_count(&node_cpu_set)) {
2664 free(node_dirlist[node_dirlist_size]);
2665 continue;
2666 }
2667
2668 ha_diag_warning("Multi-socket cpu detected, automatically binding on active CPUs of '%s' (%u active cpu(s))\n", node, ha_cpuset_count(&node_cpu_set));
2669 if (sched_setaffinity(getpid(), sizeof(node_cpu_set.cpuset), &node_cpu_set.cpuset) == -1) {
2670 ha_warning("Cannot set the cpu affinity for this multi-cpu machine\n");
2671
2672 /* clear the cpuset used as return value */
2673 ha_cpuset_zero(&node_cpu_set);
2674 }
2675
2676 free(node_dirlist[node_dirlist_size]);
2677 break;
2678 }
2679
2680 free_scandir_entries:
2681 while (node_dirlist_size-- > 0)
2682 free(node_dirlist[node_dirlist_size]);
2683 free(node_dirlist);
2684
2685 return ha_cpuset_count(&node_cpu_set);
2686}
Amaury Denoyelleb09f4472021-12-15 09:48:39 +01002687
David CARLIERf5d48f82021-12-06 11:00:10 +00002688#elif defined(__FreeBSD__)
2689static int numa_detect_topology()
2690{
2691 struct hap_cpuset node_cpu_set;
2692 int ndomains = 0, i;
2693 size_t len = sizeof(ndomains);
2694
2695 if (sysctlbyname("vm.ndomains", &ndomains, &len, NULL, 0) == -1) {
2696 ha_notice("Cannot assess the number of CPUs domains\n");
2697 return 0;
2698 }
2699
2700 BUG_ON(ndomains > MAXMEMDOM);
2701 ha_cpuset_zero(&node_cpu_set);
2702
Willy Tarreaue1a01072023-04-22 19:26:07 +02002703 if (ndomains < 2)
2704 goto leave;
2705
David CARLIERf5d48f82021-12-06 11:00:10 +00002706 /*
2707 * We retrieve the first active valid CPU domain
2708 * with active cpu and binding it, we returns
2709 * the number of cpu from the said domain
2710 */
2711 for (i = 0; i < ndomains; i ++) {
2712 struct hap_cpuset dom;
2713 ha_cpuset_zero(&dom);
2714 if (cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_DOMAIN, i, sizeof(dom.cpuset), &dom.cpuset) == -1)
2715 continue;
2716
2717 if (!ha_cpuset_count(&dom))
2718 continue;
2719
2720 ha_cpuset_assign(&node_cpu_set, &dom);
2721
2722 ha_diag_warning("Multi-socket cpu detected, automatically binding on active CPUs of '%d' (%u active cpu(s))\n", i, ha_cpuset_count(&node_cpu_set));
2723 if (cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, -1, sizeof(node_cpu_set.cpuset), &node_cpu_set.cpuset) == -1) {
2724 ha_warning("Cannot set the cpu affinity for this multi-cpu machine\n");
2725
2726 /* clear the cpuset used as return value */
2727 ha_cpuset_zero(&node_cpu_set);
2728 }
2729 break;
2730 }
Willy Tarreaue1a01072023-04-22 19:26:07 +02002731 leave:
David CARLIERf5d48f82021-12-06 11:00:10 +00002732 return ha_cpuset_count(&node_cpu_set);
2733}
2734
Amaury Denoyelleb09f4472021-12-15 09:48:39 +01002735#else
2736static int numa_detect_topology()
2737{
2738 return 0;
2739}
2740
2741#endif
2742#endif /* USE_THREAD && USE_CPU_AFFINITY */
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002743
Willy Tarreaubb925012009-07-23 13:36:36 +02002744/*
2745 * Returns the error code, 0 if OK, or any combination of :
2746 * - ERR_ABORT: must abort ASAP
2747 * - ERR_FATAL: we can continue parsing but not start the service
2748 * - ERR_WARN: a warning has been emitted
2749 * - ERR_ALERT: an alert has been emitted
2750 * Only the two first ones can stop processing, the two others are just
2751 * indicators.
2752 */
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002753int check_config_validity()
2754{
2755 int cfgerr = 0;
2756 struct proxy *curproxy = NULL;
Emeric Brun3b68b602022-08-18 15:53:21 +02002757 struct proxy *init_proxies_list = NULL;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002758 struct stktable *t;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002759 struct server *newsrv = NULL;
Willy Tarreaubb925012009-07-23 13:36:36 +02002760 int err_code = 0;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002761 unsigned int next_pxid = 1;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002762 struct bind_conf *bind_conf;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002763 char *err;
William Lallemand48b4bb42017-10-23 14:36:34 +02002764 struct cfg_postparser *postparser;
Emeric Brun750fe792020-12-23 16:51:12 +01002765 struct resolvers *curr_resolvers = NULL;
Amaury Denoyelle3efee652021-03-08 17:31:39 +01002766 int i;
Frédéric Lécaille372508c2022-05-06 08:53:16 +02002767 int diag_no_cluster_secret = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002768
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002769 bind_conf = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002770 /*
2771 * Now, check for the integrity of all that we have collected.
2772 */
2773
Willy Tarreau193b8c62012-11-22 00:17:38 +01002774 if (!global.tune.max_http_hdr)
2775 global.tune.max_http_hdr = MAX_HTTP_HDR;
2776
2777 if (!global.tune.cookie_len)
2778 global.tune.cookie_len = CAPTURE_LEN;
2779
Stéphane Cottin23e9e932017-05-18 08:58:41 +02002780 if (!global.tune.requri_len)
2781 global.tune.requri_len = REQURI_LEN;
2782
Willy Tarreau149ab772019-01-26 14:27:06 +01002783 if (!global.nbthread) {
2784 /* nbthread not set, thus automatic. In this case, and only if
2785 * running on a single process, we enable the same number of
2786 * threads as the number of CPUs the process is bound to. This
2787 * allows to easily control the number of threads using taskset.
2788 */
2789 global.nbthread = 1;
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002790
Willy Tarreau149ab772019-01-26 14:27:06 +01002791#if defined(USE_THREAD)
Willy Tarreaub63dbb72021-06-11 16:50:29 +02002792 {
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002793 int numa_cores = 0;
Amaury Denoyelleb09f4472021-12-15 09:48:39 +01002794#if defined(USE_CPU_AFFINITY)
Amaury Denoyelle0f50cb92021-03-26 18:50:33 +01002795 if (global.numa_cpu_mapping && !thread_cpu_mask_forced())
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002796 numa_cores = numa_detect_topology();
2797#endif
2798 global.nbthread = numa_cores ? numa_cores :
2799 thread_cpus_enabled_at_boot;
Willy Tarreau400b3ae2022-12-08 08:04:46 +01002800
2801 /* Note that we cannot have more than 32 or 64 threads per group */
2802 if (!global.nbtgroups)
2803 global.nbtgroups = 1;
2804
2805 if (global.nbthread > MAX_THREADS_PER_GROUP * global.nbtgroups) {
2806 ha_diag_warning("nbthread not set, found %d CPUs, limiting to %d threads (maximum is %d per thread group). Please set nbthreads and/or increase thread-groups in the global section to silence this warning.\n",
2807 global.nbthread, MAX_THREADS_PER_GROUP * global.nbtgroups, MAX_THREADS_PER_GROUP);
2808 global.nbthread = MAX_THREADS_PER_GROUP * global.nbtgroups;
2809 }
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002810 }
Willy Tarreau149ab772019-01-26 14:27:06 +01002811#endif
2812 }
2813
Willy Tarreauc33b9692021-09-22 12:07:23 +02002814 if (!global.nbtgroups)
2815 global.nbtgroups = 1;
2816
Willy Tarreaue6806eb2021-09-27 10:10:26 +02002817 if (thread_map_to_groups() < 0) {
2818 err_code |= ERR_ALERT | ERR_FATAL;
2819 goto out;
2820 }
2821
Willy Tarreaubafbe012017-11-24 17:34:44 +01002822 pool_head_requri = create_pool("requri", global.tune.requri_len , MEM_F_SHARED);
Emeric Brun96fd9262017-07-05 13:33:16 +02002823
Willy Tarreaubafbe012017-11-24 17:34:44 +01002824 pool_head_capture = create_pool("capture", global.tune.cookie_len, MEM_F_SHARED);
Willy Tarreau193b8c62012-11-22 00:17:38 +01002825
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002826 /* Post initialisation of the users and groups lists. */
2827 err_code = userlist_postinit();
2828 if (err_code != ERR_NONE)
2829 goto out;
2830
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002831 /* first, we will invert the proxy list order */
2832 curproxy = NULL;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002833 while (proxies_list) {
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002834 struct proxy *next;
2835
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002836 next = proxies_list->next;
2837 proxies_list->next = curproxy;
2838 curproxy = proxies_list;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002839 if (!next)
2840 break;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002841 proxies_list = next;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002842 }
2843
Emeric Brun3b68b602022-08-18 15:53:21 +02002844 /* starting to initialize the main proxies list */
2845 init_proxies_list = proxies_list;
2846
2847init_proxies_list_stage1:
2848 for (curproxy = init_proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002849 struct switching_rule *rule;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002850 struct server_rule *srule;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002851 struct sticking_rule *mrule;
Dragan Dosen1322d092015-09-22 16:05:32 +02002852 struct logsrv *tmplogsrv;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002853 unsigned int next_id;
2854
Willy Tarreaud3dbfd92021-08-20 10:15:40 +02002855 if (!(curproxy->cap & PR_CAP_INT) && curproxy->uuid < 0) {
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002856 /* proxy ID not set, use automatic numbering with first
Willy Tarreaud3dbfd92021-08-20 10:15:40 +02002857 * spare entry starting with next_pxid. We don't assign
2858 * numbers for internal proxies as they may depend on
2859 * build or config options and we don't want them to
2860 * possibly reuse existing IDs.
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002861 */
2862 next_pxid = get_next_id(&used_proxy_id, next_pxid);
2863 curproxy->conf.id.key = curproxy->uuid = next_pxid;
2864 eb32_insert(&used_proxy_id, &curproxy->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002865 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01002866
Willy Tarreau32b51cd2021-08-26 15:59:44 +02002867 if (curproxy->mode == PR_MODE_HTTP && global.tune.bufsize >= (256 << 20) && ONLY_ONCE()) {
2868 ha_alert("global.tune.bufsize must be below 256 MB when HTTP is in use (current value = %d).\n",
2869 global.tune.bufsize);
2870 cfgerr++;
2871 }
2872
Willy Tarreaud3dbfd92021-08-20 10:15:40 +02002873 /* next IDs are shifted even if the proxy is disabled, this
2874 * guarantees that a proxy that is temporarily disabled in the
2875 * configuration doesn't cause a renumbering. Internal proxies
2876 * that are not assigned a static ID must never shift the IDs
2877 * either since they may appear in any order (Lua, logs, etc).
2878 * The GLOBAL proxy that carries the stats socket has its ID
2879 * forced to zero.
2880 */
2881 if (curproxy->uuid >= 0)
2882 next_pxid++;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002883
Christopher Fauletdfd10ab2021-10-06 14:24:19 +02002884 if (curproxy->flags & PR_FL_DISABLED) {
Willy Tarreau02b092f2020-10-07 18:36:54 +02002885 /* ensure we don't keep listeners uselessly bound. We
2886 * can't disable their listeners yet (fdtab not
2887 * allocated yet) but let's skip them.
2888 */
Dragan Dosen7d61a332019-05-07 14:16:18 +02002889 if (curproxy->table) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002890 ha_free(&curproxy->table->peers.name);
Dragan Dosen7d61a332019-05-07 14:16:18 +02002891 curproxy->table->peers.p = NULL;
2892 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002893 continue;
2894 }
2895
Christopher Fauletff556272021-10-13 11:04:10 +02002896 /* The current proxy is referencing a default proxy. We must
2897 * finalize its config, but only once. If the default proxy is
2898 * ready (PR_FL_READY) it means it was already fully configured.
2899 */
2900 if (curproxy->defpx) {
2901 if (!(curproxy->defpx->flags & PR_FL_READY)) {
Christopher Fauletee08d6c2021-10-13 15:40:15 +02002902 /* check validity for 'tcp-request' layer 4/5/6/7 rules */
2903 cfgerr += check_action_rules(&curproxy->defpx->tcp_req.l4_rules, curproxy->defpx, &err_code);
2904 cfgerr += check_action_rules(&curproxy->defpx->tcp_req.l5_rules, curproxy->defpx, &err_code);
2905 cfgerr += check_action_rules(&curproxy->defpx->tcp_req.inspect_rules, curproxy->defpx, &err_code);
2906 cfgerr += check_action_rules(&curproxy->defpx->tcp_rep.inspect_rules, curproxy->defpx, &err_code);
2907 cfgerr += check_action_rules(&curproxy->defpx->http_req_rules, curproxy->defpx, &err_code);
2908 cfgerr += check_action_rules(&curproxy->defpx->http_res_rules, curproxy->defpx, &err_code);
2909 cfgerr += check_action_rules(&curproxy->defpx->http_after_res_rules, curproxy->defpx, &err_code);
2910
Christopher Fauletff556272021-10-13 11:04:10 +02002911 err = NULL;
2912 i = smp_resolve_args(curproxy->defpx, &err);
2913 cfgerr += i;
2914 if (i) {
2915 indent_msg(&err, 8);
2916 ha_alert("%s%s\n", i > 1 ? "multiple argument resolution errors:" : "", err);
2917 ha_free(&err);
2918 }
2919 else
2920 cfgerr += acl_find_targets(curproxy->defpx);
2921
2922 /* default proxy is now ready. Set the right FE/BE capabilities */
2923 curproxy->defpx->flags |= PR_FL_READY;
2924 }
2925 }
2926
Willy Tarreau3d209582014-05-09 17:06:11 +02002927 /* check and reduce the bind-proc of each listener */
2928 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreauf6a84442023-04-22 23:25:38 +02002929 int ret;
Willy Tarreau3d209582014-05-09 17:06:11 +02002930
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002931 /* HTTP frontends with "h2" as ALPN/NPN will work in
2932 * HTTP/2 and absolutely require buffers 16kB or larger.
2933 */
2934#ifdef USE_OPENSSL
Willy Tarreau158c18e2023-04-19 08:28:40 +02002935 /* no-alpn ? If so, it's the right moment to remove it */
2936 if (bind_conf->ssl_conf.alpn_str && !bind_conf->ssl_conf.alpn_len) {
2937 free(bind_conf->ssl_conf.alpn_str);
2938 bind_conf->ssl_conf.alpn_str = NULL;
2939 }
Willy Tarreau5003ac72023-04-19 09:12:33 +02002940#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
2941 else if (!bind_conf->ssl_conf.alpn_str && !bind_conf->ssl_conf.npn_str &&
2942 ((bind_conf->options & BC_O_USE_SSL) || bind_conf->xprt == xprt_get(XPRT_QUIC)) &&
2943 curproxy->mode == PR_MODE_HTTP && global.tune.bufsize >= 16384) {
2944
2945 /* Neither ALPN nor NPN were explicitly set nor disabled, we're
2946 * in HTTP mode with an SSL or QUIC listener, we can enable ALPN.
2947 * Note that it's in binary form.
2948 */
2949 if (bind_conf->xprt == xprt_get(XPRT_QUIC))
2950 bind_conf->ssl_conf.alpn_str = strdup("\002h3");
2951 else
2952 bind_conf->ssl_conf.alpn_str = strdup("\002h2\010http/1.1");
2953
2954 if (!bind_conf->ssl_conf.alpn_str) {
2955 ha_alert("Proxy '%s': out of memory while trying to allocate a default alpn string in 'bind %s' at [%s:%d].\n",
2956 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
2957 cfgerr++;
2958 err_code |= ERR_FATAL | ERR_ALERT;
2959 goto out;
2960 }
2961 bind_conf->ssl_conf.alpn_len = strlen(bind_conf->ssl_conf.alpn_str);
2962 }
2963#endif
Willy Tarreau158c18e2023-04-19 08:28:40 +02002964
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002965 if (curproxy->mode == PR_MODE_HTTP && global.tune.bufsize < 16384) {
2966#ifdef OPENSSL_NPN_NEGOTIATED
2967 /* check NPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002968 if (bind_conf->ssl_conf.npn_str && strstr(bind_conf->ssl_conf.npn_str, "\002h2")) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02002969 ha_alert("HTTP frontend '%s' enables HTTP/2 via NPN at [%s:%d], so global.tune.bufsize must be at least 16384 bytes (%d now).\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01002970 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002971 cfgerr++;
2972 }
2973#endif
2974#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
2975 /* check ALPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002976 if (bind_conf->ssl_conf.alpn_str && strstr(bind_conf->ssl_conf.alpn_str, "\002h2")) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02002977 ha_alert("HTTP frontend '%s' enables HTTP/2 via ALPN at [%s:%d], so global.tune.bufsize must be at least 16384 bytes (%d now).\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01002978 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002979 cfgerr++;
2980 }
2981#endif
2982 } /* HTTP && bufsize < 16384 */
2983#endif
2984
Willy Tarreauf6a84442023-04-22 23:25:38 +02002985 /* finish the bind setup */
2986 ret = bind_complete_thread_setup(bind_conf, &err_code);
2987 if (ret != 0) {
2988 cfgerr += ret;
2989 if (err_code & ERR_FATAL)
2990 goto out;
Willy Tarreau01cac3f2021-10-12 08:47:54 +02002991 }
Willy Tarreau3d209582014-05-09 17:06:11 +02002992 }
2993
Willy Tarreauff01a212009-03-15 13:46:16 +01002994 switch (curproxy->mode) {
Willy Tarreauff01a212009-03-15 13:46:16 +01002995 case PR_MODE_TCP:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002996 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002997 break;
2998
2999 case PR_MODE_HTTP:
Willy Tarreau25320b22013-03-24 07:22:08 +01003000 curproxy->http_needed = 1;
Willy Tarreauff01a212009-03-15 13:46:16 +01003001 break;
William Lallemandcf62f7e2018-10-26 14:47:40 +02003002
3003 case PR_MODE_CLI:
3004 cfgerr += proxy_cfg_ensure_no_http(curproxy);
3005 break;
Emeric Brun3b68b602022-08-18 15:53:21 +02003006
Emeric Brun54932b42020-07-07 09:43:24 +02003007 case PR_MODE_SYSLOG:
Emeric Brun3b68b602022-08-18 15:53:21 +02003008 /* this mode is initialized as the classic tcp proxy */
3009 cfgerr += proxy_cfg_ensure_no_http(curproxy);
3010 break;
3011
Willy Tarreaua389c9e2020-10-07 17:49:42 +02003012 case PR_MODE_PEERS:
Emeric Brun54932b42020-07-07 09:43:24 +02003013 case PR_MODES:
3014 /* should not happen, bug gcc warn missing switch statement */
Emeric Brun3b68b602022-08-18 15:53:21 +02003015 ha_alert("%s '%s' cannot initialize this proxy mode (peers) in this way. NOTE: PLEASE REPORT THIS TO DEVELOPERS AS YOU'RE NOT SUPPOSED TO BE ABLE TO CREATE A CONFIGURATION TRIGGERING THIS!\n",
Emeric Brun54932b42020-07-07 09:43:24 +02003016 proxy_type_str(curproxy), curproxy->id);
3017 cfgerr++;
3018 break;
Willy Tarreauff01a212009-03-15 13:46:16 +01003019 }
3020
William Lallemand2c04a5a2021-08-13 15:21:12 +02003021 if (!(curproxy->cap & PR_CAP_INT) && (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->conf.listeners)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003022 ha_warning("%s '%s' has no 'bind' directive. Please declare it as a backend if this was intended.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003023 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauf3934b82015-08-11 11:36:45 +02003024 err_code |= ERR_WARN;
3025 }
3026
Willy Tarreau77e0dae2020-10-14 15:44:27 +02003027 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003028 if (curproxy->lbprm.algo & BE_LB_KIND) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01003029 if (curproxy->options & PR_O_TRANSP) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003030 ha_alert("%s '%s' cannot use both transparent and balance mode.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003031 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01003032 cfgerr++;
3033 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02003034#ifdef WE_DONT_SUPPORT_SERVERLESS_LISTENERS
Willy Tarreau3cd9af22009-03-15 14:06:41 +01003035 else if (curproxy->srv == NULL) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003036 ha_alert("%s '%s' needs at least 1 server in balance mode.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003037 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01003038 cfgerr++;
3039 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02003040#endif
Willy Tarreau1620ec32011-08-06 17:05:02 +02003041 else if (curproxy->options & PR_O_DISPATCH) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003042 ha_warning("dispatch address of %s '%s' will be ignored in balance mode.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003043 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003044 err_code |= ERR_WARN;
Willy Tarreau3cd9af22009-03-15 14:06:41 +01003045 }
3046 }
Willy Tarreau25241232021-07-18 19:18:56 +02003047 else if (!(curproxy->options & (PR_O_TRANSP | PR_O_DISPATCH))) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01003048 /* If no LB algo is set in a backend, and we're not in
3049 * transparent mode, dispatch mode nor proxy mode, we
3050 * want to use balance roundrobin by default.
3051 */
3052 curproxy->lbprm.algo &= ~BE_LB_ALGO;
3053 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaubaaee002006-06-26 02:48:02 +02003054 }
3055 }
Willy Tarreau193cf932007-09-17 10:17:23 +02003056
Willy Tarreau1620ec32011-08-06 17:05:02 +02003057 if (curproxy->options & PR_O_DISPATCH)
Willy Tarreau25241232021-07-18 19:18:56 +02003058 curproxy->options &= ~PR_O_TRANSP;
Willy Tarreau1620ec32011-08-06 17:05:02 +02003059 else if (curproxy->options & PR_O_TRANSP)
Willy Tarreau25241232021-07-18 19:18:56 +02003060 curproxy->options &= ~PR_O_DISPATCH;
Willy Tarreau82936582007-11-30 15:20:09 +01003061
Christopher Faulete5870d82020-04-15 11:32:03 +02003062 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_HTTP_RS)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003063 ha_warning("%s '%s' uses http-check rules without 'option httpchk', so the rules are ignored.\n",
Christopher Faulete5870d82020-04-15 11:32:03 +02003064 proxy_type_str(curproxy), curproxy->id);
3065 err_code |= ERR_WARN;
3066 }
3067
3068 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_TCPCHK_CHK &&
Christopher Fauletc0fcbe42020-06-03 19:00:42 +02003069 (curproxy->tcpcheck_rules.flags & TCPCHK_RULES_PROTO_CHK) != TCPCHK_RULES_HTTP_CHK) {
Willy Tarreau1620ec32011-08-06 17:05:02 +02003070 if (curproxy->options & PR_O_DISABLE404) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003071 ha_warning("'%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003072 "disable-on-404", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02003073 err_code |= ERR_WARN;
3074 curproxy->options &= ~PR_O_DISABLE404;
3075 }
3076 if (curproxy->options2 & PR_O2_CHK_SNDST) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003077 ha_warning("'%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003078 "send-state", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02003079 err_code |= ERR_WARN;
3080 curproxy->options &= ~PR_O2_CHK_SNDST;
3081 }
Willy Tarreauef781042010-01-27 11:53:01 +01003082 }
3083
Simon Horman98637e52014-06-20 12:30:16 +09003084 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_EXT_CHK) {
3085 if (!global.external_check) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003086 ha_alert("Proxy '%s' : '%s' unable to find required 'global.external-check'.\n",
3087 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09003088 cfgerr++;
3089 }
3090 if (!curproxy->check_command) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003091 ha_alert("Proxy '%s' : '%s' unable to find required 'external-check command'.\n",
3092 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09003093 cfgerr++;
3094 }
Willy Tarreaud96f1122019-12-03 07:07:36 +01003095 if (!(global.tune.options & GTUNE_INSECURE_FORK)) {
3096 ha_warning("Proxy '%s' : 'insecure-fork-wanted' not enabled in the global section, '%s' will likely fail.\n",
3097 curproxy->id, "option external-check");
3098 err_code |= ERR_WARN;
3099 }
Simon Horman98637e52014-06-20 12:30:16 +09003100 }
3101
Simon Horman64e34162015-02-06 11:11:57 +09003102 if (curproxy->email_alert.set) {
Simon Horman0ba0e4a2015-01-30 11:23:00 +09003103 if (!(curproxy->email_alert.mailers.name && curproxy->email_alert.from && curproxy->email_alert.to)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003104 ha_warning("'email-alert' will be ignored for %s '%s' (the presence any of "
Christopher Faulet767a84b2017-11-24 16:50:31 +01003105 "'email-alert from', 'email-alert level' 'email-alert mailers', "
3106 "'email-alert myhostname', or 'email-alert to' "
3107 "requires each of 'email-alert from', 'email-alert mailers' and 'email-alert to' "
3108 "to be present).\n",
3109 proxy_type_str(curproxy), curproxy->id);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09003110 err_code |= ERR_WARN;
3111 free_email_alert(curproxy);
3112 }
3113 if (!curproxy->email_alert.myhostname)
Cyril Bontée22bfd62015-12-04 03:07:07 +01003114 curproxy->email_alert.myhostname = strdup(hostname);
Simon Horman9dc49962015-01-30 11:22:59 +09003115 }
3116
Simon Horman98637e52014-06-20 12:30:16 +09003117 if (curproxy->check_command) {
3118 int clear = 0;
3119 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003120 ha_warning("'%s' will be ignored for %s '%s' (requires 'option external-check').\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003121 "external-check command", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09003122 err_code |= ERR_WARN;
3123 clear = 1;
3124 }
3125 if (curproxy->check_command[0] != '/' && !curproxy->check_path) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003126 ha_alert("Proxy '%s': '%s' does not have a leading '/' and 'external-check path' is not set.\n",
3127 curproxy->id, "external-check command");
Simon Horman98637e52014-06-20 12:30:16 +09003128 cfgerr++;
3129 }
3130 if (clear) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003131 ha_free(&curproxy->check_command);
Simon Horman98637e52014-06-20 12:30:16 +09003132 }
3133 }
3134
3135 if (curproxy->check_path) {
3136 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003137 ha_warning("'%s' will be ignored for %s '%s' (requires 'option external-check').\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003138 "external-check path", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09003139 err_code |= ERR_WARN;
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003140 ha_free(&curproxy->check_path);
Simon Horman98637e52014-06-20 12:30:16 +09003141 }
3142 }
3143
Willy Tarreau5fdfb912007-01-01 23:11:07 +01003144 /* if a default backend was specified, let's find it */
3145 if (curproxy->defbe.name) {
3146 struct proxy *target;
3147
Willy Tarreauafb39922015-05-26 12:04:09 +02003148 target = proxy_be_by_name(curproxy->defbe.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01003149 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003150 ha_alert("Proxy '%s': unable to find required default_backend: '%s'.\n",
3151 curproxy->id, curproxy->defbe.name);
Willy Tarreau5fdfb912007-01-01 23:11:07 +01003152 cfgerr++;
3153 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003154 ha_alert("Proxy '%s': loop detected for default_backend: '%s'.\n",
3155 curproxy->id, curproxy->defbe.name);
Willy Tarreaubb925012009-07-23 13:36:36 +02003156 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02003157 } else if (target->mode != curproxy->mode &&
3158 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
3159
Christopher Faulet767a84b2017-11-24 16:50:31 +01003160 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) as its default backend (see 'mode').\n",
3161 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
3162 curproxy->conf.file, curproxy->conf.line,
3163 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
3164 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02003165 cfgerr++;
Willy Tarreau5fdfb912007-01-01 23:11:07 +01003166 } else {
3167 free(curproxy->defbe.name);
3168 curproxy->defbe.be = target;
Willy Tarreauff678132012-02-13 14:32:34 +01003169 /* Emit a warning if this proxy also has some servers */
3170 if (curproxy->srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003171 ha_warning("In proxy '%s', the 'default_backend' rule always has precedence over the servers, which will never be used.\n",
3172 curproxy->id);
Willy Tarreauff678132012-02-13 14:32:34 +01003173 err_code |= ERR_WARN;
3174 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02003175 }
3176 }
3177
Willy Tarreau55ea7572007-06-17 19:56:27 +02003178 /* find the target proxy for 'use_backend' rules */
3179 list_for_each_entry(rule, &curproxy->switching_rules, list) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02003180 struct proxy *target;
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01003181 struct logformat_node *node;
3182 char *pxname;
3183
3184 /* Try to parse the string as a log format expression. If the result
3185 * of the parsing is only one entry containing a simple string, then
3186 * it's a standard string corresponding to a static rule, thus the
3187 * parsing is cancelled and be.name is restored to be resolved.
3188 */
3189 pxname = rule->be.name;
3190 LIST_INIT(&rule->be.expr);
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +01003191 curproxy->conf.args.ctx = ARGC_UBK;
3192 curproxy->conf.args.file = rule->file;
3193 curproxy->conf.args.line = rule->line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003194 err = NULL;
3195 if (!parse_logformat_string(pxname, curproxy, &rule->be.expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003196 ha_alert("Parsing [%s:%d]: failed to parse use_backend rule '%s' : %s.\n",
3197 rule->file, rule->line, pxname, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003198 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003199 cfgerr++;
3200 continue;
3201 }
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01003202 node = LIST_NEXT(&rule->be.expr, struct logformat_node *, list);
3203
3204 if (!LIST_ISEMPTY(&rule->be.expr)) {
3205 if (node->type != LOG_FMT_TEXT || node->list.n != &rule->be.expr) {
3206 rule->dynamic = 1;
3207 free(pxname);
3208 continue;
3209 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02003210 /* Only one element in the list, a simple string: free the expression and
3211 * fall back to static rule
3212 */
Willy Tarreau2b718102021-04-21 07:32:39 +02003213 LIST_DELETE(&node->list);
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01003214 free(node->arg);
3215 free(node);
3216 }
3217
3218 rule->dynamic = 0;
3219 rule->be.name = pxname;
Willy Tarreau55ea7572007-06-17 19:56:27 +02003220
Willy Tarreauafb39922015-05-26 12:04:09 +02003221 target = proxy_be_by_name(rule->be.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01003222 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003223 ha_alert("Proxy '%s': unable to find required use_backend: '%s'.\n",
3224 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02003225 cfgerr++;
3226 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003227 ha_alert("Proxy '%s': loop detected for use_backend: '%s'.\n",
3228 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02003229 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02003230 } else if (target->mode != curproxy->mode &&
3231 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
3232
Christopher Faulet767a84b2017-11-24 16:50:31 +01003233 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) in a 'use_backend' rule (see 'mode').\n",
3234 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
3235 curproxy->conf.file, curproxy->conf.line,
3236 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
3237 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02003238 cfgerr++;
Willy Tarreau55ea7572007-06-17 19:56:27 +02003239 } else {
Willy Tarreau35cd7342021-02-26 20:51:47 +01003240 ha_free(&rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02003241 rule->be.backend = target;
3242 }
Christopher Faulet581db2b2021-03-26 10:02:46 +01003243 err_code |= warnif_tcp_http_cond(curproxy, rule->cond);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02003244 }
3245
Willy Tarreau64ab6072014-09-16 12:17:36 +02003246 /* find the target server for 'use_server' rules */
Willy Tarreau4a5cade2012-04-05 21:09:48 +02003247 list_for_each_entry(srule, &curproxy->server_rules, list) {
Jerome Magnin824186b2020-03-29 09:37:12 +02003248 struct server *target;
3249 struct logformat_node *node;
3250 char *server_name;
3251
3252 /* We try to parse the string as a log format expression. If the result of the parsing
3253 * is only one entry containing a single string, then it's a standard string corresponding
3254 * to a static rule, thus the parsing is cancelled and we fall back to setting srv.ptr.
3255 */
3256 server_name = srule->srv.name;
3257 LIST_INIT(&srule->expr);
3258 curproxy->conf.args.ctx = ARGC_USRV;
3259 err = NULL;
3260 if (!parse_logformat_string(server_name, curproxy, &srule->expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
3261 ha_alert("Parsing [%s:%d]; use-server rule failed to parse log-format '%s' : %s.\n",
3262 srule->file, srule->line, server_name, err);
3263 free(err);
3264 cfgerr++;
3265 continue;
3266 }
3267 node = LIST_NEXT(&srule->expr, struct logformat_node *, list);
3268
3269 if (!LIST_ISEMPTY(&srule->expr)) {
3270 if (node->type != LOG_FMT_TEXT || node->list.n != &srule->expr) {
3271 srule->dynamic = 1;
3272 free(server_name);
3273 continue;
3274 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02003275 /* Only one element in the list, a simple string: free the expression and
3276 * fall back to static rule
3277 */
Willy Tarreau2b718102021-04-21 07:32:39 +02003278 LIST_DELETE(&node->list);
Jerome Magnin824186b2020-03-29 09:37:12 +02003279 free(node->arg);
3280 free(node);
3281 }
3282
3283 srule->dynamic = 0;
3284 srule->srv.name = server_name;
3285 target = findserver(curproxy, srule->srv.name);
Christopher Faulet581db2b2021-03-26 10:02:46 +01003286 err_code |= warnif_tcp_http_cond(curproxy, srule->cond);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02003287
3288 if (!target) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003289 ha_alert("%s '%s' : unable to find server '%s' referenced in a 'use-server' rule.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003290 proxy_type_str(curproxy), curproxy->id, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02003291 cfgerr++;
3292 continue;
3293 }
Willy Tarreau35cd7342021-02-26 20:51:47 +01003294 ha_free(&srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02003295 srule->srv.ptr = target;
Amaury Denoyelle06269612021-08-23 14:05:07 +02003296 target->flags |= SRV_F_NON_PURGEABLE;
Willy Tarreau55ea7572007-06-17 19:56:27 +02003297 }
3298
Emeric Brunb982a3d2010-01-04 15:45:53 +01003299 /* find the target table for 'stick' rules */
3300 list_for_each_entry(mrule, &curproxy->sticking_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003301 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01003302
Emeric Brun1d33b292010-01-04 15:47:17 +01003303 curproxy->be_req_ana |= AN_REQ_STICKING_RULES;
3304 if (mrule->flags & STK_IS_STORE)
3305 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
3306
Emeric Brunb982a3d2010-01-04 15:45:53 +01003307 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003308 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003309 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003310 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01003311
3312 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003313 ha_alert("Proxy '%s': unable to find stick-table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01003314 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003315 cfgerr++;
3316 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003317 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003318 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
3319 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003320 cfgerr++;
3321 }
3322 else {
Willy Tarreau35cd7342021-02-26 20:51:47 +01003323 ha_free(&mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003324 mrule->table.t = target;
Emeric Brunc64a2a32021-06-30 18:01:02 +02003325 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL, NULL);
3326 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_KEY, NULL, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02003327 if (!in_proxies_list(target->proxies_list, curproxy)) {
3328 curproxy->next_stkt_ref = target->proxies_list;
3329 target->proxies_list = curproxy;
3330 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01003331 }
Christopher Faulet581db2b2021-03-26 10:02:46 +01003332 err_code |= warnif_tcp_http_cond(curproxy, mrule->cond);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003333 }
3334
3335 /* find the target table for 'store response' rules */
3336 list_for_each_entry(mrule, &curproxy->storersp_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003337 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01003338
Emeric Brun1d33b292010-01-04 15:47:17 +01003339 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
3340
Emeric Brunb982a3d2010-01-04 15:45:53 +01003341 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003342 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003343 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003344 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01003345
3346 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003347 ha_alert("Proxy '%s': unable to find store table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01003348 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003349 cfgerr++;
3350 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003351 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003352 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
3353 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003354 cfgerr++;
3355 }
3356 else {
Willy Tarreau35cd7342021-02-26 20:51:47 +01003357 ha_free(&mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003358 mrule->table.t = target;
Emeric Brunc64a2a32021-06-30 18:01:02 +02003359 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL, NULL);
3360 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_KEY, NULL, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02003361 if (!in_proxies_list(target->proxies_list, curproxy)) {
3362 curproxy->next_stkt_ref = target->proxies_list;
3363 target->proxies_list = curproxy;
3364 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01003365 }
3366 }
3367
Christopher Faulet42c6cf92021-03-25 17:19:04 +01003368 /* check validity for 'tcp-request' layer 4/5/6/7 rules */
3369 cfgerr += check_action_rules(&curproxy->tcp_req.l4_rules, curproxy, &err_code);
3370 cfgerr += check_action_rules(&curproxy->tcp_req.l5_rules, curproxy, &err_code);
3371 cfgerr += check_action_rules(&curproxy->tcp_req.inspect_rules, curproxy, &err_code);
3372 cfgerr += check_action_rules(&curproxy->tcp_rep.inspect_rules, curproxy, &err_code);
3373 cfgerr += check_action_rules(&curproxy->http_req_rules, curproxy, &err_code);
3374 cfgerr += check_action_rules(&curproxy->http_res_rules, curproxy, &err_code);
3375 cfgerr += check_action_rules(&curproxy->http_after_res_rules, curproxy, &err_code);
Christopher Faulet6d0c3df2020-01-22 09:26:35 +01003376
Christopher Faulet5eef0182021-03-31 17:13:49 +02003377 /* Warn is a switch-mode http is used on a TCP listener with servers but no backend */
3378 if (!curproxy->defbe.name && LIST_ISEMPTY(&curproxy->switching_rules) && curproxy->srv) {
3379 if ((curproxy->options & PR_O_HTTP_UPG) && curproxy->mode == PR_MODE_TCP)
3380 ha_warning("Proxy '%s' : 'switch-mode http' configured for a %s %s with no backend. "
3381 "Incoming connections upgraded to HTTP cannot be routed to TCP servers\n",
3382 curproxy->id, proxy_mode_str(curproxy->mode), proxy_type_str(curproxy));
3383 }
3384
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003385 if (curproxy->table && curproxy->table->peers.name) {
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003386 struct peers *curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02003387
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003388 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003389 if (strcmp(curpeers->id, curproxy->table->peers.name) == 0) {
Willy Tarreau35cd7342021-02-26 20:51:47 +01003390 ha_free(&curproxy->table->peers.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003391 curproxy->table->peers.p = curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02003392 break;
3393 }
3394 }
3395
3396 if (!curpeers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003397 ha_alert("Proxy '%s': unable to find sync peers '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003398 curproxy->id, curproxy->table->peers.name);
Willy Tarreau35cd7342021-02-26 20:51:47 +01003399 ha_free(&curproxy->table->peers.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003400 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02003401 cfgerr++;
3402 }
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02003403 else if (curpeers->disabled) {
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003404 /* silently disable this peers section */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003405 curproxy->table->peers.p = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003406 }
Emeric Brun32da3c42010-09-23 18:39:19 +02003407 else if (!curpeers->peers_fe) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003408 ha_alert("Proxy '%s': unable to find local peer '%s' in peers section '%s'.\n",
3409 curproxy->id, localpeer, curpeers->id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003410 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02003411 cfgerr++;
3412 }
3413 }
3414
Simon Horman9dc49962015-01-30 11:22:59 +09003415
3416 if (curproxy->email_alert.mailers.name) {
3417 struct mailers *curmailers = mailers;
3418
3419 for (curmailers = mailers; curmailers; curmailers = curmailers->next) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003420 if (strcmp(curmailers->id, curproxy->email_alert.mailers.name) == 0)
Simon Horman9dc49962015-01-30 11:22:59 +09003421 break;
Simon Horman9dc49962015-01-30 11:22:59 +09003422 }
Simon Horman9dc49962015-01-30 11:22:59 +09003423 if (!curmailers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003424 ha_alert("Proxy '%s': unable to find mailers '%s'.\n",
3425 curproxy->id, curproxy->email_alert.mailers.name);
Simon Horman9dc49962015-01-30 11:22:59 +09003426 free_email_alert(curproxy);
3427 cfgerr++;
3428 }
Christopher Faulet0108bb32017-10-20 21:34:32 +02003429 else {
3430 err = NULL;
3431 if (init_email_alert(curmailers, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003432 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulet0108bb32017-10-20 21:34:32 +02003433 free(err);
3434 cfgerr++;
3435 }
3436 }
Simon Horman9dc49962015-01-30 11:22:59 +09003437 }
3438
Willy Tarreau5bbc6762021-02-12 11:49:25 +01003439 if (curproxy->uri_auth && !(curproxy->uri_auth->flags & STAT_CONVDONE) &&
Willy Tarreauff011f22011-01-06 17:51:27 +01003440 !LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules) &&
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003441 (curproxy->uri_auth->userlist || curproxy->uri_auth->auth_realm )) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003442 ha_alert("%s '%s': stats 'auth'/'realm' and 'http-request' can't be used at the same time.\n",
3443 "proxy", curproxy->id);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003444 cfgerr++;
3445 goto out_uri_auth_compat;
3446 }
3447
Willy Tarreauee4f5f82019-10-09 09:59:22 +02003448 if (curproxy->uri_auth && curproxy->uri_auth->userlist &&
Willy Tarreau5bbc6762021-02-12 11:49:25 +01003449 (!(curproxy->uri_auth->flags & STAT_CONVDONE) ||
Willy Tarreauee4f5f82019-10-09 09:59:22 +02003450 LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules))) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01003451 const char *uri_auth_compat_req[10];
Thierry FOURNIERa28a9422015-08-04 19:35:46 +02003452 struct act_rule *rule;
Amaury Denoyelle3efee652021-03-08 17:31:39 +01003453 i = 0;
3454
Willy Tarreau95fa4692010-02-01 13:05:50 +01003455 /* build the ACL condition from scratch. We're relying on anonymous ACLs for that */
3456 uri_auth_compat_req[i++] = "auth";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003457
3458 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01003459 uri_auth_compat_req[i++] = "realm";
3460 uri_auth_compat_req[i++] = curproxy->uri_auth->auth_realm;
3461 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003462
Willy Tarreau95fa4692010-02-01 13:05:50 +01003463 uri_auth_compat_req[i++] = "unless";
3464 uri_auth_compat_req[i++] = "{";
3465 uri_auth_compat_req[i++] = "http_auth(.internal-stats-userlist)";
3466 uri_auth_compat_req[i++] = "}";
3467 uri_auth_compat_req[i++] = "";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003468
Willy Tarreauff011f22011-01-06 17:51:27 +01003469 rule = parse_http_req_cond(uri_auth_compat_req, "internal-stats-auth-compat", 0, curproxy);
3470 if (!rule) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01003471 cfgerr++;
3472 break;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003473 }
3474
Willy Tarreau2b718102021-04-21 07:32:39 +02003475 LIST_APPEND(&curproxy->uri_auth->http_req_rules, &rule->list);
Willy Tarreau95fa4692010-02-01 13:05:50 +01003476
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003477 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003478 ha_free(&curproxy->uri_auth->auth_realm);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003479 }
Willy Tarreau5bbc6762021-02-12 11:49:25 +01003480 curproxy->uri_auth->flags |= STAT_CONVDONE;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003481 }
3482out_uri_auth_compat:
3483
Dragan Dosen43885c72015-10-01 13:18:13 +02003484 /* check whether we have a log server that uses RFC5424 log format */
Dragan Dosen1322d092015-09-22 16:05:32 +02003485 list_for_each_entry(tmplogsrv, &curproxy->logsrvs, list) {
Dragan Dosen43885c72015-10-01 13:18:13 +02003486 if (tmplogsrv->format == LOG_FORMAT_RFC5424) {
3487 if (!curproxy->conf.logformat_sd_string) {
3488 /* set the default logformat_sd_string */
3489 curproxy->conf.logformat_sd_string = default_rfc5424_sd_log_format;
3490 }
Dragan Dosen1322d092015-09-22 16:05:32 +02003491 break;
Dragan Dosen1322d092015-09-22 16:05:32 +02003492 }
Dragan Dosen1322d092015-09-22 16:05:32 +02003493 }
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02003494
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003495 /* compile the log format */
3496 if (!(curproxy->cap & PR_CAP_FE)) {
Willy Tarreau62a61232013-04-12 18:13:46 +02003497 if (curproxy->conf.logformat_string != default_http_log_format &&
3498 curproxy->conf.logformat_string != default_tcp_log_format &&
3499 curproxy->conf.logformat_string != clf_http_log_format)
3500 free(curproxy->conf.logformat_string);
3501 curproxy->conf.logformat_string = NULL;
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003502 ha_free(&curproxy->conf.lfs_file);
Willy Tarreau62a61232013-04-12 18:13:46 +02003503 curproxy->conf.lfs_line = 0;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003504
3505 if (curproxy->conf.logformat_sd_string != default_rfc5424_sd_log_format)
3506 free(curproxy->conf.logformat_sd_string);
3507 curproxy->conf.logformat_sd_string = NULL;
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003508 ha_free(&curproxy->conf.lfsd_file);
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003509 curproxy->conf.lfsd_line = 0;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003510 }
3511
Willy Tarreau62a61232013-04-12 18:13:46 +02003512 if (curproxy->conf.logformat_string) {
3513 curproxy->conf.args.ctx = ARGC_LOG;
3514 curproxy->conf.args.file = curproxy->conf.lfs_file;
3515 curproxy->conf.args.line = curproxy->conf.lfs_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003516 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02003517 if (!parse_logformat_string(curproxy->conf.logformat_string, curproxy, &curproxy->logformat,
3518 LOG_OPT_MANDATORY|LOG_OPT_MERGE_SPACES,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003519 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003520 ha_alert("Parsing [%s:%d]: failed to parse log-format : %s.\n",
3521 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003522 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003523 cfgerr++;
3524 }
Willy Tarreau62a61232013-04-12 18:13:46 +02003525 curproxy->conf.args.file = NULL;
3526 curproxy->conf.args.line = 0;
3527 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003528
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003529 if (curproxy->conf.logformat_sd_string) {
3530 curproxy->conf.args.ctx = ARGC_LOGSD;
3531 curproxy->conf.args.file = curproxy->conf.lfsd_file;
3532 curproxy->conf.args.line = curproxy->conf.lfsd_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003533 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02003534 if (!parse_logformat_string(curproxy->conf.logformat_sd_string, curproxy, &curproxy->logformat_sd,
3535 LOG_OPT_MANDATORY|LOG_OPT_MERGE_SPACES,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003536 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003537 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
3538 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003539 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003540 cfgerr++;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003541 } else if (!add_to_logformat_list(NULL, NULL, LF_SEPARATOR, &curproxy->logformat_sd, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003542 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
3543 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003544 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003545 cfgerr++;
3546 }
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003547 curproxy->conf.args.file = NULL;
3548 curproxy->conf.args.line = 0;
3549 }
3550
Willy Tarreau62a61232013-04-12 18:13:46 +02003551 if (curproxy->conf.uniqueid_format_string) {
Christopher Faulet7a06ffb2021-10-13 17:22:17 +02003552 int where = 0;
3553
Willy Tarreau62a61232013-04-12 18:13:46 +02003554 curproxy->conf.args.ctx = ARGC_UIF;
3555 curproxy->conf.args.file = curproxy->conf.uif_file;
3556 curproxy->conf.args.line = curproxy->conf.uif_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003557 err = NULL;
Christopher Faulet7a06ffb2021-10-13 17:22:17 +02003558 if (curproxy->cap & PR_CAP_FE)
3559 where |= SMP_VAL_FE_HRQ_HDR;
3560 if (curproxy->cap & PR_CAP_BE)
3561 where |= SMP_VAL_BE_HRQ_HDR;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02003562 if (!parse_logformat_string(curproxy->conf.uniqueid_format_string, curproxy, &curproxy->format_unique_id,
Christopher Faulet7a06ffb2021-10-13 17:22:17 +02003563 LOG_OPT_HTTP|LOG_OPT_MERGE_SPACES, where, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003564 ha_alert("Parsing [%s:%d]: failed to parse unique-id : %s.\n",
3565 curproxy->conf.uif_file, curproxy->conf.uif_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003566 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003567 cfgerr++;
3568 }
Willy Tarreau62a61232013-04-12 18:13:46 +02003569 curproxy->conf.args.file = NULL;
3570 curproxy->conf.args.line = 0;
3571 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003572
Remi Tricot-Le Bretonfe21fe72021-08-31 12:08:52 +02003573 if (curproxy->conf.error_logformat_string) {
3574 curproxy->conf.args.ctx = ARGC_LOG;
3575 curproxy->conf.args.file = curproxy->conf.elfs_file;
3576 curproxy->conf.args.line = curproxy->conf.elfs_line;
3577 err = NULL;
3578 if (!parse_logformat_string(curproxy->conf.error_logformat_string, curproxy, &curproxy->logformat_error,
3579 LOG_OPT_MANDATORY|LOG_OPT_MERGE_SPACES,
3580 SMP_VAL_FE_LOG_END, &err)) {
3581 ha_alert("Parsing [%s:%d]: failed to parse error-log-format : %s.\n",
3582 curproxy->conf.elfs_file, curproxy->conf.elfs_line, err);
3583 free(err);
3584 cfgerr++;
3585 }
3586 curproxy->conf.args.file = NULL;
3587 curproxy->conf.args.line = 0;
3588 }
3589
Willy Tarreau7c9a0fe2022-04-25 10:25:34 +02003590 /* "balance hash" needs to compile its expression */
3591 if ((curproxy->lbprm.algo & BE_LB_ALGO) == BE_LB_ALGO_SMP) {
3592 int idx = 0;
3593 const char *args[] = {
3594 curproxy->lbprm.arg_str,
3595 NULL,
3596 };
3597
3598 err = NULL;
3599 curproxy->conf.args.ctx = ARGC_USRV; // same context as use_server.
3600 curproxy->lbprm.expr =
3601 sample_parse_expr((char **)args, &idx,
3602 curproxy->conf.file, curproxy->conf.line,
3603 &err, &curproxy->conf.args, NULL);
3604
3605 if (!curproxy->lbprm.expr) {
3606 ha_alert("%s '%s' [%s:%d]: failed to parse 'balance hash' expression '%s' in : %s.\n",
3607 proxy_type_str(curproxy), curproxy->id,
3608 curproxy->conf.file, curproxy->conf.line,
3609 curproxy->lbprm.arg_str, err);
3610 ha_free(&err);
3611 cfgerr++;
3612 }
3613 else if (!(curproxy->lbprm.expr->fetch->val & SMP_VAL_BE_SET_SRV)) {
3614 ha_alert("%s '%s' [%s:%d]: error detected while parsing 'balance hash' expression '%s' "
3615 "which requires information from %s, which is not available here.\n",
3616 proxy_type_str(curproxy), curproxy->id,
3617 curproxy->conf.file, curproxy->conf.line,
3618 curproxy->lbprm.arg_str, sample_src_names(curproxy->lbprm.expr->fetch->use));
3619 cfgerr++;
3620 }
3621 else if (curproxy->mode == PR_MODE_HTTP && (curproxy->lbprm.expr->fetch->use & SMP_USE_L6REQ)) {
3622 ha_warning("%s '%s' [%s:%d]: L6 sample fetch <%s> will be ignored in 'balance hash' expression in HTTP mode.\n",
3623 proxy_type_str(curproxy), curproxy->id,
3624 curproxy->conf.file, curproxy->conf.line,
3625 curproxy->lbprm.arg_str);
3626 }
3627 else
3628 curproxy->http_needed |= !!(curproxy->lbprm.expr->fetch->use & SMP_USE_HTTP_ANY);
3629 }
Aurelien DARRAGONb2e2ec52023-01-09 11:09:03 +01003630
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01003631 /* only now we can check if some args remain unresolved.
3632 * This must be done after the users and groups resolution.
3633 */
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01003634 err = NULL;
3635 i = smp_resolve_args(curproxy, &err);
3636 cfgerr += i;
3637 if (i) {
3638 indent_msg(&err, 8);
3639 ha_alert("%s%s\n", i > 1 ? "multiple argument resolution errors:" : "", err);
3640 ha_free(&err);
3641 } else
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003642 cfgerr += acl_find_targets(curproxy);
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01003643
William Lallemand2c04a5a2021-08-13 15:21:12 +02003644 if (!(curproxy->cap & PR_CAP_INT) && (curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003645 (((curproxy->cap & PR_CAP_FE) && !curproxy->timeout.client) ||
Willy Tarreaud825eef2007-05-12 22:35:00 +02003646 ((curproxy->cap & PR_CAP_BE) && (curproxy->srv) &&
Willy Tarreauce887fd2012-05-12 12:50:00 +02003647 (!curproxy->timeout.connect ||
3648 (!curproxy->timeout.server && (curproxy->mode == PR_MODE_HTTP || !curproxy->timeout.tunnel)))))) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003649 ha_warning("missing timeouts for %s '%s'.\n"
Christopher Faulet767a84b2017-11-24 16:50:31 +01003650 " | While not properly invalid, you will certainly encounter various problems\n"
3651 " | with such a configuration. To fix this, please ensure that all following\n"
3652 " | timeouts are set to a non-zero value: 'client', 'connect', 'server'.\n",
3653 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003654 err_code |= ERR_WARN;
Willy Tarreau2738a142006-07-08 17:28:09 +02003655 }
Willy Tarreauf3c69202006-07-09 16:42:34 +02003656
Willy Tarreau1fa31262007-12-03 00:36:16 +01003657 /* Historically, the tarpit and queue timeouts were inherited from contimeout.
3658 * We must still support older configurations, so let's find out whether those
3659 * parameters have been set or must be copied from contimeouts.
3660 */
Willy Tarreau937c3ea2021-02-12 11:14:35 +01003661 if (!curproxy->timeout.tarpit)
3662 curproxy->timeout.tarpit = curproxy->timeout.connect;
3663 if ((curproxy->cap & PR_CAP_BE) && !curproxy->timeout.queue)
3664 curproxy->timeout.queue = curproxy->timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01003665
Christopher Faulete5870d82020-04-15 11:32:03 +02003666 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_TCP_RS)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003667 ha_warning("%s '%s' uses tcp-check rules without 'option tcp-check', so the rules are ignored.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003668 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau215663d2014-06-13 18:30:23 +02003669 err_code |= ERR_WARN;
3670 }
3671
Willy Tarreau193b8c62012-11-22 00:17:38 +01003672 /* ensure that cookie capture length is not too large */
3673 if (curproxy->capture_len >= global.tune.cookie_len) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003674 ha_warning("truncating capture length to %d bytes for %s '%s'.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003675 global.tune.cookie_len - 1, proxy_type_str(curproxy), curproxy->id);
Willy Tarreau193b8c62012-11-22 00:17:38 +01003676 err_code |= ERR_WARN;
3677 curproxy->capture_len = global.tune.cookie_len - 1;
3678 }
3679
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003680 /* The small pools required for the capture lists */
Willy Tarreau9a54e132012-03-24 08:33:05 +01003681 if (curproxy->nb_req_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003682 curproxy->req_cap_pool = create_pool("ptrcap",
3683 curproxy->nb_req_cap * sizeof(char *),
3684 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003685 }
3686
3687 if (curproxy->nb_rsp_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003688 curproxy->rsp_cap_pool = create_pool("ptrcap",
3689 curproxy->nb_rsp_cap * sizeof(char *),
3690 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003691 }
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003692
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003693 switch (curproxy->load_server_state_from_file) {
3694 case PR_SRV_STATE_FILE_UNSPEC:
3695 curproxy->load_server_state_from_file = PR_SRV_STATE_FILE_NONE;
3696 break;
3697 case PR_SRV_STATE_FILE_GLOBAL:
3698 if (!global.server_state_file) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003699 ha_warning("backend '%s' configured to load server state file from global section 'server-state-file' directive. Unfortunately, 'server-state-file' is not set!\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003700 curproxy->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003701 err_code |= ERR_WARN;
3702 }
3703 break;
3704 }
3705
Willy Tarreaubaaee002006-06-26 02:48:02 +02003706 /* first, we will invert the servers list order */
3707 newsrv = NULL;
3708 while (curproxy->srv) {
3709 struct server *next;
3710
3711 next = curproxy->srv->next;
3712 curproxy->srv->next = newsrv;
3713 newsrv = curproxy->srv;
3714 if (!next)
3715 break;
3716 curproxy->srv = next;
3717 }
3718
Willy Tarreau17edc812014-01-03 12:14:34 +01003719 /* Check that no server name conflicts. This causes trouble in the stats.
3720 * We only emit a warning for the first conflict affecting each server,
3721 * in order to avoid combinatory explosion if all servers have the same
3722 * name. We do that only for servers which do not have an explicit ID,
3723 * because these IDs were made also for distinguishing them and we don't
3724 * want to annoy people who correctly manage them.
3725 */
3726 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3727 struct server *other_srv;
3728
3729 if (newsrv->puid)
3730 continue;
3731
3732 for (other_srv = curproxy->srv; other_srv && other_srv != newsrv; other_srv = other_srv->next) {
3733 if (!other_srv->puid && strcmp(other_srv->id, newsrv->id) == 0) {
Willy Tarreaub01302f2019-05-27 19:31:06 +02003734 ha_alert("parsing [%s:%d] : %s '%s', another server named '%s' was already defined at line %d, please use distinct names.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003735 newsrv->conf.file, newsrv->conf.line,
3736 proxy_type_str(curproxy), curproxy->id,
3737 newsrv->id, other_srv->conf.line);
Willy Tarreaub01302f2019-05-27 19:31:06 +02003738 cfgerr++;
Willy Tarreau17edc812014-01-03 12:14:34 +01003739 break;
3740 }
3741 }
3742 }
3743
Willy Tarreaudd701652010-05-25 23:03:02 +02003744 /* assign automatic UIDs to servers which don't have one yet */
3745 next_id = 1;
3746 newsrv = curproxy->srv;
3747 while (newsrv != NULL) {
3748 if (!newsrv->puid) {
3749 /* server ID not set, use automatic numbering with first
3750 * spare entry starting with next_svid.
3751 */
3752 next_id = get_next_id(&curproxy->conf.used_server_id, next_id);
3753 newsrv->conf.id.key = newsrv->puid = next_id;
3754 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
3755 }
Amaury Denoyelle077c6b82021-06-14 17:04:25 +02003756 newsrv->conf.name.key = newsrv->id;
3757 ebis_insert(&curproxy->conf.used_server_name, &newsrv->conf.name);
3758
Willy Tarreaudd701652010-05-25 23:03:02 +02003759 next_id++;
3760 newsrv = newsrv->next;
3761 }
3762
Willy Tarreau20697042007-11-15 23:26:18 +01003763 curproxy->lbprm.wmult = 1; /* default weight multiplier */
Willy Tarreau5dc2fa62007-11-19 19:10:18 +01003764 curproxy->lbprm.wdiv = 1; /* default weight divider */
Willy Tarreaubaaee002006-06-26 02:48:02 +02003765
Willy Tarreau62c3be22012-01-20 13:12:32 +01003766 /*
3767 * If this server supports a maxconn parameter, it needs a dedicated
3768 * tasks to fill the emptied slots when a connection leaves.
3769 * Also, resolve deferred tracking dependency if needed.
3770 */
3771 newsrv = curproxy->srv;
3772 while (newsrv != NULL) {
Amaury Denoyellee74cbc32021-05-28 10:34:01 +02003773 set_usermsgs_ctx(newsrv->conf.file, newsrv->conf.line, &newsrv->obj_type);
3774
Aurelien DARRAGON3e7a0bb2023-02-08 11:49:02 +01003775 srv_minmax_conn_apply(newsrv);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003776
William Dauchyf6370442020-11-14 19:25:33 +01003777 /* this will also properly set the transport layer for
3778 * prod and checks
3779 * if default-server have use_ssl, prerare ssl init
3780 * without activating it */
3781 if (newsrv->use_ssl == 1 || newsrv->check.use_ssl == 1 ||
Christopher Faulet4ab26792021-12-01 09:50:41 +01003782 (newsrv->proxy->options & PR_O_TCPCHK_SSL) ||
3783 ((newsrv->flags & SRV_F_DEFSRV_USE_SSL) && newsrv->use_ssl != 1)) {
Willy Tarreau17d45382016-12-22 21:16:08 +01003784 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
3785 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(newsrv);
3786 }
Emeric Brun94324a42012-10-11 14:00:19 +02003787
Willy Tarreau034c88c2017-01-23 23:36:45 +01003788 if ((newsrv->flags & SRV_F_FASTOPEN) &&
3789 ((curproxy->retry_type & (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)) !=
3790 (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)))
Amaury Denoyellee74cbc32021-05-28 10:34:01 +02003791 ha_warning("server has tfo activated, the backend should be configured with at least 'conn-failure', 'empty-response' and 'response-timeout' or we wouldn't be able to retry the connection on failure.\n");
Willy Tarreau034c88c2017-01-23 23:36:45 +01003792
Willy Tarreau62c3be22012-01-20 13:12:32 +01003793 if (newsrv->trackit) {
Amaury Denoyelle669b6202021-07-13 10:35:23 +02003794 if (srv_apply_track(newsrv, curproxy)) {
3795 ++cfgerr;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003796 goto next_srv;
3797 }
Willy Tarreau62c3be22012-01-20 13:12:32 +01003798 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003799
Willy Tarreau62c3be22012-01-20 13:12:32 +01003800 next_srv:
Amaury Denoyellee74cbc32021-05-28 10:34:01 +02003801 reset_usermsgs_ctx();
Willy Tarreau62c3be22012-01-20 13:12:32 +01003802 newsrv = newsrv->next;
3803 }
3804
Olivier Houchard4e694042017-03-14 20:01:29 +01003805 /*
3806 * Try to generate dynamic cookies for servers now.
3807 * It couldn't be done earlier, since at the time we parsed
3808 * the server line, we may not have known yet that we
3809 * should use dynamic cookies, or the secret key may not
3810 * have been provided yet.
3811 */
3812 if (curproxy->ck_opts & PR_CK_DYNAMIC) {
3813 newsrv = curproxy->srv;
3814 while (newsrv != NULL) {
3815 srv_set_dyncookie(newsrv);
3816 newsrv = newsrv->next;
3817 }
3818
3819 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003820 /* We have to initialize the server lookup mechanism depending
Joseph Herlanta14c03e2018-11-15 14:04:19 -08003821 * on what LB algorithm was chosen.
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003822 */
3823
3824 curproxy->lbprm.algo &= ~(BE_LB_LKUP | BE_LB_PROP_DYN);
3825 switch (curproxy->lbprm.algo & BE_LB_KIND) {
3826 case BE_LB_KIND_RR:
Willy Tarreau9757a382009-10-03 12:56:50 +02003827 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_STATIC) {
3828 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3829 init_server_map(curproxy);
Willy Tarreau760e81d2018-05-03 07:20:40 +02003830 } else if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_RANDOM) {
3831 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
Remi Tricot-Le Breton47646202021-05-19 16:40:28 +02003832 if (chash_init_server_tree(curproxy) < 0) {
3833 cfgerr++;
3834 }
Willy Tarreau9757a382009-10-03 12:56:50 +02003835 } else {
3836 curproxy->lbprm.algo |= BE_LB_LKUP_RRTREE | BE_LB_PROP_DYN;
3837 fwrr_init_server_groups(curproxy);
3838 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003839 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003840
Willy Tarreau3ebb1162012-02-13 16:57:44 +01003841 case BE_LB_KIND_CB:
Willy Tarreauf09c6602012-02-13 17:12:08 +01003842 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_CB_LC) {
3843 curproxy->lbprm.algo |= BE_LB_LKUP_LCTREE | BE_LB_PROP_DYN;
3844 fwlc_init_server_tree(curproxy);
3845 } else {
3846 curproxy->lbprm.algo |= BE_LB_LKUP_FSTREE | BE_LB_PROP_DYN;
3847 fas_init_server_tree(curproxy);
3848 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003849 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003850
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003851 case BE_LB_KIND_HI:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003852 if ((curproxy->lbprm.algo & BE_LB_HASH_TYPE) == BE_LB_HASH_CONS) {
3853 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
Remi Tricot-Le Breton47646202021-05-19 16:40:28 +02003854 if (chash_init_server_tree(curproxy) < 0) {
3855 cfgerr++;
3856 }
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003857 } else {
3858 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3859 init_server_map(curproxy);
3860 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003861 break;
3862 }
Willy Tarreaucd10def2020-10-17 18:48:47 +02003863 HA_RWLOCK_INIT(&curproxy->lbprm.lock);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003864
3865 if (curproxy->options & PR_O_LOGASAP)
3866 curproxy->to_log &= ~LW_BYTES;
3867
William Lallemand2c04a5a2021-08-13 15:21:12 +02003868 if (!(curproxy->cap & PR_CAP_INT) && (curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003869 (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->logsrvs) &&
3870 (!LIST_ISEMPTY(&curproxy->logformat) || !LIST_ISEMPTY(&curproxy->logformat_sd))) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003871 ha_warning("log format ignored for %s '%s' since it has no log address.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003872 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003873 err_code |= ERR_WARN;
3874 }
3875
Christopher Faulet3b6446f2021-03-15 15:10:38 +01003876 if (curproxy->mode != PR_MODE_HTTP && !(curproxy->options & PR_O_HTTP_UPG)) {
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003877 int optnum;
3878
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003879 if (curproxy->uri_auth) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003880 ha_warning("'stats' statement ignored for %s '%s' as it requires HTTP mode.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003881 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003882 err_code |= ERR_WARN;
3883 curproxy->uri_auth = NULL;
3884 }
3885
Willy Tarreaude7dc882017-03-10 11:49:21 +01003886 if (curproxy->capture_name) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003887 ha_warning("'capture' statement ignored for %s '%s' as it requires HTTP mode.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003888 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003889 err_code |= ERR_WARN;
3890 }
3891
3892 if (!LIST_ISEMPTY(&curproxy->http_req_rules)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003893 ha_warning("'http-request' rules ignored for %s '%s' as they require HTTP mode.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003894 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003895 err_code |= ERR_WARN;
3896 }
3897
3898 if (!LIST_ISEMPTY(&curproxy->http_res_rules)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003899 ha_warning("'http-response' rules ignored for %s '%s' as they require HTTP mode.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003900 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003901 err_code |= ERR_WARN;
3902 }
3903
Christopher Fauletbb7abed2021-03-15 15:09:21 +01003904 if (!LIST_ISEMPTY(&curproxy->http_after_res_rules)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003905 ha_warning("'http-after-response' rules ignored for %s '%s' as they require HTTP mode.\n",
Christopher Fauletbb7abed2021-03-15 15:09:21 +01003906 proxy_type_str(curproxy), curproxy->id);
3907 err_code |= ERR_WARN;
3908 }
3909
Willy Tarreaude7dc882017-03-10 11:49:21 +01003910 if (!LIST_ISEMPTY(&curproxy->redirect_rules)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003911 ha_warning("'redirect' rules ignored for %s '%s' as they require HTTP mode.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003912 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003913 err_code |= ERR_WARN;
3914 }
3915
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003916 for (optnum = 0; cfg_opts[optnum].name; optnum++) {
3917 if (cfg_opts[optnum].mode == PR_MODE_HTTP &&
3918 (curproxy->cap & cfg_opts[optnum].cap) &&
3919 (curproxy->options & cfg_opts[optnum].val)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003920 ha_warning("'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003921 cfg_opts[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003922 err_code |= ERR_WARN;
3923 curproxy->options &= ~cfg_opts[optnum].val;
3924 }
3925 }
3926
3927 for (optnum = 0; cfg_opts2[optnum].name; optnum++) {
3928 if (cfg_opts2[optnum].mode == PR_MODE_HTTP &&
3929 (curproxy->cap & cfg_opts2[optnum].cap) &&
3930 (curproxy->options2 & cfg_opts2[optnum].val)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003931 ha_warning("'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003932 cfg_opts2[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003933 err_code |= ERR_WARN;
3934 curproxy->options2 &= ~cfg_opts2[optnum].val;
3935 }
3936 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003937
Willy Tarreau29fbe512015-08-20 19:35:14 +02003938#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003939 if (curproxy->conn_src.bind_hdr_occ) {
3940 curproxy->conn_src.bind_hdr_occ = 0;
Amaury Denoyelle11124302021-06-04 18:22:08 +02003941 ha_warning("%s '%s' : ignoring use of header %s as source IP in non-HTTP mode.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003942 proxy_type_str(curproxy), curproxy->id, curproxy->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003943 err_code |= ERR_WARN;
3944 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003945#endif
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003946 }
3947
Willy Tarreaubaaee002006-06-26 02:48:02 +02003948 /*
Willy Tarreau21d2af32008-02-14 20:25:24 +01003949 * ensure that we're not cross-dressing a TCP server into HTTP.
3950 */
3951 newsrv = curproxy->srv;
3952 while (newsrv != NULL) {
Willy Tarreau0cec3312011-10-31 13:49:26 +01003953 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->rdr_len) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003954 ha_alert("%s '%s' : server cannot have cookie or redirect prefix in non-HTTP mode.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003955 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003956 cfgerr++;
Willy Tarreau21d2af32008-02-14 20:25:24 +01003957 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003958
Willy Tarreau0cec3312011-10-31 13:49:26 +01003959 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->cklen) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003960 ha_warning("%s '%s' : ignoring cookie for server '%s' as HTTP mode is disabled.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003961 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau0cec3312011-10-31 13:49:26 +01003962 err_code |= ERR_WARN;
3963 }
3964
Willy Tarreauc93cd162014-05-13 15:54:22 +02003965 if ((newsrv->flags & SRV_F_MAPPORTS) && (curproxy->options2 & PR_O2_RDPC_PRST)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02003966 ha_warning("%s '%s' : RDP cookie persistence will not work for server '%s' because it lacks an explicit port number.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003967 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau82ffa392013-08-13 17:19:08 +02003968 err_code |= ERR_WARN;
3969 }
3970
Willy Tarreau29fbe512015-08-20 19:35:14 +02003971#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003972 if (curproxy->mode != PR_MODE_HTTP && newsrv->conn_src.bind_hdr_occ) {
3973 newsrv->conn_src.bind_hdr_occ = 0;
Amaury Denoyelle11124302021-06-04 18:22:08 +02003974 ha_warning("%s '%s' : server %s cannot use header %s as source IP in non-HTTP mode.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003975 proxy_type_str(curproxy), curproxy->id, newsrv->id, newsrv->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003976 err_code |= ERR_WARN;
3977 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003978#endif
Willy Tarreau4c183462017-01-06 12:21:38 +01003979
Willy Tarreau46deab62018-04-28 07:18:15 +02003980 if ((curproxy->mode != PR_MODE_HTTP) && (curproxy->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR)
3981 curproxy->options &= ~PR_O_REUSE_MASK;
3982
Willy Tarreau21d2af32008-02-14 20:25:24 +01003983 newsrv = newsrv->next;
3984 }
3985
Christopher Fauletd7c91962015-04-30 11:48:27 +02003986 /* Check filter configuration, if any */
3987 cfgerr += flt_check(curproxy);
3988
Willy Tarreauc1a21672009-08-16 22:37:44 +02003989 if (curproxy->cap & PR_CAP_FE) {
Willy Tarreau050536d2012-10-04 08:47:34 +02003990 if (!curproxy->accept)
3991 curproxy->accept = frontend_accept;
Willy Tarreau81f9aa32010-06-01 17:45:26 +02003992
Christopher Fauletee08d6c2021-10-13 15:40:15 +02003993 if (!LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules) ||
3994 (curproxy->defpx && !LIST_ISEMPTY(&curproxy->defpx->tcp_req.inspect_rules)))
Willy Tarreaufb356202010-08-03 14:02:05 +02003995 curproxy->fe_req_ana |= AN_REQ_INSPECT_FE;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003996
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003997 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003998 curproxy->fe_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_PROCESS_FE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003999 curproxy->fe_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_FE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02004000 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02004001
William Lallemandcf62f7e2018-10-26 14:47:40 +02004002 if (curproxy->mode == PR_MODE_CLI) {
4003 curproxy->fe_req_ana |= AN_REQ_WAIT_CLI;
4004 curproxy->fe_rsp_ana |= AN_RES_WAIT_CLI;
4005 }
4006
Willy Tarreauc1a21672009-08-16 22:37:44 +02004007 /* both TCP and HTTP must check switching rules */
4008 curproxy->fe_req_ana |= AN_REQ_SWITCHING_RULES;
Christopher Fauletd7c91962015-04-30 11:48:27 +02004009
4010 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01004011 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01004012 curproxy->fe_req_ana |= AN_REQ_FLT_START_FE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
4013 curproxy->fe_rsp_ana |= AN_RES_FLT_START_FE | AN_RES_FLT_XFER_DATA | AN_RES_FLT_END;
Christopher Fauletd7c91962015-04-30 11:48:27 +02004014 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02004015 }
4016
4017 if (curproxy->cap & PR_CAP_BE) {
Christopher Fauletee08d6c2021-10-13 15:40:15 +02004018 if (!LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules) ||
4019 (curproxy->defpx && !LIST_ISEMPTY(&curproxy->defpx->tcp_req.inspect_rules)))
Willy Tarreaufb356202010-08-03 14:02:05 +02004020 curproxy->be_req_ana |= AN_REQ_INSPECT_BE;
4021
Christopher Fauletee08d6c2021-10-13 15:40:15 +02004022 if (!LIST_ISEMPTY(&curproxy->tcp_rep.inspect_rules) ||
4023 (curproxy->defpx && !LIST_ISEMPTY(&curproxy->defpx->tcp_rep.inspect_rules)))
Emeric Brun97679e72010-09-23 17:56:44 +02004024 curproxy->be_rsp_ana |= AN_RES_INSPECT;
4025
Willy Tarreau4e5b8282009-08-16 22:57:50 +02004026 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02004027 curproxy->be_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_INNER | AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02004028 curproxy->be_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_BE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02004029 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02004030
4031 /* If the backend does requires RDP cookie persistence, we have to
4032 * enable the corresponding analyser.
4033 */
4034 if (curproxy->options2 & PR_O2_RDPC_PRST)
4035 curproxy->be_req_ana |= AN_REQ_PRST_RDP_COOKIE;
Christopher Fauletd7c91962015-04-30 11:48:27 +02004036
4037 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01004038 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01004039 curproxy->be_req_ana |= AN_REQ_FLT_START_BE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
4040 curproxy->be_rsp_ana |= AN_RES_FLT_START_BE | AN_RES_FLT_XFER_DATA | AN_RES_FLT_END;
Christopher Fauletd7c91962015-04-30 11:48:27 +02004041 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02004042 }
Christopher Fauleta717b992018-04-10 14:43:00 +02004043
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02004044 /* Check the mux protocols, if any, for each listener and server
Christopher Fauleta717b992018-04-10 14:43:00 +02004045 * attached to the current proxy */
4046 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
4047 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01004048 const struct mux_proto_list *mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02004049
Willy Tarreau730cc022022-05-20 18:07:06 +02004050 if (!bind_conf->mux_proto) {
4051 /* No protocol was specified. If we're using QUIC at the transport
4052 * layer, we'll instantiate it as a mux as well. If QUIC is not
Ilya Shipitsin3b64a282022-07-29 22:26:53 +05004053 * compiled in, this will remain NULL.
Willy Tarreau730cc022022-05-20 18:07:06 +02004054 */
4055 if (bind_conf->xprt && bind_conf->xprt == xprt_get(XPRT_QUIC))
4056 bind_conf->mux_proto = get_mux_proto(ist("quic"));
4057 }
4058
Christopher Fauleta717b992018-04-10 14:43:00 +02004059 if (!bind_conf->mux_proto)
4060 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01004061
4062 /* it is possible that an incorrect mux was referenced
4063 * due to the proxy's mode not being taken into account
4064 * on first pass. Let's adjust it now.
4065 */
4066 mux_ent = conn_get_best_mux_entry(bind_conf->mux_proto->token, PROTO_SIDE_FE, mode);
4067
4068 if (!mux_ent || !isteq(mux_ent->token, bind_conf->mux_proto->token)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02004069 ha_alert("%s '%s' : MUX protocol '%.*s' is not usable for 'bind %s' at [%s:%d].\n",
Christopher Fauleta717b992018-04-10 14:43:00 +02004070 proxy_type_str(curproxy), curproxy->id,
4071 (int)bind_conf->mux_proto->token.len,
4072 bind_conf->mux_proto->token.ptr,
4073 bind_conf->arg, bind_conf->file, bind_conf->line);
4074 cfgerr++;
Willy Tarreaucac619b2022-05-20 17:53:32 +02004075 } else {
4076 if ((mux_ent->mux->flags & MX_FL_FRAMED) && !(bind_conf->options & BC_O_USE_SOCK_DGRAM)) {
4077 ha_alert("%s '%s' : frame-based MUX protocol '%.*s' is incompatible with stream transport of 'bind %s' at [%s:%d].\n",
4078 proxy_type_str(curproxy), curproxy->id,
4079 (int)bind_conf->mux_proto->token.len,
4080 bind_conf->mux_proto->token.ptr,
4081 bind_conf->arg, bind_conf->file, bind_conf->line);
4082 cfgerr++;
4083 }
4084 else if (!(mux_ent->mux->flags & MX_FL_FRAMED) && !(bind_conf->options & BC_O_USE_SOCK_STREAM)) {
4085 ha_alert("%s '%s' : stream-based MUX protocol '%.*s' is incompatible with framed transport of 'bind %s' at [%s:%d].\n",
4086 proxy_type_str(curproxy), curproxy->id,
4087 (int)bind_conf->mux_proto->token.len,
4088 bind_conf->mux_proto->token.ptr,
4089 bind_conf->arg, bind_conf->file, bind_conf->line);
4090 cfgerr++;
4091 }
Christopher Fauleta717b992018-04-10 14:43:00 +02004092 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01004093
4094 /* update the mux */
4095 bind_conf->mux_proto = mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02004096 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02004097 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
4098 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01004099 const struct mux_proto_list *mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02004100
4101 if (!newsrv->mux_proto)
4102 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01004103
4104 /* it is possible that an incorrect mux was referenced
4105 * due to the proxy's mode not being taken into account
4106 * on first pass. Let's adjust it now.
4107 */
4108 mux_ent = conn_get_best_mux_entry(newsrv->mux_proto->token, PROTO_SIDE_BE, mode);
4109
4110 if (!mux_ent || !isteq(mux_ent->token, newsrv->mux_proto->token)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02004111 ha_alert("%s '%s' : MUX protocol '%.*s' is not usable for server '%s' at [%s:%d].\n",
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02004112 proxy_type_str(curproxy), curproxy->id,
4113 (int)newsrv->mux_proto->token.len,
4114 newsrv->mux_proto->token.ptr,
4115 newsrv->id, newsrv->conf.file, newsrv->conf.line);
4116 cfgerr++;
4117 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01004118
4119 /* update the mux */
4120 newsrv->mux_proto = mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02004121 }
Amaury Denoyellef2c27a52021-07-23 15:46:46 +02004122
4123 /* Allocate default tcp-check rules for proxies without
4124 * explicit rules.
4125 */
4126 if (curproxy->cap & PR_CAP_BE) {
4127 if (!(curproxy->options2 & PR_O2_CHK_ANY)) {
4128 struct tcpcheck_ruleset *rs = NULL;
4129 struct tcpcheck_rules *rules = &curproxy->tcpcheck_rules;
4130
4131 curproxy->options2 |= PR_O2_TCPCHK_CHK;
4132
4133 rs = find_tcpcheck_ruleset("*tcp-check");
4134 if (!rs) {
4135 rs = create_tcpcheck_ruleset("*tcp-check");
4136 if (rs == NULL) {
4137 ha_alert("config: %s '%s': out of memory.\n",
4138 proxy_type_str(curproxy), curproxy->id);
4139 cfgerr++;
4140 }
4141 }
4142
4143 free_tcpcheck_vars(&rules->preset_vars);
4144 rules->list = &rs->rules;
4145 rules->flags = 0;
4146 }
4147 }
Willy Tarreau4cdac162021-03-05 10:48:42 +01004148 }
Willy Tarreau835daa12019-02-07 14:46:29 +01004149
Emeric Brun3b68b602022-08-18 15:53:21 +02004150 /*
4151 * We have just initialized the main proxies list
4152 * we must also configure the log-forward proxies list
4153 */
4154 if (init_proxies_list == proxies_list) {
4155 init_proxies_list = cfg_log_forward;
Emeric Brun8032a272022-08-22 10:25:11 +02004156 /* check if list is not null to avoid infinite loop */
4157 if (init_proxies_list)
4158 goto init_proxies_list_stage1;
Emeric Brun3b68b602022-08-18 15:53:21 +02004159 }
4160
Emeric Brund6e581d2022-09-13 16:16:30 +02004161 if (init_proxies_list == cfg_log_forward) {
4162 init_proxies_list = sink_proxies_list;
4163 /* check if list is not null to avoid infinite loop */
4164 if (init_proxies_list)
4165 goto init_proxies_list_stage1;
4166 }
4167
Willy Tarreau4cdac162021-03-05 10:48:42 +01004168 /***********************************************************/
4169 /* At this point, target names have already been resolved. */
4170 /***********************************************************/
Willy Tarreau835daa12019-02-07 14:46:29 +01004171
Willy Tarreau4cdac162021-03-05 10:48:42 +01004172 /* we must finish to initialize certain things on the servers */
Willy Tarreau835daa12019-02-07 14:46:29 +01004173
Willy Tarreau4cdac162021-03-05 10:48:42 +01004174 list_for_each_entry(newsrv, &servers_list, global_list) {
4175 /* initialize idle conns lists */
Miroslav Zagorac8a8f2702021-06-15 15:33:20 +02004176 if (srv_init_per_thr(newsrv) == -1) {
Willy Tarreau430bf4a2021-03-04 09:45:32 +01004177 ha_alert("parsing [%s:%d] : failed to allocate per-thread lists for server '%s'.\n",
4178 newsrv->conf.file, newsrv->conf.line, newsrv->id);
Willy Tarreau4cdac162021-03-05 10:48:42 +01004179 cfgerr++;
4180 continue;
4181 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01004182
Willy Tarreau4cdac162021-03-05 10:48:42 +01004183 if (newsrv->max_idle_conns != 0) {
Amaury Denoyelle3efee652021-03-08 17:31:39 +01004184 newsrv->curr_idle_thr = calloc(global.nbthread, sizeof(*newsrv->curr_idle_thr));
4185 if (!newsrv->curr_idle_thr) {
4186 ha_alert("parsing [%s:%d] : failed to allocate idle connection tasks for server '%s'.\n",
4187 newsrv->conf.file, newsrv->conf.line, newsrv->id);
4188 cfgerr++;
4189 continue;
4190 }
Remi Tricot-Le Breton47646202021-05-19 16:40:28 +02004191
Amaury Denoyelle3efee652021-03-08 17:31:39 +01004192 }
4193 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01004194
Willy Tarreaubeeabf52021-10-01 18:23:30 +02004195 idle_conn_task = task_new_anywhere();
Amaury Denoyelle3efee652021-03-08 17:31:39 +01004196 if (!idle_conn_task) {
4197 ha_alert("parsing : failed to allocate global idle connection task.\n");
4198 cfgerr++;
4199 }
4200 else {
4201 idle_conn_task->process = srv_cleanup_idle_conns;
4202 idle_conn_task->context = NULL;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01004203
Amaury Denoyelle3efee652021-03-08 17:31:39 +01004204 for (i = 0; i < global.nbthread; i++) {
Willy Tarreaubeeabf52021-10-01 18:23:30 +02004205 idle_conns[i].cleanup_task = task_new_on(i);
Amaury Denoyelle3efee652021-03-08 17:31:39 +01004206 if (!idle_conns[i].cleanup_task) {
4207 ha_alert("parsing : failed to allocate idle connection tasks for thread '%d'.\n", i);
4208 cfgerr++;
4209 break;
Willy Tarreau4cdac162021-03-05 10:48:42 +01004210 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01004211
Amaury Denoyelle3efee652021-03-08 17:31:39 +01004212 idle_conns[i].cleanup_task->process = srv_cleanup_toremove_conns;
4213 idle_conns[i].cleanup_task->context = NULL;
4214 HA_SPIN_INIT(&idle_conns[i].idle_conns_lock);
4215 MT_LIST_INIT(&idle_conns[i].toremove_conns);
Willy Tarreau835daa12019-02-07 14:46:29 +01004216 }
Willy Tarreau419ead82014-09-16 13:41:21 +02004217 }
4218
Willy Tarreau419ead82014-09-16 13:41:21 +02004219 /* perform the final checks before creating tasks */
4220
Emeric Brun3b68b602022-08-18 15:53:21 +02004221 /* starting to initialize the main proxies list */
4222 init_proxies_list = proxies_list;
4223
4224init_proxies_list_stage2:
4225 for (curproxy = init_proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02004226 struct listener *listener;
4227 unsigned int next_id;
Willy Tarreauc1a21672009-08-16 22:37:44 +02004228
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02004229 /* Configure SSL for each bind line.
4230 * Note: if configuration fails at some point, the ->ctx member
4231 * remains NULL so that listeners can later detach.
4232 */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004233 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau55d37912016-12-21 23:38:39 +01004234 if (bind_conf->xprt->prepare_bind_conf &&
4235 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02004236 cfgerr++;
Willy Tarreau7866e8e2023-01-12 18:39:42 +01004237 bind_conf->analysers |= curproxy->fe_req_ana;
Willy Tarreau882f2482023-01-12 18:52:23 +01004238 if (!bind_conf->maxaccept)
4239 bind_conf->maxaccept = global.tune.maxaccept ? global.tune.maxaccept : MAX_ACCEPT;
Willy Tarreau30836152023-01-12 19:10:17 +01004240 bind_conf->accept = session_accept_fd;
Willy Tarreaucfb7c2f2023-01-12 19:37:07 +01004241 if (curproxy->options & PR_O_TCP_NOLING)
4242 bind_conf->options |= BC_O_NOLINGER;
Willy Tarreau9bdcf422023-01-12 19:40:42 +01004243
4244 /* smart accept mode is automatic in HTTP mode */
4245 if ((curproxy->options2 & PR_O2_SMARTACC) ||
4246 ((curproxy->mode == PR_MODE_HTTP || (bind_conf->options & BC_O_USE_SSL)) &&
4247 !(curproxy->no_options2 & PR_O2_SMARTACC)))
4248 bind_conf->options |= BC_O_NOQUICKACK;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004249 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02004250
Willy Tarreaue6b98942007-10-29 01:09:36 +01004251 /* adjust this proxy's listeners */
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02004252 next_id = 1;
Willy Tarreau4348fad2012-09-20 16:48:07 +02004253 list_for_each_entry(listener, &curproxy->conf.listeners, by_fe) {
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02004254 if (!listener->luid) {
4255 /* listener ID not set, use automatic numbering with first
4256 * spare entry starting with next_luid.
4257 */
4258 next_id = get_next_id(&curproxy->conf.used_listener_id, next_id);
4259 listener->conf.id.key = listener->luid = next_id;
4260 eb32_insert(&curproxy->conf.used_listener_id, &listener->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02004261 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01004262 next_id++;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02004263
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02004264 /* enable separate counters */
4265 if (curproxy->options2 & PR_O2_SOCKSTAT) {
Willy Tarreauae9bea02016-11-25 14:44:52 +01004266 listener->counters = calloc(1, sizeof(*listener->counters));
Willy Tarreau19d14ef2012-10-29 16:51:55 +01004267 if (!listener->name)
4268 memprintf(&listener->name, "sock-%d", listener->luid);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02004269 }
Willy Tarreau81796be2012-09-22 19:11:47 +02004270
Amaury Denoyelleb59b8892022-01-25 17:48:47 +01004271#ifdef USE_QUIC
Willy Tarreau9e2682a2023-01-12 20:20:57 +01004272 if (listener->bind_conf->xprt == xprt_get(XPRT_QUIC)) {
Amaury Denoyelle996ca7d2022-11-14 16:17:13 +01004273 if (!global.cluster_secret) {
Frédéric Lécaille372508c2022-05-06 08:53:16 +02004274 diag_no_cluster_secret = 1;
Amaury Denoyelle996ca7d2022-11-14 16:17:13 +01004275 if (listener->bind_conf->options & BC_O_QUIC_FORCE_RETRY) {
4276 ha_alert("QUIC listener with quic-force-retry requires global cluster-secret to be set.\n");
4277 cfgerr++;
4278 }
4279 }
Amaury Denoyelle0aba11e2022-09-29 18:31:24 +02004280
Amaury Denoyellef68b2cb2022-01-25 16:21:47 +01004281 li_init_per_thr(listener);
4282 }
Amaury Denoyelleb59b8892022-01-25 17:48:47 +01004283#endif
Willy Tarreaue6b98942007-10-29 01:09:36 +01004284 }
4285
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004286 /* Release unused SSL configs */
4287 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau11ba4042022-05-20 15:56:32 +02004288 if (!(bind_conf->options & BC_O_USE_SSL) && bind_conf->xprt->destroy_bind_conf)
Willy Tarreau795cdab2016-12-22 17:30:54 +01004289 bind_conf->xprt->destroy_bind_conf(bind_conf);
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004290 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02004291
Willy Tarreau918ff602011-07-25 16:33:49 +02004292 /* create the task associated with the proxy */
Willy Tarreaubeeabf52021-10-01 18:23:30 +02004293 curproxy->task = task_new_anywhere();
Willy Tarreau918ff602011-07-25 16:33:49 +02004294 if (curproxy->task) {
4295 curproxy->task->context = curproxy;
4296 curproxy->task->process = manage_proxy;
Christopher Faulet56717802021-10-13 10:10:09 +02004297 curproxy->flags |= PR_FL_READY;
Willy Tarreau918ff602011-07-25 16:33:49 +02004298 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004299 ha_alert("Proxy '%s': no more memory when trying to allocate the management task\n",
4300 curproxy->id);
Willy Tarreau918ff602011-07-25 16:33:49 +02004301 cfgerr++;
4302 }
Willy Tarreaub369a042014-09-16 13:21:03 +02004303 }
4304
Emeric Brun3b68b602022-08-18 15:53:21 +02004305 /*
4306 * We have just initialized the main proxies list
4307 * we must also configure the log-forward proxies list
4308 */
4309 if (init_proxies_list == proxies_list) {
4310 init_proxies_list = cfg_log_forward;
Emeric Brun8032a272022-08-22 10:25:11 +02004311 /* check if list is not null to avoid infinite loop */
4312 if (init_proxies_list)
4313 goto init_proxies_list_stage2;
Emeric Brun3b68b602022-08-18 15:53:21 +02004314 }
4315
Amaury Denoyelle28ea31c2022-11-14 16:18:46 +01004316 if (diag_no_cluster_secret) {
4317 ha_diag_warning("Generating a random cluster secret. "
4318 "You should define your own one in the configuration to ensure consistency "
4319 "after reload/restart or across your whole cluster.\n");
4320 }
Frédéric Lécaille372508c2022-05-06 08:53:16 +02004321
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01004322 /*
4323 * Recount currently required checks.
4324 */
4325
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004326 for (curproxy=proxies_list; curproxy; curproxy=curproxy->next) {
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01004327 int optnum;
4328
Willy Tarreau66aa61f2009-01-18 21:44:07 +01004329 for (optnum = 0; cfg_opts[optnum].name; optnum++)
4330 if (curproxy->options & cfg_opts[optnum].val)
4331 global.last_checks |= cfg_opts[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01004332
Willy Tarreau66aa61f2009-01-18 21:44:07 +01004333 for (optnum = 0; cfg_opts2[optnum].name; optnum++)
4334 if (curproxy->options2 & cfg_opts2[optnum].val)
4335 global.last_checks |= cfg_opts2[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01004336 }
4337
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02004338 if (cfg_peers) {
4339 struct peers *curpeers = cfg_peers, **last;
Willy Tarreau122541c2011-09-07 21:24:49 +02004340 struct peer *p, *pb;
4341
Willy Tarreau1e273012015-05-01 19:15:17 +02004342 /* Remove all peers sections which don't have a valid listener,
4343 * which are not used by any table, or which are bound to more
4344 * than one process.
Willy Tarreau122541c2011-09-07 21:24:49 +02004345 */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02004346 last = &cfg_peers;
Willy Tarreau122541c2011-09-07 21:24:49 +02004347 while (*last) {
Frédéric Lécaille36d15652022-10-17 14:58:19 +02004348 struct peer *peer;
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01004349 struct stktable *t;
Willy Tarreau122541c2011-09-07 21:24:49 +02004350 curpeers = *last;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004351
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02004352 if (curpeers->disabled) {
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004353 /* the "disabled" keyword was present */
4354 if (curpeers->peers_fe)
4355 stop_proxy(curpeers->peers_fe);
4356 curpeers->peers_fe = NULL;
4357 }
Frédéric Lécaille5a4fe5a2019-10-04 08:30:04 +02004358 else if (!curpeers->peers_fe || !curpeers->peers_fe->id) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004359 ha_warning("Removing incomplete section 'peers %s' (no peer named '%s').\n",
4360 curpeers->id, localpeer);
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01004361 if (curpeers->peers_fe)
4362 stop_proxy(curpeers->peers_fe);
4363 curpeers->peers_fe = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004364 }
4365 else {
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01004366 /* Initializes the transport layer of the server part of all the peers belonging to
4367 * <curpeers> section if required.
4368 * Note that ->srv is used by the local peer of a new process to connect to the local peer
4369 * of an old process.
4370 */
Christopher Faulet56717802021-10-13 10:10:09 +02004371 curpeers->peers_fe->flags |= PR_FL_READY;
Frédéric Lécaille1055e682018-04-26 14:35:21 +02004372 p = curpeers->remote;
4373 while (p) {
Frédéric Lécaille355b2032019-01-11 14:06:12 +01004374 if (p->srv) {
Christopher Fauletf61f33a2020-03-27 18:55:49 +01004375 if (p->srv->use_ssl == 1 && xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
Frédéric Lécaille355b2032019-01-11 14:06:12 +01004376 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(p->srv);
4377 }
Frédéric Lécaille1055e682018-04-26 14:35:21 +02004378 p = p->next;
4379 }
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01004380 /* Configure the SSL bindings of the local peer if required. */
4381 if (!LIST_ISEMPTY(&curpeers->peers_fe->conf.bind)) {
4382 struct list *l;
4383 struct bind_conf *bind_conf;
Willy Tarreaua22db652023-04-22 23:52:17 +02004384 int ret;
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01004385
4386 l = &curpeers->peers_fe->conf.bind;
4387 bind_conf = LIST_ELEM(l->n, typeof(bind_conf), by_fe);
Willy Tarreaud2494e02022-07-05 16:00:56 +02004388
Christopher Faulet1b6fa7f2022-07-26 19:03:51 +02004389 if (curpeers->local->srv) {
4390 if (curpeers->local->srv->use_ssl == 1 && !(bind_conf->options & BC_O_USE_SSL)) {
4391 ha_warning("Peers section '%s': local peer have a non-SSL listener and a SSL server configured at line %s:%d.\n",
4392 curpeers->peers_fe->id, curpeers->local->conf.file, curpeers->local->conf.line);
4393 }
4394 else if (curpeers->local->srv->use_ssl != 1 && (bind_conf->options & BC_O_USE_SSL)) {
4395 ha_warning("Peers section '%s': local peer have a SSL listener and a non-SSL server configured at line %s:%d.\n",
4396 curpeers->peers_fe->id, curpeers->local->conf.file, curpeers->local->conf.line);
4397 }
4398 }
4399
Willy Tarreaua22db652023-04-22 23:52:17 +02004400 /* finish the bind setup */
4401 ret = bind_complete_thread_setup(bind_conf, &err_code);
4402 if (ret != 0) {
4403 cfgerr += ret;
4404 if (err_code & ERR_FATAL)
4405 goto out;
Willy Tarreaud2494e02022-07-05 16:00:56 +02004406 }
4407
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01004408 if (bind_conf->xprt->prepare_bind_conf &&
4409 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
4410 cfgerr++;
4411 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02004412 if (!peers_init_sync(curpeers) || !peers_alloc_dcache(curpeers)) {
Willy Tarreaud9443442018-10-15 11:18:03 +02004413 ha_alert("Peers section '%s': out of memory, giving up on peers.\n",
4414 curpeers->id);
4415 cfgerr++;
4416 break;
4417 }
Willy Tarreau122541c2011-09-07 21:24:49 +02004418 last = &curpeers->next;
Frédéric Lécaille36d15652022-10-17 14:58:19 +02004419
4420 /* Ignore the peer shard greater than the number of peer shard for this section.
4421 * Also ignore the peer shard of the local peer.
4422 */
4423 for (peer = curpeers->remote; peer; peer = peer->next) {
4424 if (peer == curpeers->local) {
4425 if (peer->srv->shard) {
4426 ha_warning("Peers section '%s': shard ignored for '%s' local peer\n",
4427 curpeers->id, peer->id);
4428 peer->srv->shard = 0;
4429 }
4430 }
4431 else if (peer->srv->shard > curpeers->nb_shards) {
4432 ha_warning("Peers section '%s': shard ignored for '%s' local peer because "
4433 "%d shard value is greater than the section number of shards (%d)\n",
4434 curpeers->id, peer->id, peer->srv->shard, curpeers->nb_shards);
4435 peer->srv->shard = 0;
4436 }
4437 }
4438
Willy Tarreau122541c2011-09-07 21:24:49 +02004439 continue;
4440 }
4441
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004442 /* clean what has been detected above */
Willy Tarreau122541c2011-09-07 21:24:49 +02004443 p = curpeers->remote;
4444 while (p) {
4445 pb = p->next;
4446 free(p->id);
4447 free(p);
4448 p = pb;
4449 }
4450
4451 /* Destroy and unlink this curpeers section.
4452 * Note: curpeers is backed up into *last.
4453 */
4454 free(curpeers->id);
4455 curpeers = curpeers->next;
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01004456 /* Reset any refereance to this peers section in the list of stick-tables */
4457 for (t = stktables_list; t; t = t->next) {
4458 if (t->peers.p && t->peers.p == *last)
4459 t->peers.p = NULL;
4460 }
Willy Tarreau122541c2011-09-07 21:24:49 +02004461 free(*last);
4462 *last = curpeers;
4463 }
4464 }
4465
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004466 for (t = stktables_list; t; t = t->next) {
4467 if (t->proxy)
4468 continue;
4469 if (!stktable_init(t)) {
4470 ha_alert("Proxy '%s': failed to initialize stick-table.\n", t->id);
4471 cfgerr++;
4472 }
4473 }
4474
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004475 /* initialize stick-tables on backend capable proxies. This must not
4476 * be done earlier because the data size may be discovered while parsing
4477 * other proxies.
4478 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004479 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Christopher Fauletdfd10ab2021-10-06 14:24:19 +02004480 if ((curproxy->flags & PR_FL_DISABLED) || !curproxy->table)
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004481 continue;
4482
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004483 if (!stktable_init(curproxy->table)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004484 ha_alert("Proxy '%s': failed to initialize stick-table.\n", curproxy->id);
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004485 cfgerr++;
4486 }
4487 }
4488
Simon Horman0d16a402015-01-30 11:22:58 +09004489 if (mailers) {
4490 struct mailers *curmailers = mailers, **last;
4491 struct mailer *m, *mb;
4492
4493 /* Remove all mailers sections which don't have a valid listener.
4494 * This can happen when a mailers section is never referenced.
4495 */
4496 last = &mailers;
4497 while (*last) {
4498 curmailers = *last;
4499 if (curmailers->users) {
4500 last = &curmailers->next;
4501 continue;
4502 }
4503
Christopher Faulet767a84b2017-11-24 16:50:31 +01004504 ha_warning("Removing incomplete section 'mailers %s'.\n",
4505 curmailers->id);
Simon Horman0d16a402015-01-30 11:22:58 +09004506
4507 m = curmailers->mailer_list;
4508 while (m) {
4509 mb = m->next;
4510 free(m->id);
4511 free(m);
4512 m = mb;
4513 }
4514
4515 /* Destroy and unlink this curmailers section.
4516 * Note: curmailers is backed up into *last.
4517 */
4518 free(curmailers->id);
4519 curmailers = curmailers->next;
4520 free(*last);
4521 *last = curmailers;
4522 }
4523 }
4524
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004525 /* Update server_state_file_name to backend name if backend is supposed to use
4526 * a server-state file locally defined and none has been provided */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004527 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004528 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_LOCAL &&
4529 curproxy->server_state_file_name == NULL)
4530 curproxy->server_state_file_name = strdup(curproxy->id);
4531 }
4532
Emeric Brun750fe792020-12-23 16:51:12 +01004533 list_for_each_entry(curr_resolvers, &sec_resolvers, list) {
Ben Draut054fbee2018-04-13 15:43:04 -06004534 if (LIST_ISEMPTY(&curr_resolvers->nameservers)) {
Amaury Denoyelle11124302021-06-04 18:22:08 +02004535 ha_warning("resolvers '%s' [%s:%d] has no nameservers configured!\n",
Ben Draut054fbee2018-04-13 15:43:04 -06004536 curr_resolvers->id, curr_resolvers->conf.file,
4537 curr_resolvers->conf.line);
4538 err_code |= ERR_WARN;
4539 }
4540 }
4541
William Lallemand48b4bb42017-10-23 14:36:34 +02004542 list_for_each_entry(postparser, &postparsers, list) {
4543 if (postparser->func)
4544 cfgerr += postparser->func();
4545 }
4546
Willy Tarreaubb925012009-07-23 13:36:36 +02004547 if (cfgerr > 0)
4548 err_code |= ERR_ALERT | ERR_FATAL;
4549 out:
4550 return err_code;
Willy Tarreaubaaee002006-06-26 02:48:02 +02004551}
4552
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004553/*
4554 * Registers the CFG keyword list <kwl> as a list of valid keywords for next
4555 * parsing sessions.
4556 */
4557void cfg_register_keywords(struct cfg_kw_list *kwl)
4558{
Willy Tarreau2b718102021-04-21 07:32:39 +02004559 LIST_APPEND(&cfg_keywords.list, &kwl->list);
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004560}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004561
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004562/*
4563 * Unregisters the CFG keyword list <kwl> from the list of valid keywords.
4564 */
4565void cfg_unregister_keywords(struct cfg_kw_list *kwl)
4566{
Willy Tarreau2b718102021-04-21 07:32:39 +02004567 LIST_DELETE(&kwl->list);
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004568 LIST_INIT(&kwl->list);
4569}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004570
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004571/* this function register new section in the haproxy configuration file.
4572 * <section_name> is the name of this new section and <section_parser>
4573 * is the called parser. If two section declaration have the same name,
4574 * only the first declared is used.
4575 */
4576int cfg_register_section(char *section_name,
William Lallemandd2ff56d2017-10-16 11:06:50 +02004577 int (*section_parser)(const char *, int, char **, int),
4578 int (*post_section_parser)())
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004579{
4580 struct cfg_section *cs;
4581
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004582 list_for_each_entry(cs, &sections, list) {
4583 if (strcmp(cs->section_name, section_name) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004584 ha_alert("register section '%s': already registered.\n", section_name);
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004585 return 0;
4586 }
4587 }
4588
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004589 cs = calloc(1, sizeof(*cs));
4590 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004591 ha_alert("register section '%s': out of memory.\n", section_name);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004592 return 0;
4593 }
4594
4595 cs->section_name = section_name;
4596 cs->section_parser = section_parser;
William Lallemandd2ff56d2017-10-16 11:06:50 +02004597 cs->post_section_parser = post_section_parser;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004598
Willy Tarreau2b718102021-04-21 07:32:39 +02004599 LIST_APPEND(&sections, &cs->list);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004600
4601 return 1;
4602}
4603
William Lallemand48b4bb42017-10-23 14:36:34 +02004604/* this function register a new function which will be called once the haproxy
4605 * configuration file has been parsed. It's useful to check dependencies
4606 * between sections or to resolve items once everything is parsed.
4607 */
4608int cfg_register_postparser(char *name, int (*func)())
4609{
4610 struct cfg_postparser *cp;
4611
4612 cp = calloc(1, sizeof(*cp));
4613 if (!cp) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004614 ha_alert("register postparser '%s': out of memory.\n", name);
William Lallemand48b4bb42017-10-23 14:36:34 +02004615 return 0;
4616 }
4617 cp->name = name;
4618 cp->func = func;
4619
Willy Tarreau2b718102021-04-21 07:32:39 +02004620 LIST_APPEND(&postparsers, &cp->list);
William Lallemand48b4bb42017-10-23 14:36:34 +02004621
4622 return 1;
4623}
4624
Willy Tarreaubaaee002006-06-26 02:48:02 +02004625/*
David Carlier845efb52015-09-25 11:49:18 +01004626 * free all config section entries
4627 */
4628void cfg_unregister_sections(void)
4629{
4630 struct cfg_section *cs, *ics;
4631
4632 list_for_each_entry_safe(cs, ics, &sections, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004633 LIST_DELETE(&cs->list);
David Carlier845efb52015-09-25 11:49:18 +01004634 free(cs);
4635 }
4636}
4637
Christopher Faulet7110b402016-10-26 11:09:44 +02004638void cfg_backup_sections(struct list *backup_sections)
4639{
4640 struct cfg_section *cs, *ics;
4641
4642 list_for_each_entry_safe(cs, ics, &sections, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004643 LIST_DELETE(&cs->list);
4644 LIST_APPEND(backup_sections, &cs->list);
Christopher Faulet7110b402016-10-26 11:09:44 +02004645 }
4646}
4647
4648void cfg_restore_sections(struct list *backup_sections)
4649{
4650 struct cfg_section *cs, *ics;
4651
4652 list_for_each_entry_safe(cs, ics, backup_sections, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004653 LIST_DELETE(&cs->list);
4654 LIST_APPEND(&sections, &cs->list);
Christopher Faulet7110b402016-10-26 11:09:44 +02004655 }
4656}
4657
Willy Tarreauca1acd62022-03-29 15:02:44 +02004658/* dumps all registered keywords by section on stdout */
4659void cfg_dump_registered_keywords()
4660{
William Lallemand44979ad2023-02-13 15:24:01 +01004661 /* CFG_GLOBAL, CFG_LISTEN, CFG_USERLIST, CFG_PEERS, CFG_CRTLIST */
4662 const char* sect_names[] = { "", "global", "listen", "userlist", "peers", "crt-list", 0 };
Willy Tarreauca1acd62022-03-29 15:02:44 +02004663 int section;
4664 int index;
4665
4666 for (section = 1; sect_names[section]; section++) {
4667 struct cfg_kw_list *kwl;
Willy Tarreaud9058262022-03-30 11:21:32 +02004668 const struct cfg_keyword *kwp, *kwn;
Willy Tarreauca1acd62022-03-29 15:02:44 +02004669
4670 printf("%s\n", sect_names[section]);
Willy Tarreaud9058262022-03-30 11:21:32 +02004671
4672 for (kwn = kwp = NULL;; kwp = kwn) {
4673 list_for_each_entry(kwl, &cfg_keywords.list, list) {
4674 for (index = 0; kwl->kw[index].kw != NULL; index++)
4675 if (kwl->kw[index].section == section &&
4676 strordered(kwp ? kwp->kw : NULL, kwl->kw[index].kw, kwn != kwp ? kwn->kw : NULL))
4677 kwn = &kwl->kw[index];
4678 }
4679 if (kwn == kwp)
4680 break;
4681 printf("\t%s\n", kwn->kw);
Willy Tarreauca1acd62022-03-29 15:02:44 +02004682 }
4683
4684 if (section == CFG_LISTEN) {
4685 /* there are plenty of other keywords there */
4686 extern struct list tcp_req_conn_keywords, tcp_req_sess_keywords,
4687 tcp_req_cont_keywords, tcp_res_cont_keywords;
4688 extern struct bind_kw_list bind_keywords;
Willy Tarreauca1acd62022-03-29 15:02:44 +02004689 extern struct srv_kw_list srv_keywords;
Willy Tarreauca1acd62022-03-29 15:02:44 +02004690 struct bind_kw_list *bkwl;
4691 struct srv_kw_list *skwl;
Willy Tarreaud9058262022-03-30 11:21:32 +02004692 const struct bind_kw *bkwp, *bkwn;
4693 const struct srv_kw *skwp, *skwn;
Willy Tarreaud9058262022-03-30 11:21:32 +02004694 const struct cfg_opt *coptp, *coptn;
Willy Tarreauca1acd62022-03-29 15:02:44 +02004695
William Lallemand44979ad2023-02-13 15:24:01 +01004696 /* display the non-ssl keywords */
Willy Tarreaud9058262022-03-30 11:21:32 +02004697 for (bkwn = bkwp = NULL;; bkwp = bkwn) {
4698 list_for_each_entry(bkwl, &bind_keywords.list, list) {
William Lallemand44979ad2023-02-13 15:24:01 +01004699 if (strcmp(bkwl->scope, "SSL") == 0) /* skip SSL keywords */
4700 continue;
4701 for (index = 0; bkwl->kw[index].kw != NULL; index++) {
Willy Tarreaud9058262022-03-30 11:21:32 +02004702 if (strordered(bkwp ? bkwp->kw : NULL,
4703 bkwl->kw[index].kw,
4704 bkwn != bkwp ? bkwn->kw : NULL))
4705 bkwn = &bkwl->kw[index];
William Lallemand44979ad2023-02-13 15:24:01 +01004706 }
Willy Tarreauca1acd62022-03-29 15:02:44 +02004707 }
Willy Tarreaud9058262022-03-30 11:21:32 +02004708 if (bkwn == bkwp)
4709 break;
4710
4711 if (!bkwn->skip)
4712 printf("\tbind <addr> %s\n", bkwn->kw);
4713 else
4714 printf("\tbind <addr> %s +%d\n", bkwn->kw, bkwn->skip);
Willy Tarreauca1acd62022-03-29 15:02:44 +02004715 }
Willy Tarreauca1acd62022-03-29 15:02:44 +02004716#if defined(USE_OPENSSL)
William Lallemand44979ad2023-02-13 15:24:01 +01004717 /* displays the "ssl" keywords */
4718 for (bkwn = bkwp = NULL;; bkwp = bkwn) {
4719 list_for_each_entry(bkwl, &bind_keywords.list, list) {
4720 if (strcmp(bkwl->scope, "SSL") != 0) /* skip non-SSL keywords */
4721 continue;
4722 for (index = 0; bkwl->kw[index].kw != NULL; index++) {
4723 if (strordered(bkwp ? bkwp->kw : NULL,
4724 bkwl->kw[index].kw,
4725 bkwn != bkwp ? bkwn->kw : NULL))
4726 bkwn = &bkwl->kw[index];
4727 }
Willy Tarreaud9058262022-03-30 11:21:32 +02004728 }
William Lallemand44979ad2023-02-13 15:24:01 +01004729 if (bkwn == bkwp)
Willy Tarreaud9058262022-03-30 11:21:32 +02004730 break;
William Lallemand44979ad2023-02-13 15:24:01 +01004731
4732 if (strcmp(bkwn->kw, "ssl") == 0) /* skip "bind <addr> ssl ssl" */
4733 continue;
4734
4735 if (!bkwn->skip)
4736 printf("\tbind <addr> ssl %s\n", bkwn->kw);
Willy Tarreauca1acd62022-03-29 15:02:44 +02004737 else
William Lallemand44979ad2023-02-13 15:24:01 +01004738 printf("\tbind <addr> ssl %s +%d\n", bkwn->kw, bkwn->skip);
Willy Tarreauca1acd62022-03-29 15:02:44 +02004739 }
4740#endif
Willy Tarreaud9058262022-03-30 11:21:32 +02004741 for (skwn = skwp = NULL;; skwp = skwn) {
4742 list_for_each_entry(skwl, &srv_keywords.list, list) {
4743 for (index = 0; skwl->kw[index].kw != NULL; index++)
4744 if (strordered(skwp ? skwp->kw : NULL,
4745 skwl->kw[index].kw,
4746 skwn != skwp ? skwn->kw : NULL))
4747 skwn = &skwl->kw[index];
Willy Tarreauca1acd62022-03-29 15:02:44 +02004748 }
Willy Tarreaud9058262022-03-30 11:21:32 +02004749 if (skwn == skwp)
4750 break;
Willy Tarreauca1acd62022-03-29 15:02:44 +02004751
Willy Tarreaud9058262022-03-30 11:21:32 +02004752 if (!skwn->skip)
4753 printf("\tserver <name> <addr> %s\n", skwn->kw);
4754 else
4755 printf("\tserver <name> <addr> %s +%d\n", skwn->kw, skwn->skip);
Willy Tarreauca1acd62022-03-29 15:02:44 +02004756 }
4757
Willy Tarreaud9058262022-03-30 11:21:32 +02004758 for (coptn = coptp = NULL;; coptp = coptn) {
4759 for (index = 0; cfg_opts[index].name; index++)
4760 if (strordered(coptp ? coptp->name : NULL,
4761 cfg_opts[index].name,
4762 coptn != coptp ? coptn->name : NULL))
4763 coptn = &cfg_opts[index];
4764
4765 for (index = 0; cfg_opts2[index].name; index++)
4766 if (strordered(coptp ? coptp->name : NULL,
4767 cfg_opts2[index].name,
4768 coptn != coptp ? coptn->name : NULL))
4769 coptn = &cfg_opts2[index];
4770 if (coptn == coptp)
4771 break;
4772
4773 printf("\toption %s [ ", coptn->name);
4774 if (coptn->cap & PR_CAP_FE)
Willy Tarreauca1acd62022-03-29 15:02:44 +02004775 printf("FE ");
Willy Tarreaud9058262022-03-30 11:21:32 +02004776 if (coptn->cap & PR_CAP_BE)
Willy Tarreauca1acd62022-03-29 15:02:44 +02004777 printf("BE ");
Willy Tarreaud9058262022-03-30 11:21:32 +02004778 if (coptn->mode == PR_MODE_HTTP)
Willy Tarreauca1acd62022-03-29 15:02:44 +02004779 printf("HTTP ");
4780 printf("]\n");
4781 }
4782
Willy Tarreaud9058262022-03-30 11:21:32 +02004783 dump_act_rules(&tcp_req_conn_keywords, "\ttcp-request connection ");
4784 dump_act_rules(&tcp_req_sess_keywords, "\ttcp-request session ");
4785 dump_act_rules(&tcp_req_cont_keywords, "\ttcp-request content ");
4786 dump_act_rules(&tcp_res_cont_keywords, "\ttcp-response content ");
4787 dump_act_rules(&http_req_keywords.list, "\thttp-request ");
4788 dump_act_rules(&http_res_keywords.list, "\thttp-response ");
4789 dump_act_rules(&http_after_res_keywords.list, "\thttp-after-response ");
Willy Tarreauca1acd62022-03-29 15:02:44 +02004790 }
William Lallemand44979ad2023-02-13 15:24:01 +01004791 if (section == CFG_CRTLIST) {
4792 /* displays the keyword available for the crt-lists */
4793 extern struct ssl_crtlist_kw ssl_crtlist_kws[] __maybe_unused;
4794 const struct ssl_crtlist_kw *sbkwp __maybe_unused, *sbkwn __maybe_unused;
4795
4796#if defined(USE_OPENSSL)
4797 for (sbkwn = sbkwp = NULL;; sbkwp = sbkwn) {
4798 for (index = 0; ssl_crtlist_kws[index].kw != NULL; index++) {
4799 if (strordered(sbkwp ? sbkwp->kw : NULL,
4800 ssl_crtlist_kws[index].kw,
4801 sbkwn != sbkwp ? sbkwn->kw : NULL))
4802 sbkwn = &ssl_crtlist_kws[index];
4803 }
4804 if (sbkwn == sbkwp)
4805 break;
4806 if (!sbkwn->skip)
4807 printf("\t%s\n", sbkwn->kw);
4808 else
4809 printf("\t%s +%d\n", sbkwn->kw, sbkwn->skip);
4810 }
4811#endif
4812
4813 }
Willy Tarreauca1acd62022-03-29 15:02:44 +02004814 }
4815}
4816
Willy Tarreaue6552512018-11-26 11:33:13 +01004817/* these are the config sections handled by default */
4818REGISTER_CONFIG_SECTION("listen", cfg_parse_listen, NULL);
4819REGISTER_CONFIG_SECTION("frontend", cfg_parse_listen, NULL);
4820REGISTER_CONFIG_SECTION("backend", cfg_parse_listen, NULL);
4821REGISTER_CONFIG_SECTION("defaults", cfg_parse_listen, NULL);
4822REGISTER_CONFIG_SECTION("global", cfg_parse_global, NULL);
4823REGISTER_CONFIG_SECTION("userlist", cfg_parse_users, NULL);
4824REGISTER_CONFIG_SECTION("peers", cfg_parse_peers, NULL);
4825REGISTER_CONFIG_SECTION("mailers", cfg_parse_mailers, NULL);
4826REGISTER_CONFIG_SECTION("namespace_list", cfg_parse_netns, NULL);
Willy Tarreau659fbf02016-05-26 17:55:28 +02004827
Willy Tarreau8a022d52021-04-27 20:29:11 +02004828static struct cfg_kw_list cfg_kws = {{ },{
4829 { CFG_GLOBAL, "default-path", cfg_parse_global_def_path },
4830 { /* END */ }
4831}};
4832
4833INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
4834
David Carlier845efb52015-09-25 11:49:18 +01004835/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02004836 * Local variables:
4837 * c-indent-level: 8
4838 * c-basic-offset: 8
4839 * End:
4840 */