blob: 56f95581a52e263902b2491e0653172e63a1298d [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 Tarreau2dd0d472006-06-29 17:53:05 +020036#include <common/cfgparse.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020037#include <common/chunk.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020038#include <common/config.h>
Willy Tarreau058e9072009-07-20 09:30:05 +020039#include <common/errors.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020040#include <common/memory.h>
41#include <common/standard.h>
42#include <common/time.h>
43#include <common/uri_auth.h>
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +010044#include <common/namespace.h>
Emeric Brunc60def82017-09-27 14:59:38 +020045#include <common/hathreads.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020046
47#include <types/capture.h>
Christopher Fauletd7c91962015-04-30 11:48:27 +020048#include <types/filters.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020049#include <types/global.h>
Willy Tarreau3fdb3662012-11-12 00:42:33 +010050#include <types/obj_type.h>
Emeric Brun32da3c42010-09-23 18:39:19 +020051#include <types/peers.h>
Simon Horman0d16a402015-01-30 11:22:58 +090052#include <types/mailers.h>
Baptiste Assmann325137d2015-04-13 23:40:55 +020053#include <types/dns.h>
William Lallemand9ed62032016-11-21 17:49:11 +010054#include <types/stats.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020055
Willy Tarreaueb0c6142007-05-07 00:53:22 +020056#include <proto/acl.h>
Christopher Faulet4fce0d82017-09-18 11:57:31 +020057#include <proto/action.h>
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +010058#include <proto/auth.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020059#include <proto/backend.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020060#include <proto/channel.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020061#include <proto/checks.h>
Baptiste Assmann201c07f2017-05-22 15:17:15 +020062#include <proto/dns.h>
William Lallemand9ed62032016-11-21 17:49:11 +010063#include <proto/stats.h>
Christopher Fauletd7c91962015-04-30 11:48:27 +020064#include <proto/filters.h>
Willy Tarreaueb472682010-05-28 18:46:57 +020065#include <proto/frontend.h>
Willy Tarreau61c112a2018-10-02 16:43:32 +020066#include <proto/http_rules.h>
Willy Tarreau6b2e11b2009-10-01 07:52:15 +020067#include <proto/lb_chash.h>
Willy Tarreauf09c6602012-02-13 17:12:08 +010068#include <proto/lb_fas.h>
Willy Tarreauf89c1872009-10-01 11:19:37 +020069#include <proto/lb_fwlc.h>
70#include <proto/lb_fwrr.h>
71#include <proto/lb_map.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020072#include <proto/listener.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020073#include <proto/log.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020074#include <proto/protocol.h>
Christopher Fauletfc9cfe42019-07-16 14:54:53 +020075#include <proto/http_ana.h>
Willy Tarreau2b5652f2006-12-31 17:46:05 +010076#include <proto/proxy.h>
Emeric Brun32da3c42010-09-23 18:39:19 +020077#include <proto/peers.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020078#include <proto/sample.h>
Willy Tarreau9903f0e2015-04-04 18:50:31 +020079#include <proto/session.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020080#include <proto/server.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020081#include <proto/stream.h>
Emeric Brunb982a3d2010-01-04 15:45:53 +010082#include <proto/stick_table.h>
Willy Tarreau39713102016-11-25 15:49:32 +010083#include <proto/task.h>
84#include <proto/tcp_rules.h>
Olivier Houchard673867c2018-05-25 16:58:52 +020085#include <proto/connection.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020086
87
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +010088/* Used to chain configuration sections definitions. This list
89 * stores struct cfg_section
90 */
91struct list sections = LIST_HEAD_INIT(sections);
92
William Lallemand48b4bb42017-10-23 14:36:34 +020093struct list postparsers = LIST_HEAD_INIT(postparsers);
94
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +010095char *cursection = NULL;
96struct proxy defproxy = { }; /* fake proxy used to assign default values on all instances */
Willy Tarreauc8d5b952019-02-27 17:25:52 +010097int cfg_maxpconn = 0; /* # of simultaneous connections per proxy (-N) */
Willy Tarreau5af24ef2009-03-15 15:23:16 +010098int cfg_maxconn = 0; /* # of simultaneous connections, (-n) */
Christopher Faulet79bdef32016-11-04 22:36:15 +010099char *cfg_scope = NULL; /* the current scope during the configuration parsing */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200100
Willy Tarreau5b2c3362008-07-09 19:39:06 +0200101/* List head of all known configuration keywords */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100102struct cfg_kw_list cfg_keywords = {
Willy Tarreau5b2c3362008-07-09 19:39:06 +0200103 .list = LIST_HEAD_INIT(cfg_keywords.list)
104};
105
Willy Tarreaubaaee002006-06-26 02:48:02 +0200106/*
107 * converts <str> to a list of listeners which are dynamically allocated.
108 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
109 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
110 * - <port> is a numerical port from 1 to 65535 ;
111 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
112 * This can be repeated as many times as necessary, separated by a coma.
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200113 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
114 * not NULL, it must be a valid pointer to either NULL or a freeable area that
115 * will be replaced with an error message.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200116 */
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200117int 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 +0200118{
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100119 char *next, *dupstr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200120 int port, end;
121
122 next = dupstr = strdup(str);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200123
Willy Tarreaubaaee002006-06-26 02:48:02 +0200124 while (next && *next) {
William Lallemand75ea0a02017-11-15 19:02:58 +0100125 int inherited = 0;
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200126 struct sockaddr_storage *ss2;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100127 int fd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200128
129 str = next;
130 /* 1) look for the end of the first address */
Krzysztof Piotr Oledzki52d522b2009-01-27 16:57:08 +0100131 if ((next = strchr(str, ',')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200132 *next++ = 0;
133 }
134
Willy Tarreau48ef4c92017-01-06 18:32:38 +0100135 ss2 = str2sa_range(str, NULL, &port, &end, err,
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200136 curproxy == global.stats_fe ? NULL : global.unix_bind.prefix,
Thierry FOURNIER7fe3be72015-09-26 20:03:36 +0200137 NULL, 1);
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100138 if (!ss2)
139 goto fail;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200140
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100141 if (ss2->ss_family == AF_INET || ss2->ss_family == AF_INET6) {
Willy Tarreau6d03cc32013-02-20 17:26:02 +0100142 if (!port && !end) {
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200143 memprintf(err, "missing port number: '%s'\n", str);
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100144 goto fail;
Emeric Bruned760922010-10-22 17:59:25 +0200145 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200146
Willy Tarreau6d03cc32013-02-20 17:26:02 +0100147 if (!port || !end) {
148 memprintf(err, "port offsets are not allowed in 'bind': '%s'\n", str);
149 goto fail;
150 }
151
Emeric Bruned760922010-10-22 17:59:25 +0200152 if (port < 1 || port > 65535) {
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200153 memprintf(err, "invalid port '%d' specified for address '%s'.\n", port, str);
Emeric Bruned760922010-10-22 17:59:25 +0200154 goto fail;
155 }
156
157 if (end < 1 || end > 65535) {
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200158 memprintf(err, "invalid port '%d' specified for address '%s'.\n", end, str);
Emeric Bruned760922010-10-22 17:59:25 +0200159 goto fail;
160 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200161 }
Willy Tarreau40aa0702013-03-10 23:51:38 +0100162 else if (ss2->ss_family == AF_UNSPEC) {
163 socklen_t addr_len;
William Lallemand75ea0a02017-11-15 19:02:58 +0100164 inherited = 1;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100165
166 /* We want to attach to an already bound fd whose number
167 * is in the addr part of ss2 when cast to sockaddr_in.
168 * Note that by definition there is a single listener.
169 * We still have to determine the address family to
170 * register the correct protocol.
171 */
172 fd = ((struct sockaddr_in *)ss2)->sin_addr.s_addr;
173 addr_len = sizeof(*ss2);
174 if (getsockname(fd, (struct sockaddr *)ss2, &addr_len) == -1) {
175 memprintf(err, "cannot use file descriptor '%d' : %s.\n", fd, strerror(errno));
176 goto fail;
177 }
178
179 port = end = get_host_port(ss2);
William Lallemand2fe7dd02018-09-11 16:51:29 +0200180
181 } else if (ss2->ss_family == AF_CUST_SOCKPAIR) {
182 socklen_t addr_len;
183 inherited = 1;
184
185 fd = ((struct sockaddr_in *)ss2)->sin_addr.s_addr;
186 addr_len = sizeof(*ss2);
187 if (getsockname(fd, (struct sockaddr *)ss2, &addr_len) == -1) {
188 memprintf(err, "cannot use file descriptor '%d' : %s.\n", fd, strerror(errno));
189 goto fail;
190 }
191
192 ss2->ss_family = AF_CUST_SOCKPAIR; /* reassign AF_CUST_SOCKPAIR because of getsockname */
193 port = end = 0;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100194 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200195
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100196 /* OK the address looks correct */
William Lallemand75ea0a02017-11-15 19:02:58 +0100197 if (!create_listeners(bind_conf, ss2, port, end, fd, inherited, err)) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200198 memprintf(err, "%s for address '%s'.\n", *err, str);
199 goto fail;
200 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200201 } /* end while(next) */
202 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200203 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200204 fail:
205 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200206 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200207}
208
William Lallemand6e62fb62015-04-28 16:55:23 +0200209/*
Willy Tarreauece9b072016-12-21 22:41:44 +0100210 * Report an error in <msg> when there are too many arguments. This version is
211 * intended to be used by keyword parsers so that the message will be included
212 * into the general error message. The index is the current keyword in args.
213 * Return 0 if the number of argument is correct, otherwise build a message and
214 * return 1. Fill err_code with an ERR_ALERT and an ERR_FATAL if not null. The
215 * message may also be null, it will simply not be produced (useful to check only).
216 * <msg> and <err_code> are only affected on error.
217 */
218int too_many_args_idx(int maxarg, int index, char **args, char **msg, int *err_code)
219{
220 int i;
221
222 if (!*args[index + maxarg + 1])
223 return 0;
224
225 if (msg) {
226 *msg = NULL;
227 memprintf(msg, "%s", args[0]);
228 for (i = 1; i <= index; i++)
229 memprintf(msg, "%s %s", *msg, args[i]);
230
231 memprintf(msg, "'%s' cannot handle unexpected argument '%s'.", *msg, args[index + maxarg + 1]);
232 }
233 if (err_code)
234 *err_code |= ERR_ALERT | ERR_FATAL;
235
236 return 1;
237}
238
239/*
240 * same as too_many_args_idx with a 0 index
241 */
242int too_many_args(int maxarg, char **args, char **msg, int *err_code)
243{
244 return too_many_args_idx(maxarg, 0, args, msg, err_code);
245}
246
247/*
William Lallemand6e62fb62015-04-28 16:55:23 +0200248 * Report a fatal Alert when there is too much arguments
249 * The index is the current keyword in args
250 * Return 0 if the number of argument is correct, otherwise emit an alert and return 1
251 * Fill err_code with an ERR_ALERT and an ERR_FATAL
252 */
253int alertif_too_many_args_idx(int maxarg, int index, const char *file, int linenum, char **args, int *err_code)
254{
255 char *kw = NULL;
256 int i;
257
258 if (!*args[index + maxarg + 1])
259 return 0;
260
261 memprintf(&kw, "%s", args[0]);
262 for (i = 1; i <= index; i++) {
263 memprintf(&kw, "%s %s", kw, args[i]);
264 }
265
Christopher Faulet767a84b2017-11-24 16:50:31 +0100266 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 +0200267 free(kw);
268 *err_code |= ERR_ALERT | ERR_FATAL;
269 return 1;
270}
271
272/*
273 * same as alertif_too_many_args_idx with a 0 index
274 */
275int alertif_too_many_args(int maxarg, const char *file, int linenum, char **args, int *err_code)
276{
277 return alertif_too_many_args_idx(maxarg, 0, file, linenum, args, err_code);
278}
279
Willy Tarreau61d18892009-03-31 10:49:21 +0200280
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100281/* Report it if a request ACL condition uses some keywords that are incompatible
282 * with the place where the ACL is used. It returns either 0 or ERR_WARN so that
283 * its result can be or'ed with err_code. Note that <cond> may be NULL and then
284 * will be ignored.
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100285 */
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100286int warnif_cond_conflicts(const struct acl_cond *cond, unsigned int where, const char *file, int line)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100287{
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100288 const struct acl *acl;
Willy Tarreau93fddf12013-03-31 22:59:32 +0200289 const char *kw;
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100290
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100291 if (!cond)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100292 return 0;
293
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100294 acl = acl_cond_conflicts(cond, where);
295 if (acl) {
296 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100297 ha_warning("parsing [%s:%d] : acl '%s' will never match because it only involves keywords that are incompatible with '%s'\n",
298 file, line, acl->name, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100299 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100300 ha_warning("parsing [%s:%d] : anonymous acl will never match because it uses keyword '%s' which is incompatible with '%s'\n",
301 file, line, LIST_ELEM(acl->expr.n, struct acl_expr *, list)->kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100302 return ERR_WARN;
303 }
304 if (!acl_cond_kw_conflicts(cond, where, &acl, &kw))
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100305 return 0;
306
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100307 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100308 ha_warning("parsing [%s:%d] : acl '%s' involves keywords '%s' which is incompatible with '%s'\n",
309 file, line, acl->name, kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100310 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100311 ha_warning("parsing [%s:%d] : anonymous acl involves keyword '%s' which is incompatible with '%s'\n",
312 file, line, kw, sample_ckp_names(where));
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100313 return ERR_WARN;
314}
315
Christopher Faulet62519022017-10-16 15:49:32 +0200316/* Parse a string representing a process number or a set of processes. It must
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100317 * be "all", "odd", "even", a number between 1 and <max> or a range with
Christopher Faulet5ab51772017-11-22 11:21:58 +0100318 * two such numbers delimited by a dash ('-'). On success, it returns
319 * 0. otherwise it returns 1 with an error message in <err>.
Christopher Faulet62519022017-10-16 15:49:32 +0200320 *
321 * Note: this function can also be used to parse a thread number or a set of
322 * threads.
323 */
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100324int parse_process_number(const char *arg, unsigned long *proc, int max, int *autoinc, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200325{
Christopher Faulet26028f62017-11-22 15:01:51 +0100326 if (autoinc) {
327 *autoinc = 0;
328 if (strncmp(arg, "auto:", 5) == 0) {
329 arg += 5;
330 *autoinc = 1;
331 }
332 }
333
Christopher Faulet62519022017-10-16 15:49:32 +0200334 if (strcmp(arg, "all") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100335 *proc |= ~0UL;
Christopher Faulet62519022017-10-16 15:49:32 +0200336 else if (strcmp(arg, "odd") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100337 *proc |= ~0UL/3UL; /* 0x555....555 */
Christopher Faulet62519022017-10-16 15:49:32 +0200338 else if (strcmp(arg, "even") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100339 *proc |= (~0UL/3UL) << 1; /* 0xAAA...AAA */
Christopher Faulet62519022017-10-16 15:49:32 +0200340 else {
Christopher Faulet18cca782019-02-07 16:29:41 +0100341 const char *p, *dash = NULL;
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100342 unsigned int low, high;
343
Christopher Faulet18cca782019-02-07 16:29:41 +0100344 for (p = arg; *p; p++) {
345 if (*p == '-' && !dash)
346 dash = p;
Willy Tarreau90807112020-02-25 08:16:33 +0100347 else if (!isdigit((unsigned char)*p)) {
Christopher Faulet18cca782019-02-07 16:29:41 +0100348 memprintf(err, "'%s' is not a valid number/range.", arg);
349 return -1;
350 }
Christopher Faulet5ab51772017-11-22 11:21:58 +0100351 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100352
353 low = high = str2uic(arg);
Christopher Faulet18cca782019-02-07 16:29:41 +0100354 if (dash)
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100355 high = ((!*(dash+1)) ? max : str2uic(dash + 1));
Christopher Fauletff4121f2017-11-22 16:38:49 +0100356
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100357 if (high < low) {
358 unsigned int swap = low;
359 low = high;
360 high = swap;
361 }
362
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100363 if (low < 1 || low > max || high > max) {
Christopher Fauletcb6a9452017-11-22 16:50:41 +0100364 memprintf(err, "'%s' is not a valid number/range."
365 " It supports numbers from 1 to %d.\n",
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100366 arg, max);
Christopher Faulet5ab51772017-11-22 11:21:58 +0100367 return 1;
368 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100369
370 for (;low <= high; low++)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100371 *proc |= 1UL << (low-1);
Christopher Faulet62519022017-10-16 15:49:32 +0200372 }
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100373 *proc &= ~0UL >> (LONGBITS - max);
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100374
Christopher Faulet5ab51772017-11-22 11:21:58 +0100375 return 0;
Christopher Faulet62519022017-10-16 15:49:32 +0200376}
377
David Carlier7e351ee2017-12-01 09:14:02 +0000378#ifdef USE_CPU_AFFINITY
Christopher Faulet62519022017-10-16 15:49:32 +0200379/* Parse cpu sets. Each CPU set is either a unique number between 0 and
380 * <LONGBITS> or a range with two such numbers delimited by a dash
381 * ('-'). Multiple CPU numbers or ranges may be specified. On success, it
382 * returns 0. otherwise it returns 1 with an error message in <err>.
383 */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100384unsigned long parse_cpu_set(const char **args, unsigned long *cpu_set, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200385{
386 int cur_arg = 0;
387
388 *cpu_set = 0;
389 while (*args[cur_arg]) {
390 char *dash;
391 unsigned int low, high;
392
Willy Tarreau90807112020-02-25 08:16:33 +0100393 if (!isdigit((unsigned char)*args[cur_arg])) {
Christopher Faulet62519022017-10-16 15:49:32 +0200394 memprintf(err, "'%s' is not a CPU range.\n", args[cur_arg]);
395 return -1;
396 }
397
398 low = high = str2uic(args[cur_arg]);
399 if ((dash = strchr(args[cur_arg], '-')) != NULL)
Christopher Fauletff4121f2017-11-22 16:38:49 +0100400 high = ((!*(dash+1)) ? LONGBITS-1 : str2uic(dash + 1));
Christopher Faulet62519022017-10-16 15:49:32 +0200401
402 if (high < low) {
403 unsigned int swap = low;
404 low = high;
405 high = swap;
406 }
407
408 if (high >= LONGBITS) {
409 memprintf(err, "supports CPU numbers from 0 to %d.\n", LONGBITS - 1);
410 return 1;
411 }
412
413 while (low <= high)
414 *cpu_set |= 1UL << low++;
415
416 cur_arg++;
417 }
418 return 0;
419}
David Carlier7e351ee2017-12-01 09:14:02 +0000420#endif
421
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200422void init_default_instance()
Willy Tarreaubaaee002006-06-26 02:48:02 +0200423{
Willy Tarreau97cb7802010-01-03 20:23:58 +0100424 init_new_proxy(&defproxy);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200425 defproxy.mode = PR_MODE_TCP;
426 defproxy.state = PR_STNEW;
427 defproxy.maxconn = cfg_maxpconn;
428 defproxy.conn_retries = CONN_RETRIES;
Joseph Lynch726ab712015-05-11 23:25:34 -0700429 defproxy.redispatch_after = 0;
Olivier Houchard86006a52018-12-14 19:37:49 +0100430 defproxy.options = PR_O_REUSE_SAFE;
Olivier Houcharda4d4fdf2018-12-14 19:27:06 +0100431 defproxy.max_out_conns = MAX_SRV_LIST;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100432
Simon Horman66183002013-02-23 10:16:43 +0900433 defproxy.defsrv.check.inter = DEF_CHKINTR;
434 defproxy.defsrv.check.fastinter = 0;
435 defproxy.defsrv.check.downinter = 0;
Simon Hormand60d6912013-11-25 10:46:36 +0900436 defproxy.defsrv.agent.inter = DEF_CHKINTR;
437 defproxy.defsrv.agent.fastinter = 0;
438 defproxy.defsrv.agent.downinter = 0;
Simon Horman58c32972013-11-25 10:46:38 +0900439 defproxy.defsrv.check.rise = DEF_RISETIME;
440 defproxy.defsrv.check.fall = DEF_FALLTIME;
441 defproxy.defsrv.agent.rise = DEF_AGENT_RISETIME;
442 defproxy.defsrv.agent.fall = DEF_AGENT_FALLTIME;
Willy Tarreau5b3a2022012-09-28 15:01:02 +0200443 defproxy.defsrv.check.port = 0;
Simon Hormand60d6912013-11-25 10:46:36 +0900444 defproxy.defsrv.agent.port = 0;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100445 defproxy.defsrv.maxqueue = 0;
446 defproxy.defsrv.minconn = 0;
447 defproxy.defsrv.maxconn = 0;
Willy Tarreau9c538e02019-01-23 10:21:49 +0100448 defproxy.defsrv.max_reuse = -1;
Olivier Houchard006e3102018-12-10 18:30:32 +0100449 defproxy.defsrv.max_idle_conns = -1;
Willy Tarreau975b1552019-06-06 16:25:55 +0200450 defproxy.defsrv.pool_purge_delay = 5000;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100451 defproxy.defsrv.slowstart = 0;
452 defproxy.defsrv.onerror = DEF_HANA_ONERR;
453 defproxy.defsrv.consecutive_errors_limit = DEF_HANA_ERRLIMIT;
454 defproxy.defsrv.uweight = defproxy.defsrv.iweight = 1;
Simon Horman64e34162015-02-06 11:11:57 +0900455
456 defproxy.email_alert.level = LOG_ALERT;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +0200457 defproxy.load_server_state_from_file = PR_SRV_STATE_FILE_UNSPEC;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200458}
459
Frédéric Lécaille18251032019-01-11 11:07:15 +0100460/* Allocate and initialize the frontend of a "peers" section found in
461 * file <file> at line <linenum> with <id> as ID.
462 * Return 0 if succeeded, -1 if not.
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200463 * Note that this function may be called from "default-server"
464 * or "peer" lines.
Frédéric Lécaille18251032019-01-11 11:07:15 +0100465 */
466static int init_peers_frontend(const char *file, int linenum,
467 const char *id, struct peers *peers)
468{
469 struct proxy *p;
470
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200471 if (peers->peers_fe) {
472 p = peers->peers_fe;
473 goto out;
474 }
Frédéric Lécaille9492c4e2019-01-11 11:47:12 +0100475
Frédéric Lécaille18251032019-01-11 11:07:15 +0100476 p = calloc(1, sizeof *p);
477 if (!p) {
478 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
479 return -1;
480 }
481
482 init_new_proxy(p);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200483 peers_setup_frontend(p);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100484 p->parent = peers;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200485 /* Finally store this frontend. */
486 peers->peers_fe = p;
487
488 out:
489 if (id && !p->id)
490 p->id = strdup(id);
Frédéric Lécaille1055e682018-04-26 14:35:21 +0200491 free(p->conf.file);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100492 p->conf.args.file = p->conf.file = strdup(file);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100493 if (linenum != -1)
494 p->conf.args.line = p->conf.line = linenum;
Frédéric Lécaille18251032019-01-11 11:07:15 +0100495
496 return 0;
497}
Willy Tarreauade5ec42010-01-28 19:33:49 +0100498
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100499/* Only change ->file, ->line and ->arg struct bind_conf member values
500 * if already present.
501 */
502static struct bind_conf *bind_conf_uniq_alloc(struct proxy *p,
503 const char *file, int line,
504 const char *arg, struct xprt_ops *xprt)
505{
506 struct bind_conf *bind_conf;
507
508 if (!LIST_ISEMPTY(&p->conf.bind)) {
509 bind_conf = LIST_ELEM((&p->conf.bind)->n, typeof(bind_conf), by_fe);
510 free(bind_conf->file);
511 bind_conf->file = strdup(file);
512 bind_conf->line = line;
513 if (arg) {
514 free(bind_conf->arg);
515 bind_conf->arg = strdup(arg);
516 }
517 }
518 else {
519 bind_conf = bind_conf_alloc(p, file, line, arg, xprt);
520 }
521
522 return bind_conf;
523}
524
525/*
526 * Allocate a new struct peer parsed at line <linenum> in file <file>
527 * to be added to <peers>.
528 * Returns the new allocated structure if succeeded, NULL if not.
529 */
530static struct peer *cfg_peers_add_peer(struct peers *peers,
531 const char *file, int linenum,
532 const char *id, int local)
533{
534 struct peer *p;
535
536 p = calloc(1, sizeof *p);
537 if (!p) {
538 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
539 return NULL;
540 }
541
542 /* the peers are linked backwards first */
543 peers->count++;
544 p->next = peers->remote;
545 peers->remote = p;
546 p->conf.file = strdup(file);
547 p->conf.line = linenum;
548 p->last_change = now.tv_sec;
549 p->xprt = xprt_get(XPRT_RAW);
550 p->sock_init_arg = NULL;
551 HA_SPIN_INIT(&p->lock);
552 if (id)
553 p->id = strdup(id);
554 if (local) {
555 p->local = 1;
556 peers->local = p;
557 }
558
559 return p;
560}
561
Willy Tarreaubaaee002006-06-26 02:48:02 +0200562/*
William Lallemand51097192015-04-14 16:35:22 +0200563 * Parse a line in a <listen>, <frontend> or <backend> section.
Willy Tarreau93893792009-07-23 13:19:11 +0200564 * Returns the error code, 0 if OK, or any combination of :
565 * - ERR_ABORT: must abort ASAP
566 * - ERR_FATAL: we can continue parsing but not start the service
567 * - ERR_WARN: a warning has been emitted
568 * - ERR_ALERT: an alert has been emitted
569 * Only the two first ones can stop processing, the two others are just
570 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200571 */
Emeric Brun32da3c42010-09-23 18:39:19 +0200572int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
573{
574 static struct peers *curpeers = NULL;
575 struct peer *newpeer = NULL;
576 const char *err;
Willy Tarreau4348fad2012-09-20 16:48:07 +0200577 struct bind_conf *bind_conf;
578 struct listener *l;
Emeric Brun32da3c42010-09-23 18:39:19 +0200579 int err_code = 0;
Willy Tarreau902636f2013-03-10 19:44:48 +0100580 char *errmsg = NULL;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100581 static int bind_line, peer_line;
582
583 if (strcmp(args[0], "bind") == 0 || strcmp(args[0], "default-bind") == 0) {
584 int cur_arg;
585 static int kws_dumped;
586 struct bind_conf *bind_conf;
587 struct bind_kw *kw;
Emeric Brun32da3c42010-09-23 18:39:19 +0200588
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100589 cur_arg = 1;
590
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200591 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
592 err_code |= ERR_ALERT | ERR_ABORT;
593 goto out;
594 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100595
596 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum,
597 NULL, xprt_get(XPRT_RAW));
598 if (*args[0] == 'b') {
599 struct listener *l;
600
601 if (peer_line) {
602 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
603 err_code |= ERR_ALERT | ERR_FATAL;
604 goto out;
605 }
606
607 if (!str2listener(args[1], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
608 if (errmsg && *errmsg) {
609 indent_msg(&errmsg, 2);
610 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
611 }
612 else
613 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
614 file, linenum, args[0], args[1], args[2]);
615 err_code |= ERR_FATAL;
616 goto out;
617 }
618 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
619 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100620 l->accept = session_accept_fd;
621 l->analysers |= curpeers->peers_fe->fe_req_ana;
622 l->default_target = curpeers->peers_fe->default_target;
623 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100624 global.maxsock++; /* for the listening socket */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100625
626 bind_line = 1;
627 if (cfg_peers->local) {
628 newpeer = cfg_peers->local;
629 }
630 else {
631 /* This peer is local.
632 * Note that we do not set the peer ID. This latter is initialized
633 * when parsing "peer" or "server" line.
634 */
635 newpeer = cfg_peers_add_peer(curpeers, file, linenum, NULL, 1);
636 if (!newpeer) {
637 err_code |= ERR_ALERT | ERR_ABORT;
638 goto out;
639 }
640 }
641 newpeer->addr = l->addr;
642 newpeer->proto = protocol_by_family(newpeer->addr.ss_family);
643 cur_arg++;
644 }
645
646 while (*args[cur_arg] && (kw = bind_find_kw(args[cur_arg]))) {
647 int ret;
648
649 ret = kw->parse(args, cur_arg, curpeers->peers_fe, bind_conf, &errmsg);
650 err_code |= ret;
651 if (ret) {
652 if (errmsg && *errmsg) {
653 indent_msg(&errmsg, 2);
654 ha_alert("parsing [%s:%d] : %s\n", file, linenum, errmsg);
655 }
656 else
657 ha_alert("parsing [%s:%d]: error encountered while processing '%s'\n",
658 file, linenum, args[cur_arg]);
659 if (ret & ERR_FATAL)
660 goto out;
661 }
662 cur_arg += 1 + kw->skip;
663 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100664 if (*args[cur_arg] != 0) {
Tim Duesterhus04bcaa12019-05-12 22:54:50 +0200665 char *kws = NULL;
666
667 if (!kws_dumped) {
668 kws_dumped = 1;
669 bind_dump_kws(&kws);
670 indent_msg(&kws, 4);
671 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100672 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section.%s%s\n",
673 file, linenum, args[cur_arg], cursection,
674 kws ? " Registered keywords :" : "", kws ? kws: "");
675 free(kws);
676 err_code |= ERR_ALERT | ERR_FATAL;
677 goto out;
678 }
679 }
680 else if (strcmp(args[0], "default-server") == 0) {
681 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
682 err_code |= ERR_ALERT | ERR_ABORT;
683 goto out;
684 }
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200685 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL, 0, 1);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200686 }
Frédéric Lécailleb6f759b2019-11-05 09:57:45 +0100687 else if (strcmp(args[0], "log") == 0) {
688 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
689 err_code |= ERR_ALERT | ERR_ABORT;
690 goto out;
691 }
692 if (!parse_logsrv(args, &curpeers->peers_fe->logsrvs, (kwm == KWM_NO), &errmsg)) {
693 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
694 err_code |= ERR_ALERT | ERR_FATAL;
695 goto out;
696 }
697 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200698 else if (strcmp(args[0], "peers") == 0) { /* new peers section */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100699 /* Initialize these static variables when entering a new "peers" section*/
700 bind_line = peer_line = 0;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100701 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100702 ha_alert("parsing [%s:%d] : missing name for peers section.\n", file, linenum);
Willy Tarreau54984722014-02-16 08:20:13 +0100703 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100704 goto out;
705 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200706
William Lallemand6e62fb62015-04-28 16:55:23 +0200707 if (alertif_too_many_args(1, file, linenum, args, &err_code))
708 goto out;
709
Emeric Brun32da3c42010-09-23 18:39:19 +0200710 err = invalid_char(args[1]);
711 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100712 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
713 file, linenum, *err, args[0], args[1]);
Willy Tarreau54984722014-02-16 08:20:13 +0100714 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100715 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200716 }
717
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200718 for (curpeers = cfg_peers; curpeers != NULL; curpeers = curpeers->next) {
Emeric Brun32da3c42010-09-23 18:39:19 +0200719 /*
720 * If there are two proxies with the same name only following
721 * combinations are allowed:
722 */
723 if (strcmp(curpeers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100724 ha_alert("Parsing [%s:%d]: peers section '%s' has the same name as another peers section declared at %s:%d.\n",
725 file, linenum, args[1], curpeers->conf.file, curpeers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +0200726 err_code |= ERR_ALERT | ERR_FATAL;
Emeric Brun32da3c42010-09-23 18:39:19 +0200727 }
728 }
729
Vincent Bernat02779b62016-04-03 13:48:43 +0200730 if ((curpeers = calloc(1, sizeof(*curpeers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100731 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Emeric Brun32da3c42010-09-23 18:39:19 +0200732 err_code |= ERR_ALERT | ERR_ABORT;
733 goto out;
734 }
735
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200736 curpeers->next = cfg_peers;
737 cfg_peers = curpeers;
Willy Tarreau8113a5d2012-10-04 08:01:43 +0200738 curpeers->conf.file = strdup(file);
Emeric Brun32da3c42010-09-23 18:39:19 +0200739 curpeers->conf.line = linenum;
740 curpeers->last_change = now.tv_sec;
741 curpeers->id = strdup(args[1]);
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200742 curpeers->state = PR_STNEW;
Emeric Brun32da3c42010-09-23 18:39:19 +0200743 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200744 else if (strcmp(args[0], "peer") == 0 ||
745 strcmp(args[0], "server") == 0) { /* peer or server definition */
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100746 int local_peer, peer;
Emeric Brun32da3c42010-09-23 18:39:19 +0200747
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100748 peer = *args[0] == 'p';
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100749 local_peer = !strcmp(args[1], localpeer);
750 /* The local peer may have already partially been parsed on a "bind" line. */
751 if (*args[0] == 'p') {
752 if (bind_line) {
753 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
754 err_code |= ERR_ALERT | ERR_FATAL;
755 goto out;
756 }
757 peer_line = 1;
758 }
759 if (cfg_peers->local && !cfg_peers->local->id && local_peer) {
760 /* The local peer has already been initialized on a "bind" line.
761 * Let's use it and store its ID.
762 */
763 newpeer = cfg_peers->local;
764 newpeer->id = strdup(localpeer);
765 }
766 else {
767 if (local_peer && cfg_peers->local) {
768 ha_alert("parsing [%s:%d] : '%s %s' : local peer name already referenced at %s:%d. %s\n",
769 file, linenum, args[0], args[1],
770 curpeers->peers_fe->conf.file, curpeers->peers_fe->conf.line, cfg_peers->local->id);
771 err_code |= ERR_FATAL;
772 goto out;
773 }
774 newpeer = cfg_peers_add_peer(curpeers, file, linenum, args[1], local_peer);
775 if (!newpeer) {
776 err_code |= ERR_ALERT | ERR_ABORT;
777 goto out;
778 }
779 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200780
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100781 /* Line number and peer ID are updated only if this peer is the local one. */
782 if (init_peers_frontend(file,
783 newpeer->local ? linenum: -1,
784 newpeer->local ? newpeer->id : NULL,
785 curpeers) != 0) {
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200786 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreaub36487e2013-03-10 18:37:42 +0100787 goto out;
788 }
Willy Tarreau2aa38802013-02-20 19:20:59 +0100789
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100790 /* This initializes curpeer->peers->peers_fe->srv.
791 * The server address is parsed only if we are parsing a "peer" line,
792 * or if we are parsing a "server" line and the current peer is not the local one.
793 */
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200794 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL, peer || !local_peer, 1);
795 if (!curpeers->peers_fe->srv) {
796 /* Remove the newly allocated peer. */
797 if (newpeer != curpeers->local) {
798 struct peer *p;
799
800 p = curpeers->remote;
801 curpeers->remote = curpeers->remote->next;
802 free(p->id);
803 free(p);
804 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200805 goto out;
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200806 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200807
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100808 /* If the peer address has just been parsed, let's copy it to <newpeer>
809 * and initializes ->proto.
810 */
811 if (peer || !local_peer) {
812 newpeer->addr = curpeers->peers_fe->srv->addr;
813 newpeer->proto = protocol_by_family(newpeer->addr.ss_family);
814 }
815
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100816 newpeer->xprt = xprt_get(XPRT_RAW);
Willy Tarreaud02394b2012-05-11 18:32:18 +0200817 newpeer->sock_init_arg = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100818 HA_SPIN_INIT(&newpeer->lock);
Willy Tarreau26d8c592012-05-07 18:12:14 +0200819
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100820 newpeer->srv = curpeers->peers_fe->srv;
821 if (!newpeer->local)
Frédéric Lécaille6617e762018-04-25 15:13:38 +0200822 goto out;
823
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100824 /* The lines above are reserved to "peer" lines. */
825 if (*args[0] == 's')
Frédéric Lécaille4ba51982018-04-25 15:32:18 +0200826 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200827
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100828 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 +0100829
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100830 if (!str2listener(args[2], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
831 if (errmsg && *errmsg) {
832 indent_msg(&errmsg, 2);
833 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 +0100834 }
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100835 else
836 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
837 file, linenum, args[0], args[1], args[2]);
838 err_code |= ERR_FATAL;
839 goto out;
840 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100841
842 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
843 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100844 l->accept = session_accept_fd;
845 l->analysers |= curpeers->peers_fe->fe_req_ana;
846 l->default_target = curpeers->peers_fe->default_target;
847 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100848 global.maxsock++; /* for the listening socket */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100849 }
850 else if (!strcmp(args[0], "table")) {
851 struct stktable *t, *other;
852 char *id;
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100853 size_t prefix_len;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100854
855 /* Line number and peer ID are updated only if this peer is the local one. */
856 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
857 err_code |= ERR_ALERT | ERR_ABORT;
858 goto out;
859 }
860
861 other = stktable_find_by_name(args[1]);
862 if (other) {
863 ha_alert("parsing [%s:%d] : stick-table name '%s' conflicts with table declared in %s '%s' at %s:%d.\n",
864 file, linenum, args[1],
865 other->proxy ? proxy_cap_str(other->proxy->cap) : "peers",
866 other->proxy ? other->id : other->peers.p->id,
867 other->conf.file, other->conf.line);
868 err_code |= ERR_ALERT | ERR_FATAL;
869 goto out;
870 }
871
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100872 /* Build the stick-table name, concatenating the "peers" section name
873 * followed by a '/' character and the table name argument.
874 */
875 chunk_reset(&trash);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100876 if (!chunk_strcpy(&trash, curpeers->id)) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100877 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
878 file, linenum, args[0], args[1]);
879 err_code |= ERR_ALERT | ERR_FATAL;
880 goto out;
881 }
882
883 prefix_len = trash.data;
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100884 if (!chunk_memcat(&trash, "/", 1) || !chunk_strcat(&trash, args[1])) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100885 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
886 file, linenum, args[0], args[1]);
887 err_code |= ERR_ALERT | ERR_FATAL;
888 goto out;
889 }
890
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100891 t = calloc(1, sizeof *t);
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100892 id = strdup(trash.area);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100893 if (!t || !id) {
894 ha_alert("parsing [%s:%d]: '%s %s' : memory allocation failed\n",
895 file, linenum, args[0], args[1]);
896 err_code |= ERR_ALERT | ERR_FATAL;
897 goto out;
898 }
899
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100900 err_code |= parse_stick_table(file, linenum, args, t, id, id + prefix_len, curpeers);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100901 if (err_code & ERR_FATAL)
902 goto out;
903
904 stktable_store_name(t);
905 t->next = stktables_list;
906 stktables_list = t;
907 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200908 else if (!strcmp(args[0], "disabled")) { /* disables this peers section */
909 curpeers->state = PR_STSTOPPED;
910 }
911 else if (!strcmp(args[0], "enabled")) { /* enables this peers section (used to revert a disabled default) */
912 curpeers->state = PR_STNEW;
913 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200914 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100915 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Emeric Brun32da3c42010-09-23 18:39:19 +0200916 err_code |= ERR_ALERT | ERR_FATAL;
917 goto out;
918 }
919
920out:
Willy Tarreau902636f2013-03-10 19:44:48 +0100921 free(errmsg);
Emeric Brun32da3c42010-09-23 18:39:19 +0200922 return err_code;
923}
924
Baptiste Assmann325137d2015-04-13 23:40:55 +0200925/*
926 * Parse a <resolvers> section.
927 * Returns the error code, 0 if OK, or any combination of :
928 * - ERR_ABORT: must abort ASAP
929 * - ERR_FATAL: we can continue parsing but not start the service
930 * - ERR_WARN: a warning has been emitted
931 * - ERR_ALERT: an alert has been emitted
932 * Only the two first ones can stop processing, the two others are just
933 * indicators.
934 */
935int cfg_parse_resolvers(const char *file, int linenum, char **args, int kwm)
936{
937 static struct dns_resolvers *curr_resolvers = NULL;
938 struct dns_nameserver *newnameserver = NULL;
939 const char *err;
940 int err_code = 0;
941 char *errmsg = NULL;
942
943 if (strcmp(args[0], "resolvers") == 0) { /* new resolvers section */
944 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100945 ha_alert("parsing [%s:%d] : missing name for resolvers section.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200946 err_code |= ERR_ALERT | ERR_ABORT;
947 goto out;
948 }
949
950 err = invalid_char(args[1]);
951 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100952 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
953 file, linenum, *err, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200954 err_code |= ERR_ALERT | ERR_ABORT;
955 goto out;
956 }
957
958 list_for_each_entry(curr_resolvers, &dns_resolvers, list) {
959 /* Error if two resolvers owns the same name */
960 if (strcmp(curr_resolvers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100961 ha_alert("Parsing [%s:%d]: resolvers '%s' has same name as another resolvers (declared at %s:%d).\n",
962 file, linenum, args[1], curr_resolvers->conf.file, curr_resolvers->conf.line);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200963 err_code |= ERR_ALERT | ERR_ABORT;
964 }
965 }
966
Vincent Bernat02779b62016-04-03 13:48:43 +0200967 if ((curr_resolvers = calloc(1, sizeof(*curr_resolvers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100968 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200969 err_code |= ERR_ALERT | ERR_ABORT;
970 goto out;
971 }
972
973 /* default values */
974 LIST_ADDQ(&dns_resolvers, &curr_resolvers->list);
975 curr_resolvers->conf.file = strdup(file);
976 curr_resolvers->conf.line = linenum;
977 curr_resolvers->id = strdup(args[1]);
978 curr_resolvers->query_ids = EB_ROOT;
Baptiste Assmann2af08fe2017-08-14 00:13:01 +0200979 /* default maximum response size */
980 curr_resolvers->accepted_payload_size = 512;
Baptiste Assmann987e16d2016-11-02 22:23:31 +0100981 /* default hold period for nx, other, refuse and timeout is 30s */
982 curr_resolvers->hold.nx = 30000;
983 curr_resolvers->hold.other = 30000;
984 curr_resolvers->hold.refused = 30000;
985 curr_resolvers->hold.timeout = 30000;
Baptiste Assmann686408b2017-08-18 10:15:42 +0200986 curr_resolvers->hold.obsolete = 0;
Baptiste Assmann325137d2015-04-13 23:40:55 +0200987 /* default hold period for valid is 10s */
Baptiste Assmann4c5490a2015-07-14 21:42:49 +0200988 curr_resolvers->hold.valid = 10000;
Christopher Faulet67957bd2017-09-27 11:00:59 +0200989 curr_resolvers->timeout.resolve = 1000;
990 curr_resolvers->timeout.retry = 1000;
Baptiste Assmann325137d2015-04-13 23:40:55 +0200991 curr_resolvers->resolve_retries = 3;
Christopher Faulet67957bd2017-09-27 11:00:59 +0200992 curr_resolvers->nb_nameservers = 0;
993 LIST_INIT(&curr_resolvers->nameservers);
994 LIST_INIT(&curr_resolvers->resolutions.curr);
995 LIST_INIT(&curr_resolvers->resolutions.wait);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100996 HA_SPIN_INIT(&curr_resolvers->lock);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200997 }
998 else if (strcmp(args[0], "nameserver") == 0) { /* nameserver definition */
999 struct sockaddr_storage *sk;
1000 int port1, port2;
1001 struct protocol *proto;
1002
1003 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001004 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1005 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001006 err_code |= ERR_ALERT | ERR_FATAL;
1007 goto out;
1008 }
1009
1010 err = invalid_char(args[1]);
1011 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001012 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1013 file, linenum, *err, args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001014 err_code |= ERR_ALERT | ERR_FATAL;
1015 goto out;
1016 }
1017
Christopher Faulet67957bd2017-09-27 11:00:59 +02001018 list_for_each_entry(newnameserver, &curr_resolvers->nameservers, list) {
Baptiste Assmanna315c552015-11-02 22:55:49 +01001019 /* Error if two resolvers owns the same name */
1020 if (strcmp(newnameserver->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001021 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 -06001022 file, linenum, args[1], newnameserver->conf.file, newnameserver->conf.line);
Baptiste Assmanna315c552015-11-02 22:55:49 +01001023 err_code |= ERR_ALERT | ERR_FATAL;
1024 }
1025 }
1026
Vincent Bernat02779b62016-04-03 13:48:43 +02001027 if ((newnameserver = calloc(1, sizeof(*newnameserver))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001028 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001029 err_code |= ERR_ALERT | ERR_ABORT;
1030 goto out;
1031 }
1032
1033 /* the nameservers are linked backward first */
Christopher Faulet67957bd2017-09-27 11:00:59 +02001034 LIST_ADDQ(&curr_resolvers->nameservers, &newnameserver->list);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001035 newnameserver->resolvers = curr_resolvers;
1036 newnameserver->conf.file = strdup(file);
1037 newnameserver->conf.line = linenum;
1038 newnameserver->id = strdup(args[1]);
1039
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001040 sk = str2sa_range(args[2], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001041 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001042 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001043 err_code |= ERR_ALERT | ERR_FATAL;
1044 goto out;
1045 }
1046
1047 proto = protocol_by_family(sk->ss_family);
1048 if (!proto || !proto->connect) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001049 ha_alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
Baptiste Assmann325137d2015-04-13 23:40:55 +02001050 file, linenum, args[0], args[1]);
1051 err_code |= ERR_ALERT | ERR_FATAL;
1052 goto out;
1053 }
1054
1055 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001056 ha_alert("parsing [%s:%d] : '%s %s' : port ranges and offsets are not allowed in '%s'\n",
1057 file, linenum, args[0], args[1], args[2]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001058 err_code |= ERR_ALERT | ERR_FATAL;
1059 goto out;
1060 }
1061
Baptiste Assmann7f43fa92016-01-21 00:59:46 +01001062 if (!port1 && !port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001063 ha_alert("parsing [%s:%d] : '%s %s' : no UDP port specified\n",
1064 file, linenum, args[0], args[1]);
Baptiste Assmann7f43fa92016-01-21 00:59:46 +01001065 err_code |= ERR_ALERT | ERR_FATAL;
1066 goto out;
1067 }
1068
Baptiste Assmann325137d2015-04-13 23:40:55 +02001069 newnameserver->addr = *sk;
1070 }
Ben Draut44e609b2018-05-29 15:40:08 -06001071 else if (strcmp(args[0], "parse-resolv-conf") == 0) {
1072 const char *whitespace = "\r\n\t ";
1073 char *resolv_line = NULL;
1074 int resolv_linenum = 0;
1075 FILE *f = NULL;
1076 char *address = NULL;
1077 struct sockaddr_storage *sk = NULL;
1078 struct protocol *proto;
1079 int duplicate_name = 0;
1080
1081 if ((resolv_line = malloc(sizeof(*resolv_line) * LINESIZE)) == NULL) {
1082 ha_alert("parsing [%s:%d] : out of memory.\n",
1083 file, linenum);
1084 err_code |= ERR_ALERT | ERR_FATAL;
1085 goto resolv_out;
1086 }
1087
1088 if ((f = fopen("/etc/resolv.conf", "r")) == NULL) {
1089 ha_alert("parsing [%s:%d] : failed to open /etc/resolv.conf.\n",
1090 file, linenum);
1091 err_code |= ERR_ALERT | ERR_FATAL;
1092 goto resolv_out;
1093 }
1094
1095 sk = calloc(1, sizeof(*sk));
1096 if (sk == NULL) {
1097 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n",
1098 resolv_linenum);
1099 err_code |= ERR_ALERT | ERR_FATAL;
1100 goto resolv_out;
1101 }
1102
1103 while (fgets(resolv_line, LINESIZE, f) != NULL) {
1104 resolv_linenum++;
1105 if (strncmp(resolv_line, "nameserver", 10) != 0)
1106 continue;
1107
1108 address = strtok(resolv_line + 10, whitespace);
1109 if (address == resolv_line + 10)
1110 continue;
1111
1112 if (address == NULL) {
1113 ha_warning("parsing [/etc/resolv.conf:%d] : nameserver line is missing address.\n",
1114 resolv_linenum);
1115 err_code |= ERR_WARN;
1116 continue;
1117 }
1118
1119 duplicate_name = 0;
1120 list_for_each_entry(newnameserver, &curr_resolvers->nameservers, list) {
1121 if (strcmp(newnameserver->id, address) == 0) {
1122 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",
1123 resolv_linenum, address, newnameserver->conf.file, newnameserver->conf.line);
1124 err_code |= ERR_WARN;
1125 duplicate_name = 1;
1126 }
1127 }
1128
1129 if (duplicate_name)
1130 continue;
1131
1132 memset(sk, 0, sizeof(*sk));
Willy Tarreau78675252020-05-28 18:07:10 +02001133 if (!str2ip2(address, sk, 1)) {
1134 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 -06001135 resolv_linenum, address);
1136 err_code |= ERR_WARN;
1137 continue;
1138 }
1139
1140 set_host_port(sk, 53);
1141
1142 proto = protocol_by_family(sk->ss_family);
1143 if (!proto || !proto->connect) {
1144 ha_warning("parsing [/etc/resolv.conf:%d] : '%s' : connect() not supported for this address family.\n",
1145 resolv_linenum, address);
1146 err_code |= ERR_WARN;
1147 continue;
1148 }
1149
1150 if ((newnameserver = calloc(1, sizeof(*newnameserver))) == NULL) {
1151 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1152 err_code |= ERR_ALERT | ERR_FATAL;
1153 goto resolv_out;
1154 }
1155
1156 newnameserver->conf.file = strdup("/etc/resolv.conf");
1157 if (newnameserver->conf.file == NULL) {
1158 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1159 err_code |= ERR_ALERT | ERR_FATAL;
1160 goto resolv_out;
1161 }
1162
1163 newnameserver->id = strdup(address);
1164 if (newnameserver->id == NULL) {
1165 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1166 err_code |= ERR_ALERT | ERR_FATAL;
1167 goto resolv_out;
1168 }
1169
1170 newnameserver->resolvers = curr_resolvers;
1171 newnameserver->conf.line = resolv_linenum;
1172 newnameserver->addr = *sk;
1173
1174 LIST_ADDQ(&curr_resolvers->nameservers, &newnameserver->list);
1175 }
1176
1177resolv_out:
1178 free(sk);
1179 free(resolv_line);
1180 if (f != NULL)
1181 fclose(f);
1182 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001183 else if (strcmp(args[0], "hold") == 0) { /* hold periods */
1184 const char *res;
1185 unsigned int time;
1186
1187 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001188 ha_alert("parsing [%s:%d] : '%s' expects an <event> and a <time> as arguments.\n",
1189 file, linenum, args[0]);
1190 ha_alert("<event> can be either 'valid', 'nx', 'refused', 'timeout', or 'other'\n");
Baptiste Assmann325137d2015-04-13 23:40:55 +02001191 err_code |= ERR_ALERT | ERR_FATAL;
1192 goto out;
1193 }
1194 res = parse_time_err(args[2], &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001195 if (res == PARSE_TIME_OVER) {
1196 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s>, maximum value is 2147483647 ms (~24.8 days).\n",
1197 file, linenum, args[1], args[0]);
1198 err_code |= ERR_ALERT | ERR_FATAL;
1199 goto out;
1200 }
1201 else if (res == PARSE_TIME_UNDER) {
1202 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s>, minimum non-null value is 1 ms.\n",
1203 file, linenum, args[1], args[0]);
1204 err_code |= ERR_ALERT | ERR_FATAL;
1205 goto out;
1206 }
1207 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001208 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s>.\n",
1209 file, linenum, *res, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001210 err_code |= ERR_ALERT | ERR_FATAL;
1211 goto out;
1212 }
Baptiste Assmann987e16d2016-11-02 22:23:31 +01001213 if (strcmp(args[1], "nx") == 0)
1214 curr_resolvers->hold.nx = time;
1215 else if (strcmp(args[1], "other") == 0)
1216 curr_resolvers->hold.other = time;
1217 else if (strcmp(args[1], "refused") == 0)
1218 curr_resolvers->hold.refused = time;
1219 else if (strcmp(args[1], "timeout") == 0)
1220 curr_resolvers->hold.timeout = time;
1221 else if (strcmp(args[1], "valid") == 0)
Baptiste Assmann325137d2015-04-13 23:40:55 +02001222 curr_resolvers->hold.valid = time;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02001223 else if (strcmp(args[1], "obsolete") == 0)
1224 curr_resolvers->hold.obsolete = time;
Baptiste Assmann325137d2015-04-13 23:40:55 +02001225 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001226 ha_alert("parsing [%s:%d] : '%s' unknown <event>: '%s', expects either 'nx', 'timeout', 'valid', 'obsolete' or 'other'.\n",
1227 file, linenum, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001228 err_code |= ERR_ALERT | ERR_FATAL;
1229 goto out;
1230 }
1231
1232 }
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001233 else if (strcmp(args[0], "accepted_payload_size") == 0) {
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001234 int i = 0;
1235
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001236 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001237 ha_alert("parsing [%s:%d] : '%s' expects <nb> as argument.\n",
1238 file, linenum, args[0]);
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001239 err_code |= ERR_ALERT | ERR_FATAL;
1240 goto out;
1241 }
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001242
1243 i = atoi(args[1]);
Willy Tarreau0c219be2017-08-22 12:01:26 +02001244 if (i < DNS_HEADER_SIZE || i > DNS_MAX_UDP_MESSAGE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001245 ha_alert("parsing [%s:%d] : '%s' must be between %d and %d inclusive (was %s).\n",
1246 file, linenum, args[0], DNS_HEADER_SIZE, DNS_MAX_UDP_MESSAGE, args[1]);
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001247 err_code |= ERR_ALERT | ERR_FATAL;
1248 goto out;
1249 }
1250
1251 curr_resolvers->accepted_payload_size = i;
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001252 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001253 else if (strcmp(args[0], "resolution_pool_size") == 0) {
Tim Duesterhus3506dae2019-05-14 20:57:56 +02001254 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 +01001255 file, linenum, args[0]);
Tim Duesterhus3506dae2019-05-14 20:57:56 +02001256 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001257 goto out;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001258 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001259 else if (strcmp(args[0], "resolve_retries") == 0) {
1260 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001261 ha_alert("parsing [%s:%d] : '%s' expects <nb> as argument.\n",
1262 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001263 err_code |= ERR_ALERT | ERR_FATAL;
1264 goto out;
1265 }
1266 curr_resolvers->resolve_retries = atoi(args[1]);
1267 }
1268 else if (strcmp(args[0], "timeout") == 0) {
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001269 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001270 ha_alert("parsing [%s:%d] : '%s' expects 'retry' or 'resolve' and <time> as arguments.\n",
1271 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001272 err_code |= ERR_ALERT | ERR_FATAL;
1273 goto out;
1274 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001275 else if (strcmp(args[1], "retry") == 0 ||
1276 strcmp(args[1], "resolve") == 0) {
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001277 const char *res;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001278 unsigned int tout;
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001279
1280 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001281 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1282 file, linenum, args[0], args[1]);
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001283 err_code |= ERR_ALERT | ERR_FATAL;
1284 goto out;
1285 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001286 res = parse_time_err(args[2], &tout, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001287 if (res == PARSE_TIME_OVER) {
1288 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\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 == PARSE_TIME_UNDER) {
1294 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1295 file, linenum, args[2], args[0], args[1]);
1296 err_code |= ERR_ALERT | ERR_FATAL;
1297 goto out;
1298 }
1299 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001300 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1301 file, linenum, *res, args[0], args[1]);
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001302 err_code |= ERR_ALERT | ERR_FATAL;
1303 goto out;
1304 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001305 if (args[1][2] == 't')
1306 curr_resolvers->timeout.retry = tout;
1307 else
1308 curr_resolvers->timeout.resolve = tout;
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001309 }
1310 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001311 ha_alert("parsing [%s:%d] : '%s' expects 'retry' or 'resolve' and <time> as arguments got '%s'.\n",
1312 file, linenum, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001313 err_code |= ERR_ALERT | ERR_FATAL;
1314 goto out;
1315 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001316 } /* neither "nameserver" nor "resolvers" */
1317 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001318 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001319 err_code |= ERR_ALERT | ERR_FATAL;
1320 goto out;
1321 }
1322
1323 out:
1324 free(errmsg);
1325 return err_code;
1326}
Simon Horman0d16a402015-01-30 11:22:58 +09001327
1328/*
William Lallemand51097192015-04-14 16:35:22 +02001329 * Parse a line in a <listen>, <frontend> or <backend> section.
Simon Horman0d16a402015-01-30 11:22:58 +09001330 * Returns the error code, 0 if OK, or any combination of :
1331 * - ERR_ABORT: must abort ASAP
1332 * - ERR_FATAL: we can continue parsing but not start the service
1333 * - ERR_WARN: a warning has been emitted
1334 * - ERR_ALERT: an alert has been emitted
1335 * Only the two first ones can stop processing, the two others are just
1336 * indicators.
1337 */
1338int cfg_parse_mailers(const char *file, int linenum, char **args, int kwm)
1339{
1340 static struct mailers *curmailers = NULL;
1341 struct mailer *newmailer = NULL;
1342 const char *err;
1343 int err_code = 0;
1344 char *errmsg = NULL;
1345
1346 if (strcmp(args[0], "mailers") == 0) { /* new mailers section */
1347 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001348 ha_alert("parsing [%s:%d] : missing name for mailers section.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001349 err_code |= ERR_ALERT | ERR_ABORT;
1350 goto out;
1351 }
1352
1353 err = invalid_char(args[1]);
1354 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001355 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
1356 file, linenum, *err, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001357 err_code |= ERR_ALERT | ERR_ABORT;
1358 goto out;
1359 }
1360
1361 for (curmailers = mailers; curmailers != NULL; curmailers = curmailers->next) {
1362 /*
1363 * If there are two proxies with the same name only following
1364 * combinations are allowed:
1365 */
1366 if (strcmp(curmailers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001367 ha_alert("Parsing [%s:%d]: mailers section '%s' has the same name as another mailers section declared at %s:%d.\n",
1368 file, linenum, args[1], curmailers->conf.file, curmailers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +02001369 err_code |= ERR_ALERT | ERR_FATAL;
Simon Horman0d16a402015-01-30 11:22:58 +09001370 }
1371 }
1372
Vincent Bernat02779b62016-04-03 13:48:43 +02001373 if ((curmailers = calloc(1, sizeof(*curmailers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001374 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001375 err_code |= ERR_ALERT | ERR_ABORT;
1376 goto out;
1377 }
1378
1379 curmailers->next = mailers;
1380 mailers = curmailers;
1381 curmailers->conf.file = strdup(file);
1382 curmailers->conf.line = linenum;
1383 curmailers->id = strdup(args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001384 curmailers->timeout.mail = DEF_MAILALERTTIME;/* XXX: Would like to Skip to the next alert, if any, ASAP.
1385 * But need enough time so that timeouts don't occur
1386 * during tcp procssing. For now just us an arbitrary default. */
Simon Horman0d16a402015-01-30 11:22:58 +09001387 }
1388 else if (strcmp(args[0], "mailer") == 0) { /* mailer definition */
1389 struct sockaddr_storage *sk;
1390 int port1, port2;
1391 struct protocol *proto;
1392
1393 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001394 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1395 file, linenum, args[0]);
Simon Horman0d16a402015-01-30 11:22:58 +09001396 err_code |= ERR_ALERT | ERR_FATAL;
1397 goto out;
1398 }
1399
1400 err = invalid_char(args[1]);
1401 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001402 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1403 file, linenum, *err, args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001404 err_code |= ERR_ALERT | ERR_FATAL;
1405 goto out;
1406 }
1407
Vincent Bernat02779b62016-04-03 13:48:43 +02001408 if ((newmailer = calloc(1, sizeof(*newmailer))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001409 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001410 err_code |= ERR_ALERT | ERR_ABORT;
1411 goto out;
1412 }
1413
1414 /* the mailers are linked backwards first */
1415 curmailers->count++;
1416 newmailer->next = curmailers->mailer_list;
1417 curmailers->mailer_list = newmailer;
1418 newmailer->mailers = curmailers;
1419 newmailer->conf.file = strdup(file);
1420 newmailer->conf.line = linenum;
1421
1422 newmailer->id = strdup(args[1]);
1423
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001424 sk = str2sa_range(args[2], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
Simon Horman0d16a402015-01-30 11:22:58 +09001425 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001426 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Simon Horman0d16a402015-01-30 11:22:58 +09001427 err_code |= ERR_ALERT | ERR_FATAL;
1428 goto out;
1429 }
1430
1431 proto = protocol_by_family(sk->ss_family);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09001432 if (!proto || !proto->connect || proto->sock_prot != IPPROTO_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001433 ha_alert("parsing [%s:%d] : '%s %s' : TCP not supported for this address family.\n",
1434 file, linenum, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001435 err_code |= ERR_ALERT | ERR_FATAL;
1436 goto out;
1437 }
1438
1439 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001440 ha_alert("parsing [%s:%d] : '%s %s' : port ranges and offsets are not allowed in '%s'\n",
1441 file, linenum, args[0], args[1], args[2]);
Simon Horman0d16a402015-01-30 11:22:58 +09001442 err_code |= ERR_ALERT | ERR_FATAL;
1443 goto out;
1444 }
1445
1446 if (!port1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001447 ha_alert("parsing [%s:%d] : '%s %s' : missing or invalid port in '%s'\n",
1448 file, linenum, args[0], args[1], args[2]);
Simon Horman0d16a402015-01-30 11:22:58 +09001449 err_code |= ERR_ALERT | ERR_FATAL;
1450 goto out;
1451 }
1452
1453 newmailer->addr = *sk;
1454 newmailer->proto = proto;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01001455 newmailer->xprt = xprt_get(XPRT_RAW);
Simon Horman0d16a402015-01-30 11:22:58 +09001456 newmailer->sock_init_arg = NULL;
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001457 }
1458 else if (strcmp(args[0], "timeout") == 0) {
1459 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001460 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments.\n",
1461 file, linenum, args[0]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001462 err_code |= ERR_ALERT | ERR_FATAL;
1463 goto out;
1464 }
1465 else if (strcmp(args[1], "mail") == 0) {
1466 const char *res;
1467 unsigned int timeout_mail;
1468 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001469 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1470 file, linenum, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001471 err_code |= ERR_ALERT | ERR_FATAL;
1472 goto out;
1473 }
1474 res = parse_time_err(args[2], &timeout_mail, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001475 if (res == PARSE_TIME_OVER) {
1476 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1477 file, linenum, args[2], args[0], args[1]);
1478 err_code |= ERR_ALERT | ERR_FATAL;
1479 goto out;
1480 }
1481 else if (res == PARSE_TIME_UNDER) {
1482 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1483 file, linenum, args[2], args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001484 err_code |= ERR_ALERT | ERR_FATAL;
1485 goto out;
1486 }
Willy Tarreau9faebe32019-06-07 19:00:37 +02001487 else if (res) {
1488 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1489 file, linenum, *res, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001490 err_code |= ERR_ALERT | ERR_FATAL;
1491 goto out;
1492 }
1493 curmailers->timeout.mail = timeout_mail;
1494 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001495 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments got '%s'.\n",
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001496 file, linenum, args[0], args[1]);
1497 err_code |= ERR_ALERT | ERR_FATAL;
1498 goto out;
1499 }
1500 }
Simon Horman0d16a402015-01-30 11:22:58 +09001501 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001502 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Simon Horman0d16a402015-01-30 11:22:58 +09001503 err_code |= ERR_ALERT | ERR_FATAL;
1504 goto out;
1505 }
1506
1507out:
1508 free(errmsg);
1509 return err_code;
1510}
1511
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +01001512void free_email_alert(struct proxy *p)
Simon Horman9dc49962015-01-30 11:22:59 +09001513{
1514 free(p->email_alert.mailers.name);
1515 p->email_alert.mailers.name = NULL;
1516 free(p->email_alert.from);
1517 p->email_alert.from = NULL;
1518 free(p->email_alert.to);
1519 p->email_alert.to = NULL;
1520 free(p->email_alert.myhostname);
1521 p->email_alert.myhostname = NULL;
1522}
1523
Willy Tarreaubaaee002006-06-26 02:48:02 +02001524
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001525int
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001526cfg_parse_netns(const char *file, int linenum, char **args, int kwm)
1527{
Willy Tarreaue5733232019-05-22 19:24:06 +02001528#ifdef USE_NS
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001529 const char *err;
1530 const char *item = args[0];
1531
1532 if (!strcmp(item, "namespace_list")) {
1533 return 0;
1534 }
1535 else if (!strcmp(item, "namespace")) {
1536 size_t idx = 1;
1537 const char *current;
1538 while (*(current = args[idx++])) {
1539 err = invalid_char(current);
1540 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001541 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1542 file, linenum, *err, item, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001543 return ERR_ALERT | ERR_FATAL;
1544 }
1545
1546 if (netns_store_lookup(current, strlen(current))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001547 ha_alert("parsing [%s:%d]: Namespace '%s' is already added.\n",
1548 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001549 return ERR_ALERT | ERR_FATAL;
1550 }
1551 if (!netns_store_insert(current)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001552 ha_alert("parsing [%s:%d]: Cannot open namespace '%s'.\n",
1553 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001554 return ERR_ALERT | ERR_FATAL;
1555 }
1556 }
1557 }
1558
1559 return 0;
1560#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001561 ha_alert("parsing [%s:%d]: namespace support is not compiled in.",
1562 file, linenum);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001563 return ERR_ALERT | ERR_FATAL;
1564#endif
1565}
1566
1567int
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001568cfg_parse_users(const char *file, int linenum, char **args, int kwm)
1569{
1570
1571 int err_code = 0;
1572 const char *err;
1573
1574 if (!strcmp(args[0], "userlist")) { /* new userlist */
1575 struct userlist *newul;
1576
1577 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001578 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1579 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001580 err_code |= ERR_ALERT | ERR_FATAL;
1581 goto out;
1582 }
William Lallemand6e62fb62015-04-28 16:55:23 +02001583 if (alertif_too_many_args(1, file, linenum, args, &err_code))
1584 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001585
1586 err = invalid_char(args[1]);
1587 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001588 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1589 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001590 err_code |= ERR_ALERT | ERR_FATAL;
1591 goto out;
1592 }
1593
1594 for (newul = userlist; newul; newul = newul->next)
1595 if (!strcmp(newul->name, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001596 ha_warning("parsing [%s:%d]: ignoring duplicated userlist '%s'.\n",
1597 file, linenum, args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001598 err_code |= ERR_WARN;
1599 goto out;
1600 }
1601
Vincent Bernat02779b62016-04-03 13:48:43 +02001602 newul = calloc(1, sizeof(*newul));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001603 if (!newul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001604 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001605 err_code |= ERR_ALERT | ERR_ABORT;
1606 goto out;
1607 }
1608
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001609 newul->name = strdup(args[1]);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001610 if (!newul->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001611 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001612 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier97880bb2016-04-08 10:35:26 +01001613 free(newul);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001614 goto out;
1615 }
1616
1617 newul->next = userlist;
1618 userlist = newul;
1619
1620 } else if (!strcmp(args[0], "group")) { /* new group */
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001621 int cur_arg;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001622 const char *err;
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001623 struct auth_groups *ag;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001624
1625 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001626 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1627 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001628 err_code |= ERR_ALERT | ERR_FATAL;
1629 goto out;
1630 }
1631
1632 err = invalid_char(args[1]);
1633 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001634 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1635 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001636 err_code |= ERR_ALERT | ERR_FATAL;
1637 goto out;
1638 }
1639
William Lallemand4ac9f542015-05-28 18:03:51 +02001640 if (!userlist)
1641 goto out;
1642
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001643 for (ag = userlist->groups; ag; ag = ag->next)
1644 if (!strcmp(ag->name, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001645 ha_warning("parsing [%s:%d]: ignoring duplicated group '%s' in userlist '%s'.\n",
1646 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001647 err_code |= ERR_ALERT;
1648 goto out;
1649 }
1650
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001651 ag = calloc(1, sizeof(*ag));
1652 if (!ag) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001653 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001654 err_code |= ERR_ALERT | ERR_ABORT;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001655 goto out;
1656 }
1657
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001658 ag->name = strdup(args[1]);
David Carlier70d60452016-08-22 23:27:42 +01001659 if (!ag->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001660 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001661 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier70d60452016-08-22 23:27:42 +01001662 free(ag);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001663 goto out;
1664 }
1665
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001666 cur_arg = 2;
1667
1668 while (*args[cur_arg]) {
1669 if (!strcmp(args[cur_arg], "users")) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001670 ag->groupusers = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001671 cur_arg += 2;
1672 continue;
1673 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001674 ha_alert("parsing [%s:%d]: '%s' only supports 'users' option.\n",
1675 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001676 err_code |= ERR_ALERT | ERR_FATAL;
David Carlier70d60452016-08-22 23:27:42 +01001677 free(ag->groupusers);
1678 free(ag->name);
1679 free(ag);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001680 goto out;
1681 }
1682 }
1683
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001684 ag->next = userlist->groups;
1685 userlist->groups = ag;
1686
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001687 } else if (!strcmp(args[0], "user")) { /* new user */
1688 struct auth_users *newuser;
1689 int cur_arg;
1690
1691 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001692 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1693 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001694 err_code |= ERR_ALERT | ERR_FATAL;
1695 goto out;
1696 }
William Lallemand4ac9f542015-05-28 18:03:51 +02001697 if (!userlist)
1698 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001699
1700 for (newuser = userlist->users; newuser; newuser = newuser->next)
1701 if (!strcmp(newuser->user, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001702 ha_warning("parsing [%s:%d]: ignoring duplicated user '%s' in userlist '%s'.\n",
1703 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001704 err_code |= ERR_ALERT;
1705 goto out;
1706 }
1707
Vincent Bernat02779b62016-04-03 13:48:43 +02001708 newuser = calloc(1, sizeof(*newuser));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001709 if (!newuser) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001710 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001711 err_code |= ERR_ALERT | ERR_ABORT;
1712 goto out;
1713 }
1714
1715 newuser->user = strdup(args[1]);
1716
1717 newuser->next = userlist->users;
1718 userlist->users = newuser;
1719
1720 cur_arg = 2;
1721
1722 while (*args[cur_arg]) {
1723 if (!strcmp(args[cur_arg], "password")) {
Willy Tarreaue5733232019-05-22 19:24:06 +02001724#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001725 if (!crypt("", args[cur_arg + 1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001726 ha_alert("parsing [%s:%d]: the encrypted password used for user '%s' is not supported by crypt(3).\n",
1727 file, linenum, newuser->user);
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001728 err_code |= ERR_ALERT | ERR_FATAL;
1729 goto out;
1730 }
1731#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001732 ha_warning("parsing [%s:%d]: no crypt(3) support compiled, encrypted passwords will not work.\n",
1733 file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001734 err_code |= ERR_ALERT;
1735#endif
1736 newuser->pass = strdup(args[cur_arg + 1]);
1737 cur_arg += 2;
1738 continue;
1739 } else if (!strcmp(args[cur_arg], "insecure-password")) {
1740 newuser->pass = strdup(args[cur_arg + 1]);
1741 newuser->flags |= AU_O_INSECURE;
1742 cur_arg += 2;
1743 continue;
1744 } else if (!strcmp(args[cur_arg], "groups")) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001745 newuser->u.groups_names = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001746 cur_arg += 2;
1747 continue;
1748 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001749 ha_alert("parsing [%s:%d]: '%s' only supports 'password', 'insecure-password' and 'groups' options.\n",
1750 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001751 err_code |= ERR_ALERT | ERR_FATAL;
1752 goto out;
1753 }
1754 }
1755 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001756 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 +01001757 err_code |= ERR_ALERT | ERR_FATAL;
1758 }
1759
1760out:
1761 return err_code;
1762}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001763
Christopher Faulet79bdef32016-11-04 22:36:15 +01001764int
1765cfg_parse_scope(const char *file, int linenum, char *line)
1766{
1767 char *beg, *end, *scope = NULL;
1768 int err_code = 0;
1769 const char *err;
1770
1771 beg = line + 1;
1772 end = strchr(beg, ']');
1773
1774 /* Detect end of scope declaration */
1775 if (!end || end == beg) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001776 ha_alert("parsing [%s:%d] : empty scope name is forbidden.\n",
1777 file, linenum);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001778 err_code |= ERR_ALERT | ERR_FATAL;
1779 goto out;
1780 }
1781
1782 /* Get scope name and check its validity */
1783 scope = my_strndup(beg, end-beg);
1784 err = invalid_char(scope);
1785 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001786 ha_alert("parsing [%s:%d] : character '%c' is not permitted in a scope name.\n",
1787 file, linenum, *err);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001788 err_code |= ERR_ALERT | ERR_ABORT;
1789 goto out;
1790 }
1791
1792 /* Be sure to have a scope declaration alone on its line */
1793 line = end+1;
1794 while (isspace((unsigned char)*line))
1795 line++;
1796 if (*line && *line != '#' && *line != '\n' && *line != '\r') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001797 ha_alert("parsing [%s:%d] : character '%c' is not permitted after scope declaration.\n",
1798 file, linenum, *line);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001799 err_code |= ERR_ALERT | ERR_ABORT;
1800 goto out;
1801 }
1802
1803 /* We have a valid scope declaration, save it */
1804 free(cfg_scope);
1805 cfg_scope = scope;
1806 scope = NULL;
1807
1808 out:
1809 free(scope);
1810 return err_code;
1811}
1812
Frédéric Lécaillea41d5312018-01-29 12:05:07 +01001813int
1814cfg_parse_track_sc_num(unsigned int *track_sc_num,
1815 const char *arg, const char *end, char **errmsg)
1816{
1817 const char *p;
1818 unsigned int num;
1819
1820 p = arg;
1821 num = read_uint64(&arg, end);
1822
1823 if (arg != end) {
1824 memprintf(errmsg, "Wrong track-sc number '%s'", p);
1825 return -1;
1826 }
1827
1828 if (num >= MAX_SESS_STKCTR) {
1829 memprintf(errmsg, "%u track-sc number exceeding "
1830 "%d (MAX_SESS_STKCTR-1) value", num, MAX_SESS_STKCTR - 1);
1831 return -1;
1832 }
1833
1834 *track_sc_num = num;
1835 return 0;
1836}
1837
Willy Tarreaubaaee002006-06-26 02:48:02 +02001838/*
1839 * This function reads and parses the configuration file given in the argument.
Willy Tarreau058e9072009-07-20 09:30:05 +02001840 * Returns the error code, 0 if OK, or any combination of :
1841 * - ERR_ABORT: must abort ASAP
1842 * - ERR_FATAL: we can continue parsing but not start the service
1843 * - ERR_WARN: a warning has been emitted
1844 * - ERR_ALERT: an alert has been emitted
1845 * Only the two first ones can stop processing, the two others are just
1846 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001847 */
Willy Tarreaub17916e2006-10-15 15:17:57 +02001848int readcfgfile(const char *file)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001849{
William Lallemand64e84512015-05-12 14:25:37 +02001850 char *thisline;
1851 int linesize = LINESIZE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001852 FILE *f;
1853 int linenum = 0;
Willy Tarreau058e9072009-07-20 09:30:05 +02001854 int err_code = 0;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001855 struct cfg_section *cs = NULL, *pcs = NULL;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001856 struct cfg_section *ics;
William Lallemand64e84512015-05-12 14:25:37 +02001857 int readbytes = 0;
1858
1859 if ((thisline = malloc(sizeof(*thisline) * linesize)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001860 ha_alert("parsing [%s] : out of memory.\n", file);
William Lallemand64e84512015-05-12 14:25:37 +02001861 return -1;
1862 }
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001863
David Carlier97880bb2016-04-08 10:35:26 +01001864 if ((f=fopen(file,"r")) == NULL) {
1865 free(thisline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001866 return -1;
David Carlier97880bb2016-04-08 10:35:26 +01001867 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001868
William Lallemandb2f07452015-05-12 14:27:13 +02001869next_line:
William Lallemand64e84512015-05-12 14:25:37 +02001870 while (fgets(thisline + readbytes, linesize - readbytes, f) != NULL) {
Willy Tarreau3842f002009-06-14 11:39:52 +02001871 int arg, kwm = KWM_STD;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001872 char *end;
1873 char *args[MAX_LINE_ARGS + 1];
1874 char *line = thisline;
William Lallemandf9873ba2015-05-05 17:37:14 +02001875 int dquote = 0; /* double quote */
1876 int squote = 0; /* simple quote */
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001877
Willy Tarreaubaaee002006-06-26 02:48:02 +02001878 linenum++;
1879
1880 end = line + strlen(line);
1881
William Lallemand64e84512015-05-12 14:25:37 +02001882 if (end-line == linesize-1 && *(end-1) != '\n') {
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001883 /* Check if we reached the limit and the last char is not \n.
1884 * Watch out for the last line without the terminating '\n'!
1885 */
William Lallemand64e84512015-05-12 14:25:37 +02001886 char *newline;
1887 int newlinesize = linesize * 2;
1888
1889 newline = realloc(thisline, sizeof(*thisline) * newlinesize);
1890 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001891 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1892 file, linenum);
William Lallemand64e84512015-05-12 14:25:37 +02001893 err_code |= ERR_ALERT | ERR_FATAL;
1894 continue;
1895 }
1896
1897 readbytes = linesize - 1;
1898 linesize = newlinesize;
1899 thisline = newline;
1900 continue;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001901 }
1902
William Lallemand64e84512015-05-12 14:25:37 +02001903 readbytes = 0;
1904
Willy Tarreaubaaee002006-06-26 02:48:02 +02001905 /* skip leading spaces */
Willy Tarreau8f8e6452007-06-17 21:51:38 +02001906 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001907 line++;
William Lallemandf9873ba2015-05-05 17:37:14 +02001908
Christopher Faulet79bdef32016-11-04 22:36:15 +01001909
Joseph Herlanta14c03e2018-11-15 14:04:19 -08001910 if (*line == '[') {/* This is the beginning if a scope */
Christopher Faulet79bdef32016-11-04 22:36:15 +01001911 err_code |= cfg_parse_scope(file, linenum, line);
1912 goto next_line;
1913 }
1914
Willy Tarreaubaaee002006-06-26 02:48:02 +02001915 arg = 0;
1916 args[arg] = line;
1917
1918 while (*line && arg < MAX_LINE_ARGS) {
William Lallemandf9873ba2015-05-05 17:37:14 +02001919 if (*line == '"' && !squote) { /* double quote outside single quotes */
1920 if (dquote)
1921 dquote = 0;
1922 else
1923 dquote = 1;
William Lallemand3f415602015-05-12 14:01:09 +02001924 memmove(line, line + 1, end - line);
William Lallemandf9873ba2015-05-05 17:37:14 +02001925 end--;
1926 }
1927 else if (*line == '\'' && !dquote) { /* single quote outside double quotes */
1928 if (squote)
1929 squote = 0;
1930 else
1931 squote = 1;
William Lallemand3f415602015-05-12 14:01:09 +02001932 memmove(line, line + 1, end - line);
William Lallemandf9873ba2015-05-05 17:37:14 +02001933 end--;
1934 }
1935 else if (*line == '\\' && !squote) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001936 /* first, we'll replace \\, \<space>, \#, \r, \n, \t, \xXX with their
1937 * C equivalent value. Other combinations left unchanged (eg: \1).
1938 */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001939 int skip = 0;
1940 if (line[1] == ' ' || line[1] == '\\' || line[1] == '#') {
1941 *line = line[1];
1942 skip = 1;
1943 }
1944 else if (line[1] == 'r') {
1945 *line = '\r';
1946 skip = 1;
William Lallemandf9873ba2015-05-05 17:37:14 +02001947 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001948 else if (line[1] == 'n') {
1949 *line = '\n';
1950 skip = 1;
1951 }
1952 else if (line[1] == 't') {
1953 *line = '\t';
1954 skip = 1;
1955 }
1956 else if (line[1] == 'x') {
Emeric Brunb982a3d2010-01-04 15:45:53 +01001957 if ((line + 3 < end) && ishex(line[2]) && ishex(line[3])) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001958 unsigned char hex1, hex2;
1959 hex1 = toupper(line[2]) - '0';
1960 hex2 = toupper(line[3]) - '0';
1961 if (hex1 > 9) hex1 -= 'A' - '9' - 1;
1962 if (hex2 > 9) hex2 -= 'A' - '9' - 1;
1963 *line = (hex1<<4) + hex2;
1964 skip = 3;
1965 }
1966 else {
Tim Duesterhusac4930e2020-05-07 19:24:20 +02001967 ha_alert("parsing [%s:%d] : invalid or incomplete '\\x' sequence '%.*s' in '%s'.\n", file, linenum, 4, line, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02001968 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhuse6291952020-05-07 19:21:31 +02001969 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001970 }
William Lallemandf9873ba2015-05-05 17:37:14 +02001971 } else if (line[1] == '"') {
1972 *line = '"';
1973 skip = 1;
1974 } else if (line[1] == '\'') {
1975 *line = '\'';
1976 skip = 1;
William Lallemandb2f07452015-05-12 14:27:13 +02001977 } else if (line[1] == '$' && dquote) { /* escaping of $ only inside double quotes */
1978 *line = '$';
1979 skip = 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001980 }
1981 if (skip) {
Cyril Bontédd1b01d2009-12-06 13:43:42 +01001982 memmove(line + 1, line + 1 + skip, end - (line + skip));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001983 end -= skip;
1984 }
1985 line++;
1986 }
William Lallemandf9873ba2015-05-05 17:37:14 +02001987 else if ((!squote && !dquote && *line == '#') || *line == '\n' || *line == '\r') {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001988 /* end of string, end of loop */
1989 *line = 0;
1990 break;
1991 }
William Lallemandf9873ba2015-05-05 17:37:14 +02001992 else if (!squote && !dquote && isspace((unsigned char)*line)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001993 /* a non-escaped space is an argument separator */
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001994 *line++ = '\0';
Willy Tarreau8f8e6452007-06-17 21:51:38 +02001995 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001996 line++;
1997 args[++arg] = line;
1998 }
William Lallemandb2f07452015-05-12 14:27:13 +02001999 else if (dquote && *line == '$') {
2000 /* environment variables are evaluated inside double quotes */
2001 char *var_beg;
2002 char *var_end;
2003 char save_char;
2004 char *value;
2005 int val_len;
2006 int newlinesize;
2007 int braces = 0;
2008
2009 var_beg = line + 1;
2010 var_end = var_beg;
2011
2012 if (*var_beg == '{') {
2013 var_beg++;
2014 var_end++;
2015 braces = 1;
2016 }
2017
Willy Tarreau90807112020-02-25 08:16:33 +01002018 if (!isalpha((unsigned char)*var_beg) && *var_beg != '_') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002019 ha_alert("parsing [%s:%d] : Variable expansion: Unrecognized character '%c' in variable name.\n", file, linenum, *var_beg);
William Lallemandb2f07452015-05-12 14:27:13 +02002020 err_code |= ERR_ALERT | ERR_FATAL;
2021 goto next_line; /* skip current line */
2022 }
2023
Willy Tarreau90807112020-02-25 08:16:33 +01002024 while (isalnum((unsigned char)*var_end) || *var_end == '_')
William Lallemandb2f07452015-05-12 14:27:13 +02002025 var_end++;
2026
2027 save_char = *var_end;
2028 *var_end = '\0';
2029 value = getenv(var_beg);
2030 *var_end = save_char;
2031 val_len = value ? strlen(value) : 0;
2032
2033 if (braces) {
2034 if (*var_end == '}') {
2035 var_end++;
2036 braces = 0;
2037 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002038 ha_alert("parsing [%s:%d] : Variable expansion: Mismatched braces.\n", file, linenum);
William Lallemandb2f07452015-05-12 14:27:13 +02002039 err_code |= ERR_ALERT | ERR_FATAL;
2040 goto next_line; /* skip current line */
2041 }
2042 }
2043
2044 newlinesize = (end - thisline) - (var_end - line) + val_len + 1;
2045
2046 /* if not enough space in thisline */
2047 if (newlinesize > linesize) {
2048 char *newline;
2049
2050 newline = realloc(thisline, newlinesize * sizeof(*thisline));
2051 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002052 ha_alert("parsing [%s:%d] : Variable expansion: Not enough memory.\n", file, linenum);
William Lallemandb2f07452015-05-12 14:27:13 +02002053 err_code |= ERR_ALERT | ERR_FATAL;
2054 goto next_line; /* slip current line */
2055 }
2056 /* recompute pointers if realloc returns a new pointer */
2057 if (newline != thisline) {
2058 int i;
2059 int diff;
2060
2061 for (i = 0; i <= arg; i++) {
2062 diff = args[i] - thisline;
2063 args[i] = newline + diff;
2064 }
2065
2066 diff = var_end - thisline;
2067 var_end = newline + diff;
2068 diff = end - thisline;
2069 end = newline + diff;
2070 diff = line - thisline;
2071 line = newline + diff;
2072 thisline = newline;
2073 }
2074 linesize = newlinesize;
2075 }
2076
2077 /* insert value inside the line */
2078 memmove(line + val_len, var_end, end - var_end + 1);
2079 memcpy(line, value, val_len);
2080 end += val_len - (var_end - line);
2081 line += val_len;
2082 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002083 else {
2084 line++;
2085 }
2086 }
William Lallemandb2f07452015-05-12 14:27:13 +02002087
William Lallemandf9873ba2015-05-05 17:37:14 +02002088 if (dquote) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002089 ha_alert("parsing [%s:%d] : Mismatched double quotes.\n", file, linenum);
William Lallemandf9873ba2015-05-05 17:37:14 +02002090 err_code |= ERR_ALERT | ERR_FATAL;
2091 }
2092
2093 if (squote) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002094 ha_alert("parsing [%s:%d] : Mismatched simple quotes.\n", file, linenum);
William Lallemandf9873ba2015-05-05 17:37:14 +02002095 err_code |= ERR_ALERT | ERR_FATAL;
2096 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002097
2098 /* empty line */
2099 if (!**args)
2100 continue;
2101
Willy Tarreau7bb651e2009-11-09 21:16:53 +01002102 if (*line) {
2103 /* we had to stop due to too many args.
2104 * Let's terminate the string, print the offending part then cut the
2105 * last arg.
2106 */
2107 while (*line && *line != '#' && *line != '\n' && *line != '\r')
2108 line++;
2109 *line = '\0';
2110
Christopher Faulet767a84b2017-11-24 16:50:31 +01002111 ha_alert("parsing [%s:%d]: line too long, truncating at word %d, position %ld: <%s>.\n",
2112 file, linenum, arg + 1, (long)(args[arg] - thisline + 1), args[arg]);
Willy Tarreau7bb651e2009-11-09 21:16:53 +01002113 err_code |= ERR_ALERT | ERR_FATAL;
2114 args[arg] = line;
2115 }
2116
Willy Tarreau540abe42007-05-02 20:50:16 +02002117 /* zero out remaining args and ensure that at least one entry
2118 * is zeroed out.
2119 */
2120 while (++arg <= MAX_LINE_ARGS) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02002121 args[arg] = line;
2122 }
2123
Willy Tarreau3842f002009-06-14 11:39:52 +02002124 /* check for keyword modifiers "no" and "default" */
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002125 if (!strcmp(args[0], "no")) {
William Lallemand0f99e342011-10-12 17:50:54 +02002126 char *tmp;
2127
Willy Tarreau3842f002009-06-14 11:39:52 +02002128 kwm = KWM_NO;
William Lallemand0f99e342011-10-12 17:50:54 +02002129 tmp = args[0];
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002130 for (arg=0; *args[arg+1]; arg++)
2131 args[arg] = args[arg+1]; // shift args after inversion
William Lallemand0f99e342011-10-12 17:50:54 +02002132 *tmp = '\0'; // fix the next arg to \0
2133 args[arg] = tmp;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002134 }
Willy Tarreau3842f002009-06-14 11:39:52 +02002135 else if (!strcmp(args[0], "default")) {
2136 kwm = KWM_DEF;
2137 for (arg=0; *args[arg+1]; arg++)
2138 args[arg] = args[arg+1]; // shift args after inversion
2139 }
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002140
William Dauchyec730982019-10-27 20:08:10 +01002141 if (kwm != KWM_STD && strcmp(args[0], "option") != 0 &&
2142 strcmp(args[0], "log") != 0 && strcmp(args[0], "busy-polling") != 0 &&
Willy Tarreaud96f1122019-12-03 07:07:36 +01002143 strcmp(args[0], "set-dumpable") != 0 && strcmp(args[0], "strict-limits") != 0 &&
2144 strcmp(args[0], "insecure-fork-wanted") != 0) {
William Dauchyec730982019-10-27 20:08:10 +01002145 ha_alert("parsing [%s:%d]: negation/default currently "
William Dauchy0fec3ab2019-10-27 20:08:11 +01002146 "supported only for options, log, busy-polling, "
Willy Tarreaud96f1122019-12-03 07:07:36 +01002147 "set-dumpable, strict-limits, and insecure-fork-wanted.\n", file, linenum);
Willy Tarreau058e9072009-07-20 09:30:05 +02002148 err_code |= ERR_ALERT | ERR_FATAL;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002149 }
2150
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002151 /* detect section start */
2152 list_for_each_entry(ics, &sections, list) {
2153 if (strcmp(args[0], ics->section_name) == 0) {
2154 cursection = ics->section_name;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002155 pcs = cs;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002156 cs = ics;
2157 break;
2158 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002159 }
2160
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002161 if (pcs && pcs->post_section_parser) {
2162 err_code |= pcs->post_section_parser();
2163 if (err_code & ERR_ABORT)
2164 goto err;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002165 }
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002166 pcs = NULL;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002167
William Lallemandd2ff56d2017-10-16 11:06:50 +02002168 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002169 ha_alert("parsing [%s:%d]: unknown keyword '%s' out of section.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02002170 err_code |= ERR_ALERT | ERR_FATAL;
William Lallemandd2ff56d2017-10-16 11:06:50 +02002171 } else {
William Lallemandd2ff56d2017-10-16 11:06:50 +02002172 err_code |= cs->section_parser(file, linenum, args, kwm);
2173 if (err_code & ERR_ABORT)
2174 goto err;
2175 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002176 }
William Lallemandd2ff56d2017-10-16 11:06:50 +02002177
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002178 if (cs && cs->post_section_parser)
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002179 err_code |= cs->post_section_parser();
William Lallemandd2ff56d2017-10-16 11:06:50 +02002180
2181err:
Christopher Faulet79bdef32016-11-04 22:36:15 +01002182 free(cfg_scope);
2183 cfg_scope = NULL;
Willy Tarreau6daf3432008-01-22 16:44:08 +01002184 cursection = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02002185 free(thisline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002186 fclose(f);
Willy Tarreau058e9072009-07-20 09:30:05 +02002187 return err_code;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002188}
2189
Willy Tarreau64ab6072014-09-16 12:17:36 +02002190/* This function propagates processes from frontend <from> to backend <to> so
2191 * that it is always guaranteed that a backend pointed to by a frontend is
2192 * bound to all of its processes. After that, if the target is a "listen"
2193 * instance, the function recursively descends the target's own targets along
Willy Tarreau98d04852015-05-26 12:18:29 +02002194 * default_backend and use_backend rules. Since the bits are
Willy Tarreau64ab6072014-09-16 12:17:36 +02002195 * checked first to ensure that <to> is already bound to all processes of
2196 * <from>, there is no risk of looping and we ensure to follow the shortest
2197 * path to the destination.
2198 *
2199 * It is possible to set <to> to NULL for the first call so that the function
2200 * takes care of visiting the initial frontend in <from>.
2201 *
2202 * It is important to note that the function relies on the fact that all names
2203 * have already been resolved.
2204 */
2205void propagate_processes(struct proxy *from, struct proxy *to)
2206{
2207 struct switching_rule *rule;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002208
2209 if (to) {
2210 /* check whether we need to go down */
2211 if (from->bind_proc &&
2212 (from->bind_proc & to->bind_proc) == from->bind_proc)
2213 return;
2214
2215 if (!from->bind_proc && !to->bind_proc)
2216 return;
2217
2218 to->bind_proc = from->bind_proc ?
2219 (to->bind_proc | from->bind_proc) : 0;
2220
2221 /* now propagate down */
2222 from = to;
2223 }
2224
Willy Tarreau8a95d8c2014-12-18 13:56:26 +01002225 if (!(from->cap & PR_CAP_FE))
Willy Tarreau64ab6072014-09-16 12:17:36 +02002226 return;
2227
Willy Tarreauf6b70012014-12-18 14:00:43 +01002228 if (from->state == PR_STSTOPPED)
2229 return;
2230
Willy Tarreau64ab6072014-09-16 12:17:36 +02002231 /* default_backend */
2232 if (from->defbe.be)
2233 propagate_processes(from, from->defbe.be);
2234
2235 /* use_backend */
2236 list_for_each_entry(rule, &from->switching_rules, list) {
Cyril Bonté51639692014-10-02 19:56:25 +02002237 if (rule->dynamic)
2238 continue;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002239 to = rule->be.backend;
2240 propagate_processes(from, to);
2241 }
Willy Tarreau64ab6072014-09-16 12:17:36 +02002242}
2243
Willy Tarreaubb925012009-07-23 13:36:36 +02002244/*
2245 * Returns the error code, 0 if OK, or any combination of :
2246 * - ERR_ABORT: must abort ASAP
2247 * - ERR_FATAL: we can continue parsing but not start the service
2248 * - ERR_WARN: a warning has been emitted
2249 * - ERR_ALERT: an alert has been emitted
2250 * Only the two first ones can stop processing, the two others are just
2251 * indicators.
2252 */
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002253int check_config_validity()
2254{
2255 int cfgerr = 0;
2256 struct proxy *curproxy = NULL;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002257 struct stktable *t;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002258 struct server *newsrv = NULL;
Willy Tarreaubb925012009-07-23 13:36:36 +02002259 int err_code = 0;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002260 unsigned int next_pxid = 1;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002261 struct bind_conf *bind_conf;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002262 char *err;
William Lallemand48b4bb42017-10-23 14:36:34 +02002263 struct cfg_postparser *postparser;
Ben Draut054fbee2018-04-13 15:43:04 -06002264 struct dns_resolvers *curr_resolvers = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002265
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002266 bind_conf = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002267 /*
2268 * Now, check for the integrity of all that we have collected.
2269 */
2270
2271 /* will be needed further to delay some tasks */
Willy Tarreaub0b37bc2008-06-23 14:00:57 +02002272 tv_update_date(0,1);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002273
Willy Tarreau193b8c62012-11-22 00:17:38 +01002274 if (!global.tune.max_http_hdr)
2275 global.tune.max_http_hdr = MAX_HTTP_HDR;
2276
2277 if (!global.tune.cookie_len)
2278 global.tune.cookie_len = CAPTURE_LEN;
2279
Stéphane Cottin23e9e932017-05-18 08:58:41 +02002280 if (!global.tune.requri_len)
2281 global.tune.requri_len = REQURI_LEN;
2282
Willy Tarreau149ab772019-01-26 14:27:06 +01002283 if (!global.nbthread) {
2284 /* nbthread not set, thus automatic. In this case, and only if
2285 * running on a single process, we enable the same number of
2286 * threads as the number of CPUs the process is bound to. This
2287 * allows to easily control the number of threads using taskset.
2288 */
2289 global.nbthread = 1;
2290#if defined(USE_THREAD)
2291 if (global.nbproc == 1)
2292 global.nbthread = thread_cpus_enabled_at_boot;
2293 all_threads_mask = nbits(global.nbthread);
2294#endif
2295 }
2296
Willy Tarreau26f6ae12019-02-02 12:56:15 +01002297 if (global.nbproc > 1 && global.nbthread > 1) {
2298 ha_alert("config : cannot enable multiple processes if multiple threads are configured. Please use either nbproc or nbthread but not both.\n");
2299 err_code |= ERR_ALERT | ERR_FATAL;
2300 goto out;
2301 }
2302
Willy Tarreaubafbe012017-11-24 17:34:44 +01002303 pool_head_requri = create_pool("requri", global.tune.requri_len , MEM_F_SHARED);
Emeric Brun96fd9262017-07-05 13:33:16 +02002304
Willy Tarreaubafbe012017-11-24 17:34:44 +01002305 pool_head_capture = create_pool("capture", global.tune.cookie_len, MEM_F_SHARED);
Willy Tarreau193b8c62012-11-22 00:17:38 +01002306
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002307 /* Post initialisation of the users and groups lists. */
2308 err_code = userlist_postinit();
2309 if (err_code != ERR_NONE)
2310 goto out;
2311
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002312 /* first, we will invert the proxy list order */
2313 curproxy = NULL;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002314 while (proxies_list) {
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002315 struct proxy *next;
2316
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002317 next = proxies_list->next;
2318 proxies_list->next = curproxy;
2319 curproxy = proxies_list;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002320 if (!next)
2321 break;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002322 proxies_list = next;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002323 }
2324
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002325 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002326 struct switching_rule *rule;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002327 struct server_rule *srule;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002328 struct sticking_rule *mrule;
Christopher Faulete4e830d2017-09-18 14:51:41 +02002329 struct act_rule *arule;
Dragan Dosen1322d092015-09-22 16:05:32 +02002330 struct logsrv *tmplogsrv;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002331 unsigned int next_id;
Willy Tarreau16a21472012-11-19 12:39:59 +01002332 int nbproc;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002333
Willy Tarreau050536d2012-10-04 08:47:34 +02002334 if (curproxy->uuid < 0) {
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002335 /* proxy ID not set, use automatic numbering with first
2336 * spare entry starting with next_pxid.
2337 */
2338 next_pxid = get_next_id(&used_proxy_id, next_pxid);
2339 curproxy->conf.id.key = curproxy->uuid = next_pxid;
2340 eb32_insert(&used_proxy_id, &curproxy->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002341 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01002342 next_pxid++;
2343
Willy Tarreau55ea7572007-06-17 19:56:27 +02002344
Willy Tarreaubaaee002006-06-26 02:48:02 +02002345 if (curproxy->state == PR_STSTOPPED) {
Willy Tarreauda250db2008-10-12 12:07:48 +02002346 /* ensure we don't keep listeners uselessly bound */
2347 stop_proxy(curproxy);
Dragan Dosen7d61a332019-05-07 14:16:18 +02002348 if (curproxy->table) {
2349 free((void *)curproxy->table->peers.name);
2350 curproxy->table->peers.p = NULL;
2351 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002352 continue;
2353 }
2354
Willy Tarreau102df612014-05-07 23:56:38 +02002355 /* Check multi-process mode compatibility for the current proxy */
2356
2357 if (curproxy->bind_proc) {
2358 /* an explicit bind-process was specified, let's check how many
2359 * processes remain.
2360 */
David Carliere6c39412015-07-02 07:00:17 +00002361 nbproc = my_popcountl(curproxy->bind_proc);
Willy Tarreau102df612014-05-07 23:56:38 +02002362
Willy Tarreaua38a7172019-02-02 17:11:28 +01002363 curproxy->bind_proc &= all_proc_mask;
Willy Tarreau102df612014-05-07 23:56:38 +02002364 if (!curproxy->bind_proc && nbproc == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002365 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 +02002366 curproxy->bind_proc = 1;
2367 }
2368 else if (!curproxy->bind_proc && nbproc > 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002369 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 +02002370 curproxy->bind_proc = 0;
2371 }
2372 }
2373
Willy Tarreau3d209582014-05-09 17:06:11 +02002374 /* check and reduce the bind-proc of each listener */
2375 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
2376 unsigned long mask;
2377
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002378 /* HTTP frontends with "h2" as ALPN/NPN will work in
2379 * HTTP/2 and absolutely require buffers 16kB or larger.
2380 */
2381#ifdef USE_OPENSSL
2382 if (curproxy->mode == PR_MODE_HTTP && global.tune.bufsize < 16384) {
2383#ifdef OPENSSL_NPN_NEGOTIATED
2384 /* check NPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002385 if (bind_conf->ssl_conf.npn_str && strstr(bind_conf->ssl_conf.npn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002386 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",
2387 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002388 cfgerr++;
2389 }
2390#endif
2391#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
2392 /* check ALPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002393 if (bind_conf->ssl_conf.alpn_str && strstr(bind_conf->ssl_conf.alpn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002394 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",
2395 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002396 cfgerr++;
2397 }
2398#endif
2399 } /* HTTP && bufsize < 16384 */
2400#endif
2401
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002402 /* detect and address thread affinity inconsistencies */
Willy Tarreaua36b3242019-02-02 13:14:34 +01002403 mask = thread_mask(bind_conf->bind_thread);
Willy Tarreau3d957172019-02-02 18:00:17 +01002404 if (!(mask & all_threads_mask)) {
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002405 unsigned long new_mask = 0;
2406
2407 while (mask) {
Willy Tarreau0c026f42018-08-01 19:12:20 +02002408 new_mask |= mask & all_threads_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002409 mask >>= global.nbthread;
2410 }
2411
Willy Tarreaua36b3242019-02-02 13:14:34 +01002412 bind_conf->bind_thread = new_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002413 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",
2414 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line, new_mask);
2415 }
2416
2417 /* detect process and nbproc affinity inconsistencies */
Willy Tarreaua36b3242019-02-02 13:14:34 +01002418 mask = proc_mask(bind_conf->bind_proc) & proc_mask(curproxy->bind_proc);
2419 if (!(mask & all_proc_mask)) {
2420 mask = proc_mask(curproxy->bind_proc) & all_proc_mask;
2421 nbproc = my_popcountl(bind_conf->bind_proc);
2422 bind_conf->bind_proc = proc_mask(bind_conf->bind_proc) & mask;
Willy Tarreau3d209582014-05-09 17:06:11 +02002423
Willy Tarreaua36b3242019-02-02 13:14:34 +01002424 if (!bind_conf->bind_proc && nbproc == 1) {
2425 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",
2426 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
2427 bind_conf->bind_proc = mask & ~(mask - 1);
2428 }
2429 else if (!bind_conf->bind_proc && nbproc > 1) {
2430 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",
2431 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
2432 bind_conf->bind_proc = 0;
2433 }
Willy Tarreau3d209582014-05-09 17:06:11 +02002434 }
2435 }
2436
Willy Tarreauff01a212009-03-15 13:46:16 +01002437 switch (curproxy->mode) {
2438 case PR_MODE_HEALTH:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002439 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002440 if (!(curproxy->cap & PR_CAP_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002441 ha_alert("config : %s '%s' cannot be in health mode as it has no frontend capability.\n",
2442 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +01002443 cfgerr++;
2444 }
2445
2446 if (curproxy->srv != NULL)
Christopher Faulet767a84b2017-11-24 16:50:31 +01002447 ha_warning("config : servers will be ignored for %s '%s'.\n",
2448 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +01002449 break;
2450
2451 case PR_MODE_TCP:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002452 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002453 break;
2454
2455 case PR_MODE_HTTP:
Willy Tarreau25320b22013-03-24 07:22:08 +01002456 curproxy->http_needed = 1;
Willy Tarreauff01a212009-03-15 13:46:16 +01002457 break;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002458
2459 case PR_MODE_CLI:
2460 cfgerr += proxy_cfg_ensure_no_http(curproxy);
2461 break;
Willy Tarreauff01a212009-03-15 13:46:16 +01002462 }
2463
Willy Tarreau58aa5cc2018-02-08 09:55:09 +01002464 if (curproxy != global.stats_fe && (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->conf.listeners)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002465 ha_warning("config : %s '%s' has no 'bind' directive. Please declare it as a backend if this was intended.\n",
2466 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauf3934b82015-08-11 11:36:45 +02002467 err_code |= ERR_WARN;
2468 }
2469
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002470 if ((curproxy->cap & PR_CAP_BE) && (curproxy->mode != PR_MODE_HEALTH)) {
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002471 if (curproxy->lbprm.algo & BE_LB_KIND) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002472 if (curproxy->options & PR_O_TRANSP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002473 ha_alert("config : %s '%s' cannot use both transparent and balance mode.\n",
2474 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002475 cfgerr++;
2476 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002477#ifdef WE_DONT_SUPPORT_SERVERLESS_LISTENERS
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002478 else if (curproxy->srv == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002479 ha_alert("config : %s '%s' needs at least 1 server in balance mode.\n",
2480 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002481 cfgerr++;
2482 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002483#endif
Willy Tarreau1620ec32011-08-06 17:05:02 +02002484 else if (curproxy->options & PR_O_DISPATCH) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002485 ha_warning("config : dispatch address of %s '%s' will be ignored in balance mode.\n",
2486 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002487 err_code |= ERR_WARN;
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002488 }
2489 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02002490 else if (!(curproxy->options & (PR_O_TRANSP | PR_O_DISPATCH | PR_O_HTTP_PROXY))) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002491 /* If no LB algo is set in a backend, and we're not in
2492 * transparent mode, dispatch mode nor proxy mode, we
2493 * want to use balance roundrobin by default.
2494 */
2495 curproxy->lbprm.algo &= ~BE_LB_ALGO;
2496 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002497 }
2498 }
Willy Tarreau193cf932007-09-17 10:17:23 +02002499
Willy Tarreau1620ec32011-08-06 17:05:02 +02002500 if (curproxy->options & PR_O_DISPATCH)
2501 curproxy->options &= ~(PR_O_TRANSP | PR_O_HTTP_PROXY);
2502 else if (curproxy->options & PR_O_HTTP_PROXY)
2503 curproxy->options &= ~(PR_O_DISPATCH | PR_O_TRANSP);
2504 else if (curproxy->options & PR_O_TRANSP)
2505 curproxy->options &= ~(PR_O_DISPATCH | PR_O_HTTP_PROXY);
Willy Tarreau82936582007-11-30 15:20:09 +01002506
Christopher Faulete5870d82020-04-15 11:32:03 +02002507 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_HTTP_RS)) {
2508 ha_warning("config : %s '%s' uses http-check rules without 'option httpchk', so the rules are ignored.\n",
2509 proxy_type_str(curproxy), curproxy->id);
2510 err_code |= ERR_WARN;
2511 }
2512
2513 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_TCPCHK_CHK &&
Christopher Fauletc0fcbe42020-06-03 19:00:42 +02002514 (curproxy->tcpcheck_rules.flags & TCPCHK_RULES_PROTO_CHK) != TCPCHK_RULES_HTTP_CHK) {
Willy Tarreau1620ec32011-08-06 17:05:02 +02002515 if (curproxy->options & PR_O_DISABLE404) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002516 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2517 "disable-on-404", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002518 err_code |= ERR_WARN;
2519 curproxy->options &= ~PR_O_DISABLE404;
2520 }
2521 if (curproxy->options2 & PR_O2_CHK_SNDST) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002522 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2523 "send-state", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002524 err_code |= ERR_WARN;
2525 curproxy->options &= ~PR_O2_CHK_SNDST;
2526 }
Willy Tarreauef781042010-01-27 11:53:01 +01002527 }
2528
Simon Horman98637e52014-06-20 12:30:16 +09002529 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_EXT_CHK) {
2530 if (!global.external_check) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002531 ha_alert("Proxy '%s' : '%s' unable to find required 'global.external-check'.\n",
2532 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002533 cfgerr++;
2534 }
2535 if (!curproxy->check_command) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002536 ha_alert("Proxy '%s' : '%s' unable to find required 'external-check command'.\n",
2537 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002538 cfgerr++;
2539 }
Willy Tarreaud96f1122019-12-03 07:07:36 +01002540 if (!(global.tune.options & GTUNE_INSECURE_FORK)) {
2541 ha_warning("Proxy '%s' : 'insecure-fork-wanted' not enabled in the global section, '%s' will likely fail.\n",
2542 curproxy->id, "option external-check");
2543 err_code |= ERR_WARN;
2544 }
Simon Horman98637e52014-06-20 12:30:16 +09002545 }
2546
Simon Horman64e34162015-02-06 11:11:57 +09002547 if (curproxy->email_alert.set) {
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002548 if (!(curproxy->email_alert.mailers.name && curproxy->email_alert.from && curproxy->email_alert.to)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002549 ha_warning("config : 'email-alert' will be ignored for %s '%s' (the presence any of "
2550 "'email-alert from', 'email-alert level' 'email-alert mailers', "
2551 "'email-alert myhostname', or 'email-alert to' "
2552 "requires each of 'email-alert from', 'email-alert mailers' and 'email-alert to' "
2553 "to be present).\n",
2554 proxy_type_str(curproxy), curproxy->id);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002555 err_code |= ERR_WARN;
2556 free_email_alert(curproxy);
2557 }
2558 if (!curproxy->email_alert.myhostname)
Cyril Bontée22bfd62015-12-04 03:07:07 +01002559 curproxy->email_alert.myhostname = strdup(hostname);
Simon Horman9dc49962015-01-30 11:22:59 +09002560 }
2561
Simon Horman98637e52014-06-20 12:30:16 +09002562 if (curproxy->check_command) {
2563 int clear = 0;
2564 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002565 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2566 "external-check command", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002567 err_code |= ERR_WARN;
2568 clear = 1;
2569 }
2570 if (curproxy->check_command[0] != '/' && !curproxy->check_path) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002571 ha_alert("Proxy '%s': '%s' does not have a leading '/' and 'external-check path' is not set.\n",
2572 curproxy->id, "external-check command");
Simon Horman98637e52014-06-20 12:30:16 +09002573 cfgerr++;
2574 }
2575 if (clear) {
2576 free(curproxy->check_command);
2577 curproxy->check_command = NULL;
2578 }
2579 }
2580
2581 if (curproxy->check_path) {
2582 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002583 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2584 "external-check path", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002585 err_code |= ERR_WARN;
2586 free(curproxy->check_path);
2587 curproxy->check_path = NULL;
2588 }
2589 }
2590
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002591 /* if a default backend was specified, let's find it */
2592 if (curproxy->defbe.name) {
2593 struct proxy *target;
2594
Willy Tarreauafb39922015-05-26 12:04:09 +02002595 target = proxy_be_by_name(curproxy->defbe.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002596 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002597 ha_alert("Proxy '%s': unable to find required default_backend: '%s'.\n",
2598 curproxy->id, curproxy->defbe.name);
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002599 cfgerr++;
2600 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002601 ha_alert("Proxy '%s': loop detected for default_backend: '%s'.\n",
2602 curproxy->id, curproxy->defbe.name);
Willy Tarreaubb925012009-07-23 13:36:36 +02002603 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002604 } else if (target->mode != curproxy->mode &&
2605 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2606
Christopher Faulet767a84b2017-11-24 16:50:31 +01002607 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) as its default backend (see 'mode').\n",
2608 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2609 curproxy->conf.file, curproxy->conf.line,
2610 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2611 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002612 cfgerr++;
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002613 } else {
2614 free(curproxy->defbe.name);
2615 curproxy->defbe.be = target;
Willy Tarreauff678132012-02-13 14:32:34 +01002616 /* Emit a warning if this proxy also has some servers */
2617 if (curproxy->srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002618 ha_warning("In proxy '%s', the 'default_backend' rule always has precedence over the servers, which will never be used.\n",
2619 curproxy->id);
Willy Tarreauff678132012-02-13 14:32:34 +01002620 err_code |= ERR_WARN;
2621 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002622 }
2623 }
2624
Willy Tarreau55ea7572007-06-17 19:56:27 +02002625 /* find the target proxy for 'use_backend' rules */
2626 list_for_each_entry(rule, &curproxy->switching_rules, list) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002627 struct proxy *target;
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002628 struct logformat_node *node;
2629 char *pxname;
2630
2631 /* Try to parse the string as a log format expression. If the result
2632 * of the parsing is only one entry containing a simple string, then
2633 * it's a standard string corresponding to a static rule, thus the
2634 * parsing is cancelled and be.name is restored to be resolved.
2635 */
2636 pxname = rule->be.name;
2637 LIST_INIT(&rule->be.expr);
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +01002638 curproxy->conf.args.ctx = ARGC_UBK;
2639 curproxy->conf.args.file = rule->file;
2640 curproxy->conf.args.line = rule->line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002641 err = NULL;
2642 if (!parse_logformat_string(pxname, curproxy, &rule->be.expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002643 ha_alert("Parsing [%s:%d]: failed to parse use_backend rule '%s' : %s.\n",
2644 rule->file, rule->line, pxname, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002645 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002646 cfgerr++;
2647 continue;
2648 }
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002649 node = LIST_NEXT(&rule->be.expr, struct logformat_node *, list);
2650
2651 if (!LIST_ISEMPTY(&rule->be.expr)) {
2652 if (node->type != LOG_FMT_TEXT || node->list.n != &rule->be.expr) {
2653 rule->dynamic = 1;
2654 free(pxname);
2655 continue;
2656 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02002657 /* Only one element in the list, a simple string: free the expression and
2658 * fall back to static rule
2659 */
2660 LIST_DEL(&node->list);
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002661 free(node->arg);
2662 free(node);
2663 }
2664
2665 rule->dynamic = 0;
2666 rule->be.name = pxname;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002667
Willy Tarreauafb39922015-05-26 12:04:09 +02002668 target = proxy_be_by_name(rule->be.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002669 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002670 ha_alert("Proxy '%s': unable to find required use_backend: '%s'.\n",
2671 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002672 cfgerr++;
2673 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002674 ha_alert("Proxy '%s': loop detected for use_backend: '%s'.\n",
2675 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002676 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002677 } else if (target->mode != curproxy->mode &&
2678 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2679
Christopher Faulet767a84b2017-11-24 16:50:31 +01002680 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) in a 'use_backend' rule (see 'mode').\n",
2681 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2682 curproxy->conf.file, curproxy->conf.line,
2683 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2684 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002685 cfgerr++;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002686 } else {
2687 free((void *)rule->be.name);
2688 rule->be.backend = target;
2689 }
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002690 }
2691
Willy Tarreau64ab6072014-09-16 12:17:36 +02002692 /* find the target server for 'use_server' rules */
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002693 list_for_each_entry(srule, &curproxy->server_rules, list) {
Jerome Magnin824186b2020-03-29 09:37:12 +02002694 struct server *target;
2695 struct logformat_node *node;
2696 char *server_name;
2697
2698 /* We try to parse the string as a log format expression. If the result of the parsing
2699 * is only one entry containing a single string, then it's a standard string corresponding
2700 * to a static rule, thus the parsing is cancelled and we fall back to setting srv.ptr.
2701 */
2702 server_name = srule->srv.name;
2703 LIST_INIT(&srule->expr);
2704 curproxy->conf.args.ctx = ARGC_USRV;
2705 err = NULL;
2706 if (!parse_logformat_string(server_name, curproxy, &srule->expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
2707 ha_alert("Parsing [%s:%d]; use-server rule failed to parse log-format '%s' : %s.\n",
2708 srule->file, srule->line, server_name, err);
2709 free(err);
2710 cfgerr++;
2711 continue;
2712 }
2713 node = LIST_NEXT(&srule->expr, struct logformat_node *, list);
2714
2715 if (!LIST_ISEMPTY(&srule->expr)) {
2716 if (node->type != LOG_FMT_TEXT || node->list.n != &srule->expr) {
2717 srule->dynamic = 1;
2718 free(server_name);
2719 continue;
2720 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02002721 /* Only one element in the list, a simple string: free the expression and
2722 * fall back to static rule
2723 */
2724 LIST_DEL(&node->list);
Jerome Magnin824186b2020-03-29 09:37:12 +02002725 free(node->arg);
2726 free(node);
2727 }
2728
2729 srule->dynamic = 0;
2730 srule->srv.name = server_name;
2731 target = findserver(curproxy, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002732
2733 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002734 ha_alert("config : %s '%s' : unable to find server '%s' referenced in a 'use-server' rule.\n",
2735 proxy_type_str(curproxy), curproxy->id, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002736 cfgerr++;
2737 continue;
2738 }
2739 free((void *)srule->srv.name);
2740 srule->srv.ptr = target;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002741 }
2742
Emeric Brunb982a3d2010-01-04 15:45:53 +01002743 /* find the target table for 'stick' rules */
2744 list_for_each_entry(mrule, &curproxy->sticking_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002745 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002746
Emeric Brun1d33b292010-01-04 15:47:17 +01002747 curproxy->be_req_ana |= AN_REQ_STICKING_RULES;
2748 if (mrule->flags & STK_IS_STORE)
2749 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2750
Emeric Brunb982a3d2010-01-04 15:45:53 +01002751 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002752 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002753 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002754 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002755
2756 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002757 ha_alert("Proxy '%s': unable to find stick-table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01002758 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002759 cfgerr++;
2760 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002761 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002762 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2763 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002764 cfgerr++;
2765 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002766 else if (target->proxy && curproxy->bind_proc & ~target->proxy->bind_proc) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002767 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2768 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002769 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002770 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002771 else {
2772 free((void *)mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002773 mrule->table.t = target;
2774 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Frédéric Lécailledb52d902019-05-17 10:12:52 +02002775 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_NAME, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02002776 if (!in_proxies_list(target->proxies_list, curproxy)) {
2777 curproxy->next_stkt_ref = target->proxies_list;
2778 target->proxies_list = curproxy;
2779 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002780 }
2781 }
2782
2783 /* find the target table for 'store response' rules */
2784 list_for_each_entry(mrule, &curproxy->storersp_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002785 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002786
Emeric Brun1d33b292010-01-04 15:47:17 +01002787 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2788
Emeric Brunb982a3d2010-01-04 15:45:53 +01002789 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002790 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002791 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002792 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002793
2794 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002795 ha_alert("Proxy '%s': unable to find store table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01002796 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002797 cfgerr++;
2798 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002799 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002800 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2801 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002802 cfgerr++;
2803 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002804 else if (target->proxy && (curproxy->bind_proc & ~target->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002805 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2806 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002807 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002808 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002809 else {
2810 free((void *)mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002811 mrule->table.t = target;
2812 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Frédéric Lécailledb52d902019-05-17 10:12:52 +02002813 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_NAME, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02002814 if (!in_proxies_list(target->proxies_list, curproxy)) {
2815 curproxy->next_stkt_ref = target->proxies_list;
2816 target->proxies_list = curproxy;
2817 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002818 }
2819 }
2820
Christopher Faulete4e830d2017-09-18 14:51:41 +02002821 /* check validity for 'tcp-request' layer 4 rules */
2822 list_for_each_entry(arule, &curproxy->tcp_req.l4_rules, list) {
2823 err = NULL;
2824 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002825 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002826 free(err);
Willy Tarreau5f53de72012-12-12 00:25:44 +01002827 cfgerr++;
2828 }
Willy Tarreaud1f96522010-08-03 19:34:32 +02002829 }
2830
Christopher Faulete4e830d2017-09-18 14:51:41 +02002831 /* check validity for 'tcp-request' layer 5 rules */
2832 list_for_each_entry(arule, &curproxy->tcp_req.l5_rules, list) {
2833 err = NULL;
2834 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002835 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002836 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002837 cfgerr++;
2838 }
2839 }
2840
Christopher Faulete4e830d2017-09-18 14:51:41 +02002841 /* check validity for 'tcp-request' layer 6 rules */
2842 list_for_each_entry(arule, &curproxy->tcp_req.inspect_rules, list) {
2843 err = NULL;
2844 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002845 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002846 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002847 cfgerr++;
2848 }
2849 }
2850
Christopher Faulete4e830d2017-09-18 14:51:41 +02002851 /* check validity for 'http-request' layer 7 rules */
2852 list_for_each_entry(arule, &curproxy->http_req_rules, list) {
2853 err = NULL;
2854 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002855 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002856 free(err);
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002857 cfgerr++;
2858 }
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002859 }
2860
Christopher Faulete4e830d2017-09-18 14:51:41 +02002861 /* check validity for 'http-response' layer 7 rules */
2862 list_for_each_entry(arule, &curproxy->http_res_rules, list) {
2863 err = NULL;
2864 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002865 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002866 free(err);
Willy Tarreau09448f72014-06-25 18:12:15 +02002867 cfgerr++;
2868 }
Willy Tarreau09448f72014-06-25 18:12:15 +02002869 }
2870
Christopher Faulet6d0c3df2020-01-22 09:26:35 +01002871 /* check validity for 'http-after-response' layer 7 rules */
2872 list_for_each_entry(arule, &curproxy->http_after_res_rules, list) {
2873 err = NULL;
2874 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
2875 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
2876 free(err);
2877 cfgerr++;
2878 }
2879 }
2880
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002881 if (curproxy->table && curproxy->table->peers.name) {
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002882 struct peers *curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002883
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002884 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002885 if (strcmp(curpeers->id, curproxy->table->peers.name) == 0) {
2886 free((void *)curproxy->table->peers.name);
2887 curproxy->table->peers.p = curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002888 break;
2889 }
2890 }
2891
2892 if (!curpeers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002893 ha_alert("Proxy '%s': unable to find sync peers '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002894 curproxy->id, curproxy->table->peers.name);
2895 free((void *)curproxy->table->peers.name);
2896 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002897 cfgerr++;
2898 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002899 else if (curpeers->state == PR_STSTOPPED) {
2900 /* silently disable this peers section */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002901 curproxy->table->peers.p = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002902 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002903 else if (!curpeers->peers_fe) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002904 ha_alert("Proxy '%s': unable to find local peer '%s' in peers section '%s'.\n",
2905 curproxy->id, localpeer, curpeers->id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002906 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002907 cfgerr++;
2908 }
2909 }
2910
Simon Horman9dc49962015-01-30 11:22:59 +09002911
2912 if (curproxy->email_alert.mailers.name) {
2913 struct mailers *curmailers = mailers;
2914
2915 for (curmailers = mailers; curmailers; curmailers = curmailers->next) {
Christopher Faulet0108bb32017-10-20 21:34:32 +02002916 if (!strcmp(curmailers->id, curproxy->email_alert.mailers.name))
Simon Horman9dc49962015-01-30 11:22:59 +09002917 break;
Simon Horman9dc49962015-01-30 11:22:59 +09002918 }
Simon Horman9dc49962015-01-30 11:22:59 +09002919 if (!curmailers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002920 ha_alert("Proxy '%s': unable to find mailers '%s'.\n",
2921 curproxy->id, curproxy->email_alert.mailers.name);
Simon Horman9dc49962015-01-30 11:22:59 +09002922 free_email_alert(curproxy);
2923 cfgerr++;
2924 }
Christopher Faulet0108bb32017-10-20 21:34:32 +02002925 else {
2926 err = NULL;
2927 if (init_email_alert(curmailers, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002928 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulet0108bb32017-10-20 21:34:32 +02002929 free(err);
2930 cfgerr++;
2931 }
2932 }
Simon Horman9dc49962015-01-30 11:22:59 +09002933 }
2934
Willy Tarreauee4f5f82019-10-09 09:59:22 +02002935 if (curproxy->uri_auth && curproxy->uri_auth != defproxy.uri_auth &&
Willy Tarreauff011f22011-01-06 17:51:27 +01002936 !LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules) &&
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002937 (curproxy->uri_auth->userlist || curproxy->uri_auth->auth_realm )) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002938 ha_alert("%s '%s': stats 'auth'/'realm' and 'http-request' can't be used at the same time.\n",
2939 "proxy", curproxy->id);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002940 cfgerr++;
2941 goto out_uri_auth_compat;
2942 }
2943
Willy Tarreauee4f5f82019-10-09 09:59:22 +02002944 if (curproxy->uri_auth && curproxy->uri_auth->userlist &&
2945 (curproxy->uri_auth != defproxy.uri_auth ||
2946 LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules))) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002947 const char *uri_auth_compat_req[10];
Thierry FOURNIERa28a9422015-08-04 19:35:46 +02002948 struct act_rule *rule;
Willy Tarreau95fa4692010-02-01 13:05:50 +01002949 int i = 0;
Willy Tarreau95fa4692010-02-01 13:05:50 +01002950 /* build the ACL condition from scratch. We're relying on anonymous ACLs for that */
2951 uri_auth_compat_req[i++] = "auth";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002952
2953 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002954 uri_auth_compat_req[i++] = "realm";
2955 uri_auth_compat_req[i++] = curproxy->uri_auth->auth_realm;
2956 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002957
Willy Tarreau95fa4692010-02-01 13:05:50 +01002958 uri_auth_compat_req[i++] = "unless";
2959 uri_auth_compat_req[i++] = "{";
2960 uri_auth_compat_req[i++] = "http_auth(.internal-stats-userlist)";
2961 uri_auth_compat_req[i++] = "}";
2962 uri_auth_compat_req[i++] = "";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002963
Willy Tarreauff011f22011-01-06 17:51:27 +01002964 rule = parse_http_req_cond(uri_auth_compat_req, "internal-stats-auth-compat", 0, curproxy);
2965 if (!rule) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002966 cfgerr++;
2967 break;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002968 }
2969
Willy Tarreauff011f22011-01-06 17:51:27 +01002970 LIST_ADDQ(&curproxy->uri_auth->http_req_rules, &rule->list);
Willy Tarreau95fa4692010-02-01 13:05:50 +01002971
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002972 if (curproxy->uri_auth->auth_realm) {
2973 free(curproxy->uri_auth->auth_realm);
2974 curproxy->uri_auth->auth_realm = NULL;
2975 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002976 }
2977out_uri_auth_compat:
2978
Dragan Dosen43885c72015-10-01 13:18:13 +02002979 /* check whether we have a log server that uses RFC5424 log format */
Dragan Dosen1322d092015-09-22 16:05:32 +02002980 list_for_each_entry(tmplogsrv, &curproxy->logsrvs, list) {
Dragan Dosen43885c72015-10-01 13:18:13 +02002981 if (tmplogsrv->format == LOG_FORMAT_RFC5424) {
2982 if (!curproxy->conf.logformat_sd_string) {
2983 /* set the default logformat_sd_string */
2984 curproxy->conf.logformat_sd_string = default_rfc5424_sd_log_format;
2985 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002986 break;
Dragan Dosen1322d092015-09-22 16:05:32 +02002987 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002988 }
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02002989
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002990 /* compile the log format */
2991 if (!(curproxy->cap & PR_CAP_FE)) {
Willy Tarreau62a61232013-04-12 18:13:46 +02002992 if (curproxy->conf.logformat_string != default_http_log_format &&
2993 curproxy->conf.logformat_string != default_tcp_log_format &&
2994 curproxy->conf.logformat_string != clf_http_log_format)
2995 free(curproxy->conf.logformat_string);
2996 curproxy->conf.logformat_string = NULL;
2997 free(curproxy->conf.lfs_file);
2998 curproxy->conf.lfs_file = NULL;
2999 curproxy->conf.lfs_line = 0;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003000
3001 if (curproxy->conf.logformat_sd_string != default_rfc5424_sd_log_format)
3002 free(curproxy->conf.logformat_sd_string);
3003 curproxy->conf.logformat_sd_string = NULL;
3004 free(curproxy->conf.lfsd_file);
3005 curproxy->conf.lfsd_file = NULL;
3006 curproxy->conf.lfsd_line = 0;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003007 }
3008
Willy Tarreau62a61232013-04-12 18:13:46 +02003009 if (curproxy->conf.logformat_string) {
3010 curproxy->conf.args.ctx = ARGC_LOG;
3011 curproxy->conf.args.file = curproxy->conf.lfs_file;
3012 curproxy->conf.args.line = curproxy->conf.lfs_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003013 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003014 if (!parse_logformat_string(curproxy->conf.logformat_string, curproxy, &curproxy->logformat, LOG_OPT_MANDATORY,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003015 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003016 ha_alert("Parsing [%s:%d]: failed to parse log-format : %s.\n",
3017 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003018 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003019 cfgerr++;
3020 }
Willy Tarreau62a61232013-04-12 18:13:46 +02003021 curproxy->conf.args.file = NULL;
3022 curproxy->conf.args.line = 0;
3023 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003024
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003025 if (curproxy->conf.logformat_sd_string) {
3026 curproxy->conf.args.ctx = ARGC_LOGSD;
3027 curproxy->conf.args.file = curproxy->conf.lfsd_file;
3028 curproxy->conf.args.line = curproxy->conf.lfsd_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003029 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003030 if (!parse_logformat_string(curproxy->conf.logformat_sd_string, curproxy, &curproxy->logformat_sd, LOG_OPT_MANDATORY,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003031 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003032 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
3033 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003034 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003035 cfgerr++;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003036 } else if (!add_to_logformat_list(NULL, NULL, LF_SEPARATOR, &curproxy->logformat_sd, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003037 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
3038 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003039 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003040 cfgerr++;
3041 }
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003042 curproxy->conf.args.file = NULL;
3043 curproxy->conf.args.line = 0;
3044 }
3045
Willy Tarreau62a61232013-04-12 18:13:46 +02003046 if (curproxy->conf.uniqueid_format_string) {
3047 curproxy->conf.args.ctx = ARGC_UIF;
3048 curproxy->conf.args.file = curproxy->conf.uif_file;
3049 curproxy->conf.args.line = curproxy->conf.uif_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003050 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003051 if (!parse_logformat_string(curproxy->conf.uniqueid_format_string, curproxy, &curproxy->format_unique_id, LOG_OPT_HTTP,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003052 (curproxy->cap & PR_CAP_FE) ? SMP_VAL_FE_HRQ_HDR : SMP_VAL_BE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003053 ha_alert("Parsing [%s:%d]: failed to parse unique-id : %s.\n",
3054 curproxy->conf.uif_file, curproxy->conf.uif_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003055 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003056 cfgerr++;
3057 }
Willy Tarreau62a61232013-04-12 18:13:46 +02003058 curproxy->conf.args.file = NULL;
3059 curproxy->conf.args.line = 0;
3060 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003061
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01003062 /* only now we can check if some args remain unresolved.
3063 * This must be done after the users and groups resolution.
3064 */
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003065 cfgerr += smp_resolve_args(curproxy);
3066 if (!cfgerr)
3067 cfgerr += acl_find_targets(curproxy);
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01003068
Willy Tarreau2738a142006-07-08 17:28:09 +02003069 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003070 (((curproxy->cap & PR_CAP_FE) && !curproxy->timeout.client) ||
Willy Tarreaud825eef2007-05-12 22:35:00 +02003071 ((curproxy->cap & PR_CAP_BE) && (curproxy->srv) &&
Willy Tarreauce887fd2012-05-12 12:50:00 +02003072 (!curproxy->timeout.connect ||
3073 (!curproxy->timeout.server && (curproxy->mode == PR_MODE_HTTP || !curproxy->timeout.tunnel)))))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003074 ha_warning("config : missing timeouts for %s '%s'.\n"
3075 " | While not properly invalid, you will certainly encounter various problems\n"
3076 " | with such a configuration. To fix this, please ensure that all following\n"
3077 " | timeouts are set to a non-zero value: 'client', 'connect', 'server'.\n",
3078 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003079 err_code |= ERR_WARN;
Willy Tarreau2738a142006-07-08 17:28:09 +02003080 }
Willy Tarreauf3c69202006-07-09 16:42:34 +02003081
Willy Tarreau1fa31262007-12-03 00:36:16 +01003082 /* Historically, the tarpit and queue timeouts were inherited from contimeout.
3083 * We must still support older configurations, so let's find out whether those
3084 * parameters have been set or must be copied from contimeouts.
3085 */
3086 if (curproxy != &defproxy) {
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003087 if (!curproxy->timeout.tarpit ||
3088 curproxy->timeout.tarpit == defproxy.timeout.tarpit) {
Willy Tarreau1fa31262007-12-03 00:36:16 +01003089 /* tarpit timeout not set. We search in the following order:
3090 * default.tarpit, curr.connect, default.connect.
3091 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003092 if (defproxy.timeout.tarpit)
Willy Tarreau1fa31262007-12-03 00:36:16 +01003093 curproxy->timeout.tarpit = defproxy.timeout.tarpit;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003094 else if (curproxy->timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003095 curproxy->timeout.tarpit = curproxy->timeout.connect;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003096 else if (defproxy.timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003097 curproxy->timeout.tarpit = defproxy.timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01003098 }
3099 if ((curproxy->cap & PR_CAP_BE) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003100 (!curproxy->timeout.queue ||
3101 curproxy->timeout.queue == defproxy.timeout.queue)) {
Willy Tarreau1fa31262007-12-03 00:36:16 +01003102 /* queue timeout not set. We search in the following order:
3103 * default.queue, curr.connect, default.connect.
3104 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003105 if (defproxy.timeout.queue)
Willy Tarreau1fa31262007-12-03 00:36:16 +01003106 curproxy->timeout.queue = defproxy.timeout.queue;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003107 else if (curproxy->timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003108 curproxy->timeout.queue = curproxy->timeout.connect;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003109 else if (defproxy.timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003110 curproxy->timeout.queue = defproxy.timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01003111 }
3112 }
3113
Christopher Faulete5870d82020-04-15 11:32:03 +02003114 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_TCP_RS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003115 ha_warning("config : %s '%s' uses tcp-check rules without 'option tcp-check', so the rules are ignored.\n",
3116 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau215663d2014-06-13 18:30:23 +02003117 err_code |= ERR_WARN;
3118 }
3119
Willy Tarreau193b8c62012-11-22 00:17:38 +01003120 /* ensure that cookie capture length is not too large */
3121 if (curproxy->capture_len >= global.tune.cookie_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003122 ha_warning("config : truncating capture length to %d bytes for %s '%s'.\n",
3123 global.tune.cookie_len - 1, proxy_type_str(curproxy), curproxy->id);
Willy Tarreau193b8c62012-11-22 00:17:38 +01003124 err_code |= ERR_WARN;
3125 curproxy->capture_len = global.tune.cookie_len - 1;
3126 }
3127
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003128 /* The small pools required for the capture lists */
Willy Tarreau9a54e132012-03-24 08:33:05 +01003129 if (curproxy->nb_req_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003130 curproxy->req_cap_pool = create_pool("ptrcap",
3131 curproxy->nb_req_cap * sizeof(char *),
3132 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003133 }
3134
3135 if (curproxy->nb_rsp_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003136 curproxy->rsp_cap_pool = create_pool("ptrcap",
3137 curproxy->nb_rsp_cap * sizeof(char *),
3138 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003139 }
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003140
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003141 switch (curproxy->load_server_state_from_file) {
3142 case PR_SRV_STATE_FILE_UNSPEC:
3143 curproxy->load_server_state_from_file = PR_SRV_STATE_FILE_NONE;
3144 break;
3145 case PR_SRV_STATE_FILE_GLOBAL:
3146 if (!global.server_state_file) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003147 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",
3148 curproxy->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003149 err_code |= ERR_WARN;
3150 }
3151 break;
3152 }
3153
Willy Tarreaubaaee002006-06-26 02:48:02 +02003154 /* first, we will invert the servers list order */
3155 newsrv = NULL;
3156 while (curproxy->srv) {
3157 struct server *next;
3158
3159 next = curproxy->srv->next;
3160 curproxy->srv->next = newsrv;
3161 newsrv = curproxy->srv;
3162 if (!next)
3163 break;
3164 curproxy->srv = next;
3165 }
3166
Willy Tarreau17edc812014-01-03 12:14:34 +01003167 /* Check that no server name conflicts. This causes trouble in the stats.
3168 * We only emit a warning for the first conflict affecting each server,
3169 * in order to avoid combinatory explosion if all servers have the same
3170 * name. We do that only for servers which do not have an explicit ID,
3171 * because these IDs were made also for distinguishing them and we don't
3172 * want to annoy people who correctly manage them.
3173 */
3174 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3175 struct server *other_srv;
3176
3177 if (newsrv->puid)
3178 continue;
3179
3180 for (other_srv = curproxy->srv; other_srv && other_srv != newsrv; other_srv = other_srv->next) {
3181 if (!other_srv->puid && strcmp(other_srv->id, newsrv->id) == 0) {
Willy Tarreaub01302f2019-05-27 19:31:06 +02003182 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 +01003183 newsrv->conf.file, newsrv->conf.line,
3184 proxy_type_str(curproxy), curproxy->id,
3185 newsrv->id, other_srv->conf.line);
Willy Tarreaub01302f2019-05-27 19:31:06 +02003186 cfgerr++;
Willy Tarreau17edc812014-01-03 12:14:34 +01003187 break;
3188 }
3189 }
3190 }
3191
Willy Tarreaudd701652010-05-25 23:03:02 +02003192 /* assign automatic UIDs to servers which don't have one yet */
3193 next_id = 1;
3194 newsrv = curproxy->srv;
3195 while (newsrv != NULL) {
3196 if (!newsrv->puid) {
3197 /* server ID not set, use automatic numbering with first
3198 * spare entry starting with next_svid.
3199 */
3200 next_id = get_next_id(&curproxy->conf.used_server_id, next_id);
3201 newsrv->conf.id.key = newsrv->puid = next_id;
3202 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Frédéric Lécaille84d60462019-05-17 14:29:15 +02003203 newsrv->conf.name.key = newsrv->id;
3204 ebis_insert(&curproxy->conf.used_server_name, &newsrv->conf.name);
Willy Tarreaudd701652010-05-25 23:03:02 +02003205 }
3206 next_id++;
3207 newsrv = newsrv->next;
3208 }
3209
Willy Tarreau20697042007-11-15 23:26:18 +01003210 curproxy->lbprm.wmult = 1; /* default weight multiplier */
Willy Tarreau5dc2fa62007-11-19 19:10:18 +01003211 curproxy->lbprm.wdiv = 1; /* default weight divider */
Willy Tarreaubaaee002006-06-26 02:48:02 +02003212
Willy Tarreau62c3be22012-01-20 13:12:32 +01003213 /*
3214 * If this server supports a maxconn parameter, it needs a dedicated
3215 * tasks to fill the emptied slots when a connection leaves.
3216 * Also, resolve deferred tracking dependency if needed.
3217 */
3218 newsrv = curproxy->srv;
3219 while (newsrv != NULL) {
3220 if (newsrv->minconn > newsrv->maxconn) {
3221 /* Only 'minconn' was specified, or it was higher than or equal
3222 * to 'maxconn'. Let's turn this into maxconn and clean it, as
3223 * this will avoid further useless expensive computations.
3224 */
3225 newsrv->maxconn = newsrv->minconn;
3226 } else if (newsrv->maxconn && !newsrv->minconn) {
3227 /* minconn was not specified, so we set it to maxconn */
3228 newsrv->minconn = newsrv->maxconn;
3229 }
3230
Willy Tarreau17d45382016-12-22 21:16:08 +01003231 /* this will also properly set the transport layer for prod and checks */
Christopher Fauletf61f33a2020-03-27 18:55:49 +01003232 if (newsrv->use_ssl == 1 || newsrv->check.use_ssl == 1 || (newsrv->proxy->options & PR_O_TCPCHK_SSL)) {
Willy Tarreau17d45382016-12-22 21:16:08 +01003233 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
3234 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(newsrv);
3235 }
Emeric Brun94324a42012-10-11 14:00:19 +02003236
Willy Tarreau034c88c2017-01-23 23:36:45 +01003237 if ((newsrv->flags & SRV_F_FASTOPEN) &&
3238 ((curproxy->retry_type & (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)) !=
3239 (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)))
3240 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",
3241 newsrv->conf.file, newsrv->conf.line,
3242 proxy_type_str(curproxy), curproxy->id,
3243 newsrv->id);
3244
Willy Tarreau62c3be22012-01-20 13:12:32 +01003245 if (newsrv->trackit) {
3246 struct proxy *px;
Willy Tarreau32091232014-05-16 13:52:00 +02003247 struct server *srv, *loop;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003248 char *pname, *sname;
3249
3250 pname = newsrv->trackit;
3251 sname = strrchr(pname, '/');
3252
3253 if (sname)
3254 *sname++ = '\0';
3255 else {
3256 sname = pname;
3257 pname = NULL;
3258 }
3259
3260 if (pname) {
Willy Tarreau9e0bb102015-05-26 11:24:42 +02003261 px = proxy_be_by_name(pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003262 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003263 ha_alert("config : %s '%s', server '%s': unable to find required proxy '%s' for tracking.\n",
3264 proxy_type_str(curproxy), curproxy->id,
3265 newsrv->id, pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003266 cfgerr++;
3267 goto next_srv;
3268 }
3269 } else
3270 px = curproxy;
3271
3272 srv = findserver(px, sname);
3273 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003274 ha_alert("config : %s '%s', server '%s': unable to find required server '%s' for tracking.\n",
3275 proxy_type_str(curproxy), curproxy->id,
3276 newsrv->id, sname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003277 cfgerr++;
3278 goto next_srv;
3279 }
3280
Christopher Faulet8892e5d2020-03-26 19:48:20 +01003281 if (!srv->do_check && !srv->do_agent && !srv->track && !srv->trackit) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003282 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for "
3283 "tracking as it does not have any check nor agent enabled.\n",
3284 proxy_type_str(curproxy), curproxy->id,
3285 newsrv->id, px->id, srv->id);
Willy Tarreau32091232014-05-16 13:52:00 +02003286 cfgerr++;
3287 goto next_srv;
3288 }
3289
3290 for (loop = srv->track; loop && loop != newsrv; loop = loop->track);
3291
Frédéric Lécaille2efc6492017-03-14 14:32:17 +01003292 if (newsrv == srv || loop) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003293 ha_alert("config : %s '%s', server '%s': unable to track %s/%s as it "
3294 "belongs to a tracking chain looping back to %s/%s.\n",
3295 proxy_type_str(curproxy), curproxy->id,
3296 newsrv->id, px->id, srv->id, px->id,
3297 newsrv == srv ? srv->id : loop->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003298 cfgerr++;
3299 goto next_srv;
3300 }
3301
3302 if (curproxy != px &&
3303 (curproxy->options & PR_O_DISABLE404) != (px->options & PR_O_DISABLE404)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003304 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for"
3305 "tracking: disable-on-404 option inconsistency.\n",
3306 proxy_type_str(curproxy), curproxy->id,
3307 newsrv->id, px->id, srv->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003308 cfgerr++;
3309 goto next_srv;
3310 }
3311
Willy Tarreau62c3be22012-01-20 13:12:32 +01003312 newsrv->track = srv;
Willy Tarreau1a53a3a2013-12-11 15:27:05 +01003313 newsrv->tracknext = srv->trackers;
3314 srv->trackers = newsrv;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003315
3316 free(newsrv->trackit);
3317 newsrv->trackit = NULL;
3318 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003319
Willy Tarreau62c3be22012-01-20 13:12:32 +01003320 next_srv:
3321 newsrv = newsrv->next;
3322 }
3323
Olivier Houchard4e694042017-03-14 20:01:29 +01003324 /*
3325 * Try to generate dynamic cookies for servers now.
3326 * It couldn't be done earlier, since at the time we parsed
3327 * the server line, we may not have known yet that we
3328 * should use dynamic cookies, or the secret key may not
3329 * have been provided yet.
3330 */
3331 if (curproxy->ck_opts & PR_CK_DYNAMIC) {
3332 newsrv = curproxy->srv;
3333 while (newsrv != NULL) {
3334 srv_set_dyncookie(newsrv);
3335 newsrv = newsrv->next;
3336 }
3337
3338 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003339 /* We have to initialize the server lookup mechanism depending
Joseph Herlanta14c03e2018-11-15 14:04:19 -08003340 * on what LB algorithm was chosen.
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003341 */
3342
3343 curproxy->lbprm.algo &= ~(BE_LB_LKUP | BE_LB_PROP_DYN);
3344 switch (curproxy->lbprm.algo & BE_LB_KIND) {
3345 case BE_LB_KIND_RR:
Willy Tarreau9757a382009-10-03 12:56:50 +02003346 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_STATIC) {
3347 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3348 init_server_map(curproxy);
Willy Tarreau760e81d2018-05-03 07:20:40 +02003349 } else if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_RANDOM) {
3350 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3351 chash_init_server_tree(curproxy);
Willy Tarreau9757a382009-10-03 12:56:50 +02003352 } else {
3353 curproxy->lbprm.algo |= BE_LB_LKUP_RRTREE | BE_LB_PROP_DYN;
3354 fwrr_init_server_groups(curproxy);
3355 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003356 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003357
Willy Tarreau3ebb1162012-02-13 16:57:44 +01003358 case BE_LB_KIND_CB:
Willy Tarreauf09c6602012-02-13 17:12:08 +01003359 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_CB_LC) {
3360 curproxy->lbprm.algo |= BE_LB_LKUP_LCTREE | BE_LB_PROP_DYN;
3361 fwlc_init_server_tree(curproxy);
3362 } else {
3363 curproxy->lbprm.algo |= BE_LB_LKUP_FSTREE | BE_LB_PROP_DYN;
3364 fas_init_server_tree(curproxy);
3365 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003366 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003367
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003368 case BE_LB_KIND_HI:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003369 if ((curproxy->lbprm.algo & BE_LB_HASH_TYPE) == BE_LB_HASH_CONS) {
3370 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3371 chash_init_server_tree(curproxy);
3372 } else {
3373 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3374 init_server_map(curproxy);
3375 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003376 break;
3377 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003378 HA_SPIN_INIT(&curproxy->lbprm.lock);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003379
3380 if (curproxy->options & PR_O_LOGASAP)
3381 curproxy->to_log &= ~LW_BYTES;
3382
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003383 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003384 (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->logsrvs) &&
3385 (!LIST_ISEMPTY(&curproxy->logformat) || !LIST_ISEMPTY(&curproxy->logformat_sd))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003386 ha_warning("config : log format ignored for %s '%s' since it has no log address.\n",
3387 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003388 err_code |= ERR_WARN;
3389 }
3390
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003391 if (curproxy->mode != PR_MODE_HTTP) {
3392 int optnum;
3393
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003394 if (curproxy->uri_auth) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003395 ha_warning("config : 'stats' statement ignored for %s '%s' as it requires HTTP mode.\n",
3396 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003397 err_code |= ERR_WARN;
3398 curproxy->uri_auth = NULL;
3399 }
3400
Willy Tarreaude7dc882017-03-10 11:49:21 +01003401 if (curproxy->capture_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003402 ha_warning("config : 'capture' statement ignored for %s '%s' as it requires HTTP mode.\n",
3403 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003404 err_code |= ERR_WARN;
3405 }
3406
3407 if (!LIST_ISEMPTY(&curproxy->http_req_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003408 ha_warning("config : 'http-request' rules ignored for %s '%s' as they require HTTP mode.\n",
3409 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003410 err_code |= ERR_WARN;
3411 }
3412
3413 if (!LIST_ISEMPTY(&curproxy->http_res_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003414 ha_warning("config : 'http-response' rules ignored for %s '%s' as they require HTTP mode.\n",
3415 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003416 err_code |= ERR_WARN;
3417 }
3418
Willy Tarreaude7dc882017-03-10 11:49:21 +01003419 if (!LIST_ISEMPTY(&curproxy->redirect_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003420 ha_warning("config : 'redirect' rules ignored for %s '%s' as they require HTTP mode.\n",
3421 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003422 err_code |= ERR_WARN;
3423 }
3424
Willy Tarreau87cf5142011-08-19 22:57:24 +02003425 if (curproxy->options & (PR_O_FWDFOR | PR_O_FF_ALWAYS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003426 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3427 "forwardfor", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003428 err_code |= ERR_WARN;
Willy Tarreau87cf5142011-08-19 22:57:24 +02003429 curproxy->options &= ~(PR_O_FWDFOR | PR_O_FF_ALWAYS);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003430 }
3431
3432 if (curproxy->options & PR_O_ORGTO) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003433 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3434 "originalto", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003435 err_code |= ERR_WARN;
3436 curproxy->options &= ~PR_O_ORGTO;
3437 }
3438
3439 for (optnum = 0; cfg_opts[optnum].name; optnum++) {
3440 if (cfg_opts[optnum].mode == PR_MODE_HTTP &&
3441 (curproxy->cap & cfg_opts[optnum].cap) &&
3442 (curproxy->options & cfg_opts[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003443 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3444 cfg_opts[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003445 err_code |= ERR_WARN;
3446 curproxy->options &= ~cfg_opts[optnum].val;
3447 }
3448 }
3449
3450 for (optnum = 0; cfg_opts2[optnum].name; optnum++) {
3451 if (cfg_opts2[optnum].mode == PR_MODE_HTTP &&
3452 (curproxy->cap & cfg_opts2[optnum].cap) &&
3453 (curproxy->options2 & cfg_opts2[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003454 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3455 cfg_opts2[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003456 err_code |= ERR_WARN;
3457 curproxy->options2 &= ~cfg_opts2[optnum].val;
3458 }
3459 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003460
Willy Tarreau29fbe512015-08-20 19:35:14 +02003461#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003462 if (curproxy->conn_src.bind_hdr_occ) {
3463 curproxy->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003464 ha_warning("config : %s '%s' : ignoring use of header %s as source IP in non-HTTP mode.\n",
3465 proxy_type_str(curproxy), curproxy->id, curproxy->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003466 err_code |= ERR_WARN;
3467 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003468#endif
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003469 }
3470
Willy Tarreaubaaee002006-06-26 02:48:02 +02003471 /*
Willy Tarreau21d2af32008-02-14 20:25:24 +01003472 * ensure that we're not cross-dressing a TCP server into HTTP.
3473 */
3474 newsrv = curproxy->srv;
3475 while (newsrv != NULL) {
Willy Tarreau0cec3312011-10-31 13:49:26 +01003476 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->rdr_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003477 ha_alert("config : %s '%s' : server cannot have cookie or redirect prefix in non-HTTP mode.\n",
3478 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003479 cfgerr++;
Willy Tarreau21d2af32008-02-14 20:25:24 +01003480 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003481
Willy Tarreau0cec3312011-10-31 13:49:26 +01003482 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->cklen) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003483 ha_warning("config : %s '%s' : ignoring cookie for server '%s' as HTTP mode is disabled.\n",
3484 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau0cec3312011-10-31 13:49:26 +01003485 err_code |= ERR_WARN;
3486 }
3487
Willy Tarreauc93cd162014-05-13 15:54:22 +02003488 if ((newsrv->flags & SRV_F_MAPPORTS) && (curproxy->options2 & PR_O2_RDPC_PRST)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003489 ha_warning("config : %s '%s' : RDP cookie persistence will not work for server '%s' because it lacks an explicit port number.\n",
3490 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau82ffa392013-08-13 17:19:08 +02003491 err_code |= ERR_WARN;
3492 }
3493
Willy Tarreau29fbe512015-08-20 19:35:14 +02003494#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003495 if (curproxy->mode != PR_MODE_HTTP && newsrv->conn_src.bind_hdr_occ) {
3496 newsrv->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003497 ha_warning("config : %s '%s' : server %s cannot use header %s as source IP in non-HTTP mode.\n",
3498 proxy_type_str(curproxy), curproxy->id, newsrv->id, newsrv->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003499 err_code |= ERR_WARN;
3500 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003501#endif
Willy Tarreau4c183462017-01-06 12:21:38 +01003502
Willy Tarreau46deab62018-04-28 07:18:15 +02003503 if ((curproxy->mode != PR_MODE_HTTP) && (curproxy->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR)
3504 curproxy->options &= ~PR_O_REUSE_MASK;
3505
Willy Tarreau21d2af32008-02-14 20:25:24 +01003506 newsrv = newsrv->next;
3507 }
3508
Christopher Fauletd7c91962015-04-30 11:48:27 +02003509 /* Check filter configuration, if any */
3510 cfgerr += flt_check(curproxy);
3511
Willy Tarreauc1a21672009-08-16 22:37:44 +02003512 if (curproxy->cap & PR_CAP_FE) {
Willy Tarreau050536d2012-10-04 08:47:34 +02003513 if (!curproxy->accept)
3514 curproxy->accept = frontend_accept;
Willy Tarreau81f9aa32010-06-01 17:45:26 +02003515
Willy Tarreauc1a21672009-08-16 22:37:44 +02003516 if (curproxy->tcp_req.inspect_delay ||
3517 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
Willy Tarreaufb356202010-08-03 14:02:05 +02003518 curproxy->fe_req_ana |= AN_REQ_INSPECT_FE;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003519
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003520 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003521 curproxy->fe_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_PROCESS_FE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003522 curproxy->fe_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_FE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003523 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003524
William Lallemandcf62f7e2018-10-26 14:47:40 +02003525 if (curproxy->mode == PR_MODE_CLI) {
3526 curproxy->fe_req_ana |= AN_REQ_WAIT_CLI;
3527 curproxy->fe_rsp_ana |= AN_RES_WAIT_CLI;
3528 }
3529
Willy Tarreauc1a21672009-08-16 22:37:44 +02003530 /* both TCP and HTTP must check switching rules */
3531 curproxy->fe_req_ana |= AN_REQ_SWITCHING_RULES;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003532
3533 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003534 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003535 curproxy->fe_req_ana |= AN_REQ_FLT_START_FE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3536 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 +01003537 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003538 curproxy->fe_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3539 curproxy->fe_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003540 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003541 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003542 }
3543
3544 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreaufb356202010-08-03 14:02:05 +02003545 if (curproxy->tcp_req.inspect_delay ||
3546 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
3547 curproxy->be_req_ana |= AN_REQ_INSPECT_BE;
3548
Emeric Brun97679e72010-09-23 17:56:44 +02003549 if (!LIST_ISEMPTY(&curproxy->tcp_rep.inspect_rules))
3550 curproxy->be_rsp_ana |= AN_RES_INSPECT;
3551
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003552 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003553 curproxy->be_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_INNER | AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003554 curproxy->be_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_BE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003555 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003556
3557 /* If the backend does requires RDP cookie persistence, we have to
3558 * enable the corresponding analyser.
3559 */
3560 if (curproxy->options2 & PR_O2_RDPC_PRST)
3561 curproxy->be_req_ana |= AN_REQ_PRST_RDP_COOKIE;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003562
3563 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003564 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003565 curproxy->be_req_ana |= AN_REQ_FLT_START_BE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3566 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 +01003567 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003568 curproxy->be_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3569 curproxy->be_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003570 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003571 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003572 }
Christopher Fauleta717b992018-04-10 14:43:00 +02003573
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003574 /* Check the mux protocols, if any, for each listener and server
Christopher Fauleta717b992018-04-10 14:43:00 +02003575 * attached to the current proxy */
3576 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3577 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003578 const struct mux_proto_list *mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003579
3580 if (!bind_conf->mux_proto)
3581 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003582
3583 /* it is possible that an incorrect mux was referenced
3584 * due to the proxy's mode not being taken into account
3585 * on first pass. Let's adjust it now.
3586 */
3587 mux_ent = conn_get_best_mux_entry(bind_conf->mux_proto->token, PROTO_SIDE_FE, mode);
3588
3589 if (!mux_ent || !isteq(mux_ent->token, bind_conf->mux_proto->token)) {
Christopher Fauleta717b992018-04-10 14:43:00 +02003590 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for 'bind %s' at [%s:%d].\n",
3591 proxy_type_str(curproxy), curproxy->id,
3592 (int)bind_conf->mux_proto->token.len,
3593 bind_conf->mux_proto->token.ptr,
3594 bind_conf->arg, bind_conf->file, bind_conf->line);
3595 cfgerr++;
3596 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003597
3598 /* update the mux */
3599 bind_conf->mux_proto = mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003600 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003601 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3602 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003603 const struct mux_proto_list *mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003604
3605 if (!newsrv->mux_proto)
3606 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003607
3608 /* it is possible that an incorrect mux was referenced
3609 * due to the proxy's mode not being taken into account
3610 * on first pass. Let's adjust it now.
3611 */
3612 mux_ent = conn_get_best_mux_entry(newsrv->mux_proto->token, PROTO_SIDE_BE, mode);
3613
3614 if (!mux_ent || !isteq(mux_ent->token, newsrv->mux_proto->token)) {
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003615 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for server '%s' at [%s:%d].\n",
3616 proxy_type_str(curproxy), curproxy->id,
3617 (int)newsrv->mux_proto->token.len,
3618 newsrv->mux_proto->token.ptr,
3619 newsrv->id, newsrv->conf.file, newsrv->conf.line);
3620 cfgerr++;
3621 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003622
3623 /* update the mux */
3624 newsrv->mux_proto = mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003625 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003626
3627 /* initialize idle conns lists */
3628 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3629 int i;
3630
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003631 newsrv->available_conns = calloc((unsigned)global.nbthread, sizeof(*newsrv->available_conns));
Willy Tarreau835daa12019-02-07 14:46:29 +01003632
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003633 if (!newsrv->available_conns) {
Willy Tarreau835daa12019-02-07 14:46:29 +01003634 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003635 newsrv->conf.file, newsrv->conf.line, newsrv->id);
Willy Tarreau835daa12019-02-07 14:46:29 +01003636 cfgerr++;
3637 continue;
3638 }
3639
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003640 for (i = 0; i < global.nbthread; i++)
3641 LIST_INIT(&newsrv->available_conns[i]);
Willy Tarreau980855b2019-02-07 14:59:29 +01003642
3643 if (newsrv->max_idle_conns != 0) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003644 if (idle_conn_task == NULL) {
3645 idle_conn_task = task_new(MAX_THREADS_MASK);
3646 if (!idle_conn_task)
3647 goto err;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003648
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003649 idle_conn_task->process = srv_cleanup_idle_connections;
3650 idle_conn_task->context = NULL;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003651
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003652 for (i = 0; i < global.nbthread; i++) {
Willy Tarreaubbb5f1d2019-10-18 08:50:49 +02003653 idle_conn_cleanup[i] = task_new(1UL << i);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003654 if (!idle_conn_cleanup[i])
3655 goto err;
3656 idle_conn_cleanup[i]->process = srv_cleanup_toremove_connections;
3657 idle_conn_cleanup[i]->context = NULL;
Olivier Houchard859dc802019-08-08 15:47:21 +02003658 MT_LIST_INIT(&toremove_connections[i]);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003659 }
3660 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003661
3662 newsrv->idle_conns = calloc((unsigned)global.nbthread, sizeof(*newsrv->idle_conns));
3663 if (!newsrv->idle_conns) {
3664 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
3665 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3666 cfgerr++;
3667 continue;
3668 }
3669
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003670 for (i = 0; i < global.nbthread; i++)
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003671 MT_LIST_INIT(&newsrv->idle_conns[i]);
3672
3673 newsrv->safe_conns = calloc((unsigned)global.nbthread, sizeof(*newsrv->safe_conns));
3674 if (!newsrv->safe_conns) {
3675 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
3676 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3677 cfgerr++;
3678 continue;
3679 }
3680
3681 for (i = 0; i < global.nbthread; i++)
3682 MT_LIST_INIT(&newsrv->safe_conns[i]);
3683
3684 newsrv->curr_idle_thr = calloc(global.nbthread, sizeof(int));
Olivier Houchardf1314812019-02-18 16:41:17 +01003685 if (!newsrv->curr_idle_thr)
3686 goto err;
Willy Tarreau980855b2019-02-07 14:59:29 +01003687 continue;
3688 err:
3689 ha_alert("parsing [%s:%d] : failed to allocate idle connection tasks for server '%s'.\n",
3690 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3691 cfgerr++;
3692 continue;
3693 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003694 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003695 }
3696
3697 /***********************************************************/
3698 /* At this point, target names have already been resolved. */
3699 /***********************************************************/
3700
3701 /* Check multi-process mode compatibility */
3702
3703 if (global.nbproc > 1 && global.stats_fe) {
3704 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3705 unsigned long mask;
3706
Willy Tarreau6daac192019-02-02 17:39:53 +01003707 mask = proc_mask(global.stats_fe->bind_proc) && all_proc_mask;
3708 mask &= proc_mask(bind_conf->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003709
3710 /* stop here if more than one process is used */
Willy Tarreau9504dd62018-10-15 09:37:03 +02003711 if (atleast2(mask))
Willy Tarreau419ead82014-09-16 13:41:21 +02003712 break;
3713 }
3714 if (&bind_conf->by_fe != &global.stats_fe->conf.bind) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003715 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 +02003716 }
3717 }
3718
3719 /* Make each frontend inherit bind-process from its listeners when not specified. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003720 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003721 if (curproxy->bind_proc)
3722 continue;
3723
3724 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3725 unsigned long mask;
3726
Willy Tarreau6daac192019-02-02 17:39:53 +01003727 mask = proc_mask(bind_conf->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003728 curproxy->bind_proc |= mask;
3729 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003730 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003731 }
3732
3733 if (global.stats_fe) {
3734 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3735 unsigned long mask;
3736
Cyril Bonté06181952016-02-24 00:14:54 +01003737 mask = bind_conf->bind_proc ? bind_conf->bind_proc : 0;
Willy Tarreau419ead82014-09-16 13:41:21 +02003738 global.stats_fe->bind_proc |= mask;
3739 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003740 global.stats_fe->bind_proc = proc_mask(global.stats_fe->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003741 }
3742
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003743 /* propagate bindings from frontends to backends. Don't do it if there
3744 * are any fatal errors as we must not call it with unresolved proxies.
3745 */
3746 if (!cfgerr) {
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003747 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003748 if (curproxy->cap & PR_CAP_FE)
3749 propagate_processes(curproxy, NULL);
3750 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003751 }
3752
3753 /* Bind each unbound backend to all processes when not specified. */
Willy Tarreau6daac192019-02-02 17:39:53 +01003754 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
3755 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003756
3757 /*******************************************************/
3758 /* At this step, all proxies have a non-null bind_proc */
3759 /*******************************************************/
3760
3761 /* perform the final checks before creating tasks */
3762
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003763 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003764 struct listener *listener;
3765 unsigned int next_id;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003766
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003767 /* Configure SSL for each bind line.
3768 * Note: if configuration fails at some point, the ->ctx member
3769 * remains NULL so that listeners can later detach.
3770 */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003771 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau55d37912016-12-21 23:38:39 +01003772 if (bind_conf->xprt->prepare_bind_conf &&
3773 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003774 cfgerr++;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003775 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003776
Willy Tarreaue6b98942007-10-29 01:09:36 +01003777 /* adjust this proxy's listeners */
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003778 next_id = 1;
Willy Tarreau4348fad2012-09-20 16:48:07 +02003779 list_for_each_entry(listener, &curproxy->conf.listeners, by_fe) {
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003780 int nbproc;
3781
3782 nbproc = my_popcountl(curproxy->bind_proc &
Cyril Bonté4920d702016-04-15 07:58:43 +02003783 (listener->bind_conf->bind_proc ? listener->bind_conf->bind_proc : curproxy->bind_proc) &
Willy Tarreaua38a7172019-02-02 17:11:28 +01003784 all_proc_mask);
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003785
3786 if (!nbproc) /* no intersection between listener and frontend */
3787 nbproc = 1;
3788
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003789 if (!listener->luid) {
3790 /* listener ID not set, use automatic numbering with first
3791 * spare entry starting with next_luid.
3792 */
3793 next_id = get_next_id(&curproxy->conf.used_listener_id, next_id);
3794 listener->conf.id.key = listener->luid = next_id;
3795 eb32_insert(&curproxy->conf.used_listener_id, &listener->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003796 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01003797 next_id++;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003798
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003799 /* enable separate counters */
3800 if (curproxy->options2 & PR_O2_SOCKSTAT) {
Willy Tarreauae9bea02016-11-25 14:44:52 +01003801 listener->counters = calloc(1, sizeof(*listener->counters));
Willy Tarreau19d14ef2012-10-29 16:51:55 +01003802 if (!listener->name)
3803 memprintf(&listener->name, "sock-%d", listener->luid);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003804 }
Willy Tarreau81796be2012-09-22 19:11:47 +02003805
Willy Tarreaue6b98942007-10-29 01:09:36 +01003806 if (curproxy->options & PR_O_TCP_NOLING)
3807 listener->options |= LI_O_NOLINGER;
Willy Tarreau16a21472012-11-19 12:39:59 +01003808 if (!listener->maxaccept)
3809 listener->maxaccept = global.tune.maxaccept ? global.tune.maxaccept : 64;
3810
3811 /* we want to have an optimal behaviour on single process mode to
3812 * maximize the work at once, but in multi-process we want to keep
3813 * some fairness between processes, so we target half of the max
3814 * number of events to be balanced over all the processes the proxy
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05003815 * is bound to. Remember that maxaccept = -1 must be kept as it is
Willy Tarreau16a21472012-11-19 12:39:59 +01003816 * used to disable the limit.
3817 */
Christopher Faulet02f3cf12019-04-30 14:08:41 +02003818 if (listener->maxaccept > 0 && nbproc > 1) {
3819 listener->maxaccept = (listener->maxaccept + 1) / 2;
Willy Tarreau16a21472012-11-19 12:39:59 +01003820 listener->maxaccept = (listener->maxaccept + nbproc - 1) / nbproc;
3821 }
3822
Willy Tarreau9903f0e2015-04-04 18:50:31 +02003823 listener->accept = session_accept_fd;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003824 listener->analysers |= curproxy->fe_req_ana;
Willy Tarreau10b688f2015-03-13 16:43:12 +01003825 listener->default_target = curproxy->default_target;
Willy Tarreau3bc13772008-12-07 11:50:35 +01003826
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003827 if (!LIST_ISEMPTY(&curproxy->tcp_req.l4_rules))
Willy Tarreau7d9736f2016-10-21 16:34:21 +02003828 listener->options |= LI_O_TCP_L4_RULES;
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003829
Willy Tarreau620408f2016-10-21 16:37:51 +02003830 if (!LIST_ISEMPTY(&curproxy->tcp_req.l5_rules))
3831 listener->options |= LI_O_TCP_L5_RULES;
3832
Willy Tarreaude3041d2010-05-31 10:56:17 +02003833 if (curproxy->mon_mask.s_addr)
3834 listener->options |= LI_O_CHK_MONNET;
3835
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003836 /* smart accept mode is automatic in HTTP mode */
3837 if ((curproxy->options2 & PR_O2_SMARTACC) ||
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003838 ((curproxy->mode == PR_MODE_HTTP || listener->bind_conf->is_ssl) &&
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003839 !(curproxy->no_options2 & PR_O2_SMARTACC)))
3840 listener->options |= LI_O_NOQUICKACK;
Willy Tarreaue6b98942007-10-29 01:09:36 +01003841 }
3842
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003843 /* Release unused SSL configs */
3844 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau795cdab2016-12-22 17:30:54 +01003845 if (!bind_conf->is_ssl && bind_conf->xprt->destroy_bind_conf)
3846 bind_conf->xprt->destroy_bind_conf(bind_conf);
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003847 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003848
Willy Tarreaua38a7172019-02-02 17:11:28 +01003849 if (atleast2(curproxy->bind_proc & all_proc_mask)) {
Willy Tarreau102df612014-05-07 23:56:38 +02003850 if (curproxy->uri_auth) {
Willy Tarreaueb791e02014-09-16 15:11:04 +02003851 int count, maxproc = 0;
3852
3853 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
David Carliere6c39412015-07-02 07:00:17 +00003854 count = my_popcountl(bind_conf->bind_proc);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003855 if (count > maxproc)
3856 maxproc = count;
3857 }
3858 /* backends have 0, frontends have 1 or more */
3859 if (maxproc != 1)
Christopher Faulet767a84b2017-11-24 16:50:31 +01003860 ha_warning("Proxy '%s': in multi-process mode, stats will be"
3861 " limited to process assigned to the current request.\n",
3862 curproxy->id);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003863
Willy Tarreau102df612014-05-07 23:56:38 +02003864 if (!LIST_ISEMPTY(&curproxy->uri_auth->admin_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003865 ha_warning("Proxy '%s': stats admin will not work correctly in multi-process mode.\n",
3866 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003867 }
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003868 }
Willy Tarreau102df612014-05-07 23:56:38 +02003869 if (!LIST_ISEMPTY(&curproxy->sticking_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003870 ha_warning("Proxy '%s': sticking rules will not work correctly in multi-process mode.\n",
3871 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003872 }
3873 }
Willy Tarreau918ff602011-07-25 16:33:49 +02003874
3875 /* create the task associated with the proxy */
Emeric Brunc60def82017-09-27 14:59:38 +02003876 curproxy->task = task_new(MAX_THREADS_MASK);
Willy Tarreau918ff602011-07-25 16:33:49 +02003877 if (curproxy->task) {
3878 curproxy->task->context = curproxy;
3879 curproxy->task->process = manage_proxy;
Willy Tarreau918ff602011-07-25 16:33:49 +02003880 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003881 ha_alert("Proxy '%s': no more memory when trying to allocate the management task\n",
3882 curproxy->id);
Willy Tarreau918ff602011-07-25 16:33:49 +02003883 cfgerr++;
3884 }
Willy Tarreaub369a042014-09-16 13:21:03 +02003885 }
3886
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003887 /*
3888 * Recount currently required checks.
3889 */
3890
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003891 for (curproxy=proxies_list; curproxy; curproxy=curproxy->next) {
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003892 int optnum;
3893
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003894 for (optnum = 0; cfg_opts[optnum].name; optnum++)
3895 if (curproxy->options & cfg_opts[optnum].val)
3896 global.last_checks |= cfg_opts[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003897
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003898 for (optnum = 0; cfg_opts2[optnum].name; optnum++)
3899 if (curproxy->options2 & cfg_opts2[optnum].val)
3900 global.last_checks |= cfg_opts2[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003901 }
3902
Willy Tarreau0fca4832015-05-01 19:12:05 +02003903 /* compute the required process bindings for the peers */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003904 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003905 if (curproxy->table && curproxy->table->peers.p)
3906 curproxy->table->peers.p->peers_fe->bind_proc |= curproxy->bind_proc;
Willy Tarreau0fca4832015-05-01 19:12:05 +02003907
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01003908 /* compute the required process bindings for the peers from <stktables_list>
3909 * for all the stick-tables, the ones coming with "peers" sections included.
3910 */
3911 for (t = stktables_list; t; t = t->next) {
3912 struct proxy *p;
3913
3914 for (p = t->proxies_list; p; p = p->next_stkt_ref) {
3915 if (t->peers.p && t->peers.p->peers_fe) {
3916 t->peers.p->peers_fe->bind_proc |= p->bind_proc;
3917 }
3918 }
3919 }
3920
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003921 if (cfg_peers) {
3922 struct peers *curpeers = cfg_peers, **last;
Willy Tarreau122541c2011-09-07 21:24:49 +02003923 struct peer *p, *pb;
3924
William Lallemanda2cfd7e2020-03-24 16:02:48 +01003925 /* In the case the peers frontend was not initialized by a
3926 stick-table used in the configuration, set its bind_proc
3927 by default to the first process. */
3928 while (curpeers) {
William Lallemand3ef2d562020-03-24 16:42:15 +01003929 if (curpeers->peers_fe) {
3930 if (curpeers->peers_fe->bind_proc == 0)
3931 curpeers->peers_fe->bind_proc = 1;
3932 }
William Lallemanda2cfd7e2020-03-24 16:02:48 +01003933 curpeers = curpeers->next;
3934 }
3935
3936 curpeers = cfg_peers;
Willy Tarreau1e273012015-05-01 19:15:17 +02003937 /* Remove all peers sections which don't have a valid listener,
3938 * which are not used by any table, or which are bound to more
3939 * than one process.
Willy Tarreau122541c2011-09-07 21:24:49 +02003940 */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003941 last = &cfg_peers;
Willy Tarreau122541c2011-09-07 21:24:49 +02003942 while (*last) {
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003943 struct stktable *t;
Willy Tarreau122541c2011-09-07 21:24:49 +02003944 curpeers = *last;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003945
3946 if (curpeers->state == PR_STSTOPPED) {
3947 /* the "disabled" keyword was present */
3948 if (curpeers->peers_fe)
3949 stop_proxy(curpeers->peers_fe);
3950 curpeers->peers_fe = NULL;
3951 }
Frédéric Lécaille5a4fe5a2019-10-04 08:30:04 +02003952 else if (!curpeers->peers_fe || !curpeers->peers_fe->id) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003953 ha_warning("Removing incomplete section 'peers %s' (no peer named '%s').\n",
3954 curpeers->id, localpeer);
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003955 if (curpeers->peers_fe)
3956 stop_proxy(curpeers->peers_fe);
3957 curpeers->peers_fe = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003958 }
Willy Tarreau9504dd62018-10-15 09:37:03 +02003959 else if (atleast2(curpeers->peers_fe->bind_proc)) {
Willy Tarreau1e273012015-05-01 19:15:17 +02003960 /* either it's totally stopped or too much used */
3961 if (curpeers->peers_fe->bind_proc) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003962 ha_alert("Peers section '%s': peers referenced by sections "
3963 "running in different processes (%d different ones). "
3964 "Check global.nbproc and all tables' bind-process "
3965 "settings.\n", curpeers->id, my_popcountl(curpeers->peers_fe->bind_proc));
Willy Tarreau1e273012015-05-01 19:15:17 +02003966 cfgerr++;
3967 }
3968 stop_proxy(curpeers->peers_fe);
3969 curpeers->peers_fe = NULL;
3970 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003971 else {
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01003972 /* Initializes the transport layer of the server part of all the peers belonging to
3973 * <curpeers> section if required.
3974 * Note that ->srv is used by the local peer of a new process to connect to the local peer
3975 * of an old process.
3976 */
Frédéric Lécaille1055e682018-04-26 14:35:21 +02003977 p = curpeers->remote;
3978 while (p) {
Frédéric Lécaille355b2032019-01-11 14:06:12 +01003979 if (p->srv) {
Christopher Fauletf61f33a2020-03-27 18:55:49 +01003980 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 +01003981 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(p->srv);
3982 }
Frédéric Lécaille1055e682018-04-26 14:35:21 +02003983 p = p->next;
3984 }
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01003985 /* Configure the SSL bindings of the local peer if required. */
3986 if (!LIST_ISEMPTY(&curpeers->peers_fe->conf.bind)) {
3987 struct list *l;
3988 struct bind_conf *bind_conf;
3989
3990 l = &curpeers->peers_fe->conf.bind;
3991 bind_conf = LIST_ELEM(l->n, typeof(bind_conf), by_fe);
3992 if (bind_conf->xprt->prepare_bind_conf &&
3993 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
3994 cfgerr++;
3995 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02003996 if (!peers_init_sync(curpeers) || !peers_alloc_dcache(curpeers)) {
Willy Tarreaud9443442018-10-15 11:18:03 +02003997 ha_alert("Peers section '%s': out of memory, giving up on peers.\n",
3998 curpeers->id);
3999 cfgerr++;
4000 break;
4001 }
Willy Tarreau122541c2011-09-07 21:24:49 +02004002 last = &curpeers->next;
4003 continue;
4004 }
4005
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004006 /* clean what has been detected above */
Willy Tarreau122541c2011-09-07 21:24:49 +02004007 p = curpeers->remote;
4008 while (p) {
4009 pb = p->next;
4010 free(p->id);
4011 free(p);
4012 p = pb;
4013 }
4014
4015 /* Destroy and unlink this curpeers section.
4016 * Note: curpeers is backed up into *last.
4017 */
4018 free(curpeers->id);
4019 curpeers = curpeers->next;
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01004020 /* Reset any refereance to this peers section in the list of stick-tables */
4021 for (t = stktables_list; t; t = t->next) {
4022 if (t->peers.p && t->peers.p == *last)
4023 t->peers.p = NULL;
4024 }
Willy Tarreau122541c2011-09-07 21:24:49 +02004025 free(*last);
4026 *last = curpeers;
4027 }
4028 }
4029
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004030 for (t = stktables_list; t; t = t->next) {
4031 if (t->proxy)
4032 continue;
4033 if (!stktable_init(t)) {
4034 ha_alert("Proxy '%s': failed to initialize stick-table.\n", t->id);
4035 cfgerr++;
4036 }
4037 }
4038
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004039 /* initialize stick-tables on backend capable proxies. This must not
4040 * be done earlier because the data size may be discovered while parsing
4041 * other proxies.
4042 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004043 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004044 if (curproxy->state == PR_STSTOPPED || !curproxy->table)
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004045 continue;
4046
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004047 if (!stktable_init(curproxy->table)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004048 ha_alert("Proxy '%s': failed to initialize stick-table.\n", curproxy->id);
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004049 cfgerr++;
4050 }
4051 }
4052
Simon Horman0d16a402015-01-30 11:22:58 +09004053 if (mailers) {
4054 struct mailers *curmailers = mailers, **last;
4055 struct mailer *m, *mb;
4056
4057 /* Remove all mailers sections which don't have a valid listener.
4058 * This can happen when a mailers section is never referenced.
4059 */
4060 last = &mailers;
4061 while (*last) {
4062 curmailers = *last;
4063 if (curmailers->users) {
4064 last = &curmailers->next;
4065 continue;
4066 }
4067
Christopher Faulet767a84b2017-11-24 16:50:31 +01004068 ha_warning("Removing incomplete section 'mailers %s'.\n",
4069 curmailers->id);
Simon Horman0d16a402015-01-30 11:22:58 +09004070
4071 m = curmailers->mailer_list;
4072 while (m) {
4073 mb = m->next;
4074 free(m->id);
4075 free(m);
4076 m = mb;
4077 }
4078
4079 /* Destroy and unlink this curmailers section.
4080 * Note: curmailers is backed up into *last.
4081 */
4082 free(curmailers->id);
4083 curmailers = curmailers->next;
4084 free(*last);
4085 *last = curmailers;
4086 }
4087 }
4088
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004089 /* Update server_state_file_name to backend name if backend is supposed to use
4090 * a server-state file locally defined and none has been provided */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004091 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004092 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_LOCAL &&
4093 curproxy->server_state_file_name == NULL)
4094 curproxy->server_state_file_name = strdup(curproxy->id);
4095 }
4096
Ben Draut054fbee2018-04-13 15:43:04 -06004097 list_for_each_entry(curr_resolvers, &dns_resolvers, list) {
4098 if (LIST_ISEMPTY(&curr_resolvers->nameservers)) {
4099 ha_warning("config : resolvers '%s' [%s:%d] has no nameservers configured!\n",
4100 curr_resolvers->id, curr_resolvers->conf.file,
4101 curr_resolvers->conf.line);
4102 err_code |= ERR_WARN;
4103 }
4104 }
4105
William Lallemand48b4bb42017-10-23 14:36:34 +02004106 list_for_each_entry(postparser, &postparsers, list) {
4107 if (postparser->func)
4108 cfgerr += postparser->func();
4109 }
4110
Willy Tarreaubb925012009-07-23 13:36:36 +02004111 if (cfgerr > 0)
4112 err_code |= ERR_ALERT | ERR_FATAL;
4113 out:
4114 return err_code;
Willy Tarreaubaaee002006-06-26 02:48:02 +02004115}
4116
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004117/*
4118 * Registers the CFG keyword list <kwl> as a list of valid keywords for next
4119 * parsing sessions.
4120 */
4121void cfg_register_keywords(struct cfg_kw_list *kwl)
4122{
4123 LIST_ADDQ(&cfg_keywords.list, &kwl->list);
4124}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004125
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004126/*
4127 * Unregisters the CFG keyword list <kwl> from the list of valid keywords.
4128 */
4129void cfg_unregister_keywords(struct cfg_kw_list *kwl)
4130{
4131 LIST_DEL(&kwl->list);
4132 LIST_INIT(&kwl->list);
4133}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004134
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004135/* this function register new section in the haproxy configuration file.
4136 * <section_name> is the name of this new section and <section_parser>
4137 * is the called parser. If two section declaration have the same name,
4138 * only the first declared is used.
4139 */
4140int cfg_register_section(char *section_name,
William Lallemandd2ff56d2017-10-16 11:06:50 +02004141 int (*section_parser)(const char *, int, char **, int),
4142 int (*post_section_parser)())
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004143{
4144 struct cfg_section *cs;
4145
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004146 list_for_each_entry(cs, &sections, list) {
4147 if (strcmp(cs->section_name, section_name) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004148 ha_alert("register section '%s': already registered.\n", section_name);
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004149 return 0;
4150 }
4151 }
4152
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004153 cs = calloc(1, sizeof(*cs));
4154 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004155 ha_alert("register section '%s': out of memory.\n", section_name);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004156 return 0;
4157 }
4158
4159 cs->section_name = section_name;
4160 cs->section_parser = section_parser;
William Lallemandd2ff56d2017-10-16 11:06:50 +02004161 cs->post_section_parser = post_section_parser;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004162
4163 LIST_ADDQ(&sections, &cs->list);
4164
4165 return 1;
4166}
4167
William Lallemand48b4bb42017-10-23 14:36:34 +02004168/* this function register a new function which will be called once the haproxy
4169 * configuration file has been parsed. It's useful to check dependencies
4170 * between sections or to resolve items once everything is parsed.
4171 */
4172int cfg_register_postparser(char *name, int (*func)())
4173{
4174 struct cfg_postparser *cp;
4175
4176 cp = calloc(1, sizeof(*cp));
4177 if (!cp) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004178 ha_alert("register postparser '%s': out of memory.\n", name);
William Lallemand48b4bb42017-10-23 14:36:34 +02004179 return 0;
4180 }
4181 cp->name = name;
4182 cp->func = func;
4183
4184 LIST_ADDQ(&postparsers, &cp->list);
4185
4186 return 1;
4187}
4188
Willy Tarreaubaaee002006-06-26 02:48:02 +02004189/*
David Carlier845efb52015-09-25 11:49:18 +01004190 * free all config section entries
4191 */
4192void cfg_unregister_sections(void)
4193{
4194 struct cfg_section *cs, *ics;
4195
4196 list_for_each_entry_safe(cs, ics, &sections, list) {
4197 LIST_DEL(&cs->list);
4198 free(cs);
4199 }
4200}
4201
Christopher Faulet7110b402016-10-26 11:09:44 +02004202void cfg_backup_sections(struct list *backup_sections)
4203{
4204 struct cfg_section *cs, *ics;
4205
4206 list_for_each_entry_safe(cs, ics, &sections, list) {
4207 LIST_DEL(&cs->list);
4208 LIST_ADDQ(backup_sections, &cs->list);
4209 }
4210}
4211
4212void cfg_restore_sections(struct list *backup_sections)
4213{
4214 struct cfg_section *cs, *ics;
4215
4216 list_for_each_entry_safe(cs, ics, backup_sections, list) {
4217 LIST_DEL(&cs->list);
4218 LIST_ADDQ(&sections, &cs->list);
4219 }
4220}
4221
Willy Tarreaue6552512018-11-26 11:33:13 +01004222/* these are the config sections handled by default */
4223REGISTER_CONFIG_SECTION("listen", cfg_parse_listen, NULL);
4224REGISTER_CONFIG_SECTION("frontend", cfg_parse_listen, NULL);
4225REGISTER_CONFIG_SECTION("backend", cfg_parse_listen, NULL);
4226REGISTER_CONFIG_SECTION("defaults", cfg_parse_listen, NULL);
4227REGISTER_CONFIG_SECTION("global", cfg_parse_global, NULL);
4228REGISTER_CONFIG_SECTION("userlist", cfg_parse_users, NULL);
4229REGISTER_CONFIG_SECTION("peers", cfg_parse_peers, NULL);
4230REGISTER_CONFIG_SECTION("mailers", cfg_parse_mailers, NULL);
4231REGISTER_CONFIG_SECTION("namespace_list", cfg_parse_netns, NULL);
4232REGISTER_CONFIG_SECTION("resolvers", cfg_parse_resolvers, NULL);
Willy Tarreau659fbf02016-05-26 17:55:28 +02004233
David Carlier845efb52015-09-25 11:49:18 +01004234/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02004235 * Local variables:
4236 * c-indent-level: 8
4237 * c-basic-offset: 8
4238 * End:
4239 */