blob: 12eae67cc46bf569003e099d6f7a8e0a6b44bf26 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Configuration parser
3 *
Willy Tarreauff011f22011-01-06 17:51:27 +01004 * Copyright 2000-2011 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreaue5733232019-05-22 19:24:06 +020013#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +020014/* This is to have crypt() defined on Linux */
15#define _GNU_SOURCE
16
Willy Tarreaue5733232019-05-22 19:24:06 +020017#ifdef USE_CRYPT_H
Cyril Bonté1a0191d2014-08-29 20:20:02 +020018/* some platforms such as Solaris need this */
19#include <crypt.h>
20#endif
Willy Tarreaue5733232019-05-22 19:24:06 +020021#endif /* USE_LIBCRYPT */
Cyril Bonté1a0191d2014-08-29 20:20:02 +020022
Willy Tarreaubaaee002006-06-26 02:48:02 +020023#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <netdb.h>
27#include <ctype.h>
Willy Tarreau95c20ac2007-03-25 15:39:23 +020028#include <pwd.h>
29#include <grp.h>
Willy Tarreau0b4ed902007-03-26 00:18:40 +020030#include <errno.h>
Willy Tarreau3f49b302007-06-11 00:29:26 +020031#include <sys/types.h>
32#include <sys/stat.h>
33#include <fcntl.h>
34#include <unistd.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020035
Willy Tarreaudcc048a2020-06-04 19:11:43 +020036#include <haproxy/acl.h>
Willy Tarreau122eba92020-06-04 10:15:32 +020037#include <haproxy/action-t.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020038#include <haproxy/api.h>
Willy Tarreauac13aea2020-06-04 10:36:03 +020039#include <haproxy/auth.h>
Willy Tarreau49801602020-06-04 22:50:02 +020040#include <haproxy/backend.h>
Willy Tarreau278161c2020-06-04 11:18:28 +020041#include <haproxy/capture.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020042#include <haproxy/cfgparse.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020043#include <haproxy/channel.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020044#include <haproxy/check.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020045#include <haproxy/chunk.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020046#include <haproxy/connection.h>
Willy Tarreaueb92deb2020-06-04 10:53:16 +020047#include <haproxy/dns.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020048#include <haproxy/errors.h>
Willy Tarreauc7babd82020-06-04 21:29:29 +020049#include <haproxy/filters.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020050#include <haproxy/frontend.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020051#include <haproxy/global.h>
Willy Tarreauc2b1ff02020-06-04 21:21:03 +020052#include <haproxy/http_ana.h>
Willy Tarreauc761f842020-06-04 11:40:28 +020053#include <haproxy/http_rules.h>
Willy Tarreaufbe8da32020-06-04 14:34:27 +020054#include <haproxy/lb_chash.h>
Willy Tarreaub5fc3bf2020-06-04 14:37:38 +020055#include <haproxy/lb_fas.h>
Willy Tarreau02549412020-06-04 14:41:04 +020056#include <haproxy/lb_fwlc.h>
Willy Tarreau546ba422020-06-04 14:45:03 +020057#include <haproxy/lb_fwrr.h>
Willy Tarreau28671592020-06-04 20:22:59 +020058#include <haproxy/lb_map.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020059#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020060#include <haproxy/log.h>
Willy Tarreaucee013e2020-06-05 11:40:38 +020061#include <haproxy/mailers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020062#include <haproxy/namespace.h>
Willy Tarreau8efbdfb2020-06-04 11:29:21 +020063#include <haproxy/obj_type-t.h>
Willy Tarreau3c2a7c22020-06-04 18:38:21 +020064#include <haproxy/peers-t.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020065#include <haproxy/peers.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020066#include <haproxy/pool.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020067#include <haproxy/protocol.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020068#include <haproxy/proxy.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020069#include <haproxy/sample.h>
70#include <haproxy/server.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020071#include <haproxy/session.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020072#include <haproxy/stats-t.h>
Willy Tarreau872f2ea2020-06-04 18:46:44 +020073#include <haproxy/stick_table.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020074#include <haproxy/stream.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020075#include <haproxy/task.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020076#include <haproxy/tcp_rules.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020077#include <haproxy/thread.h>
78#include <haproxy/time.h>
79#include <haproxy/tools.h>
80#include <haproxy/uri_auth-t.h>
Frédéric Lécaille884f2e92020-11-23 14:23:21 +010081#include <haproxy/xprt_quic.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020082
83
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +010084/* Used to chain configuration sections definitions. This list
85 * stores struct cfg_section
86 */
87struct list sections = LIST_HEAD_INIT(sections);
88
William Lallemand48b4bb42017-10-23 14:36:34 +020089struct list postparsers = LIST_HEAD_INIT(postparsers);
90
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +010091char *cursection = NULL;
92struct proxy defproxy = { }; /* fake proxy used to assign default values on all instances */
Willy Tarreauc8d5b952019-02-27 17:25:52 +010093int cfg_maxpconn = 0; /* # of simultaneous connections per proxy (-N) */
Willy Tarreau5af24ef2009-03-15 15:23:16 +010094int cfg_maxconn = 0; /* # of simultaneous connections, (-n) */
Christopher Faulet79bdef32016-11-04 22:36:15 +010095char *cfg_scope = NULL; /* the current scope during the configuration parsing */
Willy Tarreaubaaee002006-06-26 02:48:02 +020096
Willy Tarreau5b2c3362008-07-09 19:39:06 +020097/* List head of all known configuration keywords */
Willy Tarreau36b9e222018-11-11 15:19:52 +010098struct cfg_kw_list cfg_keywords = {
Willy Tarreau5b2c3362008-07-09 19:39:06 +020099 .list = LIST_HEAD_INIT(cfg_keywords.list)
100};
101
Willy Tarreaubaaee002006-06-26 02:48:02 +0200102/*
103 * converts <str> to a list of listeners which are dynamically allocated.
104 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
105 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
106 * - <port> is a numerical port from 1 to 65535 ;
107 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
108 * This can be repeated as many times as necessary, separated by a coma.
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200109 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
110 * not NULL, it must be a valid pointer to either NULL or a freeable area that
111 * will be replaced with an error message.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200112 */
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200113int 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 +0200114{
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200115 struct protocol *proto;
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100116 char *next, *dupstr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200117 int port, end;
118
119 next = dupstr = strdup(str);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200120
Willy Tarreaubaaee002006-06-26 02:48:02 +0200121 while (next && *next) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200122 struct sockaddr_storage *ss2;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100123 int fd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200124
125 str = next;
126 /* 1) look for the end of the first address */
Krzysztof Piotr Oledzki52d522b2009-01-27 16:57:08 +0100127 if ((next = strchr(str, ',')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200128 *next++ = 0;
129 }
130
Willy Tarreau5fc93282020-09-16 18:25:03 +0200131 ss2 = str2sa_range(str, NULL, &port, &end, &fd, &proto, err,
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200132 curproxy == global.stats_fe ? NULL : global.unix_bind.prefix,
Willy Tarreau32819932020-09-04 15:53:16 +0200133 NULL, PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_PORT_RANGE |
Willy Tarreau5e1779a2020-09-16 16:28:08 +0200134 PA_O_SOCKET_FD | PA_O_STREAM | PA_O_XPRT);
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100135 if (!ss2)
136 goto fail;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200137
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100138 /* OK the address looks correct */
Frédéric Lécaille884f2e92020-11-23 14:23:21 +0100139
140#ifdef USE_QUIC
141 /* The transport layer automatically switches to QUIC when QUIC
142 * is selected, regardless of bind_conf settings. We then need
143 * to initialize QUIC params.
144 */
145 if (proto->sock_type == SOCK_DGRAM && proto->ctrl_type == SOCK_STREAM) {
146 bind_conf->xprt = xprt_get(XPRT_QUIC);
147 quic_transport_params_init(&bind_conf->quic_params, 1);
148 }
149#endif
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200150 if (!create_listeners(bind_conf, ss2, port, end, fd, proto, err)) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200151 memprintf(err, "%s for address '%s'.\n", *err, str);
152 goto fail;
153 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200154 } /* end while(next) */
155 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200156 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200157 fail:
158 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200159 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200160}
161
William Lallemand6e62fb62015-04-28 16:55:23 +0200162/*
Willy Tarreauaa333122020-09-16 15:13:04 +0200163 * converts <str> to a list of datagram-oriented listeners which are dynamically
164 * allocated.
165 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
166 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
167 * - <port> is a numerical port from 1 to 65535 ;
168 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
169 * This can be repeated as many times as necessary, separated by a coma.
170 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
171 * not NULL, it must be a valid pointer to either NULL or a freeable area that
172 * will be replaced with an error message.
173 */
174int str2receiver(char *str, struct proxy *curproxy, struct bind_conf *bind_conf, const char *file, int line, char **err)
175{
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200176 struct protocol *proto;
Willy Tarreauaa333122020-09-16 15:13:04 +0200177 char *next, *dupstr;
178 int port, end;
179
180 next = dupstr = strdup(str);
181
182 while (next && *next) {
183 struct sockaddr_storage *ss2;
184 int fd = -1;
185
186 str = next;
187 /* 1) look for the end of the first address */
188 if ((next = strchr(str, ',')) != NULL) {
189 *next++ = 0;
190 }
191
Willy Tarreau5fc93282020-09-16 18:25:03 +0200192 ss2 = str2sa_range(str, NULL, &port, &end, &fd, &proto, err,
Willy Tarreauaa333122020-09-16 15:13:04 +0200193 curproxy == global.stats_fe ? NULL : global.unix_bind.prefix,
194 NULL, PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_PORT_RANGE |
195 PA_O_SOCKET_FD | PA_O_DGRAM | PA_O_XPRT);
196 if (!ss2)
197 goto fail;
198
199 /* OK the address looks correct */
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200200 if (!create_listeners(bind_conf, ss2, port, end, fd, proto, err)) {
Willy Tarreauaa333122020-09-16 15:13:04 +0200201 memprintf(err, "%s for address '%s'.\n", *err, str);
202 goto fail;
203 }
204 } /* end while(next) */
205 free(dupstr);
206 return 1;
207 fail:
208 free(dupstr);
209 return 0;
210}
211
212/*
Willy Tarreauece9b072016-12-21 22:41:44 +0100213 * Report an error in <msg> when there are too many arguments. This version is
214 * intended to be used by keyword parsers so that the message will be included
215 * into the general error message. The index is the current keyword in args.
216 * Return 0 if the number of argument is correct, otherwise build a message and
217 * return 1. Fill err_code with an ERR_ALERT and an ERR_FATAL if not null. The
218 * message may also be null, it will simply not be produced (useful to check only).
219 * <msg> and <err_code> are only affected on error.
220 */
221int too_many_args_idx(int maxarg, int index, char **args, char **msg, int *err_code)
222{
223 int i;
224
225 if (!*args[index + maxarg + 1])
226 return 0;
227
228 if (msg) {
229 *msg = NULL;
230 memprintf(msg, "%s", args[0]);
231 for (i = 1; i <= index; i++)
232 memprintf(msg, "%s %s", *msg, args[i]);
233
234 memprintf(msg, "'%s' cannot handle unexpected argument '%s'.", *msg, args[index + maxarg + 1]);
235 }
236 if (err_code)
237 *err_code |= ERR_ALERT | ERR_FATAL;
238
239 return 1;
240}
241
242/*
243 * same as too_many_args_idx with a 0 index
244 */
245int too_many_args(int maxarg, char **args, char **msg, int *err_code)
246{
247 return too_many_args_idx(maxarg, 0, args, msg, err_code);
248}
249
250/*
William Lallemand6e62fb62015-04-28 16:55:23 +0200251 * Report a fatal Alert when there is too much arguments
252 * The index is the current keyword in args
253 * Return 0 if the number of argument is correct, otherwise emit an alert and return 1
254 * Fill err_code with an ERR_ALERT and an ERR_FATAL
255 */
256int alertif_too_many_args_idx(int maxarg, int index, const char *file, int linenum, char **args, int *err_code)
257{
258 char *kw = NULL;
259 int i;
260
261 if (!*args[index + maxarg + 1])
262 return 0;
263
264 memprintf(&kw, "%s", args[0]);
265 for (i = 1; i <= index; i++) {
266 memprintf(&kw, "%s %s", kw, args[i]);
267 }
268
Christopher Faulet767a84b2017-11-24 16:50:31 +0100269 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 +0200270 free(kw);
271 *err_code |= ERR_ALERT | ERR_FATAL;
272 return 1;
273}
274
275/*
276 * same as alertif_too_many_args_idx with a 0 index
277 */
278int alertif_too_many_args(int maxarg, const char *file, int linenum, char **args, int *err_code)
279{
280 return alertif_too_many_args_idx(maxarg, 0, file, linenum, args, err_code);
281}
282
Willy Tarreau61d18892009-03-31 10:49:21 +0200283
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100284/* Report it if a request ACL condition uses some keywords that are incompatible
285 * with the place where the ACL is used. It returns either 0 or ERR_WARN so that
286 * its result can be or'ed with err_code. Note that <cond> may be NULL and then
287 * will be ignored.
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100288 */
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100289int warnif_cond_conflicts(const struct acl_cond *cond, unsigned int where, const char *file, int line)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100290{
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100291 const struct acl *acl;
Willy Tarreau93fddf12013-03-31 22:59:32 +0200292 const char *kw;
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100293
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100294 if (!cond)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100295 return 0;
296
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100297 acl = acl_cond_conflicts(cond, where);
298 if (acl) {
299 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100300 ha_warning("parsing [%s:%d] : acl '%s' will never match because it only involves keywords that are incompatible with '%s'\n",
301 file, line, acl->name, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100302 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100303 ha_warning("parsing [%s:%d] : anonymous acl will never match because it uses keyword '%s' which is incompatible with '%s'\n",
304 file, line, LIST_ELEM(acl->expr.n, struct acl_expr *, list)->kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100305 return ERR_WARN;
306 }
307 if (!acl_cond_kw_conflicts(cond, where, &acl, &kw))
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100308 return 0;
309
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100310 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100311 ha_warning("parsing [%s:%d] : acl '%s' involves keywords '%s' which is incompatible with '%s'\n",
312 file, line, acl->name, kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100313 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100314 ha_warning("parsing [%s:%d] : anonymous acl involves keyword '%s' which is incompatible with '%s'\n",
315 file, line, kw, sample_ckp_names(where));
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100316 return ERR_WARN;
317}
318
Christopher Faulet62519022017-10-16 15:49:32 +0200319/* Parse a string representing a process number or a set of processes. It must
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100320 * be "all", "odd", "even", a number between 1 and <max> or a range with
Christopher Faulet5ab51772017-11-22 11:21:58 +0100321 * two such numbers delimited by a dash ('-'). On success, it returns
322 * 0. otherwise it returns 1 with an error message in <err>.
Christopher Faulet62519022017-10-16 15:49:32 +0200323 *
324 * Note: this function can also be used to parse a thread number or a set of
325 * threads.
326 */
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100327int parse_process_number(const char *arg, unsigned long *proc, int max, int *autoinc, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200328{
Christopher Faulet26028f62017-11-22 15:01:51 +0100329 if (autoinc) {
330 *autoinc = 0;
331 if (strncmp(arg, "auto:", 5) == 0) {
332 arg += 5;
333 *autoinc = 1;
334 }
335 }
336
Christopher Faulet62519022017-10-16 15:49:32 +0200337 if (strcmp(arg, "all") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100338 *proc |= ~0UL;
Christopher Faulet62519022017-10-16 15:49:32 +0200339 else if (strcmp(arg, "odd") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100340 *proc |= ~0UL/3UL; /* 0x555....555 */
Christopher Faulet62519022017-10-16 15:49:32 +0200341 else if (strcmp(arg, "even") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100342 *proc |= (~0UL/3UL) << 1; /* 0xAAA...AAA */
Christopher Faulet62519022017-10-16 15:49:32 +0200343 else {
Christopher Faulet18cca782019-02-07 16:29:41 +0100344 const char *p, *dash = NULL;
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100345 unsigned int low, high;
346
Christopher Faulet18cca782019-02-07 16:29:41 +0100347 for (p = arg; *p; p++) {
348 if (*p == '-' && !dash)
349 dash = p;
Willy Tarreau90807112020-02-25 08:16:33 +0100350 else if (!isdigit((unsigned char)*p)) {
Christopher Faulet18cca782019-02-07 16:29:41 +0100351 memprintf(err, "'%s' is not a valid number/range.", arg);
352 return -1;
353 }
Christopher Faulet5ab51772017-11-22 11:21:58 +0100354 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100355
356 low = high = str2uic(arg);
Christopher Faulet18cca782019-02-07 16:29:41 +0100357 if (dash)
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100358 high = ((!*(dash+1)) ? max : str2uic(dash + 1));
Christopher Fauletff4121f2017-11-22 16:38:49 +0100359
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100360 if (high < low) {
361 unsigned int swap = low;
362 low = high;
363 high = swap;
364 }
365
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100366 if (low < 1 || low > max || high > max) {
Christopher Fauletcb6a9452017-11-22 16:50:41 +0100367 memprintf(err, "'%s' is not a valid number/range."
368 " It supports numbers from 1 to %d.\n",
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100369 arg, max);
Christopher Faulet5ab51772017-11-22 11:21:58 +0100370 return 1;
371 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100372
373 for (;low <= high; low++)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100374 *proc |= 1UL << (low-1);
Christopher Faulet62519022017-10-16 15:49:32 +0200375 }
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100376 *proc &= ~0UL >> (LONGBITS - max);
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100377
Christopher Faulet5ab51772017-11-22 11:21:58 +0100378 return 0;
Christopher Faulet62519022017-10-16 15:49:32 +0200379}
380
David Carlier7e351ee2017-12-01 09:14:02 +0000381#ifdef USE_CPU_AFFINITY
Christopher Faulet62519022017-10-16 15:49:32 +0200382/* Parse cpu sets. Each CPU set is either a unique number between 0 and
383 * <LONGBITS> or a range with two such numbers delimited by a dash
384 * ('-'). Multiple CPU numbers or ranges may be specified. On success, it
385 * returns 0. otherwise it returns 1 with an error message in <err>.
386 */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100387unsigned long parse_cpu_set(const char **args, unsigned long *cpu_set, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200388{
389 int cur_arg = 0;
390
391 *cpu_set = 0;
392 while (*args[cur_arg]) {
393 char *dash;
394 unsigned int low, high;
395
Willy Tarreau90807112020-02-25 08:16:33 +0100396 if (!isdigit((unsigned char)*args[cur_arg])) {
Christopher Faulet62519022017-10-16 15:49:32 +0200397 memprintf(err, "'%s' is not a CPU range.\n", args[cur_arg]);
398 return -1;
399 }
400
401 low = high = str2uic(args[cur_arg]);
402 if ((dash = strchr(args[cur_arg], '-')) != NULL)
Christopher Fauletff4121f2017-11-22 16:38:49 +0100403 high = ((!*(dash+1)) ? LONGBITS-1 : str2uic(dash + 1));
Christopher Faulet62519022017-10-16 15:49:32 +0200404
405 if (high < low) {
406 unsigned int swap = low;
407 low = high;
408 high = swap;
409 }
410
411 if (high >= LONGBITS) {
412 memprintf(err, "supports CPU numbers from 0 to %d.\n", LONGBITS - 1);
413 return 1;
414 }
415
416 while (low <= high)
417 *cpu_set |= 1UL << low++;
418
419 cur_arg++;
420 }
421 return 0;
422}
David Carlier7e351ee2017-12-01 09:14:02 +0000423#endif
424
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200425void init_default_instance()
Willy Tarreaubaaee002006-06-26 02:48:02 +0200426{
Willy Tarreau97cb7802010-01-03 20:23:58 +0100427 init_new_proxy(&defproxy);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200428 defproxy.mode = PR_MODE_TCP;
Willy Tarreauc3914d42020-09-24 08:39:22 +0200429 defproxy.disabled = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200430 defproxy.maxconn = cfg_maxpconn;
431 defproxy.conn_retries = CONN_RETRIES;
Joseph Lynch726ab712015-05-11 23:25:34 -0700432 defproxy.redispatch_after = 0;
Olivier Houchard86006a52018-12-14 19:37:49 +0100433 defproxy.options = PR_O_REUSE_SAFE;
Olivier Houcharda4d4fdf2018-12-14 19:27:06 +0100434 defproxy.max_out_conns = MAX_SRV_LIST;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100435
Simon Horman66183002013-02-23 10:16:43 +0900436 defproxy.defsrv.check.inter = DEF_CHKINTR;
437 defproxy.defsrv.check.fastinter = 0;
438 defproxy.defsrv.check.downinter = 0;
Simon Hormand60d6912013-11-25 10:46:36 +0900439 defproxy.defsrv.agent.inter = DEF_CHKINTR;
440 defproxy.defsrv.agent.fastinter = 0;
441 defproxy.defsrv.agent.downinter = 0;
Simon Horman58c32972013-11-25 10:46:38 +0900442 defproxy.defsrv.check.rise = DEF_RISETIME;
443 defproxy.defsrv.check.fall = DEF_FALLTIME;
444 defproxy.defsrv.agent.rise = DEF_AGENT_RISETIME;
445 defproxy.defsrv.agent.fall = DEF_AGENT_FALLTIME;
Willy Tarreau5b3a2022012-09-28 15:01:02 +0200446 defproxy.defsrv.check.port = 0;
Simon Hormand60d6912013-11-25 10:46:36 +0900447 defproxy.defsrv.agent.port = 0;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100448 defproxy.defsrv.maxqueue = 0;
449 defproxy.defsrv.minconn = 0;
450 defproxy.defsrv.maxconn = 0;
Willy Tarreau9c538e02019-01-23 10:21:49 +0100451 defproxy.defsrv.max_reuse = -1;
Olivier Houchard006e3102018-12-10 18:30:32 +0100452 defproxy.defsrv.max_idle_conns = -1;
Willy Tarreau975b1552019-06-06 16:25:55 +0200453 defproxy.defsrv.pool_purge_delay = 5000;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100454 defproxy.defsrv.slowstart = 0;
455 defproxy.defsrv.onerror = DEF_HANA_ONERR;
456 defproxy.defsrv.consecutive_errors_limit = DEF_HANA_ERRLIMIT;
457 defproxy.defsrv.uweight = defproxy.defsrv.iweight = 1;
Simon Horman64e34162015-02-06 11:11:57 +0900458
459 defproxy.email_alert.level = LOG_ALERT;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +0200460 defproxy.load_server_state_from_file = PR_SRV_STATE_FILE_UNSPEC;
Frédéric Lécaille0a769012020-11-23 15:50:46 +0100461#if defined(USE_QUIC)
462 quic_transport_params_init(&defproxy.defsrv.quic_params, 0);
463#endif
464
Willy Tarreaubaaee002006-06-26 02:48:02 +0200465}
466
Frédéric Lécaille18251032019-01-11 11:07:15 +0100467/* Allocate and initialize the frontend of a "peers" section found in
468 * file <file> at line <linenum> with <id> as ID.
469 * Return 0 if succeeded, -1 if not.
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200470 * Note that this function may be called from "default-server"
471 * or "peer" lines.
Frédéric Lécaille18251032019-01-11 11:07:15 +0100472 */
473static int init_peers_frontend(const char *file, int linenum,
474 const char *id, struct peers *peers)
475{
476 struct proxy *p;
477
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200478 if (peers->peers_fe) {
479 p = peers->peers_fe;
480 goto out;
481 }
Frédéric Lécaille9492c4e2019-01-11 11:47:12 +0100482
Frédéric Lécaille18251032019-01-11 11:07:15 +0100483 p = calloc(1, sizeof *p);
484 if (!p) {
485 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
486 return -1;
487 }
488
489 init_new_proxy(p);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200490 peers_setup_frontend(p);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100491 p->parent = peers;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200492 /* Finally store this frontend. */
493 peers->peers_fe = p;
494
495 out:
496 if (id && !p->id)
497 p->id = strdup(id);
Frédéric Lécaille1055e682018-04-26 14:35:21 +0200498 free(p->conf.file);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100499 p->conf.args.file = p->conf.file = strdup(file);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100500 if (linenum != -1)
501 p->conf.args.line = p->conf.line = linenum;
Frédéric Lécaille18251032019-01-11 11:07:15 +0100502
503 return 0;
504}
Willy Tarreauade5ec42010-01-28 19:33:49 +0100505
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100506/* Only change ->file, ->line and ->arg struct bind_conf member values
507 * if already present.
508 */
509static struct bind_conf *bind_conf_uniq_alloc(struct proxy *p,
510 const char *file, int line,
511 const char *arg, struct xprt_ops *xprt)
512{
513 struct bind_conf *bind_conf;
514
515 if (!LIST_ISEMPTY(&p->conf.bind)) {
516 bind_conf = LIST_ELEM((&p->conf.bind)->n, typeof(bind_conf), by_fe);
517 free(bind_conf->file);
518 bind_conf->file = strdup(file);
519 bind_conf->line = line;
520 if (arg) {
521 free(bind_conf->arg);
522 bind_conf->arg = strdup(arg);
523 }
524 }
525 else {
526 bind_conf = bind_conf_alloc(p, file, line, arg, xprt);
527 }
528
529 return bind_conf;
530}
531
532/*
533 * Allocate a new struct peer parsed at line <linenum> in file <file>
534 * to be added to <peers>.
535 * Returns the new allocated structure if succeeded, NULL if not.
536 */
537static struct peer *cfg_peers_add_peer(struct peers *peers,
538 const char *file, int linenum,
539 const char *id, int local)
540{
541 struct peer *p;
542
543 p = calloc(1, sizeof *p);
544 if (!p) {
545 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
546 return NULL;
547 }
548
549 /* the peers are linked backwards first */
550 peers->count++;
551 p->next = peers->remote;
552 peers->remote = p;
553 p->conf.file = strdup(file);
554 p->conf.line = linenum;
555 p->last_change = now.tv_sec;
556 p->xprt = xprt_get(XPRT_RAW);
557 p->sock_init_arg = NULL;
558 HA_SPIN_INIT(&p->lock);
559 if (id)
560 p->id = strdup(id);
561 if (local) {
562 p->local = 1;
563 peers->local = p;
564 }
565
566 return p;
567}
568
Willy Tarreaubaaee002006-06-26 02:48:02 +0200569/*
William Lallemand51097192015-04-14 16:35:22 +0200570 * Parse a line in a <listen>, <frontend> or <backend> section.
Willy Tarreau93893792009-07-23 13:19:11 +0200571 * Returns the error code, 0 if OK, or any combination of :
572 * - ERR_ABORT: must abort ASAP
573 * - ERR_FATAL: we can continue parsing but not start the service
574 * - ERR_WARN: a warning has been emitted
575 * - ERR_ALERT: an alert has been emitted
576 * Only the two first ones can stop processing, the two others are just
577 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200578 */
Emeric Brun32da3c42010-09-23 18:39:19 +0200579int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
580{
581 static struct peers *curpeers = NULL;
582 struct peer *newpeer = NULL;
583 const char *err;
Willy Tarreau4348fad2012-09-20 16:48:07 +0200584 struct bind_conf *bind_conf;
585 struct listener *l;
Emeric Brun32da3c42010-09-23 18:39:19 +0200586 int err_code = 0;
Willy Tarreau902636f2013-03-10 19:44:48 +0100587 char *errmsg = NULL;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100588 static int bind_line, peer_line;
589
590 if (strcmp(args[0], "bind") == 0 || strcmp(args[0], "default-bind") == 0) {
591 int cur_arg;
592 static int kws_dumped;
593 struct bind_conf *bind_conf;
594 struct bind_kw *kw;
Emeric Brun32da3c42010-09-23 18:39:19 +0200595
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100596 cur_arg = 1;
597
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200598 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
599 err_code |= ERR_ALERT | ERR_ABORT;
600 goto out;
601 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100602
603 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum,
604 NULL, xprt_get(XPRT_RAW));
605 if (*args[0] == 'b') {
606 struct listener *l;
607
608 if (peer_line) {
609 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
610 err_code |= ERR_ALERT | ERR_FATAL;
611 goto out;
612 }
613
614 if (!str2listener(args[1], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
615 if (errmsg && *errmsg) {
616 indent_msg(&errmsg, 2);
617 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
618 }
619 else
620 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
621 file, linenum, args[0], args[1], args[2]);
622 err_code |= ERR_FATAL;
623 goto out;
624 }
625 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
626 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100627 l->accept = session_accept_fd;
628 l->analysers |= curpeers->peers_fe->fe_req_ana;
629 l->default_target = curpeers->peers_fe->default_target;
630 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100631 global.maxsock++; /* for the listening socket */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100632
633 bind_line = 1;
634 if (cfg_peers->local) {
635 newpeer = cfg_peers->local;
636 }
637 else {
638 /* This peer is local.
639 * Note that we do not set the peer ID. This latter is initialized
640 * when parsing "peer" or "server" line.
641 */
642 newpeer = cfg_peers_add_peer(curpeers, file, linenum, NULL, 1);
643 if (!newpeer) {
644 err_code |= ERR_ALERT | ERR_ABORT;
645 goto out;
646 }
647 }
Willy Tarreau37159062020-08-27 07:48:42 +0200648 newpeer->addr = l->rx.addr;
Willy Tarreau5fc93282020-09-16 18:25:03 +0200649 newpeer->proto = l->rx.proto;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100650 cur_arg++;
651 }
652
653 while (*args[cur_arg] && (kw = bind_find_kw(args[cur_arg]))) {
654 int ret;
655
656 ret = kw->parse(args, cur_arg, curpeers->peers_fe, bind_conf, &errmsg);
657 err_code |= ret;
658 if (ret) {
659 if (errmsg && *errmsg) {
660 indent_msg(&errmsg, 2);
661 ha_alert("parsing [%s:%d] : %s\n", file, linenum, errmsg);
662 }
663 else
664 ha_alert("parsing [%s:%d]: error encountered while processing '%s'\n",
665 file, linenum, args[cur_arg]);
666 if (ret & ERR_FATAL)
667 goto out;
668 }
669 cur_arg += 1 + kw->skip;
670 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100671 if (*args[cur_arg] != 0) {
Tim Duesterhus04bcaa12019-05-12 22:54:50 +0200672 char *kws = NULL;
673
674 if (!kws_dumped) {
675 kws_dumped = 1;
676 bind_dump_kws(&kws);
677 indent_msg(&kws, 4);
678 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100679 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section.%s%s\n",
680 file, linenum, args[cur_arg], cursection,
681 kws ? " Registered keywords :" : "", kws ? kws: "");
682 free(kws);
683 err_code |= ERR_ALERT | ERR_FATAL;
684 goto out;
685 }
686 }
687 else if (strcmp(args[0], "default-server") == 0) {
688 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
689 err_code |= ERR_ALERT | ERR_ABORT;
690 goto out;
691 }
Emeric Brund3db3842020-07-21 16:54:36 +0200692 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL, 0, 1, 1);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200693 }
Frédéric Lécailleb6f759b2019-11-05 09:57:45 +0100694 else if (strcmp(args[0], "log") == 0) {
695 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
696 err_code |= ERR_ALERT | ERR_ABORT;
697 goto out;
698 }
699 if (!parse_logsrv(args, &curpeers->peers_fe->logsrvs, (kwm == KWM_NO), &errmsg)) {
700 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
701 err_code |= ERR_ALERT | ERR_FATAL;
702 goto out;
703 }
704 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200705 else if (strcmp(args[0], "peers") == 0) { /* new peers section */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100706 /* Initialize these static variables when entering a new "peers" section*/
707 bind_line = peer_line = 0;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100708 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100709 ha_alert("parsing [%s:%d] : missing name for peers section.\n", file, linenum);
Willy Tarreau54984722014-02-16 08:20:13 +0100710 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100711 goto out;
712 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200713
William Lallemand6e62fb62015-04-28 16:55:23 +0200714 if (alertif_too_many_args(1, file, linenum, args, &err_code))
715 goto out;
716
Emeric Brun32da3c42010-09-23 18:39:19 +0200717 err = invalid_char(args[1]);
718 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100719 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
720 file, linenum, *err, args[0], args[1]);
Willy Tarreau54984722014-02-16 08:20:13 +0100721 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100722 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200723 }
724
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200725 for (curpeers = cfg_peers; curpeers != NULL; curpeers = curpeers->next) {
Emeric Brun32da3c42010-09-23 18:39:19 +0200726 /*
727 * If there are two proxies with the same name only following
728 * combinations are allowed:
729 */
730 if (strcmp(curpeers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100731 ha_alert("Parsing [%s:%d]: peers section '%s' has the same name as another peers section declared at %s:%d.\n",
732 file, linenum, args[1], curpeers->conf.file, curpeers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +0200733 err_code |= ERR_ALERT | ERR_FATAL;
Emeric Brun32da3c42010-09-23 18:39:19 +0200734 }
735 }
736
Vincent Bernat02779b62016-04-03 13:48:43 +0200737 if ((curpeers = calloc(1, sizeof(*curpeers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100738 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Emeric Brun32da3c42010-09-23 18:39:19 +0200739 err_code |= ERR_ALERT | ERR_ABORT;
740 goto out;
741 }
742
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200743 curpeers->next = cfg_peers;
744 cfg_peers = curpeers;
Willy Tarreau8113a5d2012-10-04 08:01:43 +0200745 curpeers->conf.file = strdup(file);
Emeric Brun32da3c42010-09-23 18:39:19 +0200746 curpeers->conf.line = linenum;
747 curpeers->last_change = now.tv_sec;
748 curpeers->id = strdup(args[1]);
Willy Tarreau1ad64ac2020-09-24 08:48:08 +0200749 curpeers->disabled = 0;
Emeric Brun32da3c42010-09-23 18:39:19 +0200750 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200751 else if (strcmp(args[0], "peer") == 0 ||
752 strcmp(args[0], "server") == 0) { /* peer or server definition */
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100753 int local_peer, peer;
Emeric Brun32da3c42010-09-23 18:39:19 +0200754
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100755 peer = *args[0] == 'p';
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100756 local_peer = strcmp(args[1], localpeer) == 0;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100757 /* The local peer may have already partially been parsed on a "bind" line. */
758 if (*args[0] == 'p') {
759 if (bind_line) {
760 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
761 err_code |= ERR_ALERT | ERR_FATAL;
762 goto out;
763 }
764 peer_line = 1;
765 }
766 if (cfg_peers->local && !cfg_peers->local->id && local_peer) {
767 /* The local peer has already been initialized on a "bind" line.
768 * Let's use it and store its ID.
769 */
770 newpeer = cfg_peers->local;
771 newpeer->id = strdup(localpeer);
772 }
773 else {
774 if (local_peer && cfg_peers->local) {
775 ha_alert("parsing [%s:%d] : '%s %s' : local peer name already referenced at %s:%d. %s\n",
776 file, linenum, args[0], args[1],
777 curpeers->peers_fe->conf.file, curpeers->peers_fe->conf.line, cfg_peers->local->id);
778 err_code |= ERR_FATAL;
779 goto out;
780 }
781 newpeer = cfg_peers_add_peer(curpeers, file, linenum, args[1], local_peer);
782 if (!newpeer) {
783 err_code |= ERR_ALERT | ERR_ABORT;
784 goto out;
785 }
786 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200787
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100788 /* Line number and peer ID are updated only if this peer is the local one. */
789 if (init_peers_frontend(file,
790 newpeer->local ? linenum: -1,
791 newpeer->local ? newpeer->id : NULL,
792 curpeers) != 0) {
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200793 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreaub36487e2013-03-10 18:37:42 +0100794 goto out;
795 }
Willy Tarreau2aa38802013-02-20 19:20:59 +0100796
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100797 /* This initializes curpeer->peers->peers_fe->srv.
798 * The server address is parsed only if we are parsing a "peer" line,
799 * or if we are parsing a "server" line and the current peer is not the local one.
800 */
Emeric Brund3db3842020-07-21 16:54:36 +0200801 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL, peer || !local_peer, 1, 1);
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200802 if (!curpeers->peers_fe->srv) {
803 /* Remove the newly allocated peer. */
804 if (newpeer != curpeers->local) {
805 struct peer *p;
806
807 p = curpeers->remote;
808 curpeers->remote = curpeers->remote->next;
809 free(p->id);
810 free(p);
811 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200812 goto out;
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200813 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200814
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100815 /* If the peer address has just been parsed, let's copy it to <newpeer>
816 * and initializes ->proto.
817 */
818 if (peer || !local_peer) {
819 newpeer->addr = curpeers->peers_fe->srv->addr;
820 newpeer->proto = protocol_by_family(newpeer->addr.ss_family);
821 }
822
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100823 newpeer->xprt = xprt_get(XPRT_RAW);
Willy Tarreaud02394b2012-05-11 18:32:18 +0200824 newpeer->sock_init_arg = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100825 HA_SPIN_INIT(&newpeer->lock);
Willy Tarreau26d8c592012-05-07 18:12:14 +0200826
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100827 newpeer->srv = curpeers->peers_fe->srv;
828 if (!newpeer->local)
Frédéric Lécaille6617e762018-04-25 15:13:38 +0200829 goto out;
830
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100831 /* The lines above are reserved to "peer" lines. */
832 if (*args[0] == 's')
Frédéric Lécaille4ba51982018-04-25 15:32:18 +0200833 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200834
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100835 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 +0100836
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100837 if (!str2listener(args[2], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
838 if (errmsg && *errmsg) {
839 indent_msg(&errmsg, 2);
840 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 +0100841 }
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100842 else
843 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
844 file, linenum, args[0], args[1], args[2]);
845 err_code |= ERR_FATAL;
846 goto out;
847 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100848
849 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
850 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100851 l->accept = session_accept_fd;
852 l->analysers |= curpeers->peers_fe->fe_req_ana;
853 l->default_target = curpeers->peers_fe->default_target;
854 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100855 global.maxsock++; /* for the listening socket */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100856 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100857 else if (strcmp(args[0], "table") == 0) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100858 struct stktable *t, *other;
859 char *id;
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100860 size_t prefix_len;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100861
862 /* Line number and peer ID are updated only if this peer is the local one. */
863 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
864 err_code |= ERR_ALERT | ERR_ABORT;
865 goto out;
866 }
867
868 other = stktable_find_by_name(args[1]);
869 if (other) {
870 ha_alert("parsing [%s:%d] : stick-table name '%s' conflicts with table declared in %s '%s' at %s:%d.\n",
871 file, linenum, args[1],
872 other->proxy ? proxy_cap_str(other->proxy->cap) : "peers",
873 other->proxy ? other->id : other->peers.p->id,
874 other->conf.file, other->conf.line);
875 err_code |= ERR_ALERT | ERR_FATAL;
876 goto out;
877 }
878
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100879 /* Build the stick-table name, concatenating the "peers" section name
880 * followed by a '/' character and the table name argument.
881 */
882 chunk_reset(&trash);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100883 if (!chunk_strcpy(&trash, curpeers->id)) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100884 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
885 file, linenum, args[0], args[1]);
886 err_code |= ERR_ALERT | ERR_FATAL;
887 goto out;
888 }
889
890 prefix_len = trash.data;
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100891 if (!chunk_memcat(&trash, "/", 1) || !chunk_strcat(&trash, args[1])) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100892 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
893 file, linenum, args[0], args[1]);
894 err_code |= ERR_ALERT | ERR_FATAL;
895 goto out;
896 }
897
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100898 t = calloc(1, sizeof *t);
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100899 id = strdup(trash.area);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100900 if (!t || !id) {
901 ha_alert("parsing [%s:%d]: '%s %s' : memory allocation failed\n",
902 file, linenum, args[0], args[1]);
Eric Salama1aab9112020-09-18 11:55:17 +0200903 free(t);
904 free(id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100905 err_code |= ERR_ALERT | ERR_FATAL;
906 goto out;
907 }
908
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100909 err_code |= parse_stick_table(file, linenum, args, t, id, id + prefix_len, curpeers);
Eric Salama1aab9112020-09-18 11:55:17 +0200910 if (err_code & ERR_FATAL) {
911 free(t);
912 free(id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100913 goto out;
Eric Salama1aab9112020-09-18 11:55:17 +0200914 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100915
916 stktable_store_name(t);
917 t->next = stktables_list;
918 stktables_list = t;
919 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100920 else if (strcmp(args[0], "disabled") == 0) { /* disables this peers section */
Willy Tarreau1ad64ac2020-09-24 08:48:08 +0200921 curpeers->disabled = 1;
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200922 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100923 else if (strcmp(args[0], "enabled") == 0) { /* enables this peers section (used to revert a disabled default) */
Willy Tarreau1ad64ac2020-09-24 08:48:08 +0200924 curpeers->disabled = 0;
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200925 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200926 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100927 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Emeric Brun32da3c42010-09-23 18:39:19 +0200928 err_code |= ERR_ALERT | ERR_FATAL;
929 goto out;
930 }
931
932out:
Willy Tarreau902636f2013-03-10 19:44:48 +0100933 free(errmsg);
Emeric Brun32da3c42010-09-23 18:39:19 +0200934 return err_code;
935}
936
Baptiste Assmann325137d2015-04-13 23:40:55 +0200937/*
938 * Parse a <resolvers> section.
939 * Returns the error code, 0 if OK, or any combination of :
940 * - ERR_ABORT: must abort ASAP
941 * - ERR_FATAL: we can continue parsing but not start the service
942 * - ERR_WARN: a warning has been emitted
943 * - ERR_ALERT: an alert has been emitted
944 * Only the two first ones can stop processing, the two others are just
945 * indicators.
946 */
947int cfg_parse_resolvers(const char *file, int linenum, char **args, int kwm)
948{
949 static struct dns_resolvers *curr_resolvers = NULL;
Baptiste Assmann325137d2015-04-13 23:40:55 +0200950 const char *err;
951 int err_code = 0;
952 char *errmsg = NULL;
953
954 if (strcmp(args[0], "resolvers") == 0) { /* new resolvers section */
955 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100956 ha_alert("parsing [%s:%d] : missing name for resolvers section.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200957 err_code |= ERR_ALERT | ERR_ABORT;
958 goto out;
959 }
960
961 err = invalid_char(args[1]);
962 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100963 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
964 file, linenum, *err, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200965 err_code |= ERR_ALERT | ERR_ABORT;
966 goto out;
967 }
968
969 list_for_each_entry(curr_resolvers, &dns_resolvers, list) {
970 /* Error if two resolvers owns the same name */
971 if (strcmp(curr_resolvers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100972 ha_alert("Parsing [%s:%d]: resolvers '%s' has same name as another resolvers (declared at %s:%d).\n",
973 file, linenum, args[1], curr_resolvers->conf.file, curr_resolvers->conf.line);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200974 err_code |= ERR_ALERT | ERR_ABORT;
975 }
976 }
977
Vincent Bernat02779b62016-04-03 13:48:43 +0200978 if ((curr_resolvers = calloc(1, sizeof(*curr_resolvers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100979 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200980 err_code |= ERR_ALERT | ERR_ABORT;
981 goto out;
982 }
983
984 /* default values */
985 LIST_ADDQ(&dns_resolvers, &curr_resolvers->list);
986 curr_resolvers->conf.file = strdup(file);
987 curr_resolvers->conf.line = linenum;
988 curr_resolvers->id = strdup(args[1]);
989 curr_resolvers->query_ids = EB_ROOT;
Baptiste Assmann2af08fe2017-08-14 00:13:01 +0200990 /* default maximum response size */
991 curr_resolvers->accepted_payload_size = 512;
Baptiste Assmann987e16d2016-11-02 22:23:31 +0100992 /* default hold period for nx, other, refuse and timeout is 30s */
993 curr_resolvers->hold.nx = 30000;
994 curr_resolvers->hold.other = 30000;
995 curr_resolvers->hold.refused = 30000;
996 curr_resolvers->hold.timeout = 30000;
Baptiste Assmann686408b2017-08-18 10:15:42 +0200997 curr_resolvers->hold.obsolete = 0;
Baptiste Assmann325137d2015-04-13 23:40:55 +0200998 /* default hold period for valid is 10s */
Baptiste Assmann4c5490a2015-07-14 21:42:49 +0200999 curr_resolvers->hold.valid = 10000;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001000 curr_resolvers->timeout.resolve = 1000;
1001 curr_resolvers->timeout.retry = 1000;
Baptiste Assmann325137d2015-04-13 23:40:55 +02001002 curr_resolvers->resolve_retries = 3;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001003 curr_resolvers->nb_nameservers = 0;
1004 LIST_INIT(&curr_resolvers->nameservers);
1005 LIST_INIT(&curr_resolvers->resolutions.curr);
1006 LIST_INIT(&curr_resolvers->resolutions.wait);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001007 HA_SPIN_INIT(&curr_resolvers->lock);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001008 }
1009 else if (strcmp(args[0], "nameserver") == 0) { /* nameserver definition */
Eric Salama9139ec32020-11-13 15:56:36 +01001010 struct dns_nameserver *newnameserver = NULL;
Baptiste Assmann325137d2015-04-13 23:40:55 +02001011 struct sockaddr_storage *sk;
1012 int port1, port2;
Baptiste Assmann325137d2015-04-13 23:40:55 +02001013
1014 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001015 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1016 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001017 err_code |= ERR_ALERT | ERR_FATAL;
1018 goto out;
1019 }
1020
1021 err = invalid_char(args[1]);
1022 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001023 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1024 file, linenum, *err, args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001025 err_code |= ERR_ALERT | ERR_FATAL;
1026 goto out;
1027 }
1028
Christopher Faulet67957bd2017-09-27 11:00:59 +02001029 list_for_each_entry(newnameserver, &curr_resolvers->nameservers, list) {
Baptiste Assmanna315c552015-11-02 22:55:49 +01001030 /* Error if two resolvers owns the same name */
1031 if (strcmp(newnameserver->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001032 ha_alert("Parsing [%s:%d]: nameserver '%s' has same name as another nameserver (declared at %s:%d).\n",
Ben Draut44e609b2018-05-29 15:40:08 -06001033 file, linenum, args[1], newnameserver->conf.file, newnameserver->conf.line);
Baptiste Assmanna315c552015-11-02 22:55:49 +01001034 err_code |= ERR_ALERT | ERR_FATAL;
1035 }
1036 }
1037
Vincent Bernat02779b62016-04-03 13:48:43 +02001038 if ((newnameserver = calloc(1, sizeof(*newnameserver))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001039 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001040 err_code |= ERR_ALERT | ERR_ABORT;
1041 goto out;
1042 }
1043
1044 /* the nameservers are linked backward first */
Christopher Faulet67957bd2017-09-27 11:00:59 +02001045 LIST_ADDQ(&curr_resolvers->nameservers, &newnameserver->list);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001046 newnameserver->resolvers = curr_resolvers;
1047 newnameserver->conf.file = strdup(file);
1048 newnameserver->conf.line = linenum;
1049 newnameserver->id = strdup(args[1]);
1050
Willy Tarreau5fc93282020-09-16 18:25:03 +02001051 sk = str2sa_range(args[2], NULL, &port1, &port2, NULL, NULL,
1052 &errmsg, NULL, NULL, PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_DGRAM);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001053 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001054 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001055 err_code |= ERR_ALERT | ERR_FATAL;
1056 goto out;
1057 }
1058
Baptiste Assmann325137d2015-04-13 23:40:55 +02001059 newnameserver->addr = *sk;
1060 }
Ben Draut44e609b2018-05-29 15:40:08 -06001061 else if (strcmp(args[0], "parse-resolv-conf") == 0) {
Eric Salama9139ec32020-11-13 15:56:36 +01001062 struct dns_nameserver *newnameserver = NULL;
Ben Draut44e609b2018-05-29 15:40:08 -06001063 const char *whitespace = "\r\n\t ";
1064 char *resolv_line = NULL;
1065 int resolv_linenum = 0;
1066 FILE *f = NULL;
1067 char *address = NULL;
1068 struct sockaddr_storage *sk = NULL;
1069 struct protocol *proto;
1070 int duplicate_name = 0;
1071
1072 if ((resolv_line = malloc(sizeof(*resolv_line) * LINESIZE)) == NULL) {
1073 ha_alert("parsing [%s:%d] : out of memory.\n",
1074 file, linenum);
1075 err_code |= ERR_ALERT | ERR_FATAL;
1076 goto resolv_out;
1077 }
1078
1079 if ((f = fopen("/etc/resolv.conf", "r")) == NULL) {
1080 ha_alert("parsing [%s:%d] : failed to open /etc/resolv.conf.\n",
1081 file, linenum);
1082 err_code |= ERR_ALERT | ERR_FATAL;
1083 goto resolv_out;
1084 }
1085
1086 sk = calloc(1, sizeof(*sk));
1087 if (sk == NULL) {
1088 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n",
1089 resolv_linenum);
1090 err_code |= ERR_ALERT | ERR_FATAL;
1091 goto resolv_out;
1092 }
1093
1094 while (fgets(resolv_line, LINESIZE, f) != NULL) {
1095 resolv_linenum++;
1096 if (strncmp(resolv_line, "nameserver", 10) != 0)
1097 continue;
1098
1099 address = strtok(resolv_line + 10, whitespace);
1100 if (address == resolv_line + 10)
1101 continue;
1102
1103 if (address == NULL) {
1104 ha_warning("parsing [/etc/resolv.conf:%d] : nameserver line is missing address.\n",
1105 resolv_linenum);
1106 err_code |= ERR_WARN;
1107 continue;
1108 }
1109
1110 duplicate_name = 0;
1111 list_for_each_entry(newnameserver, &curr_resolvers->nameservers, list) {
1112 if (strcmp(newnameserver->id, address) == 0) {
1113 ha_warning("Parsing [/etc/resolv.conf:%d] : generated name for /etc/resolv.conf nameserver '%s' conflicts with another nameserver (declared at %s:%d), it appears to be a duplicate and will be excluded.\n",
1114 resolv_linenum, address, newnameserver->conf.file, newnameserver->conf.line);
1115 err_code |= ERR_WARN;
1116 duplicate_name = 1;
1117 }
1118 }
1119
1120 if (duplicate_name)
1121 continue;
1122
1123 memset(sk, 0, sizeof(*sk));
Willy Tarreau78675252020-05-28 18:07:10 +02001124 if (!str2ip2(address, sk, 1)) {
1125 ha_warning("parsing [/etc/resolv.conf:%d] : address '%s' could not be recognized, nameserver will be excluded.\n",
Ben Draut44e609b2018-05-29 15:40:08 -06001126 resolv_linenum, address);
1127 err_code |= ERR_WARN;
1128 continue;
1129 }
1130
1131 set_host_port(sk, 53);
1132
1133 proto = protocol_by_family(sk->ss_family);
1134 if (!proto || !proto->connect) {
1135 ha_warning("parsing [/etc/resolv.conf:%d] : '%s' : connect() not supported for this address family.\n",
1136 resolv_linenum, address);
1137 err_code |= ERR_WARN;
1138 continue;
1139 }
1140
1141 if ((newnameserver = calloc(1, sizeof(*newnameserver))) == NULL) {
1142 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1143 err_code |= ERR_ALERT | ERR_FATAL;
1144 goto resolv_out;
1145 }
1146
1147 newnameserver->conf.file = strdup("/etc/resolv.conf");
1148 if (newnameserver->conf.file == NULL) {
1149 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1150 err_code |= ERR_ALERT | ERR_FATAL;
Eric Salama9139ec32020-11-13 15:56:36 +01001151 free(newnameserver);
Ben Draut44e609b2018-05-29 15:40:08 -06001152 goto resolv_out;
1153 }
1154
1155 newnameserver->id = strdup(address);
1156 if (newnameserver->id == NULL) {
1157 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1158 err_code |= ERR_ALERT | ERR_FATAL;
Eric Salama9139ec32020-11-13 15:56:36 +01001159 free((char *)newnameserver->conf.file);
1160 free(newnameserver);
Ben Draut44e609b2018-05-29 15:40:08 -06001161 goto resolv_out;
1162 }
1163
1164 newnameserver->resolvers = curr_resolvers;
1165 newnameserver->conf.line = resolv_linenum;
1166 newnameserver->addr = *sk;
1167
1168 LIST_ADDQ(&curr_resolvers->nameservers, &newnameserver->list);
1169 }
1170
1171resolv_out:
1172 free(sk);
1173 free(resolv_line);
1174 if (f != NULL)
1175 fclose(f);
1176 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001177 else if (strcmp(args[0], "hold") == 0) { /* hold periods */
1178 const char *res;
1179 unsigned int time;
1180
1181 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001182 ha_alert("parsing [%s:%d] : '%s' expects an <event> and a <time> as arguments.\n",
1183 file, linenum, args[0]);
1184 ha_alert("<event> can be either 'valid', 'nx', 'refused', 'timeout', or 'other'\n");
Baptiste Assmann325137d2015-04-13 23:40:55 +02001185 err_code |= ERR_ALERT | ERR_FATAL;
1186 goto out;
1187 }
1188 res = parse_time_err(args[2], &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001189 if (res == PARSE_TIME_OVER) {
1190 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s>, maximum value is 2147483647 ms (~24.8 days).\n",
1191 file, linenum, args[1], args[0]);
1192 err_code |= ERR_ALERT | ERR_FATAL;
1193 goto out;
1194 }
1195 else if (res == PARSE_TIME_UNDER) {
1196 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s>, minimum non-null value is 1 ms.\n",
1197 file, linenum, args[1], args[0]);
1198 err_code |= ERR_ALERT | ERR_FATAL;
1199 goto out;
1200 }
1201 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001202 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s>.\n",
1203 file, linenum, *res, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001204 err_code |= ERR_ALERT | ERR_FATAL;
1205 goto out;
1206 }
Baptiste Assmann987e16d2016-11-02 22:23:31 +01001207 if (strcmp(args[1], "nx") == 0)
1208 curr_resolvers->hold.nx = time;
1209 else if (strcmp(args[1], "other") == 0)
1210 curr_resolvers->hold.other = time;
1211 else if (strcmp(args[1], "refused") == 0)
1212 curr_resolvers->hold.refused = time;
1213 else if (strcmp(args[1], "timeout") == 0)
1214 curr_resolvers->hold.timeout = time;
1215 else if (strcmp(args[1], "valid") == 0)
Baptiste Assmann325137d2015-04-13 23:40:55 +02001216 curr_resolvers->hold.valid = time;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02001217 else if (strcmp(args[1], "obsolete") == 0)
1218 curr_resolvers->hold.obsolete = time;
Baptiste Assmann325137d2015-04-13 23:40:55 +02001219 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001220 ha_alert("parsing [%s:%d] : '%s' unknown <event>: '%s', expects either 'nx', 'timeout', 'valid', 'obsolete' or 'other'.\n",
1221 file, linenum, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001222 err_code |= ERR_ALERT | ERR_FATAL;
1223 goto out;
1224 }
1225
1226 }
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001227 else if (strcmp(args[0], "accepted_payload_size") == 0) {
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001228 int i = 0;
1229
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001230 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001231 ha_alert("parsing [%s:%d] : '%s' expects <nb> as argument.\n",
1232 file, linenum, args[0]);
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001233 err_code |= ERR_ALERT | ERR_FATAL;
1234 goto out;
1235 }
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001236
1237 i = atoi(args[1]);
Willy Tarreau0c219be2017-08-22 12:01:26 +02001238 if (i < DNS_HEADER_SIZE || i > DNS_MAX_UDP_MESSAGE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001239 ha_alert("parsing [%s:%d] : '%s' must be between %d and %d inclusive (was %s).\n",
1240 file, linenum, args[0], DNS_HEADER_SIZE, DNS_MAX_UDP_MESSAGE, args[1]);
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001241 err_code |= ERR_ALERT | ERR_FATAL;
1242 goto out;
1243 }
1244
1245 curr_resolvers->accepted_payload_size = i;
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001246 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001247 else if (strcmp(args[0], "resolution_pool_size") == 0) {
Tim Duesterhus3506dae2019-05-14 20:57:56 +02001248 ha_alert("parsing [%s:%d] : '%s' directive is not supported anymore (it never appeared in a stable release).\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01001249 file, linenum, args[0]);
Tim Duesterhus3506dae2019-05-14 20:57:56 +02001250 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001251 goto out;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001252 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001253 else if (strcmp(args[0], "resolve_retries") == 0) {
1254 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001255 ha_alert("parsing [%s:%d] : '%s' expects <nb> as argument.\n",
1256 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001257 err_code |= ERR_ALERT | ERR_FATAL;
1258 goto out;
1259 }
1260 curr_resolvers->resolve_retries = atoi(args[1]);
1261 }
1262 else if (strcmp(args[0], "timeout") == 0) {
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001263 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001264 ha_alert("parsing [%s:%d] : '%s' expects 'retry' or 'resolve' and <time> as arguments.\n",
1265 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001266 err_code |= ERR_ALERT | ERR_FATAL;
1267 goto out;
1268 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001269 else if (strcmp(args[1], "retry") == 0 ||
1270 strcmp(args[1], "resolve") == 0) {
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001271 const char *res;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001272 unsigned int tout;
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001273
1274 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001275 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1276 file, linenum, args[0], args[1]);
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001277 err_code |= ERR_ALERT | ERR_FATAL;
1278 goto out;
1279 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001280 res = parse_time_err(args[2], &tout, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001281 if (res == PARSE_TIME_OVER) {
1282 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1283 file, linenum, args[2], args[0], args[1]);
1284 err_code |= ERR_ALERT | ERR_FATAL;
1285 goto out;
1286 }
1287 else if (res == PARSE_TIME_UNDER) {
1288 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1289 file, linenum, args[2], args[0], args[1]);
1290 err_code |= ERR_ALERT | ERR_FATAL;
1291 goto out;
1292 }
1293 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001294 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1295 file, linenum, *res, args[0], args[1]);
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001296 err_code |= ERR_ALERT | ERR_FATAL;
1297 goto out;
1298 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001299 if (args[1][2] == 't')
1300 curr_resolvers->timeout.retry = tout;
1301 else
1302 curr_resolvers->timeout.resolve = tout;
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001303 }
1304 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001305 ha_alert("parsing [%s:%d] : '%s' expects 'retry' or 'resolve' and <time> as arguments got '%s'.\n",
1306 file, linenum, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001307 err_code |= ERR_ALERT | ERR_FATAL;
1308 goto out;
1309 }
Eric Salama9139ec32020-11-13 15:56:36 +01001310 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001311 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001312 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001313 err_code |= ERR_ALERT | ERR_FATAL;
1314 goto out;
1315 }
1316
1317 out:
1318 free(errmsg);
1319 return err_code;
1320}
Simon Horman0d16a402015-01-30 11:22:58 +09001321
1322/*
William Lallemand51097192015-04-14 16:35:22 +02001323 * Parse a line in a <listen>, <frontend> or <backend> section.
Simon Horman0d16a402015-01-30 11:22:58 +09001324 * Returns the error code, 0 if OK, or any combination of :
1325 * - ERR_ABORT: must abort ASAP
1326 * - ERR_FATAL: we can continue parsing but not start the service
1327 * - ERR_WARN: a warning has been emitted
1328 * - ERR_ALERT: an alert has been emitted
1329 * Only the two first ones can stop processing, the two others are just
1330 * indicators.
1331 */
1332int cfg_parse_mailers(const char *file, int linenum, char **args, int kwm)
1333{
1334 static struct mailers *curmailers = NULL;
1335 struct mailer *newmailer = NULL;
1336 const char *err;
1337 int err_code = 0;
1338 char *errmsg = NULL;
1339
1340 if (strcmp(args[0], "mailers") == 0) { /* new mailers section */
1341 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001342 ha_alert("parsing [%s:%d] : missing name for mailers section.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001343 err_code |= ERR_ALERT | ERR_ABORT;
1344 goto out;
1345 }
1346
1347 err = invalid_char(args[1]);
1348 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001349 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
1350 file, linenum, *err, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001351 err_code |= ERR_ALERT | ERR_ABORT;
1352 goto out;
1353 }
1354
1355 for (curmailers = mailers; curmailers != NULL; curmailers = curmailers->next) {
1356 /*
1357 * If there are two proxies with the same name only following
1358 * combinations are allowed:
1359 */
1360 if (strcmp(curmailers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001361 ha_alert("Parsing [%s:%d]: mailers section '%s' has the same name as another mailers section declared at %s:%d.\n",
1362 file, linenum, args[1], curmailers->conf.file, curmailers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +02001363 err_code |= ERR_ALERT | ERR_FATAL;
Simon Horman0d16a402015-01-30 11:22:58 +09001364 }
1365 }
1366
Vincent Bernat02779b62016-04-03 13:48:43 +02001367 if ((curmailers = calloc(1, sizeof(*curmailers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001368 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001369 err_code |= ERR_ALERT | ERR_ABORT;
1370 goto out;
1371 }
1372
1373 curmailers->next = mailers;
1374 mailers = curmailers;
1375 curmailers->conf.file = strdup(file);
1376 curmailers->conf.line = linenum;
1377 curmailers->id = strdup(args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001378 curmailers->timeout.mail = DEF_MAILALERTTIME;/* XXX: Would like to Skip to the next alert, if any, ASAP.
1379 * But need enough time so that timeouts don't occur
1380 * during tcp procssing. For now just us an arbitrary default. */
Simon Horman0d16a402015-01-30 11:22:58 +09001381 }
1382 else if (strcmp(args[0], "mailer") == 0) { /* mailer definition */
1383 struct sockaddr_storage *sk;
1384 int port1, port2;
1385 struct protocol *proto;
1386
1387 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001388 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1389 file, linenum, args[0]);
Simon Horman0d16a402015-01-30 11:22:58 +09001390 err_code |= ERR_ALERT | ERR_FATAL;
1391 goto out;
1392 }
1393
1394 err = invalid_char(args[1]);
1395 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001396 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1397 file, linenum, *err, args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001398 err_code |= ERR_ALERT | ERR_FATAL;
1399 goto out;
1400 }
1401
Vincent Bernat02779b62016-04-03 13:48:43 +02001402 if ((newmailer = calloc(1, sizeof(*newmailer))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001403 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001404 err_code |= ERR_ALERT | ERR_ABORT;
1405 goto out;
1406 }
1407
1408 /* the mailers are linked backwards first */
1409 curmailers->count++;
1410 newmailer->next = curmailers->mailer_list;
1411 curmailers->mailer_list = newmailer;
1412 newmailer->mailers = curmailers;
1413 newmailer->conf.file = strdup(file);
1414 newmailer->conf.line = linenum;
1415
1416 newmailer->id = strdup(args[1]);
1417
Willy Tarreau5fc93282020-09-16 18:25:03 +02001418 sk = str2sa_range(args[2], NULL, &port1, &port2, NULL, &proto,
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001419 &errmsg, NULL, NULL,
1420 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 +09001421 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001422 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Simon Horman0d16a402015-01-30 11:22:58 +09001423 err_code |= ERR_ALERT | ERR_FATAL;
1424 goto out;
1425 }
1426
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001427 if (proto->sock_prot != IPPROTO_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001428 ha_alert("parsing [%s:%d] : '%s %s' : TCP not supported for this address family.\n",
1429 file, linenum, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001430 err_code |= ERR_ALERT | ERR_FATAL;
1431 goto out;
1432 }
1433
Simon Horman0d16a402015-01-30 11:22:58 +09001434 newmailer->addr = *sk;
1435 newmailer->proto = proto;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01001436 newmailer->xprt = xprt_get(XPRT_RAW);
Simon Horman0d16a402015-01-30 11:22:58 +09001437 newmailer->sock_init_arg = NULL;
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001438 }
1439 else if (strcmp(args[0], "timeout") == 0) {
1440 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001441 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments.\n",
1442 file, linenum, args[0]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001443 err_code |= ERR_ALERT | ERR_FATAL;
1444 goto out;
1445 }
1446 else if (strcmp(args[1], "mail") == 0) {
1447 const char *res;
1448 unsigned int timeout_mail;
1449 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001450 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1451 file, linenum, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001452 err_code |= ERR_ALERT | ERR_FATAL;
1453 goto out;
1454 }
1455 res = parse_time_err(args[2], &timeout_mail, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001456 if (res == PARSE_TIME_OVER) {
1457 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1458 file, linenum, args[2], args[0], args[1]);
1459 err_code |= ERR_ALERT | ERR_FATAL;
1460 goto out;
1461 }
1462 else if (res == PARSE_TIME_UNDER) {
1463 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1464 file, linenum, args[2], args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001465 err_code |= ERR_ALERT | ERR_FATAL;
1466 goto out;
1467 }
Willy Tarreau9faebe32019-06-07 19:00:37 +02001468 else if (res) {
1469 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1470 file, linenum, *res, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001471 err_code |= ERR_ALERT | ERR_FATAL;
1472 goto out;
1473 }
1474 curmailers->timeout.mail = timeout_mail;
1475 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001476 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments got '%s'.\n",
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001477 file, linenum, args[0], args[1]);
1478 err_code |= ERR_ALERT | ERR_FATAL;
1479 goto out;
1480 }
1481 }
Simon Horman0d16a402015-01-30 11:22:58 +09001482 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001483 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Simon Horman0d16a402015-01-30 11:22:58 +09001484 err_code |= ERR_ALERT | ERR_FATAL;
1485 goto out;
1486 }
1487
1488out:
1489 free(errmsg);
1490 return err_code;
1491}
1492
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +01001493void free_email_alert(struct proxy *p)
Simon Horman9dc49962015-01-30 11:22:59 +09001494{
1495 free(p->email_alert.mailers.name);
1496 p->email_alert.mailers.name = NULL;
1497 free(p->email_alert.from);
1498 p->email_alert.from = NULL;
1499 free(p->email_alert.to);
1500 p->email_alert.to = NULL;
1501 free(p->email_alert.myhostname);
1502 p->email_alert.myhostname = NULL;
1503}
1504
Willy Tarreaubaaee002006-06-26 02:48:02 +02001505
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001506int
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001507cfg_parse_netns(const char *file, int linenum, char **args, int kwm)
1508{
Willy Tarreaue5733232019-05-22 19:24:06 +02001509#ifdef USE_NS
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001510 const char *err;
1511 const char *item = args[0];
1512
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001513 if (strcmp(item, "namespace_list") == 0) {
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001514 return 0;
1515 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001516 else if (strcmp(item, "namespace") == 0) {
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001517 size_t idx = 1;
1518 const char *current;
1519 while (*(current = args[idx++])) {
1520 err = invalid_char(current);
1521 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001522 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1523 file, linenum, *err, item, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001524 return ERR_ALERT | ERR_FATAL;
1525 }
1526
1527 if (netns_store_lookup(current, strlen(current))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001528 ha_alert("parsing [%s:%d]: Namespace '%s' is already added.\n",
1529 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001530 return ERR_ALERT | ERR_FATAL;
1531 }
1532 if (!netns_store_insert(current)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001533 ha_alert("parsing [%s:%d]: Cannot open namespace '%s'.\n",
1534 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001535 return ERR_ALERT | ERR_FATAL;
1536 }
1537 }
1538 }
1539
1540 return 0;
1541#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001542 ha_alert("parsing [%s:%d]: namespace support is not compiled in.",
1543 file, linenum);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001544 return ERR_ALERT | ERR_FATAL;
1545#endif
1546}
1547
1548int
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001549cfg_parse_users(const char *file, int linenum, char **args, int kwm)
1550{
1551
1552 int err_code = 0;
1553 const char *err;
1554
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001555 if (strcmp(args[0], "userlist") == 0) { /* new userlist */
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001556 struct userlist *newul;
1557
1558 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001559 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1560 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001561 err_code |= ERR_ALERT | ERR_FATAL;
1562 goto out;
1563 }
William Lallemand6e62fb62015-04-28 16:55:23 +02001564 if (alertif_too_many_args(1, file, linenum, args, &err_code))
1565 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001566
1567 err = invalid_char(args[1]);
1568 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001569 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1570 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001571 err_code |= ERR_ALERT | ERR_FATAL;
1572 goto out;
1573 }
1574
1575 for (newul = userlist; newul; newul = newul->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001576 if (strcmp(newul->name, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001577 ha_warning("parsing [%s:%d]: ignoring duplicated userlist '%s'.\n",
1578 file, linenum, args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001579 err_code |= ERR_WARN;
1580 goto out;
1581 }
1582
Vincent Bernat02779b62016-04-03 13:48:43 +02001583 newul = calloc(1, sizeof(*newul));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001584 if (!newul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001585 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001586 err_code |= ERR_ALERT | ERR_ABORT;
1587 goto out;
1588 }
1589
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001590 newul->name = strdup(args[1]);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001591 if (!newul->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001592 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001593 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier97880bb2016-04-08 10:35:26 +01001594 free(newul);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001595 goto out;
1596 }
1597
1598 newul->next = userlist;
1599 userlist = newul;
1600
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001601 } else if (strcmp(args[0], "group") == 0) { /* new group */
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001602 int cur_arg;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001603 const char *err;
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001604 struct auth_groups *ag;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001605
1606 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001607 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1608 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001609 err_code |= ERR_ALERT | ERR_FATAL;
1610 goto out;
1611 }
1612
1613 err = invalid_char(args[1]);
1614 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001615 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1616 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001617 err_code |= ERR_ALERT | ERR_FATAL;
1618 goto out;
1619 }
1620
William Lallemand4ac9f542015-05-28 18:03:51 +02001621 if (!userlist)
1622 goto out;
1623
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001624 for (ag = userlist->groups; ag; ag = ag->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001625 if (strcmp(ag->name, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001626 ha_warning("parsing [%s:%d]: ignoring duplicated group '%s' in userlist '%s'.\n",
1627 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001628 err_code |= ERR_ALERT;
1629 goto out;
1630 }
1631
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001632 ag = calloc(1, sizeof(*ag));
1633 if (!ag) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001634 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001635 err_code |= ERR_ALERT | ERR_ABORT;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001636 goto out;
1637 }
1638
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001639 ag->name = strdup(args[1]);
David Carlier70d60452016-08-22 23:27:42 +01001640 if (!ag->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001641 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001642 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier70d60452016-08-22 23:27:42 +01001643 free(ag);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001644 goto out;
1645 }
1646
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001647 cur_arg = 2;
1648
1649 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001650 if (strcmp(args[cur_arg], "users") == 0) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001651 ag->groupusers = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001652 cur_arg += 2;
1653 continue;
1654 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001655 ha_alert("parsing [%s:%d]: '%s' only supports 'users' option.\n",
1656 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001657 err_code |= ERR_ALERT | ERR_FATAL;
David Carlier70d60452016-08-22 23:27:42 +01001658 free(ag->groupusers);
1659 free(ag->name);
1660 free(ag);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001661 goto out;
1662 }
1663 }
1664
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001665 ag->next = userlist->groups;
1666 userlist->groups = ag;
1667
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001668 } else if (strcmp(args[0], "user") == 0) { /* new user */
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001669 struct auth_users *newuser;
1670 int cur_arg;
1671
1672 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001673 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1674 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001675 err_code |= ERR_ALERT | ERR_FATAL;
1676 goto out;
1677 }
William Lallemand4ac9f542015-05-28 18:03:51 +02001678 if (!userlist)
1679 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001680
1681 for (newuser = userlist->users; newuser; newuser = newuser->next)
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001682 if (strcmp(newuser->user, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001683 ha_warning("parsing [%s:%d]: ignoring duplicated user '%s' in userlist '%s'.\n",
1684 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001685 err_code |= ERR_ALERT;
1686 goto out;
1687 }
1688
Vincent Bernat02779b62016-04-03 13:48:43 +02001689 newuser = calloc(1, sizeof(*newuser));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001690 if (!newuser) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001691 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001692 err_code |= ERR_ALERT | ERR_ABORT;
1693 goto out;
1694 }
1695
1696 newuser->user = strdup(args[1]);
1697
1698 newuser->next = userlist->users;
1699 userlist->users = newuser;
1700
1701 cur_arg = 2;
1702
1703 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001704 if (strcmp(args[cur_arg], "password") == 0) {
Willy Tarreaue5733232019-05-22 19:24:06 +02001705#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001706 if (!crypt("", args[cur_arg + 1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001707 ha_alert("parsing [%s:%d]: the encrypted password used for user '%s' is not supported by crypt(3).\n",
1708 file, linenum, newuser->user);
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001709 err_code |= ERR_ALERT | ERR_FATAL;
1710 goto out;
1711 }
1712#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001713 ha_warning("parsing [%s:%d]: no crypt(3) support compiled, encrypted passwords will not work.\n",
1714 file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001715 err_code |= ERR_ALERT;
1716#endif
1717 newuser->pass = strdup(args[cur_arg + 1]);
1718 cur_arg += 2;
1719 continue;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001720 } else if (strcmp(args[cur_arg], "insecure-password") == 0) {
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001721 newuser->pass = strdup(args[cur_arg + 1]);
1722 newuser->flags |= AU_O_INSECURE;
1723 cur_arg += 2;
1724 continue;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001725 } else if (strcmp(args[cur_arg], "groups") == 0) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001726 newuser->u.groups_names = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001727 cur_arg += 2;
1728 continue;
1729 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001730 ha_alert("parsing [%s:%d]: '%s' only supports 'password', 'insecure-password' and 'groups' options.\n",
1731 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001732 err_code |= ERR_ALERT | ERR_FATAL;
1733 goto out;
1734 }
1735 }
1736 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001737 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 +01001738 err_code |= ERR_ALERT | ERR_FATAL;
1739 }
1740
1741out:
1742 return err_code;
1743}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001744
Christopher Faulet79bdef32016-11-04 22:36:15 +01001745int
1746cfg_parse_scope(const char *file, int linenum, char *line)
1747{
1748 char *beg, *end, *scope = NULL;
1749 int err_code = 0;
1750 const char *err;
1751
1752 beg = line + 1;
1753 end = strchr(beg, ']');
1754
1755 /* Detect end of scope declaration */
1756 if (!end || end == beg) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001757 ha_alert("parsing [%s:%d] : empty scope name is forbidden.\n",
1758 file, linenum);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001759 err_code |= ERR_ALERT | ERR_FATAL;
1760 goto out;
1761 }
1762
1763 /* Get scope name and check its validity */
1764 scope = my_strndup(beg, end-beg);
1765 err = invalid_char(scope);
1766 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001767 ha_alert("parsing [%s:%d] : character '%c' is not permitted in a scope name.\n",
1768 file, linenum, *err);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001769 err_code |= ERR_ALERT | ERR_ABORT;
1770 goto out;
1771 }
1772
1773 /* Be sure to have a scope declaration alone on its line */
1774 line = end+1;
1775 while (isspace((unsigned char)*line))
1776 line++;
1777 if (*line && *line != '#' && *line != '\n' && *line != '\r') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001778 ha_alert("parsing [%s:%d] : character '%c' is not permitted after scope declaration.\n",
1779 file, linenum, *line);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001780 err_code |= ERR_ALERT | ERR_ABORT;
1781 goto out;
1782 }
1783
1784 /* We have a valid scope declaration, save it */
1785 free(cfg_scope);
1786 cfg_scope = scope;
1787 scope = NULL;
1788
1789 out:
1790 free(scope);
1791 return err_code;
1792}
1793
Frédéric Lécaillea41d5312018-01-29 12:05:07 +01001794int
1795cfg_parse_track_sc_num(unsigned int *track_sc_num,
1796 const char *arg, const char *end, char **errmsg)
1797{
1798 const char *p;
1799 unsigned int num;
1800
1801 p = arg;
1802 num = read_uint64(&arg, end);
1803
1804 if (arg != end) {
1805 memprintf(errmsg, "Wrong track-sc number '%s'", p);
1806 return -1;
1807 }
1808
1809 if (num >= MAX_SESS_STKCTR) {
1810 memprintf(errmsg, "%u track-sc number exceeding "
1811 "%d (MAX_SESS_STKCTR-1) value", num, MAX_SESS_STKCTR - 1);
1812 return -1;
1813 }
1814
1815 *track_sc_num = num;
1816 return 0;
1817}
1818
Willy Tarreaubaaee002006-06-26 02:48:02 +02001819/*
1820 * This function reads and parses the configuration file given in the argument.
Willy Tarreau058e9072009-07-20 09:30:05 +02001821 * Returns the error code, 0 if OK, or any combination of :
1822 * - ERR_ABORT: must abort ASAP
1823 * - ERR_FATAL: we can continue parsing but not start the service
1824 * - ERR_WARN: a warning has been emitted
1825 * - ERR_ALERT: an alert has been emitted
1826 * Only the two first ones can stop processing, the two others are just
1827 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001828 */
Willy Tarreaub17916e2006-10-15 15:17:57 +02001829int readcfgfile(const char *file)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001830{
William Lallemand64e84512015-05-12 14:25:37 +02001831 char *thisline;
1832 int linesize = LINESIZE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001833 FILE *f;
1834 int linenum = 0;
Willy Tarreau058e9072009-07-20 09:30:05 +02001835 int err_code = 0;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001836 struct cfg_section *cs = NULL, *pcs = NULL;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001837 struct cfg_section *ics;
William Lallemand64e84512015-05-12 14:25:37 +02001838 int readbytes = 0;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001839 char *outline = NULL;
1840 size_t outlen = 0;
1841 size_t outlinesize = 0;
Willy Tarreau32234e72020-06-16 17:14:33 +02001842 int fatal = 0;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001843 int missing_lf = -1;
William Lallemand64e84512015-05-12 14:25:37 +02001844
1845 if ((thisline = malloc(sizeof(*thisline) * linesize)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001846 ha_alert("parsing [%s] : out of memory.\n", file);
William Lallemand64e84512015-05-12 14:25:37 +02001847 return -1;
1848 }
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001849
David Carlier97880bb2016-04-08 10:35:26 +01001850 if ((f=fopen(file,"r")) == NULL) {
1851 free(thisline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001852 return -1;
David Carlier97880bb2016-04-08 10:35:26 +01001853 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001854
William Lallemandb2f07452015-05-12 14:27:13 +02001855next_line:
William Lallemand64e84512015-05-12 14:25:37 +02001856 while (fgets(thisline + readbytes, linesize - readbytes, f) != NULL) {
Willy Tarreau3842f002009-06-14 11:39:52 +02001857 int arg, kwm = KWM_STD;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001858 char *end;
1859 char *args[MAX_LINE_ARGS + 1];
1860 char *line = thisline;
1861
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001862 if (missing_lf != -1) {
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001863 ha_alert("parsing [%s:%d]: Stray NUL character at position %d.\n",
1864 file, linenum, (missing_lf + 1));
1865 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001866 missing_lf = -1;
Tim Duesterhusf92afb72020-08-18 22:00:04 +02001867 break;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001868 }
1869
Willy Tarreaubaaee002006-06-26 02:48:02 +02001870 linenum++;
1871
Willy Tarreau32234e72020-06-16 17:14:33 +02001872 if (fatal >= 50) {
1873 ha_alert("parsing [%s:%d]: too many fatal errors (%d), stopping now.\n", file, linenum, fatal);
1874 break;
1875 }
1876
Willy Tarreaubaaee002006-06-26 02:48:02 +02001877 end = line + strlen(line);
1878
William Lallemand64e84512015-05-12 14:25:37 +02001879 if (end-line == linesize-1 && *(end-1) != '\n') {
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001880 /* Check if we reached the limit and the last char is not \n.
1881 * Watch out for the last line without the terminating '\n'!
1882 */
William Lallemand64e84512015-05-12 14:25:37 +02001883 char *newline;
1884 int newlinesize = linesize * 2;
1885
1886 newline = realloc(thisline, sizeof(*thisline) * newlinesize);
1887 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001888 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1889 file, linenum);
William Lallemand64e84512015-05-12 14:25:37 +02001890 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001891 fatal++;
Willy Tarreau40cb26f2020-06-25 09:37:54 +02001892 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001893 continue;
1894 }
1895
1896 readbytes = linesize - 1;
1897 linesize = newlinesize;
1898 thisline = newline;
Willy Tarreau40cb26f2020-06-25 09:37:54 +02001899 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001900 continue;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001901 }
1902
William Lallemand64e84512015-05-12 14:25:37 +02001903 readbytes = 0;
1904
Willy Tarreau08488f62020-06-26 17:24:54 +02001905 if (end > line && *(end-1) == '\n') {
Tim Duesterhus70f58992020-06-22 22:57:44 +02001906 /* kill trailing LF */
1907 *(end - 1) = 0;
1908 }
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001909 else {
1910 /* mark this line as truncated */
1911 missing_lf = end - line;
1912 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001913
Willy Tarreaubaaee002006-06-26 02:48:02 +02001914 /* skip leading spaces */
Willy Tarreau8f8e6452007-06-17 21:51:38 +02001915 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001916 line++;
William Lallemandf9873ba2015-05-05 17:37:14 +02001917
Joseph Herlanta14c03e2018-11-15 14:04:19 -08001918 if (*line == '[') {/* This is the beginning if a scope */
Christopher Faulet79bdef32016-11-04 22:36:15 +01001919 err_code |= cfg_parse_scope(file, linenum, line);
1920 goto next_line;
1921 }
1922
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001923 while (1) {
1924 uint32_t err;
1925 char *errptr;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001926
Willy Tarreau61dd44b2020-06-25 07:35:42 +02001927 arg = MAX_LINE_ARGS + 1;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001928 outlen = outlinesize;
1929 err = parse_line(line, outline, &outlen, args, &arg,
1930 PARSE_OPT_ENV | PARSE_OPT_DQUOTE | PARSE_OPT_SQUOTE |
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02001931 PARSE_OPT_BKSLASH | PARSE_OPT_SHARP | PARSE_OPT_WORD_EXPAND,
1932 &errptr);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001933
1934 if (err & PARSE_ERR_QUOTE) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001935 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1936
1937 ha_alert("parsing [%s:%d]: unmatched quote at position %d:\n"
1938 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001939 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001940 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001941 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001942 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001943
1944 if (err & PARSE_ERR_BRACE) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001945 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1946
1947 ha_alert("parsing [%s:%d]: unmatched brace in environment variable name at position %d:\n"
1948 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001949 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001950 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001951 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001952 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001953
1954 if (err & PARSE_ERR_VARNAME) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001955 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1956
1957 ha_alert("parsing [%s:%d]: forbidden first char in environment variable name at position %d:\n"
1958 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001959 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001960 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001961 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001962 }
William Lallemandb2f07452015-05-12 14:27:13 +02001963
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001964 if (err & PARSE_ERR_HEX) {
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02001965 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1966
1967 ha_alert("parsing [%s:%d]: truncated or invalid hexadecimal sequence at position %d:\n"
1968 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001969 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus9f658a52020-06-16 18:14:21 +02001970 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001971 goto next_line;
1972 }
William Lallemandb2f07452015-05-12 14:27:13 +02001973
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02001974 if (err & PARSE_ERR_WRONG_EXPAND) {
1975 size_t newpos = sanitize_for_printing(line, errptr - line, 80);
1976
1977 ha_alert("parsing [%s:%d]: truncated or invalid word expansion sequence at position %d:\n"
1978 " %s\n %*s\n", file, linenum, (int)(errptr-thisline+1), line, (int)(newpos+1), "^");
1979 err_code |= ERR_ALERT | ERR_FATAL;
1980 fatal++;
1981 goto next_line;
1982 }
1983
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001984 if (err & (PARSE_ERR_TOOLARGE|PARSE_ERR_OVERLAP)) {
1985 outlinesize = (outlen + 1023) & -1024;
Ilya Shipitsin76837bc2021-01-07 22:45:13 +05001986 outline = my_realloc2(outline, outlinesize);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001987 if (outline == NULL) {
1988 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1989 file, linenum);
William Lallemandb2f07452015-05-12 14:27:13 +02001990 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001991 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001992 goto next_line;
William Lallemandb2f07452015-05-12 14:27:13 +02001993 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001994 /* try again */
1995 continue;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001996 }
Willy Tarreau07d47062020-06-25 07:41:22 +02001997
1998 if (err & PARSE_ERR_TOOMANY) {
1999 /* only check this *after* being sure the output is allocated */
2000 ha_alert("parsing [%s:%d]: too many words, truncating after word %d, position %ld: <%s>.\n",
2001 file, linenum, MAX_LINE_ARGS, (long)(args[MAX_LINE_ARGS-1] - outline + 1), args[MAX_LINE_ARGS-1]);
2002 err_code |= ERR_ALERT | ERR_FATAL;
2003 fatal++;
2004 goto next_line;
2005 }
2006
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002007 /* everything's OK */
2008 break;
William Lallemandf9873ba2015-05-05 17:37:14 +02002009 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002010
2011 /* empty line */
2012 if (!**args)
2013 continue;
2014
Willy Tarreau3842f002009-06-14 11:39:52 +02002015 /* check for keyword modifiers "no" and "default" */
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002016 if (strcmp(args[0], "no") == 0) {
William Lallemand0f99e342011-10-12 17:50:54 +02002017 char *tmp;
2018
Willy Tarreau3842f002009-06-14 11:39:52 +02002019 kwm = KWM_NO;
William Lallemand0f99e342011-10-12 17:50:54 +02002020 tmp = args[0];
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002021 for (arg=0; *args[arg+1]; arg++)
2022 args[arg] = args[arg+1]; // shift args after inversion
William Lallemand0f99e342011-10-12 17:50:54 +02002023 *tmp = '\0'; // fix the next arg to \0
2024 args[arg] = tmp;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002025 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002026 else if (strcmp(args[0], "default") == 0) {
Willy Tarreau3842f002009-06-14 11:39:52 +02002027 kwm = KWM_DEF;
2028 for (arg=0; *args[arg+1]; arg++)
2029 args[arg] = args[arg+1]; // shift args after inversion
2030 }
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002031
William Dauchyec730982019-10-27 20:08:10 +01002032 if (kwm != KWM_STD && strcmp(args[0], "option") != 0 &&
2033 strcmp(args[0], "log") != 0 && strcmp(args[0], "busy-polling") != 0 &&
Willy Tarreaud96f1122019-12-03 07:07:36 +01002034 strcmp(args[0], "set-dumpable") != 0 && strcmp(args[0], "strict-limits") != 0 &&
2035 strcmp(args[0], "insecure-fork-wanted") != 0) {
William Dauchyec730982019-10-27 20:08:10 +01002036 ha_alert("parsing [%s:%d]: negation/default currently "
William Dauchy0fec3ab2019-10-27 20:08:11 +01002037 "supported only for options, log, busy-polling, "
Willy Tarreaud96f1122019-12-03 07:07:36 +01002038 "set-dumpable, strict-limits, and insecure-fork-wanted.\n", file, linenum);
Willy Tarreau058e9072009-07-20 09:30:05 +02002039 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02002040 fatal++;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002041 }
2042
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002043 /* detect section start */
2044 list_for_each_entry(ics, &sections, list) {
2045 if (strcmp(args[0], ics->section_name) == 0) {
2046 cursection = ics->section_name;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002047 pcs = cs;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002048 cs = ics;
2049 break;
2050 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002051 }
2052
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002053 if (pcs && pcs->post_section_parser) {
Willy Tarreau32234e72020-06-16 17:14:33 +02002054 int status;
2055
2056 status = pcs->post_section_parser();
2057 err_code |= status;
2058 if (status & ERR_FATAL)
2059 fatal++;
2060
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002061 if (err_code & ERR_ABORT)
2062 goto err;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002063 }
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002064 pcs = NULL;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002065
William Lallemandd2ff56d2017-10-16 11:06:50 +02002066 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002067 ha_alert("parsing [%s:%d]: unknown keyword '%s' out of section.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02002068 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02002069 fatal++;
William Lallemandd2ff56d2017-10-16 11:06:50 +02002070 } else {
Willy Tarreau32234e72020-06-16 17:14:33 +02002071 int status;
2072
2073 status = cs->section_parser(file, linenum, args, kwm);
2074 err_code |= status;
2075 if (status & ERR_FATAL)
2076 fatal++;
2077
William Lallemandd2ff56d2017-10-16 11:06:50 +02002078 if (err_code & ERR_ABORT)
2079 goto err;
2080 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002081 }
William Lallemandd2ff56d2017-10-16 11:06:50 +02002082
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02002083 if (missing_lf != -1) {
Tim Duesterhusf92afb72020-08-18 22:00:04 +02002084 ha_alert("parsing [%s:%d]: Missing LF on last line, file might have been truncated at position %d.\n",
2085 file, linenum, (missing_lf + 1));
2086 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02002087 }
2088
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002089 if (cs && cs->post_section_parser)
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002090 err_code |= cs->post_section_parser();
William Lallemandd2ff56d2017-10-16 11:06:50 +02002091
2092err:
Christopher Faulet79bdef32016-11-04 22:36:15 +01002093 free(cfg_scope);
2094 cfg_scope = NULL;
Willy Tarreau6daf3432008-01-22 16:44:08 +01002095 cursection = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02002096 free(thisline);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002097 free(outline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002098 fclose(f);
Willy Tarreau058e9072009-07-20 09:30:05 +02002099 return err_code;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002100}
2101
Willy Tarreau64ab6072014-09-16 12:17:36 +02002102/* This function propagates processes from frontend <from> to backend <to> so
2103 * that it is always guaranteed that a backend pointed to by a frontend is
2104 * bound to all of its processes. After that, if the target is a "listen"
2105 * instance, the function recursively descends the target's own targets along
Willy Tarreau98d04852015-05-26 12:18:29 +02002106 * default_backend and use_backend rules. Since the bits are
Willy Tarreau64ab6072014-09-16 12:17:36 +02002107 * checked first to ensure that <to> is already bound to all processes of
2108 * <from>, there is no risk of looping and we ensure to follow the shortest
2109 * path to the destination.
2110 *
2111 * It is possible to set <to> to NULL for the first call so that the function
2112 * takes care of visiting the initial frontend in <from>.
2113 *
2114 * It is important to note that the function relies on the fact that all names
2115 * have already been resolved.
2116 */
2117void propagate_processes(struct proxy *from, struct proxy *to)
2118{
2119 struct switching_rule *rule;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002120
2121 if (to) {
2122 /* check whether we need to go down */
2123 if (from->bind_proc &&
2124 (from->bind_proc & to->bind_proc) == from->bind_proc)
2125 return;
2126
2127 if (!from->bind_proc && !to->bind_proc)
2128 return;
2129
2130 to->bind_proc = from->bind_proc ?
2131 (to->bind_proc | from->bind_proc) : 0;
2132
2133 /* now propagate down */
2134 from = to;
2135 }
2136
Willy Tarreau8a95d8c2014-12-18 13:56:26 +01002137 if (!(from->cap & PR_CAP_FE))
Willy Tarreau64ab6072014-09-16 12:17:36 +02002138 return;
2139
Willy Tarreauc3914d42020-09-24 08:39:22 +02002140 if (from->disabled)
Willy Tarreauf6b70012014-12-18 14:00:43 +01002141 return;
2142
Willy Tarreau64ab6072014-09-16 12:17:36 +02002143 /* default_backend */
2144 if (from->defbe.be)
2145 propagate_processes(from, from->defbe.be);
2146
2147 /* use_backend */
2148 list_for_each_entry(rule, &from->switching_rules, list) {
Cyril Bonté51639692014-10-02 19:56:25 +02002149 if (rule->dynamic)
2150 continue;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002151 to = rule->be.backend;
2152 propagate_processes(from, to);
2153 }
Willy Tarreau64ab6072014-09-16 12:17:36 +02002154}
2155
Willy Tarreaubb925012009-07-23 13:36:36 +02002156/*
2157 * Returns the error code, 0 if OK, or any combination of :
2158 * - ERR_ABORT: must abort ASAP
2159 * - ERR_FATAL: we can continue parsing but not start the service
2160 * - ERR_WARN: a warning has been emitted
2161 * - ERR_ALERT: an alert has been emitted
2162 * Only the two first ones can stop processing, the two others are just
2163 * indicators.
2164 */
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002165int check_config_validity()
2166{
2167 int cfgerr = 0;
2168 struct proxy *curproxy = NULL;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002169 struct stktable *t;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002170 struct server *newsrv = NULL;
Willy Tarreaubb925012009-07-23 13:36:36 +02002171 int err_code = 0;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002172 unsigned int next_pxid = 1;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002173 struct bind_conf *bind_conf;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002174 char *err;
William Lallemand48b4bb42017-10-23 14:36:34 +02002175 struct cfg_postparser *postparser;
Ben Draut054fbee2018-04-13 15:43:04 -06002176 struct dns_resolvers *curr_resolvers = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002177
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002178 bind_conf = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002179 /*
2180 * Now, check for the integrity of all that we have collected.
2181 */
2182
2183 /* will be needed further to delay some tasks */
Willy Tarreaub0b37bc2008-06-23 14:00:57 +02002184 tv_update_date(0,1);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002185
Willy Tarreau193b8c62012-11-22 00:17:38 +01002186 if (!global.tune.max_http_hdr)
2187 global.tune.max_http_hdr = MAX_HTTP_HDR;
2188
2189 if (!global.tune.cookie_len)
2190 global.tune.cookie_len = CAPTURE_LEN;
2191
Stéphane Cottin23e9e932017-05-18 08:58:41 +02002192 if (!global.tune.requri_len)
2193 global.tune.requri_len = REQURI_LEN;
2194
Willy Tarreau149ab772019-01-26 14:27:06 +01002195 if (!global.nbthread) {
2196 /* nbthread not set, thus automatic. In this case, and only if
2197 * running on a single process, we enable the same number of
2198 * threads as the number of CPUs the process is bound to. This
2199 * allows to easily control the number of threads using taskset.
2200 */
2201 global.nbthread = 1;
2202#if defined(USE_THREAD)
2203 if (global.nbproc == 1)
2204 global.nbthread = thread_cpus_enabled_at_boot;
2205 all_threads_mask = nbits(global.nbthread);
2206#endif
2207 }
2208
Willy Tarreau26f6ae12019-02-02 12:56:15 +01002209 if (global.nbproc > 1 && global.nbthread > 1) {
2210 ha_alert("config : cannot enable multiple processes if multiple threads are configured. Please use either nbproc or nbthread but not both.\n");
2211 err_code |= ERR_ALERT | ERR_FATAL;
2212 goto out;
2213 }
2214
Willy Tarreaubafbe012017-11-24 17:34:44 +01002215 pool_head_requri = create_pool("requri", global.tune.requri_len , MEM_F_SHARED);
Emeric Brun96fd9262017-07-05 13:33:16 +02002216
Willy Tarreaubafbe012017-11-24 17:34:44 +01002217 pool_head_capture = create_pool("capture", global.tune.cookie_len, MEM_F_SHARED);
Willy Tarreau193b8c62012-11-22 00:17:38 +01002218
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002219 /* Post initialisation of the users and groups lists. */
2220 err_code = userlist_postinit();
2221 if (err_code != ERR_NONE)
2222 goto out;
2223
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002224 /* first, we will invert the proxy list order */
2225 curproxy = NULL;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002226 while (proxies_list) {
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002227 struct proxy *next;
2228
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002229 next = proxies_list->next;
2230 proxies_list->next = curproxy;
2231 curproxy = proxies_list;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002232 if (!next)
2233 break;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002234 proxies_list = next;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002235 }
2236
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002237 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002238 struct switching_rule *rule;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002239 struct server_rule *srule;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002240 struct sticking_rule *mrule;
Christopher Faulete4e830d2017-09-18 14:51:41 +02002241 struct act_rule *arule;
Dragan Dosen1322d092015-09-22 16:05:32 +02002242 struct logsrv *tmplogsrv;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002243 unsigned int next_id;
Willy Tarreau16a21472012-11-19 12:39:59 +01002244 int nbproc;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002245
Willy Tarreau050536d2012-10-04 08:47:34 +02002246 if (curproxy->uuid < 0) {
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002247 /* proxy ID not set, use automatic numbering with first
2248 * spare entry starting with next_pxid.
2249 */
2250 next_pxid = get_next_id(&used_proxy_id, next_pxid);
2251 curproxy->conf.id.key = curproxy->uuid = next_pxid;
2252 eb32_insert(&used_proxy_id, &curproxy->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002253 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01002254 next_pxid++;
2255
Willy Tarreau55ea7572007-06-17 19:56:27 +02002256
Willy Tarreauc3914d42020-09-24 08:39:22 +02002257 if (curproxy->disabled) {
Willy Tarreau02b092f2020-10-07 18:36:54 +02002258 /* ensure we don't keep listeners uselessly bound. We
2259 * can't disable their listeners yet (fdtab not
2260 * allocated yet) but let's skip them.
2261 */
Dragan Dosen7d61a332019-05-07 14:16:18 +02002262 if (curproxy->table) {
2263 free((void *)curproxy->table->peers.name);
Willy Tarreau02b092f2020-10-07 18:36:54 +02002264 curproxy->table->peers.name = NULL;
Dragan Dosen7d61a332019-05-07 14:16:18 +02002265 curproxy->table->peers.p = NULL;
2266 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002267 continue;
2268 }
2269
Willy Tarreau102df612014-05-07 23:56:38 +02002270 /* Check multi-process mode compatibility for the current proxy */
2271
2272 if (curproxy->bind_proc) {
2273 /* an explicit bind-process was specified, let's check how many
2274 * processes remain.
2275 */
David Carliere6c39412015-07-02 07:00:17 +00002276 nbproc = my_popcountl(curproxy->bind_proc);
Willy Tarreau102df612014-05-07 23:56:38 +02002277
Willy Tarreaua38a7172019-02-02 17:11:28 +01002278 curproxy->bind_proc &= all_proc_mask;
Willy Tarreau102df612014-05-07 23:56:38 +02002279 if (!curproxy->bind_proc && nbproc == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002280 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 +02002281 curproxy->bind_proc = 1;
2282 }
2283 else if (!curproxy->bind_proc && nbproc > 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002284 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 +02002285 curproxy->bind_proc = 0;
2286 }
2287 }
2288
Willy Tarreau3d209582014-05-09 17:06:11 +02002289 /* check and reduce the bind-proc of each listener */
2290 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
2291 unsigned long mask;
2292
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002293 /* HTTP frontends with "h2" as ALPN/NPN will work in
2294 * HTTP/2 and absolutely require buffers 16kB or larger.
2295 */
2296#ifdef USE_OPENSSL
2297 if (curproxy->mode == PR_MODE_HTTP && global.tune.bufsize < 16384) {
2298#ifdef OPENSSL_NPN_NEGOTIATED
2299 /* check NPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002300 if (bind_conf->ssl_conf.npn_str && strstr(bind_conf->ssl_conf.npn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002301 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",
2302 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002303 cfgerr++;
2304 }
2305#endif
2306#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
2307 /* check ALPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002308 if (bind_conf->ssl_conf.alpn_str && strstr(bind_conf->ssl_conf.alpn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002309 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",
2310 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002311 cfgerr++;
2312 }
2313#endif
2314 } /* HTTP && bufsize < 16384 */
2315#endif
2316
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002317 /* detect and address thread affinity inconsistencies */
Willy Tarreaue26993c2020-09-03 07:18:55 +02002318 mask = thread_mask(bind_conf->settings.bind_thread);
Willy Tarreau3d957172019-02-02 18:00:17 +01002319 if (!(mask & all_threads_mask)) {
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002320 unsigned long new_mask = 0;
2321
2322 while (mask) {
Willy Tarreau0c026f42018-08-01 19:12:20 +02002323 new_mask |= mask & all_threads_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002324 mask >>= global.nbthread;
2325 }
2326
Willy Tarreaue26993c2020-09-03 07:18:55 +02002327 bind_conf->settings.bind_thread = new_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002328 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",
2329 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line, new_mask);
2330 }
2331
2332 /* detect process and nbproc affinity inconsistencies */
Willy Tarreaue26993c2020-09-03 07:18:55 +02002333 mask = proc_mask(bind_conf->settings.bind_proc) & proc_mask(curproxy->bind_proc);
Willy Tarreaua36b3242019-02-02 13:14:34 +01002334 if (!(mask & all_proc_mask)) {
2335 mask = proc_mask(curproxy->bind_proc) & all_proc_mask;
Willy Tarreaue26993c2020-09-03 07:18:55 +02002336 nbproc = my_popcountl(bind_conf->settings.bind_proc);
2337 bind_conf->settings.bind_proc = proc_mask(bind_conf->settings.bind_proc) & mask;
Willy Tarreau3d209582014-05-09 17:06:11 +02002338
Willy Tarreaue26993c2020-09-03 07:18:55 +02002339 if (!bind_conf->settings.bind_proc && nbproc == 1) {
Willy Tarreaua36b3242019-02-02 13:14:34 +01002340 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",
2341 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreaue26993c2020-09-03 07:18:55 +02002342 bind_conf->settings.bind_proc = mask & ~(mask - 1);
Willy Tarreaua36b3242019-02-02 13:14:34 +01002343 }
Willy Tarreaue26993c2020-09-03 07:18:55 +02002344 else if (!bind_conf->settings.bind_proc && nbproc > 1) {
Willy Tarreaua36b3242019-02-02 13:14:34 +01002345 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",
2346 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreaue26993c2020-09-03 07:18:55 +02002347 bind_conf->settings.bind_proc = 0;
Willy Tarreaua36b3242019-02-02 13:14:34 +01002348 }
Willy Tarreau3d209582014-05-09 17:06:11 +02002349 }
2350 }
2351
Willy Tarreauff01a212009-03-15 13:46:16 +01002352 switch (curproxy->mode) {
Willy Tarreauff01a212009-03-15 13:46:16 +01002353 case PR_MODE_TCP:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002354 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002355 break;
2356
2357 case PR_MODE_HTTP:
Willy Tarreau25320b22013-03-24 07:22:08 +01002358 curproxy->http_needed = 1;
Willy Tarreauff01a212009-03-15 13:46:16 +01002359 break;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002360
2361 case PR_MODE_CLI:
2362 cfgerr += proxy_cfg_ensure_no_http(curproxy);
2363 break;
Emeric Brun54932b42020-07-07 09:43:24 +02002364 case PR_MODE_SYSLOG:
Willy Tarreaua389c9e2020-10-07 17:49:42 +02002365 case PR_MODE_PEERS:
Emeric Brun54932b42020-07-07 09:43:24 +02002366 case PR_MODES:
2367 /* should not happen, bug gcc warn missing switch statement */
Willy Tarreaua389c9e2020-10-07 17:49:42 +02002368 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 +02002369 proxy_type_str(curproxy), curproxy->id);
2370 cfgerr++;
2371 break;
Willy Tarreauff01a212009-03-15 13:46:16 +01002372 }
2373
Willy Tarreau58aa5cc2018-02-08 09:55:09 +01002374 if (curproxy != global.stats_fe && (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->conf.listeners)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002375 ha_warning("config : %s '%s' has no 'bind' directive. Please declare it as a backend if this was intended.\n",
2376 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauf3934b82015-08-11 11:36:45 +02002377 err_code |= ERR_WARN;
2378 }
2379
Willy Tarreau77e0dae2020-10-14 15:44:27 +02002380 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002381 if (curproxy->lbprm.algo & BE_LB_KIND) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002382 if (curproxy->options & PR_O_TRANSP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002383 ha_alert("config : %s '%s' cannot use both transparent and balance mode.\n",
2384 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002385 cfgerr++;
2386 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002387#ifdef WE_DONT_SUPPORT_SERVERLESS_LISTENERS
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002388 else if (curproxy->srv == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002389 ha_alert("config : %s '%s' needs at least 1 server in balance mode.\n",
2390 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002391 cfgerr++;
2392 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002393#endif
Willy Tarreau1620ec32011-08-06 17:05:02 +02002394 else if (curproxy->options & PR_O_DISPATCH) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002395 ha_warning("config : dispatch address of %s '%s' will be ignored in balance mode.\n",
2396 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002397 err_code |= ERR_WARN;
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002398 }
2399 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02002400 else if (!(curproxy->options & (PR_O_TRANSP | PR_O_DISPATCH | PR_O_HTTP_PROXY))) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002401 /* If no LB algo is set in a backend, and we're not in
2402 * transparent mode, dispatch mode nor proxy mode, we
2403 * want to use balance roundrobin by default.
2404 */
2405 curproxy->lbprm.algo &= ~BE_LB_ALGO;
2406 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002407 }
2408 }
Willy Tarreau193cf932007-09-17 10:17:23 +02002409
Willy Tarreau1620ec32011-08-06 17:05:02 +02002410 if (curproxy->options & PR_O_DISPATCH)
2411 curproxy->options &= ~(PR_O_TRANSP | PR_O_HTTP_PROXY);
2412 else if (curproxy->options & PR_O_HTTP_PROXY)
2413 curproxy->options &= ~(PR_O_DISPATCH | PR_O_TRANSP);
2414 else if (curproxy->options & PR_O_TRANSP)
2415 curproxy->options &= ~(PR_O_DISPATCH | PR_O_HTTP_PROXY);
Willy Tarreau82936582007-11-30 15:20:09 +01002416
Christopher Faulete5870d82020-04-15 11:32:03 +02002417 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_HTTP_RS)) {
2418 ha_warning("config : %s '%s' uses http-check rules without 'option httpchk', so the rules are ignored.\n",
2419 proxy_type_str(curproxy), curproxy->id);
2420 err_code |= ERR_WARN;
2421 }
2422
2423 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_TCPCHK_CHK &&
Christopher Fauletc0fcbe42020-06-03 19:00:42 +02002424 (curproxy->tcpcheck_rules.flags & TCPCHK_RULES_PROTO_CHK) != TCPCHK_RULES_HTTP_CHK) {
Willy Tarreau1620ec32011-08-06 17:05:02 +02002425 if (curproxy->options & PR_O_DISABLE404) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002426 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2427 "disable-on-404", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002428 err_code |= ERR_WARN;
2429 curproxy->options &= ~PR_O_DISABLE404;
2430 }
2431 if (curproxy->options2 & PR_O2_CHK_SNDST) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002432 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2433 "send-state", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002434 err_code |= ERR_WARN;
2435 curproxy->options &= ~PR_O2_CHK_SNDST;
2436 }
Willy Tarreauef781042010-01-27 11:53:01 +01002437 }
2438
Simon Horman98637e52014-06-20 12:30:16 +09002439 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_EXT_CHK) {
2440 if (!global.external_check) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002441 ha_alert("Proxy '%s' : '%s' unable to find required 'global.external-check'.\n",
2442 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002443 cfgerr++;
2444 }
2445 if (!curproxy->check_command) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002446 ha_alert("Proxy '%s' : '%s' unable to find required 'external-check command'.\n",
2447 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002448 cfgerr++;
2449 }
Willy Tarreaud96f1122019-12-03 07:07:36 +01002450 if (!(global.tune.options & GTUNE_INSECURE_FORK)) {
2451 ha_warning("Proxy '%s' : 'insecure-fork-wanted' not enabled in the global section, '%s' will likely fail.\n",
2452 curproxy->id, "option external-check");
2453 err_code |= ERR_WARN;
2454 }
Simon Horman98637e52014-06-20 12:30:16 +09002455 }
2456
Simon Horman64e34162015-02-06 11:11:57 +09002457 if (curproxy->email_alert.set) {
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002458 if (!(curproxy->email_alert.mailers.name && curproxy->email_alert.from && curproxy->email_alert.to)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002459 ha_warning("config : 'email-alert' will be ignored for %s '%s' (the presence any of "
2460 "'email-alert from', 'email-alert level' 'email-alert mailers', "
2461 "'email-alert myhostname', or 'email-alert to' "
2462 "requires each of 'email-alert from', 'email-alert mailers' and 'email-alert to' "
2463 "to be present).\n",
2464 proxy_type_str(curproxy), curproxy->id);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002465 err_code |= ERR_WARN;
2466 free_email_alert(curproxy);
2467 }
2468 if (!curproxy->email_alert.myhostname)
Cyril Bontée22bfd62015-12-04 03:07:07 +01002469 curproxy->email_alert.myhostname = strdup(hostname);
Simon Horman9dc49962015-01-30 11:22:59 +09002470 }
2471
Simon Horman98637e52014-06-20 12:30:16 +09002472 if (curproxy->check_command) {
2473 int clear = 0;
2474 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002475 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2476 "external-check command", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002477 err_code |= ERR_WARN;
2478 clear = 1;
2479 }
2480 if (curproxy->check_command[0] != '/' && !curproxy->check_path) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002481 ha_alert("Proxy '%s': '%s' does not have a leading '/' and 'external-check path' is not set.\n",
2482 curproxy->id, "external-check command");
Simon Horman98637e52014-06-20 12:30:16 +09002483 cfgerr++;
2484 }
2485 if (clear) {
2486 free(curproxy->check_command);
2487 curproxy->check_command = NULL;
2488 }
2489 }
2490
2491 if (curproxy->check_path) {
2492 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002493 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2494 "external-check path", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002495 err_code |= ERR_WARN;
2496 free(curproxy->check_path);
2497 curproxy->check_path = NULL;
2498 }
2499 }
2500
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002501 /* if a default backend was specified, let's find it */
2502 if (curproxy->defbe.name) {
2503 struct proxy *target;
2504
Willy Tarreauafb39922015-05-26 12:04:09 +02002505 target = proxy_be_by_name(curproxy->defbe.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002506 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002507 ha_alert("Proxy '%s': unable to find required default_backend: '%s'.\n",
2508 curproxy->id, curproxy->defbe.name);
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002509 cfgerr++;
2510 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002511 ha_alert("Proxy '%s': loop detected for default_backend: '%s'.\n",
2512 curproxy->id, curproxy->defbe.name);
Willy Tarreaubb925012009-07-23 13:36:36 +02002513 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002514 } else if (target->mode != curproxy->mode &&
2515 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2516
Christopher Faulet767a84b2017-11-24 16:50:31 +01002517 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) as its default backend (see 'mode').\n",
2518 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2519 curproxy->conf.file, curproxy->conf.line,
2520 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2521 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002522 cfgerr++;
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002523 } else {
2524 free(curproxy->defbe.name);
2525 curproxy->defbe.be = target;
Willy Tarreauff678132012-02-13 14:32:34 +01002526 /* Emit a warning if this proxy also has some servers */
2527 if (curproxy->srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002528 ha_warning("In proxy '%s', the 'default_backend' rule always has precedence over the servers, which will never be used.\n",
2529 curproxy->id);
Willy Tarreauff678132012-02-13 14:32:34 +01002530 err_code |= ERR_WARN;
2531 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002532 }
2533 }
2534
Willy Tarreau55ea7572007-06-17 19:56:27 +02002535 /* find the target proxy for 'use_backend' rules */
2536 list_for_each_entry(rule, &curproxy->switching_rules, list) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002537 struct proxy *target;
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002538 struct logformat_node *node;
2539 char *pxname;
2540
2541 /* Try to parse the string as a log format expression. If the result
2542 * of the parsing is only one entry containing a simple string, then
2543 * it's a standard string corresponding to a static rule, thus the
2544 * parsing is cancelled and be.name is restored to be resolved.
2545 */
2546 pxname = rule->be.name;
2547 LIST_INIT(&rule->be.expr);
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +01002548 curproxy->conf.args.ctx = ARGC_UBK;
2549 curproxy->conf.args.file = rule->file;
2550 curproxy->conf.args.line = rule->line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002551 err = NULL;
2552 if (!parse_logformat_string(pxname, curproxy, &rule->be.expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002553 ha_alert("Parsing [%s:%d]: failed to parse use_backend rule '%s' : %s.\n",
2554 rule->file, rule->line, pxname, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002555 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002556 cfgerr++;
2557 continue;
2558 }
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002559 node = LIST_NEXT(&rule->be.expr, struct logformat_node *, list);
2560
2561 if (!LIST_ISEMPTY(&rule->be.expr)) {
2562 if (node->type != LOG_FMT_TEXT || node->list.n != &rule->be.expr) {
2563 rule->dynamic = 1;
2564 free(pxname);
2565 continue;
2566 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02002567 /* Only one element in the list, a simple string: free the expression and
2568 * fall back to static rule
2569 */
2570 LIST_DEL(&node->list);
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002571 free(node->arg);
2572 free(node);
2573 }
2574
2575 rule->dynamic = 0;
2576 rule->be.name = pxname;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002577
Willy Tarreauafb39922015-05-26 12:04:09 +02002578 target = proxy_be_by_name(rule->be.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002579 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002580 ha_alert("Proxy '%s': unable to find required use_backend: '%s'.\n",
2581 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002582 cfgerr++;
2583 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002584 ha_alert("Proxy '%s': loop detected for use_backend: '%s'.\n",
2585 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002586 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002587 } else if (target->mode != curproxy->mode &&
2588 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2589
Christopher Faulet767a84b2017-11-24 16:50:31 +01002590 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) in a 'use_backend' rule (see 'mode').\n",
2591 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2592 curproxy->conf.file, curproxy->conf.line,
2593 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2594 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002595 cfgerr++;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002596 } else {
2597 free((void *)rule->be.name);
2598 rule->be.backend = target;
2599 }
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002600 }
2601
Willy Tarreau64ab6072014-09-16 12:17:36 +02002602 /* find the target server for 'use_server' rules */
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002603 list_for_each_entry(srule, &curproxy->server_rules, list) {
Jerome Magnin824186b2020-03-29 09:37:12 +02002604 struct server *target;
2605 struct logformat_node *node;
2606 char *server_name;
2607
2608 /* We try to parse the string as a log format expression. If the result of the parsing
2609 * is only one entry containing a single string, then it's a standard string corresponding
2610 * to a static rule, thus the parsing is cancelled and we fall back to setting srv.ptr.
2611 */
2612 server_name = srule->srv.name;
2613 LIST_INIT(&srule->expr);
2614 curproxy->conf.args.ctx = ARGC_USRV;
2615 err = NULL;
2616 if (!parse_logformat_string(server_name, curproxy, &srule->expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
2617 ha_alert("Parsing [%s:%d]; use-server rule failed to parse log-format '%s' : %s.\n",
2618 srule->file, srule->line, server_name, err);
2619 free(err);
2620 cfgerr++;
2621 continue;
2622 }
2623 node = LIST_NEXT(&srule->expr, struct logformat_node *, list);
2624
2625 if (!LIST_ISEMPTY(&srule->expr)) {
2626 if (node->type != LOG_FMT_TEXT || node->list.n != &srule->expr) {
2627 srule->dynamic = 1;
2628 free(server_name);
2629 continue;
2630 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02002631 /* Only one element in the list, a simple string: free the expression and
2632 * fall back to static rule
2633 */
2634 LIST_DEL(&node->list);
Jerome Magnin824186b2020-03-29 09:37:12 +02002635 free(node->arg);
2636 free(node);
2637 }
2638
2639 srule->dynamic = 0;
2640 srule->srv.name = server_name;
2641 target = findserver(curproxy, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002642
2643 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002644 ha_alert("config : %s '%s' : unable to find server '%s' referenced in a 'use-server' rule.\n",
2645 proxy_type_str(curproxy), curproxy->id, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002646 cfgerr++;
2647 continue;
2648 }
2649 free((void *)srule->srv.name);
2650 srule->srv.ptr = target;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002651 }
2652
Emeric Brunb982a3d2010-01-04 15:45:53 +01002653 /* find the target table for 'stick' rules */
2654 list_for_each_entry(mrule, &curproxy->sticking_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002655 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002656
Emeric Brun1d33b292010-01-04 15:47:17 +01002657 curproxy->be_req_ana |= AN_REQ_STICKING_RULES;
2658 if (mrule->flags & STK_IS_STORE)
2659 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2660
Emeric Brunb982a3d2010-01-04 15:45:53 +01002661 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002662 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002663 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002664 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002665
2666 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002667 ha_alert("Proxy '%s': unable to find stick-table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01002668 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002669 cfgerr++;
2670 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002671 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002672 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2673 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002674 cfgerr++;
2675 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002676 else if (target->proxy && curproxy->bind_proc & ~target->proxy->bind_proc) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002677 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2678 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002679 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002680 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002681 else {
2682 free((void *)mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002683 mrule->table.t = target;
2684 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Thayne McCombs92149f92020-11-20 01:28:26 -07002685 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_KEY, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02002686 if (!in_proxies_list(target->proxies_list, curproxy)) {
2687 curproxy->next_stkt_ref = target->proxies_list;
2688 target->proxies_list = curproxy;
2689 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002690 }
2691 }
2692
2693 /* find the target table for 'store response' rules */
2694 list_for_each_entry(mrule, &curproxy->storersp_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002695 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002696
Emeric Brun1d33b292010-01-04 15:47:17 +01002697 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2698
Emeric Brunb982a3d2010-01-04 15:45:53 +01002699 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002700 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002701 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002702 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002703
2704 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002705 ha_alert("Proxy '%s': unable to find store table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01002706 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002707 cfgerr++;
2708 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002709 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002710 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2711 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002712 cfgerr++;
2713 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002714 else if (target->proxy && (curproxy->bind_proc & ~target->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002715 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2716 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002717 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002718 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002719 else {
2720 free((void *)mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002721 mrule->table.t = target;
2722 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Thayne McCombs92149f92020-11-20 01:28:26 -07002723 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_KEY, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02002724 if (!in_proxies_list(target->proxies_list, curproxy)) {
2725 curproxy->next_stkt_ref = target->proxies_list;
2726 target->proxies_list = curproxy;
2727 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002728 }
2729 }
2730
Christopher Faulete4e830d2017-09-18 14:51:41 +02002731 /* check validity for 'tcp-request' layer 4 rules */
2732 list_for_each_entry(arule, &curproxy->tcp_req.l4_rules, list) {
2733 err = NULL;
2734 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002735 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002736 free(err);
Willy Tarreau5f53de72012-12-12 00:25:44 +01002737 cfgerr++;
2738 }
Willy Tarreaud1f96522010-08-03 19:34:32 +02002739 }
2740
Christopher Faulete4e830d2017-09-18 14:51:41 +02002741 /* check validity for 'tcp-request' layer 5 rules */
2742 list_for_each_entry(arule, &curproxy->tcp_req.l5_rules, list) {
2743 err = NULL;
2744 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002745 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002746 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002747 cfgerr++;
2748 }
2749 }
2750
Christopher Faulete4e830d2017-09-18 14:51:41 +02002751 /* check validity for 'tcp-request' layer 6 rules */
2752 list_for_each_entry(arule, &curproxy->tcp_req.inspect_rules, list) {
2753 err = NULL;
2754 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002755 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002756 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002757 cfgerr++;
2758 }
2759 }
2760
Christopher Faulete4e830d2017-09-18 14:51:41 +02002761 /* check validity for 'http-request' layer 7 rules */
2762 list_for_each_entry(arule, &curproxy->http_req_rules, list) {
2763 err = NULL;
2764 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002765 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002766 free(err);
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002767 cfgerr++;
2768 }
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002769 }
2770
Christopher Faulete4e830d2017-09-18 14:51:41 +02002771 /* check validity for 'http-response' layer 7 rules */
2772 list_for_each_entry(arule, &curproxy->http_res_rules, list) {
2773 err = NULL;
2774 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002775 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002776 free(err);
Willy Tarreau09448f72014-06-25 18:12:15 +02002777 cfgerr++;
2778 }
Willy Tarreau09448f72014-06-25 18:12:15 +02002779 }
2780
Christopher Faulet6d0c3df2020-01-22 09:26:35 +01002781 /* check validity for 'http-after-response' layer 7 rules */
2782 list_for_each_entry(arule, &curproxy->http_after_res_rules, list) {
2783 err = NULL;
2784 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
2785 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
2786 free(err);
2787 cfgerr++;
2788 }
2789 }
2790
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002791 if (curproxy->table && curproxy->table->peers.name) {
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002792 struct peers *curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002793
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002794 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002795 if (strcmp(curpeers->id, curproxy->table->peers.name) == 0) {
2796 free((void *)curproxy->table->peers.name);
2797 curproxy->table->peers.p = curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002798 break;
2799 }
2800 }
2801
2802 if (!curpeers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002803 ha_alert("Proxy '%s': unable to find sync peers '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002804 curproxy->id, curproxy->table->peers.name);
2805 free((void *)curproxy->table->peers.name);
2806 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002807 cfgerr++;
2808 }
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02002809 else if (curpeers->disabled) {
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002810 /* silently disable this peers section */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002811 curproxy->table->peers.p = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002812 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002813 else if (!curpeers->peers_fe) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002814 ha_alert("Proxy '%s': unable to find local peer '%s' in peers section '%s'.\n",
2815 curproxy->id, localpeer, curpeers->id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002816 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002817 cfgerr++;
2818 }
2819 }
2820
Simon Horman9dc49962015-01-30 11:22:59 +09002821
2822 if (curproxy->email_alert.mailers.name) {
2823 struct mailers *curmailers = mailers;
2824
2825 for (curmailers = mailers; curmailers; curmailers = curmailers->next) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002826 if (strcmp(curmailers->id, curproxy->email_alert.mailers.name) == 0)
Simon Horman9dc49962015-01-30 11:22:59 +09002827 break;
Simon Horman9dc49962015-01-30 11:22:59 +09002828 }
Simon Horman9dc49962015-01-30 11:22:59 +09002829 if (!curmailers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002830 ha_alert("Proxy '%s': unable to find mailers '%s'.\n",
2831 curproxy->id, curproxy->email_alert.mailers.name);
Simon Horman9dc49962015-01-30 11:22:59 +09002832 free_email_alert(curproxy);
2833 cfgerr++;
2834 }
Christopher Faulet0108bb32017-10-20 21:34:32 +02002835 else {
2836 err = NULL;
2837 if (init_email_alert(curmailers, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002838 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulet0108bb32017-10-20 21:34:32 +02002839 free(err);
2840 cfgerr++;
2841 }
2842 }
Simon Horman9dc49962015-01-30 11:22:59 +09002843 }
2844
Willy Tarreauee4f5f82019-10-09 09:59:22 +02002845 if (curproxy->uri_auth && curproxy->uri_auth != defproxy.uri_auth &&
Willy Tarreauff011f22011-01-06 17:51:27 +01002846 !LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules) &&
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002847 (curproxy->uri_auth->userlist || curproxy->uri_auth->auth_realm )) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002848 ha_alert("%s '%s': stats 'auth'/'realm' and 'http-request' can't be used at the same time.\n",
2849 "proxy", curproxy->id);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002850 cfgerr++;
2851 goto out_uri_auth_compat;
2852 }
2853
Willy Tarreauee4f5f82019-10-09 09:59:22 +02002854 if (curproxy->uri_auth && curproxy->uri_auth->userlist &&
2855 (curproxy->uri_auth != defproxy.uri_auth ||
2856 LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules))) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002857 const char *uri_auth_compat_req[10];
Thierry FOURNIERa28a9422015-08-04 19:35:46 +02002858 struct act_rule *rule;
Willy Tarreau95fa4692010-02-01 13:05:50 +01002859 int i = 0;
Willy Tarreau95fa4692010-02-01 13:05:50 +01002860 /* build the ACL condition from scratch. We're relying on anonymous ACLs for that */
2861 uri_auth_compat_req[i++] = "auth";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002862
2863 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002864 uri_auth_compat_req[i++] = "realm";
2865 uri_auth_compat_req[i++] = curproxy->uri_auth->auth_realm;
2866 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002867
Willy Tarreau95fa4692010-02-01 13:05:50 +01002868 uri_auth_compat_req[i++] = "unless";
2869 uri_auth_compat_req[i++] = "{";
2870 uri_auth_compat_req[i++] = "http_auth(.internal-stats-userlist)";
2871 uri_auth_compat_req[i++] = "}";
2872 uri_auth_compat_req[i++] = "";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002873
Willy Tarreauff011f22011-01-06 17:51:27 +01002874 rule = parse_http_req_cond(uri_auth_compat_req, "internal-stats-auth-compat", 0, curproxy);
2875 if (!rule) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002876 cfgerr++;
2877 break;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002878 }
2879
Willy Tarreauff011f22011-01-06 17:51:27 +01002880 LIST_ADDQ(&curproxy->uri_auth->http_req_rules, &rule->list);
Willy Tarreau95fa4692010-02-01 13:05:50 +01002881
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002882 if (curproxy->uri_auth->auth_realm) {
2883 free(curproxy->uri_auth->auth_realm);
2884 curproxy->uri_auth->auth_realm = NULL;
2885 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002886 }
2887out_uri_auth_compat:
2888
Dragan Dosen43885c72015-10-01 13:18:13 +02002889 /* check whether we have a log server that uses RFC5424 log format */
Dragan Dosen1322d092015-09-22 16:05:32 +02002890 list_for_each_entry(tmplogsrv, &curproxy->logsrvs, list) {
Dragan Dosen43885c72015-10-01 13:18:13 +02002891 if (tmplogsrv->format == LOG_FORMAT_RFC5424) {
2892 if (!curproxy->conf.logformat_sd_string) {
2893 /* set the default logformat_sd_string */
2894 curproxy->conf.logformat_sd_string = default_rfc5424_sd_log_format;
2895 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002896 break;
Dragan Dosen1322d092015-09-22 16:05:32 +02002897 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002898 }
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02002899
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002900 /* compile the log format */
2901 if (!(curproxy->cap & PR_CAP_FE)) {
Willy Tarreau62a61232013-04-12 18:13:46 +02002902 if (curproxy->conf.logformat_string != default_http_log_format &&
2903 curproxy->conf.logformat_string != default_tcp_log_format &&
2904 curproxy->conf.logformat_string != clf_http_log_format)
2905 free(curproxy->conf.logformat_string);
2906 curproxy->conf.logformat_string = NULL;
2907 free(curproxy->conf.lfs_file);
2908 curproxy->conf.lfs_file = NULL;
2909 curproxy->conf.lfs_line = 0;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002910
2911 if (curproxy->conf.logformat_sd_string != default_rfc5424_sd_log_format)
2912 free(curproxy->conf.logformat_sd_string);
2913 curproxy->conf.logformat_sd_string = NULL;
2914 free(curproxy->conf.lfsd_file);
2915 curproxy->conf.lfsd_file = NULL;
2916 curproxy->conf.lfsd_line = 0;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002917 }
2918
Willy Tarreau62a61232013-04-12 18:13:46 +02002919 if (curproxy->conf.logformat_string) {
2920 curproxy->conf.args.ctx = ARGC_LOG;
2921 curproxy->conf.args.file = curproxy->conf.lfs_file;
2922 curproxy->conf.args.line = curproxy->conf.lfs_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002923 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02002924 if (!parse_logformat_string(curproxy->conf.logformat_string, curproxy, &curproxy->logformat,
2925 LOG_OPT_MANDATORY|LOG_OPT_MERGE_SPACES,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002926 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002927 ha_alert("Parsing [%s:%d]: failed to parse log-format : %s.\n",
2928 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002929 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002930 cfgerr++;
2931 }
Willy Tarreau62a61232013-04-12 18:13:46 +02002932 curproxy->conf.args.file = NULL;
2933 curproxy->conf.args.line = 0;
2934 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002935
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002936 if (curproxy->conf.logformat_sd_string) {
2937 curproxy->conf.args.ctx = ARGC_LOGSD;
2938 curproxy->conf.args.file = curproxy->conf.lfsd_file;
2939 curproxy->conf.args.line = curproxy->conf.lfsd_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002940 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02002941 if (!parse_logformat_string(curproxy->conf.logformat_sd_string, curproxy, &curproxy->logformat_sd,
2942 LOG_OPT_MANDATORY|LOG_OPT_MERGE_SPACES,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002943 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002944 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
2945 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002946 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002947 cfgerr++;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002948 } else if (!add_to_logformat_list(NULL, NULL, LF_SEPARATOR, &curproxy->logformat_sd, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002949 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
2950 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002951 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002952 cfgerr++;
2953 }
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002954 curproxy->conf.args.file = NULL;
2955 curproxy->conf.args.line = 0;
2956 }
2957
Willy Tarreau62a61232013-04-12 18:13:46 +02002958 if (curproxy->conf.uniqueid_format_string) {
2959 curproxy->conf.args.ctx = ARGC_UIF;
2960 curproxy->conf.args.file = curproxy->conf.uif_file;
2961 curproxy->conf.args.line = curproxy->conf.uif_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002962 err = NULL;
Dragan Dosen1e3b16f2020-06-23 18:16:44 +02002963 if (!parse_logformat_string(curproxy->conf.uniqueid_format_string, curproxy, &curproxy->format_unique_id,
2964 LOG_OPT_HTTP|LOG_OPT_MERGE_SPACES,
2965 (curproxy->cap & PR_CAP_FE) ? SMP_VAL_FE_HRQ_HDR
2966 : SMP_VAL_BE_HRQ_HDR,
2967 &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002968 ha_alert("Parsing [%s:%d]: failed to parse unique-id : %s.\n",
2969 curproxy->conf.uif_file, curproxy->conf.uif_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002970 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002971 cfgerr++;
2972 }
Willy Tarreau62a61232013-04-12 18:13:46 +02002973 curproxy->conf.args.file = NULL;
2974 curproxy->conf.args.line = 0;
2975 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002976
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002977 /* only now we can check if some args remain unresolved.
2978 * This must be done after the users and groups resolution.
2979 */
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002980 cfgerr += smp_resolve_args(curproxy);
2981 if (!cfgerr)
2982 cfgerr += acl_find_targets(curproxy);
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01002983
Willy Tarreau2738a142006-07-08 17:28:09 +02002984 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002985 (((curproxy->cap & PR_CAP_FE) && !curproxy->timeout.client) ||
Willy Tarreaud825eef2007-05-12 22:35:00 +02002986 ((curproxy->cap & PR_CAP_BE) && (curproxy->srv) &&
Willy Tarreauce887fd2012-05-12 12:50:00 +02002987 (!curproxy->timeout.connect ||
2988 (!curproxy->timeout.server && (curproxy->mode == PR_MODE_HTTP || !curproxy->timeout.tunnel)))))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002989 ha_warning("config : missing timeouts for %s '%s'.\n"
2990 " | While not properly invalid, you will certainly encounter various problems\n"
2991 " | with such a configuration. To fix this, please ensure that all following\n"
2992 " | timeouts are set to a non-zero value: 'client', 'connect', 'server'.\n",
2993 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002994 err_code |= ERR_WARN;
Willy Tarreau2738a142006-07-08 17:28:09 +02002995 }
Willy Tarreauf3c69202006-07-09 16:42:34 +02002996
Willy Tarreau1fa31262007-12-03 00:36:16 +01002997 /* Historically, the tarpit and queue timeouts were inherited from contimeout.
2998 * We must still support older configurations, so let's find out whether those
2999 * parameters have been set or must be copied from contimeouts.
3000 */
3001 if (curproxy != &defproxy) {
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003002 if (!curproxy->timeout.tarpit ||
3003 curproxy->timeout.tarpit == defproxy.timeout.tarpit) {
Willy Tarreau1fa31262007-12-03 00:36:16 +01003004 /* tarpit timeout not set. We search in the following order:
3005 * default.tarpit, curr.connect, default.connect.
3006 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003007 if (defproxy.timeout.tarpit)
Willy Tarreau1fa31262007-12-03 00:36:16 +01003008 curproxy->timeout.tarpit = defproxy.timeout.tarpit;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003009 else if (curproxy->timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003010 curproxy->timeout.tarpit = curproxy->timeout.connect;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003011 else if (defproxy.timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003012 curproxy->timeout.tarpit = defproxy.timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01003013 }
3014 if ((curproxy->cap & PR_CAP_BE) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003015 (!curproxy->timeout.queue ||
3016 curproxy->timeout.queue == defproxy.timeout.queue)) {
Willy Tarreau1fa31262007-12-03 00:36:16 +01003017 /* queue timeout not set. We search in the following order:
3018 * default.queue, curr.connect, default.connect.
3019 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003020 if (defproxy.timeout.queue)
Willy Tarreau1fa31262007-12-03 00:36:16 +01003021 curproxy->timeout.queue = defproxy.timeout.queue;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003022 else if (curproxy->timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003023 curproxy->timeout.queue = curproxy->timeout.connect;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003024 else if (defproxy.timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003025 curproxy->timeout.queue = defproxy.timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01003026 }
3027 }
3028
Christopher Faulete5870d82020-04-15 11:32:03 +02003029 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_TCP_RS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003030 ha_warning("config : %s '%s' uses tcp-check rules without 'option tcp-check', so the rules are ignored.\n",
3031 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau215663d2014-06-13 18:30:23 +02003032 err_code |= ERR_WARN;
3033 }
3034
Willy Tarreau193b8c62012-11-22 00:17:38 +01003035 /* ensure that cookie capture length is not too large */
3036 if (curproxy->capture_len >= global.tune.cookie_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003037 ha_warning("config : truncating capture length to %d bytes for %s '%s'.\n",
3038 global.tune.cookie_len - 1, proxy_type_str(curproxy), curproxy->id);
Willy Tarreau193b8c62012-11-22 00:17:38 +01003039 err_code |= ERR_WARN;
3040 curproxy->capture_len = global.tune.cookie_len - 1;
3041 }
3042
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003043 /* The small pools required for the capture lists */
Willy Tarreau9a54e132012-03-24 08:33:05 +01003044 if (curproxy->nb_req_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003045 curproxy->req_cap_pool = create_pool("ptrcap",
3046 curproxy->nb_req_cap * sizeof(char *),
3047 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003048 }
3049
3050 if (curproxy->nb_rsp_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003051 curproxy->rsp_cap_pool = create_pool("ptrcap",
3052 curproxy->nb_rsp_cap * sizeof(char *),
3053 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003054 }
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003055
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003056 switch (curproxy->load_server_state_from_file) {
3057 case PR_SRV_STATE_FILE_UNSPEC:
3058 curproxy->load_server_state_from_file = PR_SRV_STATE_FILE_NONE;
3059 break;
3060 case PR_SRV_STATE_FILE_GLOBAL:
3061 if (!global.server_state_file) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003062 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",
3063 curproxy->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003064 err_code |= ERR_WARN;
3065 }
3066 break;
3067 }
3068
Willy Tarreaubaaee002006-06-26 02:48:02 +02003069 /* first, we will invert the servers list order */
3070 newsrv = NULL;
3071 while (curproxy->srv) {
3072 struct server *next;
3073
3074 next = curproxy->srv->next;
3075 curproxy->srv->next = newsrv;
3076 newsrv = curproxy->srv;
3077 if (!next)
3078 break;
3079 curproxy->srv = next;
3080 }
3081
Willy Tarreau17edc812014-01-03 12:14:34 +01003082 /* Check that no server name conflicts. This causes trouble in the stats.
3083 * We only emit a warning for the first conflict affecting each server,
3084 * in order to avoid combinatory explosion if all servers have the same
3085 * name. We do that only for servers which do not have an explicit ID,
3086 * because these IDs were made also for distinguishing them and we don't
3087 * want to annoy people who correctly manage them.
3088 */
3089 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3090 struct server *other_srv;
3091
3092 if (newsrv->puid)
3093 continue;
3094
3095 for (other_srv = curproxy->srv; other_srv && other_srv != newsrv; other_srv = other_srv->next) {
3096 if (!other_srv->puid && strcmp(other_srv->id, newsrv->id) == 0) {
Willy Tarreaub01302f2019-05-27 19:31:06 +02003097 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 +01003098 newsrv->conf.file, newsrv->conf.line,
3099 proxy_type_str(curproxy), curproxy->id,
3100 newsrv->id, other_srv->conf.line);
Willy Tarreaub01302f2019-05-27 19:31:06 +02003101 cfgerr++;
Willy Tarreau17edc812014-01-03 12:14:34 +01003102 break;
3103 }
3104 }
3105 }
3106
Willy Tarreaudd701652010-05-25 23:03:02 +02003107 /* assign automatic UIDs to servers which don't have one yet */
3108 next_id = 1;
3109 newsrv = curproxy->srv;
3110 while (newsrv != NULL) {
3111 if (!newsrv->puid) {
3112 /* server ID not set, use automatic numbering with first
3113 * spare entry starting with next_svid.
3114 */
3115 next_id = get_next_id(&curproxy->conf.used_server_id, next_id);
3116 newsrv->conf.id.key = newsrv->puid = next_id;
3117 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Frédéric Lécaille84d60462019-05-17 14:29:15 +02003118 newsrv->conf.name.key = newsrv->id;
3119 ebis_insert(&curproxy->conf.used_server_name, &newsrv->conf.name);
Willy Tarreaudd701652010-05-25 23:03:02 +02003120 }
3121 next_id++;
3122 newsrv = newsrv->next;
3123 }
3124
Willy Tarreau20697042007-11-15 23:26:18 +01003125 curproxy->lbprm.wmult = 1; /* default weight multiplier */
Willy Tarreau5dc2fa62007-11-19 19:10:18 +01003126 curproxy->lbprm.wdiv = 1; /* default weight divider */
Willy Tarreaubaaee002006-06-26 02:48:02 +02003127
Willy Tarreau62c3be22012-01-20 13:12:32 +01003128 /*
3129 * If this server supports a maxconn parameter, it needs a dedicated
3130 * tasks to fill the emptied slots when a connection leaves.
3131 * Also, resolve deferred tracking dependency if needed.
3132 */
3133 newsrv = curproxy->srv;
3134 while (newsrv != NULL) {
3135 if (newsrv->minconn > newsrv->maxconn) {
3136 /* Only 'minconn' was specified, or it was higher than or equal
3137 * to 'maxconn'. Let's turn this into maxconn and clean it, as
3138 * this will avoid further useless expensive computations.
3139 */
3140 newsrv->maxconn = newsrv->minconn;
3141 } else if (newsrv->maxconn && !newsrv->minconn) {
3142 /* minconn was not specified, so we set it to maxconn */
3143 newsrv->minconn = newsrv->maxconn;
3144 }
3145
William Dauchyf6370442020-11-14 19:25:33 +01003146 /* this will also properly set the transport layer for
3147 * prod and checks
3148 * if default-server have use_ssl, prerare ssl init
3149 * without activating it */
3150 if (newsrv->use_ssl == 1 || newsrv->check.use_ssl == 1 ||
3151 (newsrv->proxy->options & PR_O_TCPCHK_SSL) ||
3152 (newsrv->use_ssl != 1 && curproxy->defsrv.use_ssl == 1)) {
Willy Tarreau17d45382016-12-22 21:16:08 +01003153 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
3154 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(newsrv);
3155 }
Emeric Brun94324a42012-10-11 14:00:19 +02003156
Willy Tarreau034c88c2017-01-23 23:36:45 +01003157 if ((newsrv->flags & SRV_F_FASTOPEN) &&
3158 ((curproxy->retry_type & (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)) !=
3159 (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)))
3160 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",
3161 newsrv->conf.file, newsrv->conf.line,
3162 proxy_type_str(curproxy), curproxy->id,
3163 newsrv->id);
3164
Willy Tarreau62c3be22012-01-20 13:12:32 +01003165 if (newsrv->trackit) {
3166 struct proxy *px;
Willy Tarreau32091232014-05-16 13:52:00 +02003167 struct server *srv, *loop;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003168 char *pname, *sname;
3169
3170 pname = newsrv->trackit;
3171 sname = strrchr(pname, '/');
3172
3173 if (sname)
3174 *sname++ = '\0';
3175 else {
3176 sname = pname;
3177 pname = NULL;
3178 }
3179
3180 if (pname) {
Willy Tarreau9e0bb102015-05-26 11:24:42 +02003181 px = proxy_be_by_name(pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003182 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003183 ha_alert("config : %s '%s', server '%s': unable to find required proxy '%s' for tracking.\n",
3184 proxy_type_str(curproxy), curproxy->id,
3185 newsrv->id, pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003186 cfgerr++;
3187 goto next_srv;
3188 }
3189 } else
3190 px = curproxy;
3191
3192 srv = findserver(px, sname);
3193 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003194 ha_alert("config : %s '%s', server '%s': unable to find required server '%s' for tracking.\n",
3195 proxy_type_str(curproxy), curproxy->id,
3196 newsrv->id, sname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003197 cfgerr++;
3198 goto next_srv;
3199 }
3200
Christopher Faulet8892e5d2020-03-26 19:48:20 +01003201 if (!srv->do_check && !srv->do_agent && !srv->track && !srv->trackit) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003202 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for "
3203 "tracking as it does not have any check nor agent enabled.\n",
3204 proxy_type_str(curproxy), curproxy->id,
3205 newsrv->id, px->id, srv->id);
Willy Tarreau32091232014-05-16 13:52:00 +02003206 cfgerr++;
3207 goto next_srv;
3208 }
3209
3210 for (loop = srv->track; loop && loop != newsrv; loop = loop->track);
3211
Frédéric Lécaille2efc6492017-03-14 14:32:17 +01003212 if (newsrv == srv || loop) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003213 ha_alert("config : %s '%s', server '%s': unable to track %s/%s as it "
3214 "belongs to a tracking chain looping back to %s/%s.\n",
3215 proxy_type_str(curproxy), curproxy->id,
3216 newsrv->id, px->id, srv->id, px->id,
3217 newsrv == srv ? srv->id : loop->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003218 cfgerr++;
3219 goto next_srv;
3220 }
3221
3222 if (curproxy != px &&
3223 (curproxy->options & PR_O_DISABLE404) != (px->options & PR_O_DISABLE404)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003224 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for"
3225 "tracking: disable-on-404 option inconsistency.\n",
3226 proxy_type_str(curproxy), curproxy->id,
3227 newsrv->id, px->id, srv->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003228 cfgerr++;
3229 goto next_srv;
3230 }
3231
Willy Tarreau62c3be22012-01-20 13:12:32 +01003232 newsrv->track = srv;
Willy Tarreau1a53a3a2013-12-11 15:27:05 +01003233 newsrv->tracknext = srv->trackers;
3234 srv->trackers = newsrv;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003235
3236 free(newsrv->trackit);
3237 newsrv->trackit = NULL;
3238 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003239
Willy Tarreau62c3be22012-01-20 13:12:32 +01003240 next_srv:
3241 newsrv = newsrv->next;
3242 }
3243
Olivier Houchard4e694042017-03-14 20:01:29 +01003244 /*
3245 * Try to generate dynamic cookies for servers now.
3246 * It couldn't be done earlier, since at the time we parsed
3247 * the server line, we may not have known yet that we
3248 * should use dynamic cookies, or the secret key may not
3249 * have been provided yet.
3250 */
3251 if (curproxy->ck_opts & PR_CK_DYNAMIC) {
3252 newsrv = curproxy->srv;
3253 while (newsrv != NULL) {
3254 srv_set_dyncookie(newsrv);
3255 newsrv = newsrv->next;
3256 }
3257
3258 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003259 /* We have to initialize the server lookup mechanism depending
Joseph Herlanta14c03e2018-11-15 14:04:19 -08003260 * on what LB algorithm was chosen.
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003261 */
3262
3263 curproxy->lbprm.algo &= ~(BE_LB_LKUP | BE_LB_PROP_DYN);
3264 switch (curproxy->lbprm.algo & BE_LB_KIND) {
3265 case BE_LB_KIND_RR:
Willy Tarreau9757a382009-10-03 12:56:50 +02003266 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_STATIC) {
3267 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3268 init_server_map(curproxy);
Willy Tarreau760e81d2018-05-03 07:20:40 +02003269 } else if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_RANDOM) {
3270 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3271 chash_init_server_tree(curproxy);
Willy Tarreau9757a382009-10-03 12:56:50 +02003272 } else {
3273 curproxy->lbprm.algo |= BE_LB_LKUP_RRTREE | BE_LB_PROP_DYN;
3274 fwrr_init_server_groups(curproxy);
3275 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003276 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003277
Willy Tarreau3ebb1162012-02-13 16:57:44 +01003278 case BE_LB_KIND_CB:
Willy Tarreauf09c6602012-02-13 17:12:08 +01003279 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_CB_LC) {
3280 curproxy->lbprm.algo |= BE_LB_LKUP_LCTREE | BE_LB_PROP_DYN;
3281 fwlc_init_server_tree(curproxy);
3282 } else {
3283 curproxy->lbprm.algo |= BE_LB_LKUP_FSTREE | BE_LB_PROP_DYN;
3284 fas_init_server_tree(curproxy);
3285 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003286 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003287
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003288 case BE_LB_KIND_HI:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003289 if ((curproxy->lbprm.algo & BE_LB_HASH_TYPE) == BE_LB_HASH_CONS) {
3290 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3291 chash_init_server_tree(curproxy);
3292 } else {
3293 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3294 init_server_map(curproxy);
3295 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003296 break;
3297 }
Willy Tarreaucd10def2020-10-17 18:48:47 +02003298 HA_RWLOCK_INIT(&curproxy->lbprm.lock);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003299
3300 if (curproxy->options & PR_O_LOGASAP)
3301 curproxy->to_log &= ~LW_BYTES;
3302
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003303 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003304 (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->logsrvs) &&
3305 (!LIST_ISEMPTY(&curproxy->logformat) || !LIST_ISEMPTY(&curproxy->logformat_sd))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003306 ha_warning("config : log format ignored for %s '%s' since it has no log address.\n",
3307 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003308 err_code |= ERR_WARN;
3309 }
3310
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003311 if (curproxy->mode != PR_MODE_HTTP) {
3312 int optnum;
3313
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003314 if (curproxy->uri_auth) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003315 ha_warning("config : 'stats' statement ignored for %s '%s' as it requires HTTP mode.\n",
3316 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003317 err_code |= ERR_WARN;
3318 curproxy->uri_auth = NULL;
3319 }
3320
Willy Tarreaude7dc882017-03-10 11:49:21 +01003321 if (curproxy->capture_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003322 ha_warning("config : 'capture' statement ignored for %s '%s' as it requires HTTP mode.\n",
3323 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003324 err_code |= ERR_WARN;
3325 }
3326
3327 if (!LIST_ISEMPTY(&curproxy->http_req_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003328 ha_warning("config : 'http-request' rules ignored for %s '%s' as they require HTTP mode.\n",
3329 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003330 err_code |= ERR_WARN;
3331 }
3332
3333 if (!LIST_ISEMPTY(&curproxy->http_res_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003334 ha_warning("config : 'http-response' rules ignored for %s '%s' as they require HTTP mode.\n",
3335 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003336 err_code |= ERR_WARN;
3337 }
3338
Willy Tarreaude7dc882017-03-10 11:49:21 +01003339 if (!LIST_ISEMPTY(&curproxy->redirect_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003340 ha_warning("config : 'redirect' rules ignored for %s '%s' as they require HTTP mode.\n",
3341 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003342 err_code |= ERR_WARN;
3343 }
3344
Willy Tarreau87cf5142011-08-19 22:57:24 +02003345 if (curproxy->options & (PR_O_FWDFOR | PR_O_FF_ALWAYS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003346 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3347 "forwardfor", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003348 err_code |= ERR_WARN;
Willy Tarreau87cf5142011-08-19 22:57:24 +02003349 curproxy->options &= ~(PR_O_FWDFOR | PR_O_FF_ALWAYS);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003350 }
3351
3352 if (curproxy->options & PR_O_ORGTO) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003353 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3354 "originalto", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003355 err_code |= ERR_WARN;
3356 curproxy->options &= ~PR_O_ORGTO;
3357 }
3358
3359 for (optnum = 0; cfg_opts[optnum].name; optnum++) {
3360 if (cfg_opts[optnum].mode == PR_MODE_HTTP &&
3361 (curproxy->cap & cfg_opts[optnum].cap) &&
3362 (curproxy->options & cfg_opts[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003363 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3364 cfg_opts[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003365 err_code |= ERR_WARN;
3366 curproxy->options &= ~cfg_opts[optnum].val;
3367 }
3368 }
3369
3370 for (optnum = 0; cfg_opts2[optnum].name; optnum++) {
3371 if (cfg_opts2[optnum].mode == PR_MODE_HTTP &&
3372 (curproxy->cap & cfg_opts2[optnum].cap) &&
3373 (curproxy->options2 & cfg_opts2[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003374 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3375 cfg_opts2[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003376 err_code |= ERR_WARN;
3377 curproxy->options2 &= ~cfg_opts2[optnum].val;
3378 }
3379 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003380
Willy Tarreau29fbe512015-08-20 19:35:14 +02003381#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003382 if (curproxy->conn_src.bind_hdr_occ) {
3383 curproxy->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003384 ha_warning("config : %s '%s' : ignoring use of header %s as source IP in non-HTTP mode.\n",
3385 proxy_type_str(curproxy), curproxy->id, curproxy->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003386 err_code |= ERR_WARN;
3387 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003388#endif
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003389 }
3390
Willy Tarreaubaaee002006-06-26 02:48:02 +02003391 /*
Willy Tarreau21d2af32008-02-14 20:25:24 +01003392 * ensure that we're not cross-dressing a TCP server into HTTP.
3393 */
3394 newsrv = curproxy->srv;
3395 while (newsrv != NULL) {
Willy Tarreau0cec3312011-10-31 13:49:26 +01003396 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->rdr_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003397 ha_alert("config : %s '%s' : server cannot have cookie or redirect prefix in non-HTTP mode.\n",
3398 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003399 cfgerr++;
Willy Tarreau21d2af32008-02-14 20:25:24 +01003400 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003401
Willy Tarreau0cec3312011-10-31 13:49:26 +01003402 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->cklen) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003403 ha_warning("config : %s '%s' : ignoring cookie for server '%s' as HTTP mode is disabled.\n",
3404 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau0cec3312011-10-31 13:49:26 +01003405 err_code |= ERR_WARN;
3406 }
3407
Willy Tarreauc93cd162014-05-13 15:54:22 +02003408 if ((newsrv->flags & SRV_F_MAPPORTS) && (curproxy->options2 & PR_O2_RDPC_PRST)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003409 ha_warning("config : %s '%s' : RDP cookie persistence will not work for server '%s' because it lacks an explicit port number.\n",
3410 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau82ffa392013-08-13 17:19:08 +02003411 err_code |= ERR_WARN;
3412 }
3413
Willy Tarreau29fbe512015-08-20 19:35:14 +02003414#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003415 if (curproxy->mode != PR_MODE_HTTP && newsrv->conn_src.bind_hdr_occ) {
3416 newsrv->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003417 ha_warning("config : %s '%s' : server %s cannot use header %s as source IP in non-HTTP mode.\n",
3418 proxy_type_str(curproxy), curproxy->id, newsrv->id, newsrv->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003419 err_code |= ERR_WARN;
3420 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003421#endif
Willy Tarreau4c183462017-01-06 12:21:38 +01003422
Willy Tarreau46deab62018-04-28 07:18:15 +02003423 if ((curproxy->mode != PR_MODE_HTTP) && (curproxy->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR)
3424 curproxy->options &= ~PR_O_REUSE_MASK;
3425
Willy Tarreau21d2af32008-02-14 20:25:24 +01003426 newsrv = newsrv->next;
3427 }
3428
Christopher Fauletd7c91962015-04-30 11:48:27 +02003429 /* Check filter configuration, if any */
3430 cfgerr += flt_check(curproxy);
3431
Willy Tarreauc1a21672009-08-16 22:37:44 +02003432 if (curproxy->cap & PR_CAP_FE) {
Willy Tarreau050536d2012-10-04 08:47:34 +02003433 if (!curproxy->accept)
3434 curproxy->accept = frontend_accept;
Willy Tarreau81f9aa32010-06-01 17:45:26 +02003435
Willy Tarreauc1a21672009-08-16 22:37:44 +02003436 if (curproxy->tcp_req.inspect_delay ||
3437 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
Willy Tarreaufb356202010-08-03 14:02:05 +02003438 curproxy->fe_req_ana |= AN_REQ_INSPECT_FE;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003439
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003440 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003441 curproxy->fe_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_PROCESS_FE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003442 curproxy->fe_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_FE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003443 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003444
William Lallemandcf62f7e2018-10-26 14:47:40 +02003445 if (curproxy->mode == PR_MODE_CLI) {
3446 curproxy->fe_req_ana |= AN_REQ_WAIT_CLI;
3447 curproxy->fe_rsp_ana |= AN_RES_WAIT_CLI;
3448 }
3449
Willy Tarreauc1a21672009-08-16 22:37:44 +02003450 /* both TCP and HTTP must check switching rules */
3451 curproxy->fe_req_ana |= AN_REQ_SWITCHING_RULES;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003452
3453 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003454 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003455 curproxy->fe_req_ana |= AN_REQ_FLT_START_FE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3456 curproxy->fe_rsp_ana |= AN_RES_FLT_START_FE | AN_RES_FLT_XFER_DATA | AN_RES_FLT_END;
Christopher Faulet309c6412015-12-02 09:57:32 +01003457 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003458 curproxy->fe_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3459 curproxy->fe_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003460 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003461 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003462 }
3463
3464 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreaufb356202010-08-03 14:02:05 +02003465 if (curproxy->tcp_req.inspect_delay ||
3466 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
3467 curproxy->be_req_ana |= AN_REQ_INSPECT_BE;
3468
Emeric Brun97679e72010-09-23 17:56:44 +02003469 if (!LIST_ISEMPTY(&curproxy->tcp_rep.inspect_rules))
3470 curproxy->be_rsp_ana |= AN_RES_INSPECT;
3471
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003472 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003473 curproxy->be_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_INNER | AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003474 curproxy->be_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_BE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003475 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003476
3477 /* If the backend does requires RDP cookie persistence, we have to
3478 * enable the corresponding analyser.
3479 */
3480 if (curproxy->options2 & PR_O2_RDPC_PRST)
3481 curproxy->be_req_ana |= AN_REQ_PRST_RDP_COOKIE;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003482
3483 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003484 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003485 curproxy->be_req_ana |= AN_REQ_FLT_START_BE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3486 curproxy->be_rsp_ana |= AN_RES_FLT_START_BE | AN_RES_FLT_XFER_DATA | AN_RES_FLT_END;
Christopher Faulet309c6412015-12-02 09:57:32 +01003487 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003488 curproxy->be_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3489 curproxy->be_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003490 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003491 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003492 }
Christopher Fauleta717b992018-04-10 14:43:00 +02003493
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003494 /* Check the mux protocols, if any, for each listener and server
Christopher Fauleta717b992018-04-10 14:43:00 +02003495 * attached to the current proxy */
3496 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3497 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003498 const struct mux_proto_list *mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003499
3500 if (!bind_conf->mux_proto)
3501 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003502
3503 /* it is possible that an incorrect mux was referenced
3504 * due to the proxy's mode not being taken into account
3505 * on first pass. Let's adjust it now.
3506 */
3507 mux_ent = conn_get_best_mux_entry(bind_conf->mux_proto->token, PROTO_SIDE_FE, mode);
3508
3509 if (!mux_ent || !isteq(mux_ent->token, bind_conf->mux_proto->token)) {
Christopher Fauleta717b992018-04-10 14:43:00 +02003510 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for 'bind %s' at [%s:%d].\n",
3511 proxy_type_str(curproxy), curproxy->id,
3512 (int)bind_conf->mux_proto->token.len,
3513 bind_conf->mux_proto->token.ptr,
3514 bind_conf->arg, bind_conf->file, bind_conf->line);
3515 cfgerr++;
3516 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003517
3518 /* update the mux */
3519 bind_conf->mux_proto = mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003520 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003521 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3522 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003523 const struct mux_proto_list *mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003524
3525 if (!newsrv->mux_proto)
3526 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003527
3528 /* it is possible that an incorrect mux was referenced
3529 * due to the proxy's mode not being taken into account
3530 * on first pass. Let's adjust it now.
3531 */
3532 mux_ent = conn_get_best_mux_entry(newsrv->mux_proto->token, PROTO_SIDE_BE, mode);
3533
3534 if (!mux_ent || !isteq(mux_ent->token, newsrv->mux_proto->token)) {
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003535 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for server '%s' at [%s:%d].\n",
3536 proxy_type_str(curproxy), curproxy->id,
3537 (int)newsrv->mux_proto->token.len,
3538 newsrv->mux_proto->token.ptr,
3539 newsrv->id, newsrv->conf.file, newsrv->conf.line);
3540 cfgerr++;
3541 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003542
3543 /* update the mux */
3544 newsrv->mux_proto = mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003545 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003546
3547 /* initialize idle conns lists */
3548 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3549 int i;
3550
Willy Tarreauad37c7a2020-07-17 14:18:36 +02003551 newsrv->available_conns = calloc(global.nbthread, sizeof(*newsrv->available_conns));
Willy Tarreau835daa12019-02-07 14:46:29 +01003552
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003553 if (!newsrv->available_conns) {
Willy Tarreau835daa12019-02-07 14:46:29 +01003554 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003555 newsrv->conf.file, newsrv->conf.line, newsrv->id);
Willy Tarreau835daa12019-02-07 14:46:29 +01003556 cfgerr++;
3557 continue;
3558 }
3559
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003560 for (i = 0; i < global.nbthread; i++)
3561 LIST_INIT(&newsrv->available_conns[i]);
Willy Tarreau980855b2019-02-07 14:59:29 +01003562
3563 if (newsrv->max_idle_conns != 0) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003564 if (idle_conn_task == NULL) {
3565 idle_conn_task = task_new(MAX_THREADS_MASK);
3566 if (!idle_conn_task)
3567 goto err;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003568
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003569 idle_conn_task->process = srv_cleanup_idle_connections;
3570 idle_conn_task->context = NULL;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003571
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003572 for (i = 0; i < global.nbthread; i++) {
Willy Tarreau4d82bf52020-06-28 00:19:17 +02003573 idle_conns[i].cleanup_task = task_new(1UL << i);
3574 if (!idle_conns[i].cleanup_task)
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003575 goto err;
Willy Tarreau4d82bf52020-06-28 00:19:17 +02003576 idle_conns[i].cleanup_task->process = srv_cleanup_toremove_connections;
3577 idle_conns[i].cleanup_task->context = NULL;
Olivier Houchardf8f4c2e2020-06-29 20:15:59 +02003578 HA_SPIN_INIT(&idle_conns[i].takeover_lock);
Willy Tarreau4d82bf52020-06-28 00:19:17 +02003579 MT_LIST_INIT(&idle_conns[i].toremove_conns);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003580 }
3581 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003582
Willy Tarreau9b9c1742020-07-17 15:04:53 +02003583 newsrv->idle_conns = calloc((unsigned short)global.nbthread, sizeof(*newsrv->idle_conns));
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003584 if (!newsrv->idle_conns) {
3585 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
3586 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3587 cfgerr++;
3588 continue;
3589 }
3590
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003591 for (i = 0; i < global.nbthread; i++)
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003592 MT_LIST_INIT(&newsrv->idle_conns[i]);
3593
Willy Tarreauad37c7a2020-07-17 14:18:36 +02003594 newsrv->safe_conns = calloc(global.nbthread, sizeof(*newsrv->safe_conns));
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003595 if (!newsrv->safe_conns) {
3596 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
3597 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3598 cfgerr++;
3599 continue;
3600 }
3601
3602 for (i = 0; i < global.nbthread; i++)
3603 MT_LIST_INIT(&newsrv->safe_conns[i]);
3604
Tim Duesterhusb53dd032020-09-12 20:26:42 +02003605 newsrv->curr_idle_thr = calloc(global.nbthread, sizeof(*newsrv->curr_idle_thr));
Olivier Houchardf1314812019-02-18 16:41:17 +01003606 if (!newsrv->curr_idle_thr)
3607 goto err;
Willy Tarreau980855b2019-02-07 14:59:29 +01003608 continue;
3609 err:
3610 ha_alert("parsing [%s:%d] : failed to allocate idle connection tasks for server '%s'.\n",
3611 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3612 cfgerr++;
3613 continue;
3614 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003615 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003616 }
3617
3618 /***********************************************************/
3619 /* At this point, target names have already been resolved. */
3620 /***********************************************************/
3621
3622 /* Check multi-process mode compatibility */
3623
3624 if (global.nbproc > 1 && global.stats_fe) {
3625 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3626 unsigned long mask;
3627
Willy Tarreau6daac192019-02-02 17:39:53 +01003628 mask = proc_mask(global.stats_fe->bind_proc) && all_proc_mask;
Willy Tarreaue26993c2020-09-03 07:18:55 +02003629 mask &= proc_mask(bind_conf->settings.bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003630
3631 /* stop here if more than one process is used */
Willy Tarreau9504dd62018-10-15 09:37:03 +02003632 if (atleast2(mask))
Willy Tarreau419ead82014-09-16 13:41:21 +02003633 break;
3634 }
3635 if (&bind_conf->by_fe != &global.stats_fe->conf.bind) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003636 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 +02003637 }
3638 }
3639
3640 /* Make each frontend inherit bind-process from its listeners when not specified. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003641 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003642 if (curproxy->bind_proc)
3643 continue;
3644
3645 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3646 unsigned long mask;
3647
Willy Tarreaue26993c2020-09-03 07:18:55 +02003648 mask = proc_mask(bind_conf->settings.bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003649 curproxy->bind_proc |= mask;
3650 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003651 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003652 }
3653
3654 if (global.stats_fe) {
3655 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3656 unsigned long mask;
3657
Willy Tarreaue26993c2020-09-03 07:18:55 +02003658 mask = bind_conf->settings.bind_proc ? bind_conf->settings.bind_proc : 0;
Willy Tarreau419ead82014-09-16 13:41:21 +02003659 global.stats_fe->bind_proc |= mask;
3660 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003661 global.stats_fe->bind_proc = proc_mask(global.stats_fe->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003662 }
3663
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003664 /* propagate bindings from frontends to backends. Don't do it if there
3665 * are any fatal errors as we must not call it with unresolved proxies.
3666 */
3667 if (!cfgerr) {
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003668 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003669 if (curproxy->cap & PR_CAP_FE)
3670 propagate_processes(curproxy, NULL);
3671 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003672 }
3673
3674 /* Bind each unbound backend to all processes when not specified. */
Willy Tarreau6daac192019-02-02 17:39:53 +01003675 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
3676 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003677
3678 /*******************************************************/
3679 /* At this step, all proxies have a non-null bind_proc */
3680 /*******************************************************/
3681
3682 /* perform the final checks before creating tasks */
3683
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003684 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003685 struct listener *listener;
3686 unsigned int next_id;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003687
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003688 /* Configure SSL for each bind line.
3689 * Note: if configuration fails at some point, the ->ctx member
3690 * remains NULL so that listeners can later detach.
3691 */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003692 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau55d37912016-12-21 23:38:39 +01003693 if (bind_conf->xprt->prepare_bind_conf &&
3694 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003695 cfgerr++;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003696 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003697
Willy Tarreaue6b98942007-10-29 01:09:36 +01003698 /* adjust this proxy's listeners */
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003699 next_id = 1;
Willy Tarreau4348fad2012-09-20 16:48:07 +02003700 list_for_each_entry(listener, &curproxy->conf.listeners, by_fe) {
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003701 int nbproc;
3702
3703 nbproc = my_popcountl(curproxy->bind_proc &
Willy Tarreaue26993c2020-09-03 07:18:55 +02003704 (listener->bind_conf->settings.bind_proc ? listener->bind_conf->settings.bind_proc : curproxy->bind_proc) &
Willy Tarreaua38a7172019-02-02 17:11:28 +01003705 all_proc_mask);
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003706
3707 if (!nbproc) /* no intersection between listener and frontend */
3708 nbproc = 1;
3709
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003710 if (!listener->luid) {
3711 /* listener ID not set, use automatic numbering with first
3712 * spare entry starting with next_luid.
3713 */
3714 next_id = get_next_id(&curproxy->conf.used_listener_id, next_id);
3715 listener->conf.id.key = listener->luid = next_id;
3716 eb32_insert(&curproxy->conf.used_listener_id, &listener->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003717 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01003718 next_id++;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003719
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003720 /* enable separate counters */
3721 if (curproxy->options2 & PR_O2_SOCKSTAT) {
Willy Tarreauae9bea02016-11-25 14:44:52 +01003722 listener->counters = calloc(1, sizeof(*listener->counters));
Willy Tarreau19d14ef2012-10-29 16:51:55 +01003723 if (!listener->name)
3724 memprintf(&listener->name, "sock-%d", listener->luid);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003725 }
Willy Tarreau81796be2012-09-22 19:11:47 +02003726
Willy Tarreaue6b98942007-10-29 01:09:36 +01003727 if (curproxy->options & PR_O_TCP_NOLING)
3728 listener->options |= LI_O_NOLINGER;
Willy Tarreau16a21472012-11-19 12:39:59 +01003729 if (!listener->maxaccept)
3730 listener->maxaccept = global.tune.maxaccept ? global.tune.maxaccept : 64;
3731
3732 /* we want to have an optimal behaviour on single process mode to
3733 * maximize the work at once, but in multi-process we want to keep
3734 * some fairness between processes, so we target half of the max
3735 * number of events to be balanced over all the processes the proxy
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05003736 * is bound to. Remember that maxaccept = -1 must be kept as it is
Willy Tarreau16a21472012-11-19 12:39:59 +01003737 * used to disable the limit.
3738 */
Christopher Faulet02f3cf12019-04-30 14:08:41 +02003739 if (listener->maxaccept > 0 && nbproc > 1) {
3740 listener->maxaccept = (listener->maxaccept + 1) / 2;
Willy Tarreau16a21472012-11-19 12:39:59 +01003741 listener->maxaccept = (listener->maxaccept + nbproc - 1) / nbproc;
3742 }
3743
Willy Tarreau9903f0e2015-04-04 18:50:31 +02003744 listener->accept = session_accept_fd;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003745 listener->analysers |= curproxy->fe_req_ana;
Willy Tarreau10b688f2015-03-13 16:43:12 +01003746 listener->default_target = curproxy->default_target;
Willy Tarreau3bc13772008-12-07 11:50:35 +01003747
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003748 if (!LIST_ISEMPTY(&curproxy->tcp_req.l4_rules))
Willy Tarreau7d9736f2016-10-21 16:34:21 +02003749 listener->options |= LI_O_TCP_L4_RULES;
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003750
Willy Tarreau620408f2016-10-21 16:37:51 +02003751 if (!LIST_ISEMPTY(&curproxy->tcp_req.l5_rules))
3752 listener->options |= LI_O_TCP_L5_RULES;
3753
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003754 /* smart accept mode is automatic in HTTP mode */
3755 if ((curproxy->options2 & PR_O2_SMARTACC) ||
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003756 ((curproxy->mode == PR_MODE_HTTP || listener->bind_conf->is_ssl) &&
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003757 !(curproxy->no_options2 & PR_O2_SMARTACC)))
3758 listener->options |= LI_O_NOQUICKACK;
Willy Tarreaue6b98942007-10-29 01:09:36 +01003759 }
3760
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003761 /* Release unused SSL configs */
3762 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau795cdab2016-12-22 17:30:54 +01003763 if (!bind_conf->is_ssl && bind_conf->xprt->destroy_bind_conf)
3764 bind_conf->xprt->destroy_bind_conf(bind_conf);
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003765 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003766
Willy Tarreaua38a7172019-02-02 17:11:28 +01003767 if (atleast2(curproxy->bind_proc & all_proc_mask)) {
Willy Tarreau102df612014-05-07 23:56:38 +02003768 if (curproxy->uri_auth) {
Willy Tarreaueb791e02014-09-16 15:11:04 +02003769 int count, maxproc = 0;
3770
3771 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreaue26993c2020-09-03 07:18:55 +02003772 count = my_popcountl(bind_conf->settings.bind_proc);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003773 if (count > maxproc)
3774 maxproc = count;
3775 }
3776 /* backends have 0, frontends have 1 or more */
3777 if (maxproc != 1)
Christopher Faulet767a84b2017-11-24 16:50:31 +01003778 ha_warning("Proxy '%s': in multi-process mode, stats will be"
3779 " limited to process assigned to the current request.\n",
3780 curproxy->id);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003781
Willy Tarreau102df612014-05-07 23:56:38 +02003782 if (!LIST_ISEMPTY(&curproxy->uri_auth->admin_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003783 ha_warning("Proxy '%s': stats admin will not work correctly in multi-process mode.\n",
3784 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003785 }
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003786 }
Willy Tarreau102df612014-05-07 23:56:38 +02003787 if (!LIST_ISEMPTY(&curproxy->sticking_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003788 ha_warning("Proxy '%s': sticking rules will not work correctly in multi-process mode.\n",
3789 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003790 }
3791 }
Willy Tarreau918ff602011-07-25 16:33:49 +02003792
3793 /* create the task associated with the proxy */
Emeric Brunc60def82017-09-27 14:59:38 +02003794 curproxy->task = task_new(MAX_THREADS_MASK);
Willy Tarreau918ff602011-07-25 16:33:49 +02003795 if (curproxy->task) {
3796 curproxy->task->context = curproxy;
3797 curproxy->task->process = manage_proxy;
Willy Tarreau918ff602011-07-25 16:33:49 +02003798 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003799 ha_alert("Proxy '%s': no more memory when trying to allocate the management task\n",
3800 curproxy->id);
Willy Tarreau918ff602011-07-25 16:33:49 +02003801 cfgerr++;
3802 }
Willy Tarreaub369a042014-09-16 13:21:03 +02003803 }
3804
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003805 /*
3806 * Recount currently required checks.
3807 */
3808
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003809 for (curproxy=proxies_list; curproxy; curproxy=curproxy->next) {
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003810 int optnum;
3811
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003812 for (optnum = 0; cfg_opts[optnum].name; optnum++)
3813 if (curproxy->options & cfg_opts[optnum].val)
3814 global.last_checks |= cfg_opts[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003815
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003816 for (optnum = 0; cfg_opts2[optnum].name; optnum++)
3817 if (curproxy->options2 & cfg_opts2[optnum].val)
3818 global.last_checks |= cfg_opts2[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003819 }
3820
Willy Tarreau0fca4832015-05-01 19:12:05 +02003821 /* compute the required process bindings for the peers */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003822 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003823 if (curproxy->table && curproxy->table->peers.p)
3824 curproxy->table->peers.p->peers_fe->bind_proc |= curproxy->bind_proc;
Willy Tarreau0fca4832015-05-01 19:12:05 +02003825
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01003826 /* compute the required process bindings for the peers from <stktables_list>
3827 * for all the stick-tables, the ones coming with "peers" sections included.
3828 */
3829 for (t = stktables_list; t; t = t->next) {
3830 struct proxy *p;
3831
3832 for (p = t->proxies_list; p; p = p->next_stkt_ref) {
3833 if (t->peers.p && t->peers.p->peers_fe) {
3834 t->peers.p->peers_fe->bind_proc |= p->bind_proc;
3835 }
3836 }
3837 }
3838
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003839 if (cfg_peers) {
3840 struct peers *curpeers = cfg_peers, **last;
Willy Tarreau122541c2011-09-07 21:24:49 +02003841 struct peer *p, *pb;
3842
William Lallemanda2cfd7e2020-03-24 16:02:48 +01003843 /* In the case the peers frontend was not initialized by a
3844 stick-table used in the configuration, set its bind_proc
3845 by default to the first process. */
3846 while (curpeers) {
William Lallemand3ef2d562020-03-24 16:42:15 +01003847 if (curpeers->peers_fe) {
3848 if (curpeers->peers_fe->bind_proc == 0)
3849 curpeers->peers_fe->bind_proc = 1;
3850 }
William Lallemanda2cfd7e2020-03-24 16:02:48 +01003851 curpeers = curpeers->next;
3852 }
3853
3854 curpeers = cfg_peers;
Willy Tarreau1e273012015-05-01 19:15:17 +02003855 /* Remove all peers sections which don't have a valid listener,
3856 * which are not used by any table, or which are bound to more
3857 * than one process.
Willy Tarreau122541c2011-09-07 21:24:49 +02003858 */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003859 last = &cfg_peers;
Willy Tarreau122541c2011-09-07 21:24:49 +02003860 while (*last) {
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003861 struct stktable *t;
Willy Tarreau122541c2011-09-07 21:24:49 +02003862 curpeers = *last;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003863
Willy Tarreau1ad64ac2020-09-24 08:48:08 +02003864 if (curpeers->disabled) {
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003865 /* the "disabled" keyword was present */
3866 if (curpeers->peers_fe)
3867 stop_proxy(curpeers->peers_fe);
3868 curpeers->peers_fe = NULL;
3869 }
Frédéric Lécaille5a4fe5a2019-10-04 08:30:04 +02003870 else if (!curpeers->peers_fe || !curpeers->peers_fe->id) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003871 ha_warning("Removing incomplete section 'peers %s' (no peer named '%s').\n",
3872 curpeers->id, localpeer);
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003873 if (curpeers->peers_fe)
3874 stop_proxy(curpeers->peers_fe);
3875 curpeers->peers_fe = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003876 }
Willy Tarreau9504dd62018-10-15 09:37:03 +02003877 else if (atleast2(curpeers->peers_fe->bind_proc)) {
Willy Tarreau1e273012015-05-01 19:15:17 +02003878 /* either it's totally stopped or too much used */
3879 if (curpeers->peers_fe->bind_proc) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003880 ha_alert("Peers section '%s': peers referenced by sections "
3881 "running in different processes (%d different ones). "
3882 "Check global.nbproc and all tables' bind-process "
3883 "settings.\n", curpeers->id, my_popcountl(curpeers->peers_fe->bind_proc));
Willy Tarreau1e273012015-05-01 19:15:17 +02003884 cfgerr++;
3885 }
3886 stop_proxy(curpeers->peers_fe);
3887 curpeers->peers_fe = NULL;
3888 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003889 else {
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01003890 /* Initializes the transport layer of the server part of all the peers belonging to
3891 * <curpeers> section if required.
3892 * Note that ->srv is used by the local peer of a new process to connect to the local peer
3893 * of an old process.
3894 */
Frédéric Lécaille1055e682018-04-26 14:35:21 +02003895 p = curpeers->remote;
3896 while (p) {
Frédéric Lécaille355b2032019-01-11 14:06:12 +01003897 if (p->srv) {
Christopher Fauletf61f33a2020-03-27 18:55:49 +01003898 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 +01003899 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(p->srv);
3900 }
Frédéric Lécaille1055e682018-04-26 14:35:21 +02003901 p = p->next;
3902 }
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01003903 /* Configure the SSL bindings of the local peer if required. */
3904 if (!LIST_ISEMPTY(&curpeers->peers_fe->conf.bind)) {
3905 struct list *l;
3906 struct bind_conf *bind_conf;
3907
3908 l = &curpeers->peers_fe->conf.bind;
3909 bind_conf = LIST_ELEM(l->n, typeof(bind_conf), by_fe);
3910 if (bind_conf->xprt->prepare_bind_conf &&
3911 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
3912 cfgerr++;
3913 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02003914 if (!peers_init_sync(curpeers) || !peers_alloc_dcache(curpeers)) {
Willy Tarreaud9443442018-10-15 11:18:03 +02003915 ha_alert("Peers section '%s': out of memory, giving up on peers.\n",
3916 curpeers->id);
3917 cfgerr++;
3918 break;
3919 }
Willy Tarreau122541c2011-09-07 21:24:49 +02003920 last = &curpeers->next;
3921 continue;
3922 }
3923
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003924 /* clean what has been detected above */
Willy Tarreau122541c2011-09-07 21:24:49 +02003925 p = curpeers->remote;
3926 while (p) {
3927 pb = p->next;
3928 free(p->id);
3929 free(p);
3930 p = pb;
3931 }
3932
3933 /* Destroy and unlink this curpeers section.
3934 * Note: curpeers is backed up into *last.
3935 */
3936 free(curpeers->id);
3937 curpeers = curpeers->next;
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003938 /* Reset any refereance to this peers section in the list of stick-tables */
3939 for (t = stktables_list; t; t = t->next) {
3940 if (t->peers.p && t->peers.p == *last)
3941 t->peers.p = NULL;
3942 }
Willy Tarreau122541c2011-09-07 21:24:49 +02003943 free(*last);
3944 *last = curpeers;
3945 }
3946 }
3947
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003948 for (t = stktables_list; t; t = t->next) {
3949 if (t->proxy)
3950 continue;
3951 if (!stktable_init(t)) {
3952 ha_alert("Proxy '%s': failed to initialize stick-table.\n", t->id);
3953 cfgerr++;
3954 }
3955 }
3956
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003957 /* initialize stick-tables on backend capable proxies. This must not
3958 * be done earlier because the data size may be discovered while parsing
3959 * other proxies.
3960 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003961 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauc3914d42020-09-24 08:39:22 +02003962 if (curproxy->disabled || !curproxy->table)
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003963 continue;
3964
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003965 if (!stktable_init(curproxy->table)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003966 ha_alert("Proxy '%s': failed to initialize stick-table.\n", curproxy->id);
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003967 cfgerr++;
3968 }
3969 }
3970
Simon Horman0d16a402015-01-30 11:22:58 +09003971 if (mailers) {
3972 struct mailers *curmailers = mailers, **last;
3973 struct mailer *m, *mb;
3974
3975 /* Remove all mailers sections which don't have a valid listener.
3976 * This can happen when a mailers section is never referenced.
3977 */
3978 last = &mailers;
3979 while (*last) {
3980 curmailers = *last;
3981 if (curmailers->users) {
3982 last = &curmailers->next;
3983 continue;
3984 }
3985
Christopher Faulet767a84b2017-11-24 16:50:31 +01003986 ha_warning("Removing incomplete section 'mailers %s'.\n",
3987 curmailers->id);
Simon Horman0d16a402015-01-30 11:22:58 +09003988
3989 m = curmailers->mailer_list;
3990 while (m) {
3991 mb = m->next;
3992 free(m->id);
3993 free(m);
3994 m = mb;
3995 }
3996
3997 /* Destroy and unlink this curmailers section.
3998 * Note: curmailers is backed up into *last.
3999 */
4000 free(curmailers->id);
4001 curmailers = curmailers->next;
4002 free(*last);
4003 *last = curmailers;
4004 }
4005 }
4006
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004007 /* Update server_state_file_name to backend name if backend is supposed to use
4008 * a server-state file locally defined and none has been provided */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004009 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004010 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_LOCAL &&
4011 curproxy->server_state_file_name == NULL)
4012 curproxy->server_state_file_name = strdup(curproxy->id);
4013 }
4014
Ben Draut054fbee2018-04-13 15:43:04 -06004015 list_for_each_entry(curr_resolvers, &dns_resolvers, list) {
4016 if (LIST_ISEMPTY(&curr_resolvers->nameservers)) {
4017 ha_warning("config : resolvers '%s' [%s:%d] has no nameservers configured!\n",
4018 curr_resolvers->id, curr_resolvers->conf.file,
4019 curr_resolvers->conf.line);
4020 err_code |= ERR_WARN;
4021 }
4022 }
4023
William Lallemand48b4bb42017-10-23 14:36:34 +02004024 list_for_each_entry(postparser, &postparsers, list) {
4025 if (postparser->func)
4026 cfgerr += postparser->func();
4027 }
4028
Willy Tarreaubb925012009-07-23 13:36:36 +02004029 if (cfgerr > 0)
4030 err_code |= ERR_ALERT | ERR_FATAL;
4031 out:
4032 return err_code;
Willy Tarreaubaaee002006-06-26 02:48:02 +02004033}
4034
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004035/*
4036 * Registers the CFG keyword list <kwl> as a list of valid keywords for next
4037 * parsing sessions.
4038 */
4039void cfg_register_keywords(struct cfg_kw_list *kwl)
4040{
4041 LIST_ADDQ(&cfg_keywords.list, &kwl->list);
4042}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004043
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004044/*
4045 * Unregisters the CFG keyword list <kwl> from the list of valid keywords.
4046 */
4047void cfg_unregister_keywords(struct cfg_kw_list *kwl)
4048{
4049 LIST_DEL(&kwl->list);
4050 LIST_INIT(&kwl->list);
4051}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004052
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004053/* this function register new section in the haproxy configuration file.
4054 * <section_name> is the name of this new section and <section_parser>
4055 * is the called parser. If two section declaration have the same name,
4056 * only the first declared is used.
4057 */
4058int cfg_register_section(char *section_name,
William Lallemandd2ff56d2017-10-16 11:06:50 +02004059 int (*section_parser)(const char *, int, char **, int),
4060 int (*post_section_parser)())
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004061{
4062 struct cfg_section *cs;
4063
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004064 list_for_each_entry(cs, &sections, list) {
4065 if (strcmp(cs->section_name, section_name) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004066 ha_alert("register section '%s': already registered.\n", section_name);
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004067 return 0;
4068 }
4069 }
4070
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004071 cs = calloc(1, sizeof(*cs));
4072 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004073 ha_alert("register section '%s': out of memory.\n", section_name);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004074 return 0;
4075 }
4076
4077 cs->section_name = section_name;
4078 cs->section_parser = section_parser;
William Lallemandd2ff56d2017-10-16 11:06:50 +02004079 cs->post_section_parser = post_section_parser;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004080
4081 LIST_ADDQ(&sections, &cs->list);
4082
4083 return 1;
4084}
4085
William Lallemand48b4bb42017-10-23 14:36:34 +02004086/* this function register a new function which will be called once the haproxy
4087 * configuration file has been parsed. It's useful to check dependencies
4088 * between sections or to resolve items once everything is parsed.
4089 */
4090int cfg_register_postparser(char *name, int (*func)())
4091{
4092 struct cfg_postparser *cp;
4093
4094 cp = calloc(1, sizeof(*cp));
4095 if (!cp) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004096 ha_alert("register postparser '%s': out of memory.\n", name);
William Lallemand48b4bb42017-10-23 14:36:34 +02004097 return 0;
4098 }
4099 cp->name = name;
4100 cp->func = func;
4101
4102 LIST_ADDQ(&postparsers, &cp->list);
4103
4104 return 1;
4105}
4106
Willy Tarreaubaaee002006-06-26 02:48:02 +02004107/*
David Carlier845efb52015-09-25 11:49:18 +01004108 * free all config section entries
4109 */
4110void cfg_unregister_sections(void)
4111{
4112 struct cfg_section *cs, *ics;
4113
4114 list_for_each_entry_safe(cs, ics, &sections, list) {
4115 LIST_DEL(&cs->list);
4116 free(cs);
4117 }
4118}
4119
Christopher Faulet7110b402016-10-26 11:09:44 +02004120void cfg_backup_sections(struct list *backup_sections)
4121{
4122 struct cfg_section *cs, *ics;
4123
4124 list_for_each_entry_safe(cs, ics, &sections, list) {
4125 LIST_DEL(&cs->list);
4126 LIST_ADDQ(backup_sections, &cs->list);
4127 }
4128}
4129
4130void cfg_restore_sections(struct list *backup_sections)
4131{
4132 struct cfg_section *cs, *ics;
4133
4134 list_for_each_entry_safe(cs, ics, backup_sections, list) {
4135 LIST_DEL(&cs->list);
4136 LIST_ADDQ(&sections, &cs->list);
4137 }
4138}
4139
Willy Tarreaue6552512018-11-26 11:33:13 +01004140/* these are the config sections handled by default */
4141REGISTER_CONFIG_SECTION("listen", cfg_parse_listen, NULL);
4142REGISTER_CONFIG_SECTION("frontend", cfg_parse_listen, NULL);
4143REGISTER_CONFIG_SECTION("backend", cfg_parse_listen, NULL);
4144REGISTER_CONFIG_SECTION("defaults", cfg_parse_listen, NULL);
4145REGISTER_CONFIG_SECTION("global", cfg_parse_global, NULL);
4146REGISTER_CONFIG_SECTION("userlist", cfg_parse_users, NULL);
4147REGISTER_CONFIG_SECTION("peers", cfg_parse_peers, NULL);
4148REGISTER_CONFIG_SECTION("mailers", cfg_parse_mailers, NULL);
4149REGISTER_CONFIG_SECTION("namespace_list", cfg_parse_netns, NULL);
4150REGISTER_CONFIG_SECTION("resolvers", cfg_parse_resolvers, NULL);
Willy Tarreau659fbf02016-05-26 17:55:28 +02004151
David Carlier845efb52015-09-25 11:49:18 +01004152/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02004153 * Local variables:
4154 * c-indent-level: 8
4155 * c-basic-offset: 8
4156 * End:
4157 */