blob: 8f612ee3c8b3851250c213a007479392711ed10c [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>
Christopher Faulet42c6cf92021-03-25 17:19:04 +010037#include <haproxy/action.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
Eric Salama1b8dacc2021-03-16 15:12:17 +010091extern struct proxy *mworker_proxy;
92
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +010093char *cursection = NULL;
Willy Tarreauc8d5b952019-02-27 17:25:52 +010094int cfg_maxpconn = 0; /* # of simultaneous connections per proxy (-N) */
Willy Tarreau5af24ef2009-03-15 15:23:16 +010095int cfg_maxconn = 0; /* # of simultaneous connections, (-n) */
Christopher Faulet79bdef32016-11-04 22:36:15 +010096char *cfg_scope = NULL; /* the current scope during the configuration parsing */
Willy Tarreaubaaee002006-06-26 02:48:02 +020097
Willy Tarreau5b2c3362008-07-09 19:39:06 +020098/* List head of all known configuration keywords */
Willy Tarreau36b9e222018-11-11 15:19:52 +010099struct cfg_kw_list cfg_keywords = {
Willy Tarreau5b2c3362008-07-09 19:39:06 +0200100 .list = LIST_HEAD_INIT(cfg_keywords.list)
101};
102
Willy Tarreau4b103022021-02-12 17:59:10 +0100103/* nested if/elif/else/endif block states */
104enum nested_cond_state {
105 NESTED_COND_IF_TAKE, // "if" with a true condition
106 NESTED_COND_IF_DROP, // "if" with a false condition
107 NESTED_COND_IF_SKIP, // "if" masked by an outer false condition
108
109 NESTED_COND_ELIF_TAKE, // "elif" with a true condition from a false one
110 NESTED_COND_ELIF_DROP, // "elif" with a false condition from a false one
111 NESTED_COND_ELIF_SKIP, // "elif" masked by an outer false condition or a previously taken if
112
113 NESTED_COND_ELSE_TAKE, // taken "else" after an if false condition
114 NESTED_COND_ELSE_DROP, // "else" masked by outer false condition or an if true condition
115};
116
117/* 100 levels of nested conditions should already be sufficient */
118#define MAXNESTEDCONDS 100
119
Willy Tarreaubaaee002006-06-26 02:48:02 +0200120/*
121 * converts <str> to a list of listeners which are dynamically allocated.
122 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
123 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
124 * - <port> is a numerical port from 1 to 65535 ;
125 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
126 * This can be repeated as many times as necessary, separated by a coma.
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200127 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
128 * not NULL, it must be a valid pointer to either NULL or a freeable area that
129 * will be replaced with an error message.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200130 */
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200131int 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 +0200132{
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200133 struct protocol *proto;
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100134 char *next, *dupstr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200135 int port, end;
136
137 next = dupstr = strdup(str);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200138
Willy Tarreaubaaee002006-06-26 02:48:02 +0200139 while (next && *next) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200140 struct sockaddr_storage *ss2;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100141 int fd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200142
143 str = next;
144 /* 1) look for the end of the first address */
Krzysztof Piotr Oledzki52d522b2009-01-27 16:57:08 +0100145 if ((next = strchr(str, ',')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200146 *next++ = 0;
147 }
148
Willy Tarreau5fc93282020-09-16 18:25:03 +0200149 ss2 = str2sa_range(str, NULL, &port, &end, &fd, &proto, err,
Eric Salama1b8dacc2021-03-16 15:12:17 +0100150 (curproxy == global.cli_fe || curproxy == mworker_proxy) ? NULL : global.unix_bind.prefix,
Willy Tarreau32819932020-09-04 15:53:16 +0200151 NULL, PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_PORT_RANGE |
Willy Tarreau5e1779a2020-09-16 16:28:08 +0200152 PA_O_SOCKET_FD | PA_O_STREAM | PA_O_XPRT);
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100153 if (!ss2)
154 goto fail;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200155
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100156 /* OK the address looks correct */
Frédéric Lécaille884f2e92020-11-23 14:23:21 +0100157
158#ifdef USE_QUIC
159 /* The transport layer automatically switches to QUIC when QUIC
160 * is selected, regardless of bind_conf settings. We then need
161 * to initialize QUIC params.
162 */
163 if (proto->sock_type == SOCK_DGRAM && proto->ctrl_type == SOCK_STREAM) {
164 bind_conf->xprt = xprt_get(XPRT_QUIC);
165 quic_transport_params_init(&bind_conf->quic_params, 1);
166 }
167#endif
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200168 if (!create_listeners(bind_conf, ss2, port, end, fd, proto, err)) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200169 memprintf(err, "%s for address '%s'.\n", *err, str);
170 goto fail;
171 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200172 } /* end while(next) */
173 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200174 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200175 fail:
176 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200177 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200178}
179
William Lallemand6e62fb62015-04-28 16:55:23 +0200180/*
Willy Tarreauaa333122020-09-16 15:13:04 +0200181 * converts <str> to a list of datagram-oriented listeners which are dynamically
182 * allocated.
183 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
184 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
185 * - <port> is a numerical port from 1 to 65535 ;
186 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
187 * This can be repeated as many times as necessary, separated by a coma.
188 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
189 * not NULL, it must be a valid pointer to either NULL or a freeable area that
190 * will be replaced with an error message.
191 */
192int str2receiver(char *str, struct proxy *curproxy, struct bind_conf *bind_conf, const char *file, int line, char **err)
193{
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200194 struct protocol *proto;
Willy Tarreauaa333122020-09-16 15:13:04 +0200195 char *next, *dupstr;
196 int port, end;
197
198 next = dupstr = strdup(str);
199
200 while (next && *next) {
201 struct sockaddr_storage *ss2;
202 int fd = -1;
203
204 str = next;
205 /* 1) look for the end of the first address */
206 if ((next = strchr(str, ',')) != NULL) {
207 *next++ = 0;
208 }
209
Willy Tarreau5fc93282020-09-16 18:25:03 +0200210 ss2 = str2sa_range(str, NULL, &port, &end, &fd, &proto, err,
Willy Tarreau4975d142021-03-13 11:00:33 +0100211 curproxy == global.cli_fe ? NULL : global.unix_bind.prefix,
Willy Tarreauaa333122020-09-16 15:13:04 +0200212 NULL, PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_PORT_RANGE |
213 PA_O_SOCKET_FD | PA_O_DGRAM | PA_O_XPRT);
214 if (!ss2)
215 goto fail;
216
217 /* OK the address looks correct */
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200218 if (!create_listeners(bind_conf, ss2, port, end, fd, proto, err)) {
Willy Tarreauaa333122020-09-16 15:13:04 +0200219 memprintf(err, "%s for address '%s'.\n", *err, str);
220 goto fail;
221 }
222 } /* end while(next) */
223 free(dupstr);
224 return 1;
225 fail:
226 free(dupstr);
227 return 0;
228}
229
230/*
Willy Tarreauece9b072016-12-21 22:41:44 +0100231 * Report an error in <msg> when there are too many arguments. This version is
232 * intended to be used by keyword parsers so that the message will be included
233 * into the general error message. The index is the current keyword in args.
234 * Return 0 if the number of argument is correct, otherwise build a message and
235 * return 1. Fill err_code with an ERR_ALERT and an ERR_FATAL if not null. The
236 * message may also be null, it will simply not be produced (useful to check only).
237 * <msg> and <err_code> are only affected on error.
238 */
239int too_many_args_idx(int maxarg, int index, char **args, char **msg, int *err_code)
240{
241 int i;
242
243 if (!*args[index + maxarg + 1])
244 return 0;
245
246 if (msg) {
247 *msg = NULL;
248 memprintf(msg, "%s", args[0]);
249 for (i = 1; i <= index; i++)
250 memprintf(msg, "%s %s", *msg, args[i]);
251
252 memprintf(msg, "'%s' cannot handle unexpected argument '%s'.", *msg, args[index + maxarg + 1]);
253 }
254 if (err_code)
255 *err_code |= ERR_ALERT | ERR_FATAL;
256
257 return 1;
258}
259
260/*
261 * same as too_many_args_idx with a 0 index
262 */
263int too_many_args(int maxarg, char **args, char **msg, int *err_code)
264{
265 return too_many_args_idx(maxarg, 0, args, msg, err_code);
266}
267
268/*
William Lallemand6e62fb62015-04-28 16:55:23 +0200269 * Report a fatal Alert when there is too much arguments
270 * The index is the current keyword in args
271 * Return 0 if the number of argument is correct, otherwise emit an alert and return 1
272 * Fill err_code with an ERR_ALERT and an ERR_FATAL
273 */
274int alertif_too_many_args_idx(int maxarg, int index, const char *file, int linenum, char **args, int *err_code)
275{
276 char *kw = NULL;
277 int i;
278
279 if (!*args[index + maxarg + 1])
280 return 0;
281
282 memprintf(&kw, "%s", args[0]);
283 for (i = 1; i <= index; i++) {
284 memprintf(&kw, "%s %s", kw, args[i]);
285 }
286
Christopher Faulet767a84b2017-11-24 16:50:31 +0100287 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 +0200288 free(kw);
289 *err_code |= ERR_ALERT | ERR_FATAL;
290 return 1;
291}
292
293/*
294 * same as alertif_too_many_args_idx with a 0 index
295 */
296int alertif_too_many_args(int maxarg, const char *file, int linenum, char **args, int *err_code)
297{
298 return alertif_too_many_args_idx(maxarg, 0, file, linenum, args, err_code);
299}
300
Willy Tarreau61d18892009-03-31 10:49:21 +0200301
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100302/* Report it if a request ACL condition uses some keywords that are incompatible
303 * with the place where the ACL is used. It returns either 0 or ERR_WARN so that
304 * its result can be or'ed with err_code. Note that <cond> may be NULL and then
305 * will be ignored.
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100306 */
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100307int warnif_cond_conflicts(const struct acl_cond *cond, unsigned int where, const char *file, int line)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100308{
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100309 const struct acl *acl;
Willy Tarreau93fddf12013-03-31 22:59:32 +0200310 const char *kw;
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100311
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100312 if (!cond)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100313 return 0;
314
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100315 acl = acl_cond_conflicts(cond, where);
316 if (acl) {
317 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100318 ha_warning("parsing [%s:%d] : acl '%s' will never match because it only involves keywords that are incompatible with '%s'\n",
319 file, line, acl->name, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100320 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100321 ha_warning("parsing [%s:%d] : anonymous acl will never match because it uses keyword '%s' which is incompatible with '%s'\n",
322 file, line, LIST_ELEM(acl->expr.n, struct acl_expr *, list)->kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100323 return ERR_WARN;
324 }
325 if (!acl_cond_kw_conflicts(cond, where, &acl, &kw))
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100326 return 0;
327
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100328 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100329 ha_warning("parsing [%s:%d] : acl '%s' involves keywords '%s' which is incompatible with '%s'\n",
330 file, line, acl->name, kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100331 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100332 ha_warning("parsing [%s:%d] : anonymous acl involves keyword '%s' which is incompatible with '%s'\n",
333 file, line, kw, sample_ckp_names(where));
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100334 return ERR_WARN;
335}
336
Christopher Faulet581db2b2021-03-26 10:02:46 +0100337/* Report it if an ACL uses a L6 sample fetch from an HTTP proxy. It returns
338 * either 0 or ERR_WARN so that its result can be or'ed with err_code. Note that
339 * <cond> may be NULL and then will be ignored.
340*/
341int warnif_tcp_http_cond(const struct proxy *px, const struct acl_cond *cond)
342{
343 if (!cond || px->mode != PR_MODE_HTTP)
344 return 0;
345
346 if (cond->use & (SMP_USE_L6REQ|SMP_USE_L6RES)) {
347 ha_warning("Proxy '%s': L6 sample fetches ignored on HTTP proxies (declared at %s:%d).\n",
348 px->id, cond->file, cond->line);
349 return ERR_WARN;
350 }
351 return 0;
352}
353
Willy Tarreaue2afcc42021-03-12 09:08:04 +0100354/* try to find in <list> the word that looks closest to <word> by counting
355 * transitions between letters, digits and other characters. Will return the
356 * best matching word if found, otherwise NULL. An optional array of extra
357 * words to compare may be passed in <extra>, but it must then be terminated
358 * by a NULL entry. If unused it may be NULL.
359 */
360const char *cfg_find_best_match(const char *word, const struct list *list, int section, const char **extra)
361{
362 uint8_t word_sig[1024]; // 0..25=letter, 26=digit, 27=other, 28=begin, 29=end
363 uint8_t list_sig[1024];
364 const struct cfg_kw_list *kwl;
365 int index;
366 const char *best_ptr = NULL;
367 int dist, best_dist = INT_MAX;
368
369 make_word_fingerprint(word_sig, word);
370 list_for_each_entry(kwl, list, list) {
371 for (index = 0; kwl->kw[index].kw != NULL; index++) {
372 if (kwl->kw[index].section != section)
373 continue;
374
375 make_word_fingerprint(list_sig, kwl->kw[index].kw);
376 dist = word_fingerprint_distance(word_sig, list_sig);
377 if (dist < best_dist) {
378 best_dist = dist;
379 best_ptr = kwl->kw[index].kw;
380 }
381 }
382 }
383
384 while (extra && *extra) {
385 make_word_fingerprint(list_sig, *extra);
386 dist = word_fingerprint_distance(word_sig, list_sig);
387 if (dist < best_dist) {
388 best_dist = dist;
389 best_ptr = *extra;
390 }
391 extra++;
392 }
393
394 if (best_dist > 2 * strlen(word) || (best_ptr && best_dist > 2 * strlen(best_ptr)))
395 best_ptr = NULL;
396 return best_ptr;
397}
398
Christopher Faulet62519022017-10-16 15:49:32 +0200399/* Parse a string representing a process number or a set of processes. It must
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100400 * be "all", "odd", "even", a number between 1 and <max> or a range with
Christopher Faulet5ab51772017-11-22 11:21:58 +0100401 * two such numbers delimited by a dash ('-'). On success, it returns
402 * 0. otherwise it returns 1 with an error message in <err>.
Christopher Faulet62519022017-10-16 15:49:32 +0200403 *
404 * Note: this function can also be used to parse a thread number or a set of
405 * threads.
406 */
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100407int parse_process_number(const char *arg, unsigned long *proc, int max, int *autoinc, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200408{
Christopher Faulet26028f62017-11-22 15:01:51 +0100409 if (autoinc) {
410 *autoinc = 0;
411 if (strncmp(arg, "auto:", 5) == 0) {
412 arg += 5;
413 *autoinc = 1;
414 }
415 }
416
Christopher Faulet62519022017-10-16 15:49:32 +0200417 if (strcmp(arg, "all") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100418 *proc |= ~0UL;
Christopher Faulet62519022017-10-16 15:49:32 +0200419 else if (strcmp(arg, "odd") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100420 *proc |= ~0UL/3UL; /* 0x555....555 */
Christopher Faulet62519022017-10-16 15:49:32 +0200421 else if (strcmp(arg, "even") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100422 *proc |= (~0UL/3UL) << 1; /* 0xAAA...AAA */
Christopher Faulet62519022017-10-16 15:49:32 +0200423 else {
Christopher Faulet18cca782019-02-07 16:29:41 +0100424 const char *p, *dash = NULL;
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100425 unsigned int low, high;
426
Christopher Faulet18cca782019-02-07 16:29:41 +0100427 for (p = arg; *p; p++) {
428 if (*p == '-' && !dash)
429 dash = p;
Willy Tarreau90807112020-02-25 08:16:33 +0100430 else if (!isdigit((unsigned char)*p)) {
Christopher Faulet18cca782019-02-07 16:29:41 +0100431 memprintf(err, "'%s' is not a valid number/range.", arg);
432 return -1;
433 }
Christopher Faulet5ab51772017-11-22 11:21:58 +0100434 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100435
436 low = high = str2uic(arg);
Christopher Faulet18cca782019-02-07 16:29:41 +0100437 if (dash)
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100438 high = ((!*(dash+1)) ? max : str2uic(dash + 1));
Christopher Fauletff4121f2017-11-22 16:38:49 +0100439
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100440 if (high < low) {
441 unsigned int swap = low;
442 low = high;
443 high = swap;
444 }
445
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100446 if (low < 1 || low > max || high > max) {
Christopher Fauletcb6a9452017-11-22 16:50:41 +0100447 memprintf(err, "'%s' is not a valid number/range."
448 " It supports numbers from 1 to %d.\n",
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100449 arg, max);
Christopher Faulet5ab51772017-11-22 11:21:58 +0100450 return 1;
451 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100452
453 for (;low <= high; low++)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100454 *proc |= 1UL << (low-1);
Christopher Faulet62519022017-10-16 15:49:32 +0200455 }
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100456 *proc &= ~0UL >> (LONGBITS - max);
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100457
Christopher Faulet5ab51772017-11-22 11:21:58 +0100458 return 0;
Christopher Faulet62519022017-10-16 15:49:32 +0200459}
460
David Carlier7e351ee2017-12-01 09:14:02 +0000461#ifdef USE_CPU_AFFINITY
Christopher Faulet62519022017-10-16 15:49:32 +0200462/* Parse cpu sets. Each CPU set is either a unique number between 0 and
463 * <LONGBITS> or a range with two such numbers delimited by a dash
464 * ('-'). Multiple CPU numbers or ranges may be specified. On success, it
465 * returns 0. otherwise it returns 1 with an error message in <err>.
466 */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100467unsigned long parse_cpu_set(const char **args, unsigned long *cpu_set, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200468{
469 int cur_arg = 0;
470
471 *cpu_set = 0;
472 while (*args[cur_arg]) {
473 char *dash;
474 unsigned int low, high;
475
Willy Tarreau90807112020-02-25 08:16:33 +0100476 if (!isdigit((unsigned char)*args[cur_arg])) {
Christopher Faulet62519022017-10-16 15:49:32 +0200477 memprintf(err, "'%s' is not a CPU range.\n", args[cur_arg]);
478 return -1;
479 }
480
481 low = high = str2uic(args[cur_arg]);
482 if ((dash = strchr(args[cur_arg], '-')) != NULL)
Christopher Fauletff4121f2017-11-22 16:38:49 +0100483 high = ((!*(dash+1)) ? LONGBITS-1 : str2uic(dash + 1));
Christopher Faulet62519022017-10-16 15:49:32 +0200484
485 if (high < low) {
486 unsigned int swap = low;
487 low = high;
488 high = swap;
489 }
490
491 if (high >= LONGBITS) {
492 memprintf(err, "supports CPU numbers from 0 to %d.\n", LONGBITS - 1);
493 return 1;
494 }
495
496 while (low <= high)
497 *cpu_set |= 1UL << low++;
498
499 cur_arg++;
500 }
501 return 0;
502}
David Carlier7e351ee2017-12-01 09:14:02 +0000503#endif
504
Frédéric Lécaille18251032019-01-11 11:07:15 +0100505/* Allocate and initialize the frontend of a "peers" section found in
506 * file <file> at line <linenum> with <id> as ID.
507 * Return 0 if succeeded, -1 if not.
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200508 * Note that this function may be called from "default-server"
509 * or "peer" lines.
Frédéric Lécaille18251032019-01-11 11:07:15 +0100510 */
511static int init_peers_frontend(const char *file, int linenum,
512 const char *id, struct peers *peers)
513{
514 struct proxy *p;
515
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200516 if (peers->peers_fe) {
517 p = peers->peers_fe;
518 goto out;
519 }
Frédéric Lécaille9492c4e2019-01-11 11:47:12 +0100520
Frédéric Lécaille18251032019-01-11 11:07:15 +0100521 p = calloc(1, sizeof *p);
522 if (!p) {
523 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
524 return -1;
525 }
526
527 init_new_proxy(p);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200528 peers_setup_frontend(p);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100529 p->parent = peers;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200530 /* Finally store this frontend. */
531 peers->peers_fe = p;
532
533 out:
534 if (id && !p->id)
535 p->id = strdup(id);
Frédéric Lécaille1055e682018-04-26 14:35:21 +0200536 free(p->conf.file);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100537 p->conf.args.file = p->conf.file = strdup(file);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100538 if (linenum != -1)
539 p->conf.args.line = p->conf.line = linenum;
Frédéric Lécaille18251032019-01-11 11:07:15 +0100540
541 return 0;
542}
Willy Tarreauade5ec42010-01-28 19:33:49 +0100543
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100544/* Only change ->file, ->line and ->arg struct bind_conf member values
545 * if already present.
546 */
547static struct bind_conf *bind_conf_uniq_alloc(struct proxy *p,
548 const char *file, int line,
549 const char *arg, struct xprt_ops *xprt)
550{
551 struct bind_conf *bind_conf;
552
553 if (!LIST_ISEMPTY(&p->conf.bind)) {
554 bind_conf = LIST_ELEM((&p->conf.bind)->n, typeof(bind_conf), by_fe);
555 free(bind_conf->file);
556 bind_conf->file = strdup(file);
557 bind_conf->line = line;
558 if (arg) {
559 free(bind_conf->arg);
560 bind_conf->arg = strdup(arg);
561 }
562 }
563 else {
564 bind_conf = bind_conf_alloc(p, file, line, arg, xprt);
565 }
566
567 return bind_conf;
568}
569
570/*
571 * Allocate a new struct peer parsed at line <linenum> in file <file>
572 * to be added to <peers>.
573 * Returns the new allocated structure if succeeded, NULL if not.
574 */
575static struct peer *cfg_peers_add_peer(struct peers *peers,
576 const char *file, int linenum,
577 const char *id, int local)
578{
579 struct peer *p;
580
581 p = calloc(1, sizeof *p);
582 if (!p) {
583 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
584 return NULL;
585 }
586
587 /* the peers are linked backwards first */
588 peers->count++;
589 p->next = peers->remote;
590 peers->remote = p;
591 p->conf.file = strdup(file);
592 p->conf.line = linenum;
593 p->last_change = now.tv_sec;
594 p->xprt = xprt_get(XPRT_RAW);
595 p->sock_init_arg = NULL;
596 HA_SPIN_INIT(&p->lock);
597 if (id)
598 p->id = strdup(id);
599 if (local) {
600 p->local = 1;
601 peers->local = p;
602 }
603
604 return p;
605}
606
Willy Tarreaubaaee002006-06-26 02:48:02 +0200607/*
William Lallemand51097192015-04-14 16:35:22 +0200608 * Parse a line in a <listen>, <frontend> or <backend> section.
Willy Tarreau93893792009-07-23 13:19:11 +0200609 * Returns the error code, 0 if OK, or any combination of :
610 * - ERR_ABORT: must abort ASAP
611 * - ERR_FATAL: we can continue parsing but not start the service
612 * - ERR_WARN: a warning has been emitted
613 * - ERR_ALERT: an alert has been emitted
614 * Only the two first ones can stop processing, the two others are just
615 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200616 */
Emeric Brun32da3c42010-09-23 18:39:19 +0200617int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
618{
619 static struct peers *curpeers = NULL;
620 struct peer *newpeer = NULL;
621 const char *err;
Willy Tarreau4348fad2012-09-20 16:48:07 +0200622 struct bind_conf *bind_conf;
623 struct listener *l;
Emeric Brun32da3c42010-09-23 18:39:19 +0200624 int err_code = 0;
Willy Tarreau902636f2013-03-10 19:44:48 +0100625 char *errmsg = NULL;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100626 static int bind_line, peer_line;
627
628 if (strcmp(args[0], "bind") == 0 || strcmp(args[0], "default-bind") == 0) {
629 int cur_arg;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100630 struct bind_conf *bind_conf;
631 struct bind_kw *kw;
Emeric Brun32da3c42010-09-23 18:39:19 +0200632
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100633 cur_arg = 1;
634
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200635 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
636 err_code |= ERR_ALERT | ERR_ABORT;
637 goto out;
638 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100639
640 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum,
641 NULL, xprt_get(XPRT_RAW));
642 if (*args[0] == 'b') {
643 struct listener *l;
644
645 if (peer_line) {
646 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
647 err_code |= ERR_ALERT | ERR_FATAL;
648 goto out;
649 }
650
651 if (!str2listener(args[1], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
652 if (errmsg && *errmsg) {
653 indent_msg(&errmsg, 2);
654 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
655 }
656 else
657 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
658 file, linenum, args[0], args[1], args[2]);
659 err_code |= ERR_FATAL;
660 goto out;
661 }
662 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
663 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100664 l->accept = session_accept_fd;
665 l->analysers |= curpeers->peers_fe->fe_req_ana;
666 l->default_target = curpeers->peers_fe->default_target;
667 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100668 global.maxsock++; /* for the listening socket */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100669
670 bind_line = 1;
671 if (cfg_peers->local) {
672 newpeer = cfg_peers->local;
673 }
674 else {
675 /* This peer is local.
676 * Note that we do not set the peer ID. This latter is initialized
677 * when parsing "peer" or "server" line.
678 */
679 newpeer = cfg_peers_add_peer(curpeers, file, linenum, NULL, 1);
680 if (!newpeer) {
681 err_code |= ERR_ALERT | ERR_ABORT;
682 goto out;
683 }
684 }
Willy Tarreau37159062020-08-27 07:48:42 +0200685 newpeer->addr = l->rx.addr;
Willy Tarreau5fc93282020-09-16 18:25:03 +0200686 newpeer->proto = l->rx.proto;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100687 cur_arg++;
688 }
689
690 while (*args[cur_arg] && (kw = bind_find_kw(args[cur_arg]))) {
691 int ret;
692
693 ret = kw->parse(args, cur_arg, curpeers->peers_fe, bind_conf, &errmsg);
694 err_code |= ret;
695 if (ret) {
696 if (errmsg && *errmsg) {
697 indent_msg(&errmsg, 2);
698 ha_alert("parsing [%s:%d] : %s\n", file, linenum, errmsg);
699 }
700 else
701 ha_alert("parsing [%s:%d]: error encountered while processing '%s'\n",
702 file, linenum, args[cur_arg]);
703 if (ret & ERR_FATAL)
704 goto out;
705 }
706 cur_arg += 1 + kw->skip;
707 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100708 if (*args[cur_arg] != 0) {
Willy Tarreau433b05f2021-03-12 10:14:07 +0100709 const char *best = bind_find_best_kw(args[cur_arg]);
710 if (best)
711 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section; did you mean '%s' maybe ?\n",
712 file, linenum, args[cur_arg], cursection, best);
713 else
714 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section.\n",
715 file, linenum, args[cur_arg], cursection);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100716 err_code |= ERR_ALERT | ERR_FATAL;
717 goto out;
718 }
719 }
720 else if (strcmp(args[0], "default-server") == 0) {
721 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
722 err_code |= ERR_ALERT | ERR_ABORT;
723 goto out;
724 }
Amaury Denoyelle30c05372021-03-08 16:36:46 +0100725 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL,
726 SRV_PARSE_DEFAULT_SERVER|SRV_PARSE_IN_PEER_SECTION|SRV_PARSE_INITIAL_RESOLVE);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200727 }
Frédéric Lécailleb6f759b2019-11-05 09:57:45 +0100728 else if (strcmp(args[0], "log") == 0) {
729 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
730 err_code |= ERR_ALERT | ERR_ABORT;
731 goto out;
732 }
733 if (!parse_logsrv(args, &curpeers->peers_fe->logsrvs, (kwm == KWM_NO), &errmsg)) {
734 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
735 err_code |= ERR_ALERT | ERR_FATAL;
736 goto out;
737 }
738 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200739 else if (strcmp(args[0], "peers") == 0) { /* new peers section */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100740 /* Initialize these static variables when entering a new "peers" section*/
741 bind_line = peer_line = 0;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100742 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100743 ha_alert("parsing [%s:%d] : missing name for peers section.\n", file, linenum);
Willy Tarreau54984722014-02-16 08:20:13 +0100744 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100745 goto out;
746 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200747
William Lallemand6e62fb62015-04-28 16:55:23 +0200748 if (alertif_too_many_args(1, file, linenum, args, &err_code))
749 goto out;
750
Emeric Brun32da3c42010-09-23 18:39:19 +0200751 err = invalid_char(args[1]);
752 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100753 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
754 file, linenum, *err, args[0], args[1]);
Willy Tarreau54984722014-02-16 08:20:13 +0100755 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100756 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200757 }
758
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200759 for (curpeers = cfg_peers; curpeers != NULL; curpeers = curpeers->next) {
Emeric Brun32da3c42010-09-23 18:39:19 +0200760 /*
761 * If there are two proxies with the same name only following
762 * combinations are allowed:
763 */
764 if (strcmp(curpeers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100765 ha_alert("Parsing [%s:%d]: peers section '%s' has the same name as another peers section declared at %s:%d.\n",
766 file, linenum, args[1], curpeers->conf.file, curpeers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +0200767 err_code |= ERR_ALERT | ERR_FATAL;
Emeric Brun32da3c42010-09-23 18:39:19 +0200768 }
769 }
770
Vincent Bernat02779b62016-04-03 13:48:43 +0200771 if ((curpeers = calloc(1, sizeof(*curpeers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100772 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Emeric Brun32da3c42010-09-23 18:39:19 +0200773 err_code |= ERR_ALERT | ERR_ABORT;
774 goto out;
775 }
776
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200777 curpeers->next = cfg_peers;
778 cfg_peers = curpeers;
Willy Tarreau8113a5d2012-10-04 08:01:43 +0200779 curpeers->conf.file = strdup(file);
Emeric Brun32da3c42010-09-23 18:39:19 +0200780 curpeers->conf.line = linenum;
781 curpeers->last_change = now.tv_sec;
782 curpeers->id = strdup(args[1]);
Willy Tarreau1ad64ac2020-09-24 08:48:08 +0200783 curpeers->disabled = 0;
Emeric Brun32da3c42010-09-23 18:39:19 +0200784 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200785 else if (strcmp(args[0], "peer") == 0 ||
786 strcmp(args[0], "server") == 0) { /* peer or server definition */
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100787 int local_peer, peer;
Amaury Denoyelle30c05372021-03-08 16:36:46 +0100788 int parse_addr = 0;
Emeric Brun32da3c42010-09-23 18:39:19 +0200789
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100790 peer = *args[0] == 'p';
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100791 local_peer = strcmp(args[1], localpeer) == 0;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100792 /* The local peer may have already partially been parsed on a "bind" line. */
793 if (*args[0] == 'p') {
794 if (bind_line) {
795 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
796 err_code |= ERR_ALERT | ERR_FATAL;
797 goto out;
798 }
799 peer_line = 1;
800 }
801 if (cfg_peers->local && !cfg_peers->local->id && local_peer) {
802 /* The local peer has already been initialized on a "bind" line.
803 * Let's use it and store its ID.
804 */
805 newpeer = cfg_peers->local;
806 newpeer->id = strdup(localpeer);
807 }
808 else {
809 if (local_peer && cfg_peers->local) {
810 ha_alert("parsing [%s:%d] : '%s %s' : local peer name already referenced at %s:%d. %s\n",
811 file, linenum, args[0], args[1],
812 curpeers->peers_fe->conf.file, curpeers->peers_fe->conf.line, cfg_peers->local->id);
813 err_code |= ERR_FATAL;
814 goto out;
815 }
816 newpeer = cfg_peers_add_peer(curpeers, file, linenum, args[1], local_peer);
817 if (!newpeer) {
818 err_code |= ERR_ALERT | ERR_ABORT;
819 goto out;
820 }
821 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200822
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100823 /* Line number and peer ID are updated only if this peer is the local one. */
824 if (init_peers_frontend(file,
825 newpeer->local ? linenum: -1,
826 newpeer->local ? newpeer->id : NULL,
827 curpeers) != 0) {
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200828 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreaub36487e2013-03-10 18:37:42 +0100829 goto out;
830 }
Willy Tarreau2aa38802013-02-20 19:20:59 +0100831
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100832 /* This initializes curpeer->peers->peers_fe->srv.
833 * The server address is parsed only if we are parsing a "peer" line,
834 * or if we are parsing a "server" line and the current peer is not the local one.
835 */
Amaury Denoyelle30c05372021-03-08 16:36:46 +0100836 parse_addr = (peer || !local_peer) ? SRV_PARSE_PARSE_ADDR : 0;
837 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL,
838 SRV_PARSE_IN_PEER_SECTION|parse_addr|SRV_PARSE_INITIAL_RESOLVE);
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200839 if (!curpeers->peers_fe->srv) {
840 /* Remove the newly allocated peer. */
841 if (newpeer != curpeers->local) {
842 struct peer *p;
843
844 p = curpeers->remote;
845 curpeers->remote = curpeers->remote->next;
846 free(p->id);
847 free(p);
848 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200849 goto out;
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200850 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200851
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100852 /* If the peer address has just been parsed, let's copy it to <newpeer>
853 * and initializes ->proto.
854 */
855 if (peer || !local_peer) {
856 newpeer->addr = curpeers->peers_fe->srv->addr;
857 newpeer->proto = protocol_by_family(newpeer->addr.ss_family);
858 }
859
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100860 newpeer->xprt = xprt_get(XPRT_RAW);
Willy Tarreaud02394b2012-05-11 18:32:18 +0200861 newpeer->sock_init_arg = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100862 HA_SPIN_INIT(&newpeer->lock);
Willy Tarreau26d8c592012-05-07 18:12:14 +0200863
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100864 newpeer->srv = curpeers->peers_fe->srv;
865 if (!newpeer->local)
Frédéric Lécaille6617e762018-04-25 15:13:38 +0200866 goto out;
867
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100868 /* The lines above are reserved to "peer" lines. */
869 if (*args[0] == 's')
Frédéric Lécaille4ba51982018-04-25 15:32:18 +0200870 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200871
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100872 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 +0100873
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100874 if (!str2listener(args[2], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
875 if (errmsg && *errmsg) {
876 indent_msg(&errmsg, 2);
877 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 +0100878 }
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100879 else
880 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
881 file, linenum, args[0], args[1], args[2]);
882 err_code |= ERR_FATAL;
883 goto out;
884 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100885
886 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
887 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100888 l->accept = session_accept_fd;
889 l->analysers |= curpeers->peers_fe->fe_req_ana;
890 l->default_target = curpeers->peers_fe->default_target;
891 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100892 global.maxsock++; /* for the listening socket */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100893 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100894 else if (strcmp(args[0], "table") == 0) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100895 struct stktable *t, *other;
896 char *id;
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100897 size_t prefix_len;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100898
899 /* Line number and peer ID are updated only if this peer is the local one. */
900 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
901 err_code |= ERR_ALERT | ERR_ABORT;
902 goto out;
903 }
904
905 other = stktable_find_by_name(args[1]);
906 if (other) {
907 ha_alert("parsing [%s:%d] : stick-table name '%s' conflicts with table declared in %s '%s' at %s:%d.\n",
908 file, linenum, args[1],
909 other->proxy ? proxy_cap_str(other->proxy->cap) : "peers",
910 other->proxy ? other->id : other->peers.p->id,
911 other->conf.file, other->conf.line);
912 err_code |= ERR_ALERT | ERR_FATAL;
913 goto out;
914 }
915
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100916 /* Build the stick-table name, concatenating the "peers" section name
917 * followed by a '/' character and the table name argument.
918 */
919 chunk_reset(&trash);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100920 if (!chunk_strcpy(&trash, curpeers->id)) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100921 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
922 file, linenum, args[0], args[1]);
923 err_code |= ERR_ALERT | ERR_FATAL;
924 goto out;
925 }
926
927 prefix_len = trash.data;
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100928 if (!chunk_memcat(&trash, "/", 1) || !chunk_strcat(&trash, args[1])) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100929 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
930 file, linenum, args[0], args[1]);
931 err_code |= ERR_ALERT | ERR_FATAL;
932 goto out;
933 }
934
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100935 t = calloc(1, sizeof *t);
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100936 id = strdup(trash.area);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100937 if (!t || !id) {
938 ha_alert("parsing [%s:%d]: '%s %s' : memory allocation failed\n",
939 file, linenum, args[0], args[1]);
Eric Salama1aab9112020-09-18 11:55:17 +0200940 free(t);
941 free(id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100942 err_code |= ERR_ALERT | ERR_FATAL;
943 goto out;
944 }
945
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100946 err_code |= parse_stick_table(file, linenum, args, t, id, id + prefix_len, curpeers);
Eric Salama1aab9112020-09-18 11:55:17 +0200947 if (err_code & ERR_FATAL) {
948 free(t);
949 free(id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100950 goto out;
Eric Salama1aab9112020-09-18 11:55:17 +0200951 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100952
953 stktable_store_name(t);
954 t->next = stktables_list;
955 stktables_list = t;
956 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100957 else if (strcmp(args[0], "disabled") == 0) { /* disables this peers section */
Willy Tarreau1ad64ac2020-09-24 08:48:08 +0200958 curpeers->disabled = 1;
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200959 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100960 else if (strcmp(args[0], "enabled") == 0) { /* enables this peers section (used to revert a disabled default) */
Willy Tarreau1ad64ac2020-09-24 08:48:08 +0200961 curpeers->disabled = 0;
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200962 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200963 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100964 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Emeric Brun32da3c42010-09-23 18:39:19 +0200965 err_code |= ERR_ALERT | ERR_FATAL;
966 goto out;
967 }
968
969out:
Willy Tarreau902636f2013-03-10 19:44:48 +0100970 free(errmsg);
Emeric Brun32da3c42010-09-23 18:39:19 +0200971 return err_code;
972}
973
Baptiste Assmann325137d2015-04-13 23:40:55 +0200974/*
William Lallemand51097192015-04-14 16:35:22 +0200975 * Parse a line in a <listen>, <frontend> or <backend> section.
Simon Horman0d16a402015-01-30 11:22:58 +0900976 * Returns the error code, 0 if OK, or any combination of :
977 * - ERR_ABORT: must abort ASAP
978 * - ERR_FATAL: we can continue parsing but not start the service
979 * - ERR_WARN: a warning has been emitted
980 * - ERR_ALERT: an alert has been emitted
981 * Only the two first ones can stop processing, the two others are just
982 * indicators.
983 */
984int cfg_parse_mailers(const char *file, int linenum, char **args, int kwm)
985{
986 static struct mailers *curmailers = NULL;
987 struct mailer *newmailer = NULL;
988 const char *err;
989 int err_code = 0;
990 char *errmsg = NULL;
991
992 if (strcmp(args[0], "mailers") == 0) { /* new mailers section */
993 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100994 ha_alert("parsing [%s:%d] : missing name for mailers section.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +0900995 err_code |= ERR_ALERT | ERR_ABORT;
996 goto out;
997 }
998
999 err = invalid_char(args[1]);
1000 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001001 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
1002 file, linenum, *err, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001003 err_code |= ERR_ALERT | ERR_ABORT;
1004 goto out;
1005 }
1006
1007 for (curmailers = mailers; curmailers != NULL; curmailers = curmailers->next) {
1008 /*
1009 * If there are two proxies with the same name only following
1010 * combinations are allowed:
1011 */
1012 if (strcmp(curmailers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001013 ha_alert("Parsing [%s:%d]: mailers section '%s' has the same name as another mailers section declared at %s:%d.\n",
1014 file, linenum, args[1], curmailers->conf.file, curmailers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +02001015 err_code |= ERR_ALERT | ERR_FATAL;
Simon Horman0d16a402015-01-30 11:22:58 +09001016 }
1017 }
1018
Vincent Bernat02779b62016-04-03 13:48:43 +02001019 if ((curmailers = calloc(1, sizeof(*curmailers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001020 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001021 err_code |= ERR_ALERT | ERR_ABORT;
1022 goto out;
1023 }
1024
1025 curmailers->next = mailers;
1026 mailers = curmailers;
1027 curmailers->conf.file = strdup(file);
1028 curmailers->conf.line = linenum;
1029 curmailers->id = strdup(args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001030 curmailers->timeout.mail = DEF_MAILALERTTIME;/* XXX: Would like to Skip to the next alert, if any, ASAP.
1031 * But need enough time so that timeouts don't occur
1032 * during tcp procssing. For now just us an arbitrary default. */
Simon Horman0d16a402015-01-30 11:22:58 +09001033 }
1034 else if (strcmp(args[0], "mailer") == 0) { /* mailer definition */
1035 struct sockaddr_storage *sk;
1036 int port1, port2;
1037 struct protocol *proto;
1038
1039 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001040 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1041 file, linenum, args[0]);
Simon Horman0d16a402015-01-30 11:22:58 +09001042 err_code |= ERR_ALERT | ERR_FATAL;
1043 goto out;
1044 }
1045
1046 err = invalid_char(args[1]);
1047 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001048 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1049 file, linenum, *err, args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001050 err_code |= ERR_ALERT | ERR_FATAL;
1051 goto out;
1052 }
1053
Vincent Bernat02779b62016-04-03 13:48:43 +02001054 if ((newmailer = calloc(1, sizeof(*newmailer))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001055 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001056 err_code |= ERR_ALERT | ERR_ABORT;
1057 goto out;
1058 }
1059
1060 /* the mailers are linked backwards first */
1061 curmailers->count++;
1062 newmailer->next = curmailers->mailer_list;
1063 curmailers->mailer_list = newmailer;
1064 newmailer->mailers = curmailers;
1065 newmailer->conf.file = strdup(file);
1066 newmailer->conf.line = linenum;
1067
1068 newmailer->id = strdup(args[1]);
1069
Willy Tarreau5fc93282020-09-16 18:25:03 +02001070 sk = str2sa_range(args[2], NULL, &port1, &port2, NULL, &proto,
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001071 &errmsg, NULL, NULL,
1072 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 +09001073 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001074 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Simon Horman0d16a402015-01-30 11:22:58 +09001075 err_code |= ERR_ALERT | ERR_FATAL;
1076 goto out;
1077 }
1078
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001079 if (proto->sock_prot != IPPROTO_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001080 ha_alert("parsing [%s:%d] : '%s %s' : TCP not supported for this address family.\n",
1081 file, linenum, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001082 err_code |= ERR_ALERT | ERR_FATAL;
1083 goto out;
1084 }
1085
Simon Horman0d16a402015-01-30 11:22:58 +09001086 newmailer->addr = *sk;
1087 newmailer->proto = proto;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01001088 newmailer->xprt = xprt_get(XPRT_RAW);
Simon Horman0d16a402015-01-30 11:22:58 +09001089 newmailer->sock_init_arg = NULL;
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001090 }
1091 else if (strcmp(args[0], "timeout") == 0) {
1092 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001093 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments.\n",
1094 file, linenum, args[0]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001095 err_code |= ERR_ALERT | ERR_FATAL;
1096 goto out;
1097 }
1098 else if (strcmp(args[1], "mail") == 0) {
1099 const char *res;
1100 unsigned int timeout_mail;
1101 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001102 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1103 file, linenum, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001104 err_code |= ERR_ALERT | ERR_FATAL;
1105 goto out;
1106 }
1107 res = parse_time_err(args[2], &timeout_mail, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001108 if (res == PARSE_TIME_OVER) {
1109 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1110 file, linenum, args[2], args[0], args[1]);
1111 err_code |= ERR_ALERT | ERR_FATAL;
1112 goto out;
1113 }
1114 else if (res == PARSE_TIME_UNDER) {
1115 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1116 file, linenum, args[2], args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001117 err_code |= ERR_ALERT | ERR_FATAL;
1118 goto out;
1119 }
Willy Tarreau9faebe32019-06-07 19:00:37 +02001120 else if (res) {
1121 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1122 file, linenum, *res, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001123 err_code |= ERR_ALERT | ERR_FATAL;
1124 goto out;
1125 }
1126 curmailers->timeout.mail = timeout_mail;
1127 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001128 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments got '%s'.\n",
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001129 file, linenum, args[0], args[1]);
1130 err_code |= ERR_ALERT | ERR_FATAL;
1131 goto out;
1132 }
1133 }
Simon Horman0d16a402015-01-30 11:22:58 +09001134 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001135 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Simon Horman0d16a402015-01-30 11:22:58 +09001136 err_code |= ERR_ALERT | ERR_FATAL;
1137 goto out;
1138 }
1139
1140out:
1141 free(errmsg);
1142 return err_code;
1143}
1144
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +01001145void free_email_alert(struct proxy *p)
Simon Horman9dc49962015-01-30 11:22:59 +09001146{
Willy Tarreau61cfdf42021-02-20 10:46:51 +01001147 ha_free(&p->email_alert.mailers.name);
1148 ha_free(&p->email_alert.from);
1149 ha_free(&p->email_alert.to);
1150 ha_free(&p->email_alert.myhostname);
Simon Horman9dc49962015-01-30 11:22:59 +09001151}
1152
Willy Tarreaubaaee002006-06-26 02:48:02 +02001153
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001154int
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001155cfg_parse_netns(const char *file, int linenum, char **args, int kwm)
1156{
Willy Tarreaue5733232019-05-22 19:24:06 +02001157#ifdef USE_NS
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001158 const char *err;
1159 const char *item = args[0];
1160
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001161 if (strcmp(item, "namespace_list") == 0) {
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001162 return 0;
1163 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001164 else if (strcmp(item, "namespace") == 0) {
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001165 size_t idx = 1;
1166 const char *current;
1167 while (*(current = args[idx++])) {
1168 err = invalid_char(current);
1169 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001170 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1171 file, linenum, *err, item, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001172 return ERR_ALERT | ERR_FATAL;
1173 }
1174
1175 if (netns_store_lookup(current, strlen(current))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001176 ha_alert("parsing [%s:%d]: Namespace '%s' is already added.\n",
1177 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001178 return ERR_ALERT | ERR_FATAL;
1179 }
1180 if (!netns_store_insert(current)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001181 ha_alert("parsing [%s:%d]: Cannot open namespace '%s'.\n",
1182 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001183 return ERR_ALERT | ERR_FATAL;
1184 }
1185 }
1186 }
1187
1188 return 0;
1189#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001190 ha_alert("parsing [%s:%d]: namespace support is not compiled in.",
1191 file, linenum);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001192 return ERR_ALERT | ERR_FATAL;
1193#endif
1194}
1195
1196int
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001197cfg_parse_users(const char *file, int linenum, char **args, int kwm)
1198{
1199
1200 int err_code = 0;
1201 const char *err;
1202
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001203 if (strcmp(args[0], "userlist") == 0) { /* new userlist */
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001204 struct userlist *newul;
1205
1206 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001207 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1208 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001209 err_code |= ERR_ALERT | ERR_FATAL;
1210 goto out;
1211 }
William Lallemand6e62fb62015-04-28 16:55:23 +02001212 if (alertif_too_many_args(1, file, linenum, args, &err_code))
1213 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001214
1215 err = invalid_char(args[1]);
1216 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001217 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1218 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001219 err_code |= ERR_ALERT | ERR_FATAL;
1220 goto out;
1221 }
1222
1223 for (newul = userlist; newul; newul = newul->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001224 if (strcmp(newul->name, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001225 ha_warning("parsing [%s:%d]: ignoring duplicated userlist '%s'.\n",
1226 file, linenum, args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001227 err_code |= ERR_WARN;
1228 goto out;
1229 }
1230
Vincent Bernat02779b62016-04-03 13:48:43 +02001231 newul = calloc(1, sizeof(*newul));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001232 if (!newul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001233 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001234 err_code |= ERR_ALERT | ERR_ABORT;
1235 goto out;
1236 }
1237
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001238 newul->name = strdup(args[1]);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001239 if (!newul->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001240 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001241 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier97880bb2016-04-08 10:35:26 +01001242 free(newul);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001243 goto out;
1244 }
1245
1246 newul->next = userlist;
1247 userlist = newul;
1248
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001249 } else if (strcmp(args[0], "group") == 0) { /* new group */
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001250 int cur_arg;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001251 const char *err;
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001252 struct auth_groups *ag;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001253
1254 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001255 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1256 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001257 err_code |= ERR_ALERT | ERR_FATAL;
1258 goto out;
1259 }
1260
1261 err = invalid_char(args[1]);
1262 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001263 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1264 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001265 err_code |= ERR_ALERT | ERR_FATAL;
1266 goto out;
1267 }
1268
William Lallemand4ac9f542015-05-28 18:03:51 +02001269 if (!userlist)
1270 goto out;
1271
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001272 for (ag = userlist->groups; ag; ag = ag->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001273 if (strcmp(ag->name, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001274 ha_warning("parsing [%s:%d]: ignoring duplicated group '%s' in userlist '%s'.\n",
1275 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001276 err_code |= ERR_ALERT;
1277 goto out;
1278 }
1279
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001280 ag = calloc(1, sizeof(*ag));
1281 if (!ag) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001282 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001283 err_code |= ERR_ALERT | ERR_ABORT;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001284 goto out;
1285 }
1286
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001287 ag->name = strdup(args[1]);
David Carlier70d60452016-08-22 23:27:42 +01001288 if (!ag->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001289 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001290 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier70d60452016-08-22 23:27:42 +01001291 free(ag);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001292 goto out;
1293 }
1294
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001295 cur_arg = 2;
1296
1297 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001298 if (strcmp(args[cur_arg], "users") == 0) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001299 ag->groupusers = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001300 cur_arg += 2;
1301 continue;
1302 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001303 ha_alert("parsing [%s:%d]: '%s' only supports 'users' option.\n",
1304 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001305 err_code |= ERR_ALERT | ERR_FATAL;
David Carlier70d60452016-08-22 23:27:42 +01001306 free(ag->groupusers);
1307 free(ag->name);
1308 free(ag);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001309 goto out;
1310 }
1311 }
1312
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001313 ag->next = userlist->groups;
1314 userlist->groups = ag;
1315
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001316 } else if (strcmp(args[0], "user") == 0) { /* new user */
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001317 struct auth_users *newuser;
1318 int cur_arg;
1319
1320 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001321 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1322 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001323 err_code |= ERR_ALERT | ERR_FATAL;
1324 goto out;
1325 }
William Lallemand4ac9f542015-05-28 18:03:51 +02001326 if (!userlist)
1327 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001328
1329 for (newuser = userlist->users; newuser; newuser = newuser->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001330 if (strcmp(newuser->user, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001331 ha_warning("parsing [%s:%d]: ignoring duplicated user '%s' in userlist '%s'.\n",
1332 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001333 err_code |= ERR_ALERT;
1334 goto out;
1335 }
1336
Vincent Bernat02779b62016-04-03 13:48:43 +02001337 newuser = calloc(1, sizeof(*newuser));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001338 if (!newuser) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001339 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001340 err_code |= ERR_ALERT | ERR_ABORT;
1341 goto out;
1342 }
1343
1344 newuser->user = strdup(args[1]);
1345
1346 newuser->next = userlist->users;
1347 userlist->users = newuser;
1348
1349 cur_arg = 2;
1350
1351 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001352 if (strcmp(args[cur_arg], "password") == 0) {
Willy Tarreaue5733232019-05-22 19:24:06 +02001353#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001354 if (!crypt("", args[cur_arg + 1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001355 ha_alert("parsing [%s:%d]: the encrypted password used for user '%s' is not supported by crypt(3).\n",
1356 file, linenum, newuser->user);
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001357 err_code |= ERR_ALERT | ERR_FATAL;
1358 goto out;
1359 }
1360#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001361 ha_warning("parsing [%s:%d]: no crypt(3) support compiled, encrypted passwords will not work.\n",
1362 file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001363 err_code |= ERR_ALERT;
1364#endif
1365 newuser->pass = strdup(args[cur_arg + 1]);
1366 cur_arg += 2;
1367 continue;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001368 } else if (strcmp(args[cur_arg], "insecure-password") == 0) {
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001369 newuser->pass = strdup(args[cur_arg + 1]);
1370 newuser->flags |= AU_O_INSECURE;
1371 cur_arg += 2;
1372 continue;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001373 } else if (strcmp(args[cur_arg], "groups") == 0) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001374 newuser->u.groups_names = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001375 cur_arg += 2;
1376 continue;
1377 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001378 ha_alert("parsing [%s:%d]: '%s' only supports 'password', 'insecure-password' and 'groups' options.\n",
1379 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001380 err_code |= ERR_ALERT | ERR_FATAL;
1381 goto out;
1382 }
1383 }
1384 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001385 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 +01001386 err_code |= ERR_ALERT | ERR_FATAL;
1387 }
1388
1389out:
1390 return err_code;
1391}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001392
Christopher Faulet79bdef32016-11-04 22:36:15 +01001393int
1394cfg_parse_scope(const char *file, int linenum, char *line)
1395{
1396 char *beg, *end, *scope = NULL;
1397 int err_code = 0;
1398 const char *err;
1399
1400 beg = line + 1;
1401 end = strchr(beg, ']');
1402
1403 /* Detect end of scope declaration */
1404 if (!end || end == beg) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001405 ha_alert("parsing [%s:%d] : empty scope name is forbidden.\n",
1406 file, linenum);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001407 err_code |= ERR_ALERT | ERR_FATAL;
1408 goto out;
1409 }
1410
1411 /* Get scope name and check its validity */
1412 scope = my_strndup(beg, end-beg);
1413 err = invalid_char(scope);
1414 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001415 ha_alert("parsing [%s:%d] : character '%c' is not permitted in a scope name.\n",
1416 file, linenum, *err);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001417 err_code |= ERR_ALERT | ERR_ABORT;
1418 goto out;
1419 }
1420
1421 /* Be sure to have a scope declaration alone on its line */
1422 line = end+1;
1423 while (isspace((unsigned char)*line))
1424 line++;
1425 if (*line && *line != '#' && *line != '\n' && *line != '\r') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001426 ha_alert("parsing [%s:%d] : character '%c' is not permitted after scope declaration.\n",
1427 file, linenum, *line);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001428 err_code |= ERR_ALERT | ERR_ABORT;
1429 goto out;
1430 }
1431
1432 /* We have a valid scope declaration, save it */
1433 free(cfg_scope);
1434 cfg_scope = scope;
1435 scope = NULL;
1436
1437 out:
1438 free(scope);
1439 return err_code;
1440}
1441
Frédéric Lécaillea41d5312018-01-29 12:05:07 +01001442int
1443cfg_parse_track_sc_num(unsigned int *track_sc_num,
1444 const char *arg, const char *end, char **errmsg)
1445{
1446 const char *p;
1447 unsigned int num;
1448
1449 p = arg;
1450 num = read_uint64(&arg, end);
1451
1452 if (arg != end) {
1453 memprintf(errmsg, "Wrong track-sc number '%s'", p);
1454 return -1;
1455 }
1456
1457 if (num >= MAX_SESS_STKCTR) {
1458 memprintf(errmsg, "%u track-sc number exceeding "
1459 "%d (MAX_SESS_STKCTR-1) value", num, MAX_SESS_STKCTR - 1);
1460 return -1;
1461 }
1462
1463 *track_sc_num = num;
1464 return 0;
1465}
1466
Willy Tarreaubaaee002006-06-26 02:48:02 +02001467/*
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001468 * Detect a global section after a non-global one and output a diagnostic
1469 * warning.
1470 */
1471static void check_section_position(char *section_name,
1472 const char *file, int linenum,
1473 int *non_global_parsed)
1474{
1475 if (!strcmp(section_name, "global")) {
1476 if (*non_global_parsed == 1)
1477 _ha_diag_warning("parsing [%s:%d] : global section detected after a non-global one, the prevalence of their statements is unspecified\n", file, linenum);
1478 }
1479 else if (*non_global_parsed == 0) {
1480 *non_global_parsed = 1;
1481 }
1482}
1483
1484/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02001485 * This function reads and parses the configuration file given in the argument.
Willy Tarreau058e9072009-07-20 09:30:05 +02001486 * Returns the error code, 0 if OK, or any combination of :
1487 * - ERR_ABORT: must abort ASAP
1488 * - ERR_FATAL: we can continue parsing but not start the service
1489 * - ERR_WARN: a warning has been emitted
1490 * - ERR_ALERT: an alert has been emitted
1491 * Only the two first ones can stop processing, the two others are just
1492 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001493 */
Willy Tarreaub17916e2006-10-15 15:17:57 +02001494int readcfgfile(const char *file)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001495{
William Lallemand64e84512015-05-12 14:25:37 +02001496 char *thisline;
1497 int linesize = LINESIZE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001498 FILE *f;
1499 int linenum = 0;
Willy Tarreau058e9072009-07-20 09:30:05 +02001500 int err_code = 0;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001501 struct cfg_section *cs = NULL, *pcs = NULL;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001502 struct cfg_section *ics;
William Lallemand64e84512015-05-12 14:25:37 +02001503 int readbytes = 0;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001504 char *outline = NULL;
1505 size_t outlen = 0;
1506 size_t outlinesize = 0;
Willy Tarreau32234e72020-06-16 17:14:33 +02001507 int fatal = 0;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001508 int missing_lf = -1;
Willy Tarreau4b103022021-02-12 17:59:10 +01001509 int nested_cond_lvl = 0;
1510 enum nested_cond_state nested_conds[MAXNESTEDCONDS];
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001511 int non_global_section_parsed = 0;
William Lallemand64e84512015-05-12 14:25:37 +02001512
1513 if ((thisline = malloc(sizeof(*thisline) * linesize)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001514 ha_alert("parsing [%s] : out of memory.\n", file);
William Lallemand64e84512015-05-12 14:25:37 +02001515 return -1;
1516 }
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001517
David Carlier97880bb2016-04-08 10:35:26 +01001518 if ((f=fopen(file,"r")) == NULL) {
1519 free(thisline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001520 return -1;
David Carlier97880bb2016-04-08 10:35:26 +01001521 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001522
William Lallemandb2f07452015-05-12 14:27:13 +02001523next_line:
William Lallemand64e84512015-05-12 14:25:37 +02001524 while (fgets(thisline + readbytes, linesize - readbytes, f) != NULL) {
Willy Tarreau3842f002009-06-14 11:39:52 +02001525 int arg, kwm = KWM_STD;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001526 char *end;
1527 char *args[MAX_LINE_ARGS + 1];
1528 char *line = thisline;
1529
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001530 if (missing_lf != -1) {
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001531 ha_alert("parsing [%s:%d]: Stray NUL character at position %d.\n",
1532 file, linenum, (missing_lf + 1));
1533 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001534 missing_lf = -1;
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001535 break;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001536 }
1537
Willy Tarreaubaaee002006-06-26 02:48:02 +02001538 linenum++;
1539
Willy Tarreau32234e72020-06-16 17:14:33 +02001540 if (fatal >= 50) {
1541 ha_alert("parsing [%s:%d]: too many fatal errors (%d), stopping now.\n", file, linenum, fatal);
1542 break;
1543 }
1544
Willy Tarreaubaaee002006-06-26 02:48:02 +02001545 end = line + strlen(line);
1546
William Lallemand64e84512015-05-12 14:25:37 +02001547 if (end-line == linesize-1 && *(end-1) != '\n') {
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001548 /* Check if we reached the limit and the last char is not \n.
1549 * Watch out for the last line without the terminating '\n'!
1550 */
William Lallemand64e84512015-05-12 14:25:37 +02001551 char *newline;
1552 int newlinesize = linesize * 2;
1553
1554 newline = realloc(thisline, sizeof(*thisline) * newlinesize);
1555 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001556 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1557 file, linenum);
William Lallemand64e84512015-05-12 14:25:37 +02001558 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001559 fatal++;
Willy Tarreau40cb26f2020-06-25 09:37:54 +02001560 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001561 continue;
1562 }
1563
1564 readbytes = linesize - 1;
1565 linesize = newlinesize;
1566 thisline = newline;
Willy Tarreau40cb26f2020-06-25 09:37:54 +02001567 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001568 continue;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001569 }
1570
William Lallemand64e84512015-05-12 14:25:37 +02001571 readbytes = 0;
1572
Willy Tarreau08488f62020-06-26 17:24:54 +02001573 if (end > line && *(end-1) == '\n') {
Tim Duesterhus70f58992020-06-22 22:57:44 +02001574 /* kill trailing LF */
1575 *(end - 1) = 0;
1576 }
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001577 else {
1578 /* mark this line as truncated */
1579 missing_lf = end - line;
1580 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001581
Willy Tarreaubaaee002006-06-26 02:48:02 +02001582 /* skip leading spaces */
Willy Tarreau8f8e6452007-06-17 21:51:38 +02001583 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001584 line++;
William Lallemandf9873ba2015-05-05 17:37:14 +02001585
Joseph Herlanta14c03e2018-11-15 14:04:19 -08001586 if (*line == '[') {/* This is the beginning if a scope */
Christopher Faulet79bdef32016-11-04 22:36:15 +01001587 err_code |= cfg_parse_scope(file, linenum, line);
1588 goto next_line;
1589 }
1590
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001591 while (1) {
1592 uint32_t err;
1593 char *errptr;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001594
Willy Tarreau61dd44b2020-06-25 07:35:42 +02001595 arg = MAX_LINE_ARGS + 1;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001596 outlen = outlinesize;
1597 err = parse_line(line, outline, &outlen, args, &arg,
1598 PARSE_OPT_ENV | PARSE_OPT_DQUOTE | PARSE_OPT_SQUOTE |
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02001599 PARSE_OPT_BKSLASH | PARSE_OPT_SHARP | PARSE_OPT_WORD_EXPAND,
1600 &errptr);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001601
1602 if (err & PARSE_ERR_QUOTE) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001603 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1604
1605 ha_alert("parsing [%s:%d]: unmatched quote at position %d:\n"
1606 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001607 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001608 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001609 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001610 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001611
1612 if (err & PARSE_ERR_BRACE) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001613 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1614
1615 ha_alert("parsing [%s:%d]: unmatched brace in environment variable name at position %d:\n"
1616 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001617 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001618 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001619 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001620 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001621
1622 if (err & PARSE_ERR_VARNAME) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001623 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1624
1625 ha_alert("parsing [%s:%d]: forbidden first char in environment variable name at position %d:\n"
1626 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001627 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001628 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001629 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001630 }
William Lallemandb2f07452015-05-12 14:27:13 +02001631
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001632 if (err & PARSE_ERR_HEX) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001633 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1634
1635 ha_alert("parsing [%s:%d]: truncated or invalid hexadecimal sequence at position %d:\n"
1636 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001637 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus9f658a52020-06-16 18:14:21 +02001638 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001639 goto next_line;
1640 }
William Lallemandb2f07452015-05-12 14:27:13 +02001641
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02001642 if (err & PARSE_ERR_WRONG_EXPAND) {
1643 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1644
1645 ha_alert("parsing [%s:%d]: truncated or invalid word expansion sequence at position %d:\n"
1646 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
1647 err_code |= ERR_ALERT | ERR_FATAL;
1648 fatal++;
1649 goto next_line;
1650 }
1651
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001652 if (err & (PARSE_ERR_TOOLARGE|PARSE_ERR_OVERLAP)) {
1653 outlinesize = (outlen + 1023) & -1024;
Ilya Shipitsin76837bc2021-01-07 22:45:13 +05001654 outline = my_realloc2(outline, outlinesize);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001655 if (outline == NULL) {
1656 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1657 file, linenum);
William Lallemandb2f07452015-05-12 14:27:13 +02001658 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001659 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001660 goto next_line;
William Lallemandb2f07452015-05-12 14:27:13 +02001661 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001662 /* try again */
1663 continue;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001664 }
Willy Tarreau07d47062020-06-25 07:41:22 +02001665
1666 if (err & PARSE_ERR_TOOMANY) {
1667 /* only check this *after* being sure the output is allocated */
1668 ha_alert("parsing [%s:%d]: too many words, truncating after word %d, position %ld: <%s>.\n",
1669 file, linenum, MAX_LINE_ARGS, (long)(args[MAX_LINE_ARGS-1] - outline + 1), args[MAX_LINE_ARGS-1]);
1670 err_code |= ERR_ALERT | ERR_FATAL;
1671 fatal++;
1672 goto next_line;
1673 }
1674
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001675 /* everything's OK */
1676 break;
William Lallemandf9873ba2015-05-05 17:37:14 +02001677 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001678
1679 /* empty line */
1680 if (!**args)
1681 continue;
1682
Willy Tarreau4b103022021-02-12 17:59:10 +01001683 /* check for config macros */
1684 if (*args[0] == '.') {
1685 if (strcmp(args[0], ".if") == 0) {
1686 nested_cond_lvl++;
1687 if (nested_cond_lvl >= MAXNESTEDCONDS) {
1688 ha_alert("parsing [%s:%d]: too many nested '.if', max is %d.\n", file, linenum, MAXNESTEDCONDS);
1689 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1690 goto err;
1691 }
1692
1693 if (nested_conds[nested_cond_lvl - 1] == NESTED_COND_IF_DROP ||
1694 nested_conds[nested_cond_lvl - 1] == NESTED_COND_IF_SKIP ||
1695 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELIF_DROP ||
1696 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELIF_SKIP ||
1697 nested_conds[nested_cond_lvl - 1] == NESTED_COND_ELSE_DROP) {
1698 nested_conds[nested_cond_lvl] = NESTED_COND_IF_SKIP;
1699 } else if (!*args[1] || *args[1] == '0') {
1700 /* empty = false */
1701 nested_conds[nested_cond_lvl] = NESTED_COND_IF_DROP;
1702 } else if (atoi(args[1]) > 0) {
1703 /* true */
1704 nested_conds[nested_cond_lvl] = NESTED_COND_IF_TAKE;
1705 } else {
1706 ha_alert("parsing [%s:%d]: unparsable conditional expression '%s'.\n", file, linenum, args[1]);
1707 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1708 goto err;
1709 }
1710 goto next_line;
1711 }
1712 else if (strcmp(args[0], ".elif") == 0) {
1713 if (!nested_cond_lvl) {
1714 ha_alert("parsing [%s:%d]: lone '.elif' with no matching '.if'.\n", file, linenum);
1715 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1716 goto err;
1717 }
1718
1719 if (nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_TAKE ||
1720 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP) {
1721 ha_alert("parsing [%s:%d]: '.elif' after '.else' is not permitted.\n", file, linenum);
1722 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1723 goto err;
1724 }
1725
1726 if (nested_conds[nested_cond_lvl] == NESTED_COND_IF_TAKE ||
1727 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
1728 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP) {
1729 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_SKIP;
1730 } else if (!*args[1] || *args[1] == '0') {
1731 /* empty = false */
1732 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_DROP;
1733 } else if (atoi(args[1]) > 0) {
1734 /* true */
1735 nested_conds[nested_cond_lvl] = NESTED_COND_ELIF_TAKE;
1736 } else {
1737 ha_alert("parsing [%s:%d]: unparsable conditional expression '%s'.\n", file, linenum, args[1]);
1738 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1739 goto err;
1740 }
1741 goto next_line;
1742 }
1743 else if (strcmp(args[0], ".else") == 0) {
1744 if (!nested_cond_lvl) {
1745 ha_alert("parsing [%s:%d]: lone '.else' with no matching '.if'.\n", file, linenum);
1746 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1747 goto err;
1748 }
1749
1750 if (nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_TAKE ||
1751 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP) {
1752 ha_alert("parsing [%s:%d]: '.else' after '.else' is not permitted.\n", file, linenum);
1753 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1754 goto err;
1755 }
1756
1757 if (nested_conds[nested_cond_lvl] == NESTED_COND_IF_TAKE ||
1758 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
1759 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_TAKE ||
1760 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP) {
1761 nested_conds[nested_cond_lvl] = NESTED_COND_ELSE_DROP;
1762 } else {
1763 /* otherwise we take the "else" */
1764 nested_conds[nested_cond_lvl] = NESTED_COND_ELSE_TAKE;
1765 }
1766 goto next_line;
1767 }
1768 else if (strcmp(args[0], ".endif") == 0) {
1769 if (!nested_cond_lvl) {
1770 ha_alert("parsing [%s:%d]: lone '.endif' with no matching '.if'.\n", file, linenum);
1771 err_code |= ERR_ALERT | ERR_FATAL;
1772 fatal++;
1773 break;
1774 }
1775 nested_cond_lvl--;
1776 goto next_line;
1777 }
1778 }
1779
1780 if (nested_cond_lvl &&
1781 (nested_conds[nested_cond_lvl] == NESTED_COND_IF_DROP ||
1782 nested_conds[nested_cond_lvl] == NESTED_COND_IF_SKIP ||
1783 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_DROP ||
1784 nested_conds[nested_cond_lvl] == NESTED_COND_ELIF_SKIP ||
1785 nested_conds[nested_cond_lvl] == NESTED_COND_ELSE_DROP)) {
1786 /* The current block is masked out by the conditions */
1787 goto next_line;
1788 }
1789
1790 /* .warning/.error/.notice */
1791 if (*args[0] == '.') {
1792 if (strcmp(args[0], ".alert") == 0) {
1793 ha_alert("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
1794 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1795 goto err;
1796 }
1797 else if (strcmp(args[0], ".warning") == 0) {
1798 ha_warning("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
1799 err_code |= ERR_WARN;
1800 goto next_line;
1801 }
1802 else if (strcmp(args[0], ".notice") == 0) {
1803 ha_notice("parsing [%s:%d]: '%s'.\n", file, linenum, args[1]);
1804 goto next_line;
1805 }
1806 else {
1807 ha_alert("parsing [%s:%d]: unknown directive '%s'.\n", file, linenum, args[0]);
1808 err_code |= ERR_ALERT | ERR_FATAL;
1809 fatal++;
1810 break;
1811 }
1812 }
1813
Willy Tarreau3842f002009-06-14 11:39:52 +02001814 /* check for keyword modifiers "no" and "default" */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001815 if (strcmp(args[0], "no") == 0) {
William Lallemand0f99e342011-10-12 17:50:54 +02001816 char *tmp;
1817
Willy Tarreau3842f002009-06-14 11:39:52 +02001818 kwm = KWM_NO;
William Lallemand0f99e342011-10-12 17:50:54 +02001819 tmp = args[0];
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01001820 for (arg=0; *args[arg+1]; arg++)
1821 args[arg] = args[arg+1]; // shift args after inversion
William Lallemand0f99e342011-10-12 17:50:54 +02001822 *tmp = '\0'; // fix the next arg to \0
1823 args[arg] = tmp;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01001824 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001825 else if (strcmp(args[0], "default") == 0) {
Willy Tarreau3842f002009-06-14 11:39:52 +02001826 kwm = KWM_DEF;
1827 for (arg=0; *args[arg+1]; arg++)
1828 args[arg] = args[arg+1]; // shift args after inversion
1829 }
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01001830
William Dauchyec730982019-10-27 20:08:10 +01001831 if (kwm != KWM_STD && strcmp(args[0], "option") != 0 &&
1832 strcmp(args[0], "log") != 0 && strcmp(args[0], "busy-polling") != 0 &&
Willy Tarreaud96f1122019-12-03 07:07:36 +01001833 strcmp(args[0], "set-dumpable") != 0 && strcmp(args[0], "strict-limits") != 0 &&
1834 strcmp(args[0], "insecure-fork-wanted") != 0) {
William Dauchyec730982019-10-27 20:08:10 +01001835 ha_alert("parsing [%s:%d]: negation/default currently "
William Dauchy0fec3ab2019-10-27 20:08:11 +01001836 "supported only for options, log, busy-polling, "
Willy Tarreaud96f1122019-12-03 07:07:36 +01001837 "set-dumpable, strict-limits, and insecure-fork-wanted.\n", file, linenum);
Willy Tarreau058e9072009-07-20 09:30:05 +02001838 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001839 fatal++;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01001840 }
1841
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001842 /* detect section start */
1843 list_for_each_entry(ics, &sections, list) {
1844 if (strcmp(args[0], ics->section_name) == 0) {
1845 cursection = ics->section_name;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01001846 pcs = cs;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001847 cs = ics;
Amaury Denoyelle728be0f2021-03-31 11:43:47 +02001848
1849 if (global.mode & MODE_DIAG) {
1850 check_section_position(args[0], file, linenum,
1851 &non_global_section_parsed);
1852 }
1853
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001854 break;
1855 }
Emeric Brun32da3c42010-09-23 18:39:19 +02001856 }
1857
Christopher Faulet7805e2b2018-11-30 13:50:47 +01001858 if (pcs && pcs->post_section_parser) {
Willy Tarreau32234e72020-06-16 17:14:33 +02001859 int status;
1860
1861 status = pcs->post_section_parser();
1862 err_code |= status;
1863 if (status & ERR_FATAL)
1864 fatal++;
1865
Christopher Faulet7805e2b2018-11-30 13:50:47 +01001866 if (err_code & ERR_ABORT)
1867 goto err;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01001868 }
Christopher Fauletbf7a9592018-12-02 09:37:38 +01001869 pcs = NULL;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01001870
William Lallemandd2ff56d2017-10-16 11:06:50 +02001871 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001872 ha_alert("parsing [%s:%d]: unknown keyword '%s' out of section.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02001873 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001874 fatal++;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001875 } else {
Willy Tarreau32234e72020-06-16 17:14:33 +02001876 int status;
1877
1878 status = cs->section_parser(file, linenum, args, kwm);
1879 err_code |= status;
1880 if (status & ERR_FATAL)
1881 fatal++;
1882
William Lallemandd2ff56d2017-10-16 11:06:50 +02001883 if (err_code & ERR_ABORT)
1884 goto err;
1885 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001886 }
William Lallemandd2ff56d2017-10-16 11:06:50 +02001887
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001888 if (missing_lf != -1) {
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001889 ha_alert("parsing [%s:%d]: Missing LF on last line, file might have been truncated at position %d.\n",
1890 file, linenum, (missing_lf + 1));
1891 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001892 }
1893
Christopher Fauletbf7a9592018-12-02 09:37:38 +01001894 if (cs && cs->post_section_parser)
Christopher Faulet7805e2b2018-11-30 13:50:47 +01001895 err_code |= cs->post_section_parser();
William Lallemandd2ff56d2017-10-16 11:06:50 +02001896
Willy Tarreau4b103022021-02-12 17:59:10 +01001897 if (nested_cond_lvl) {
1898 ha_alert("parsing [%s:%d]: non-terminated '.if' block.\n", file, linenum);
1899 err_code |= ERR_ALERT | ERR_FATAL | ERR_ABORT;
1900 }
William Lallemandd2ff56d2017-10-16 11:06:50 +02001901err:
Willy Tarreau61cfdf42021-02-20 10:46:51 +01001902 ha_free(&cfg_scope);
Willy Tarreau6daf3432008-01-22 16:44:08 +01001903 cursection = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02001904 free(thisline);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001905 free(outline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001906 fclose(f);
Willy Tarreau058e9072009-07-20 09:30:05 +02001907 return err_code;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02001908}
1909
Willy Tarreau64ab6072014-09-16 12:17:36 +02001910/* This function propagates processes from frontend <from> to backend <to> so
1911 * that it is always guaranteed that a backend pointed to by a frontend is
1912 * bound to all of its processes. After that, if the target is a "listen"
1913 * instance, the function recursively descends the target's own targets along
Willy Tarreau98d04852015-05-26 12:18:29 +02001914 * default_backend and use_backend rules. Since the bits are
Willy Tarreau64ab6072014-09-16 12:17:36 +02001915 * checked first to ensure that <to> is already bound to all processes of
1916 * <from>, there is no risk of looping and we ensure to follow the shortest
1917 * path to the destination.
1918 *
1919 * It is possible to set <to> to NULL for the first call so that the function
1920 * takes care of visiting the initial frontend in <from>.
1921 *
1922 * It is important to note that the function relies on the fact that all names
1923 * have already been resolved.
1924 */
1925void propagate_processes(struct proxy *from, struct proxy *to)
1926{
1927 struct switching_rule *rule;
Willy Tarreau64ab6072014-09-16 12:17:36 +02001928
1929 if (to) {
1930 /* check whether we need to go down */
1931 if (from->bind_proc &&
1932 (from->bind_proc & to->bind_proc) == from->bind_proc)
1933 return;
1934
1935 if (!from->bind_proc && !to->bind_proc)
1936 return;
1937
1938 to->bind_proc = from->bind_proc ?
1939 (to->bind_proc | from->bind_proc) : 0;
1940
1941 /* now propagate down */
1942 from = to;
1943 }
1944
Willy Tarreau8a95d8c2014-12-18 13:56:26 +01001945 if (!(from->cap & PR_CAP_FE))
Willy Tarreau64ab6072014-09-16 12:17:36 +02001946 return;
1947
Willy Tarreauc3914d42020-09-24 08:39:22 +02001948 if (from->disabled)
Willy Tarreauf6b70012014-12-18 14:00:43 +01001949 return;
1950
Willy Tarreau64ab6072014-09-16 12:17:36 +02001951 /* default_backend */
1952 if (from->defbe.be)
1953 propagate_processes(from, from->defbe.be);
1954
1955 /* use_backend */
1956 list_for_each_entry(rule, &from->switching_rules, list) {
Cyril Bonté51639692014-10-02 19:56:25 +02001957 if (rule->dynamic)
1958 continue;
Willy Tarreau64ab6072014-09-16 12:17:36 +02001959 to = rule->be.backend;
1960 propagate_processes(from, to);
1961 }
Willy Tarreau64ab6072014-09-16 12:17:36 +02001962}
1963
Willy Tarreaubb925012009-07-23 13:36:36 +02001964/*
1965 * Returns the error code, 0 if OK, or any combination of :
1966 * - ERR_ABORT: must abort ASAP
1967 * - ERR_FATAL: we can continue parsing but not start the service
1968 * - ERR_WARN: a warning has been emitted
1969 * - ERR_ALERT: an alert has been emitted
1970 * Only the two first ones can stop processing, the two others are just
1971 * indicators.
1972 */
Willy Tarreau915e1eb2009-06-22 15:48:36 +02001973int check_config_validity()
1974{
1975 int cfgerr = 0;
1976 struct proxy *curproxy = NULL;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001977 struct stktable *t;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02001978 struct server *newsrv = NULL;
Willy Tarreaubb925012009-07-23 13:36:36 +02001979 int err_code = 0;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02001980 unsigned int next_pxid = 1;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02001981 struct bind_conf *bind_conf;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01001982 char *err;
William Lallemand48b4bb42017-10-23 14:36:34 +02001983 struct cfg_postparser *postparser;
Emeric Brun750fe792020-12-23 16:51:12 +01001984 struct resolvers *curr_resolvers = NULL;
Amaury Denoyelle3efee652021-03-08 17:31:39 +01001985 int i;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001986
Willy Tarreau2a65ff02012-09-13 17:54:29 +02001987 bind_conf = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001988 /*
1989 * Now, check for the integrity of all that we have collected.
1990 */
1991
1992 /* will be needed further to delay some tasks */
Willy Tarreaub0b37bc2008-06-23 14:00:57 +02001993 tv_update_date(0,1);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001994
Willy Tarreau193b8c62012-11-22 00:17:38 +01001995 if (!global.tune.max_http_hdr)
1996 global.tune.max_http_hdr = MAX_HTTP_HDR;
1997
1998 if (!global.tune.cookie_len)
1999 global.tune.cookie_len = CAPTURE_LEN;
2000
Stéphane Cottin23e9e932017-05-18 08:58:41 +02002001 if (!global.tune.requri_len)
2002 global.tune.requri_len = REQURI_LEN;
2003
Willy Tarreau149ab772019-01-26 14:27:06 +01002004 if (!global.nbthread) {
2005 /* nbthread not set, thus automatic. In this case, and only if
2006 * running on a single process, we enable the same number of
2007 * threads as the number of CPUs the process is bound to. This
2008 * allows to easily control the number of threads using taskset.
2009 */
2010 global.nbthread = 1;
2011#if defined(USE_THREAD)
2012 if (global.nbproc == 1)
2013 global.nbthread = thread_cpus_enabled_at_boot;
2014 all_threads_mask = nbits(global.nbthread);
2015#endif
2016 }
2017
Willy Tarreau26f6ae12019-02-02 12:56:15 +01002018 if (global.nbproc > 1 && global.nbthread > 1) {
2019 ha_alert("config : cannot enable multiple processes if multiple threads are configured. Please use either nbproc or nbthread but not both.\n");
2020 err_code |= ERR_ALERT | ERR_FATAL;
2021 goto out;
2022 }
2023
Willy Tarreaubafbe012017-11-24 17:34:44 +01002024 pool_head_requri = create_pool("requri", global.tune.requri_len , MEM_F_SHARED);
Emeric Brun96fd9262017-07-05 13:33:16 +02002025
Willy Tarreaubafbe012017-11-24 17:34:44 +01002026 pool_head_capture = create_pool("capture", global.tune.cookie_len, MEM_F_SHARED);
Willy Tarreau193b8c62012-11-22 00:17:38 +01002027
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002028 /* Post initialisation of the users and groups lists. */
2029 err_code = userlist_postinit();
2030 if (err_code != ERR_NONE)
2031 goto out;
2032
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002033 /* first, we will invert the proxy list order */
2034 curproxy = NULL;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002035 while (proxies_list) {
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002036 struct proxy *next;
2037
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002038 next = proxies_list->next;
2039 proxies_list->next = curproxy;
2040 curproxy = proxies_list;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002041 if (!next)
2042 break;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002043 proxies_list = next;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002044 }
2045
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002046 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002047 struct switching_rule *rule;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002048 struct server_rule *srule;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002049 struct sticking_rule *mrule;
Dragan Dosen1322d092015-09-22 16:05:32 +02002050 struct logsrv *tmplogsrv;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002051 unsigned int next_id;
Willy Tarreau16a21472012-11-19 12:39:59 +01002052 int nbproc;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002053
Willy Tarreau050536d2012-10-04 08:47:34 +02002054 if (curproxy->uuid < 0) {
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002055 /* proxy ID not set, use automatic numbering with first
2056 * spare entry starting with next_pxid.
2057 */
2058 next_pxid = get_next_id(&used_proxy_id, next_pxid);
2059 curproxy->conf.id.key = curproxy->uuid = next_pxid;
2060 eb32_insert(&used_proxy_id, &curproxy->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002061 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01002062 next_pxid++;
2063
Willy Tarreau55ea7572007-06-17 19:56:27 +02002064
Willy Tarreauc3914d42020-09-24 08:39:22 +02002065 if (curproxy->disabled) {
Willy Tarreau02b092f2020-10-07 18:36:54 +02002066 /* ensure we don't keep listeners uselessly bound. We
2067 * can't disable their listeners yet (fdtab not
2068 * allocated yet) but let's skip them.
2069 */
Dragan Dosen7d61a332019-05-07 14:16:18 +02002070 if (curproxy->table) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002071 ha_free(&curproxy->table->peers.name);
Dragan Dosen7d61a332019-05-07 14:16:18 +02002072 curproxy->table->peers.p = NULL;
2073 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002074 continue;
2075 }
2076
Willy Tarreau102df612014-05-07 23:56:38 +02002077 /* Check multi-process mode compatibility for the current proxy */
2078
2079 if (curproxy->bind_proc) {
2080 /* an explicit bind-process was specified, let's check how many
2081 * processes remain.
2082 */
David Carliere6c39412015-07-02 07:00:17 +00002083 nbproc = my_popcountl(curproxy->bind_proc);
Willy Tarreau102df612014-05-07 23:56:38 +02002084
Willy Tarreaua38a7172019-02-02 17:11:28 +01002085 curproxy->bind_proc &= all_proc_mask;
Willy Tarreau102df612014-05-07 23:56:38 +02002086 if (!curproxy->bind_proc && nbproc == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002087 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 +02002088 curproxy->bind_proc = 1;
2089 }
2090 else if (!curproxy->bind_proc && nbproc > 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002091 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 +02002092 curproxy->bind_proc = 0;
2093 }
2094 }
2095
Willy Tarreau3d209582014-05-09 17:06:11 +02002096 /* check and reduce the bind-proc of each listener */
2097 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
2098 unsigned long mask;
2099
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002100 /* HTTP frontends with "h2" as ALPN/NPN will work in
2101 * HTTP/2 and absolutely require buffers 16kB or larger.
2102 */
2103#ifdef USE_OPENSSL
2104 if (curproxy->mode == PR_MODE_HTTP && global.tune.bufsize < 16384) {
2105#ifdef OPENSSL_NPN_NEGOTIATED
2106 /* check NPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002107 if (bind_conf->ssl_conf.npn_str && strstr(bind_conf->ssl_conf.npn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002108 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",
2109 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002110 cfgerr++;
2111 }
2112#endif
2113#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
2114 /* check ALPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002115 if (bind_conf->ssl_conf.alpn_str && strstr(bind_conf->ssl_conf.alpn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002116 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",
2117 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002118 cfgerr++;
2119 }
2120#endif
2121 } /* HTTP && bufsize < 16384 */
2122#endif
2123
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002124 /* detect and address thread affinity inconsistencies */
Willy Tarreaue26993c2020-09-03 07:18:55 +02002125 mask = thread_mask(bind_conf->settings.bind_thread);
Willy Tarreau3d957172019-02-02 18:00:17 +01002126 if (!(mask & all_threads_mask)) {
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002127 unsigned long new_mask = 0;
2128
2129 while (mask) {
Willy Tarreau0c026f42018-08-01 19:12:20 +02002130 new_mask |= mask & all_threads_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002131 mask >>= global.nbthread;
2132 }
2133
Willy Tarreaue26993c2020-09-03 07:18:55 +02002134 bind_conf->settings.bind_thread = new_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002135 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",
2136 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line, new_mask);
2137 }
2138
2139 /* detect process and nbproc affinity inconsistencies */
Willy Tarreaue26993c2020-09-03 07:18:55 +02002140 mask = proc_mask(bind_conf->settings.bind_proc) & proc_mask(curproxy->bind_proc);
Willy Tarreaua36b3242019-02-02 13:14:34 +01002141 if (!(mask & all_proc_mask)) {
2142 mask = proc_mask(curproxy->bind_proc) & all_proc_mask;
Willy Tarreaue26993c2020-09-03 07:18:55 +02002143 nbproc = my_popcountl(bind_conf->settings.bind_proc);
2144 bind_conf->settings.bind_proc = proc_mask(bind_conf->settings.bind_proc) & mask;
Willy Tarreau3d209582014-05-09 17:06:11 +02002145
Willy Tarreaue26993c2020-09-03 07:18:55 +02002146 if (!bind_conf->settings.bind_proc && nbproc == 1) {
Willy Tarreaua36b3242019-02-02 13:14:34 +01002147 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",
2148 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreaue26993c2020-09-03 07:18:55 +02002149 bind_conf->settings.bind_proc = mask & ~(mask - 1);
Willy Tarreaua36b3242019-02-02 13:14:34 +01002150 }
Willy Tarreaue26993c2020-09-03 07:18:55 +02002151 else if (!bind_conf->settings.bind_proc && nbproc > 1) {
Willy Tarreaua36b3242019-02-02 13:14:34 +01002152 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",
2153 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreaue26993c2020-09-03 07:18:55 +02002154 bind_conf->settings.bind_proc = 0;
Willy Tarreaua36b3242019-02-02 13:14:34 +01002155 }
Willy Tarreau3d209582014-05-09 17:06:11 +02002156 }
2157 }
2158
Willy Tarreauff01a212009-03-15 13:46:16 +01002159 switch (curproxy->mode) {
Willy Tarreauff01a212009-03-15 13:46:16 +01002160 case PR_MODE_TCP:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002161 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002162 break;
2163
2164 case PR_MODE_HTTP:
Willy Tarreau25320b22013-03-24 07:22:08 +01002165 curproxy->http_needed = 1;
Willy Tarreauff01a212009-03-15 13:46:16 +01002166 break;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002167
2168 case PR_MODE_CLI:
2169 cfgerr += proxy_cfg_ensure_no_http(curproxy);
2170 break;
Emeric Brun54932b42020-07-07 09:43:24 +02002171 case PR_MODE_SYSLOG:
Willy Tarreaua389c9e2020-10-07 17:49:42 +02002172 case PR_MODE_PEERS:
Emeric Brun54932b42020-07-07 09:43:24 +02002173 case PR_MODES:
2174 /* should not happen, bug gcc warn missing switch statement */
Willy Tarreaua389c9e2020-10-07 17:49:42 +02002175 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 +02002176 proxy_type_str(curproxy), curproxy->id);
2177 cfgerr++;
2178 break;
Willy Tarreauff01a212009-03-15 13:46:16 +01002179 }
2180
Willy Tarreau4975d142021-03-13 11:00:33 +01002181 if (curproxy != global.cli_fe && (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->conf.listeners)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002182 ha_warning("config : %s '%s' has no 'bind' directive. Please declare it as a backend if this was intended.\n",
2183 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauf3934b82015-08-11 11:36:45 +02002184 err_code |= ERR_WARN;
2185 }
2186
Willy Tarreau77e0dae2020-10-14 15:44:27 +02002187 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002188 if (curproxy->lbprm.algo & BE_LB_KIND) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002189 if (curproxy->options & PR_O_TRANSP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002190 ha_alert("config : %s '%s' cannot use both transparent and balance mode.\n",
2191 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002192 cfgerr++;
2193 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002194#ifdef WE_DONT_SUPPORT_SERVERLESS_LISTENERS
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002195 else if (curproxy->srv == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002196 ha_alert("config : %s '%s' needs at least 1 server in balance mode.\n",
2197 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002198 cfgerr++;
2199 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002200#endif
Willy Tarreau1620ec32011-08-06 17:05:02 +02002201 else if (curproxy->options & PR_O_DISPATCH) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002202 ha_warning("config : dispatch address of %s '%s' will be ignored in balance mode.\n",
2203 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002204 err_code |= ERR_WARN;
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002205 }
2206 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02002207 else if (!(curproxy->options & (PR_O_TRANSP | PR_O_DISPATCH | PR_O_HTTP_PROXY))) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002208 /* If no LB algo is set in a backend, and we're not in
2209 * transparent mode, dispatch mode nor proxy mode, we
2210 * want to use balance roundrobin by default.
2211 */
2212 curproxy->lbprm.algo &= ~BE_LB_ALGO;
2213 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002214 }
2215 }
Willy Tarreau193cf932007-09-17 10:17:23 +02002216
Willy Tarreau1620ec32011-08-06 17:05:02 +02002217 if (curproxy->options & PR_O_DISPATCH)
2218 curproxy->options &= ~(PR_O_TRANSP | PR_O_HTTP_PROXY);
2219 else if (curproxy->options & PR_O_HTTP_PROXY)
2220 curproxy->options &= ~(PR_O_DISPATCH | PR_O_TRANSP);
2221 else if (curproxy->options & PR_O_TRANSP)
2222 curproxy->options &= ~(PR_O_DISPATCH | PR_O_HTTP_PROXY);
Willy Tarreau82936582007-11-30 15:20:09 +01002223
Christopher Faulete5870d82020-04-15 11:32:03 +02002224 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_HTTP_RS)) {
2225 ha_warning("config : %s '%s' uses http-check rules without 'option httpchk', so the rules are ignored.\n",
2226 proxy_type_str(curproxy), curproxy->id);
2227 err_code |= ERR_WARN;
2228 }
2229
2230 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_TCPCHK_CHK &&
Christopher Fauletc0fcbe42020-06-03 19:00:42 +02002231 (curproxy->tcpcheck_rules.flags & TCPCHK_RULES_PROTO_CHK) != TCPCHK_RULES_HTTP_CHK) {
Willy Tarreau1620ec32011-08-06 17:05:02 +02002232 if (curproxy->options & PR_O_DISABLE404) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002233 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2234 "disable-on-404", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002235 err_code |= ERR_WARN;
2236 curproxy->options &= ~PR_O_DISABLE404;
2237 }
2238 if (curproxy->options2 & PR_O2_CHK_SNDST) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002239 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2240 "send-state", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002241 err_code |= ERR_WARN;
2242 curproxy->options &= ~PR_O2_CHK_SNDST;
2243 }
Willy Tarreauef781042010-01-27 11:53:01 +01002244 }
2245
Simon Horman98637e52014-06-20 12:30:16 +09002246 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_EXT_CHK) {
2247 if (!global.external_check) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002248 ha_alert("Proxy '%s' : '%s' unable to find required 'global.external-check'.\n",
2249 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002250 cfgerr++;
2251 }
2252 if (!curproxy->check_command) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002253 ha_alert("Proxy '%s' : '%s' unable to find required 'external-check command'.\n",
2254 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002255 cfgerr++;
2256 }
Willy Tarreaud96f1122019-12-03 07:07:36 +01002257 if (!(global.tune.options & GTUNE_INSECURE_FORK)) {
2258 ha_warning("Proxy '%s' : 'insecure-fork-wanted' not enabled in the global section, '%s' will likely fail.\n",
2259 curproxy->id, "option external-check");
2260 err_code |= ERR_WARN;
2261 }
Simon Horman98637e52014-06-20 12:30:16 +09002262 }
2263
Simon Horman64e34162015-02-06 11:11:57 +09002264 if (curproxy->email_alert.set) {
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002265 if (!(curproxy->email_alert.mailers.name && curproxy->email_alert.from && curproxy->email_alert.to)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002266 ha_warning("config : 'email-alert' will be ignored for %s '%s' (the presence any of "
2267 "'email-alert from', 'email-alert level' 'email-alert mailers', "
2268 "'email-alert myhostname', or 'email-alert to' "
2269 "requires each of 'email-alert from', 'email-alert mailers' and 'email-alert to' "
2270 "to be present).\n",
2271 proxy_type_str(curproxy), curproxy->id);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002272 err_code |= ERR_WARN;
2273 free_email_alert(curproxy);
2274 }
2275 if (!curproxy->email_alert.myhostname)
Cyril Bontée22bfd62015-12-04 03:07:07 +01002276 curproxy->email_alert.myhostname = strdup(hostname);
Simon Horman9dc49962015-01-30 11:22:59 +09002277 }
2278
Simon Horman98637e52014-06-20 12:30:16 +09002279 if (curproxy->check_command) {
2280 int clear = 0;
2281 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002282 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2283 "external-check command", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002284 err_code |= ERR_WARN;
2285 clear = 1;
2286 }
2287 if (curproxy->check_command[0] != '/' && !curproxy->check_path) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002288 ha_alert("Proxy '%s': '%s' does not have a leading '/' and 'external-check path' is not set.\n",
2289 curproxy->id, "external-check command");
Simon Horman98637e52014-06-20 12:30:16 +09002290 cfgerr++;
2291 }
2292 if (clear) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002293 ha_free(&curproxy->check_command);
Simon Horman98637e52014-06-20 12:30:16 +09002294 }
2295 }
2296
2297 if (curproxy->check_path) {
2298 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002299 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2300 "external-check path", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002301 err_code |= ERR_WARN;
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002302 ha_free(&curproxy->check_path);
Simon Horman98637e52014-06-20 12:30:16 +09002303 }
2304 }
2305
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002306 /* if a default backend was specified, let's find it */
2307 if (curproxy->defbe.name) {
2308 struct proxy *target;
2309
Willy Tarreauafb39922015-05-26 12:04:09 +02002310 target = proxy_be_by_name(curproxy->defbe.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002311 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002312 ha_alert("Proxy '%s': unable to find required default_backend: '%s'.\n",
2313 curproxy->id, curproxy->defbe.name);
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002314 cfgerr++;
2315 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002316 ha_alert("Proxy '%s': loop detected for default_backend: '%s'.\n",
2317 curproxy->id, curproxy->defbe.name);
Willy Tarreaubb925012009-07-23 13:36:36 +02002318 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002319 } else if (target->mode != curproxy->mode &&
2320 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2321
Christopher Faulet767a84b2017-11-24 16:50:31 +01002322 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) as its default backend (see 'mode').\n",
2323 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2324 curproxy->conf.file, curproxy->conf.line,
2325 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2326 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002327 cfgerr++;
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002328 } else {
2329 free(curproxy->defbe.name);
2330 curproxy->defbe.be = target;
Willy Tarreauff678132012-02-13 14:32:34 +01002331 /* Emit a warning if this proxy also has some servers */
2332 if (curproxy->srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002333 ha_warning("In proxy '%s', the 'default_backend' rule always has precedence over the servers, which will never be used.\n",
2334 curproxy->id);
Willy Tarreauff678132012-02-13 14:32:34 +01002335 err_code |= ERR_WARN;
2336 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002337 }
2338 }
2339
Willy Tarreau55ea7572007-06-17 19:56:27 +02002340 /* find the target proxy for 'use_backend' rules */
2341 list_for_each_entry(rule, &curproxy->switching_rules, list) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002342 struct proxy *target;
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002343 struct logformat_node *node;
2344 char *pxname;
2345
2346 /* Try to parse the string as a log format expression. If the result
2347 * of the parsing is only one entry containing a simple string, then
2348 * it's a standard string corresponding to a static rule, thus the
2349 * parsing is cancelled and be.name is restored to be resolved.
2350 */
2351 pxname = rule->be.name;
2352 LIST_INIT(&rule->be.expr);
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +01002353 curproxy->conf.args.ctx = ARGC_UBK;
2354 curproxy->conf.args.file = rule->file;
2355 curproxy->conf.args.line = rule->line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002356 err = NULL;
2357 if (!parse_logformat_string(pxname, curproxy, &rule->be.expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002358 ha_alert("Parsing [%s:%d]: failed to parse use_backend rule '%s' : %s.\n",
2359 rule->file, rule->line, pxname, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002360 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002361 cfgerr++;
2362 continue;
2363 }
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002364 node = LIST_NEXT(&rule->be.expr, struct logformat_node *, list);
2365
2366 if (!LIST_ISEMPTY(&rule->be.expr)) {
2367 if (node->type != LOG_FMT_TEXT || node->list.n != &rule->be.expr) {
2368 rule->dynamic = 1;
2369 free(pxname);
2370 continue;
2371 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02002372 /* Only one element in the list, a simple string: free the expression and
2373 * fall back to static rule
2374 */
2375 LIST_DEL(&node->list);
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002376 free(node->arg);
2377 free(node);
2378 }
2379
2380 rule->dynamic = 0;
2381 rule->be.name = pxname;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002382
Willy Tarreauafb39922015-05-26 12:04:09 +02002383 target = proxy_be_by_name(rule->be.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002384 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002385 ha_alert("Proxy '%s': unable to find required use_backend: '%s'.\n",
2386 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002387 cfgerr++;
2388 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002389 ha_alert("Proxy '%s': loop detected for use_backend: '%s'.\n",
2390 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002391 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002392 } else if (target->mode != curproxy->mode &&
2393 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2394
Christopher Faulet767a84b2017-11-24 16:50:31 +01002395 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) in a 'use_backend' rule (see 'mode').\n",
2396 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2397 curproxy->conf.file, curproxy->conf.line,
2398 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2399 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002400 cfgerr++;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002401 } else {
Willy Tarreau35cd7342021-02-26 20:51:47 +01002402 ha_free(&rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002403 rule->be.backend = target;
2404 }
Christopher Faulet581db2b2021-03-26 10:02:46 +01002405 err_code |= warnif_tcp_http_cond(curproxy, rule->cond);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002406 }
2407
Willy Tarreau64ab6072014-09-16 12:17:36 +02002408 /* find the target server for 'use_server' rules */
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002409 list_for_each_entry(srule, &curproxy->server_rules, list) {
Jerome Magnin824186b2020-03-29 09:37:12 +02002410 struct server *target;
2411 struct logformat_node *node;
2412 char *server_name;
2413
2414 /* We try to parse the string as a log format expression. If the result of the parsing
2415 * is only one entry containing a single string, then it's a standard string corresponding
2416 * to a static rule, thus the parsing is cancelled and we fall back to setting srv.ptr.
2417 */
2418 server_name = srule->srv.name;
2419 LIST_INIT(&srule->expr);
2420 curproxy->conf.args.ctx = ARGC_USRV;
2421 err = NULL;
2422 if (!parse_logformat_string(server_name, curproxy, &srule->expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
2423 ha_alert("Parsing [%s:%d]; use-server rule failed to parse log-format '%s' : %s.\n",
2424 srule->file, srule->line, server_name, err);
2425 free(err);
2426 cfgerr++;
2427 continue;
2428 }
2429 node = LIST_NEXT(&srule->expr, struct logformat_node *, list);
2430
2431 if (!LIST_ISEMPTY(&srule->expr)) {
2432 if (node->type != LOG_FMT_TEXT || node->list.n != &srule->expr) {
2433 srule->dynamic = 1;
2434 free(server_name);
2435 continue;
2436 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02002437 /* Only one element in the list, a simple string: free the expression and
2438 * fall back to static rule
2439 */
2440 LIST_DEL(&node->list);
Jerome Magnin824186b2020-03-29 09:37:12 +02002441 free(node->arg);
2442 free(node);
2443 }
2444
2445 srule->dynamic = 0;
2446 srule->srv.name = server_name;
2447 target = findserver(curproxy, srule->srv.name);
Christopher Faulet581db2b2021-03-26 10:02:46 +01002448 err_code |= warnif_tcp_http_cond(curproxy, srule->cond);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002449
2450 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002451 ha_alert("config : %s '%s' : unable to find server '%s' referenced in a 'use-server' rule.\n",
2452 proxy_type_str(curproxy), curproxy->id, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002453 cfgerr++;
2454 continue;
2455 }
Willy Tarreau35cd7342021-02-26 20:51:47 +01002456 ha_free(&srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002457 srule->srv.ptr = target;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002458 }
2459
Emeric Brunb982a3d2010-01-04 15:45:53 +01002460 /* find the target table for 'stick' rules */
2461 list_for_each_entry(mrule, &curproxy->sticking_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002462 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002463
Emeric Brun1d33b292010-01-04 15:47:17 +01002464 curproxy->be_req_ana |= AN_REQ_STICKING_RULES;
2465 if (mrule->flags & STK_IS_STORE)
2466 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2467
Emeric Brunb982a3d2010-01-04 15:45:53 +01002468 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002469 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002470 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002471 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002472
2473 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002474 ha_alert("Proxy '%s': unable to find stick-table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01002475 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002476 cfgerr++;
2477 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002478 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002479 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2480 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002481 cfgerr++;
2482 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002483 else if (target->proxy && curproxy->bind_proc & ~target->proxy->bind_proc) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002484 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2485 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002486 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002487 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002488 else {
Willy Tarreau35cd7342021-02-26 20:51:47 +01002489 ha_free(&mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002490 mrule->table.t = target;
2491 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Thayne McCombs92149f92020-11-20 01:28:26 -07002492 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_KEY, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02002493 if (!in_proxies_list(target->proxies_list, curproxy)) {
2494 curproxy->next_stkt_ref = target->proxies_list;
2495 target->proxies_list = curproxy;
2496 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002497 }
Christopher Faulet581db2b2021-03-26 10:02:46 +01002498 err_code |= warnif_tcp_http_cond(curproxy, mrule->cond);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002499 }
2500
2501 /* find the target table for 'store response' rules */
2502 list_for_each_entry(mrule, &curproxy->storersp_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002503 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002504
Emeric Brun1d33b292010-01-04 15:47:17 +01002505 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2506
Emeric Brunb982a3d2010-01-04 15:45:53 +01002507 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002508 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002509 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002510 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002511
2512 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002513 ha_alert("Proxy '%s': unable to find store table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01002514 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002515 cfgerr++;
2516 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002517 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002518 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2519 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002520 cfgerr++;
2521 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002522 else if (target->proxy && (curproxy->bind_proc & ~target->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002523 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2524 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002525 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002526 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002527 else {
Willy Tarreau35cd7342021-02-26 20:51:47 +01002528 ha_free(&mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002529 mrule->table.t = target;
2530 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Thayne McCombs92149f92020-11-20 01:28:26 -07002531 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_KEY, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02002532 if (!in_proxies_list(target->proxies_list, curproxy)) {
2533 curproxy->next_stkt_ref = target->proxies_list;
2534 target->proxies_list = curproxy;
2535 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002536 }
2537 }
2538
Christopher Faulet42c6cf92021-03-25 17:19:04 +01002539 /* check validity for 'tcp-request' layer 4/5/6/7 rules */
2540 cfgerr += check_action_rules(&curproxy->tcp_req.l4_rules, curproxy, &err_code);
2541 cfgerr += check_action_rules(&curproxy->tcp_req.l5_rules, curproxy, &err_code);
2542 cfgerr += check_action_rules(&curproxy->tcp_req.inspect_rules, curproxy, &err_code);
2543 cfgerr += check_action_rules(&curproxy->tcp_rep.inspect_rules, curproxy, &err_code);
2544 cfgerr += check_action_rules(&curproxy->http_req_rules, curproxy, &err_code);
2545 cfgerr += check_action_rules(&curproxy->http_res_rules, curproxy, &err_code);
2546 cfgerr += check_action_rules(&curproxy->http_after_res_rules, curproxy, &err_code);
Christopher Faulet6d0c3df2020-01-22 09:26:35 +01002547
Christopher Faulet5eef0182021-03-31 17:13:49 +02002548 /* Warn is a switch-mode http is used on a TCP listener with servers but no backend */
2549 if (!curproxy->defbe.name && LIST_ISEMPTY(&curproxy->switching_rules) && curproxy->srv) {
2550 if ((curproxy->options & PR_O_HTTP_UPG) && curproxy->mode == PR_MODE_TCP)
2551 ha_warning("Proxy '%s' : 'switch-mode http' configured for a %s %s with no backend. "
2552 "Incoming connections upgraded to HTTP cannot be routed to TCP servers\n",
2553 curproxy->id, proxy_mode_str(curproxy->mode), proxy_type_str(curproxy));
2554 }
2555
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002556 if (curproxy->table && curproxy->table->peers.name) {
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002557 struct peers *curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002558
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002559 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002560 if (strcmp(curpeers->id, curproxy->table->peers.name) == 0) {
Willy Tarreau35cd7342021-02-26 20:51:47 +01002561 ha_free(&curproxy->table->peers.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002562 curproxy->table->peers.p = curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002563 break;
2564 }
2565 }
2566
2567 if (!curpeers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002568 ha_alert("Proxy '%s': unable to find sync peers '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002569 curproxy->id, curproxy->table->peers.name);
Willy Tarreau35cd7342021-02-26 20:51:47 +01002570 ha_free(&curproxy->table->peers.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002571 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002572 cfgerr++;
2573 }
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02002574 else if (curpeers->disabled) {
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002575 /* silently disable this peers section */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002576 curproxy->table->peers.p = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002577 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002578 else if (!curpeers->peers_fe) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002579 ha_alert("Proxy '%s': unable to find local peer '%s' in peers section '%s'.\n",
2580 curproxy->id, localpeer, curpeers->id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002581 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002582 cfgerr++;
2583 }
2584 }
2585
Simon Horman9dc49962015-01-30 11:22:59 +09002586
2587 if (curproxy->email_alert.mailers.name) {
2588 struct mailers *curmailers = mailers;
2589
2590 for (curmailers = mailers; curmailers; curmailers = curmailers->next) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002591 if (strcmp(curmailers->id, curproxy->email_alert.mailers.name) == 0)
Simon Horman9dc49962015-01-30 11:22:59 +09002592 break;
Simon Horman9dc49962015-01-30 11:22:59 +09002593 }
Simon Horman9dc49962015-01-30 11:22:59 +09002594 if (!curmailers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002595 ha_alert("Proxy '%s': unable to find mailers '%s'.\n",
2596 curproxy->id, curproxy->email_alert.mailers.name);
Simon Horman9dc49962015-01-30 11:22:59 +09002597 free_email_alert(curproxy);
2598 cfgerr++;
2599 }
Christopher Faulet0108bb32017-10-20 21:34:32 +02002600 else {
2601 err = NULL;
2602 if (init_email_alert(curmailers, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002603 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulet0108bb32017-10-20 21:34:32 +02002604 free(err);
2605 cfgerr++;
2606 }
2607 }
Simon Horman9dc49962015-01-30 11:22:59 +09002608 }
2609
Willy Tarreau5bbc6762021-02-12 11:49:25 +01002610 if (curproxy->uri_auth && !(curproxy->uri_auth->flags & STAT_CONVDONE) &&
Willy Tarreauff011f22011-01-06 17:51:27 +01002611 !LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules) &&
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002612 (curproxy->uri_auth->userlist || curproxy->uri_auth->auth_realm )) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002613 ha_alert("%s '%s': stats 'auth'/'realm' and 'http-request' can't be used at the same time.\n",
2614 "proxy", curproxy->id);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002615 cfgerr++;
2616 goto out_uri_auth_compat;
2617 }
2618
Willy Tarreauee4f5f82019-10-09 09:59:22 +02002619 if (curproxy->uri_auth && curproxy->uri_auth->userlist &&
Willy Tarreau5bbc6762021-02-12 11:49:25 +01002620 (!(curproxy->uri_auth->flags & STAT_CONVDONE) ||
Willy Tarreauee4f5f82019-10-09 09:59:22 +02002621 LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules))) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002622 const char *uri_auth_compat_req[10];
Thierry FOURNIERa28a9422015-08-04 19:35:46 +02002623 struct act_rule *rule;
Amaury Denoyelle3efee652021-03-08 17:31:39 +01002624 i = 0;
2625
Willy Tarreau95fa4692010-02-01 13:05:50 +01002626 /* build the ACL condition from scratch. We're relying on anonymous ACLs for that */
2627 uri_auth_compat_req[i++] = "auth";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002628
2629 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002630 uri_auth_compat_req[i++] = "realm";
2631 uri_auth_compat_req[i++] = curproxy->uri_auth->auth_realm;
2632 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002633
Willy Tarreau95fa4692010-02-01 13:05:50 +01002634 uri_auth_compat_req[i++] = "unless";
2635 uri_auth_compat_req[i++] = "{";
2636 uri_auth_compat_req[i++] = "http_auth(.internal-stats-userlist)";
2637 uri_auth_compat_req[i++] = "}";
2638 uri_auth_compat_req[i++] = "";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002639
Willy Tarreauff011f22011-01-06 17:51:27 +01002640 rule = parse_http_req_cond(uri_auth_compat_req, "internal-stats-auth-compat", 0, curproxy);
2641 if (!rule) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002642 cfgerr++;
2643 break;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002644 }
2645
Willy Tarreauff011f22011-01-06 17:51:27 +01002646 LIST_ADDQ(&curproxy->uri_auth->http_req_rules, &rule->list);
Willy Tarreau95fa4692010-02-01 13:05:50 +01002647
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002648 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002649 ha_free(&curproxy->uri_auth->auth_realm);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002650 }
Willy Tarreau5bbc6762021-02-12 11:49:25 +01002651 curproxy->uri_auth->flags |= STAT_CONVDONE;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002652 }
2653out_uri_auth_compat:
2654
Dragan Dosen43885c72015-10-01 13:18:13 +02002655 /* check whether we have a log server that uses RFC5424 log format */
Dragan Dosen1322d092015-09-22 16:05:32 +02002656 list_for_each_entry(tmplogsrv, &curproxy->logsrvs, list) {
Dragan Dosen43885c72015-10-01 13:18:13 +02002657 if (tmplogsrv->format == LOG_FORMAT_RFC5424) {
2658 if (!curproxy->conf.logformat_sd_string) {
2659 /* set the default logformat_sd_string */
2660 curproxy->conf.logformat_sd_string = default_rfc5424_sd_log_format;
2661 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002662 break;
Dragan Dosen1322d092015-09-22 16:05:32 +02002663 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002664 }
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02002665
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002666 /* compile the log format */
2667 if (!(curproxy->cap & PR_CAP_FE)) {
Willy Tarreau62a61232013-04-12 18:13:46 +02002668 if (curproxy->conf.logformat_string != default_http_log_format &&
2669 curproxy->conf.logformat_string != default_tcp_log_format &&
2670 curproxy->conf.logformat_string != clf_http_log_format)
2671 free(curproxy->conf.logformat_string);
2672 curproxy->conf.logformat_string = NULL;
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002673 ha_free(&curproxy->conf.lfs_file);
Willy Tarreau62a61232013-04-12 18:13:46 +02002674 curproxy->conf.lfs_line = 0;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002675
2676 if (curproxy->conf.logformat_sd_string != default_rfc5424_sd_log_format)
2677 free(curproxy->conf.logformat_sd_string);
2678 curproxy->conf.logformat_sd_string = NULL;
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002679 ha_free(&curproxy->conf.lfsd_file);
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002680 curproxy->conf.lfsd_line = 0;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002681 }
2682
Willy Tarreau62a61232013-04-12 18:13:46 +02002683 if (curproxy->conf.logformat_string) {
2684 curproxy->conf.args.ctx = ARGC_LOG;
2685 curproxy->conf.args.file = curproxy->conf.lfs_file;
2686 curproxy->conf.args.line = curproxy->conf.lfs_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002687 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02002688 if (!parse_logformat_string(curproxy->conf.logformat_string, curproxy, &curproxy->logformat,
2689 LOG_OPT_MANDATORY|LOG_OPT_MERGE_SPACES,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002690 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002691 ha_alert("Parsing [%s:%d]: failed to parse log-format : %s.\n",
2692 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002693 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002694 cfgerr++;
2695 }
Willy Tarreau62a61232013-04-12 18:13:46 +02002696 curproxy->conf.args.file = NULL;
2697 curproxy->conf.args.line = 0;
2698 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002699
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002700 if (curproxy->conf.logformat_sd_string) {
2701 curproxy->conf.args.ctx = ARGC_LOGSD;
2702 curproxy->conf.args.file = curproxy->conf.lfsd_file;
2703 curproxy->conf.args.line = curproxy->conf.lfsd_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002704 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02002705 if (!parse_logformat_string(curproxy->conf.logformat_sd_string, curproxy, &curproxy->logformat_sd,
2706 LOG_OPT_MANDATORY|LOG_OPT_MERGE_SPACES,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002707 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002708 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
2709 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002710 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002711 cfgerr++;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002712 } else if (!add_to_logformat_list(NULL, NULL, LF_SEPARATOR, &curproxy->logformat_sd, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002713 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
2714 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002715 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002716 cfgerr++;
2717 }
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002718 curproxy->conf.args.file = NULL;
2719 curproxy->conf.args.line = 0;
2720 }
2721
Willy Tarreau62a61232013-04-12 18:13:46 +02002722 if (curproxy->conf.uniqueid_format_string) {
2723 curproxy->conf.args.ctx = ARGC_UIF;
2724 curproxy->conf.args.file = curproxy->conf.uif_file;
2725 curproxy->conf.args.line = curproxy->conf.uif_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002726 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02002727 if (!parse_logformat_string(curproxy->conf.uniqueid_format_string, curproxy, &curproxy->format_unique_id,
2728 LOG_OPT_HTTP|LOG_OPT_MERGE_SPACES,
2729 (curproxy->cap & PR_CAP_FE) ? SMP_VAL_FE_HRQ_HDR
2730 : SMP_VAL_BE_HRQ_HDR,
2731 &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002732 ha_alert("Parsing [%s:%d]: failed to parse unique-id : %s.\n",
2733 curproxy->conf.uif_file, curproxy->conf.uif_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002734 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002735 cfgerr++;
2736 }
Willy Tarreau62a61232013-04-12 18:13:46 +02002737 curproxy->conf.args.file = NULL;
2738 curproxy->conf.args.line = 0;
2739 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002740
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002741 /* only now we can check if some args remain unresolved.
2742 * This must be done after the users and groups resolution.
2743 */
Willy Tarreau77e6a4e2021-03-26 16:11:55 +01002744 err = NULL;
2745 i = smp_resolve_args(curproxy, &err);
2746 cfgerr += i;
2747 if (i) {
2748 indent_msg(&err, 8);
2749 ha_alert("%s%s\n", i > 1 ? "multiple argument resolution errors:" : "", err);
2750 ha_free(&err);
2751 } else
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002752 cfgerr += acl_find_targets(curproxy);
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01002753
Willy Tarreau2738a142006-07-08 17:28:09 +02002754 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002755 (((curproxy->cap & PR_CAP_FE) && !curproxy->timeout.client) ||
Willy Tarreaud825eef2007-05-12 22:35:00 +02002756 ((curproxy->cap & PR_CAP_BE) && (curproxy->srv) &&
Willy Tarreauce887fd2012-05-12 12:50:00 +02002757 (!curproxy->timeout.connect ||
2758 (!curproxy->timeout.server && (curproxy->mode == PR_MODE_HTTP || !curproxy->timeout.tunnel)))))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002759 ha_warning("config : missing timeouts for %s '%s'.\n"
2760 " | While not properly invalid, you will certainly encounter various problems\n"
2761 " | with such a configuration. To fix this, please ensure that all following\n"
2762 " | timeouts are set to a non-zero value: 'client', 'connect', 'server'.\n",
2763 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002764 err_code |= ERR_WARN;
Willy Tarreau2738a142006-07-08 17:28:09 +02002765 }
Willy Tarreauf3c69202006-07-09 16:42:34 +02002766
Willy Tarreau1fa31262007-12-03 00:36:16 +01002767 /* Historically, the tarpit and queue timeouts were inherited from contimeout.
2768 * We must still support older configurations, so let's find out whether those
2769 * parameters have been set or must be copied from contimeouts.
2770 */
Willy Tarreau937c3ea2021-02-12 11:14:35 +01002771 if (!curproxy->timeout.tarpit)
2772 curproxy->timeout.tarpit = curproxy->timeout.connect;
2773 if ((curproxy->cap & PR_CAP_BE) && !curproxy->timeout.queue)
2774 curproxy->timeout.queue = curproxy->timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01002775
Christopher Faulete5870d82020-04-15 11:32:03 +02002776 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_TCP_RS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002777 ha_warning("config : %s '%s' uses tcp-check rules without 'option tcp-check', so the rules are ignored.\n",
2778 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau215663d2014-06-13 18:30:23 +02002779 err_code |= ERR_WARN;
2780 }
2781
Willy Tarreau193b8c62012-11-22 00:17:38 +01002782 /* ensure that cookie capture length is not too large */
2783 if (curproxy->capture_len >= global.tune.cookie_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002784 ha_warning("config : truncating capture length to %d bytes for %s '%s'.\n",
2785 global.tune.cookie_len - 1, proxy_type_str(curproxy), curproxy->id);
Willy Tarreau193b8c62012-11-22 00:17:38 +01002786 err_code |= ERR_WARN;
2787 curproxy->capture_len = global.tune.cookie_len - 1;
2788 }
2789
Willy Tarreaucf7f3202007-05-13 22:46:04 +02002790 /* The small pools required for the capture lists */
Willy Tarreau9a54e132012-03-24 08:33:05 +01002791 if (curproxy->nb_req_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02002792 curproxy->req_cap_pool = create_pool("ptrcap",
2793 curproxy->nb_req_cap * sizeof(char *),
2794 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01002795 }
2796
2797 if (curproxy->nb_rsp_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02002798 curproxy->rsp_cap_pool = create_pool("ptrcap",
2799 curproxy->nb_rsp_cap * sizeof(char *),
2800 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01002801 }
Willy Tarreaucf7f3202007-05-13 22:46:04 +02002802
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002803 switch (curproxy->load_server_state_from_file) {
2804 case PR_SRV_STATE_FILE_UNSPEC:
2805 curproxy->load_server_state_from_file = PR_SRV_STATE_FILE_NONE;
2806 break;
2807 case PR_SRV_STATE_FILE_GLOBAL:
2808 if (!global.server_state_file) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002809 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",
2810 curproxy->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002811 err_code |= ERR_WARN;
2812 }
2813 break;
2814 }
2815
Willy Tarreaubaaee002006-06-26 02:48:02 +02002816 /* first, we will invert the servers list order */
2817 newsrv = NULL;
2818 while (curproxy->srv) {
2819 struct server *next;
2820
2821 next = curproxy->srv->next;
2822 curproxy->srv->next = newsrv;
2823 newsrv = curproxy->srv;
2824 if (!next)
2825 break;
2826 curproxy->srv = next;
2827 }
2828
Willy Tarreau17edc812014-01-03 12:14:34 +01002829 /* Check that no server name conflicts. This causes trouble in the stats.
2830 * We only emit a warning for the first conflict affecting each server,
2831 * in order to avoid combinatory explosion if all servers have the same
2832 * name. We do that only for servers which do not have an explicit ID,
2833 * because these IDs were made also for distinguishing them and we don't
2834 * want to annoy people who correctly manage them.
2835 */
2836 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
2837 struct server *other_srv;
2838
2839 if (newsrv->puid)
2840 continue;
2841
2842 for (other_srv = curproxy->srv; other_srv && other_srv != newsrv; other_srv = other_srv->next) {
2843 if (!other_srv->puid && strcmp(other_srv->id, newsrv->id) == 0) {
Willy Tarreaub01302f2019-05-27 19:31:06 +02002844 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 +01002845 newsrv->conf.file, newsrv->conf.line,
2846 proxy_type_str(curproxy), curproxy->id,
2847 newsrv->id, other_srv->conf.line);
Willy Tarreaub01302f2019-05-27 19:31:06 +02002848 cfgerr++;
Willy Tarreau17edc812014-01-03 12:14:34 +01002849 break;
2850 }
2851 }
2852 }
2853
Willy Tarreaudd701652010-05-25 23:03:02 +02002854 /* assign automatic UIDs to servers which don't have one yet */
2855 next_id = 1;
2856 newsrv = curproxy->srv;
2857 while (newsrv != NULL) {
2858 if (!newsrv->puid) {
2859 /* server ID not set, use automatic numbering with first
2860 * spare entry starting with next_svid.
2861 */
2862 next_id = get_next_id(&curproxy->conf.used_server_id, next_id);
2863 newsrv->conf.id.key = newsrv->puid = next_id;
2864 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Frédéric Lécaille84d60462019-05-17 14:29:15 +02002865 newsrv->conf.name.key = newsrv->id;
2866 ebis_insert(&curproxy->conf.used_server_name, &newsrv->conf.name);
Willy Tarreaudd701652010-05-25 23:03:02 +02002867 }
2868 next_id++;
2869 newsrv = newsrv->next;
2870 }
2871
Willy Tarreau20697042007-11-15 23:26:18 +01002872 curproxy->lbprm.wmult = 1; /* default weight multiplier */
Willy Tarreau5dc2fa62007-11-19 19:10:18 +01002873 curproxy->lbprm.wdiv = 1; /* default weight divider */
Willy Tarreaubaaee002006-06-26 02:48:02 +02002874
Willy Tarreau62c3be22012-01-20 13:12:32 +01002875 /*
2876 * If this server supports a maxconn parameter, it needs a dedicated
2877 * tasks to fill the emptied slots when a connection leaves.
2878 * Also, resolve deferred tracking dependency if needed.
2879 */
2880 newsrv = curproxy->srv;
2881 while (newsrv != NULL) {
2882 if (newsrv->minconn > newsrv->maxconn) {
2883 /* Only 'minconn' was specified, or it was higher than or equal
2884 * to 'maxconn'. Let's turn this into maxconn and clean it, as
2885 * this will avoid further useless expensive computations.
2886 */
2887 newsrv->maxconn = newsrv->minconn;
2888 } else if (newsrv->maxconn && !newsrv->minconn) {
2889 /* minconn was not specified, so we set it to maxconn */
2890 newsrv->minconn = newsrv->maxconn;
2891 }
2892
William Dauchyf6370442020-11-14 19:25:33 +01002893 /* this will also properly set the transport layer for
2894 * prod and checks
2895 * if default-server have use_ssl, prerare ssl init
2896 * without activating it */
2897 if (newsrv->use_ssl == 1 || newsrv->check.use_ssl == 1 ||
2898 (newsrv->proxy->options & PR_O_TCPCHK_SSL) ||
2899 (newsrv->use_ssl != 1 && curproxy->defsrv.use_ssl == 1)) {
Willy Tarreau17d45382016-12-22 21:16:08 +01002900 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
2901 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(newsrv);
2902 }
Emeric Brun94324a42012-10-11 14:00:19 +02002903
Willy Tarreau034c88c2017-01-23 23:36:45 +01002904 if ((newsrv->flags & SRV_F_FASTOPEN) &&
2905 ((curproxy->retry_type & (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)) !=
2906 (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)))
2907 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",
2908 newsrv->conf.file, newsrv->conf.line,
2909 proxy_type_str(curproxy), curproxy->id,
2910 newsrv->id);
2911
Willy Tarreau62c3be22012-01-20 13:12:32 +01002912 if (newsrv->trackit) {
2913 struct proxy *px;
Willy Tarreau32091232014-05-16 13:52:00 +02002914 struct server *srv, *loop;
Willy Tarreau62c3be22012-01-20 13:12:32 +01002915 char *pname, *sname;
2916
2917 pname = newsrv->trackit;
2918 sname = strrchr(pname, '/');
2919
2920 if (sname)
2921 *sname++ = '\0';
2922 else {
2923 sname = pname;
2924 pname = NULL;
2925 }
2926
2927 if (pname) {
Willy Tarreau9e0bb102015-05-26 11:24:42 +02002928 px = proxy_be_by_name(pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002929 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002930 ha_alert("config : %s '%s', server '%s': unable to find required proxy '%s' for tracking.\n",
2931 proxy_type_str(curproxy), curproxy->id,
2932 newsrv->id, pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002933 cfgerr++;
2934 goto next_srv;
2935 }
2936 } else
2937 px = curproxy;
2938
2939 srv = findserver(px, sname);
2940 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002941 ha_alert("config : %s '%s', server '%s': unable to find required server '%s' for tracking.\n",
2942 proxy_type_str(curproxy), curproxy->id,
2943 newsrv->id, sname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002944 cfgerr++;
2945 goto next_srv;
2946 }
2947
Christopher Faulet8892e5d2020-03-26 19:48:20 +01002948 if (!srv->do_check && !srv->do_agent && !srv->track && !srv->trackit) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002949 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for "
2950 "tracking as it does not have any check nor agent enabled.\n",
2951 proxy_type_str(curproxy), curproxy->id,
2952 newsrv->id, px->id, srv->id);
Willy Tarreau32091232014-05-16 13:52:00 +02002953 cfgerr++;
2954 goto next_srv;
2955 }
2956
2957 for (loop = srv->track; loop && loop != newsrv; loop = loop->track);
2958
Frédéric Lécaille2efc6492017-03-14 14:32:17 +01002959 if (newsrv == srv || loop) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002960 ha_alert("config : %s '%s', server '%s': unable to track %s/%s as it "
2961 "belongs to a tracking chain looping back to %s/%s.\n",
2962 proxy_type_str(curproxy), curproxy->id,
2963 newsrv->id, px->id, srv->id, px->id,
2964 newsrv == srv ? srv->id : loop->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002965 cfgerr++;
2966 goto next_srv;
2967 }
2968
2969 if (curproxy != px &&
2970 (curproxy->options & PR_O_DISABLE404) != (px->options & PR_O_DISABLE404)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002971 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for"
2972 "tracking: disable-on-404 option inconsistency.\n",
2973 proxy_type_str(curproxy), curproxy->id,
2974 newsrv->id, px->id, srv->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002975 cfgerr++;
2976 goto next_srv;
2977 }
2978
Willy Tarreau62c3be22012-01-20 13:12:32 +01002979 newsrv->track = srv;
Willy Tarreau1a53a3a2013-12-11 15:27:05 +01002980 newsrv->tracknext = srv->trackers;
2981 srv->trackers = newsrv;
Willy Tarreau62c3be22012-01-20 13:12:32 +01002982
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002983 ha_free(&newsrv->trackit);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002984 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002985
Willy Tarreau62c3be22012-01-20 13:12:32 +01002986 next_srv:
2987 newsrv = newsrv->next;
2988 }
2989
Olivier Houchard4e694042017-03-14 20:01:29 +01002990 /*
2991 * Try to generate dynamic cookies for servers now.
2992 * It couldn't be done earlier, since at the time we parsed
2993 * the server line, we may not have known yet that we
2994 * should use dynamic cookies, or the secret key may not
2995 * have been provided yet.
2996 */
2997 if (curproxy->ck_opts & PR_CK_DYNAMIC) {
2998 newsrv = curproxy->srv;
2999 while (newsrv != NULL) {
3000 srv_set_dyncookie(newsrv);
3001 newsrv = newsrv->next;
3002 }
3003
3004 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003005 /* We have to initialize the server lookup mechanism depending
Joseph Herlanta14c03e2018-11-15 14:04:19 -08003006 * on what LB algorithm was chosen.
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003007 */
3008
3009 curproxy->lbprm.algo &= ~(BE_LB_LKUP | BE_LB_PROP_DYN);
3010 switch (curproxy->lbprm.algo & BE_LB_KIND) {
3011 case BE_LB_KIND_RR:
Willy Tarreau9757a382009-10-03 12:56:50 +02003012 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_STATIC) {
3013 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3014 init_server_map(curproxy);
Willy Tarreau760e81d2018-05-03 07:20:40 +02003015 } else if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_RANDOM) {
3016 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3017 chash_init_server_tree(curproxy);
Willy Tarreau9757a382009-10-03 12:56:50 +02003018 } else {
3019 curproxy->lbprm.algo |= BE_LB_LKUP_RRTREE | BE_LB_PROP_DYN;
3020 fwrr_init_server_groups(curproxy);
3021 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003022 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003023
Willy Tarreau3ebb1162012-02-13 16:57:44 +01003024 case BE_LB_KIND_CB:
Willy Tarreauf09c6602012-02-13 17:12:08 +01003025 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_CB_LC) {
3026 curproxy->lbprm.algo |= BE_LB_LKUP_LCTREE | BE_LB_PROP_DYN;
3027 fwlc_init_server_tree(curproxy);
3028 } else {
3029 curproxy->lbprm.algo |= BE_LB_LKUP_FSTREE | BE_LB_PROP_DYN;
3030 fas_init_server_tree(curproxy);
3031 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003032 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003033
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003034 case BE_LB_KIND_HI:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003035 if ((curproxy->lbprm.algo & BE_LB_HASH_TYPE) == BE_LB_HASH_CONS) {
3036 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3037 chash_init_server_tree(curproxy);
3038 } else {
3039 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3040 init_server_map(curproxy);
3041 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003042 break;
3043 }
Willy Tarreaucd10def2020-10-17 18:48:47 +02003044 HA_RWLOCK_INIT(&curproxy->lbprm.lock);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003045
3046 if (curproxy->options & PR_O_LOGASAP)
3047 curproxy->to_log &= ~LW_BYTES;
3048
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003049 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003050 (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->logsrvs) &&
3051 (!LIST_ISEMPTY(&curproxy->logformat) || !LIST_ISEMPTY(&curproxy->logformat_sd))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003052 ha_warning("config : log format ignored for %s '%s' since it has no log address.\n",
3053 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003054 err_code |= ERR_WARN;
3055 }
3056
Christopher Faulet3b6446f2021-03-15 15:10:38 +01003057 if (curproxy->mode != PR_MODE_HTTP && !(curproxy->options & PR_O_HTTP_UPG)) {
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003058 int optnum;
3059
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003060 if (curproxy->uri_auth) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003061 ha_warning("config : 'stats' statement ignored for %s '%s' as it requires HTTP mode.\n",
3062 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003063 err_code |= ERR_WARN;
3064 curproxy->uri_auth = NULL;
3065 }
3066
Willy Tarreaude7dc882017-03-10 11:49:21 +01003067 if (curproxy->capture_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003068 ha_warning("config : 'capture' statement ignored for %s '%s' as it requires HTTP mode.\n",
3069 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003070 err_code |= ERR_WARN;
3071 }
3072
3073 if (!LIST_ISEMPTY(&curproxy->http_req_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003074 ha_warning("config : 'http-request' rules ignored for %s '%s' as they require HTTP mode.\n",
3075 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003076 err_code |= ERR_WARN;
3077 }
3078
3079 if (!LIST_ISEMPTY(&curproxy->http_res_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003080 ha_warning("config : 'http-response' rules ignored for %s '%s' as they require HTTP mode.\n",
3081 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003082 err_code |= ERR_WARN;
3083 }
3084
Christopher Fauletbb7abed2021-03-15 15:09:21 +01003085 if (!LIST_ISEMPTY(&curproxy->http_after_res_rules)) {
3086 ha_warning("config : 'http-after-response' rules ignored for %s '%s' as they require HTTP mode.\n",
3087 proxy_type_str(curproxy), curproxy->id);
3088 err_code |= ERR_WARN;
3089 }
3090
Willy Tarreaude7dc882017-03-10 11:49:21 +01003091 if (!LIST_ISEMPTY(&curproxy->redirect_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003092 ha_warning("config : 'redirect' rules ignored for %s '%s' as they require HTTP mode.\n",
3093 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003094 err_code |= ERR_WARN;
3095 }
3096
Willy Tarreau87cf5142011-08-19 22:57:24 +02003097 if (curproxy->options & (PR_O_FWDFOR | PR_O_FF_ALWAYS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003098 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3099 "forwardfor", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003100 err_code |= ERR_WARN;
Willy Tarreau87cf5142011-08-19 22:57:24 +02003101 curproxy->options &= ~(PR_O_FWDFOR | PR_O_FF_ALWAYS);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003102 }
3103
3104 if (curproxy->options & PR_O_ORGTO) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003105 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3106 "originalto", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003107 err_code |= ERR_WARN;
3108 curproxy->options &= ~PR_O_ORGTO;
3109 }
3110
3111 for (optnum = 0; cfg_opts[optnum].name; optnum++) {
3112 if (cfg_opts[optnum].mode == PR_MODE_HTTP &&
3113 (curproxy->cap & cfg_opts[optnum].cap) &&
3114 (curproxy->options & cfg_opts[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003115 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3116 cfg_opts[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003117 err_code |= ERR_WARN;
3118 curproxy->options &= ~cfg_opts[optnum].val;
3119 }
3120 }
3121
3122 for (optnum = 0; cfg_opts2[optnum].name; optnum++) {
3123 if (cfg_opts2[optnum].mode == PR_MODE_HTTP &&
3124 (curproxy->cap & cfg_opts2[optnum].cap) &&
3125 (curproxy->options2 & cfg_opts2[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003126 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3127 cfg_opts2[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003128 err_code |= ERR_WARN;
3129 curproxy->options2 &= ~cfg_opts2[optnum].val;
3130 }
3131 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003132
Willy Tarreau29fbe512015-08-20 19:35:14 +02003133#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003134 if (curproxy->conn_src.bind_hdr_occ) {
3135 curproxy->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003136 ha_warning("config : %s '%s' : ignoring use of header %s as source IP in non-HTTP mode.\n",
3137 proxy_type_str(curproxy), curproxy->id, curproxy->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003138 err_code |= ERR_WARN;
3139 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003140#endif
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003141 }
3142
Willy Tarreaubaaee002006-06-26 02:48:02 +02003143 /*
Willy Tarreau21d2af32008-02-14 20:25:24 +01003144 * ensure that we're not cross-dressing a TCP server into HTTP.
3145 */
3146 newsrv = curproxy->srv;
3147 while (newsrv != NULL) {
Willy Tarreau0cec3312011-10-31 13:49:26 +01003148 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->rdr_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003149 ha_alert("config : %s '%s' : server cannot have cookie or redirect prefix in non-HTTP mode.\n",
3150 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003151 cfgerr++;
Willy Tarreau21d2af32008-02-14 20:25:24 +01003152 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003153
Willy Tarreau0cec3312011-10-31 13:49:26 +01003154 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->cklen) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003155 ha_warning("config : %s '%s' : ignoring cookie for server '%s' as HTTP mode is disabled.\n",
3156 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau0cec3312011-10-31 13:49:26 +01003157 err_code |= ERR_WARN;
3158 }
3159
Willy Tarreauc93cd162014-05-13 15:54:22 +02003160 if ((newsrv->flags & SRV_F_MAPPORTS) && (curproxy->options2 & PR_O2_RDPC_PRST)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003161 ha_warning("config : %s '%s' : RDP cookie persistence will not work for server '%s' because it lacks an explicit port number.\n",
3162 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau82ffa392013-08-13 17:19:08 +02003163 err_code |= ERR_WARN;
3164 }
3165
Willy Tarreau29fbe512015-08-20 19:35:14 +02003166#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003167 if (curproxy->mode != PR_MODE_HTTP && newsrv->conn_src.bind_hdr_occ) {
3168 newsrv->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003169 ha_warning("config : %s '%s' : server %s cannot use header %s as source IP in non-HTTP mode.\n",
3170 proxy_type_str(curproxy), curproxy->id, newsrv->id, newsrv->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003171 err_code |= ERR_WARN;
3172 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003173#endif
Willy Tarreau4c183462017-01-06 12:21:38 +01003174
Willy Tarreau46deab62018-04-28 07:18:15 +02003175 if ((curproxy->mode != PR_MODE_HTTP) && (curproxy->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR)
3176 curproxy->options &= ~PR_O_REUSE_MASK;
3177
Willy Tarreau21d2af32008-02-14 20:25:24 +01003178 newsrv = newsrv->next;
3179 }
3180
Christopher Fauletd7c91962015-04-30 11:48:27 +02003181 /* Check filter configuration, if any */
3182 cfgerr += flt_check(curproxy);
3183
Willy Tarreauc1a21672009-08-16 22:37:44 +02003184 if (curproxy->cap & PR_CAP_FE) {
Willy Tarreau050536d2012-10-04 08:47:34 +02003185 if (!curproxy->accept)
3186 curproxy->accept = frontend_accept;
Willy Tarreau81f9aa32010-06-01 17:45:26 +02003187
Willy Tarreauc1a21672009-08-16 22:37:44 +02003188 if (curproxy->tcp_req.inspect_delay ||
3189 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
Willy Tarreaufb356202010-08-03 14:02:05 +02003190 curproxy->fe_req_ana |= AN_REQ_INSPECT_FE;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003191
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003192 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003193 curproxy->fe_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_PROCESS_FE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003194 curproxy->fe_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_FE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003195 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003196
William Lallemandcf62f7e2018-10-26 14:47:40 +02003197 if (curproxy->mode == PR_MODE_CLI) {
3198 curproxy->fe_req_ana |= AN_REQ_WAIT_CLI;
3199 curproxy->fe_rsp_ana |= AN_RES_WAIT_CLI;
3200 }
3201
Willy Tarreauc1a21672009-08-16 22:37:44 +02003202 /* both TCP and HTTP must check switching rules */
3203 curproxy->fe_req_ana |= AN_REQ_SWITCHING_RULES;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003204
3205 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003206 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003207 curproxy->fe_req_ana |= AN_REQ_FLT_START_FE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3208 curproxy->fe_rsp_ana |= AN_RES_FLT_START_FE | AN_RES_FLT_XFER_DATA | AN_RES_FLT_END;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003209 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003210 }
3211
3212 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreaufb356202010-08-03 14:02:05 +02003213 if (curproxy->tcp_req.inspect_delay ||
3214 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
3215 curproxy->be_req_ana |= AN_REQ_INSPECT_BE;
3216
Emeric Brun97679e72010-09-23 17:56:44 +02003217 if (!LIST_ISEMPTY(&curproxy->tcp_rep.inspect_rules))
3218 curproxy->be_rsp_ana |= AN_RES_INSPECT;
3219
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003220 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003221 curproxy->be_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_INNER | AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003222 curproxy->be_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_BE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003223 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003224
3225 /* If the backend does requires RDP cookie persistence, we have to
3226 * enable the corresponding analyser.
3227 */
3228 if (curproxy->options2 & PR_O2_RDPC_PRST)
3229 curproxy->be_req_ana |= AN_REQ_PRST_RDP_COOKIE;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003230
3231 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003232 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003233 curproxy->be_req_ana |= AN_REQ_FLT_START_BE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3234 curproxy->be_rsp_ana |= AN_RES_FLT_START_BE | AN_RES_FLT_XFER_DATA | AN_RES_FLT_END;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003235 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003236 }
Christopher Fauleta717b992018-04-10 14:43:00 +02003237
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003238 /* Check the mux protocols, if any, for each listener and server
Christopher Fauleta717b992018-04-10 14:43:00 +02003239 * attached to the current proxy */
3240 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3241 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003242 const struct mux_proto_list *mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003243
3244 if (!bind_conf->mux_proto)
3245 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003246
3247 /* it is possible that an incorrect mux was referenced
3248 * due to the proxy's mode not being taken into account
3249 * on first pass. Let's adjust it now.
3250 */
3251 mux_ent = conn_get_best_mux_entry(bind_conf->mux_proto->token, PROTO_SIDE_FE, mode);
3252
3253 if (!mux_ent || !isteq(mux_ent->token, bind_conf->mux_proto->token)) {
Christopher Fauleta717b992018-04-10 14:43:00 +02003254 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for 'bind %s' at [%s:%d].\n",
3255 proxy_type_str(curproxy), curproxy->id,
3256 (int)bind_conf->mux_proto->token.len,
3257 bind_conf->mux_proto->token.ptr,
3258 bind_conf->arg, bind_conf->file, bind_conf->line);
3259 cfgerr++;
3260 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003261
3262 /* update the mux */
3263 bind_conf->mux_proto = mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003264 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003265 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3266 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003267 const struct mux_proto_list *mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003268
3269 if (!newsrv->mux_proto)
3270 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003271
3272 /* it is possible that an incorrect mux was referenced
3273 * due to the proxy's mode not being taken into account
3274 * on first pass. Let's adjust it now.
3275 */
3276 mux_ent = conn_get_best_mux_entry(newsrv->mux_proto->token, PROTO_SIDE_BE, mode);
3277
3278 if (!mux_ent || !isteq(mux_ent->token, newsrv->mux_proto->token)) {
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003279 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for server '%s' at [%s:%d].\n",
3280 proxy_type_str(curproxy), curproxy->id,
3281 (int)newsrv->mux_proto->token.len,
3282 newsrv->mux_proto->token.ptr,
3283 newsrv->id, newsrv->conf.file, newsrv->conf.line);
3284 cfgerr++;
3285 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003286
3287 /* update the mux */
3288 newsrv->mux_proto = mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003289 }
Willy Tarreau4cdac162021-03-05 10:48:42 +01003290 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003291
Willy Tarreau4cdac162021-03-05 10:48:42 +01003292 /***********************************************************/
3293 /* At this point, target names have already been resolved. */
3294 /***********************************************************/
Willy Tarreau835daa12019-02-07 14:46:29 +01003295
Willy Tarreau4cdac162021-03-05 10:48:42 +01003296 /* we must finish to initialize certain things on the servers */
Willy Tarreau835daa12019-02-07 14:46:29 +01003297
Willy Tarreau4cdac162021-03-05 10:48:42 +01003298 list_for_each_entry(newsrv, &servers_list, global_list) {
3299 /* initialize idle conns lists */
Willy Tarreau430bf4a2021-03-04 09:45:32 +01003300 newsrv->per_thr = calloc(global.nbthread, sizeof(*newsrv->per_thr));
3301 if (!newsrv->per_thr) {
3302 ha_alert("parsing [%s:%d] : failed to allocate per-thread lists for server '%s'.\n",
3303 newsrv->conf.file, newsrv->conf.line, newsrv->id);
Willy Tarreau4cdac162021-03-05 10:48:42 +01003304 cfgerr++;
3305 continue;
3306 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003307
Willy Tarreau430bf4a2021-03-04 09:45:32 +01003308 for (i = 0; i < global.nbthread; i++) {
3309 newsrv->per_thr[i].idle_conns = EB_ROOT;
3310 newsrv->per_thr[i].safe_conns = EB_ROOT;
3311 newsrv->per_thr[i].avail_conns = EB_ROOT;
Willy Tarreaud4e78d82021-03-04 10:47:54 +01003312 MT_LIST_INIT(&newsrv->per_thr[i].streams);
Willy Tarreau430bf4a2021-03-04 09:45:32 +01003313 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003314
Willy Tarreau4cdac162021-03-05 10:48:42 +01003315 if (newsrv->max_idle_conns != 0) {
Amaury Denoyelle3efee652021-03-08 17:31:39 +01003316 newsrv->curr_idle_thr = calloc(global.nbthread, sizeof(*newsrv->curr_idle_thr));
3317 if (!newsrv->curr_idle_thr) {
3318 ha_alert("parsing [%s:%d] : failed to allocate idle connection tasks for server '%s'.\n",
3319 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3320 cfgerr++;
3321 continue;
3322 }
3323 }
3324 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003325
Amaury Denoyelle3efee652021-03-08 17:31:39 +01003326 idle_conn_task = task_new(MAX_THREADS_MASK);
3327 if (!idle_conn_task) {
3328 ha_alert("parsing : failed to allocate global idle connection task.\n");
3329 cfgerr++;
3330 }
3331 else {
3332 idle_conn_task->process = srv_cleanup_idle_conns;
3333 idle_conn_task->context = NULL;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003334
Amaury Denoyelle3efee652021-03-08 17:31:39 +01003335 for (i = 0; i < global.nbthread; i++) {
3336 idle_conns[i].cleanup_task = task_new(1UL << i);
3337 if (!idle_conns[i].cleanup_task) {
3338 ha_alert("parsing : failed to allocate idle connection tasks for thread '%d'.\n", i);
3339 cfgerr++;
3340 break;
Willy Tarreau4cdac162021-03-05 10:48:42 +01003341 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003342
Amaury Denoyelle3efee652021-03-08 17:31:39 +01003343 idle_conns[i].cleanup_task->process = srv_cleanup_toremove_conns;
3344 idle_conns[i].cleanup_task->context = NULL;
3345 HA_SPIN_INIT(&idle_conns[i].idle_conns_lock);
3346 MT_LIST_INIT(&idle_conns[i].toremove_conns);
Willy Tarreau835daa12019-02-07 14:46:29 +01003347 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003348 }
3349
Willy Tarreau419ead82014-09-16 13:41:21 +02003350 /* Check multi-process mode compatibility */
3351
Willy Tarreau4975d142021-03-13 11:00:33 +01003352 if (global.nbproc > 1 && global.cli_fe) {
3353 list_for_each_entry(bind_conf, &global.cli_fe->conf.bind, by_fe) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003354 unsigned long mask;
3355
Willy Tarreau4975d142021-03-13 11:00:33 +01003356 mask = proc_mask(global.cli_fe->bind_proc) && all_proc_mask;
Willy Tarreaue26993c2020-09-03 07:18:55 +02003357 mask &= proc_mask(bind_conf->settings.bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003358
3359 /* stop here if more than one process is used */
Willy Tarreau9504dd62018-10-15 09:37:03 +02003360 if (atleast2(mask))
Willy Tarreau419ead82014-09-16 13:41:21 +02003361 break;
3362 }
Willy Tarreau4975d142021-03-13 11:00:33 +01003363 if (&bind_conf->by_fe != &global.cli_fe->conf.bind) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003364 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 +02003365 }
3366 }
3367
3368 /* Make each frontend inherit bind-process from its listeners when not specified. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003369 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003370 if (curproxy->bind_proc)
3371 continue;
3372
3373 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3374 unsigned long mask;
3375
Willy Tarreaue26993c2020-09-03 07:18:55 +02003376 mask = proc_mask(bind_conf->settings.bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003377 curproxy->bind_proc |= mask;
3378 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003379 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003380 }
3381
Willy Tarreau4975d142021-03-13 11:00:33 +01003382 if (global.cli_fe) {
3383 list_for_each_entry(bind_conf, &global.cli_fe->conf.bind, by_fe) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003384 unsigned long mask;
3385
Willy Tarreaue26993c2020-09-03 07:18:55 +02003386 mask = bind_conf->settings.bind_proc ? bind_conf->settings.bind_proc : 0;
Willy Tarreau4975d142021-03-13 11:00:33 +01003387 global.cli_fe->bind_proc |= mask;
Willy Tarreau419ead82014-09-16 13:41:21 +02003388 }
Willy Tarreau4975d142021-03-13 11:00:33 +01003389 global.cli_fe->bind_proc = proc_mask(global.cli_fe->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003390 }
3391
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003392 /* propagate bindings from frontends to backends. Don't do it if there
3393 * are any fatal errors as we must not call it with unresolved proxies.
3394 */
3395 if (!cfgerr) {
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003396 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003397 if (curproxy->cap & PR_CAP_FE)
3398 propagate_processes(curproxy, NULL);
3399 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003400 }
3401
3402 /* Bind each unbound backend to all processes when not specified. */
Willy Tarreau6daac192019-02-02 17:39:53 +01003403 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
3404 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003405
3406 /*******************************************************/
3407 /* At this step, all proxies have a non-null bind_proc */
3408 /*******************************************************/
3409
3410 /* perform the final checks before creating tasks */
3411
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003412 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003413 struct listener *listener;
3414 unsigned int next_id;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003415
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003416 /* Configure SSL for each bind line.
3417 * Note: if configuration fails at some point, the ->ctx member
3418 * remains NULL so that listeners can later detach.
3419 */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003420 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau55d37912016-12-21 23:38:39 +01003421 if (bind_conf->xprt->prepare_bind_conf &&
3422 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003423 cfgerr++;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003424 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003425
Willy Tarreaue6b98942007-10-29 01:09:36 +01003426 /* adjust this proxy's listeners */
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003427 next_id = 1;
Willy Tarreau4348fad2012-09-20 16:48:07 +02003428 list_for_each_entry(listener, &curproxy->conf.listeners, by_fe) {
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003429 int nbproc;
3430
3431 nbproc = my_popcountl(curproxy->bind_proc &
Willy Tarreaue26993c2020-09-03 07:18:55 +02003432 (listener->bind_conf->settings.bind_proc ? listener->bind_conf->settings.bind_proc : curproxy->bind_proc) &
Willy Tarreaua38a7172019-02-02 17:11:28 +01003433 all_proc_mask);
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003434
3435 if (!nbproc) /* no intersection between listener and frontend */
3436 nbproc = 1;
3437
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003438 if (!listener->luid) {
3439 /* listener ID not set, use automatic numbering with first
3440 * spare entry starting with next_luid.
3441 */
3442 next_id = get_next_id(&curproxy->conf.used_listener_id, next_id);
3443 listener->conf.id.key = listener->luid = next_id;
3444 eb32_insert(&curproxy->conf.used_listener_id, &listener->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003445 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01003446 next_id++;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003447
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003448 /* enable separate counters */
3449 if (curproxy->options2 & PR_O2_SOCKSTAT) {
Willy Tarreauae9bea02016-11-25 14:44:52 +01003450 listener->counters = calloc(1, sizeof(*listener->counters));
Willy Tarreau19d14ef2012-10-29 16:51:55 +01003451 if (!listener->name)
3452 memprintf(&listener->name, "sock-%d", listener->luid);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003453 }
Willy Tarreau81796be2012-09-22 19:11:47 +02003454
Willy Tarreaue6b98942007-10-29 01:09:36 +01003455 if (curproxy->options & PR_O_TCP_NOLING)
3456 listener->options |= LI_O_NOLINGER;
Willy Tarreau16a21472012-11-19 12:39:59 +01003457 if (!listener->maxaccept)
Willy Tarreau66161322021-02-19 15:50:27 +01003458 listener->maxaccept = global.tune.maxaccept ? global.tune.maxaccept : MAX_ACCEPT;
Willy Tarreau16a21472012-11-19 12:39:59 +01003459
3460 /* we want to have an optimal behaviour on single process mode to
3461 * maximize the work at once, but in multi-process we want to keep
3462 * some fairness between processes, so we target half of the max
3463 * number of events to be balanced over all the processes the proxy
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05003464 * is bound to. Remember that maxaccept = -1 must be kept as it is
Willy Tarreau16a21472012-11-19 12:39:59 +01003465 * used to disable the limit.
3466 */
Christopher Faulet02f3cf12019-04-30 14:08:41 +02003467 if (listener->maxaccept > 0 && nbproc > 1) {
3468 listener->maxaccept = (listener->maxaccept + 1) / 2;
Willy Tarreau16a21472012-11-19 12:39:59 +01003469 listener->maxaccept = (listener->maxaccept + nbproc - 1) / nbproc;
3470 }
3471
Willy Tarreau9903f0e2015-04-04 18:50:31 +02003472 listener->accept = session_accept_fd;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003473 listener->analysers |= curproxy->fe_req_ana;
Willy Tarreau10b688f2015-03-13 16:43:12 +01003474 listener->default_target = curproxy->default_target;
Willy Tarreau3bc13772008-12-07 11:50:35 +01003475
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003476 if (!LIST_ISEMPTY(&curproxy->tcp_req.l4_rules))
Willy Tarreau7d9736f2016-10-21 16:34:21 +02003477 listener->options |= LI_O_TCP_L4_RULES;
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003478
Willy Tarreau620408f2016-10-21 16:37:51 +02003479 if (!LIST_ISEMPTY(&curproxy->tcp_req.l5_rules))
3480 listener->options |= LI_O_TCP_L5_RULES;
3481
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003482 /* smart accept mode is automatic in HTTP mode */
3483 if ((curproxy->options2 & PR_O2_SMARTACC) ||
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003484 ((curproxy->mode == PR_MODE_HTTP || listener->bind_conf->is_ssl) &&
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003485 !(curproxy->no_options2 & PR_O2_SMARTACC)))
3486 listener->options |= LI_O_NOQUICKACK;
Willy Tarreaue6b98942007-10-29 01:09:36 +01003487 }
3488
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003489 /* Release unused SSL configs */
3490 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau795cdab2016-12-22 17:30:54 +01003491 if (!bind_conf->is_ssl && bind_conf->xprt->destroy_bind_conf)
3492 bind_conf->xprt->destroy_bind_conf(bind_conf);
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003493 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003494
Willy Tarreaua38a7172019-02-02 17:11:28 +01003495 if (atleast2(curproxy->bind_proc & all_proc_mask)) {
Willy Tarreau102df612014-05-07 23:56:38 +02003496 if (curproxy->uri_auth) {
Willy Tarreaueb791e02014-09-16 15:11:04 +02003497 int count, maxproc = 0;
3498
3499 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreaue26993c2020-09-03 07:18:55 +02003500 count = my_popcountl(bind_conf->settings.bind_proc);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003501 if (count > maxproc)
3502 maxproc = count;
3503 }
3504 /* backends have 0, frontends have 1 or more */
3505 if (maxproc != 1)
Christopher Faulet767a84b2017-11-24 16:50:31 +01003506 ha_warning("Proxy '%s': in multi-process mode, stats will be"
3507 " limited to process assigned to the current request.\n",
3508 curproxy->id);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003509
Willy Tarreau102df612014-05-07 23:56:38 +02003510 if (!LIST_ISEMPTY(&curproxy->uri_auth->admin_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003511 ha_warning("Proxy '%s': stats admin will not work correctly in multi-process mode.\n",
3512 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003513 }
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003514 }
Willy Tarreau102df612014-05-07 23:56:38 +02003515 if (!LIST_ISEMPTY(&curproxy->sticking_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003516 ha_warning("Proxy '%s': sticking rules will not work correctly in multi-process mode.\n",
3517 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003518 }
3519 }
Willy Tarreau918ff602011-07-25 16:33:49 +02003520
3521 /* create the task associated with the proxy */
Emeric Brunc60def82017-09-27 14:59:38 +02003522 curproxy->task = task_new(MAX_THREADS_MASK);
Willy Tarreau918ff602011-07-25 16:33:49 +02003523 if (curproxy->task) {
3524 curproxy->task->context = curproxy;
3525 curproxy->task->process = manage_proxy;
Willy Tarreau918ff602011-07-25 16:33:49 +02003526 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003527 ha_alert("Proxy '%s': no more memory when trying to allocate the management task\n",
3528 curproxy->id);
Willy Tarreau918ff602011-07-25 16:33:49 +02003529 cfgerr++;
3530 }
Willy Tarreaub369a042014-09-16 13:21:03 +02003531 }
3532
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003533 /*
3534 * Recount currently required checks.
3535 */
3536
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003537 for (curproxy=proxies_list; curproxy; curproxy=curproxy->next) {
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003538 int optnum;
3539
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003540 for (optnum = 0; cfg_opts[optnum].name; optnum++)
3541 if (curproxy->options & cfg_opts[optnum].val)
3542 global.last_checks |= cfg_opts[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003543
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003544 for (optnum = 0; cfg_opts2[optnum].name; optnum++)
3545 if (curproxy->options2 & cfg_opts2[optnum].val)
3546 global.last_checks |= cfg_opts2[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003547 }
3548
Willy Tarreau0fca4832015-05-01 19:12:05 +02003549 /* compute the required process bindings for the peers */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003550 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003551 if (curproxy->table && curproxy->table->peers.p)
3552 curproxy->table->peers.p->peers_fe->bind_proc |= curproxy->bind_proc;
Willy Tarreau0fca4832015-05-01 19:12:05 +02003553
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01003554 /* compute the required process bindings for the peers from <stktables_list>
3555 * for all the stick-tables, the ones coming with "peers" sections included.
3556 */
3557 for (t = stktables_list; t; t = t->next) {
3558 struct proxy *p;
3559
3560 for (p = t->proxies_list; p; p = p->next_stkt_ref) {
3561 if (t->peers.p && t->peers.p->peers_fe) {
3562 t->peers.p->peers_fe->bind_proc |= p->bind_proc;
3563 }
3564 }
3565 }
3566
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003567 if (cfg_peers) {
3568 struct peers *curpeers = cfg_peers, **last;
Willy Tarreau122541c2011-09-07 21:24:49 +02003569 struct peer *p, *pb;
3570
William Lallemanda2cfd7e2020-03-24 16:02:48 +01003571 /* In the case the peers frontend was not initialized by a
3572 stick-table used in the configuration, set its bind_proc
3573 by default to the first process. */
3574 while (curpeers) {
William Lallemand3ef2d562020-03-24 16:42:15 +01003575 if (curpeers->peers_fe) {
3576 if (curpeers->peers_fe->bind_proc == 0)
3577 curpeers->peers_fe->bind_proc = 1;
3578 }
William Lallemanda2cfd7e2020-03-24 16:02:48 +01003579 curpeers = curpeers->next;
3580 }
3581
3582 curpeers = cfg_peers;
Willy Tarreau1e273012015-05-01 19:15:17 +02003583 /* Remove all peers sections which don't have a valid listener,
3584 * which are not used by any table, or which are bound to more
3585 * than one process.
Willy Tarreau122541c2011-09-07 21:24:49 +02003586 */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003587 last = &cfg_peers;
Willy Tarreau122541c2011-09-07 21:24:49 +02003588 while (*last) {
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003589 struct stktable *t;
Willy Tarreau122541c2011-09-07 21:24:49 +02003590 curpeers = *last;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003591
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02003592 if (curpeers->disabled) {
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003593 /* the "disabled" keyword was present */
3594 if (curpeers->peers_fe)
3595 stop_proxy(curpeers->peers_fe);
3596 curpeers->peers_fe = NULL;
3597 }
Frédéric Lécaille5a4fe5a2019-10-04 08:30:04 +02003598 else if (!curpeers->peers_fe || !curpeers->peers_fe->id) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003599 ha_warning("Removing incomplete section 'peers %s' (no peer named '%s').\n",
3600 curpeers->id, localpeer);
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003601 if (curpeers->peers_fe)
3602 stop_proxy(curpeers->peers_fe);
3603 curpeers->peers_fe = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003604 }
Willy Tarreau9504dd62018-10-15 09:37:03 +02003605 else if (atleast2(curpeers->peers_fe->bind_proc)) {
Willy Tarreau1e273012015-05-01 19:15:17 +02003606 /* either it's totally stopped or too much used */
3607 if (curpeers->peers_fe->bind_proc) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003608 ha_alert("Peers section '%s': peers referenced by sections "
3609 "running in different processes (%d different ones). "
3610 "Check global.nbproc and all tables' bind-process "
3611 "settings.\n", curpeers->id, my_popcountl(curpeers->peers_fe->bind_proc));
Willy Tarreau1e273012015-05-01 19:15:17 +02003612 cfgerr++;
3613 }
3614 stop_proxy(curpeers->peers_fe);
3615 curpeers->peers_fe = NULL;
3616 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003617 else {
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01003618 /* Initializes the transport layer of the server part of all the peers belonging to
3619 * <curpeers> section if required.
3620 * Note that ->srv is used by the local peer of a new process to connect to the local peer
3621 * of an old process.
3622 */
Frédéric Lécaille1055e682018-04-26 14:35:21 +02003623 p = curpeers->remote;
3624 while (p) {
Frédéric Lécaille355b2032019-01-11 14:06:12 +01003625 if (p->srv) {
Christopher Fauletf61f33a2020-03-27 18:55:49 +01003626 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 +01003627 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(p->srv);
3628 }
Frédéric Lécaille1055e682018-04-26 14:35:21 +02003629 p = p->next;
3630 }
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01003631 /* Configure the SSL bindings of the local peer if required. */
3632 if (!LIST_ISEMPTY(&curpeers->peers_fe->conf.bind)) {
3633 struct list *l;
3634 struct bind_conf *bind_conf;
3635
3636 l = &curpeers->peers_fe->conf.bind;
3637 bind_conf = LIST_ELEM(l->n, typeof(bind_conf), by_fe);
3638 if (bind_conf->xprt->prepare_bind_conf &&
3639 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
3640 cfgerr++;
3641 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02003642 if (!peers_init_sync(curpeers) || !peers_alloc_dcache(curpeers)) {
Willy Tarreaud9443442018-10-15 11:18:03 +02003643 ha_alert("Peers section '%s': out of memory, giving up on peers.\n",
3644 curpeers->id);
3645 cfgerr++;
3646 break;
3647 }
Willy Tarreau122541c2011-09-07 21:24:49 +02003648 last = &curpeers->next;
3649 continue;
3650 }
3651
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003652 /* clean what has been detected above */
Willy Tarreau122541c2011-09-07 21:24:49 +02003653 p = curpeers->remote;
3654 while (p) {
3655 pb = p->next;
3656 free(p->id);
3657 free(p);
3658 p = pb;
3659 }
3660
3661 /* Destroy and unlink this curpeers section.
3662 * Note: curpeers is backed up into *last.
3663 */
3664 free(curpeers->id);
3665 curpeers = curpeers->next;
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003666 /* Reset any refereance to this peers section in the list of stick-tables */
3667 for (t = stktables_list; t; t = t->next) {
3668 if (t->peers.p && t->peers.p == *last)
3669 t->peers.p = NULL;
3670 }
Willy Tarreau122541c2011-09-07 21:24:49 +02003671 free(*last);
3672 *last = curpeers;
3673 }
3674 }
3675
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003676 for (t = stktables_list; t; t = t->next) {
3677 if (t->proxy)
3678 continue;
3679 if (!stktable_init(t)) {
3680 ha_alert("Proxy '%s': failed to initialize stick-table.\n", t->id);
3681 cfgerr++;
3682 }
3683 }
3684
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003685 /* initialize stick-tables on backend capable proxies. This must not
3686 * be done earlier because the data size may be discovered while parsing
3687 * other proxies.
3688 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003689 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauc3914d42020-09-24 08:39:22 +02003690 if (curproxy->disabled || !curproxy->table)
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003691 continue;
3692
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003693 if (!stktable_init(curproxy->table)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003694 ha_alert("Proxy '%s': failed to initialize stick-table.\n", curproxy->id);
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003695 cfgerr++;
3696 }
3697 }
3698
Simon Horman0d16a402015-01-30 11:22:58 +09003699 if (mailers) {
3700 struct mailers *curmailers = mailers, **last;
3701 struct mailer *m, *mb;
3702
3703 /* Remove all mailers sections which don't have a valid listener.
3704 * This can happen when a mailers section is never referenced.
3705 */
3706 last = &mailers;
3707 while (*last) {
3708 curmailers = *last;
3709 if (curmailers->users) {
3710 last = &curmailers->next;
3711 continue;
3712 }
3713
Christopher Faulet767a84b2017-11-24 16:50:31 +01003714 ha_warning("Removing incomplete section 'mailers %s'.\n",
3715 curmailers->id);
Simon Horman0d16a402015-01-30 11:22:58 +09003716
3717 m = curmailers->mailer_list;
3718 while (m) {
3719 mb = m->next;
3720 free(m->id);
3721 free(m);
3722 m = mb;
3723 }
3724
3725 /* Destroy and unlink this curmailers section.
3726 * Note: curmailers is backed up into *last.
3727 */
3728 free(curmailers->id);
3729 curmailers = curmailers->next;
3730 free(*last);
3731 *last = curmailers;
3732 }
3733 }
3734
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003735 /* Update server_state_file_name to backend name if backend is supposed to use
3736 * a server-state file locally defined and none has been provided */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003737 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003738 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_LOCAL &&
3739 curproxy->server_state_file_name == NULL)
3740 curproxy->server_state_file_name = strdup(curproxy->id);
3741 }
3742
Emeric Brun750fe792020-12-23 16:51:12 +01003743 list_for_each_entry(curr_resolvers, &sec_resolvers, list) {
Ben Draut054fbee2018-04-13 15:43:04 -06003744 if (LIST_ISEMPTY(&curr_resolvers->nameservers)) {
3745 ha_warning("config : resolvers '%s' [%s:%d] has no nameservers configured!\n",
3746 curr_resolvers->id, curr_resolvers->conf.file,
3747 curr_resolvers->conf.line);
3748 err_code |= ERR_WARN;
3749 }
3750 }
3751
William Lallemand48b4bb42017-10-23 14:36:34 +02003752 list_for_each_entry(postparser, &postparsers, list) {
3753 if (postparser->func)
3754 cfgerr += postparser->func();
3755 }
3756
Willy Tarreaubb925012009-07-23 13:36:36 +02003757 if (cfgerr > 0)
3758 err_code |= ERR_ALERT | ERR_FATAL;
3759 out:
3760 return err_code;
Willy Tarreaubaaee002006-06-26 02:48:02 +02003761}
3762
Willy Tarreau5b2c3362008-07-09 19:39:06 +02003763/*
3764 * Registers the CFG keyword list <kwl> as a list of valid keywords for next
3765 * parsing sessions.
3766 */
3767void cfg_register_keywords(struct cfg_kw_list *kwl)
3768{
3769 LIST_ADDQ(&cfg_keywords.list, &kwl->list);
3770}
Willy Tarreaubaaee002006-06-26 02:48:02 +02003771
Willy Tarreau5b2c3362008-07-09 19:39:06 +02003772/*
3773 * Unregisters the CFG keyword list <kwl> from the list of valid keywords.
3774 */
3775void cfg_unregister_keywords(struct cfg_kw_list *kwl)
3776{
3777 LIST_DEL(&kwl->list);
3778 LIST_INIT(&kwl->list);
3779}
Willy Tarreaubaaee002006-06-26 02:48:02 +02003780
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003781/* this function register new section in the haproxy configuration file.
3782 * <section_name> is the name of this new section and <section_parser>
3783 * is the called parser. If two section declaration have the same name,
3784 * only the first declared is used.
3785 */
3786int cfg_register_section(char *section_name,
William Lallemandd2ff56d2017-10-16 11:06:50 +02003787 int (*section_parser)(const char *, int, char **, int),
3788 int (*post_section_parser)())
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003789{
3790 struct cfg_section *cs;
3791
Willy Tarreau5e4261b2016-05-17 16:16:09 +02003792 list_for_each_entry(cs, &sections, list) {
3793 if (strcmp(cs->section_name, section_name) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003794 ha_alert("register section '%s': already registered.\n", section_name);
Willy Tarreau5e4261b2016-05-17 16:16:09 +02003795 return 0;
3796 }
3797 }
3798
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003799 cs = calloc(1, sizeof(*cs));
3800 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003801 ha_alert("register section '%s': out of memory.\n", section_name);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003802 return 0;
3803 }
3804
3805 cs->section_name = section_name;
3806 cs->section_parser = section_parser;
William Lallemandd2ff56d2017-10-16 11:06:50 +02003807 cs->post_section_parser = post_section_parser;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003808
3809 LIST_ADDQ(&sections, &cs->list);
3810
3811 return 1;
3812}
3813
William Lallemand48b4bb42017-10-23 14:36:34 +02003814/* this function register a new function which will be called once the haproxy
3815 * configuration file has been parsed. It's useful to check dependencies
3816 * between sections or to resolve items once everything is parsed.
3817 */
3818int cfg_register_postparser(char *name, int (*func)())
3819{
3820 struct cfg_postparser *cp;
3821
3822 cp = calloc(1, sizeof(*cp));
3823 if (!cp) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003824 ha_alert("register postparser '%s': out of memory.\n", name);
William Lallemand48b4bb42017-10-23 14:36:34 +02003825 return 0;
3826 }
3827 cp->name = name;
3828 cp->func = func;
3829
3830 LIST_ADDQ(&postparsers, &cp->list);
3831
3832 return 1;
3833}
3834
Willy Tarreaubaaee002006-06-26 02:48:02 +02003835/*
David Carlier845efb52015-09-25 11:49:18 +01003836 * free all config section entries
3837 */
3838void cfg_unregister_sections(void)
3839{
3840 struct cfg_section *cs, *ics;
3841
3842 list_for_each_entry_safe(cs, ics, &sections, list) {
3843 LIST_DEL(&cs->list);
3844 free(cs);
3845 }
3846}
3847
Christopher Faulet7110b402016-10-26 11:09:44 +02003848void cfg_backup_sections(struct list *backup_sections)
3849{
3850 struct cfg_section *cs, *ics;
3851
3852 list_for_each_entry_safe(cs, ics, &sections, list) {
3853 LIST_DEL(&cs->list);
3854 LIST_ADDQ(backup_sections, &cs->list);
3855 }
3856}
3857
3858void cfg_restore_sections(struct list *backup_sections)
3859{
3860 struct cfg_section *cs, *ics;
3861
3862 list_for_each_entry_safe(cs, ics, backup_sections, list) {
3863 LIST_DEL(&cs->list);
3864 LIST_ADDQ(&sections, &cs->list);
3865 }
3866}
3867
Willy Tarreaue6552512018-11-26 11:33:13 +01003868/* these are the config sections handled by default */
3869REGISTER_CONFIG_SECTION("listen", cfg_parse_listen, NULL);
3870REGISTER_CONFIG_SECTION("frontend", cfg_parse_listen, NULL);
3871REGISTER_CONFIG_SECTION("backend", cfg_parse_listen, NULL);
3872REGISTER_CONFIG_SECTION("defaults", cfg_parse_listen, NULL);
3873REGISTER_CONFIG_SECTION("global", cfg_parse_global, NULL);
3874REGISTER_CONFIG_SECTION("userlist", cfg_parse_users, NULL);
3875REGISTER_CONFIG_SECTION("peers", cfg_parse_peers, NULL);
3876REGISTER_CONFIG_SECTION("mailers", cfg_parse_mailers, NULL);
3877REGISTER_CONFIG_SECTION("namespace_list", cfg_parse_netns, NULL);
Willy Tarreau659fbf02016-05-26 17:55:28 +02003878
David Carlier845efb52015-09-25 11:49:18 +01003879/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02003880 * Local variables:
3881 * c-indent-level: 8
3882 * c-basic-offset: 8
3883 * End:
3884 */