blob: d210b8413bad9f91f969a47489c6d729e03a29f3 [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 Tarreaue36b38e2022-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 Tarreaue36b38e2022-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 Tarreaue36b38e2022-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>
37#include <fcntl.h>
38#include <unistd.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020039
Willy Tarreaudcc048a2020-06-04 19:11:43 +020040#include <haproxy/acl.h>
Christopher Faulet42c6cf92021-03-25 17:19:04 +010041#include <haproxy/action.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020042#include <haproxy/api.h>
Willy Tarreau732525f2021-05-06 15:49:04 +020043#include <haproxy/arg.h>
Willy Tarreauac13aea2020-06-04 10:36:03 +020044#include <haproxy/auth.h>
Willy Tarreau49801602020-06-04 22:50:02 +020045#include <haproxy/backend.h>
Willy Tarreau278161c2020-06-04 11:18:28 +020046#include <haproxy/capture.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>
Amaury Denoyellea6f9c5d2021-04-23 16:58:08 +020051#ifdef USE_CPU_AFFINITY
Amaury Denoyellec90932b2021-04-14 16:16:03 +020052#include <haproxy/cpuset.h>
Amaury Denoyellea6f9c5d2021-04-23 16:58:08 +020053#endif
Willy Tarreau7ea393d2020-06-04 18:02:10 +020054#include <haproxy/connection.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020055#include <haproxy/errors.h>
Willy Tarreauc7babd82020-06-04 21:29:29 +020056#include <haproxy/filters.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020057#include <haproxy/frontend.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020058#include <haproxy/global.h>
Willy Tarreauc2b1ff02020-06-04 21:21:03 +020059#include <haproxy/http_ana.h>
Willy Tarreauc761f842020-06-04 11:40:28 +020060#include <haproxy/http_rules.h>
Willy Tarreaufbe8da32020-06-04 14:34:27 +020061#include <haproxy/lb_chash.h>
Willy Tarreaub5fc3bf2020-06-04 14:37:38 +020062#include <haproxy/lb_fas.h>
Willy Tarreau02549412020-06-04 14:41:04 +020063#include <haproxy/lb_fwlc.h>
Willy Tarreau546ba422020-06-04 14:45:03 +020064#include <haproxy/lb_fwrr.h>
Willy Tarreau28671592020-06-04 20:22:59 +020065#include <haproxy/lb_map.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020066#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020067#include <haproxy/log.h>
Emeric Brunfd667082022-09-13 16:16:30 +020068#include <haproxy/sink.h>
Willy Tarreaucee013e2020-06-05 11:40:38 +020069#include <haproxy/mailers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020070#include <haproxy/namespace.h>
Willy Tarreau8efbdfb2020-06-04 11:29:21 +020071#include <haproxy/obj_type-t.h>
Willy Tarreau644358e2023-04-19 10:41:55 +020072#include <haproxy/openssl-compat.h>
Willy Tarreau3c2a7c22020-06-04 18:38:21 +020073#include <haproxy/peers-t.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020074#include <haproxy/peers.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020075#include <haproxy/pool.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020076#include <haproxy/protocol.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020077#include <haproxy/proxy.h>
Emeric Brunc9437992021-02-12 19:42:55 +010078#include <haproxy/resolvers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020079#include <haproxy/sample.h>
80#include <haproxy/server.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020081#include <haproxy/session.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020082#include <haproxy/stats-t.h>
Willy Tarreau872f2ea2020-06-04 18:46:44 +020083#include <haproxy/stick_table.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020084#include <haproxy/stream.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020085#include <haproxy/task.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020086#include <haproxy/tcp_rules.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020087#include <haproxy/thread.h>
88#include <haproxy/time.h>
89#include <haproxy/tools.h>
90#include <haproxy/uri_auth-t.h>
Frédéric Lécaille884f2e92020-11-23 14:23:21 +010091#include <haproxy/xprt_quic.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020092
93
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +010094/* Used to chain configuration sections definitions. This list
95 * stores struct cfg_section
96 */
97struct list sections = LIST_HEAD_INIT(sections);
98
William Lallemand48b4bb42017-10-23 14:36:34 +020099struct list postparsers = LIST_HEAD_INIT(postparsers);
100
Eric Salama1b8dacc2021-03-16 15:12:17 +0100101extern struct proxy *mworker_proxy;
102
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100103char *cursection = NULL;
Willy Tarreauc8d5b952019-02-27 17:25:52 +0100104int cfg_maxpconn = 0; /* # of simultaneous connections per proxy (-N) */
Willy Tarreau5af24ef2009-03-15 15:23:16 +0100105int cfg_maxconn = 0; /* # of simultaneous connections, (-n) */
Christopher Faulet79bdef32016-11-04 22:36:15 +0100106char *cfg_scope = NULL; /* the current scope during the configuration parsing */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200107
Willy Tarreau8a022d52021-04-27 20:29:11 +0200108/* how to handle default paths */
109static enum default_path_mode {
110 DEFAULT_PATH_CURRENT = 0, /* "current": paths are relative to CWD (this is the default) */
111 DEFAULT_PATH_CONFIG, /* "config": paths are relative to config file */
112 DEFAULT_PATH_PARENT, /* "parent": paths are relative to config file's ".." */
113 DEFAULT_PATH_ORIGIN, /* "origin": paths are relative to default_path_origin */
114} default_path_mode;
115
116static char initial_cwd[PATH_MAX];
117static char current_cwd[PATH_MAX];
118
Willy Tarreau5b2c3362008-07-09 19:39:06 +0200119/* List head of all known configuration keywords */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100120struct cfg_kw_list cfg_keywords = {
Willy Tarreau5b2c3362008-07-09 19:39:06 +0200121 .list = LIST_HEAD_INIT(cfg_keywords.list)
122};
123
Willy Tarreau4b103022021-02-12 17:59:10 +0100124/* nested if/elif/else/endif block states */
125enum nested_cond_state {
126 NESTED_COND_IF_TAKE, // "if" with a true condition
127 NESTED_COND_IF_DROP, // "if" with a false condition
128 NESTED_COND_IF_SKIP, // "if" masked by an outer false condition
129
130 NESTED_COND_ELIF_TAKE, // "elif" with a true condition from a false one
131 NESTED_COND_ELIF_DROP, // "elif" with a false condition from a false one
132 NESTED_COND_ELIF_SKIP, // "elif" masked by an outer false condition or a previously taken if
133
134 NESTED_COND_ELSE_TAKE, // taken "else" after an if false condition
135 NESTED_COND_ELSE_DROP, // "else" masked by outer false condition or an if true condition
136};
137
138/* 100 levels of nested conditions should already be sufficient */
139#define MAXNESTEDCONDS 100
140
Willy Tarreau732525f2021-05-06 15:49:04 +0200141/* supported conditional predicates for .if/.elif */
142enum cond_predicate {
143 CFG_PRED_NONE, // none
Willy Tarreau42ed14b2021-05-06 15:55:14 +0200144 CFG_PRED_DEFINED, // "defined"
Willy Tarreau58ca7062021-05-06 16:34:23 +0200145 CFG_PRED_FEATURE, // "feature"
Willy Tarreau6492e872021-05-06 16:10:09 +0200146 CFG_PRED_STREQ, // "streq"
147 CFG_PRED_STRNEQ, // "strneq"
Willy Tarreau0b7c78a2021-05-06 16:53:26 +0200148 CFG_PRED_VERSION_ATLEAST, // "version_atleast"
149 CFG_PRED_VERSION_BEFORE, // "version_before"
Willy Tarreau732525f2021-05-06 15:49:04 +0200150};
151
152struct cond_pred_kw {
153 const char *word; // NULL marks the end of the list
154 enum cond_predicate prd; // one of the CFG_PRED_* above
155 uint64_t arg_mask; // mask of supported arguments (strings only)
156};
157
158/* supported condition predicates */
159const struct cond_pred_kw cond_predicates[] = {
Willy Tarreau42ed14b2021-05-06 15:55:14 +0200160 { "defined", CFG_PRED_DEFINED, ARG1(1, STR) },
Willy Tarreau58ca7062021-05-06 16:34:23 +0200161 { "feature", CFG_PRED_FEATURE, ARG1(1, STR) },
Willy Tarreau6492e872021-05-06 16:10:09 +0200162 { "streq", CFG_PRED_STREQ, ARG2(2, STR, STR) },
163 { "strneq", CFG_PRED_STRNEQ, ARG2(2, STR, STR) },
Willy Tarreau0b7c78a2021-05-06 16:53:26 +0200164 { "version_atleast", CFG_PRED_VERSION_ATLEAST, ARG1(1, STR) },
165 { "version_before", CFG_PRED_VERSION_BEFORE, ARG1(1, STR) },
Willy Tarreau732525f2021-05-06 15:49:04 +0200166 { NULL, CFG_PRED_NONE, 0 }
167};
168
Willy Tarreaubaaee002006-06-26 02:48:02 +0200169/*
170 * converts <str> to a list of listeners which are dynamically allocated.
171 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
172 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
173 * - <port> is a numerical port from 1 to 65535 ;
174 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
175 * This can be repeated as many times as necessary, separated by a coma.
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200176 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
177 * not NULL, it must be a valid pointer to either NULL or a freeable area that
178 * will be replaced with an error message.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200179 */
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200180int 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 +0200181{
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200182 struct protocol *proto;
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100183 char *next, *dupstr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200184 int port, end;
185
186 next = dupstr = strdup(str);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200187
Willy Tarreaubaaee002006-06-26 02:48:02 +0200188 while (next && *next) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200189 struct sockaddr_storage *ss2;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100190 int fd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200191
192 str = next;
193 /* 1) look for the end of the first address */
Krzysztof Piotr Oledzki52d522b2009-01-27 16:57:08 +0100194 if ((next = strchr(str, ',')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200195 *next++ = 0;
196 }
197
Willy Tarreau5fc93282020-09-16 18:25:03 +0200198 ss2 = str2sa_range(str, NULL, &port, &end, &fd, &proto, err,
Eric Salama1b8dacc2021-03-16 15:12:17 +0100199 (curproxy == global.cli_fe || curproxy == mworker_proxy) ? NULL : global.unix_bind.prefix,
Willy Tarreau32819932020-09-04 15:53:16 +0200200 NULL, PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_PORT_RANGE |
Willy Tarreau5e1779a2020-09-16 16:28:08 +0200201 PA_O_SOCKET_FD | PA_O_STREAM | PA_O_XPRT);
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100202 if (!ss2)
203 goto fail;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200204
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100205 /* OK the address looks correct */
Frédéric Lécaille884f2e92020-11-23 14:23:21 +0100206
207#ifdef USE_QUIC
208 /* The transport layer automatically switches to QUIC when QUIC
209 * is selected, regardless of bind_conf settings. We then need
210 * to initialize QUIC params.
211 */
212 if (proto->sock_type == SOCK_DGRAM && proto->ctrl_type == SOCK_STREAM) {
213 bind_conf->xprt = xprt_get(XPRT_QUIC);
214 quic_transport_params_init(&bind_conf->quic_params, 1);
215 }
216#endif
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200217 if (!create_listeners(bind_conf, ss2, port, end, fd, proto, err)) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200218 memprintf(err, "%s for address '%s'.\n", *err, str);
219 goto fail;
220 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200221 } /* end while(next) */
222 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200223 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200224 fail:
225 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200226 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200227}
228
William Lallemand6e62fb62015-04-28 16:55:23 +0200229/*
Willy Tarreauaa333122020-09-16 15:13:04 +0200230 * converts <str> to a list of datagram-oriented listeners which are dynamically
231 * allocated.
232 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
233 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
234 * - <port> is a numerical port from 1 to 65535 ;
235 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
236 * This can be repeated as many times as necessary, separated by a coma.
237 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
238 * not NULL, it must be a valid pointer to either NULL or a freeable area that
239 * will be replaced with an error message.
240 */
241int str2receiver(char *str, struct proxy *curproxy, struct bind_conf *bind_conf, const char *file, int line, char **err)
242{
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200243 struct protocol *proto;
Willy Tarreauaa333122020-09-16 15:13:04 +0200244 char *next, *dupstr;
245 int port, end;
246
247 next = dupstr = strdup(str);
248
249 while (next && *next) {
250 struct sockaddr_storage *ss2;
251 int fd = -1;
252
253 str = next;
254 /* 1) look for the end of the first address */
255 if ((next = strchr(str, ',')) != NULL) {
256 *next++ = 0;
257 }
258
Willy Tarreau5fc93282020-09-16 18:25:03 +0200259 ss2 = str2sa_range(str, NULL, &port, &end, &fd, &proto, err,
Willy Tarreau4975d142021-03-13 11:00:33 +0100260 curproxy == global.cli_fe ? NULL : global.unix_bind.prefix,
Willy Tarreauaa333122020-09-16 15:13:04 +0200261 NULL, PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_PORT_RANGE |
262 PA_O_SOCKET_FD | PA_O_DGRAM | PA_O_XPRT);
263 if (!ss2)
264 goto fail;
265
266 /* OK the address looks correct */
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200267 if (!create_listeners(bind_conf, ss2, port, end, fd, proto, err)) {
Willy Tarreauaa333122020-09-16 15:13:04 +0200268 memprintf(err, "%s for address '%s'.\n", *err, str);
269 goto fail;
270 }
271 } /* end while(next) */
272 free(dupstr);
273 return 1;
274 fail:
275 free(dupstr);
276 return 0;
277}
278
279/*
Willy Tarreau08138612021-05-08 19:58:37 +0200280 * Sends a warning if proxy <proxy> does not have at least one of the
281 * capabilities in <cap>. An optional <hint> may be added at the end
282 * of the warning to help the user. Returns 1 if a warning was emitted
283 * or 0 if the condition is valid.
284 */
285int warnifnotcap(struct proxy *proxy, int cap, const char *file, int line, const char *arg, const char *hint)
286{
287 char *msg;
288
289 switch (cap) {
290 case PR_CAP_BE: msg = "no backend"; break;
291 case PR_CAP_FE: msg = "no frontend"; break;
292 case PR_CAP_BE|PR_CAP_FE: msg = "neither frontend nor backend"; break;
293 default: msg = "not enough"; break;
294 }
295
296 if (!(proxy->cap & cap)) {
297 ha_warning("parsing [%s:%d] : '%s' ignored because %s '%s' has %s capability.%s\n",
298 file, line, arg, proxy_type_str(proxy), proxy->id, msg, hint ? hint : "");
299 return 1;
300 }
301 return 0;
302}
303
304/*
305 * Sends an alert if proxy <proxy> does not have at least one of the
306 * capabilities in <cap>. An optional <hint> may be added at the end
307 * of the alert to help the user. Returns 1 if an alert was emitted
308 * or 0 if the condition is valid.
309 */
310int failifnotcap(struct proxy *proxy, int cap, const char *file, int line, const char *arg, const char *hint)
311{
312 char *msg;
313
314 switch (cap) {
315 case PR_CAP_BE: msg = "no backend"; break;
316 case PR_CAP_FE: msg = "no frontend"; break;
317 case PR_CAP_BE|PR_CAP_FE: msg = "neither frontend nor backend"; break;
318 default: msg = "not enough"; break;
319 }
320
321 if (!(proxy->cap & cap)) {
322 ha_alert("parsing [%s:%d] : '%s' not allowed because %s '%s' has %s capability.%s\n",
323 file, line, arg, proxy_type_str(proxy), proxy->id, msg, hint ? hint : "");
324 return 1;
325 }
326 return 0;
327}
328
329/*
Willy Tarreauece9b072016-12-21 22:41:44 +0100330 * Report an error in <msg> when there are too many arguments. This version is
331 * intended to be used by keyword parsers so that the message will be included
332 * into the general error message. The index is the current keyword in args.
333 * Return 0 if the number of argument is correct, otherwise build a message and
334 * return 1. Fill err_code with an ERR_ALERT and an ERR_FATAL if not null. The
335 * message may also be null, it will simply not be produced (useful to check only).
336 * <msg> and <err_code> are only affected on error.
337 */
338int too_many_args_idx(int maxarg, int index, char **args, char **msg, int *err_code)
339{
340 int i;
341
342 if (!*args[index + maxarg + 1])
343 return 0;
344
345 if (msg) {
346 *msg = NULL;
347 memprintf(msg, "%s", args[0]);
348 for (i = 1; i <= index; i++)
349 memprintf(msg, "%s %s", *msg, args[i]);
350
351 memprintf(msg, "'%s' cannot handle unexpected argument '%s'.", *msg, args[index + maxarg + 1]);
352 }
353 if (err_code)
354 *err_code |= ERR_ALERT | ERR_FATAL;
355
356 return 1;
357}
358
359/*
360 * same as too_many_args_idx with a 0 index
361 */
362int too_many_args(int maxarg, char **args, char **msg, int *err_code)
363{
364 return too_many_args_idx(maxarg, 0, args, msg, err_code);
365}
366
367/*
William Lallemand6e62fb62015-04-28 16:55:23 +0200368 * Report a fatal Alert when there is too much arguments
369 * The index is the current keyword in args
370 * Return 0 if the number of argument is correct, otherwise emit an alert and return 1
371 * Fill err_code with an ERR_ALERT and an ERR_FATAL
372 */
373int alertif_too_many_args_idx(int maxarg, int index, const char *file, int linenum, char **args, int *err_code)
374{
375 char *kw = NULL;
376 int i;
377
378 if (!*args[index + maxarg + 1])
379 return 0;
380
381 memprintf(&kw, "%s", args[0]);
382 for (i = 1; i <= index; i++) {
383 memprintf(&kw, "%s %s", kw, args[i]);
384 }
385
Christopher Faulet767a84b2017-11-24 16:50:31 +0100386 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 +0200387 free(kw);
388 *err_code |= ERR_ALERT | ERR_FATAL;
389 return 1;
390}
391
392/*
393 * same as alertif_too_many_args_idx with a 0 index
394 */
395int alertif_too_many_args(int maxarg, const char *file, int linenum, char **args, int *err_code)
396{
397 return alertif_too_many_args_idx(maxarg, 0, file, linenum, args, err_code);
398}
399
Willy Tarreau61d18892009-03-31 10:49:21 +0200400
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100401/* Report it if a request ACL condition uses some keywords that are incompatible
402 * with the place where the ACL is used. It returns either 0 or ERR_WARN so that
403 * its result can be or'ed with err_code. Note that <cond> may be NULL and then
404 * will be ignored.
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100405 */
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100406int warnif_cond_conflicts(const struct acl_cond *cond, unsigned int where, const char *file, int line)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100407{
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100408 const struct acl *acl;
Willy Tarreau93fddf12013-03-31 22:59:32 +0200409 const char *kw;
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100410
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100411 if (!cond)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100412 return 0;
413
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100414 acl = acl_cond_conflicts(cond, where);
415 if (acl) {
416 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100417 ha_warning("parsing [%s:%d] : acl '%s' will never match because it only involves keywords that are incompatible with '%s'\n",
418 file, line, acl->name, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100419 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100420 ha_warning("parsing [%s:%d] : anonymous acl will never match because it uses keyword '%s' which is incompatible with '%s'\n",
421 file, line, LIST_ELEM(acl->expr.n, struct acl_expr *, list)->kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100422 return ERR_WARN;
423 }
424 if (!acl_cond_kw_conflicts(cond, where, &acl, &kw))
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100425 return 0;
426
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100427 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100428 ha_warning("parsing [%s:%d] : acl '%s' involves keywords '%s' which is incompatible with '%s'\n",
429 file, line, acl->name, kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100430 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100431 ha_warning("parsing [%s:%d] : anonymous acl involves keyword '%s' which is incompatible with '%s'\n",
432 file, line, kw, sample_ckp_names(where));
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100433 return ERR_WARN;
434}
435
Christopher Faulet581db2b2021-03-26 10:02:46 +0100436/* Report it if an ACL uses a L6 sample fetch from an HTTP proxy. It returns
437 * either 0 or ERR_WARN so that its result can be or'ed with err_code. Note that
438 * <cond> may be NULL and then will be ignored.
439*/
440int warnif_tcp_http_cond(const struct proxy *px, const struct acl_cond *cond)
441{
442 if (!cond || px->mode != PR_MODE_HTTP)
443 return 0;
444
445 if (cond->use & (SMP_USE_L6REQ|SMP_USE_L6RES)) {
446 ha_warning("Proxy '%s': L6 sample fetches ignored on HTTP proxies (declared at %s:%d).\n",
447 px->id, cond->file, cond->line);
448 return ERR_WARN;
449 }
450 return 0;
451}
452
Willy Tarreaue2afcc42021-03-12 09:08:04 +0100453/* try to find in <list> the word that looks closest to <word> by counting
454 * transitions between letters, digits and other characters. Will return the
455 * best matching word if found, otherwise NULL. An optional array of extra
456 * words to compare may be passed in <extra>, but it must then be terminated
457 * by a NULL entry. If unused it may be NULL.
458 */
459const char *cfg_find_best_match(const char *word, const struct list *list, int section, const char **extra)
460{
461 uint8_t word_sig[1024]; // 0..25=letter, 26=digit, 27=other, 28=begin, 29=end
462 uint8_t list_sig[1024];
463 const struct cfg_kw_list *kwl;
464 int index;
465 const char *best_ptr = NULL;
466 int dist, best_dist = INT_MAX;
467
468 make_word_fingerprint(word_sig, word);
469 list_for_each_entry(kwl, list, list) {
470 for (index = 0; kwl->kw[index].kw != NULL; index++) {
471 if (kwl->kw[index].section != section)
472 continue;
473
474 make_word_fingerprint(list_sig, kwl->kw[index].kw);
475 dist = word_fingerprint_distance(word_sig, list_sig);
476 if (dist < best_dist) {
477 best_dist = dist;
478 best_ptr = kwl->kw[index].kw;
479 }
480 }
481 }
482
483 while (extra && *extra) {
484 make_word_fingerprint(list_sig, *extra);
485 dist = word_fingerprint_distance(word_sig, list_sig);
486 if (dist < best_dist) {
487 best_dist = dist;
488 best_ptr = *extra;
489 }
490 extra++;
491 }
492
493 if (best_dist > 2 * strlen(word) || (best_ptr && best_dist > 2 * strlen(best_ptr)))
494 best_ptr = NULL;
495 return best_ptr;
496}
497
Christopher Faulet62519022017-10-16 15:49:32 +0200498/* Parse a string representing a process number or a set of processes. It must
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100499 * be "all", "odd", "even", a number between 1 and <max> or a range with
Christopher Faulet5ab51772017-11-22 11:21:58 +0100500 * two such numbers delimited by a dash ('-'). On success, it returns
501 * 0. otherwise it returns 1 with an error message in <err>.
Christopher Faulet62519022017-10-16 15:49:32 +0200502 *
503 * Note: this function can also be used to parse a thread number or a set of
504 * threads.
505 */
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100506int parse_process_number(const char *arg, unsigned long *proc, int max, int *autoinc, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200507{
Christopher Faulet26028f62017-11-22 15:01:51 +0100508 if (autoinc) {
509 *autoinc = 0;
510 if (strncmp(arg, "auto:", 5) == 0) {
511 arg += 5;
512 *autoinc = 1;
513 }
514 }
515
Christopher Faulet62519022017-10-16 15:49:32 +0200516 if (strcmp(arg, "all") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100517 *proc |= ~0UL;
Christopher Faulet62519022017-10-16 15:49:32 +0200518 else if (strcmp(arg, "odd") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100519 *proc |= ~0UL/3UL; /* 0x555....555 */
Christopher Faulet62519022017-10-16 15:49:32 +0200520 else if (strcmp(arg, "even") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100521 *proc |= (~0UL/3UL) << 1; /* 0xAAA...AAA */
Christopher Faulet62519022017-10-16 15:49:32 +0200522 else {
Christopher Faulet18cca782019-02-07 16:29:41 +0100523 const char *p, *dash = NULL;
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100524 unsigned int low, high;
525
Christopher Faulet18cca782019-02-07 16:29:41 +0100526 for (p = arg; *p; p++) {
527 if (*p == '-' && !dash)
528 dash = p;
Willy Tarreau90807112020-02-25 08:16:33 +0100529 else if (!isdigit((unsigned char)*p)) {
Christopher Faulet18cca782019-02-07 16:29:41 +0100530 memprintf(err, "'%s' is not a valid number/range.", arg);
531 return -1;
532 }
Christopher Faulet5ab51772017-11-22 11:21:58 +0100533 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100534
535 low = high = str2uic(arg);
Christopher Faulet18cca782019-02-07 16:29:41 +0100536 if (dash)
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100537 high = ((!*(dash+1)) ? max : str2uic(dash + 1));
Christopher Fauletff4121f2017-11-22 16:38:49 +0100538
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100539 if (high < low) {
540 unsigned int swap = low;
541 low = high;
542 high = swap;
543 }
544
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100545 if (low < 1 || low > max || high > max) {
Christopher Fauletcb6a9452017-11-22 16:50:41 +0100546 memprintf(err, "'%s' is not a valid number/range."
547 " It supports numbers from 1 to %d.\n",
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100548 arg, max);
Christopher Faulet5ab51772017-11-22 11:21:58 +0100549 return 1;
550 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100551
552 for (;low <= high; low++)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100553 *proc |= 1UL << (low-1);
Christopher Faulet62519022017-10-16 15:49:32 +0200554 }
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100555 *proc &= ~0UL >> (LONGBITS - max);
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100556
Christopher Faulet5ab51772017-11-22 11:21:58 +0100557 return 0;
Christopher Faulet62519022017-10-16 15:49:32 +0200558}
559
David Carlier7e351ee2017-12-01 09:14:02 +0000560#ifdef USE_CPU_AFFINITY
Christopher Faulet62519022017-10-16 15:49:32 +0200561/* Parse cpu sets. Each CPU set is either a unique number between 0 and
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200562 * ha_cpuset_size() - 1 or a range with two such numbers delimited by a dash
Amaury Denoyellea8082352021-04-06 16:46:15 +0200563 * ('-'). If <comma_allowed> is set, each CPU set can be a list of unique
564 * numbers or ranges separated by a comma. It is also possible to specify
565 * multiple cpu numbers or ranges in distinct argument in <args>. On success,
566 * it returns 0, otherwise it returns 1 with an error message in <err>.
Christopher Faulet62519022017-10-16 15:49:32 +0200567 */
Amaury Denoyellea8082352021-04-06 16:46:15 +0200568unsigned long parse_cpu_set(const char **args, struct hap_cpuset *cpu_set,
569 int comma_allowed, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200570{
571 int cur_arg = 0;
Amaury Denoyellea8082352021-04-06 16:46:15 +0200572 const char *arg;
Christopher Faulet62519022017-10-16 15:49:32 +0200573
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200574 ha_cpuset_zero(cpu_set);
575
Amaury Denoyellea8082352021-04-06 16:46:15 +0200576 arg = args[cur_arg];
577 while (*arg) {
578 const char *dash, *comma;
Christopher Faulet62519022017-10-16 15:49:32 +0200579 unsigned int low, high;
580
Willy Tarreau90807112020-02-25 08:16:33 +0100581 if (!isdigit((unsigned char)*args[cur_arg])) {
Amaury Denoyellea8082352021-04-06 16:46:15 +0200582 memprintf(err, "'%s' is not a CPU range.", arg);
Christopher Faulet62519022017-10-16 15:49:32 +0200583 return -1;
584 }
585
Amaury Denoyellea8082352021-04-06 16:46:15 +0200586 low = high = str2uic(arg);
587
588 comma = comma_allowed ? strchr(arg, ',') : NULL;
589 dash = strchr(arg, '-');
590
591 if (dash && (!comma || dash < comma))
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200592 high = *(dash+1) ? str2uic(dash + 1) : ha_cpuset_size() - 1;
Christopher Faulet62519022017-10-16 15:49:32 +0200593
594 if (high < low) {
595 unsigned int swap = low;
596 low = high;
597 high = swap;
598 }
599
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200600 if (high >= ha_cpuset_size()) {
601 memprintf(err, "supports CPU numbers from 0 to %d.",
602 ha_cpuset_size() - 1);
Christopher Faulet62519022017-10-16 15:49:32 +0200603 return 1;
604 }
605
606 while (low <= high)
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200607 ha_cpuset_set(cpu_set, low++);
Christopher Faulet62519022017-10-16 15:49:32 +0200608
Amaury Denoyellea8082352021-04-06 16:46:15 +0200609 /* if a comma is present, parse the rest of the arg, else
610 * skip to the next arg */
611 arg = comma ? comma + 1 : args[++cur_arg];
Christopher Faulet62519022017-10-16 15:49:32 +0200612 }
613 return 0;
614}
David Carlier7e351ee2017-12-01 09:14:02 +0000615#endif
616
Frédéric Lécaille18251032019-01-11 11:07:15 +0100617/* Allocate and initialize the frontend of a "peers" section found in
618 * file <file> at line <linenum> with <id> as ID.
619 * Return 0 if succeeded, -1 if not.
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200620 * Note that this function may be called from "default-server"
621 * or "peer" lines.
Frédéric Lécaille18251032019-01-11 11:07:15 +0100622 */
623static int init_peers_frontend(const char *file, int linenum,
624 const char *id, struct peers *peers)
625{
626 struct proxy *p;
627
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200628 if (peers->peers_fe) {
629 p = peers->peers_fe;
630 goto out;
631 }
Frédéric Lécaille9492c4e2019-01-11 11:47:12 +0100632
Frédéric Lécaille18251032019-01-11 11:07:15 +0100633 p = calloc(1, sizeof *p);
634 if (!p) {
635 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
636 return -1;
637 }
638
639 init_new_proxy(p);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200640 peers_setup_frontend(p);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100641 p->parent = peers;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200642 /* Finally store this frontend. */
643 peers->peers_fe = p;
644
645 out:
646 if (id && !p->id)
647 p->id = strdup(id);
Frédéric Lécaille1055e682018-04-26 14:35:21 +0200648 free(p->conf.file);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100649 p->conf.args.file = p->conf.file = strdup(file);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100650 if (linenum != -1)
651 p->conf.args.line = p->conf.line = linenum;
Frédéric Lécaille18251032019-01-11 11:07:15 +0100652
653 return 0;
654}
Willy Tarreauade5ec42010-01-28 19:33:49 +0100655
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100656/* Only change ->file, ->line and ->arg struct bind_conf member values
657 * if already present.
658 */
659static struct bind_conf *bind_conf_uniq_alloc(struct proxy *p,
660 const char *file, int line,
661 const char *arg, struct xprt_ops *xprt)
662{
663 struct bind_conf *bind_conf;
664
665 if (!LIST_ISEMPTY(&p->conf.bind)) {
666 bind_conf = LIST_ELEM((&p->conf.bind)->n, typeof(bind_conf), by_fe);
Emeric Brun0618a3a2022-05-25 10:12:07 +0200667 /*
668 * We keep bind_conf->file and bind_conf->line unchanged
669 * to make them available for error messages
670 */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100671 if (arg) {
672 free(bind_conf->arg);
673 bind_conf->arg = strdup(arg);
674 }
675 }
676 else {
677 bind_conf = bind_conf_alloc(p, file, line, arg, xprt);
678 }
679
680 return bind_conf;
681}
682
683/*
684 * Allocate a new struct peer parsed at line <linenum> in file <file>
685 * to be added to <peers>.
686 * Returns the new allocated structure if succeeded, NULL if not.
687 */
688static struct peer *cfg_peers_add_peer(struct peers *peers,
689 const char *file, int linenum,
690 const char *id, int local)
691{
692 struct peer *p;
693
694 p = calloc(1, sizeof *p);
695 if (!p) {
696 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
697 return NULL;
698 }
699
700 /* the peers are linked backwards first */
701 peers->count++;
702 p->next = peers->remote;
703 peers->remote = p;
704 p->conf.file = strdup(file);
705 p->conf.line = linenum;
706 p->last_change = now.tv_sec;
707 p->xprt = xprt_get(XPRT_RAW);
708 p->sock_init_arg = NULL;
709 HA_SPIN_INIT(&p->lock);
710 if (id)
711 p->id = strdup(id);
712 if (local) {
713 p->local = 1;
714 peers->local = p;
715 }
716
717 return p;
718}
719
Willy Tarreaubaaee002006-06-26 02:48:02 +0200720/*
William Lallemand51097192015-04-14 16:35:22 +0200721 * Parse a line in a <listen>, <frontend> or <backend> section.
Willy Tarreau93893792009-07-23 13:19:11 +0200722 * Returns the error code, 0 if OK, or any combination of :
723 * - ERR_ABORT: must abort ASAP
724 * - ERR_FATAL: we can continue parsing but not start the service
725 * - ERR_WARN: a warning has been emitted
726 * - ERR_ALERT: an alert has been emitted
727 * Only the two first ones can stop processing, the two others are just
728 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200729 */
Emeric Brun32da3c42010-09-23 18:39:19 +0200730int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
731{
732 static struct peers *curpeers = NULL;
733 struct peer *newpeer = NULL;
734 const char *err;
Willy Tarreau4348fad2012-09-20 16:48:07 +0200735 struct bind_conf *bind_conf;
736 struct listener *l;
Emeric Brun32da3c42010-09-23 18:39:19 +0200737 int err_code = 0;
Willy Tarreau902636f2013-03-10 19:44:48 +0100738 char *errmsg = NULL;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100739 static int bind_line, peer_line;
740
741 if (strcmp(args[0], "bind") == 0 || strcmp(args[0], "default-bind") == 0) {
742 int cur_arg;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100743 struct bind_conf *bind_conf;
744 struct bind_kw *kw;
Emeric Brun32da3c42010-09-23 18:39:19 +0200745
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100746 cur_arg = 1;
747
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200748 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
749 err_code |= ERR_ALERT | ERR_ABORT;
750 goto out;
751 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100752
753 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum,
Willy Tarreau8ed76152022-07-05 15:54:09 +0200754 args[1], xprt_get(XPRT_RAW));
William Lallemand8e1b8df2022-07-06 14:30:23 +0200755 if (!bind_conf) {
756 ha_alert("parsing [%s:%d] : '%s %s' : cannot allocate memory.\n", file, linenum, args[0], args[1]);
757 err_code |= ERR_FATAL;
758 goto out;
759 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100760 if (*args[0] == 'b') {
761 struct listener *l;
762
763 if (peer_line) {
764 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
765 err_code |= ERR_ALERT | ERR_FATAL;
766 goto out;
767 }
768
Emeric Brun0618a3a2022-05-25 10:12:07 +0200769 if (!LIST_ISEMPTY(&bind_conf->listeners)) {
770 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);
771 err_code |= ERR_FATAL;
772 }
773
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100774 if (!str2listener(args[1], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
775 if (errmsg && *errmsg) {
776 indent_msg(&errmsg, 2);
777 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
778 }
779 else
780 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
Willy Tarreau5ab278b2022-05-20 15:19:48 +0200781 file, linenum, args[0], args[1], args[1]);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100782 err_code |= ERR_FATAL;
783 goto out;
784 }
Emeric Bruna25fb612022-05-25 10:25:45 +0200785 /*
786 * Newly allocated listener is at the end of the list
787 */
788 l = LIST_ELEM(bind_conf->listeners.p, typeof(l), by_bind);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100789 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100790 l->accept = session_accept_fd;
791 l->analysers |= curpeers->peers_fe->fe_req_ana;
792 l->default_target = curpeers->peers_fe->default_target;
793 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100794 global.maxsock++; /* for the listening socket */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100795
796 bind_line = 1;
797 if (cfg_peers->local) {
798 newpeer = cfg_peers->local;
799 }
800 else {
801 /* This peer is local.
802 * Note that we do not set the peer ID. This latter is initialized
803 * when parsing "peer" or "server" line.
804 */
805 newpeer = cfg_peers_add_peer(curpeers, file, linenum, NULL, 1);
806 if (!newpeer) {
807 err_code |= ERR_ALERT | ERR_ABORT;
808 goto out;
809 }
810 }
Willy Tarreau37159062020-08-27 07:48:42 +0200811 newpeer->addr = l->rx.addr;
Willy Tarreau5fc93282020-09-16 18:25:03 +0200812 newpeer->proto = l->rx.proto;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100813 cur_arg++;
814 }
815
816 while (*args[cur_arg] && (kw = bind_find_kw(args[cur_arg]))) {
817 int ret;
818
819 ret = kw->parse(args, cur_arg, curpeers->peers_fe, bind_conf, &errmsg);
820 err_code |= ret;
821 if (ret) {
822 if (errmsg && *errmsg) {
823 indent_msg(&errmsg, 2);
824 ha_alert("parsing [%s:%d] : %s\n", file, linenum, errmsg);
825 }
826 else
827 ha_alert("parsing [%s:%d]: error encountered while processing '%s'\n",
828 file, linenum, args[cur_arg]);
829 if (ret & ERR_FATAL)
830 goto out;
831 }
832 cur_arg += 1 + kw->skip;
833 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100834 if (*args[cur_arg] != 0) {
Willy Tarreau433b05f2021-03-12 10:14:07 +0100835 const char *best = bind_find_best_kw(args[cur_arg]);
836 if (best)
837 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section; did you mean '%s' maybe ?\n",
838 file, linenum, args[cur_arg], cursection, best);
839 else
840 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section.\n",
841 file, linenum, args[cur_arg], cursection);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100842 err_code |= ERR_ALERT | ERR_FATAL;
843 goto out;
844 }
845 }
846 else if (strcmp(args[0], "default-server") == 0) {
847 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
848 err_code |= ERR_ALERT | ERR_ABORT;
849 goto out;
850 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +0100851 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL,
852 SRV_PARSE_DEFAULT_SERVER|SRV_PARSE_IN_PEER_SECTION|SRV_PARSE_INITIAL_RESOLVE);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200853 }
Frédéric Lécailleb6f759b2019-11-05 09:57:45 +0100854 else if (strcmp(args[0], "log") == 0) {
855 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
856 err_code |= ERR_ALERT | ERR_ABORT;
857 goto out;
858 }
Emeric Brun9533a702021-04-02 10:13:43 +0200859 if (!parse_logsrv(args, &curpeers->peers_fe->logsrvs, (kwm == KWM_NO), file, linenum, &errmsg)) {
Frédéric Lécailleb6f759b2019-11-05 09:57:45 +0100860 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
861 err_code |= ERR_ALERT | ERR_FATAL;
862 goto out;
863 }
864 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200865 else if (strcmp(args[0], "peers") == 0) { /* new peers section */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100866 /* Initialize these static variables when entering a new "peers" section*/
867 bind_line = peer_line = 0;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100868 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100869 ha_alert("parsing [%s:%d] : missing name for peers section.\n", file, linenum);
Willy Tarreau54984722014-02-16 08:20:13 +0100870 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100871 goto out;
872 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200873
William Lallemand6e62fb62015-04-28 16:55:23 +0200874 if (alertif_too_many_args(1, file, linenum, args, &err_code))
875 goto out;
876
Emeric Brun32da3c42010-09-23 18:39:19 +0200877 err = invalid_char(args[1]);
878 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100879 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
880 file, linenum, *err, args[0], args[1]);
Willy Tarreau54984722014-02-16 08:20:13 +0100881 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100882 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200883 }
884
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200885 for (curpeers = cfg_peers; curpeers != NULL; curpeers = curpeers->next) {
Emeric Brun32da3c42010-09-23 18:39:19 +0200886 /*
887 * If there are two proxies with the same name only following
888 * combinations are allowed:
889 */
890 if (strcmp(curpeers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100891 ha_alert("Parsing [%s:%d]: peers section '%s' has the same name as another peers section declared at %s:%d.\n",
892 file, linenum, args[1], curpeers->conf.file, curpeers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +0200893 err_code |= ERR_ALERT | ERR_FATAL;
Emeric Brun32da3c42010-09-23 18:39:19 +0200894 }
895 }
896
Vincent Bernat02779b62016-04-03 13:48:43 +0200897 if ((curpeers = calloc(1, sizeof(*curpeers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100898 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Emeric Brun32da3c42010-09-23 18:39:19 +0200899 err_code |= ERR_ALERT | ERR_ABORT;
900 goto out;
901 }
902
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200903 curpeers->next = cfg_peers;
904 cfg_peers = curpeers;
Willy Tarreau8113a5d2012-10-04 08:01:43 +0200905 curpeers->conf.file = strdup(file);
Emeric Brun32da3c42010-09-23 18:39:19 +0200906 curpeers->conf.line = linenum;
907 curpeers->last_change = now.tv_sec;
908 curpeers->id = strdup(args[1]);
Willy Tarreau1ad64ac2020-09-24 08:48:08 +0200909 curpeers->disabled = 0;
Emeric Brun32da3c42010-09-23 18:39:19 +0200910 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200911 else if (strcmp(args[0], "peer") == 0 ||
912 strcmp(args[0], "server") == 0) { /* peer or server definition */
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100913 int local_peer, peer;
Amaury Denoyelle30c05372021-03-08 16:36:46 +0100914 int parse_addr = 0;
Emeric Brun32da3c42010-09-23 18:39:19 +0200915
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100916 peer = *args[0] == 'p';
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100917 local_peer = strcmp(args[1], localpeer) == 0;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100918 /* The local peer may have already partially been parsed on a "bind" line. */
919 if (*args[0] == 'p') {
920 if (bind_line) {
921 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
922 err_code |= ERR_ALERT | ERR_FATAL;
923 goto out;
924 }
925 peer_line = 1;
926 }
927 if (cfg_peers->local && !cfg_peers->local->id && local_peer) {
928 /* The local peer has already been initialized on a "bind" line.
929 * Let's use it and store its ID.
930 */
931 newpeer = cfg_peers->local;
932 newpeer->id = strdup(localpeer);
933 }
934 else {
935 if (local_peer && cfg_peers->local) {
936 ha_alert("parsing [%s:%d] : '%s %s' : local peer name already referenced at %s:%d. %s\n",
937 file, linenum, args[0], args[1],
938 curpeers->peers_fe->conf.file, curpeers->peers_fe->conf.line, cfg_peers->local->id);
939 err_code |= ERR_FATAL;
940 goto out;
941 }
942 newpeer = cfg_peers_add_peer(curpeers, file, linenum, args[1], local_peer);
943 if (!newpeer) {
944 err_code |= ERR_ALERT | ERR_ABORT;
945 goto out;
946 }
947 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200948
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100949 /* Line number and peer ID are updated only if this peer is the local one. */
950 if (init_peers_frontend(file,
951 newpeer->local ? linenum: -1,
952 newpeer->local ? newpeer->id : NULL,
953 curpeers) != 0) {
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200954 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreaub36487e2013-03-10 18:37:42 +0100955 goto out;
956 }
Willy Tarreau2aa38802013-02-20 19:20:59 +0100957
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100958 /* This initializes curpeer->peers->peers_fe->srv.
959 * The server address is parsed only if we are parsing a "peer" line,
960 * or if we are parsing a "server" line and the current peer is not the local one.
961 */
Amaury Denoyelle30c05372021-03-08 16:36:46 +0100962 parse_addr = (peer || !local_peer) ? SRV_PARSE_PARSE_ADDR : 0;
963 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL,
964 SRV_PARSE_IN_PEER_SECTION|parse_addr|SRV_PARSE_INITIAL_RESOLVE);
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200965 if (!curpeers->peers_fe->srv) {
966 /* Remove the newly allocated peer. */
967 if (newpeer != curpeers->local) {
968 struct peer *p;
969
970 p = curpeers->remote;
971 curpeers->remote = curpeers->remote->next;
972 free(p->id);
973 free(p);
974 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200975 goto out;
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200976 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200977
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100978 /* If the peer address has just been parsed, let's copy it to <newpeer>
979 * and initializes ->proto.
980 */
981 if (peer || !local_peer) {
982 newpeer->addr = curpeers->peers_fe->srv->addr;
983 newpeer->proto = protocol_by_family(newpeer->addr.ss_family);
984 }
985
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100986 newpeer->xprt = xprt_get(XPRT_RAW);
Willy Tarreaud02394b2012-05-11 18:32:18 +0200987 newpeer->sock_init_arg = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100988 HA_SPIN_INIT(&newpeer->lock);
Willy Tarreau26d8c592012-05-07 18:12:14 +0200989
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100990 newpeer->srv = curpeers->peers_fe->srv;
991 if (!newpeer->local)
Frédéric Lécaille6617e762018-04-25 15:13:38 +0200992 goto out;
993
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100994 /* The lines above are reserved to "peer" lines. */
995 if (*args[0] == 's')
Frédéric Lécaille4ba51982018-04-25 15:32:18 +0200996 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200997
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100998 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum, args[2], xprt_get(XPRT_RAW));
William Lallemand8e1b8df2022-07-06 14:30:23 +0200999 if (!bind_conf) {
1000 ha_alert("parsing [%s:%d] : '%s %s' : Cannot allocate memory.\n", file, linenum, args[0], args[1]);
1001 err_code |= ERR_FATAL;
1002 goto out;
1003 }
Frédéric Lécaille16e49102019-01-11 11:27:16 +01001004
Emeric Brun0618a3a2022-05-25 10:12:07 +02001005 if (!LIST_ISEMPTY(&bind_conf->listeners)) {
1006 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);
1007 err_code |= ERR_FATAL;
1008 }
1009
Frédéric Lécaille91694d52019-01-11 11:43:53 +01001010 if (!str2listener(args[2], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
1011 if (errmsg && *errmsg) {
1012 indent_msg(&errmsg, 2);
1013 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 +01001014 }
Frédéric Lécaille91694d52019-01-11 11:43:53 +01001015 else
1016 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
1017 file, linenum, args[0], args[1], args[2]);
1018 err_code |= ERR_FATAL;
1019 goto out;
1020 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +01001021
Emeric Bruna25fb612022-05-25 10:25:45 +02001022 /*
1023 * Newly allocated listener is at the end of the list
1024 */
1025 l = LIST_ELEM(bind_conf->listeners.p, typeof(l), by_bind);
Frédéric Lécaille355b2032019-01-11 14:06:12 +01001026 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +01001027 l->accept = session_accept_fd;
1028 l->analysers |= curpeers->peers_fe->fe_req_ana;
1029 l->default_target = curpeers->peers_fe->default_target;
1030 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +01001031 global.maxsock++; /* for the listening socket */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001032 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001033 else if (strcmp(args[0], "table") == 0) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001034 struct stktable *t, *other;
1035 char *id;
Frédéric Lécaillec02766a2019-03-20 15:06:55 +01001036 size_t prefix_len;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001037
1038 /* Line number and peer ID are updated only if this peer is the local one. */
1039 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
1040 err_code |= ERR_ALERT | ERR_ABORT;
1041 goto out;
1042 }
1043
1044 other = stktable_find_by_name(args[1]);
1045 if (other) {
1046 ha_alert("parsing [%s:%d] : stick-table name '%s' conflicts with table declared in %s '%s' at %s:%d.\n",
1047 file, linenum, args[1],
1048 other->proxy ? proxy_cap_str(other->proxy->cap) : "peers",
1049 other->proxy ? other->id : other->peers.p->id,
1050 other->conf.file, other->conf.line);
1051 err_code |= ERR_ALERT | ERR_FATAL;
1052 goto out;
1053 }
1054
Frédéric Lécaillec02766a2019-03-20 15:06:55 +01001055 /* Build the stick-table name, concatenating the "peers" section name
1056 * followed by a '/' character and the table name argument.
1057 */
1058 chunk_reset(&trash);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +01001059 if (!chunk_strcpy(&trash, curpeers->id)) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +01001060 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
1061 file, linenum, args[0], args[1]);
1062 err_code |= ERR_ALERT | ERR_FATAL;
1063 goto out;
1064 }
1065
1066 prefix_len = trash.data;
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +01001067 if (!chunk_memcat(&trash, "/", 1) || !chunk_strcat(&trash, args[1])) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +01001068 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
1069 file, linenum, args[0], args[1]);
1070 err_code |= ERR_ALERT | ERR_FATAL;
1071 goto out;
1072 }
1073
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001074 t = calloc(1, sizeof *t);
Frédéric Lécaillec02766a2019-03-20 15:06:55 +01001075 id = strdup(trash.area);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001076 if (!t || !id) {
1077 ha_alert("parsing [%s:%d]: '%s %s' : memory allocation failed\n",
1078 file, linenum, args[0], args[1]);
Eric Salama1aab9112020-09-18 11:55:17 +02001079 free(t);
1080 free(id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001081 err_code |= ERR_ALERT | ERR_FATAL;
1082 goto out;
1083 }
1084
Frédéric Lécaillec02766a2019-03-20 15:06:55 +01001085 err_code |= parse_stick_table(file, linenum, args, t, id, id + prefix_len, curpeers);
Eric Salama1aab9112020-09-18 11:55:17 +02001086 if (err_code & ERR_FATAL) {
1087 free(t);
1088 free(id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001089 goto out;
Eric Salama1aab9112020-09-18 11:55:17 +02001090 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001091
1092 stktable_store_name(t);
1093 t->next = stktables_list;
1094 stktables_list = t;
1095 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001096 else if (strcmp(args[0], "disabled") == 0) { /* disables this peers section */
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02001097 curpeers->disabled = 1;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02001098 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001099 else if (strcmp(args[0], "enabled") == 0) { /* enables this peers section (used to revert a disabled default) */
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02001100 curpeers->disabled = 0;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02001101 }
Emeric Brun32da3c42010-09-23 18:39:19 +02001102 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001103 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Emeric Brun32da3c42010-09-23 18:39:19 +02001104 err_code |= ERR_ALERT | ERR_FATAL;
1105 goto out;
1106 }
1107
1108out:
Willy Tarreau902636f2013-03-10 19:44:48 +01001109 free(errmsg);
Emeric Brun32da3c42010-09-23 18:39:19 +02001110 return err_code;
1111}
1112
Baptiste Assmann325137d2015-04-13 23:40:55 +02001113/*
William Lallemand51097192015-04-14 16:35:22 +02001114 * Parse a line in a <listen>, <frontend> or <backend> section.
Simon Horman0d16a402015-01-30 11:22:58 +09001115 * Returns the error code, 0 if OK, or any combination of :
1116 * - ERR_ABORT: must abort ASAP
1117 * - ERR_FATAL: we can continue parsing but not start the service
1118 * - ERR_WARN: a warning has been emitted
1119 * - ERR_ALERT: an alert has been emitted
1120 * Only the two first ones can stop processing, the two others are just
1121 * indicators.
1122 */
1123int cfg_parse_mailers(const char *file, int linenum, char **args, int kwm)
1124{
1125 static struct mailers *curmailers = NULL;
1126 struct mailer *newmailer = NULL;
1127 const char *err;
1128 int err_code = 0;
1129 char *errmsg = NULL;
1130
1131 if (strcmp(args[0], "mailers") == 0) { /* new mailers section */
1132 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001133 ha_alert("parsing [%s:%d] : missing name for mailers section.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001134 err_code |= ERR_ALERT | ERR_ABORT;
1135 goto out;
1136 }
1137
1138 err = invalid_char(args[1]);
1139 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001140 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
1141 file, linenum, *err, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001142 err_code |= ERR_ALERT | ERR_ABORT;
1143 goto out;
1144 }
1145
1146 for (curmailers = mailers; curmailers != NULL; curmailers = curmailers->next) {
1147 /*
1148 * If there are two proxies with the same name only following
1149 * combinations are allowed:
1150 */
1151 if (strcmp(curmailers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001152 ha_alert("Parsing [%s:%d]: mailers section '%s' has the same name as another mailers section declared at %s:%d.\n",
1153 file, linenum, args[1], curmailers->conf.file, curmailers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +02001154 err_code |= ERR_ALERT | ERR_FATAL;
Simon Horman0d16a402015-01-30 11:22:58 +09001155 }
1156 }
1157
Vincent Bernat02779b62016-04-03 13:48:43 +02001158 if ((curmailers = calloc(1, sizeof(*curmailers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001159 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001160 err_code |= ERR_ALERT | ERR_ABORT;
1161 goto out;
1162 }
1163
1164 curmailers->next = mailers;
1165 mailers = curmailers;
1166 curmailers->conf.file = strdup(file);
1167 curmailers->conf.line = linenum;
1168 curmailers->id = strdup(args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001169 curmailers->timeout.mail = DEF_MAILALERTTIME;/* XXX: Would like to Skip to the next alert, if any, ASAP.
1170 * But need enough time so that timeouts don't occur
1171 * during tcp procssing. For now just us an arbitrary default. */
Simon Horman0d16a402015-01-30 11:22:58 +09001172 }
1173 else if (strcmp(args[0], "mailer") == 0) { /* mailer definition */
1174 struct sockaddr_storage *sk;
1175 int port1, port2;
1176 struct protocol *proto;
1177
1178 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001179 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1180 file, linenum, args[0]);
Simon Horman0d16a402015-01-30 11:22:58 +09001181 err_code |= ERR_ALERT | ERR_FATAL;
1182 goto out;
1183 }
1184
1185 err = invalid_char(args[1]);
1186 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001187 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1188 file, linenum, *err, args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001189 err_code |= ERR_ALERT | ERR_FATAL;
1190 goto out;
1191 }
1192
Vincent Bernat02779b62016-04-03 13:48:43 +02001193 if ((newmailer = calloc(1, sizeof(*newmailer))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001194 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001195 err_code |= ERR_ALERT | ERR_ABORT;
1196 goto out;
1197 }
1198
1199 /* the mailers are linked backwards first */
1200 curmailers->count++;
1201 newmailer->next = curmailers->mailer_list;
1202 curmailers->mailer_list = newmailer;
1203 newmailer->mailers = curmailers;
1204 newmailer->conf.file = strdup(file);
1205 newmailer->conf.line = linenum;
1206
1207 newmailer->id = strdup(args[1]);
1208
Willy Tarreau5fc93282020-09-16 18:25:03 +02001209 sk = str2sa_range(args[2], NULL, &port1, &port2, NULL, &proto,
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001210 &errmsg, NULL, NULL,
1211 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 +09001212 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001213 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Simon Horman0d16a402015-01-30 11:22:58 +09001214 err_code |= ERR_ALERT | ERR_FATAL;
1215 goto out;
1216 }
1217
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001218 if (proto->sock_prot != IPPROTO_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001219 ha_alert("parsing [%s:%d] : '%s %s' : TCP not supported for this address family.\n",
1220 file, linenum, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001221 err_code |= ERR_ALERT | ERR_FATAL;
1222 goto out;
1223 }
1224
Simon Horman0d16a402015-01-30 11:22:58 +09001225 newmailer->addr = *sk;
1226 newmailer->proto = proto;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01001227 newmailer->xprt = xprt_get(XPRT_RAW);
Simon Horman0d16a402015-01-30 11:22:58 +09001228 newmailer->sock_init_arg = NULL;
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001229 }
1230 else if (strcmp(args[0], "timeout") == 0) {
1231 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001232 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments.\n",
1233 file, linenum, args[0]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001234 err_code |= ERR_ALERT | ERR_FATAL;
1235 goto out;
1236 }
1237 else if (strcmp(args[1], "mail") == 0) {
1238 const char *res;
1239 unsigned int timeout_mail;
1240 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001241 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1242 file, linenum, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001243 err_code |= ERR_ALERT | ERR_FATAL;
1244 goto out;
1245 }
1246 res = parse_time_err(args[2], &timeout_mail, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001247 if (res == PARSE_TIME_OVER) {
1248 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1249 file, linenum, args[2], args[0], args[1]);
1250 err_code |= ERR_ALERT | ERR_FATAL;
1251 goto out;
1252 }
1253 else if (res == PARSE_TIME_UNDER) {
1254 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1255 file, linenum, args[2], args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001256 err_code |= ERR_ALERT | ERR_FATAL;
1257 goto out;
1258 }
Willy Tarreau9faebe32019-06-07 19:00:37 +02001259 else if (res) {
1260 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1261 file, linenum, *res, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001262 err_code |= ERR_ALERT | ERR_FATAL;
1263 goto out;
1264 }
1265 curmailers->timeout.mail = timeout_mail;
1266 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001267 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments got '%s'.\n",
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001268 file, linenum, args[0], args[1]);
1269 err_code |= ERR_ALERT | ERR_FATAL;
1270 goto out;
1271 }
1272 }
Simon Horman0d16a402015-01-30 11:22:58 +09001273 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001274 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Simon Horman0d16a402015-01-30 11:22:58 +09001275 err_code |= ERR_ALERT | ERR_FATAL;
1276 goto out;
1277 }
1278
1279out:
1280 free(errmsg);
1281 return err_code;
1282}
1283
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +01001284void free_email_alert(struct proxy *p)
Simon Horman9dc49962015-01-30 11:22:59 +09001285{
Willy Tarreau61cfdf42021-02-20 10:46:51 +01001286 ha_free(&p->email_alert.mailers.name);
1287 ha_free(&p->email_alert.from);
1288 ha_free(&p->email_alert.to);
1289 ha_free(&p->email_alert.myhostname);
Simon Horman9dc49962015-01-30 11:22:59 +09001290}
1291
Willy Tarreaubaaee002006-06-26 02:48:02 +02001292
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001293int
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001294cfg_parse_netns(const char *file, int linenum, char **args, int kwm)
1295{
Willy Tarreaue5733232019-05-22 19:24:06 +02001296#ifdef USE_NS
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001297 const char *err;
1298 const char *item = args[0];
1299
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001300 if (strcmp(item, "namespace_list") == 0) {
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001301 return 0;
1302 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001303 else if (strcmp(item, "namespace") == 0) {
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001304 size_t idx = 1;
1305 const char *current;
1306 while (*(current = args[idx++])) {
1307 err = invalid_char(current);
1308 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001309 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1310 file, linenum, *err, item, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001311 return ERR_ALERT | ERR_FATAL;
1312 }
1313
1314 if (netns_store_lookup(current, strlen(current))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001315 ha_alert("parsing [%s:%d]: Namespace '%s' is already added.\n",
1316 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001317 return ERR_ALERT | ERR_FATAL;
1318 }
1319 if (!netns_store_insert(current)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001320 ha_alert("parsing [%s:%d]: Cannot open namespace '%s'.\n",
1321 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001322 return ERR_ALERT | ERR_FATAL;
1323 }
1324 }
1325 }
1326
1327 return 0;
1328#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001329 ha_alert("parsing [%s:%d]: namespace support is not compiled in.",
1330 file, linenum);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001331 return ERR_ALERT | ERR_FATAL;
1332#endif
1333}
1334
1335int
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001336cfg_parse_users(const char *file, int linenum, char **args, int kwm)
1337{
1338
1339 int err_code = 0;
1340 const char *err;
1341
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001342 if (strcmp(args[0], "userlist") == 0) { /* new userlist */
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001343 struct userlist *newul;
1344
1345 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001346 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1347 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001348 err_code |= ERR_ALERT | ERR_FATAL;
1349 goto out;
1350 }
William Lallemand6e62fb62015-04-28 16:55:23 +02001351 if (alertif_too_many_args(1, file, linenum, args, &err_code))
1352 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001353
1354 err = invalid_char(args[1]);
1355 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001356 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1357 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001358 err_code |= ERR_ALERT | ERR_FATAL;
1359 goto out;
1360 }
1361
1362 for (newul = userlist; newul; newul = newul->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001363 if (strcmp(newul->name, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001364 ha_warning("parsing [%s:%d]: ignoring duplicated userlist '%s'.\n",
1365 file, linenum, args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001366 err_code |= ERR_WARN;
1367 goto out;
1368 }
1369
Vincent Bernat02779b62016-04-03 13:48:43 +02001370 newul = calloc(1, sizeof(*newul));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001371 if (!newul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001372 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001373 err_code |= ERR_ALERT | ERR_ABORT;
1374 goto out;
1375 }
1376
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001377 newul->name = strdup(args[1]);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001378 if (!newul->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001379 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001380 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier97880bb2016-04-08 10:35:26 +01001381 free(newul);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001382 goto out;
1383 }
1384
1385 newul->next = userlist;
1386 userlist = newul;
1387
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001388 } else if (strcmp(args[0], "group") == 0) { /* new group */
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001389 int cur_arg;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001390 const char *err;
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001391 struct auth_groups *ag;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001392
1393 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001394 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1395 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001396 err_code |= ERR_ALERT | ERR_FATAL;
1397 goto out;
1398 }
1399
1400 err = invalid_char(args[1]);
1401 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001402 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1403 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001404 err_code |= ERR_ALERT | ERR_FATAL;
1405 goto out;
1406 }
1407
William Lallemand4ac9f542015-05-28 18:03:51 +02001408 if (!userlist)
1409 goto out;
1410
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001411 for (ag = userlist->groups; ag; ag = ag->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001412 if (strcmp(ag->name, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001413 ha_warning("parsing [%s:%d]: ignoring duplicated group '%s' in userlist '%s'.\n",
1414 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001415 err_code |= ERR_ALERT;
1416 goto out;
1417 }
1418
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001419 ag = calloc(1, sizeof(*ag));
1420 if (!ag) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001421 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001422 err_code |= ERR_ALERT | ERR_ABORT;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001423 goto out;
1424 }
1425
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001426 ag->name = strdup(args[1]);
David Carlier70d60452016-08-22 23:27:42 +01001427 if (!ag->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001428 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001429 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier70d60452016-08-22 23:27:42 +01001430 free(ag);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001431 goto out;
1432 }
1433
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001434 cur_arg = 2;
1435
1436 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001437 if (strcmp(args[cur_arg], "users") == 0) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001438 ag->groupusers = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001439 cur_arg += 2;
1440 continue;
1441 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001442 ha_alert("parsing [%s:%d]: '%s' only supports 'users' option.\n",
1443 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001444 err_code |= ERR_ALERT | ERR_FATAL;
David Carlier70d60452016-08-22 23:27:42 +01001445 free(ag->groupusers);
1446 free(ag->name);
1447 free(ag);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001448 goto out;
1449 }
1450 }
1451
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001452 ag->next = userlist->groups;
1453 userlist->groups = ag;
1454
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001455 } else if (strcmp(args[0], "user") == 0) { /* new user */
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001456 struct auth_users *newuser;
1457 int cur_arg;
1458
1459 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001460 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1461 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001462 err_code |= ERR_ALERT | ERR_FATAL;
1463 goto out;
1464 }
William Lallemand4ac9f542015-05-28 18:03:51 +02001465 if (!userlist)
1466 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001467
1468 for (newuser = userlist->users; newuser; newuser = newuser->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001469 if (strcmp(newuser->user, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001470 ha_warning("parsing [%s:%d]: ignoring duplicated user '%s' in userlist '%s'.\n",
1471 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001472 err_code |= ERR_ALERT;
1473 goto out;
1474 }
1475
Vincent Bernat02779b62016-04-03 13:48:43 +02001476 newuser = calloc(1, sizeof(*newuser));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001477 if (!newuser) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001478 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001479 err_code |= ERR_ALERT | ERR_ABORT;
1480 goto out;
1481 }
1482
1483 newuser->user = strdup(args[1]);
1484
1485 newuser->next = userlist->users;
1486 userlist->users = newuser;
1487
1488 cur_arg = 2;
1489
1490 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001491 if (strcmp(args[cur_arg], "password") == 0) {
Willy Tarreaue5733232019-05-22 19:24:06 +02001492#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001493 if (!crypt("", args[cur_arg + 1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001494 ha_alert("parsing [%s:%d]: the encrypted password used for user '%s' is not supported by crypt(3).\n",
1495 file, linenum, newuser->user);
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001496 err_code |= ERR_ALERT | ERR_FATAL;
1497 goto out;
1498 }
1499#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001500 ha_warning("parsing [%s:%d]: no crypt(3) support compiled, encrypted passwords will not work.\n",
1501 file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001502 err_code |= ERR_ALERT;
1503#endif
1504 newuser->pass = strdup(args[cur_arg + 1]);
1505 cur_arg += 2;
1506 continue;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001507 } else if (strcmp(args[cur_arg], "insecure-password") == 0) {
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001508 newuser->pass = strdup(args[cur_arg + 1]);
1509 newuser->flags |= AU_O_INSECURE;
1510 cur_arg += 2;
1511 continue;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001512 } else if (strcmp(args[cur_arg], "groups") == 0) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001513 newuser->u.groups_names = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001514 cur_arg += 2;
1515 continue;
1516 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001517 ha_alert("parsing [%s:%d]: '%s' only supports 'password', 'insecure-password' and 'groups' options.\n",
1518 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001519 err_code |= ERR_ALERT | ERR_FATAL;
1520 goto out;
1521 }
1522 }
1523 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001524 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 +01001525 err_code |= ERR_ALERT | ERR_FATAL;
1526 }
1527
1528out:
1529 return err_code;
1530}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001531
Christopher Faulet79bdef32016-11-04 22:36:15 +01001532int
1533cfg_parse_scope(const char *file, int linenum, char *line)
1534{
1535 char *beg, *end, *scope = NULL;
1536 int err_code = 0;
1537 const char *err;
1538
1539 beg = line + 1;
1540 end = strchr(beg, ']');
1541
1542 /* Detect end of scope declaration */
1543 if (!end || end == beg) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001544 ha_alert("parsing [%s:%d] : empty scope name is forbidden.\n",
1545 file, linenum);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001546 err_code |= ERR_ALERT | ERR_FATAL;
1547 goto out;
1548 }
1549
1550 /* Get scope name and check its validity */
1551 scope = my_strndup(beg, end-beg);
1552 err = invalid_char(scope);
1553 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001554 ha_alert("parsing [%s:%d] : character '%c' is not permitted in a scope name.\n",
1555 file, linenum, *err);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001556 err_code |= ERR_ALERT | ERR_ABORT;
1557 goto out;
1558 }
1559
1560 /* Be sure to have a scope declaration alone on its line */
1561 line = end+1;
1562 while (isspace((unsigned char)*line))
1563 line++;
1564 if (*line && *line != '#' && *line != '\n' && *line != '\r') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001565 ha_alert("parsing [%s:%d] : character '%c' is not permitted after scope declaration.\n",
1566 file, linenum, *line);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001567 err_code |= ERR_ALERT | ERR_ABORT;
1568 goto out;
1569 }
1570
1571 /* We have a valid scope declaration, save it */
1572 free(cfg_scope);
1573 cfg_scope = scope;
1574 scope = NULL;
1575
1576 out:
1577 free(scope);
1578 return err_code;
1579}
1580
Frédéric Lécaillea41d5312018-01-29 12:05:07 +01001581int
1582cfg_parse_track_sc_num(unsigned int *track_sc_num,
1583 const char *arg, const char *end, char **errmsg)
1584{
1585 const char *p;
1586 unsigned int num;
1587
1588 p = arg;
1589 num = read_uint64(&arg, end);
1590
1591 if (arg != end) {
1592 memprintf(errmsg, "Wrong track-sc number '%s'", p);
1593 return -1;
1594 }
1595
1596 if (num >= MAX_SESS_STKCTR) {
1597 memprintf(errmsg, "%u track-sc number exceeding "
1598 "%d (MAX_SESS_STKCTR-1) value", num, MAX_SESS_STKCTR - 1);
1599 return -1;
1600 }
1601
1602 *track_sc_num = num;
1603 return 0;
1604}
1605
Willy Tarreaubaaee002006-06-26 02:48:02 +02001606/*
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001607 * Detect a global section after a non-global one and output a diagnostic
1608 * warning.
1609 */
1610static void check_section_position(char *section_name,
1611 const char *file, int linenum,
1612 int *non_global_parsed)
1613{
1614 if (!strcmp(section_name, "global")) {
1615 if (*non_global_parsed == 1)
1616 _ha_diag_warning("parsing [%s:%d] : global section detected after a non-global one, the prevalence of their statements is unspecified\n", file, linenum);
1617 }
1618 else if (*non_global_parsed == 0) {
1619 *non_global_parsed = 1;
1620 }
1621}
1622
Willy Tarreau8a022d52021-04-27 20:29:11 +02001623/* apply the current default_path setting for config file <file>, and
1624 * optionally replace the current path to <origin> if not NULL while the
1625 * default-path mode is set to "origin". Errors are returned into an
1626 * allocated string passed to <err> if it's not NULL. Returns 0 on failure
1627 * or non-zero on success.
1628 */
1629static int cfg_apply_default_path(const char *file, const char *origin, char **err)
1630{
1631 const char *beg, *end;
1632
1633 /* make path start at <beg> and end before <end>, and switch it to ""
1634 * if no slash was passed.
1635 */
1636 beg = file;
1637 end = strrchr(beg, '/');
1638 if (!end)
1639 end = beg;
1640
1641 if (!*initial_cwd) {
1642 if (getcwd(initial_cwd, sizeof(initial_cwd)) == NULL) {
1643 if (err)
1644 memprintf(err, "Impossible to retrieve startup directory name: %s", strerror(errno));
1645 return 0;
1646 }
1647 }
1648 else if (chdir(initial_cwd) == -1) {
1649 if (err)
1650 memprintf(err, "Impossible to get back to initial directory '%s': %s", initial_cwd, strerror(errno));
1651 return 0;
1652 }
1653
1654 /* OK now we're (back) to initial_cwd */
1655
1656 switch (default_path_mode) {
1657 case DEFAULT_PATH_CURRENT:
1658 /* current_cwd never set, nothing to do */
1659 return 1;
1660
1661 case DEFAULT_PATH_ORIGIN:
1662 /* current_cwd set in the config */
1663 if (origin &&
1664 snprintf(current_cwd, sizeof(current_cwd), "%s", origin) > sizeof(current_cwd)) {
1665 if (err)
1666 memprintf(err, "Absolute path too long: '%s'", origin);
1667 return 0;
1668 }
1669 break;
1670
1671 case DEFAULT_PATH_CONFIG:
1672 if (end - beg >= sizeof(current_cwd)) {
1673 if (err)
1674 memprintf(err, "Config file path too long, cannot use for relative paths: '%s'", file);
1675 return 0;
1676 }
1677 memcpy(current_cwd, beg, end - beg);
1678 current_cwd[end - beg] = 0;
1679 break;
1680
1681 case DEFAULT_PATH_PARENT:
1682 if (end - beg + 3 >= sizeof(current_cwd)) {
1683 if (err)
1684 memprintf(err, "Config file path too long, cannot use for relative paths: '%s'", file);
1685 return 0;
1686 }
1687 memcpy(current_cwd, beg, end - beg);
1688 if (end > beg)
1689 memcpy(current_cwd + (end - beg), "/..\0", 4);
1690 else
1691 memcpy(current_cwd + (end - beg), "..\0", 3);
1692 break;
1693 }
1694
1695 if (*current_cwd && chdir(current_cwd) == -1) {
1696 if (err)
1697 memprintf(err, "Impossible to get back to directory '%s': %s", initial_cwd, strerror(errno));
1698 return 0;
1699 }
1700
1701 return 1;
1702}
1703
1704/* parses a global "default-path" directive. */
1705static int cfg_parse_global_def_path(char **args, int section_type, struct proxy *curpx,
1706 const struct proxy *defpx, const char *file, int line,
1707 char **err)
1708{
1709 int ret = -1;
1710
1711 /* "current", "config", "parent", "origin <path>" */
1712
1713 if (strcmp(args[1], "current") == 0)
1714 default_path_mode = DEFAULT_PATH_CURRENT;
1715 else if (strcmp(args[1], "config") == 0)
1716 default_path_mode = DEFAULT_PATH_CONFIG;
1717 else if (strcmp(args[1], "parent") == 0)
1718 default_path_mode = DEFAULT_PATH_PARENT;
1719 else if (strcmp(args[1], "origin") == 0)
1720 default_path_mode = DEFAULT_PATH_ORIGIN;
1721 else {
1722 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]);
1723 goto end;
1724 }
1725
1726 if (default_path_mode == DEFAULT_PATH_ORIGIN) {
1727 if (!*args[2]) {
1728 memprintf(err, "'%s %s' expects a directory as an argument.", args[0], args[1]);
1729 goto end;
1730 }
1731 if (!cfg_apply_default_path(file, args[2], err)) {
1732 memprintf(err, "couldn't set '%s' to origin '%s': %s.", args[0], args[2], *err);
1733 goto end;
1734 }
1735 }
1736 else if (!cfg_apply_default_path(file, NULL, err)) {
1737 memprintf(err, "couldn't set '%s' to '%s': %s.", args[0], args[1], *err);
1738 goto end;
1739 }
1740
1741 /* note that once applied, the path is immediately updated */
1742
1743 ret = 0;
1744 end:
1745 return ret;
1746}
1747
Willy Tarreau732525f2021-05-06 15:49:04 +02001748/* looks up a cond predicate matching the keyword in <str>, possibly followed
1749 * by a parenthesis. Returns a pointer to it or NULL if not found.
1750 */
1751static const struct cond_pred_kw *cfg_lookup_cond_pred(const char *str)
1752{
1753 const struct cond_pred_kw *ret;
1754 int len = strcspn(str, " (");
1755
1756 for (ret = &cond_predicates[0]; ret->word; ret++) {
1757 if (len != strlen(ret->word))
1758 continue;
1759 if (strncmp(str, ret->word, len) != 0)
1760 continue;
1761 return ret;
1762 }
1763 return NULL;
1764}
1765
Willy Tarreau6a2110c2021-05-06 08:19:48 +02001766/* evaluate a condition on a .if/.elif line. The condition is already tokenized
1767 * in <err>. Returns -1 on error (in which case err is filled with a message,
Willy Tarreau299bd1c2021-05-06 15:07:10 +02001768 * and only in this case), 0 if the condition is false, 1 if it's true. If
1769 * <errptr> is not NULL, it's set to the first invalid character on error.
Willy Tarreau6a2110c2021-05-06 08:19:48 +02001770 */
Willy Tarreau299bd1c2021-05-06 15:07:10 +02001771static int cfg_eval_condition(char **args, char **err, const char **errptr)
Willy Tarreau6a2110c2021-05-06 08:19:48 +02001772{
Willy Tarreau732525f2021-05-06 15:49:04 +02001773 const struct cond_pred_kw *cond_pred = NULL;
1774 const char *end_ptr;
1775 struct arg *argp = NULL;
1776 int err_arg;
1777 int nbargs;
1778 int ret = -1;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02001779 char *end;
1780 long val;
1781
1782 if (!*args[0]) /* note: empty = false */
1783 return 0;
1784
1785 val = strtol(args[0], &end, 0);
1786 if (end && *end == '\0')
1787 return val != 0;
1788
Willy Tarreau732525f2021-05-06 15:49:04 +02001789 /* below we'll likely all make_arg_list() so we must return only via
1790 * the <done> label which frees the arg list.
1791 */
1792 cond_pred = cfg_lookup_cond_pred(args[0]);
1793 if (cond_pred) {
1794 nbargs = make_arg_list(args[0] + strlen(cond_pred->word), -1,
1795 cond_pred->arg_mask, &argp, err,
1796 &end_ptr, &err_arg, NULL);
1797
1798 if (nbargs < 0) {
1799 memprintf(err, "%s in argument %d of predicate '%s' used in conditional expression", *err, err_arg, cond_pred->word);
1800 if (errptr)
1801 *errptr = end_ptr;
1802 goto done;
1803 }
1804
1805 /* here we know we have a valid predicate with <nbargs> valid
1806 * arguments, placed in <argp> (which we'll need to free).
1807 */
1808 switch (cond_pred->prd) {
Willy Tarreau42ed14b2021-05-06 15:55:14 +02001809 case CFG_PRED_DEFINED: // checks if arg exists as an environment variable
1810 ret = getenv(argp[0].data.str.area) != NULL;
1811 goto done;
1812
Willy Tarreau58ca7062021-05-06 16:34:23 +02001813 case CFG_PRED_FEATURE: { // checks if the arg matches an enabled feature
1814 const char *p;
1815
1816 for (p = build_features; (p = strstr(p, argp[0].data.str.area)); p++) {
1817 if ((p[argp[0].data.str.data] == ' ' || p[argp[0].data.str.data] == 0) &&
1818 p > build_features) {
1819 if (*(p-1) == '+') { // "+OPENSSL"
1820 ret = 1;
1821 goto done;
1822 }
1823 else if (*(p-1) == '-') { // "-OPENSSL"
1824 ret = 0;
1825 goto done;
1826 }
1827 /* it was a sub-word, let's restart from next place */
1828 }
1829 }
1830 /* not found */
1831 ret = 0;
1832 goto done;
1833 }
Willy Tarreau6492e872021-05-06 16:10:09 +02001834 case CFG_PRED_STREQ: // checks if the two arg are equal
1835 ret = strcmp(argp[0].data.str.area, argp[1].data.str.area) == 0;
1836 goto done;
1837
1838 case CFG_PRED_STRNEQ: // checks if the two arg are different
1839 ret = strcmp(argp[0].data.str.area, argp[1].data.str.area) != 0;
1840 goto done;
1841
Willy Tarreau0b7c78a2021-05-06 16:53:26 +02001842 case CFG_PRED_VERSION_ATLEAST: // checks if the current version is at least this one
1843 ret = compare_current_version(argp[0].data.str.area) <= 0;
1844 goto done;
1845
1846 case CFG_PRED_VERSION_BEFORE: // checks if the current version is older than this one
1847 ret = compare_current_version(argp[0].data.str.area) > 0;
1848 goto done;
1849
Willy Tarreau732525f2021-05-06 15:49:04 +02001850 default:
1851 memprintf(err, "internal error: unhandled conditional expression predicate '%s'", cond_pred->word);
1852 if (errptr)
1853 *errptr = args[0];
1854 goto done;
1855 }
1856 }
1857
Willy Tarreau299bd1c2021-05-06 15:07:10 +02001858 memprintf(err, "unparsable conditional expression '%s'", args[0]);
1859 if (errptr)
1860 *errptr = args[0];
Willy Tarreau732525f2021-05-06 15:49:04 +02001861 done:
1862 for (nbargs = 0; argp && argp[nbargs].type != ARGT_STOP; nbargs++) {
1863 if (argp[nbargs].type == ARGT_STR)
1864 free(argp[nbargs].data.str.area);
1865 }
1866 free(argp);
1867 return ret;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02001868}
Willy Tarreau8a022d52021-04-27 20:29:11 +02001869
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001870/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02001871 * This function reads and parses the configuration file given in the argument.
Willy Tarreauda543e12021-04-27 18:30:28 +02001872 * Returns the error code, 0 if OK, -1 if the config file couldn't be opened,
1873 * or any combination of :
Willy Tarreau058e9072009-07-20 09:30:05 +02001874 * - ERR_ABORT: must abort ASAP
1875 * - ERR_FATAL: we can continue parsing but not start the service
1876 * - ERR_WARN: a warning has been emitted
1877 * - ERR_ALERT: an alert has been emitted
1878 * Only the two first ones can stop processing, the two others are just
1879 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001880 */
Willy Tarreaub17916e2006-10-15 15:17:57 +02001881int readcfgfile(const char *file)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001882{
Willy Tarreauda543e12021-04-27 18:30:28 +02001883 char *thisline = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02001884 int linesize = LINESIZE;
Willy Tarreauda543e12021-04-27 18:30:28 +02001885 FILE *f = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001886 int linenum = 0;
Willy Tarreau058e9072009-07-20 09:30:05 +02001887 int err_code = 0;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001888 struct cfg_section *cs = NULL, *pcs = NULL;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001889 struct cfg_section *ics;
William Lallemand64e84512015-05-12 14:25:37 +02001890 int readbytes = 0;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001891 char *outline = NULL;
1892 size_t outlen = 0;
1893 size_t outlinesize = 0;
Willy Tarreau32234e72020-06-16 17:14:33 +02001894 int fatal = 0;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001895 int missing_lf = -1;
Willy Tarreau4b103022021-02-12 17:59:10 +01001896 int nested_cond_lvl = 0;
1897 enum nested_cond_state nested_conds[MAXNESTEDCONDS];
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001898 int non_global_section_parsed = 0;
Willy Tarreau8a022d52021-04-27 20:29:11 +02001899 char *errmsg = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02001900
Willy Tarreau51508052021-05-06 10:04:45 +02001901 global.cfg_curr_line = 0;
1902 global.cfg_curr_file = file;
1903
William Lallemand64e84512015-05-12 14:25:37 +02001904 if ((thisline = malloc(sizeof(*thisline) * linesize)) == NULL) {
Willy Tarreauda543e12021-04-27 18:30:28 +02001905 ha_alert("Out of memory trying to allocate a buffer for a configuration line.\n");
1906 err_code = -1;
1907 goto err;
William Lallemand64e84512015-05-12 14:25:37 +02001908 }
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001909
Willy Tarreauda543e12021-04-27 18:30:28 +02001910 if ((f = fopen(file,"r")) == NULL) {
1911 err_code = -1;
1912 goto err;
David Carlier97880bb2016-04-08 10:35:26 +01001913 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001914
Willy Tarreau8a022d52021-04-27 20:29:11 +02001915 /* change to the new dir if required */
1916 if (!cfg_apply_default_path(file, NULL, &errmsg)) {
1917 ha_alert("parsing [%s:%d]: failed to apply default-path: %s.\n", file, linenum, errmsg);
1918 free(errmsg);
1919 err_code = -1;
1920 goto err;
1921 }
1922
William Lallemandb2f07452015-05-12 14:27:13 +02001923next_line:
William Lallemand64e84512015-05-12 14:25:37 +02001924 while (fgets(thisline + readbytes, linesize - readbytes, f) != NULL) {
Willy Tarreau3842f002009-06-14 11:39:52 +02001925 int arg, kwm = KWM_STD;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001926 char *end;
1927 char *args[MAX_LINE_ARGS + 1];
1928 char *line = thisline;
1929
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001930 if (missing_lf != -1) {
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001931 ha_alert("parsing [%s:%d]: Stray NUL character at position %d.\n",
1932 file, linenum, (missing_lf + 1));
1933 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001934 missing_lf = -1;
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001935 break;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001936 }
1937
Willy Tarreaubaaee002006-06-26 02:48:02 +02001938 linenum++;
Willy Tarreau51508052021-05-06 10:04:45 +02001939 global.cfg_curr_line = linenum;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001940
Willy Tarreau32234e72020-06-16 17:14:33 +02001941 if (fatal >= 50) {
1942 ha_alert("parsing [%s:%d]: too many fatal errors (%d), stopping now.\n", file, linenum, fatal);
1943 break;
1944 }
1945
Willy Tarreaubaaee002006-06-26 02:48:02 +02001946 end = line + strlen(line);
1947
William Lallemand64e84512015-05-12 14:25:37 +02001948 if (end-line == linesize-1 && *(end-1) != '\n') {
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001949 /* Check if we reached the limit and the last char is not \n.
1950 * Watch out for the last line without the terminating '\n'!
1951 */
William Lallemand64e84512015-05-12 14:25:37 +02001952 char *newline;
1953 int newlinesize = linesize * 2;
1954
1955 newline = realloc(thisline, sizeof(*thisline) * newlinesize);
1956 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001957 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1958 file, linenum);
William Lallemand64e84512015-05-12 14:25:37 +02001959 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001960 fatal++;
Willy Tarreau40cb26f2020-06-25 09:37:54 +02001961 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001962 continue;
1963 }
1964
1965 readbytes = linesize - 1;
1966 linesize = newlinesize;
1967 thisline = newline;
Willy Tarreau40cb26f2020-06-25 09:37:54 +02001968 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001969 continue;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001970 }
1971
William Lallemand64e84512015-05-12 14:25:37 +02001972 readbytes = 0;
1973
Willy Tarreau08488f62020-06-26 17:24:54 +02001974 if (end > line && *(end-1) == '\n') {
Tim Duesterhus70f58992020-06-22 22:57:44 +02001975 /* kill trailing LF */
1976 *(end - 1) = 0;
1977 }
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001978 else {
1979 /* mark this line as truncated */
1980 missing_lf = end - line;
1981 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001982
Willy Tarreaubaaee002006-06-26 02:48:02 +02001983 /* skip leading spaces */
Willy Tarreau8f8e6452007-06-17 21:51:38 +02001984 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001985 line++;
William Lallemandf9873ba2015-05-05 17:37:14 +02001986
Joseph Herlanta14c03e2018-11-15 14:04:19 -08001987 if (*line == '[') {/* This is the beginning if a scope */
Christopher Faulet79bdef32016-11-04 22:36:15 +01001988 err_code |= cfg_parse_scope(file, linenum, line);
1989 goto next_line;
1990 }
1991
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001992 while (1) {
1993 uint32_t err;
1994 char *errptr;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001995
Willy Tarreau61dd44b2020-06-25 07:35:42 +02001996 arg = MAX_LINE_ARGS + 1;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001997 outlen = outlinesize;
1998 err = parse_line(line, outline, &outlen, args, &arg,
1999 PARSE_OPT_ENV | PARSE_OPT_DQUOTE | PARSE_OPT_SQUOTE |
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02002000 PARSE_OPT_BKSLASH | PARSE_OPT_SHARP | PARSE_OPT_WORD_EXPAND,
2001 &errptr);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002002
2003 if (err & PARSE_ERR_QUOTE) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02002004 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
2005
2006 ha_alert("parsing [%s:%d]: unmatched quote at position %d:\n"
2007 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002008 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02002009 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002010 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002011 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002012
2013 if (err & PARSE_ERR_BRACE) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02002014 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
2015
2016 ha_alert("parsing [%s:%d]: unmatched brace in environment variable name at position %d:\n"
2017 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002018 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02002019 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002020 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002021 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002022
2023 if (err & PARSE_ERR_VARNAME) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02002024 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
2025
2026 ha_alert("parsing [%s:%d]: forbidden first char in environment variable name at position %d:\n"
2027 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002028 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02002029 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002030 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002031 }
William Lallemandb2f07452015-05-12 14:27:13 +02002032
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002033 if (err & PARSE_ERR_HEX) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02002034 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
2035
2036 ha_alert("parsing [%s:%d]: truncated or invalid hexadecimal sequence at position %d:\n"
2037 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002038 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus9f658a52020-06-16 18:14:21 +02002039 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002040 goto next_line;
2041 }
William Lallemandb2f07452015-05-12 14:27:13 +02002042
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02002043 if (err & PARSE_ERR_WRONG_EXPAND) {
2044 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
2045
2046 ha_alert("parsing [%s:%d]: truncated or invalid word expansion sequence at position %d:\n"
2047 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
2048 err_code |= ERR_ALERT | ERR_FATAL;
2049 fatal++;
2050 goto next_line;
2051 }
2052
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002053 if (err & (PARSE_ERR_TOOLARGE|PARSE_ERR_OVERLAP)) {
2054 outlinesize = (outlen + 1023) & -1024;
Ilya Shipitsin76837bc2021-01-07 22:45:13 +05002055 outline = my_realloc2(outline, outlinesize);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002056 if (outline == NULL) {
2057 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
2058 file, linenum);
Willy Tarreau0c68be72022-05-20 09:13:38 +02002059 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
Willy Tarreau32234e72020-06-16 17:14:33 +02002060 fatal++;
Christopher Faulet6ae99cb2022-05-18 16:22:43 +02002061 outlinesize = 0;
Willy Tarreau0c68be72022-05-20 09:13:38 +02002062 goto err;
William Lallemandb2f07452015-05-12 14:27:13 +02002063 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002064 /* try again */
2065 continue;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002066 }
Willy Tarreau07d47062020-06-25 07:41:22 +02002067
2068 if (err & PARSE_ERR_TOOMANY) {
2069 /* only check this *after* being sure the output is allocated */
2070 ha_alert("parsing [%s:%d]: too many words, truncating after word %d, position %ld: <%s>.\n",
2071 file, linenum, MAX_LINE_ARGS, (long)(args[MAX_LINE_ARGS-1] - outline + 1), args[MAX_LINE_ARGS-1]);
2072 err_code |= ERR_ALERT | ERR_FATAL;
2073 fatal++;
2074 goto next_line;
2075 }
2076
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002077 /* everything's OK */
2078 break;
William Lallemandf9873ba2015-05-05 17:37:14 +02002079 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002080
2081 /* empty line */
2082 if (!**args)
2083 continue;
2084
Willy Tarreau4b103022021-02-12 17:59:10 +01002085 /* check for config macros */
2086 if (*args[0] == '.') {
2087 if (strcmp(args[0], ".if") == 0) {
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002088 const char *errptr = NULL;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002089 char *errmsg = NULL;
2090 int cond;
2091
Tim Duesterhusf41ea3e2021-05-26 17:45:33 +02002092 if (*args[2]) {
2093 ha_warning("parsing [%s:%d]: Unexpected argument '%s' for '%s'.\n",
2094 file, linenum, args[2], args[0]);
2095 err_code |= ERR_WARN;
2096 }
2097
Willy Tarreau4b103022021-02-12 17:59:10 +01002098 nested_cond_lvl++;
2099 if (nested_cond_lvl >= MAXNESTEDCONDS) {
2100 ha_alert("parsing [%s:%d]: too many nested '.if', max is %d.\n", file, linenum, MAXNESTEDCONDS);
2101 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2102 goto err;
2103 }
2104
Willy Tarreau6e647c92021-05-06 08:46:11 +02002105 if (nested_cond_lvl > 1 &&
2106 (nested_conds[nested_cond_lvl - 1] == NESTED_COND_IF_DROP ||
2107 nested_conds[nested_cond_lvl - 1] == NESTED_COND_IF_SKIP ||
2108 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELIF_DROP ||
2109 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELIF_SKIP ||
2110 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELSE_DROP)) {
Willy Tarreau4b103022021-02-12 17:59:10 +01002111 nested_conds[nested_cond_lvl] = NESTED_COND_IF_SKIP;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002112 goto next_line;
2113 }
2114
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002115 cond = cfg_eval_condition(args + 1, &errmsg, &errptr);
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002116 if (cond < 0) {
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002117 size_t newpos = sanitize_for_printing(args[1], errptr - args[1], 76);
2118
2119 ha_alert("parsing [%s:%d]: %s in '.if' at position %d:\n .if %s\n %*s\n",
2120 file, linenum, errmsg,
2121 (int)(errptr-args[1]+1), args[1], (int)(newpos+5), "^");
2122
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002123 free(errmsg);
Willy Tarreau4b103022021-02-12 17:59:10 +01002124 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2125 goto err;
2126 }
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002127
2128 if (cond)
2129 nested_conds[nested_cond_lvl] = NESTED_COND_IF_TAKE;
2130 else
2131 nested_conds[nested_cond_lvl] = NESTED_COND_IF_DROP;
2132
Willy Tarreau4b103022021-02-12 17:59:10 +01002133 goto next_line;
2134 }
2135 else if (strcmp(args[0], ".elif") == 0) {
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002136 const char *errptr = NULL;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002137 char *errmsg = NULL;
2138 int cond;
2139
Tim Duesterhusf41ea3e2021-05-26 17:45:33 +02002140 if (*args[2]) {
2141 ha_warning("parsing [%s:%d]: Unexpected argument '%s' for '%s'.\n",
2142 file, linenum, args[2], args[0]);
2143 err_code |= ERR_WARN;
2144 }
2145
Willy Tarreau4b103022021-02-12 17:59:10 +01002146 if (!nested_cond_lvl) {
2147 ha_alert("parsing [%s:%d]: lone '.elif' with no matching '.if'.\n", file, linenum);
2148 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2149 goto err;
2150 }
2151
2152 if (nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_TAKE ||
2153 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP) {
2154 ha_alert("parsing [%s:%d]: '.elif' after '.else' is not permitted.\n", file, linenum);
2155 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2156 goto err;
2157 }
2158
2159 if (nested_conds[nested_cond_lvl] == NESTED_COND_IF_TAKE ||
2160 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
Willy Tarreauf67ff022021-05-06 08:48:09 +02002161 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_TAKE ||
Willy Tarreau4b103022021-02-12 17:59:10 +01002162 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP) {
2163 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_SKIP;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002164 goto next_line;
2165 }
2166
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002167 cond = cfg_eval_condition(args + 1, &errmsg, &errptr);
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002168 if (cond < 0) {
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002169 size_t newpos = sanitize_for_printing(args[1], errptr - args[1], 74);
2170
2171 ha_alert("parsing [%s:%d]: %s in '.elif' at position %d:\n .elif %s\n %*s\n",
2172 file, linenum, errmsg,
2173 (int)(errptr-args[1]+1), args[1], (int)(newpos+7), "^");
2174
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002175 free(errmsg);
Willy Tarreau4b103022021-02-12 17:59:10 +01002176 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2177 goto err;
2178 }
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002179
2180 if (cond)
2181 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_TAKE;
2182 else
2183 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_DROP;
2184
Willy Tarreau4b103022021-02-12 17:59:10 +01002185 goto next_line;
2186 }
2187 else if (strcmp(args[0], ".else") == 0) {
Tim Duesterhusf41ea3e2021-05-26 17:45:33 +02002188 if (*args[1]) {
2189 ha_warning("parsing [%s:%d]: Unxpected argument '%s' for '%s'.\n",
2190 file, linenum, args[1], args[0]);
2191 err_code |= ERR_WARN;
2192 }
2193
Willy Tarreau4b103022021-02-12 17:59:10 +01002194 if (!nested_cond_lvl) {
2195 ha_alert("parsing [%s:%d]: lone '.else' with no matching '.if'.\n", file, linenum);
2196 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2197 goto err;
2198 }
2199
2200 if (nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_TAKE ||
2201 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP) {
2202 ha_alert("parsing [%s:%d]: '.else' after '.else' is not permitted.\n", file, linenum);
2203 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2204 goto err;
2205 }
2206
2207 if (nested_conds[nested_cond_lvl] == NESTED_COND_IF_TAKE ||
2208 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
2209 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_TAKE ||
2210 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP) {
2211 nested_conds[nested_cond_lvl] = NESTED_COND_ELSE_DROP;
2212 } else {
2213 /* otherwise we take the "else" */
2214 nested_conds[nested_cond_lvl] = NESTED_COND_ELSE_TAKE;
2215 }
2216 goto next_line;
2217 }
2218 else if (strcmp(args[0], ".endif") == 0) {
Tim Duesterhusf41ea3e2021-05-26 17:45:33 +02002219 if (*args[1]) {
2220 ha_warning("parsing [%s:%d]: Unxpected argument '%s' for '%s'.\n",
2221 file, linenum, args[1], args[0]);
2222 err_code |= ERR_WARN;
2223 }
2224
Willy Tarreau4b103022021-02-12 17:59:10 +01002225 if (!nested_cond_lvl) {
2226 ha_alert("parsing [%s:%d]: lone '.endif' with no matching '.if'.\n", file, linenum);
Tim Duesterhusf41ea3e2021-05-26 17:45:33 +02002227 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
Willy Tarreau4b103022021-02-12 17:59:10 +01002228 break;
2229 }
2230 nested_cond_lvl--;
2231 goto next_line;
2232 }
2233 }
2234
2235 if (nested_cond_lvl &&
2236 (nested_conds[nested_cond_lvl] == NESTED_COND_IF_DROP ||
2237 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
2238 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_DROP ||
2239 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP ||
2240 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP)) {
2241 /* The current block is masked out by the conditions */
2242 goto next_line;
2243 }
2244
Willy Tarreau7190b982021-05-07 08:59:50 +02002245 /* .warning/.error/.notice/.diag */
Willy Tarreau4b103022021-02-12 17:59:10 +01002246 if (*args[0] == '.') {
2247 if (strcmp(args[0], ".alert") == 0) {
Tim Duesterhusf41ea3e2021-05-26 17:45:33 +02002248 if (*args[2]) {
2249 ha_warning("parsing [%s:%d]: Unexpected argument '%s' for '%s'. Use quotes if the message should contain spaces.\n",
2250 file, linenum, args[2], args[0]);
2251 err_code |= ERR_WARN;
2252 }
2253
Willy Tarreau4b103022021-02-12 17:59:10 +01002254 ha_alert("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
2255 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2256 goto err;
2257 }
2258 else if (strcmp(args[0], ".warning") == 0) {
Tim Duesterhusf41ea3e2021-05-26 17:45:33 +02002259 if (*args[2]) {
2260 ha_warning("parsing [%s:%d]: Unexpected argument '%s' for '%s'. Use quotes if the message should contain spaces.\n",
2261 file, linenum, args[2], args[0]);
2262 err_code |= ERR_WARN;
2263 }
2264
Willy Tarreau4b103022021-02-12 17:59:10 +01002265 ha_warning("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
2266 err_code |= ERR_WARN;
2267 goto next_line;
2268 }
2269 else if (strcmp(args[0], ".notice") == 0) {
Tim Duesterhusf41ea3e2021-05-26 17:45:33 +02002270 if (*args[2]) {
2271 ha_warning("parsing [%s:%d]: Unexpected argument '%s' for '%s'. Use quotes if the message should contain spaces.\n",
2272 file, linenum, args[2], args[0]);
2273 err_code |= ERR_WARN;
2274 }
2275
Willy Tarreau4b103022021-02-12 17:59:10 +01002276 ha_notice("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
2277 goto next_line;
2278 }
Willy Tarreau7190b982021-05-07 08:59:50 +02002279 else if (strcmp(args[0], ".diag") == 0) {
Tim Duesterhusf41ea3e2021-05-26 17:45:33 +02002280 if (*args[2]) {
2281 ha_warning("parsing [%s:%d]: Unexpected argument '%s' for '%s'. Use quotes if the message should contain spaces.\n",
2282 file, linenum, args[2], args[0]);
2283 err_code |= ERR_WARN;
2284 }
2285
Willy Tarreau7190b982021-05-07 08:59:50 +02002286 ha_diag_warning("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
2287 goto next_line;
2288 }
Willy Tarreau4b103022021-02-12 17:59:10 +01002289 else {
2290 ha_alert("parsing [%s:%d]: unknown directive '%s'.\n", file, linenum, args[0]);
2291 err_code |= ERR_ALERT | ERR_FATAL;
2292 fatal++;
2293 break;
2294 }
2295 }
2296
Willy Tarreau3842f002009-06-14 11:39:52 +02002297 /* check for keyword modifiers "no" and "default" */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002298 if (strcmp(args[0], "no") == 0) {
William Lallemand0f99e342011-10-12 17:50:54 +02002299 char *tmp;
2300
Willy Tarreau3842f002009-06-14 11:39:52 +02002301 kwm = KWM_NO;
William Lallemand0f99e342011-10-12 17:50:54 +02002302 tmp = args[0];
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002303 for (arg=0; *args[arg+1]; arg++)
2304 args[arg] = args[arg+1]; // shift args after inversion
William Lallemand0f99e342011-10-12 17:50:54 +02002305 *tmp = '\0'; // fix the next arg to \0
2306 args[arg] = tmp;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002307 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002308 else if (strcmp(args[0], "default") == 0) {
Willy Tarreau3842f002009-06-14 11:39:52 +02002309 kwm = KWM_DEF;
2310 for (arg=0; *args[arg+1]; arg++)
2311 args[arg] = args[arg+1]; // shift args after inversion
2312 }
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002313
William Dauchyec730982019-10-27 20:08:10 +01002314 if (kwm != KWM_STD && strcmp(args[0], "option") != 0 &&
2315 strcmp(args[0], "log") != 0 && strcmp(args[0], "busy-polling") != 0 &&
Willy Tarreaud96f1122019-12-03 07:07:36 +01002316 strcmp(args[0], "set-dumpable") != 0 && strcmp(args[0], "strict-limits") != 0 &&
Amaury Denoyelle0f50cb92021-03-26 18:50:33 +01002317 strcmp(args[0], "insecure-fork-wanted") != 0 &&
2318 strcmp(args[0], "numa-cpu-mapping") != 0) {
William Dauchyec730982019-10-27 20:08:10 +01002319 ha_alert("parsing [%s:%d]: negation/default currently "
William Dauchy0fec3ab2019-10-27 20:08:11 +01002320 "supported only for options, log, busy-polling, "
Amaury Denoyelle0f50cb92021-03-26 18:50:33 +01002321 "set-dumpable, strict-limits, insecure-fork-wanted "
2322 "and numa-cpu-mapping.\n", file, linenum);
Willy Tarreau058e9072009-07-20 09:30:05 +02002323 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02002324 fatal++;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002325 }
2326
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002327 /* detect section start */
2328 list_for_each_entry(ics, &sections, list) {
2329 if (strcmp(args[0], ics->section_name) == 0) {
2330 cursection = ics->section_name;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002331 pcs = cs;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002332 cs = ics;
Willy Tarreau51508052021-05-06 10:04:45 +02002333 free(global.cfg_curr_section);
2334 global.cfg_curr_section = strdup(*args[1] ? args[1] : args[0]);
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02002335
2336 if (global.mode & MODE_DIAG) {
2337 check_section_position(args[0], file, linenum,
2338 &non_global_section_parsed);
2339 }
2340
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002341 break;
2342 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002343 }
2344
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002345 if (pcs && pcs->post_section_parser) {
Willy Tarreau32234e72020-06-16 17:14:33 +02002346 int status;
2347
2348 status = pcs->post_section_parser();
2349 err_code |= status;
2350 if (status & ERR_FATAL)
2351 fatal++;
2352
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002353 if (err_code & ERR_ABORT)
2354 goto err;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002355 }
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002356 pcs = NULL;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002357
William Lallemandd2ff56d2017-10-16 11:06:50 +02002358 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002359 ha_alert("parsing [%s:%d]: unknown keyword '%s' out of section.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02002360 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02002361 fatal++;
William Lallemandd2ff56d2017-10-16 11:06:50 +02002362 } else {
Willy Tarreau32234e72020-06-16 17:14:33 +02002363 int status;
2364
2365 status = cs->section_parser(file, linenum, args, kwm);
2366 err_code |= status;
2367 if (status & ERR_FATAL)
2368 fatal++;
2369
William Lallemandd2ff56d2017-10-16 11:06:50 +02002370 if (err_code & ERR_ABORT)
2371 goto err;
2372 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002373 }
William Lallemandd2ff56d2017-10-16 11:06:50 +02002374
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02002375 if (missing_lf != -1) {
Tim Duesterhusf92afb72020-08-18 22:00:04 +02002376 ha_alert("parsing [%s:%d]: Missing LF on last line, file might have been truncated at position %d.\n",
2377 file, linenum, (missing_lf + 1));
2378 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02002379 }
2380
Willy Tarreau51508052021-05-06 10:04:45 +02002381 ha_free(&global.cfg_curr_section);
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002382 if (cs && cs->post_section_parser)
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002383 err_code |= cs->post_section_parser();
William Lallemandd2ff56d2017-10-16 11:06:50 +02002384
Willy Tarreau4b103022021-02-12 17:59:10 +01002385 if (nested_cond_lvl) {
2386 ha_alert("parsing [%s:%d]: non-terminated '.if' block.\n", file, linenum);
2387 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2388 }
Willy Tarreau8a022d52021-04-27 20:29:11 +02002389
2390 if (*initial_cwd && chdir(initial_cwd) == -1) {
2391 ha_alert("Impossible to get back to initial directory '%s' : %s\n", initial_cwd, strerror(errno));
2392 err_code |= ERR_ALERT | ERR_FATAL;
2393 }
2394
William Lallemandd2ff56d2017-10-16 11:06:50 +02002395err:
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002396 ha_free(&cfg_scope);
Willy Tarreau6daf3432008-01-22 16:44:08 +01002397 cursection = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02002398 free(thisline);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002399 free(outline);
Willy Tarreau51508052021-05-06 10:04:45 +02002400 global.cfg_curr_line = 0;
2401 global.cfg_curr_file = NULL;
2402
Willy Tarreauda543e12021-04-27 18:30:28 +02002403 if (f)
2404 fclose(f);
2405
Willy Tarreau058e9072009-07-20 09:30:05 +02002406 return err_code;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002407}
2408
Willy Tarreau64ab6072014-09-16 12:17:36 +02002409/* This function propagates processes from frontend <from> to backend <to> so
2410 * that it is always guaranteed that a backend pointed to by a frontend is
2411 * bound to all of its processes. After that, if the target is a "listen"
2412 * instance, the function recursively descends the target's own targets along
Willy Tarreau98d04852015-05-26 12:18:29 +02002413 * default_backend and use_backend rules. Since the bits are
Willy Tarreau64ab6072014-09-16 12:17:36 +02002414 * checked first to ensure that <to> is already bound to all processes of
2415 * <from>, there is no risk of looping and we ensure to follow the shortest
2416 * path to the destination.
2417 *
2418 * It is possible to set <to> to NULL for the first call so that the function
2419 * takes care of visiting the initial frontend in <from>.
2420 *
2421 * It is important to note that the function relies on the fact that all names
2422 * have already been resolved.
2423 */
2424void propagate_processes(struct proxy *from, struct proxy *to)
2425{
2426 struct switching_rule *rule;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002427
2428 if (to) {
2429 /* check whether we need to go down */
2430 if (from->bind_proc &&
2431 (from->bind_proc & to->bind_proc) == from->bind_proc)
2432 return;
2433
2434 if (!from->bind_proc && !to->bind_proc)
2435 return;
2436
2437 to->bind_proc = from->bind_proc ?
2438 (to->bind_proc | from->bind_proc) : 0;
2439
2440 /* now propagate down */
2441 from = to;
2442 }
2443
Willy Tarreau8a95d8c2014-12-18 13:56:26 +01002444 if (!(from->cap & PR_CAP_FE))
Willy Tarreau64ab6072014-09-16 12:17:36 +02002445 return;
2446
Willy Tarreauc3914d42020-09-24 08:39:22 +02002447 if (from->disabled)
Willy Tarreauf6b70012014-12-18 14:00:43 +01002448 return;
2449
Willy Tarreau64ab6072014-09-16 12:17:36 +02002450 /* default_backend */
2451 if (from->defbe.be)
2452 propagate_processes(from, from->defbe.be);
2453
2454 /* use_backend */
2455 list_for_each_entry(rule, &from->switching_rules, list) {
Cyril Bonté51639692014-10-02 19:56:25 +02002456 if (rule->dynamic)
2457 continue;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002458 to = rule->be.backend;
2459 propagate_processes(from, to);
2460 }
Willy Tarreau64ab6072014-09-16 12:17:36 +02002461}
2462
Willy Tarreau6bfc10c2021-05-14 08:30:46 +02002463#if defined(USE_THREAD) && defined(__linux__) && defined USE_CPU_AFFINITY
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002464/* filter directory name of the pattern node<X> */
2465static int numa_filter(const struct dirent *dir)
2466{
2467 char *endptr;
2468
2469 /* dir name must start with "node" prefix */
2470 if (strncmp(dir->d_name, "node", 4))
2471 return 0;
2472
2473 /* dir name must be at least 5 characters long */
2474 if (!dir->d_name[4])
2475 return 0;
2476
2477 /* dir name must end with a numeric id */
2478 if (strtol(&dir->d_name[4], &endptr, 10) < 0 || *endptr)
2479 return 0;
2480
2481 /* all tests succeeded */
2482 return 1;
2483}
2484
2485/* Parse a linux cpu map string representing to a numeric cpu mask map
2486 * The cpu map string is a list of 4-byte hex strings separated by commas, with
2487 * most-significant byte first, one bit per cpu number.
2488 */
2489static void parse_cpumap(char *cpumap_str, struct hap_cpuset *cpu_set)
2490{
2491 unsigned long cpumap;
2492 char *start, *endptr, *comma;
2493 int i, j;
2494
2495 ha_cpuset_zero(cpu_set);
2496
2497 i = 0;
2498 do {
2499 /* reverse-search for a comma, parse the string after the comma
2500 * or at the beginning if no comma found
2501 */
2502 comma = strrchr(cpumap_str, ',');
2503 start = comma ? comma + 1 : cpumap_str;
2504
2505 cpumap = strtoul(start, &endptr, 16);
2506 for (j = 0; cpumap; cpumap >>= 1, ++j) {
2507 if (cpumap & 0x1)
2508 ha_cpuset_set(cpu_set, j + i * 32);
2509 }
2510
2511 if (comma)
2512 *comma = '\0';
2513 ++i;
2514 } while (comma);
2515}
2516
2517/* Read the first line of a file from <path> into the trash buffer.
2518 * Returns 0 on success, otherwise non-zero.
2519 */
2520static int read_file_to_trash(const char *path)
2521{
2522 FILE *file;
2523 int ret = 1;
2524
2525 file = fopen(path, "r");
2526 if (file) {
2527 if (fgets(trash.area, trash.size, file))
2528 ret = 0;
2529
2530 fclose(file);
2531 }
2532
2533 return ret;
2534}
2535
2536/* Inspect the cpu topology of the machine on startup. If a multi-socket
2537 * machine is detected, try to bind on the first node with active cpu. This is
2538 * done to prevent an impact on the overall performance when the topology of
2539 * the machine is unknown. This function is not called if one of the conditions
2540 * is met :
2541 * - a non-null nbthread directive is active
2542 * - a restrictive cpu-map directive is active
2543 * - a restrictive affinity is already applied, for example via taskset
2544 *
2545 * Returns the count of cpus selected. If no automatic binding was required or
2546 * an error occurred and the topology is unknown, 0 is returned.
2547 */
2548static int numa_detect_topology()
2549{
2550 struct dirent **node_dirlist;
2551 int node_dirlist_size;
2552
2553 struct hap_cpuset active_cpus, node_cpu_set;
2554 const char *parse_cpu_set_args[2];
2555 char cpumap_path[PATH_MAX];
2556 char *err = NULL;
2557
2558 /* node_cpu_set count is used as return value */
2559 ha_cpuset_zero(&node_cpu_set);
2560
2561 /* 1. count the sysfs node<X> directories */
Willy Tarreau07bf21c2021-04-23 19:09:16 +02002562 node_dirlist = NULL;
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002563 node_dirlist_size = scandir(NUMA_DETECT_SYSTEM_SYSFS_PATH"/node", &node_dirlist, numa_filter, alphasort);
2564 if (node_dirlist_size <= 1)
2565 goto free_scandir_entries;
2566
2567 /* 2. read and parse the list of currently online cpu */
2568 if (read_file_to_trash(NUMA_DETECT_SYSTEM_SYSFS_PATH"/cpu/online")) {
2569 ha_notice("Cannot read online CPUs list, will not try to refine binding\n");
2570 goto free_scandir_entries;
2571 }
2572
2573 parse_cpu_set_args[0] = trash.area;
2574 parse_cpu_set_args[1] = "\0";
2575 if (parse_cpu_set(parse_cpu_set_args, &active_cpus, 1, &err)) {
2576 ha_notice("Cannot read online CPUs list: '%s'. Will not try to refine binding\n", err);
2577 free(err);
2578 goto free_scandir_entries;
2579 }
2580
2581 /* 3. loop through nodes dirs and find the first one with active cpus */
2582 while (node_dirlist_size--) {
2583 const char *node = node_dirlist[node_dirlist_size]->d_name;
2584 ha_cpuset_zero(&node_cpu_set);
2585
2586 snprintf(cpumap_path, PATH_MAX, "%s/node/%s/cpumap",
2587 NUMA_DETECT_SYSTEM_SYSFS_PATH, node);
2588
2589 if (read_file_to_trash(cpumap_path)) {
2590 ha_notice("Cannot read CPUs list of '%s', will not select them to refine binding\n", node);
2591 free(node_dirlist[node_dirlist_size]);
2592 continue;
2593 }
2594
2595 parse_cpumap(trash.area, &node_cpu_set);
2596 ha_cpuset_and(&node_cpu_set, &active_cpus);
2597
2598 /* 5. set affinity on the first found node with active cpus */
2599 if (!ha_cpuset_count(&node_cpu_set)) {
2600 free(node_dirlist[node_dirlist_size]);
2601 continue;
2602 }
2603
2604 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));
2605 if (sched_setaffinity(getpid(), sizeof(node_cpu_set.cpuset), &node_cpu_set.cpuset) == -1) {
2606 ha_warning("Cannot set the cpu affinity for this multi-cpu machine\n");
2607
2608 /* clear the cpuset used as return value */
2609 ha_cpuset_zero(&node_cpu_set);
2610 }
2611
2612 free(node_dirlist[node_dirlist_size]);
2613 break;
2614 }
2615
2616 free_scandir_entries:
2617 while (node_dirlist_size-- > 0)
2618 free(node_dirlist[node_dirlist_size]);
2619 free(node_dirlist);
2620
2621 return ha_cpuset_count(&node_cpu_set);
2622}
2623#endif /* __linux__ && USE_CPU_AFFINITY */
2624
Willy Tarreaubb925012009-07-23 13:36:36 +02002625/*
2626 * Returns the error code, 0 if OK, or any combination of :
2627 * - ERR_ABORT: must abort ASAP
2628 * - ERR_FATAL: we can continue parsing but not start the service
2629 * - ERR_WARN: a warning has been emitted
2630 * - ERR_ALERT: an alert has been emitted
2631 * Only the two first ones can stop processing, the two others are just
2632 * indicators.
2633 */
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002634int check_config_validity()
2635{
2636 int cfgerr = 0;
2637 struct proxy *curproxy = NULL;
Emeric Brunfe0979f2022-08-18 15:53:21 +02002638 struct proxy *init_proxies_list = NULL;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002639 struct stktable *t;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002640 struct server *newsrv = NULL;
Willy Tarreaubb925012009-07-23 13:36:36 +02002641 int err_code = 0;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002642 unsigned int next_pxid = 1;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002643 struct bind_conf *bind_conf;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002644 char *err;
William Lallemand48b4bb42017-10-23 14:36:34 +02002645 struct cfg_postparser *postparser;
Emeric Brun750fe792020-12-23 16:51:12 +01002646 struct resolvers *curr_resolvers = NULL;
Amaury Denoyelle3efee652021-03-08 17:31:39 +01002647 int i;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002648
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002649 bind_conf = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002650 /*
2651 * Now, check for the integrity of all that we have collected.
2652 */
2653
Willy Tarreau193b8c62012-11-22 00:17:38 +01002654 if (!global.tune.max_http_hdr)
2655 global.tune.max_http_hdr = MAX_HTTP_HDR;
2656
2657 if (!global.tune.cookie_len)
2658 global.tune.cookie_len = CAPTURE_LEN;
2659
Stéphane Cottin23e9e932017-05-18 08:58:41 +02002660 if (!global.tune.requri_len)
2661 global.tune.requri_len = REQURI_LEN;
2662
Willy Tarreau149ab772019-01-26 14:27:06 +01002663 if (!global.nbthread) {
2664 /* nbthread not set, thus automatic. In this case, and only if
2665 * running on a single process, we enable the same number of
2666 * threads as the number of CPUs the process is bound to. This
2667 * allows to easily control the number of threads using taskset.
2668 */
2669 global.nbthread = 1;
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002670
Willy Tarreau149ab772019-01-26 14:27:06 +01002671#if defined(USE_THREAD)
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002672 if (global.nbproc == 1) {
2673 int numa_cores = 0;
2674#if defined(__linux__) && defined USE_CPU_AFFINITY
Amaury Denoyelle0f50cb92021-03-26 18:50:33 +01002675 if (global.numa_cpu_mapping && !thread_cpu_mask_forced())
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002676 numa_cores = numa_detect_topology();
2677#endif
2678 global.nbthread = numa_cores ? numa_cores :
2679 thread_cpus_enabled_at_boot;
Willy Tarreaufea6f522023-03-09 11:47:55 +01002680
2681 if (global.nbthread > MAX_THREADS) {
2682 ha_diag_warning("nbthread not set, found %d CPUs, limiting to %d threads. Please set nbthreads in the global section to silence this warning.\n",
2683 global.nbthread, MAX_THREADS);
2684 global.nbthread = MAX_THREADS;
2685 }
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002686 }
Willy Tarreau149ab772019-01-26 14:27:06 +01002687 all_threads_mask = nbits(global.nbthread);
2688#endif
2689 }
2690
Willy Tarreau26f6ae12019-02-02 12:56:15 +01002691 if (global.nbproc > 1 && global.nbthread > 1) {
2692 ha_alert("config : cannot enable multiple processes if multiple threads are configured. Please use either nbproc or nbthread but not both.\n");
2693 err_code |= ERR_ALERT | ERR_FATAL;
2694 goto out;
2695 }
2696
Willy Tarreaubafbe012017-11-24 17:34:44 +01002697 pool_head_requri = create_pool("requri", global.tune.requri_len , MEM_F_SHARED);
Emeric Brun96fd9262017-07-05 13:33:16 +02002698
Willy Tarreaubafbe012017-11-24 17:34:44 +01002699 pool_head_capture = create_pool("capture", global.tune.cookie_len, MEM_F_SHARED);
Willy Tarreau193b8c62012-11-22 00:17:38 +01002700
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002701 /* Post initialisation of the users and groups lists. */
2702 err_code = userlist_postinit();
2703 if (err_code != ERR_NONE)
2704 goto out;
2705
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002706 /* first, we will invert the proxy list order */
2707 curproxy = NULL;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002708 while (proxies_list) {
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002709 struct proxy *next;
2710
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002711 next = proxies_list->next;
2712 proxies_list->next = curproxy;
2713 curproxy = proxies_list;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002714 if (!next)
2715 break;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002716 proxies_list = next;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002717 }
2718
Emeric Brunfe0979f2022-08-18 15:53:21 +02002719 /* starting to initialize the main proxies list */
2720 init_proxies_list = proxies_list;
2721
2722init_proxies_list_stage1:
2723 for (curproxy = init_proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002724 struct switching_rule *rule;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002725 struct server_rule *srule;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002726 struct sticking_rule *mrule;
Dragan Dosen1322d092015-09-22 16:05:32 +02002727 struct logsrv *tmplogsrv;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002728 unsigned int next_id;
Willy Tarreau16a21472012-11-19 12:39:59 +01002729 int nbproc;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002730
Willy Tarreau050536d2012-10-04 08:47:34 +02002731 if (curproxy->uuid < 0) {
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002732 /* proxy ID not set, use automatic numbering with first
2733 * spare entry starting with next_pxid.
2734 */
2735 next_pxid = get_next_id(&used_proxy_id, next_pxid);
2736 curproxy->conf.id.key = curproxy->uuid = next_pxid;
2737 eb32_insert(&used_proxy_id, &curproxy->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002738 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01002739 next_pxid++;
2740
Willy Tarreau95d08102021-08-26 15:59:44 +02002741 if (curproxy->mode == PR_MODE_HTTP && global.tune.bufsize >= (256 << 20) && ONLY_ONCE()) {
2742 ha_alert("global.tune.bufsize must be below 256 MB when HTTP is in use (current value = %d).\n",
2743 global.tune.bufsize);
2744 cfgerr++;
2745 }
Willy Tarreau55ea7572007-06-17 19:56:27 +02002746
Willy Tarreauc3914d42020-09-24 08:39:22 +02002747 if (curproxy->disabled) {
Willy Tarreau02b092f2020-10-07 18:36:54 +02002748 /* ensure we don't keep listeners uselessly bound. We
2749 * can't disable their listeners yet (fdtab not
2750 * allocated yet) but let's skip them.
2751 */
Dragan Dosen7d61a332019-05-07 14:16:18 +02002752 if (curproxy->table) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002753 ha_free(&curproxy->table->peers.name);
Dragan Dosen7d61a332019-05-07 14:16:18 +02002754 curproxy->table->peers.p = NULL;
2755 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002756 continue;
2757 }
2758
Willy Tarreau102df612014-05-07 23:56:38 +02002759 /* Check multi-process mode compatibility for the current proxy */
2760
2761 if (curproxy->bind_proc) {
2762 /* an explicit bind-process was specified, let's check how many
2763 * processes remain.
2764 */
David Carliere6c39412015-07-02 07:00:17 +00002765 nbproc = my_popcountl(curproxy->bind_proc);
Willy Tarreau102df612014-05-07 23:56:38 +02002766
Willy Tarreaua38a7172019-02-02 17:11:28 +01002767 curproxy->bind_proc &= all_proc_mask;
Willy Tarreau102df612014-05-07 23:56:38 +02002768 if (!curproxy->bind_proc && nbproc == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002769 ha_warning("Proxy '%s': the process specified on the 'bind-process' directive refers to a process number that is higher than global.nbproc. The proxy has been forced to run on process 1 only.\n", curproxy->id);
Willy Tarreau102df612014-05-07 23:56:38 +02002770 curproxy->bind_proc = 1;
2771 }
2772 else if (!curproxy->bind_proc && nbproc > 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002773 ha_warning("Proxy '%s': all processes specified on the 'bind-process' directive refer to numbers that are all higher than global.nbproc. The directive was ignored and the proxy will run on all processes.\n", curproxy->id);
Willy Tarreau102df612014-05-07 23:56:38 +02002774 curproxy->bind_proc = 0;
2775 }
2776 }
2777
Willy Tarreau3d209582014-05-09 17:06:11 +02002778 /* check and reduce the bind-proc of each listener */
2779 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
2780 unsigned long mask;
2781
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002782 /* HTTP frontends with "h2" as ALPN/NPN will work in
2783 * HTTP/2 and absolutely require buffers 16kB or larger.
2784 */
2785#ifdef USE_OPENSSL
2786 if (curproxy->mode == PR_MODE_HTTP && global.tune.bufsize < 16384) {
2787#ifdef OPENSSL_NPN_NEGOTIATED
2788 /* check NPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002789 if (bind_conf->ssl_conf.npn_str && strstr(bind_conf->ssl_conf.npn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002790 ha_alert("config : HTTP frontend '%s' enables HTTP/2 via NPN at [%s:%d], so global.tune.bufsize must be at least 16384 bytes (%d now).\n",
2791 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002792 cfgerr++;
2793 }
2794#endif
2795#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
2796 /* check ALPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002797 if (bind_conf->ssl_conf.alpn_str && strstr(bind_conf->ssl_conf.alpn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002798 ha_alert("config : HTTP frontend '%s' enables HTTP/2 via ALPN at [%s:%d], so global.tune.bufsize must be at least 16384 bytes (%d now).\n",
2799 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002800 cfgerr++;
2801 }
2802#endif
2803 } /* HTTP && bufsize < 16384 */
2804#endif
2805
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002806 /* detect and address thread affinity inconsistencies */
Willy Tarreaue26993c2020-09-03 07:18:55 +02002807 mask = thread_mask(bind_conf->settings.bind_thread);
Willy Tarreau3d957172019-02-02 18:00:17 +01002808 if (!(mask & all_threads_mask)) {
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002809 unsigned long new_mask = 0;
2810
2811 while (mask) {
Willy Tarreau0c026f42018-08-01 19:12:20 +02002812 new_mask |= mask & all_threads_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002813 mask >>= global.nbthread;
2814 }
2815
Willy Tarreaue26993c2020-09-03 07:18:55 +02002816 bind_conf->settings.bind_thread = new_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002817 ha_warning("Proxy '%s': the thread range specified on the 'process' directive of 'bind %s' at [%s:%d] only refers to thread numbers out of the range defined by the global 'nbthread' directive. The thread numbers were remapped to existing threads instead (mask 0x%lx).\n",
2818 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line, new_mask);
2819 }
2820
2821 /* detect process and nbproc affinity inconsistencies */
Willy Tarreaue26993c2020-09-03 07:18:55 +02002822 mask = proc_mask(bind_conf->settings.bind_proc) & proc_mask(curproxy->bind_proc);
Willy Tarreaua36b3242019-02-02 13:14:34 +01002823 if (!(mask & all_proc_mask)) {
2824 mask = proc_mask(curproxy->bind_proc) & all_proc_mask;
Willy Tarreaue26993c2020-09-03 07:18:55 +02002825 nbproc = my_popcountl(bind_conf->settings.bind_proc);
2826 bind_conf->settings.bind_proc = proc_mask(bind_conf->settings.bind_proc) & mask;
Willy Tarreau3d209582014-05-09 17:06:11 +02002827
Willy Tarreaue26993c2020-09-03 07:18:55 +02002828 if (!bind_conf->settings.bind_proc && nbproc == 1) {
Willy Tarreaua36b3242019-02-02 13:14:34 +01002829 ha_warning("Proxy '%s': the process number specified on the 'process' directive of 'bind %s' at [%s:%d] refers to a process not covered by the proxy. This has been fixed by forcing it to run on the proxy's first process only.\n",
2830 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreaue26993c2020-09-03 07:18:55 +02002831 bind_conf->settings.bind_proc = mask & ~(mask - 1);
Willy Tarreaua36b3242019-02-02 13:14:34 +01002832 }
Willy Tarreaue26993c2020-09-03 07:18:55 +02002833 else if (!bind_conf->settings.bind_proc && nbproc > 1) {
Willy Tarreaua36b3242019-02-02 13:14:34 +01002834 ha_warning("Proxy '%s': the process range specified on the 'process' directive of 'bind %s' at [%s:%d] only refers to processes not covered by the proxy. The directive was ignored so that all of the proxy's processes are used.\n",
2835 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreaue26993c2020-09-03 07:18:55 +02002836 bind_conf->settings.bind_proc = 0;
Willy Tarreaua36b3242019-02-02 13:14:34 +01002837 }
Willy Tarreau3d209582014-05-09 17:06:11 +02002838 }
2839 }
2840
Willy Tarreauff01a212009-03-15 13:46:16 +01002841 switch (curproxy->mode) {
Willy Tarreauff01a212009-03-15 13:46:16 +01002842 case PR_MODE_TCP:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002843 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002844 break;
2845
2846 case PR_MODE_HTTP:
Willy Tarreau25320b22013-03-24 07:22:08 +01002847 curproxy->http_needed = 1;
Willy Tarreauff01a212009-03-15 13:46:16 +01002848 break;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002849
2850 case PR_MODE_CLI:
2851 cfgerr += proxy_cfg_ensure_no_http(curproxy);
2852 break;
Emeric Brunfe0979f2022-08-18 15:53:21 +02002853
Emeric Brun54932b42020-07-07 09:43:24 +02002854 case PR_MODE_SYSLOG:
Emeric Brunfe0979f2022-08-18 15:53:21 +02002855 /* this mode is initialized as the classic tcp proxy */
2856 cfgerr += proxy_cfg_ensure_no_http(curproxy);
2857 break;
2858
Willy Tarreaua389c9e2020-10-07 17:49:42 +02002859 case PR_MODE_PEERS:
Emeric Brun54932b42020-07-07 09:43:24 +02002860 case PR_MODES:
2861 /* should not happen, bug gcc warn missing switch statement */
Emeric Brunfe0979f2022-08-18 15:53:21 +02002862 ha_alert("config: %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 +02002863 proxy_type_str(curproxy), curproxy->id);
2864 cfgerr++;
2865 break;
Willy Tarreauff01a212009-03-15 13:46:16 +01002866 }
2867
Willy Tarreau4975d142021-03-13 11:00:33 +01002868 if (curproxy != global.cli_fe && (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->conf.listeners)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002869 ha_warning("config : %s '%s' has no 'bind' directive. Please declare it as a backend if this was intended.\n",
2870 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauf3934b82015-08-11 11:36:45 +02002871 err_code |= ERR_WARN;
2872 }
2873
Willy Tarreau77e0dae2020-10-14 15:44:27 +02002874 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002875 if (curproxy->lbprm.algo & BE_LB_KIND) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002876 if (curproxy->options & PR_O_TRANSP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002877 ha_alert("config : %s '%s' cannot use both transparent and balance mode.\n",
2878 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002879 cfgerr++;
2880 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002881#ifdef WE_DONT_SUPPORT_SERVERLESS_LISTENERS
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002882 else if (curproxy->srv == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002883 ha_alert("config : %s '%s' needs at least 1 server in balance mode.\n",
2884 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002885 cfgerr++;
2886 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002887#endif
Willy Tarreau1620ec32011-08-06 17:05:02 +02002888 else if (curproxy->options & PR_O_DISPATCH) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002889 ha_warning("config : dispatch address of %s '%s' will be ignored in balance mode.\n",
2890 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002891 err_code |= ERR_WARN;
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002892 }
2893 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02002894 else if (!(curproxy->options & (PR_O_TRANSP | PR_O_DISPATCH | PR_O_HTTP_PROXY))) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002895 /* If no LB algo is set in a backend, and we're not in
2896 * transparent mode, dispatch mode nor proxy mode, we
2897 * want to use balance roundrobin by default.
2898 */
2899 curproxy->lbprm.algo &= ~BE_LB_ALGO;
2900 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002901 }
2902 }
Willy Tarreau193cf932007-09-17 10:17:23 +02002903
Willy Tarreau1620ec32011-08-06 17:05:02 +02002904 if (curproxy->options & PR_O_DISPATCH)
2905 curproxy->options &= ~(PR_O_TRANSP | PR_O_HTTP_PROXY);
2906 else if (curproxy->options & PR_O_HTTP_PROXY)
2907 curproxy->options &= ~(PR_O_DISPATCH | PR_O_TRANSP);
2908 else if (curproxy->options & PR_O_TRANSP)
2909 curproxy->options &= ~(PR_O_DISPATCH | PR_O_HTTP_PROXY);
Willy Tarreau82936582007-11-30 15:20:09 +01002910
Christopher Faulete5870d82020-04-15 11:32:03 +02002911 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_HTTP_RS)) {
2912 ha_warning("config : %s '%s' uses http-check rules without 'option httpchk', so the rules are ignored.\n",
2913 proxy_type_str(curproxy), curproxy->id);
2914 err_code |= ERR_WARN;
2915 }
2916
2917 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_TCPCHK_CHK &&
Christopher Fauletc0fcbe42020-06-03 19:00:42 +02002918 (curproxy->tcpcheck_rules.flags & TCPCHK_RULES_PROTO_CHK) != TCPCHK_RULES_HTTP_CHK) {
Willy Tarreau1620ec32011-08-06 17:05:02 +02002919 if (curproxy->options & PR_O_DISABLE404) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002920 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2921 "disable-on-404", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002922 err_code |= ERR_WARN;
2923 curproxy->options &= ~PR_O_DISABLE404;
2924 }
2925 if (curproxy->options2 & PR_O2_CHK_SNDST) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002926 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2927 "send-state", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002928 err_code |= ERR_WARN;
2929 curproxy->options &= ~PR_O2_CHK_SNDST;
2930 }
Willy Tarreauef781042010-01-27 11:53:01 +01002931 }
2932
Simon Horman98637e52014-06-20 12:30:16 +09002933 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_EXT_CHK) {
2934 if (!global.external_check) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002935 ha_alert("Proxy '%s' : '%s' unable to find required 'global.external-check'.\n",
2936 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002937 cfgerr++;
2938 }
2939 if (!curproxy->check_command) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002940 ha_alert("Proxy '%s' : '%s' unable to find required 'external-check command'.\n",
2941 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002942 cfgerr++;
2943 }
Willy Tarreaud96f1122019-12-03 07:07:36 +01002944 if (!(global.tune.options & GTUNE_INSECURE_FORK)) {
2945 ha_warning("Proxy '%s' : 'insecure-fork-wanted' not enabled in the global section, '%s' will likely fail.\n",
2946 curproxy->id, "option external-check");
2947 err_code |= ERR_WARN;
2948 }
Simon Horman98637e52014-06-20 12:30:16 +09002949 }
2950
Simon Horman64e34162015-02-06 11:11:57 +09002951 if (curproxy->email_alert.set) {
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002952 if (!(curproxy->email_alert.mailers.name && curproxy->email_alert.from && curproxy->email_alert.to)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002953 ha_warning("config : 'email-alert' will be ignored for %s '%s' (the presence any of "
2954 "'email-alert from', 'email-alert level' 'email-alert mailers', "
2955 "'email-alert myhostname', or 'email-alert to' "
2956 "requires each of 'email-alert from', 'email-alert mailers' and 'email-alert to' "
2957 "to be present).\n",
2958 proxy_type_str(curproxy), curproxy->id);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002959 err_code |= ERR_WARN;
2960 free_email_alert(curproxy);
2961 }
2962 if (!curproxy->email_alert.myhostname)
Cyril Bontée22bfd62015-12-04 03:07:07 +01002963 curproxy->email_alert.myhostname = strdup(hostname);
Simon Horman9dc49962015-01-30 11:22:59 +09002964 }
2965
Simon Horman98637e52014-06-20 12:30:16 +09002966 if (curproxy->check_command) {
2967 int clear = 0;
2968 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002969 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2970 "external-check command", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002971 err_code |= ERR_WARN;
2972 clear = 1;
2973 }
2974 if (curproxy->check_command[0] != '/' && !curproxy->check_path) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002975 ha_alert("Proxy '%s': '%s' does not have a leading '/' and 'external-check path' is not set.\n",
2976 curproxy->id, "external-check command");
Simon Horman98637e52014-06-20 12:30:16 +09002977 cfgerr++;
2978 }
2979 if (clear) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002980 ha_free(&curproxy->check_command);
Simon Horman98637e52014-06-20 12:30:16 +09002981 }
2982 }
2983
2984 if (curproxy->check_path) {
2985 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002986 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2987 "external-check path", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002988 err_code |= ERR_WARN;
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002989 ha_free(&curproxy->check_path);
Simon Horman98637e52014-06-20 12:30:16 +09002990 }
2991 }
2992
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002993 /* if a default backend was specified, let's find it */
2994 if (curproxy->defbe.name) {
2995 struct proxy *target;
2996
Willy Tarreauafb39922015-05-26 12:04:09 +02002997 target = proxy_be_by_name(curproxy->defbe.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002998 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002999 ha_alert("Proxy '%s': unable to find required default_backend: '%s'.\n",
3000 curproxy->id, curproxy->defbe.name);
Willy Tarreau5fdfb912007-01-01 23:11:07 +01003001 cfgerr++;
3002 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003003 ha_alert("Proxy '%s': loop detected for default_backend: '%s'.\n",
3004 curproxy->id, curproxy->defbe.name);
Willy Tarreaubb925012009-07-23 13:36:36 +02003005 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02003006 } else if (target->mode != curproxy->mode &&
3007 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
3008
Christopher Faulet767a84b2017-11-24 16:50:31 +01003009 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) as its default backend (see 'mode').\n",
3010 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
3011 curproxy->conf.file, curproxy->conf.line,
3012 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
3013 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02003014 cfgerr++;
Willy Tarreau5fdfb912007-01-01 23:11:07 +01003015 } else {
3016 free(curproxy->defbe.name);
3017 curproxy->defbe.be = target;
Willy Tarreauff678132012-02-13 14:32:34 +01003018 /* Emit a warning if this proxy also has some servers */
3019 if (curproxy->srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003020 ha_warning("In proxy '%s', the 'default_backend' rule always has precedence over the servers, which will never be used.\n",
3021 curproxy->id);
Willy Tarreauff678132012-02-13 14:32:34 +01003022 err_code |= ERR_WARN;
3023 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02003024 }
3025 }
3026
Willy Tarreau55ea7572007-06-17 19:56:27 +02003027 /* find the target proxy for 'use_backend' rules */
3028 list_for_each_entry(rule, &curproxy->switching_rules, list) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02003029 struct proxy *target;
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01003030 struct logformat_node *node;
3031 char *pxname;
3032
3033 /* Try to parse the string as a log format expression. If the result
3034 * of the parsing is only one entry containing a simple string, then
3035 * it's a standard string corresponding to a static rule, thus the
3036 * parsing is cancelled and be.name is restored to be resolved.
3037 */
3038 pxname = rule->be.name;
3039 LIST_INIT(&rule->be.expr);
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +01003040 curproxy->conf.args.ctx = ARGC_UBK;
3041 curproxy->conf.args.file = rule->file;
3042 curproxy->conf.args.line = rule->line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003043 err = NULL;
3044 if (!parse_logformat_string(pxname, curproxy, &rule->be.expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003045 ha_alert("Parsing [%s:%d]: failed to parse use_backend rule '%s' : %s.\n",
3046 rule->file, rule->line, pxname, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003047 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003048 cfgerr++;
3049 continue;
3050 }
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01003051 node = LIST_NEXT(&rule->be.expr, struct logformat_node *, list);
3052
3053 if (!LIST_ISEMPTY(&rule->be.expr)) {
3054 if (node->type != LOG_FMT_TEXT || node->list.n != &rule->be.expr) {
3055 rule->dynamic = 1;
3056 free(pxname);
3057 continue;
3058 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02003059 /* Only one element in the list, a simple string: free the expression and
3060 * fall back to static rule
3061 */
Willy Tarreau2b718102021-04-21 07:32:39 +02003062 LIST_DELETE(&node->list);
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01003063 free(node->arg);
3064 free(node);
3065 }
3066
3067 rule->dynamic = 0;
3068 rule->be.name = pxname;
Willy Tarreau55ea7572007-06-17 19:56:27 +02003069
Willy Tarreauafb39922015-05-26 12:04:09 +02003070 target = proxy_be_by_name(rule->be.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01003071 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003072 ha_alert("Proxy '%s': unable to find required use_backend: '%s'.\n",
3073 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02003074 cfgerr++;
3075 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003076 ha_alert("Proxy '%s': loop detected for use_backend: '%s'.\n",
3077 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02003078 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02003079 } else if (target->mode != curproxy->mode &&
3080 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
3081
Christopher Faulet767a84b2017-11-24 16:50:31 +01003082 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) in a 'use_backend' rule (see 'mode').\n",
3083 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
3084 curproxy->conf.file, curproxy->conf.line,
3085 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
3086 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02003087 cfgerr++;
Willy Tarreau55ea7572007-06-17 19:56:27 +02003088 } else {
Willy Tarreau35cd7342021-02-26 20:51:47 +01003089 ha_free(&rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02003090 rule->be.backend = target;
3091 }
Christopher Faulet581db2b2021-03-26 10:02:46 +01003092 err_code |= warnif_tcp_http_cond(curproxy, rule->cond);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02003093 }
3094
Willy Tarreau64ab6072014-09-16 12:17:36 +02003095 /* find the target server for 'use_server' rules */
Willy Tarreau4a5cade2012-04-05 21:09:48 +02003096 list_for_each_entry(srule, &curproxy->server_rules, list) {
Jerome Magnin824186b2020-03-29 09:37:12 +02003097 struct server *target;
3098 struct logformat_node *node;
3099 char *server_name;
3100
3101 /* We try to parse the string as a log format expression. If the result of the parsing
3102 * is only one entry containing a single string, then it's a standard string corresponding
3103 * to a static rule, thus the parsing is cancelled and we fall back to setting srv.ptr.
3104 */
3105 server_name = srule->srv.name;
3106 LIST_INIT(&srule->expr);
3107 curproxy->conf.args.ctx = ARGC_USRV;
3108 err = NULL;
3109 if (!parse_logformat_string(server_name, curproxy, &srule->expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
3110 ha_alert("Parsing [%s:%d]; use-server rule failed to parse log-format '%s' : %s.\n",
3111 srule->file, srule->line, server_name, err);
3112 free(err);
3113 cfgerr++;
3114 continue;
3115 }
3116 node = LIST_NEXT(&srule->expr, struct logformat_node *, list);
3117
3118 if (!LIST_ISEMPTY(&srule->expr)) {
3119 if (node->type != LOG_FMT_TEXT || node->list.n != &srule->expr) {
3120 srule->dynamic = 1;
3121 free(server_name);
3122 continue;
3123 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02003124 /* Only one element in the list, a simple string: free the expression and
3125 * fall back to static rule
3126 */
Willy Tarreau2b718102021-04-21 07:32:39 +02003127 LIST_DELETE(&node->list);
Jerome Magnin824186b2020-03-29 09:37:12 +02003128 free(node->arg);
3129 free(node);
3130 }
3131
3132 srule->dynamic = 0;
3133 srule->srv.name = server_name;
3134 target = findserver(curproxy, srule->srv.name);
Christopher Faulet581db2b2021-03-26 10:02:46 +01003135 err_code |= warnif_tcp_http_cond(curproxy, srule->cond);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02003136
3137 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003138 ha_alert("config : %s '%s' : unable to find server '%s' referenced in a 'use-server' rule.\n",
3139 proxy_type_str(curproxy), curproxy->id, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02003140 cfgerr++;
3141 continue;
3142 }
Willy Tarreau35cd7342021-02-26 20:51:47 +01003143 ha_free(&srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02003144 srule->srv.ptr = target;
Willy Tarreau55ea7572007-06-17 19:56:27 +02003145 }
3146
Emeric Brunb982a3d2010-01-04 15:45:53 +01003147 /* find the target table for 'stick' rules */
3148 list_for_each_entry(mrule, &curproxy->sticking_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003149 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01003150
Emeric Brun1d33b292010-01-04 15:47:17 +01003151 curproxy->be_req_ana |= AN_REQ_STICKING_RULES;
3152 if (mrule->flags & STK_IS_STORE)
3153 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
3154
Emeric Brunb982a3d2010-01-04 15:45:53 +01003155 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003156 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003157 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003158 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01003159
3160 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003161 ha_alert("Proxy '%s': unable to find stick-table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01003162 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003163 cfgerr++;
3164 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003165 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003166 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
3167 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003168 cfgerr++;
3169 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003170 else if (target->proxy && curproxy->bind_proc & ~target->proxy->bind_proc) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01003171 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
3172 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01003173 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01003174 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01003175 else {
Willy Tarreau35cd7342021-02-26 20:51:47 +01003176 ha_free(&mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003177 mrule->table.t = target;
3178 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Thayne McCombs92149f92020-11-20 01:28:26 -07003179 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_KEY, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02003180 if (!in_proxies_list(target->proxies_list, curproxy)) {
3181 curproxy->next_stkt_ref = target->proxies_list;
3182 target->proxies_list = curproxy;
3183 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01003184 }
Christopher Faulet581db2b2021-03-26 10:02:46 +01003185 err_code |= warnif_tcp_http_cond(curproxy, mrule->cond);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003186 }
3187
3188 /* find the target table for 'store response' rules */
3189 list_for_each_entry(mrule, &curproxy->storersp_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003190 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01003191
Emeric Brun1d33b292010-01-04 15:47:17 +01003192 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
3193
Emeric Brunb982a3d2010-01-04 15:45:53 +01003194 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003195 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003196 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003197 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01003198
3199 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003200 ha_alert("Proxy '%s': unable to find store table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01003201 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003202 cfgerr++;
3203 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003204 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003205 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
3206 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003207 cfgerr++;
3208 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003209 else if (target->proxy && (curproxy->bind_proc & ~target->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01003210 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
3211 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01003212 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01003213 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01003214 else {
Willy Tarreau35cd7342021-02-26 20:51:47 +01003215 ha_free(&mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003216 mrule->table.t = target;
3217 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Thayne McCombs92149f92020-11-20 01:28:26 -07003218 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_KEY, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02003219 if (!in_proxies_list(target->proxies_list, curproxy)) {
3220 curproxy->next_stkt_ref = target->proxies_list;
3221 target->proxies_list = curproxy;
3222 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01003223 }
3224 }
3225
Christopher Faulet42c6cf92021-03-25 17:19:04 +01003226 /* check validity for 'tcp-request' layer 4/5/6/7 rules */
3227 cfgerr += check_action_rules(&curproxy->tcp_req.l4_rules, curproxy, &err_code);
3228 cfgerr += check_action_rules(&curproxy->tcp_req.l5_rules, curproxy, &err_code);
3229 cfgerr += check_action_rules(&curproxy->tcp_req.inspect_rules, curproxy, &err_code);
3230 cfgerr += check_action_rules(&curproxy->tcp_rep.inspect_rules, curproxy, &err_code);
3231 cfgerr += check_action_rules(&curproxy->http_req_rules, curproxy, &err_code);
3232 cfgerr += check_action_rules(&curproxy->http_res_rules, curproxy, &err_code);
3233 cfgerr += check_action_rules(&curproxy->http_after_res_rules, curproxy, &err_code);
Christopher Faulet6d0c3df2020-01-22 09:26:35 +01003234
Christopher Faulet5eef0182021-03-31 17:13:49 +02003235 /* Warn is a switch-mode http is used on a TCP listener with servers but no backend */
3236 if (!curproxy->defbe.name && LIST_ISEMPTY(&curproxy->switching_rules) && curproxy->srv) {
3237 if ((curproxy->options & PR_O_HTTP_UPG) && curproxy->mode == PR_MODE_TCP)
3238 ha_warning("Proxy '%s' : 'switch-mode http' configured for a %s %s with no backend. "
3239 "Incoming connections upgraded to HTTP cannot be routed to TCP servers\n",
3240 curproxy->id, proxy_mode_str(curproxy->mode), proxy_type_str(curproxy));
3241 }
3242
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003243 if (curproxy->table && curproxy->table->peers.name) {
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003244 struct peers *curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02003245
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003246 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003247 if (strcmp(curpeers->id, curproxy->table->peers.name) == 0) {
Willy Tarreau35cd7342021-02-26 20:51:47 +01003248 ha_free(&curproxy->table->peers.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003249 curproxy->table->peers.p = curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02003250 break;
3251 }
3252 }
3253
3254 if (!curpeers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003255 ha_alert("Proxy '%s': unable to find sync peers '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003256 curproxy->id, curproxy->table->peers.name);
Willy Tarreau35cd7342021-02-26 20:51:47 +01003257 ha_free(&curproxy->table->peers.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003258 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02003259 cfgerr++;
3260 }
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02003261 else if (curpeers->disabled) {
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003262 /* silently disable this peers section */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003263 curproxy->table->peers.p = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003264 }
Emeric Brun32da3c42010-09-23 18:39:19 +02003265 else if (!curpeers->peers_fe) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003266 ha_alert("Proxy '%s': unable to find local peer '%s' in peers section '%s'.\n",
3267 curproxy->id, localpeer, curpeers->id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003268 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02003269 cfgerr++;
3270 }
3271 }
3272
Simon Horman9dc49962015-01-30 11:22:59 +09003273
3274 if (curproxy->email_alert.mailers.name) {
3275 struct mailers *curmailers = mailers;
3276
3277 for (curmailers = mailers; curmailers; curmailers = curmailers->next) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003278 if (strcmp(curmailers->id, curproxy->email_alert.mailers.name) == 0)
Simon Horman9dc49962015-01-30 11:22:59 +09003279 break;
Simon Horman9dc49962015-01-30 11:22:59 +09003280 }
Simon Horman9dc49962015-01-30 11:22:59 +09003281 if (!curmailers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003282 ha_alert("Proxy '%s': unable to find mailers '%s'.\n",
3283 curproxy->id, curproxy->email_alert.mailers.name);
Simon Horman9dc49962015-01-30 11:22:59 +09003284 free_email_alert(curproxy);
3285 cfgerr++;
3286 }
Christopher Faulet0108bb32017-10-20 21:34:32 +02003287 else {
3288 err = NULL;
3289 if (init_email_alert(curmailers, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003290 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulet0108bb32017-10-20 21:34:32 +02003291 free(err);
3292 cfgerr++;
3293 }
3294 }
Simon Horman9dc49962015-01-30 11:22:59 +09003295 }
3296
Willy Tarreau5bbc6762021-02-12 11:49:25 +01003297 if (curproxy->uri_auth && !(curproxy->uri_auth->flags & STAT_CONVDONE) &&
Willy Tarreauff011f22011-01-06 17:51:27 +01003298 !LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules) &&
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003299 (curproxy->uri_auth->userlist || curproxy->uri_auth->auth_realm )) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003300 ha_alert("%s '%s': stats 'auth'/'realm' and 'http-request' can't be used at the same time.\n",
3301 "proxy", curproxy->id);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003302 cfgerr++;
3303 goto out_uri_auth_compat;
3304 }
3305
Willy Tarreauee4f5f82019-10-09 09:59:22 +02003306 if (curproxy->uri_auth && curproxy->uri_auth->userlist &&
Willy Tarreau5bbc6762021-02-12 11:49:25 +01003307 (!(curproxy->uri_auth->flags & STAT_CONVDONE) ||
Willy Tarreauee4f5f82019-10-09 09:59:22 +02003308 LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules))) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01003309 const char *uri_auth_compat_req[10];
Thierry FOURNIERa28a9422015-08-04 19:35:46 +02003310 struct act_rule *rule;
Amaury Denoyelle3efee652021-03-08 17:31:39 +01003311 i = 0;
3312
Willy Tarreau95fa4692010-02-01 13:05:50 +01003313 /* build the ACL condition from scratch. We're relying on anonymous ACLs for that */
3314 uri_auth_compat_req[i++] = "auth";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003315
3316 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01003317 uri_auth_compat_req[i++] = "realm";
3318 uri_auth_compat_req[i++] = curproxy->uri_auth->auth_realm;
3319 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003320
Willy Tarreau95fa4692010-02-01 13:05:50 +01003321 uri_auth_compat_req[i++] = "unless";
3322 uri_auth_compat_req[i++] = "{";
3323 uri_auth_compat_req[i++] = "http_auth(.internal-stats-userlist)";
3324 uri_auth_compat_req[i++] = "}";
3325 uri_auth_compat_req[i++] = "";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003326
Willy Tarreauff011f22011-01-06 17:51:27 +01003327 rule = parse_http_req_cond(uri_auth_compat_req, "internal-stats-auth-compat", 0, curproxy);
3328 if (!rule) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01003329 cfgerr++;
3330 break;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003331 }
3332
Willy Tarreau2b718102021-04-21 07:32:39 +02003333 LIST_APPEND(&curproxy->uri_auth->http_req_rules, &rule->list);
Willy Tarreau95fa4692010-02-01 13:05:50 +01003334
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003335 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003336 ha_free(&curproxy->uri_auth->auth_realm);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003337 }
Willy Tarreau5bbc6762021-02-12 11:49:25 +01003338 curproxy->uri_auth->flags |= STAT_CONVDONE;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003339 }
3340out_uri_auth_compat:
3341
Dragan Dosen43885c72015-10-01 13:18:13 +02003342 /* check whether we have a log server that uses RFC5424 log format */
Dragan Dosen1322d092015-09-22 16:05:32 +02003343 list_for_each_entry(tmplogsrv, &curproxy->logsrvs, list) {
Dragan Dosen43885c72015-10-01 13:18:13 +02003344 if (tmplogsrv->format == LOG_FORMAT_RFC5424) {
3345 if (!curproxy->conf.logformat_sd_string) {
3346 /* set the default logformat_sd_string */
3347 curproxy->conf.logformat_sd_string = default_rfc5424_sd_log_format;
3348 }
Dragan Dosen1322d092015-09-22 16:05:32 +02003349 break;
Dragan Dosen1322d092015-09-22 16:05:32 +02003350 }
Dragan Dosen1322d092015-09-22 16:05:32 +02003351 }
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02003352
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003353 /* compile the log format */
3354 if (!(curproxy->cap & PR_CAP_FE)) {
Willy Tarreau62a61232013-04-12 18:13:46 +02003355 if (curproxy->conf.logformat_string != default_http_log_format &&
3356 curproxy->conf.logformat_string != default_tcp_log_format &&
3357 curproxy->conf.logformat_string != clf_http_log_format)
3358 free(curproxy->conf.logformat_string);
3359 curproxy->conf.logformat_string = NULL;
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003360 ha_free(&curproxy->conf.lfs_file);
Willy Tarreau62a61232013-04-12 18:13:46 +02003361 curproxy->conf.lfs_line = 0;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003362
3363 if (curproxy->conf.logformat_sd_string != default_rfc5424_sd_log_format)
3364 free(curproxy->conf.logformat_sd_string);
3365 curproxy->conf.logformat_sd_string = NULL;
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003366 ha_free(&curproxy->conf.lfsd_file);
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003367 curproxy->conf.lfsd_line = 0;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003368 }
3369
Willy Tarreau62a61232013-04-12 18:13:46 +02003370 if (curproxy->conf.logformat_string) {
3371 curproxy->conf.args.ctx = ARGC_LOG;
3372 curproxy->conf.args.file = curproxy->conf.lfs_file;
3373 curproxy->conf.args.line = curproxy->conf.lfs_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003374 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02003375 if (!parse_logformat_string(curproxy->conf.logformat_string, curproxy, &curproxy->logformat,
3376 LOG_OPT_MANDATORY|LOG_OPT_MERGE_SPACES,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003377 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003378 ha_alert("Parsing [%s:%d]: failed to parse log-format : %s.\n",
3379 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003380 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003381 cfgerr++;
3382 }
Willy Tarreau62a61232013-04-12 18:13:46 +02003383 curproxy->conf.args.file = NULL;
3384 curproxy->conf.args.line = 0;
3385 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003386
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003387 if (curproxy->conf.logformat_sd_string) {
3388 curproxy->conf.args.ctx = ARGC_LOGSD;
3389 curproxy->conf.args.file = curproxy->conf.lfsd_file;
3390 curproxy->conf.args.line = curproxy->conf.lfsd_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003391 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02003392 if (!parse_logformat_string(curproxy->conf.logformat_sd_string, curproxy, &curproxy->logformat_sd,
3393 LOG_OPT_MANDATORY|LOG_OPT_MERGE_SPACES,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003394 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003395 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
3396 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003397 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003398 cfgerr++;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003399 } else if (!add_to_logformat_list(NULL, NULL, LF_SEPARATOR, &curproxy->logformat_sd, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003400 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
3401 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003402 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003403 cfgerr++;
3404 }
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003405 curproxy->conf.args.file = NULL;
3406 curproxy->conf.args.line = 0;
3407 }
3408
Willy Tarreau62a61232013-04-12 18:13:46 +02003409 if (curproxy->conf.uniqueid_format_string) {
Christopher Faulet5f802b32021-10-13 17:22:17 +02003410 int where = 0;
3411
Willy Tarreau62a61232013-04-12 18:13:46 +02003412 curproxy->conf.args.ctx = ARGC_UIF;
3413 curproxy->conf.args.file = curproxy->conf.uif_file;
3414 curproxy->conf.args.line = curproxy->conf.uif_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003415 err = NULL;
Christopher Faulet5f802b32021-10-13 17:22:17 +02003416 if (curproxy->cap & PR_CAP_FE)
3417 where |= SMP_VAL_FE_HRQ_HDR;
3418 if (curproxy->cap & PR_CAP_BE)
3419 where |= SMP_VAL_BE_HRQ_HDR;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02003420 if (!parse_logformat_string(curproxy->conf.uniqueid_format_string, curproxy, &curproxy->format_unique_id,
Christopher Faulet5f802b32021-10-13 17:22:17 +02003421 LOG_OPT_HTTP|LOG_OPT_MERGE_SPACES, where, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003422 ha_alert("Parsing [%s:%d]: failed to parse unique-id : %s.\n",
3423 curproxy->conf.uif_file, curproxy->conf.uif_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003424 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003425 cfgerr++;
3426 }
Willy Tarreau62a61232013-04-12 18:13:46 +02003427 curproxy->conf.args.file = NULL;
3428 curproxy->conf.args.line = 0;
3429 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003430
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01003431 /* only now we can check if some args remain unresolved.
3432 * This must be done after the users and groups resolution.
3433 */
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01003434 err = NULL;
3435 i = smp_resolve_args(curproxy, &err);
3436 cfgerr += i;
3437 if (i) {
3438 indent_msg(&err, 8);
3439 ha_alert("%s%s\n", i > 1 ? "multiple argument resolution errors:" : "", err);
3440 ha_free(&err);
3441 } else
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003442 cfgerr += acl_find_targets(curproxy);
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01003443
Willy Tarreau2738a142006-07-08 17:28:09 +02003444 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003445 (((curproxy->cap & PR_CAP_FE) && !curproxy->timeout.client) ||
Willy Tarreaud825eef2007-05-12 22:35:00 +02003446 ((curproxy->cap & PR_CAP_BE) && (curproxy->srv) &&
Willy Tarreauce887fd2012-05-12 12:50:00 +02003447 (!curproxy->timeout.connect ||
3448 (!curproxy->timeout.server && (curproxy->mode == PR_MODE_HTTP || !curproxy->timeout.tunnel)))))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003449 ha_warning("config : missing timeouts for %s '%s'.\n"
3450 " | While not properly invalid, you will certainly encounter various problems\n"
3451 " | with such a configuration. To fix this, please ensure that all following\n"
3452 " | timeouts are set to a non-zero value: 'client', 'connect', 'server'.\n",
3453 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003454 err_code |= ERR_WARN;
Willy Tarreau2738a142006-07-08 17:28:09 +02003455 }
Willy Tarreauf3c69202006-07-09 16:42:34 +02003456
Willy Tarreau1fa31262007-12-03 00:36:16 +01003457 /* Historically, the tarpit and queue timeouts were inherited from contimeout.
3458 * We must still support older configurations, so let's find out whether those
3459 * parameters have been set or must be copied from contimeouts.
3460 */
Willy Tarreau937c3ea2021-02-12 11:14:35 +01003461 if (!curproxy->timeout.tarpit)
3462 curproxy->timeout.tarpit = curproxy->timeout.connect;
3463 if ((curproxy->cap & PR_CAP_BE) && !curproxy->timeout.queue)
3464 curproxy->timeout.queue = curproxy->timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01003465
Christopher Faulete5870d82020-04-15 11:32:03 +02003466 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_TCP_RS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003467 ha_warning("config : %s '%s' uses tcp-check rules without 'option tcp-check', so the rules are ignored.\n",
3468 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau215663d2014-06-13 18:30:23 +02003469 err_code |= ERR_WARN;
3470 }
3471
Willy Tarreau193b8c62012-11-22 00:17:38 +01003472 /* ensure that cookie capture length is not too large */
3473 if (curproxy->capture_len >= global.tune.cookie_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003474 ha_warning("config : truncating capture length to %d bytes for %s '%s'.\n",
3475 global.tune.cookie_len - 1, proxy_type_str(curproxy), curproxy->id);
Willy Tarreau193b8c62012-11-22 00:17:38 +01003476 err_code |= ERR_WARN;
3477 curproxy->capture_len = global.tune.cookie_len - 1;
3478 }
3479
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003480 /* The small pools required for the capture lists */
Willy Tarreau9a54e132012-03-24 08:33:05 +01003481 if (curproxy->nb_req_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003482 curproxy->req_cap_pool = create_pool("ptrcap",
3483 curproxy->nb_req_cap * sizeof(char *),
3484 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003485 }
3486
3487 if (curproxy->nb_rsp_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003488 curproxy->rsp_cap_pool = create_pool("ptrcap",
3489 curproxy->nb_rsp_cap * sizeof(char *),
3490 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003491 }
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003492
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003493 switch (curproxy->load_server_state_from_file) {
3494 case PR_SRV_STATE_FILE_UNSPEC:
3495 curproxy->load_server_state_from_file = PR_SRV_STATE_FILE_NONE;
3496 break;
3497 case PR_SRV_STATE_FILE_GLOBAL:
3498 if (!global.server_state_file) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003499 ha_warning("config : backend '%s' configured to load server state file from global section 'server-state-file' directive. Unfortunately, 'server-state-file' is not set!\n",
3500 curproxy->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003501 err_code |= ERR_WARN;
3502 }
3503 break;
3504 }
3505
Willy Tarreaubaaee002006-06-26 02:48:02 +02003506 /* first, we will invert the servers list order */
3507 newsrv = NULL;
3508 while (curproxy->srv) {
3509 struct server *next;
3510
3511 next = curproxy->srv->next;
3512 curproxy->srv->next = newsrv;
3513 newsrv = curproxy->srv;
3514 if (!next)
3515 break;
3516 curproxy->srv = next;
3517 }
3518
Willy Tarreau17edc812014-01-03 12:14:34 +01003519 /* Check that no server name conflicts. This causes trouble in the stats.
3520 * We only emit a warning for the first conflict affecting each server,
3521 * in order to avoid combinatory explosion if all servers have the same
3522 * name. We do that only for servers which do not have an explicit ID,
3523 * because these IDs were made also for distinguishing them and we don't
3524 * want to annoy people who correctly manage them.
3525 */
3526 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3527 struct server *other_srv;
3528
3529 if (newsrv->puid)
3530 continue;
3531
3532 for (other_srv = curproxy->srv; other_srv && other_srv != newsrv; other_srv = other_srv->next) {
3533 if (!other_srv->puid && strcmp(other_srv->id, newsrv->id) == 0) {
Willy Tarreaub01302f2019-05-27 19:31:06 +02003534 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 +01003535 newsrv->conf.file, newsrv->conf.line,
3536 proxy_type_str(curproxy), curproxy->id,
3537 newsrv->id, other_srv->conf.line);
Willy Tarreaub01302f2019-05-27 19:31:06 +02003538 cfgerr++;
Willy Tarreau17edc812014-01-03 12:14:34 +01003539 break;
3540 }
3541 }
3542 }
3543
Willy Tarreaudd701652010-05-25 23:03:02 +02003544 /* assign automatic UIDs to servers which don't have one yet */
3545 next_id = 1;
3546 newsrv = curproxy->srv;
3547 while (newsrv != NULL) {
3548 if (!newsrv->puid) {
3549 /* server ID not set, use automatic numbering with first
3550 * spare entry starting with next_svid.
3551 */
3552 next_id = get_next_id(&curproxy->conf.used_server_id, next_id);
3553 newsrv->conf.id.key = newsrv->puid = next_id;
3554 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
3555 }
Amaury Denoyelle50779ae2021-06-14 17:04:25 +02003556 newsrv->conf.name.key = newsrv->id;
3557 ebis_insert(&curproxy->conf.used_server_name, &newsrv->conf.name);
3558
Willy Tarreaudd701652010-05-25 23:03:02 +02003559 next_id++;
3560 newsrv = newsrv->next;
3561 }
3562
Willy Tarreau20697042007-11-15 23:26:18 +01003563 curproxy->lbprm.wmult = 1; /* default weight multiplier */
Willy Tarreau5dc2fa62007-11-19 19:10:18 +01003564 curproxy->lbprm.wdiv = 1; /* default weight divider */
Willy Tarreaubaaee002006-06-26 02:48:02 +02003565
Willy Tarreau62c3be22012-01-20 13:12:32 +01003566 /*
3567 * If this server supports a maxconn parameter, it needs a dedicated
3568 * tasks to fill the emptied slots when a connection leaves.
3569 * Also, resolve deferred tracking dependency if needed.
3570 */
3571 newsrv = curproxy->srv;
3572 while (newsrv != NULL) {
3573 if (newsrv->minconn > newsrv->maxconn) {
3574 /* Only 'minconn' was specified, or it was higher than or equal
3575 * to 'maxconn'. Let's turn this into maxconn and clean it, as
3576 * this will avoid further useless expensive computations.
3577 */
3578 newsrv->maxconn = newsrv->minconn;
3579 } else if (newsrv->maxconn && !newsrv->minconn) {
3580 /* minconn was not specified, so we set it to maxconn */
3581 newsrv->minconn = newsrv->maxconn;
3582 }
3583
William Dauchyf6370442020-11-14 19:25:33 +01003584 /* this will also properly set the transport layer for
3585 * prod and checks
3586 * if default-server have use_ssl, prerare ssl init
3587 * without activating it */
3588 if (newsrv->use_ssl == 1 || newsrv->check.use_ssl == 1 ||
Christopher Faulet7cbd1562021-12-01 09:50:41 +01003589 (newsrv->proxy->options & PR_O_TCPCHK_SSL) ||
3590 ((newsrv->flags & SRV_F_DEFSRV_USE_SSL) && newsrv->use_ssl != 1)) {
Willy Tarreau17d45382016-12-22 21:16:08 +01003591 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
3592 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(newsrv);
3593 }
Emeric Brun94324a42012-10-11 14:00:19 +02003594
Willy Tarreau034c88c2017-01-23 23:36:45 +01003595 if ((newsrv->flags & SRV_F_FASTOPEN) &&
3596 ((curproxy->retry_type & (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)) !=
3597 (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)))
3598 ha_warning("parsing [%s:%d] : %s '%s': server '%s' 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",
3599 newsrv->conf.file, newsrv->conf.line,
3600 proxy_type_str(curproxy), curproxy->id,
3601 newsrv->id);
3602
Willy Tarreau62c3be22012-01-20 13:12:32 +01003603 if (newsrv->trackit) {
3604 struct proxy *px;
Willy Tarreau32091232014-05-16 13:52:00 +02003605 struct server *srv, *loop;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003606 char *pname, *sname;
3607
3608 pname = newsrv->trackit;
3609 sname = strrchr(pname, '/');
3610
3611 if (sname)
3612 *sname++ = '\0';
3613 else {
3614 sname = pname;
3615 pname = NULL;
3616 }
3617
3618 if (pname) {
Willy Tarreau9e0bb102015-05-26 11:24:42 +02003619 px = proxy_be_by_name(pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003620 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003621 ha_alert("config : %s '%s', server '%s': unable to find required proxy '%s' for tracking.\n",
3622 proxy_type_str(curproxy), curproxy->id,
3623 newsrv->id, pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003624 cfgerr++;
3625 goto next_srv;
3626 }
3627 } else
3628 px = curproxy;
3629
3630 srv = findserver(px, sname);
3631 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003632 ha_alert("config : %s '%s', server '%s': unable to find required server '%s' for tracking.\n",
3633 proxy_type_str(curproxy), curproxy->id,
3634 newsrv->id, sname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003635 cfgerr++;
3636 goto next_srv;
3637 }
3638
Christopher Faulet8892e5d2020-03-26 19:48:20 +01003639 if (!srv->do_check && !srv->do_agent && !srv->track && !srv->trackit) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003640 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for "
3641 "tracking as it does not have any check nor agent enabled.\n",
3642 proxy_type_str(curproxy), curproxy->id,
3643 newsrv->id, px->id, srv->id);
Willy Tarreau32091232014-05-16 13:52:00 +02003644 cfgerr++;
3645 goto next_srv;
3646 }
3647
3648 for (loop = srv->track; loop && loop != newsrv; loop = loop->track);
3649
Frédéric Lécaille2efc6492017-03-14 14:32:17 +01003650 if (newsrv == srv || loop) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003651 ha_alert("config : %s '%s', server '%s': unable to track %s/%s as it "
3652 "belongs to a tracking chain looping back to %s/%s.\n",
3653 proxy_type_str(curproxy), curproxy->id,
3654 newsrv->id, px->id, srv->id, px->id,
3655 newsrv == srv ? srv->id : loop->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003656 cfgerr++;
3657 goto next_srv;
3658 }
3659
3660 if (curproxy != px &&
3661 (curproxy->options & PR_O_DISABLE404) != (px->options & PR_O_DISABLE404)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003662 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for"
3663 "tracking: disable-on-404 option inconsistency.\n",
3664 proxy_type_str(curproxy), curproxy->id,
3665 newsrv->id, px->id, srv->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003666 cfgerr++;
3667 goto next_srv;
3668 }
3669
Willy Tarreau62c3be22012-01-20 13:12:32 +01003670 newsrv->track = srv;
Willy Tarreau1a53a3a2013-12-11 15:27:05 +01003671 newsrv->tracknext = srv->trackers;
3672 srv->trackers = newsrv;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003673
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003674 ha_free(&newsrv->trackit);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003675 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003676
Willy Tarreau62c3be22012-01-20 13:12:32 +01003677 next_srv:
3678 newsrv = newsrv->next;
3679 }
3680
Olivier Houchard4e694042017-03-14 20:01:29 +01003681 /*
3682 * Try to generate dynamic cookies for servers now.
3683 * It couldn't be done earlier, since at the time we parsed
3684 * the server line, we may not have known yet that we
3685 * should use dynamic cookies, or the secret key may not
3686 * have been provided yet.
3687 */
3688 if (curproxy->ck_opts & PR_CK_DYNAMIC) {
3689 newsrv = curproxy->srv;
3690 while (newsrv != NULL) {
3691 srv_set_dyncookie(newsrv);
3692 newsrv = newsrv->next;
3693 }
3694
3695 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003696 /* We have to initialize the server lookup mechanism depending
Joseph Herlanta14c03e2018-11-15 14:04:19 -08003697 * on what LB algorithm was chosen.
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003698 */
3699
3700 curproxy->lbprm.algo &= ~(BE_LB_LKUP | BE_LB_PROP_DYN);
3701 switch (curproxy->lbprm.algo & BE_LB_KIND) {
3702 case BE_LB_KIND_RR:
Willy Tarreau9757a382009-10-03 12:56:50 +02003703 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_STATIC) {
3704 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3705 init_server_map(curproxy);
Willy Tarreau760e81d2018-05-03 07:20:40 +02003706 } else if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_RANDOM) {
3707 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
Remi Tricot-Le Bretonc5c5bc42021-05-19 16:40:28 +02003708 if (chash_init_server_tree(curproxy) < 0) {
3709 cfgerr++;
3710 }
Willy Tarreau9757a382009-10-03 12:56:50 +02003711 } else {
3712 curproxy->lbprm.algo |= BE_LB_LKUP_RRTREE | BE_LB_PROP_DYN;
3713 fwrr_init_server_groups(curproxy);
3714 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003715 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003716
Willy Tarreau3ebb1162012-02-13 16:57:44 +01003717 case BE_LB_KIND_CB:
Willy Tarreauf09c6602012-02-13 17:12:08 +01003718 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_CB_LC) {
3719 curproxy->lbprm.algo |= BE_LB_LKUP_LCTREE | BE_LB_PROP_DYN;
3720 fwlc_init_server_tree(curproxy);
3721 } else {
3722 curproxy->lbprm.algo |= BE_LB_LKUP_FSTREE | BE_LB_PROP_DYN;
3723 fas_init_server_tree(curproxy);
3724 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003725 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003726
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003727 case BE_LB_KIND_HI:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003728 if ((curproxy->lbprm.algo & BE_LB_HASH_TYPE) == BE_LB_HASH_CONS) {
3729 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
Remi Tricot-Le Bretonc5c5bc42021-05-19 16:40:28 +02003730 if (chash_init_server_tree(curproxy) < 0) {
3731 cfgerr++;
3732 }
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003733 } else {
3734 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3735 init_server_map(curproxy);
3736 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003737 break;
3738 }
Willy Tarreaucd10def2020-10-17 18:48:47 +02003739 HA_RWLOCK_INIT(&curproxy->lbprm.lock);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003740
3741 if (curproxy->options & PR_O_LOGASAP)
3742 curproxy->to_log &= ~LW_BYTES;
3743
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003744 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003745 (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->logsrvs) &&
3746 (!LIST_ISEMPTY(&curproxy->logformat) || !LIST_ISEMPTY(&curproxy->logformat_sd))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003747 ha_warning("config : log format ignored for %s '%s' since it has no log address.\n",
3748 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003749 err_code |= ERR_WARN;
3750 }
3751
Christopher Faulet3b6446f2021-03-15 15:10:38 +01003752 if (curproxy->mode != PR_MODE_HTTP && !(curproxy->options & PR_O_HTTP_UPG)) {
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003753 int optnum;
3754
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003755 if (curproxy->uri_auth) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003756 ha_warning("config : 'stats' statement ignored for %s '%s' as it requires HTTP mode.\n",
3757 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003758 err_code |= ERR_WARN;
3759 curproxy->uri_auth = NULL;
3760 }
3761
Willy Tarreaude7dc882017-03-10 11:49:21 +01003762 if (curproxy->capture_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003763 ha_warning("config : 'capture' statement ignored for %s '%s' as it requires HTTP mode.\n",
3764 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003765 err_code |= ERR_WARN;
3766 }
3767
3768 if (!LIST_ISEMPTY(&curproxy->http_req_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003769 ha_warning("config : 'http-request' rules ignored for %s '%s' as they require HTTP mode.\n",
3770 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003771 err_code |= ERR_WARN;
3772 }
3773
3774 if (!LIST_ISEMPTY(&curproxy->http_res_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003775 ha_warning("config : 'http-response' rules ignored for %s '%s' as they require HTTP mode.\n",
3776 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003777 err_code |= ERR_WARN;
3778 }
3779
Christopher Fauletbb7abed2021-03-15 15:09:21 +01003780 if (!LIST_ISEMPTY(&curproxy->http_after_res_rules)) {
3781 ha_warning("config : 'http-after-response' rules ignored for %s '%s' as they require HTTP mode.\n",
3782 proxy_type_str(curproxy), curproxy->id);
3783 err_code |= ERR_WARN;
3784 }
3785
Willy Tarreaude7dc882017-03-10 11:49:21 +01003786 if (!LIST_ISEMPTY(&curproxy->redirect_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003787 ha_warning("config : 'redirect' rules ignored for %s '%s' as they require HTTP mode.\n",
3788 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003789 err_code |= ERR_WARN;
3790 }
3791
Willy Tarreau87cf5142011-08-19 22:57:24 +02003792 if (curproxy->options & (PR_O_FWDFOR | PR_O_FF_ALWAYS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003793 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3794 "forwardfor", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003795 err_code |= ERR_WARN;
Willy Tarreau87cf5142011-08-19 22:57:24 +02003796 curproxy->options &= ~(PR_O_FWDFOR | PR_O_FF_ALWAYS);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003797 }
3798
3799 if (curproxy->options & PR_O_ORGTO) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003800 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3801 "originalto", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003802 err_code |= ERR_WARN;
3803 curproxy->options &= ~PR_O_ORGTO;
3804 }
3805
3806 for (optnum = 0; cfg_opts[optnum].name; optnum++) {
3807 if (cfg_opts[optnum].mode == PR_MODE_HTTP &&
3808 (curproxy->cap & cfg_opts[optnum].cap) &&
3809 (curproxy->options & cfg_opts[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003810 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3811 cfg_opts[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003812 err_code |= ERR_WARN;
3813 curproxy->options &= ~cfg_opts[optnum].val;
3814 }
3815 }
3816
3817 for (optnum = 0; cfg_opts2[optnum].name; optnum++) {
3818 if (cfg_opts2[optnum].mode == PR_MODE_HTTP &&
3819 (curproxy->cap & cfg_opts2[optnum].cap) &&
3820 (curproxy->options2 & cfg_opts2[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003821 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3822 cfg_opts2[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003823 err_code |= ERR_WARN;
3824 curproxy->options2 &= ~cfg_opts2[optnum].val;
3825 }
3826 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003827
Willy Tarreau29fbe512015-08-20 19:35:14 +02003828#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003829 if (curproxy->conn_src.bind_hdr_occ) {
3830 curproxy->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003831 ha_warning("config : %s '%s' : ignoring use of header %s as source IP in non-HTTP mode.\n",
3832 proxy_type_str(curproxy), curproxy->id, curproxy->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003833 err_code |= ERR_WARN;
3834 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003835#endif
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003836 }
3837
Willy Tarreaubaaee002006-06-26 02:48:02 +02003838 /*
Willy Tarreau21d2af32008-02-14 20:25:24 +01003839 * ensure that we're not cross-dressing a TCP server into HTTP.
3840 */
3841 newsrv = curproxy->srv;
3842 while (newsrv != NULL) {
Willy Tarreau0cec3312011-10-31 13:49:26 +01003843 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->rdr_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003844 ha_alert("config : %s '%s' : server cannot have cookie or redirect prefix in non-HTTP mode.\n",
3845 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003846 cfgerr++;
Willy Tarreau21d2af32008-02-14 20:25:24 +01003847 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003848
Willy Tarreau0cec3312011-10-31 13:49:26 +01003849 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->cklen) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003850 ha_warning("config : %s '%s' : ignoring cookie for server '%s' as HTTP mode is disabled.\n",
3851 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau0cec3312011-10-31 13:49:26 +01003852 err_code |= ERR_WARN;
3853 }
3854
Willy Tarreauc93cd162014-05-13 15:54:22 +02003855 if ((newsrv->flags & SRV_F_MAPPORTS) && (curproxy->options2 & PR_O2_RDPC_PRST)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003856 ha_warning("config : %s '%s' : RDP cookie persistence will not work for server '%s' because it lacks an explicit port number.\n",
3857 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau82ffa392013-08-13 17:19:08 +02003858 err_code |= ERR_WARN;
3859 }
3860
Willy Tarreau29fbe512015-08-20 19:35:14 +02003861#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003862 if (curproxy->mode != PR_MODE_HTTP && newsrv->conn_src.bind_hdr_occ) {
3863 newsrv->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003864 ha_warning("config : %s '%s' : server %s cannot use header %s as source IP in non-HTTP mode.\n",
3865 proxy_type_str(curproxy), curproxy->id, newsrv->id, newsrv->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003866 err_code |= ERR_WARN;
3867 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003868#endif
Willy Tarreau4c183462017-01-06 12:21:38 +01003869
Willy Tarreau46deab62018-04-28 07:18:15 +02003870 if ((curproxy->mode != PR_MODE_HTTP) && (curproxy->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR)
3871 curproxy->options &= ~PR_O_REUSE_MASK;
3872
Willy Tarreau21d2af32008-02-14 20:25:24 +01003873 newsrv = newsrv->next;
3874 }
3875
Christopher Fauletd7c91962015-04-30 11:48:27 +02003876 /* Check filter configuration, if any */
3877 cfgerr += flt_check(curproxy);
3878
Willy Tarreauc1a21672009-08-16 22:37:44 +02003879 if (curproxy->cap & PR_CAP_FE) {
Willy Tarreau050536d2012-10-04 08:47:34 +02003880 if (!curproxy->accept)
3881 curproxy->accept = frontend_accept;
Willy Tarreau81f9aa32010-06-01 17:45:26 +02003882
Willy Tarreauc1a21672009-08-16 22:37:44 +02003883 if (curproxy->tcp_req.inspect_delay ||
3884 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
Willy Tarreaufb356202010-08-03 14:02:05 +02003885 curproxy->fe_req_ana |= AN_REQ_INSPECT_FE;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003886
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003887 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003888 curproxy->fe_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_PROCESS_FE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003889 curproxy->fe_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_FE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003890 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003891
William Lallemandcf62f7e2018-10-26 14:47:40 +02003892 if (curproxy->mode == PR_MODE_CLI) {
3893 curproxy->fe_req_ana |= AN_REQ_WAIT_CLI;
3894 curproxy->fe_rsp_ana |= AN_RES_WAIT_CLI;
3895 }
3896
Willy Tarreauc1a21672009-08-16 22:37:44 +02003897 /* both TCP and HTTP must check switching rules */
3898 curproxy->fe_req_ana |= AN_REQ_SWITCHING_RULES;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003899
3900 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003901 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003902 curproxy->fe_req_ana |= AN_REQ_FLT_START_FE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3903 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 +02003904 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003905 }
3906
3907 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreaufb356202010-08-03 14:02:05 +02003908 if (curproxy->tcp_req.inspect_delay ||
3909 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
3910 curproxy->be_req_ana |= AN_REQ_INSPECT_BE;
3911
Emeric Brun97679e72010-09-23 17:56:44 +02003912 if (!LIST_ISEMPTY(&curproxy->tcp_rep.inspect_rules))
3913 curproxy->be_rsp_ana |= AN_RES_INSPECT;
3914
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003915 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003916 curproxy->be_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_INNER | AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003917 curproxy->be_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_BE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003918 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003919
3920 /* If the backend does requires RDP cookie persistence, we have to
3921 * enable the corresponding analyser.
3922 */
3923 if (curproxy->options2 & PR_O2_RDPC_PRST)
3924 curproxy->be_req_ana |= AN_REQ_PRST_RDP_COOKIE;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003925
3926 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003927 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003928 curproxy->be_req_ana |= AN_REQ_FLT_START_BE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3929 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 +02003930 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003931 }
Christopher Fauleta717b992018-04-10 14:43:00 +02003932
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003933 /* Check the mux protocols, if any, for each listener and server
Christopher Fauleta717b992018-04-10 14:43:00 +02003934 * attached to the current proxy */
3935 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3936 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003937 const struct mux_proto_list *mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003938
3939 if (!bind_conf->mux_proto)
3940 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003941
3942 /* it is possible that an incorrect mux was referenced
3943 * due to the proxy's mode not being taken into account
3944 * on first pass. Let's adjust it now.
3945 */
3946 mux_ent = conn_get_best_mux_entry(bind_conf->mux_proto->token, PROTO_SIDE_FE, mode);
3947
3948 if (!mux_ent || !isteq(mux_ent->token, bind_conf->mux_proto->token)) {
Christopher Fauleta717b992018-04-10 14:43:00 +02003949 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for 'bind %s' at [%s:%d].\n",
3950 proxy_type_str(curproxy), curproxy->id,
3951 (int)bind_conf->mux_proto->token.len,
3952 bind_conf->mux_proto->token.ptr,
3953 bind_conf->arg, bind_conf->file, bind_conf->line);
3954 cfgerr++;
3955 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003956
3957 /* update the mux */
3958 bind_conf->mux_proto = mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003959 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003960 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3961 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003962 const struct mux_proto_list *mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003963
3964 if (!newsrv->mux_proto)
3965 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003966
3967 /* it is possible that an incorrect mux was referenced
3968 * due to the proxy's mode not being taken into account
3969 * on first pass. Let's adjust it now.
3970 */
3971 mux_ent = conn_get_best_mux_entry(newsrv->mux_proto->token, PROTO_SIDE_BE, mode);
3972
3973 if (!mux_ent || !isteq(mux_ent->token, newsrv->mux_proto->token)) {
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003974 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for server '%s' at [%s:%d].\n",
3975 proxy_type_str(curproxy), curproxy->id,
3976 (int)newsrv->mux_proto->token.len,
3977 newsrv->mux_proto->token.ptr,
3978 newsrv->id, newsrv->conf.file, newsrv->conf.line);
3979 cfgerr++;
3980 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003981
3982 /* update the mux */
3983 newsrv->mux_proto = mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003984 }
Willy Tarreau4cdac162021-03-05 10:48:42 +01003985 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003986
Emeric Brunfe0979f2022-08-18 15:53:21 +02003987 /*
3988 * We have just initialized the main proxies list
3989 * we must also configure the log-forward proxies list
3990 */
3991 if (init_proxies_list == proxies_list) {
3992 init_proxies_list = cfg_log_forward;
Emeric Brunba6af4f2022-08-22 10:25:11 +02003993 /* check if list is not null to avoid infinite loop */
3994 if (init_proxies_list)
3995 goto init_proxies_list_stage1;
Emeric Brunfe0979f2022-08-18 15:53:21 +02003996 }
3997
Emeric Brunfd667082022-09-13 16:16:30 +02003998 if (init_proxies_list == cfg_log_forward) {
3999 init_proxies_list = sink_proxies_list;
4000 /* check if list is not null to avoid infinite loop */
4001 if (init_proxies_list)
4002 goto init_proxies_list_stage1;
4003 }
4004
Willy Tarreau4cdac162021-03-05 10:48:42 +01004005 /***********************************************************/
4006 /* At this point, target names have already been resolved. */
4007 /***********************************************************/
Willy Tarreau835daa12019-02-07 14:46:29 +01004008
Willy Tarreau4cdac162021-03-05 10:48:42 +01004009 /* we must finish to initialize certain things on the servers */
Willy Tarreau835daa12019-02-07 14:46:29 +01004010
Willy Tarreau4cdac162021-03-05 10:48:42 +01004011 list_for_each_entry(newsrv, &servers_list, global_list) {
4012 /* initialize idle conns lists */
Willy Tarreau430bf4a2021-03-04 09:45:32 +01004013 newsrv->per_thr = calloc(global.nbthread, sizeof(*newsrv->per_thr));
4014 if (!newsrv->per_thr) {
4015 ha_alert("parsing [%s:%d] : failed to allocate per-thread lists for server '%s'.\n",
4016 newsrv->conf.file, newsrv->conf.line, newsrv->id);
Willy Tarreau4cdac162021-03-05 10:48:42 +01004017 cfgerr++;
4018 continue;
4019 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01004020
Willy Tarreau430bf4a2021-03-04 09:45:32 +01004021 for (i = 0; i < global.nbthread; i++) {
4022 newsrv->per_thr[i].idle_conns = EB_ROOT;
4023 newsrv->per_thr[i].safe_conns = EB_ROOT;
4024 newsrv->per_thr[i].avail_conns = EB_ROOT;
Willy Tarreaud4e78d82021-03-04 10:47:54 +01004025 MT_LIST_INIT(&newsrv->per_thr[i].streams);
Willy Tarreau430bf4a2021-03-04 09:45:32 +01004026 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01004027
Willy Tarreau4cdac162021-03-05 10:48:42 +01004028 if (newsrv->max_idle_conns != 0) {
Amaury Denoyelle3efee652021-03-08 17:31:39 +01004029 newsrv->curr_idle_thr = calloc(global.nbthread, sizeof(*newsrv->curr_idle_thr));
4030 if (!newsrv->curr_idle_thr) {
4031 ha_alert("parsing [%s:%d] : failed to allocate idle connection tasks for server '%s'.\n",
4032 newsrv->conf.file, newsrv->conf.line, newsrv->id);
4033 cfgerr++;
4034 continue;
4035 }
Remi Tricot-Le Bretonc5c5bc42021-05-19 16:40:28 +02004036
Amaury Denoyelle3efee652021-03-08 17:31:39 +01004037 }
4038 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01004039
Amaury Denoyelle3efee652021-03-08 17:31:39 +01004040 idle_conn_task = task_new(MAX_THREADS_MASK);
4041 if (!idle_conn_task) {
4042 ha_alert("parsing : failed to allocate global idle connection task.\n");
4043 cfgerr++;
4044 }
4045 else {
4046 idle_conn_task->process = srv_cleanup_idle_conns;
4047 idle_conn_task->context = NULL;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01004048
Amaury Denoyelle3efee652021-03-08 17:31:39 +01004049 for (i = 0; i < global.nbthread; i++) {
4050 idle_conns[i].cleanup_task = task_new(1UL << i);
4051 if (!idle_conns[i].cleanup_task) {
4052 ha_alert("parsing : failed to allocate idle connection tasks for thread '%d'.\n", i);
4053 cfgerr++;
4054 break;
Willy Tarreau4cdac162021-03-05 10:48:42 +01004055 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01004056
Amaury Denoyelle3efee652021-03-08 17:31:39 +01004057 idle_conns[i].cleanup_task->process = srv_cleanup_toremove_conns;
4058 idle_conns[i].cleanup_task->context = NULL;
4059 HA_SPIN_INIT(&idle_conns[i].idle_conns_lock);
4060 MT_LIST_INIT(&idle_conns[i].toremove_conns);
Willy Tarreau835daa12019-02-07 14:46:29 +01004061 }
Willy Tarreau419ead82014-09-16 13:41:21 +02004062 }
4063
Willy Tarreau419ead82014-09-16 13:41:21 +02004064 /* Check multi-process mode compatibility */
4065
Willy Tarreau4975d142021-03-13 11:00:33 +01004066 if (global.nbproc > 1 && global.cli_fe) {
4067 list_for_each_entry(bind_conf, &global.cli_fe->conf.bind, by_fe) {
Willy Tarreau419ead82014-09-16 13:41:21 +02004068 unsigned long mask;
4069
Willy Tarreau4975d142021-03-13 11:00:33 +01004070 mask = proc_mask(global.cli_fe->bind_proc) && all_proc_mask;
Willy Tarreaue26993c2020-09-03 07:18:55 +02004071 mask &= proc_mask(bind_conf->settings.bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02004072
4073 /* stop here if more than one process is used */
Willy Tarreau9504dd62018-10-15 09:37:03 +02004074 if (atleast2(mask))
Willy Tarreau419ead82014-09-16 13:41:21 +02004075 break;
4076 }
Willy Tarreau4975d142021-03-13 11:00:33 +01004077 if (&bind_conf->by_fe != &global.cli_fe->conf.bind) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004078 ha_warning("stats socket will not work as expected in multi-process mode (nbproc > 1), you should force process binding globally using 'stats bind-process' or per socket using the 'process' attribute.\n");
Willy Tarreau419ead82014-09-16 13:41:21 +02004079 }
4080 }
4081
4082 /* Make each frontend inherit bind-process from its listeners when not specified. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004083 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02004084 if (curproxy->bind_proc)
4085 continue;
4086
4087 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
4088 unsigned long mask;
4089
Willy Tarreaue26993c2020-09-03 07:18:55 +02004090 mask = proc_mask(bind_conf->settings.bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02004091 curproxy->bind_proc |= mask;
4092 }
Willy Tarreau6daac192019-02-02 17:39:53 +01004093 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02004094 }
4095
Willy Tarreau4975d142021-03-13 11:00:33 +01004096 if (global.cli_fe) {
4097 list_for_each_entry(bind_conf, &global.cli_fe->conf.bind, by_fe) {
Willy Tarreau419ead82014-09-16 13:41:21 +02004098 unsigned long mask;
4099
Willy Tarreaue26993c2020-09-03 07:18:55 +02004100 mask = bind_conf->settings.bind_proc ? bind_conf->settings.bind_proc : 0;
Willy Tarreau4975d142021-03-13 11:00:33 +01004101 global.cli_fe->bind_proc |= mask;
Willy Tarreau419ead82014-09-16 13:41:21 +02004102 }
Willy Tarreau4975d142021-03-13 11:00:33 +01004103 global.cli_fe->bind_proc = proc_mask(global.cli_fe->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02004104 }
4105
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02004106 /* propagate bindings from frontends to backends. Don't do it if there
4107 * are any fatal errors as we must not call it with unresolved proxies.
4108 */
4109 if (!cfgerr) {
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004110 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02004111 if (curproxy->cap & PR_CAP_FE)
4112 propagate_processes(curproxy, NULL);
4113 }
Willy Tarreau419ead82014-09-16 13:41:21 +02004114 }
4115
4116 /* Bind each unbound backend to all processes when not specified. */
Willy Tarreau6daac192019-02-02 17:39:53 +01004117 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
4118 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02004119
4120 /*******************************************************/
4121 /* At this step, all proxies have a non-null bind_proc */
4122 /*******************************************************/
4123
4124 /* perform the final checks before creating tasks */
4125
Emeric Brunfe0979f2022-08-18 15:53:21 +02004126 /* starting to initialize the main proxies list */
4127 init_proxies_list = proxies_list;
4128
4129init_proxies_list_stage2:
4130 for (curproxy = init_proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02004131 struct listener *listener;
4132 unsigned int next_id;
Willy Tarreauc1a21672009-08-16 22:37:44 +02004133
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02004134 /* Configure SSL for each bind line.
4135 * Note: if configuration fails at some point, the ->ctx member
4136 * remains NULL so that listeners can later detach.
4137 */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004138 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau55d37912016-12-21 23:38:39 +01004139 if (bind_conf->xprt->prepare_bind_conf &&
4140 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02004141 cfgerr++;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004142 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02004143
Willy Tarreaue6b98942007-10-29 01:09:36 +01004144 /* adjust this proxy's listeners */
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02004145 next_id = 1;
Willy Tarreau4348fad2012-09-20 16:48:07 +02004146 list_for_each_entry(listener, &curproxy->conf.listeners, by_fe) {
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02004147 int nbproc;
4148
4149 nbproc = my_popcountl(curproxy->bind_proc &
Willy Tarreaue26993c2020-09-03 07:18:55 +02004150 (listener->bind_conf->settings.bind_proc ? listener->bind_conf->settings.bind_proc : curproxy->bind_proc) &
Willy Tarreaua38a7172019-02-02 17:11:28 +01004151 all_proc_mask);
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02004152
4153 if (!nbproc) /* no intersection between listener and frontend */
4154 nbproc = 1;
4155
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02004156 if (!listener->luid) {
4157 /* listener ID not set, use automatic numbering with first
4158 * spare entry starting with next_luid.
4159 */
4160 next_id = get_next_id(&curproxy->conf.used_listener_id, next_id);
4161 listener->conf.id.key = listener->luid = next_id;
4162 eb32_insert(&curproxy->conf.used_listener_id, &listener->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02004163 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01004164 next_id++;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02004165
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02004166 /* enable separate counters */
4167 if (curproxy->options2 & PR_O2_SOCKSTAT) {
Willy Tarreauae9bea02016-11-25 14:44:52 +01004168 listener->counters = calloc(1, sizeof(*listener->counters));
Willy Tarreau19d14ef2012-10-29 16:51:55 +01004169 if (!listener->name)
4170 memprintf(&listener->name, "sock-%d", listener->luid);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02004171 }
Willy Tarreau81796be2012-09-22 19:11:47 +02004172
Willy Tarreaue6b98942007-10-29 01:09:36 +01004173 if (curproxy->options & PR_O_TCP_NOLING)
4174 listener->options |= LI_O_NOLINGER;
Willy Tarreau16a21472012-11-19 12:39:59 +01004175 if (!listener->maxaccept)
Willy Tarreau66161322021-02-19 15:50:27 +01004176 listener->maxaccept = global.tune.maxaccept ? global.tune.maxaccept : MAX_ACCEPT;
Willy Tarreau16a21472012-11-19 12:39:59 +01004177
4178 /* we want to have an optimal behaviour on single process mode to
4179 * maximize the work at once, but in multi-process we want to keep
4180 * some fairness between processes, so we target half of the max
4181 * number of events to be balanced over all the processes the proxy
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05004182 * is bound to. Remember that maxaccept = -1 must be kept as it is
Willy Tarreau16a21472012-11-19 12:39:59 +01004183 * used to disable the limit.
4184 */
Christopher Faulet02f3cf12019-04-30 14:08:41 +02004185 if (listener->maxaccept > 0 && nbproc > 1) {
4186 listener->maxaccept = (listener->maxaccept + 1) / 2;
Willy Tarreau16a21472012-11-19 12:39:59 +01004187 listener->maxaccept = (listener->maxaccept + nbproc - 1) / nbproc;
4188 }
4189
Willy Tarreau9903f0e2015-04-04 18:50:31 +02004190 listener->accept = session_accept_fd;
Willy Tarreauc1a21672009-08-16 22:37:44 +02004191 listener->analysers |= curproxy->fe_req_ana;
Willy Tarreau10b688f2015-03-13 16:43:12 +01004192 listener->default_target = curproxy->default_target;
Willy Tarreau3bc13772008-12-07 11:50:35 +01004193
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02004194 if (!LIST_ISEMPTY(&curproxy->tcp_req.l4_rules))
Willy Tarreau7d9736f2016-10-21 16:34:21 +02004195 listener->options |= LI_O_TCP_L4_RULES;
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02004196
Willy Tarreau620408f2016-10-21 16:37:51 +02004197 if (!LIST_ISEMPTY(&curproxy->tcp_req.l5_rules))
4198 listener->options |= LI_O_TCP_L5_RULES;
4199
Willy Tarreau9ea05a72009-06-14 12:07:01 +02004200 /* smart accept mode is automatic in HTTP mode */
4201 if ((curproxy->options2 & PR_O2_SMARTACC) ||
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004202 ((curproxy->mode == PR_MODE_HTTP || listener->bind_conf->is_ssl) &&
Willy Tarreau9ea05a72009-06-14 12:07:01 +02004203 !(curproxy->no_options2 & PR_O2_SMARTACC)))
4204 listener->options |= LI_O_NOQUICKACK;
Willy Tarreaue6b98942007-10-29 01:09:36 +01004205 }
4206
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004207 /* Release unused SSL configs */
4208 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau795cdab2016-12-22 17:30:54 +01004209 if (!bind_conf->is_ssl && bind_conf->xprt->destroy_bind_conf)
4210 bind_conf->xprt->destroy_bind_conf(bind_conf);
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004211 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02004212
Willy Tarreaua38a7172019-02-02 17:11:28 +01004213 if (atleast2(curproxy->bind_proc & all_proc_mask)) {
Willy Tarreau102df612014-05-07 23:56:38 +02004214 if (curproxy->uri_auth) {
Willy Tarreaueb791e02014-09-16 15:11:04 +02004215 int count, maxproc = 0;
4216
4217 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreaue26993c2020-09-03 07:18:55 +02004218 count = my_popcountl(bind_conf->settings.bind_proc);
Willy Tarreaueb791e02014-09-16 15:11:04 +02004219 if (count > maxproc)
4220 maxproc = count;
4221 }
4222 /* backends have 0, frontends have 1 or more */
4223 if (maxproc != 1)
Christopher Faulet767a84b2017-11-24 16:50:31 +01004224 ha_warning("Proxy '%s': in multi-process mode, stats will be"
4225 " limited to process assigned to the current request.\n",
4226 curproxy->id);
Willy Tarreaueb791e02014-09-16 15:11:04 +02004227
Willy Tarreau102df612014-05-07 23:56:38 +02004228 if (!LIST_ISEMPTY(&curproxy->uri_auth->admin_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004229 ha_warning("Proxy '%s': stats admin will not work correctly in multi-process mode.\n",
4230 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01004231 }
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01004232 }
Willy Tarreau102df612014-05-07 23:56:38 +02004233 if (!LIST_ISEMPTY(&curproxy->sticking_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004234 ha_warning("Proxy '%s': sticking rules will not work correctly in multi-process mode.\n",
4235 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01004236 }
4237 }
Willy Tarreau918ff602011-07-25 16:33:49 +02004238
4239 /* create the task associated with the proxy */
Emeric Brunc60def82017-09-27 14:59:38 +02004240 curproxy->task = task_new(MAX_THREADS_MASK);
Willy Tarreau918ff602011-07-25 16:33:49 +02004241 if (curproxy->task) {
4242 curproxy->task->context = curproxy;
4243 curproxy->task->process = manage_proxy;
Willy Tarreau918ff602011-07-25 16:33:49 +02004244 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004245 ha_alert("Proxy '%s': no more memory when trying to allocate the management task\n",
4246 curproxy->id);
Willy Tarreau918ff602011-07-25 16:33:49 +02004247 cfgerr++;
4248 }
Willy Tarreaub369a042014-09-16 13:21:03 +02004249 }
4250
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01004251 /*
Emeric Brunfe0979f2022-08-18 15:53:21 +02004252 * We have just initialized the main proxies list
4253 * we must also configure the log-forward proxies list
4254 */
4255 if (init_proxies_list == proxies_list) {
4256 init_proxies_list = cfg_log_forward;
Emeric Brunba6af4f2022-08-22 10:25:11 +02004257 /* check if list is not null to avoid infinite loop */
4258 if (init_proxies_list)
4259 goto init_proxies_list_stage2;
Emeric Brunfe0979f2022-08-18 15:53:21 +02004260 }
4261
4262 /*
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01004263 * Recount currently required checks.
4264 */
4265
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004266 for (curproxy=proxies_list; curproxy; curproxy=curproxy->next) {
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01004267 int optnum;
4268
Willy Tarreau66aa61f2009-01-18 21:44:07 +01004269 for (optnum = 0; cfg_opts[optnum].name; optnum++)
4270 if (curproxy->options & cfg_opts[optnum].val)
4271 global.last_checks |= cfg_opts[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01004272
Willy Tarreau66aa61f2009-01-18 21:44:07 +01004273 for (optnum = 0; cfg_opts2[optnum].name; optnum++)
4274 if (curproxy->options2 & cfg_opts2[optnum].val)
4275 global.last_checks |= cfg_opts2[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01004276 }
4277
Willy Tarreau0fca4832015-05-01 19:12:05 +02004278 /* compute the required process bindings for the peers */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004279 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004280 if (curproxy->table && curproxy->table->peers.p)
4281 curproxy->table->peers.p->peers_fe->bind_proc |= curproxy->bind_proc;
Willy Tarreau0fca4832015-05-01 19:12:05 +02004282
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01004283 /* compute the required process bindings for the peers from <stktables_list>
4284 * for all the stick-tables, the ones coming with "peers" sections included.
4285 */
4286 for (t = stktables_list; t; t = t->next) {
4287 struct proxy *p;
4288
4289 for (p = t->proxies_list; p; p = p->next_stkt_ref) {
4290 if (t->peers.p && t->peers.p->peers_fe) {
4291 t->peers.p->peers_fe->bind_proc |= p->bind_proc;
4292 }
4293 }
4294 }
4295
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02004296 if (cfg_peers) {
4297 struct peers *curpeers = cfg_peers, **last;
Willy Tarreau122541c2011-09-07 21:24:49 +02004298 struct peer *p, *pb;
4299
William Lallemanda2cfd7e2020-03-24 16:02:48 +01004300 /* In the case the peers frontend was not initialized by a
4301 stick-table used in the configuration, set its bind_proc
4302 by default to the first process. */
4303 while (curpeers) {
William Lallemand3ef2d562020-03-24 16:42:15 +01004304 if (curpeers->peers_fe) {
4305 if (curpeers->peers_fe->bind_proc == 0)
4306 curpeers->peers_fe->bind_proc = 1;
4307 }
William Lallemanda2cfd7e2020-03-24 16:02:48 +01004308 curpeers = curpeers->next;
4309 }
4310
4311 curpeers = cfg_peers;
Willy Tarreau1e273012015-05-01 19:15:17 +02004312 /* Remove all peers sections which don't have a valid listener,
4313 * which are not used by any table, or which are bound to more
4314 * than one process.
Willy Tarreau122541c2011-09-07 21:24:49 +02004315 */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02004316 last = &cfg_peers;
Willy Tarreau122541c2011-09-07 21:24:49 +02004317 while (*last) {
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01004318 struct stktable *t;
Willy Tarreau122541c2011-09-07 21:24:49 +02004319 curpeers = *last;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004320
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02004321 if (curpeers->disabled) {
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004322 /* the "disabled" keyword was present */
4323 if (curpeers->peers_fe)
4324 stop_proxy(curpeers->peers_fe);
4325 curpeers->peers_fe = NULL;
4326 }
Frédéric Lécaille5a4fe5a2019-10-04 08:30:04 +02004327 else if (!curpeers->peers_fe || !curpeers->peers_fe->id) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004328 ha_warning("Removing incomplete section 'peers %s' (no peer named '%s').\n",
4329 curpeers->id, localpeer);
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01004330 if (curpeers->peers_fe)
4331 stop_proxy(curpeers->peers_fe);
4332 curpeers->peers_fe = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004333 }
Willy Tarreau9504dd62018-10-15 09:37:03 +02004334 else if (atleast2(curpeers->peers_fe->bind_proc)) {
Willy Tarreau1e273012015-05-01 19:15:17 +02004335 /* either it's totally stopped or too much used */
4336 if (curpeers->peers_fe->bind_proc) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004337 ha_alert("Peers section '%s': peers referenced by sections "
4338 "running in different processes (%d different ones). "
4339 "Check global.nbproc and all tables' bind-process "
4340 "settings.\n", curpeers->id, my_popcountl(curpeers->peers_fe->bind_proc));
Willy Tarreau1e273012015-05-01 19:15:17 +02004341 cfgerr++;
4342 }
4343 stop_proxy(curpeers->peers_fe);
4344 curpeers->peers_fe = NULL;
4345 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004346 else {
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01004347 /* Initializes the transport layer of the server part of all the peers belonging to
4348 * <curpeers> section if required.
4349 * Note that ->srv is used by the local peer of a new process to connect to the local peer
4350 * of an old process.
4351 */
Frédéric Lécaille1055e682018-04-26 14:35:21 +02004352 p = curpeers->remote;
4353 while (p) {
Frédéric Lécaille355b2032019-01-11 14:06:12 +01004354 if (p->srv) {
Christopher Fauletf61f33a2020-03-27 18:55:49 +01004355 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 +01004356 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(p->srv);
4357 }
Frédéric Lécaille1055e682018-04-26 14:35:21 +02004358 p = p->next;
4359 }
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01004360 /* Configure the SSL bindings of the local peer if required. */
4361 if (!LIST_ISEMPTY(&curpeers->peers_fe->conf.bind)) {
4362 struct list *l;
4363 struct bind_conf *bind_conf;
4364
4365 l = &curpeers->peers_fe->conf.bind;
4366 bind_conf = LIST_ELEM(l->n, typeof(bind_conf), by_fe);
4367 if (bind_conf->xprt->prepare_bind_conf &&
4368 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
4369 cfgerr++;
4370 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02004371 if (!peers_init_sync(curpeers) || !peers_alloc_dcache(curpeers)) {
Willy Tarreaud9443442018-10-15 11:18:03 +02004372 ha_alert("Peers section '%s': out of memory, giving up on peers.\n",
4373 curpeers->id);
4374 cfgerr++;
4375 break;
4376 }
Willy Tarreau122541c2011-09-07 21:24:49 +02004377 last = &curpeers->next;
4378 continue;
4379 }
4380
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004381 /* clean what has been detected above */
Willy Tarreau122541c2011-09-07 21:24:49 +02004382 p = curpeers->remote;
4383 while (p) {
4384 pb = p->next;
4385 free(p->id);
4386 free(p);
4387 p = pb;
4388 }
4389
4390 /* Destroy and unlink this curpeers section.
4391 * Note: curpeers is backed up into *last.
4392 */
4393 free(curpeers->id);
4394 curpeers = curpeers->next;
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01004395 /* Reset any refereance to this peers section in the list of stick-tables */
4396 for (t = stktables_list; t; t = t->next) {
4397 if (t->peers.p && t->peers.p == *last)
4398 t->peers.p = NULL;
4399 }
Willy Tarreau122541c2011-09-07 21:24:49 +02004400 free(*last);
4401 *last = curpeers;
4402 }
4403 }
4404
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004405 for (t = stktables_list; t; t = t->next) {
4406 if (t->proxy)
4407 continue;
4408 if (!stktable_init(t)) {
Aurelien DARRAGONc04eb0b2023-11-03 12:10:56 +01004409 ha_alert("Parsing [%s:%d]: failed to initialize '%s' stick-table.\n", t->conf.file, t->conf.line, t->id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004410 cfgerr++;
4411 }
4412 }
4413
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004414 /* initialize stick-tables on backend capable proxies. This must not
4415 * be done earlier because the data size may be discovered while parsing
4416 * other proxies.
4417 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004418 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauc3914d42020-09-24 08:39:22 +02004419 if (curproxy->disabled || !curproxy->table)
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004420 continue;
4421
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004422 if (!stktable_init(curproxy->table)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004423 ha_alert("Proxy '%s': failed to initialize stick-table.\n", curproxy->id);
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004424 cfgerr++;
4425 }
4426 }
4427
Simon Horman0d16a402015-01-30 11:22:58 +09004428 if (mailers) {
4429 struct mailers *curmailers = mailers, **last;
4430 struct mailer *m, *mb;
4431
4432 /* Remove all mailers sections which don't have a valid listener.
4433 * This can happen when a mailers section is never referenced.
4434 */
4435 last = &mailers;
4436 while (*last) {
4437 curmailers = *last;
4438 if (curmailers->users) {
4439 last = &curmailers->next;
4440 continue;
4441 }
4442
Christopher Faulet767a84b2017-11-24 16:50:31 +01004443 ha_warning("Removing incomplete section 'mailers %s'.\n",
4444 curmailers->id);
Simon Horman0d16a402015-01-30 11:22:58 +09004445
4446 m = curmailers->mailer_list;
4447 while (m) {
4448 mb = m->next;
4449 free(m->id);
4450 free(m);
4451 m = mb;
4452 }
4453
4454 /* Destroy and unlink this curmailers section.
4455 * Note: curmailers is backed up into *last.
4456 */
4457 free(curmailers->id);
4458 curmailers = curmailers->next;
4459 free(*last);
4460 *last = curmailers;
4461 }
4462 }
4463
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004464 /* Update server_state_file_name to backend name if backend is supposed to use
4465 * a server-state file locally defined and none has been provided */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004466 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004467 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_LOCAL &&
4468 curproxy->server_state_file_name == NULL)
4469 curproxy->server_state_file_name = strdup(curproxy->id);
4470 }
4471
Emeric Brun750fe792020-12-23 16:51:12 +01004472 list_for_each_entry(curr_resolvers, &sec_resolvers, list) {
Ben Draut054fbee2018-04-13 15:43:04 -06004473 if (LIST_ISEMPTY(&curr_resolvers->nameservers)) {
4474 ha_warning("config : resolvers '%s' [%s:%d] has no nameservers configured!\n",
4475 curr_resolvers->id, curr_resolvers->conf.file,
4476 curr_resolvers->conf.line);
4477 err_code |= ERR_WARN;
4478 }
4479 }
4480
William Lallemand48b4bb42017-10-23 14:36:34 +02004481 list_for_each_entry(postparser, &postparsers, list) {
4482 if (postparser->func)
4483 cfgerr += postparser->func();
4484 }
4485
Willy Tarreaubb925012009-07-23 13:36:36 +02004486 if (cfgerr > 0)
4487 err_code |= ERR_ALERT | ERR_FATAL;
4488 out:
4489 return err_code;
Willy Tarreaubaaee002006-06-26 02:48:02 +02004490}
4491
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004492/*
4493 * Registers the CFG keyword list <kwl> as a list of valid keywords for next
4494 * parsing sessions.
4495 */
4496void cfg_register_keywords(struct cfg_kw_list *kwl)
4497{
Willy Tarreau2b718102021-04-21 07:32:39 +02004498 LIST_APPEND(&cfg_keywords.list, &kwl->list);
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004499}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004500
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004501/*
4502 * Unregisters the CFG keyword list <kwl> from the list of valid keywords.
4503 */
4504void cfg_unregister_keywords(struct cfg_kw_list *kwl)
4505{
Willy Tarreau2b718102021-04-21 07:32:39 +02004506 LIST_DELETE(&kwl->list);
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004507 LIST_INIT(&kwl->list);
4508}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004509
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004510/* this function register new section in the haproxy configuration file.
4511 * <section_name> is the name of this new section and <section_parser>
4512 * is the called parser. If two section declaration have the same name,
4513 * only the first declared is used.
4514 */
4515int cfg_register_section(char *section_name,
William Lallemandd2ff56d2017-10-16 11:06:50 +02004516 int (*section_parser)(const char *, int, char **, int),
4517 int (*post_section_parser)())
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004518{
4519 struct cfg_section *cs;
4520
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004521 list_for_each_entry(cs, &sections, list) {
4522 if (strcmp(cs->section_name, section_name) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004523 ha_alert("register section '%s': already registered.\n", section_name);
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004524 return 0;
4525 }
4526 }
4527
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004528 cs = calloc(1, sizeof(*cs));
4529 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004530 ha_alert("register section '%s': out of memory.\n", section_name);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004531 return 0;
4532 }
4533
4534 cs->section_name = section_name;
4535 cs->section_parser = section_parser;
William Lallemandd2ff56d2017-10-16 11:06:50 +02004536 cs->post_section_parser = post_section_parser;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004537
Willy Tarreau2b718102021-04-21 07:32:39 +02004538 LIST_APPEND(&sections, &cs->list);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004539
4540 return 1;
4541}
4542
William Lallemand48b4bb42017-10-23 14:36:34 +02004543/* this function register a new function which will be called once the haproxy
4544 * configuration file has been parsed. It's useful to check dependencies
4545 * between sections or to resolve items once everything is parsed.
4546 */
4547int cfg_register_postparser(char *name, int (*func)())
4548{
4549 struct cfg_postparser *cp;
4550
4551 cp = calloc(1, sizeof(*cp));
4552 if (!cp) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004553 ha_alert("register postparser '%s': out of memory.\n", name);
William Lallemand48b4bb42017-10-23 14:36:34 +02004554 return 0;
4555 }
4556 cp->name = name;
4557 cp->func = func;
4558
Willy Tarreau2b718102021-04-21 07:32:39 +02004559 LIST_APPEND(&postparsers, &cp->list);
William Lallemand48b4bb42017-10-23 14:36:34 +02004560
4561 return 1;
4562}
4563
Willy Tarreaubaaee002006-06-26 02:48:02 +02004564/*
David Carlier845efb52015-09-25 11:49:18 +01004565 * free all config section entries
4566 */
4567void cfg_unregister_sections(void)
4568{
4569 struct cfg_section *cs, *ics;
4570
4571 list_for_each_entry_safe(cs, ics, &sections, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004572 LIST_DELETE(&cs->list);
David Carlier845efb52015-09-25 11:49:18 +01004573 free(cs);
4574 }
4575}
4576
Christopher Faulet7110b402016-10-26 11:09:44 +02004577void cfg_backup_sections(struct list *backup_sections)
4578{
4579 struct cfg_section *cs, *ics;
4580
4581 list_for_each_entry_safe(cs, ics, &sections, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004582 LIST_DELETE(&cs->list);
4583 LIST_APPEND(backup_sections, &cs->list);
Christopher Faulet7110b402016-10-26 11:09:44 +02004584 }
4585}
4586
4587void cfg_restore_sections(struct list *backup_sections)
4588{
4589 struct cfg_section *cs, *ics;
4590
4591 list_for_each_entry_safe(cs, ics, backup_sections, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004592 LIST_DELETE(&cs->list);
4593 LIST_APPEND(&sections, &cs->list);
Christopher Faulet7110b402016-10-26 11:09:44 +02004594 }
4595}
4596
Willy Tarreaue6552512018-11-26 11:33:13 +01004597/* these are the config sections handled by default */
4598REGISTER_CONFIG_SECTION("listen", cfg_parse_listen, NULL);
4599REGISTER_CONFIG_SECTION("frontend", cfg_parse_listen, NULL);
4600REGISTER_CONFIG_SECTION("backend", cfg_parse_listen, NULL);
4601REGISTER_CONFIG_SECTION("defaults", cfg_parse_listen, NULL);
4602REGISTER_CONFIG_SECTION("global", cfg_parse_global, NULL);
4603REGISTER_CONFIG_SECTION("userlist", cfg_parse_users, NULL);
4604REGISTER_CONFIG_SECTION("peers", cfg_parse_peers, NULL);
4605REGISTER_CONFIG_SECTION("mailers", cfg_parse_mailers, NULL);
4606REGISTER_CONFIG_SECTION("namespace_list", cfg_parse_netns, NULL);
Willy Tarreau659fbf02016-05-26 17:55:28 +02004607
Willy Tarreau8a022d52021-04-27 20:29:11 +02004608static struct cfg_kw_list cfg_kws = {{ },{
4609 { CFG_GLOBAL, "default-path", cfg_parse_global_def_path },
4610 { /* END */ }
4611}};
4612
4613INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
4614
David Carlier845efb52015-09-25 11:49:18 +01004615/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02004616 * Local variables:
4617 * c-indent-level: 8
4618 * c-basic-offset: 8
4619 * End:
4620 */