blob: 2c660ab0dae3bc6002ab4308bc530fe8ec1a1378 [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
Cyril Bonté1a0191d2014-08-29 20:20:02 +020013#ifdef CONFIG_HAP_CRYPT
14/* This is to have crypt() defined on Linux */
15#define _GNU_SOURCE
16
17#ifdef NEED_CRYPT_H
18/* some platforms such as Solaris need this */
19#include <crypt.h>
20#endif
21#endif /* CONFIG_HAP_CRYPT */
22
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 Tarreau34eb6712011-10-24 18:15:04 +020066#include <proto/hdr_idx.h>
Willy Tarreau61c112a2018-10-02 16:43:32 +020067#include <proto/http_rules.h>
Willy Tarreau6b2e11b2009-10-01 07:52:15 +020068#include <proto/lb_chash.h>
Willy Tarreauf09c6602012-02-13 17:12:08 +010069#include <proto/lb_fas.h>
Willy Tarreauf89c1872009-10-01 11:19:37 +020070#include <proto/lb_fwlc.h>
71#include <proto/lb_fwrr.h>
72#include <proto/lb_map.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020073#include <proto/listener.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020074#include <proto/log.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020075#include <proto/protocol.h>
Willy Tarreaue6b98942007-10-29 01:09:36 +010076#include <proto/proto_http.h>
Willy Tarreau2b5652f2006-12-31 17:46:05 +010077#include <proto/proxy.h>
Emeric Brun32da3c42010-09-23 18:39:19 +020078#include <proto/peers.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020079#include <proto/sample.h>
Willy Tarreau9903f0e2015-04-04 18:50:31 +020080#include <proto/session.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020081#include <proto/server.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020082#include <proto/stream.h>
Emeric Brunb982a3d2010-01-04 15:45:53 +010083#include <proto/stick_table.h>
Willy Tarreau39713102016-11-25 15:49:32 +010084#include <proto/task.h>
85#include <proto/tcp_rules.h>
Olivier Houchard673867c2018-05-25 16:58:52 +020086#include <proto/connection.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020087
88
Willy Tarreauf3c69202006-07-09 16:42:34 +020089/* This is the SSLv3 CLIENT HELLO packet used in conjunction with the
90 * ssl-hello-chk option to ensure that the remote server speaks SSL.
91 *
92 * Check RFC 2246 (TLSv1.0) sections A.3 and A.4 for details.
93 */
94const char sslv3_client_hello_pkt[] = {
95 "\x16" /* ContentType : 0x16 = Hanshake */
96 "\x03\x00" /* ProtocolVersion : 0x0300 = SSLv3 */
97 "\x00\x79" /* ContentLength : 0x79 bytes after this one */
98 "\x01" /* HanshakeType : 0x01 = CLIENT HELLO */
99 "\x00\x00\x75" /* HandshakeLength : 0x75 bytes after this one */
100 "\x03\x00" /* Hello Version : 0x0300 = v3 */
101 "\x00\x00\x00\x00" /* Unix GMT Time (s) : filled with <now> (@0x0B) */
102 "HAPROXYSSLCHK\nHAPROXYSSLCHK\n" /* Random : must be exactly 28 bytes */
103 "\x00" /* Session ID length : empty (no session ID) */
104 "\x00\x4E" /* Cipher Suite Length : 78 bytes after this one */
105 "\x00\x01" "\x00\x02" "\x00\x03" "\x00\x04" /* 39 most common ciphers : */
106 "\x00\x05" "\x00\x06" "\x00\x07" "\x00\x08" /* 0x01...0x1B, 0x2F...0x3A */
107 "\x00\x09" "\x00\x0A" "\x00\x0B" "\x00\x0C" /* This covers RSA/DH, */
108 "\x00\x0D" "\x00\x0E" "\x00\x0F" "\x00\x10" /* various bit lengths, */
109 "\x00\x11" "\x00\x12" "\x00\x13" "\x00\x14" /* SHA1/MD5, DES/3DES/AES... */
110 "\x00\x15" "\x00\x16" "\x00\x17" "\x00\x18"
111 "\x00\x19" "\x00\x1A" "\x00\x1B" "\x00\x2F"
112 "\x00\x30" "\x00\x31" "\x00\x32" "\x00\x33"
113 "\x00\x34" "\x00\x35" "\x00\x36" "\x00\x37"
114 "\x00\x38" "\x00\x39" "\x00\x3A"
115 "\x01" /* Compression Length : 0x01 = 1 byte for types */
116 "\x00" /* Compression Type : 0x00 = NULL compression */
117};
118
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +0100119/* Used to chain configuration sections definitions. This list
120 * stores struct cfg_section
121 */
122struct list sections = LIST_HEAD_INIT(sections);
123
William Lallemand48b4bb42017-10-23 14:36:34 +0200124struct list postparsers = LIST_HEAD_INIT(postparsers);
125
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100126char *cursection = NULL;
127struct proxy defproxy = { }; /* fake proxy used to assign default values on all instances */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200128int cfg_maxpconn = DEFAULT_MAXCONN; /* # of simultaneous connections per proxy (-N) */
Willy Tarreau5af24ef2009-03-15 15:23:16 +0100129int cfg_maxconn = 0; /* # of simultaneous connections, (-n) */
Christopher Faulet79bdef32016-11-04 22:36:15 +0100130char *cfg_scope = NULL; /* the current scope during the configuration parsing */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200131
Willy Tarreau5b2c3362008-07-09 19:39:06 +0200132/* List head of all known configuration keywords */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100133struct cfg_kw_list cfg_keywords = {
Willy Tarreau5b2c3362008-07-09 19:39:06 +0200134 .list = LIST_HEAD_INIT(cfg_keywords.list)
135};
136
Willy Tarreaubaaee002006-06-26 02:48:02 +0200137/*
138 * converts <str> to a list of listeners which are dynamically allocated.
139 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
140 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
141 * - <port> is a numerical port from 1 to 65535 ;
142 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
143 * This can be repeated as many times as necessary, separated by a coma.
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200144 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
145 * not NULL, it must be a valid pointer to either NULL or a freeable area that
146 * will be replaced with an error message.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200147 */
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200148int 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 +0200149{
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100150 char *next, *dupstr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200151 int port, end;
152
153 next = dupstr = strdup(str);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200154
Willy Tarreaubaaee002006-06-26 02:48:02 +0200155 while (next && *next) {
William Lallemand75ea0a02017-11-15 19:02:58 +0100156 int inherited = 0;
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200157 struct sockaddr_storage *ss2;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100158 int fd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200159
160 str = next;
161 /* 1) look for the end of the first address */
Krzysztof Piotr Oledzki52d522b2009-01-27 16:57:08 +0100162 if ((next = strchr(str, ',')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200163 *next++ = 0;
164 }
165
Willy Tarreau48ef4c92017-01-06 18:32:38 +0100166 ss2 = str2sa_range(str, NULL, &port, &end, err,
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200167 curproxy == global.stats_fe ? NULL : global.unix_bind.prefix,
Thierry FOURNIER7fe3be72015-09-26 20:03:36 +0200168 NULL, 1);
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100169 if (!ss2)
170 goto fail;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200171
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100172 if (ss2->ss_family == AF_INET || ss2->ss_family == AF_INET6) {
Willy Tarreau6d03cc32013-02-20 17:26:02 +0100173 if (!port && !end) {
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200174 memprintf(err, "missing port number: '%s'\n", str);
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100175 goto fail;
Emeric Bruned760922010-10-22 17:59:25 +0200176 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200177
Willy Tarreau6d03cc32013-02-20 17:26:02 +0100178 if (!port || !end) {
179 memprintf(err, "port offsets are not allowed in 'bind': '%s'\n", str);
180 goto fail;
181 }
182
Emeric Bruned760922010-10-22 17:59:25 +0200183 if (port < 1 || port > 65535) {
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200184 memprintf(err, "invalid port '%d' specified for address '%s'.\n", port, str);
Emeric Bruned760922010-10-22 17:59:25 +0200185 goto fail;
186 }
187
188 if (end < 1 || end > 65535) {
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200189 memprintf(err, "invalid port '%d' specified for address '%s'.\n", end, str);
Emeric Bruned760922010-10-22 17:59:25 +0200190 goto fail;
191 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200192 }
Willy Tarreau40aa0702013-03-10 23:51:38 +0100193 else if (ss2->ss_family == AF_UNSPEC) {
194 socklen_t addr_len;
William Lallemand75ea0a02017-11-15 19:02:58 +0100195 inherited = 1;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100196
197 /* We want to attach to an already bound fd whose number
198 * is in the addr part of ss2 when cast to sockaddr_in.
199 * Note that by definition there is a single listener.
200 * We still have to determine the address family to
201 * register the correct protocol.
202 */
203 fd = ((struct sockaddr_in *)ss2)->sin_addr.s_addr;
204 addr_len = sizeof(*ss2);
205 if (getsockname(fd, (struct sockaddr *)ss2, &addr_len) == -1) {
206 memprintf(err, "cannot use file descriptor '%d' : %s.\n", fd, strerror(errno));
207 goto fail;
208 }
209
210 port = end = get_host_port(ss2);
William Lallemand2fe7dd02018-09-11 16:51:29 +0200211
212 } else if (ss2->ss_family == AF_CUST_SOCKPAIR) {
213 socklen_t addr_len;
214 inherited = 1;
215
216 fd = ((struct sockaddr_in *)ss2)->sin_addr.s_addr;
217 addr_len = sizeof(*ss2);
218 if (getsockname(fd, (struct sockaddr *)ss2, &addr_len) == -1) {
219 memprintf(err, "cannot use file descriptor '%d' : %s.\n", fd, strerror(errno));
220 goto fail;
221 }
222
223 ss2->ss_family = AF_CUST_SOCKPAIR; /* reassign AF_CUST_SOCKPAIR because of getsockname */
224 port = end = 0;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100225 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200226
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100227 /* OK the address looks correct */
William Lallemand75ea0a02017-11-15 19:02:58 +0100228 if (!create_listeners(bind_conf, ss2, port, end, fd, inherited, err)) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200229 memprintf(err, "%s for address '%s'.\n", *err, str);
230 goto fail;
231 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200232 } /* end while(next) */
233 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200234 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200235 fail:
236 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200237 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200238}
239
William Lallemand6e62fb62015-04-28 16:55:23 +0200240/*
Willy Tarreauece9b072016-12-21 22:41:44 +0100241 * Report an error in <msg> when there are too many arguments. This version is
242 * intended to be used by keyword parsers so that the message will be included
243 * into the general error message. The index is the current keyword in args.
244 * Return 0 if the number of argument is correct, otherwise build a message and
245 * return 1. Fill err_code with an ERR_ALERT and an ERR_FATAL if not null. The
246 * message may also be null, it will simply not be produced (useful to check only).
247 * <msg> and <err_code> are only affected on error.
248 */
249int too_many_args_idx(int maxarg, int index, char **args, char **msg, int *err_code)
250{
251 int i;
252
253 if (!*args[index + maxarg + 1])
254 return 0;
255
256 if (msg) {
257 *msg = NULL;
258 memprintf(msg, "%s", args[0]);
259 for (i = 1; i <= index; i++)
260 memprintf(msg, "%s %s", *msg, args[i]);
261
262 memprintf(msg, "'%s' cannot handle unexpected argument '%s'.", *msg, args[index + maxarg + 1]);
263 }
264 if (err_code)
265 *err_code |= ERR_ALERT | ERR_FATAL;
266
267 return 1;
268}
269
270/*
271 * same as too_many_args_idx with a 0 index
272 */
273int too_many_args(int maxarg, char **args, char **msg, int *err_code)
274{
275 return too_many_args_idx(maxarg, 0, args, msg, err_code);
276}
277
278/*
William Lallemand6e62fb62015-04-28 16:55:23 +0200279 * Report a fatal Alert when there is too much arguments
280 * The index is the current keyword in args
281 * Return 0 if the number of argument is correct, otherwise emit an alert and return 1
282 * Fill err_code with an ERR_ALERT and an ERR_FATAL
283 */
284int alertif_too_many_args_idx(int maxarg, int index, const char *file, int linenum, char **args, int *err_code)
285{
286 char *kw = NULL;
287 int i;
288
289 if (!*args[index + maxarg + 1])
290 return 0;
291
292 memprintf(&kw, "%s", args[0]);
293 for (i = 1; i <= index; i++) {
294 memprintf(&kw, "%s %s", kw, args[i]);
295 }
296
Christopher Faulet767a84b2017-11-24 16:50:31 +0100297 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 +0200298 free(kw);
299 *err_code |= ERR_ALERT | ERR_FATAL;
300 return 1;
301}
302
303/*
304 * same as alertif_too_many_args_idx with a 0 index
305 */
306int alertif_too_many_args(int maxarg, const char *file, int linenum, char **args, int *err_code)
307{
308 return alertif_too_many_args_idx(maxarg, 0, file, linenum, args, err_code);
309}
310
Willy Tarreau61d18892009-03-31 10:49:21 +0200311
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100312/* Report it if a request ACL condition uses some keywords that are incompatible
313 * with the place where the ACL is used. It returns either 0 or ERR_WARN so that
314 * its result can be or'ed with err_code. Note that <cond> may be NULL and then
315 * will be ignored.
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100316 */
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100317int warnif_cond_conflicts(const struct acl_cond *cond, unsigned int where, const char *file, int line)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100318{
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100319 const struct acl *acl;
Willy Tarreau93fddf12013-03-31 22:59:32 +0200320 const char *kw;
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100321
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100322 if (!cond)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100323 return 0;
324
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100325 acl = acl_cond_conflicts(cond, where);
326 if (acl) {
327 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100328 ha_warning("parsing [%s:%d] : acl '%s' will never match because it only involves keywords that are incompatible with '%s'\n",
329 file, line, acl->name, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100330 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100331 ha_warning("parsing [%s:%d] : anonymous acl will never match because it uses keyword '%s' which is incompatible with '%s'\n",
332 file, line, LIST_ELEM(acl->expr.n, struct acl_expr *, list)->kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100333 return ERR_WARN;
334 }
335 if (!acl_cond_kw_conflicts(cond, where, &acl, &kw))
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100336 return 0;
337
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100338 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100339 ha_warning("parsing [%s:%d] : acl '%s' involves keywords '%s' which is incompatible with '%s'\n",
340 file, line, acl->name, kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100341 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100342 ha_warning("parsing [%s:%d] : anonymous acl involves keyword '%s' which is incompatible with '%s'\n",
343 file, line, kw, sample_ckp_names(where));
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100344 return ERR_WARN;
345}
346
Christopher Faulet62519022017-10-16 15:49:32 +0200347/* Parse a string representing a process number or a set of processes. It must
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100348 * be "all", "odd", "even", a number between 1 and <LONGBITS> or a range with
Christopher Faulet5ab51772017-11-22 11:21:58 +0100349 * two such numbers delimited by a dash ('-'). On success, it returns
350 * 0. otherwise it returns 1 with an error message in <err>.
Christopher Faulet62519022017-10-16 15:49:32 +0200351 *
352 * Note: this function can also be used to parse a thread number or a set of
353 * threads.
354 */
Christopher Faulet26028f62017-11-22 15:01:51 +0100355int parse_process_number(const char *arg, unsigned long *proc, int *autoinc, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200356{
Christopher Faulet26028f62017-11-22 15:01:51 +0100357 if (autoinc) {
358 *autoinc = 0;
359 if (strncmp(arg, "auto:", 5) == 0) {
360 arg += 5;
361 *autoinc = 1;
362 }
363 }
364
Christopher Faulet62519022017-10-16 15:49:32 +0200365 if (strcmp(arg, "all") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100366 *proc |= ~0UL;
Christopher Faulet62519022017-10-16 15:49:32 +0200367 else if (strcmp(arg, "odd") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100368 *proc |= ~0UL/3UL; /* 0x555....555 */
Christopher Faulet62519022017-10-16 15:49:32 +0200369 else if (strcmp(arg, "even") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100370 *proc |= (~0UL/3UL) << 1; /* 0xAAA...AAA */
Christopher Faulet62519022017-10-16 15:49:32 +0200371 else {
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100372 char *dash;
373 unsigned int low, high;
374
Christopher Faulet5ab51772017-11-22 11:21:58 +0100375 if (!isdigit((int)*arg)) {
Christopher Fauletcb6a9452017-11-22 16:50:41 +0100376 memprintf(err, "'%s' is not a valid number.\n", arg);
Christopher Faulet5ab51772017-11-22 11:21:58 +0100377 return -1;
378 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100379
380 low = high = str2uic(arg);
381 if ((dash = strchr(arg, '-')) != NULL)
Christopher Fauletff4121f2017-11-22 16:38:49 +0100382 high = ((!*(dash+1)) ? LONGBITS : str2uic(dash + 1));
383
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100384 if (high < low) {
385 unsigned int swap = low;
386 low = high;
387 high = swap;
388 }
389
Christopher Faulet5ab51772017-11-22 11:21:58 +0100390 if (low < 1 || low > LONGBITS || high > LONGBITS) {
Christopher Fauletcb6a9452017-11-22 16:50:41 +0100391 memprintf(err, "'%s' is not a valid number/range."
392 " It supports numbers from 1 to %d.\n",
Christopher Faulet5ab51772017-11-22 11:21:58 +0100393 arg, LONGBITS);
394 return 1;
395 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100396
397 for (;low <= high; low++)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100398 *proc |= 1UL << (low-1);
Christopher Faulet62519022017-10-16 15:49:32 +0200399 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100400
Christopher Faulet5ab51772017-11-22 11:21:58 +0100401 return 0;
Christopher Faulet62519022017-10-16 15:49:32 +0200402}
403
David Carlier7e351ee2017-12-01 09:14:02 +0000404#ifdef USE_CPU_AFFINITY
Christopher Faulet62519022017-10-16 15:49:32 +0200405/* Parse cpu sets. Each CPU set is either a unique number between 0 and
406 * <LONGBITS> or a range with two such numbers delimited by a dash
407 * ('-'). Multiple CPU numbers or ranges may be specified. On success, it
408 * returns 0. otherwise it returns 1 with an error message in <err>.
409 */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100410unsigned long parse_cpu_set(const char **args, unsigned long *cpu_set, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200411{
412 int cur_arg = 0;
413
414 *cpu_set = 0;
415 while (*args[cur_arg]) {
416 char *dash;
417 unsigned int low, high;
418
419 if (!isdigit((int)*args[cur_arg])) {
420 memprintf(err, "'%s' is not a CPU range.\n", args[cur_arg]);
421 return -1;
422 }
423
424 low = high = str2uic(args[cur_arg]);
425 if ((dash = strchr(args[cur_arg], '-')) != NULL)
Christopher Fauletff4121f2017-11-22 16:38:49 +0100426 high = ((!*(dash+1)) ? LONGBITS-1 : str2uic(dash + 1));
Christopher Faulet62519022017-10-16 15:49:32 +0200427
428 if (high < low) {
429 unsigned int swap = low;
430 low = high;
431 high = swap;
432 }
433
434 if (high >= LONGBITS) {
435 memprintf(err, "supports CPU numbers from 0 to %d.\n", LONGBITS - 1);
436 return 1;
437 }
438
439 while (low <= high)
440 *cpu_set |= 1UL << low++;
441
442 cur_arg++;
443 }
444 return 0;
445}
David Carlier7e351ee2017-12-01 09:14:02 +0000446#endif
447
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200448void init_default_instance()
Willy Tarreaubaaee002006-06-26 02:48:02 +0200449{
Willy Tarreau97cb7802010-01-03 20:23:58 +0100450 init_new_proxy(&defproxy);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200451 defproxy.mode = PR_MODE_TCP;
452 defproxy.state = PR_STNEW;
453 defproxy.maxconn = cfg_maxpconn;
454 defproxy.conn_retries = CONN_RETRIES;
Joseph Lynch726ab712015-05-11 23:25:34 -0700455 defproxy.redispatch_after = 0;
Andrew Rodlandb1f48e32016-10-25 12:49:05 -0400456 defproxy.lbprm.chash.balance_factor = 0;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100457
Simon Horman66183002013-02-23 10:16:43 +0900458 defproxy.defsrv.check.inter = DEF_CHKINTR;
459 defproxy.defsrv.check.fastinter = 0;
460 defproxy.defsrv.check.downinter = 0;
Simon Hormand60d6912013-11-25 10:46:36 +0900461 defproxy.defsrv.agent.inter = DEF_CHKINTR;
462 defproxy.defsrv.agent.fastinter = 0;
463 defproxy.defsrv.agent.downinter = 0;
Simon Horman58c32972013-11-25 10:46:38 +0900464 defproxy.defsrv.check.rise = DEF_RISETIME;
465 defproxy.defsrv.check.fall = DEF_FALLTIME;
466 defproxy.defsrv.agent.rise = DEF_AGENT_RISETIME;
467 defproxy.defsrv.agent.fall = DEF_AGENT_FALLTIME;
Willy Tarreau5b3a2022012-09-28 15:01:02 +0200468 defproxy.defsrv.check.port = 0;
Simon Hormand60d6912013-11-25 10:46:36 +0900469 defproxy.defsrv.agent.port = 0;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100470 defproxy.defsrv.maxqueue = 0;
471 defproxy.defsrv.minconn = 0;
472 defproxy.defsrv.maxconn = 0;
473 defproxy.defsrv.slowstart = 0;
474 defproxy.defsrv.onerror = DEF_HANA_ONERR;
475 defproxy.defsrv.consecutive_errors_limit = DEF_HANA_ERRLIMIT;
476 defproxy.defsrv.uweight = defproxy.defsrv.iweight = 1;
Simon Horman64e34162015-02-06 11:11:57 +0900477
478 defproxy.email_alert.level = LOG_ALERT;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +0200479 defproxy.load_server_state_from_file = PR_SRV_STATE_FILE_UNSPEC;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200480}
481
Willy Tarreauade5ec42010-01-28 19:33:49 +0100482
Willy Tarreaubaaee002006-06-26 02:48:02 +0200483/*
William Lallemand51097192015-04-14 16:35:22 +0200484 * Parse a line in a <listen>, <frontend> or <backend> section.
Willy Tarreau93893792009-07-23 13:19:11 +0200485 * Returns the error code, 0 if OK, or any combination of :
486 * - ERR_ABORT: must abort ASAP
487 * - ERR_FATAL: we can continue parsing but not start the service
488 * - ERR_WARN: a warning has been emitted
489 * - ERR_ALERT: an alert has been emitted
490 * Only the two first ones can stop processing, the two others are just
491 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200492 */
Emeric Brun32da3c42010-09-23 18:39:19 +0200493int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
494{
495 static struct peers *curpeers = NULL;
496 struct peer *newpeer = NULL;
497 const char *err;
Willy Tarreau4348fad2012-09-20 16:48:07 +0200498 struct bind_conf *bind_conf;
499 struct listener *l;
Emeric Brun32da3c42010-09-23 18:39:19 +0200500 int err_code = 0;
Willy Tarreau902636f2013-03-10 19:44:48 +0100501 char *errmsg = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +0200502
503 if (strcmp(args[0], "peers") == 0) { /* new peers section */
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100504 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100505 ha_alert("parsing [%s:%d] : missing name for peers section.\n", file, linenum);
Willy Tarreau54984722014-02-16 08:20:13 +0100506 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100507 goto out;
508 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200509
William Lallemand6e62fb62015-04-28 16:55:23 +0200510 if (alertif_too_many_args(1, file, linenum, args, &err_code))
511 goto out;
512
Emeric Brun32da3c42010-09-23 18:39:19 +0200513 err = invalid_char(args[1]);
514 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100515 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
516 file, linenum, *err, args[0], args[1]);
Willy Tarreau54984722014-02-16 08:20:13 +0100517 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100518 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200519 }
520
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200521 for (curpeers = cfg_peers; curpeers != NULL; curpeers = curpeers->next) {
Emeric Brun32da3c42010-09-23 18:39:19 +0200522 /*
523 * If there are two proxies with the same name only following
524 * combinations are allowed:
525 */
526 if (strcmp(curpeers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100527 ha_alert("Parsing [%s:%d]: peers section '%s' has the same name as another peers section declared at %s:%d.\n",
528 file, linenum, args[1], curpeers->conf.file, curpeers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +0200529 err_code |= ERR_ALERT | ERR_FATAL;
Emeric Brun32da3c42010-09-23 18:39:19 +0200530 }
531 }
532
Vincent Bernat02779b62016-04-03 13:48:43 +0200533 if ((curpeers = calloc(1, sizeof(*curpeers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100534 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Emeric Brun32da3c42010-09-23 18:39:19 +0200535 err_code |= ERR_ALERT | ERR_ABORT;
536 goto out;
537 }
538
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200539 curpeers->next = cfg_peers;
540 cfg_peers = curpeers;
Willy Tarreau8113a5d2012-10-04 08:01:43 +0200541 curpeers->conf.file = strdup(file);
Emeric Brun32da3c42010-09-23 18:39:19 +0200542 curpeers->conf.line = linenum;
543 curpeers->last_change = now.tv_sec;
544 curpeers->id = strdup(args[1]);
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200545 curpeers->state = PR_STNEW;
Emeric Brun32da3c42010-09-23 18:39:19 +0200546 }
547 else if (strcmp(args[0], "peer") == 0) { /* peer definition */
David du Colombier6f5ccb12011-03-10 22:26:24 +0100548 struct sockaddr_storage *sk;
Willy Tarreau2aa38802013-02-20 19:20:59 +0100549 int port1, port2;
Willy Tarreaub36487e2013-03-10 18:37:42 +0100550 struct protocol *proto;
Emeric Brun32da3c42010-09-23 18:39:19 +0200551
552 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100553 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
554 file, linenum, args[0]);
Emeric Brun32da3c42010-09-23 18:39:19 +0200555 err_code |= ERR_ALERT | ERR_FATAL;
556 goto out;
557 }
558
559 err = invalid_char(args[1]);
560 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100561 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
562 file, linenum, *err, args[1]);
Emeric Brun32da3c42010-09-23 18:39:19 +0200563 err_code |= ERR_ALERT | ERR_FATAL;
564 goto out;
565 }
566
Vincent Bernat02779b62016-04-03 13:48:43 +0200567 if ((newpeer = calloc(1, sizeof(*newpeer))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100568 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Emeric Brun32da3c42010-09-23 18:39:19 +0200569 err_code |= ERR_ALERT | ERR_ABORT;
570 goto out;
571 }
572
573 /* the peers are linked backwards first */
574 curpeers->count++;
575 newpeer->next = curpeers->remote;
576 curpeers->remote = newpeer;
Willy Tarreau8113a5d2012-10-04 08:01:43 +0200577 newpeer->conf.file = strdup(file);
Emeric Brun32da3c42010-09-23 18:39:19 +0200578 newpeer->conf.line = linenum;
579
580 newpeer->last_change = now.tv_sec;
581 newpeer->id = strdup(args[1]);
582
Willy Tarreau48ef4c92017-01-06 18:32:38 +0100583 sk = str2sa_range(args[2], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
Willy Tarreau2aa38802013-02-20 19:20:59 +0100584 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100585 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Willy Tarreau2aa38802013-02-20 19:20:59 +0100586 err_code |= ERR_ALERT | ERR_FATAL;
587 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200588 }
Willy Tarreaub36487e2013-03-10 18:37:42 +0100589
590 proto = protocol_by_family(sk->ss_family);
591 if (!proto || !proto->connect) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100592 ha_alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
593 file, linenum, args[0], args[1]);
Willy Tarreaub36487e2013-03-10 18:37:42 +0100594 err_code |= ERR_ALERT | ERR_FATAL;
595 goto out;
596 }
Willy Tarreau2aa38802013-02-20 19:20:59 +0100597
598 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100599 ha_alert("parsing [%s:%d] : '%s %s' : port ranges and offsets are not allowed in '%s'\n",
600 file, linenum, args[0], args[1], args[2]);
Emeric Brun32da3c42010-09-23 18:39:19 +0200601 err_code |= ERR_ALERT | ERR_FATAL;
602 goto out;
603 }
604
Willy Tarreau2aa38802013-02-20 19:20:59 +0100605 if (!port1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100606 ha_alert("parsing [%s:%d] : '%s %s' : missing or invalid port in '%s'\n",
607 file, linenum, args[0], args[1], args[2]);
Emeric Brun32da3c42010-09-23 18:39:19 +0200608 err_code |= ERR_ALERT | ERR_FATAL;
609 goto out;
610 }
Willy Tarreau2aa38802013-02-20 19:20:59 +0100611
Emeric Brun32da3c42010-09-23 18:39:19 +0200612 newpeer->addr = *sk;
Willy Tarreaub36487e2013-03-10 18:37:42 +0100613 newpeer->proto = proto;
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100614 newpeer->xprt = xprt_get(XPRT_RAW);
Willy Tarreaud02394b2012-05-11 18:32:18 +0200615 newpeer->sock_init_arg = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100616 HA_SPIN_INIT(&newpeer->lock);
Willy Tarreau26d8c592012-05-07 18:12:14 +0200617
Emeric Brun32da3c42010-09-23 18:39:19 +0200618 if (strcmp(newpeer->id, localpeer) == 0) {
619 /* Current is local peer, it define a frontend */
620 newpeer->local = 1;
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200621 cfg_peers->local = newpeer;
Emeric Brun32da3c42010-09-23 18:39:19 +0200622
623 if (!curpeers->peers_fe) {
624 if ((curpeers->peers_fe = calloc(1, sizeof(struct proxy))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100625 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Emeric Brun32da3c42010-09-23 18:39:19 +0200626 err_code |= ERR_ALERT | ERR_ABORT;
627 goto out;
628 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200629
Willy Tarreau237250c2011-07-29 01:49:03 +0200630 init_new_proxy(curpeers->peers_fe);
631 curpeers->peers_fe->parent = curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +0200632 curpeers->peers_fe->id = strdup(args[1]);
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200633 curpeers->peers_fe->conf.args.file = curpeers->peers_fe->conf.file = strdup(file);
634 curpeers->peers_fe->conf.args.line = curpeers->peers_fe->conf.line = linenum;
Willy Tarreau91d96282015-03-13 15:47:26 +0100635 peers_setup_frontend(curpeers->peers_fe);
Willy Tarreau4348fad2012-09-20 16:48:07 +0200636
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100637 bind_conf = bind_conf_alloc(curpeers->peers_fe, file, linenum, args[2], xprt_get(XPRT_RAW));
Willy Tarreau4348fad2012-09-20 16:48:07 +0200638
Willy Tarreau902636f2013-03-10 19:44:48 +0100639 if (!str2listener(args[2], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
640 if (errmsg && *errmsg) {
641 indent_msg(&errmsg, 2);
Christopher Faulet767a84b2017-11-24 16:50:31 +0100642 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200643 }
644 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100645 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
646 file, linenum, args[0], args[1], args[2]);
Emeric Brun32da3c42010-09-23 18:39:19 +0200647 err_code |= ERR_FATAL;
648 goto out;
649 }
Willy Tarreau4348fad2012-09-20 16:48:07 +0200650
651 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
Willy Tarreauacf3bf92013-01-18 10:51:07 +0100652 l->maxaccept = 1;
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200653 l->maxconn = curpeers->peers_fe->maxconn;
654 l->backlog = curpeers->peers_fe->backlog;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200655 l->accept = session_accept_fd;
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200656 l->analysers |= curpeers->peers_fe->fe_req_ana;
657 l->default_target = curpeers->peers_fe->default_target;
Willy Tarreau4348fad2012-09-20 16:48:07 +0200658 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
659 global.maxsock += l->maxconn;
660 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200661 }
Willy Tarreau8b8fd562013-01-18 11:12:27 +0100662 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100663 ha_alert("parsing [%s:%d] : '%s %s' : local peer name already referenced at %s:%d.\n",
664 file, linenum, args[0], args[1],
665 curpeers->peers_fe->conf.file, curpeers->peers_fe->conf.line);
Willy Tarreau8b8fd562013-01-18 11:12:27 +0100666 err_code |= ERR_FATAL;
667 goto out;
668 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200669 }
670 } /* neither "peer" nor "peers" */
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200671 else if (!strcmp(args[0], "disabled")) { /* disables this peers section */
672 curpeers->state = PR_STSTOPPED;
673 }
674 else if (!strcmp(args[0], "enabled")) { /* enables this peers section (used to revert a disabled default) */
675 curpeers->state = PR_STNEW;
676 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200677 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100678 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Emeric Brun32da3c42010-09-23 18:39:19 +0200679 err_code |= ERR_ALERT | ERR_FATAL;
680 goto out;
681 }
682
683out:
Willy Tarreau902636f2013-03-10 19:44:48 +0100684 free(errmsg);
Emeric Brun32da3c42010-09-23 18:39:19 +0200685 return err_code;
686}
687
Baptiste Assmann325137d2015-04-13 23:40:55 +0200688/*
689 * Parse a <resolvers> section.
690 * Returns the error code, 0 if OK, or any combination of :
691 * - ERR_ABORT: must abort ASAP
692 * - ERR_FATAL: we can continue parsing but not start the service
693 * - ERR_WARN: a warning has been emitted
694 * - ERR_ALERT: an alert has been emitted
695 * Only the two first ones can stop processing, the two others are just
696 * indicators.
697 */
698int cfg_parse_resolvers(const char *file, int linenum, char **args, int kwm)
699{
700 static struct dns_resolvers *curr_resolvers = NULL;
701 struct dns_nameserver *newnameserver = NULL;
702 const char *err;
703 int err_code = 0;
704 char *errmsg = NULL;
705
706 if (strcmp(args[0], "resolvers") == 0) { /* new resolvers section */
707 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100708 ha_alert("parsing [%s:%d] : missing name for resolvers section.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200709 err_code |= ERR_ALERT | ERR_ABORT;
710 goto out;
711 }
712
713 err = invalid_char(args[1]);
714 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100715 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
716 file, linenum, *err, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200717 err_code |= ERR_ALERT | ERR_ABORT;
718 goto out;
719 }
720
721 list_for_each_entry(curr_resolvers, &dns_resolvers, list) {
722 /* Error if two resolvers owns the same name */
723 if (strcmp(curr_resolvers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100724 ha_alert("Parsing [%s:%d]: resolvers '%s' has same name as another resolvers (declared at %s:%d).\n",
725 file, linenum, args[1], curr_resolvers->conf.file, curr_resolvers->conf.line);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200726 err_code |= ERR_ALERT | ERR_ABORT;
727 }
728 }
729
Vincent Bernat02779b62016-04-03 13:48:43 +0200730 if ((curr_resolvers = calloc(1, sizeof(*curr_resolvers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100731 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200732 err_code |= ERR_ALERT | ERR_ABORT;
733 goto out;
734 }
735
736 /* default values */
737 LIST_ADDQ(&dns_resolvers, &curr_resolvers->list);
738 curr_resolvers->conf.file = strdup(file);
739 curr_resolvers->conf.line = linenum;
740 curr_resolvers->id = strdup(args[1]);
741 curr_resolvers->query_ids = EB_ROOT;
Baptiste Assmann2af08fe2017-08-14 00:13:01 +0200742 /* default maximum response size */
743 curr_resolvers->accepted_payload_size = 512;
Baptiste Assmann987e16d2016-11-02 22:23:31 +0100744 /* default hold period for nx, other, refuse and timeout is 30s */
745 curr_resolvers->hold.nx = 30000;
746 curr_resolvers->hold.other = 30000;
747 curr_resolvers->hold.refused = 30000;
748 curr_resolvers->hold.timeout = 30000;
Baptiste Assmann686408b2017-08-18 10:15:42 +0200749 curr_resolvers->hold.obsolete = 0;
Baptiste Assmann325137d2015-04-13 23:40:55 +0200750 /* default hold period for valid is 10s */
Baptiste Assmann4c5490a2015-07-14 21:42:49 +0200751 curr_resolvers->hold.valid = 10000;
Christopher Faulet67957bd2017-09-27 11:00:59 +0200752 curr_resolvers->timeout.resolve = 1000;
753 curr_resolvers->timeout.retry = 1000;
Baptiste Assmann325137d2015-04-13 23:40:55 +0200754 curr_resolvers->resolve_retries = 3;
Christopher Faulet67957bd2017-09-27 11:00:59 +0200755 curr_resolvers->nb_nameservers = 0;
756 LIST_INIT(&curr_resolvers->nameservers);
757 LIST_INIT(&curr_resolvers->resolutions.curr);
758 LIST_INIT(&curr_resolvers->resolutions.wait);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100759 HA_SPIN_INIT(&curr_resolvers->lock);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200760 }
761 else if (strcmp(args[0], "nameserver") == 0) { /* nameserver definition */
762 struct sockaddr_storage *sk;
763 int port1, port2;
764 struct protocol *proto;
765
766 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100767 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
768 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200769 err_code |= ERR_ALERT | ERR_FATAL;
770 goto out;
771 }
772
773 err = invalid_char(args[1]);
774 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100775 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
776 file, linenum, *err, args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200777 err_code |= ERR_ALERT | ERR_FATAL;
778 goto out;
779 }
780
Christopher Faulet67957bd2017-09-27 11:00:59 +0200781 list_for_each_entry(newnameserver, &curr_resolvers->nameservers, list) {
Baptiste Assmanna315c552015-11-02 22:55:49 +0100782 /* Error if two resolvers owns the same name */
783 if (strcmp(newnameserver->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100784 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 -0600785 file, linenum, args[1], newnameserver->conf.file, newnameserver->conf.line);
Baptiste Assmanna315c552015-11-02 22:55:49 +0100786 err_code |= ERR_ALERT | ERR_FATAL;
787 }
788 }
789
Vincent Bernat02779b62016-04-03 13:48:43 +0200790 if ((newnameserver = calloc(1, sizeof(*newnameserver))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100791 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200792 err_code |= ERR_ALERT | ERR_ABORT;
793 goto out;
794 }
795
796 /* the nameservers are linked backward first */
Christopher Faulet67957bd2017-09-27 11:00:59 +0200797 LIST_ADDQ(&curr_resolvers->nameservers, &newnameserver->list);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200798 newnameserver->resolvers = curr_resolvers;
799 newnameserver->conf.file = strdup(file);
800 newnameserver->conf.line = linenum;
801 newnameserver->id = strdup(args[1]);
802
Willy Tarreau48ef4c92017-01-06 18:32:38 +0100803 sk = str2sa_range(args[2], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200804 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100805 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200806 err_code |= ERR_ALERT | ERR_FATAL;
807 goto out;
808 }
809
810 proto = protocol_by_family(sk->ss_family);
811 if (!proto || !proto->connect) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100812 ha_alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
Baptiste Assmann325137d2015-04-13 23:40:55 +0200813 file, linenum, args[0], args[1]);
814 err_code |= ERR_ALERT | ERR_FATAL;
815 goto out;
816 }
817
818 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100819 ha_alert("parsing [%s:%d] : '%s %s' : port ranges and offsets are not allowed in '%s'\n",
820 file, linenum, args[0], args[1], args[2]);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200821 err_code |= ERR_ALERT | ERR_FATAL;
822 goto out;
823 }
824
Baptiste Assmann7f43fa92016-01-21 00:59:46 +0100825 if (!port1 && !port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100826 ha_alert("parsing [%s:%d] : '%s %s' : no UDP port specified\n",
827 file, linenum, args[0], args[1]);
Baptiste Assmann7f43fa92016-01-21 00:59:46 +0100828 err_code |= ERR_ALERT | ERR_FATAL;
829 goto out;
830 }
831
Baptiste Assmann325137d2015-04-13 23:40:55 +0200832 newnameserver->addr = *sk;
833 }
Ben Draut44e609b2018-05-29 15:40:08 -0600834 else if (strcmp(args[0], "parse-resolv-conf") == 0) {
835 const char *whitespace = "\r\n\t ";
836 char *resolv_line = NULL;
837 int resolv_linenum = 0;
838 FILE *f = NULL;
839 char *address = NULL;
840 struct sockaddr_storage *sk = NULL;
841 struct protocol *proto;
842 int duplicate_name = 0;
843
844 if ((resolv_line = malloc(sizeof(*resolv_line) * LINESIZE)) == NULL) {
845 ha_alert("parsing [%s:%d] : out of memory.\n",
846 file, linenum);
847 err_code |= ERR_ALERT | ERR_FATAL;
848 goto resolv_out;
849 }
850
851 if ((f = fopen("/etc/resolv.conf", "r")) == NULL) {
852 ha_alert("parsing [%s:%d] : failed to open /etc/resolv.conf.\n",
853 file, linenum);
854 err_code |= ERR_ALERT | ERR_FATAL;
855 goto resolv_out;
856 }
857
858 sk = calloc(1, sizeof(*sk));
859 if (sk == NULL) {
860 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n",
861 resolv_linenum);
862 err_code |= ERR_ALERT | ERR_FATAL;
863 goto resolv_out;
864 }
865
866 while (fgets(resolv_line, LINESIZE, f) != NULL) {
867 resolv_linenum++;
868 if (strncmp(resolv_line, "nameserver", 10) != 0)
869 continue;
870
871 address = strtok(resolv_line + 10, whitespace);
872 if (address == resolv_line + 10)
873 continue;
874
875 if (address == NULL) {
876 ha_warning("parsing [/etc/resolv.conf:%d] : nameserver line is missing address.\n",
877 resolv_linenum);
878 err_code |= ERR_WARN;
879 continue;
880 }
881
882 duplicate_name = 0;
883 list_for_each_entry(newnameserver, &curr_resolvers->nameservers, list) {
884 if (strcmp(newnameserver->id, address) == 0) {
885 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",
886 resolv_linenum, address, newnameserver->conf.file, newnameserver->conf.line);
887 err_code |= ERR_WARN;
888 duplicate_name = 1;
889 }
890 }
891
892 if (duplicate_name)
893 continue;
894
895 memset(sk, 0, sizeof(*sk));
896 sk = str2ip2(address, sk, 1);
897 if (!sk) {
898 ha_warning("parsing [/etc/resolv.conf:%d] : address '%s' could not be recognized, namerserver will be excluded.\n",
899 resolv_linenum, address);
900 err_code |= ERR_WARN;
901 continue;
902 }
903
904 set_host_port(sk, 53);
905
906 proto = protocol_by_family(sk->ss_family);
907 if (!proto || !proto->connect) {
908 ha_warning("parsing [/etc/resolv.conf:%d] : '%s' : connect() not supported for this address family.\n",
909 resolv_linenum, address);
910 err_code |= ERR_WARN;
911 continue;
912 }
913
914 if ((newnameserver = calloc(1, sizeof(*newnameserver))) == NULL) {
915 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
916 err_code |= ERR_ALERT | ERR_FATAL;
917 goto resolv_out;
918 }
919
920 newnameserver->conf.file = strdup("/etc/resolv.conf");
921 if (newnameserver->conf.file == NULL) {
922 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
923 err_code |= ERR_ALERT | ERR_FATAL;
924 goto resolv_out;
925 }
926
927 newnameserver->id = strdup(address);
928 if (newnameserver->id == NULL) {
929 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
930 err_code |= ERR_ALERT | ERR_FATAL;
931 goto resolv_out;
932 }
933
934 newnameserver->resolvers = curr_resolvers;
935 newnameserver->conf.line = resolv_linenum;
936 newnameserver->addr = *sk;
937
938 LIST_ADDQ(&curr_resolvers->nameservers, &newnameserver->list);
939 }
940
941resolv_out:
942 free(sk);
943 free(resolv_line);
944 if (f != NULL)
945 fclose(f);
946 }
Baptiste Assmann325137d2015-04-13 23:40:55 +0200947 else if (strcmp(args[0], "hold") == 0) { /* hold periods */
948 const char *res;
949 unsigned int time;
950
951 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100952 ha_alert("parsing [%s:%d] : '%s' expects an <event> and a <time> as arguments.\n",
953 file, linenum, args[0]);
954 ha_alert("<event> can be either 'valid', 'nx', 'refused', 'timeout', or 'other'\n");
Baptiste Assmann325137d2015-04-13 23:40:55 +0200955 err_code |= ERR_ALERT | ERR_FATAL;
956 goto out;
957 }
958 res = parse_time_err(args[2], &time, TIME_UNIT_MS);
959 if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100960 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s>.\n",
961 file, linenum, *res, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200962 err_code |= ERR_ALERT | ERR_FATAL;
963 goto out;
964 }
Baptiste Assmann987e16d2016-11-02 22:23:31 +0100965 if (strcmp(args[1], "nx") == 0)
966 curr_resolvers->hold.nx = time;
967 else if (strcmp(args[1], "other") == 0)
968 curr_resolvers->hold.other = time;
969 else if (strcmp(args[1], "refused") == 0)
970 curr_resolvers->hold.refused = time;
971 else if (strcmp(args[1], "timeout") == 0)
972 curr_resolvers->hold.timeout = time;
973 else if (strcmp(args[1], "valid") == 0)
Baptiste Assmann325137d2015-04-13 23:40:55 +0200974 curr_resolvers->hold.valid = time;
Olivier Houcharda8c6db82017-07-06 18:46:47 +0200975 else if (strcmp(args[1], "obsolete") == 0)
976 curr_resolvers->hold.obsolete = time;
Baptiste Assmann325137d2015-04-13 23:40:55 +0200977 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100978 ha_alert("parsing [%s:%d] : '%s' unknown <event>: '%s', expects either 'nx', 'timeout', 'valid', 'obsolete' or 'other'.\n",
979 file, linenum, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200980 err_code |= ERR_ALERT | ERR_FATAL;
981 goto out;
982 }
983
984 }
Baptiste Assmann2af08fe2017-08-14 00:13:01 +0200985 else if (strcmp(args[0], "accepted_payload_size") == 0) {
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +0200986 int i = 0;
987
Baptiste Assmann2af08fe2017-08-14 00:13:01 +0200988 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100989 ha_alert("parsing [%s:%d] : '%s' expects <nb> as argument.\n",
990 file, linenum, args[0]);
Baptiste Assmann2af08fe2017-08-14 00:13:01 +0200991 err_code |= ERR_ALERT | ERR_FATAL;
992 goto out;
993 }
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +0200994
995 i = atoi(args[1]);
Willy Tarreau0c219be2017-08-22 12:01:26 +0200996 if (i < DNS_HEADER_SIZE || i > DNS_MAX_UDP_MESSAGE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100997 ha_alert("parsing [%s:%d] : '%s' must be between %d and %d inclusive (was %s).\n",
998 file, linenum, args[0], DNS_HEADER_SIZE, DNS_MAX_UDP_MESSAGE, args[1]);
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +0200999 err_code |= ERR_ALERT | ERR_FATAL;
1000 goto out;
1001 }
1002
1003 curr_resolvers->accepted_payload_size = i;
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001004 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001005 else if (strcmp(args[0], "resolution_pool_size") == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001006 ha_warning("parsing [%s:%d] : '%s' directive is now deprecated and ignored.\n",
1007 file, linenum, args[0]);
Christopher Faulet67957bd2017-09-27 11:00:59 +02001008 err_code |= ERR_WARN;
1009 goto out;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001010 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001011 else if (strcmp(args[0], "resolve_retries") == 0) {
1012 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001013 ha_alert("parsing [%s:%d] : '%s' expects <nb> as argument.\n",
1014 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001015 err_code |= ERR_ALERT | ERR_FATAL;
1016 goto out;
1017 }
1018 curr_resolvers->resolve_retries = atoi(args[1]);
1019 }
1020 else if (strcmp(args[0], "timeout") == 0) {
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001021 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001022 ha_alert("parsing [%s:%d] : '%s' expects 'retry' or 'resolve' and <time> as arguments.\n",
1023 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001024 err_code |= ERR_ALERT | ERR_FATAL;
1025 goto out;
1026 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001027 else if (strcmp(args[1], "retry") == 0 ||
1028 strcmp(args[1], "resolve") == 0) {
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001029 const char *res;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001030 unsigned int tout;
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001031
1032 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001033 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1034 file, linenum, args[0], args[1]);
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001035 err_code |= ERR_ALERT | ERR_FATAL;
1036 goto out;
1037 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001038 res = parse_time_err(args[2], &tout, TIME_UNIT_MS);
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001039 if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001040 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1041 file, linenum, *res, args[0], args[1]);
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001042 err_code |= ERR_ALERT | ERR_FATAL;
1043 goto out;
1044 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001045 if (args[1][2] == 't')
1046 curr_resolvers->timeout.retry = tout;
1047 else
1048 curr_resolvers->timeout.resolve = tout;
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001049 }
1050 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001051 ha_alert("parsing [%s:%d] : '%s' expects 'retry' or 'resolve' and <time> as arguments got '%s'.\n",
1052 file, linenum, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001053 err_code |= ERR_ALERT | ERR_FATAL;
1054 goto out;
1055 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001056 } /* neither "nameserver" nor "resolvers" */
1057 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001058 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001059 err_code |= ERR_ALERT | ERR_FATAL;
1060 goto out;
1061 }
1062
1063 out:
1064 free(errmsg);
1065 return err_code;
1066}
Simon Horman0d16a402015-01-30 11:22:58 +09001067
1068/*
William Lallemand51097192015-04-14 16:35:22 +02001069 * Parse a line in a <listen>, <frontend> or <backend> section.
Simon Horman0d16a402015-01-30 11:22:58 +09001070 * Returns the error code, 0 if OK, or any combination of :
1071 * - ERR_ABORT: must abort ASAP
1072 * - ERR_FATAL: we can continue parsing but not start the service
1073 * - ERR_WARN: a warning has been emitted
1074 * - ERR_ALERT: an alert has been emitted
1075 * Only the two first ones can stop processing, the two others are just
1076 * indicators.
1077 */
1078int cfg_parse_mailers(const char *file, int linenum, char **args, int kwm)
1079{
1080 static struct mailers *curmailers = NULL;
1081 struct mailer *newmailer = NULL;
1082 const char *err;
1083 int err_code = 0;
1084 char *errmsg = NULL;
1085
1086 if (strcmp(args[0], "mailers") == 0) { /* new mailers section */
1087 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001088 ha_alert("parsing [%s:%d] : missing name for mailers section.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001089 err_code |= ERR_ALERT | ERR_ABORT;
1090 goto out;
1091 }
1092
1093 err = invalid_char(args[1]);
1094 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001095 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
1096 file, linenum, *err, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001097 err_code |= ERR_ALERT | ERR_ABORT;
1098 goto out;
1099 }
1100
1101 for (curmailers = mailers; curmailers != NULL; curmailers = curmailers->next) {
1102 /*
1103 * If there are two proxies with the same name only following
1104 * combinations are allowed:
1105 */
1106 if (strcmp(curmailers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001107 ha_alert("Parsing [%s:%d]: mailers section '%s' has the same name as another mailers section declared at %s:%d.\n",
1108 file, linenum, args[1], curmailers->conf.file, curmailers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +02001109 err_code |= ERR_ALERT | ERR_FATAL;
Simon Horman0d16a402015-01-30 11:22:58 +09001110 }
1111 }
1112
Vincent Bernat02779b62016-04-03 13:48:43 +02001113 if ((curmailers = calloc(1, sizeof(*curmailers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001114 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001115 err_code |= ERR_ALERT | ERR_ABORT;
1116 goto out;
1117 }
1118
1119 curmailers->next = mailers;
1120 mailers = curmailers;
1121 curmailers->conf.file = strdup(file);
1122 curmailers->conf.line = linenum;
1123 curmailers->id = strdup(args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001124 curmailers->timeout.mail = DEF_MAILALERTTIME;/* XXX: Would like to Skip to the next alert, if any, ASAP.
1125 * But need enough time so that timeouts don't occur
1126 * during tcp procssing. For now just us an arbitrary default. */
Simon Horman0d16a402015-01-30 11:22:58 +09001127 }
1128 else if (strcmp(args[0], "mailer") == 0) { /* mailer definition */
1129 struct sockaddr_storage *sk;
1130 int port1, port2;
1131 struct protocol *proto;
1132
1133 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001134 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1135 file, linenum, args[0]);
Simon Horman0d16a402015-01-30 11:22:58 +09001136 err_code |= ERR_ALERT | ERR_FATAL;
1137 goto out;
1138 }
1139
1140 err = invalid_char(args[1]);
1141 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001142 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1143 file, linenum, *err, args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001144 err_code |= ERR_ALERT | ERR_FATAL;
1145 goto out;
1146 }
1147
Vincent Bernat02779b62016-04-03 13:48:43 +02001148 if ((newmailer = calloc(1, sizeof(*newmailer))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001149 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001150 err_code |= ERR_ALERT | ERR_ABORT;
1151 goto out;
1152 }
1153
1154 /* the mailers are linked backwards first */
1155 curmailers->count++;
1156 newmailer->next = curmailers->mailer_list;
1157 curmailers->mailer_list = newmailer;
1158 newmailer->mailers = curmailers;
1159 newmailer->conf.file = strdup(file);
1160 newmailer->conf.line = linenum;
1161
1162 newmailer->id = strdup(args[1]);
1163
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001164 sk = str2sa_range(args[2], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
Simon Horman0d16a402015-01-30 11:22:58 +09001165 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001166 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Simon Horman0d16a402015-01-30 11:22:58 +09001167 err_code |= ERR_ALERT | ERR_FATAL;
1168 goto out;
1169 }
1170
1171 proto = protocol_by_family(sk->ss_family);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09001172 if (!proto || !proto->connect || proto->sock_prot != IPPROTO_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001173 ha_alert("parsing [%s:%d] : '%s %s' : TCP not supported for this address family.\n",
1174 file, linenum, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001175 err_code |= ERR_ALERT | ERR_FATAL;
1176 goto out;
1177 }
1178
1179 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001180 ha_alert("parsing [%s:%d] : '%s %s' : port ranges and offsets are not allowed in '%s'\n",
1181 file, linenum, args[0], args[1], args[2]);
Simon Horman0d16a402015-01-30 11:22:58 +09001182 err_code |= ERR_ALERT | ERR_FATAL;
1183 goto out;
1184 }
1185
1186 if (!port1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001187 ha_alert("parsing [%s:%d] : '%s %s' : missing or invalid port in '%s'\n",
1188 file, linenum, args[0], args[1], args[2]);
Simon Horman0d16a402015-01-30 11:22:58 +09001189 err_code |= ERR_ALERT | ERR_FATAL;
1190 goto out;
1191 }
1192
1193 newmailer->addr = *sk;
1194 newmailer->proto = proto;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01001195 newmailer->xprt = xprt_get(XPRT_RAW);
Simon Horman0d16a402015-01-30 11:22:58 +09001196 newmailer->sock_init_arg = NULL;
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001197 }
1198 else if (strcmp(args[0], "timeout") == 0) {
1199 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001200 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments.\n",
1201 file, linenum, args[0]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001202 err_code |= ERR_ALERT | ERR_FATAL;
1203 goto out;
1204 }
1205 else if (strcmp(args[1], "mail") == 0) {
1206 const char *res;
1207 unsigned int timeout_mail;
1208 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001209 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1210 file, linenum, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001211 err_code |= ERR_ALERT | ERR_FATAL;
1212 goto out;
1213 }
1214 res = parse_time_err(args[2], &timeout_mail, TIME_UNIT_MS);
1215 if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001216 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s>.\n",
1217 file, linenum, *res, args[0]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001218 err_code |= ERR_ALERT | ERR_FATAL;
1219 goto out;
1220 }
1221 if (timeout_mail <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001222 ha_alert("parsing [%s:%d] : '%s %s' expects a positive <time> argument.\n", file, linenum, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001223 err_code |= ERR_ALERT | ERR_FATAL;
1224 goto out;
1225 }
1226 curmailers->timeout.mail = timeout_mail;
1227 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001228 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments got '%s'.\n",
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001229 file, linenum, args[0], args[1]);
1230 err_code |= ERR_ALERT | ERR_FATAL;
1231 goto out;
1232 }
1233 }
Simon Horman0d16a402015-01-30 11:22:58 +09001234 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001235 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Simon Horman0d16a402015-01-30 11:22:58 +09001236 err_code |= ERR_ALERT | ERR_FATAL;
1237 goto out;
1238 }
1239
1240out:
1241 free(errmsg);
1242 return err_code;
1243}
1244
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +01001245void free_email_alert(struct proxy *p)
Simon Horman9dc49962015-01-30 11:22:59 +09001246{
1247 free(p->email_alert.mailers.name);
1248 p->email_alert.mailers.name = NULL;
1249 free(p->email_alert.from);
1250 p->email_alert.from = NULL;
1251 free(p->email_alert.to);
1252 p->email_alert.to = NULL;
1253 free(p->email_alert.myhostname);
1254 p->email_alert.myhostname = NULL;
1255}
1256
Willy Tarreaubaaee002006-06-26 02:48:02 +02001257
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001258int
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001259cfg_parse_netns(const char *file, int linenum, char **args, int kwm)
1260{
1261#ifdef CONFIG_HAP_NS
1262 const char *err;
1263 const char *item = args[0];
1264
1265 if (!strcmp(item, "namespace_list")) {
1266 return 0;
1267 }
1268 else if (!strcmp(item, "namespace")) {
1269 size_t idx = 1;
1270 const char *current;
1271 while (*(current = args[idx++])) {
1272 err = invalid_char(current);
1273 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001274 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1275 file, linenum, *err, item, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001276 return ERR_ALERT | ERR_FATAL;
1277 }
1278
1279 if (netns_store_lookup(current, strlen(current))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001280 ha_alert("parsing [%s:%d]: Namespace '%s' is already added.\n",
1281 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001282 return ERR_ALERT | ERR_FATAL;
1283 }
1284 if (!netns_store_insert(current)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001285 ha_alert("parsing [%s:%d]: Cannot open namespace '%s'.\n",
1286 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001287 return ERR_ALERT | ERR_FATAL;
1288 }
1289 }
1290 }
1291
1292 return 0;
1293#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001294 ha_alert("parsing [%s:%d]: namespace support is not compiled in.",
1295 file, linenum);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001296 return ERR_ALERT | ERR_FATAL;
1297#endif
1298}
1299
1300int
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001301cfg_parse_users(const char *file, int linenum, char **args, int kwm)
1302{
1303
1304 int err_code = 0;
1305 const char *err;
1306
1307 if (!strcmp(args[0], "userlist")) { /* new userlist */
1308 struct userlist *newul;
1309
1310 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001311 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1312 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001313 err_code |= ERR_ALERT | ERR_FATAL;
1314 goto out;
1315 }
William Lallemand6e62fb62015-04-28 16:55:23 +02001316 if (alertif_too_many_args(1, file, linenum, args, &err_code))
1317 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001318
1319 err = invalid_char(args[1]);
1320 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001321 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1322 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001323 err_code |= ERR_ALERT | ERR_FATAL;
1324 goto out;
1325 }
1326
1327 for (newul = userlist; newul; newul = newul->next)
1328 if (!strcmp(newul->name, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001329 ha_warning("parsing [%s:%d]: ignoring duplicated userlist '%s'.\n",
1330 file, linenum, args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001331 err_code |= ERR_WARN;
1332 goto out;
1333 }
1334
Vincent Bernat02779b62016-04-03 13:48:43 +02001335 newul = calloc(1, sizeof(*newul));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001336 if (!newul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001337 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001338 err_code |= ERR_ALERT | ERR_ABORT;
1339 goto out;
1340 }
1341
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001342 newul->name = strdup(args[1]);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001343 if (!newul->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001344 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001345 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier97880bb2016-04-08 10:35:26 +01001346 free(newul);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001347 goto out;
1348 }
1349
1350 newul->next = userlist;
1351 userlist = newul;
1352
1353 } else if (!strcmp(args[0], "group")) { /* new group */
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001354 int cur_arg;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001355 const char *err;
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001356 struct auth_groups *ag;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001357
1358 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001359 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1360 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001361 err_code |= ERR_ALERT | ERR_FATAL;
1362 goto out;
1363 }
1364
1365 err = invalid_char(args[1]);
1366 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001367 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1368 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001369 err_code |= ERR_ALERT | ERR_FATAL;
1370 goto out;
1371 }
1372
William Lallemand4ac9f542015-05-28 18:03:51 +02001373 if (!userlist)
1374 goto out;
1375
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001376 for (ag = userlist->groups; ag; ag = ag->next)
1377 if (!strcmp(ag->name, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001378 ha_warning("parsing [%s:%d]: ignoring duplicated group '%s' in userlist '%s'.\n",
1379 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001380 err_code |= ERR_ALERT;
1381 goto out;
1382 }
1383
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001384 ag = calloc(1, sizeof(*ag));
1385 if (!ag) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001386 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001387 err_code |= ERR_ALERT | ERR_ABORT;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001388 goto out;
1389 }
1390
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001391 ag->name = strdup(args[1]);
David Carlier70d60452016-08-22 23:27:42 +01001392 if (!ag->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001393 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001394 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier70d60452016-08-22 23:27:42 +01001395 free(ag);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001396 goto out;
1397 }
1398
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001399 cur_arg = 2;
1400
1401 while (*args[cur_arg]) {
1402 if (!strcmp(args[cur_arg], "users")) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001403 ag->groupusers = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001404 cur_arg += 2;
1405 continue;
1406 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001407 ha_alert("parsing [%s:%d]: '%s' only supports 'users' option.\n",
1408 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001409 err_code |= ERR_ALERT | ERR_FATAL;
David Carlier70d60452016-08-22 23:27:42 +01001410 free(ag->groupusers);
1411 free(ag->name);
1412 free(ag);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001413 goto out;
1414 }
1415 }
1416
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001417 ag->next = userlist->groups;
1418 userlist->groups = ag;
1419
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001420 } else if (!strcmp(args[0], "user")) { /* new user */
1421 struct auth_users *newuser;
1422 int cur_arg;
1423
1424 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001425 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1426 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001427 err_code |= ERR_ALERT | ERR_FATAL;
1428 goto out;
1429 }
William Lallemand4ac9f542015-05-28 18:03:51 +02001430 if (!userlist)
1431 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001432
1433 for (newuser = userlist->users; newuser; newuser = newuser->next)
1434 if (!strcmp(newuser->user, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001435 ha_warning("parsing [%s:%d]: ignoring duplicated user '%s' in userlist '%s'.\n",
1436 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001437 err_code |= ERR_ALERT;
1438 goto out;
1439 }
1440
Vincent Bernat02779b62016-04-03 13:48:43 +02001441 newuser = calloc(1, sizeof(*newuser));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001442 if (!newuser) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001443 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001444 err_code |= ERR_ALERT | ERR_ABORT;
1445 goto out;
1446 }
1447
1448 newuser->user = strdup(args[1]);
1449
1450 newuser->next = userlist->users;
1451 userlist->users = newuser;
1452
1453 cur_arg = 2;
1454
1455 while (*args[cur_arg]) {
1456 if (!strcmp(args[cur_arg], "password")) {
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001457#ifdef CONFIG_HAP_CRYPT
1458 if (!crypt("", args[cur_arg + 1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001459 ha_alert("parsing [%s:%d]: the encrypted password used for user '%s' is not supported by crypt(3).\n",
1460 file, linenum, newuser->user);
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001461 err_code |= ERR_ALERT | ERR_FATAL;
1462 goto out;
1463 }
1464#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001465 ha_warning("parsing [%s:%d]: no crypt(3) support compiled, encrypted passwords will not work.\n",
1466 file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001467 err_code |= ERR_ALERT;
1468#endif
1469 newuser->pass = strdup(args[cur_arg + 1]);
1470 cur_arg += 2;
1471 continue;
1472 } else if (!strcmp(args[cur_arg], "insecure-password")) {
1473 newuser->pass = strdup(args[cur_arg + 1]);
1474 newuser->flags |= AU_O_INSECURE;
1475 cur_arg += 2;
1476 continue;
1477 } else if (!strcmp(args[cur_arg], "groups")) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001478 newuser->u.groups_names = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001479 cur_arg += 2;
1480 continue;
1481 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001482 ha_alert("parsing [%s:%d]: '%s' only supports 'password', 'insecure-password' and 'groups' options.\n",
1483 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001484 err_code |= ERR_ALERT | ERR_FATAL;
1485 goto out;
1486 }
1487 }
1488 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001489 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 +01001490 err_code |= ERR_ALERT | ERR_FATAL;
1491 }
1492
1493out:
1494 return err_code;
1495}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001496
Christopher Faulet79bdef32016-11-04 22:36:15 +01001497int
1498cfg_parse_scope(const char *file, int linenum, char *line)
1499{
1500 char *beg, *end, *scope = NULL;
1501 int err_code = 0;
1502 const char *err;
1503
1504 beg = line + 1;
1505 end = strchr(beg, ']');
1506
1507 /* Detect end of scope declaration */
1508 if (!end || end == beg) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001509 ha_alert("parsing [%s:%d] : empty scope name is forbidden.\n",
1510 file, linenum);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001511 err_code |= ERR_ALERT | ERR_FATAL;
1512 goto out;
1513 }
1514
1515 /* Get scope name and check its validity */
1516 scope = my_strndup(beg, end-beg);
1517 err = invalid_char(scope);
1518 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001519 ha_alert("parsing [%s:%d] : character '%c' is not permitted in a scope name.\n",
1520 file, linenum, *err);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001521 err_code |= ERR_ALERT | ERR_ABORT;
1522 goto out;
1523 }
1524
1525 /* Be sure to have a scope declaration alone on its line */
1526 line = end+1;
1527 while (isspace((unsigned char)*line))
1528 line++;
1529 if (*line && *line != '#' && *line != '\n' && *line != '\r') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001530 ha_alert("parsing [%s:%d] : character '%c' is not permitted after scope declaration.\n",
1531 file, linenum, *line);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001532 err_code |= ERR_ALERT | ERR_ABORT;
1533 goto out;
1534 }
1535
1536 /* We have a valid scope declaration, save it */
1537 free(cfg_scope);
1538 cfg_scope = scope;
1539 scope = NULL;
1540
1541 out:
1542 free(scope);
1543 return err_code;
1544}
1545
Frédéric Lécaillea41d5312018-01-29 12:05:07 +01001546int
1547cfg_parse_track_sc_num(unsigned int *track_sc_num,
1548 const char *arg, const char *end, char **errmsg)
1549{
1550 const char *p;
1551 unsigned int num;
1552
1553 p = arg;
1554 num = read_uint64(&arg, end);
1555
1556 if (arg != end) {
1557 memprintf(errmsg, "Wrong track-sc number '%s'", p);
1558 return -1;
1559 }
1560
1561 if (num >= MAX_SESS_STKCTR) {
1562 memprintf(errmsg, "%u track-sc number exceeding "
1563 "%d (MAX_SESS_STKCTR-1) value", num, MAX_SESS_STKCTR - 1);
1564 return -1;
1565 }
1566
1567 *track_sc_num = num;
1568 return 0;
1569}
1570
Willy Tarreaubaaee002006-06-26 02:48:02 +02001571/*
1572 * This function reads and parses the configuration file given in the argument.
Willy Tarreau058e9072009-07-20 09:30:05 +02001573 * Returns the error code, 0 if OK, or any combination of :
1574 * - ERR_ABORT: must abort ASAP
1575 * - ERR_FATAL: we can continue parsing but not start the service
1576 * - ERR_WARN: a warning has been emitted
1577 * - ERR_ALERT: an alert has been emitted
1578 * Only the two first ones can stop processing, the two others are just
1579 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001580 */
Willy Tarreaub17916e2006-10-15 15:17:57 +02001581int readcfgfile(const char *file)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001582{
William Lallemand64e84512015-05-12 14:25:37 +02001583 char *thisline;
1584 int linesize = LINESIZE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001585 FILE *f;
1586 int linenum = 0;
Willy Tarreau058e9072009-07-20 09:30:05 +02001587 int err_code = 0;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001588 struct cfg_section *cs = NULL, *pcs = NULL;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001589 struct cfg_section *ics;
William Lallemand64e84512015-05-12 14:25:37 +02001590 int readbytes = 0;
1591
1592 if ((thisline = malloc(sizeof(*thisline) * linesize)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001593 ha_alert("parsing [%s] : out of memory.\n", file);
William Lallemand64e84512015-05-12 14:25:37 +02001594 return -1;
1595 }
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001596
David Carlier97880bb2016-04-08 10:35:26 +01001597 if ((f=fopen(file,"r")) == NULL) {
1598 free(thisline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001599 return -1;
David Carlier97880bb2016-04-08 10:35:26 +01001600 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001601
William Lallemandb2f07452015-05-12 14:27:13 +02001602next_line:
William Lallemand64e84512015-05-12 14:25:37 +02001603 while (fgets(thisline + readbytes, linesize - readbytes, f) != NULL) {
Willy Tarreau3842f002009-06-14 11:39:52 +02001604 int arg, kwm = KWM_STD;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001605 char *end;
1606 char *args[MAX_LINE_ARGS + 1];
1607 char *line = thisline;
William Lallemandf9873ba2015-05-05 17:37:14 +02001608 int dquote = 0; /* double quote */
1609 int squote = 0; /* simple quote */
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001610
Willy Tarreaubaaee002006-06-26 02:48:02 +02001611 linenum++;
1612
1613 end = line + strlen(line);
1614
William Lallemand64e84512015-05-12 14:25:37 +02001615 if (end-line == linesize-1 && *(end-1) != '\n') {
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001616 /* Check if we reached the limit and the last char is not \n.
1617 * Watch out for the last line without the terminating '\n'!
1618 */
William Lallemand64e84512015-05-12 14:25:37 +02001619 char *newline;
1620 int newlinesize = linesize * 2;
1621
1622 newline = realloc(thisline, sizeof(*thisline) * newlinesize);
1623 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001624 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1625 file, linenum);
William Lallemand64e84512015-05-12 14:25:37 +02001626 err_code |= ERR_ALERT | ERR_FATAL;
1627 continue;
1628 }
1629
1630 readbytes = linesize - 1;
1631 linesize = newlinesize;
1632 thisline = newline;
1633 continue;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001634 }
1635
William Lallemand64e84512015-05-12 14:25:37 +02001636 readbytes = 0;
1637
Willy Tarreaubaaee002006-06-26 02:48:02 +02001638 /* skip leading spaces */
Willy Tarreau8f8e6452007-06-17 21:51:38 +02001639 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001640 line++;
William Lallemandf9873ba2015-05-05 17:37:14 +02001641
Christopher Faulet79bdef32016-11-04 22:36:15 +01001642
Joseph Herlanta14c03e2018-11-15 14:04:19 -08001643 if (*line == '[') {/* This is the beginning if a scope */
Christopher Faulet79bdef32016-11-04 22:36:15 +01001644 err_code |= cfg_parse_scope(file, linenum, line);
1645 goto next_line;
1646 }
1647
Willy Tarreaubaaee002006-06-26 02:48:02 +02001648 arg = 0;
1649 args[arg] = line;
1650
1651 while (*line && arg < MAX_LINE_ARGS) {
William Lallemandf9873ba2015-05-05 17:37:14 +02001652 if (*line == '"' && !squote) { /* double quote outside single quotes */
1653 if (dquote)
1654 dquote = 0;
1655 else
1656 dquote = 1;
William Lallemand3f415602015-05-12 14:01:09 +02001657 memmove(line, line + 1, end - line);
William Lallemandf9873ba2015-05-05 17:37:14 +02001658 end--;
1659 }
1660 else if (*line == '\'' && !dquote) { /* single quote outside double quotes */
1661 if (squote)
1662 squote = 0;
1663 else
1664 squote = 1;
William Lallemand3f415602015-05-12 14:01:09 +02001665 memmove(line, line + 1, end - line);
William Lallemandf9873ba2015-05-05 17:37:14 +02001666 end--;
1667 }
1668 else if (*line == '\\' && !squote) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001669 /* first, we'll replace \\, \<space>, \#, \r, \n, \t, \xXX with their
1670 * C equivalent value. Other combinations left unchanged (eg: \1).
1671 */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001672 int skip = 0;
1673 if (line[1] == ' ' || line[1] == '\\' || line[1] == '#') {
1674 *line = line[1];
1675 skip = 1;
1676 }
1677 else if (line[1] == 'r') {
1678 *line = '\r';
1679 skip = 1;
William Lallemandf9873ba2015-05-05 17:37:14 +02001680 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001681 else if (line[1] == 'n') {
1682 *line = '\n';
1683 skip = 1;
1684 }
1685 else if (line[1] == 't') {
1686 *line = '\t';
1687 skip = 1;
1688 }
1689 else if (line[1] == 'x') {
Emeric Brunb982a3d2010-01-04 15:45:53 +01001690 if ((line + 3 < end) && ishex(line[2]) && ishex(line[3])) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001691 unsigned char hex1, hex2;
1692 hex1 = toupper(line[2]) - '0';
1693 hex2 = toupper(line[3]) - '0';
1694 if (hex1 > 9) hex1 -= 'A' - '9' - 1;
1695 if (hex2 > 9) hex2 -= 'A' - '9' - 1;
1696 *line = (hex1<<4) + hex2;
1697 skip = 3;
1698 }
1699 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001700 ha_alert("parsing [%s:%d] : invalid or incomplete '\\x' sequence in '%s'.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02001701 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001702 }
William Lallemandf9873ba2015-05-05 17:37:14 +02001703 } else if (line[1] == '"') {
1704 *line = '"';
1705 skip = 1;
1706 } else if (line[1] == '\'') {
1707 *line = '\'';
1708 skip = 1;
William Lallemandb2f07452015-05-12 14:27:13 +02001709 } else if (line[1] == '$' && dquote) { /* escaping of $ only inside double quotes */
1710 *line = '$';
1711 skip = 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001712 }
1713 if (skip) {
Cyril Bontédd1b01d2009-12-06 13:43:42 +01001714 memmove(line + 1, line + 1 + skip, end - (line + skip));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001715 end -= skip;
1716 }
1717 line++;
1718 }
William Lallemandf9873ba2015-05-05 17:37:14 +02001719 else if ((!squote && !dquote && *line == '#') || *line == '\n' || *line == '\r') {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001720 /* end of string, end of loop */
1721 *line = 0;
1722 break;
1723 }
William Lallemandf9873ba2015-05-05 17:37:14 +02001724 else if (!squote && !dquote && isspace((unsigned char)*line)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001725 /* a non-escaped space is an argument separator */
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001726 *line++ = '\0';
Willy Tarreau8f8e6452007-06-17 21:51:38 +02001727 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001728 line++;
1729 args[++arg] = line;
1730 }
William Lallemandb2f07452015-05-12 14:27:13 +02001731 else if (dquote && *line == '$') {
1732 /* environment variables are evaluated inside double quotes */
1733 char *var_beg;
1734 char *var_end;
1735 char save_char;
1736 char *value;
1737 int val_len;
1738 int newlinesize;
1739 int braces = 0;
1740
1741 var_beg = line + 1;
1742 var_end = var_beg;
1743
1744 if (*var_beg == '{') {
1745 var_beg++;
1746 var_end++;
1747 braces = 1;
1748 }
1749
1750 if (!isalpha((int)(unsigned char)*var_beg) && *var_beg != '_') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001751 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 +02001752 err_code |= ERR_ALERT | ERR_FATAL;
1753 goto next_line; /* skip current line */
1754 }
1755
1756 while (isalnum((int)(unsigned char)*var_end) || *var_end == '_')
1757 var_end++;
1758
1759 save_char = *var_end;
1760 *var_end = '\0';
1761 value = getenv(var_beg);
1762 *var_end = save_char;
1763 val_len = value ? strlen(value) : 0;
1764
1765 if (braces) {
1766 if (*var_end == '}') {
1767 var_end++;
1768 braces = 0;
1769 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001770 ha_alert("parsing [%s:%d] : Variable expansion: Mismatched braces.\n", file, linenum);
William Lallemandb2f07452015-05-12 14:27:13 +02001771 err_code |= ERR_ALERT | ERR_FATAL;
1772 goto next_line; /* skip current line */
1773 }
1774 }
1775
1776 newlinesize = (end - thisline) - (var_end - line) + val_len + 1;
1777
1778 /* if not enough space in thisline */
1779 if (newlinesize > linesize) {
1780 char *newline;
1781
1782 newline = realloc(thisline, newlinesize * sizeof(*thisline));
1783 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001784 ha_alert("parsing [%s:%d] : Variable expansion: Not enough memory.\n", file, linenum);
William Lallemandb2f07452015-05-12 14:27:13 +02001785 err_code |= ERR_ALERT | ERR_FATAL;
1786 goto next_line; /* slip current line */
1787 }
1788 /* recompute pointers if realloc returns a new pointer */
1789 if (newline != thisline) {
1790 int i;
1791 int diff;
1792
1793 for (i = 0; i <= arg; i++) {
1794 diff = args[i] - thisline;
1795 args[i] = newline + diff;
1796 }
1797
1798 diff = var_end - thisline;
1799 var_end = newline + diff;
1800 diff = end - thisline;
1801 end = newline + diff;
1802 diff = line - thisline;
1803 line = newline + diff;
1804 thisline = newline;
1805 }
1806 linesize = newlinesize;
1807 }
1808
1809 /* insert value inside the line */
1810 memmove(line + val_len, var_end, end - var_end + 1);
1811 memcpy(line, value, val_len);
1812 end += val_len - (var_end - line);
1813 line += val_len;
1814 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001815 else {
1816 line++;
1817 }
1818 }
William Lallemandb2f07452015-05-12 14:27:13 +02001819
William Lallemandf9873ba2015-05-05 17:37:14 +02001820 if (dquote) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001821 ha_alert("parsing [%s:%d] : Mismatched double quotes.\n", file, linenum);
William Lallemandf9873ba2015-05-05 17:37:14 +02001822 err_code |= ERR_ALERT | ERR_FATAL;
1823 }
1824
1825 if (squote) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001826 ha_alert("parsing [%s:%d] : Mismatched simple quotes.\n", file, linenum);
William Lallemandf9873ba2015-05-05 17:37:14 +02001827 err_code |= ERR_ALERT | ERR_FATAL;
1828 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001829
1830 /* empty line */
1831 if (!**args)
1832 continue;
1833
Willy Tarreau7bb651e2009-11-09 21:16:53 +01001834 if (*line) {
1835 /* we had to stop due to too many args.
1836 * Let's terminate the string, print the offending part then cut the
1837 * last arg.
1838 */
1839 while (*line && *line != '#' && *line != '\n' && *line != '\r')
1840 line++;
1841 *line = '\0';
1842
Christopher Faulet767a84b2017-11-24 16:50:31 +01001843 ha_alert("parsing [%s:%d]: line too long, truncating at word %d, position %ld: <%s>.\n",
1844 file, linenum, arg + 1, (long)(args[arg] - thisline + 1), args[arg]);
Willy Tarreau7bb651e2009-11-09 21:16:53 +01001845 err_code |= ERR_ALERT | ERR_FATAL;
1846 args[arg] = line;
1847 }
1848
Willy Tarreau540abe42007-05-02 20:50:16 +02001849 /* zero out remaining args and ensure that at least one entry
1850 * is zeroed out.
1851 */
1852 while (++arg <= MAX_LINE_ARGS) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001853 args[arg] = line;
1854 }
1855
Willy Tarreau3842f002009-06-14 11:39:52 +02001856 /* check for keyword modifiers "no" and "default" */
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01001857 if (!strcmp(args[0], "no")) {
William Lallemand0f99e342011-10-12 17:50:54 +02001858 char *tmp;
1859
Willy Tarreau3842f002009-06-14 11:39:52 +02001860 kwm = KWM_NO;
William Lallemand0f99e342011-10-12 17:50:54 +02001861 tmp = args[0];
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01001862 for (arg=0; *args[arg+1]; arg++)
1863 args[arg] = args[arg+1]; // shift args after inversion
William Lallemand0f99e342011-10-12 17:50:54 +02001864 *tmp = '\0'; // fix the next arg to \0
1865 args[arg] = tmp;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01001866 }
Willy Tarreau3842f002009-06-14 11:39:52 +02001867 else if (!strcmp(args[0], "default")) {
1868 kwm = KWM_DEF;
1869 for (arg=0; *args[arg+1]; arg++)
1870 args[arg] = args[arg+1]; // shift args after inversion
1871 }
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01001872
William Lallemand0f99e342011-10-12 17:50:54 +02001873 if (kwm != KWM_STD && strcmp(args[0], "option") != 0 && \
1874 strcmp(args[0], "log") != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001875 ha_alert("parsing [%s:%d]: negation/default currently supported only for options and log.\n", file, linenum);
Willy Tarreau058e9072009-07-20 09:30:05 +02001876 err_code |= ERR_ALERT | ERR_FATAL;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01001877 }
1878
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001879 /* detect section start */
1880 list_for_each_entry(ics, &sections, list) {
1881 if (strcmp(args[0], ics->section_name) == 0) {
1882 cursection = ics->section_name;
1883 cs = ics;
1884 break;
1885 }
Emeric Brun32da3c42010-09-23 18:39:19 +02001886 }
1887
William Lallemandd2ff56d2017-10-16 11:06:50 +02001888 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001889 ha_alert("parsing [%s:%d]: unknown keyword '%s' out of section.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02001890 err_code |= ERR_ALERT | ERR_FATAL;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001891 } else {
1892 /* else it's a section keyword */
Willy Tarreau058e9072009-07-20 09:30:05 +02001893
William Lallemandd2ff56d2017-10-16 11:06:50 +02001894 if (pcs != cs && pcs && pcs->post_section_parser) {
1895 err_code |= pcs->post_section_parser();
1896 if (err_code & ERR_ABORT)
1897 goto err;
1898 }
1899
1900 err_code |= cs->section_parser(file, linenum, args, kwm);
1901 if (err_code & ERR_ABORT)
1902 goto err;
1903 }
1904 pcs = cs;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001905 }
William Lallemandd2ff56d2017-10-16 11:06:50 +02001906
1907 if (pcs == cs && pcs && pcs->post_section_parser)
1908 err_code |= pcs->post_section_parser();
1909
1910err:
Christopher Faulet79bdef32016-11-04 22:36:15 +01001911 free(cfg_scope);
1912 cfg_scope = NULL;
Willy Tarreau6daf3432008-01-22 16:44:08 +01001913 cursection = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02001914 free(thisline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001915 fclose(f);
Willy Tarreau058e9072009-07-20 09:30:05 +02001916 return err_code;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02001917}
1918
Willy Tarreau64ab6072014-09-16 12:17:36 +02001919/* This function propagates processes from frontend <from> to backend <to> so
1920 * that it is always guaranteed that a backend pointed to by a frontend is
1921 * bound to all of its processes. After that, if the target is a "listen"
1922 * instance, the function recursively descends the target's own targets along
Willy Tarreau98d04852015-05-26 12:18:29 +02001923 * default_backend and use_backend rules. Since the bits are
Willy Tarreau64ab6072014-09-16 12:17:36 +02001924 * checked first to ensure that <to> is already bound to all processes of
1925 * <from>, there is no risk of looping and we ensure to follow the shortest
1926 * path to the destination.
1927 *
1928 * It is possible to set <to> to NULL for the first call so that the function
1929 * takes care of visiting the initial frontend in <from>.
1930 *
1931 * It is important to note that the function relies on the fact that all names
1932 * have already been resolved.
1933 */
1934void propagate_processes(struct proxy *from, struct proxy *to)
1935{
1936 struct switching_rule *rule;
Willy Tarreau64ab6072014-09-16 12:17:36 +02001937
1938 if (to) {
1939 /* check whether we need to go down */
1940 if (from->bind_proc &&
1941 (from->bind_proc & to->bind_proc) == from->bind_proc)
1942 return;
1943
1944 if (!from->bind_proc && !to->bind_proc)
1945 return;
1946
1947 to->bind_proc = from->bind_proc ?
1948 (to->bind_proc | from->bind_proc) : 0;
1949
1950 /* now propagate down */
1951 from = to;
1952 }
1953
Willy Tarreau8a95d8c2014-12-18 13:56:26 +01001954 if (!(from->cap & PR_CAP_FE))
Willy Tarreau64ab6072014-09-16 12:17:36 +02001955 return;
1956
Willy Tarreauf6b70012014-12-18 14:00:43 +01001957 if (from->state == PR_STSTOPPED)
1958 return;
1959
Willy Tarreau64ab6072014-09-16 12:17:36 +02001960 /* default_backend */
1961 if (from->defbe.be)
1962 propagate_processes(from, from->defbe.be);
1963
1964 /* use_backend */
1965 list_for_each_entry(rule, &from->switching_rules, list) {
Cyril Bonté51639692014-10-02 19:56:25 +02001966 if (rule->dynamic)
1967 continue;
Willy Tarreau64ab6072014-09-16 12:17:36 +02001968 to = rule->be.backend;
1969 propagate_processes(from, to);
1970 }
Willy Tarreau64ab6072014-09-16 12:17:36 +02001971}
1972
Willy Tarreaubb925012009-07-23 13:36:36 +02001973/*
1974 * Returns the error code, 0 if OK, or any combination of :
1975 * - ERR_ABORT: must abort ASAP
1976 * - ERR_FATAL: we can continue parsing but not start the service
1977 * - ERR_WARN: a warning has been emitted
1978 * - ERR_ALERT: an alert has been emitted
1979 * Only the two first ones can stop processing, the two others are just
1980 * indicators.
1981 */
Willy Tarreau915e1eb2009-06-22 15:48:36 +02001982int check_config_validity()
1983{
1984 int cfgerr = 0;
1985 struct proxy *curproxy = NULL;
1986 struct server *newsrv = NULL;
Willy Tarreaubb925012009-07-23 13:36:36 +02001987 int err_code = 0;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02001988 unsigned int next_pxid = 1;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02001989 struct bind_conf *bind_conf;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01001990 char *err;
William Lallemand48b4bb42017-10-23 14:36:34 +02001991 struct cfg_postparser *postparser;
Ben Draut054fbee2018-04-13 15:43:04 -06001992 struct dns_resolvers *curr_resolvers = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001993
Willy Tarreau2a65ff02012-09-13 17:54:29 +02001994 bind_conf = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001995 /*
1996 * Now, check for the integrity of all that we have collected.
1997 */
1998
1999 /* will be needed further to delay some tasks */
Willy Tarreaub0b37bc2008-06-23 14:00:57 +02002000 tv_update_date(0,1);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002001
Willy Tarreau193b8c62012-11-22 00:17:38 +01002002 if (!global.tune.max_http_hdr)
2003 global.tune.max_http_hdr = MAX_HTTP_HDR;
2004
2005 if (!global.tune.cookie_len)
2006 global.tune.cookie_len = CAPTURE_LEN;
2007
Stéphane Cottin23e9e932017-05-18 08:58:41 +02002008 if (!global.tune.requri_len)
2009 global.tune.requri_len = REQURI_LEN;
2010
Willy Tarreaubafbe012017-11-24 17:34:44 +01002011 pool_head_requri = create_pool("requri", global.tune.requri_len , MEM_F_SHARED);
Emeric Brun96fd9262017-07-05 13:33:16 +02002012
Willy Tarreaubafbe012017-11-24 17:34:44 +01002013 pool_head_capture = create_pool("capture", global.tune.cookie_len, MEM_F_SHARED);
Willy Tarreau193b8c62012-11-22 00:17:38 +01002014
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002015 /* Post initialisation of the users and groups lists. */
2016 err_code = userlist_postinit();
2017 if (err_code != ERR_NONE)
2018 goto out;
2019
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002020 /* first, we will invert the proxy list order */
2021 curproxy = NULL;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002022 while (proxies_list) {
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002023 struct proxy *next;
2024
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002025 next = proxies_list->next;
2026 proxies_list->next = curproxy;
2027 curproxy = proxies_list;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002028 if (!next)
2029 break;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002030 proxies_list = next;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002031 }
2032
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002033 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002034 struct switching_rule *rule;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002035 struct server_rule *srule;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002036 struct sticking_rule *mrule;
Christopher Faulete4e830d2017-09-18 14:51:41 +02002037 struct act_rule *arule;
Dragan Dosen1322d092015-09-22 16:05:32 +02002038 struct logsrv *tmplogsrv;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002039 unsigned int next_id;
Willy Tarreau16a21472012-11-19 12:39:59 +01002040 int nbproc;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002041
Willy Tarreau050536d2012-10-04 08:47:34 +02002042 if (curproxy->uuid < 0) {
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002043 /* proxy ID not set, use automatic numbering with first
2044 * spare entry starting with next_pxid.
2045 */
2046 next_pxid = get_next_id(&used_proxy_id, next_pxid);
2047 curproxy->conf.id.key = curproxy->uuid = next_pxid;
2048 eb32_insert(&used_proxy_id, &curproxy->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002049 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01002050 next_pxid++;
2051
Willy Tarreau55ea7572007-06-17 19:56:27 +02002052
Willy Tarreaubaaee002006-06-26 02:48:02 +02002053 if (curproxy->state == PR_STSTOPPED) {
Willy Tarreauda250db2008-10-12 12:07:48 +02002054 /* ensure we don't keep listeners uselessly bound */
2055 stop_proxy(curproxy);
Willy Tarreau02df7742015-05-01 19:59:56 +02002056 free((void *)curproxy->table.peers.name);
2057 curproxy->table.peers.p = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002058 continue;
2059 }
2060
Willy Tarreau102df612014-05-07 23:56:38 +02002061 /* Check multi-process mode compatibility for the current proxy */
2062
2063 if (curproxy->bind_proc) {
2064 /* an explicit bind-process was specified, let's check how many
2065 * processes remain.
2066 */
David Carliere6c39412015-07-02 07:00:17 +00002067 nbproc = my_popcountl(curproxy->bind_proc);
Willy Tarreau102df612014-05-07 23:56:38 +02002068
2069 curproxy->bind_proc &= nbits(global.nbproc);
2070 if (!curproxy->bind_proc && nbproc == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002071 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 +02002072 curproxy->bind_proc = 1;
2073 }
2074 else if (!curproxy->bind_proc && nbproc > 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002075 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 +02002076 curproxy->bind_proc = 0;
2077 }
2078 }
2079
Willy Tarreau3d209582014-05-09 17:06:11 +02002080 /* check and reduce the bind-proc of each listener */
2081 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
2082 unsigned long mask;
2083
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002084 /* HTTP frontends with "h2" as ALPN/NPN will work in
2085 * HTTP/2 and absolutely require buffers 16kB or larger.
2086 */
2087#ifdef USE_OPENSSL
2088 if (curproxy->mode == PR_MODE_HTTP && global.tune.bufsize < 16384) {
2089#ifdef OPENSSL_NPN_NEGOTIATED
2090 /* check NPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002091 if (bind_conf->ssl_conf.npn_str && strstr(bind_conf->ssl_conf.npn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002092 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",
2093 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002094 cfgerr++;
2095 }
2096#endif
2097#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
2098 /* check ALPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002099 if (bind_conf->ssl_conf.alpn_str && strstr(bind_conf->ssl_conf.alpn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002100 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",
2101 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002102 cfgerr++;
2103 }
2104#endif
2105 } /* HTTP && bufsize < 16384 */
2106#endif
2107
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002108 /* detect and address thread affinity inconsistencies */
2109 nbproc = 0;
2110 if (bind_conf->bind_proc)
2111 nbproc = my_ffsl(bind_conf->bind_proc);
2112
2113 mask = bind_conf->bind_thread[nbproc - 1];
Willy Tarreau0c026f42018-08-01 19:12:20 +02002114 if (mask && !(mask & all_threads_mask)) {
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002115 unsigned long new_mask = 0;
2116
2117 while (mask) {
Willy Tarreau0c026f42018-08-01 19:12:20 +02002118 new_mask |= mask & all_threads_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002119 mask >>= global.nbthread;
2120 }
2121
2122 for (nbproc = 0; nbproc < LONGBITS; nbproc++) {
2123 if (!bind_conf->bind_proc || (bind_conf->bind_proc & (1UL << nbproc)))
2124 bind_conf->bind_thread[nbproc] = new_mask;
2125 }
2126 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",
2127 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line, new_mask);
2128 }
2129
2130 /* detect process and nbproc affinity inconsistencies */
Willy Tarreau3d209582014-05-09 17:06:11 +02002131 if (!bind_conf->bind_proc)
2132 continue;
2133
2134 mask = nbits(global.nbproc);
2135 if (curproxy->bind_proc)
2136 mask &= curproxy->bind_proc;
2137 /* mask cannot be null here thanks to the previous checks */
2138
David Carliere6c39412015-07-02 07:00:17 +00002139 nbproc = my_popcountl(bind_conf->bind_proc);
Willy Tarreau3d209582014-05-09 17:06:11 +02002140 bind_conf->bind_proc &= mask;
2141
2142 if (!bind_conf->bind_proc && nbproc == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002143 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",
2144 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreau3d209582014-05-09 17:06:11 +02002145 bind_conf->bind_proc = mask & ~(mask - 1);
2146 }
2147 else if (!bind_conf->bind_proc && nbproc > 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002148 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",
2149 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreau3d209582014-05-09 17:06:11 +02002150 bind_conf->bind_proc = 0;
2151 }
2152 }
2153
Willy Tarreauff01a212009-03-15 13:46:16 +01002154 switch (curproxy->mode) {
2155 case PR_MODE_HEALTH:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002156 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002157 if (!(curproxy->cap & PR_CAP_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002158 ha_alert("config : %s '%s' cannot be in health mode as it has no frontend capability.\n",
2159 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +01002160 cfgerr++;
2161 }
2162
2163 if (curproxy->srv != NULL)
Christopher Faulet767a84b2017-11-24 16:50:31 +01002164 ha_warning("config : servers will be ignored for %s '%s'.\n",
2165 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +01002166 break;
2167
2168 case PR_MODE_TCP:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002169 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002170 break;
2171
2172 case PR_MODE_HTTP:
Willy Tarreau25320b22013-03-24 07:22:08 +01002173 curproxy->http_needed = 1;
Willy Tarreauff01a212009-03-15 13:46:16 +01002174 break;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002175
2176 case PR_MODE_CLI:
2177 cfgerr += proxy_cfg_ensure_no_http(curproxy);
2178 break;
Willy Tarreauff01a212009-03-15 13:46:16 +01002179 }
2180
Willy Tarreau58aa5cc2018-02-08 09:55:09 +01002181 if (curproxy != global.stats_fe && (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->conf.listeners)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002182 ha_warning("config : %s '%s' has no 'bind' directive. Please declare it as a backend if this was intended.\n",
2183 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauf3934b82015-08-11 11:36:45 +02002184 err_code |= ERR_WARN;
2185 }
2186
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002187 if ((curproxy->cap & PR_CAP_BE) && (curproxy->mode != PR_MODE_HEALTH)) {
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002188 if (curproxy->lbprm.algo & BE_LB_KIND) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002189 if (curproxy->options & PR_O_TRANSP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002190 ha_alert("config : %s '%s' cannot use both transparent and balance mode.\n",
2191 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002192 cfgerr++;
2193 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002194#ifdef WE_DONT_SUPPORT_SERVERLESS_LISTENERS
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002195 else if (curproxy->srv == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002196 ha_alert("config : %s '%s' needs at least 1 server in balance mode.\n",
2197 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002198 cfgerr++;
2199 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002200#endif
Willy Tarreau1620ec32011-08-06 17:05:02 +02002201 else if (curproxy->options & PR_O_DISPATCH) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002202 ha_warning("config : dispatch address of %s '%s' will be ignored in balance mode.\n",
2203 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002204 err_code |= ERR_WARN;
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002205 }
2206 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02002207 else if (!(curproxy->options & (PR_O_TRANSP | PR_O_DISPATCH | PR_O_HTTP_PROXY))) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002208 /* If no LB algo is set in a backend, and we're not in
2209 * transparent mode, dispatch mode nor proxy mode, we
2210 * want to use balance roundrobin by default.
2211 */
2212 curproxy->lbprm.algo &= ~BE_LB_ALGO;
2213 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002214 }
2215 }
Willy Tarreau193cf932007-09-17 10:17:23 +02002216
Willy Tarreau1620ec32011-08-06 17:05:02 +02002217 if (curproxy->options & PR_O_DISPATCH)
2218 curproxy->options &= ~(PR_O_TRANSP | PR_O_HTTP_PROXY);
2219 else if (curproxy->options & PR_O_HTTP_PROXY)
2220 curproxy->options &= ~(PR_O_DISPATCH | PR_O_TRANSP);
2221 else if (curproxy->options & PR_O_TRANSP)
2222 curproxy->options &= ~(PR_O_DISPATCH | PR_O_HTTP_PROXY);
Willy Tarreau82936582007-11-30 15:20:09 +01002223
Willy Tarreau1620ec32011-08-06 17:05:02 +02002224 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_HTTP_CHK) {
2225 if (curproxy->options & PR_O_DISABLE404) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002226 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2227 "disable-on-404", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002228 err_code |= ERR_WARN;
2229 curproxy->options &= ~PR_O_DISABLE404;
2230 }
2231 if (curproxy->options2 & PR_O2_CHK_SNDST) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002232 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2233 "send-state", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002234 err_code |= ERR_WARN;
2235 curproxy->options &= ~PR_O2_CHK_SNDST;
2236 }
Willy Tarreauef781042010-01-27 11:53:01 +01002237 }
2238
Simon Horman98637e52014-06-20 12:30:16 +09002239 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_EXT_CHK) {
2240 if (!global.external_check) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002241 ha_alert("Proxy '%s' : '%s' unable to find required 'global.external-check'.\n",
2242 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002243 cfgerr++;
2244 }
2245 if (!curproxy->check_command) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002246 ha_alert("Proxy '%s' : '%s' unable to find required 'external-check command'.\n",
2247 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002248 cfgerr++;
2249 }
2250 }
2251
Simon Horman64e34162015-02-06 11:11:57 +09002252 if (curproxy->email_alert.set) {
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002253 if (!(curproxy->email_alert.mailers.name && curproxy->email_alert.from && curproxy->email_alert.to)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002254 ha_warning("config : 'email-alert' will be ignored for %s '%s' (the presence any of "
2255 "'email-alert from', 'email-alert level' 'email-alert mailers', "
2256 "'email-alert myhostname', or 'email-alert to' "
2257 "requires each of 'email-alert from', 'email-alert mailers' and 'email-alert to' "
2258 "to be present).\n",
2259 proxy_type_str(curproxy), curproxy->id);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002260 err_code |= ERR_WARN;
2261 free_email_alert(curproxy);
2262 }
2263 if (!curproxy->email_alert.myhostname)
Cyril Bontée22bfd62015-12-04 03:07:07 +01002264 curproxy->email_alert.myhostname = strdup(hostname);
Simon Horman9dc49962015-01-30 11:22:59 +09002265 }
2266
Simon Horman98637e52014-06-20 12:30:16 +09002267 if (curproxy->check_command) {
2268 int clear = 0;
2269 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002270 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2271 "external-check command", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002272 err_code |= ERR_WARN;
2273 clear = 1;
2274 }
2275 if (curproxy->check_command[0] != '/' && !curproxy->check_path) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002276 ha_alert("Proxy '%s': '%s' does not have a leading '/' and 'external-check path' is not set.\n",
2277 curproxy->id, "external-check command");
Simon Horman98637e52014-06-20 12:30:16 +09002278 cfgerr++;
2279 }
2280 if (clear) {
2281 free(curproxy->check_command);
2282 curproxy->check_command = NULL;
2283 }
2284 }
2285
2286 if (curproxy->check_path) {
2287 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002288 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2289 "external-check path", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002290 err_code |= ERR_WARN;
2291 free(curproxy->check_path);
2292 curproxy->check_path = NULL;
2293 }
2294 }
2295
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002296 /* if a default backend was specified, let's find it */
2297 if (curproxy->defbe.name) {
2298 struct proxy *target;
2299
Willy Tarreauafb39922015-05-26 12:04:09 +02002300 target = proxy_be_by_name(curproxy->defbe.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002301 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002302 ha_alert("Proxy '%s': unable to find required default_backend: '%s'.\n",
2303 curproxy->id, curproxy->defbe.name);
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002304 cfgerr++;
2305 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002306 ha_alert("Proxy '%s': loop detected for default_backend: '%s'.\n",
2307 curproxy->id, curproxy->defbe.name);
Willy Tarreaubb925012009-07-23 13:36:36 +02002308 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002309 } else if (target->mode != curproxy->mode &&
2310 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2311
Christopher Faulet767a84b2017-11-24 16:50:31 +01002312 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) as its default backend (see 'mode').\n",
2313 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2314 curproxy->conf.file, curproxy->conf.line,
2315 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2316 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002317 cfgerr++;
Willy Tarreau68ad3a42018-10-22 11:49:15 +02002318 } else if ((curproxy->options2 ^ target->options2) & PR_O2_USE_HTX) {
2319 ha_alert("%s %s '%s' (%s:%d) tries to use %s %s '%s' (%s:%d) as its default backend, both of which disagree on 'option http-use-htx'.\n",
2320 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2321 curproxy->conf.file, curproxy->conf.line,
2322 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2323 target->conf.file, target->conf.line);
2324 cfgerr++;
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002325 } else {
2326 free(curproxy->defbe.name);
2327 curproxy->defbe.be = target;
Emeric Brun3f783572017-01-12 11:21:28 +01002328 /* Update tot_fe_maxconn for a further fullconn's computation */
2329 target->tot_fe_maxconn += curproxy->maxconn;
Willy Tarreauff678132012-02-13 14:32:34 +01002330 /* Emit a warning if this proxy also has some servers */
2331 if (curproxy->srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002332 ha_warning("In proxy '%s', the 'default_backend' rule always has precedence over the servers, which will never be used.\n",
2333 curproxy->id);
Willy Tarreauff678132012-02-13 14:32:34 +01002334 err_code |= ERR_WARN;
2335 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002336 }
2337 }
2338
Emeric Brun3f783572017-01-12 11:21:28 +01002339 if (!curproxy->defbe.be && (curproxy->cap & PR_CAP_LISTEN) == PR_CAP_LISTEN) {
2340 /* Case of listen without default backend
2341 * The curproxy will be its own default backend
2342 * so we update tot_fe_maxconn for a further
2343 * fullconn's computation */
2344 curproxy->tot_fe_maxconn += curproxy->maxconn;
2345 }
2346
Willy Tarreau55ea7572007-06-17 19:56:27 +02002347 /* find the target proxy for 'use_backend' rules */
2348 list_for_each_entry(rule, &curproxy->switching_rules, list) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002349 struct proxy *target;
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002350 struct logformat_node *node;
2351 char *pxname;
2352
2353 /* Try to parse the string as a log format expression. If the result
2354 * of the parsing is only one entry containing a simple string, then
2355 * it's a standard string corresponding to a static rule, thus the
2356 * parsing is cancelled and be.name is restored to be resolved.
2357 */
2358 pxname = rule->be.name;
2359 LIST_INIT(&rule->be.expr);
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +01002360 curproxy->conf.args.ctx = ARGC_UBK;
2361 curproxy->conf.args.file = rule->file;
2362 curproxy->conf.args.line = rule->line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002363 err = NULL;
2364 if (!parse_logformat_string(pxname, curproxy, &rule->be.expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002365 ha_alert("Parsing [%s:%d]: failed to parse use_backend rule '%s' : %s.\n",
2366 rule->file, rule->line, pxname, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002367 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002368 cfgerr++;
2369 continue;
2370 }
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002371 node = LIST_NEXT(&rule->be.expr, struct logformat_node *, list);
2372
2373 if (!LIST_ISEMPTY(&rule->be.expr)) {
2374 if (node->type != LOG_FMT_TEXT || node->list.n != &rule->be.expr) {
2375 rule->dynamic = 1;
2376 free(pxname);
2377 continue;
2378 }
2379 /* simple string: free the expression and fall back to static rule */
2380 free(node->arg);
2381 free(node);
2382 }
2383
2384 rule->dynamic = 0;
2385 rule->be.name = pxname;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002386
Willy Tarreauafb39922015-05-26 12:04:09 +02002387 target = proxy_be_by_name(rule->be.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002388 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002389 ha_alert("Proxy '%s': unable to find required use_backend: '%s'.\n",
2390 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002391 cfgerr++;
2392 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002393 ha_alert("Proxy '%s': loop detected for use_backend: '%s'.\n",
2394 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002395 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002396 } else if (target->mode != curproxy->mode &&
2397 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2398
Christopher Faulet767a84b2017-11-24 16:50:31 +01002399 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) in a 'use_backend' rule (see 'mode').\n",
2400 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2401 curproxy->conf.file, curproxy->conf.line,
2402 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2403 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002404 cfgerr++;
Willy Tarreau68ad3a42018-10-22 11:49:15 +02002405 } else if ((curproxy->options2 ^ target->options2) & PR_O2_USE_HTX) {
2406 ha_alert("%s %s '%s' (%s:%d) tries to use %s %s '%s' (%s:%d) in a 'use_backend' rule, both of which disagree on 'option http-use-htx'.\n",
2407 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2408 curproxy->conf.file, curproxy->conf.line,
2409 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2410 target->conf.file, target->conf.line);
2411 cfgerr++;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002412 } else {
2413 free((void *)rule->be.name);
2414 rule->be.backend = target;
Emeric Brun3f783572017-01-12 11:21:28 +01002415 /* For each target of switching rules, we update
2416 * their tot_fe_maxconn, except if a previous rule point
2417 * on the same backend or on the default backend */
2418 if (rule->be.backend != curproxy->defbe.be) {
2419 struct switching_rule *swrule;
2420
2421 list_for_each_entry(swrule, &curproxy->switching_rules, list) {
2422 if (rule == swrule) {
2423 target->tot_fe_maxconn += curproxy->maxconn;
2424 break;
2425 }
2426 else if (!swrule->dynamic && swrule->be.backend == rule->be.backend) {
2427 /* there is multiple ref of this backend */
2428 break;
2429 }
2430 }
2431 }
Willy Tarreau55ea7572007-06-17 19:56:27 +02002432 }
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002433 }
2434
Willy Tarreau64ab6072014-09-16 12:17:36 +02002435 /* find the target server for 'use_server' rules */
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002436 list_for_each_entry(srule, &curproxy->server_rules, list) {
2437 struct server *target = findserver(curproxy, srule->srv.name);
2438
2439 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002440 ha_alert("config : %s '%s' : unable to find server '%s' referenced in a 'use-server' rule.\n",
2441 proxy_type_str(curproxy), curproxy->id, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002442 cfgerr++;
2443 continue;
2444 }
2445 free((void *)srule->srv.name);
2446 srule->srv.ptr = target;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002447 }
2448
Emeric Brunb982a3d2010-01-04 15:45:53 +01002449 /* find the target table for 'stick' rules */
2450 list_for_each_entry(mrule, &curproxy->sticking_rules, list) {
2451 struct proxy *target;
2452
Emeric Brun1d33b292010-01-04 15:47:17 +01002453 curproxy->be_req_ana |= AN_REQ_STICKING_RULES;
2454 if (mrule->flags & STK_IS_STORE)
2455 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2456
Emeric Brunb982a3d2010-01-04 15:45:53 +01002457 if (mrule->table.name)
Willy Tarreau9e0bb102015-05-26 11:24:42 +02002458 target = proxy_tbl_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002459 else
2460 target = curproxy;
2461
2462 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002463 ha_alert("Proxy '%s': unable to find stick-table '%s'.\n",
2464 curproxy->id, mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002465 cfgerr++;
2466 }
2467 else if (target->table.size == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002468 ha_alert("Proxy '%s': stick-table '%s' used but not configured.\n",
2469 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002470 cfgerr++;
2471 }
Willy Tarreau12785782012-04-27 21:37:17 +02002472 else if (!stktable_compatible_sample(mrule->expr, target->table.type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002473 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2474 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002475 cfgerr++;
2476 }
2477 else {
2478 free((void *)mrule->table.name);
2479 mrule->table.t = &(target->table);
Willy Tarreau888617d2010-06-20 09:11:39 +02002480 stktable_alloc_data_type(&target->table, STKTABLE_DT_SERVER_ID, NULL);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002481 }
2482 }
2483
2484 /* find the target table for 'store response' rules */
2485 list_for_each_entry(mrule, &curproxy->storersp_rules, list) {
2486 struct proxy *target;
2487
Emeric Brun1d33b292010-01-04 15:47:17 +01002488 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2489
Emeric Brunb982a3d2010-01-04 15:45:53 +01002490 if (mrule->table.name)
Willy Tarreau9e0bb102015-05-26 11:24:42 +02002491 target = proxy_tbl_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002492 else
2493 target = curproxy;
2494
2495 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002496 ha_alert("Proxy '%s': unable to find store table '%s'.\n",
2497 curproxy->id, mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002498 cfgerr++;
2499 }
2500 else if (target->table.size == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002501 ha_alert("Proxy '%s': stick-table '%s' used but not configured.\n",
2502 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002503 cfgerr++;
2504 }
Willy Tarreau12785782012-04-27 21:37:17 +02002505 else if (!stktable_compatible_sample(mrule->expr, target->table.type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002506 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2507 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002508 cfgerr++;
2509 }
2510 else {
2511 free((void *)mrule->table.name);
2512 mrule->table.t = &(target->table);
Willy Tarreau888617d2010-06-20 09:11:39 +02002513 stktable_alloc_data_type(&target->table, STKTABLE_DT_SERVER_ID, NULL);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002514 }
2515 }
2516
Christopher Faulete4e830d2017-09-18 14:51:41 +02002517 /* check validity for 'tcp-request' layer 4 rules */
2518 list_for_each_entry(arule, &curproxy->tcp_req.l4_rules, list) {
2519 err = NULL;
2520 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002521 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002522 free(err);
Willy Tarreau5f53de72012-12-12 00:25:44 +01002523 cfgerr++;
2524 }
Willy Tarreaud1f96522010-08-03 19:34:32 +02002525 }
2526
Christopher Faulete4e830d2017-09-18 14:51:41 +02002527 /* check validity for 'tcp-request' layer 5 rules */
2528 list_for_each_entry(arule, &curproxy->tcp_req.l5_rules, list) {
2529 err = NULL;
2530 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002531 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002532 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002533 cfgerr++;
2534 }
2535 }
2536
Christopher Faulete4e830d2017-09-18 14:51:41 +02002537 /* check validity for 'tcp-request' layer 6 rules */
2538 list_for_each_entry(arule, &curproxy->tcp_req.inspect_rules, list) {
2539 err = NULL;
2540 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002541 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002542 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002543 cfgerr++;
2544 }
2545 }
2546
Christopher Faulete4e830d2017-09-18 14:51:41 +02002547 /* check validity for 'http-request' layer 7 rules */
2548 list_for_each_entry(arule, &curproxy->http_req_rules, list) {
2549 err = NULL;
2550 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002551 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002552 free(err);
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002553 cfgerr++;
2554 }
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002555 }
2556
Christopher Faulete4e830d2017-09-18 14:51:41 +02002557 /* check validity for 'http-response' layer 7 rules */
2558 list_for_each_entry(arule, &curproxy->http_res_rules, list) {
2559 err = NULL;
2560 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002561 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002562 free(err);
Willy Tarreau09448f72014-06-25 18:12:15 +02002563 cfgerr++;
2564 }
Willy Tarreau09448f72014-06-25 18:12:15 +02002565 }
2566
Willy Tarreaub3dc39d2014-04-28 22:06:57 +02002567 /* move any "block" rules at the beginning of the http-request rules */
2568 if (!LIST_ISEMPTY(&curproxy->block_rules)) {
2569 /* insert block_rules into http_req_rules at the beginning */
2570 curproxy->block_rules.p->n = curproxy->http_req_rules.n;
2571 curproxy->http_req_rules.n->p = curproxy->block_rules.p;
2572 curproxy->block_rules.n->p = &curproxy->http_req_rules;
2573 curproxy->http_req_rules.n = curproxy->block_rules.n;
2574 LIST_INIT(&curproxy->block_rules);
2575 }
2576
Emeric Brun32da3c42010-09-23 18:39:19 +02002577 if (curproxy->table.peers.name) {
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002578 struct peers *curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002579
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002580 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
Emeric Brun32da3c42010-09-23 18:39:19 +02002581 if (strcmp(curpeers->id, curproxy->table.peers.name) == 0) {
2582 free((void *)curproxy->table.peers.name);
Willy Tarreau973ca492013-01-17 21:34:52 +01002583 curproxy->table.peers.p = curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002584 break;
2585 }
2586 }
2587
2588 if (!curpeers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002589 ha_alert("Proxy '%s': unable to find sync peers '%s'.\n",
2590 curproxy->id, curproxy->table.peers.name);
Willy Tarreaud66bf962011-10-28 14:16:49 +02002591 free((void *)curproxy->table.peers.name);
2592 curproxy->table.peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002593 cfgerr++;
2594 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002595 else if (curpeers->state == PR_STSTOPPED) {
2596 /* silently disable this peers section */
2597 curproxy->table.peers.p = NULL;
2598 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002599 else if (!curpeers->peers_fe) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002600 ha_alert("Proxy '%s': unable to find local peer '%s' in peers section '%s'.\n",
2601 curproxy->id, localpeer, curpeers->id);
Willy Tarreaud66bf962011-10-28 14:16:49 +02002602 curproxy->table.peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002603 cfgerr++;
2604 }
2605 }
2606
Simon Horman9dc49962015-01-30 11:22:59 +09002607
2608 if (curproxy->email_alert.mailers.name) {
2609 struct mailers *curmailers = mailers;
2610
2611 for (curmailers = mailers; curmailers; curmailers = curmailers->next) {
Christopher Faulet0108bb32017-10-20 21:34:32 +02002612 if (!strcmp(curmailers->id, curproxy->email_alert.mailers.name))
Simon Horman9dc49962015-01-30 11:22:59 +09002613 break;
Simon Horman9dc49962015-01-30 11:22:59 +09002614 }
Simon Horman9dc49962015-01-30 11:22:59 +09002615 if (!curmailers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002616 ha_alert("Proxy '%s': unable to find mailers '%s'.\n",
2617 curproxy->id, curproxy->email_alert.mailers.name);
Simon Horman9dc49962015-01-30 11:22:59 +09002618 free_email_alert(curproxy);
2619 cfgerr++;
2620 }
Christopher Faulet0108bb32017-10-20 21:34:32 +02002621 else {
2622 err = NULL;
2623 if (init_email_alert(curmailers, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002624 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulet0108bb32017-10-20 21:34:32 +02002625 free(err);
2626 cfgerr++;
2627 }
2628 }
Simon Horman9dc49962015-01-30 11:22:59 +09002629 }
2630
Krzysztof Piotr Oledzki329f74d2010-02-22 20:27:23 +01002631 if (curproxy->uri_auth && !(curproxy->uri_auth->flags & ST_CONVDONE) &&
Willy Tarreauff011f22011-01-06 17:51:27 +01002632 !LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules) &&
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002633 (curproxy->uri_auth->userlist || curproxy->uri_auth->auth_realm )) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002634 ha_alert("%s '%s': stats 'auth'/'realm' and 'http-request' can't be used at the same time.\n",
2635 "proxy", curproxy->id);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002636 cfgerr++;
2637 goto out_uri_auth_compat;
2638 }
2639
Krzysztof Piotr Oledzki329f74d2010-02-22 20:27:23 +01002640 if (curproxy->uri_auth && curproxy->uri_auth->userlist && !(curproxy->uri_auth->flags & ST_CONVDONE)) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002641 const char *uri_auth_compat_req[10];
Thierry FOURNIERa28a9422015-08-04 19:35:46 +02002642 struct act_rule *rule;
Willy Tarreau95fa4692010-02-01 13:05:50 +01002643 int i = 0;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002644
Willy Tarreau95fa4692010-02-01 13:05:50 +01002645 /* build the ACL condition from scratch. We're relying on anonymous ACLs for that */
2646 uri_auth_compat_req[i++] = "auth";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002647
2648 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002649 uri_auth_compat_req[i++] = "realm";
2650 uri_auth_compat_req[i++] = curproxy->uri_auth->auth_realm;
2651 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002652
Willy Tarreau95fa4692010-02-01 13:05:50 +01002653 uri_auth_compat_req[i++] = "unless";
2654 uri_auth_compat_req[i++] = "{";
2655 uri_auth_compat_req[i++] = "http_auth(.internal-stats-userlist)";
2656 uri_auth_compat_req[i++] = "}";
2657 uri_auth_compat_req[i++] = "";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002658
Willy Tarreauff011f22011-01-06 17:51:27 +01002659 rule = parse_http_req_cond(uri_auth_compat_req, "internal-stats-auth-compat", 0, curproxy);
2660 if (!rule) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002661 cfgerr++;
2662 break;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002663 }
2664
Willy Tarreauff011f22011-01-06 17:51:27 +01002665 LIST_ADDQ(&curproxy->uri_auth->http_req_rules, &rule->list);
Willy Tarreau95fa4692010-02-01 13:05:50 +01002666
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002667 if (curproxy->uri_auth->auth_realm) {
2668 free(curproxy->uri_auth->auth_realm);
2669 curproxy->uri_auth->auth_realm = NULL;
2670 }
Krzysztof Piotr Oledzki329f74d2010-02-22 20:27:23 +01002671
2672 curproxy->uri_auth->flags |= ST_CONVDONE;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002673 }
2674out_uri_auth_compat:
2675
Dragan Dosen43885c72015-10-01 13:18:13 +02002676 /* check whether we have a log server that uses RFC5424 log format */
Dragan Dosen1322d092015-09-22 16:05:32 +02002677 list_for_each_entry(tmplogsrv, &curproxy->logsrvs, list) {
Dragan Dosen43885c72015-10-01 13:18:13 +02002678 if (tmplogsrv->format == LOG_FORMAT_RFC5424) {
2679 if (!curproxy->conf.logformat_sd_string) {
2680 /* set the default logformat_sd_string */
2681 curproxy->conf.logformat_sd_string = default_rfc5424_sd_log_format;
2682 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002683 break;
Dragan Dosen1322d092015-09-22 16:05:32 +02002684 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002685 }
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02002686
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002687 /* compile the log format */
2688 if (!(curproxy->cap & PR_CAP_FE)) {
Willy Tarreau62a61232013-04-12 18:13:46 +02002689 if (curproxy->conf.logformat_string != default_http_log_format &&
2690 curproxy->conf.logformat_string != default_tcp_log_format &&
2691 curproxy->conf.logformat_string != clf_http_log_format)
2692 free(curproxy->conf.logformat_string);
2693 curproxy->conf.logformat_string = NULL;
2694 free(curproxy->conf.lfs_file);
2695 curproxy->conf.lfs_file = NULL;
2696 curproxy->conf.lfs_line = 0;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002697
2698 if (curproxy->conf.logformat_sd_string != default_rfc5424_sd_log_format)
2699 free(curproxy->conf.logformat_sd_string);
2700 curproxy->conf.logformat_sd_string = NULL;
2701 free(curproxy->conf.lfsd_file);
2702 curproxy->conf.lfsd_file = NULL;
2703 curproxy->conf.lfsd_line = 0;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002704 }
2705
Willy Tarreau62a61232013-04-12 18:13:46 +02002706 if (curproxy->conf.logformat_string) {
2707 curproxy->conf.args.ctx = ARGC_LOG;
2708 curproxy->conf.args.file = curproxy->conf.lfs_file;
2709 curproxy->conf.args.line = curproxy->conf.lfs_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002710 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002711 if (!parse_logformat_string(curproxy->conf.logformat_string, curproxy, &curproxy->logformat, LOG_OPT_MANDATORY,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002712 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002713 ha_alert("Parsing [%s:%d]: failed to parse log-format : %s.\n",
2714 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002715 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002716 cfgerr++;
2717 }
Willy Tarreau62a61232013-04-12 18:13:46 +02002718 curproxy->conf.args.file = NULL;
2719 curproxy->conf.args.line = 0;
2720 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002721
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002722 if (curproxy->conf.logformat_sd_string) {
2723 curproxy->conf.args.ctx = ARGC_LOGSD;
2724 curproxy->conf.args.file = curproxy->conf.lfsd_file;
2725 curproxy->conf.args.line = curproxy->conf.lfsd_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002726 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002727 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 +01002728 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002729 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
2730 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002731 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002732 cfgerr++;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002733 } else if (!add_to_logformat_list(NULL, NULL, LF_SEPARATOR, &curproxy->logformat_sd, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002734 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
2735 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002736 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002737 cfgerr++;
2738 }
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002739 curproxy->conf.args.file = NULL;
2740 curproxy->conf.args.line = 0;
2741 }
2742
Willy Tarreau62a61232013-04-12 18:13:46 +02002743 if (curproxy->conf.uniqueid_format_string) {
2744 curproxy->conf.args.ctx = ARGC_UIF;
2745 curproxy->conf.args.file = curproxy->conf.uif_file;
2746 curproxy->conf.args.line = curproxy->conf.uif_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002747 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002748 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 +01002749 (curproxy->cap & PR_CAP_FE) ? SMP_VAL_FE_HRQ_HDR : SMP_VAL_BE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002750 ha_alert("Parsing [%s:%d]: failed to parse unique-id : %s.\n",
2751 curproxy->conf.uif_file, curproxy->conf.uif_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002752 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002753 cfgerr++;
2754 }
Willy Tarreau62a61232013-04-12 18:13:46 +02002755 curproxy->conf.args.file = NULL;
2756 curproxy->conf.args.line = 0;
2757 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002758
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002759 /* only now we can check if some args remain unresolved.
2760 * This must be done after the users and groups resolution.
2761 */
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002762 cfgerr += smp_resolve_args(curproxy);
2763 if (!cfgerr)
2764 cfgerr += acl_find_targets(curproxy);
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01002765
Willy Tarreau2738a142006-07-08 17:28:09 +02002766 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002767 (((curproxy->cap & PR_CAP_FE) && !curproxy->timeout.client) ||
Willy Tarreaud825eef2007-05-12 22:35:00 +02002768 ((curproxy->cap & PR_CAP_BE) && (curproxy->srv) &&
Willy Tarreauce887fd2012-05-12 12:50:00 +02002769 (!curproxy->timeout.connect ||
2770 (!curproxy->timeout.server && (curproxy->mode == PR_MODE_HTTP || !curproxy->timeout.tunnel)))))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002771 ha_warning("config : missing timeouts for %s '%s'.\n"
2772 " | While not properly invalid, you will certainly encounter various problems\n"
2773 " | with such a configuration. To fix this, please ensure that all following\n"
2774 " | timeouts are set to a non-zero value: 'client', 'connect', 'server'.\n",
2775 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002776 err_code |= ERR_WARN;
Willy Tarreau2738a142006-07-08 17:28:09 +02002777 }
Willy Tarreauf3c69202006-07-09 16:42:34 +02002778
Willy Tarreau1fa31262007-12-03 00:36:16 +01002779 /* Historically, the tarpit and queue timeouts were inherited from contimeout.
2780 * We must still support older configurations, so let's find out whether those
2781 * parameters have been set or must be copied from contimeouts.
2782 */
2783 if (curproxy != &defproxy) {
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002784 if (!curproxy->timeout.tarpit ||
2785 curproxy->timeout.tarpit == defproxy.timeout.tarpit) {
Willy Tarreau1fa31262007-12-03 00:36:16 +01002786 /* tarpit timeout not set. We search in the following order:
2787 * default.tarpit, curr.connect, default.connect.
2788 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002789 if (defproxy.timeout.tarpit)
Willy Tarreau1fa31262007-12-03 00:36:16 +01002790 curproxy->timeout.tarpit = defproxy.timeout.tarpit;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002791 else if (curproxy->timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01002792 curproxy->timeout.tarpit = curproxy->timeout.connect;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002793 else if (defproxy.timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01002794 curproxy->timeout.tarpit = defproxy.timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01002795 }
2796 if ((curproxy->cap & PR_CAP_BE) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002797 (!curproxy->timeout.queue ||
2798 curproxy->timeout.queue == defproxy.timeout.queue)) {
Willy Tarreau1fa31262007-12-03 00:36:16 +01002799 /* queue timeout not set. We search in the following order:
2800 * default.queue, curr.connect, default.connect.
2801 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002802 if (defproxy.timeout.queue)
Willy Tarreau1fa31262007-12-03 00:36:16 +01002803 curproxy->timeout.queue = defproxy.timeout.queue;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002804 else if (curproxy->timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01002805 curproxy->timeout.queue = curproxy->timeout.connect;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002806 else if (defproxy.timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01002807 curproxy->timeout.queue = defproxy.timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01002808 }
2809 }
2810
Willy Tarreau1620ec32011-08-06 17:05:02 +02002811 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_SSL3_CHK) {
Willy Tarreau137325d2010-02-01 16:38:17 +01002812 curproxy->check_len = sizeof(sslv3_client_hello_pkt) - 1;
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002813 curproxy->check_req = malloc(curproxy->check_len);
Willy Tarreau137325d2010-02-01 16:38:17 +01002814 memcpy(curproxy->check_req, sslv3_client_hello_pkt, curproxy->check_len);
Willy Tarreauf3c69202006-07-09 16:42:34 +02002815 }
2816
Willy Tarreau215663d2014-06-13 18:30:23 +02002817 if (!LIST_ISEMPTY(&curproxy->tcpcheck_rules) &&
2818 (curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_TCPCHK_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002819 ha_warning("config : %s '%s' uses tcp-check rules without 'option tcp-check', so the rules are ignored.\n",
2820 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau215663d2014-06-13 18:30:23 +02002821 err_code |= ERR_WARN;
2822 }
2823
Willy Tarreau193b8c62012-11-22 00:17:38 +01002824 /* ensure that cookie capture length is not too large */
2825 if (curproxy->capture_len >= global.tune.cookie_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002826 ha_warning("config : truncating capture length to %d bytes for %s '%s'.\n",
2827 global.tune.cookie_len - 1, proxy_type_str(curproxy), curproxy->id);
Willy Tarreau193b8c62012-11-22 00:17:38 +01002828 err_code |= ERR_WARN;
2829 curproxy->capture_len = global.tune.cookie_len - 1;
2830 }
2831
Willy Tarreaucf7f3202007-05-13 22:46:04 +02002832 /* The small pools required for the capture lists */
Willy Tarreau9a54e132012-03-24 08:33:05 +01002833 if (curproxy->nb_req_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02002834 curproxy->req_cap_pool = create_pool("ptrcap",
2835 curproxy->nb_req_cap * sizeof(char *),
2836 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01002837 }
2838
2839 if (curproxy->nb_rsp_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02002840 curproxy->rsp_cap_pool = create_pool("ptrcap",
2841 curproxy->nb_rsp_cap * sizeof(char *),
2842 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01002843 }
Willy Tarreaucf7f3202007-05-13 22:46:04 +02002844
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002845 switch (curproxy->load_server_state_from_file) {
2846 case PR_SRV_STATE_FILE_UNSPEC:
2847 curproxy->load_server_state_from_file = PR_SRV_STATE_FILE_NONE;
2848 break;
2849 case PR_SRV_STATE_FILE_GLOBAL:
2850 if (!global.server_state_file) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002851 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",
2852 curproxy->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02002853 err_code |= ERR_WARN;
2854 }
2855 break;
2856 }
2857
Willy Tarreaubaaee002006-06-26 02:48:02 +02002858 /* first, we will invert the servers list order */
2859 newsrv = NULL;
2860 while (curproxy->srv) {
2861 struct server *next;
2862
2863 next = curproxy->srv->next;
2864 curproxy->srv->next = newsrv;
2865 newsrv = curproxy->srv;
2866 if (!next)
2867 break;
2868 curproxy->srv = next;
2869 }
2870
Willy Tarreau17edc812014-01-03 12:14:34 +01002871 /* Check that no server name conflicts. This causes trouble in the stats.
2872 * We only emit a warning for the first conflict affecting each server,
2873 * in order to avoid combinatory explosion if all servers have the same
2874 * name. We do that only for servers which do not have an explicit ID,
2875 * because these IDs were made also for distinguishing them and we don't
2876 * want to annoy people who correctly manage them.
2877 */
2878 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
2879 struct server *other_srv;
2880
2881 if (newsrv->puid)
2882 continue;
2883
2884 for (other_srv = curproxy->srv; other_srv && other_srv != newsrv; other_srv = other_srv->next) {
2885 if (!other_srv->puid && strcmp(other_srv->id, newsrv->id) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002886 ha_warning("parsing [%s:%d] : %s '%s', another server named '%s' was defined without an explicit ID at line %d, this is not recommended.\n",
2887 newsrv->conf.file, newsrv->conf.line,
2888 proxy_type_str(curproxy), curproxy->id,
2889 newsrv->id, other_srv->conf.line);
Willy Tarreau17edc812014-01-03 12:14:34 +01002890 break;
2891 }
2892 }
2893 }
2894
Willy Tarreaudd701652010-05-25 23:03:02 +02002895 /* assign automatic UIDs to servers which don't have one yet */
2896 next_id = 1;
2897 newsrv = curproxy->srv;
2898 while (newsrv != NULL) {
2899 if (!newsrv->puid) {
2900 /* server ID not set, use automatic numbering with first
2901 * spare entry starting with next_svid.
2902 */
2903 next_id = get_next_id(&curproxy->conf.used_server_id, next_id);
2904 newsrv->conf.id.key = newsrv->puid = next_id;
2905 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
2906 }
2907 next_id++;
2908 newsrv = newsrv->next;
2909 }
2910
Willy Tarreau20697042007-11-15 23:26:18 +01002911 curproxy->lbprm.wmult = 1; /* default weight multiplier */
Willy Tarreau5dc2fa62007-11-19 19:10:18 +01002912 curproxy->lbprm.wdiv = 1; /* default weight divider */
Willy Tarreaubaaee002006-06-26 02:48:02 +02002913
Willy Tarreau62c3be22012-01-20 13:12:32 +01002914 /*
2915 * If this server supports a maxconn parameter, it needs a dedicated
2916 * tasks to fill the emptied slots when a connection leaves.
2917 * Also, resolve deferred tracking dependency if needed.
2918 */
2919 newsrv = curproxy->srv;
2920 while (newsrv != NULL) {
2921 if (newsrv->minconn > newsrv->maxconn) {
2922 /* Only 'minconn' was specified, or it was higher than or equal
2923 * to 'maxconn'. Let's turn this into maxconn and clean it, as
2924 * this will avoid further useless expensive computations.
2925 */
2926 newsrv->maxconn = newsrv->minconn;
2927 } else if (newsrv->maxconn && !newsrv->minconn) {
2928 /* minconn was not specified, so we set it to maxconn */
2929 newsrv->minconn = newsrv->maxconn;
2930 }
2931
Willy Tarreau17d45382016-12-22 21:16:08 +01002932 /* this will also properly set the transport layer for prod and checks */
2933 if (newsrv->use_ssl || newsrv->check.use_ssl) {
2934 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
2935 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(newsrv);
2936 }
Emeric Brun94324a42012-10-11 14:00:19 +02002937
Willy Tarreau2f075e92013-12-03 11:11:34 +01002938 /* set the check type on the server */
2939 newsrv->check.type = curproxy->options2 & PR_O2_CHK_ANY;
2940
Willy Tarreau62c3be22012-01-20 13:12:32 +01002941 if (newsrv->trackit) {
2942 struct proxy *px;
Willy Tarreau32091232014-05-16 13:52:00 +02002943 struct server *srv, *loop;
Willy Tarreau62c3be22012-01-20 13:12:32 +01002944 char *pname, *sname;
2945
2946 pname = newsrv->trackit;
2947 sname = strrchr(pname, '/');
2948
2949 if (sname)
2950 *sname++ = '\0';
2951 else {
2952 sname = pname;
2953 pname = NULL;
2954 }
2955
2956 if (pname) {
Willy Tarreau9e0bb102015-05-26 11:24:42 +02002957 px = proxy_be_by_name(pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002958 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002959 ha_alert("config : %s '%s', server '%s': unable to find required proxy '%s' for tracking.\n",
2960 proxy_type_str(curproxy), curproxy->id,
2961 newsrv->id, pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002962 cfgerr++;
2963 goto next_srv;
2964 }
2965 } else
2966 px = curproxy;
2967
2968 srv = findserver(px, sname);
2969 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002970 ha_alert("config : %s '%s', server '%s': unable to find required server '%s' for tracking.\n",
2971 proxy_type_str(curproxy), curproxy->id,
2972 newsrv->id, sname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002973 cfgerr++;
2974 goto next_srv;
2975 }
2976
Willy Tarreau32091232014-05-16 13:52:00 +02002977 if (!(srv->check.state & CHK_ST_CONFIGURED) &&
2978 !(srv->agent.state & CHK_ST_CONFIGURED) &&
2979 !srv->track && !srv->trackit) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002980 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for "
2981 "tracking as it does not have any check nor agent enabled.\n",
2982 proxy_type_str(curproxy), curproxy->id,
2983 newsrv->id, px->id, srv->id);
Willy Tarreau32091232014-05-16 13:52:00 +02002984 cfgerr++;
2985 goto next_srv;
2986 }
2987
2988 for (loop = srv->track; loop && loop != newsrv; loop = loop->track);
2989
Frédéric Lécaille2efc6492017-03-14 14:32:17 +01002990 if (newsrv == srv || loop) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002991 ha_alert("config : %s '%s', server '%s': unable to track %s/%s as it "
2992 "belongs to a tracking chain looping back to %s/%s.\n",
2993 proxy_type_str(curproxy), curproxy->id,
2994 newsrv->id, px->id, srv->id, px->id,
2995 newsrv == srv ? srv->id : loop->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01002996 cfgerr++;
2997 goto next_srv;
2998 }
2999
3000 if (curproxy != px &&
3001 (curproxy->options & PR_O_DISABLE404) != (px->options & PR_O_DISABLE404)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003002 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for"
3003 "tracking: disable-on-404 option inconsistency.\n",
3004 proxy_type_str(curproxy), curproxy->id,
3005 newsrv->id, px->id, srv->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003006 cfgerr++;
3007 goto next_srv;
3008 }
3009
Willy Tarreau62c3be22012-01-20 13:12:32 +01003010 newsrv->track = srv;
Willy Tarreau1a53a3a2013-12-11 15:27:05 +01003011 newsrv->tracknext = srv->trackers;
3012 srv->trackers = newsrv;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003013
3014 free(newsrv->trackit);
3015 newsrv->trackit = NULL;
3016 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003017
Willy Tarreau62c3be22012-01-20 13:12:32 +01003018 next_srv:
3019 newsrv = newsrv->next;
3020 }
3021
Olivier Houchard4e694042017-03-14 20:01:29 +01003022 /*
3023 * Try to generate dynamic cookies for servers now.
3024 * It couldn't be done earlier, since at the time we parsed
3025 * the server line, we may not have known yet that we
3026 * should use dynamic cookies, or the secret key may not
3027 * have been provided yet.
3028 */
3029 if (curproxy->ck_opts & PR_CK_DYNAMIC) {
3030 newsrv = curproxy->srv;
3031 while (newsrv != NULL) {
3032 srv_set_dyncookie(newsrv);
3033 newsrv = newsrv->next;
3034 }
3035
3036 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003037 /* We have to initialize the server lookup mechanism depending
Joseph Herlanta14c03e2018-11-15 14:04:19 -08003038 * on what LB algorithm was chosen.
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003039 */
3040
3041 curproxy->lbprm.algo &= ~(BE_LB_LKUP | BE_LB_PROP_DYN);
3042 switch (curproxy->lbprm.algo & BE_LB_KIND) {
3043 case BE_LB_KIND_RR:
Willy Tarreau9757a382009-10-03 12:56:50 +02003044 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_STATIC) {
3045 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3046 init_server_map(curproxy);
Willy Tarreau760e81d2018-05-03 07:20:40 +02003047 } else if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_RANDOM) {
3048 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3049 chash_init_server_tree(curproxy);
Willy Tarreau9757a382009-10-03 12:56:50 +02003050 } else {
3051 curproxy->lbprm.algo |= BE_LB_LKUP_RRTREE | BE_LB_PROP_DYN;
3052 fwrr_init_server_groups(curproxy);
3053 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003054 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003055
Willy Tarreau3ebb1162012-02-13 16:57:44 +01003056 case BE_LB_KIND_CB:
Willy Tarreauf09c6602012-02-13 17:12:08 +01003057 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_CB_LC) {
3058 curproxy->lbprm.algo |= BE_LB_LKUP_LCTREE | BE_LB_PROP_DYN;
3059 fwlc_init_server_tree(curproxy);
3060 } else {
3061 curproxy->lbprm.algo |= BE_LB_LKUP_FSTREE | BE_LB_PROP_DYN;
3062 fas_init_server_tree(curproxy);
3063 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003064 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003065
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003066 case BE_LB_KIND_HI:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003067 if ((curproxy->lbprm.algo & BE_LB_HASH_TYPE) == BE_LB_HASH_CONS) {
3068 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3069 chash_init_server_tree(curproxy);
3070 } else {
3071 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3072 init_server_map(curproxy);
3073 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003074 break;
3075 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003076 HA_SPIN_INIT(&curproxy->lbprm.lock);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003077
3078 if (curproxy->options & PR_O_LOGASAP)
3079 curproxy->to_log &= ~LW_BYTES;
3080
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003081 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003082 (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->logsrvs) &&
3083 (!LIST_ISEMPTY(&curproxy->logformat) || !LIST_ISEMPTY(&curproxy->logformat_sd))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003084 ha_warning("config : log format ignored for %s '%s' since it has no log address.\n",
3085 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003086 err_code |= ERR_WARN;
3087 }
3088
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003089 if (curproxy->mode != PR_MODE_HTTP) {
3090 int optnum;
3091
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003092 if (curproxy->uri_auth) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003093 ha_warning("config : 'stats' statement ignored for %s '%s' as it requires HTTP mode.\n",
3094 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003095 err_code |= ERR_WARN;
3096 curproxy->uri_auth = NULL;
3097 }
3098
Willy Tarreaude7dc882017-03-10 11:49:21 +01003099 if (curproxy->capture_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003100 ha_warning("config : 'capture' statement ignored for %s '%s' as it requires HTTP mode.\n",
3101 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003102 err_code |= ERR_WARN;
3103 }
3104
3105 if (!LIST_ISEMPTY(&curproxy->http_req_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003106 ha_warning("config : 'http-request' rules ignored for %s '%s' as they require HTTP mode.\n",
3107 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003108 err_code |= ERR_WARN;
3109 }
3110
3111 if (!LIST_ISEMPTY(&curproxy->http_res_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003112 ha_warning("config : 'http-response' rules ignored for %s '%s' as they require HTTP mode.\n",
3113 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003114 err_code |= ERR_WARN;
3115 }
3116
3117 if (!LIST_ISEMPTY(&curproxy->block_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003118 ha_warning("config : 'block' rules ignored for %s '%s' as they require HTTP mode.\n",
3119 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003120 err_code |= ERR_WARN;
3121 }
3122
3123 if (!LIST_ISEMPTY(&curproxy->redirect_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003124 ha_warning("config : 'redirect' rules ignored for %s '%s' as they require HTTP mode.\n",
3125 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003126 err_code |= ERR_WARN;
3127 }
3128
Willy Tarreau87cf5142011-08-19 22:57:24 +02003129 if (curproxy->options & (PR_O_FWDFOR | PR_O_FF_ALWAYS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003130 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3131 "forwardfor", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003132 err_code |= ERR_WARN;
Willy Tarreau87cf5142011-08-19 22:57:24 +02003133 curproxy->options &= ~(PR_O_FWDFOR | PR_O_FF_ALWAYS);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003134 }
3135
3136 if (curproxy->options & PR_O_ORGTO) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003137 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3138 "originalto", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003139 err_code |= ERR_WARN;
3140 curproxy->options &= ~PR_O_ORGTO;
3141 }
3142
3143 for (optnum = 0; cfg_opts[optnum].name; optnum++) {
3144 if (cfg_opts[optnum].mode == PR_MODE_HTTP &&
3145 (curproxy->cap & cfg_opts[optnum].cap) &&
3146 (curproxy->options & cfg_opts[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003147 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3148 cfg_opts[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003149 err_code |= ERR_WARN;
3150 curproxy->options &= ~cfg_opts[optnum].val;
3151 }
3152 }
3153
3154 for (optnum = 0; cfg_opts2[optnum].name; optnum++) {
3155 if (cfg_opts2[optnum].mode == PR_MODE_HTTP &&
3156 (curproxy->cap & cfg_opts2[optnum].cap) &&
3157 (curproxy->options2 & cfg_opts2[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003158 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3159 cfg_opts2[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003160 err_code |= ERR_WARN;
3161 curproxy->options2 &= ~cfg_opts2[optnum].val;
3162 }
3163 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003164
Willy Tarreau29fbe512015-08-20 19:35:14 +02003165#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003166 if (curproxy->conn_src.bind_hdr_occ) {
3167 curproxy->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003168 ha_warning("config : %s '%s' : ignoring use of header %s as source IP in non-HTTP mode.\n",
3169 proxy_type_str(curproxy), curproxy->id, curproxy->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003170 err_code |= ERR_WARN;
3171 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003172#endif
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003173 }
3174
Willy Tarreaubaaee002006-06-26 02:48:02 +02003175 /*
Willy Tarreau21d2af32008-02-14 20:25:24 +01003176 * ensure that we're not cross-dressing a TCP server into HTTP.
3177 */
3178 newsrv = curproxy->srv;
3179 while (newsrv != NULL) {
Willy Tarreau0cec3312011-10-31 13:49:26 +01003180 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->rdr_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003181 ha_alert("config : %s '%s' : server cannot have cookie or redirect prefix in non-HTTP mode.\n",
3182 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003183 cfgerr++;
Willy Tarreau21d2af32008-02-14 20:25:24 +01003184 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003185
Willy Tarreau0cec3312011-10-31 13:49:26 +01003186 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->cklen) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003187 ha_warning("config : %s '%s' : ignoring cookie for server '%s' as HTTP mode is disabled.\n",
3188 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau0cec3312011-10-31 13:49:26 +01003189 err_code |= ERR_WARN;
3190 }
3191
Willy Tarreauc93cd162014-05-13 15:54:22 +02003192 if ((newsrv->flags & SRV_F_MAPPORTS) && (curproxy->options2 & PR_O2_RDPC_PRST)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003193 ha_warning("config : %s '%s' : RDP cookie persistence will not work for server '%s' because it lacks an explicit port number.\n",
3194 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau82ffa392013-08-13 17:19:08 +02003195 err_code |= ERR_WARN;
3196 }
3197
Willy Tarreau29fbe512015-08-20 19:35:14 +02003198#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003199 if (curproxy->mode != PR_MODE_HTTP && newsrv->conn_src.bind_hdr_occ) {
3200 newsrv->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003201 ha_warning("config : %s '%s' : server %s cannot use header %s as source IP in non-HTTP mode.\n",
3202 proxy_type_str(curproxy), curproxy->id, newsrv->id, newsrv->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003203 err_code |= ERR_WARN;
3204 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003205#endif
Willy Tarreau4c183462017-01-06 12:21:38 +01003206
Willy Tarreau46deab62018-04-28 07:18:15 +02003207 if ((curproxy->mode != PR_MODE_HTTP) && (curproxy->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR)
3208 curproxy->options &= ~PR_O_REUSE_MASK;
3209
Willy Tarreau4c183462017-01-06 12:21:38 +01003210 if ((curproxy->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR) {
3211 if ((curproxy->conn_src.opts & CO_SRC_TPROXY_MASK) == CO_SRC_TPROXY_CLI ||
3212 (curproxy->conn_src.opts & CO_SRC_TPROXY_MASK) == CO_SRC_TPROXY_CIP ||
3213 (newsrv->conn_src.opts & CO_SRC_TPROXY_MASK) == CO_SRC_TPROXY_CLI ||
3214 (newsrv->conn_src.opts & CO_SRC_TPROXY_MASK) == CO_SRC_TPROXY_CIP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003215 ha_warning("config : %s '%s' : connections to server '%s' use the client's IP address as the source while http-reuse is enabled and allows the same connection to be shared between multiple clients. It is strongly advised to disable 'usesrc' and to use the 'forwardfor' option instead.\n",
3216 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau4c183462017-01-06 12:21:38 +01003217 err_code |= ERR_WARN;
3218 }
3219
3220
3221 if (newsrv->pp_opts & (SRV_PP_V1|SRV_PP_V2)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003222 ha_warning("config : %s '%s' : connections to server '%s' will have a PROXY protocol header announcing the first client's IP address while http-reuse is enabled and allows the same connection to be shared between multiple clients. It is strongly advised to disable 'send-proxy' and to use the 'forwardfor' option instead.\n",
3223 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau4c183462017-01-06 12:21:38 +01003224 err_code |= ERR_WARN;
3225 }
3226 }
3227
Willy Tarreau21d2af32008-02-14 20:25:24 +01003228 newsrv = newsrv->next;
3229 }
3230
Willy Tarreaue42bd962014-09-16 16:21:19 +02003231 /* check if we have a frontend with "tcp-request content" looking at L7
3232 * with no inspect-delay
3233 */
3234 if ((curproxy->cap & PR_CAP_FE) && !curproxy->tcp_req.inspect_delay) {
Christopher Faulete4e830d2017-09-18 14:51:41 +02003235 list_for_each_entry(arule, &curproxy->tcp_req.inspect_rules, list) {
3236 if (arule->action == ACT_TCP_CAPTURE &&
3237 !(arule->arg.cap.expr->fetch->val & SMP_VAL_FE_SES_ACC))
Willy Tarreaue42bd962014-09-16 16:21:19 +02003238 break;
Christopher Faulete4e830d2017-09-18 14:51:41 +02003239 if ((arule->action >= ACT_ACTION_TRK_SC0 && arule->action <= ACT_ACTION_TRK_SCMAX) &&
3240 !(arule->arg.trk_ctr.expr->fetch->val & SMP_VAL_FE_SES_ACC))
Willy Tarreaue42bd962014-09-16 16:21:19 +02003241 break;
3242 }
3243
Christopher Faulete4e830d2017-09-18 14:51:41 +02003244 if (&arule->list != &curproxy->tcp_req.inspect_rules) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003245 ha_warning("config : %s '%s' : some 'tcp-request content' rules explicitly depending on request"
3246 " contents were found in a frontend without any 'tcp-request inspect-delay' setting."
3247 " This means that these rules will randomly find their contents. This can be fixed by"
3248 " setting the tcp-request inspect-delay.\n",
3249 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue42bd962014-09-16 16:21:19 +02003250 err_code |= ERR_WARN;
3251 }
3252 }
3253
Christopher Fauletd7c91962015-04-30 11:48:27 +02003254 /* Check filter configuration, if any */
3255 cfgerr += flt_check(curproxy);
3256
Willy Tarreauc1a21672009-08-16 22:37:44 +02003257 if (curproxy->cap & PR_CAP_FE) {
Willy Tarreau050536d2012-10-04 08:47:34 +02003258 if (!curproxy->accept)
3259 curproxy->accept = frontend_accept;
Willy Tarreau81f9aa32010-06-01 17:45:26 +02003260
Willy Tarreauc1a21672009-08-16 22:37:44 +02003261 if (curproxy->tcp_req.inspect_delay ||
3262 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
Willy Tarreaufb356202010-08-03 14:02:05 +02003263 curproxy->fe_req_ana |= AN_REQ_INSPECT_FE;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003264
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003265 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003266 curproxy->fe_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_PROCESS_FE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003267 curproxy->fe_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_FE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003268 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003269
William Lallemandcf62f7e2018-10-26 14:47:40 +02003270 if (curproxy->mode == PR_MODE_CLI) {
3271 curproxy->fe_req_ana |= AN_REQ_WAIT_CLI;
3272 curproxy->fe_rsp_ana |= AN_RES_WAIT_CLI;
3273 }
3274
Willy Tarreauc1a21672009-08-16 22:37:44 +02003275 /* both TCP and HTTP must check switching rules */
3276 curproxy->fe_req_ana |= AN_REQ_SWITCHING_RULES;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003277
3278 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003279 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003280 curproxy->fe_req_ana |= AN_REQ_FLT_START_FE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3281 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 +01003282 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003283 curproxy->fe_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3284 curproxy->fe_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003285 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003286 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003287 }
3288
3289 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreaufb356202010-08-03 14:02:05 +02003290 if (curproxy->tcp_req.inspect_delay ||
3291 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
3292 curproxy->be_req_ana |= AN_REQ_INSPECT_BE;
3293
Emeric Brun97679e72010-09-23 17:56:44 +02003294 if (!LIST_ISEMPTY(&curproxy->tcp_rep.inspect_rules))
3295 curproxy->be_rsp_ana |= AN_RES_INSPECT;
3296
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003297 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003298 curproxy->be_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_INNER | AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003299 curproxy->be_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_BE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003300 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003301
3302 /* If the backend does requires RDP cookie persistence, we have to
3303 * enable the corresponding analyser.
3304 */
3305 if (curproxy->options2 & PR_O2_RDPC_PRST)
3306 curproxy->be_req_ana |= AN_REQ_PRST_RDP_COOKIE;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003307
3308 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003309 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003310 curproxy->be_req_ana |= AN_REQ_FLT_START_BE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3311 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 +01003312 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003313 curproxy->be_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3314 curproxy->be_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003315 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003316 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003317 }
Christopher Fauleta717b992018-04-10 14:43:00 +02003318
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003319 /* Check the mux protocols, if any, for each listener and server
Christopher Fauleta717b992018-04-10 14:43:00 +02003320 * attached to the current proxy */
3321 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3322 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
3323
Christopher Faulet7ff4f142018-11-20 11:23:52 +01003324 /* Special case for HTX because it is still experimental */
3325 if (curproxy->options2 & PR_O2_USE_HTX)
3326 mode = PROTO_MODE_HTX;
3327
Christopher Fauleta717b992018-04-10 14:43:00 +02003328 if (!bind_conf->mux_proto)
3329 continue;
3330 if (!(bind_conf->mux_proto->mode & mode)) {
3331 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for 'bind %s' at [%s:%d].\n",
3332 proxy_type_str(curproxy), curproxy->id,
3333 (int)bind_conf->mux_proto->token.len,
3334 bind_conf->mux_proto->token.ptr,
3335 bind_conf->arg, bind_conf->file, bind_conf->line);
3336 cfgerr++;
3337 }
3338 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003339 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3340 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
3341
Christopher Faulet7ff4f142018-11-20 11:23:52 +01003342 /* Special case for HTX because it is still experimental */
3343 if (curproxy->options2 & PR_O2_USE_HTX)
3344 mode = PROTO_MODE_HTX;
3345
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003346 if (!newsrv->mux_proto)
3347 continue;
3348 if (!(newsrv->mux_proto->mode & mode)) {
3349 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for server '%s' at [%s:%d].\n",
3350 proxy_type_str(curproxy), curproxy->id,
3351 (int)newsrv->mux_proto->token.len,
3352 newsrv->mux_proto->token.ptr,
3353 newsrv->id, newsrv->conf.file, newsrv->conf.line);
3354 cfgerr++;
3355 }
3356 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003357 }
3358
3359 /***********************************************************/
3360 /* At this point, target names have already been resolved. */
3361 /***********************************************************/
3362
3363 /* Check multi-process mode compatibility */
3364
3365 if (global.nbproc > 1 && global.stats_fe) {
3366 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3367 unsigned long mask;
3368
3369 mask = nbits(global.nbproc);
3370 if (global.stats_fe->bind_proc)
3371 mask &= global.stats_fe->bind_proc;
3372
3373 if (bind_conf->bind_proc)
3374 mask &= bind_conf->bind_proc;
3375
3376 /* stop here if more than one process is used */
Willy Tarreau9504dd62018-10-15 09:37:03 +02003377 if (atleast2(mask))
Willy Tarreau419ead82014-09-16 13:41:21 +02003378 break;
3379 }
3380 if (&bind_conf->by_fe != &global.stats_fe->conf.bind) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003381 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 +02003382 }
3383 }
3384
3385 /* Make each frontend inherit bind-process from its listeners when not specified. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003386 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003387 if (curproxy->bind_proc)
3388 continue;
3389
3390 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3391 unsigned long mask;
3392
Willy Tarreaue428b082015-05-04 21:57:58 +02003393 mask = bind_conf->bind_proc ? bind_conf->bind_proc : nbits(global.nbproc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003394 curproxy->bind_proc |= mask;
3395 }
3396
3397 if (!curproxy->bind_proc)
Willy Tarreaue428b082015-05-04 21:57:58 +02003398 curproxy->bind_proc = nbits(global.nbproc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003399 }
3400
3401 if (global.stats_fe) {
3402 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3403 unsigned long mask;
3404
Cyril Bonté06181952016-02-24 00:14:54 +01003405 mask = bind_conf->bind_proc ? bind_conf->bind_proc : 0;
Willy Tarreau419ead82014-09-16 13:41:21 +02003406 global.stats_fe->bind_proc |= mask;
3407 }
3408 if (!global.stats_fe->bind_proc)
Willy Tarreaue428b082015-05-04 21:57:58 +02003409 global.stats_fe->bind_proc = nbits(global.nbproc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003410 }
3411
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003412 /* propagate bindings from frontends to backends. Don't do it if there
3413 * are any fatal errors as we must not call it with unresolved proxies.
3414 */
3415 if (!cfgerr) {
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003416 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003417 if (curproxy->cap & PR_CAP_FE)
3418 propagate_processes(curproxy, NULL);
3419 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003420 }
3421
3422 /* Bind each unbound backend to all processes when not specified. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003423 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003424 if (curproxy->bind_proc)
3425 continue;
Willy Tarreaue428b082015-05-04 21:57:58 +02003426 curproxy->bind_proc = nbits(global.nbproc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003427 }
3428
3429 /*******************************************************/
3430 /* At this step, all proxies have a non-null bind_proc */
3431 /*******************************************************/
3432
3433 /* perform the final checks before creating tasks */
3434
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003435 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003436 struct listener *listener;
3437 unsigned int next_id;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003438
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003439 /* Configure SSL for each bind line.
3440 * Note: if configuration fails at some point, the ->ctx member
3441 * remains NULL so that listeners can later detach.
3442 */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003443 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau55d37912016-12-21 23:38:39 +01003444 if (bind_conf->xprt->prepare_bind_conf &&
3445 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003446 cfgerr++;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003447 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003448
Willy Tarreaue6b98942007-10-29 01:09:36 +01003449 /* adjust this proxy's listeners */
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003450 next_id = 1;
Willy Tarreau4348fad2012-09-20 16:48:07 +02003451 list_for_each_entry(listener, &curproxy->conf.listeners, by_fe) {
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003452 int nbproc;
3453
3454 nbproc = my_popcountl(curproxy->bind_proc &
Cyril Bonté4920d702016-04-15 07:58:43 +02003455 (listener->bind_conf->bind_proc ? listener->bind_conf->bind_proc : curproxy->bind_proc) &
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003456 nbits(global.nbproc));
3457
3458 if (!nbproc) /* no intersection between listener and frontend */
3459 nbproc = 1;
3460
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003461 if (!listener->luid) {
3462 /* listener ID not set, use automatic numbering with first
3463 * spare entry starting with next_luid.
3464 */
3465 next_id = get_next_id(&curproxy->conf.used_listener_id, next_id);
3466 listener->conf.id.key = listener->luid = next_id;
3467 eb32_insert(&curproxy->conf.used_listener_id, &listener->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003468 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01003469 next_id++;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003470
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003471 /* enable separate counters */
3472 if (curproxy->options2 & PR_O2_SOCKSTAT) {
Willy Tarreauae9bea02016-11-25 14:44:52 +01003473 listener->counters = calloc(1, sizeof(*listener->counters));
Willy Tarreau19d14ef2012-10-29 16:51:55 +01003474 if (!listener->name)
3475 memprintf(&listener->name, "sock-%d", listener->luid);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003476 }
Willy Tarreau81796be2012-09-22 19:11:47 +02003477
Willy Tarreaue6b98942007-10-29 01:09:36 +01003478 if (curproxy->options & PR_O_TCP_NOLING)
3479 listener->options |= LI_O_NOLINGER;
Willy Tarreau32368ce2012-09-06 11:10:55 +02003480 if (!listener->maxconn)
3481 listener->maxconn = curproxy->maxconn;
3482 if (!listener->backlog)
3483 listener->backlog = curproxy->backlog;
Willy Tarreau16a21472012-11-19 12:39:59 +01003484 if (!listener->maxaccept)
3485 listener->maxaccept = global.tune.maxaccept ? global.tune.maxaccept : 64;
3486
3487 /* we want to have an optimal behaviour on single process mode to
3488 * maximize the work at once, but in multi-process we want to keep
3489 * some fairness between processes, so we target half of the max
3490 * number of events to be balanced over all the processes the proxy
3491 * is bound to. Rememeber that maxaccept = -1 must be kept as it is
3492 * used to disable the limit.
3493 */
3494 if (listener->maxaccept > 0) {
3495 if (nbproc > 1)
3496 listener->maxaccept = (listener->maxaccept + 1) / 2;
3497 listener->maxaccept = (listener->maxaccept + nbproc - 1) / nbproc;
3498 }
3499
Willy Tarreau9903f0e2015-04-04 18:50:31 +02003500 listener->accept = session_accept_fd;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003501 listener->analysers |= curproxy->fe_req_ana;
Willy Tarreau10b688f2015-03-13 16:43:12 +01003502 listener->default_target = curproxy->default_target;
Willy Tarreau3bc13772008-12-07 11:50:35 +01003503
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003504 if (!LIST_ISEMPTY(&curproxy->tcp_req.l4_rules))
Willy Tarreau7d9736f2016-10-21 16:34:21 +02003505 listener->options |= LI_O_TCP_L4_RULES;
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003506
Willy Tarreau620408f2016-10-21 16:37:51 +02003507 if (!LIST_ISEMPTY(&curproxy->tcp_req.l5_rules))
3508 listener->options |= LI_O_TCP_L5_RULES;
3509
Willy Tarreaude3041d2010-05-31 10:56:17 +02003510 if (curproxy->mon_mask.s_addr)
3511 listener->options |= LI_O_CHK_MONNET;
3512
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003513 /* smart accept mode is automatic in HTTP mode */
3514 if ((curproxy->options2 & PR_O2_SMARTACC) ||
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003515 ((curproxy->mode == PR_MODE_HTTP || listener->bind_conf->is_ssl) &&
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003516 !(curproxy->no_options2 & PR_O2_SMARTACC)))
3517 listener->options |= LI_O_NOQUICKACK;
Willy Tarreaue6b98942007-10-29 01:09:36 +01003518 }
3519
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003520 /* Release unused SSL configs */
3521 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau795cdab2016-12-22 17:30:54 +01003522 if (!bind_conf->is_ssl && bind_conf->xprt->destroy_bind_conf)
3523 bind_conf->xprt->destroy_bind_conf(bind_conf);
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003524 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003525
Willy Tarreau9504dd62018-10-15 09:37:03 +02003526 if (atleast2(curproxy->bind_proc & nbits(global.nbproc))) {
Willy Tarreau102df612014-05-07 23:56:38 +02003527 if (curproxy->uri_auth) {
Willy Tarreaueb791e02014-09-16 15:11:04 +02003528 int count, maxproc = 0;
3529
3530 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
David Carliere6c39412015-07-02 07:00:17 +00003531 count = my_popcountl(bind_conf->bind_proc);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003532 if (count > maxproc)
3533 maxproc = count;
3534 }
3535 /* backends have 0, frontends have 1 or more */
3536 if (maxproc != 1)
Christopher Faulet767a84b2017-11-24 16:50:31 +01003537 ha_warning("Proxy '%s': in multi-process mode, stats will be"
3538 " limited to process assigned to the current request.\n",
3539 curproxy->id);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003540
Willy Tarreau102df612014-05-07 23:56:38 +02003541 if (!LIST_ISEMPTY(&curproxy->uri_auth->admin_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003542 ha_warning("Proxy '%s': stats admin will not work correctly in multi-process mode.\n",
3543 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003544 }
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003545 }
Willy Tarreau102df612014-05-07 23:56:38 +02003546 if (!LIST_ISEMPTY(&curproxy->sticking_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003547 ha_warning("Proxy '%s': sticking rules will not work correctly in multi-process mode.\n",
3548 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003549 }
3550 }
Willy Tarreau918ff602011-07-25 16:33:49 +02003551
3552 /* create the task associated with the proxy */
Emeric Brunc60def82017-09-27 14:59:38 +02003553 curproxy->task = task_new(MAX_THREADS_MASK);
Willy Tarreau918ff602011-07-25 16:33:49 +02003554 if (curproxy->task) {
3555 curproxy->task->context = curproxy;
3556 curproxy->task->process = manage_proxy;
Willy Tarreau918ff602011-07-25 16:33:49 +02003557 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003558 ha_alert("Proxy '%s': no more memory when trying to allocate the management task\n",
3559 curproxy->id);
Willy Tarreau918ff602011-07-25 16:33:49 +02003560 cfgerr++;
3561 }
Willy Tarreaub369a042014-09-16 13:21:03 +02003562 }
3563
Willy Tarreaufbb78422011-06-05 15:38:35 +02003564 /* automatically compute fullconn if not set. We must not do it in the
3565 * loop above because cross-references are not yet fully resolved.
3566 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003567 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreaufbb78422011-06-05 15:38:35 +02003568 /* If <fullconn> is not set, let's set it to 10% of the sum of
3569 * the possible incoming frontend's maxconns.
3570 */
3571 if (!curproxy->fullconn && (curproxy->cap & PR_CAP_BE)) {
Willy Tarreaufbb78422011-06-05 15:38:35 +02003572 /* we have the sum of the maxconns in <total>. We only
3573 * keep 10% of that sum to set the default fullconn, with
3574 * a hard minimum of 1 (to avoid a divide by zero).
3575 */
Emeric Brun3f783572017-01-12 11:21:28 +01003576 curproxy->fullconn = (curproxy->tot_fe_maxconn + 9) / 10;
Willy Tarreaufbb78422011-06-05 15:38:35 +02003577 if (!curproxy->fullconn)
3578 curproxy->fullconn = 1;
3579 }
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01003580 }
3581
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003582 /*
3583 * Recount currently required checks.
3584 */
3585
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003586 for (curproxy=proxies_list; curproxy; curproxy=curproxy->next) {
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003587 int optnum;
3588
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003589 for (optnum = 0; cfg_opts[optnum].name; optnum++)
3590 if (curproxy->options & cfg_opts[optnum].val)
3591 global.last_checks |= cfg_opts[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003592
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003593 for (optnum = 0; cfg_opts2[optnum].name; optnum++)
3594 if (curproxy->options2 & cfg_opts2[optnum].val)
3595 global.last_checks |= cfg_opts2[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003596 }
3597
Willy Tarreau0fca4832015-05-01 19:12:05 +02003598 /* compute the required process bindings for the peers */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003599 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
Willy Tarreau0fca4832015-05-01 19:12:05 +02003600 if (curproxy->table.peers.p)
3601 curproxy->table.peers.p->peers_fe->bind_proc |= curproxy->bind_proc;
3602
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003603 if (cfg_peers) {
3604 struct peers *curpeers = cfg_peers, **last;
Willy Tarreau122541c2011-09-07 21:24:49 +02003605 struct peer *p, *pb;
3606
Willy Tarreau1e273012015-05-01 19:15:17 +02003607 /* Remove all peers sections which don't have a valid listener,
3608 * which are not used by any table, or which are bound to more
3609 * than one process.
Willy Tarreau122541c2011-09-07 21:24:49 +02003610 */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003611 last = &cfg_peers;
Willy Tarreau122541c2011-09-07 21:24:49 +02003612 while (*last) {
3613 curpeers = *last;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003614
3615 if (curpeers->state == PR_STSTOPPED) {
3616 /* the "disabled" keyword was present */
3617 if (curpeers->peers_fe)
3618 stop_proxy(curpeers->peers_fe);
3619 curpeers->peers_fe = NULL;
3620 }
3621 else if (!curpeers->peers_fe) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003622 ha_warning("Removing incomplete section 'peers %s' (no peer named '%s').\n",
3623 curpeers->id, localpeer);
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003624 }
Willy Tarreau9504dd62018-10-15 09:37:03 +02003625 else if (atleast2(curpeers->peers_fe->bind_proc)) {
Willy Tarreau1e273012015-05-01 19:15:17 +02003626 /* either it's totally stopped or too much used */
3627 if (curpeers->peers_fe->bind_proc) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003628 ha_alert("Peers section '%s': peers referenced by sections "
3629 "running in different processes (%d different ones). "
3630 "Check global.nbproc and all tables' bind-process "
3631 "settings.\n", curpeers->id, my_popcountl(curpeers->peers_fe->bind_proc));
Willy Tarreau1e273012015-05-01 19:15:17 +02003632 cfgerr++;
3633 }
3634 stop_proxy(curpeers->peers_fe);
3635 curpeers->peers_fe = NULL;
3636 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003637 else {
Willy Tarreaud9443442018-10-15 11:18:03 +02003638 if (!peers_init_sync(curpeers)) {
3639 ha_alert("Peers section '%s': out of memory, giving up on peers.\n",
3640 curpeers->id);
3641 cfgerr++;
3642 break;
3643 }
Willy Tarreau122541c2011-09-07 21:24:49 +02003644 last = &curpeers->next;
3645 continue;
3646 }
3647
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003648 /* clean what has been detected above */
Willy Tarreau122541c2011-09-07 21:24:49 +02003649 p = curpeers->remote;
3650 while (p) {
3651 pb = p->next;
3652 free(p->id);
3653 free(p);
3654 p = pb;
3655 }
3656
3657 /* Destroy and unlink this curpeers section.
3658 * Note: curpeers is backed up into *last.
3659 */
3660 free(curpeers->id);
3661 curpeers = curpeers->next;
3662 free(*last);
3663 *last = curpeers;
3664 }
3665 }
3666
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003667 /* initialize stick-tables on backend capable proxies. This must not
3668 * be done earlier because the data size may be discovered while parsing
3669 * other proxies.
3670 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003671 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003672 if (curproxy->state == PR_STSTOPPED)
3673 continue;
3674
3675 if (!stktable_init(&curproxy->table)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003676 ha_alert("Proxy '%s': failed to initialize stick-table.\n", curproxy->id);
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003677 cfgerr++;
3678 }
3679 }
3680
Simon Horman0d16a402015-01-30 11:22:58 +09003681 if (mailers) {
3682 struct mailers *curmailers = mailers, **last;
3683 struct mailer *m, *mb;
3684
3685 /* Remove all mailers sections which don't have a valid listener.
3686 * This can happen when a mailers section is never referenced.
3687 */
3688 last = &mailers;
3689 while (*last) {
3690 curmailers = *last;
3691 if (curmailers->users) {
3692 last = &curmailers->next;
3693 continue;
3694 }
3695
Christopher Faulet767a84b2017-11-24 16:50:31 +01003696 ha_warning("Removing incomplete section 'mailers %s'.\n",
3697 curmailers->id);
Simon Horman0d16a402015-01-30 11:22:58 +09003698
3699 m = curmailers->mailer_list;
3700 while (m) {
3701 mb = m->next;
3702 free(m->id);
3703 free(m);
3704 m = mb;
3705 }
3706
3707 /* Destroy and unlink this curmailers section.
3708 * Note: curmailers is backed up into *last.
3709 */
3710 free(curmailers->id);
3711 curmailers = curmailers->next;
3712 free(*last);
3713 *last = curmailers;
3714 }
3715 }
3716
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003717 /* Update server_state_file_name to backend name if backend is supposed to use
3718 * a server-state file locally defined and none has been provided */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003719 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003720 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_LOCAL &&
3721 curproxy->server_state_file_name == NULL)
3722 curproxy->server_state_file_name = strdup(curproxy->id);
3723 }
3724
Willy Tarreaubafbe012017-11-24 17:34:44 +01003725 pool_head_hdr_idx = create_pool("hdr_idx",
Willy Tarreauac1932d2011-10-24 19:14:41 +02003726 global.tune.max_http_hdr * sizeof(struct hdr_idx_elem),
Willy Tarreau34eb6712011-10-24 18:15:04 +02003727 MEM_F_SHARED);
3728
Ben Draut054fbee2018-04-13 15:43:04 -06003729 list_for_each_entry(curr_resolvers, &dns_resolvers, list) {
3730 if (LIST_ISEMPTY(&curr_resolvers->nameservers)) {
3731 ha_warning("config : resolvers '%s' [%s:%d] has no nameservers configured!\n",
3732 curr_resolvers->id, curr_resolvers->conf.file,
3733 curr_resolvers->conf.line);
3734 err_code |= ERR_WARN;
3735 }
3736 }
3737
William Lallemand48b4bb42017-10-23 14:36:34 +02003738 list_for_each_entry(postparser, &postparsers, list) {
3739 if (postparser->func)
3740 cfgerr += postparser->func();
3741 }
3742
Willy Tarreaubb925012009-07-23 13:36:36 +02003743 if (cfgerr > 0)
3744 err_code |= ERR_ALERT | ERR_FATAL;
3745 out:
3746 return err_code;
Willy Tarreaubaaee002006-06-26 02:48:02 +02003747}
3748
Willy Tarreau5b2c3362008-07-09 19:39:06 +02003749/*
3750 * Registers the CFG keyword list <kwl> as a list of valid keywords for next
3751 * parsing sessions.
3752 */
3753void cfg_register_keywords(struct cfg_kw_list *kwl)
3754{
3755 LIST_ADDQ(&cfg_keywords.list, &kwl->list);
3756}
Willy Tarreaubaaee002006-06-26 02:48:02 +02003757
Willy Tarreau5b2c3362008-07-09 19:39:06 +02003758/*
3759 * Unregisters the CFG keyword list <kwl> from the list of valid keywords.
3760 */
3761void cfg_unregister_keywords(struct cfg_kw_list *kwl)
3762{
3763 LIST_DEL(&kwl->list);
3764 LIST_INIT(&kwl->list);
3765}
Willy Tarreaubaaee002006-06-26 02:48:02 +02003766
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003767/* this function register new section in the haproxy configuration file.
3768 * <section_name> is the name of this new section and <section_parser>
3769 * is the called parser. If two section declaration have the same name,
3770 * only the first declared is used.
3771 */
3772int cfg_register_section(char *section_name,
William Lallemandd2ff56d2017-10-16 11:06:50 +02003773 int (*section_parser)(const char *, int, char **, int),
3774 int (*post_section_parser)())
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003775{
3776 struct cfg_section *cs;
3777
Willy Tarreau5e4261b2016-05-17 16:16:09 +02003778 list_for_each_entry(cs, &sections, list) {
3779 if (strcmp(cs->section_name, section_name) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003780 ha_alert("register section '%s': already registered.\n", section_name);
Willy Tarreau5e4261b2016-05-17 16:16:09 +02003781 return 0;
3782 }
3783 }
3784
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003785 cs = calloc(1, sizeof(*cs));
3786 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003787 ha_alert("register section '%s': out of memory.\n", section_name);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003788 return 0;
3789 }
3790
3791 cs->section_name = section_name;
3792 cs->section_parser = section_parser;
William Lallemandd2ff56d2017-10-16 11:06:50 +02003793 cs->post_section_parser = post_section_parser;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01003794
3795 LIST_ADDQ(&sections, &cs->list);
3796
3797 return 1;
3798}
3799
William Lallemand48b4bb42017-10-23 14:36:34 +02003800/* this function register a new function which will be called once the haproxy
3801 * configuration file has been parsed. It's useful to check dependencies
3802 * between sections or to resolve items once everything is parsed.
3803 */
3804int cfg_register_postparser(char *name, int (*func)())
3805{
3806 struct cfg_postparser *cp;
3807
3808 cp = calloc(1, sizeof(*cp));
3809 if (!cp) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003810 ha_alert("register postparser '%s': out of memory.\n", name);
William Lallemand48b4bb42017-10-23 14:36:34 +02003811 return 0;
3812 }
3813 cp->name = name;
3814 cp->func = func;
3815
3816 LIST_ADDQ(&postparsers, &cp->list);
3817
3818 return 1;
3819}
3820
Willy Tarreaubaaee002006-06-26 02:48:02 +02003821/*
David Carlier845efb52015-09-25 11:49:18 +01003822 * free all config section entries
3823 */
3824void cfg_unregister_sections(void)
3825{
3826 struct cfg_section *cs, *ics;
3827
3828 list_for_each_entry_safe(cs, ics, &sections, list) {
3829 LIST_DEL(&cs->list);
3830 free(cs);
3831 }
3832}
3833
Christopher Faulet7110b402016-10-26 11:09:44 +02003834void cfg_backup_sections(struct list *backup_sections)
3835{
3836 struct cfg_section *cs, *ics;
3837
3838 list_for_each_entry_safe(cs, ics, &sections, list) {
3839 LIST_DEL(&cs->list);
3840 LIST_ADDQ(backup_sections, &cs->list);
3841 }
3842}
3843
3844void cfg_restore_sections(struct list *backup_sections)
3845{
3846 struct cfg_section *cs, *ics;
3847
3848 list_for_each_entry_safe(cs, ics, backup_sections, list) {
3849 LIST_DEL(&cs->list);
3850 LIST_ADDQ(&sections, &cs->list);
3851 }
3852}
3853
Willy Tarreau659fbf02016-05-26 17:55:28 +02003854__attribute__((constructor))
3855static void cfgparse_init(void)
3856{
3857 /* Register internal sections */
William Lallemandd2ff56d2017-10-16 11:06:50 +02003858 cfg_register_section("listen", cfg_parse_listen, NULL);
3859 cfg_register_section("frontend", cfg_parse_listen, NULL);
3860 cfg_register_section("backend", cfg_parse_listen, NULL);
3861 cfg_register_section("defaults", cfg_parse_listen, NULL);
3862 cfg_register_section("global", cfg_parse_global, NULL);
3863 cfg_register_section("userlist", cfg_parse_users, NULL);
3864 cfg_register_section("peers", cfg_parse_peers, NULL);
3865 cfg_register_section("mailers", cfg_parse_mailers, NULL);
3866 cfg_register_section("namespace_list", cfg_parse_netns, NULL);
3867 cfg_register_section("resolvers", cfg_parse_resolvers, NULL);
Willy Tarreau659fbf02016-05-26 17:55:28 +02003868}
3869
David Carlier845efb52015-09-25 11:49:18 +01003870/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02003871 * Local variables:
3872 * c-indent-level: 8
3873 * c-basic-offset: 8
3874 * End:
3875 */