blob: 317ef2a23eeefbfafb551002f26b9dd389f46237 [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
Willy Tarreaubaaee002006-06-26 02:48:02 +020023#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <netdb.h>
27#include <ctype.h>
Willy Tarreau95c20ac2007-03-25 15:39:23 +020028#include <pwd.h>
29#include <grp.h>
Willy Tarreau0b4ed902007-03-26 00:18:40 +020030#include <errno.h>
Willy Tarreau3f49b302007-06-11 00:29:26 +020031#include <sys/types.h>
32#include <sys/stat.h>
33#include <fcntl.h>
34#include <unistd.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020035
Willy Tarreaudcc048a2020-06-04 19:11:43 +020036#include <haproxy/acl.h>
Willy Tarreau122eba92020-06-04 10:15:32 +020037#include <haproxy/action-t.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020038#include <haproxy/api.h>
Willy Tarreauac13aea2020-06-04 10:36:03 +020039#include <haproxy/auth.h>
Willy Tarreau49801602020-06-04 22:50:02 +020040#include <haproxy/backend.h>
Willy Tarreau278161c2020-06-04 11:18:28 +020041#include <haproxy/capture.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020042#include <haproxy/cfgparse.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020043#include <haproxy/channel.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020044#include <haproxy/check.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020045#include <haproxy/chunk.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020046#include <haproxy/connection.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020047#include <haproxy/errors.h>
Willy Tarreauc7babd82020-06-04 21:29:29 +020048#include <haproxy/filters.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020049#include <haproxy/frontend.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020050#include <haproxy/global.h>
Willy Tarreauc2b1ff02020-06-04 21:21:03 +020051#include <haproxy/http_ana.h>
Willy Tarreauc761f842020-06-04 11:40:28 +020052#include <haproxy/http_rules.h>
Willy Tarreaufbe8da32020-06-04 14:34:27 +020053#include <haproxy/lb_chash.h>
Willy Tarreaub5fc3bf2020-06-04 14:37:38 +020054#include <haproxy/lb_fas.h>
Willy Tarreau02549412020-06-04 14:41:04 +020055#include <haproxy/lb_fwlc.h>
Willy Tarreau546ba422020-06-04 14:45:03 +020056#include <haproxy/lb_fwrr.h>
Willy Tarreau28671592020-06-04 20:22:59 +020057#include <haproxy/lb_map.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020058#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020059#include <haproxy/log.h>
Willy Tarreaucee013e2020-06-05 11:40:38 +020060#include <haproxy/mailers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020061#include <haproxy/namespace.h>
Willy Tarreau8efbdfb2020-06-04 11:29:21 +020062#include <haproxy/obj_type-t.h>
Willy Tarreau3c2a7c22020-06-04 18:38:21 +020063#include <haproxy/peers-t.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020064#include <haproxy/peers.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020065#include <haproxy/pool.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020066#include <haproxy/protocol.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020067#include <haproxy/proxy.h>
Emeric Brunc9437992021-02-12 19:42:55 +010068#include <haproxy/resolvers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020069#include <haproxy/sample.h>
70#include <haproxy/server.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020071#include <haproxy/session.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020072#include <haproxy/stats-t.h>
Willy Tarreau872f2ea2020-06-04 18:46:44 +020073#include <haproxy/stick_table.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020074#include <haproxy/stream.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020075#include <haproxy/task.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020076#include <haproxy/tcp_rules.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020077#include <haproxy/thread.h>
78#include <haproxy/time.h>
79#include <haproxy/tools.h>
80#include <haproxy/uri_auth-t.h>
Frédéric Lécaille884f2e92020-11-23 14:23:21 +010081#include <haproxy/xprt_quic.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020082
83
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +010084/* Used to chain configuration sections definitions. This list
85 * stores struct cfg_section
86 */
87struct list sections = LIST_HEAD_INIT(sections);
88
William Lallemand48b4bb42017-10-23 14:36:34 +020089struct list postparsers = LIST_HEAD_INIT(postparsers);
90
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +010091char *cursection = NULL;
Willy Tarreauc8d5b952019-02-27 17:25:52 +010092int cfg_maxpconn = 0; /* # of simultaneous connections per proxy (-N) */
Willy Tarreau5af24ef2009-03-15 15:23:16 +010093int cfg_maxconn = 0; /* # of simultaneous connections, (-n) */
Christopher Faulet79bdef32016-11-04 22:36:15 +010094char *cfg_scope = NULL; /* the current scope during the configuration parsing */
Willy Tarreaubaaee002006-06-26 02:48:02 +020095
Willy Tarreau5b2c3362008-07-09 19:39:06 +020096/* List head of all known configuration keywords */
Willy Tarreau36b9e222018-11-11 15:19:52 +010097struct cfg_kw_list cfg_keywords = {
Willy Tarreau5b2c3362008-07-09 19:39:06 +020098 .list = LIST_HEAD_INIT(cfg_keywords.list)
99};
100
Willy Tarreau4b103022021-02-12 17:59:10 +0100101/* nested if/elif/else/endif block states */
102enum nested_cond_state {
103 NESTED_COND_IF_TAKE, // "if" with a true condition
104 NESTED_COND_IF_DROP, // "if" with a false condition
105 NESTED_COND_IF_SKIP, // "if" masked by an outer false condition
106
107 NESTED_COND_ELIF_TAKE, // "elif" with a true condition from a false one
108 NESTED_COND_ELIF_DROP, // "elif" with a false condition from a false one
109 NESTED_COND_ELIF_SKIP, // "elif" masked by an outer false condition or a previously taken if
110
111 NESTED_COND_ELSE_TAKE, // taken "else" after an if false condition
112 NESTED_COND_ELSE_DROP, // "else" masked by outer false condition or an if true condition
113};
114
115/* 100 levels of nested conditions should already be sufficient */
116#define MAXNESTEDCONDS 100
117
Willy Tarreaubaaee002006-06-26 02:48:02 +0200118/*
119 * converts <str> to a list of listeners which are dynamically allocated.
120 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
121 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
122 * - <port> is a numerical port from 1 to 65535 ;
123 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
124 * This can be repeated as many times as necessary, separated by a coma.
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200125 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
126 * not NULL, it must be a valid pointer to either NULL or a freeable area that
127 * will be replaced with an error message.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200128 */
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200129int 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 +0200130{
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200131 struct protocol *proto;
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100132 char *next, *dupstr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200133 int port, end;
134
135 next = dupstr = strdup(str);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200136
Willy Tarreaubaaee002006-06-26 02:48:02 +0200137 while (next && *next) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200138 struct sockaddr_storage *ss2;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100139 int fd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200140
141 str = next;
142 /* 1) look for the end of the first address */
Krzysztof Piotr Oledzki52d522b2009-01-27 16:57:08 +0100143 if ((next = strchr(str, ',')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200144 *next++ = 0;
145 }
146
Willy Tarreau5fc93282020-09-16 18:25:03 +0200147 ss2 = str2sa_range(str, NULL, &port, &end, &fd, &proto, err,
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200148 curproxy == global.stats_fe ? NULL : global.unix_bind.prefix,
Willy Tarreau32819932020-09-04 15:53:16 +0200149 NULL, PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_PORT_RANGE |
Willy Tarreau5e1779a2020-09-16 16:28:08 +0200150 PA_O_SOCKET_FD | PA_O_STREAM | PA_O_XPRT);
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100151 if (!ss2)
152 goto fail;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200153
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100154 /* OK the address looks correct */
Frédéric Lécaille884f2e92020-11-23 14:23:21 +0100155
156#ifdef USE_QUIC
157 /* The transport layer automatically switches to QUIC when QUIC
158 * is selected, regardless of bind_conf settings. We then need
159 * to initialize QUIC params.
160 */
161 if (proto->sock_type == SOCK_DGRAM && proto->ctrl_type == SOCK_STREAM) {
162 bind_conf->xprt = xprt_get(XPRT_QUIC);
163 quic_transport_params_init(&bind_conf->quic_params, 1);
164 }
165#endif
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200166 if (!create_listeners(bind_conf, ss2, port, end, fd, proto, err)) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200167 memprintf(err, "%s for address '%s'.\n", *err, str);
168 goto fail;
169 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200170 } /* end while(next) */
171 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200172 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200173 fail:
174 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200175 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200176}
177
William Lallemand6e62fb62015-04-28 16:55:23 +0200178/*
Willy Tarreauaa333122020-09-16 15:13:04 +0200179 * converts <str> to a list of datagram-oriented listeners which are dynamically
180 * allocated.
181 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
182 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
183 * - <port> is a numerical port from 1 to 65535 ;
184 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
185 * This can be repeated as many times as necessary, separated by a coma.
186 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
187 * not NULL, it must be a valid pointer to either NULL or a freeable area that
188 * will be replaced with an error message.
189 */
190int str2receiver(char *str, struct proxy *curproxy, struct bind_conf *bind_conf, const char *file, int line, char **err)
191{
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200192 struct protocol *proto;
Willy Tarreauaa333122020-09-16 15:13:04 +0200193 char *next, *dupstr;
194 int port, end;
195
196 next = dupstr = strdup(str);
197
198 while (next && *next) {
199 struct sockaddr_storage *ss2;
200 int fd = -1;
201
202 str = next;
203 /* 1) look for the end of the first address */
204 if ((next = strchr(str, ',')) != NULL) {
205 *next++ = 0;
206 }
207
Willy Tarreau5fc93282020-09-16 18:25:03 +0200208 ss2 = str2sa_range(str, NULL, &port, &end, &fd, &proto, err,
Willy Tarreauaa333122020-09-16 15:13:04 +0200209 curproxy == global.stats_fe ? NULL : global.unix_bind.prefix,
210 NULL, PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_PORT_RANGE |
211 PA_O_SOCKET_FD | PA_O_DGRAM | PA_O_XPRT);
212 if (!ss2)
213 goto fail;
214
215 /* OK the address looks correct */
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200216 if (!create_listeners(bind_conf, ss2, port, end, fd, proto, err)) {
Willy Tarreauaa333122020-09-16 15:13:04 +0200217 memprintf(err, "%s for address '%s'.\n", *err, str);
218 goto fail;
219 }
220 } /* end while(next) */
221 free(dupstr);
222 return 1;
223 fail:
224 free(dupstr);
225 return 0;
226}
227
228/*
Willy Tarreauece9b072016-12-21 22:41:44 +0100229 * Report an error in <msg> when there are too many arguments. This version is
230 * intended to be used by keyword parsers so that the message will be included
231 * into the general error message. The index is the current keyword in args.
232 * Return 0 if the number of argument is correct, otherwise build a message and
233 * return 1. Fill err_code with an ERR_ALERT and an ERR_FATAL if not null. The
234 * message may also be null, it will simply not be produced (useful to check only).
235 * <msg> and <err_code> are only affected on error.
236 */
237int too_many_args_idx(int maxarg, int index, char **args, char **msg, int *err_code)
238{
239 int i;
240
241 if (!*args[index + maxarg + 1])
242 return 0;
243
244 if (msg) {
245 *msg = NULL;
246 memprintf(msg, "%s", args[0]);
247 for (i = 1; i <= index; i++)
248 memprintf(msg, "%s %s", *msg, args[i]);
249
250 memprintf(msg, "'%s' cannot handle unexpected argument '%s'.", *msg, args[index + maxarg + 1]);
251 }
252 if (err_code)
253 *err_code |= ERR_ALERT | ERR_FATAL;
254
255 return 1;
256}
257
258/*
259 * same as too_many_args_idx with a 0 index
260 */
261int too_many_args(int maxarg, char **args, char **msg, int *err_code)
262{
263 return too_many_args_idx(maxarg, 0, args, msg, err_code);
264}
265
266/*
William Lallemand6e62fb62015-04-28 16:55:23 +0200267 * Report a fatal Alert when there is too much arguments
268 * The index is the current keyword in args
269 * Return 0 if the number of argument is correct, otherwise emit an alert and return 1
270 * Fill err_code with an ERR_ALERT and an ERR_FATAL
271 */
272int alertif_too_many_args_idx(int maxarg, int index, const char *file, int linenum, char **args, int *err_code)
273{
274 char *kw = NULL;
275 int i;
276
277 if (!*args[index + maxarg + 1])
278 return 0;
279
280 memprintf(&kw, "%s", args[0]);
281 for (i = 1; i <= index; i++) {
282 memprintf(&kw, "%s %s", kw, args[i]);
283 }
284
Christopher Faulet767a84b2017-11-24 16:50:31 +0100285 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 +0200286 free(kw);
287 *err_code |= ERR_ALERT | ERR_FATAL;
288 return 1;
289}
290
291/*
292 * same as alertif_too_many_args_idx with a 0 index
293 */
294int alertif_too_many_args(int maxarg, const char *file, int linenum, char **args, int *err_code)
295{
296 return alertif_too_many_args_idx(maxarg, 0, file, linenum, args, err_code);
297}
298
Willy Tarreau61d18892009-03-31 10:49:21 +0200299
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100300/* Report it if a request ACL condition uses some keywords that are incompatible
301 * with the place where the ACL is used. It returns either 0 or ERR_WARN so that
302 * its result can be or'ed with err_code. Note that <cond> may be NULL and then
303 * will be ignored.
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100304 */
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100305int warnif_cond_conflicts(const struct acl_cond *cond, unsigned int where, const char *file, int line)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100306{
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100307 const struct acl *acl;
Willy Tarreau93fddf12013-03-31 22:59:32 +0200308 const char *kw;
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100309
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100310 if (!cond)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100311 return 0;
312
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100313 acl = acl_cond_conflicts(cond, where);
314 if (acl) {
315 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100316 ha_warning("parsing [%s:%d] : acl '%s' will never match because it only involves keywords that are incompatible with '%s'\n",
317 file, line, acl->name, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100318 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100319 ha_warning("parsing [%s:%d] : anonymous acl will never match because it uses keyword '%s' which is incompatible with '%s'\n",
320 file, line, LIST_ELEM(acl->expr.n, struct acl_expr *, list)->kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100321 return ERR_WARN;
322 }
323 if (!acl_cond_kw_conflicts(cond, where, &acl, &kw))
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100324 return 0;
325
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100326 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100327 ha_warning("parsing [%s:%d] : acl '%s' involves keywords '%s' which is incompatible with '%s'\n",
328 file, line, acl->name, kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100329 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100330 ha_warning("parsing [%s:%d] : anonymous acl involves keyword '%s' which is incompatible with '%s'\n",
331 file, line, kw, sample_ckp_names(where));
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100332 return ERR_WARN;
333}
334
Christopher Faulet62519022017-10-16 15:49:32 +0200335/* Parse a string representing a process number or a set of processes. It must
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100336 * be "all", "odd", "even", a number between 1 and <max> or a range with
Christopher Faulet5ab51772017-11-22 11:21:58 +0100337 * two such numbers delimited by a dash ('-'). On success, it returns
338 * 0. otherwise it returns 1 with an error message in <err>.
Christopher Faulet62519022017-10-16 15:49:32 +0200339 *
340 * Note: this function can also be used to parse a thread number or a set of
341 * threads.
342 */
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100343int parse_process_number(const char *arg, unsigned long *proc, int max, int *autoinc, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200344{
Christopher Faulet26028f62017-11-22 15:01:51 +0100345 if (autoinc) {
346 *autoinc = 0;
347 if (strncmp(arg, "auto:", 5) == 0) {
348 arg += 5;
349 *autoinc = 1;
350 }
351 }
352
Christopher Faulet62519022017-10-16 15:49:32 +0200353 if (strcmp(arg, "all") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100354 *proc |= ~0UL;
Christopher Faulet62519022017-10-16 15:49:32 +0200355 else if (strcmp(arg, "odd") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100356 *proc |= ~0UL/3UL; /* 0x555....555 */
Christopher Faulet62519022017-10-16 15:49:32 +0200357 else if (strcmp(arg, "even") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100358 *proc |= (~0UL/3UL) << 1; /* 0xAAA...AAA */
Christopher Faulet62519022017-10-16 15:49:32 +0200359 else {
Christopher Faulet18cca782019-02-07 16:29:41 +0100360 const char *p, *dash = NULL;
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100361 unsigned int low, high;
362
Christopher Faulet18cca782019-02-07 16:29:41 +0100363 for (p = arg; *p; p++) {
364 if (*p == '-' && !dash)
365 dash = p;
Willy Tarreau90807112020-02-25 08:16:33 +0100366 else if (!isdigit((unsigned char)*p)) {
Christopher Faulet18cca782019-02-07 16:29:41 +0100367 memprintf(err, "'%s' is not a valid number/range.", arg);
368 return -1;
369 }
Christopher Faulet5ab51772017-11-22 11:21:58 +0100370 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100371
372 low = high = str2uic(arg);
Christopher Faulet18cca782019-02-07 16:29:41 +0100373 if (dash)
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100374 high = ((!*(dash+1)) ? max : str2uic(dash + 1));
Christopher Fauletff4121f2017-11-22 16:38:49 +0100375
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100376 if (high < low) {
377 unsigned int swap = low;
378 low = high;
379 high = swap;
380 }
381
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100382 if (low < 1 || low > max || high > max) {
Christopher Fauletcb6a9452017-11-22 16:50:41 +0100383 memprintf(err, "'%s' is not a valid number/range."
384 " It supports numbers from 1 to %d.\n",
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100385 arg, max);
Christopher Faulet5ab51772017-11-22 11:21:58 +0100386 return 1;
387 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100388
389 for (;low <= high; low++)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100390 *proc |= 1UL << (low-1);
Christopher Faulet62519022017-10-16 15:49:32 +0200391 }
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100392 *proc &= ~0UL >> (LONGBITS - max);
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100393
Christopher Faulet5ab51772017-11-22 11:21:58 +0100394 return 0;
Christopher Faulet62519022017-10-16 15:49:32 +0200395}
396
David Carlier7e351ee2017-12-01 09:14:02 +0000397#ifdef USE_CPU_AFFINITY
Christopher Faulet62519022017-10-16 15:49:32 +0200398/* Parse cpu sets. Each CPU set is either a unique number between 0 and
399 * <LONGBITS> or a range with two such numbers delimited by a dash
400 * ('-'). Multiple CPU numbers or ranges may be specified. On success, it
401 * returns 0. otherwise it returns 1 with an error message in <err>.
402 */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100403unsigned long parse_cpu_set(const char **args, unsigned long *cpu_set, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200404{
405 int cur_arg = 0;
406
407 *cpu_set = 0;
408 while (*args[cur_arg]) {
409 char *dash;
410 unsigned int low, high;
411
Willy Tarreau90807112020-02-25 08:16:33 +0100412 if (!isdigit((unsigned char)*args[cur_arg])) {
Christopher Faulet62519022017-10-16 15:49:32 +0200413 memprintf(err, "'%s' is not a CPU range.\n", args[cur_arg]);
414 return -1;
415 }
416
417 low = high = str2uic(args[cur_arg]);
418 if ((dash = strchr(args[cur_arg], '-')) != NULL)
Christopher Fauletff4121f2017-11-22 16:38:49 +0100419 high = ((!*(dash+1)) ? LONGBITS-1 : str2uic(dash + 1));
Christopher Faulet62519022017-10-16 15:49:32 +0200420
421 if (high < low) {
422 unsigned int swap = low;
423 low = high;
424 high = swap;
425 }
426
427 if (high >= LONGBITS) {
428 memprintf(err, "supports CPU numbers from 0 to %d.\n", LONGBITS - 1);
429 return 1;
430 }
431
432 while (low <= high)
433 *cpu_set |= 1UL << low++;
434
435 cur_arg++;
436 }
437 return 0;
438}
David Carlier7e351ee2017-12-01 09:14:02 +0000439#endif
440
Frédéric Lécaille18251032019-01-11 11:07:15 +0100441/* Allocate and initialize the frontend of a "peers" section found in
442 * file <file> at line <linenum> with <id> as ID.
443 * Return 0 if succeeded, -1 if not.
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200444 * Note that this function may be called from "default-server"
445 * or "peer" lines.
Frédéric Lécaille18251032019-01-11 11:07:15 +0100446 */
447static int init_peers_frontend(const char *file, int linenum,
448 const char *id, struct peers *peers)
449{
450 struct proxy *p;
451
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200452 if (peers->peers_fe) {
453 p = peers->peers_fe;
454 goto out;
455 }
Frédéric Lécaille9492c4e2019-01-11 11:47:12 +0100456
Frédéric Lécaille18251032019-01-11 11:07:15 +0100457 p = calloc(1, sizeof *p);
458 if (!p) {
459 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
460 return -1;
461 }
462
463 init_new_proxy(p);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200464 peers_setup_frontend(p);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100465 p->parent = peers;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200466 /* Finally store this frontend. */
467 peers->peers_fe = p;
468
469 out:
470 if (id && !p->id)
471 p->id = strdup(id);
Frédéric Lécaille1055e682018-04-26 14:35:21 +0200472 free(p->conf.file);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100473 p->conf.args.file = p->conf.file = strdup(file);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100474 if (linenum != -1)
475 p->conf.args.line = p->conf.line = linenum;
Frédéric Lécaille18251032019-01-11 11:07:15 +0100476
477 return 0;
478}
Willy Tarreauade5ec42010-01-28 19:33:49 +0100479
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100480/* Only change ->file, ->line and ->arg struct bind_conf member values
481 * if already present.
482 */
483static struct bind_conf *bind_conf_uniq_alloc(struct proxy *p,
484 const char *file, int line,
485 const char *arg, struct xprt_ops *xprt)
486{
487 struct bind_conf *bind_conf;
488
489 if (!LIST_ISEMPTY(&p->conf.bind)) {
490 bind_conf = LIST_ELEM((&p->conf.bind)->n, typeof(bind_conf), by_fe);
491 free(bind_conf->file);
492 bind_conf->file = strdup(file);
493 bind_conf->line = line;
494 if (arg) {
495 free(bind_conf->arg);
496 bind_conf->arg = strdup(arg);
497 }
498 }
499 else {
500 bind_conf = bind_conf_alloc(p, file, line, arg, xprt);
501 }
502
503 return bind_conf;
504}
505
506/*
507 * Allocate a new struct peer parsed at line <linenum> in file <file>
508 * to be added to <peers>.
509 * Returns the new allocated structure if succeeded, NULL if not.
510 */
511static struct peer *cfg_peers_add_peer(struct peers *peers,
512 const char *file, int linenum,
513 const char *id, int local)
514{
515 struct peer *p;
516
517 p = calloc(1, sizeof *p);
518 if (!p) {
519 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
520 return NULL;
521 }
522
523 /* the peers are linked backwards first */
524 peers->count++;
525 p->next = peers->remote;
526 peers->remote = p;
527 p->conf.file = strdup(file);
528 p->conf.line = linenum;
529 p->last_change = now.tv_sec;
530 p->xprt = xprt_get(XPRT_RAW);
531 p->sock_init_arg = NULL;
532 HA_SPIN_INIT(&p->lock);
533 if (id)
534 p->id = strdup(id);
535 if (local) {
536 p->local = 1;
537 peers->local = p;
538 }
539
540 return p;
541}
542
Willy Tarreaubaaee002006-06-26 02:48:02 +0200543/*
William Lallemand51097192015-04-14 16:35:22 +0200544 * Parse a line in a <listen>, <frontend> or <backend> section.
Willy Tarreau93893792009-07-23 13:19:11 +0200545 * Returns the error code, 0 if OK, or any combination of :
546 * - ERR_ABORT: must abort ASAP
547 * - ERR_FATAL: we can continue parsing but not start the service
548 * - ERR_WARN: a warning has been emitted
549 * - ERR_ALERT: an alert has been emitted
550 * Only the two first ones can stop processing, the two others are just
551 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200552 */
Emeric Brun32da3c42010-09-23 18:39:19 +0200553int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
554{
555 static struct peers *curpeers = NULL;
556 struct peer *newpeer = NULL;
557 const char *err;
Willy Tarreau4348fad2012-09-20 16:48:07 +0200558 struct bind_conf *bind_conf;
559 struct listener *l;
Emeric Brun32da3c42010-09-23 18:39:19 +0200560 int err_code = 0;
Willy Tarreau902636f2013-03-10 19:44:48 +0100561 char *errmsg = NULL;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100562 static int bind_line, peer_line;
563
564 if (strcmp(args[0], "bind") == 0 || strcmp(args[0], "default-bind") == 0) {
565 int cur_arg;
566 static int kws_dumped;
567 struct bind_conf *bind_conf;
568 struct bind_kw *kw;
Emeric Brun32da3c42010-09-23 18:39:19 +0200569
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100570 cur_arg = 1;
571
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200572 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
573 err_code |= ERR_ALERT | ERR_ABORT;
574 goto out;
575 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100576
577 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum,
578 NULL, xprt_get(XPRT_RAW));
579 if (*args[0] == 'b') {
580 struct listener *l;
581
582 if (peer_line) {
583 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
584 err_code |= ERR_ALERT | ERR_FATAL;
585 goto out;
586 }
587
588 if (!str2listener(args[1], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
589 if (errmsg && *errmsg) {
590 indent_msg(&errmsg, 2);
591 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
592 }
593 else
594 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
595 file, linenum, args[0], args[1], args[2]);
596 err_code |= ERR_FATAL;
597 goto out;
598 }
599 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
600 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100601 l->accept = session_accept_fd;
602 l->analysers |= curpeers->peers_fe->fe_req_ana;
603 l->default_target = curpeers->peers_fe->default_target;
604 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100605 global.maxsock++; /* for the listening socket */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100606
607 bind_line = 1;
608 if (cfg_peers->local) {
609 newpeer = cfg_peers->local;
610 }
611 else {
612 /* This peer is local.
613 * Note that we do not set the peer ID. This latter is initialized
614 * when parsing "peer" or "server" line.
615 */
616 newpeer = cfg_peers_add_peer(curpeers, file, linenum, NULL, 1);
617 if (!newpeer) {
618 err_code |= ERR_ALERT | ERR_ABORT;
619 goto out;
620 }
621 }
Willy Tarreau37159062020-08-27 07:48:42 +0200622 newpeer->addr = l->rx.addr;
Willy Tarreau5fc93282020-09-16 18:25:03 +0200623 newpeer->proto = l->rx.proto;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100624 cur_arg++;
625 }
626
627 while (*args[cur_arg] && (kw = bind_find_kw(args[cur_arg]))) {
628 int ret;
629
630 ret = kw->parse(args, cur_arg, curpeers->peers_fe, bind_conf, &errmsg);
631 err_code |= ret;
632 if (ret) {
633 if (errmsg && *errmsg) {
634 indent_msg(&errmsg, 2);
635 ha_alert("parsing [%s:%d] : %s\n", file, linenum, errmsg);
636 }
637 else
638 ha_alert("parsing [%s:%d]: error encountered while processing '%s'\n",
639 file, linenum, args[cur_arg]);
640 if (ret & ERR_FATAL)
641 goto out;
642 }
643 cur_arg += 1 + kw->skip;
644 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100645 if (*args[cur_arg] != 0) {
Tim Duesterhus04bcaa12019-05-12 22:54:50 +0200646 char *kws = NULL;
647
648 if (!kws_dumped) {
649 kws_dumped = 1;
650 bind_dump_kws(&kws);
651 indent_msg(&kws, 4);
652 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100653 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section.%s%s\n",
654 file, linenum, args[cur_arg], cursection,
655 kws ? " Registered keywords :" : "", kws ? kws: "");
656 free(kws);
657 err_code |= ERR_ALERT | ERR_FATAL;
658 goto out;
659 }
660 }
661 else if (strcmp(args[0], "default-server") == 0) {
662 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
663 err_code |= ERR_ALERT | ERR_ABORT;
664 goto out;
665 }
Emeric Brund3db3842020-07-21 16:54:36 +0200666 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL, 0, 1, 1);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200667 }
Frédéric Lécailleb6f759b2019-11-05 09:57:45 +0100668 else if (strcmp(args[0], "log") == 0) {
669 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
670 err_code |= ERR_ALERT | ERR_ABORT;
671 goto out;
672 }
673 if (!parse_logsrv(args, &curpeers->peers_fe->logsrvs, (kwm == KWM_NO), &errmsg)) {
674 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
675 err_code |= ERR_ALERT | ERR_FATAL;
676 goto out;
677 }
678 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200679 else if (strcmp(args[0], "peers") == 0) { /* new peers section */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100680 /* Initialize these static variables when entering a new "peers" section*/
681 bind_line = peer_line = 0;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100682 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100683 ha_alert("parsing [%s:%d] : missing name for peers section.\n", file, linenum);
Willy Tarreau54984722014-02-16 08:20:13 +0100684 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100685 goto out;
686 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200687
William Lallemand6e62fb62015-04-28 16:55:23 +0200688 if (alertif_too_many_args(1, file, linenum, args, &err_code))
689 goto out;
690
Emeric Brun32da3c42010-09-23 18:39:19 +0200691 err = invalid_char(args[1]);
692 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100693 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
694 file, linenum, *err, args[0], args[1]);
Willy Tarreau54984722014-02-16 08:20:13 +0100695 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100696 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200697 }
698
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200699 for (curpeers = cfg_peers; curpeers != NULL; curpeers = curpeers->next) {
Emeric Brun32da3c42010-09-23 18:39:19 +0200700 /*
701 * If there are two proxies with the same name only following
702 * combinations are allowed:
703 */
704 if (strcmp(curpeers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100705 ha_alert("Parsing [%s:%d]: peers section '%s' has the same name as another peers section declared at %s:%d.\n",
706 file, linenum, args[1], curpeers->conf.file, curpeers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +0200707 err_code |= ERR_ALERT | ERR_FATAL;
Emeric Brun32da3c42010-09-23 18:39:19 +0200708 }
709 }
710
Vincent Bernat02779b62016-04-03 13:48:43 +0200711 if ((curpeers = calloc(1, sizeof(*curpeers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100712 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Emeric Brun32da3c42010-09-23 18:39:19 +0200713 err_code |= ERR_ALERT | ERR_ABORT;
714 goto out;
715 }
716
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200717 curpeers->next = cfg_peers;
718 cfg_peers = curpeers;
Willy Tarreau8113a5d2012-10-04 08:01:43 +0200719 curpeers->conf.file = strdup(file);
Emeric Brun32da3c42010-09-23 18:39:19 +0200720 curpeers->conf.line = linenum;
721 curpeers->last_change = now.tv_sec;
722 curpeers->id = strdup(args[1]);
Willy Tarreau1ad64ac2020-09-24 08:48:08 +0200723 curpeers->disabled = 0;
Emeric Brun32da3c42010-09-23 18:39:19 +0200724 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200725 else if (strcmp(args[0], "peer") == 0 ||
726 strcmp(args[0], "server") == 0) { /* peer or server definition */
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100727 int local_peer, peer;
Emeric Brun32da3c42010-09-23 18:39:19 +0200728
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100729 peer = *args[0] == 'p';
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100730 local_peer = strcmp(args[1], localpeer) == 0;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100731 /* The local peer may have already partially been parsed on a "bind" line. */
732 if (*args[0] == 'p') {
733 if (bind_line) {
734 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
735 err_code |= ERR_ALERT | ERR_FATAL;
736 goto out;
737 }
738 peer_line = 1;
739 }
740 if (cfg_peers->local && !cfg_peers->local->id && local_peer) {
741 /* The local peer has already been initialized on a "bind" line.
742 * Let's use it and store its ID.
743 */
744 newpeer = cfg_peers->local;
745 newpeer->id = strdup(localpeer);
746 }
747 else {
748 if (local_peer && cfg_peers->local) {
749 ha_alert("parsing [%s:%d] : '%s %s' : local peer name already referenced at %s:%d. %s\n",
750 file, linenum, args[0], args[1],
751 curpeers->peers_fe->conf.file, curpeers->peers_fe->conf.line, cfg_peers->local->id);
752 err_code |= ERR_FATAL;
753 goto out;
754 }
755 newpeer = cfg_peers_add_peer(curpeers, file, linenum, args[1], local_peer);
756 if (!newpeer) {
757 err_code |= ERR_ALERT | ERR_ABORT;
758 goto out;
759 }
760 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200761
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100762 /* Line number and peer ID are updated only if this peer is the local one. */
763 if (init_peers_frontend(file,
764 newpeer->local ? linenum: -1,
765 newpeer->local ? newpeer->id : NULL,
766 curpeers) != 0) {
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200767 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreaub36487e2013-03-10 18:37:42 +0100768 goto out;
769 }
Willy Tarreau2aa38802013-02-20 19:20:59 +0100770
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100771 /* This initializes curpeer->peers->peers_fe->srv.
772 * The server address is parsed only if we are parsing a "peer" line,
773 * or if we are parsing a "server" line and the current peer is not the local one.
774 */
Emeric Brund3db3842020-07-21 16:54:36 +0200775 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL, peer || !local_peer, 1, 1);
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200776 if (!curpeers->peers_fe->srv) {
777 /* Remove the newly allocated peer. */
778 if (newpeer != curpeers->local) {
779 struct peer *p;
780
781 p = curpeers->remote;
782 curpeers->remote = curpeers->remote->next;
783 free(p->id);
784 free(p);
785 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200786 goto out;
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200787 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200788
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100789 /* If the peer address has just been parsed, let's copy it to <newpeer>
790 * and initializes ->proto.
791 */
792 if (peer || !local_peer) {
793 newpeer->addr = curpeers->peers_fe->srv->addr;
794 newpeer->proto = protocol_by_family(newpeer->addr.ss_family);
795 }
796
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100797 newpeer->xprt = xprt_get(XPRT_RAW);
Willy Tarreaud02394b2012-05-11 18:32:18 +0200798 newpeer->sock_init_arg = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100799 HA_SPIN_INIT(&newpeer->lock);
Willy Tarreau26d8c592012-05-07 18:12:14 +0200800
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100801 newpeer->srv = curpeers->peers_fe->srv;
802 if (!newpeer->local)
Frédéric Lécaille6617e762018-04-25 15:13:38 +0200803 goto out;
804
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100805 /* The lines above are reserved to "peer" lines. */
806 if (*args[0] == 's')
Frédéric Lécaille4ba51982018-04-25 15:32:18 +0200807 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200808
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100809 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 +0100810
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100811 if (!str2listener(args[2], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
812 if (errmsg && *errmsg) {
813 indent_msg(&errmsg, 2);
814 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 +0100815 }
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100816 else
817 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
818 file, linenum, args[0], args[1], args[2]);
819 err_code |= ERR_FATAL;
820 goto out;
821 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100822
823 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
824 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100825 l->accept = session_accept_fd;
826 l->analysers |= curpeers->peers_fe->fe_req_ana;
827 l->default_target = curpeers->peers_fe->default_target;
828 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100829 global.maxsock++; /* for the listening socket */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100830 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100831 else if (strcmp(args[0], "table") == 0) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100832 struct stktable *t, *other;
833 char *id;
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100834 size_t prefix_len;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100835
836 /* Line number and peer ID are updated only if this peer is the local one. */
837 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
838 err_code |= ERR_ALERT | ERR_ABORT;
839 goto out;
840 }
841
842 other = stktable_find_by_name(args[1]);
843 if (other) {
844 ha_alert("parsing [%s:%d] : stick-table name '%s' conflicts with table declared in %s '%s' at %s:%d.\n",
845 file, linenum, args[1],
846 other->proxy ? proxy_cap_str(other->proxy->cap) : "peers",
847 other->proxy ? other->id : other->peers.p->id,
848 other->conf.file, other->conf.line);
849 err_code |= ERR_ALERT | ERR_FATAL;
850 goto out;
851 }
852
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100853 /* Build the stick-table name, concatenating the "peers" section name
854 * followed by a '/' character and the table name argument.
855 */
856 chunk_reset(&trash);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100857 if (!chunk_strcpy(&trash, curpeers->id)) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100858 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
859 file, linenum, args[0], args[1]);
860 err_code |= ERR_ALERT | ERR_FATAL;
861 goto out;
862 }
863
864 prefix_len = trash.data;
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100865 if (!chunk_memcat(&trash, "/", 1) || !chunk_strcat(&trash, args[1])) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100866 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
867 file, linenum, args[0], args[1]);
868 err_code |= ERR_ALERT | ERR_FATAL;
869 goto out;
870 }
871
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100872 t = calloc(1, sizeof *t);
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100873 id = strdup(trash.area);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100874 if (!t || !id) {
875 ha_alert("parsing [%s:%d]: '%s %s' : memory allocation failed\n",
876 file, linenum, args[0], args[1]);
Eric Salama1aab9112020-09-18 11:55:17 +0200877 free(t);
878 free(id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100879 err_code |= ERR_ALERT | ERR_FATAL;
880 goto out;
881 }
882
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100883 err_code |= parse_stick_table(file, linenum, args, t, id, id + prefix_len, curpeers);
Eric Salama1aab9112020-09-18 11:55:17 +0200884 if (err_code & ERR_FATAL) {
885 free(t);
886 free(id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100887 goto out;
Eric Salama1aab9112020-09-18 11:55:17 +0200888 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100889
890 stktable_store_name(t);
891 t->next = stktables_list;
892 stktables_list = t;
893 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100894 else if (strcmp(args[0], "disabled") == 0) { /* disables this peers section */
Willy Tarreau1ad64ac2020-09-24 08:48:08 +0200895 curpeers->disabled = 1;
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200896 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100897 else if (strcmp(args[0], "enabled") == 0) { /* enables this peers section (used to revert a disabled default) */
Willy Tarreau1ad64ac2020-09-24 08:48:08 +0200898 curpeers->disabled = 0;
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200899 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200900 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100901 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Emeric Brun32da3c42010-09-23 18:39:19 +0200902 err_code |= ERR_ALERT | ERR_FATAL;
903 goto out;
904 }
905
906out:
Willy Tarreau902636f2013-03-10 19:44:48 +0100907 free(errmsg);
Emeric Brun32da3c42010-09-23 18:39:19 +0200908 return err_code;
909}
910
Baptiste Assmann325137d2015-04-13 23:40:55 +0200911/*
William Lallemand51097192015-04-14 16:35:22 +0200912 * Parse a line in a <listen>, <frontend> or <backend> section.
Simon Horman0d16a402015-01-30 11:22:58 +0900913 * Returns the error code, 0 if OK, or any combination of :
914 * - ERR_ABORT: must abort ASAP
915 * - ERR_FATAL: we can continue parsing but not start the service
916 * - ERR_WARN: a warning has been emitted
917 * - ERR_ALERT: an alert has been emitted
918 * Only the two first ones can stop processing, the two others are just
919 * indicators.
920 */
921int cfg_parse_mailers(const char *file, int linenum, char **args, int kwm)
922{
923 static struct mailers *curmailers = NULL;
924 struct mailer *newmailer = NULL;
925 const char *err;
926 int err_code = 0;
927 char *errmsg = NULL;
928
929 if (strcmp(args[0], "mailers") == 0) { /* new mailers section */
930 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100931 ha_alert("parsing [%s:%d] : missing name for mailers section.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +0900932 err_code |= ERR_ALERT | ERR_ABORT;
933 goto out;
934 }
935
936 err = invalid_char(args[1]);
937 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100938 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
939 file, linenum, *err, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +0900940 err_code |= ERR_ALERT | ERR_ABORT;
941 goto out;
942 }
943
944 for (curmailers = mailers; curmailers != NULL; curmailers = curmailers->next) {
945 /*
946 * If there are two proxies with the same name only following
947 * combinations are allowed:
948 */
949 if (strcmp(curmailers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100950 ha_alert("Parsing [%s:%d]: mailers section '%s' has the same name as another mailers section declared at %s:%d.\n",
951 file, linenum, args[1], curmailers->conf.file, curmailers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +0200952 err_code |= ERR_ALERT | ERR_FATAL;
Simon Horman0d16a402015-01-30 11:22:58 +0900953 }
954 }
955
Vincent Bernat02779b62016-04-03 13:48:43 +0200956 if ((curmailers = calloc(1, sizeof(*curmailers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100957 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +0900958 err_code |= ERR_ALERT | ERR_ABORT;
959 goto out;
960 }
961
962 curmailers->next = mailers;
963 mailers = curmailers;
964 curmailers->conf.file = strdup(file);
965 curmailers->conf.line = linenum;
966 curmailers->id = strdup(args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +0100967 curmailers->timeout.mail = DEF_MAILALERTTIME;/* XXX: Would like to Skip to the next alert, if any, ASAP.
968 * But need enough time so that timeouts don't occur
969 * during tcp procssing. For now just us an arbitrary default. */
Simon Horman0d16a402015-01-30 11:22:58 +0900970 }
971 else if (strcmp(args[0], "mailer") == 0) { /* mailer definition */
972 struct sockaddr_storage *sk;
973 int port1, port2;
974 struct protocol *proto;
975
976 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100977 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
978 file, linenum, args[0]);
Simon Horman0d16a402015-01-30 11:22:58 +0900979 err_code |= ERR_ALERT | ERR_FATAL;
980 goto out;
981 }
982
983 err = invalid_char(args[1]);
984 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100985 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
986 file, linenum, *err, args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +0900987 err_code |= ERR_ALERT | ERR_FATAL;
988 goto out;
989 }
990
Vincent Bernat02779b62016-04-03 13:48:43 +0200991 if ((newmailer = calloc(1, sizeof(*newmailer))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100992 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +0900993 err_code |= ERR_ALERT | ERR_ABORT;
994 goto out;
995 }
996
997 /* the mailers are linked backwards first */
998 curmailers->count++;
999 newmailer->next = curmailers->mailer_list;
1000 curmailers->mailer_list = newmailer;
1001 newmailer->mailers = curmailers;
1002 newmailer->conf.file = strdup(file);
1003 newmailer->conf.line = linenum;
1004
1005 newmailer->id = strdup(args[1]);
1006
Willy Tarreau5fc93282020-09-16 18:25:03 +02001007 sk = str2sa_range(args[2], NULL, &port1, &port2, NULL, &proto,
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001008 &errmsg, NULL, NULL,
1009 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 +09001010 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001011 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Simon Horman0d16a402015-01-30 11:22:58 +09001012 err_code |= ERR_ALERT | ERR_FATAL;
1013 goto out;
1014 }
1015
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001016 if (proto->sock_prot != IPPROTO_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001017 ha_alert("parsing [%s:%d] : '%s %s' : TCP not supported for this address family.\n",
1018 file, linenum, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001019 err_code |= ERR_ALERT | ERR_FATAL;
1020 goto out;
1021 }
1022
Simon Horman0d16a402015-01-30 11:22:58 +09001023 newmailer->addr = *sk;
1024 newmailer->proto = proto;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01001025 newmailer->xprt = xprt_get(XPRT_RAW);
Simon Horman0d16a402015-01-30 11:22:58 +09001026 newmailer->sock_init_arg = NULL;
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001027 }
1028 else if (strcmp(args[0], "timeout") == 0) {
1029 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001030 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments.\n",
1031 file, linenum, args[0]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001032 err_code |= ERR_ALERT | ERR_FATAL;
1033 goto out;
1034 }
1035 else if (strcmp(args[1], "mail") == 0) {
1036 const char *res;
1037 unsigned int timeout_mail;
1038 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001039 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1040 file, linenum, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001041 err_code |= ERR_ALERT | ERR_FATAL;
1042 goto out;
1043 }
1044 res = parse_time_err(args[2], &timeout_mail, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001045 if (res == PARSE_TIME_OVER) {
1046 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1047 file, linenum, args[2], args[0], args[1]);
1048 err_code |= ERR_ALERT | ERR_FATAL;
1049 goto out;
1050 }
1051 else if (res == PARSE_TIME_UNDER) {
1052 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1053 file, linenum, args[2], args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001054 err_code |= ERR_ALERT | ERR_FATAL;
1055 goto out;
1056 }
Willy Tarreau9faebe32019-06-07 19:00:37 +02001057 else if (res) {
1058 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1059 file, linenum, *res, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001060 err_code |= ERR_ALERT | ERR_FATAL;
1061 goto out;
1062 }
1063 curmailers->timeout.mail = timeout_mail;
1064 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001065 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments got '%s'.\n",
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001066 file, linenum, args[0], args[1]);
1067 err_code |= ERR_ALERT | ERR_FATAL;
1068 goto out;
1069 }
1070 }
Simon Horman0d16a402015-01-30 11:22:58 +09001071 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001072 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Simon Horman0d16a402015-01-30 11:22:58 +09001073 err_code |= ERR_ALERT | ERR_FATAL;
1074 goto out;
1075 }
1076
1077out:
1078 free(errmsg);
1079 return err_code;
1080}
1081
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +01001082void free_email_alert(struct proxy *p)
Simon Horman9dc49962015-01-30 11:22:59 +09001083{
1084 free(p->email_alert.mailers.name);
1085 p->email_alert.mailers.name = NULL;
1086 free(p->email_alert.from);
1087 p->email_alert.from = NULL;
1088 free(p->email_alert.to);
1089 p->email_alert.to = NULL;
1090 free(p->email_alert.myhostname);
1091 p->email_alert.myhostname = NULL;
1092}
1093
Willy Tarreaubaaee002006-06-26 02:48:02 +02001094
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001095int
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001096cfg_parse_netns(const char *file, int linenum, char **args, int kwm)
1097{
Willy Tarreaue5733232019-05-22 19:24:06 +02001098#ifdef USE_NS
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001099 const char *err;
1100 const char *item = args[0];
1101
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001102 if (strcmp(item, "namespace_list") == 0) {
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001103 return 0;
1104 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001105 else if (strcmp(item, "namespace") == 0) {
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001106 size_t idx = 1;
1107 const char *current;
1108 while (*(current = args[idx++])) {
1109 err = invalid_char(current);
1110 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001111 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1112 file, linenum, *err, item, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001113 return ERR_ALERT | ERR_FATAL;
1114 }
1115
1116 if (netns_store_lookup(current, strlen(current))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001117 ha_alert("parsing [%s:%d]: Namespace '%s' is already added.\n",
1118 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001119 return ERR_ALERT | ERR_FATAL;
1120 }
1121 if (!netns_store_insert(current)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001122 ha_alert("parsing [%s:%d]: Cannot open namespace '%s'.\n",
1123 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001124 return ERR_ALERT | ERR_FATAL;
1125 }
1126 }
1127 }
1128
1129 return 0;
1130#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001131 ha_alert("parsing [%s:%d]: namespace support is not compiled in.",
1132 file, linenum);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001133 return ERR_ALERT | ERR_FATAL;
1134#endif
1135}
1136
1137int
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001138cfg_parse_users(const char *file, int linenum, char **args, int kwm)
1139{
1140
1141 int err_code = 0;
1142 const char *err;
1143
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001144 if (strcmp(args[0], "userlist") == 0) { /* new userlist */
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001145 struct userlist *newul;
1146
1147 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001148 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1149 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001150 err_code |= ERR_ALERT | ERR_FATAL;
1151 goto out;
1152 }
William Lallemand6e62fb62015-04-28 16:55:23 +02001153 if (alertif_too_many_args(1, file, linenum, args, &err_code))
1154 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001155
1156 err = invalid_char(args[1]);
1157 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001158 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1159 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001160 err_code |= ERR_ALERT | ERR_FATAL;
1161 goto out;
1162 }
1163
1164 for (newul = userlist; newul; newul = newul->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001165 if (strcmp(newul->name, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001166 ha_warning("parsing [%s:%d]: ignoring duplicated userlist '%s'.\n",
1167 file, linenum, args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001168 err_code |= ERR_WARN;
1169 goto out;
1170 }
1171
Vincent Bernat02779b62016-04-03 13:48:43 +02001172 newul = calloc(1, sizeof(*newul));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001173 if (!newul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001174 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001175 err_code |= ERR_ALERT | ERR_ABORT;
1176 goto out;
1177 }
1178
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001179 newul->name = strdup(args[1]);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001180 if (!newul->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001181 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001182 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier97880bb2016-04-08 10:35:26 +01001183 free(newul);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001184 goto out;
1185 }
1186
1187 newul->next = userlist;
1188 userlist = newul;
1189
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001190 } else if (strcmp(args[0], "group") == 0) { /* new group */
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001191 int cur_arg;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001192 const char *err;
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001193 struct auth_groups *ag;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001194
1195 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001196 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1197 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001198 err_code |= ERR_ALERT | ERR_FATAL;
1199 goto out;
1200 }
1201
1202 err = invalid_char(args[1]);
1203 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001204 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1205 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001206 err_code |= ERR_ALERT | ERR_FATAL;
1207 goto out;
1208 }
1209
William Lallemand4ac9f542015-05-28 18:03:51 +02001210 if (!userlist)
1211 goto out;
1212
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001213 for (ag = userlist->groups; ag; ag = ag->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001214 if (strcmp(ag->name, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001215 ha_warning("parsing [%s:%d]: ignoring duplicated group '%s' in userlist '%s'.\n",
1216 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001217 err_code |= ERR_ALERT;
1218 goto out;
1219 }
1220
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001221 ag = calloc(1, sizeof(*ag));
1222 if (!ag) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001223 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001224 err_code |= ERR_ALERT | ERR_ABORT;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001225 goto out;
1226 }
1227
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001228 ag->name = strdup(args[1]);
David Carlier70d60452016-08-22 23:27:42 +01001229 if (!ag->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001230 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001231 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier70d60452016-08-22 23:27:42 +01001232 free(ag);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001233 goto out;
1234 }
1235
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001236 cur_arg = 2;
1237
1238 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001239 if (strcmp(args[cur_arg], "users") == 0) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001240 ag->groupusers = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001241 cur_arg += 2;
1242 continue;
1243 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001244 ha_alert("parsing [%s:%d]: '%s' only supports 'users' option.\n",
1245 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001246 err_code |= ERR_ALERT | ERR_FATAL;
David Carlier70d60452016-08-22 23:27:42 +01001247 free(ag->groupusers);
1248 free(ag->name);
1249 free(ag);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001250 goto out;
1251 }
1252 }
1253
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001254 ag->next = userlist->groups;
1255 userlist->groups = ag;
1256
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001257 } else if (strcmp(args[0], "user") == 0) { /* new user */
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001258 struct auth_users *newuser;
1259 int cur_arg;
1260
1261 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001262 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1263 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001264 err_code |= ERR_ALERT | ERR_FATAL;
1265 goto out;
1266 }
William Lallemand4ac9f542015-05-28 18:03:51 +02001267 if (!userlist)
1268 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001269
1270 for (newuser = userlist->users; newuser; newuser = newuser->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001271 if (strcmp(newuser->user, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001272 ha_warning("parsing [%s:%d]: ignoring duplicated user '%s' in userlist '%s'.\n",
1273 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001274 err_code |= ERR_ALERT;
1275 goto out;
1276 }
1277
Vincent Bernat02779b62016-04-03 13:48:43 +02001278 newuser = calloc(1, sizeof(*newuser));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001279 if (!newuser) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001280 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001281 err_code |= ERR_ALERT | ERR_ABORT;
1282 goto out;
1283 }
1284
1285 newuser->user = strdup(args[1]);
1286
1287 newuser->next = userlist->users;
1288 userlist->users = newuser;
1289
1290 cur_arg = 2;
1291
1292 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001293 if (strcmp(args[cur_arg], "password") == 0) {
Willy Tarreaue5733232019-05-22 19:24:06 +02001294#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001295 if (!crypt("", args[cur_arg + 1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001296 ha_alert("parsing [%s:%d]: the encrypted password used for user '%s' is not supported by crypt(3).\n",
1297 file, linenum, newuser->user);
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001298 err_code |= ERR_ALERT | ERR_FATAL;
1299 goto out;
1300 }
1301#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001302 ha_warning("parsing [%s:%d]: no crypt(3) support compiled, encrypted passwords will not work.\n",
1303 file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001304 err_code |= ERR_ALERT;
1305#endif
1306 newuser->pass = strdup(args[cur_arg + 1]);
1307 cur_arg += 2;
1308 continue;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001309 } else if (strcmp(args[cur_arg], "insecure-password") == 0) {
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001310 newuser->pass = strdup(args[cur_arg + 1]);
1311 newuser->flags |= AU_O_INSECURE;
1312 cur_arg += 2;
1313 continue;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001314 } else if (strcmp(args[cur_arg], "groups") == 0) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001315 newuser->u.groups_names = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001316 cur_arg += 2;
1317 continue;
1318 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001319 ha_alert("parsing [%s:%d]: '%s' only supports 'password', 'insecure-password' and 'groups' options.\n",
1320 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001321 err_code |= ERR_ALERT | ERR_FATAL;
1322 goto out;
1323 }
1324 }
1325 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001326 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 +01001327 err_code |= ERR_ALERT | ERR_FATAL;
1328 }
1329
1330out:
1331 return err_code;
1332}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001333
Christopher Faulet79bdef32016-11-04 22:36:15 +01001334int
1335cfg_parse_scope(const char *file, int linenum, char *line)
1336{
1337 char *beg, *end, *scope = NULL;
1338 int err_code = 0;
1339 const char *err;
1340
1341 beg = line + 1;
1342 end = strchr(beg, ']');
1343
1344 /* Detect end of scope declaration */
1345 if (!end || end == beg) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001346 ha_alert("parsing [%s:%d] : empty scope name is forbidden.\n",
1347 file, linenum);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001348 err_code |= ERR_ALERT | ERR_FATAL;
1349 goto out;
1350 }
1351
1352 /* Get scope name and check its validity */
1353 scope = my_strndup(beg, end-beg);
1354 err = invalid_char(scope);
1355 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001356 ha_alert("parsing [%s:%d] : character '%c' is not permitted in a scope name.\n",
1357 file, linenum, *err);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001358 err_code |= ERR_ALERT | ERR_ABORT;
1359 goto out;
1360 }
1361
1362 /* Be sure to have a scope declaration alone on its line */
1363 line = end+1;
1364 while (isspace((unsigned char)*line))
1365 line++;
1366 if (*line && *line != '#' && *line != '\n' && *line != '\r') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001367 ha_alert("parsing [%s:%d] : character '%c' is not permitted after scope declaration.\n",
1368 file, linenum, *line);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001369 err_code |= ERR_ALERT | ERR_ABORT;
1370 goto out;
1371 }
1372
1373 /* We have a valid scope declaration, save it */
1374 free(cfg_scope);
1375 cfg_scope = scope;
1376 scope = NULL;
1377
1378 out:
1379 free(scope);
1380 return err_code;
1381}
1382
Frédéric Lécaillea41d5312018-01-29 12:05:07 +01001383int
1384cfg_parse_track_sc_num(unsigned int *track_sc_num,
1385 const char *arg, const char *end, char **errmsg)
1386{
1387 const char *p;
1388 unsigned int num;
1389
1390 p = arg;
1391 num = read_uint64(&arg, end);
1392
1393 if (arg != end) {
1394 memprintf(errmsg, "Wrong track-sc number '%s'", p);
1395 return -1;
1396 }
1397
1398 if (num >= MAX_SESS_STKCTR) {
1399 memprintf(errmsg, "%u track-sc number exceeding "
1400 "%d (MAX_SESS_STKCTR-1) value", num, MAX_SESS_STKCTR - 1);
1401 return -1;
1402 }
1403
1404 *track_sc_num = num;
1405 return 0;
1406}
1407
Willy Tarreaubaaee002006-06-26 02:48:02 +02001408/*
1409 * This function reads and parses the configuration file given in the argument.
Willy Tarreau058e9072009-07-20 09:30:05 +02001410 * Returns the error code, 0 if OK, or any combination of :
1411 * - ERR_ABORT: must abort ASAP
1412 * - ERR_FATAL: we can continue parsing but not start the service
1413 * - ERR_WARN: a warning has been emitted
1414 * - ERR_ALERT: an alert has been emitted
1415 * Only the two first ones can stop processing, the two others are just
1416 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001417 */
Willy Tarreaub17916e2006-10-15 15:17:57 +02001418int readcfgfile(const char *file)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001419{
William Lallemand64e84512015-05-12 14:25:37 +02001420 char *thisline;
1421 int linesize = LINESIZE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001422 FILE *f;
1423 int linenum = 0;
Willy Tarreau058e9072009-07-20 09:30:05 +02001424 int err_code = 0;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001425 struct cfg_section *cs = NULL, *pcs = NULL;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001426 struct cfg_section *ics;
William Lallemand64e84512015-05-12 14:25:37 +02001427 int readbytes = 0;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001428 char *outline = NULL;
1429 size_t outlen = 0;
1430 size_t outlinesize = 0;
Willy Tarreau32234e72020-06-16 17:14:33 +02001431 int fatal = 0;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001432 int missing_lf = -1;
Willy Tarreau4b103022021-02-12 17:59:10 +01001433 int nested_cond_lvl = 0;
1434 enum nested_cond_state nested_conds[MAXNESTEDCONDS];
William Lallemand64e84512015-05-12 14:25:37 +02001435
1436 if ((thisline = malloc(sizeof(*thisline) * linesize)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001437 ha_alert("parsing [%s] : out of memory.\n", file);
William Lallemand64e84512015-05-12 14:25:37 +02001438 return -1;
1439 }
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001440
David Carlier97880bb2016-04-08 10:35:26 +01001441 if ((f=fopen(file,"r")) == NULL) {
1442 free(thisline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001443 return -1;
David Carlier97880bb2016-04-08 10:35:26 +01001444 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001445
William Lallemandb2f07452015-05-12 14:27:13 +02001446next_line:
William Lallemand64e84512015-05-12 14:25:37 +02001447 while (fgets(thisline + readbytes, linesize - readbytes, f) != NULL) {
Willy Tarreau3842f002009-06-14 11:39:52 +02001448 int arg, kwm = KWM_STD;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001449 char *end;
1450 char *args[MAX_LINE_ARGS + 1];
1451 char *line = thisline;
1452
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001453 if (missing_lf != -1) {
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001454 ha_alert("parsing [%s:%d]: Stray NUL character at position %d.\n",
1455 file, linenum, (missing_lf + 1));
1456 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001457 missing_lf = -1;
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001458 break;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001459 }
1460
Willy Tarreaubaaee002006-06-26 02:48:02 +02001461 linenum++;
1462
Willy Tarreau32234e72020-06-16 17:14:33 +02001463 if (fatal >= 50) {
1464 ha_alert("parsing [%s:%d]: too many fatal errors (%d), stopping now.\n", file, linenum, fatal);
1465 break;
1466 }
1467
Willy Tarreaubaaee002006-06-26 02:48:02 +02001468 end = line + strlen(line);
1469
William Lallemand64e84512015-05-12 14:25:37 +02001470 if (end-line == linesize-1 && *(end-1) != '\n') {
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001471 /* Check if we reached the limit and the last char is not \n.
1472 * Watch out for the last line without the terminating '\n'!
1473 */
William Lallemand64e84512015-05-12 14:25:37 +02001474 char *newline;
1475 int newlinesize = linesize * 2;
1476
1477 newline = realloc(thisline, sizeof(*thisline) * newlinesize);
1478 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001479 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1480 file, linenum);
William Lallemand64e84512015-05-12 14:25:37 +02001481 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001482 fatal++;
Willy Tarreau40cb26f2020-06-25 09:37:54 +02001483 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001484 continue;
1485 }
1486
1487 readbytes = linesize - 1;
1488 linesize = newlinesize;
1489 thisline = newline;
Willy Tarreau40cb26f2020-06-25 09:37:54 +02001490 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001491 continue;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001492 }
1493
William Lallemand64e84512015-05-12 14:25:37 +02001494 readbytes = 0;
1495
Willy Tarreau08488f62020-06-26 17:24:54 +02001496 if (end > line && *(end-1) == '\n') {
Tim Duesterhus70f58992020-06-22 22:57:44 +02001497 /* kill trailing LF */
1498 *(end - 1) = 0;
1499 }
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001500 else {
1501 /* mark this line as truncated */
1502 missing_lf = end - line;
1503 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001504
Willy Tarreaubaaee002006-06-26 02:48:02 +02001505 /* skip leading spaces */
Willy Tarreau8f8e6452007-06-17 21:51:38 +02001506 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001507 line++;
William Lallemandf9873ba2015-05-05 17:37:14 +02001508
Joseph Herlanta14c03e2018-11-15 14:04:19 -08001509 if (*line == '[') {/* This is the beginning if a scope */
Christopher Faulet79bdef32016-11-04 22:36:15 +01001510 err_code |= cfg_parse_scope(file, linenum, line);
1511 goto next_line;
1512 }
1513
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001514 while (1) {
1515 uint32_t err;
1516 char *errptr;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001517
Willy Tarreau61dd44b2020-06-25 07:35:42 +02001518 arg = MAX_LINE_ARGS + 1;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001519 outlen = outlinesize;
1520 err = parse_line(line, outline, &outlen, args, &arg,
1521 PARSE_OPT_ENV | PARSE_OPT_DQUOTE | PARSE_OPT_SQUOTE |
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02001522 PARSE_OPT_BKSLASH | PARSE_OPT_SHARP | PARSE_OPT_WORD_EXPAND,
1523 &errptr);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001524
1525 if (err & PARSE_ERR_QUOTE) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001526 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1527
1528 ha_alert("parsing [%s:%d]: unmatched quote at position %d:\n"
1529 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001530 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001531 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001532 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001533 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001534
1535 if (err & PARSE_ERR_BRACE) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001536 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1537
1538 ha_alert("parsing [%s:%d]: unmatched brace in environment variable name at position %d:\n"
1539 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001540 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001541 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001542 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001543 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001544
1545 if (err & PARSE_ERR_VARNAME) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001546 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1547
1548 ha_alert("parsing [%s:%d]: forbidden first char in environment variable name at position %d:\n"
1549 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001550 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001551 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001552 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001553 }
William Lallemandb2f07452015-05-12 14:27:13 +02001554
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001555 if (err & PARSE_ERR_HEX) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001556 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1557
1558 ha_alert("parsing [%s:%d]: truncated or invalid hexadecimal sequence at position %d:\n"
1559 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001560 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus9f658a52020-06-16 18:14:21 +02001561 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001562 goto next_line;
1563 }
William Lallemandb2f07452015-05-12 14:27:13 +02001564
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02001565 if (err & PARSE_ERR_WRONG_EXPAND) {
1566 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1567
1568 ha_alert("parsing [%s:%d]: truncated or invalid word expansion sequence at position %d:\n"
1569 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
1570 err_code |= ERR_ALERT | ERR_FATAL;
1571 fatal++;
1572 goto next_line;
1573 }
1574
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001575 if (err & (PARSE_ERR_TOOLARGE|PARSE_ERR_OVERLAP)) {
1576 outlinesize = (outlen + 1023) & -1024;
Ilya Shipitsin76837bc2021-01-07 22:45:13 +05001577 outline = my_realloc2(outline, outlinesize);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001578 if (outline == NULL) {
1579 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1580 file, linenum);
William Lallemandb2f07452015-05-12 14:27:13 +02001581 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001582 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001583 goto next_line;
William Lallemandb2f07452015-05-12 14:27:13 +02001584 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001585 /* try again */
1586 continue;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001587 }
Willy Tarreau07d47062020-06-25 07:41:22 +02001588
1589 if (err & PARSE_ERR_TOOMANY) {
1590 /* only check this *after* being sure the output is allocated */
1591 ha_alert("parsing [%s:%d]: too many words, truncating after word %d, position %ld: <%s>.\n",
1592 file, linenum, MAX_LINE_ARGS, (long)(args[MAX_LINE_ARGS-1] - outline + 1), args[MAX_LINE_ARGS-1]);
1593 err_code |= ERR_ALERT | ERR_FATAL;
1594 fatal++;
1595 goto next_line;
1596 }
1597
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001598 /* everything's OK */
1599 break;
William Lallemandf9873ba2015-05-05 17:37:14 +02001600 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001601
1602 /* empty line */
1603 if (!**args)
1604 continue;
1605
Willy Tarreau4b103022021-02-12 17:59:10 +01001606 /* check for config macros */
1607 if (*args[0] == '.') {
1608 if (strcmp(args[0], ".if") == 0) {
1609 nested_cond_lvl++;
1610 if (nested_cond_lvl >= MAXNESTEDCONDS) {
1611 ha_alert("parsing [%s:%d]: too many nested '.if', max is %d.\n", file, linenum, MAXNESTEDCONDS);
1612 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1613 goto err;
1614 }
1615
1616 if (nested_conds[nested_cond_lvl - 1] == NESTED_COND_IF_DROP ||
1617 nested_conds[nested_cond_lvl - 1] == NESTED_COND_IF_SKIP ||
1618 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELIF_DROP ||
1619 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELIF_SKIP ||
1620 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELSE_DROP) {
1621 nested_conds[nested_cond_lvl] = NESTED_COND_IF_SKIP;
1622 } else if (!*args[1] || *args[1] == '0') {
1623 /* empty = false */
1624 nested_conds[nested_cond_lvl] = NESTED_COND_IF_DROP;
1625 } else if (atoi(args[1]) > 0) {
1626 /* true */
1627 nested_conds[nested_cond_lvl] = NESTED_COND_IF_TAKE;
1628 } else {
1629 ha_alert("parsing [%s:%d]: unparsable conditional expression '%s'.\n", file, linenum, args[1]);
1630 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1631 goto err;
1632 }
1633 goto next_line;
1634 }
1635 else if (strcmp(args[0], ".elif") == 0) {
1636 if (!nested_cond_lvl) {
1637 ha_alert("parsing [%s:%d]: lone '.elif' with no matching '.if'.\n", file, linenum);
1638 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1639 goto err;
1640 }
1641
1642 if (nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_TAKE ||
1643 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP) {
1644 ha_alert("parsing [%s:%d]: '.elif' after '.else' is not permitted.\n", file, linenum);
1645 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1646 goto err;
1647 }
1648
1649 if (nested_conds[nested_cond_lvl] == NESTED_COND_IF_TAKE ||
1650 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
1651 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP) {
1652 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_SKIP;
1653 } else if (!*args[1] || *args[1] == '0') {
1654 /* empty = false */
1655 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_DROP;
1656 } else if (atoi(args[1]) > 0) {
1657 /* true */
1658 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_TAKE;
1659 } else {
1660 ha_alert("parsing [%s:%d]: unparsable conditional expression '%s'.\n", file, linenum, args[1]);
1661 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1662 goto err;
1663 }
1664 goto next_line;
1665 }
1666 else if (strcmp(args[0], ".else") == 0) {
1667 if (!nested_cond_lvl) {
1668 ha_alert("parsing [%s:%d]: lone '.else' with no matching '.if'.\n", file, linenum);
1669 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1670 goto err;
1671 }
1672
1673 if (nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_TAKE ||
1674 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP) {
1675 ha_alert("parsing [%s:%d]: '.else' after '.else' is not permitted.\n", file, linenum);
1676 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1677 goto err;
1678 }
1679
1680 if (nested_conds[nested_cond_lvl] == NESTED_COND_IF_TAKE ||
1681 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
1682 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_TAKE ||
1683 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP) {
1684 nested_conds[nested_cond_lvl] = NESTED_COND_ELSE_DROP;
1685 } else {
1686 /* otherwise we take the "else" */
1687 nested_conds[nested_cond_lvl] = NESTED_COND_ELSE_TAKE;
1688 }
1689 goto next_line;
1690 }
1691 else if (strcmp(args[0], ".endif") == 0) {
1692 if (!nested_cond_lvl) {
1693 ha_alert("parsing [%s:%d]: lone '.endif' with no matching '.if'.\n", file, linenum);
1694 err_code |= ERR_ALERT | ERR_FATAL;
1695 fatal++;
1696 break;
1697 }
1698 nested_cond_lvl--;
1699 goto next_line;
1700 }
1701 }
1702
1703 if (nested_cond_lvl &&
1704 (nested_conds[nested_cond_lvl] == NESTED_COND_IF_DROP ||
1705 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
1706 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_DROP ||
1707 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP ||
1708 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP)) {
1709 /* The current block is masked out by the conditions */
1710 goto next_line;
1711 }
1712
1713 /* .warning/.error/.notice */
1714 if (*args[0] == '.') {
1715 if (strcmp(args[0], ".alert") == 0) {
1716 ha_alert("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
1717 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1718 goto err;
1719 }
1720 else if (strcmp(args[0], ".warning") == 0) {
1721 ha_warning("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
1722 err_code |= ERR_WARN;
1723 goto next_line;
1724 }
1725 else if (strcmp(args[0], ".notice") == 0) {
1726 ha_notice("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
1727 goto next_line;
1728 }
1729 else {
1730 ha_alert("parsing [%s:%d]: unknown directive '%s'.\n", file, linenum, args[0]);
1731 err_code |= ERR_ALERT | ERR_FATAL;
1732 fatal++;
1733 break;
1734 }
1735 }
1736
Willy Tarreau3842f002009-06-14 11:39:52 +02001737 /* check for keyword modifiers "no" and "default" */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001738 if (strcmp(args[0], "no") == 0) {
William Lallemand0f99e342011-10-12 17:50:54 +02001739 char *tmp;
1740
Willy Tarreau3842f002009-06-14 11:39:52 +02001741 kwm = KWM_NO;
William Lallemand0f99e342011-10-12 17:50:54 +02001742 tmp = args[0];
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01001743 for (arg=0; *args[arg+1]; arg++)
1744 args[arg] = args[arg+1]; // shift args after inversion
William Lallemand0f99e342011-10-12 17:50:54 +02001745 *tmp = '\0'; // fix the next arg to \0
1746 args[arg] = tmp;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01001747 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001748 else if (strcmp(args[0], "default") == 0) {
Willy Tarreau3842f002009-06-14 11:39:52 +02001749 kwm = KWM_DEF;
1750 for (arg=0; *args[arg+1]; arg++)
1751 args[arg] = args[arg+1]; // shift args after inversion
1752 }
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01001753
William Dauchyec730982019-10-27 20:08:10 +01001754 if (kwm != KWM_STD && strcmp(args[0], "option") != 0 &&
1755 strcmp(args[0], "log") != 0 && strcmp(args[0], "busy-polling") != 0 &&
Willy Tarreaud96f1122019-12-03 07:07:36 +01001756 strcmp(args[0], "set-dumpable") != 0 && strcmp(args[0], "strict-limits") != 0 &&
1757 strcmp(args[0], "insecure-fork-wanted") != 0) {
William Dauchyec730982019-10-27 20:08:10 +01001758 ha_alert("parsing [%s:%d]: negation/default currently "
William Dauchy0fec3ab2019-10-27 20:08:11 +01001759 "supported only for options, log, busy-polling, "
Willy Tarreaud96f1122019-12-03 07:07:36 +01001760 "set-dumpable, strict-limits, and insecure-fork-wanted.\n", file, linenum);
Willy Tarreau058e9072009-07-20 09:30:05 +02001761 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001762 fatal++;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01001763 }
1764
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001765 /* detect section start */
1766 list_for_each_entry(ics, &sections, list) {
1767 if (strcmp(args[0], ics->section_name) == 0) {
1768 cursection = ics->section_name;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01001769 pcs = cs;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001770 cs = ics;
1771 break;
1772 }
Emeric Brun32da3c42010-09-23 18:39:19 +02001773 }
1774
Christopher Faulet7805e2b2018-11-30 13:50:47 +01001775 if (pcs && pcs->post_section_parser) {
Willy Tarreau32234e72020-06-16 17:14:33 +02001776 int status;
1777
1778 status = pcs->post_section_parser();
1779 err_code |= status;
1780 if (status & ERR_FATAL)
1781 fatal++;
1782
Christopher Faulet7805e2b2018-11-30 13:50:47 +01001783 if (err_code & ERR_ABORT)
1784 goto err;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01001785 }
Christopher Fauletbf7a9592018-12-02 09:37:38 +01001786 pcs = NULL;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01001787
William Lallemandd2ff56d2017-10-16 11:06:50 +02001788 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001789 ha_alert("parsing [%s:%d]: unknown keyword '%s' out of section.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02001790 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001791 fatal++;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001792 } else {
Willy Tarreau32234e72020-06-16 17:14:33 +02001793 int status;
1794
1795 status = cs->section_parser(file, linenum, args, kwm);
1796 err_code |= status;
1797 if (status & ERR_FATAL)
1798 fatal++;
1799
William Lallemandd2ff56d2017-10-16 11:06:50 +02001800 if (err_code & ERR_ABORT)
1801 goto err;
1802 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001803 }
William Lallemandd2ff56d2017-10-16 11:06:50 +02001804
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001805 if (missing_lf != -1) {
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001806 ha_alert("parsing [%s:%d]: Missing LF on last line, file might have been truncated at position %d.\n",
1807 file, linenum, (missing_lf + 1));
1808 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001809 }
1810
Christopher Fauletbf7a9592018-12-02 09:37:38 +01001811 if (cs && cs->post_section_parser)
Christopher Faulet7805e2b2018-11-30 13:50:47 +01001812 err_code |= cs->post_section_parser();
William Lallemandd2ff56d2017-10-16 11:06:50 +02001813
Willy Tarreau4b103022021-02-12 17:59:10 +01001814 if (nested_cond_lvl) {
1815 ha_alert("parsing [%s:%d]: non-terminated '.if' block.\n", file, linenum);
1816 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1817 }
William Lallemandd2ff56d2017-10-16 11:06:50 +02001818err:
Christopher Faulet79bdef32016-11-04 22:36:15 +01001819 free(cfg_scope);
1820 cfg_scope = NULL;
Willy Tarreau6daf3432008-01-22 16:44:08 +01001821 cursection = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02001822 free(thisline);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001823 free(outline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001824 fclose(f);
Willy Tarreau058e9072009-07-20 09:30:05 +02001825 return err_code;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02001826}
1827
Willy Tarreau64ab6072014-09-16 12:17:36 +02001828/* This function propagates processes from frontend <from> to backend <to> so
1829 * that it is always guaranteed that a backend pointed to by a frontend is
1830 * bound to all of its processes. After that, if the target is a "listen"
1831 * instance, the function recursively descends the target's own targets along
Willy Tarreau98d04852015-05-26 12:18:29 +02001832 * default_backend and use_backend rules. Since the bits are
Willy Tarreau64ab6072014-09-16 12:17:36 +02001833 * checked first to ensure that <to> is already bound to all processes of
1834 * <from>, there is no risk of looping and we ensure to follow the shortest
1835 * path to the destination.
1836 *
1837 * It is possible to set <to> to NULL for the first call so that the function
1838 * takes care of visiting the initial frontend in <from>.
1839 *
1840 * It is important to note that the function relies on the fact that all names
1841 * have already been resolved.
1842 */
1843void propagate_processes(struct proxy *from, struct proxy *to)
1844{
1845 struct switching_rule *rule;
Willy Tarreau64ab6072014-09-16 12:17:36 +02001846
1847 if (to) {
1848 /* check whether we need to go down */
1849 if (from->bind_proc &&
1850 (from->bind_proc & to->bind_proc) == from->bind_proc)
1851 return;
1852
1853 if (!from->bind_proc && !to->bind_proc)
1854 return;
1855
1856 to->bind_proc = from->bind_proc ?
1857 (to->bind_proc | from->bind_proc) : 0;
1858
1859 /* now propagate down */
1860 from = to;
1861 }
1862
Willy Tarreau8a95d8c2014-12-18 13:56:26 +01001863 if (!(from->cap & PR_CAP_FE))
Willy Tarreau64ab6072014-09-16 12:17:36 +02001864 return;
1865
Willy Tarreauc3914d42020-09-24 08:39:22 +02001866 if (from->disabled)
Willy Tarreauf6b70012014-12-18 14:00:43 +01001867 return;
1868
Willy Tarreau64ab6072014-09-16 12:17:36 +02001869 /* default_backend */
1870 if (from->defbe.be)
1871 propagate_processes(from, from->defbe.be);
1872
1873 /* use_backend */
1874 list_for_each_entry(rule, &from->switching_rules, list) {
Cyril Bonté51639692014-10-02 19:56:25 +02001875 if (rule->dynamic)
1876 continue;
Willy Tarreau64ab6072014-09-16 12:17:36 +02001877 to = rule->be.backend;
1878 propagate_processes(from, to);
1879 }
Willy Tarreau64ab6072014-09-16 12:17:36 +02001880}
1881
Willy Tarreaubb925012009-07-23 13:36:36 +02001882/*
1883 * Returns the error code, 0 if OK, or any combination of :
1884 * - ERR_ABORT: must abort ASAP
1885 * - ERR_FATAL: we can continue parsing but not start the service
1886 * - ERR_WARN: a warning has been emitted
1887 * - ERR_ALERT: an alert has been emitted
1888 * Only the two first ones can stop processing, the two others are just
1889 * indicators.
1890 */
Willy Tarreau915e1eb2009-06-22 15:48:36 +02001891int check_config_validity()
1892{
1893 int cfgerr = 0;
1894 struct proxy *curproxy = NULL;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001895 struct stktable *t;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02001896 struct server *newsrv = NULL;
Willy Tarreaubb925012009-07-23 13:36:36 +02001897 int err_code = 0;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02001898 unsigned int next_pxid = 1;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02001899 struct bind_conf *bind_conf;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01001900 char *err;
William Lallemand48b4bb42017-10-23 14:36:34 +02001901 struct cfg_postparser *postparser;
Emeric Brun750fe792020-12-23 16:51:12 +01001902 struct resolvers *curr_resolvers = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001903
Willy Tarreau2a65ff02012-09-13 17:54:29 +02001904 bind_conf = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001905 /*
1906 * Now, check for the integrity of all that we have collected.
1907 */
1908
1909 /* will be needed further to delay some tasks */
Willy Tarreaub0b37bc2008-06-23 14:00:57 +02001910 tv_update_date(0,1);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001911
Willy Tarreau193b8c62012-11-22 00:17:38 +01001912 if (!global.tune.max_http_hdr)
1913 global.tune.max_http_hdr = MAX_HTTP_HDR;
1914
1915 if (!global.tune.cookie_len)
1916 global.tune.cookie_len = CAPTURE_LEN;
1917
Stéphane Cottin23e9e932017-05-18 08:58:41 +02001918 if (!global.tune.requri_len)
1919 global.tune.requri_len = REQURI_LEN;
1920
Willy Tarreau149ab772019-01-26 14:27:06 +01001921 if (!global.nbthread) {
1922 /* nbthread not set, thus automatic. In this case, and only if
1923 * running on a single process, we enable the same number of
1924 * threads as the number of CPUs the process is bound to. This
1925 * allows to easily control the number of threads using taskset.
1926 */
1927 global.nbthread = 1;
1928#if defined(USE_THREAD)
1929 if (global.nbproc == 1)
1930 global.nbthread = thread_cpus_enabled_at_boot;
1931 all_threads_mask = nbits(global.nbthread);
1932#endif
1933 }
1934
Willy Tarreau26f6ae12019-02-02 12:56:15 +01001935 if (global.nbproc > 1 && global.nbthread > 1) {
1936 ha_alert("config : cannot enable multiple processes if multiple threads are configured. Please use either nbproc or nbthread but not both.\n");
1937 err_code |= ERR_ALERT | ERR_FATAL;
1938 goto out;
1939 }
1940
Willy Tarreaubafbe012017-11-24 17:34:44 +01001941 pool_head_requri = create_pool("requri", global.tune.requri_len , MEM_F_SHARED);
Emeric Brun96fd9262017-07-05 13:33:16 +02001942
Willy Tarreaubafbe012017-11-24 17:34:44 +01001943 pool_head_capture = create_pool("capture", global.tune.cookie_len, MEM_F_SHARED);
Willy Tarreau193b8c62012-11-22 00:17:38 +01001944
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001945 /* Post initialisation of the users and groups lists. */
1946 err_code = userlist_postinit();
1947 if (err_code != ERR_NONE)
1948 goto out;
1949
Willy Tarreau55bc0f82009-03-15 14:51:53 +01001950 /* first, we will invert the proxy list order */
1951 curproxy = NULL;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001952 while (proxies_list) {
Willy Tarreau55bc0f82009-03-15 14:51:53 +01001953 struct proxy *next;
1954
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001955 next = proxies_list->next;
1956 proxies_list->next = curproxy;
1957 curproxy = proxies_list;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01001958 if (!next)
1959 break;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001960 proxies_list = next;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01001961 }
1962
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001963 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02001964 struct switching_rule *rule;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001965 struct server_rule *srule;
Emeric Brunb982a3d2010-01-04 15:45:53 +01001966 struct sticking_rule *mrule;
Christopher Faulete4e830d2017-09-18 14:51:41 +02001967 struct act_rule *arule;
Dragan Dosen1322d092015-09-22 16:05:32 +02001968 struct logsrv *tmplogsrv;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02001969 unsigned int next_id;
Willy Tarreau16a21472012-11-19 12:39:59 +01001970 int nbproc;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02001971
Willy Tarreau050536d2012-10-04 08:47:34 +02001972 if (curproxy->uuid < 0) {
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02001973 /* proxy ID not set, use automatic numbering with first
1974 * spare entry starting with next_pxid.
1975 */
1976 next_pxid = get_next_id(&used_proxy_id, next_pxid);
1977 curproxy->conf.id.key = curproxy->uuid = next_pxid;
1978 eb32_insert(&used_proxy_id, &curproxy->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02001979 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01001980 next_pxid++;
1981
Willy Tarreau55ea7572007-06-17 19:56:27 +02001982
Willy Tarreauc3914d42020-09-24 08:39:22 +02001983 if (curproxy->disabled) {
Willy Tarreau02b092f2020-10-07 18:36:54 +02001984 /* ensure we don't keep listeners uselessly bound. We
1985 * can't disable their listeners yet (fdtab not
1986 * allocated yet) but let's skip them.
1987 */
Dragan Dosen7d61a332019-05-07 14:16:18 +02001988 if (curproxy->table) {
1989 free((void *)curproxy->table->peers.name);
Willy Tarreau02b092f2020-10-07 18:36:54 +02001990 curproxy->table->peers.name = NULL;
Dragan Dosen7d61a332019-05-07 14:16:18 +02001991 curproxy->table->peers.p = NULL;
1992 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001993 continue;
1994 }
1995
Willy Tarreau102df612014-05-07 23:56:38 +02001996 /* Check multi-process mode compatibility for the current proxy */
1997
1998 if (curproxy->bind_proc) {
1999 /* an explicit bind-process was specified, let's check how many
2000 * processes remain.
2001 */
David Carliere6c39412015-07-02 07:00:17 +00002002 nbproc = my_popcountl(curproxy->bind_proc);
Willy Tarreau102df612014-05-07 23:56:38 +02002003
Willy Tarreaua38a7172019-02-02 17:11:28 +01002004 curproxy->bind_proc &= all_proc_mask;
Willy Tarreau102df612014-05-07 23:56:38 +02002005 if (!curproxy->bind_proc && nbproc == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002006 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 +02002007 curproxy->bind_proc = 1;
2008 }
2009 else if (!curproxy->bind_proc && nbproc > 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002010 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 +02002011 curproxy->bind_proc = 0;
2012 }
2013 }
2014
Willy Tarreau3d209582014-05-09 17:06:11 +02002015 /* check and reduce the bind-proc of each listener */
2016 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
2017 unsigned long mask;
2018
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002019 /* HTTP frontends with "h2" as ALPN/NPN will work in
2020 * HTTP/2 and absolutely require buffers 16kB or larger.
2021 */
2022#ifdef USE_OPENSSL
2023 if (curproxy->mode == PR_MODE_HTTP && global.tune.bufsize < 16384) {
2024#ifdef OPENSSL_NPN_NEGOTIATED
2025 /* check NPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002026 if (bind_conf->ssl_conf.npn_str && strstr(bind_conf->ssl_conf.npn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002027 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",
2028 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002029 cfgerr++;
2030 }
2031#endif
2032#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
2033 /* check ALPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002034 if (bind_conf->ssl_conf.alpn_str && strstr(bind_conf->ssl_conf.alpn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002035 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",
2036 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002037 cfgerr++;
2038 }
2039#endif
2040 } /* HTTP && bufsize < 16384 */
2041#endif
2042
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002043 /* detect and address thread affinity inconsistencies */
Willy Tarreaue26993c2020-09-03 07:18:55 +02002044 mask = thread_mask(bind_conf->settings.bind_thread);
Willy Tarreau3d957172019-02-02 18:00:17 +01002045 if (!(mask & all_threads_mask)) {
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002046 unsigned long new_mask = 0;
2047
2048 while (mask) {
Willy Tarreau0c026f42018-08-01 19:12:20 +02002049 new_mask |= mask & all_threads_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002050 mask >>= global.nbthread;
2051 }
2052
Willy Tarreaue26993c2020-09-03 07:18:55 +02002053 bind_conf->settings.bind_thread = new_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002054 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",
2055 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line, new_mask);
2056 }
2057
2058 /* detect process and nbproc affinity inconsistencies */
Willy Tarreaue26993c2020-09-03 07:18:55 +02002059 mask = proc_mask(bind_conf->settings.bind_proc) & proc_mask(curproxy->bind_proc);
Willy Tarreaua36b3242019-02-02 13:14:34 +01002060 if (!(mask & all_proc_mask)) {
2061 mask = proc_mask(curproxy->bind_proc) & all_proc_mask;
Willy Tarreaue26993c2020-09-03 07:18:55 +02002062 nbproc = my_popcountl(bind_conf->settings.bind_proc);
2063 bind_conf->settings.bind_proc = proc_mask(bind_conf->settings.bind_proc) & mask;
Willy Tarreau3d209582014-05-09 17:06:11 +02002064
Willy Tarreaue26993c2020-09-03 07:18:55 +02002065 if (!bind_conf->settings.bind_proc && nbproc == 1) {
Willy Tarreaua36b3242019-02-02 13:14:34 +01002066 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",
2067 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreaue26993c2020-09-03 07:18:55 +02002068 bind_conf->settings.bind_proc = mask & ~(mask - 1);
Willy Tarreaua36b3242019-02-02 13:14:34 +01002069 }
Willy Tarreaue26993c2020-09-03 07:18:55 +02002070 else if (!bind_conf->settings.bind_proc && nbproc > 1) {
Willy Tarreaua36b3242019-02-02 13:14:34 +01002071 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",
2072 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreaue26993c2020-09-03 07:18:55 +02002073 bind_conf->settings.bind_proc = 0;
Willy Tarreaua36b3242019-02-02 13:14:34 +01002074 }
Willy Tarreau3d209582014-05-09 17:06:11 +02002075 }
2076 }
2077
Willy Tarreauff01a212009-03-15 13:46:16 +01002078 switch (curproxy->mode) {
Willy Tarreauff01a212009-03-15 13:46:16 +01002079 case PR_MODE_TCP:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002080 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002081 break;
2082
2083 case PR_MODE_HTTP:
Willy Tarreau25320b22013-03-24 07:22:08 +01002084 curproxy->http_needed = 1;
Willy Tarreauff01a212009-03-15 13:46:16 +01002085 break;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002086
2087 case PR_MODE_CLI:
2088 cfgerr += proxy_cfg_ensure_no_http(curproxy);
2089 break;
Emeric Brun54932b42020-07-07 09:43:24 +02002090 case PR_MODE_SYSLOG:
Willy Tarreaua389c9e2020-10-07 17:49:42 +02002091 case PR_MODE_PEERS:
Emeric Brun54932b42020-07-07 09:43:24 +02002092 case PR_MODES:
2093 /* should not happen, bug gcc warn missing switch statement */
Willy Tarreaua389c9e2020-10-07 17:49:42 +02002094 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 +02002095 proxy_type_str(curproxy), curproxy->id);
2096 cfgerr++;
2097 break;
Willy Tarreauff01a212009-03-15 13:46:16 +01002098 }
2099
Willy Tarreau58aa5cc2018-02-08 09:55:09 +01002100 if (curproxy != global.stats_fe && (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->conf.listeners)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002101 ha_warning("config : %s '%s' has no 'bind' directive. Please declare it as a backend if this was intended.\n",
2102 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauf3934b82015-08-11 11:36:45 +02002103 err_code |= ERR_WARN;
2104 }
2105
Willy Tarreau77e0dae2020-10-14 15:44:27 +02002106 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002107 if (curproxy->lbprm.algo & BE_LB_KIND) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002108 if (curproxy->options & PR_O_TRANSP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002109 ha_alert("config : %s '%s' cannot use both transparent and balance mode.\n",
2110 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002111 cfgerr++;
2112 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002113#ifdef WE_DONT_SUPPORT_SERVERLESS_LISTENERS
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002114 else if (curproxy->srv == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002115 ha_alert("config : %s '%s' needs at least 1 server in balance mode.\n",
2116 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002117 cfgerr++;
2118 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002119#endif
Willy Tarreau1620ec32011-08-06 17:05:02 +02002120 else if (curproxy->options & PR_O_DISPATCH) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002121 ha_warning("config : dispatch address of %s '%s' will be ignored in balance mode.\n",
2122 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002123 err_code |= ERR_WARN;
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002124 }
2125 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02002126 else if (!(curproxy->options & (PR_O_TRANSP | PR_O_DISPATCH | PR_O_HTTP_PROXY))) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002127 /* If no LB algo is set in a backend, and we're not in
2128 * transparent mode, dispatch mode nor proxy mode, we
2129 * want to use balance roundrobin by default.
2130 */
2131 curproxy->lbprm.algo &= ~BE_LB_ALGO;
2132 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002133 }
2134 }
Willy Tarreau193cf932007-09-17 10:17:23 +02002135
Willy Tarreau1620ec32011-08-06 17:05:02 +02002136 if (curproxy->options & PR_O_DISPATCH)
2137 curproxy->options &= ~(PR_O_TRANSP | PR_O_HTTP_PROXY);
2138 else if (curproxy->options & PR_O_HTTP_PROXY)
2139 curproxy->options &= ~(PR_O_DISPATCH | PR_O_TRANSP);
2140 else if (curproxy->options & PR_O_TRANSP)
2141 curproxy->options &= ~(PR_O_DISPATCH | PR_O_HTTP_PROXY);
Willy Tarreau82936582007-11-30 15:20:09 +01002142
Christopher Faulete5870d82020-04-15 11:32:03 +02002143 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_HTTP_RS)) {
2144 ha_warning("config : %s '%s' uses http-check rules without 'option httpchk', so the rules are ignored.\n",
2145 proxy_type_str(curproxy), curproxy->id);
2146 err_code |= ERR_WARN;
2147 }
2148
2149 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_TCPCHK_CHK &&
Christopher Fauletc0fcbe42020-06-03 19:00:42 +02002150 (curproxy->tcpcheck_rules.flags & TCPCHK_RULES_PROTO_CHK) != TCPCHK_RULES_HTTP_CHK) {
Willy Tarreau1620ec32011-08-06 17:05:02 +02002151 if (curproxy->options & PR_O_DISABLE404) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002152 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2153 "disable-on-404", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002154 err_code |= ERR_WARN;
2155 curproxy->options &= ~PR_O_DISABLE404;
2156 }
2157 if (curproxy->options2 & PR_O2_CHK_SNDST) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002158 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2159 "send-state", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002160 err_code |= ERR_WARN;
2161 curproxy->options &= ~PR_O2_CHK_SNDST;
2162 }
Willy Tarreauef781042010-01-27 11:53:01 +01002163 }
2164
Simon Horman98637e52014-06-20 12:30:16 +09002165 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_EXT_CHK) {
2166 if (!global.external_check) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002167 ha_alert("Proxy '%s' : '%s' unable to find required 'global.external-check'.\n",
2168 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002169 cfgerr++;
2170 }
2171 if (!curproxy->check_command) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002172 ha_alert("Proxy '%s' : '%s' unable to find required 'external-check command'.\n",
2173 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002174 cfgerr++;
2175 }
Willy Tarreaud96f1122019-12-03 07:07:36 +01002176 if (!(global.tune.options & GTUNE_INSECURE_FORK)) {
2177 ha_warning("Proxy '%s' : 'insecure-fork-wanted' not enabled in the global section, '%s' will likely fail.\n",
2178 curproxy->id, "option external-check");
2179 err_code |= ERR_WARN;
2180 }
Simon Horman98637e52014-06-20 12:30:16 +09002181 }
2182
Simon Horman64e34162015-02-06 11:11:57 +09002183 if (curproxy->email_alert.set) {
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002184 if (!(curproxy->email_alert.mailers.name && curproxy->email_alert.from && curproxy->email_alert.to)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002185 ha_warning("config : 'email-alert' will be ignored for %s '%s' (the presence any of "
2186 "'email-alert from', 'email-alert level' 'email-alert mailers', "
2187 "'email-alert myhostname', or 'email-alert to' "
2188 "requires each of 'email-alert from', 'email-alert mailers' and 'email-alert to' "
2189 "to be present).\n",
2190 proxy_type_str(curproxy), curproxy->id);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002191 err_code |= ERR_WARN;
2192 free_email_alert(curproxy);
2193 }
2194 if (!curproxy->email_alert.myhostname)
Cyril Bontée22bfd62015-12-04 03:07:07 +01002195 curproxy->email_alert.myhostname = strdup(hostname);
Simon Horman9dc49962015-01-30 11:22:59 +09002196 }
2197
Simon Horman98637e52014-06-20 12:30:16 +09002198 if (curproxy->check_command) {
2199 int clear = 0;
2200 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002201 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2202 "external-check command", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002203 err_code |= ERR_WARN;
2204 clear = 1;
2205 }
2206 if (curproxy->check_command[0] != '/' && !curproxy->check_path) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002207 ha_alert("Proxy '%s': '%s' does not have a leading '/' and 'external-check path' is not set.\n",
2208 curproxy->id, "external-check command");
Simon Horman98637e52014-06-20 12:30:16 +09002209 cfgerr++;
2210 }
2211 if (clear) {
2212 free(curproxy->check_command);
2213 curproxy->check_command = NULL;
2214 }
2215 }
2216
2217 if (curproxy->check_path) {
2218 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002219 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2220 "external-check path", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002221 err_code |= ERR_WARN;
2222 free(curproxy->check_path);
2223 curproxy->check_path = NULL;
2224 }
2225 }
2226
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002227 /* if a default backend was specified, let's find it */
2228 if (curproxy->defbe.name) {
2229 struct proxy *target;
2230
Willy Tarreauafb39922015-05-26 12:04:09 +02002231 target = proxy_be_by_name(curproxy->defbe.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002232 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002233 ha_alert("Proxy '%s': unable to find required default_backend: '%s'.\n",
2234 curproxy->id, curproxy->defbe.name);
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002235 cfgerr++;
2236 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002237 ha_alert("Proxy '%s': loop detected for default_backend: '%s'.\n",
2238 curproxy->id, curproxy->defbe.name);
Willy Tarreaubb925012009-07-23 13:36:36 +02002239 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002240 } else if (target->mode != curproxy->mode &&
2241 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2242
Christopher Faulet767a84b2017-11-24 16:50:31 +01002243 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) as its default backend (see 'mode').\n",
2244 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2245 curproxy->conf.file, curproxy->conf.line,
2246 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2247 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002248 cfgerr++;
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002249 } else {
2250 free(curproxy->defbe.name);
2251 curproxy->defbe.be = target;
Willy Tarreauff678132012-02-13 14:32:34 +01002252 /* Emit a warning if this proxy also has some servers */
2253 if (curproxy->srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002254 ha_warning("In proxy '%s', the 'default_backend' rule always has precedence over the servers, which will never be used.\n",
2255 curproxy->id);
Willy Tarreauff678132012-02-13 14:32:34 +01002256 err_code |= ERR_WARN;
2257 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002258 }
2259 }
2260
Willy Tarreau55ea7572007-06-17 19:56:27 +02002261 /* find the target proxy for 'use_backend' rules */
2262 list_for_each_entry(rule, &curproxy->switching_rules, list) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002263 struct proxy *target;
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002264 struct logformat_node *node;
2265 char *pxname;
2266
2267 /* Try to parse the string as a log format expression. If the result
2268 * of the parsing is only one entry containing a simple string, then
2269 * it's a standard string corresponding to a static rule, thus the
2270 * parsing is cancelled and be.name is restored to be resolved.
2271 */
2272 pxname = rule->be.name;
2273 LIST_INIT(&rule->be.expr);
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +01002274 curproxy->conf.args.ctx = ARGC_UBK;
2275 curproxy->conf.args.file = rule->file;
2276 curproxy->conf.args.line = rule->line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002277 err = NULL;
2278 if (!parse_logformat_string(pxname, curproxy, &rule->be.expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002279 ha_alert("Parsing [%s:%d]: failed to parse use_backend rule '%s' : %s.\n",
2280 rule->file, rule->line, pxname, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002281 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002282 cfgerr++;
2283 continue;
2284 }
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002285 node = LIST_NEXT(&rule->be.expr, struct logformat_node *, list);
2286
2287 if (!LIST_ISEMPTY(&rule->be.expr)) {
2288 if (node->type != LOG_FMT_TEXT || node->list.n != &rule->be.expr) {
2289 rule->dynamic = 1;
2290 free(pxname);
2291 continue;
2292 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02002293 /* Only one element in the list, a simple string: free the expression and
2294 * fall back to static rule
2295 */
2296 LIST_DEL(&node->list);
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002297 free(node->arg);
2298 free(node);
2299 }
2300
2301 rule->dynamic = 0;
2302 rule->be.name = pxname;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002303
Willy Tarreauafb39922015-05-26 12:04:09 +02002304 target = proxy_be_by_name(rule->be.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002305 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002306 ha_alert("Proxy '%s': unable to find required use_backend: '%s'.\n",
2307 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002308 cfgerr++;
2309 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002310 ha_alert("Proxy '%s': loop detected for use_backend: '%s'.\n",
2311 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002312 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002313 } else if (target->mode != curproxy->mode &&
2314 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2315
Christopher Faulet767a84b2017-11-24 16:50:31 +01002316 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) in a 'use_backend' rule (see 'mode').\n",
2317 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2318 curproxy->conf.file, curproxy->conf.line,
2319 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2320 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002321 cfgerr++;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002322 } else {
2323 free((void *)rule->be.name);
2324 rule->be.backend = target;
2325 }
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002326 }
2327
Willy Tarreau64ab6072014-09-16 12:17:36 +02002328 /* find the target server for 'use_server' rules */
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002329 list_for_each_entry(srule, &curproxy->server_rules, list) {
Jerome Magnin824186b2020-03-29 09:37:12 +02002330 struct server *target;
2331 struct logformat_node *node;
2332 char *server_name;
2333
2334 /* We try to parse the string as a log format expression. If the result of the parsing
2335 * is only one entry containing a single string, then it's a standard string corresponding
2336 * to a static rule, thus the parsing is cancelled and we fall back to setting srv.ptr.
2337 */
2338 server_name = srule->srv.name;
2339 LIST_INIT(&srule->expr);
2340 curproxy->conf.args.ctx = ARGC_USRV;
2341 err = NULL;
2342 if (!parse_logformat_string(server_name, curproxy, &srule->expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
2343 ha_alert("Parsing [%s:%d]; use-server rule failed to parse log-format '%s' : %s.\n",
2344 srule->file, srule->line, server_name, err);
2345 free(err);
2346 cfgerr++;
2347 continue;
2348 }
2349 node = LIST_NEXT(&srule->expr, struct logformat_node *, list);
2350
2351 if (!LIST_ISEMPTY(&srule->expr)) {
2352 if (node->type != LOG_FMT_TEXT || node->list.n != &srule->expr) {
2353 srule->dynamic = 1;
2354 free(server_name);
2355 continue;
2356 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02002357 /* Only one element in the list, a simple string: free the expression and
2358 * fall back to static rule
2359 */
2360 LIST_DEL(&node->list);
Jerome Magnin824186b2020-03-29 09:37:12 +02002361 free(node->arg);
2362 free(node);
2363 }
2364
2365 srule->dynamic = 0;
2366 srule->srv.name = server_name;
2367 target = findserver(curproxy, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002368
2369 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002370 ha_alert("config : %s '%s' : unable to find server '%s' referenced in a 'use-server' rule.\n",
2371 proxy_type_str(curproxy), curproxy->id, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002372 cfgerr++;
2373 continue;
2374 }
2375 free((void *)srule->srv.name);
2376 srule->srv.ptr = target;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002377 }
2378
Emeric Brunb982a3d2010-01-04 15:45:53 +01002379 /* find the target table for 'stick' rules */
2380 list_for_each_entry(mrule, &curproxy->sticking_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002381 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002382
Emeric Brun1d33b292010-01-04 15:47:17 +01002383 curproxy->be_req_ana |= AN_REQ_STICKING_RULES;
2384 if (mrule->flags & STK_IS_STORE)
2385 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2386
Emeric Brunb982a3d2010-01-04 15:45:53 +01002387 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002388 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002389 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002390 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002391
2392 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002393 ha_alert("Proxy '%s': unable to find stick-table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01002394 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002395 cfgerr++;
2396 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002397 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002398 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2399 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002400 cfgerr++;
2401 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002402 else if (target->proxy && curproxy->bind_proc & ~target->proxy->bind_proc) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002403 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2404 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002405 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002406 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002407 else {
2408 free((void *)mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002409 mrule->table.t = target;
2410 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Thayne McCombs92149f92020-11-20 01:28:26 -07002411 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_KEY, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02002412 if (!in_proxies_list(target->proxies_list, curproxy)) {
2413 curproxy->next_stkt_ref = target->proxies_list;
2414 target->proxies_list = curproxy;
2415 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002416 }
2417 }
2418
2419 /* find the target table for 'store response' rules */
2420 list_for_each_entry(mrule, &curproxy->storersp_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002421 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002422
Emeric Brun1d33b292010-01-04 15:47:17 +01002423 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2424
Emeric Brunb982a3d2010-01-04 15:45:53 +01002425 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002426 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002427 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002428 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002429
2430 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002431 ha_alert("Proxy '%s': unable to find store table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01002432 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002433 cfgerr++;
2434 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002435 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002436 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2437 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002438 cfgerr++;
2439 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002440 else if (target->proxy && (curproxy->bind_proc & ~target->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002441 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2442 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002443 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002444 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002445 else {
2446 free((void *)mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002447 mrule->table.t = target;
2448 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Thayne McCombs92149f92020-11-20 01:28:26 -07002449 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_KEY, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02002450 if (!in_proxies_list(target->proxies_list, curproxy)) {
2451 curproxy->next_stkt_ref = target->proxies_list;
2452 target->proxies_list = curproxy;
2453 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002454 }
2455 }
2456
Christopher Faulete4e830d2017-09-18 14:51:41 +02002457 /* check validity for 'tcp-request' layer 4 rules */
2458 list_for_each_entry(arule, &curproxy->tcp_req.l4_rules, list) {
2459 err = NULL;
2460 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002461 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002462 free(err);
Willy Tarreau5f53de72012-12-12 00:25:44 +01002463 cfgerr++;
2464 }
Willy Tarreaud1f96522010-08-03 19:34:32 +02002465 }
2466
Christopher Faulete4e830d2017-09-18 14:51:41 +02002467 /* check validity for 'tcp-request' layer 5 rules */
2468 list_for_each_entry(arule, &curproxy->tcp_req.l5_rules, list) {
2469 err = NULL;
2470 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002471 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002472 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002473 cfgerr++;
2474 }
2475 }
2476
Christopher Faulete4e830d2017-09-18 14:51:41 +02002477 /* check validity for 'tcp-request' layer 6 rules */
2478 list_for_each_entry(arule, &curproxy->tcp_req.inspect_rules, list) {
2479 err = NULL;
2480 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002481 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002482 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002483 cfgerr++;
2484 }
2485 }
2486
Christopher Faulete4e830d2017-09-18 14:51:41 +02002487 /* check validity for 'http-request' layer 7 rules */
2488 list_for_each_entry(arule, &curproxy->http_req_rules, list) {
2489 err = NULL;
2490 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002491 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002492 free(err);
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002493 cfgerr++;
2494 }
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002495 }
2496
Christopher Faulete4e830d2017-09-18 14:51:41 +02002497 /* check validity for 'http-response' layer 7 rules */
2498 list_for_each_entry(arule, &curproxy->http_res_rules, list) {
2499 err = NULL;
2500 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002501 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002502 free(err);
Willy Tarreau09448f72014-06-25 18:12:15 +02002503 cfgerr++;
2504 }
Willy Tarreau09448f72014-06-25 18:12:15 +02002505 }
2506
Christopher Faulet6d0c3df2020-01-22 09:26:35 +01002507 /* check validity for 'http-after-response' layer 7 rules */
2508 list_for_each_entry(arule, &curproxy->http_after_res_rules, list) {
2509 err = NULL;
2510 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
2511 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
2512 free(err);
2513 cfgerr++;
2514 }
2515 }
2516
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002517 if (curproxy->table && curproxy->table->peers.name) {
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002518 struct peers *curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002519
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002520 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002521 if (strcmp(curpeers->id, curproxy->table->peers.name) == 0) {
2522 free((void *)curproxy->table->peers.name);
2523 curproxy->table->peers.p = curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002524 break;
2525 }
2526 }
2527
2528 if (!curpeers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002529 ha_alert("Proxy '%s': unable to find sync peers '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002530 curproxy->id, curproxy->table->peers.name);
2531 free((void *)curproxy->table->peers.name);
2532 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002533 cfgerr++;
2534 }
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02002535 else if (curpeers->disabled) {
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002536 /* silently disable this peers section */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002537 curproxy->table->peers.p = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002538 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002539 else if (!curpeers->peers_fe) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002540 ha_alert("Proxy '%s': unable to find local peer '%s' in peers section '%s'.\n",
2541 curproxy->id, localpeer, curpeers->id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002542 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002543 cfgerr++;
2544 }
2545 }
2546
Simon Horman9dc49962015-01-30 11:22:59 +09002547
2548 if (curproxy->email_alert.mailers.name) {
2549 struct mailers *curmailers = mailers;
2550
2551 for (curmailers = mailers; curmailers; curmailers = curmailers->next) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002552 if (strcmp(curmailers->id, curproxy->email_alert.mailers.name) == 0)
Simon Horman9dc49962015-01-30 11:22:59 +09002553 break;
Simon Horman9dc49962015-01-30 11:22:59 +09002554 }
Simon Horman9dc49962015-01-30 11:22:59 +09002555 if (!curmailers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002556 ha_alert("Proxy '%s': unable to find mailers '%s'.\n",
2557 curproxy->id, curproxy->email_alert.mailers.name);
Simon Horman9dc49962015-01-30 11:22:59 +09002558 free_email_alert(curproxy);
2559 cfgerr++;
2560 }
Christopher Faulet0108bb32017-10-20 21:34:32 +02002561 else {
2562 err = NULL;
2563 if (init_email_alert(curmailers, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002564 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulet0108bb32017-10-20 21:34:32 +02002565 free(err);
2566 cfgerr++;
2567 }
2568 }
Simon Horman9dc49962015-01-30 11:22:59 +09002569 }
2570
Willy Tarreau5bbc6762021-02-12 11:49:25 +01002571 if (curproxy->uri_auth && !(curproxy->uri_auth->flags & STAT_CONVDONE) &&
Willy Tarreauff011f22011-01-06 17:51:27 +01002572 !LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules) &&
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002573 (curproxy->uri_auth->userlist || curproxy->uri_auth->auth_realm )) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002574 ha_alert("%s '%s': stats 'auth'/'realm' and 'http-request' can't be used at the same time.\n",
2575 "proxy", curproxy->id);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002576 cfgerr++;
2577 goto out_uri_auth_compat;
2578 }
2579
Willy Tarreauee4f5f82019-10-09 09:59:22 +02002580 if (curproxy->uri_auth && curproxy->uri_auth->userlist &&
Willy Tarreau5bbc6762021-02-12 11:49:25 +01002581 (!(curproxy->uri_auth->flags & STAT_CONVDONE) ||
Willy Tarreauee4f5f82019-10-09 09:59:22 +02002582 LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules))) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002583 const char *uri_auth_compat_req[10];
Thierry FOURNIERa28a9422015-08-04 19:35:46 +02002584 struct act_rule *rule;
Willy Tarreau95fa4692010-02-01 13:05:50 +01002585 int i = 0;
Willy Tarreau95fa4692010-02-01 13:05:50 +01002586 /* build the ACL condition from scratch. We're relying on anonymous ACLs for that */
2587 uri_auth_compat_req[i++] = "auth";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002588
2589 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002590 uri_auth_compat_req[i++] = "realm";
2591 uri_auth_compat_req[i++] = curproxy->uri_auth->auth_realm;
2592 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002593
Willy Tarreau95fa4692010-02-01 13:05:50 +01002594 uri_auth_compat_req[i++] = "unless";
2595 uri_auth_compat_req[i++] = "{";
2596 uri_auth_compat_req[i++] = "http_auth(.internal-stats-userlist)";
2597 uri_auth_compat_req[i++] = "}";
2598 uri_auth_compat_req[i++] = "";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002599
Willy Tarreauff011f22011-01-06 17:51:27 +01002600 rule = parse_http_req_cond(uri_auth_compat_req, "internal-stats-auth-compat", 0, curproxy);
2601 if (!rule) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002602 cfgerr++;
2603 break;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002604 }
2605
Willy Tarreauff011f22011-01-06 17:51:27 +01002606 LIST_ADDQ(&curproxy->uri_auth->http_req_rules, &rule->list);
Willy Tarreau95fa4692010-02-01 13:05:50 +01002607
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002608 if (curproxy->uri_auth->auth_realm) {
2609 free(curproxy->uri_auth->auth_realm);
2610 curproxy->uri_auth->auth_realm = NULL;
2611 }
Willy Tarreau5bbc6762021-02-12 11:49:25 +01002612 curproxy->uri_auth->flags |= STAT_CONVDONE;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002613 }
2614out_uri_auth_compat:
2615
Dragan Dosen43885c72015-10-01 13:18:13 +02002616 /* check whether we have a log server that uses RFC5424 log format */
Dragan Dosen1322d092015-09-22 16:05:32 +02002617 list_for_each_entry(tmplogsrv, &curproxy->logsrvs, list) {
Dragan Dosen43885c72015-10-01 13:18:13 +02002618 if (tmplogsrv->format == LOG_FORMAT_RFC5424) {
2619 if (!curproxy->conf.logformat_sd_string) {
2620 /* set the default logformat_sd_string */
2621 curproxy->conf.logformat_sd_string = default_rfc5424_sd_log_format;
2622 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002623 break;
Dragan Dosen1322d092015-09-22 16:05:32 +02002624 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002625 }
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02002626
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002627 /* compile the log format */
2628 if (!(curproxy->cap & PR_CAP_FE)) {
Willy Tarreau62a61232013-04-12 18:13:46 +02002629 if (curproxy->conf.logformat_string != default_http_log_format &&
2630 curproxy->conf.logformat_string != default_tcp_log_format &&
2631 curproxy->conf.logformat_string != clf_http_log_format)
2632 free(curproxy->conf.logformat_string);
2633 curproxy->conf.logformat_string = NULL;
2634 free(curproxy->conf.lfs_file);
2635 curproxy->conf.lfs_file = NULL;
2636 curproxy->conf.lfs_line = 0;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002637
2638 if (curproxy->conf.logformat_sd_string != default_rfc5424_sd_log_format)
2639 free(curproxy->conf.logformat_sd_string);
2640 curproxy->conf.logformat_sd_string = NULL;
2641 free(curproxy->conf.lfsd_file);
2642 curproxy->conf.lfsd_file = NULL;
2643 curproxy->conf.lfsd_line = 0;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002644 }
2645
Willy Tarreau62a61232013-04-12 18:13:46 +02002646 if (curproxy->conf.logformat_string) {
2647 curproxy->conf.args.ctx = ARGC_LOG;
2648 curproxy->conf.args.file = curproxy->conf.lfs_file;
2649 curproxy->conf.args.line = curproxy->conf.lfs_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002650 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02002651 if (!parse_logformat_string(curproxy->conf.logformat_string, curproxy, &curproxy->logformat,
2652 LOG_OPT_MANDATORY|LOG_OPT_MERGE_SPACES,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002653 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002654 ha_alert("Parsing [%s:%d]: failed to parse log-format : %s.\n",
2655 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002656 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002657 cfgerr++;
2658 }
Willy Tarreau62a61232013-04-12 18:13:46 +02002659 curproxy->conf.args.file = NULL;
2660 curproxy->conf.args.line = 0;
2661 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002662
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002663 if (curproxy->conf.logformat_sd_string) {
2664 curproxy->conf.args.ctx = ARGC_LOGSD;
2665 curproxy->conf.args.file = curproxy->conf.lfsd_file;
2666 curproxy->conf.args.line = curproxy->conf.lfsd_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002667 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02002668 if (!parse_logformat_string(curproxy->conf.logformat_sd_string, curproxy, &curproxy->logformat_sd,
2669 LOG_OPT_MANDATORY|LOG_OPT_MERGE_SPACES,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002670 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002671 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
2672 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002673 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002674 cfgerr++;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002675 } else if (!add_to_logformat_list(NULL, NULL, LF_SEPARATOR, &curproxy->logformat_sd, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002676 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
2677 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002678 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002679 cfgerr++;
2680 }
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002681 curproxy->conf.args.file = NULL;
2682 curproxy->conf.args.line = 0;
2683 }
2684
Willy Tarreau62a61232013-04-12 18:13:46 +02002685 if (curproxy->conf.uniqueid_format_string) {
2686 curproxy->conf.args.ctx = ARGC_UIF;
2687 curproxy->conf.args.file = curproxy->conf.uif_file;
2688 curproxy->conf.args.line = curproxy->conf.uif_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002689 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02002690 if (!parse_logformat_string(curproxy->conf.uniqueid_format_string, curproxy, &curproxy->format_unique_id,
2691 LOG_OPT_HTTP|LOG_OPT_MERGE_SPACES,
2692 (curproxy->cap & PR_CAP_FE) ? SMP_VAL_FE_HRQ_HDR
2693 : SMP_VAL_BE_HRQ_HDR,
2694 &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002695 ha_alert("Parsing [%s:%d]: failed to parse unique-id : %s.\n",
2696 curproxy->conf.uif_file, curproxy->conf.uif_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002697 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002698 cfgerr++;
2699 }
Willy Tarreau62a61232013-04-12 18:13:46 +02002700 curproxy->conf.args.file = NULL;
2701 curproxy->conf.args.line = 0;
2702 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002703
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002704 /* only now we can check if some args remain unresolved.
2705 * This must be done after the users and groups resolution.
2706 */
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002707 cfgerr += smp_resolve_args(curproxy);
2708 if (!cfgerr)
2709 cfgerr += acl_find_targets(curproxy);
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01002710
Willy Tarreau2738a142006-07-08 17:28:09 +02002711 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002712 (((curproxy->cap & PR_CAP_FE) && !curproxy->timeout.client) ||
Willy Tarreaud825eef2007-05-12 22:35:00 +02002713 ((curproxy->cap & PR_CAP_BE) && (curproxy->srv) &&
Willy Tarreauce887fd2012-05-12 12:50:00 +02002714 (!curproxy->timeout.connect ||
2715 (!curproxy->timeout.server && (curproxy->mode == PR_MODE_HTTP || !curproxy->timeout.tunnel)))))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002716 ha_warning("config : missing timeouts for %s '%s'.\n"
2717 " | While not properly invalid, you will certainly encounter various problems\n"
2718 " | with such a configuration. To fix this, please ensure that all following\n"
2719 " | timeouts are set to a non-zero value: 'client', 'connect', 'server'.\n",
2720 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002721 err_code |= ERR_WARN;
Willy Tarreau2738a142006-07-08 17:28:09 +02002722 }
Willy Tarreauf3c69202006-07-09 16:42:34 +02002723
Willy Tarreau1fa31262007-12-03 00:36:16 +01002724 /* Historically, the tarpit and queue timeouts were inherited from contimeout.
2725 * We must still support older configurations, so let's find out whether those
2726 * parameters have been set or must be copied from contimeouts.
2727 */
Willy Tarreau937c3ea2021-02-12 11:14:35 +01002728 if (!curproxy->timeout.tarpit)
2729 curproxy->timeout.tarpit = curproxy->timeout.connect;
2730 if ((curproxy->cap & PR_CAP_BE) && !curproxy->timeout.queue)
2731 curproxy->timeout.queue = curproxy->timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01002732
Christopher Faulete5870d82020-04-15 11:32:03 +02002733 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_TCP_RS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002734 ha_warning("config : %s '%s' uses tcp-check rules without 'option tcp-check', so the rules are ignored.\n",
2735 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau215663d2014-06-13 18:30:23 +02002736 err_code |= ERR_WARN;
2737 }
2738
Willy Tarreau193b8c62012-11-22 00:17:38 +01002739 /* ensure that cookie capture length is not too large */
2740 if (curproxy->capture_len >= global.tune.cookie_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002741 ha_warning("config : truncating capture length to %d bytes for %s '%s'.\n",
2742 global.tune.cookie_len - 1, proxy_type_str(curproxy), curproxy->id);
Willy Tarreau193b8c62012-11-22 00:17:38 +01002743 err_code |= ERR_WARN;
2744 curproxy->capture_len = global.tune.cookie_len - 1;
2745 }
2746
Willy Tarreaucf7f3202007-05-13 22:46:04 +02002747 /* The small pools required for the capture lists */
Willy Tarreau9a54e132012-03-24 08:33:05 +01002748 if (curproxy->nb_req_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02002749 curproxy->req_cap_pool = create_pool("ptrcap",
2750 curproxy->nb_req_cap * sizeof(char *),
2751 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01002752 }
2753
2754 if (curproxy->nb_rsp_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02002755 curproxy->rsp_cap_pool = create_pool("ptrcap",
2756 curproxy->nb_rsp_cap * sizeof(char *),
2757 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01002758 }
Willy Tarreaucf7f3202007-05-13 22:46:04 +02002759
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002760 switch (curproxy->load_server_state_from_file) {
2761 case PR_SRV_STATE_FILE_UNSPEC:
2762 curproxy->load_server_state_from_file = PR_SRV_STATE_FILE_NONE;
2763 break;
2764 case PR_SRV_STATE_FILE_GLOBAL:
2765 if (!global.server_state_file) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002766 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",
2767 curproxy->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002768 err_code |= ERR_WARN;
2769 }
2770 break;
2771 }
2772
Willy Tarreaubaaee002006-06-26 02:48:02 +02002773 /* first, we will invert the servers list order */
2774 newsrv = NULL;
2775 while (curproxy->srv) {
2776 struct server *next;
2777
2778 next = curproxy->srv->next;
2779 curproxy->srv->next = newsrv;
2780 newsrv = curproxy->srv;
2781 if (!next)
2782 break;
2783 curproxy->srv = next;
2784 }
2785
Willy Tarreau17edc812014-01-03 12:14:34 +01002786 /* Check that no server name conflicts. This causes trouble in the stats.
2787 * We only emit a warning for the first conflict affecting each server,
2788 * in order to avoid combinatory explosion if all servers have the same
2789 * name. We do that only for servers which do not have an explicit ID,
2790 * because these IDs were made also for distinguishing them and we don't
2791 * want to annoy people who correctly manage them.
2792 */
2793 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
2794 struct server *other_srv;
2795
2796 if (newsrv->puid)
2797 continue;
2798
2799 for (other_srv = curproxy->srv; other_srv && other_srv != newsrv; other_srv = other_srv->next) {
2800 if (!other_srv->puid && strcmp(other_srv->id, newsrv->id) == 0) {
Willy Tarreaub01302f2019-05-27 19:31:06 +02002801 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 +01002802 newsrv->conf.file, newsrv->conf.line,
2803 proxy_type_str(curproxy), curproxy->id,
2804 newsrv->id, other_srv->conf.line);
Willy Tarreaub01302f2019-05-27 19:31:06 +02002805 cfgerr++;
Willy Tarreau17edc812014-01-03 12:14:34 +01002806 break;
2807 }
2808 }
2809 }
2810
Willy Tarreaudd701652010-05-25 23:03:02 +02002811 /* assign automatic UIDs to servers which don't have one yet */
2812 next_id = 1;
2813 newsrv = curproxy->srv;
2814 while (newsrv != NULL) {
2815 if (!newsrv->puid) {
2816 /* server ID not set, use automatic numbering with first
2817 * spare entry starting with next_svid.
2818 */
2819 next_id = get_next_id(&curproxy->conf.used_server_id, next_id);
2820 newsrv->conf.id.key = newsrv->puid = next_id;
2821 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Frédéric Lécaille84d60462019-05-17 14:29:15 +02002822 newsrv->conf.name.key = newsrv->id;
2823 ebis_insert(&curproxy->conf.used_server_name, &newsrv->conf.name);
Willy Tarreaudd701652010-05-25 23:03:02 +02002824 }
2825 next_id++;
2826 newsrv = newsrv->next;
2827 }
2828
Willy Tarreau20697042007-11-15 23:26:18 +01002829 curproxy->lbprm.wmult = 1; /* default weight multiplier */
Willy Tarreau5dc2fa62007-11-19 19:10:18 +01002830 curproxy->lbprm.wdiv = 1; /* default weight divider */
Willy Tarreaubaaee002006-06-26 02:48:02 +02002831
Willy Tarreau62c3be22012-01-20 13:12:32 +01002832 /*
2833 * If this server supports a maxconn parameter, it needs a dedicated
2834 * tasks to fill the emptied slots when a connection leaves.
2835 * Also, resolve deferred tracking dependency if needed.
2836 */
2837 newsrv = curproxy->srv;
2838 while (newsrv != NULL) {
2839 if (newsrv->minconn > newsrv->maxconn) {
2840 /* Only 'minconn' was specified, or it was higher than or equal
2841 * to 'maxconn'. Let's turn this into maxconn and clean it, as
2842 * this will avoid further useless expensive computations.
2843 */
2844 newsrv->maxconn = newsrv->minconn;
2845 } else if (newsrv->maxconn && !newsrv->minconn) {
2846 /* minconn was not specified, so we set it to maxconn */
2847 newsrv->minconn = newsrv->maxconn;
2848 }
2849
William Dauchyf6370442020-11-14 19:25:33 +01002850 /* this will also properly set the transport layer for
2851 * prod and checks
2852 * if default-server have use_ssl, prerare ssl init
2853 * without activating it */
2854 if (newsrv->use_ssl == 1 || newsrv->check.use_ssl == 1 ||
2855 (newsrv->proxy->options & PR_O_TCPCHK_SSL) ||
2856 (newsrv->use_ssl != 1 && curproxy->defsrv.use_ssl == 1)) {
Willy Tarreau17d45382016-12-22 21:16:08 +01002857 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
2858 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(newsrv);
2859 }
Emeric Brun94324a42012-10-11 14:00:19 +02002860
Willy Tarreau034c88c2017-01-23 23:36:45 +01002861 if ((newsrv->flags & SRV_F_FASTOPEN) &&
2862 ((curproxy->retry_type & (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)) !=
2863 (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)))
2864 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",
2865 newsrv->conf.file, newsrv->conf.line,
2866 proxy_type_str(curproxy), curproxy->id,
2867 newsrv->id);
2868
Willy Tarreau62c3be22012-01-20 13:12:32 +01002869 if (newsrv->trackit) {
2870 struct proxy *px;
Willy Tarreau32091232014-05-16 13:52:00 +02002871 struct server *srv, *loop;
Willy Tarreau62c3be22012-01-20 13:12:32 +01002872 char *pname, *sname;
2873
2874 pname = newsrv->trackit;
2875 sname = strrchr(pname, '/');
2876
2877 if (sname)
2878 *sname++ = '\0';
2879 else {
2880 sname = pname;
2881 pname = NULL;
2882 }
2883
2884 if (pname) {
Willy Tarreau9e0bb102015-05-26 11:24:42 +02002885 px = proxy_be_by_name(pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002886 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002887 ha_alert("config : %s '%s', server '%s': unable to find required proxy '%s' for tracking.\n",
2888 proxy_type_str(curproxy), curproxy->id,
2889 newsrv->id, pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002890 cfgerr++;
2891 goto next_srv;
2892 }
2893 } else
2894 px = curproxy;
2895
2896 srv = findserver(px, sname);
2897 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002898 ha_alert("config : %s '%s', server '%s': unable to find required server '%s' for tracking.\n",
2899 proxy_type_str(curproxy), curproxy->id,
2900 newsrv->id, sname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002901 cfgerr++;
2902 goto next_srv;
2903 }
2904
Christopher Faulet8892e5d2020-03-26 19:48:20 +01002905 if (!srv->do_check && !srv->do_agent && !srv->track && !srv->trackit) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002906 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for "
2907 "tracking as it does not have any check nor agent enabled.\n",
2908 proxy_type_str(curproxy), curproxy->id,
2909 newsrv->id, px->id, srv->id);
Willy Tarreau32091232014-05-16 13:52:00 +02002910 cfgerr++;
2911 goto next_srv;
2912 }
2913
2914 for (loop = srv->track; loop && loop != newsrv; loop = loop->track);
2915
Frédéric Lécaille2efc6492017-03-14 14:32:17 +01002916 if (newsrv == srv || loop) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002917 ha_alert("config : %s '%s', server '%s': unable to track %s/%s as it "
2918 "belongs to a tracking chain looping back to %s/%s.\n",
2919 proxy_type_str(curproxy), curproxy->id,
2920 newsrv->id, px->id, srv->id, px->id,
2921 newsrv == srv ? srv->id : loop->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002922 cfgerr++;
2923 goto next_srv;
2924 }
2925
2926 if (curproxy != px &&
2927 (curproxy->options & PR_O_DISABLE404) != (px->options & PR_O_DISABLE404)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002928 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for"
2929 "tracking: disable-on-404 option inconsistency.\n",
2930 proxy_type_str(curproxy), curproxy->id,
2931 newsrv->id, px->id, srv->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002932 cfgerr++;
2933 goto next_srv;
2934 }
2935
Willy Tarreau62c3be22012-01-20 13:12:32 +01002936 newsrv->track = srv;
Willy Tarreau1a53a3a2013-12-11 15:27:05 +01002937 newsrv->tracknext = srv->trackers;
2938 srv->trackers = newsrv;
Willy Tarreau62c3be22012-01-20 13:12:32 +01002939
2940 free(newsrv->trackit);
2941 newsrv->trackit = NULL;
2942 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002943
Willy Tarreau62c3be22012-01-20 13:12:32 +01002944 next_srv:
2945 newsrv = newsrv->next;
2946 }
2947
Olivier Houchard4e694042017-03-14 20:01:29 +01002948 /*
2949 * Try to generate dynamic cookies for servers now.
2950 * It couldn't be done earlier, since at the time we parsed
2951 * the server line, we may not have known yet that we
2952 * should use dynamic cookies, or the secret key may not
2953 * have been provided yet.
2954 */
2955 if (curproxy->ck_opts & PR_CK_DYNAMIC) {
2956 newsrv = curproxy->srv;
2957 while (newsrv != NULL) {
2958 srv_set_dyncookie(newsrv);
2959 newsrv = newsrv->next;
2960 }
2961
2962 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002963 /* We have to initialize the server lookup mechanism depending
Joseph Herlanta14c03e2018-11-15 14:04:19 -08002964 * on what LB algorithm was chosen.
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002965 */
2966
2967 curproxy->lbprm.algo &= ~(BE_LB_LKUP | BE_LB_PROP_DYN);
2968 switch (curproxy->lbprm.algo & BE_LB_KIND) {
2969 case BE_LB_KIND_RR:
Willy Tarreau9757a382009-10-03 12:56:50 +02002970 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_STATIC) {
2971 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
2972 init_server_map(curproxy);
Willy Tarreau760e81d2018-05-03 07:20:40 +02002973 } else if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_RANDOM) {
2974 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
2975 chash_init_server_tree(curproxy);
Willy Tarreau9757a382009-10-03 12:56:50 +02002976 } else {
2977 curproxy->lbprm.algo |= BE_LB_LKUP_RRTREE | BE_LB_PROP_DYN;
2978 fwrr_init_server_groups(curproxy);
2979 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002980 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02002981
Willy Tarreau3ebb1162012-02-13 16:57:44 +01002982 case BE_LB_KIND_CB:
Willy Tarreauf09c6602012-02-13 17:12:08 +01002983 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_CB_LC) {
2984 curproxy->lbprm.algo |= BE_LB_LKUP_LCTREE | BE_LB_PROP_DYN;
2985 fwlc_init_server_tree(curproxy);
2986 } else {
2987 curproxy->lbprm.algo |= BE_LB_LKUP_FSTREE | BE_LB_PROP_DYN;
2988 fas_init_server_tree(curproxy);
2989 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002990 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02002991
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002992 case BE_LB_KIND_HI:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02002993 if ((curproxy->lbprm.algo & BE_LB_HASH_TYPE) == BE_LB_HASH_CONS) {
2994 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
2995 chash_init_server_tree(curproxy);
2996 } else {
2997 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
2998 init_server_map(curproxy);
2999 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003000 break;
3001 }
Willy Tarreaucd10def2020-10-17 18:48:47 +02003002 HA_RWLOCK_INIT(&curproxy->lbprm.lock);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003003
3004 if (curproxy->options & PR_O_LOGASAP)
3005 curproxy->to_log &= ~LW_BYTES;
3006
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003007 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003008 (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->logsrvs) &&
3009 (!LIST_ISEMPTY(&curproxy->logformat) || !LIST_ISEMPTY(&curproxy->logformat_sd))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003010 ha_warning("config : log format ignored for %s '%s' since it has no log address.\n",
3011 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003012 err_code |= ERR_WARN;
3013 }
3014
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003015 if (curproxy->mode != PR_MODE_HTTP) {
3016 int optnum;
3017
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003018 if (curproxy->uri_auth) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003019 ha_warning("config : 'stats' statement ignored for %s '%s' as it requires HTTP mode.\n",
3020 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003021 err_code |= ERR_WARN;
3022 curproxy->uri_auth = NULL;
3023 }
3024
Willy Tarreaude7dc882017-03-10 11:49:21 +01003025 if (curproxy->capture_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003026 ha_warning("config : 'capture' statement ignored for %s '%s' as it requires HTTP mode.\n",
3027 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003028 err_code |= ERR_WARN;
3029 }
3030
3031 if (!LIST_ISEMPTY(&curproxy->http_req_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003032 ha_warning("config : 'http-request' rules ignored for %s '%s' as they require HTTP mode.\n",
3033 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003034 err_code |= ERR_WARN;
3035 }
3036
3037 if (!LIST_ISEMPTY(&curproxy->http_res_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003038 ha_warning("config : 'http-response' rules ignored for %s '%s' as they require HTTP mode.\n",
3039 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003040 err_code |= ERR_WARN;
3041 }
3042
Willy Tarreaude7dc882017-03-10 11:49:21 +01003043 if (!LIST_ISEMPTY(&curproxy->redirect_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003044 ha_warning("config : 'redirect' rules ignored for %s '%s' as they require HTTP mode.\n",
3045 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003046 err_code |= ERR_WARN;
3047 }
3048
Willy Tarreau87cf5142011-08-19 22:57:24 +02003049 if (curproxy->options & (PR_O_FWDFOR | PR_O_FF_ALWAYS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003050 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3051 "forwardfor", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003052 err_code |= ERR_WARN;
Willy Tarreau87cf5142011-08-19 22:57:24 +02003053 curproxy->options &= ~(PR_O_FWDFOR | PR_O_FF_ALWAYS);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003054 }
3055
3056 if (curproxy->options & PR_O_ORGTO) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003057 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3058 "originalto", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003059 err_code |= ERR_WARN;
3060 curproxy->options &= ~PR_O_ORGTO;
3061 }
3062
3063 for (optnum = 0; cfg_opts[optnum].name; optnum++) {
3064 if (cfg_opts[optnum].mode == PR_MODE_HTTP &&
3065 (curproxy->cap & cfg_opts[optnum].cap) &&
3066 (curproxy->options & cfg_opts[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003067 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3068 cfg_opts[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003069 err_code |= ERR_WARN;
3070 curproxy->options &= ~cfg_opts[optnum].val;
3071 }
3072 }
3073
3074 for (optnum = 0; cfg_opts2[optnum].name; optnum++) {
3075 if (cfg_opts2[optnum].mode == PR_MODE_HTTP &&
3076 (curproxy->cap & cfg_opts2[optnum].cap) &&
3077 (curproxy->options2 & cfg_opts2[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003078 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3079 cfg_opts2[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003080 err_code |= ERR_WARN;
3081 curproxy->options2 &= ~cfg_opts2[optnum].val;
3082 }
3083 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003084
Willy Tarreau29fbe512015-08-20 19:35:14 +02003085#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003086 if (curproxy->conn_src.bind_hdr_occ) {
3087 curproxy->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003088 ha_warning("config : %s '%s' : ignoring use of header %s as source IP in non-HTTP mode.\n",
3089 proxy_type_str(curproxy), curproxy->id, curproxy->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003090 err_code |= ERR_WARN;
3091 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003092#endif
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003093 }
3094
Willy Tarreaubaaee002006-06-26 02:48:02 +02003095 /*
Willy Tarreau21d2af32008-02-14 20:25:24 +01003096 * ensure that we're not cross-dressing a TCP server into HTTP.
3097 */
3098 newsrv = curproxy->srv;
3099 while (newsrv != NULL) {
Willy Tarreau0cec3312011-10-31 13:49:26 +01003100 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->rdr_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003101 ha_alert("config : %s '%s' : server cannot have cookie or redirect prefix in non-HTTP mode.\n",
3102 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003103 cfgerr++;
Willy Tarreau21d2af32008-02-14 20:25:24 +01003104 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003105
Willy Tarreau0cec3312011-10-31 13:49:26 +01003106 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->cklen) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003107 ha_warning("config : %s '%s' : ignoring cookie for server '%s' as HTTP mode is disabled.\n",
3108 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau0cec3312011-10-31 13:49:26 +01003109 err_code |= ERR_WARN;
3110 }
3111
Willy Tarreauc93cd162014-05-13 15:54:22 +02003112 if ((newsrv->flags & SRV_F_MAPPORTS) && (curproxy->options2 & PR_O2_RDPC_PRST)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003113 ha_warning("config : %s '%s' : RDP cookie persistence will not work for server '%s' because it lacks an explicit port number.\n",
3114 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau82ffa392013-08-13 17:19:08 +02003115 err_code |= ERR_WARN;
3116 }
3117
Willy Tarreau29fbe512015-08-20 19:35:14 +02003118#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003119 if (curproxy->mode != PR_MODE_HTTP && newsrv->conn_src.bind_hdr_occ) {
3120 newsrv->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003121 ha_warning("config : %s '%s' : server %s cannot use header %s as source IP in non-HTTP mode.\n",
3122 proxy_type_str(curproxy), curproxy->id, newsrv->id, newsrv->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003123 err_code |= ERR_WARN;
3124 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003125#endif
Willy Tarreau4c183462017-01-06 12:21:38 +01003126
Willy Tarreau46deab62018-04-28 07:18:15 +02003127 if ((curproxy->mode != PR_MODE_HTTP) && (curproxy->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR)
3128 curproxy->options &= ~PR_O_REUSE_MASK;
3129
Willy Tarreau21d2af32008-02-14 20:25:24 +01003130 newsrv = newsrv->next;
3131 }
3132
Christopher Fauletd7c91962015-04-30 11:48:27 +02003133 /* Check filter configuration, if any */
3134 cfgerr += flt_check(curproxy);
3135
Willy Tarreauc1a21672009-08-16 22:37:44 +02003136 if (curproxy->cap & PR_CAP_FE) {
Willy Tarreau050536d2012-10-04 08:47:34 +02003137 if (!curproxy->accept)
3138 curproxy->accept = frontend_accept;
Willy Tarreau81f9aa32010-06-01 17:45:26 +02003139
Willy Tarreauc1a21672009-08-16 22:37:44 +02003140 if (curproxy->tcp_req.inspect_delay ||
3141 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
Willy Tarreaufb356202010-08-03 14:02:05 +02003142 curproxy->fe_req_ana |= AN_REQ_INSPECT_FE;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003143
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003144 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003145 curproxy->fe_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_PROCESS_FE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003146 curproxy->fe_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_FE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003147 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003148
William Lallemandcf62f7e2018-10-26 14:47:40 +02003149 if (curproxy->mode == PR_MODE_CLI) {
3150 curproxy->fe_req_ana |= AN_REQ_WAIT_CLI;
3151 curproxy->fe_rsp_ana |= AN_RES_WAIT_CLI;
3152 }
3153
Willy Tarreauc1a21672009-08-16 22:37:44 +02003154 /* both TCP and HTTP must check switching rules */
3155 curproxy->fe_req_ana |= AN_REQ_SWITCHING_RULES;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003156
3157 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003158 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003159 curproxy->fe_req_ana |= AN_REQ_FLT_START_FE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3160 curproxy->fe_rsp_ana |= AN_RES_FLT_START_FE | AN_RES_FLT_XFER_DATA | AN_RES_FLT_END;
Christopher Faulet309c6412015-12-02 09:57:32 +01003161 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003162 curproxy->fe_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3163 curproxy->fe_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003164 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003165 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003166 }
3167
3168 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreaufb356202010-08-03 14:02:05 +02003169 if (curproxy->tcp_req.inspect_delay ||
3170 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
3171 curproxy->be_req_ana |= AN_REQ_INSPECT_BE;
3172
Emeric Brun97679e72010-09-23 17:56:44 +02003173 if (!LIST_ISEMPTY(&curproxy->tcp_rep.inspect_rules))
3174 curproxy->be_rsp_ana |= AN_RES_INSPECT;
3175
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003176 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003177 curproxy->be_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_INNER | AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003178 curproxy->be_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_BE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003179 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003180
3181 /* If the backend does requires RDP cookie persistence, we have to
3182 * enable the corresponding analyser.
3183 */
3184 if (curproxy->options2 & PR_O2_RDPC_PRST)
3185 curproxy->be_req_ana |= AN_REQ_PRST_RDP_COOKIE;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003186
3187 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003188 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003189 curproxy->be_req_ana |= AN_REQ_FLT_START_BE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3190 curproxy->be_rsp_ana |= AN_RES_FLT_START_BE | AN_RES_FLT_XFER_DATA | AN_RES_FLT_END;
Christopher Faulet309c6412015-12-02 09:57:32 +01003191 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003192 curproxy->be_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3193 curproxy->be_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003194 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003195 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003196 }
Christopher Fauleta717b992018-04-10 14:43:00 +02003197
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003198 /* Check the mux protocols, if any, for each listener and server
Christopher Fauleta717b992018-04-10 14:43:00 +02003199 * attached to the current proxy */
3200 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3201 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003202 const struct mux_proto_list *mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003203
3204 if (!bind_conf->mux_proto)
3205 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003206
3207 /* it is possible that an incorrect mux was referenced
3208 * due to the proxy's mode not being taken into account
3209 * on first pass. Let's adjust it now.
3210 */
3211 mux_ent = conn_get_best_mux_entry(bind_conf->mux_proto->token, PROTO_SIDE_FE, mode);
3212
3213 if (!mux_ent || !isteq(mux_ent->token, bind_conf->mux_proto->token)) {
Christopher Fauleta717b992018-04-10 14:43:00 +02003214 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for 'bind %s' at [%s:%d].\n",
3215 proxy_type_str(curproxy), curproxy->id,
3216 (int)bind_conf->mux_proto->token.len,
3217 bind_conf->mux_proto->token.ptr,
3218 bind_conf->arg, bind_conf->file, bind_conf->line);
3219 cfgerr++;
3220 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003221
3222 /* update the mux */
3223 bind_conf->mux_proto = mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003224 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003225 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3226 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003227 const struct mux_proto_list *mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003228
3229 if (!newsrv->mux_proto)
3230 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003231
3232 /* it is possible that an incorrect mux was referenced
3233 * due to the proxy's mode not being taken into account
3234 * on first pass. Let's adjust it now.
3235 */
3236 mux_ent = conn_get_best_mux_entry(newsrv->mux_proto->token, PROTO_SIDE_BE, mode);
3237
3238 if (!mux_ent || !isteq(mux_ent->token, newsrv->mux_proto->token)) {
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003239 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for server '%s' at [%s:%d].\n",
3240 proxy_type_str(curproxy), curproxy->id,
3241 (int)newsrv->mux_proto->token.len,
3242 newsrv->mux_proto->token.ptr,
3243 newsrv->id, newsrv->conf.file, newsrv->conf.line);
3244 cfgerr++;
3245 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003246
3247 /* update the mux */
3248 newsrv->mux_proto = mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003249 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003250
3251 /* initialize idle conns lists */
3252 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3253 int i;
3254
Amaury Denoyellef232cb32021-01-06 16:14:12 +01003255 newsrv->available_conns_tree = calloc(global.nbthread, sizeof(*newsrv->available_conns_tree));
Willy Tarreau835daa12019-02-07 14:46:29 +01003256
Amaury Denoyellef232cb32021-01-06 16:14:12 +01003257 if (!newsrv->available_conns_tree) {
Willy Tarreau835daa12019-02-07 14:46:29 +01003258 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
Amaury Denoyellef232cb32021-01-06 16:14:12 +01003259 newsrv->conf.file, newsrv->conf.line, newsrv->id);
Willy Tarreau835daa12019-02-07 14:46:29 +01003260 cfgerr++;
3261 continue;
3262 }
3263
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003264 for (i = 0; i < global.nbthread; i++)
Amaury Denoyellef232cb32021-01-06 16:14:12 +01003265 newsrv->available_conns_tree[i] = EB_ROOT;
Willy Tarreau980855b2019-02-07 14:59:29 +01003266
3267 if (newsrv->max_idle_conns != 0) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003268 if (idle_conn_task == NULL) {
3269 idle_conn_task = task_new(MAX_THREADS_MASK);
3270 if (!idle_conn_task)
3271 goto err;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003272
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003273 idle_conn_task->process = srv_cleanup_idle_connections;
3274 idle_conn_task->context = NULL;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003275
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003276 for (i = 0; i < global.nbthread; i++) {
Willy Tarreau4d82bf52020-06-28 00:19:17 +02003277 idle_conns[i].cleanup_task = task_new(1UL << i);
3278 if (!idle_conns[i].cleanup_task)
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003279 goto err;
Willy Tarreau4d82bf52020-06-28 00:19:17 +02003280 idle_conns[i].cleanup_task->process = srv_cleanup_toremove_connections;
3281 idle_conns[i].cleanup_task->context = NULL;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01003282 HA_SPIN_INIT(&idle_conns[i].idle_conns_lock);
Willy Tarreau4d82bf52020-06-28 00:19:17 +02003283 MT_LIST_INIT(&idle_conns[i].toremove_conns);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003284 }
3285 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003286
Amaury Denoyellef232cb32021-01-06 16:14:12 +01003287 newsrv->idle_conns_tree = calloc((unsigned short)global.nbthread, sizeof(*newsrv->idle_conns_tree));
3288 if (!newsrv->idle_conns_tree) {
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003289 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
Amaury Denoyellef232cb32021-01-06 16:14:12 +01003290 newsrv->conf.file, newsrv->conf.line, newsrv->id);
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003291 cfgerr++;
3292 continue;
3293 }
3294
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003295 for (i = 0; i < global.nbthread; i++)
Amaury Denoyellef232cb32021-01-06 16:14:12 +01003296 newsrv->idle_conns_tree[i] = EB_ROOT;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003297
Amaury Denoyellef232cb32021-01-06 16:14:12 +01003298 newsrv->safe_conns_tree = calloc(global.nbthread, sizeof(*newsrv->safe_conns_tree));
3299 if (!newsrv->safe_conns_tree) {
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003300 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
Amaury Denoyellef232cb32021-01-06 16:14:12 +01003301 newsrv->conf.file, newsrv->conf.line, newsrv->id);
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003302 cfgerr++;
3303 continue;
3304 }
3305
3306 for (i = 0; i < global.nbthread; i++)
Amaury Denoyellef232cb32021-01-06 16:14:12 +01003307 newsrv->safe_conns_tree[i] = EB_ROOT;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003308
Tim Duesterhusb53dd032020-09-12 20:26:42 +02003309 newsrv->curr_idle_thr = calloc(global.nbthread, sizeof(*newsrv->curr_idle_thr));
Olivier Houchardf1314812019-02-18 16:41:17 +01003310 if (!newsrv->curr_idle_thr)
3311 goto err;
Willy Tarreau980855b2019-02-07 14:59:29 +01003312 continue;
3313 err:
3314 ha_alert("parsing [%s:%d] : failed to allocate idle connection tasks for server '%s'.\n",
3315 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3316 cfgerr++;
3317 continue;
3318 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003319 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003320 }
3321
3322 /***********************************************************/
3323 /* At this point, target names have already been resolved. */
3324 /***********************************************************/
3325
3326 /* Check multi-process mode compatibility */
3327
3328 if (global.nbproc > 1 && global.stats_fe) {
3329 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3330 unsigned long mask;
3331
Willy Tarreau6daac192019-02-02 17:39:53 +01003332 mask = proc_mask(global.stats_fe->bind_proc) && all_proc_mask;
Willy Tarreaue26993c2020-09-03 07:18:55 +02003333 mask &= proc_mask(bind_conf->settings.bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003334
3335 /* stop here if more than one process is used */
Willy Tarreau9504dd62018-10-15 09:37:03 +02003336 if (atleast2(mask))
Willy Tarreau419ead82014-09-16 13:41:21 +02003337 break;
3338 }
3339 if (&bind_conf->by_fe != &global.stats_fe->conf.bind) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003340 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 +02003341 }
3342 }
3343
3344 /* Make each frontend inherit bind-process from its listeners when not specified. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003345 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003346 if (curproxy->bind_proc)
3347 continue;
3348
3349 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3350 unsigned long mask;
3351
Willy Tarreaue26993c2020-09-03 07:18:55 +02003352 mask = proc_mask(bind_conf->settings.bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003353 curproxy->bind_proc |= mask;
3354 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003355 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003356 }
3357
3358 if (global.stats_fe) {
3359 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3360 unsigned long mask;
3361
Willy Tarreaue26993c2020-09-03 07:18:55 +02003362 mask = bind_conf->settings.bind_proc ? bind_conf->settings.bind_proc : 0;
Willy Tarreau419ead82014-09-16 13:41:21 +02003363 global.stats_fe->bind_proc |= mask;
3364 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003365 global.stats_fe->bind_proc = proc_mask(global.stats_fe->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003366 }
3367
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003368 /* propagate bindings from frontends to backends. Don't do it if there
3369 * are any fatal errors as we must not call it with unresolved proxies.
3370 */
3371 if (!cfgerr) {
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003372 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003373 if (curproxy->cap & PR_CAP_FE)
3374 propagate_processes(curproxy, NULL);
3375 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003376 }
3377
3378 /* Bind each unbound backend to all processes when not specified. */
Willy Tarreau6daac192019-02-02 17:39:53 +01003379 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
3380 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003381
3382 /*******************************************************/
3383 /* At this step, all proxies have a non-null bind_proc */
3384 /*******************************************************/
3385
3386 /* perform the final checks before creating tasks */
3387
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003388 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003389 struct listener *listener;
3390 unsigned int next_id;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003391
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003392 /* Configure SSL for each bind line.
3393 * Note: if configuration fails at some point, the ->ctx member
3394 * remains NULL so that listeners can later detach.
3395 */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003396 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau55d37912016-12-21 23:38:39 +01003397 if (bind_conf->xprt->prepare_bind_conf &&
3398 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003399 cfgerr++;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003400 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003401
Willy Tarreaue6b98942007-10-29 01:09:36 +01003402 /* adjust this proxy's listeners */
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003403 next_id = 1;
Willy Tarreau4348fad2012-09-20 16:48:07 +02003404 list_for_each_entry(listener, &curproxy->conf.listeners, by_fe) {
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003405 int nbproc;
3406
3407 nbproc = my_popcountl(curproxy->bind_proc &
Willy Tarreaue26993c2020-09-03 07:18:55 +02003408 (listener->bind_conf->settings.bind_proc ? listener->bind_conf->settings.bind_proc : curproxy->bind_proc) &
Willy Tarreaua38a7172019-02-02 17:11:28 +01003409 all_proc_mask);
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003410
3411 if (!nbproc) /* no intersection between listener and frontend */
3412 nbproc = 1;
3413
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003414 if (!listener->luid) {
3415 /* listener ID not set, use automatic numbering with first
3416 * spare entry starting with next_luid.
3417 */
3418 next_id = get_next_id(&curproxy->conf.used_listener_id, next_id);
3419 listener->conf.id.key = listener->luid = next_id;
3420 eb32_insert(&curproxy->conf.used_listener_id, &listener->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003421 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01003422 next_id++;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003423
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003424 /* enable separate counters */
3425 if (curproxy->options2 & PR_O2_SOCKSTAT) {
Willy Tarreauae9bea02016-11-25 14:44:52 +01003426 listener->counters = calloc(1, sizeof(*listener->counters));
Willy Tarreau19d14ef2012-10-29 16:51:55 +01003427 if (!listener->name)
3428 memprintf(&listener->name, "sock-%d", listener->luid);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003429 }
Willy Tarreau81796be2012-09-22 19:11:47 +02003430
Willy Tarreaue6b98942007-10-29 01:09:36 +01003431 if (curproxy->options & PR_O_TCP_NOLING)
3432 listener->options |= LI_O_NOLINGER;
Willy Tarreau16a21472012-11-19 12:39:59 +01003433 if (!listener->maxaccept)
Willy Tarreau66161322021-02-19 15:50:27 +01003434 listener->maxaccept = global.tune.maxaccept ? global.tune.maxaccept : MAX_ACCEPT;
Willy Tarreau16a21472012-11-19 12:39:59 +01003435
3436 /* we want to have an optimal behaviour on single process mode to
3437 * maximize the work at once, but in multi-process we want to keep
3438 * some fairness between processes, so we target half of the max
3439 * number of events to be balanced over all the processes the proxy
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05003440 * is bound to. Remember that maxaccept = -1 must be kept as it is
Willy Tarreau16a21472012-11-19 12:39:59 +01003441 * used to disable the limit.
3442 */
Christopher Faulet02f3cf12019-04-30 14:08:41 +02003443 if (listener->maxaccept > 0 && nbproc > 1) {
3444 listener->maxaccept = (listener->maxaccept + 1) / 2;
Willy Tarreau16a21472012-11-19 12:39:59 +01003445 listener->maxaccept = (listener->maxaccept + nbproc - 1) / nbproc;
3446 }
3447
Willy Tarreau9903f0e2015-04-04 18:50:31 +02003448 listener->accept = session_accept_fd;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003449 listener->analysers |= curproxy->fe_req_ana;
Willy Tarreau10b688f2015-03-13 16:43:12 +01003450 listener->default_target = curproxy->default_target;
Willy Tarreau3bc13772008-12-07 11:50:35 +01003451
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003452 if (!LIST_ISEMPTY(&curproxy->tcp_req.l4_rules))
Willy Tarreau7d9736f2016-10-21 16:34:21 +02003453 listener->options |= LI_O_TCP_L4_RULES;
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003454
Willy Tarreau620408f2016-10-21 16:37:51 +02003455 if (!LIST_ISEMPTY(&curproxy->tcp_req.l5_rules))
3456 listener->options |= LI_O_TCP_L5_RULES;
3457
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003458 /* smart accept mode is automatic in HTTP mode */
3459 if ((curproxy->options2 & PR_O2_SMARTACC) ||
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003460 ((curproxy->mode == PR_MODE_HTTP || listener->bind_conf->is_ssl) &&
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003461 !(curproxy->no_options2 & PR_O2_SMARTACC)))
3462 listener->options |= LI_O_NOQUICKACK;
Willy Tarreaue6b98942007-10-29 01:09:36 +01003463 }
3464
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003465 /* Release unused SSL configs */
3466 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau795cdab2016-12-22 17:30:54 +01003467 if (!bind_conf->is_ssl && bind_conf->xprt->destroy_bind_conf)
3468 bind_conf->xprt->destroy_bind_conf(bind_conf);
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003469 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003470
Willy Tarreaua38a7172019-02-02 17:11:28 +01003471 if (atleast2(curproxy->bind_proc & all_proc_mask)) {
Willy Tarreau102df612014-05-07 23:56:38 +02003472 if (curproxy->uri_auth) {
Willy Tarreaueb791e02014-09-16 15:11:04 +02003473 int count, maxproc = 0;
3474
3475 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreaue26993c2020-09-03 07:18:55 +02003476 count = my_popcountl(bind_conf->settings.bind_proc);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003477 if (count > maxproc)
3478 maxproc = count;
3479 }
3480 /* backends have 0, frontends have 1 or more */
3481 if (maxproc != 1)
Christopher Faulet767a84b2017-11-24 16:50:31 +01003482 ha_warning("Proxy '%s': in multi-process mode, stats will be"
3483 " limited to process assigned to the current request.\n",
3484 curproxy->id);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003485
Willy Tarreau102df612014-05-07 23:56:38 +02003486 if (!LIST_ISEMPTY(&curproxy->uri_auth->admin_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003487 ha_warning("Proxy '%s': stats admin will not work correctly in multi-process mode.\n",
3488 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003489 }
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003490 }
Willy Tarreau102df612014-05-07 23:56:38 +02003491 if (!LIST_ISEMPTY(&curproxy->sticking_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003492 ha_warning("Proxy '%s': sticking rules will not work correctly in multi-process mode.\n",
3493 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003494 }
3495 }
Willy Tarreau918ff602011-07-25 16:33:49 +02003496
3497 /* create the task associated with the proxy */
Emeric Brunc60def82017-09-27 14:59:38 +02003498 curproxy->task = task_new(MAX_THREADS_MASK);
Willy Tarreau918ff602011-07-25 16:33:49 +02003499 if (curproxy->task) {
3500 curproxy->task->context = curproxy;
3501 curproxy->task->process = manage_proxy;
Willy Tarreau918ff602011-07-25 16:33:49 +02003502 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003503 ha_alert("Proxy '%s': no more memory when trying to allocate the management task\n",
3504 curproxy->id);
Willy Tarreau918ff602011-07-25 16:33:49 +02003505 cfgerr++;
3506 }
Willy Tarreaub369a042014-09-16 13:21:03 +02003507 }
3508
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003509 /*
3510 * Recount currently required checks.
3511 */
3512
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003513 for (curproxy=proxies_list; curproxy; curproxy=curproxy->next) {
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003514 int optnum;
3515
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003516 for (optnum = 0; cfg_opts[optnum].name; optnum++)
3517 if (curproxy->options & cfg_opts[optnum].val)
3518 global.last_checks |= cfg_opts[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003519
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003520 for (optnum = 0; cfg_opts2[optnum].name; optnum++)
3521 if (curproxy->options2 & cfg_opts2[optnum].val)
3522 global.last_checks |= cfg_opts2[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003523 }
3524
Willy Tarreau0fca4832015-05-01 19:12:05 +02003525 /* compute the required process bindings for the peers */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003526 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003527 if (curproxy->table && curproxy->table->peers.p)
3528 curproxy->table->peers.p->peers_fe->bind_proc |= curproxy->bind_proc;
Willy Tarreau0fca4832015-05-01 19:12:05 +02003529
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01003530 /* compute the required process bindings for the peers from <stktables_list>
3531 * for all the stick-tables, the ones coming with "peers" sections included.
3532 */
3533 for (t = stktables_list; t; t = t->next) {
3534 struct proxy *p;
3535
3536 for (p = t->proxies_list; p; p = p->next_stkt_ref) {
3537 if (t->peers.p && t->peers.p->peers_fe) {
3538 t->peers.p->peers_fe->bind_proc |= p->bind_proc;
3539 }
3540 }
3541 }
3542
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003543 if (cfg_peers) {
3544 struct peers *curpeers = cfg_peers, **last;
Willy Tarreau122541c2011-09-07 21:24:49 +02003545 struct peer *p, *pb;
3546
William Lallemanda2cfd7e2020-03-24 16:02:48 +01003547 /* In the case the peers frontend was not initialized by a
3548 stick-table used in the configuration, set its bind_proc
3549 by default to the first process. */
3550 while (curpeers) {
William Lallemand3ef2d562020-03-24 16:42:15 +01003551 if (curpeers->peers_fe) {
3552 if (curpeers->peers_fe->bind_proc == 0)
3553 curpeers->peers_fe->bind_proc = 1;
3554 }
William Lallemanda2cfd7e2020-03-24 16:02:48 +01003555 curpeers = curpeers->next;
3556 }
3557
3558 curpeers = cfg_peers;
Willy Tarreau1e273012015-05-01 19:15:17 +02003559 /* Remove all peers sections which don't have a valid listener,
3560 * which are not used by any table, or which are bound to more
3561 * than one process.
Willy Tarreau122541c2011-09-07 21:24:49 +02003562 */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003563 last = &cfg_peers;
Willy Tarreau122541c2011-09-07 21:24:49 +02003564 while (*last) {
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003565 struct stktable *t;
Willy Tarreau122541c2011-09-07 21:24:49 +02003566 curpeers = *last;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003567
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02003568 if (curpeers->disabled) {
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003569 /* the "disabled" keyword was present */
3570 if (curpeers->peers_fe)
3571 stop_proxy(curpeers->peers_fe);
3572 curpeers->peers_fe = NULL;
3573 }
Frédéric Lécaille5a4fe5a2019-10-04 08:30:04 +02003574 else if (!curpeers->peers_fe || !curpeers->peers_fe->id) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003575 ha_warning("Removing incomplete section 'peers %s' (no peer named '%s').\n",
3576 curpeers->id, localpeer);
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003577 if (curpeers->peers_fe)
3578 stop_proxy(curpeers->peers_fe);
3579 curpeers->peers_fe = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003580 }
Willy Tarreau9504dd62018-10-15 09:37:03 +02003581 else if (atleast2(curpeers->peers_fe->bind_proc)) {
Willy Tarreau1e273012015-05-01 19:15:17 +02003582 /* either it's totally stopped or too much used */
3583 if (curpeers->peers_fe->bind_proc) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003584 ha_alert("Peers section '%s': peers referenced by sections "
3585 "running in different processes (%d different ones). "
3586 "Check global.nbproc and all tables' bind-process "
3587 "settings.\n", curpeers->id, my_popcountl(curpeers->peers_fe->bind_proc));
Willy Tarreau1e273012015-05-01 19:15:17 +02003588 cfgerr++;
3589 }
3590 stop_proxy(curpeers->peers_fe);
3591 curpeers->peers_fe = NULL;
3592 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003593 else {
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01003594 /* Initializes the transport layer of the server part of all the peers belonging to
3595 * <curpeers> section if required.
3596 * Note that ->srv is used by the local peer of a new process to connect to the local peer
3597 * of an old process.
3598 */
Frédéric Lécaille1055e682018-04-26 14:35:21 +02003599 p = curpeers->remote;
3600 while (p) {
Frédéric Lécaille355b2032019-01-11 14:06:12 +01003601 if (p->srv) {
Christopher Fauletf61f33a2020-03-27 18:55:49 +01003602 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 +01003603 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(p->srv);
3604 }
Frédéric Lécaille1055e682018-04-26 14:35:21 +02003605 p = p->next;
3606 }
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01003607 /* Configure the SSL bindings of the local peer if required. */
3608 if (!LIST_ISEMPTY(&curpeers->peers_fe->conf.bind)) {
3609 struct list *l;
3610 struct bind_conf *bind_conf;
3611
3612 l = &curpeers->peers_fe->conf.bind;
3613 bind_conf = LIST_ELEM(l->n, typeof(bind_conf), by_fe);
3614 if (bind_conf->xprt->prepare_bind_conf &&
3615 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
3616 cfgerr++;
3617 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02003618 if (!peers_init_sync(curpeers) || !peers_alloc_dcache(curpeers)) {
Willy Tarreaud9443442018-10-15 11:18:03 +02003619 ha_alert("Peers section '%s': out of memory, giving up on peers.\n",
3620 curpeers->id);
3621 cfgerr++;
3622 break;
3623 }
Willy Tarreau122541c2011-09-07 21:24:49 +02003624 last = &curpeers->next;
3625 continue;
3626 }
3627
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003628 /* clean what has been detected above */
Willy Tarreau122541c2011-09-07 21:24:49 +02003629 p = curpeers->remote;
3630 while (p) {
3631 pb = p->next;
3632 free(p->id);
3633 free(p);
3634 p = pb;
3635 }
3636
3637 /* Destroy and unlink this curpeers section.
3638 * Note: curpeers is backed up into *last.
3639 */
3640 free(curpeers->id);
3641 curpeers = curpeers->next;
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003642 /* Reset any refereance to this peers section in the list of stick-tables */
3643 for (t = stktables_list; t; t = t->next) {
3644 if (t->peers.p && t->peers.p == *last)
3645 t->peers.p = NULL;
3646 }
Willy Tarreau122541c2011-09-07 21:24:49 +02003647 free(*last);
3648 *last = curpeers;
3649 }
3650 }
3651
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003652 for (t = stktables_list; t; t = t->next) {
3653 if (t->proxy)
3654 continue;
3655 if (!stktable_init(t)) {
3656 ha_alert("Proxy '%s': failed to initialize stick-table.\n", t->id);
3657 cfgerr++;
3658 }
3659 }
3660
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003661 /* initialize stick-tables on backend capable proxies. This must not
3662 * be done earlier because the data size may be discovered while parsing
3663 * other proxies.
3664 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003665 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauc3914d42020-09-24 08:39:22 +02003666 if (curproxy->disabled || !curproxy->table)
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003667 continue;
3668
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003669 if (!stktable_init(curproxy->table)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003670 ha_alert("Proxy '%s': failed to initialize stick-table.\n", curproxy->id);
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003671 cfgerr++;
3672 }
3673 }
3674
Simon Horman0d16a402015-01-30 11:22:58 +09003675 if (mailers) {
3676 struct mailers *curmailers = mailers, **last;
3677 struct mailer *m, *mb;
3678
3679 /* Remove all mailers sections which don't have a valid listener.
3680 * This can happen when a mailers section is never referenced.
3681 */
3682 last = &mailers;
3683 while (*last) {
3684 curmailers = *last;
3685 if (curmailers->users) {
3686 last = &curmailers->next;
3687 continue;
3688 }
3689
Christopher Faulet767a84b2017-11-24 16:50:31 +01003690 ha_warning("Removing incomplete section 'mailers %s'.\n",
3691 curmailers->id);
Simon Horman0d16a402015-01-30 11:22:58 +09003692
3693 m = curmailers->mailer_list;
3694 while (m) {
3695 mb = m->next;
3696 free(m->id);
3697 free(m);
3698 m = mb;
3699 }
3700
3701 /* Destroy and unlink this curmailers section.
3702 * Note: curmailers is backed up into *last.
3703 */
3704 free(curmailers->id);
3705 curmailers = curmailers->next;
3706 free(*last);
3707 *last = curmailers;
3708 }
3709 }
3710
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003711 /* Update server_state_file_name to backend name if backend is supposed to use
3712 * a server-state file locally defined and none has been provided */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003713 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003714 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_LOCAL &&
3715 curproxy->server_state_file_name == NULL)
3716 curproxy->server_state_file_name = strdup(curproxy->id);
3717 }
3718
Emeric Brun750fe792020-12-23 16:51:12 +01003719 list_for_each_entry(curr_resolvers, &sec_resolvers, list) {
Ben Draut054fbee2018-04-13 15:43:04 -06003720 if (LIST_ISEMPTY(&curr_resolvers->nameservers)) {
3721 ha_warning("config : resolvers '%s' [%s:%d] has no nameservers configured!\n",
3722 curr_resolvers->id, curr_resolvers->conf.file,
3723 curr_resolvers->conf.line);
3724 err_code |= ERR_WARN;
3725 }
3726 }
3727
William Lallemand48b4bb42017-10-23 14:36:34 +02003728 list_for_each_entry(postparser, &postparsers, list) {
3729 if (postparser->func)
3730 cfgerr += postparser->func();
3731 }
3732
Willy Tarreaubb925012009-07-23 13:36:36 +02003733 if (cfgerr > 0)
3734 err_code |= ERR_ALERT | ERR_FATAL;
3735 out:
3736 return err_code;
Willy Tarreaubaaee002006-06-26 02:48:02 +02003737}
3738
Willy Tarreau5b2c3362008-07-09 19:39:06 +02003739/*
3740 * Registers the CFG keyword list <kwl> as a list of valid keywords for next
3741 * parsing sessions.
3742 */
3743void cfg_register_keywords(struct cfg_kw_list *kwl)
3744{
3745 LIST_ADDQ(&cfg_keywords.list, &kwl->list);
3746}
Willy Tarreaubaaee002006-06-26 02:48:02 +02003747
Willy Tarreau5b2c3362008-07-09 19:39:06 +02003748/*
3749 * Unregisters the CFG keyword list <kwl> from the list of valid keywords.
3750 */
3751void cfg_unregister_keywords(struct cfg_kw_list *kwl)
3752{
3753 LIST_DEL(&kwl->list);
3754 LIST_INIT(&kwl->list);
3755}
Willy Tarreaubaaee002006-06-26 02:48:02 +02003756
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003757/* this function register new section in the haproxy configuration file.
3758 * <section_name> is the name of this new section and <section_parser>
3759 * is the called parser. If two section declaration have the same name,
3760 * only the first declared is used.
3761 */
3762int cfg_register_section(char *section_name,
William Lallemandd2ff56d2017-10-16 11:06:50 +02003763 int (*section_parser)(const char *, int, char **, int),
3764 int (*post_section_parser)())
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003765{
3766 struct cfg_section *cs;
3767
Willy Tarreau5e4261b2016-05-17 16:16:09 +02003768 list_for_each_entry(cs, &sections, list) {
3769 if (strcmp(cs->section_name, section_name) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003770 ha_alert("register section '%s': already registered.\n", section_name);
Willy Tarreau5e4261b2016-05-17 16:16:09 +02003771 return 0;
3772 }
3773 }
3774
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003775 cs = calloc(1, sizeof(*cs));
3776 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003777 ha_alert("register section '%s': out of memory.\n", section_name);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003778 return 0;
3779 }
3780
3781 cs->section_name = section_name;
3782 cs->section_parser = section_parser;
William Lallemandd2ff56d2017-10-16 11:06:50 +02003783 cs->post_section_parser = post_section_parser;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003784
3785 LIST_ADDQ(&sections, &cs->list);
3786
3787 return 1;
3788}
3789
William Lallemand48b4bb42017-10-23 14:36:34 +02003790/* this function register a new function which will be called once the haproxy
3791 * configuration file has been parsed. It's useful to check dependencies
3792 * between sections or to resolve items once everything is parsed.
3793 */
3794int cfg_register_postparser(char *name, int (*func)())
3795{
3796 struct cfg_postparser *cp;
3797
3798 cp = calloc(1, sizeof(*cp));
3799 if (!cp) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003800 ha_alert("register postparser '%s': out of memory.\n", name);
William Lallemand48b4bb42017-10-23 14:36:34 +02003801 return 0;
3802 }
3803 cp->name = name;
3804 cp->func = func;
3805
3806 LIST_ADDQ(&postparsers, &cp->list);
3807
3808 return 1;
3809}
3810
Willy Tarreaubaaee002006-06-26 02:48:02 +02003811/*
David Carlier845efb52015-09-25 11:49:18 +01003812 * free all config section entries
3813 */
3814void cfg_unregister_sections(void)
3815{
3816 struct cfg_section *cs, *ics;
3817
3818 list_for_each_entry_safe(cs, ics, &sections, list) {
3819 LIST_DEL(&cs->list);
3820 free(cs);
3821 }
3822}
3823
Christopher Faulet7110b402016-10-26 11:09:44 +02003824void cfg_backup_sections(struct list *backup_sections)
3825{
3826 struct cfg_section *cs, *ics;
3827
3828 list_for_each_entry_safe(cs, ics, &sections, list) {
3829 LIST_DEL(&cs->list);
3830 LIST_ADDQ(backup_sections, &cs->list);
3831 }
3832}
3833
3834void cfg_restore_sections(struct list *backup_sections)
3835{
3836 struct cfg_section *cs, *ics;
3837
3838 list_for_each_entry_safe(cs, ics, backup_sections, list) {
3839 LIST_DEL(&cs->list);
3840 LIST_ADDQ(&sections, &cs->list);
3841 }
3842}
3843
Willy Tarreaue6552512018-11-26 11:33:13 +01003844/* these are the config sections handled by default */
3845REGISTER_CONFIG_SECTION("listen", cfg_parse_listen, NULL);
3846REGISTER_CONFIG_SECTION("frontend", cfg_parse_listen, NULL);
3847REGISTER_CONFIG_SECTION("backend", cfg_parse_listen, NULL);
3848REGISTER_CONFIG_SECTION("defaults", cfg_parse_listen, NULL);
3849REGISTER_CONFIG_SECTION("global", cfg_parse_global, NULL);
3850REGISTER_CONFIG_SECTION("userlist", cfg_parse_users, NULL);
3851REGISTER_CONFIG_SECTION("peers", cfg_parse_peers, NULL);
3852REGISTER_CONFIG_SECTION("mailers", cfg_parse_mailers, NULL);
3853REGISTER_CONFIG_SECTION("namespace_list", cfg_parse_netns, NULL);
Willy Tarreau659fbf02016-05-26 17:55:28 +02003854
David Carlier845efb52015-09-25 11:49:18 +01003855/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02003856 * Local variables:
3857 * c-indent-level: 8
3858 * c-basic-offset: 8
3859 * End:
3860 */