blob: af727440bd45c4279687c94286a6b0f99f98718b [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 Tarreaue5733232019-05-22 19:24:06 +020013#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +020014/* This is to have crypt() defined on Linux */
15#define _GNU_SOURCE
16
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 Tarreau3f49b302007-06-11 00:29:26 +020032#include <sys/types.h>
33#include <sys/stat.h>
34#include <fcntl.h>
35#include <unistd.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020036
Willy Tarreaudcc048a2020-06-04 19:11:43 +020037#include <haproxy/acl.h>
Christopher Faulet42c6cf92021-03-25 17:19:04 +010038#include <haproxy/action.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020039#include <haproxy/api.h>
Willy Tarreau732525f2021-05-06 15:49:04 +020040#include <haproxy/arg.h>
Willy Tarreauac13aea2020-06-04 10:36:03 +020041#include <haproxy/auth.h>
Willy Tarreau49801602020-06-04 22:50:02 +020042#include <haproxy/backend.h>
Willy Tarreau278161c2020-06-04 11:18:28 +020043#include <haproxy/capture.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020044#include <haproxy/cfgparse.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020045#include <haproxy/channel.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020046#include <haproxy/check.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020047#include <haproxy/chunk.h>
Amaury Denoyellea6f9c5d2021-04-23 16:58:08 +020048#ifdef USE_CPU_AFFINITY
Amaury Denoyellec90932b2021-04-14 16:16:03 +020049#include <haproxy/cpuset.h>
Amaury Denoyellea6f9c5d2021-04-23 16:58:08 +020050#endif
Willy Tarreau7ea393d2020-06-04 18:02:10 +020051#include <haproxy/connection.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020052#include <haproxy/errors.h>
Willy Tarreauc7babd82020-06-04 21:29:29 +020053#include <haproxy/filters.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020054#include <haproxy/frontend.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020055#include <haproxy/global.h>
Willy Tarreauc2b1ff02020-06-04 21:21:03 +020056#include <haproxy/http_ana.h>
Willy Tarreauc761f842020-06-04 11:40:28 +020057#include <haproxy/http_rules.h>
Willy Tarreaufbe8da32020-06-04 14:34:27 +020058#include <haproxy/lb_chash.h>
Willy Tarreaub5fc3bf2020-06-04 14:37:38 +020059#include <haproxy/lb_fas.h>
Willy Tarreau02549412020-06-04 14:41:04 +020060#include <haproxy/lb_fwlc.h>
Willy Tarreau546ba422020-06-04 14:45:03 +020061#include <haproxy/lb_fwrr.h>
Willy Tarreau28671592020-06-04 20:22:59 +020062#include <haproxy/lb_map.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020063#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020064#include <haproxy/log.h>
Willy Tarreaucee013e2020-06-05 11:40:38 +020065#include <haproxy/mailers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020066#include <haproxy/namespace.h>
Willy Tarreau8efbdfb2020-06-04 11:29:21 +020067#include <haproxy/obj_type-t.h>
Willy Tarreau3c2a7c22020-06-04 18:38:21 +020068#include <haproxy/peers-t.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020069#include <haproxy/peers.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020070#include <haproxy/pool.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020071#include <haproxy/protocol.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020072#include <haproxy/proxy.h>
Emeric Brunc9437992021-02-12 19:42:55 +010073#include <haproxy/resolvers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020074#include <haproxy/sample.h>
75#include <haproxy/server.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020076#include <haproxy/session.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020077#include <haproxy/stats-t.h>
Willy Tarreau872f2ea2020-06-04 18:46:44 +020078#include <haproxy/stick_table.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020079#include <haproxy/stream.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020080#include <haproxy/task.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020081#include <haproxy/tcp_rules.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020082#include <haproxy/thread.h>
83#include <haproxy/time.h>
84#include <haproxy/tools.h>
85#include <haproxy/uri_auth-t.h>
Frédéric Lécaille884f2e92020-11-23 14:23:21 +010086#include <haproxy/xprt_quic.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020087
88
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +010089/* Used to chain configuration sections definitions. This list
90 * stores struct cfg_section
91 */
92struct list sections = LIST_HEAD_INIT(sections);
93
William Lallemand48b4bb42017-10-23 14:36:34 +020094struct list postparsers = LIST_HEAD_INIT(postparsers);
95
Eric Salama1b8dacc2021-03-16 15:12:17 +010096extern struct proxy *mworker_proxy;
97
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +010098char *cursection = NULL;
Willy Tarreauc8d5b952019-02-27 17:25:52 +010099int cfg_maxpconn = 0; /* # of simultaneous connections per proxy (-N) */
Willy Tarreau5af24ef2009-03-15 15:23:16 +0100100int cfg_maxconn = 0; /* # of simultaneous connections, (-n) */
Christopher Faulet79bdef32016-11-04 22:36:15 +0100101char *cfg_scope = NULL; /* the current scope during the configuration parsing */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200102
Willy Tarreau8a022d52021-04-27 20:29:11 +0200103/* how to handle default paths */
104static enum default_path_mode {
105 DEFAULT_PATH_CURRENT = 0, /* "current": paths are relative to CWD (this is the default) */
106 DEFAULT_PATH_CONFIG, /* "config": paths are relative to config file */
107 DEFAULT_PATH_PARENT, /* "parent": paths are relative to config file's ".." */
108 DEFAULT_PATH_ORIGIN, /* "origin": paths are relative to default_path_origin */
109} default_path_mode;
110
111static char initial_cwd[PATH_MAX];
112static char current_cwd[PATH_MAX];
113
Willy Tarreau5b2c3362008-07-09 19:39:06 +0200114/* List head of all known configuration keywords */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100115struct cfg_kw_list cfg_keywords = {
Willy Tarreau5b2c3362008-07-09 19:39:06 +0200116 .list = LIST_HEAD_INIT(cfg_keywords.list)
117};
118
Willy Tarreau4b103022021-02-12 17:59:10 +0100119/* nested if/elif/else/endif block states */
120enum nested_cond_state {
121 NESTED_COND_IF_TAKE, // "if" with a true condition
122 NESTED_COND_IF_DROP, // "if" with a false condition
123 NESTED_COND_IF_SKIP, // "if" masked by an outer false condition
124
125 NESTED_COND_ELIF_TAKE, // "elif" with a true condition from a false one
126 NESTED_COND_ELIF_DROP, // "elif" with a false condition from a false one
127 NESTED_COND_ELIF_SKIP, // "elif" masked by an outer false condition or a previously taken if
128
129 NESTED_COND_ELSE_TAKE, // taken "else" after an if false condition
130 NESTED_COND_ELSE_DROP, // "else" masked by outer false condition or an if true condition
131};
132
133/* 100 levels of nested conditions should already be sufficient */
134#define MAXNESTEDCONDS 100
135
Willy Tarreau732525f2021-05-06 15:49:04 +0200136/* supported conditional predicates for .if/.elif */
137enum cond_predicate {
138 CFG_PRED_NONE, // none
Willy Tarreau42ed14b2021-05-06 15:55:14 +0200139 CFG_PRED_DEFINED, // "defined"
Willy Tarreau58ca7062021-05-06 16:34:23 +0200140 CFG_PRED_FEATURE, // "feature"
Willy Tarreau6492e872021-05-06 16:10:09 +0200141 CFG_PRED_STREQ, // "streq"
142 CFG_PRED_STRNEQ, // "strneq"
Willy Tarreau0b7c78a2021-05-06 16:53:26 +0200143 CFG_PRED_VERSION_ATLEAST, // "version_atleast"
144 CFG_PRED_VERSION_BEFORE, // "version_before"
Willy Tarreau732525f2021-05-06 15:49:04 +0200145};
146
147struct cond_pred_kw {
148 const char *word; // NULL marks the end of the list
149 enum cond_predicate prd; // one of the CFG_PRED_* above
150 uint64_t arg_mask; // mask of supported arguments (strings only)
151};
152
153/* supported condition predicates */
154const struct cond_pred_kw cond_predicates[] = {
Willy Tarreau42ed14b2021-05-06 15:55:14 +0200155 { "defined", CFG_PRED_DEFINED, ARG1(1, STR) },
Willy Tarreau58ca7062021-05-06 16:34:23 +0200156 { "feature", CFG_PRED_FEATURE, ARG1(1, STR) },
Willy Tarreau6492e872021-05-06 16:10:09 +0200157 { "streq", CFG_PRED_STREQ, ARG2(2, STR, STR) },
158 { "strneq", CFG_PRED_STRNEQ, ARG2(2, STR, STR) },
Willy Tarreau0b7c78a2021-05-06 16:53:26 +0200159 { "version_atleast", CFG_PRED_VERSION_ATLEAST, ARG1(1, STR) },
160 { "version_before", CFG_PRED_VERSION_BEFORE, ARG1(1, STR) },
Willy Tarreau732525f2021-05-06 15:49:04 +0200161 { NULL, CFG_PRED_NONE, 0 }
162};
163
Willy Tarreaubaaee002006-06-26 02:48:02 +0200164/*
165 * converts <str> to a list of listeners which are dynamically allocated.
166 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
167 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
168 * - <port> is a numerical port from 1 to 65535 ;
169 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
170 * This can be repeated as many times as necessary, separated by a coma.
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200171 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
172 * not NULL, it must be a valid pointer to either NULL or a freeable area that
173 * will be replaced with an error message.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200174 */
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200175int 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 +0200176{
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200177 struct protocol *proto;
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100178 char *next, *dupstr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200179 int port, end;
180
181 next = dupstr = strdup(str);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200182
Willy Tarreaubaaee002006-06-26 02:48:02 +0200183 while (next && *next) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200184 struct sockaddr_storage *ss2;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100185 int fd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200186
187 str = next;
188 /* 1) look for the end of the first address */
Krzysztof Piotr Oledzki52d522b2009-01-27 16:57:08 +0100189 if ((next = strchr(str, ',')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200190 *next++ = 0;
191 }
192
Willy Tarreau5fc93282020-09-16 18:25:03 +0200193 ss2 = str2sa_range(str, NULL, &port, &end, &fd, &proto, err,
Eric Salama1b8dacc2021-03-16 15:12:17 +0100194 (curproxy == global.cli_fe || curproxy == mworker_proxy) ? NULL : global.unix_bind.prefix,
Willy Tarreau32819932020-09-04 15:53:16 +0200195 NULL, PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_PORT_RANGE |
Willy Tarreau5e1779a2020-09-16 16:28:08 +0200196 PA_O_SOCKET_FD | PA_O_STREAM | PA_O_XPRT);
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100197 if (!ss2)
198 goto fail;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200199
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100200 /* OK the address looks correct */
Frédéric Lécaille884f2e92020-11-23 14:23:21 +0100201
202#ifdef USE_QUIC
203 /* The transport layer automatically switches to QUIC when QUIC
204 * is selected, regardless of bind_conf settings. We then need
205 * to initialize QUIC params.
206 */
207 if (proto->sock_type == SOCK_DGRAM && proto->ctrl_type == SOCK_STREAM) {
208 bind_conf->xprt = xprt_get(XPRT_QUIC);
209 quic_transport_params_init(&bind_conf->quic_params, 1);
210 }
211#endif
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200212 if (!create_listeners(bind_conf, ss2, port, end, fd, proto, err)) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200213 memprintf(err, "%s for address '%s'.\n", *err, str);
214 goto fail;
215 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200216 } /* end while(next) */
217 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200218 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200219 fail:
220 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200221 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200222}
223
William Lallemand6e62fb62015-04-28 16:55:23 +0200224/*
Willy Tarreauaa333122020-09-16 15:13:04 +0200225 * converts <str> to a list of datagram-oriented listeners which are dynamically
226 * allocated.
227 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
228 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
229 * - <port> is a numerical port from 1 to 65535 ;
230 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
231 * This can be repeated as many times as necessary, separated by a coma.
232 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
233 * not NULL, it must be a valid pointer to either NULL or a freeable area that
234 * will be replaced with an error message.
235 */
236int str2receiver(char *str, struct proxy *curproxy, struct bind_conf *bind_conf, const char *file, int line, char **err)
237{
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200238 struct protocol *proto;
Willy Tarreauaa333122020-09-16 15:13:04 +0200239 char *next, *dupstr;
240 int port, end;
241
242 next = dupstr = strdup(str);
243
244 while (next && *next) {
245 struct sockaddr_storage *ss2;
246 int fd = -1;
247
248 str = next;
249 /* 1) look for the end of the first address */
250 if ((next = strchr(str, ',')) != NULL) {
251 *next++ = 0;
252 }
253
Willy Tarreau5fc93282020-09-16 18:25:03 +0200254 ss2 = str2sa_range(str, NULL, &port, &end, &fd, &proto, err,
Willy Tarreau4975d142021-03-13 11:00:33 +0100255 curproxy == global.cli_fe ? NULL : global.unix_bind.prefix,
Willy Tarreauaa333122020-09-16 15:13:04 +0200256 NULL, PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_PORT_RANGE |
257 PA_O_SOCKET_FD | PA_O_DGRAM | PA_O_XPRT);
258 if (!ss2)
259 goto fail;
260
261 /* OK the address looks correct */
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200262 if (!create_listeners(bind_conf, ss2, port, end, fd, proto, err)) {
Willy Tarreauaa333122020-09-16 15:13:04 +0200263 memprintf(err, "%s for address '%s'.\n", *err, str);
264 goto fail;
265 }
266 } /* end while(next) */
267 free(dupstr);
268 return 1;
269 fail:
270 free(dupstr);
271 return 0;
272}
273
274/*
Willy Tarreauece9b072016-12-21 22:41:44 +0100275 * Report an error in <msg> when there are too many arguments. This version is
276 * intended to be used by keyword parsers so that the message will be included
277 * into the general error message. The index is the current keyword in args.
278 * Return 0 if the number of argument is correct, otherwise build a message and
279 * return 1. Fill err_code with an ERR_ALERT and an ERR_FATAL if not null. The
280 * message may also be null, it will simply not be produced (useful to check only).
281 * <msg> and <err_code> are only affected on error.
282 */
283int too_many_args_idx(int maxarg, int index, char **args, char **msg, int *err_code)
284{
285 int i;
286
287 if (!*args[index + maxarg + 1])
288 return 0;
289
290 if (msg) {
291 *msg = NULL;
292 memprintf(msg, "%s", args[0]);
293 for (i = 1; i <= index; i++)
294 memprintf(msg, "%s %s", *msg, args[i]);
295
296 memprintf(msg, "'%s' cannot handle unexpected argument '%s'.", *msg, args[index + maxarg + 1]);
297 }
298 if (err_code)
299 *err_code |= ERR_ALERT | ERR_FATAL;
300
301 return 1;
302}
303
304/*
305 * same as too_many_args_idx with a 0 index
306 */
307int too_many_args(int maxarg, char **args, char **msg, int *err_code)
308{
309 return too_many_args_idx(maxarg, 0, args, msg, err_code);
310}
311
312/*
William Lallemand6e62fb62015-04-28 16:55:23 +0200313 * Report a fatal Alert when there is too much arguments
314 * The index is the current keyword in args
315 * Return 0 if the number of argument is correct, otherwise emit an alert and return 1
316 * Fill err_code with an ERR_ALERT and an ERR_FATAL
317 */
318int alertif_too_many_args_idx(int maxarg, int index, const char *file, int linenum, char **args, int *err_code)
319{
320 char *kw = NULL;
321 int i;
322
323 if (!*args[index + maxarg + 1])
324 return 0;
325
326 memprintf(&kw, "%s", args[0]);
327 for (i = 1; i <= index; i++) {
328 memprintf(&kw, "%s %s", kw, args[i]);
329 }
330
Christopher Faulet767a84b2017-11-24 16:50:31 +0100331 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 +0200332 free(kw);
333 *err_code |= ERR_ALERT | ERR_FATAL;
334 return 1;
335}
336
337/*
338 * same as alertif_too_many_args_idx with a 0 index
339 */
340int alertif_too_many_args(int maxarg, const char *file, int linenum, char **args, int *err_code)
341{
342 return alertif_too_many_args_idx(maxarg, 0, file, linenum, args, err_code);
343}
344
Willy Tarreau61d18892009-03-31 10:49:21 +0200345
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100346/* Report it if a request ACL condition uses some keywords that are incompatible
347 * with the place where the ACL is used. It returns either 0 or ERR_WARN so that
348 * its result can be or'ed with err_code. Note that <cond> may be NULL and then
349 * will be ignored.
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100350 */
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100351int warnif_cond_conflicts(const struct acl_cond *cond, unsigned int where, const char *file, int line)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100352{
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100353 const struct acl *acl;
Willy Tarreau93fddf12013-03-31 22:59:32 +0200354 const char *kw;
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100355
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100356 if (!cond)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100357 return 0;
358
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100359 acl = acl_cond_conflicts(cond, where);
360 if (acl) {
361 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100362 ha_warning("parsing [%s:%d] : acl '%s' will never match because it only involves keywords that are incompatible with '%s'\n",
363 file, line, acl->name, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100364 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100365 ha_warning("parsing [%s:%d] : anonymous acl will never match because it uses keyword '%s' which is incompatible with '%s'\n",
366 file, line, LIST_ELEM(acl->expr.n, struct acl_expr *, list)->kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100367 return ERR_WARN;
368 }
369 if (!acl_cond_kw_conflicts(cond, where, &acl, &kw))
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100370 return 0;
371
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100372 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100373 ha_warning("parsing [%s:%d] : acl '%s' involves keywords '%s' which is incompatible with '%s'\n",
374 file, line, acl->name, kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100375 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100376 ha_warning("parsing [%s:%d] : anonymous acl involves keyword '%s' which is incompatible with '%s'\n",
377 file, line, kw, sample_ckp_names(where));
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100378 return ERR_WARN;
379}
380
Christopher Faulet581db2b2021-03-26 10:02:46 +0100381/* Report it if an ACL uses a L6 sample fetch from an HTTP proxy. It returns
382 * either 0 or ERR_WARN so that its result can be or'ed with err_code. Note that
383 * <cond> may be NULL and then will be ignored.
384*/
385int warnif_tcp_http_cond(const struct proxy *px, const struct acl_cond *cond)
386{
387 if (!cond || px->mode != PR_MODE_HTTP)
388 return 0;
389
390 if (cond->use & (SMP_USE_L6REQ|SMP_USE_L6RES)) {
391 ha_warning("Proxy '%s': L6 sample fetches ignored on HTTP proxies (declared at %s:%d).\n",
392 px->id, cond->file, cond->line);
393 return ERR_WARN;
394 }
395 return 0;
396}
397
Willy Tarreaue2afcc42021-03-12 09:08:04 +0100398/* try to find in <list> the word that looks closest to <word> by counting
399 * transitions between letters, digits and other characters. Will return the
400 * best matching word if found, otherwise NULL. An optional array of extra
401 * words to compare may be passed in <extra>, but it must then be terminated
402 * by a NULL entry. If unused it may be NULL.
403 */
404const char *cfg_find_best_match(const char *word, const struct list *list, int section, const char **extra)
405{
406 uint8_t word_sig[1024]; // 0..25=letter, 26=digit, 27=other, 28=begin, 29=end
407 uint8_t list_sig[1024];
408 const struct cfg_kw_list *kwl;
409 int index;
410 const char *best_ptr = NULL;
411 int dist, best_dist = INT_MAX;
412
413 make_word_fingerprint(word_sig, word);
414 list_for_each_entry(kwl, list, list) {
415 for (index = 0; kwl->kw[index].kw != NULL; index++) {
416 if (kwl->kw[index].section != section)
417 continue;
418
419 make_word_fingerprint(list_sig, kwl->kw[index].kw);
420 dist = word_fingerprint_distance(word_sig, list_sig);
421 if (dist < best_dist) {
422 best_dist = dist;
423 best_ptr = kwl->kw[index].kw;
424 }
425 }
426 }
427
428 while (extra && *extra) {
429 make_word_fingerprint(list_sig, *extra);
430 dist = word_fingerprint_distance(word_sig, list_sig);
431 if (dist < best_dist) {
432 best_dist = dist;
433 best_ptr = *extra;
434 }
435 extra++;
436 }
437
438 if (best_dist > 2 * strlen(word) || (best_ptr && best_dist > 2 * strlen(best_ptr)))
439 best_ptr = NULL;
440 return best_ptr;
441}
442
Christopher Faulet62519022017-10-16 15:49:32 +0200443/* Parse a string representing a process number or a set of processes. It must
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100444 * be "all", "odd", "even", a number between 1 and <max> or a range with
Christopher Faulet5ab51772017-11-22 11:21:58 +0100445 * two such numbers delimited by a dash ('-'). On success, it returns
446 * 0. otherwise it returns 1 with an error message in <err>.
Christopher Faulet62519022017-10-16 15:49:32 +0200447 *
448 * Note: this function can also be used to parse a thread number or a set of
449 * threads.
450 */
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100451int parse_process_number(const char *arg, unsigned long *proc, int max, int *autoinc, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200452{
Christopher Faulet26028f62017-11-22 15:01:51 +0100453 if (autoinc) {
454 *autoinc = 0;
455 if (strncmp(arg, "auto:", 5) == 0) {
456 arg += 5;
457 *autoinc = 1;
458 }
459 }
460
Christopher Faulet62519022017-10-16 15:49:32 +0200461 if (strcmp(arg, "all") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100462 *proc |= ~0UL;
Christopher Faulet62519022017-10-16 15:49:32 +0200463 else if (strcmp(arg, "odd") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100464 *proc |= ~0UL/3UL; /* 0x555....555 */
Christopher Faulet62519022017-10-16 15:49:32 +0200465 else if (strcmp(arg, "even") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100466 *proc |= (~0UL/3UL) << 1; /* 0xAAA...AAA */
Christopher Faulet62519022017-10-16 15:49:32 +0200467 else {
Christopher Faulet18cca782019-02-07 16:29:41 +0100468 const char *p, *dash = NULL;
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100469 unsigned int low, high;
470
Christopher Faulet18cca782019-02-07 16:29:41 +0100471 for (p = arg; *p; p++) {
472 if (*p == '-' && !dash)
473 dash = p;
Willy Tarreau90807112020-02-25 08:16:33 +0100474 else if (!isdigit((unsigned char)*p)) {
Christopher Faulet18cca782019-02-07 16:29:41 +0100475 memprintf(err, "'%s' is not a valid number/range.", arg);
476 return -1;
477 }
Christopher Faulet5ab51772017-11-22 11:21:58 +0100478 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100479
480 low = high = str2uic(arg);
Christopher Faulet18cca782019-02-07 16:29:41 +0100481 if (dash)
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100482 high = ((!*(dash+1)) ? max : str2uic(dash + 1));
Christopher Fauletff4121f2017-11-22 16:38:49 +0100483
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100484 if (high < low) {
485 unsigned int swap = low;
486 low = high;
487 high = swap;
488 }
489
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100490 if (low < 1 || low > max || high > max) {
Christopher Fauletcb6a9452017-11-22 16:50:41 +0100491 memprintf(err, "'%s' is not a valid number/range."
492 " It supports numbers from 1 to %d.\n",
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100493 arg, max);
Christopher Faulet5ab51772017-11-22 11:21:58 +0100494 return 1;
495 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100496
497 for (;low <= high; low++)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100498 *proc |= 1UL << (low-1);
Christopher Faulet62519022017-10-16 15:49:32 +0200499 }
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100500 *proc &= ~0UL >> (LONGBITS - max);
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100501
Christopher Faulet5ab51772017-11-22 11:21:58 +0100502 return 0;
Christopher Faulet62519022017-10-16 15:49:32 +0200503}
504
David Carlier7e351ee2017-12-01 09:14:02 +0000505#ifdef USE_CPU_AFFINITY
Christopher Faulet62519022017-10-16 15:49:32 +0200506/* Parse cpu sets. Each CPU set is either a unique number between 0 and
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200507 * ha_cpuset_size() - 1 or a range with two such numbers delimited by a dash
Amaury Denoyellea8082352021-04-06 16:46:15 +0200508 * ('-'). If <comma_allowed> is set, each CPU set can be a list of unique
509 * numbers or ranges separated by a comma. It is also possible to specify
510 * multiple cpu numbers or ranges in distinct argument in <args>. On success,
511 * it returns 0, otherwise it returns 1 with an error message in <err>.
Christopher Faulet62519022017-10-16 15:49:32 +0200512 */
Amaury Denoyellea8082352021-04-06 16:46:15 +0200513unsigned long parse_cpu_set(const char **args, struct hap_cpuset *cpu_set,
514 int comma_allowed, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200515{
516 int cur_arg = 0;
Amaury Denoyellea8082352021-04-06 16:46:15 +0200517 const char *arg;
Christopher Faulet62519022017-10-16 15:49:32 +0200518
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200519 ha_cpuset_zero(cpu_set);
520
Amaury Denoyellea8082352021-04-06 16:46:15 +0200521 arg = args[cur_arg];
522 while (*arg) {
523 const char *dash, *comma;
Christopher Faulet62519022017-10-16 15:49:32 +0200524 unsigned int low, high;
525
Willy Tarreau90807112020-02-25 08:16:33 +0100526 if (!isdigit((unsigned char)*args[cur_arg])) {
Amaury Denoyellea8082352021-04-06 16:46:15 +0200527 memprintf(err, "'%s' is not a CPU range.", arg);
Christopher Faulet62519022017-10-16 15:49:32 +0200528 return -1;
529 }
530
Amaury Denoyellea8082352021-04-06 16:46:15 +0200531 low = high = str2uic(arg);
532
533 comma = comma_allowed ? strchr(arg, ',') : NULL;
534 dash = strchr(arg, '-');
535
536 if (dash && (!comma || dash < comma))
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200537 high = *(dash+1) ? str2uic(dash + 1) : ha_cpuset_size() - 1;
Christopher Faulet62519022017-10-16 15:49:32 +0200538
539 if (high < low) {
540 unsigned int swap = low;
541 low = high;
542 high = swap;
543 }
544
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200545 if (high >= ha_cpuset_size()) {
546 memprintf(err, "supports CPU numbers from 0 to %d.",
547 ha_cpuset_size() - 1);
Christopher Faulet62519022017-10-16 15:49:32 +0200548 return 1;
549 }
550
551 while (low <= high)
Amaury Denoyellec90932b2021-04-14 16:16:03 +0200552 ha_cpuset_set(cpu_set, low++);
Christopher Faulet62519022017-10-16 15:49:32 +0200553
Amaury Denoyellea8082352021-04-06 16:46:15 +0200554 /* if a comma is present, parse the rest of the arg, else
555 * skip to the next arg */
556 arg = comma ? comma + 1 : args[++cur_arg];
Christopher Faulet62519022017-10-16 15:49:32 +0200557 }
558 return 0;
559}
David Carlier7e351ee2017-12-01 09:14:02 +0000560#endif
561
Frédéric Lécaille18251032019-01-11 11:07:15 +0100562/* Allocate and initialize the frontend of a "peers" section found in
563 * file <file> at line <linenum> with <id> as ID.
564 * Return 0 if succeeded, -1 if not.
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200565 * Note that this function may be called from "default-server"
566 * or "peer" lines.
Frédéric Lécaille18251032019-01-11 11:07:15 +0100567 */
568static int init_peers_frontend(const char *file, int linenum,
569 const char *id, struct peers *peers)
570{
571 struct proxy *p;
572
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200573 if (peers->peers_fe) {
574 p = peers->peers_fe;
575 goto out;
576 }
Frédéric Lécaille9492c4e2019-01-11 11:47:12 +0100577
Frédéric Lécaille18251032019-01-11 11:07:15 +0100578 p = calloc(1, sizeof *p);
579 if (!p) {
580 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
581 return -1;
582 }
583
584 init_new_proxy(p);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200585 peers_setup_frontend(p);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100586 p->parent = peers;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200587 /* Finally store this frontend. */
588 peers->peers_fe = p;
589
590 out:
591 if (id && !p->id)
592 p->id = strdup(id);
Frédéric Lécaille1055e682018-04-26 14:35:21 +0200593 free(p->conf.file);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100594 p->conf.args.file = p->conf.file = strdup(file);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100595 if (linenum != -1)
596 p->conf.args.line = p->conf.line = linenum;
Frédéric Lécaille18251032019-01-11 11:07:15 +0100597
598 return 0;
599}
Willy Tarreauade5ec42010-01-28 19:33:49 +0100600
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100601/* Only change ->file, ->line and ->arg struct bind_conf member values
602 * if already present.
603 */
604static struct bind_conf *bind_conf_uniq_alloc(struct proxy *p,
605 const char *file, int line,
606 const char *arg, struct xprt_ops *xprt)
607{
608 struct bind_conf *bind_conf;
609
610 if (!LIST_ISEMPTY(&p->conf.bind)) {
611 bind_conf = LIST_ELEM((&p->conf.bind)->n, typeof(bind_conf), by_fe);
612 free(bind_conf->file);
613 bind_conf->file = strdup(file);
614 bind_conf->line = line;
615 if (arg) {
616 free(bind_conf->arg);
617 bind_conf->arg = strdup(arg);
618 }
619 }
620 else {
621 bind_conf = bind_conf_alloc(p, file, line, arg, xprt);
622 }
623
624 return bind_conf;
625}
626
627/*
628 * Allocate a new struct peer parsed at line <linenum> in file <file>
629 * to be added to <peers>.
630 * Returns the new allocated structure if succeeded, NULL if not.
631 */
632static struct peer *cfg_peers_add_peer(struct peers *peers,
633 const char *file, int linenum,
634 const char *id, int local)
635{
636 struct peer *p;
637
638 p = calloc(1, sizeof *p);
639 if (!p) {
640 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
641 return NULL;
642 }
643
644 /* the peers are linked backwards first */
645 peers->count++;
646 p->next = peers->remote;
647 peers->remote = p;
648 p->conf.file = strdup(file);
649 p->conf.line = linenum;
650 p->last_change = now.tv_sec;
651 p->xprt = xprt_get(XPRT_RAW);
652 p->sock_init_arg = NULL;
653 HA_SPIN_INIT(&p->lock);
654 if (id)
655 p->id = strdup(id);
656 if (local) {
657 p->local = 1;
658 peers->local = p;
659 }
660
661 return p;
662}
663
Willy Tarreaubaaee002006-06-26 02:48:02 +0200664/*
William Lallemand51097192015-04-14 16:35:22 +0200665 * Parse a line in a <listen>, <frontend> or <backend> section.
Willy Tarreau93893792009-07-23 13:19:11 +0200666 * Returns the error code, 0 if OK, or any combination of :
667 * - ERR_ABORT: must abort ASAP
668 * - ERR_FATAL: we can continue parsing but not start the service
669 * - ERR_WARN: a warning has been emitted
670 * - ERR_ALERT: an alert has been emitted
671 * Only the two first ones can stop processing, the two others are just
672 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200673 */
Emeric Brun32da3c42010-09-23 18:39:19 +0200674int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
675{
676 static struct peers *curpeers = NULL;
677 struct peer *newpeer = NULL;
678 const char *err;
Willy Tarreau4348fad2012-09-20 16:48:07 +0200679 struct bind_conf *bind_conf;
680 struct listener *l;
Emeric Brun32da3c42010-09-23 18:39:19 +0200681 int err_code = 0;
Willy Tarreau902636f2013-03-10 19:44:48 +0100682 char *errmsg = NULL;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100683 static int bind_line, peer_line;
684
685 if (strcmp(args[0], "bind") == 0 || strcmp(args[0], "default-bind") == 0) {
686 int cur_arg;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100687 struct bind_conf *bind_conf;
688 struct bind_kw *kw;
Emeric Brun32da3c42010-09-23 18:39:19 +0200689
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100690 cur_arg = 1;
691
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200692 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
693 err_code |= ERR_ALERT | ERR_ABORT;
694 goto out;
695 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100696
697 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum,
698 NULL, xprt_get(XPRT_RAW));
699 if (*args[0] == 'b') {
700 struct listener *l;
701
702 if (peer_line) {
703 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
704 err_code |= ERR_ALERT | ERR_FATAL;
705 goto out;
706 }
707
708 if (!str2listener(args[1], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
709 if (errmsg && *errmsg) {
710 indent_msg(&errmsg, 2);
711 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
712 }
713 else
714 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
715 file, linenum, args[0], args[1], args[2]);
716 err_code |= ERR_FATAL;
717 goto out;
718 }
719 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
720 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100721 l->accept = session_accept_fd;
722 l->analysers |= curpeers->peers_fe->fe_req_ana;
723 l->default_target = curpeers->peers_fe->default_target;
724 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100725 global.maxsock++; /* for the listening socket */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100726
727 bind_line = 1;
728 if (cfg_peers->local) {
729 newpeer = cfg_peers->local;
730 }
731 else {
732 /* This peer is local.
733 * Note that we do not set the peer ID. This latter is initialized
734 * when parsing "peer" or "server" line.
735 */
736 newpeer = cfg_peers_add_peer(curpeers, file, linenum, NULL, 1);
737 if (!newpeer) {
738 err_code |= ERR_ALERT | ERR_ABORT;
739 goto out;
740 }
741 }
Willy Tarreau37159062020-08-27 07:48:42 +0200742 newpeer->addr = l->rx.addr;
Willy Tarreau5fc93282020-09-16 18:25:03 +0200743 newpeer->proto = l->rx.proto;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100744 cur_arg++;
745 }
746
747 while (*args[cur_arg] && (kw = bind_find_kw(args[cur_arg]))) {
748 int ret;
749
750 ret = kw->parse(args, cur_arg, curpeers->peers_fe, bind_conf, &errmsg);
751 err_code |= ret;
752 if (ret) {
753 if (errmsg && *errmsg) {
754 indent_msg(&errmsg, 2);
755 ha_alert("parsing [%s:%d] : %s\n", file, linenum, errmsg);
756 }
757 else
758 ha_alert("parsing [%s:%d]: error encountered while processing '%s'\n",
759 file, linenum, args[cur_arg]);
760 if (ret & ERR_FATAL)
761 goto out;
762 }
763 cur_arg += 1 + kw->skip;
764 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100765 if (*args[cur_arg] != 0) {
Willy Tarreau433b05f2021-03-12 10:14:07 +0100766 const char *best = bind_find_best_kw(args[cur_arg]);
767 if (best)
768 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section; did you mean '%s' maybe ?\n",
769 file, linenum, args[cur_arg], cursection, best);
770 else
771 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section.\n",
772 file, linenum, args[cur_arg], cursection);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100773 err_code |= ERR_ALERT | ERR_FATAL;
774 goto out;
775 }
776 }
777 else if (strcmp(args[0], "default-server") == 0) {
778 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
779 err_code |= ERR_ALERT | ERR_ABORT;
780 goto out;
781 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +0100782 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL,
783 SRV_PARSE_DEFAULT_SERVER|SRV_PARSE_IN_PEER_SECTION|SRV_PARSE_INITIAL_RESOLVE);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200784 }
Frédéric Lécailleb6f759b2019-11-05 09:57:45 +0100785 else if (strcmp(args[0], "log") == 0) {
786 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
787 err_code |= ERR_ALERT | ERR_ABORT;
788 goto out;
789 }
Emeric Brun9533a702021-04-02 10:13:43 +0200790 if (!parse_logsrv(args, &curpeers->peers_fe->logsrvs, (kwm == KWM_NO), file, linenum, &errmsg)) {
Frédéric Lécailleb6f759b2019-11-05 09:57:45 +0100791 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
792 err_code |= ERR_ALERT | ERR_FATAL;
793 goto out;
794 }
795 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200796 else if (strcmp(args[0], "peers") == 0) { /* new peers section */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100797 /* Initialize these static variables when entering a new "peers" section*/
798 bind_line = peer_line = 0;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100799 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100800 ha_alert("parsing [%s:%d] : missing name for peers section.\n", file, linenum);
Willy Tarreau54984722014-02-16 08:20:13 +0100801 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100802 goto out;
803 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200804
William Lallemand6e62fb62015-04-28 16:55:23 +0200805 if (alertif_too_many_args(1, file, linenum, args, &err_code))
806 goto out;
807
Emeric Brun32da3c42010-09-23 18:39:19 +0200808 err = invalid_char(args[1]);
809 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100810 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
811 file, linenum, *err, args[0], args[1]);
Willy Tarreau54984722014-02-16 08:20:13 +0100812 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100813 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200814 }
815
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200816 for (curpeers = cfg_peers; curpeers != NULL; curpeers = curpeers->next) {
Emeric Brun32da3c42010-09-23 18:39:19 +0200817 /*
818 * If there are two proxies with the same name only following
819 * combinations are allowed:
820 */
821 if (strcmp(curpeers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100822 ha_alert("Parsing [%s:%d]: peers section '%s' has the same name as another peers section declared at %s:%d.\n",
823 file, linenum, args[1], curpeers->conf.file, curpeers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +0200824 err_code |= ERR_ALERT | ERR_FATAL;
Emeric Brun32da3c42010-09-23 18:39:19 +0200825 }
826 }
827
Vincent Bernat02779b62016-04-03 13:48:43 +0200828 if ((curpeers = calloc(1, sizeof(*curpeers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100829 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Emeric Brun32da3c42010-09-23 18:39:19 +0200830 err_code |= ERR_ALERT | ERR_ABORT;
831 goto out;
832 }
833
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200834 curpeers->next = cfg_peers;
835 cfg_peers = curpeers;
Willy Tarreau8113a5d2012-10-04 08:01:43 +0200836 curpeers->conf.file = strdup(file);
Emeric Brun32da3c42010-09-23 18:39:19 +0200837 curpeers->conf.line = linenum;
838 curpeers->last_change = now.tv_sec;
839 curpeers->id = strdup(args[1]);
Willy Tarreau1ad64ac2020-09-24 08:48:08 +0200840 curpeers->disabled = 0;
Emeric Brun32da3c42010-09-23 18:39:19 +0200841 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200842 else if (strcmp(args[0], "peer") == 0 ||
843 strcmp(args[0], "server") == 0) { /* peer or server definition */
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100844 int local_peer, peer;
Amaury Denoyelle30c05372021-03-08 16:36:46 +0100845 int parse_addr = 0;
Emeric Brun32da3c42010-09-23 18:39:19 +0200846
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100847 peer = *args[0] == 'p';
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100848 local_peer = strcmp(args[1], localpeer) == 0;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100849 /* The local peer may have already partially been parsed on a "bind" line. */
850 if (*args[0] == 'p') {
851 if (bind_line) {
852 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
853 err_code |= ERR_ALERT | ERR_FATAL;
854 goto out;
855 }
856 peer_line = 1;
857 }
858 if (cfg_peers->local && !cfg_peers->local->id && local_peer) {
859 /* The local peer has already been initialized on a "bind" line.
860 * Let's use it and store its ID.
861 */
862 newpeer = cfg_peers->local;
863 newpeer->id = strdup(localpeer);
864 }
865 else {
866 if (local_peer && cfg_peers->local) {
867 ha_alert("parsing [%s:%d] : '%s %s' : local peer name already referenced at %s:%d. %s\n",
868 file, linenum, args[0], args[1],
869 curpeers->peers_fe->conf.file, curpeers->peers_fe->conf.line, cfg_peers->local->id);
870 err_code |= ERR_FATAL;
871 goto out;
872 }
873 newpeer = cfg_peers_add_peer(curpeers, file, linenum, args[1], local_peer);
874 if (!newpeer) {
875 err_code |= ERR_ALERT | ERR_ABORT;
876 goto out;
877 }
878 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200879
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100880 /* Line number and peer ID are updated only if this peer is the local one. */
881 if (init_peers_frontend(file,
882 newpeer->local ? linenum: -1,
883 newpeer->local ? newpeer->id : NULL,
884 curpeers) != 0) {
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200885 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreaub36487e2013-03-10 18:37:42 +0100886 goto out;
887 }
Willy Tarreau2aa38802013-02-20 19:20:59 +0100888
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100889 /* This initializes curpeer->peers->peers_fe->srv.
890 * The server address is parsed only if we are parsing a "peer" line,
891 * or if we are parsing a "server" line and the current peer is not the local one.
892 */
Amaury Denoyelle30c05372021-03-08 16:36:46 +0100893 parse_addr = (peer || !local_peer) ? SRV_PARSE_PARSE_ADDR : 0;
894 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL,
895 SRV_PARSE_IN_PEER_SECTION|parse_addr|SRV_PARSE_INITIAL_RESOLVE);
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200896 if (!curpeers->peers_fe->srv) {
897 /* Remove the newly allocated peer. */
898 if (newpeer != curpeers->local) {
899 struct peer *p;
900
901 p = curpeers->remote;
902 curpeers->remote = curpeers->remote->next;
903 free(p->id);
904 free(p);
905 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200906 goto out;
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200907 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200908
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100909 /* If the peer address has just been parsed, let's copy it to <newpeer>
910 * and initializes ->proto.
911 */
912 if (peer || !local_peer) {
913 newpeer->addr = curpeers->peers_fe->srv->addr;
914 newpeer->proto = protocol_by_family(newpeer->addr.ss_family);
915 }
916
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100917 newpeer->xprt = xprt_get(XPRT_RAW);
Willy Tarreaud02394b2012-05-11 18:32:18 +0200918 newpeer->sock_init_arg = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100919 HA_SPIN_INIT(&newpeer->lock);
Willy Tarreau26d8c592012-05-07 18:12:14 +0200920
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100921 newpeer->srv = curpeers->peers_fe->srv;
922 if (!newpeer->local)
Frédéric Lécaille6617e762018-04-25 15:13:38 +0200923 goto out;
924
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100925 /* The lines above are reserved to "peer" lines. */
926 if (*args[0] == 's')
Frédéric Lécaille4ba51982018-04-25 15:32:18 +0200927 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200928
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100929 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum, args[2], xprt_get(XPRT_RAW));
Frédéric Lécaille16e49102019-01-11 11:27:16 +0100930
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100931 if (!str2listener(args[2], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
932 if (errmsg && *errmsg) {
933 indent_msg(&errmsg, 2);
934 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 +0100935 }
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100936 else
937 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
938 file, linenum, args[0], args[1], args[2]);
939 err_code |= ERR_FATAL;
940 goto out;
941 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100942
943 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
944 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100945 l->accept = session_accept_fd;
946 l->analysers |= curpeers->peers_fe->fe_req_ana;
947 l->default_target = curpeers->peers_fe->default_target;
948 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100949 global.maxsock++; /* for the listening socket */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100950 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100951 else if (strcmp(args[0], "table") == 0) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100952 struct stktable *t, *other;
953 char *id;
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100954 size_t prefix_len;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100955
956 /* Line number and peer ID are updated only if this peer is the local one. */
957 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
958 err_code |= ERR_ALERT | ERR_ABORT;
959 goto out;
960 }
961
962 other = stktable_find_by_name(args[1]);
963 if (other) {
964 ha_alert("parsing [%s:%d] : stick-table name '%s' conflicts with table declared in %s '%s' at %s:%d.\n",
965 file, linenum, args[1],
966 other->proxy ? proxy_cap_str(other->proxy->cap) : "peers",
967 other->proxy ? other->id : other->peers.p->id,
968 other->conf.file, other->conf.line);
969 err_code |= ERR_ALERT | ERR_FATAL;
970 goto out;
971 }
972
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100973 /* Build the stick-table name, concatenating the "peers" section name
974 * followed by a '/' character and the table name argument.
975 */
976 chunk_reset(&trash);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100977 if (!chunk_strcpy(&trash, curpeers->id)) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100978 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
979 file, linenum, args[0], args[1]);
980 err_code |= ERR_ALERT | ERR_FATAL;
981 goto out;
982 }
983
984 prefix_len = trash.data;
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100985 if (!chunk_memcat(&trash, "/", 1) || !chunk_strcat(&trash, args[1])) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100986 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
987 file, linenum, args[0], args[1]);
988 err_code |= ERR_ALERT | ERR_FATAL;
989 goto out;
990 }
991
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100992 t = calloc(1, sizeof *t);
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100993 id = strdup(trash.area);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100994 if (!t || !id) {
995 ha_alert("parsing [%s:%d]: '%s %s' : memory allocation failed\n",
996 file, linenum, args[0], args[1]);
Eric Salama1aab9112020-09-18 11:55:17 +0200997 free(t);
998 free(id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100999 err_code |= ERR_ALERT | ERR_FATAL;
1000 goto out;
1001 }
1002
Frédéric Lécaillec02766a2019-03-20 15:06:55 +01001003 err_code |= parse_stick_table(file, linenum, args, t, id, id + prefix_len, curpeers);
Eric Salama1aab9112020-09-18 11:55:17 +02001004 if (err_code & ERR_FATAL) {
1005 free(t);
1006 free(id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001007 goto out;
Eric Salama1aab9112020-09-18 11:55:17 +02001008 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001009
1010 stktable_store_name(t);
1011 t->next = stktables_list;
1012 stktables_list = t;
1013 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001014 else if (strcmp(args[0], "disabled") == 0) { /* disables this peers section */
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02001015 curpeers->disabled = 1;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02001016 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001017 else if (strcmp(args[0], "enabled") == 0) { /* enables this peers section (used to revert a disabled default) */
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02001018 curpeers->disabled = 0;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02001019 }
Emeric Brun32da3c42010-09-23 18:39:19 +02001020 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001021 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Emeric Brun32da3c42010-09-23 18:39:19 +02001022 err_code |= ERR_ALERT | ERR_FATAL;
1023 goto out;
1024 }
1025
1026out:
Willy Tarreau902636f2013-03-10 19:44:48 +01001027 free(errmsg);
Emeric Brun32da3c42010-09-23 18:39:19 +02001028 return err_code;
1029}
1030
Baptiste Assmann325137d2015-04-13 23:40:55 +02001031/*
William Lallemand51097192015-04-14 16:35:22 +02001032 * Parse a line in a <listen>, <frontend> or <backend> section.
Simon Horman0d16a402015-01-30 11:22:58 +09001033 * Returns the error code, 0 if OK, or any combination of :
1034 * - ERR_ABORT: must abort ASAP
1035 * - ERR_FATAL: we can continue parsing but not start the service
1036 * - ERR_WARN: a warning has been emitted
1037 * - ERR_ALERT: an alert has been emitted
1038 * Only the two first ones can stop processing, the two others are just
1039 * indicators.
1040 */
1041int cfg_parse_mailers(const char *file, int linenum, char **args, int kwm)
1042{
1043 static struct mailers *curmailers = NULL;
1044 struct mailer *newmailer = NULL;
1045 const char *err;
1046 int err_code = 0;
1047 char *errmsg = NULL;
1048
1049 if (strcmp(args[0], "mailers") == 0) { /* new mailers section */
1050 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001051 ha_alert("parsing [%s:%d] : missing name for mailers section.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001052 err_code |= ERR_ALERT | ERR_ABORT;
1053 goto out;
1054 }
1055
1056 err = invalid_char(args[1]);
1057 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001058 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
1059 file, linenum, *err, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001060 err_code |= ERR_ALERT | ERR_ABORT;
1061 goto out;
1062 }
1063
1064 for (curmailers = mailers; curmailers != NULL; curmailers = curmailers->next) {
1065 /*
1066 * If there are two proxies with the same name only following
1067 * combinations are allowed:
1068 */
1069 if (strcmp(curmailers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001070 ha_alert("Parsing [%s:%d]: mailers section '%s' has the same name as another mailers section declared at %s:%d.\n",
1071 file, linenum, args[1], curmailers->conf.file, curmailers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +02001072 err_code |= ERR_ALERT | ERR_FATAL;
Simon Horman0d16a402015-01-30 11:22:58 +09001073 }
1074 }
1075
Vincent Bernat02779b62016-04-03 13:48:43 +02001076 if ((curmailers = calloc(1, sizeof(*curmailers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001077 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001078 err_code |= ERR_ALERT | ERR_ABORT;
1079 goto out;
1080 }
1081
1082 curmailers->next = mailers;
1083 mailers = curmailers;
1084 curmailers->conf.file = strdup(file);
1085 curmailers->conf.line = linenum;
1086 curmailers->id = strdup(args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001087 curmailers->timeout.mail = DEF_MAILALERTTIME;/* XXX: Would like to Skip to the next alert, if any, ASAP.
1088 * But need enough time so that timeouts don't occur
1089 * during tcp procssing. For now just us an arbitrary default. */
Simon Horman0d16a402015-01-30 11:22:58 +09001090 }
1091 else if (strcmp(args[0], "mailer") == 0) { /* mailer definition */
1092 struct sockaddr_storage *sk;
1093 int port1, port2;
1094 struct protocol *proto;
1095
1096 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001097 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1098 file, linenum, args[0]);
Simon Horman0d16a402015-01-30 11:22:58 +09001099 err_code |= ERR_ALERT | ERR_FATAL;
1100 goto out;
1101 }
1102
1103 err = invalid_char(args[1]);
1104 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001105 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1106 file, linenum, *err, args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001107 err_code |= ERR_ALERT | ERR_FATAL;
1108 goto out;
1109 }
1110
Vincent Bernat02779b62016-04-03 13:48:43 +02001111 if ((newmailer = calloc(1, sizeof(*newmailer))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001112 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001113 err_code |= ERR_ALERT | ERR_ABORT;
1114 goto out;
1115 }
1116
1117 /* the mailers are linked backwards first */
1118 curmailers->count++;
1119 newmailer->next = curmailers->mailer_list;
1120 curmailers->mailer_list = newmailer;
1121 newmailer->mailers = curmailers;
1122 newmailer->conf.file = strdup(file);
1123 newmailer->conf.line = linenum;
1124
1125 newmailer->id = strdup(args[1]);
1126
Willy Tarreau5fc93282020-09-16 18:25:03 +02001127 sk = str2sa_range(args[2], NULL, &port1, &port2, NULL, &proto,
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001128 &errmsg, NULL, NULL,
1129 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 +09001130 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001131 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Simon Horman0d16a402015-01-30 11:22:58 +09001132 err_code |= ERR_ALERT | ERR_FATAL;
1133 goto out;
1134 }
1135
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001136 if (proto->sock_prot != IPPROTO_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001137 ha_alert("parsing [%s:%d] : '%s %s' : TCP not supported for this address family.\n",
1138 file, linenum, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001139 err_code |= ERR_ALERT | ERR_FATAL;
1140 goto out;
1141 }
1142
Simon Horman0d16a402015-01-30 11:22:58 +09001143 newmailer->addr = *sk;
1144 newmailer->proto = proto;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01001145 newmailer->xprt = xprt_get(XPRT_RAW);
Simon Horman0d16a402015-01-30 11:22:58 +09001146 newmailer->sock_init_arg = NULL;
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001147 }
1148 else if (strcmp(args[0], "timeout") == 0) {
1149 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001150 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments.\n",
1151 file, linenum, args[0]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001152 err_code |= ERR_ALERT | ERR_FATAL;
1153 goto out;
1154 }
1155 else if (strcmp(args[1], "mail") == 0) {
1156 const char *res;
1157 unsigned int timeout_mail;
1158 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001159 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1160 file, linenum, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001161 err_code |= ERR_ALERT | ERR_FATAL;
1162 goto out;
1163 }
1164 res = parse_time_err(args[2], &timeout_mail, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001165 if (res == PARSE_TIME_OVER) {
1166 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1167 file, linenum, args[2], args[0], args[1]);
1168 err_code |= ERR_ALERT | ERR_FATAL;
1169 goto out;
1170 }
1171 else if (res == PARSE_TIME_UNDER) {
1172 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1173 file, linenum, args[2], args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001174 err_code |= ERR_ALERT | ERR_FATAL;
1175 goto out;
1176 }
Willy Tarreau9faebe32019-06-07 19:00:37 +02001177 else if (res) {
1178 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1179 file, linenum, *res, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001180 err_code |= ERR_ALERT | ERR_FATAL;
1181 goto out;
1182 }
1183 curmailers->timeout.mail = timeout_mail;
1184 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001185 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments got '%s'.\n",
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001186 file, linenum, args[0], args[1]);
1187 err_code |= ERR_ALERT | ERR_FATAL;
1188 goto out;
1189 }
1190 }
Simon Horman0d16a402015-01-30 11:22:58 +09001191 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001192 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Simon Horman0d16a402015-01-30 11:22:58 +09001193 err_code |= ERR_ALERT | ERR_FATAL;
1194 goto out;
1195 }
1196
1197out:
1198 free(errmsg);
1199 return err_code;
1200}
1201
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +01001202void free_email_alert(struct proxy *p)
Simon Horman9dc49962015-01-30 11:22:59 +09001203{
Willy Tarreau61cfdf42021-02-20 10:46:51 +01001204 ha_free(&p->email_alert.mailers.name);
1205 ha_free(&p->email_alert.from);
1206 ha_free(&p->email_alert.to);
1207 ha_free(&p->email_alert.myhostname);
Simon Horman9dc49962015-01-30 11:22:59 +09001208}
1209
Willy Tarreaubaaee002006-06-26 02:48:02 +02001210
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001211int
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001212cfg_parse_netns(const char *file, int linenum, char **args, int kwm)
1213{
Willy Tarreaue5733232019-05-22 19:24:06 +02001214#ifdef USE_NS
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001215 const char *err;
1216 const char *item = args[0];
1217
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001218 if (strcmp(item, "namespace_list") == 0) {
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001219 return 0;
1220 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001221 else if (strcmp(item, "namespace") == 0) {
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001222 size_t idx = 1;
1223 const char *current;
1224 while (*(current = args[idx++])) {
1225 err = invalid_char(current);
1226 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001227 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1228 file, linenum, *err, item, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001229 return ERR_ALERT | ERR_FATAL;
1230 }
1231
1232 if (netns_store_lookup(current, strlen(current))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001233 ha_alert("parsing [%s:%d]: Namespace '%s' is already added.\n",
1234 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001235 return ERR_ALERT | ERR_FATAL;
1236 }
1237 if (!netns_store_insert(current)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001238 ha_alert("parsing [%s:%d]: Cannot open namespace '%s'.\n",
1239 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001240 return ERR_ALERT | ERR_FATAL;
1241 }
1242 }
1243 }
1244
1245 return 0;
1246#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001247 ha_alert("parsing [%s:%d]: namespace support is not compiled in.",
1248 file, linenum);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001249 return ERR_ALERT | ERR_FATAL;
1250#endif
1251}
1252
1253int
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001254cfg_parse_users(const char *file, int linenum, char **args, int kwm)
1255{
1256
1257 int err_code = 0;
1258 const char *err;
1259
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001260 if (strcmp(args[0], "userlist") == 0) { /* new userlist */
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001261 struct userlist *newul;
1262
1263 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001264 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1265 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001266 err_code |= ERR_ALERT | ERR_FATAL;
1267 goto out;
1268 }
William Lallemand6e62fb62015-04-28 16:55:23 +02001269 if (alertif_too_many_args(1, file, linenum, args, &err_code))
1270 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001271
1272 err = invalid_char(args[1]);
1273 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001274 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1275 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001276 err_code |= ERR_ALERT | ERR_FATAL;
1277 goto out;
1278 }
1279
1280 for (newul = userlist; newul; newul = newul->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001281 if (strcmp(newul->name, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001282 ha_warning("parsing [%s:%d]: ignoring duplicated userlist '%s'.\n",
1283 file, linenum, args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001284 err_code |= ERR_WARN;
1285 goto out;
1286 }
1287
Vincent Bernat02779b62016-04-03 13:48:43 +02001288 newul = calloc(1, sizeof(*newul));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001289 if (!newul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001290 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001291 err_code |= ERR_ALERT | ERR_ABORT;
1292 goto out;
1293 }
1294
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001295 newul->name = strdup(args[1]);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001296 if (!newul->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001297 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001298 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier97880bb2016-04-08 10:35:26 +01001299 free(newul);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001300 goto out;
1301 }
1302
1303 newul->next = userlist;
1304 userlist = newul;
1305
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001306 } else if (strcmp(args[0], "group") == 0) { /* new group */
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001307 int cur_arg;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001308 const char *err;
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001309 struct auth_groups *ag;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001310
1311 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001312 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1313 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001314 err_code |= ERR_ALERT | ERR_FATAL;
1315 goto out;
1316 }
1317
1318 err = invalid_char(args[1]);
1319 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001320 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1321 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001322 err_code |= ERR_ALERT | ERR_FATAL;
1323 goto out;
1324 }
1325
William Lallemand4ac9f542015-05-28 18:03:51 +02001326 if (!userlist)
1327 goto out;
1328
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001329 for (ag = userlist->groups; ag; ag = ag->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001330 if (strcmp(ag->name, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001331 ha_warning("parsing [%s:%d]: ignoring duplicated group '%s' in userlist '%s'.\n",
1332 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001333 err_code |= ERR_ALERT;
1334 goto out;
1335 }
1336
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001337 ag = calloc(1, sizeof(*ag));
1338 if (!ag) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001339 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001340 err_code |= ERR_ALERT | ERR_ABORT;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001341 goto out;
1342 }
1343
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001344 ag->name = strdup(args[1]);
David Carlier70d60452016-08-22 23:27:42 +01001345 if (!ag->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001346 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001347 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier70d60452016-08-22 23:27:42 +01001348 free(ag);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001349 goto out;
1350 }
1351
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001352 cur_arg = 2;
1353
1354 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001355 if (strcmp(args[cur_arg], "users") == 0) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001356 ag->groupusers = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001357 cur_arg += 2;
1358 continue;
1359 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001360 ha_alert("parsing [%s:%d]: '%s' only supports 'users' option.\n",
1361 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001362 err_code |= ERR_ALERT | ERR_FATAL;
David Carlier70d60452016-08-22 23:27:42 +01001363 free(ag->groupusers);
1364 free(ag->name);
1365 free(ag);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001366 goto out;
1367 }
1368 }
1369
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001370 ag->next = userlist->groups;
1371 userlist->groups = ag;
1372
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001373 } else if (strcmp(args[0], "user") == 0) { /* new user */
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001374 struct auth_users *newuser;
1375 int cur_arg;
1376
1377 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001378 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1379 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001380 err_code |= ERR_ALERT | ERR_FATAL;
1381 goto out;
1382 }
William Lallemand4ac9f542015-05-28 18:03:51 +02001383 if (!userlist)
1384 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001385
1386 for (newuser = userlist->users; newuser; newuser = newuser->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001387 if (strcmp(newuser->user, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001388 ha_warning("parsing [%s:%d]: ignoring duplicated user '%s' in userlist '%s'.\n",
1389 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001390 err_code |= ERR_ALERT;
1391 goto out;
1392 }
1393
Vincent Bernat02779b62016-04-03 13:48:43 +02001394 newuser = calloc(1, sizeof(*newuser));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001395 if (!newuser) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001396 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001397 err_code |= ERR_ALERT | ERR_ABORT;
1398 goto out;
1399 }
1400
1401 newuser->user = strdup(args[1]);
1402
1403 newuser->next = userlist->users;
1404 userlist->users = newuser;
1405
1406 cur_arg = 2;
1407
1408 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001409 if (strcmp(args[cur_arg], "password") == 0) {
Willy Tarreaue5733232019-05-22 19:24:06 +02001410#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001411 if (!crypt("", args[cur_arg + 1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001412 ha_alert("parsing [%s:%d]: the encrypted password used for user '%s' is not supported by crypt(3).\n",
1413 file, linenum, newuser->user);
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001414 err_code |= ERR_ALERT | ERR_FATAL;
1415 goto out;
1416 }
1417#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001418 ha_warning("parsing [%s:%d]: no crypt(3) support compiled, encrypted passwords will not work.\n",
1419 file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001420 err_code |= ERR_ALERT;
1421#endif
1422 newuser->pass = strdup(args[cur_arg + 1]);
1423 cur_arg += 2;
1424 continue;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001425 } else if (strcmp(args[cur_arg], "insecure-password") == 0) {
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001426 newuser->pass = strdup(args[cur_arg + 1]);
1427 newuser->flags |= AU_O_INSECURE;
1428 cur_arg += 2;
1429 continue;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001430 } else if (strcmp(args[cur_arg], "groups") == 0) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001431 newuser->u.groups_names = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001432 cur_arg += 2;
1433 continue;
1434 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001435 ha_alert("parsing [%s:%d]: '%s' only supports 'password', 'insecure-password' and 'groups' options.\n",
1436 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001437 err_code |= ERR_ALERT | ERR_FATAL;
1438 goto out;
1439 }
1440 }
1441 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001442 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 +01001443 err_code |= ERR_ALERT | ERR_FATAL;
1444 }
1445
1446out:
1447 return err_code;
1448}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001449
Christopher Faulet79bdef32016-11-04 22:36:15 +01001450int
1451cfg_parse_scope(const char *file, int linenum, char *line)
1452{
1453 char *beg, *end, *scope = NULL;
1454 int err_code = 0;
1455 const char *err;
1456
1457 beg = line + 1;
1458 end = strchr(beg, ']');
1459
1460 /* Detect end of scope declaration */
1461 if (!end || end == beg) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001462 ha_alert("parsing [%s:%d] : empty scope name is forbidden.\n",
1463 file, linenum);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001464 err_code |= ERR_ALERT | ERR_FATAL;
1465 goto out;
1466 }
1467
1468 /* Get scope name and check its validity */
1469 scope = my_strndup(beg, end-beg);
1470 err = invalid_char(scope);
1471 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001472 ha_alert("parsing [%s:%d] : character '%c' is not permitted in a scope name.\n",
1473 file, linenum, *err);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001474 err_code |= ERR_ALERT | ERR_ABORT;
1475 goto out;
1476 }
1477
1478 /* Be sure to have a scope declaration alone on its line */
1479 line = end+1;
1480 while (isspace((unsigned char)*line))
1481 line++;
1482 if (*line && *line != '#' && *line != '\n' && *line != '\r') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001483 ha_alert("parsing [%s:%d] : character '%c' is not permitted after scope declaration.\n",
1484 file, linenum, *line);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001485 err_code |= ERR_ALERT | ERR_ABORT;
1486 goto out;
1487 }
1488
1489 /* We have a valid scope declaration, save it */
1490 free(cfg_scope);
1491 cfg_scope = scope;
1492 scope = NULL;
1493
1494 out:
1495 free(scope);
1496 return err_code;
1497}
1498
Frédéric Lécaillea41d5312018-01-29 12:05:07 +01001499int
1500cfg_parse_track_sc_num(unsigned int *track_sc_num,
1501 const char *arg, const char *end, char **errmsg)
1502{
1503 const char *p;
1504 unsigned int num;
1505
1506 p = arg;
1507 num = read_uint64(&arg, end);
1508
1509 if (arg != end) {
1510 memprintf(errmsg, "Wrong track-sc number '%s'", p);
1511 return -1;
1512 }
1513
1514 if (num >= MAX_SESS_STKCTR) {
1515 memprintf(errmsg, "%u track-sc number exceeding "
1516 "%d (MAX_SESS_STKCTR-1) value", num, MAX_SESS_STKCTR - 1);
1517 return -1;
1518 }
1519
1520 *track_sc_num = num;
1521 return 0;
1522}
1523
Willy Tarreaubaaee002006-06-26 02:48:02 +02001524/*
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001525 * Detect a global section after a non-global one and output a diagnostic
1526 * warning.
1527 */
1528static void check_section_position(char *section_name,
1529 const char *file, int linenum,
1530 int *non_global_parsed)
1531{
1532 if (!strcmp(section_name, "global")) {
1533 if (*non_global_parsed == 1)
1534 _ha_diag_warning("parsing [%s:%d] : global section detected after a non-global one, the prevalence of their statements is unspecified\n", file, linenum);
1535 }
1536 else if (*non_global_parsed == 0) {
1537 *non_global_parsed = 1;
1538 }
1539}
1540
Willy Tarreau8a022d52021-04-27 20:29:11 +02001541/* apply the current default_path setting for config file <file>, and
1542 * optionally replace the current path to <origin> if not NULL while the
1543 * default-path mode is set to "origin". Errors are returned into an
1544 * allocated string passed to <err> if it's not NULL. Returns 0 on failure
1545 * or non-zero on success.
1546 */
1547static int cfg_apply_default_path(const char *file, const char *origin, char **err)
1548{
1549 const char *beg, *end;
1550
1551 /* make path start at <beg> and end before <end>, and switch it to ""
1552 * if no slash was passed.
1553 */
1554 beg = file;
1555 end = strrchr(beg, '/');
1556 if (!end)
1557 end = beg;
1558
1559 if (!*initial_cwd) {
1560 if (getcwd(initial_cwd, sizeof(initial_cwd)) == NULL) {
1561 if (err)
1562 memprintf(err, "Impossible to retrieve startup directory name: %s", strerror(errno));
1563 return 0;
1564 }
1565 }
1566 else if (chdir(initial_cwd) == -1) {
1567 if (err)
1568 memprintf(err, "Impossible to get back to initial directory '%s': %s", initial_cwd, strerror(errno));
1569 return 0;
1570 }
1571
1572 /* OK now we're (back) to initial_cwd */
1573
1574 switch (default_path_mode) {
1575 case DEFAULT_PATH_CURRENT:
1576 /* current_cwd never set, nothing to do */
1577 return 1;
1578
1579 case DEFAULT_PATH_ORIGIN:
1580 /* current_cwd set in the config */
1581 if (origin &&
1582 snprintf(current_cwd, sizeof(current_cwd), "%s", origin) > sizeof(current_cwd)) {
1583 if (err)
1584 memprintf(err, "Absolute path too long: '%s'", origin);
1585 return 0;
1586 }
1587 break;
1588
1589 case DEFAULT_PATH_CONFIG:
1590 if (end - beg >= sizeof(current_cwd)) {
1591 if (err)
1592 memprintf(err, "Config file path too long, cannot use for relative paths: '%s'", file);
1593 return 0;
1594 }
1595 memcpy(current_cwd, beg, end - beg);
1596 current_cwd[end - beg] = 0;
1597 break;
1598
1599 case DEFAULT_PATH_PARENT:
1600 if (end - beg + 3 >= sizeof(current_cwd)) {
1601 if (err)
1602 memprintf(err, "Config file path too long, cannot use for relative paths: '%s'", file);
1603 return 0;
1604 }
1605 memcpy(current_cwd, beg, end - beg);
1606 if (end > beg)
1607 memcpy(current_cwd + (end - beg), "/..\0", 4);
1608 else
1609 memcpy(current_cwd + (end - beg), "..\0", 3);
1610 break;
1611 }
1612
1613 if (*current_cwd && chdir(current_cwd) == -1) {
1614 if (err)
1615 memprintf(err, "Impossible to get back to directory '%s': %s", initial_cwd, strerror(errno));
1616 return 0;
1617 }
1618
1619 return 1;
1620}
1621
1622/* parses a global "default-path" directive. */
1623static int cfg_parse_global_def_path(char **args, int section_type, struct proxy *curpx,
1624 const struct proxy *defpx, const char *file, int line,
1625 char **err)
1626{
1627 int ret = -1;
1628
1629 /* "current", "config", "parent", "origin <path>" */
1630
1631 if (strcmp(args[1], "current") == 0)
1632 default_path_mode = DEFAULT_PATH_CURRENT;
1633 else if (strcmp(args[1], "config") == 0)
1634 default_path_mode = DEFAULT_PATH_CONFIG;
1635 else if (strcmp(args[1], "parent") == 0)
1636 default_path_mode = DEFAULT_PATH_PARENT;
1637 else if (strcmp(args[1], "origin") == 0)
1638 default_path_mode = DEFAULT_PATH_ORIGIN;
1639 else {
1640 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]);
1641 goto end;
1642 }
1643
1644 if (default_path_mode == DEFAULT_PATH_ORIGIN) {
1645 if (!*args[2]) {
1646 memprintf(err, "'%s %s' expects a directory as an argument.", args[0], args[1]);
1647 goto end;
1648 }
1649 if (!cfg_apply_default_path(file, args[2], err)) {
1650 memprintf(err, "couldn't set '%s' to origin '%s': %s.", args[0], args[2], *err);
1651 goto end;
1652 }
1653 }
1654 else if (!cfg_apply_default_path(file, NULL, err)) {
1655 memprintf(err, "couldn't set '%s' to '%s': %s.", args[0], args[1], *err);
1656 goto end;
1657 }
1658
1659 /* note that once applied, the path is immediately updated */
1660
1661 ret = 0;
1662 end:
1663 return ret;
1664}
1665
Willy Tarreau732525f2021-05-06 15:49:04 +02001666/* looks up a cond predicate matching the keyword in <str>, possibly followed
1667 * by a parenthesis. Returns a pointer to it or NULL if not found.
1668 */
1669static const struct cond_pred_kw *cfg_lookup_cond_pred(const char *str)
1670{
1671 const struct cond_pred_kw *ret;
1672 int len = strcspn(str, " (");
1673
1674 for (ret = &cond_predicates[0]; ret->word; ret++) {
1675 if (len != strlen(ret->word))
1676 continue;
1677 if (strncmp(str, ret->word, len) != 0)
1678 continue;
1679 return ret;
1680 }
1681 return NULL;
1682}
1683
Willy Tarreau6a2110c2021-05-06 08:19:48 +02001684/* evaluate a condition on a .if/.elif line. The condition is already tokenized
1685 * in <err>. Returns -1 on error (in which case err is filled with a message,
Willy Tarreau299bd1c2021-05-06 15:07:10 +02001686 * and only in this case), 0 if the condition is false, 1 if it's true. If
1687 * <errptr> is not NULL, it's set to the first invalid character on error.
Willy Tarreau6a2110c2021-05-06 08:19:48 +02001688 */
Willy Tarreau299bd1c2021-05-06 15:07:10 +02001689static int cfg_eval_condition(char **args, char **err, const char **errptr)
Willy Tarreau6a2110c2021-05-06 08:19:48 +02001690{
Willy Tarreau732525f2021-05-06 15:49:04 +02001691 const struct cond_pred_kw *cond_pred = NULL;
1692 const char *end_ptr;
1693 struct arg *argp = NULL;
1694 int err_arg;
1695 int nbargs;
1696 int ret = -1;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02001697 char *end;
1698 long val;
1699
1700 if (!*args[0]) /* note: empty = false */
1701 return 0;
1702
1703 val = strtol(args[0], &end, 0);
1704 if (end && *end == '\0')
1705 return val != 0;
1706
Willy Tarreau732525f2021-05-06 15:49:04 +02001707 /* below we'll likely all make_arg_list() so we must return only via
1708 * the <done> label which frees the arg list.
1709 */
1710 cond_pred = cfg_lookup_cond_pred(args[0]);
1711 if (cond_pred) {
1712 nbargs = make_arg_list(args[0] + strlen(cond_pred->word), -1,
1713 cond_pred->arg_mask, &argp, err,
1714 &end_ptr, &err_arg, NULL);
1715
1716 if (nbargs < 0) {
1717 memprintf(err, "%s in argument %d of predicate '%s' used in conditional expression", *err, err_arg, cond_pred->word);
1718 if (errptr)
1719 *errptr = end_ptr;
1720 goto done;
1721 }
1722
1723 /* here we know we have a valid predicate with <nbargs> valid
1724 * arguments, placed in <argp> (which we'll need to free).
1725 */
1726 switch (cond_pred->prd) {
Willy Tarreau42ed14b2021-05-06 15:55:14 +02001727 case CFG_PRED_DEFINED: // checks if arg exists as an environment variable
1728 ret = getenv(argp[0].data.str.area) != NULL;
1729 goto done;
1730
Willy Tarreau58ca7062021-05-06 16:34:23 +02001731 case CFG_PRED_FEATURE: { // checks if the arg matches an enabled feature
1732 const char *p;
1733
1734 for (p = build_features; (p = strstr(p, argp[0].data.str.area)); p++) {
1735 if ((p[argp[0].data.str.data] == ' ' || p[argp[0].data.str.data] == 0) &&
1736 p > build_features) {
1737 if (*(p-1) == '+') { // "+OPENSSL"
1738 ret = 1;
1739 goto done;
1740 }
1741 else if (*(p-1) == '-') { // "-OPENSSL"
1742 ret = 0;
1743 goto done;
1744 }
1745 /* it was a sub-word, let's restart from next place */
1746 }
1747 }
1748 /* not found */
1749 ret = 0;
1750 goto done;
1751 }
Willy Tarreau6492e872021-05-06 16:10:09 +02001752 case CFG_PRED_STREQ: // checks if the two arg are equal
1753 ret = strcmp(argp[0].data.str.area, argp[1].data.str.area) == 0;
1754 goto done;
1755
1756 case CFG_PRED_STRNEQ: // checks if the two arg are different
1757 ret = strcmp(argp[0].data.str.area, argp[1].data.str.area) != 0;
1758 goto done;
1759
Willy Tarreau0b7c78a2021-05-06 16:53:26 +02001760 case CFG_PRED_VERSION_ATLEAST: // checks if the current version is at least this one
1761 ret = compare_current_version(argp[0].data.str.area) <= 0;
1762 goto done;
1763
1764 case CFG_PRED_VERSION_BEFORE: // checks if the current version is older than this one
1765 ret = compare_current_version(argp[0].data.str.area) > 0;
1766 goto done;
1767
Willy Tarreau732525f2021-05-06 15:49:04 +02001768 default:
1769 memprintf(err, "internal error: unhandled conditional expression predicate '%s'", cond_pred->word);
1770 if (errptr)
1771 *errptr = args[0];
1772 goto done;
1773 }
1774 }
1775
Willy Tarreau299bd1c2021-05-06 15:07:10 +02001776 memprintf(err, "unparsable conditional expression '%s'", args[0]);
1777 if (errptr)
1778 *errptr = args[0];
Willy Tarreau732525f2021-05-06 15:49:04 +02001779 done:
1780 for (nbargs = 0; argp && argp[nbargs].type != ARGT_STOP; nbargs++) {
1781 if (argp[nbargs].type == ARGT_STR)
1782 free(argp[nbargs].data.str.area);
1783 }
1784 free(argp);
1785 return ret;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02001786}
Willy Tarreau8a022d52021-04-27 20:29:11 +02001787
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001788/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02001789 * This function reads and parses the configuration file given in the argument.
Willy Tarreauda543e12021-04-27 18:30:28 +02001790 * Returns the error code, 0 if OK, -1 if the config file couldn't be opened,
1791 * or any combination of :
Willy Tarreau058e9072009-07-20 09:30:05 +02001792 * - ERR_ABORT: must abort ASAP
1793 * - ERR_FATAL: we can continue parsing but not start the service
1794 * - ERR_WARN: a warning has been emitted
1795 * - ERR_ALERT: an alert has been emitted
1796 * Only the two first ones can stop processing, the two others are just
1797 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001798 */
Willy Tarreaub17916e2006-10-15 15:17:57 +02001799int readcfgfile(const char *file)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001800{
Willy Tarreauda543e12021-04-27 18:30:28 +02001801 char *thisline = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02001802 int linesize = LINESIZE;
Willy Tarreauda543e12021-04-27 18:30:28 +02001803 FILE *f = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001804 int linenum = 0;
Willy Tarreau058e9072009-07-20 09:30:05 +02001805 int err_code = 0;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001806 struct cfg_section *cs = NULL, *pcs = NULL;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001807 struct cfg_section *ics;
William Lallemand64e84512015-05-12 14:25:37 +02001808 int readbytes = 0;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001809 char *outline = NULL;
1810 size_t outlen = 0;
1811 size_t outlinesize = 0;
Willy Tarreau32234e72020-06-16 17:14:33 +02001812 int fatal = 0;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001813 int missing_lf = -1;
Willy Tarreau4b103022021-02-12 17:59:10 +01001814 int nested_cond_lvl = 0;
1815 enum nested_cond_state nested_conds[MAXNESTEDCONDS];
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001816 int non_global_section_parsed = 0;
Willy Tarreau8a022d52021-04-27 20:29:11 +02001817 char *errmsg = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02001818
Willy Tarreau51508052021-05-06 10:04:45 +02001819 global.cfg_curr_line = 0;
1820 global.cfg_curr_file = file;
1821
William Lallemand64e84512015-05-12 14:25:37 +02001822 if ((thisline = malloc(sizeof(*thisline) * linesize)) == NULL) {
Willy Tarreauda543e12021-04-27 18:30:28 +02001823 ha_alert("Out of memory trying to allocate a buffer for a configuration line.\n");
1824 err_code = -1;
1825 goto err;
William Lallemand64e84512015-05-12 14:25:37 +02001826 }
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001827
Willy Tarreauda543e12021-04-27 18:30:28 +02001828 if ((f = fopen(file,"r")) == NULL) {
1829 err_code = -1;
1830 goto err;
David Carlier97880bb2016-04-08 10:35:26 +01001831 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001832
Willy Tarreau8a022d52021-04-27 20:29:11 +02001833 /* change to the new dir if required */
1834 if (!cfg_apply_default_path(file, NULL, &errmsg)) {
1835 ha_alert("parsing [%s:%d]: failed to apply default-path: %s.\n", file, linenum, errmsg);
1836 free(errmsg);
1837 err_code = -1;
1838 goto err;
1839 }
1840
William Lallemandb2f07452015-05-12 14:27:13 +02001841next_line:
William Lallemand64e84512015-05-12 14:25:37 +02001842 while (fgets(thisline + readbytes, linesize - readbytes, f) != NULL) {
Willy Tarreau3842f002009-06-14 11:39:52 +02001843 int arg, kwm = KWM_STD;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001844 char *end;
1845 char *args[MAX_LINE_ARGS + 1];
1846 char *line = thisline;
1847
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001848 if (missing_lf != -1) {
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001849 ha_alert("parsing [%s:%d]: Stray NUL character at position %d.\n",
1850 file, linenum, (missing_lf + 1));
1851 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001852 missing_lf = -1;
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001853 break;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001854 }
1855
Willy Tarreaubaaee002006-06-26 02:48:02 +02001856 linenum++;
Willy Tarreau51508052021-05-06 10:04:45 +02001857 global.cfg_curr_line = linenum;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001858
Willy Tarreau32234e72020-06-16 17:14:33 +02001859 if (fatal >= 50) {
1860 ha_alert("parsing [%s:%d]: too many fatal errors (%d), stopping now.\n", file, linenum, fatal);
1861 break;
1862 }
1863
Willy Tarreaubaaee002006-06-26 02:48:02 +02001864 end = line + strlen(line);
1865
William Lallemand64e84512015-05-12 14:25:37 +02001866 if (end-line == linesize-1 && *(end-1) != '\n') {
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001867 /* Check if we reached the limit and the last char is not \n.
1868 * Watch out for the last line without the terminating '\n'!
1869 */
William Lallemand64e84512015-05-12 14:25:37 +02001870 char *newline;
1871 int newlinesize = linesize * 2;
1872
1873 newline = realloc(thisline, sizeof(*thisline) * newlinesize);
1874 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001875 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1876 file, linenum);
William Lallemand64e84512015-05-12 14:25:37 +02001877 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001878 fatal++;
Willy Tarreau40cb26f2020-06-25 09:37:54 +02001879 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001880 continue;
1881 }
1882
1883 readbytes = linesize - 1;
1884 linesize = newlinesize;
1885 thisline = newline;
Willy Tarreau40cb26f2020-06-25 09:37:54 +02001886 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001887 continue;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001888 }
1889
William Lallemand64e84512015-05-12 14:25:37 +02001890 readbytes = 0;
1891
Willy Tarreau08488f62020-06-26 17:24:54 +02001892 if (end > line && *(end-1) == '\n') {
Tim Duesterhus70f58992020-06-22 22:57:44 +02001893 /* kill trailing LF */
1894 *(end - 1) = 0;
1895 }
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001896 else {
1897 /* mark this line as truncated */
1898 missing_lf = end - line;
1899 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001900
Willy Tarreaubaaee002006-06-26 02:48:02 +02001901 /* skip leading spaces */
Willy Tarreau8f8e6452007-06-17 21:51:38 +02001902 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001903 line++;
William Lallemandf9873ba2015-05-05 17:37:14 +02001904
Joseph Herlanta14c03e2018-11-15 14:04:19 -08001905 if (*line == '[') {/* This is the beginning if a scope */
Christopher Faulet79bdef32016-11-04 22:36:15 +01001906 err_code |= cfg_parse_scope(file, linenum, line);
1907 goto next_line;
1908 }
1909
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001910 while (1) {
1911 uint32_t err;
1912 char *errptr;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001913
Willy Tarreau61dd44b2020-06-25 07:35:42 +02001914 arg = MAX_LINE_ARGS + 1;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001915 outlen = outlinesize;
1916 err = parse_line(line, outline, &outlen, args, &arg,
1917 PARSE_OPT_ENV | PARSE_OPT_DQUOTE | PARSE_OPT_SQUOTE |
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02001918 PARSE_OPT_BKSLASH | PARSE_OPT_SHARP | PARSE_OPT_WORD_EXPAND,
1919 &errptr);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001920
1921 if (err & PARSE_ERR_QUOTE) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001922 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1923
1924 ha_alert("parsing [%s:%d]: unmatched quote at position %d:\n"
1925 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001926 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001927 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001928 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001929 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001930
1931 if (err & PARSE_ERR_BRACE) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001932 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1933
1934 ha_alert("parsing [%s:%d]: unmatched brace in environment variable name at position %d:\n"
1935 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001936 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001937 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001938 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001939 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001940
1941 if (err & PARSE_ERR_VARNAME) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001942 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1943
1944 ha_alert("parsing [%s:%d]: forbidden first char in environment variable name at position %d:\n"
1945 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001946 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001947 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001948 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001949 }
William Lallemandb2f07452015-05-12 14:27:13 +02001950
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001951 if (err & PARSE_ERR_HEX) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001952 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1953
1954 ha_alert("parsing [%s:%d]: truncated or invalid hexadecimal sequence at position %d:\n"
1955 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001956 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus9f658a52020-06-16 18:14:21 +02001957 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001958 goto next_line;
1959 }
William Lallemandb2f07452015-05-12 14:27:13 +02001960
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02001961 if (err & PARSE_ERR_WRONG_EXPAND) {
1962 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1963
1964 ha_alert("parsing [%s:%d]: truncated or invalid word expansion sequence at position %d:\n"
1965 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
1966 err_code |= ERR_ALERT | ERR_FATAL;
1967 fatal++;
1968 goto next_line;
1969 }
1970
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001971 if (err & (PARSE_ERR_TOOLARGE|PARSE_ERR_OVERLAP)) {
1972 outlinesize = (outlen + 1023) & -1024;
Ilya Shipitsin76837bc2021-01-07 22:45:13 +05001973 outline = my_realloc2(outline, outlinesize);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001974 if (outline == NULL) {
1975 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1976 file, linenum);
William Lallemandb2f07452015-05-12 14:27:13 +02001977 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001978 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001979 goto next_line;
William Lallemandb2f07452015-05-12 14:27:13 +02001980 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001981 /* try again */
1982 continue;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001983 }
Willy Tarreau07d47062020-06-25 07:41:22 +02001984
1985 if (err & PARSE_ERR_TOOMANY) {
1986 /* only check this *after* being sure the output is allocated */
1987 ha_alert("parsing [%s:%d]: too many words, truncating after word %d, position %ld: <%s>.\n",
1988 file, linenum, MAX_LINE_ARGS, (long)(args[MAX_LINE_ARGS-1] - outline + 1), args[MAX_LINE_ARGS-1]);
1989 err_code |= ERR_ALERT | ERR_FATAL;
1990 fatal++;
1991 goto next_line;
1992 }
1993
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001994 /* everything's OK */
1995 break;
William Lallemandf9873ba2015-05-05 17:37:14 +02001996 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001997
1998 /* empty line */
1999 if (!**args)
2000 continue;
2001
Willy Tarreau4b103022021-02-12 17:59:10 +01002002 /* check for config macros */
2003 if (*args[0] == '.') {
2004 if (strcmp(args[0], ".if") == 0) {
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002005 const char *errptr = NULL;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002006 char *errmsg = NULL;
2007 int cond;
2008
Willy Tarreau4b103022021-02-12 17:59:10 +01002009 nested_cond_lvl++;
2010 if (nested_cond_lvl >= MAXNESTEDCONDS) {
2011 ha_alert("parsing [%s:%d]: too many nested '.if', max is %d.\n", file, linenum, MAXNESTEDCONDS);
2012 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2013 goto err;
2014 }
2015
Willy Tarreau6e647c92021-05-06 08:46:11 +02002016 if (nested_cond_lvl > 1 &&
2017 (nested_conds[nested_cond_lvl - 1] == NESTED_COND_IF_DROP ||
2018 nested_conds[nested_cond_lvl - 1] == NESTED_COND_IF_SKIP ||
2019 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELIF_DROP ||
2020 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELIF_SKIP ||
2021 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELSE_DROP)) {
Willy Tarreau4b103022021-02-12 17:59:10 +01002022 nested_conds[nested_cond_lvl] = NESTED_COND_IF_SKIP;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002023 goto next_line;
2024 }
2025
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002026 cond = cfg_eval_condition(args + 1, &errmsg, &errptr);
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002027 if (cond < 0) {
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002028 size_t newpos = sanitize_for_printing(args[1], errptr - args[1], 76);
2029
2030 ha_alert("parsing [%s:%d]: %s in '.if' at position %d:\n .if %s\n %*s\n",
2031 file, linenum, errmsg,
2032 (int)(errptr-args[1]+1), args[1], (int)(newpos+5), "^");
2033
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002034 free(errmsg);
Willy Tarreau4b103022021-02-12 17:59:10 +01002035 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2036 goto err;
2037 }
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002038
2039 if (cond)
2040 nested_conds[nested_cond_lvl] = NESTED_COND_IF_TAKE;
2041 else
2042 nested_conds[nested_cond_lvl] = NESTED_COND_IF_DROP;
2043
Willy Tarreau4b103022021-02-12 17:59:10 +01002044 goto next_line;
2045 }
2046 else if (strcmp(args[0], ".elif") == 0) {
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002047 const char *errptr = NULL;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002048 char *errmsg = NULL;
2049 int cond;
2050
Willy Tarreau4b103022021-02-12 17:59:10 +01002051 if (!nested_cond_lvl) {
2052 ha_alert("parsing [%s:%d]: lone '.elif' with no matching '.if'.\n", file, linenum);
2053 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2054 goto err;
2055 }
2056
2057 if (nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_TAKE ||
2058 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP) {
2059 ha_alert("parsing [%s:%d]: '.elif' after '.else' is not permitted.\n", file, linenum);
2060 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2061 goto err;
2062 }
2063
2064 if (nested_conds[nested_cond_lvl] == NESTED_COND_IF_TAKE ||
2065 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
Willy Tarreauf67ff022021-05-06 08:48:09 +02002066 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_TAKE ||
Willy Tarreau4b103022021-02-12 17:59:10 +01002067 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP) {
2068 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_SKIP;
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002069 goto next_line;
2070 }
2071
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002072 cond = cfg_eval_condition(args + 1, &errmsg, &errptr);
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002073 if (cond < 0) {
Willy Tarreau299bd1c2021-05-06 15:07:10 +02002074 size_t newpos = sanitize_for_printing(args[1], errptr - args[1], 74);
2075
2076 ha_alert("parsing [%s:%d]: %s in '.elif' at position %d:\n .elif %s\n %*s\n",
2077 file, linenum, errmsg,
2078 (int)(errptr-args[1]+1), args[1], (int)(newpos+7), "^");
2079
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002080 free(errmsg);
Willy Tarreau4b103022021-02-12 17:59:10 +01002081 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2082 goto err;
2083 }
Willy Tarreau6a2110c2021-05-06 08:19:48 +02002084
2085 if (cond)
2086 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_TAKE;
2087 else
2088 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_DROP;
2089
Willy Tarreau4b103022021-02-12 17:59:10 +01002090 goto next_line;
2091 }
2092 else if (strcmp(args[0], ".else") == 0) {
2093 if (!nested_cond_lvl) {
2094 ha_alert("parsing [%s:%d]: lone '.else' with no matching '.if'.\n", file, linenum);
2095 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2096 goto err;
2097 }
2098
2099 if (nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_TAKE ||
2100 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP) {
2101 ha_alert("parsing [%s:%d]: '.else' after '.else' is not permitted.\n", file, linenum);
2102 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2103 goto err;
2104 }
2105
2106 if (nested_conds[nested_cond_lvl] == NESTED_COND_IF_TAKE ||
2107 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
2108 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_TAKE ||
2109 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP) {
2110 nested_conds[nested_cond_lvl] = NESTED_COND_ELSE_DROP;
2111 } else {
2112 /* otherwise we take the "else" */
2113 nested_conds[nested_cond_lvl] = NESTED_COND_ELSE_TAKE;
2114 }
2115 goto next_line;
2116 }
2117 else if (strcmp(args[0], ".endif") == 0) {
2118 if (!nested_cond_lvl) {
2119 ha_alert("parsing [%s:%d]: lone '.endif' with no matching '.if'.\n", file, linenum);
2120 err_code |= ERR_ALERT | ERR_FATAL;
2121 fatal++;
2122 break;
2123 }
2124 nested_cond_lvl--;
2125 goto next_line;
2126 }
2127 }
2128
2129 if (nested_cond_lvl &&
2130 (nested_conds[nested_cond_lvl] == NESTED_COND_IF_DROP ||
2131 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
2132 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_DROP ||
2133 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP ||
2134 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP)) {
2135 /* The current block is masked out by the conditions */
2136 goto next_line;
2137 }
2138
Willy Tarreau7190b982021-05-07 08:59:50 +02002139 /* .warning/.error/.notice/.diag */
Willy Tarreau4b103022021-02-12 17:59:10 +01002140 if (*args[0] == '.') {
2141 if (strcmp(args[0], ".alert") == 0) {
2142 ha_alert("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
2143 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2144 goto err;
2145 }
2146 else if (strcmp(args[0], ".warning") == 0) {
2147 ha_warning("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
2148 err_code |= ERR_WARN;
2149 goto next_line;
2150 }
2151 else if (strcmp(args[0], ".notice") == 0) {
2152 ha_notice("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
2153 goto next_line;
2154 }
Willy Tarreau7190b982021-05-07 08:59:50 +02002155 else if (strcmp(args[0], ".diag") == 0) {
2156 ha_diag_warning("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
2157 goto next_line;
2158 }
Willy Tarreau4b103022021-02-12 17:59:10 +01002159 else {
2160 ha_alert("parsing [%s:%d]: unknown directive '%s'.\n", file, linenum, args[0]);
2161 err_code |= ERR_ALERT | ERR_FATAL;
2162 fatal++;
2163 break;
2164 }
2165 }
2166
Willy Tarreau3842f002009-06-14 11:39:52 +02002167 /* check for keyword modifiers "no" and "default" */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002168 if (strcmp(args[0], "no") == 0) {
William Lallemand0f99e342011-10-12 17:50:54 +02002169 char *tmp;
2170
Willy Tarreau3842f002009-06-14 11:39:52 +02002171 kwm = KWM_NO;
William Lallemand0f99e342011-10-12 17:50:54 +02002172 tmp = args[0];
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002173 for (arg=0; *args[arg+1]; arg++)
2174 args[arg] = args[arg+1]; // shift args after inversion
William Lallemand0f99e342011-10-12 17:50:54 +02002175 *tmp = '\0'; // fix the next arg to \0
2176 args[arg] = tmp;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002177 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002178 else if (strcmp(args[0], "default") == 0) {
Willy Tarreau3842f002009-06-14 11:39:52 +02002179 kwm = KWM_DEF;
2180 for (arg=0; *args[arg+1]; arg++)
2181 args[arg] = args[arg+1]; // shift args after inversion
2182 }
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002183
William Dauchyec730982019-10-27 20:08:10 +01002184 if (kwm != KWM_STD && strcmp(args[0], "option") != 0 &&
2185 strcmp(args[0], "log") != 0 && strcmp(args[0], "busy-polling") != 0 &&
Willy Tarreaud96f1122019-12-03 07:07:36 +01002186 strcmp(args[0], "set-dumpable") != 0 && strcmp(args[0], "strict-limits") != 0 &&
Amaury Denoyelle0f50cb92021-03-26 18:50:33 +01002187 strcmp(args[0], "insecure-fork-wanted") != 0 &&
2188 strcmp(args[0], "numa-cpu-mapping") != 0) {
William Dauchyec730982019-10-27 20:08:10 +01002189 ha_alert("parsing [%s:%d]: negation/default currently "
William Dauchy0fec3ab2019-10-27 20:08:11 +01002190 "supported only for options, log, busy-polling, "
Amaury Denoyelle0f50cb92021-03-26 18:50:33 +01002191 "set-dumpable, strict-limits, insecure-fork-wanted "
2192 "and numa-cpu-mapping.\n", file, linenum);
Willy Tarreau058e9072009-07-20 09:30:05 +02002193 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02002194 fatal++;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002195 }
2196
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002197 /* detect section start */
2198 list_for_each_entry(ics, &sections, list) {
2199 if (strcmp(args[0], ics->section_name) == 0) {
2200 cursection = ics->section_name;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002201 pcs = cs;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002202 cs = ics;
Willy Tarreau51508052021-05-06 10:04:45 +02002203 free(global.cfg_curr_section);
2204 global.cfg_curr_section = strdup(*args[1] ? args[1] : args[0]);
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02002205
2206 if (global.mode & MODE_DIAG) {
2207 check_section_position(args[0], file, linenum,
2208 &non_global_section_parsed);
2209 }
2210
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002211 break;
2212 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002213 }
2214
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002215 if (pcs && pcs->post_section_parser) {
Willy Tarreau32234e72020-06-16 17:14:33 +02002216 int status;
2217
2218 status = pcs->post_section_parser();
2219 err_code |= status;
2220 if (status & ERR_FATAL)
2221 fatal++;
2222
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002223 if (err_code & ERR_ABORT)
2224 goto err;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002225 }
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002226 pcs = NULL;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002227
William Lallemandd2ff56d2017-10-16 11:06:50 +02002228 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002229 ha_alert("parsing [%s:%d]: unknown keyword '%s' out of section.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02002230 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02002231 fatal++;
William Lallemandd2ff56d2017-10-16 11:06:50 +02002232 } else {
Willy Tarreau32234e72020-06-16 17:14:33 +02002233 int status;
2234
2235 status = cs->section_parser(file, linenum, args, kwm);
2236 err_code |= status;
2237 if (status & ERR_FATAL)
2238 fatal++;
2239
William Lallemandd2ff56d2017-10-16 11:06:50 +02002240 if (err_code & ERR_ABORT)
2241 goto err;
2242 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002243 }
William Lallemandd2ff56d2017-10-16 11:06:50 +02002244
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02002245 if (missing_lf != -1) {
Tim Duesterhusf92afb72020-08-18 22:00:04 +02002246 ha_alert("parsing [%s:%d]: Missing LF on last line, file might have been truncated at position %d.\n",
2247 file, linenum, (missing_lf + 1));
2248 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02002249 }
2250
Willy Tarreau51508052021-05-06 10:04:45 +02002251 ha_free(&global.cfg_curr_section);
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002252 if (cs && cs->post_section_parser)
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002253 err_code |= cs->post_section_parser();
William Lallemandd2ff56d2017-10-16 11:06:50 +02002254
Willy Tarreau4b103022021-02-12 17:59:10 +01002255 if (nested_cond_lvl) {
2256 ha_alert("parsing [%s:%d]: non-terminated '.if' block.\n", file, linenum);
2257 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
2258 }
Willy Tarreau8a022d52021-04-27 20:29:11 +02002259
2260 if (*initial_cwd && chdir(initial_cwd) == -1) {
2261 ha_alert("Impossible to get back to initial directory '%s' : %s\n", initial_cwd, strerror(errno));
2262 err_code |= ERR_ALERT | ERR_FATAL;
2263 }
2264
William Lallemandd2ff56d2017-10-16 11:06:50 +02002265err:
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002266 ha_free(&cfg_scope);
Willy Tarreau6daf3432008-01-22 16:44:08 +01002267 cursection = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02002268 free(thisline);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002269 free(outline);
Willy Tarreau51508052021-05-06 10:04:45 +02002270 global.cfg_curr_line = 0;
2271 global.cfg_curr_file = NULL;
2272
Willy Tarreauda543e12021-04-27 18:30:28 +02002273 if (f)
2274 fclose(f);
2275
Willy Tarreau058e9072009-07-20 09:30:05 +02002276 return err_code;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002277}
2278
Willy Tarreau64ab6072014-09-16 12:17:36 +02002279/* This function propagates processes from frontend <from> to backend <to> so
2280 * that it is always guaranteed that a backend pointed to by a frontend is
2281 * bound to all of its processes. After that, if the target is a "listen"
2282 * instance, the function recursively descends the target's own targets along
Willy Tarreau98d04852015-05-26 12:18:29 +02002283 * default_backend and use_backend rules. Since the bits are
Willy Tarreau64ab6072014-09-16 12:17:36 +02002284 * checked first to ensure that <to> is already bound to all processes of
2285 * <from>, there is no risk of looping and we ensure to follow the shortest
2286 * path to the destination.
2287 *
2288 * It is possible to set <to> to NULL for the first call so that the function
2289 * takes care of visiting the initial frontend in <from>.
2290 *
2291 * It is important to note that the function relies on the fact that all names
2292 * have already been resolved.
2293 */
2294void propagate_processes(struct proxy *from, struct proxy *to)
2295{
2296 struct switching_rule *rule;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002297
2298 if (to) {
2299 /* check whether we need to go down */
2300 if (from->bind_proc &&
2301 (from->bind_proc & to->bind_proc) == from->bind_proc)
2302 return;
2303
2304 if (!from->bind_proc && !to->bind_proc)
2305 return;
2306
2307 to->bind_proc = from->bind_proc ?
2308 (to->bind_proc | from->bind_proc) : 0;
2309
2310 /* now propagate down */
2311 from = to;
2312 }
2313
Willy Tarreau8a95d8c2014-12-18 13:56:26 +01002314 if (!(from->cap & PR_CAP_FE))
Willy Tarreau64ab6072014-09-16 12:17:36 +02002315 return;
2316
Willy Tarreauc3914d42020-09-24 08:39:22 +02002317 if (from->disabled)
Willy Tarreauf6b70012014-12-18 14:00:43 +01002318 return;
2319
Willy Tarreau64ab6072014-09-16 12:17:36 +02002320 /* default_backend */
2321 if (from->defbe.be)
2322 propagate_processes(from, from->defbe.be);
2323
2324 /* use_backend */
2325 list_for_each_entry(rule, &from->switching_rules, list) {
Cyril Bonté51639692014-10-02 19:56:25 +02002326 if (rule->dynamic)
2327 continue;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002328 to = rule->be.backend;
2329 propagate_processes(from, to);
2330 }
Willy Tarreau64ab6072014-09-16 12:17:36 +02002331}
2332
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002333#if defined(__linux__) && defined USE_CPU_AFFINITY
2334/* filter directory name of the pattern node<X> */
2335static int numa_filter(const struct dirent *dir)
2336{
2337 char *endptr;
2338
2339 /* dir name must start with "node" prefix */
2340 if (strncmp(dir->d_name, "node", 4))
2341 return 0;
2342
2343 /* dir name must be at least 5 characters long */
2344 if (!dir->d_name[4])
2345 return 0;
2346
2347 /* dir name must end with a numeric id */
2348 if (strtol(&dir->d_name[4], &endptr, 10) < 0 || *endptr)
2349 return 0;
2350
2351 /* all tests succeeded */
2352 return 1;
2353}
2354
2355/* Parse a linux cpu map string representing to a numeric cpu mask map
2356 * The cpu map string is a list of 4-byte hex strings separated by commas, with
2357 * most-significant byte first, one bit per cpu number.
2358 */
2359static void parse_cpumap(char *cpumap_str, struct hap_cpuset *cpu_set)
2360{
2361 unsigned long cpumap;
2362 char *start, *endptr, *comma;
2363 int i, j;
2364
2365 ha_cpuset_zero(cpu_set);
2366
2367 i = 0;
2368 do {
2369 /* reverse-search for a comma, parse the string after the comma
2370 * or at the beginning if no comma found
2371 */
2372 comma = strrchr(cpumap_str, ',');
2373 start = comma ? comma + 1 : cpumap_str;
2374
2375 cpumap = strtoul(start, &endptr, 16);
2376 for (j = 0; cpumap; cpumap >>= 1, ++j) {
2377 if (cpumap & 0x1)
2378 ha_cpuset_set(cpu_set, j + i * 32);
2379 }
2380
2381 if (comma)
2382 *comma = '\0';
2383 ++i;
2384 } while (comma);
2385}
2386
2387/* Read the first line of a file from <path> into the trash buffer.
2388 * Returns 0 on success, otherwise non-zero.
2389 */
2390static int read_file_to_trash(const char *path)
2391{
2392 FILE *file;
2393 int ret = 1;
2394
2395 file = fopen(path, "r");
2396 if (file) {
2397 if (fgets(trash.area, trash.size, file))
2398 ret = 0;
2399
2400 fclose(file);
2401 }
2402
2403 return ret;
2404}
2405
2406/* Inspect the cpu topology of the machine on startup. If a multi-socket
2407 * machine is detected, try to bind on the first node with active cpu. This is
2408 * done to prevent an impact on the overall performance when the topology of
2409 * the machine is unknown. This function is not called if one of the conditions
2410 * is met :
2411 * - a non-null nbthread directive is active
2412 * - a restrictive cpu-map directive is active
2413 * - a restrictive affinity is already applied, for example via taskset
2414 *
2415 * Returns the count of cpus selected. If no automatic binding was required or
2416 * an error occurred and the topology is unknown, 0 is returned.
2417 */
2418static int numa_detect_topology()
2419{
2420 struct dirent **node_dirlist;
2421 int node_dirlist_size;
2422
2423 struct hap_cpuset active_cpus, node_cpu_set;
2424 const char *parse_cpu_set_args[2];
2425 char cpumap_path[PATH_MAX];
2426 char *err = NULL;
2427
2428 /* node_cpu_set count is used as return value */
2429 ha_cpuset_zero(&node_cpu_set);
2430
2431 /* 1. count the sysfs node<X> directories */
Willy Tarreau07bf21c2021-04-23 19:09:16 +02002432 node_dirlist = NULL;
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002433 node_dirlist_size = scandir(NUMA_DETECT_SYSTEM_SYSFS_PATH"/node", &node_dirlist, numa_filter, alphasort);
2434 if (node_dirlist_size <= 1)
2435 goto free_scandir_entries;
2436
2437 /* 2. read and parse the list of currently online cpu */
2438 if (read_file_to_trash(NUMA_DETECT_SYSTEM_SYSFS_PATH"/cpu/online")) {
2439 ha_notice("Cannot read online CPUs list, will not try to refine binding\n");
2440 goto free_scandir_entries;
2441 }
2442
2443 parse_cpu_set_args[0] = trash.area;
2444 parse_cpu_set_args[1] = "\0";
2445 if (parse_cpu_set(parse_cpu_set_args, &active_cpus, 1, &err)) {
2446 ha_notice("Cannot read online CPUs list: '%s'. Will not try to refine binding\n", err);
2447 free(err);
2448 goto free_scandir_entries;
2449 }
2450
2451 /* 3. loop through nodes dirs and find the first one with active cpus */
2452 while (node_dirlist_size--) {
2453 const char *node = node_dirlist[node_dirlist_size]->d_name;
2454 ha_cpuset_zero(&node_cpu_set);
2455
2456 snprintf(cpumap_path, PATH_MAX, "%s/node/%s/cpumap",
2457 NUMA_DETECT_SYSTEM_SYSFS_PATH, node);
2458
2459 if (read_file_to_trash(cpumap_path)) {
2460 ha_notice("Cannot read CPUs list of '%s', will not select them to refine binding\n", node);
2461 free(node_dirlist[node_dirlist_size]);
2462 continue;
2463 }
2464
2465 parse_cpumap(trash.area, &node_cpu_set);
2466 ha_cpuset_and(&node_cpu_set, &active_cpus);
2467
2468 /* 5. set affinity on the first found node with active cpus */
2469 if (!ha_cpuset_count(&node_cpu_set)) {
2470 free(node_dirlist[node_dirlist_size]);
2471 continue;
2472 }
2473
2474 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));
2475 if (sched_setaffinity(getpid(), sizeof(node_cpu_set.cpuset), &node_cpu_set.cpuset) == -1) {
2476 ha_warning("Cannot set the cpu affinity for this multi-cpu machine\n");
2477
2478 /* clear the cpuset used as return value */
2479 ha_cpuset_zero(&node_cpu_set);
2480 }
2481
2482 free(node_dirlist[node_dirlist_size]);
2483 break;
2484 }
2485
2486 free_scandir_entries:
2487 while (node_dirlist_size-- > 0)
2488 free(node_dirlist[node_dirlist_size]);
2489 free(node_dirlist);
2490
2491 return ha_cpuset_count(&node_cpu_set);
2492}
2493#endif /* __linux__ && USE_CPU_AFFINITY */
2494
Willy Tarreaubb925012009-07-23 13:36:36 +02002495/*
2496 * Returns the error code, 0 if OK, or any combination of :
2497 * - ERR_ABORT: must abort ASAP
2498 * - ERR_FATAL: we can continue parsing but not start the service
2499 * - ERR_WARN: a warning has been emitted
2500 * - ERR_ALERT: an alert has been emitted
2501 * Only the two first ones can stop processing, the two others are just
2502 * indicators.
2503 */
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002504int check_config_validity()
2505{
2506 int cfgerr = 0;
2507 struct proxy *curproxy = NULL;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002508 struct stktable *t;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002509 struct server *newsrv = NULL;
Willy Tarreaubb925012009-07-23 13:36:36 +02002510 int err_code = 0;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002511 unsigned int next_pxid = 1;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002512 struct bind_conf *bind_conf;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002513 char *err;
William Lallemand48b4bb42017-10-23 14:36:34 +02002514 struct cfg_postparser *postparser;
Emeric Brun750fe792020-12-23 16:51:12 +01002515 struct resolvers *curr_resolvers = NULL;
Amaury Denoyelle3efee652021-03-08 17:31:39 +01002516 int i;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002517
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002518 bind_conf = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002519 /*
2520 * Now, check for the integrity of all that we have collected.
2521 */
2522
2523 /* will be needed further to delay some tasks */
Willy Tarreaub0b37bc2008-06-23 14:00:57 +02002524 tv_update_date(0,1);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002525
Willy Tarreau193b8c62012-11-22 00:17:38 +01002526 if (!global.tune.max_http_hdr)
2527 global.tune.max_http_hdr = MAX_HTTP_HDR;
2528
2529 if (!global.tune.cookie_len)
2530 global.tune.cookie_len = CAPTURE_LEN;
2531
Stéphane Cottin23e9e932017-05-18 08:58:41 +02002532 if (!global.tune.requri_len)
2533 global.tune.requri_len = REQURI_LEN;
2534
Willy Tarreau149ab772019-01-26 14:27:06 +01002535 if (!global.nbthread) {
2536 /* nbthread not set, thus automatic. In this case, and only if
2537 * running on a single process, we enable the same number of
2538 * threads as the number of CPUs the process is bound to. This
2539 * allows to easily control the number of threads using taskset.
2540 */
2541 global.nbthread = 1;
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002542
Willy Tarreau149ab772019-01-26 14:27:06 +01002543#if defined(USE_THREAD)
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002544 if (global.nbproc == 1) {
2545 int numa_cores = 0;
2546#if defined(__linux__) && defined USE_CPU_AFFINITY
Amaury Denoyelle0f50cb92021-03-26 18:50:33 +01002547 if (global.numa_cpu_mapping && !thread_cpu_mask_forced())
Amaury Denoyelleb56a7c82021-03-26 18:20:47 +01002548 numa_cores = numa_detect_topology();
2549#endif
2550 global.nbthread = numa_cores ? numa_cores :
2551 thread_cpus_enabled_at_boot;
2552 }
Willy Tarreau149ab772019-01-26 14:27:06 +01002553 all_threads_mask = nbits(global.nbthread);
2554#endif
2555 }
2556
Willy Tarreau26f6ae12019-02-02 12:56:15 +01002557 if (global.nbproc > 1 && global.nbthread > 1) {
2558 ha_alert("config : cannot enable multiple processes if multiple threads are configured. Please use either nbproc or nbthread but not both.\n");
2559 err_code |= ERR_ALERT | ERR_FATAL;
2560 goto out;
2561 }
2562
Willy Tarreaubafbe012017-11-24 17:34:44 +01002563 pool_head_requri = create_pool("requri", global.tune.requri_len , MEM_F_SHARED);
Emeric Brun96fd9262017-07-05 13:33:16 +02002564
Willy Tarreaubafbe012017-11-24 17:34:44 +01002565 pool_head_capture = create_pool("capture", global.tune.cookie_len, MEM_F_SHARED);
Willy Tarreau193b8c62012-11-22 00:17:38 +01002566
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002567 /* Post initialisation of the users and groups lists. */
2568 err_code = userlist_postinit();
2569 if (err_code != ERR_NONE)
2570 goto out;
2571
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002572 /* first, we will invert the proxy list order */
2573 curproxy = NULL;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002574 while (proxies_list) {
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002575 struct proxy *next;
2576
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002577 next = proxies_list->next;
2578 proxies_list->next = curproxy;
2579 curproxy = proxies_list;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002580 if (!next)
2581 break;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002582 proxies_list = next;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002583 }
2584
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002585 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002586 struct switching_rule *rule;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002587 struct server_rule *srule;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002588 struct sticking_rule *mrule;
Dragan Dosen1322d092015-09-22 16:05:32 +02002589 struct logsrv *tmplogsrv;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002590 unsigned int next_id;
Willy Tarreau16a21472012-11-19 12:39:59 +01002591 int nbproc;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002592
Willy Tarreau050536d2012-10-04 08:47:34 +02002593 if (curproxy->uuid < 0) {
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002594 /* proxy ID not set, use automatic numbering with first
2595 * spare entry starting with next_pxid.
2596 */
2597 next_pxid = get_next_id(&used_proxy_id, next_pxid);
2598 curproxy->conf.id.key = curproxy->uuid = next_pxid;
2599 eb32_insert(&used_proxy_id, &curproxy->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002600 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01002601 next_pxid++;
2602
Willy Tarreau55ea7572007-06-17 19:56:27 +02002603
Willy Tarreauc3914d42020-09-24 08:39:22 +02002604 if (curproxy->disabled) {
Willy Tarreau02b092f2020-10-07 18:36:54 +02002605 /* ensure we don't keep listeners uselessly bound. We
2606 * can't disable their listeners yet (fdtab not
2607 * allocated yet) but let's skip them.
2608 */
Dragan Dosen7d61a332019-05-07 14:16:18 +02002609 if (curproxy->table) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002610 ha_free(&curproxy->table->peers.name);
Dragan Dosen7d61a332019-05-07 14:16:18 +02002611 curproxy->table->peers.p = NULL;
2612 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002613 continue;
2614 }
2615
Willy Tarreau102df612014-05-07 23:56:38 +02002616 /* Check multi-process mode compatibility for the current proxy */
2617
2618 if (curproxy->bind_proc) {
2619 /* an explicit bind-process was specified, let's check how many
2620 * processes remain.
2621 */
David Carliere6c39412015-07-02 07:00:17 +00002622 nbproc = my_popcountl(curproxy->bind_proc);
Willy Tarreau102df612014-05-07 23:56:38 +02002623
Willy Tarreaua38a7172019-02-02 17:11:28 +01002624 curproxy->bind_proc &= all_proc_mask;
Willy Tarreau102df612014-05-07 23:56:38 +02002625 if (!curproxy->bind_proc && nbproc == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002626 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 +02002627 curproxy->bind_proc = 1;
2628 }
2629 else if (!curproxy->bind_proc && nbproc > 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002630 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 +02002631 curproxy->bind_proc = 0;
2632 }
2633 }
2634
Willy Tarreau3d209582014-05-09 17:06:11 +02002635 /* check and reduce the bind-proc of each listener */
2636 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
2637 unsigned long mask;
2638
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002639 /* HTTP frontends with "h2" as ALPN/NPN will work in
2640 * HTTP/2 and absolutely require buffers 16kB or larger.
2641 */
2642#ifdef USE_OPENSSL
2643 if (curproxy->mode == PR_MODE_HTTP && global.tune.bufsize < 16384) {
2644#ifdef OPENSSL_NPN_NEGOTIATED
2645 /* check NPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002646 if (bind_conf->ssl_conf.npn_str && strstr(bind_conf->ssl_conf.npn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002647 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",
2648 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002649 cfgerr++;
2650 }
2651#endif
2652#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
2653 /* check ALPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002654 if (bind_conf->ssl_conf.alpn_str && strstr(bind_conf->ssl_conf.alpn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002655 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",
2656 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002657 cfgerr++;
2658 }
2659#endif
2660 } /* HTTP && bufsize < 16384 */
2661#endif
2662
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002663 /* detect and address thread affinity inconsistencies */
Willy Tarreaue26993c2020-09-03 07:18:55 +02002664 mask = thread_mask(bind_conf->settings.bind_thread);
Willy Tarreau3d957172019-02-02 18:00:17 +01002665 if (!(mask & all_threads_mask)) {
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002666 unsigned long new_mask = 0;
2667
2668 while (mask) {
Willy Tarreau0c026f42018-08-01 19:12:20 +02002669 new_mask |= mask & all_threads_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002670 mask >>= global.nbthread;
2671 }
2672
Willy Tarreaue26993c2020-09-03 07:18:55 +02002673 bind_conf->settings.bind_thread = new_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002674 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",
2675 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line, new_mask);
2676 }
2677
2678 /* detect process and nbproc affinity inconsistencies */
Willy Tarreaue26993c2020-09-03 07:18:55 +02002679 mask = proc_mask(bind_conf->settings.bind_proc) & proc_mask(curproxy->bind_proc);
Willy Tarreaua36b3242019-02-02 13:14:34 +01002680 if (!(mask & all_proc_mask)) {
2681 mask = proc_mask(curproxy->bind_proc) & all_proc_mask;
Willy Tarreaue26993c2020-09-03 07:18:55 +02002682 nbproc = my_popcountl(bind_conf->settings.bind_proc);
2683 bind_conf->settings.bind_proc = proc_mask(bind_conf->settings.bind_proc) & mask;
Willy Tarreau3d209582014-05-09 17:06:11 +02002684
Willy Tarreaue26993c2020-09-03 07:18:55 +02002685 if (!bind_conf->settings.bind_proc && nbproc == 1) {
Willy Tarreaua36b3242019-02-02 13:14:34 +01002686 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",
2687 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreaue26993c2020-09-03 07:18:55 +02002688 bind_conf->settings.bind_proc = mask & ~(mask - 1);
Willy Tarreaua36b3242019-02-02 13:14:34 +01002689 }
Willy Tarreaue26993c2020-09-03 07:18:55 +02002690 else if (!bind_conf->settings.bind_proc && nbproc > 1) {
Willy Tarreaua36b3242019-02-02 13:14:34 +01002691 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",
2692 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreaue26993c2020-09-03 07:18:55 +02002693 bind_conf->settings.bind_proc = 0;
Willy Tarreaua36b3242019-02-02 13:14:34 +01002694 }
Willy Tarreau3d209582014-05-09 17:06:11 +02002695 }
2696 }
2697
Willy Tarreauff01a212009-03-15 13:46:16 +01002698 switch (curproxy->mode) {
Willy Tarreauff01a212009-03-15 13:46:16 +01002699 case PR_MODE_TCP:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002700 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002701 break;
2702
2703 case PR_MODE_HTTP:
Willy Tarreau25320b22013-03-24 07:22:08 +01002704 curproxy->http_needed = 1;
Willy Tarreauff01a212009-03-15 13:46:16 +01002705 break;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002706
2707 case PR_MODE_CLI:
2708 cfgerr += proxy_cfg_ensure_no_http(curproxy);
2709 break;
Emeric Brun54932b42020-07-07 09:43:24 +02002710 case PR_MODE_SYSLOG:
Willy Tarreaua389c9e2020-10-07 17:49:42 +02002711 case PR_MODE_PEERS:
Emeric Brun54932b42020-07-07 09:43:24 +02002712 case PR_MODES:
2713 /* should not happen, bug gcc warn missing switch statement */
Willy Tarreaua389c9e2020-10-07 17:49:42 +02002714 ha_alert("config : %s '%s' cannot use peers or syslog mode for this proxy. 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 +02002715 proxy_type_str(curproxy), curproxy->id);
2716 cfgerr++;
2717 break;
Willy Tarreauff01a212009-03-15 13:46:16 +01002718 }
2719
Willy Tarreau4975d142021-03-13 11:00:33 +01002720 if (curproxy != global.cli_fe && (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->conf.listeners)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002721 ha_warning("config : %s '%s' has no 'bind' directive. Please declare it as a backend if this was intended.\n",
2722 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauf3934b82015-08-11 11:36:45 +02002723 err_code |= ERR_WARN;
2724 }
2725
Willy Tarreau77e0dae2020-10-14 15:44:27 +02002726 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002727 if (curproxy->lbprm.algo & BE_LB_KIND) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002728 if (curproxy->options & PR_O_TRANSP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002729 ha_alert("config : %s '%s' cannot use both transparent and balance mode.\n",
2730 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002731 cfgerr++;
2732 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002733#ifdef WE_DONT_SUPPORT_SERVERLESS_LISTENERS
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002734 else if (curproxy->srv == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002735 ha_alert("config : %s '%s' needs at least 1 server in balance mode.\n",
2736 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002737 cfgerr++;
2738 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002739#endif
Willy Tarreau1620ec32011-08-06 17:05:02 +02002740 else if (curproxy->options & PR_O_DISPATCH) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002741 ha_warning("config : dispatch address of %s '%s' will be ignored in balance mode.\n",
2742 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002743 err_code |= ERR_WARN;
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002744 }
2745 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02002746 else if (!(curproxy->options & (PR_O_TRANSP | PR_O_DISPATCH | PR_O_HTTP_PROXY))) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002747 /* If no LB algo is set in a backend, and we're not in
2748 * transparent mode, dispatch mode nor proxy mode, we
2749 * want to use balance roundrobin by default.
2750 */
2751 curproxy->lbprm.algo &= ~BE_LB_ALGO;
2752 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002753 }
2754 }
Willy Tarreau193cf932007-09-17 10:17:23 +02002755
Willy Tarreau1620ec32011-08-06 17:05:02 +02002756 if (curproxy->options & PR_O_DISPATCH)
2757 curproxy->options &= ~(PR_O_TRANSP | PR_O_HTTP_PROXY);
2758 else if (curproxy->options & PR_O_HTTP_PROXY)
2759 curproxy->options &= ~(PR_O_DISPATCH | PR_O_TRANSP);
2760 else if (curproxy->options & PR_O_TRANSP)
2761 curproxy->options &= ~(PR_O_DISPATCH | PR_O_HTTP_PROXY);
Willy Tarreau82936582007-11-30 15:20:09 +01002762
Christopher Faulete5870d82020-04-15 11:32:03 +02002763 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_HTTP_RS)) {
2764 ha_warning("config : %s '%s' uses http-check rules without 'option httpchk', so the rules are ignored.\n",
2765 proxy_type_str(curproxy), curproxy->id);
2766 err_code |= ERR_WARN;
2767 }
2768
2769 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_TCPCHK_CHK &&
Christopher Fauletc0fcbe42020-06-03 19:00:42 +02002770 (curproxy->tcpcheck_rules.flags & TCPCHK_RULES_PROTO_CHK) != TCPCHK_RULES_HTTP_CHK) {
Willy Tarreau1620ec32011-08-06 17:05:02 +02002771 if (curproxy->options & PR_O_DISABLE404) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002772 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2773 "disable-on-404", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002774 err_code |= ERR_WARN;
2775 curproxy->options &= ~PR_O_DISABLE404;
2776 }
2777 if (curproxy->options2 & PR_O2_CHK_SNDST) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002778 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2779 "send-state", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002780 err_code |= ERR_WARN;
2781 curproxy->options &= ~PR_O2_CHK_SNDST;
2782 }
Willy Tarreauef781042010-01-27 11:53:01 +01002783 }
2784
Simon Horman98637e52014-06-20 12:30:16 +09002785 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_EXT_CHK) {
2786 if (!global.external_check) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002787 ha_alert("Proxy '%s' : '%s' unable to find required 'global.external-check'.\n",
2788 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002789 cfgerr++;
2790 }
2791 if (!curproxy->check_command) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002792 ha_alert("Proxy '%s' : '%s' unable to find required 'external-check command'.\n",
2793 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002794 cfgerr++;
2795 }
Willy Tarreaud96f1122019-12-03 07:07:36 +01002796 if (!(global.tune.options & GTUNE_INSECURE_FORK)) {
2797 ha_warning("Proxy '%s' : 'insecure-fork-wanted' not enabled in the global section, '%s' will likely fail.\n",
2798 curproxy->id, "option external-check");
2799 err_code |= ERR_WARN;
2800 }
Simon Horman98637e52014-06-20 12:30:16 +09002801 }
2802
Simon Horman64e34162015-02-06 11:11:57 +09002803 if (curproxy->email_alert.set) {
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002804 if (!(curproxy->email_alert.mailers.name && curproxy->email_alert.from && curproxy->email_alert.to)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002805 ha_warning("config : 'email-alert' will be ignored for %s '%s' (the presence any of "
2806 "'email-alert from', 'email-alert level' 'email-alert mailers', "
2807 "'email-alert myhostname', or 'email-alert to' "
2808 "requires each of 'email-alert from', 'email-alert mailers' and 'email-alert to' "
2809 "to be present).\n",
2810 proxy_type_str(curproxy), curproxy->id);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002811 err_code |= ERR_WARN;
2812 free_email_alert(curproxy);
2813 }
2814 if (!curproxy->email_alert.myhostname)
Cyril Bontée22bfd62015-12-04 03:07:07 +01002815 curproxy->email_alert.myhostname = strdup(hostname);
Simon Horman9dc49962015-01-30 11:22:59 +09002816 }
2817
Simon Horman98637e52014-06-20 12:30:16 +09002818 if (curproxy->check_command) {
2819 int clear = 0;
2820 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002821 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2822 "external-check command", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002823 err_code |= ERR_WARN;
2824 clear = 1;
2825 }
2826 if (curproxy->check_command[0] != '/' && !curproxy->check_path) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002827 ha_alert("Proxy '%s': '%s' does not have a leading '/' and 'external-check path' is not set.\n",
2828 curproxy->id, "external-check command");
Simon Horman98637e52014-06-20 12:30:16 +09002829 cfgerr++;
2830 }
2831 if (clear) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002832 ha_free(&curproxy->check_command);
Simon Horman98637e52014-06-20 12:30:16 +09002833 }
2834 }
2835
2836 if (curproxy->check_path) {
2837 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002838 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2839 "external-check path", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002840 err_code |= ERR_WARN;
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002841 ha_free(&curproxy->check_path);
Simon Horman98637e52014-06-20 12:30:16 +09002842 }
2843 }
2844
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002845 /* if a default backend was specified, let's find it */
2846 if (curproxy->defbe.name) {
2847 struct proxy *target;
2848
Willy Tarreauafb39922015-05-26 12:04:09 +02002849 target = proxy_be_by_name(curproxy->defbe.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002850 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002851 ha_alert("Proxy '%s': unable to find required default_backend: '%s'.\n",
2852 curproxy->id, curproxy->defbe.name);
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002853 cfgerr++;
2854 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002855 ha_alert("Proxy '%s': loop detected for default_backend: '%s'.\n",
2856 curproxy->id, curproxy->defbe.name);
Willy Tarreaubb925012009-07-23 13:36:36 +02002857 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002858 } else if (target->mode != curproxy->mode &&
2859 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2860
Christopher Faulet767a84b2017-11-24 16:50:31 +01002861 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) as its default backend (see 'mode').\n",
2862 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2863 curproxy->conf.file, curproxy->conf.line,
2864 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2865 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002866 cfgerr++;
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002867 } else {
2868 free(curproxy->defbe.name);
2869 curproxy->defbe.be = target;
Willy Tarreauff678132012-02-13 14:32:34 +01002870 /* Emit a warning if this proxy also has some servers */
2871 if (curproxy->srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002872 ha_warning("In proxy '%s', the 'default_backend' rule always has precedence over the servers, which will never be used.\n",
2873 curproxy->id);
Willy Tarreauff678132012-02-13 14:32:34 +01002874 err_code |= ERR_WARN;
2875 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002876 }
2877 }
2878
Willy Tarreau55ea7572007-06-17 19:56:27 +02002879 /* find the target proxy for 'use_backend' rules */
2880 list_for_each_entry(rule, &curproxy->switching_rules, list) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002881 struct proxy *target;
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002882 struct logformat_node *node;
2883 char *pxname;
2884
2885 /* Try to parse the string as a log format expression. If the result
2886 * of the parsing is only one entry containing a simple string, then
2887 * it's a standard string corresponding to a static rule, thus the
2888 * parsing is cancelled and be.name is restored to be resolved.
2889 */
2890 pxname = rule->be.name;
2891 LIST_INIT(&rule->be.expr);
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +01002892 curproxy->conf.args.ctx = ARGC_UBK;
2893 curproxy->conf.args.file = rule->file;
2894 curproxy->conf.args.line = rule->line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002895 err = NULL;
2896 if (!parse_logformat_string(pxname, curproxy, &rule->be.expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002897 ha_alert("Parsing [%s:%d]: failed to parse use_backend rule '%s' : %s.\n",
2898 rule->file, rule->line, pxname, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002899 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002900 cfgerr++;
2901 continue;
2902 }
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002903 node = LIST_NEXT(&rule->be.expr, struct logformat_node *, list);
2904
2905 if (!LIST_ISEMPTY(&rule->be.expr)) {
2906 if (node->type != LOG_FMT_TEXT || node->list.n != &rule->be.expr) {
2907 rule->dynamic = 1;
2908 free(pxname);
2909 continue;
2910 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02002911 /* Only one element in the list, a simple string: free the expression and
2912 * fall back to static rule
2913 */
Willy Tarreau2b718102021-04-21 07:32:39 +02002914 LIST_DELETE(&node->list);
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002915 free(node->arg);
2916 free(node);
2917 }
2918
2919 rule->dynamic = 0;
2920 rule->be.name = pxname;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002921
Willy Tarreauafb39922015-05-26 12:04:09 +02002922 target = proxy_be_by_name(rule->be.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002923 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002924 ha_alert("Proxy '%s': unable to find required use_backend: '%s'.\n",
2925 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002926 cfgerr++;
2927 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002928 ha_alert("Proxy '%s': loop detected for use_backend: '%s'.\n",
2929 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002930 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002931 } else if (target->mode != curproxy->mode &&
2932 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2933
Christopher Faulet767a84b2017-11-24 16:50:31 +01002934 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) in a 'use_backend' rule (see 'mode').\n",
2935 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2936 curproxy->conf.file, curproxy->conf.line,
2937 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2938 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002939 cfgerr++;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002940 } else {
Willy Tarreau35cd7342021-02-26 20:51:47 +01002941 ha_free(&rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002942 rule->be.backend = target;
2943 }
Christopher Faulet581db2b2021-03-26 10:02:46 +01002944 err_code |= warnif_tcp_http_cond(curproxy, rule->cond);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002945 }
2946
Willy Tarreau64ab6072014-09-16 12:17:36 +02002947 /* find the target server for 'use_server' rules */
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002948 list_for_each_entry(srule, &curproxy->server_rules, list) {
Jerome Magnin824186b2020-03-29 09:37:12 +02002949 struct server *target;
2950 struct logformat_node *node;
2951 char *server_name;
2952
2953 /* We try to parse the string as a log format expression. If the result of the parsing
2954 * is only one entry containing a single string, then it's a standard string corresponding
2955 * to a static rule, thus the parsing is cancelled and we fall back to setting srv.ptr.
2956 */
2957 server_name = srule->srv.name;
2958 LIST_INIT(&srule->expr);
2959 curproxy->conf.args.ctx = ARGC_USRV;
2960 err = NULL;
2961 if (!parse_logformat_string(server_name, curproxy, &srule->expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
2962 ha_alert("Parsing [%s:%d]; use-server rule failed to parse log-format '%s' : %s.\n",
2963 srule->file, srule->line, server_name, err);
2964 free(err);
2965 cfgerr++;
2966 continue;
2967 }
2968 node = LIST_NEXT(&srule->expr, struct logformat_node *, list);
2969
2970 if (!LIST_ISEMPTY(&srule->expr)) {
2971 if (node->type != LOG_FMT_TEXT || node->list.n != &srule->expr) {
2972 srule->dynamic = 1;
2973 free(server_name);
2974 continue;
2975 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02002976 /* Only one element in the list, a simple string: free the expression and
2977 * fall back to static rule
2978 */
Willy Tarreau2b718102021-04-21 07:32:39 +02002979 LIST_DELETE(&node->list);
Jerome Magnin824186b2020-03-29 09:37:12 +02002980 free(node->arg);
2981 free(node);
2982 }
2983
2984 srule->dynamic = 0;
2985 srule->srv.name = server_name;
2986 target = findserver(curproxy, srule->srv.name);
Christopher Faulet581db2b2021-03-26 10:02:46 +01002987 err_code |= warnif_tcp_http_cond(curproxy, srule->cond);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002988
2989 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002990 ha_alert("config : %s '%s' : unable to find server '%s' referenced in a 'use-server' rule.\n",
2991 proxy_type_str(curproxy), curproxy->id, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002992 cfgerr++;
2993 continue;
2994 }
Willy Tarreau35cd7342021-02-26 20:51:47 +01002995 ha_free(&srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002996 srule->srv.ptr = target;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002997 }
2998
Emeric Brunb982a3d2010-01-04 15:45:53 +01002999 /* find the target table for 'stick' rules */
3000 list_for_each_entry(mrule, &curproxy->sticking_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003001 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01003002
Emeric Brun1d33b292010-01-04 15:47:17 +01003003 curproxy->be_req_ana |= AN_REQ_STICKING_RULES;
3004 if (mrule->flags & STK_IS_STORE)
3005 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
3006
Emeric Brunb982a3d2010-01-04 15:45:53 +01003007 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003008 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003009 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003010 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01003011
3012 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003013 ha_alert("Proxy '%s': unable to find stick-table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01003014 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003015 cfgerr++;
3016 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003017 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003018 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
3019 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003020 cfgerr++;
3021 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003022 else if (target->proxy && curproxy->bind_proc & ~target->proxy->bind_proc) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01003023 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
3024 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01003025 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01003026 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01003027 else {
Willy Tarreau35cd7342021-02-26 20:51:47 +01003028 ha_free(&mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003029 mrule->table.t = target;
3030 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Thayne McCombs92149f92020-11-20 01:28:26 -07003031 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_KEY, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02003032 if (!in_proxies_list(target->proxies_list, curproxy)) {
3033 curproxy->next_stkt_ref = target->proxies_list;
3034 target->proxies_list = curproxy;
3035 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01003036 }
Christopher Faulet581db2b2021-03-26 10:02:46 +01003037 err_code |= warnif_tcp_http_cond(curproxy, mrule->cond);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003038 }
3039
3040 /* find the target table for 'store response' rules */
3041 list_for_each_entry(mrule, &curproxy->storersp_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003042 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01003043
Emeric Brun1d33b292010-01-04 15:47:17 +01003044 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
3045
Emeric Brunb982a3d2010-01-04 15:45:53 +01003046 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003047 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003048 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003049 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01003050
3051 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003052 ha_alert("Proxy '%s': unable to find store table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01003053 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003054 cfgerr++;
3055 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003056 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003057 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
3058 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01003059 cfgerr++;
3060 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003061 else if (target->proxy && (curproxy->bind_proc & ~target->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01003062 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
3063 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01003064 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01003065 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01003066 else {
Willy Tarreau35cd7342021-02-26 20:51:47 +01003067 ha_free(&mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003068 mrule->table.t = target;
3069 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Thayne McCombs92149f92020-11-20 01:28:26 -07003070 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_KEY, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02003071 if (!in_proxies_list(target->proxies_list, curproxy)) {
3072 curproxy->next_stkt_ref = target->proxies_list;
3073 target->proxies_list = curproxy;
3074 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01003075 }
3076 }
3077
Christopher Faulet42c6cf92021-03-25 17:19:04 +01003078 /* check validity for 'tcp-request' layer 4/5/6/7 rules */
3079 cfgerr += check_action_rules(&curproxy->tcp_req.l4_rules, curproxy, &err_code);
3080 cfgerr += check_action_rules(&curproxy->tcp_req.l5_rules, curproxy, &err_code);
3081 cfgerr += check_action_rules(&curproxy->tcp_req.inspect_rules, curproxy, &err_code);
3082 cfgerr += check_action_rules(&curproxy->tcp_rep.inspect_rules, curproxy, &err_code);
3083 cfgerr += check_action_rules(&curproxy->http_req_rules, curproxy, &err_code);
3084 cfgerr += check_action_rules(&curproxy->http_res_rules, curproxy, &err_code);
3085 cfgerr += check_action_rules(&curproxy->http_after_res_rules, curproxy, &err_code);
Christopher Faulet6d0c3df2020-01-22 09:26:35 +01003086
Christopher Faulet5eef0182021-03-31 17:13:49 +02003087 /* Warn is a switch-mode http is used on a TCP listener with servers but no backend */
3088 if (!curproxy->defbe.name && LIST_ISEMPTY(&curproxy->switching_rules) && curproxy->srv) {
3089 if ((curproxy->options & PR_O_HTTP_UPG) && curproxy->mode == PR_MODE_TCP)
3090 ha_warning("Proxy '%s' : 'switch-mode http' configured for a %s %s with no backend. "
3091 "Incoming connections upgraded to HTTP cannot be routed to TCP servers\n",
3092 curproxy->id, proxy_mode_str(curproxy->mode), proxy_type_str(curproxy));
3093 }
3094
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003095 if (curproxy->table && curproxy->table->peers.name) {
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003096 struct peers *curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02003097
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003098 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003099 if (strcmp(curpeers->id, curproxy->table->peers.name) == 0) {
Willy Tarreau35cd7342021-02-26 20:51:47 +01003100 ha_free(&curproxy->table->peers.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003101 curproxy->table->peers.p = curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02003102 break;
3103 }
3104 }
3105
3106 if (!curpeers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003107 ha_alert("Proxy '%s': unable to find sync peers '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003108 curproxy->id, curproxy->table->peers.name);
Willy Tarreau35cd7342021-02-26 20:51:47 +01003109 ha_free(&curproxy->table->peers.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003110 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02003111 cfgerr++;
3112 }
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02003113 else if (curpeers->disabled) {
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003114 /* silently disable this peers section */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003115 curproxy->table->peers.p = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003116 }
Emeric Brun32da3c42010-09-23 18:39:19 +02003117 else if (!curpeers->peers_fe) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003118 ha_alert("Proxy '%s': unable to find local peer '%s' in peers section '%s'.\n",
3119 curproxy->id, localpeer, curpeers->id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003120 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02003121 cfgerr++;
3122 }
3123 }
3124
Simon Horman9dc49962015-01-30 11:22:59 +09003125
3126 if (curproxy->email_alert.mailers.name) {
3127 struct mailers *curmailers = mailers;
3128
3129 for (curmailers = mailers; curmailers; curmailers = curmailers->next) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003130 if (strcmp(curmailers->id, curproxy->email_alert.mailers.name) == 0)
Simon Horman9dc49962015-01-30 11:22:59 +09003131 break;
Simon Horman9dc49962015-01-30 11:22:59 +09003132 }
Simon Horman9dc49962015-01-30 11:22:59 +09003133 if (!curmailers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003134 ha_alert("Proxy '%s': unable to find mailers '%s'.\n",
3135 curproxy->id, curproxy->email_alert.mailers.name);
Simon Horman9dc49962015-01-30 11:22:59 +09003136 free_email_alert(curproxy);
3137 cfgerr++;
3138 }
Christopher Faulet0108bb32017-10-20 21:34:32 +02003139 else {
3140 err = NULL;
3141 if (init_email_alert(curmailers, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003142 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulet0108bb32017-10-20 21:34:32 +02003143 free(err);
3144 cfgerr++;
3145 }
3146 }
Simon Horman9dc49962015-01-30 11:22:59 +09003147 }
3148
Willy Tarreau5bbc6762021-02-12 11:49:25 +01003149 if (curproxy->uri_auth && !(curproxy->uri_auth->flags & STAT_CONVDONE) &&
Willy Tarreauff011f22011-01-06 17:51:27 +01003150 !LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules) &&
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003151 (curproxy->uri_auth->userlist || curproxy->uri_auth->auth_realm )) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003152 ha_alert("%s '%s': stats 'auth'/'realm' and 'http-request' can't be used at the same time.\n",
3153 "proxy", curproxy->id);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003154 cfgerr++;
3155 goto out_uri_auth_compat;
3156 }
3157
Willy Tarreauee4f5f82019-10-09 09:59:22 +02003158 if (curproxy->uri_auth && curproxy->uri_auth->userlist &&
Willy Tarreau5bbc6762021-02-12 11:49:25 +01003159 (!(curproxy->uri_auth->flags & STAT_CONVDONE) ||
Willy Tarreauee4f5f82019-10-09 09:59:22 +02003160 LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules))) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01003161 const char *uri_auth_compat_req[10];
Thierry FOURNIERa28a9422015-08-04 19:35:46 +02003162 struct act_rule *rule;
Amaury Denoyelle3efee652021-03-08 17:31:39 +01003163 i = 0;
3164
Willy Tarreau95fa4692010-02-01 13:05:50 +01003165 /* build the ACL condition from scratch. We're relying on anonymous ACLs for that */
3166 uri_auth_compat_req[i++] = "auth";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003167
3168 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01003169 uri_auth_compat_req[i++] = "realm";
3170 uri_auth_compat_req[i++] = curproxy->uri_auth->auth_realm;
3171 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003172
Willy Tarreau95fa4692010-02-01 13:05:50 +01003173 uri_auth_compat_req[i++] = "unless";
3174 uri_auth_compat_req[i++] = "{";
3175 uri_auth_compat_req[i++] = "http_auth(.internal-stats-userlist)";
3176 uri_auth_compat_req[i++] = "}";
3177 uri_auth_compat_req[i++] = "";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003178
Willy Tarreauff011f22011-01-06 17:51:27 +01003179 rule = parse_http_req_cond(uri_auth_compat_req, "internal-stats-auth-compat", 0, curproxy);
3180 if (!rule) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01003181 cfgerr++;
3182 break;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003183 }
3184
Willy Tarreau2b718102021-04-21 07:32:39 +02003185 LIST_APPEND(&curproxy->uri_auth->http_req_rules, &rule->list);
Willy Tarreau95fa4692010-02-01 13:05:50 +01003186
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003187 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003188 ha_free(&curproxy->uri_auth->auth_realm);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003189 }
Willy Tarreau5bbc6762021-02-12 11:49:25 +01003190 curproxy->uri_auth->flags |= STAT_CONVDONE;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01003191 }
3192out_uri_auth_compat:
3193
Dragan Dosen43885c72015-10-01 13:18:13 +02003194 /* check whether we have a log server that uses RFC5424 log format */
Dragan Dosen1322d092015-09-22 16:05:32 +02003195 list_for_each_entry(tmplogsrv, &curproxy->logsrvs, list) {
Dragan Dosen43885c72015-10-01 13:18:13 +02003196 if (tmplogsrv->format == LOG_FORMAT_RFC5424) {
3197 if (!curproxy->conf.logformat_sd_string) {
3198 /* set the default logformat_sd_string */
3199 curproxy->conf.logformat_sd_string = default_rfc5424_sd_log_format;
3200 }
Dragan Dosen1322d092015-09-22 16:05:32 +02003201 break;
Dragan Dosen1322d092015-09-22 16:05:32 +02003202 }
Dragan Dosen1322d092015-09-22 16:05:32 +02003203 }
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02003204
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003205 /* compile the log format */
3206 if (!(curproxy->cap & PR_CAP_FE)) {
Willy Tarreau62a61232013-04-12 18:13:46 +02003207 if (curproxy->conf.logformat_string != default_http_log_format &&
3208 curproxy->conf.logformat_string != default_tcp_log_format &&
3209 curproxy->conf.logformat_string != clf_http_log_format)
3210 free(curproxy->conf.logformat_string);
3211 curproxy->conf.logformat_string = NULL;
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003212 ha_free(&curproxy->conf.lfs_file);
Willy Tarreau62a61232013-04-12 18:13:46 +02003213 curproxy->conf.lfs_line = 0;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003214
3215 if (curproxy->conf.logformat_sd_string != default_rfc5424_sd_log_format)
3216 free(curproxy->conf.logformat_sd_string);
3217 curproxy->conf.logformat_sd_string = NULL;
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003218 ha_free(&curproxy->conf.lfsd_file);
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003219 curproxy->conf.lfsd_line = 0;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003220 }
3221
Willy Tarreau62a61232013-04-12 18:13:46 +02003222 if (curproxy->conf.logformat_string) {
3223 curproxy->conf.args.ctx = ARGC_LOG;
3224 curproxy->conf.args.file = curproxy->conf.lfs_file;
3225 curproxy->conf.args.line = curproxy->conf.lfs_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003226 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02003227 if (!parse_logformat_string(curproxy->conf.logformat_string, curproxy, &curproxy->logformat,
3228 LOG_OPT_MANDATORY|LOG_OPT_MERGE_SPACES,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003229 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003230 ha_alert("Parsing [%s:%d]: failed to parse log-format : %s.\n",
3231 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003232 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003233 cfgerr++;
3234 }
Willy Tarreau62a61232013-04-12 18:13:46 +02003235 curproxy->conf.args.file = NULL;
3236 curproxy->conf.args.line = 0;
3237 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003238
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003239 if (curproxy->conf.logformat_sd_string) {
3240 curproxy->conf.args.ctx = ARGC_LOGSD;
3241 curproxy->conf.args.file = curproxy->conf.lfsd_file;
3242 curproxy->conf.args.line = curproxy->conf.lfsd_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003243 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02003244 if (!parse_logformat_string(curproxy->conf.logformat_sd_string, curproxy, &curproxy->logformat_sd,
3245 LOG_OPT_MANDATORY|LOG_OPT_MERGE_SPACES,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003246 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003247 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
3248 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003249 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003250 cfgerr++;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003251 } else if (!add_to_logformat_list(NULL, NULL, LF_SEPARATOR, &curproxy->logformat_sd, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003252 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
3253 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003254 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003255 cfgerr++;
3256 }
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003257 curproxy->conf.args.file = NULL;
3258 curproxy->conf.args.line = 0;
3259 }
3260
Willy Tarreau62a61232013-04-12 18:13:46 +02003261 if (curproxy->conf.uniqueid_format_string) {
3262 curproxy->conf.args.ctx = ARGC_UIF;
3263 curproxy->conf.args.file = curproxy->conf.uif_file;
3264 curproxy->conf.args.line = curproxy->conf.uif_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003265 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02003266 if (!parse_logformat_string(curproxy->conf.uniqueid_format_string, curproxy, &curproxy->format_unique_id,
3267 LOG_OPT_HTTP|LOG_OPT_MERGE_SPACES,
3268 (curproxy->cap & PR_CAP_FE) ? SMP_VAL_FE_HRQ_HDR
3269 : SMP_VAL_BE_HRQ_HDR,
3270 &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003271 ha_alert("Parsing [%s:%d]: failed to parse unique-id : %s.\n",
3272 curproxy->conf.uif_file, curproxy->conf.uif_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003273 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003274 cfgerr++;
3275 }
Willy Tarreau62a61232013-04-12 18:13:46 +02003276 curproxy->conf.args.file = NULL;
3277 curproxy->conf.args.line = 0;
3278 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003279
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01003280 /* only now we can check if some args remain unresolved.
3281 * This must be done after the users and groups resolution.
3282 */
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01003283 err = NULL;
3284 i = smp_resolve_args(curproxy, &err);
3285 cfgerr += i;
3286 if (i) {
3287 indent_msg(&err, 8);
3288 ha_alert("%s%s\n", i > 1 ? "multiple argument resolution errors:" : "", err);
3289 ha_free(&err);
3290 } else
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003291 cfgerr += acl_find_targets(curproxy);
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01003292
Willy Tarreau2738a142006-07-08 17:28:09 +02003293 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003294 (((curproxy->cap & PR_CAP_FE) && !curproxy->timeout.client) ||
Willy Tarreaud825eef2007-05-12 22:35:00 +02003295 ((curproxy->cap & PR_CAP_BE) && (curproxy->srv) &&
Willy Tarreauce887fd2012-05-12 12:50:00 +02003296 (!curproxy->timeout.connect ||
3297 (!curproxy->timeout.server && (curproxy->mode == PR_MODE_HTTP || !curproxy->timeout.tunnel)))))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003298 ha_warning("config : missing timeouts for %s '%s'.\n"
3299 " | While not properly invalid, you will certainly encounter various problems\n"
3300 " | with such a configuration. To fix this, please ensure that all following\n"
3301 " | timeouts are set to a non-zero value: 'client', 'connect', 'server'.\n",
3302 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003303 err_code |= ERR_WARN;
Willy Tarreau2738a142006-07-08 17:28:09 +02003304 }
Willy Tarreauf3c69202006-07-09 16:42:34 +02003305
Willy Tarreau1fa31262007-12-03 00:36:16 +01003306 /* Historically, the tarpit and queue timeouts were inherited from contimeout.
3307 * We must still support older configurations, so let's find out whether those
3308 * parameters have been set or must be copied from contimeouts.
3309 */
Willy Tarreau937c3ea2021-02-12 11:14:35 +01003310 if (!curproxy->timeout.tarpit)
3311 curproxy->timeout.tarpit = curproxy->timeout.connect;
3312 if ((curproxy->cap & PR_CAP_BE) && !curproxy->timeout.queue)
3313 curproxy->timeout.queue = curproxy->timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01003314
Christopher Faulete5870d82020-04-15 11:32:03 +02003315 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_TCP_RS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003316 ha_warning("config : %s '%s' uses tcp-check rules without 'option tcp-check', so the rules are ignored.\n",
3317 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau215663d2014-06-13 18:30:23 +02003318 err_code |= ERR_WARN;
3319 }
3320
Willy Tarreau193b8c62012-11-22 00:17:38 +01003321 /* ensure that cookie capture length is not too large */
3322 if (curproxy->capture_len >= global.tune.cookie_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003323 ha_warning("config : truncating capture length to %d bytes for %s '%s'.\n",
3324 global.tune.cookie_len - 1, proxy_type_str(curproxy), curproxy->id);
Willy Tarreau193b8c62012-11-22 00:17:38 +01003325 err_code |= ERR_WARN;
3326 curproxy->capture_len = global.tune.cookie_len - 1;
3327 }
3328
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003329 /* The small pools required for the capture lists */
Willy Tarreau9a54e132012-03-24 08:33:05 +01003330 if (curproxy->nb_req_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003331 curproxy->req_cap_pool = create_pool("ptrcap",
3332 curproxy->nb_req_cap * sizeof(char *),
3333 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003334 }
3335
3336 if (curproxy->nb_rsp_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003337 curproxy->rsp_cap_pool = create_pool("ptrcap",
3338 curproxy->nb_rsp_cap * sizeof(char *),
3339 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003340 }
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003341
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003342 switch (curproxy->load_server_state_from_file) {
3343 case PR_SRV_STATE_FILE_UNSPEC:
3344 curproxy->load_server_state_from_file = PR_SRV_STATE_FILE_NONE;
3345 break;
3346 case PR_SRV_STATE_FILE_GLOBAL:
3347 if (!global.server_state_file) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003348 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",
3349 curproxy->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003350 err_code |= ERR_WARN;
3351 }
3352 break;
3353 }
3354
Willy Tarreaubaaee002006-06-26 02:48:02 +02003355 /* first, we will invert the servers list order */
3356 newsrv = NULL;
3357 while (curproxy->srv) {
3358 struct server *next;
3359
3360 next = curproxy->srv->next;
3361 curproxy->srv->next = newsrv;
3362 newsrv = curproxy->srv;
3363 if (!next)
3364 break;
3365 curproxy->srv = next;
3366 }
3367
Willy Tarreau17edc812014-01-03 12:14:34 +01003368 /* Check that no server name conflicts. This causes trouble in the stats.
3369 * We only emit a warning for the first conflict affecting each server,
3370 * in order to avoid combinatory explosion if all servers have the same
3371 * name. We do that only for servers which do not have an explicit ID,
3372 * because these IDs were made also for distinguishing them and we don't
3373 * want to annoy people who correctly manage them.
3374 */
3375 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3376 struct server *other_srv;
3377
3378 if (newsrv->puid)
3379 continue;
3380
3381 for (other_srv = curproxy->srv; other_srv && other_srv != newsrv; other_srv = other_srv->next) {
3382 if (!other_srv->puid && strcmp(other_srv->id, newsrv->id) == 0) {
Willy Tarreaub01302f2019-05-27 19:31:06 +02003383 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 +01003384 newsrv->conf.file, newsrv->conf.line,
3385 proxy_type_str(curproxy), curproxy->id,
3386 newsrv->id, other_srv->conf.line);
Willy Tarreaub01302f2019-05-27 19:31:06 +02003387 cfgerr++;
Willy Tarreau17edc812014-01-03 12:14:34 +01003388 break;
3389 }
3390 }
3391 }
3392
Willy Tarreaudd701652010-05-25 23:03:02 +02003393 /* assign automatic UIDs to servers which don't have one yet */
3394 next_id = 1;
3395 newsrv = curproxy->srv;
3396 while (newsrv != NULL) {
3397 if (!newsrv->puid) {
3398 /* server ID not set, use automatic numbering with first
3399 * spare entry starting with next_svid.
3400 */
3401 next_id = get_next_id(&curproxy->conf.used_server_id, next_id);
3402 newsrv->conf.id.key = newsrv->puid = next_id;
3403 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Frédéric Lécaille84d60462019-05-17 14:29:15 +02003404 newsrv->conf.name.key = newsrv->id;
3405 ebis_insert(&curproxy->conf.used_server_name, &newsrv->conf.name);
Willy Tarreaudd701652010-05-25 23:03:02 +02003406 }
3407 next_id++;
3408 newsrv = newsrv->next;
3409 }
3410
Willy Tarreau20697042007-11-15 23:26:18 +01003411 curproxy->lbprm.wmult = 1; /* default weight multiplier */
Willy Tarreau5dc2fa62007-11-19 19:10:18 +01003412 curproxy->lbprm.wdiv = 1; /* default weight divider */
Willy Tarreaubaaee002006-06-26 02:48:02 +02003413
Willy Tarreau62c3be22012-01-20 13:12:32 +01003414 /*
3415 * If this server supports a maxconn parameter, it needs a dedicated
3416 * tasks to fill the emptied slots when a connection leaves.
3417 * Also, resolve deferred tracking dependency if needed.
3418 */
3419 newsrv = curproxy->srv;
3420 while (newsrv != NULL) {
3421 if (newsrv->minconn > newsrv->maxconn) {
3422 /* Only 'minconn' was specified, or it was higher than or equal
3423 * to 'maxconn'. Let's turn this into maxconn and clean it, as
3424 * this will avoid further useless expensive computations.
3425 */
3426 newsrv->maxconn = newsrv->minconn;
3427 } else if (newsrv->maxconn && !newsrv->minconn) {
3428 /* minconn was not specified, so we set it to maxconn */
3429 newsrv->minconn = newsrv->maxconn;
3430 }
3431
William Dauchyf6370442020-11-14 19:25:33 +01003432 /* this will also properly set the transport layer for
3433 * prod and checks
3434 * if default-server have use_ssl, prerare ssl init
3435 * without activating it */
3436 if (newsrv->use_ssl == 1 || newsrv->check.use_ssl == 1 ||
3437 (newsrv->proxy->options & PR_O_TCPCHK_SSL) ||
3438 (newsrv->use_ssl != 1 && curproxy->defsrv.use_ssl == 1)) {
Willy Tarreau17d45382016-12-22 21:16:08 +01003439 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
3440 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(newsrv);
3441 }
Emeric Brun94324a42012-10-11 14:00:19 +02003442
Willy Tarreau034c88c2017-01-23 23:36:45 +01003443 if ((newsrv->flags & SRV_F_FASTOPEN) &&
3444 ((curproxy->retry_type & (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)) !=
3445 (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)))
3446 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",
3447 newsrv->conf.file, newsrv->conf.line,
3448 proxy_type_str(curproxy), curproxy->id,
3449 newsrv->id);
3450
Willy Tarreau62c3be22012-01-20 13:12:32 +01003451 if (newsrv->trackit) {
3452 struct proxy *px;
Willy Tarreau32091232014-05-16 13:52:00 +02003453 struct server *srv, *loop;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003454 char *pname, *sname;
3455
3456 pname = newsrv->trackit;
3457 sname = strrchr(pname, '/');
3458
3459 if (sname)
3460 *sname++ = '\0';
3461 else {
3462 sname = pname;
3463 pname = NULL;
3464 }
3465
3466 if (pname) {
Willy Tarreau9e0bb102015-05-26 11:24:42 +02003467 px = proxy_be_by_name(pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003468 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003469 ha_alert("config : %s '%s', server '%s': unable to find required proxy '%s' for tracking.\n",
3470 proxy_type_str(curproxy), curproxy->id,
3471 newsrv->id, pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003472 cfgerr++;
3473 goto next_srv;
3474 }
3475 } else
3476 px = curproxy;
3477
3478 srv = findserver(px, sname);
3479 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003480 ha_alert("config : %s '%s', server '%s': unable to find required server '%s' for tracking.\n",
3481 proxy_type_str(curproxy), curproxy->id,
3482 newsrv->id, sname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003483 cfgerr++;
3484 goto next_srv;
3485 }
3486
Christopher Faulet8892e5d2020-03-26 19:48:20 +01003487 if (!srv->do_check && !srv->do_agent && !srv->track && !srv->trackit) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003488 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for "
3489 "tracking as it does not have any check nor agent enabled.\n",
3490 proxy_type_str(curproxy), curproxy->id,
3491 newsrv->id, px->id, srv->id);
Willy Tarreau32091232014-05-16 13:52:00 +02003492 cfgerr++;
3493 goto next_srv;
3494 }
3495
3496 for (loop = srv->track; loop && loop != newsrv; loop = loop->track);
3497
Frédéric Lécaille2efc6492017-03-14 14:32:17 +01003498 if (newsrv == srv || loop) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003499 ha_alert("config : %s '%s', server '%s': unable to track %s/%s as it "
3500 "belongs to a tracking chain looping back to %s/%s.\n",
3501 proxy_type_str(curproxy), curproxy->id,
3502 newsrv->id, px->id, srv->id, px->id,
3503 newsrv == srv ? srv->id : loop->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003504 cfgerr++;
3505 goto next_srv;
3506 }
3507
3508 if (curproxy != px &&
3509 (curproxy->options & PR_O_DISABLE404) != (px->options & PR_O_DISABLE404)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003510 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for"
3511 "tracking: disable-on-404 option inconsistency.\n",
3512 proxy_type_str(curproxy), curproxy->id,
3513 newsrv->id, px->id, srv->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003514 cfgerr++;
3515 goto next_srv;
3516 }
3517
Willy Tarreau62c3be22012-01-20 13:12:32 +01003518 newsrv->track = srv;
Willy Tarreau1a53a3a2013-12-11 15:27:05 +01003519 newsrv->tracknext = srv->trackers;
3520 srv->trackers = newsrv;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003521
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003522 ha_free(&newsrv->trackit);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003523 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003524
Willy Tarreau62c3be22012-01-20 13:12:32 +01003525 next_srv:
3526 newsrv = newsrv->next;
3527 }
3528
Olivier Houchard4e694042017-03-14 20:01:29 +01003529 /*
3530 * Try to generate dynamic cookies for servers now.
3531 * It couldn't be done earlier, since at the time we parsed
3532 * the server line, we may not have known yet that we
3533 * should use dynamic cookies, or the secret key may not
3534 * have been provided yet.
3535 */
3536 if (curproxy->ck_opts & PR_CK_DYNAMIC) {
3537 newsrv = curproxy->srv;
3538 while (newsrv != NULL) {
3539 srv_set_dyncookie(newsrv);
3540 newsrv = newsrv->next;
3541 }
3542
3543 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003544 /* We have to initialize the server lookup mechanism depending
Joseph Herlanta14c03e2018-11-15 14:04:19 -08003545 * on what LB algorithm was chosen.
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003546 */
3547
3548 curproxy->lbprm.algo &= ~(BE_LB_LKUP | BE_LB_PROP_DYN);
3549 switch (curproxy->lbprm.algo & BE_LB_KIND) {
3550 case BE_LB_KIND_RR:
Willy Tarreau9757a382009-10-03 12:56:50 +02003551 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_STATIC) {
3552 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3553 init_server_map(curproxy);
Willy Tarreau760e81d2018-05-03 07:20:40 +02003554 } else if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_RANDOM) {
3555 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3556 chash_init_server_tree(curproxy);
Willy Tarreau9757a382009-10-03 12:56:50 +02003557 } else {
3558 curproxy->lbprm.algo |= BE_LB_LKUP_RRTREE | BE_LB_PROP_DYN;
3559 fwrr_init_server_groups(curproxy);
3560 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003561 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003562
Willy Tarreau3ebb1162012-02-13 16:57:44 +01003563 case BE_LB_KIND_CB:
Willy Tarreauf09c6602012-02-13 17:12:08 +01003564 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_CB_LC) {
3565 curproxy->lbprm.algo |= BE_LB_LKUP_LCTREE | BE_LB_PROP_DYN;
3566 fwlc_init_server_tree(curproxy);
3567 } else {
3568 curproxy->lbprm.algo |= BE_LB_LKUP_FSTREE | BE_LB_PROP_DYN;
3569 fas_init_server_tree(curproxy);
3570 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003571 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003572
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003573 case BE_LB_KIND_HI:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003574 if ((curproxy->lbprm.algo & BE_LB_HASH_TYPE) == BE_LB_HASH_CONS) {
3575 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3576 chash_init_server_tree(curproxy);
3577 } else {
3578 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3579 init_server_map(curproxy);
3580 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003581 break;
3582 }
Willy Tarreaucd10def2020-10-17 18:48:47 +02003583 HA_RWLOCK_INIT(&curproxy->lbprm.lock);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003584
3585 if (curproxy->options & PR_O_LOGASAP)
3586 curproxy->to_log &= ~LW_BYTES;
3587
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003588 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003589 (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->logsrvs) &&
3590 (!LIST_ISEMPTY(&curproxy->logformat) || !LIST_ISEMPTY(&curproxy->logformat_sd))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003591 ha_warning("config : log format ignored for %s '%s' since it has no log address.\n",
3592 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003593 err_code |= ERR_WARN;
3594 }
3595
Christopher Faulet3b6446f2021-03-15 15:10:38 +01003596 if (curproxy->mode != PR_MODE_HTTP && !(curproxy->options & PR_O_HTTP_UPG)) {
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003597 int optnum;
3598
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003599 if (curproxy->uri_auth) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003600 ha_warning("config : 'stats' statement ignored for %s '%s' as it requires HTTP mode.\n",
3601 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003602 err_code |= ERR_WARN;
3603 curproxy->uri_auth = NULL;
3604 }
3605
Willy Tarreaude7dc882017-03-10 11:49:21 +01003606 if (curproxy->capture_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003607 ha_warning("config : 'capture' statement ignored for %s '%s' as it requires HTTP mode.\n",
3608 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003609 err_code |= ERR_WARN;
3610 }
3611
3612 if (!LIST_ISEMPTY(&curproxy->http_req_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003613 ha_warning("config : 'http-request' rules ignored for %s '%s' as they require HTTP mode.\n",
3614 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003615 err_code |= ERR_WARN;
3616 }
3617
3618 if (!LIST_ISEMPTY(&curproxy->http_res_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003619 ha_warning("config : 'http-response' rules ignored for %s '%s' as they require HTTP mode.\n",
3620 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003621 err_code |= ERR_WARN;
3622 }
3623
Christopher Fauletbb7abed2021-03-15 15:09:21 +01003624 if (!LIST_ISEMPTY(&curproxy->http_after_res_rules)) {
3625 ha_warning("config : 'http-after-response' rules ignored for %s '%s' as they require HTTP mode.\n",
3626 proxy_type_str(curproxy), curproxy->id);
3627 err_code |= ERR_WARN;
3628 }
3629
Willy Tarreaude7dc882017-03-10 11:49:21 +01003630 if (!LIST_ISEMPTY(&curproxy->redirect_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003631 ha_warning("config : 'redirect' rules ignored for %s '%s' as they require HTTP mode.\n",
3632 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003633 err_code |= ERR_WARN;
3634 }
3635
Willy Tarreau87cf5142011-08-19 22:57:24 +02003636 if (curproxy->options & (PR_O_FWDFOR | PR_O_FF_ALWAYS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003637 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3638 "forwardfor", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003639 err_code |= ERR_WARN;
Willy Tarreau87cf5142011-08-19 22:57:24 +02003640 curproxy->options &= ~(PR_O_FWDFOR | PR_O_FF_ALWAYS);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003641 }
3642
3643 if (curproxy->options & PR_O_ORGTO) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003644 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3645 "originalto", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003646 err_code |= ERR_WARN;
3647 curproxy->options &= ~PR_O_ORGTO;
3648 }
3649
3650 for (optnum = 0; cfg_opts[optnum].name; optnum++) {
3651 if (cfg_opts[optnum].mode == PR_MODE_HTTP &&
3652 (curproxy->cap & cfg_opts[optnum].cap) &&
3653 (curproxy->options & cfg_opts[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003654 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3655 cfg_opts[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003656 err_code |= ERR_WARN;
3657 curproxy->options &= ~cfg_opts[optnum].val;
3658 }
3659 }
3660
3661 for (optnum = 0; cfg_opts2[optnum].name; optnum++) {
3662 if (cfg_opts2[optnum].mode == PR_MODE_HTTP &&
3663 (curproxy->cap & cfg_opts2[optnum].cap) &&
3664 (curproxy->options2 & cfg_opts2[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003665 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3666 cfg_opts2[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003667 err_code |= ERR_WARN;
3668 curproxy->options2 &= ~cfg_opts2[optnum].val;
3669 }
3670 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003671
Willy Tarreau29fbe512015-08-20 19:35:14 +02003672#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003673 if (curproxy->conn_src.bind_hdr_occ) {
3674 curproxy->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003675 ha_warning("config : %s '%s' : ignoring use of header %s as source IP in non-HTTP mode.\n",
3676 proxy_type_str(curproxy), curproxy->id, curproxy->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003677 err_code |= ERR_WARN;
3678 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003679#endif
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003680 }
3681
Willy Tarreaubaaee002006-06-26 02:48:02 +02003682 /*
Willy Tarreau21d2af32008-02-14 20:25:24 +01003683 * ensure that we're not cross-dressing a TCP server into HTTP.
3684 */
3685 newsrv = curproxy->srv;
3686 while (newsrv != NULL) {
Willy Tarreau0cec3312011-10-31 13:49:26 +01003687 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->rdr_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003688 ha_alert("config : %s '%s' : server cannot have cookie or redirect prefix in non-HTTP mode.\n",
3689 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003690 cfgerr++;
Willy Tarreau21d2af32008-02-14 20:25:24 +01003691 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003692
Willy Tarreau0cec3312011-10-31 13:49:26 +01003693 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->cklen) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003694 ha_warning("config : %s '%s' : ignoring cookie for server '%s' as HTTP mode is disabled.\n",
3695 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau0cec3312011-10-31 13:49:26 +01003696 err_code |= ERR_WARN;
3697 }
3698
Willy Tarreauc93cd162014-05-13 15:54:22 +02003699 if ((newsrv->flags & SRV_F_MAPPORTS) && (curproxy->options2 & PR_O2_RDPC_PRST)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003700 ha_warning("config : %s '%s' : RDP cookie persistence will not work for server '%s' because it lacks an explicit port number.\n",
3701 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau82ffa392013-08-13 17:19:08 +02003702 err_code |= ERR_WARN;
3703 }
3704
Willy Tarreau29fbe512015-08-20 19:35:14 +02003705#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003706 if (curproxy->mode != PR_MODE_HTTP && newsrv->conn_src.bind_hdr_occ) {
3707 newsrv->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003708 ha_warning("config : %s '%s' : server %s cannot use header %s as source IP in non-HTTP mode.\n",
3709 proxy_type_str(curproxy), curproxy->id, newsrv->id, newsrv->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003710 err_code |= ERR_WARN;
3711 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003712#endif
Willy Tarreau4c183462017-01-06 12:21:38 +01003713
Willy Tarreau46deab62018-04-28 07:18:15 +02003714 if ((curproxy->mode != PR_MODE_HTTP) && (curproxy->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR)
3715 curproxy->options &= ~PR_O_REUSE_MASK;
3716
Willy Tarreau21d2af32008-02-14 20:25:24 +01003717 newsrv = newsrv->next;
3718 }
3719
Christopher Fauletd7c91962015-04-30 11:48:27 +02003720 /* Check filter configuration, if any */
3721 cfgerr += flt_check(curproxy);
3722
Willy Tarreauc1a21672009-08-16 22:37:44 +02003723 if (curproxy->cap & PR_CAP_FE) {
Willy Tarreau050536d2012-10-04 08:47:34 +02003724 if (!curproxy->accept)
3725 curproxy->accept = frontend_accept;
Willy Tarreau81f9aa32010-06-01 17:45:26 +02003726
Willy Tarreauc1a21672009-08-16 22:37:44 +02003727 if (curproxy->tcp_req.inspect_delay ||
3728 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
Willy Tarreaufb356202010-08-03 14:02:05 +02003729 curproxy->fe_req_ana |= AN_REQ_INSPECT_FE;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003730
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003731 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003732 curproxy->fe_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_PROCESS_FE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003733 curproxy->fe_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_FE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003734 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003735
William Lallemandcf62f7e2018-10-26 14:47:40 +02003736 if (curproxy->mode == PR_MODE_CLI) {
3737 curproxy->fe_req_ana |= AN_REQ_WAIT_CLI;
3738 curproxy->fe_rsp_ana |= AN_RES_WAIT_CLI;
3739 }
3740
Willy Tarreauc1a21672009-08-16 22:37:44 +02003741 /* both TCP and HTTP must check switching rules */
3742 curproxy->fe_req_ana |= AN_REQ_SWITCHING_RULES;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003743
3744 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003745 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003746 curproxy->fe_req_ana |= AN_REQ_FLT_START_FE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3747 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 +02003748 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003749 }
3750
3751 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreaufb356202010-08-03 14:02:05 +02003752 if (curproxy->tcp_req.inspect_delay ||
3753 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
3754 curproxy->be_req_ana |= AN_REQ_INSPECT_BE;
3755
Emeric Brun97679e72010-09-23 17:56:44 +02003756 if (!LIST_ISEMPTY(&curproxy->tcp_rep.inspect_rules))
3757 curproxy->be_rsp_ana |= AN_RES_INSPECT;
3758
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003759 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003760 curproxy->be_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_INNER | AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003761 curproxy->be_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_BE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003762 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003763
3764 /* If the backend does requires RDP cookie persistence, we have to
3765 * enable the corresponding analyser.
3766 */
3767 if (curproxy->options2 & PR_O2_RDPC_PRST)
3768 curproxy->be_req_ana |= AN_REQ_PRST_RDP_COOKIE;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003769
3770 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003771 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003772 curproxy->be_req_ana |= AN_REQ_FLT_START_BE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3773 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 +02003774 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003775 }
Christopher Fauleta717b992018-04-10 14:43:00 +02003776
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003777 /* Check the mux protocols, if any, for each listener and server
Christopher Fauleta717b992018-04-10 14:43:00 +02003778 * attached to the current proxy */
3779 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3780 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003781 const struct mux_proto_list *mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003782
3783 if (!bind_conf->mux_proto)
3784 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003785
3786 /* it is possible that an incorrect mux was referenced
3787 * due to the proxy's mode not being taken into account
3788 * on first pass. Let's adjust it now.
3789 */
3790 mux_ent = conn_get_best_mux_entry(bind_conf->mux_proto->token, PROTO_SIDE_FE, mode);
3791
3792 if (!mux_ent || !isteq(mux_ent->token, bind_conf->mux_proto->token)) {
Christopher Fauleta717b992018-04-10 14:43:00 +02003793 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for 'bind %s' at [%s:%d].\n",
3794 proxy_type_str(curproxy), curproxy->id,
3795 (int)bind_conf->mux_proto->token.len,
3796 bind_conf->mux_proto->token.ptr,
3797 bind_conf->arg, bind_conf->file, bind_conf->line);
3798 cfgerr++;
3799 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003800
3801 /* update the mux */
3802 bind_conf->mux_proto = mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003803 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003804 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3805 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003806 const struct mux_proto_list *mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003807
3808 if (!newsrv->mux_proto)
3809 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003810
3811 /* it is possible that an incorrect mux was referenced
3812 * due to the proxy's mode not being taken into account
3813 * on first pass. Let's adjust it now.
3814 */
3815 mux_ent = conn_get_best_mux_entry(newsrv->mux_proto->token, PROTO_SIDE_BE, mode);
3816
3817 if (!mux_ent || !isteq(mux_ent->token, newsrv->mux_proto->token)) {
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003818 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for server '%s' at [%s:%d].\n",
3819 proxy_type_str(curproxy), curproxy->id,
3820 (int)newsrv->mux_proto->token.len,
3821 newsrv->mux_proto->token.ptr,
3822 newsrv->id, newsrv->conf.file, newsrv->conf.line);
3823 cfgerr++;
3824 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003825
3826 /* update the mux */
3827 newsrv->mux_proto = mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003828 }
Willy Tarreau4cdac162021-03-05 10:48:42 +01003829 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003830
Willy Tarreau4cdac162021-03-05 10:48:42 +01003831 /***********************************************************/
3832 /* At this point, target names have already been resolved. */
3833 /***********************************************************/
Willy Tarreau835daa12019-02-07 14:46:29 +01003834
Willy Tarreau4cdac162021-03-05 10:48:42 +01003835 /* we must finish to initialize certain things on the servers */
Willy Tarreau835daa12019-02-07 14:46:29 +01003836
Willy Tarreau4cdac162021-03-05 10:48:42 +01003837 list_for_each_entry(newsrv, &servers_list, global_list) {
3838 /* initialize idle conns lists */
Willy Tarreau430bf4a2021-03-04 09:45:32 +01003839 newsrv->per_thr = calloc(global.nbthread, sizeof(*newsrv->per_thr));
3840 if (!newsrv->per_thr) {
3841 ha_alert("parsing [%s:%d] : failed to allocate per-thread lists for server '%s'.\n",
3842 newsrv->conf.file, newsrv->conf.line, newsrv->id);
Willy Tarreau4cdac162021-03-05 10:48:42 +01003843 cfgerr++;
3844 continue;
3845 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003846
Willy Tarreau430bf4a2021-03-04 09:45:32 +01003847 for (i = 0; i < global.nbthread; i++) {
3848 newsrv->per_thr[i].idle_conns = EB_ROOT;
3849 newsrv->per_thr[i].safe_conns = EB_ROOT;
3850 newsrv->per_thr[i].avail_conns = EB_ROOT;
Willy Tarreaud4e78d82021-03-04 10:47:54 +01003851 MT_LIST_INIT(&newsrv->per_thr[i].streams);
Willy Tarreau430bf4a2021-03-04 09:45:32 +01003852 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003853
Willy Tarreau4cdac162021-03-05 10:48:42 +01003854 if (newsrv->max_idle_conns != 0) {
Amaury Denoyelle3efee652021-03-08 17:31:39 +01003855 newsrv->curr_idle_thr = calloc(global.nbthread, sizeof(*newsrv->curr_idle_thr));
3856 if (!newsrv->curr_idle_thr) {
3857 ha_alert("parsing [%s:%d] : failed to allocate idle connection tasks for server '%s'.\n",
3858 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3859 cfgerr++;
3860 continue;
3861 }
3862 }
3863 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003864
Amaury Denoyelle3efee652021-03-08 17:31:39 +01003865 idle_conn_task = task_new(MAX_THREADS_MASK);
3866 if (!idle_conn_task) {
3867 ha_alert("parsing : failed to allocate global idle connection task.\n");
3868 cfgerr++;
3869 }
3870 else {
3871 idle_conn_task->process = srv_cleanup_idle_conns;
3872 idle_conn_task->context = NULL;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003873
Amaury Denoyelle3efee652021-03-08 17:31:39 +01003874 for (i = 0; i < global.nbthread; i++) {
3875 idle_conns[i].cleanup_task = task_new(1UL << i);
3876 if (!idle_conns[i].cleanup_task) {
3877 ha_alert("parsing : failed to allocate idle connection tasks for thread '%d'.\n", i);
3878 cfgerr++;
3879 break;
Willy Tarreau4cdac162021-03-05 10:48:42 +01003880 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003881
Amaury Denoyelle3efee652021-03-08 17:31:39 +01003882 idle_conns[i].cleanup_task->process = srv_cleanup_toremove_conns;
3883 idle_conns[i].cleanup_task->context = NULL;
3884 HA_SPIN_INIT(&idle_conns[i].idle_conns_lock);
3885 MT_LIST_INIT(&idle_conns[i].toremove_conns);
Willy Tarreau835daa12019-02-07 14:46:29 +01003886 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003887 }
3888
Willy Tarreau419ead82014-09-16 13:41:21 +02003889 /* Check multi-process mode compatibility */
3890
Willy Tarreau4975d142021-03-13 11:00:33 +01003891 if (global.nbproc > 1 && global.cli_fe) {
3892 list_for_each_entry(bind_conf, &global.cli_fe->conf.bind, by_fe) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003893 unsigned long mask;
3894
Willy Tarreau4975d142021-03-13 11:00:33 +01003895 mask = proc_mask(global.cli_fe->bind_proc) && all_proc_mask;
Willy Tarreaue26993c2020-09-03 07:18:55 +02003896 mask &= proc_mask(bind_conf->settings.bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003897
3898 /* stop here if more than one process is used */
Willy Tarreau9504dd62018-10-15 09:37:03 +02003899 if (atleast2(mask))
Willy Tarreau419ead82014-09-16 13:41:21 +02003900 break;
3901 }
Willy Tarreau4975d142021-03-13 11:00:33 +01003902 if (&bind_conf->by_fe != &global.cli_fe->conf.bind) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003903 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 +02003904 }
3905 }
3906
3907 /* Make each frontend inherit bind-process from its listeners when not specified. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003908 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003909 if (curproxy->bind_proc)
3910 continue;
3911
3912 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3913 unsigned long mask;
3914
Willy Tarreaue26993c2020-09-03 07:18:55 +02003915 mask = proc_mask(bind_conf->settings.bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003916 curproxy->bind_proc |= mask;
3917 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003918 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003919 }
3920
Willy Tarreau4975d142021-03-13 11:00:33 +01003921 if (global.cli_fe) {
3922 list_for_each_entry(bind_conf, &global.cli_fe->conf.bind, by_fe) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003923 unsigned long mask;
3924
Willy Tarreaue26993c2020-09-03 07:18:55 +02003925 mask = bind_conf->settings.bind_proc ? bind_conf->settings.bind_proc : 0;
Willy Tarreau4975d142021-03-13 11:00:33 +01003926 global.cli_fe->bind_proc |= mask;
Willy Tarreau419ead82014-09-16 13:41:21 +02003927 }
Willy Tarreau4975d142021-03-13 11:00:33 +01003928 global.cli_fe->bind_proc = proc_mask(global.cli_fe->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003929 }
3930
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003931 /* propagate bindings from frontends to backends. Don't do it if there
3932 * are any fatal errors as we must not call it with unresolved proxies.
3933 */
3934 if (!cfgerr) {
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003935 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003936 if (curproxy->cap & PR_CAP_FE)
3937 propagate_processes(curproxy, NULL);
3938 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003939 }
3940
3941 /* Bind each unbound backend to all processes when not specified. */
Willy Tarreau6daac192019-02-02 17:39:53 +01003942 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
3943 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003944
3945 /*******************************************************/
3946 /* At this step, all proxies have a non-null bind_proc */
3947 /*******************************************************/
3948
3949 /* perform the final checks before creating tasks */
3950
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003951 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003952 struct listener *listener;
3953 unsigned int next_id;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003954
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003955 /* Configure SSL for each bind line.
3956 * Note: if configuration fails at some point, the ->ctx member
3957 * remains NULL so that listeners can later detach.
3958 */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003959 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau55d37912016-12-21 23:38:39 +01003960 if (bind_conf->xprt->prepare_bind_conf &&
3961 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003962 cfgerr++;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003963 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003964
Willy Tarreaue6b98942007-10-29 01:09:36 +01003965 /* adjust this proxy's listeners */
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003966 next_id = 1;
Willy Tarreau4348fad2012-09-20 16:48:07 +02003967 list_for_each_entry(listener, &curproxy->conf.listeners, by_fe) {
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003968 int nbproc;
3969
3970 nbproc = my_popcountl(curproxy->bind_proc &
Willy Tarreaue26993c2020-09-03 07:18:55 +02003971 (listener->bind_conf->settings.bind_proc ? listener->bind_conf->settings.bind_proc : curproxy->bind_proc) &
Willy Tarreaua38a7172019-02-02 17:11:28 +01003972 all_proc_mask);
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003973
3974 if (!nbproc) /* no intersection between listener and frontend */
3975 nbproc = 1;
3976
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003977 if (!listener->luid) {
3978 /* listener ID not set, use automatic numbering with first
3979 * spare entry starting with next_luid.
3980 */
3981 next_id = get_next_id(&curproxy->conf.used_listener_id, next_id);
3982 listener->conf.id.key = listener->luid = next_id;
3983 eb32_insert(&curproxy->conf.used_listener_id, &listener->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003984 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01003985 next_id++;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003986
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003987 /* enable separate counters */
3988 if (curproxy->options2 & PR_O2_SOCKSTAT) {
Willy Tarreauae9bea02016-11-25 14:44:52 +01003989 listener->counters = calloc(1, sizeof(*listener->counters));
Willy Tarreau19d14ef2012-10-29 16:51:55 +01003990 if (!listener->name)
3991 memprintf(&listener->name, "sock-%d", listener->luid);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003992 }
Willy Tarreau81796be2012-09-22 19:11:47 +02003993
Willy Tarreaue6b98942007-10-29 01:09:36 +01003994 if (curproxy->options & PR_O_TCP_NOLING)
3995 listener->options |= LI_O_NOLINGER;
Willy Tarreau16a21472012-11-19 12:39:59 +01003996 if (!listener->maxaccept)
Willy Tarreau66161322021-02-19 15:50:27 +01003997 listener->maxaccept = global.tune.maxaccept ? global.tune.maxaccept : MAX_ACCEPT;
Willy Tarreau16a21472012-11-19 12:39:59 +01003998
3999 /* we want to have an optimal behaviour on single process mode to
4000 * maximize the work at once, but in multi-process we want to keep
4001 * some fairness between processes, so we target half of the max
4002 * number of events to be balanced over all the processes the proxy
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05004003 * is bound to. Remember that maxaccept = -1 must be kept as it is
Willy Tarreau16a21472012-11-19 12:39:59 +01004004 * used to disable the limit.
4005 */
Christopher Faulet02f3cf12019-04-30 14:08:41 +02004006 if (listener->maxaccept > 0 && nbproc > 1) {
4007 listener->maxaccept = (listener->maxaccept + 1) / 2;
Willy Tarreau16a21472012-11-19 12:39:59 +01004008 listener->maxaccept = (listener->maxaccept + nbproc - 1) / nbproc;
4009 }
4010
Willy Tarreau9903f0e2015-04-04 18:50:31 +02004011 listener->accept = session_accept_fd;
Willy Tarreauc1a21672009-08-16 22:37:44 +02004012 listener->analysers |= curproxy->fe_req_ana;
Willy Tarreau10b688f2015-03-13 16:43:12 +01004013 listener->default_target = curproxy->default_target;
Willy Tarreau3bc13772008-12-07 11:50:35 +01004014
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02004015 if (!LIST_ISEMPTY(&curproxy->tcp_req.l4_rules))
Willy Tarreau7d9736f2016-10-21 16:34:21 +02004016 listener->options |= LI_O_TCP_L4_RULES;
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02004017
Willy Tarreau620408f2016-10-21 16:37:51 +02004018 if (!LIST_ISEMPTY(&curproxy->tcp_req.l5_rules))
4019 listener->options |= LI_O_TCP_L5_RULES;
4020
Willy Tarreau9ea05a72009-06-14 12:07:01 +02004021 /* smart accept mode is automatic in HTTP mode */
4022 if ((curproxy->options2 & PR_O2_SMARTACC) ||
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004023 ((curproxy->mode == PR_MODE_HTTP || listener->bind_conf->is_ssl) &&
Willy Tarreau9ea05a72009-06-14 12:07:01 +02004024 !(curproxy->no_options2 & PR_O2_SMARTACC)))
4025 listener->options |= LI_O_NOQUICKACK;
Willy Tarreaue6b98942007-10-29 01:09:36 +01004026 }
4027
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004028 /* Release unused SSL configs */
4029 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau795cdab2016-12-22 17:30:54 +01004030 if (!bind_conf->is_ssl && bind_conf->xprt->destroy_bind_conf)
4031 bind_conf->xprt->destroy_bind_conf(bind_conf);
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004032 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02004033
Willy Tarreaua38a7172019-02-02 17:11:28 +01004034 if (atleast2(curproxy->bind_proc & all_proc_mask)) {
Willy Tarreau102df612014-05-07 23:56:38 +02004035 if (curproxy->uri_auth) {
Willy Tarreaueb791e02014-09-16 15:11:04 +02004036 int count, maxproc = 0;
4037
4038 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreaue26993c2020-09-03 07:18:55 +02004039 count = my_popcountl(bind_conf->settings.bind_proc);
Willy Tarreaueb791e02014-09-16 15:11:04 +02004040 if (count > maxproc)
4041 maxproc = count;
4042 }
4043 /* backends have 0, frontends have 1 or more */
4044 if (maxproc != 1)
Christopher Faulet767a84b2017-11-24 16:50:31 +01004045 ha_warning("Proxy '%s': in multi-process mode, stats will be"
4046 " limited to process assigned to the current request.\n",
4047 curproxy->id);
Willy Tarreaueb791e02014-09-16 15:11:04 +02004048
Willy Tarreau102df612014-05-07 23:56:38 +02004049 if (!LIST_ISEMPTY(&curproxy->uri_auth->admin_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004050 ha_warning("Proxy '%s': stats admin will not work correctly in multi-process mode.\n",
4051 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01004052 }
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01004053 }
Willy Tarreau102df612014-05-07 23:56:38 +02004054 if (!LIST_ISEMPTY(&curproxy->sticking_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004055 ha_warning("Proxy '%s': sticking rules will not work correctly in multi-process mode.\n",
4056 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01004057 }
4058 }
Willy Tarreau918ff602011-07-25 16:33:49 +02004059
4060 /* create the task associated with the proxy */
Emeric Brunc60def82017-09-27 14:59:38 +02004061 curproxy->task = task_new(MAX_THREADS_MASK);
Willy Tarreau918ff602011-07-25 16:33:49 +02004062 if (curproxy->task) {
4063 curproxy->task->context = curproxy;
4064 curproxy->task->process = manage_proxy;
Willy Tarreau918ff602011-07-25 16:33:49 +02004065 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004066 ha_alert("Proxy '%s': no more memory when trying to allocate the management task\n",
4067 curproxy->id);
Willy Tarreau918ff602011-07-25 16:33:49 +02004068 cfgerr++;
4069 }
Willy Tarreaub369a042014-09-16 13:21:03 +02004070 }
4071
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01004072 /*
4073 * Recount currently required checks.
4074 */
4075
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004076 for (curproxy=proxies_list; curproxy; curproxy=curproxy->next) {
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01004077 int optnum;
4078
Willy Tarreau66aa61f2009-01-18 21:44:07 +01004079 for (optnum = 0; cfg_opts[optnum].name; optnum++)
4080 if (curproxy->options & cfg_opts[optnum].val)
4081 global.last_checks |= cfg_opts[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01004082
Willy Tarreau66aa61f2009-01-18 21:44:07 +01004083 for (optnum = 0; cfg_opts2[optnum].name; optnum++)
4084 if (curproxy->options2 & cfg_opts2[optnum].val)
4085 global.last_checks |= cfg_opts2[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01004086 }
4087
Willy Tarreau0fca4832015-05-01 19:12:05 +02004088 /* compute the required process bindings for the peers */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004089 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004090 if (curproxy->table && curproxy->table->peers.p)
4091 curproxy->table->peers.p->peers_fe->bind_proc |= curproxy->bind_proc;
Willy Tarreau0fca4832015-05-01 19:12:05 +02004092
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01004093 /* compute the required process bindings for the peers from <stktables_list>
4094 * for all the stick-tables, the ones coming with "peers" sections included.
4095 */
4096 for (t = stktables_list; t; t = t->next) {
4097 struct proxy *p;
4098
4099 for (p = t->proxies_list; p; p = p->next_stkt_ref) {
4100 if (t->peers.p && t->peers.p->peers_fe) {
4101 t->peers.p->peers_fe->bind_proc |= p->bind_proc;
4102 }
4103 }
4104 }
4105
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02004106 if (cfg_peers) {
4107 struct peers *curpeers = cfg_peers, **last;
Willy Tarreau122541c2011-09-07 21:24:49 +02004108 struct peer *p, *pb;
4109
William Lallemanda2cfd7e2020-03-24 16:02:48 +01004110 /* In the case the peers frontend was not initialized by a
4111 stick-table used in the configuration, set its bind_proc
4112 by default to the first process. */
4113 while (curpeers) {
William Lallemand3ef2d562020-03-24 16:42:15 +01004114 if (curpeers->peers_fe) {
4115 if (curpeers->peers_fe->bind_proc == 0)
4116 curpeers->peers_fe->bind_proc = 1;
4117 }
William Lallemanda2cfd7e2020-03-24 16:02:48 +01004118 curpeers = curpeers->next;
4119 }
4120
4121 curpeers = cfg_peers;
Willy Tarreau1e273012015-05-01 19:15:17 +02004122 /* Remove all peers sections which don't have a valid listener,
4123 * which are not used by any table, or which are bound to more
4124 * than one process.
Willy Tarreau122541c2011-09-07 21:24:49 +02004125 */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02004126 last = &cfg_peers;
Willy Tarreau122541c2011-09-07 21:24:49 +02004127 while (*last) {
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01004128 struct stktable *t;
Willy Tarreau122541c2011-09-07 21:24:49 +02004129 curpeers = *last;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004130
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02004131 if (curpeers->disabled) {
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004132 /* the "disabled" keyword was present */
4133 if (curpeers->peers_fe)
4134 stop_proxy(curpeers->peers_fe);
4135 curpeers->peers_fe = NULL;
4136 }
Frédéric Lécaille5a4fe5a2019-10-04 08:30:04 +02004137 else if (!curpeers->peers_fe || !curpeers->peers_fe->id) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004138 ha_warning("Removing incomplete section 'peers %s' (no peer named '%s').\n",
4139 curpeers->id, localpeer);
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01004140 if (curpeers->peers_fe)
4141 stop_proxy(curpeers->peers_fe);
4142 curpeers->peers_fe = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004143 }
Willy Tarreau9504dd62018-10-15 09:37:03 +02004144 else if (atleast2(curpeers->peers_fe->bind_proc)) {
Willy Tarreau1e273012015-05-01 19:15:17 +02004145 /* either it's totally stopped or too much used */
4146 if (curpeers->peers_fe->bind_proc) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004147 ha_alert("Peers section '%s': peers referenced by sections "
4148 "running in different processes (%d different ones). "
4149 "Check global.nbproc and all tables' bind-process "
4150 "settings.\n", curpeers->id, my_popcountl(curpeers->peers_fe->bind_proc));
Willy Tarreau1e273012015-05-01 19:15:17 +02004151 cfgerr++;
4152 }
4153 stop_proxy(curpeers->peers_fe);
4154 curpeers->peers_fe = NULL;
4155 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004156 else {
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01004157 /* Initializes the transport layer of the server part of all the peers belonging to
4158 * <curpeers> section if required.
4159 * Note that ->srv is used by the local peer of a new process to connect to the local peer
4160 * of an old process.
4161 */
Frédéric Lécaille1055e682018-04-26 14:35:21 +02004162 p = curpeers->remote;
4163 while (p) {
Frédéric Lécaille355b2032019-01-11 14:06:12 +01004164 if (p->srv) {
Christopher Fauletf61f33a2020-03-27 18:55:49 +01004165 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 +01004166 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(p->srv);
4167 }
Frédéric Lécaille1055e682018-04-26 14:35:21 +02004168 p = p->next;
4169 }
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01004170 /* Configure the SSL bindings of the local peer if required. */
4171 if (!LIST_ISEMPTY(&curpeers->peers_fe->conf.bind)) {
4172 struct list *l;
4173 struct bind_conf *bind_conf;
4174
4175 l = &curpeers->peers_fe->conf.bind;
4176 bind_conf = LIST_ELEM(l->n, typeof(bind_conf), by_fe);
4177 if (bind_conf->xprt->prepare_bind_conf &&
4178 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
4179 cfgerr++;
4180 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02004181 if (!peers_init_sync(curpeers) || !peers_alloc_dcache(curpeers)) {
Willy Tarreaud9443442018-10-15 11:18:03 +02004182 ha_alert("Peers section '%s': out of memory, giving up on peers.\n",
4183 curpeers->id);
4184 cfgerr++;
4185 break;
4186 }
Willy Tarreau122541c2011-09-07 21:24:49 +02004187 last = &curpeers->next;
4188 continue;
4189 }
4190
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004191 /* clean what has been detected above */
Willy Tarreau122541c2011-09-07 21:24:49 +02004192 p = curpeers->remote;
4193 while (p) {
4194 pb = p->next;
4195 free(p->id);
4196 free(p);
4197 p = pb;
4198 }
4199
4200 /* Destroy and unlink this curpeers section.
4201 * Note: curpeers is backed up into *last.
4202 */
4203 free(curpeers->id);
4204 curpeers = curpeers->next;
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01004205 /* Reset any refereance to this peers section in the list of stick-tables */
4206 for (t = stktables_list; t; t = t->next) {
4207 if (t->peers.p && t->peers.p == *last)
4208 t->peers.p = NULL;
4209 }
Willy Tarreau122541c2011-09-07 21:24:49 +02004210 free(*last);
4211 *last = curpeers;
4212 }
4213 }
4214
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004215 for (t = stktables_list; t; t = t->next) {
4216 if (t->proxy)
4217 continue;
4218 if (!stktable_init(t)) {
4219 ha_alert("Proxy '%s': failed to initialize stick-table.\n", t->id);
4220 cfgerr++;
4221 }
4222 }
4223
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004224 /* initialize stick-tables on backend capable proxies. This must not
4225 * be done earlier because the data size may be discovered while parsing
4226 * other proxies.
4227 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004228 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauc3914d42020-09-24 08:39:22 +02004229 if (curproxy->disabled || !curproxy->table)
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004230 continue;
4231
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004232 if (!stktable_init(curproxy->table)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004233 ha_alert("Proxy '%s': failed to initialize stick-table.\n", curproxy->id);
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004234 cfgerr++;
4235 }
4236 }
4237
Simon Horman0d16a402015-01-30 11:22:58 +09004238 if (mailers) {
4239 struct mailers *curmailers = mailers, **last;
4240 struct mailer *m, *mb;
4241
4242 /* Remove all mailers sections which don't have a valid listener.
4243 * This can happen when a mailers section is never referenced.
4244 */
4245 last = &mailers;
4246 while (*last) {
4247 curmailers = *last;
4248 if (curmailers->users) {
4249 last = &curmailers->next;
4250 continue;
4251 }
4252
Christopher Faulet767a84b2017-11-24 16:50:31 +01004253 ha_warning("Removing incomplete section 'mailers %s'.\n",
4254 curmailers->id);
Simon Horman0d16a402015-01-30 11:22:58 +09004255
4256 m = curmailers->mailer_list;
4257 while (m) {
4258 mb = m->next;
4259 free(m->id);
4260 free(m);
4261 m = mb;
4262 }
4263
4264 /* Destroy and unlink this curmailers section.
4265 * Note: curmailers is backed up into *last.
4266 */
4267 free(curmailers->id);
4268 curmailers = curmailers->next;
4269 free(*last);
4270 *last = curmailers;
4271 }
4272 }
4273
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004274 /* Update server_state_file_name to backend name if backend is supposed to use
4275 * a server-state file locally defined and none has been provided */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004276 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004277 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_LOCAL &&
4278 curproxy->server_state_file_name == NULL)
4279 curproxy->server_state_file_name = strdup(curproxy->id);
4280 }
4281
Emeric Brun750fe792020-12-23 16:51:12 +01004282 list_for_each_entry(curr_resolvers, &sec_resolvers, list) {
Ben Draut054fbee2018-04-13 15:43:04 -06004283 if (LIST_ISEMPTY(&curr_resolvers->nameservers)) {
4284 ha_warning("config : resolvers '%s' [%s:%d] has no nameservers configured!\n",
4285 curr_resolvers->id, curr_resolvers->conf.file,
4286 curr_resolvers->conf.line);
4287 err_code |= ERR_WARN;
4288 }
4289 }
4290
William Lallemand48b4bb42017-10-23 14:36:34 +02004291 list_for_each_entry(postparser, &postparsers, list) {
4292 if (postparser->func)
4293 cfgerr += postparser->func();
4294 }
4295
Willy Tarreaubb925012009-07-23 13:36:36 +02004296 if (cfgerr > 0)
4297 err_code |= ERR_ALERT | ERR_FATAL;
4298 out:
4299 return err_code;
Willy Tarreaubaaee002006-06-26 02:48:02 +02004300}
4301
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004302/*
4303 * Registers the CFG keyword list <kwl> as a list of valid keywords for next
4304 * parsing sessions.
4305 */
4306void cfg_register_keywords(struct cfg_kw_list *kwl)
4307{
Willy Tarreau2b718102021-04-21 07:32:39 +02004308 LIST_APPEND(&cfg_keywords.list, &kwl->list);
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004309}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004310
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004311/*
4312 * Unregisters the CFG keyword list <kwl> from the list of valid keywords.
4313 */
4314void cfg_unregister_keywords(struct cfg_kw_list *kwl)
4315{
Willy Tarreau2b718102021-04-21 07:32:39 +02004316 LIST_DELETE(&kwl->list);
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004317 LIST_INIT(&kwl->list);
4318}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004319
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004320/* this function register new section in the haproxy configuration file.
4321 * <section_name> is the name of this new section and <section_parser>
4322 * is the called parser. If two section declaration have the same name,
4323 * only the first declared is used.
4324 */
4325int cfg_register_section(char *section_name,
William Lallemandd2ff56d2017-10-16 11:06:50 +02004326 int (*section_parser)(const char *, int, char **, int),
4327 int (*post_section_parser)())
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004328{
4329 struct cfg_section *cs;
4330
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004331 list_for_each_entry(cs, &sections, list) {
4332 if (strcmp(cs->section_name, section_name) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004333 ha_alert("register section '%s': already registered.\n", section_name);
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004334 return 0;
4335 }
4336 }
4337
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004338 cs = calloc(1, sizeof(*cs));
4339 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004340 ha_alert("register section '%s': out of memory.\n", section_name);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004341 return 0;
4342 }
4343
4344 cs->section_name = section_name;
4345 cs->section_parser = section_parser;
William Lallemandd2ff56d2017-10-16 11:06:50 +02004346 cs->post_section_parser = post_section_parser;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004347
Willy Tarreau2b718102021-04-21 07:32:39 +02004348 LIST_APPEND(&sections, &cs->list);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004349
4350 return 1;
4351}
4352
William Lallemand48b4bb42017-10-23 14:36:34 +02004353/* this function register a new function which will be called once the haproxy
4354 * configuration file has been parsed. It's useful to check dependencies
4355 * between sections or to resolve items once everything is parsed.
4356 */
4357int cfg_register_postparser(char *name, int (*func)())
4358{
4359 struct cfg_postparser *cp;
4360
4361 cp = calloc(1, sizeof(*cp));
4362 if (!cp) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004363 ha_alert("register postparser '%s': out of memory.\n", name);
William Lallemand48b4bb42017-10-23 14:36:34 +02004364 return 0;
4365 }
4366 cp->name = name;
4367 cp->func = func;
4368
Willy Tarreau2b718102021-04-21 07:32:39 +02004369 LIST_APPEND(&postparsers, &cp->list);
William Lallemand48b4bb42017-10-23 14:36:34 +02004370
4371 return 1;
4372}
4373
Willy Tarreaubaaee002006-06-26 02:48:02 +02004374/*
David Carlier845efb52015-09-25 11:49:18 +01004375 * free all config section entries
4376 */
4377void cfg_unregister_sections(void)
4378{
4379 struct cfg_section *cs, *ics;
4380
4381 list_for_each_entry_safe(cs, ics, &sections, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004382 LIST_DELETE(&cs->list);
David Carlier845efb52015-09-25 11:49:18 +01004383 free(cs);
4384 }
4385}
4386
Christopher Faulet7110b402016-10-26 11:09:44 +02004387void cfg_backup_sections(struct list *backup_sections)
4388{
4389 struct cfg_section *cs, *ics;
4390
4391 list_for_each_entry_safe(cs, ics, &sections, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004392 LIST_DELETE(&cs->list);
4393 LIST_APPEND(backup_sections, &cs->list);
Christopher Faulet7110b402016-10-26 11:09:44 +02004394 }
4395}
4396
4397void cfg_restore_sections(struct list *backup_sections)
4398{
4399 struct cfg_section *cs, *ics;
4400
4401 list_for_each_entry_safe(cs, ics, backup_sections, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02004402 LIST_DELETE(&cs->list);
4403 LIST_APPEND(&sections, &cs->list);
Christopher Faulet7110b402016-10-26 11:09:44 +02004404 }
4405}
4406
Willy Tarreaue6552512018-11-26 11:33:13 +01004407/* these are the config sections handled by default */
4408REGISTER_CONFIG_SECTION("listen", cfg_parse_listen, NULL);
4409REGISTER_CONFIG_SECTION("frontend", cfg_parse_listen, NULL);
4410REGISTER_CONFIG_SECTION("backend", cfg_parse_listen, NULL);
4411REGISTER_CONFIG_SECTION("defaults", cfg_parse_listen, NULL);
4412REGISTER_CONFIG_SECTION("global", cfg_parse_global, NULL);
4413REGISTER_CONFIG_SECTION("userlist", cfg_parse_users, NULL);
4414REGISTER_CONFIG_SECTION("peers", cfg_parse_peers, NULL);
4415REGISTER_CONFIG_SECTION("mailers", cfg_parse_mailers, NULL);
4416REGISTER_CONFIG_SECTION("namespace_list", cfg_parse_netns, NULL);
Willy Tarreau659fbf02016-05-26 17:55:28 +02004417
Willy Tarreau8a022d52021-04-27 20:29:11 +02004418static struct cfg_kw_list cfg_kws = {{ },{
4419 { CFG_GLOBAL, "default-path", cfg_parse_global_def_path },
4420 { /* END */ }
4421}};
4422
4423INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
4424
David Carlier845efb52015-09-25 11:49:18 +01004425/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02004426 * Local variables:
4427 * c-indent-level: 8
4428 * c-basic-offset: 8
4429 * End:
4430 */