blob: 6f453b5cf82eb70ac3eee6274b69c147dd560844 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Configuration parser
3 *
Willy Tarreauff011f22011-01-06 17:51:27 +01004 * Copyright 2000-2011 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreaue5733232019-05-22 19:24:06 +020013#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +020014/* This is to have crypt() defined on Linux */
15#define _GNU_SOURCE
16
Willy Tarreaue5733232019-05-22 19:24:06 +020017#ifdef USE_CRYPT_H
Cyril Bonté1a0191d2014-08-29 20:20:02 +020018/* some platforms such as Solaris need this */
19#include <crypt.h>
20#endif
Willy Tarreaue5733232019-05-22 19:24:06 +020021#endif /* USE_LIBCRYPT */
Cyril Bonté1a0191d2014-08-29 20:20:02 +020022
Willy Tarreaubaaee002006-06-26 02:48:02 +020023#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <netdb.h>
27#include <ctype.h>
Willy Tarreau95c20ac2007-03-25 15:39:23 +020028#include <pwd.h>
29#include <grp.h>
Willy Tarreau0b4ed902007-03-26 00:18:40 +020030#include <errno.h>
Willy Tarreau3f49b302007-06-11 00:29:26 +020031#include <sys/types.h>
32#include <sys/stat.h>
33#include <fcntl.h>
34#include <unistd.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020035
Willy Tarreau2dd0d472006-06-29 17:53:05 +020036#include <common/cfgparse.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020037#include <common/chunk.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020038#include <common/config.h>
Willy Tarreau058e9072009-07-20 09:30:05 +020039#include <common/errors.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020040#include <common/memory.h>
41#include <common/standard.h>
42#include <common/time.h>
43#include <common/uri_auth.h>
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +010044#include <common/namespace.h>
Emeric Brunc60def82017-09-27 14:59:38 +020045#include <common/hathreads.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020046
47#include <types/capture.h>
Christopher Fauletd7c91962015-04-30 11:48:27 +020048#include <types/filters.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020049#include <types/global.h>
Willy Tarreau3fdb3662012-11-12 00:42:33 +010050#include <types/obj_type.h>
Emeric Brun32da3c42010-09-23 18:39:19 +020051#include <types/peers.h>
Simon Horman0d16a402015-01-30 11:22:58 +090052#include <types/mailers.h>
Baptiste Assmann325137d2015-04-13 23:40:55 +020053#include <types/dns.h>
William Lallemand9ed62032016-11-21 17:49:11 +010054#include <types/stats.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020055
Willy Tarreaueb0c6142007-05-07 00:53:22 +020056#include <proto/acl.h>
Christopher Faulet4fce0d82017-09-18 11:57:31 +020057#include <proto/action.h>
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +010058#include <proto/auth.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020059#include <proto/backend.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020060#include <proto/channel.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020061#include <proto/checks.h>
Baptiste Assmann201c07f2017-05-22 15:17:15 +020062#include <proto/dns.h>
William Lallemand9ed62032016-11-21 17:49:11 +010063#include <proto/stats.h>
Christopher Fauletd7c91962015-04-30 11:48:27 +020064#include <proto/filters.h>
Willy Tarreaueb472682010-05-28 18:46:57 +020065#include <proto/frontend.h>
Willy 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 Tarreauc8d5b952019-02-27 17:25:52 +0100128int cfg_maxpconn = 0; /* # 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
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100348 * be "all", "odd", "even", a number between 1 and <max> 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 */
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100355int parse_process_number(const char *arg, unsigned long *proc, int max, 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 Faulet18cca782019-02-07 16:29:41 +0100372 const char *p, *dash = NULL;
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100373 unsigned int low, high;
374
Christopher Faulet18cca782019-02-07 16:29:41 +0100375 for (p = arg; *p; p++) {
376 if (*p == '-' && !dash)
377 dash = p;
378 else if (!isdigit((int)*p)) {
379 memprintf(err, "'%s' is not a valid number/range.", arg);
380 return -1;
381 }
Christopher Faulet5ab51772017-11-22 11:21:58 +0100382 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100383
384 low = high = str2uic(arg);
Christopher Faulet18cca782019-02-07 16:29:41 +0100385 if (dash)
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100386 high = ((!*(dash+1)) ? max : str2uic(dash + 1));
Christopher Fauletff4121f2017-11-22 16:38:49 +0100387
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100388 if (high < low) {
389 unsigned int swap = low;
390 low = high;
391 high = swap;
392 }
393
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100394 if (low < 1 || low > max || high > max) {
Christopher Fauletcb6a9452017-11-22 16:50:41 +0100395 memprintf(err, "'%s' is not a valid number/range."
396 " It supports numbers from 1 to %d.\n",
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100397 arg, max);
Christopher Faulet5ab51772017-11-22 11:21:58 +0100398 return 1;
399 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100400
401 for (;low <= high; low++)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100402 *proc |= 1UL << (low-1);
Christopher Faulet62519022017-10-16 15:49:32 +0200403 }
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100404 *proc &= ~0UL >> (LONGBITS - max);
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100405
Christopher Faulet5ab51772017-11-22 11:21:58 +0100406 return 0;
Christopher Faulet62519022017-10-16 15:49:32 +0200407}
408
David Carlier7e351ee2017-12-01 09:14:02 +0000409#ifdef USE_CPU_AFFINITY
Christopher Faulet62519022017-10-16 15:49:32 +0200410/* Parse cpu sets. Each CPU set is either a unique number between 0 and
411 * <LONGBITS> or a range with two such numbers delimited by a dash
412 * ('-'). Multiple CPU numbers or ranges may be specified. On success, it
413 * returns 0. otherwise it returns 1 with an error message in <err>.
414 */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100415unsigned long parse_cpu_set(const char **args, unsigned long *cpu_set, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200416{
417 int cur_arg = 0;
418
419 *cpu_set = 0;
420 while (*args[cur_arg]) {
421 char *dash;
422 unsigned int low, high;
423
424 if (!isdigit((int)*args[cur_arg])) {
425 memprintf(err, "'%s' is not a CPU range.\n", args[cur_arg]);
426 return -1;
427 }
428
429 low = high = str2uic(args[cur_arg]);
430 if ((dash = strchr(args[cur_arg], '-')) != NULL)
Christopher Fauletff4121f2017-11-22 16:38:49 +0100431 high = ((!*(dash+1)) ? LONGBITS-1 : str2uic(dash + 1));
Christopher Faulet62519022017-10-16 15:49:32 +0200432
433 if (high < low) {
434 unsigned int swap = low;
435 low = high;
436 high = swap;
437 }
438
439 if (high >= LONGBITS) {
440 memprintf(err, "supports CPU numbers from 0 to %d.\n", LONGBITS - 1);
441 return 1;
442 }
443
444 while (low <= high)
445 *cpu_set |= 1UL << low++;
446
447 cur_arg++;
448 }
449 return 0;
450}
David Carlier7e351ee2017-12-01 09:14:02 +0000451#endif
452
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200453void init_default_instance()
Willy Tarreaubaaee002006-06-26 02:48:02 +0200454{
Willy Tarreau97cb7802010-01-03 20:23:58 +0100455 init_new_proxy(&defproxy);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200456 defproxy.mode = PR_MODE_TCP;
457 defproxy.state = PR_STNEW;
458 defproxy.maxconn = cfg_maxpconn;
459 defproxy.conn_retries = CONN_RETRIES;
Joseph Lynch726ab712015-05-11 23:25:34 -0700460 defproxy.redispatch_after = 0;
Olivier Houchard86006a52018-12-14 19:37:49 +0100461 defproxy.options = PR_O_REUSE_SAFE;
Olivier Houcharda4d4fdf2018-12-14 19:27:06 +0100462 defproxy.max_out_conns = MAX_SRV_LIST;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100463
Simon Horman66183002013-02-23 10:16:43 +0900464 defproxy.defsrv.check.inter = DEF_CHKINTR;
465 defproxy.defsrv.check.fastinter = 0;
466 defproxy.defsrv.check.downinter = 0;
Simon Hormand60d6912013-11-25 10:46:36 +0900467 defproxy.defsrv.agent.inter = DEF_CHKINTR;
468 defproxy.defsrv.agent.fastinter = 0;
469 defproxy.defsrv.agent.downinter = 0;
Simon Horman58c32972013-11-25 10:46:38 +0900470 defproxy.defsrv.check.rise = DEF_RISETIME;
471 defproxy.defsrv.check.fall = DEF_FALLTIME;
472 defproxy.defsrv.agent.rise = DEF_AGENT_RISETIME;
473 defproxy.defsrv.agent.fall = DEF_AGENT_FALLTIME;
Willy Tarreau5b3a2022012-09-28 15:01:02 +0200474 defproxy.defsrv.check.port = 0;
Simon Hormand60d6912013-11-25 10:46:36 +0900475 defproxy.defsrv.agent.port = 0;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100476 defproxy.defsrv.maxqueue = 0;
477 defproxy.defsrv.minconn = 0;
478 defproxy.defsrv.maxconn = 0;
Willy Tarreau9c538e02019-01-23 10:21:49 +0100479 defproxy.defsrv.max_reuse = -1;
Olivier Houchard006e3102018-12-10 18:30:32 +0100480 defproxy.defsrv.max_idle_conns = -1;
Willy Tarreau975b1552019-06-06 16:25:55 +0200481 defproxy.defsrv.pool_purge_delay = 5000;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100482 defproxy.defsrv.slowstart = 0;
483 defproxy.defsrv.onerror = DEF_HANA_ONERR;
484 defproxy.defsrv.consecutive_errors_limit = DEF_HANA_ERRLIMIT;
485 defproxy.defsrv.uweight = defproxy.defsrv.iweight = 1;
Simon Horman64e34162015-02-06 11:11:57 +0900486
487 defproxy.email_alert.level = LOG_ALERT;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +0200488 defproxy.load_server_state_from_file = PR_SRV_STATE_FILE_UNSPEC;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200489}
490
Frédéric Lécaille18251032019-01-11 11:07:15 +0100491/* Allocate and initialize the frontend of a "peers" section found in
492 * file <file> at line <linenum> with <id> as ID.
493 * Return 0 if succeeded, -1 if not.
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200494 * Note that this function may be called from "default-server"
495 * or "peer" lines.
Frédéric Lécaille18251032019-01-11 11:07:15 +0100496 */
497static int init_peers_frontend(const char *file, int linenum,
498 const char *id, struct peers *peers)
499{
500 struct proxy *p;
501
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200502 if (peers->peers_fe) {
503 p = peers->peers_fe;
504 goto out;
505 }
Frédéric Lécaille9492c4e2019-01-11 11:47:12 +0100506
Frédéric Lécaille18251032019-01-11 11:07:15 +0100507 p = calloc(1, sizeof *p);
508 if (!p) {
509 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
510 return -1;
511 }
512
513 init_new_proxy(p);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200514 peers_setup_frontend(p);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100515 p->parent = peers;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200516 /* Finally store this frontend. */
517 peers->peers_fe = p;
518
519 out:
520 if (id && !p->id)
521 p->id = strdup(id);
Frédéric Lécaille1055e682018-04-26 14:35:21 +0200522 free(p->conf.file);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100523 p->conf.args.file = p->conf.file = strdup(file);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100524 if (linenum != -1)
525 p->conf.args.line = p->conf.line = linenum;
Frédéric Lécaille18251032019-01-11 11:07:15 +0100526
527 return 0;
528}
Willy Tarreauade5ec42010-01-28 19:33:49 +0100529
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100530/* Only change ->file, ->line and ->arg struct bind_conf member values
531 * if already present.
532 */
533static struct bind_conf *bind_conf_uniq_alloc(struct proxy *p,
534 const char *file, int line,
535 const char *arg, struct xprt_ops *xprt)
536{
537 struct bind_conf *bind_conf;
538
539 if (!LIST_ISEMPTY(&p->conf.bind)) {
540 bind_conf = LIST_ELEM((&p->conf.bind)->n, typeof(bind_conf), by_fe);
541 free(bind_conf->file);
542 bind_conf->file = strdup(file);
543 bind_conf->line = line;
544 if (arg) {
545 free(bind_conf->arg);
546 bind_conf->arg = strdup(arg);
547 }
548 }
549 else {
550 bind_conf = bind_conf_alloc(p, file, line, arg, xprt);
551 }
552
553 return bind_conf;
554}
555
556/*
557 * Allocate a new struct peer parsed at line <linenum> in file <file>
558 * to be added to <peers>.
559 * Returns the new allocated structure if succeeded, NULL if not.
560 */
561static struct peer *cfg_peers_add_peer(struct peers *peers,
562 const char *file, int linenum,
563 const char *id, int local)
564{
565 struct peer *p;
566
567 p = calloc(1, sizeof *p);
568 if (!p) {
569 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
570 return NULL;
571 }
572
573 /* the peers are linked backwards first */
574 peers->count++;
575 p->next = peers->remote;
576 peers->remote = p;
577 p->conf.file = strdup(file);
578 p->conf.line = linenum;
579 p->last_change = now.tv_sec;
580 p->xprt = xprt_get(XPRT_RAW);
581 p->sock_init_arg = NULL;
582 HA_SPIN_INIT(&p->lock);
583 if (id)
584 p->id = strdup(id);
585 if (local) {
586 p->local = 1;
587 peers->local = p;
588 }
589
590 return p;
591}
592
Willy Tarreaubaaee002006-06-26 02:48:02 +0200593/*
William Lallemand51097192015-04-14 16:35:22 +0200594 * Parse a line in a <listen>, <frontend> or <backend> section.
Willy Tarreau93893792009-07-23 13:19:11 +0200595 * Returns the error code, 0 if OK, or any combination of :
596 * - ERR_ABORT: must abort ASAP
597 * - ERR_FATAL: we can continue parsing but not start the service
598 * - ERR_WARN: a warning has been emitted
599 * - ERR_ALERT: an alert has been emitted
600 * Only the two first ones can stop processing, the two others are just
601 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200602 */
Emeric Brun32da3c42010-09-23 18:39:19 +0200603int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
604{
605 static struct peers *curpeers = NULL;
606 struct peer *newpeer = NULL;
607 const char *err;
Willy Tarreau4348fad2012-09-20 16:48:07 +0200608 struct bind_conf *bind_conf;
609 struct listener *l;
Emeric Brun32da3c42010-09-23 18:39:19 +0200610 int err_code = 0;
Willy Tarreau902636f2013-03-10 19:44:48 +0100611 char *errmsg = NULL;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100612 static int bind_line, peer_line;
613
614 if (strcmp(args[0], "bind") == 0 || strcmp(args[0], "default-bind") == 0) {
615 int cur_arg;
616 static int kws_dumped;
617 struct bind_conf *bind_conf;
618 struct bind_kw *kw;
Emeric Brun32da3c42010-09-23 18:39:19 +0200619
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100620 cur_arg = 1;
621
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200622 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
623 err_code |= ERR_ALERT | ERR_ABORT;
624 goto out;
625 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100626
627 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum,
628 NULL, xprt_get(XPRT_RAW));
629 if (*args[0] == 'b') {
630 struct listener *l;
631
632 if (peer_line) {
633 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
634 err_code |= ERR_ALERT | ERR_FATAL;
635 goto out;
636 }
637
638 if (!str2listener(args[1], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
639 if (errmsg && *errmsg) {
640 indent_msg(&errmsg, 2);
641 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
642 }
643 else
644 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
645 file, linenum, args[0], args[1], args[2]);
646 err_code |= ERR_FATAL;
647 goto out;
648 }
649 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
650 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100651 l->accept = session_accept_fd;
652 l->analysers |= curpeers->peers_fe->fe_req_ana;
653 l->default_target = curpeers->peers_fe->default_target;
654 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100655 global.maxsock++; /* for the listening socket */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100656
657 bind_line = 1;
658 if (cfg_peers->local) {
659 newpeer = cfg_peers->local;
660 }
661 else {
662 /* This peer is local.
663 * Note that we do not set the peer ID. This latter is initialized
664 * when parsing "peer" or "server" line.
665 */
666 newpeer = cfg_peers_add_peer(curpeers, file, linenum, NULL, 1);
667 if (!newpeer) {
668 err_code |= ERR_ALERT | ERR_ABORT;
669 goto out;
670 }
671 }
672 newpeer->addr = l->addr;
673 newpeer->proto = protocol_by_family(newpeer->addr.ss_family);
674 cur_arg++;
675 }
676
677 while (*args[cur_arg] && (kw = bind_find_kw(args[cur_arg]))) {
678 int ret;
679
680 ret = kw->parse(args, cur_arg, curpeers->peers_fe, bind_conf, &errmsg);
681 err_code |= ret;
682 if (ret) {
683 if (errmsg && *errmsg) {
684 indent_msg(&errmsg, 2);
685 ha_alert("parsing [%s:%d] : %s\n", file, linenum, errmsg);
686 }
687 else
688 ha_alert("parsing [%s:%d]: error encountered while processing '%s'\n",
689 file, linenum, args[cur_arg]);
690 if (ret & ERR_FATAL)
691 goto out;
692 }
693 cur_arg += 1 + kw->skip;
694 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100695 if (*args[cur_arg] != 0) {
Tim Duesterhus04bcaa12019-05-12 22:54:50 +0200696 char *kws = NULL;
697
698 if (!kws_dumped) {
699 kws_dumped = 1;
700 bind_dump_kws(&kws);
701 indent_msg(&kws, 4);
702 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100703 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section.%s%s\n",
704 file, linenum, args[cur_arg], cursection,
705 kws ? " Registered keywords :" : "", kws ? kws: "");
706 free(kws);
707 err_code |= ERR_ALERT | ERR_FATAL;
708 goto out;
709 }
710 }
711 else if (strcmp(args[0], "default-server") == 0) {
712 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
713 err_code |= ERR_ALERT | ERR_ABORT;
714 goto out;
715 }
Emeric Brun33f0a732020-07-21 16:54:36 +0200716 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL, 0, 1, 1);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200717 }
718 else if (strcmp(args[0], "peers") == 0) { /* new peers section */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100719 /* Initialize these static variables when entering a new "peers" section*/
720 bind_line = peer_line = 0;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100721 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100722 ha_alert("parsing [%s:%d] : missing name for peers section.\n", file, linenum);
Willy Tarreau54984722014-02-16 08:20:13 +0100723 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100724 goto out;
725 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200726
William Lallemand6e62fb62015-04-28 16:55:23 +0200727 if (alertif_too_many_args(1, file, linenum, args, &err_code))
728 goto out;
729
Emeric Brun32da3c42010-09-23 18:39:19 +0200730 err = invalid_char(args[1]);
731 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100732 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
733 file, linenum, *err, args[0], args[1]);
Willy Tarreau54984722014-02-16 08:20:13 +0100734 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100735 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200736 }
737
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200738 for (curpeers = cfg_peers; curpeers != NULL; curpeers = curpeers->next) {
Emeric Brun32da3c42010-09-23 18:39:19 +0200739 /*
740 * If there are two proxies with the same name only following
741 * combinations are allowed:
742 */
743 if (strcmp(curpeers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100744 ha_alert("Parsing [%s:%d]: peers section '%s' has the same name as another peers section declared at %s:%d.\n",
745 file, linenum, args[1], curpeers->conf.file, curpeers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +0200746 err_code |= ERR_ALERT | ERR_FATAL;
Emeric Brun32da3c42010-09-23 18:39:19 +0200747 }
748 }
749
Vincent Bernat02779b62016-04-03 13:48:43 +0200750 if ((curpeers = calloc(1, sizeof(*curpeers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100751 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Emeric Brun32da3c42010-09-23 18:39:19 +0200752 err_code |= ERR_ALERT | ERR_ABORT;
753 goto out;
754 }
755
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200756 curpeers->next = cfg_peers;
757 cfg_peers = curpeers;
Willy Tarreau8113a5d2012-10-04 08:01:43 +0200758 curpeers->conf.file = strdup(file);
Emeric Brun32da3c42010-09-23 18:39:19 +0200759 curpeers->conf.line = linenum;
760 curpeers->last_change = now.tv_sec;
761 curpeers->id = strdup(args[1]);
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200762 curpeers->state = PR_STNEW;
Emeric Brun32da3c42010-09-23 18:39:19 +0200763 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200764 else if (strcmp(args[0], "peer") == 0 ||
765 strcmp(args[0], "server") == 0) { /* peer or server definition */
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100766 int local_peer, peer;
Emeric Brun32da3c42010-09-23 18:39:19 +0200767
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100768 peer = *args[0] == 'p';
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100769 local_peer = !strcmp(args[1], localpeer);
770 /* The local peer may have already partially been parsed on a "bind" line. */
771 if (*args[0] == 'p') {
772 if (bind_line) {
773 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
774 err_code |= ERR_ALERT | ERR_FATAL;
775 goto out;
776 }
777 peer_line = 1;
778 }
779 if (cfg_peers->local && !cfg_peers->local->id && local_peer) {
780 /* The local peer has already been initialized on a "bind" line.
781 * Let's use it and store its ID.
782 */
783 newpeer = cfg_peers->local;
784 newpeer->id = strdup(localpeer);
785 }
786 else {
787 if (local_peer && cfg_peers->local) {
788 ha_alert("parsing [%s:%d] : '%s %s' : local peer name already referenced at %s:%d. %s\n",
789 file, linenum, args[0], args[1],
790 curpeers->peers_fe->conf.file, curpeers->peers_fe->conf.line, cfg_peers->local->id);
791 err_code |= ERR_FATAL;
792 goto out;
793 }
794 newpeer = cfg_peers_add_peer(curpeers, file, linenum, args[1], local_peer);
795 if (!newpeer) {
796 err_code |= ERR_ALERT | ERR_ABORT;
797 goto out;
798 }
799 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200800
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100801 /* Line number and peer ID are updated only if this peer is the local one. */
802 if (init_peers_frontend(file,
803 newpeer->local ? linenum: -1,
804 newpeer->local ? newpeer->id : NULL,
805 curpeers) != 0) {
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200806 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreaub36487e2013-03-10 18:37:42 +0100807 goto out;
808 }
Willy Tarreau2aa38802013-02-20 19:20:59 +0100809
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100810 /* This initializes curpeer->peers->peers_fe->srv.
811 * The server address is parsed only if we are parsing a "peer" line,
812 * or if we are parsing a "server" line and the current peer is not the local one.
813 */
Emeric Brun33f0a732020-07-21 16:54:36 +0200814 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL, peer || !local_peer, 1, 1);
Frédéric Lécaille9b0d59d2020-04-03 09:43:47 +0200815 if (!curpeers->peers_fe->srv) {
816 /* Remove the newly allocated peer. */
817 if (newpeer != curpeers->local) {
818 struct peer *p;
819
820 p = curpeers->remote;
821 curpeers->remote = curpeers->remote->next;
822 free(p->id);
823 free(p);
824 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200825 goto out;
Frédéric Lécaille9b0d59d2020-04-03 09:43:47 +0200826 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200827
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100828 /* If the peer address has just been parsed, let's copy it to <newpeer>
829 * and initializes ->proto.
830 */
831 if (peer || !local_peer) {
832 newpeer->addr = curpeers->peers_fe->srv->addr;
833 newpeer->proto = protocol_by_family(newpeer->addr.ss_family);
834 }
835
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100836 newpeer->xprt = xprt_get(XPRT_RAW);
Willy Tarreaud02394b2012-05-11 18:32:18 +0200837 newpeer->sock_init_arg = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100838 HA_SPIN_INIT(&newpeer->lock);
Willy Tarreau26d8c592012-05-07 18:12:14 +0200839
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100840 newpeer->srv = curpeers->peers_fe->srv;
841 if (!newpeer->local)
Frédéric Lécaille6617e762018-04-25 15:13:38 +0200842 goto out;
843
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100844 /* The lines above are reserved to "peer" lines. */
845 if (*args[0] == 's')
Frédéric Lécaille4ba51982018-04-25 15:32:18 +0200846 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200847
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100848 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum, args[2], xprt_get(XPRT_RAW));
Frédéric Lécaille16e49102019-01-11 11:27:16 +0100849
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100850 if (!str2listener(args[2], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
851 if (errmsg && *errmsg) {
852 indent_msg(&errmsg, 2);
853 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Frédéric Lécaille16e49102019-01-11 11:27:16 +0100854 }
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100855 else
856 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
857 file, linenum, args[0], args[1], args[2]);
858 err_code |= ERR_FATAL;
859 goto out;
860 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100861
862 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
863 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100864 l->accept = session_accept_fd;
865 l->analysers |= curpeers->peers_fe->fe_req_ana;
866 l->default_target = curpeers->peers_fe->default_target;
867 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100868 global.maxsock++; /* for the listening socket */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100869 }
870 else if (!strcmp(args[0], "table")) {
871 struct stktable *t, *other;
872 char *id;
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100873 size_t prefix_len;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100874
875 /* Line number and peer ID are updated only if this peer is the local one. */
876 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
877 err_code |= ERR_ALERT | ERR_ABORT;
878 goto out;
879 }
880
881 other = stktable_find_by_name(args[1]);
882 if (other) {
883 ha_alert("parsing [%s:%d] : stick-table name '%s' conflicts with table declared in %s '%s' at %s:%d.\n",
884 file, linenum, args[1],
885 other->proxy ? proxy_cap_str(other->proxy->cap) : "peers",
886 other->proxy ? other->id : other->peers.p->id,
887 other->conf.file, other->conf.line);
888 err_code |= ERR_ALERT | ERR_FATAL;
889 goto out;
890 }
891
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100892 /* Build the stick-table name, concatenating the "peers" section name
893 * followed by a '/' character and the table name argument.
894 */
895 chunk_reset(&trash);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100896 if (!chunk_strcpy(&trash, curpeers->id)) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100897 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
898 file, linenum, args[0], args[1]);
899 err_code |= ERR_ALERT | ERR_FATAL;
900 goto out;
901 }
902
903 prefix_len = trash.data;
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100904 if (!chunk_memcat(&trash, "/", 1) || !chunk_strcat(&trash, args[1])) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100905 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
906 file, linenum, args[0], args[1]);
907 err_code |= ERR_ALERT | ERR_FATAL;
908 goto out;
909 }
910
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100911 t = calloc(1, sizeof *t);
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100912 id = strdup(trash.area);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100913 if (!t || !id) {
914 ha_alert("parsing [%s:%d]: '%s %s' : memory allocation failed\n",
915 file, linenum, args[0], args[1]);
916 err_code |= ERR_ALERT | ERR_FATAL;
917 goto out;
918 }
919
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100920 err_code |= parse_stick_table(file, linenum, args, t, id, id + prefix_len, curpeers);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100921 if (err_code & ERR_FATAL)
922 goto out;
923
924 stktable_store_name(t);
925 t->next = stktables_list;
926 stktables_list = t;
927 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200928 else if (!strcmp(args[0], "disabled")) { /* disables this peers section */
929 curpeers->state = PR_STSTOPPED;
930 }
931 else if (!strcmp(args[0], "enabled")) { /* enables this peers section (used to revert a disabled default) */
932 curpeers->state = PR_STNEW;
933 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200934 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100935 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Emeric Brun32da3c42010-09-23 18:39:19 +0200936 err_code |= ERR_ALERT | ERR_FATAL;
937 goto out;
938 }
939
940out:
Willy Tarreau902636f2013-03-10 19:44:48 +0100941 free(errmsg);
Emeric Brun32da3c42010-09-23 18:39:19 +0200942 return err_code;
943}
944
Baptiste Assmann325137d2015-04-13 23:40:55 +0200945/*
946 * Parse a <resolvers> section.
947 * Returns the error code, 0 if OK, or any combination of :
948 * - ERR_ABORT: must abort ASAP
949 * - ERR_FATAL: we can continue parsing but not start the service
950 * - ERR_WARN: a warning has been emitted
951 * - ERR_ALERT: an alert has been emitted
952 * Only the two first ones can stop processing, the two others are just
953 * indicators.
954 */
955int cfg_parse_resolvers(const char *file, int linenum, char **args, int kwm)
956{
957 static struct dns_resolvers *curr_resolvers = NULL;
958 struct dns_nameserver *newnameserver = NULL;
959 const char *err;
960 int err_code = 0;
961 char *errmsg = NULL;
962
963 if (strcmp(args[0], "resolvers") == 0) { /* new resolvers section */
964 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100965 ha_alert("parsing [%s:%d] : missing name for resolvers section.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200966 err_code |= ERR_ALERT | ERR_ABORT;
967 goto out;
968 }
969
970 err = invalid_char(args[1]);
971 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100972 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
973 file, linenum, *err, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200974 err_code |= ERR_ALERT | ERR_ABORT;
975 goto out;
976 }
977
978 list_for_each_entry(curr_resolvers, &dns_resolvers, list) {
979 /* Error if two resolvers owns the same name */
980 if (strcmp(curr_resolvers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100981 ha_alert("Parsing [%s:%d]: resolvers '%s' has same name as another resolvers (declared at %s:%d).\n",
982 file, linenum, args[1], curr_resolvers->conf.file, curr_resolvers->conf.line);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200983 err_code |= ERR_ALERT | ERR_ABORT;
984 }
985 }
986
Vincent Bernat02779b62016-04-03 13:48:43 +0200987 if ((curr_resolvers = calloc(1, sizeof(*curr_resolvers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100988 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200989 err_code |= ERR_ALERT | ERR_ABORT;
990 goto out;
991 }
992
993 /* default values */
994 LIST_ADDQ(&dns_resolvers, &curr_resolvers->list);
995 curr_resolvers->conf.file = strdup(file);
996 curr_resolvers->conf.line = linenum;
997 curr_resolvers->id = strdup(args[1]);
998 curr_resolvers->query_ids = EB_ROOT;
Baptiste Assmann2af08fe2017-08-14 00:13:01 +0200999 /* default maximum response size */
1000 curr_resolvers->accepted_payload_size = 512;
Baptiste Assmann987e16d2016-11-02 22:23:31 +01001001 /* default hold period for nx, other, refuse and timeout is 30s */
1002 curr_resolvers->hold.nx = 30000;
1003 curr_resolvers->hold.other = 30000;
1004 curr_resolvers->hold.refused = 30000;
1005 curr_resolvers->hold.timeout = 30000;
Baptiste Assmann686408b2017-08-18 10:15:42 +02001006 curr_resolvers->hold.obsolete = 0;
Baptiste Assmann325137d2015-04-13 23:40:55 +02001007 /* default hold period for valid is 10s */
Baptiste Assmann4c5490a2015-07-14 21:42:49 +02001008 curr_resolvers->hold.valid = 10000;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001009 curr_resolvers->timeout.resolve = 1000;
1010 curr_resolvers->timeout.retry = 1000;
Baptiste Assmann325137d2015-04-13 23:40:55 +02001011 curr_resolvers->resolve_retries = 3;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001012 curr_resolvers->nb_nameservers = 0;
1013 LIST_INIT(&curr_resolvers->nameservers);
1014 LIST_INIT(&curr_resolvers->resolutions.curr);
1015 LIST_INIT(&curr_resolvers->resolutions.wait);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001016 HA_SPIN_INIT(&curr_resolvers->lock);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001017 }
1018 else if (strcmp(args[0], "nameserver") == 0) { /* nameserver definition */
1019 struct sockaddr_storage *sk;
1020 int port1, port2;
1021 struct protocol *proto;
1022
1023 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001024 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1025 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001026 err_code |= ERR_ALERT | ERR_FATAL;
1027 goto out;
1028 }
1029
1030 err = invalid_char(args[1]);
1031 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001032 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1033 file, linenum, *err, args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001034 err_code |= ERR_ALERT | ERR_FATAL;
1035 goto out;
1036 }
1037
Christopher Faulet67957bd2017-09-27 11:00:59 +02001038 list_for_each_entry(newnameserver, &curr_resolvers->nameservers, list) {
Baptiste Assmanna315c552015-11-02 22:55:49 +01001039 /* Error if two resolvers owns the same name */
1040 if (strcmp(newnameserver->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001041 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 -06001042 file, linenum, args[1], newnameserver->conf.file, newnameserver->conf.line);
Baptiste Assmanna315c552015-11-02 22:55:49 +01001043 err_code |= ERR_ALERT | ERR_FATAL;
1044 }
1045 }
1046
Vincent Bernat02779b62016-04-03 13:48:43 +02001047 if ((newnameserver = calloc(1, sizeof(*newnameserver))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001048 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001049 err_code |= ERR_ALERT | ERR_ABORT;
1050 goto out;
1051 }
1052
1053 /* the nameservers are linked backward first */
Christopher Faulet67957bd2017-09-27 11:00:59 +02001054 LIST_ADDQ(&curr_resolvers->nameservers, &newnameserver->list);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001055 newnameserver->resolvers = curr_resolvers;
1056 newnameserver->conf.file = strdup(file);
1057 newnameserver->conf.line = linenum;
1058 newnameserver->id = strdup(args[1]);
1059
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001060 sk = str2sa_range(args[2], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001061 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001062 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001063 err_code |= ERR_ALERT | ERR_FATAL;
1064 goto out;
1065 }
1066
1067 proto = protocol_by_family(sk->ss_family);
1068 if (!proto || !proto->connect) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001069 ha_alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
Baptiste Assmann325137d2015-04-13 23:40:55 +02001070 file, linenum, args[0], args[1]);
1071 err_code |= ERR_ALERT | ERR_FATAL;
1072 goto out;
1073 }
1074
1075 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001076 ha_alert("parsing [%s:%d] : '%s %s' : port ranges and offsets are not allowed in '%s'\n",
1077 file, linenum, args[0], args[1], args[2]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001078 err_code |= ERR_ALERT | ERR_FATAL;
1079 goto out;
1080 }
1081
Baptiste Assmann7f43fa92016-01-21 00:59:46 +01001082 if (!port1 && !port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001083 ha_alert("parsing [%s:%d] : '%s %s' : no UDP port specified\n",
1084 file, linenum, args[0], args[1]);
Baptiste Assmann7f43fa92016-01-21 00:59:46 +01001085 err_code |= ERR_ALERT | ERR_FATAL;
1086 goto out;
1087 }
1088
Baptiste Assmann325137d2015-04-13 23:40:55 +02001089 newnameserver->addr = *sk;
1090 }
Ben Draut44e609b2018-05-29 15:40:08 -06001091 else if (strcmp(args[0], "parse-resolv-conf") == 0) {
1092 const char *whitespace = "\r\n\t ";
1093 char *resolv_line = NULL;
1094 int resolv_linenum = 0;
1095 FILE *f = NULL;
1096 char *address = NULL;
1097 struct sockaddr_storage *sk = NULL;
1098 struct protocol *proto;
1099 int duplicate_name = 0;
1100
1101 if ((resolv_line = malloc(sizeof(*resolv_line) * LINESIZE)) == NULL) {
1102 ha_alert("parsing [%s:%d] : out of memory.\n",
1103 file, linenum);
1104 err_code |= ERR_ALERT | ERR_FATAL;
1105 goto resolv_out;
1106 }
1107
1108 if ((f = fopen("/etc/resolv.conf", "r")) == NULL) {
1109 ha_alert("parsing [%s:%d] : failed to open /etc/resolv.conf.\n",
1110 file, linenum);
1111 err_code |= ERR_ALERT | ERR_FATAL;
1112 goto resolv_out;
1113 }
1114
1115 sk = calloc(1, sizeof(*sk));
1116 if (sk == NULL) {
1117 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n",
1118 resolv_linenum);
1119 err_code |= ERR_ALERT | ERR_FATAL;
1120 goto resolv_out;
1121 }
1122
1123 while (fgets(resolv_line, LINESIZE, f) != NULL) {
1124 resolv_linenum++;
1125 if (strncmp(resolv_line, "nameserver", 10) != 0)
1126 continue;
1127
1128 address = strtok(resolv_line + 10, whitespace);
1129 if (address == resolv_line + 10)
1130 continue;
1131
1132 if (address == NULL) {
1133 ha_warning("parsing [/etc/resolv.conf:%d] : nameserver line is missing address.\n",
1134 resolv_linenum);
1135 err_code |= ERR_WARN;
1136 continue;
1137 }
1138
1139 duplicate_name = 0;
1140 list_for_each_entry(newnameserver, &curr_resolvers->nameservers, list) {
1141 if (strcmp(newnameserver->id, address) == 0) {
1142 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",
1143 resolv_linenum, address, newnameserver->conf.file, newnameserver->conf.line);
1144 err_code |= ERR_WARN;
1145 duplicate_name = 1;
1146 }
1147 }
1148
1149 if (duplicate_name)
1150 continue;
1151
1152 memset(sk, 0, sizeof(*sk));
Willy Tarreau98fbb972020-05-28 18:07:10 +02001153 if (!str2ip2(address, sk, 1)) {
1154 ha_warning("parsing [/etc/resolv.conf:%d] : address '%s' could not be recognized, nameserver will be excluded.\n",
Ben Draut44e609b2018-05-29 15:40:08 -06001155 resolv_linenum, address);
1156 err_code |= ERR_WARN;
1157 continue;
1158 }
1159
1160 set_host_port(sk, 53);
1161
1162 proto = protocol_by_family(sk->ss_family);
1163 if (!proto || !proto->connect) {
1164 ha_warning("parsing [/etc/resolv.conf:%d] : '%s' : connect() not supported for this address family.\n",
1165 resolv_linenum, address);
1166 err_code |= ERR_WARN;
1167 continue;
1168 }
1169
1170 if ((newnameserver = calloc(1, sizeof(*newnameserver))) == NULL) {
1171 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1172 err_code |= ERR_ALERT | ERR_FATAL;
1173 goto resolv_out;
1174 }
1175
1176 newnameserver->conf.file = strdup("/etc/resolv.conf");
1177 if (newnameserver->conf.file == NULL) {
1178 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1179 err_code |= ERR_ALERT | ERR_FATAL;
1180 goto resolv_out;
1181 }
1182
1183 newnameserver->id = strdup(address);
1184 if (newnameserver->id == NULL) {
1185 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1186 err_code |= ERR_ALERT | ERR_FATAL;
1187 goto resolv_out;
1188 }
1189
1190 newnameserver->resolvers = curr_resolvers;
1191 newnameserver->conf.line = resolv_linenum;
1192 newnameserver->addr = *sk;
1193
1194 LIST_ADDQ(&curr_resolvers->nameservers, &newnameserver->list);
1195 }
1196
1197resolv_out:
1198 free(sk);
1199 free(resolv_line);
1200 if (f != NULL)
1201 fclose(f);
1202 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001203 else if (strcmp(args[0], "hold") == 0) { /* hold periods */
1204 const char *res;
1205 unsigned int time;
1206
1207 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001208 ha_alert("parsing [%s:%d] : '%s' expects an <event> and a <time> as arguments.\n",
1209 file, linenum, args[0]);
1210 ha_alert("<event> can be either 'valid', 'nx', 'refused', 'timeout', or 'other'\n");
Baptiste Assmann325137d2015-04-13 23:40:55 +02001211 err_code |= ERR_ALERT | ERR_FATAL;
1212 goto out;
1213 }
1214 res = parse_time_err(args[2], &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001215 if (res == PARSE_TIME_OVER) {
1216 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s>, maximum value is 2147483647 ms (~24.8 days).\n",
1217 file, linenum, args[1], args[0]);
1218 err_code |= ERR_ALERT | ERR_FATAL;
1219 goto out;
1220 }
1221 else if (res == PARSE_TIME_UNDER) {
1222 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s>, minimum non-null value is 1 ms.\n",
1223 file, linenum, args[1], args[0]);
1224 err_code |= ERR_ALERT | ERR_FATAL;
1225 goto out;
1226 }
1227 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001228 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s>.\n",
1229 file, linenum, *res, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001230 err_code |= ERR_ALERT | ERR_FATAL;
1231 goto out;
1232 }
Baptiste Assmann987e16d2016-11-02 22:23:31 +01001233 if (strcmp(args[1], "nx") == 0)
1234 curr_resolvers->hold.nx = time;
1235 else if (strcmp(args[1], "other") == 0)
1236 curr_resolvers->hold.other = time;
1237 else if (strcmp(args[1], "refused") == 0)
1238 curr_resolvers->hold.refused = time;
1239 else if (strcmp(args[1], "timeout") == 0)
1240 curr_resolvers->hold.timeout = time;
1241 else if (strcmp(args[1], "valid") == 0)
Baptiste Assmann325137d2015-04-13 23:40:55 +02001242 curr_resolvers->hold.valid = time;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02001243 else if (strcmp(args[1], "obsolete") == 0)
1244 curr_resolvers->hold.obsolete = time;
Baptiste Assmann325137d2015-04-13 23:40:55 +02001245 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001246 ha_alert("parsing [%s:%d] : '%s' unknown <event>: '%s', expects either 'nx', 'timeout', 'valid', 'obsolete' or 'other'.\n",
1247 file, linenum, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001248 err_code |= ERR_ALERT | ERR_FATAL;
1249 goto out;
1250 }
1251
1252 }
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001253 else if (strcmp(args[0], "accepted_payload_size") == 0) {
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001254 int i = 0;
1255
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001256 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001257 ha_alert("parsing [%s:%d] : '%s' expects <nb> as argument.\n",
1258 file, linenum, args[0]);
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001259 err_code |= ERR_ALERT | ERR_FATAL;
1260 goto out;
1261 }
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001262
1263 i = atoi(args[1]);
Willy Tarreau0c219be2017-08-22 12:01:26 +02001264 if (i < DNS_HEADER_SIZE || i > DNS_MAX_UDP_MESSAGE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001265 ha_alert("parsing [%s:%d] : '%s' must be between %d and %d inclusive (was %s).\n",
1266 file, linenum, args[0], DNS_HEADER_SIZE, DNS_MAX_UDP_MESSAGE, args[1]);
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001267 err_code |= ERR_ALERT | ERR_FATAL;
1268 goto out;
1269 }
1270
1271 curr_resolvers->accepted_payload_size = i;
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001272 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001273 else if (strcmp(args[0], "resolution_pool_size") == 0) {
Tim Duesterhus3506dae2019-05-14 20:57:56 +02001274 ha_alert("parsing [%s:%d] : '%s' directive is not supported anymore (it never appeared in a stable release).\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01001275 file, linenum, args[0]);
Tim Duesterhus3506dae2019-05-14 20:57:56 +02001276 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001277 goto out;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001278 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001279 else if (strcmp(args[0], "resolve_retries") == 0) {
1280 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001281 ha_alert("parsing [%s:%d] : '%s' expects <nb> as argument.\n",
1282 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001283 err_code |= ERR_ALERT | ERR_FATAL;
1284 goto out;
1285 }
1286 curr_resolvers->resolve_retries = atoi(args[1]);
1287 }
1288 else if (strcmp(args[0], "timeout") == 0) {
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001289 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001290 ha_alert("parsing [%s:%d] : '%s' expects 'retry' or 'resolve' and <time> as arguments.\n",
1291 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001292 err_code |= ERR_ALERT | ERR_FATAL;
1293 goto out;
1294 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001295 else if (strcmp(args[1], "retry") == 0 ||
1296 strcmp(args[1], "resolve") == 0) {
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001297 const char *res;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001298 unsigned int tout;
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001299
1300 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001301 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1302 file, linenum, args[0], args[1]);
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001303 err_code |= ERR_ALERT | ERR_FATAL;
1304 goto out;
1305 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001306 res = parse_time_err(args[2], &tout, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001307 if (res == PARSE_TIME_OVER) {
1308 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1309 file, linenum, args[2], args[0], args[1]);
1310 err_code |= ERR_ALERT | ERR_FATAL;
1311 goto out;
1312 }
1313 else if (res == PARSE_TIME_UNDER) {
1314 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1315 file, linenum, args[2], args[0], args[1]);
1316 err_code |= ERR_ALERT | ERR_FATAL;
1317 goto out;
1318 }
1319 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001320 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1321 file, linenum, *res, args[0], args[1]);
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001322 err_code |= ERR_ALERT | ERR_FATAL;
1323 goto out;
1324 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001325 if (args[1][2] == 't')
1326 curr_resolvers->timeout.retry = tout;
1327 else
1328 curr_resolvers->timeout.resolve = tout;
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001329 }
1330 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001331 ha_alert("parsing [%s:%d] : '%s' expects 'retry' or 'resolve' and <time> as arguments got '%s'.\n",
1332 file, linenum, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001333 err_code |= ERR_ALERT | ERR_FATAL;
1334 goto out;
1335 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001336 } /* neither "nameserver" nor "resolvers" */
1337 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001338 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001339 err_code |= ERR_ALERT | ERR_FATAL;
1340 goto out;
1341 }
1342
1343 out:
1344 free(errmsg);
1345 return err_code;
1346}
Simon Horman0d16a402015-01-30 11:22:58 +09001347
1348/*
William Lallemand51097192015-04-14 16:35:22 +02001349 * Parse a line in a <listen>, <frontend> or <backend> section.
Simon Horman0d16a402015-01-30 11:22:58 +09001350 * Returns the error code, 0 if OK, or any combination of :
1351 * - ERR_ABORT: must abort ASAP
1352 * - ERR_FATAL: we can continue parsing but not start the service
1353 * - ERR_WARN: a warning has been emitted
1354 * - ERR_ALERT: an alert has been emitted
1355 * Only the two first ones can stop processing, the two others are just
1356 * indicators.
1357 */
1358int cfg_parse_mailers(const char *file, int linenum, char **args, int kwm)
1359{
1360 static struct mailers *curmailers = NULL;
1361 struct mailer *newmailer = NULL;
1362 const char *err;
1363 int err_code = 0;
1364 char *errmsg = NULL;
1365
1366 if (strcmp(args[0], "mailers") == 0) { /* new mailers section */
1367 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001368 ha_alert("parsing [%s:%d] : missing name for mailers section.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001369 err_code |= ERR_ALERT | ERR_ABORT;
1370 goto out;
1371 }
1372
1373 err = invalid_char(args[1]);
1374 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001375 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
1376 file, linenum, *err, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001377 err_code |= ERR_ALERT | ERR_ABORT;
1378 goto out;
1379 }
1380
1381 for (curmailers = mailers; curmailers != NULL; curmailers = curmailers->next) {
1382 /*
1383 * If there are two proxies with the same name only following
1384 * combinations are allowed:
1385 */
1386 if (strcmp(curmailers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001387 ha_alert("Parsing [%s:%d]: mailers section '%s' has the same name as another mailers section declared at %s:%d.\n",
1388 file, linenum, args[1], curmailers->conf.file, curmailers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +02001389 err_code |= ERR_ALERT | ERR_FATAL;
Simon Horman0d16a402015-01-30 11:22:58 +09001390 }
1391 }
1392
Vincent Bernat02779b62016-04-03 13:48:43 +02001393 if ((curmailers = calloc(1, sizeof(*curmailers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001394 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001395 err_code |= ERR_ALERT | ERR_ABORT;
1396 goto out;
1397 }
1398
1399 curmailers->next = mailers;
1400 mailers = curmailers;
1401 curmailers->conf.file = strdup(file);
1402 curmailers->conf.line = linenum;
1403 curmailers->id = strdup(args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001404 curmailers->timeout.mail = DEF_MAILALERTTIME;/* XXX: Would like to Skip to the next alert, if any, ASAP.
1405 * But need enough time so that timeouts don't occur
1406 * during tcp procssing. For now just us an arbitrary default. */
Simon Horman0d16a402015-01-30 11:22:58 +09001407 }
1408 else if (strcmp(args[0], "mailer") == 0) { /* mailer definition */
1409 struct sockaddr_storage *sk;
1410 int port1, port2;
1411 struct protocol *proto;
1412
1413 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001414 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1415 file, linenum, args[0]);
Simon Horman0d16a402015-01-30 11:22:58 +09001416 err_code |= ERR_ALERT | ERR_FATAL;
1417 goto out;
1418 }
1419
1420 err = invalid_char(args[1]);
1421 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001422 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1423 file, linenum, *err, args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001424 err_code |= ERR_ALERT | ERR_FATAL;
1425 goto out;
1426 }
1427
Vincent Bernat02779b62016-04-03 13:48:43 +02001428 if ((newmailer = calloc(1, sizeof(*newmailer))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001429 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001430 err_code |= ERR_ALERT | ERR_ABORT;
1431 goto out;
1432 }
1433
1434 /* the mailers are linked backwards first */
1435 curmailers->count++;
1436 newmailer->next = curmailers->mailer_list;
1437 curmailers->mailer_list = newmailer;
1438 newmailer->mailers = curmailers;
1439 newmailer->conf.file = strdup(file);
1440 newmailer->conf.line = linenum;
1441
1442 newmailer->id = strdup(args[1]);
1443
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001444 sk = str2sa_range(args[2], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
Simon Horman0d16a402015-01-30 11:22:58 +09001445 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001446 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Simon Horman0d16a402015-01-30 11:22:58 +09001447 err_code |= ERR_ALERT | ERR_FATAL;
1448 goto out;
1449 }
1450
1451 proto = protocol_by_family(sk->ss_family);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09001452 if (!proto || !proto->connect || proto->sock_prot != IPPROTO_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001453 ha_alert("parsing [%s:%d] : '%s %s' : TCP not supported for this address family.\n",
1454 file, linenum, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001455 err_code |= ERR_ALERT | ERR_FATAL;
1456 goto out;
1457 }
1458
1459 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001460 ha_alert("parsing [%s:%d] : '%s %s' : port ranges and offsets are not allowed in '%s'\n",
1461 file, linenum, args[0], args[1], args[2]);
Simon Horman0d16a402015-01-30 11:22:58 +09001462 err_code |= ERR_ALERT | ERR_FATAL;
1463 goto out;
1464 }
1465
1466 if (!port1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001467 ha_alert("parsing [%s:%d] : '%s %s' : missing or invalid port in '%s'\n",
1468 file, linenum, args[0], args[1], args[2]);
Simon Horman0d16a402015-01-30 11:22:58 +09001469 err_code |= ERR_ALERT | ERR_FATAL;
1470 goto out;
1471 }
1472
1473 newmailer->addr = *sk;
1474 newmailer->proto = proto;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01001475 newmailer->xprt = xprt_get(XPRT_RAW);
Simon Horman0d16a402015-01-30 11:22:58 +09001476 newmailer->sock_init_arg = NULL;
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001477 }
1478 else if (strcmp(args[0], "timeout") == 0) {
1479 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001480 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments.\n",
1481 file, linenum, args[0]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001482 err_code |= ERR_ALERT | ERR_FATAL;
1483 goto out;
1484 }
1485 else if (strcmp(args[1], "mail") == 0) {
1486 const char *res;
1487 unsigned int timeout_mail;
1488 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001489 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1490 file, linenum, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001491 err_code |= ERR_ALERT | ERR_FATAL;
1492 goto out;
1493 }
1494 res = parse_time_err(args[2], &timeout_mail, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001495 if (res == PARSE_TIME_OVER) {
1496 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1497 file, linenum, args[2], args[0], args[1]);
1498 err_code |= ERR_ALERT | ERR_FATAL;
1499 goto out;
1500 }
1501 else if (res == PARSE_TIME_UNDER) {
1502 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1503 file, linenum, args[2], args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001504 err_code |= ERR_ALERT | ERR_FATAL;
1505 goto out;
1506 }
Willy Tarreau9faebe32019-06-07 19:00:37 +02001507 else if (res) {
1508 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1509 file, linenum, *res, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001510 err_code |= ERR_ALERT | ERR_FATAL;
1511 goto out;
1512 }
1513 curmailers->timeout.mail = timeout_mail;
1514 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001515 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments got '%s'.\n",
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001516 file, linenum, args[0], args[1]);
1517 err_code |= ERR_ALERT | ERR_FATAL;
1518 goto out;
1519 }
1520 }
Simon Horman0d16a402015-01-30 11:22:58 +09001521 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001522 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Simon Horman0d16a402015-01-30 11:22:58 +09001523 err_code |= ERR_ALERT | ERR_FATAL;
1524 goto out;
1525 }
1526
1527out:
1528 free(errmsg);
1529 return err_code;
1530}
1531
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +01001532void free_email_alert(struct proxy *p)
Simon Horman9dc49962015-01-30 11:22:59 +09001533{
1534 free(p->email_alert.mailers.name);
1535 p->email_alert.mailers.name = NULL;
1536 free(p->email_alert.from);
1537 p->email_alert.from = NULL;
1538 free(p->email_alert.to);
1539 p->email_alert.to = NULL;
1540 free(p->email_alert.myhostname);
1541 p->email_alert.myhostname = NULL;
1542}
1543
Willy Tarreaubaaee002006-06-26 02:48:02 +02001544
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001545int
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001546cfg_parse_netns(const char *file, int linenum, char **args, int kwm)
1547{
Willy Tarreaue5733232019-05-22 19:24:06 +02001548#ifdef USE_NS
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001549 const char *err;
1550 const char *item = args[0];
1551
1552 if (!strcmp(item, "namespace_list")) {
1553 return 0;
1554 }
1555 else if (!strcmp(item, "namespace")) {
1556 size_t idx = 1;
1557 const char *current;
1558 while (*(current = args[idx++])) {
1559 err = invalid_char(current);
1560 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001561 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1562 file, linenum, *err, item, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001563 return ERR_ALERT | ERR_FATAL;
1564 }
1565
1566 if (netns_store_lookup(current, strlen(current))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001567 ha_alert("parsing [%s:%d]: Namespace '%s' is already added.\n",
1568 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001569 return ERR_ALERT | ERR_FATAL;
1570 }
1571 if (!netns_store_insert(current)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001572 ha_alert("parsing [%s:%d]: Cannot open namespace '%s'.\n",
1573 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001574 return ERR_ALERT | ERR_FATAL;
1575 }
1576 }
1577 }
1578
1579 return 0;
1580#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001581 ha_alert("parsing [%s:%d]: namespace support is not compiled in.",
1582 file, linenum);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001583 return ERR_ALERT | ERR_FATAL;
1584#endif
1585}
1586
1587int
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001588cfg_parse_users(const char *file, int linenum, char **args, int kwm)
1589{
1590
1591 int err_code = 0;
1592 const char *err;
1593
1594 if (!strcmp(args[0], "userlist")) { /* new userlist */
1595 struct userlist *newul;
1596
1597 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001598 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1599 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001600 err_code |= ERR_ALERT | ERR_FATAL;
1601 goto out;
1602 }
William Lallemand6e62fb62015-04-28 16:55:23 +02001603 if (alertif_too_many_args(1, file, linenum, args, &err_code))
1604 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001605
1606 err = invalid_char(args[1]);
1607 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001608 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1609 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001610 err_code |= ERR_ALERT | ERR_FATAL;
1611 goto out;
1612 }
1613
1614 for (newul = userlist; newul; newul = newul->next)
1615 if (!strcmp(newul->name, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001616 ha_warning("parsing [%s:%d]: ignoring duplicated userlist '%s'.\n",
1617 file, linenum, args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001618 err_code |= ERR_WARN;
1619 goto out;
1620 }
1621
Vincent Bernat02779b62016-04-03 13:48:43 +02001622 newul = calloc(1, sizeof(*newul));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001623 if (!newul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001624 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001625 err_code |= ERR_ALERT | ERR_ABORT;
1626 goto out;
1627 }
1628
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001629 newul->name = strdup(args[1]);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001630 if (!newul->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001631 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001632 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier97880bb2016-04-08 10:35:26 +01001633 free(newul);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001634 goto out;
1635 }
1636
1637 newul->next = userlist;
1638 userlist = newul;
1639
1640 } else if (!strcmp(args[0], "group")) { /* new group */
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001641 int cur_arg;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001642 const char *err;
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001643 struct auth_groups *ag;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001644
1645 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001646 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1647 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001648 err_code |= ERR_ALERT | ERR_FATAL;
1649 goto out;
1650 }
1651
1652 err = invalid_char(args[1]);
1653 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001654 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1655 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001656 err_code |= ERR_ALERT | ERR_FATAL;
1657 goto out;
1658 }
1659
William Lallemand4ac9f542015-05-28 18:03:51 +02001660 if (!userlist)
1661 goto out;
1662
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001663 for (ag = userlist->groups; ag; ag = ag->next)
1664 if (!strcmp(ag->name, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001665 ha_warning("parsing [%s:%d]: ignoring duplicated group '%s' in userlist '%s'.\n",
1666 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001667 err_code |= ERR_ALERT;
1668 goto out;
1669 }
1670
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001671 ag = calloc(1, sizeof(*ag));
1672 if (!ag) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001673 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001674 err_code |= ERR_ALERT | ERR_ABORT;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001675 goto out;
1676 }
1677
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001678 ag->name = strdup(args[1]);
David Carlier70d60452016-08-22 23:27:42 +01001679 if (!ag->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001680 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001681 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier70d60452016-08-22 23:27:42 +01001682 free(ag);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001683 goto out;
1684 }
1685
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001686 cur_arg = 2;
1687
1688 while (*args[cur_arg]) {
1689 if (!strcmp(args[cur_arg], "users")) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001690 ag->groupusers = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001691 cur_arg += 2;
1692 continue;
1693 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001694 ha_alert("parsing [%s:%d]: '%s' only supports 'users' option.\n",
1695 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001696 err_code |= ERR_ALERT | ERR_FATAL;
David Carlier70d60452016-08-22 23:27:42 +01001697 free(ag->groupusers);
1698 free(ag->name);
1699 free(ag);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001700 goto out;
1701 }
1702 }
1703
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001704 ag->next = userlist->groups;
1705 userlist->groups = ag;
1706
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001707 } else if (!strcmp(args[0], "user")) { /* new user */
1708 struct auth_users *newuser;
1709 int cur_arg;
1710
1711 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001712 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1713 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001714 err_code |= ERR_ALERT | ERR_FATAL;
1715 goto out;
1716 }
William Lallemand4ac9f542015-05-28 18:03:51 +02001717 if (!userlist)
1718 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001719
1720 for (newuser = userlist->users; newuser; newuser = newuser->next)
1721 if (!strcmp(newuser->user, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001722 ha_warning("parsing [%s:%d]: ignoring duplicated user '%s' in userlist '%s'.\n",
1723 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001724 err_code |= ERR_ALERT;
1725 goto out;
1726 }
1727
Vincent Bernat02779b62016-04-03 13:48:43 +02001728 newuser = calloc(1, sizeof(*newuser));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001729 if (!newuser) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001730 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001731 err_code |= ERR_ALERT | ERR_ABORT;
1732 goto out;
1733 }
1734
1735 newuser->user = strdup(args[1]);
1736
1737 newuser->next = userlist->users;
1738 userlist->users = newuser;
1739
1740 cur_arg = 2;
1741
1742 while (*args[cur_arg]) {
1743 if (!strcmp(args[cur_arg], "password")) {
Willy Tarreaue5733232019-05-22 19:24:06 +02001744#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001745 if (!crypt("", args[cur_arg + 1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001746 ha_alert("parsing [%s:%d]: the encrypted password used for user '%s' is not supported by crypt(3).\n",
1747 file, linenum, newuser->user);
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001748 err_code |= ERR_ALERT | ERR_FATAL;
1749 goto out;
1750 }
1751#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001752 ha_warning("parsing [%s:%d]: no crypt(3) support compiled, encrypted passwords will not work.\n",
1753 file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001754 err_code |= ERR_ALERT;
1755#endif
1756 newuser->pass = strdup(args[cur_arg + 1]);
1757 cur_arg += 2;
1758 continue;
1759 } else if (!strcmp(args[cur_arg], "insecure-password")) {
1760 newuser->pass = strdup(args[cur_arg + 1]);
1761 newuser->flags |= AU_O_INSECURE;
1762 cur_arg += 2;
1763 continue;
1764 } else if (!strcmp(args[cur_arg], "groups")) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001765 newuser->u.groups_names = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001766 cur_arg += 2;
1767 continue;
1768 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001769 ha_alert("parsing [%s:%d]: '%s' only supports 'password', 'insecure-password' and 'groups' options.\n",
1770 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001771 err_code |= ERR_ALERT | ERR_FATAL;
1772 goto out;
1773 }
1774 }
1775 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001776 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 +01001777 err_code |= ERR_ALERT | ERR_FATAL;
1778 }
1779
1780out:
1781 return err_code;
1782}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001783
Christopher Faulet79bdef32016-11-04 22:36:15 +01001784int
1785cfg_parse_scope(const char *file, int linenum, char *line)
1786{
1787 char *beg, *end, *scope = NULL;
1788 int err_code = 0;
1789 const char *err;
1790
1791 beg = line + 1;
1792 end = strchr(beg, ']');
1793
1794 /* Detect end of scope declaration */
1795 if (!end || end == beg) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001796 ha_alert("parsing [%s:%d] : empty scope name is forbidden.\n",
1797 file, linenum);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001798 err_code |= ERR_ALERT | ERR_FATAL;
1799 goto out;
1800 }
1801
1802 /* Get scope name and check its validity */
1803 scope = my_strndup(beg, end-beg);
1804 err = invalid_char(scope);
1805 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001806 ha_alert("parsing [%s:%d] : character '%c' is not permitted in a scope name.\n",
1807 file, linenum, *err);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001808 err_code |= ERR_ALERT | ERR_ABORT;
1809 goto out;
1810 }
1811
1812 /* Be sure to have a scope declaration alone on its line */
1813 line = end+1;
1814 while (isspace((unsigned char)*line))
1815 line++;
1816 if (*line && *line != '#' && *line != '\n' && *line != '\r') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001817 ha_alert("parsing [%s:%d] : character '%c' is not permitted after scope declaration.\n",
1818 file, linenum, *line);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001819 err_code |= ERR_ALERT | ERR_ABORT;
1820 goto out;
1821 }
1822
1823 /* We have a valid scope declaration, save it */
1824 free(cfg_scope);
1825 cfg_scope = scope;
1826 scope = NULL;
1827
1828 out:
1829 free(scope);
1830 return err_code;
1831}
1832
Frédéric Lécaillea41d5312018-01-29 12:05:07 +01001833int
1834cfg_parse_track_sc_num(unsigned int *track_sc_num,
1835 const char *arg, const char *end, char **errmsg)
1836{
1837 const char *p;
1838 unsigned int num;
1839
1840 p = arg;
1841 num = read_uint64(&arg, end);
1842
1843 if (arg != end) {
1844 memprintf(errmsg, "Wrong track-sc number '%s'", p);
1845 return -1;
1846 }
1847
1848 if (num >= MAX_SESS_STKCTR) {
1849 memprintf(errmsg, "%u track-sc number exceeding "
1850 "%d (MAX_SESS_STKCTR-1) value", num, MAX_SESS_STKCTR - 1);
1851 return -1;
1852 }
1853
1854 *track_sc_num = num;
1855 return 0;
1856}
1857
Willy Tarreaubaaee002006-06-26 02:48:02 +02001858/*
1859 * This function reads and parses the configuration file given in the argument.
Willy Tarreau058e9072009-07-20 09:30:05 +02001860 * Returns the error code, 0 if OK, or any combination of :
1861 * - ERR_ABORT: must abort ASAP
1862 * - ERR_FATAL: we can continue parsing but not start the service
1863 * - ERR_WARN: a warning has been emitted
1864 * - ERR_ALERT: an alert has been emitted
1865 * Only the two first ones can stop processing, the two others are just
1866 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001867 */
Willy Tarreaub17916e2006-10-15 15:17:57 +02001868int readcfgfile(const char *file)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001869{
William Lallemand64e84512015-05-12 14:25:37 +02001870 char *thisline;
1871 int linesize = LINESIZE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001872 FILE *f;
1873 int linenum = 0;
Willy Tarreau058e9072009-07-20 09:30:05 +02001874 int err_code = 0;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001875 struct cfg_section *cs = NULL, *pcs = NULL;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001876 struct cfg_section *ics;
William Lallemand64e84512015-05-12 14:25:37 +02001877 int readbytes = 0;
1878
1879 if ((thisline = malloc(sizeof(*thisline) * linesize)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001880 ha_alert("parsing [%s] : out of memory.\n", file);
William Lallemand64e84512015-05-12 14:25:37 +02001881 return -1;
1882 }
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001883
David Carlier97880bb2016-04-08 10:35:26 +01001884 if ((f=fopen(file,"r")) == NULL) {
1885 free(thisline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001886 return -1;
David Carlier97880bb2016-04-08 10:35:26 +01001887 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001888
William Lallemandb2f07452015-05-12 14:27:13 +02001889next_line:
William Lallemand64e84512015-05-12 14:25:37 +02001890 while (fgets(thisline + readbytes, linesize - readbytes, f) != NULL) {
Willy Tarreau3842f002009-06-14 11:39:52 +02001891 int arg, kwm = KWM_STD;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001892 char *end;
1893 char *args[MAX_LINE_ARGS + 1];
1894 char *line = thisline;
William Lallemandf9873ba2015-05-05 17:37:14 +02001895 int dquote = 0; /* double quote */
1896 int squote = 0; /* simple quote */
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001897
Willy Tarreaubaaee002006-06-26 02:48:02 +02001898 linenum++;
1899
1900 end = line + strlen(line);
1901
William Lallemand64e84512015-05-12 14:25:37 +02001902 if (end-line == linesize-1 && *(end-1) != '\n') {
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001903 /* Check if we reached the limit and the last char is not \n.
1904 * Watch out for the last line without the terminating '\n'!
1905 */
William Lallemand64e84512015-05-12 14:25:37 +02001906 char *newline;
1907 int newlinesize = linesize * 2;
1908
1909 newline = realloc(thisline, sizeof(*thisline) * newlinesize);
1910 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001911 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1912 file, linenum);
William Lallemand64e84512015-05-12 14:25:37 +02001913 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau4d4dda12020-06-25 09:37:54 +02001914 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001915 continue;
1916 }
1917
1918 readbytes = linesize - 1;
1919 linesize = newlinesize;
1920 thisline = newline;
Willy Tarreau4d4dda12020-06-25 09:37:54 +02001921 linenum--;
William Lallemand64e84512015-05-12 14:25:37 +02001922 continue;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001923 }
1924
William Lallemand64e84512015-05-12 14:25:37 +02001925 readbytes = 0;
1926
Willy Tarreaubaaee002006-06-26 02:48:02 +02001927 /* skip leading spaces */
Willy Tarreau8f8e6452007-06-17 21:51:38 +02001928 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001929 line++;
William Lallemandf9873ba2015-05-05 17:37:14 +02001930
Christopher Faulet79bdef32016-11-04 22:36:15 +01001931
Joseph Herlanta14c03e2018-11-15 14:04:19 -08001932 if (*line == '[') {/* This is the beginning if a scope */
Christopher Faulet79bdef32016-11-04 22:36:15 +01001933 err_code |= cfg_parse_scope(file, linenum, line);
1934 goto next_line;
1935 }
1936
Willy Tarreaubaaee002006-06-26 02:48:02 +02001937 arg = 0;
1938 args[arg] = line;
1939
1940 while (*line && arg < MAX_LINE_ARGS) {
William Lallemandf9873ba2015-05-05 17:37:14 +02001941 if (*line == '"' && !squote) { /* double quote outside single quotes */
1942 if (dquote)
1943 dquote = 0;
1944 else
1945 dquote = 1;
William Lallemand3f415602015-05-12 14:01:09 +02001946 memmove(line, line + 1, end - line);
William Lallemandf9873ba2015-05-05 17:37:14 +02001947 end--;
1948 }
1949 else if (*line == '\'' && !dquote) { /* single quote outside double quotes */
1950 if (squote)
1951 squote = 0;
1952 else
1953 squote = 1;
William Lallemand3f415602015-05-12 14:01:09 +02001954 memmove(line, line + 1, end - line);
William Lallemandf9873ba2015-05-05 17:37:14 +02001955 end--;
1956 }
1957 else if (*line == '\\' && !squote) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001958 /* first, we'll replace \\, \<space>, \#, \r, \n, \t, \xXX with their
1959 * C equivalent value. Other combinations left unchanged (eg: \1).
1960 */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001961 int skip = 0;
1962 if (line[1] == ' ' || line[1] == '\\' || line[1] == '#') {
1963 *line = line[1];
1964 skip = 1;
1965 }
1966 else if (line[1] == 'r') {
1967 *line = '\r';
1968 skip = 1;
William Lallemandf9873ba2015-05-05 17:37:14 +02001969 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001970 else if (line[1] == 'n') {
1971 *line = '\n';
1972 skip = 1;
1973 }
1974 else if (line[1] == 't') {
1975 *line = '\t';
1976 skip = 1;
1977 }
1978 else if (line[1] == 'x') {
Emeric Brunb982a3d2010-01-04 15:45:53 +01001979 if ((line + 3 < end) && ishex(line[2]) && ishex(line[3])) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001980 unsigned char hex1, hex2;
1981 hex1 = toupper(line[2]) - '0';
1982 hex2 = toupper(line[3]) - '0';
1983 if (hex1 > 9) hex1 -= 'A' - '9' - 1;
1984 if (hex2 > 9) hex2 -= 'A' - '9' - 1;
1985 *line = (hex1<<4) + hex2;
1986 skip = 3;
1987 }
1988 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001989 ha_alert("parsing [%s:%d] : invalid or incomplete '\\x' sequence in '%s'.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02001990 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus9f244222020-05-07 19:21:31 +02001991 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001992 }
William Lallemandf9873ba2015-05-05 17:37:14 +02001993 } else if (line[1] == '"') {
1994 *line = '"';
1995 skip = 1;
1996 } else if (line[1] == '\'') {
1997 *line = '\'';
1998 skip = 1;
William Lallemandb2f07452015-05-12 14:27:13 +02001999 } else if (line[1] == '$' && dquote) { /* escaping of $ only inside double quotes */
2000 *line = '$';
2001 skip = 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002002 }
2003 if (skip) {
Cyril Bontédd1b01d2009-12-06 13:43:42 +01002004 memmove(line + 1, line + 1 + skip, end - (line + skip));
Willy Tarreaubaaee002006-06-26 02:48:02 +02002005 end -= skip;
2006 }
2007 line++;
2008 }
William Lallemandf9873ba2015-05-05 17:37:14 +02002009 else if ((!squote && !dquote && *line == '#') || *line == '\n' || *line == '\r') {
Willy Tarreaubaaee002006-06-26 02:48:02 +02002010 /* end of string, end of loop */
2011 *line = 0;
2012 break;
2013 }
William Lallemandf9873ba2015-05-05 17:37:14 +02002014 else if (!squote && !dquote && isspace((unsigned char)*line)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02002015 /* a non-escaped space is an argument separator */
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01002016 *line++ = '\0';
Willy Tarreau8f8e6452007-06-17 21:51:38 +02002017 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02002018 line++;
2019 args[++arg] = line;
2020 }
William Lallemandb2f07452015-05-12 14:27:13 +02002021 else if (dquote && *line == '$') {
2022 /* environment variables are evaluated inside double quotes */
2023 char *var_beg;
2024 char *var_end;
2025 char save_char;
2026 char *value;
2027 int val_len;
2028 int newlinesize;
2029 int braces = 0;
2030
2031 var_beg = line + 1;
2032 var_end = var_beg;
2033
2034 if (*var_beg == '{') {
2035 var_beg++;
2036 var_end++;
2037 braces = 1;
2038 }
2039
2040 if (!isalpha((int)(unsigned char)*var_beg) && *var_beg != '_') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002041 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 +02002042 err_code |= ERR_ALERT | ERR_FATAL;
2043 goto next_line; /* skip current line */
2044 }
2045
2046 while (isalnum((int)(unsigned char)*var_end) || *var_end == '_')
2047 var_end++;
2048
2049 save_char = *var_end;
2050 *var_end = '\0';
2051 value = getenv(var_beg);
2052 *var_end = save_char;
2053 val_len = value ? strlen(value) : 0;
2054
2055 if (braces) {
2056 if (*var_end == '}') {
2057 var_end++;
2058 braces = 0;
2059 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002060 ha_alert("parsing [%s:%d] : Variable expansion: Mismatched braces.\n", file, linenum);
William Lallemandb2f07452015-05-12 14:27:13 +02002061 err_code |= ERR_ALERT | ERR_FATAL;
2062 goto next_line; /* skip current line */
2063 }
2064 }
2065
2066 newlinesize = (end - thisline) - (var_end - line) + val_len + 1;
2067
2068 /* if not enough space in thisline */
2069 if (newlinesize > linesize) {
2070 char *newline;
2071
2072 newline = realloc(thisline, newlinesize * sizeof(*thisline));
2073 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002074 ha_alert("parsing [%s:%d] : Variable expansion: Not enough memory.\n", file, linenum);
William Lallemandb2f07452015-05-12 14:27:13 +02002075 err_code |= ERR_ALERT | ERR_FATAL;
2076 goto next_line; /* slip current line */
2077 }
2078 /* recompute pointers if realloc returns a new pointer */
2079 if (newline != thisline) {
2080 int i;
2081 int diff;
2082
2083 for (i = 0; i <= arg; i++) {
2084 diff = args[i] - thisline;
2085 args[i] = newline + diff;
2086 }
2087
2088 diff = var_end - thisline;
2089 var_end = newline + diff;
2090 diff = end - thisline;
2091 end = newline + diff;
2092 diff = line - thisline;
2093 line = newline + diff;
2094 thisline = newline;
2095 }
2096 linesize = newlinesize;
2097 }
2098
2099 /* insert value inside the line */
2100 memmove(line + val_len, var_end, end - var_end + 1);
2101 memcpy(line, value, val_len);
2102 end += val_len - (var_end - line);
2103 line += val_len;
2104 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002105 else {
2106 line++;
2107 }
2108 }
William Lallemandb2f07452015-05-12 14:27:13 +02002109
William Lallemandf9873ba2015-05-05 17:37:14 +02002110 if (dquote) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002111 ha_alert("parsing [%s:%d] : Mismatched double quotes.\n", file, linenum);
William Lallemandf9873ba2015-05-05 17:37:14 +02002112 err_code |= ERR_ALERT | ERR_FATAL;
2113 }
2114
2115 if (squote) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002116 ha_alert("parsing [%s:%d] : Mismatched simple quotes.\n", file, linenum);
William Lallemandf9873ba2015-05-05 17:37:14 +02002117 err_code |= ERR_ALERT | ERR_FATAL;
2118 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002119
2120 /* empty line */
2121 if (!**args)
2122 continue;
2123
Willy Tarreau7bb651e2009-11-09 21:16:53 +01002124 if (*line) {
2125 /* we had to stop due to too many args.
2126 * Let's terminate the string, print the offending part then cut the
2127 * last arg.
2128 */
2129 while (*line && *line != '#' && *line != '\n' && *line != '\r')
2130 line++;
2131 *line = '\0';
2132
Christopher Faulet767a84b2017-11-24 16:50:31 +01002133 ha_alert("parsing [%s:%d]: line too long, truncating at word %d, position %ld: <%s>.\n",
2134 file, linenum, arg + 1, (long)(args[arg] - thisline + 1), args[arg]);
Willy Tarreau7bb651e2009-11-09 21:16:53 +01002135 err_code |= ERR_ALERT | ERR_FATAL;
2136 args[arg] = line;
2137 }
2138
Willy Tarreau540abe42007-05-02 20:50:16 +02002139 /* zero out remaining args and ensure that at least one entry
2140 * is zeroed out.
2141 */
2142 while (++arg <= MAX_LINE_ARGS) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02002143 args[arg] = line;
2144 }
2145
Willy Tarreau3842f002009-06-14 11:39:52 +02002146 /* check for keyword modifiers "no" and "default" */
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002147 if (!strcmp(args[0], "no")) {
William Lallemand0f99e342011-10-12 17:50:54 +02002148 char *tmp;
2149
Willy Tarreau3842f002009-06-14 11:39:52 +02002150 kwm = KWM_NO;
William Lallemand0f99e342011-10-12 17:50:54 +02002151 tmp = args[0];
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002152 for (arg=0; *args[arg+1]; arg++)
2153 args[arg] = args[arg+1]; // shift args after inversion
William Lallemand0f99e342011-10-12 17:50:54 +02002154 *tmp = '\0'; // fix the next arg to \0
2155 args[arg] = tmp;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002156 }
Willy Tarreau3842f002009-06-14 11:39:52 +02002157 else if (!strcmp(args[0], "default")) {
2158 kwm = KWM_DEF;
2159 for (arg=0; *args[arg+1]; arg++)
2160 args[arg] = args[arg+1]; // shift args after inversion
2161 }
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002162
William Lallemand0f99e342011-10-12 17:50:54 +02002163 if (kwm != KWM_STD && strcmp(args[0], "option") != 0 && \
Willy Tarreaubeb859a2018-11-22 18:07:59 +01002164 strcmp(args[0], "log") != 0 && strcmp(args[0], "busy-polling")) {
2165 ha_alert("parsing [%s:%d]: negation/default currently supported only for options, log, and busy-polling.\n", file, linenum);
Willy Tarreau058e9072009-07-20 09:30:05 +02002166 err_code |= ERR_ALERT | ERR_FATAL;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002167 }
2168
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002169 /* detect section start */
2170 list_for_each_entry(ics, &sections, list) {
2171 if (strcmp(args[0], ics->section_name) == 0) {
2172 cursection = ics->section_name;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002173 pcs = cs;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002174 cs = ics;
2175 break;
2176 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002177 }
2178
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002179 if (pcs && pcs->post_section_parser) {
2180 err_code |= pcs->post_section_parser();
2181 if (err_code & ERR_ABORT)
2182 goto err;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002183 }
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002184 pcs = NULL;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002185
William Lallemandd2ff56d2017-10-16 11:06:50 +02002186 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002187 ha_alert("parsing [%s:%d]: unknown keyword '%s' out of section.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02002188 err_code |= ERR_ALERT | ERR_FATAL;
William Lallemandd2ff56d2017-10-16 11:06:50 +02002189 } else {
William Lallemandd2ff56d2017-10-16 11:06:50 +02002190 err_code |= cs->section_parser(file, linenum, args, kwm);
2191 if (err_code & ERR_ABORT)
2192 goto err;
2193 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002194 }
William Lallemandd2ff56d2017-10-16 11:06:50 +02002195
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002196 if (cs && cs->post_section_parser)
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002197 err_code |= cs->post_section_parser();
William Lallemandd2ff56d2017-10-16 11:06:50 +02002198
2199err:
Christopher Faulet79bdef32016-11-04 22:36:15 +01002200 free(cfg_scope);
2201 cfg_scope = NULL;
Willy Tarreau6daf3432008-01-22 16:44:08 +01002202 cursection = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02002203 free(thisline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002204 fclose(f);
Willy Tarreau058e9072009-07-20 09:30:05 +02002205 return err_code;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002206}
2207
Willy Tarreau64ab6072014-09-16 12:17:36 +02002208/* This function propagates processes from frontend <from> to backend <to> so
2209 * that it is always guaranteed that a backend pointed to by a frontend is
2210 * bound to all of its processes. After that, if the target is a "listen"
2211 * instance, the function recursively descends the target's own targets along
Willy Tarreau98d04852015-05-26 12:18:29 +02002212 * default_backend and use_backend rules. Since the bits are
Willy Tarreau64ab6072014-09-16 12:17:36 +02002213 * checked first to ensure that <to> is already bound to all processes of
2214 * <from>, there is no risk of looping and we ensure to follow the shortest
2215 * path to the destination.
2216 *
2217 * It is possible to set <to> to NULL for the first call so that the function
2218 * takes care of visiting the initial frontend in <from>.
2219 *
2220 * It is important to note that the function relies on the fact that all names
2221 * have already been resolved.
2222 */
2223void propagate_processes(struct proxy *from, struct proxy *to)
2224{
2225 struct switching_rule *rule;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002226
2227 if (to) {
2228 /* check whether we need to go down */
2229 if (from->bind_proc &&
2230 (from->bind_proc & to->bind_proc) == from->bind_proc)
2231 return;
2232
2233 if (!from->bind_proc && !to->bind_proc)
2234 return;
2235
2236 to->bind_proc = from->bind_proc ?
2237 (to->bind_proc | from->bind_proc) : 0;
2238
2239 /* now propagate down */
2240 from = to;
2241 }
2242
Willy Tarreau8a95d8c2014-12-18 13:56:26 +01002243 if (!(from->cap & PR_CAP_FE))
Willy Tarreau64ab6072014-09-16 12:17:36 +02002244 return;
2245
Willy Tarreauf6b70012014-12-18 14:00:43 +01002246 if (from->state == PR_STSTOPPED)
2247 return;
2248
Willy Tarreau64ab6072014-09-16 12:17:36 +02002249 /* default_backend */
2250 if (from->defbe.be)
2251 propagate_processes(from, from->defbe.be);
2252
2253 /* use_backend */
2254 list_for_each_entry(rule, &from->switching_rules, list) {
Cyril Bonté51639692014-10-02 19:56:25 +02002255 if (rule->dynamic)
2256 continue;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002257 to = rule->be.backend;
2258 propagate_processes(from, to);
2259 }
Willy Tarreau64ab6072014-09-16 12:17:36 +02002260}
2261
Willy Tarreaubb925012009-07-23 13:36:36 +02002262/*
2263 * Returns the error code, 0 if OK, or any combination of :
2264 * - ERR_ABORT: must abort ASAP
2265 * - ERR_FATAL: we can continue parsing but not start the service
2266 * - ERR_WARN: a warning has been emitted
2267 * - ERR_ALERT: an alert has been emitted
2268 * Only the two first ones can stop processing, the two others are just
2269 * indicators.
2270 */
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002271int check_config_validity()
2272{
2273 int cfgerr = 0;
2274 struct proxy *curproxy = NULL;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002275 struct stktable *t;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002276 struct server *newsrv = NULL;
Willy Tarreaubb925012009-07-23 13:36:36 +02002277 int err_code = 0;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002278 unsigned int next_pxid = 1;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002279 struct bind_conf *bind_conf;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002280 char *err;
William Lallemand48b4bb42017-10-23 14:36:34 +02002281 struct cfg_postparser *postparser;
Ben Draut054fbee2018-04-13 15:43:04 -06002282 struct dns_resolvers *curr_resolvers = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002283
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002284 bind_conf = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002285 /*
2286 * Now, check for the integrity of all that we have collected.
2287 */
2288
2289 /* will be needed further to delay some tasks */
Willy Tarreaub0b37bc2008-06-23 14:00:57 +02002290 tv_update_date(0,1);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002291
Willy Tarreau193b8c62012-11-22 00:17:38 +01002292 if (!global.tune.max_http_hdr)
2293 global.tune.max_http_hdr = MAX_HTTP_HDR;
2294
2295 if (!global.tune.cookie_len)
2296 global.tune.cookie_len = CAPTURE_LEN;
2297
Stéphane Cottin23e9e932017-05-18 08:58:41 +02002298 if (!global.tune.requri_len)
2299 global.tune.requri_len = REQURI_LEN;
2300
Willy Tarreau149ab772019-01-26 14:27:06 +01002301 if (!global.nbthread) {
2302 /* nbthread not set, thus automatic. In this case, and only if
2303 * running on a single process, we enable the same number of
2304 * threads as the number of CPUs the process is bound to. This
2305 * allows to easily control the number of threads using taskset.
2306 */
2307 global.nbthread = 1;
2308#if defined(USE_THREAD)
2309 if (global.nbproc == 1)
2310 global.nbthread = thread_cpus_enabled_at_boot;
2311 all_threads_mask = nbits(global.nbthread);
2312#endif
2313 }
2314
Willy Tarreau26f6ae12019-02-02 12:56:15 +01002315 if (global.nbproc > 1 && global.nbthread > 1) {
2316 ha_alert("config : cannot enable multiple processes if multiple threads are configured. Please use either nbproc or nbthread but not both.\n");
2317 err_code |= ERR_ALERT | ERR_FATAL;
2318 goto out;
2319 }
2320
Willy Tarreaubafbe012017-11-24 17:34:44 +01002321 pool_head_requri = create_pool("requri", global.tune.requri_len , MEM_F_SHARED);
Emeric Brun96fd9262017-07-05 13:33:16 +02002322
Willy Tarreaubafbe012017-11-24 17:34:44 +01002323 pool_head_capture = create_pool("capture", global.tune.cookie_len, MEM_F_SHARED);
Willy Tarreau193b8c62012-11-22 00:17:38 +01002324
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002325 /* Post initialisation of the users and groups lists. */
2326 err_code = userlist_postinit();
2327 if (err_code != ERR_NONE)
2328 goto out;
2329
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002330 /* first, we will invert the proxy list order */
2331 curproxy = NULL;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002332 while (proxies_list) {
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002333 struct proxy *next;
2334
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002335 next = proxies_list->next;
2336 proxies_list->next = curproxy;
2337 curproxy = proxies_list;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002338 if (!next)
2339 break;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002340 proxies_list = next;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002341 }
2342
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002343 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002344 struct switching_rule *rule;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002345 struct server_rule *srule;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002346 struct sticking_rule *mrule;
Christopher Faulete4e830d2017-09-18 14:51:41 +02002347 struct act_rule *arule;
Dragan Dosen1322d092015-09-22 16:05:32 +02002348 struct logsrv *tmplogsrv;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002349 unsigned int next_id;
Willy Tarreau16a21472012-11-19 12:39:59 +01002350 int nbproc;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002351
Willy Tarreau050536d2012-10-04 08:47:34 +02002352 if (curproxy->uuid < 0) {
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002353 /* proxy ID not set, use automatic numbering with first
2354 * spare entry starting with next_pxid.
2355 */
2356 next_pxid = get_next_id(&used_proxy_id, next_pxid);
2357 curproxy->conf.id.key = curproxy->uuid = next_pxid;
2358 eb32_insert(&used_proxy_id, &curproxy->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002359 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01002360 next_pxid++;
2361
Willy Tarreau55ea7572007-06-17 19:56:27 +02002362
Willy Tarreaubaaee002006-06-26 02:48:02 +02002363 if (curproxy->state == PR_STSTOPPED) {
Willy Tarreauda250db2008-10-12 12:07:48 +02002364 /* ensure we don't keep listeners uselessly bound */
2365 stop_proxy(curproxy);
Dragan Dosen7d61a332019-05-07 14:16:18 +02002366 if (curproxy->table) {
2367 free((void *)curproxy->table->peers.name);
2368 curproxy->table->peers.p = NULL;
2369 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002370 continue;
2371 }
2372
Willy Tarreau102df612014-05-07 23:56:38 +02002373 /* Check multi-process mode compatibility for the current proxy */
2374
2375 if (curproxy->bind_proc) {
2376 /* an explicit bind-process was specified, let's check how many
2377 * processes remain.
2378 */
David Carliere6c39412015-07-02 07:00:17 +00002379 nbproc = my_popcountl(curproxy->bind_proc);
Willy Tarreau102df612014-05-07 23:56:38 +02002380
Willy Tarreaua38a7172019-02-02 17:11:28 +01002381 curproxy->bind_proc &= all_proc_mask;
Willy Tarreau102df612014-05-07 23:56:38 +02002382 if (!curproxy->bind_proc && nbproc == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002383 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 +02002384 curproxy->bind_proc = 1;
2385 }
2386 else if (!curproxy->bind_proc && nbproc > 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002387 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 +02002388 curproxy->bind_proc = 0;
2389 }
2390 }
2391
Willy Tarreau3d209582014-05-09 17:06:11 +02002392 /* check and reduce the bind-proc of each listener */
2393 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
2394 unsigned long mask;
2395
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002396 /* HTTP frontends with "h2" as ALPN/NPN will work in
2397 * HTTP/2 and absolutely require buffers 16kB or larger.
2398 */
2399#ifdef USE_OPENSSL
2400 if (curproxy->mode == PR_MODE_HTTP && global.tune.bufsize < 16384) {
2401#ifdef OPENSSL_NPN_NEGOTIATED
2402 /* check NPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002403 if (bind_conf->ssl_conf.npn_str && strstr(bind_conf->ssl_conf.npn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002404 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",
2405 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002406 cfgerr++;
2407 }
2408#endif
2409#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
2410 /* check ALPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002411 if (bind_conf->ssl_conf.alpn_str && strstr(bind_conf->ssl_conf.alpn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002412 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",
2413 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002414 cfgerr++;
2415 }
2416#endif
2417 } /* HTTP && bufsize < 16384 */
2418#endif
2419
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002420 /* detect and address thread affinity inconsistencies */
Willy Tarreaua36b3242019-02-02 13:14:34 +01002421 mask = thread_mask(bind_conf->bind_thread);
Willy Tarreau3d957172019-02-02 18:00:17 +01002422 if (!(mask & all_threads_mask)) {
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002423 unsigned long new_mask = 0;
2424
2425 while (mask) {
Willy Tarreau0c026f42018-08-01 19:12:20 +02002426 new_mask |= mask & all_threads_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002427 mask >>= global.nbthread;
2428 }
2429
Willy Tarreaua36b3242019-02-02 13:14:34 +01002430 bind_conf->bind_thread = new_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002431 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",
2432 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line, new_mask);
2433 }
2434
2435 /* detect process and nbproc affinity inconsistencies */
Willy Tarreaua36b3242019-02-02 13:14:34 +01002436 mask = proc_mask(bind_conf->bind_proc) & proc_mask(curproxy->bind_proc);
2437 if (!(mask & all_proc_mask)) {
2438 mask = proc_mask(curproxy->bind_proc) & all_proc_mask;
2439 nbproc = my_popcountl(bind_conf->bind_proc);
2440 bind_conf->bind_proc = proc_mask(bind_conf->bind_proc) & mask;
Willy Tarreau3d209582014-05-09 17:06:11 +02002441
Willy Tarreaua36b3242019-02-02 13:14:34 +01002442 if (!bind_conf->bind_proc && nbproc == 1) {
2443 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",
2444 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
2445 bind_conf->bind_proc = mask & ~(mask - 1);
2446 }
2447 else if (!bind_conf->bind_proc && nbproc > 1) {
2448 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",
2449 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
2450 bind_conf->bind_proc = 0;
2451 }
Willy Tarreau3d209582014-05-09 17:06:11 +02002452 }
2453 }
2454
Willy Tarreauff01a212009-03-15 13:46:16 +01002455 switch (curproxy->mode) {
2456 case PR_MODE_HEALTH:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002457 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002458 if (!(curproxy->cap & PR_CAP_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002459 ha_alert("config : %s '%s' cannot be in health mode as it has no frontend capability.\n",
2460 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +01002461 cfgerr++;
2462 }
2463
2464 if (curproxy->srv != NULL)
Christopher Faulet767a84b2017-11-24 16:50:31 +01002465 ha_warning("config : servers will be ignored for %s '%s'.\n",
2466 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +01002467 break;
2468
2469 case PR_MODE_TCP:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002470 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002471 break;
2472
2473 case PR_MODE_HTTP:
Willy Tarreau25320b22013-03-24 07:22:08 +01002474 curproxy->http_needed = 1;
Willy Tarreauff01a212009-03-15 13:46:16 +01002475 break;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002476
2477 case PR_MODE_CLI:
2478 cfgerr += proxy_cfg_ensure_no_http(curproxy);
2479 break;
Willy Tarreauff01a212009-03-15 13:46:16 +01002480 }
2481
Willy Tarreau58aa5cc2018-02-08 09:55:09 +01002482 if (curproxy != global.stats_fe && (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->conf.listeners)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002483 ha_warning("config : %s '%s' has no 'bind' directive. Please declare it as a backend if this was intended.\n",
2484 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauf3934b82015-08-11 11:36:45 +02002485 err_code |= ERR_WARN;
2486 }
2487
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002488 if ((curproxy->cap & PR_CAP_BE) && (curproxy->mode != PR_MODE_HEALTH)) {
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002489 if (curproxy->lbprm.algo & BE_LB_KIND) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002490 if (curproxy->options & PR_O_TRANSP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002491 ha_alert("config : %s '%s' cannot use both transparent and balance mode.\n",
2492 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002493 cfgerr++;
2494 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002495#ifdef WE_DONT_SUPPORT_SERVERLESS_LISTENERS
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002496 else if (curproxy->srv == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002497 ha_alert("config : %s '%s' needs at least 1 server in balance mode.\n",
2498 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002499 cfgerr++;
2500 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002501#endif
Willy Tarreau1620ec32011-08-06 17:05:02 +02002502 else if (curproxy->options & PR_O_DISPATCH) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002503 ha_warning("config : dispatch address of %s '%s' will be ignored in balance mode.\n",
2504 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002505 err_code |= ERR_WARN;
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002506 }
2507 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02002508 else if (!(curproxy->options & (PR_O_TRANSP | PR_O_DISPATCH | PR_O_HTTP_PROXY))) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002509 /* If no LB algo is set in a backend, and we're not in
2510 * transparent mode, dispatch mode nor proxy mode, we
2511 * want to use balance roundrobin by default.
2512 */
2513 curproxy->lbprm.algo &= ~BE_LB_ALGO;
2514 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002515 }
2516 }
Willy Tarreau193cf932007-09-17 10:17:23 +02002517
Willy Tarreau1620ec32011-08-06 17:05:02 +02002518 if (curproxy->options & PR_O_DISPATCH)
2519 curproxy->options &= ~(PR_O_TRANSP | PR_O_HTTP_PROXY);
2520 else if (curproxy->options & PR_O_HTTP_PROXY)
2521 curproxy->options &= ~(PR_O_DISPATCH | PR_O_TRANSP);
2522 else if (curproxy->options & PR_O_TRANSP)
2523 curproxy->options &= ~(PR_O_DISPATCH | PR_O_HTTP_PROXY);
Willy Tarreau82936582007-11-30 15:20:09 +01002524
Willy Tarreau1620ec32011-08-06 17:05:02 +02002525 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_HTTP_CHK) {
2526 if (curproxy->options & PR_O_DISABLE404) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002527 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2528 "disable-on-404", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002529 err_code |= ERR_WARN;
2530 curproxy->options &= ~PR_O_DISABLE404;
2531 }
2532 if (curproxy->options2 & PR_O2_CHK_SNDST) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002533 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2534 "send-state", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002535 err_code |= ERR_WARN;
2536 curproxy->options &= ~PR_O2_CHK_SNDST;
2537 }
Willy Tarreauef781042010-01-27 11:53:01 +01002538 }
2539
Simon Horman98637e52014-06-20 12:30:16 +09002540 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_EXT_CHK) {
2541 if (!global.external_check) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002542 ha_alert("Proxy '%s' : '%s' unable to find required 'global.external-check'.\n",
2543 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002544 cfgerr++;
2545 }
2546 if (!curproxy->check_command) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002547 ha_alert("Proxy '%s' : '%s' unable to find required 'external-check command'.\n",
2548 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002549 cfgerr++;
2550 }
2551 }
2552
Olivier Houcharda254a372019-04-05 15:30:12 +02002553 if ((curproxy->retry_type &~ PR_RE_CONN_FAILED) &&
2554 !(curproxy->options2 & PR_O2_USE_HTX)) {
2555 ha_warning("Proxy '%s' : retry-on with any other keywords than 'conn-failure' will be ignored, requires 'option http-use-htx'.\n", curproxy->id);
2556 err_code |= ERR_WARN;
2557 curproxy->retry_type &= PR_RE_CONN_FAILED;
2558 }
Simon Horman64e34162015-02-06 11:11:57 +09002559 if (curproxy->email_alert.set) {
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002560 if (!(curproxy->email_alert.mailers.name && curproxy->email_alert.from && curproxy->email_alert.to)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002561 ha_warning("config : 'email-alert' will be ignored for %s '%s' (the presence any of "
2562 "'email-alert from', 'email-alert level' 'email-alert mailers', "
2563 "'email-alert myhostname', or 'email-alert to' "
2564 "requires each of 'email-alert from', 'email-alert mailers' and 'email-alert to' "
2565 "to be present).\n",
2566 proxy_type_str(curproxy), curproxy->id);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002567 err_code |= ERR_WARN;
2568 free_email_alert(curproxy);
2569 }
2570 if (!curproxy->email_alert.myhostname)
Cyril Bontée22bfd62015-12-04 03:07:07 +01002571 curproxy->email_alert.myhostname = strdup(hostname);
Simon Horman9dc49962015-01-30 11:22:59 +09002572 }
2573
Simon Horman98637e52014-06-20 12:30:16 +09002574 if (curproxy->check_command) {
2575 int clear = 0;
2576 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002577 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2578 "external-check command", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002579 err_code |= ERR_WARN;
2580 clear = 1;
2581 }
2582 if (curproxy->check_command[0] != '/' && !curproxy->check_path) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002583 ha_alert("Proxy '%s': '%s' does not have a leading '/' and 'external-check path' is not set.\n",
2584 curproxy->id, "external-check command");
Simon Horman98637e52014-06-20 12:30:16 +09002585 cfgerr++;
2586 }
2587 if (clear) {
2588 free(curproxy->check_command);
2589 curproxy->check_command = NULL;
2590 }
2591 }
2592
2593 if (curproxy->check_path) {
2594 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002595 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2596 "external-check path", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002597 err_code |= ERR_WARN;
2598 free(curproxy->check_path);
2599 curproxy->check_path = NULL;
2600 }
2601 }
2602
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002603 /* if a default backend was specified, let's find it */
2604 if (curproxy->defbe.name) {
2605 struct proxy *target;
2606
Willy Tarreauafb39922015-05-26 12:04:09 +02002607 target = proxy_be_by_name(curproxy->defbe.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002608 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002609 ha_alert("Proxy '%s': unable to find required default_backend: '%s'.\n",
2610 curproxy->id, curproxy->defbe.name);
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002611 cfgerr++;
2612 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002613 ha_alert("Proxy '%s': loop detected for default_backend: '%s'.\n",
2614 curproxy->id, curproxy->defbe.name);
Willy Tarreaubb925012009-07-23 13:36:36 +02002615 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002616 } else if (target->mode != curproxy->mode &&
2617 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2618
Christopher Faulet767a84b2017-11-24 16:50:31 +01002619 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) as its default backend (see 'mode').\n",
2620 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2621 curproxy->conf.file, curproxy->conf.line,
2622 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2623 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002624 cfgerr++;
Willy Tarreau68ad3a42018-10-22 11:49:15 +02002625 } else if ((curproxy->options2 ^ target->options2) & PR_O2_USE_HTX) {
2626 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",
2627 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2628 curproxy->conf.file, curproxy->conf.line,
2629 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2630 target->conf.file, target->conf.line);
2631 cfgerr++;
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002632 } else {
2633 free(curproxy->defbe.name);
2634 curproxy->defbe.be = target;
Willy Tarreauff678132012-02-13 14:32:34 +01002635 /* Emit a warning if this proxy also has some servers */
2636 if (curproxy->srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002637 ha_warning("In proxy '%s', the 'default_backend' rule always has precedence over the servers, which will never be used.\n",
2638 curproxy->id);
Willy Tarreauff678132012-02-13 14:32:34 +01002639 err_code |= ERR_WARN;
2640 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002641 }
2642 }
2643
Willy Tarreau55ea7572007-06-17 19:56:27 +02002644 /* find the target proxy for 'use_backend' rules */
2645 list_for_each_entry(rule, &curproxy->switching_rules, list) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002646 struct proxy *target;
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002647 struct logformat_node *node;
2648 char *pxname;
2649
2650 /* Try to parse the string as a log format expression. If the result
2651 * of the parsing is only one entry containing a simple string, then
2652 * it's a standard string corresponding to a static rule, thus the
2653 * parsing is cancelled and be.name is restored to be resolved.
2654 */
2655 pxname = rule->be.name;
2656 LIST_INIT(&rule->be.expr);
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +01002657 curproxy->conf.args.ctx = ARGC_UBK;
2658 curproxy->conf.args.file = rule->file;
2659 curproxy->conf.args.line = rule->line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002660 err = NULL;
2661 if (!parse_logformat_string(pxname, curproxy, &rule->be.expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002662 ha_alert("Parsing [%s:%d]: failed to parse use_backend rule '%s' : %s.\n",
2663 rule->file, rule->line, pxname, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002664 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002665 cfgerr++;
2666 continue;
2667 }
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002668 node = LIST_NEXT(&rule->be.expr, struct logformat_node *, list);
2669
2670 if (!LIST_ISEMPTY(&rule->be.expr)) {
2671 if (node->type != LOG_FMT_TEXT || node->list.n != &rule->be.expr) {
2672 rule->dynamic = 1;
2673 free(pxname);
2674 continue;
2675 }
Christopher Faulet8762fea2020-05-07 15:59:33 +02002676 /* Only one element in the list, a simple string: free the expression and
2677 * fall back to static rule
2678 */
2679 LIST_DEL(&node->list);
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002680 free(node->arg);
2681 free(node);
2682 }
2683
2684 rule->dynamic = 0;
2685 rule->be.name = pxname;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002686
Willy Tarreauafb39922015-05-26 12:04:09 +02002687 target = proxy_be_by_name(rule->be.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002688 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002689 ha_alert("Proxy '%s': unable to find required use_backend: '%s'.\n",
2690 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002691 cfgerr++;
2692 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002693 ha_alert("Proxy '%s': loop detected for use_backend: '%s'.\n",
2694 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002695 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002696 } else if (target->mode != curproxy->mode &&
2697 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2698
Christopher Faulet767a84b2017-11-24 16:50:31 +01002699 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) in a 'use_backend' rule (see 'mode').\n",
2700 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2701 curproxy->conf.file, curproxy->conf.line,
2702 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2703 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002704 cfgerr++;
Willy Tarreau68ad3a42018-10-22 11:49:15 +02002705 } else if ((curproxy->options2 ^ target->options2) & PR_O2_USE_HTX) {
2706 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",
2707 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2708 curproxy->conf.file, curproxy->conf.line,
2709 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2710 target->conf.file, target->conf.line);
2711 cfgerr++;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002712 } else {
2713 free((void *)rule->be.name);
2714 rule->be.backend = target;
2715 }
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002716 }
2717
Willy Tarreau64ab6072014-09-16 12:17:36 +02002718 /* find the target server for 'use_server' rules */
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002719 list_for_each_entry(srule, &curproxy->server_rules, list) {
2720 struct server *target = findserver(curproxy, srule->srv.name);
2721
2722 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002723 ha_alert("config : %s '%s' : unable to find server '%s' referenced in a 'use-server' rule.\n",
2724 proxy_type_str(curproxy), curproxy->id, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002725 cfgerr++;
2726 continue;
2727 }
2728 free((void *)srule->srv.name);
2729 srule->srv.ptr = target;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002730 }
2731
Emeric Brunb982a3d2010-01-04 15:45:53 +01002732 /* find the target table for 'stick' rules */
2733 list_for_each_entry(mrule, &curproxy->sticking_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002734 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002735
Emeric Brun1d33b292010-01-04 15:47:17 +01002736 curproxy->be_req_ana |= AN_REQ_STICKING_RULES;
2737 if (mrule->flags & STK_IS_STORE)
2738 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2739
Emeric Brunb982a3d2010-01-04 15:45:53 +01002740 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002741 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002742 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002743 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002744
2745 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002746 ha_alert("Proxy '%s': unable to find stick-table '%s'.\n",
Willy Tarreauecb5b892020-01-24 07:19:34 +01002747 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002748 cfgerr++;
2749 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002750 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002751 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2752 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002753 cfgerr++;
2754 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002755 else if (target->proxy && curproxy->bind_proc & ~target->proxy->bind_proc) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002756 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2757 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002758 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002759 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002760 else {
2761 free((void *)mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002762 mrule->table.t = target;
2763 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Frédéric Lécailledb52d902019-05-17 10:12:52 +02002764 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_NAME, NULL);
Frédéric Lécaillef596b4f2019-09-02 14:02:28 +02002765 if (!in_proxies_list(target->proxies_list, curproxy)) {
2766 curproxy->next_stkt_ref = target->proxies_list;
2767 target->proxies_list = curproxy;
2768 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002769 }
2770 }
2771
2772 /* find the target table for 'store response' rules */
2773 list_for_each_entry(mrule, &curproxy->storersp_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002774 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002775
Emeric Brun1d33b292010-01-04 15:47:17 +01002776 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2777
Emeric Brunb982a3d2010-01-04 15:45:53 +01002778 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002779 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002780 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002781 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002782
2783 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002784 ha_alert("Proxy '%s': unable to find store table '%s'.\n",
Willy Tarreauecb5b892020-01-24 07:19:34 +01002785 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002786 cfgerr++;
2787 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002788 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002789 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2790 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002791 cfgerr++;
2792 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002793 else if (target->proxy && (curproxy->bind_proc & ~target->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002794 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2795 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002796 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002797 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002798 else {
2799 free((void *)mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002800 mrule->table.t = target;
2801 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Frédéric Lécailledb52d902019-05-17 10:12:52 +02002802 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_NAME, NULL);
Frédéric Lécaillef596b4f2019-09-02 14:02:28 +02002803 if (!in_proxies_list(target->proxies_list, curproxy)) {
2804 curproxy->next_stkt_ref = target->proxies_list;
2805 target->proxies_list = curproxy;
2806 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002807 }
2808 }
2809
Christopher Faulete4e830d2017-09-18 14:51:41 +02002810 /* check validity for 'tcp-request' layer 4 rules */
2811 list_for_each_entry(arule, &curproxy->tcp_req.l4_rules, list) {
2812 err = NULL;
2813 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002814 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002815 free(err);
Willy Tarreau5f53de72012-12-12 00:25:44 +01002816 cfgerr++;
2817 }
Willy Tarreaud1f96522010-08-03 19:34:32 +02002818 }
2819
Christopher Faulete4e830d2017-09-18 14:51:41 +02002820 /* check validity for 'tcp-request' layer 5 rules */
2821 list_for_each_entry(arule, &curproxy->tcp_req.l5_rules, list) {
2822 err = NULL;
2823 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002824 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002825 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002826 cfgerr++;
2827 }
2828 }
2829
Christopher Faulete4e830d2017-09-18 14:51:41 +02002830 /* check validity for 'tcp-request' layer 6 rules */
2831 list_for_each_entry(arule, &curproxy->tcp_req.inspect_rules, list) {
2832 err = NULL;
2833 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002834 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002835 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002836 cfgerr++;
2837 }
2838 }
2839
Christopher Faulete4e830d2017-09-18 14:51:41 +02002840 /* check validity for 'http-request' layer 7 rules */
2841 list_for_each_entry(arule, &curproxy->http_req_rules, list) {
2842 err = NULL;
2843 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002844 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002845 free(err);
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002846 cfgerr++;
2847 }
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002848 }
2849
Christopher Faulete4e830d2017-09-18 14:51:41 +02002850 /* check validity for 'http-response' layer 7 rules */
2851 list_for_each_entry(arule, &curproxy->http_res_rules, list) {
2852 err = NULL;
2853 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002854 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002855 free(err);
Willy Tarreau09448f72014-06-25 18:12:15 +02002856 cfgerr++;
2857 }
Willy Tarreau09448f72014-06-25 18:12:15 +02002858 }
2859
Willy Tarreaub3dc39d2014-04-28 22:06:57 +02002860 /* move any "block" rules at the beginning of the http-request rules */
2861 if (!LIST_ISEMPTY(&curproxy->block_rules)) {
2862 /* insert block_rules into http_req_rules at the beginning */
2863 curproxy->block_rules.p->n = curproxy->http_req_rules.n;
2864 curproxy->http_req_rules.n->p = curproxy->block_rules.p;
2865 curproxy->block_rules.n->p = &curproxy->http_req_rules;
2866 curproxy->http_req_rules.n = curproxy->block_rules.n;
2867 LIST_INIT(&curproxy->block_rules);
2868 }
2869
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002870 if (curproxy->table && curproxy->table->peers.name) {
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002871 struct peers *curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002872
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002873 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002874 if (strcmp(curpeers->id, curproxy->table->peers.name) == 0) {
2875 free((void *)curproxy->table->peers.name);
2876 curproxy->table->peers.p = curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002877 break;
2878 }
2879 }
2880
2881 if (!curpeers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002882 ha_alert("Proxy '%s': unable to find sync peers '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002883 curproxy->id, curproxy->table->peers.name);
2884 free((void *)curproxy->table->peers.name);
2885 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002886 cfgerr++;
2887 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002888 else if (curpeers->state == PR_STSTOPPED) {
2889 /* silently disable this peers section */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002890 curproxy->table->peers.p = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002891 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002892 else if (!curpeers->peers_fe) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002893 ha_alert("Proxy '%s': unable to find local peer '%s' in peers section '%s'.\n",
2894 curproxy->id, localpeer, curpeers->id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002895 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002896 cfgerr++;
2897 }
2898 }
2899
Simon Horman9dc49962015-01-30 11:22:59 +09002900
2901 if (curproxy->email_alert.mailers.name) {
2902 struct mailers *curmailers = mailers;
2903
2904 for (curmailers = mailers; curmailers; curmailers = curmailers->next) {
Christopher Faulet0108bb32017-10-20 21:34:32 +02002905 if (!strcmp(curmailers->id, curproxy->email_alert.mailers.name))
Simon Horman9dc49962015-01-30 11:22:59 +09002906 break;
Simon Horman9dc49962015-01-30 11:22:59 +09002907 }
Simon Horman9dc49962015-01-30 11:22:59 +09002908 if (!curmailers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002909 ha_alert("Proxy '%s': unable to find mailers '%s'.\n",
2910 curproxy->id, curproxy->email_alert.mailers.name);
Simon Horman9dc49962015-01-30 11:22:59 +09002911 free_email_alert(curproxy);
2912 cfgerr++;
2913 }
Christopher Faulet0108bb32017-10-20 21:34:32 +02002914 else {
2915 err = NULL;
2916 if (init_email_alert(curmailers, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002917 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulet0108bb32017-10-20 21:34:32 +02002918 free(err);
2919 cfgerr++;
2920 }
2921 }
Simon Horman9dc49962015-01-30 11:22:59 +09002922 }
2923
Krzysztof Piotr Oledzki329f74d2010-02-22 20:27:23 +01002924 if (curproxy->uri_auth && !(curproxy->uri_auth->flags & ST_CONVDONE) &&
Willy Tarreauff011f22011-01-06 17:51:27 +01002925 !LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules) &&
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002926 (curproxy->uri_auth->userlist || curproxy->uri_auth->auth_realm )) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002927 ha_alert("%s '%s': stats 'auth'/'realm' and 'http-request' can't be used at the same time.\n",
2928 "proxy", curproxy->id);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002929 cfgerr++;
2930 goto out_uri_auth_compat;
2931 }
2932
Krzysztof Piotr Oledzki329f74d2010-02-22 20:27:23 +01002933 if (curproxy->uri_auth && curproxy->uri_auth->userlist && !(curproxy->uri_auth->flags & ST_CONVDONE)) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002934 const char *uri_auth_compat_req[10];
Thierry FOURNIERa28a9422015-08-04 19:35:46 +02002935 struct act_rule *rule;
Willy Tarreau95fa4692010-02-01 13:05:50 +01002936 int i = 0;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002937
Willy Tarreau95fa4692010-02-01 13:05:50 +01002938 /* build the ACL condition from scratch. We're relying on anonymous ACLs for that */
2939 uri_auth_compat_req[i++] = "auth";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002940
2941 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002942 uri_auth_compat_req[i++] = "realm";
2943 uri_auth_compat_req[i++] = curproxy->uri_auth->auth_realm;
2944 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002945
Willy Tarreau95fa4692010-02-01 13:05:50 +01002946 uri_auth_compat_req[i++] = "unless";
2947 uri_auth_compat_req[i++] = "{";
2948 uri_auth_compat_req[i++] = "http_auth(.internal-stats-userlist)";
2949 uri_auth_compat_req[i++] = "}";
2950 uri_auth_compat_req[i++] = "";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002951
Willy Tarreauff011f22011-01-06 17:51:27 +01002952 rule = parse_http_req_cond(uri_auth_compat_req, "internal-stats-auth-compat", 0, curproxy);
2953 if (!rule) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002954 cfgerr++;
2955 break;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002956 }
2957
Willy Tarreauff011f22011-01-06 17:51:27 +01002958 LIST_ADDQ(&curproxy->uri_auth->http_req_rules, &rule->list);
Willy Tarreau95fa4692010-02-01 13:05:50 +01002959
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002960 if (curproxy->uri_auth->auth_realm) {
2961 free(curproxy->uri_auth->auth_realm);
2962 curproxy->uri_auth->auth_realm = NULL;
2963 }
Krzysztof Piotr Oledzki329f74d2010-02-22 20:27:23 +01002964
2965 curproxy->uri_auth->flags |= ST_CONVDONE;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002966 }
2967out_uri_auth_compat:
2968
Dragan Dosen43885c72015-10-01 13:18:13 +02002969 /* check whether we have a log server that uses RFC5424 log format */
Dragan Dosen1322d092015-09-22 16:05:32 +02002970 list_for_each_entry(tmplogsrv, &curproxy->logsrvs, list) {
Dragan Dosen43885c72015-10-01 13:18:13 +02002971 if (tmplogsrv->format == LOG_FORMAT_RFC5424) {
2972 if (!curproxy->conf.logformat_sd_string) {
2973 /* set the default logformat_sd_string */
2974 curproxy->conf.logformat_sd_string = default_rfc5424_sd_log_format;
2975 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002976 break;
Dragan Dosen1322d092015-09-22 16:05:32 +02002977 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002978 }
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02002979
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002980 /* compile the log format */
2981 if (!(curproxy->cap & PR_CAP_FE)) {
Willy Tarreau62a61232013-04-12 18:13:46 +02002982 if (curproxy->conf.logformat_string != default_http_log_format &&
2983 curproxy->conf.logformat_string != default_tcp_log_format &&
2984 curproxy->conf.logformat_string != clf_http_log_format)
2985 free(curproxy->conf.logformat_string);
2986 curproxy->conf.logformat_string = NULL;
2987 free(curproxy->conf.lfs_file);
2988 curproxy->conf.lfs_file = NULL;
2989 curproxy->conf.lfs_line = 0;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002990
2991 if (curproxy->conf.logformat_sd_string != default_rfc5424_sd_log_format)
2992 free(curproxy->conf.logformat_sd_string);
2993 curproxy->conf.logformat_sd_string = NULL;
2994 free(curproxy->conf.lfsd_file);
2995 curproxy->conf.lfsd_file = NULL;
2996 curproxy->conf.lfsd_line = 0;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002997 }
2998
Willy Tarreau62a61232013-04-12 18:13:46 +02002999 if (curproxy->conf.logformat_string) {
3000 curproxy->conf.args.ctx = ARGC_LOG;
3001 curproxy->conf.args.file = curproxy->conf.lfs_file;
3002 curproxy->conf.args.line = curproxy->conf.lfs_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003003 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003004 if (!parse_logformat_string(curproxy->conf.logformat_string, curproxy, &curproxy->logformat, LOG_OPT_MANDATORY,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003005 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003006 ha_alert("Parsing [%s:%d]: failed to parse log-format : %s.\n",
3007 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003008 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003009 cfgerr++;
3010 }
Willy Tarreau62a61232013-04-12 18:13:46 +02003011 curproxy->conf.args.file = NULL;
3012 curproxy->conf.args.line = 0;
3013 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003014
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003015 if (curproxy->conf.logformat_sd_string) {
3016 curproxy->conf.args.ctx = ARGC_LOGSD;
3017 curproxy->conf.args.file = curproxy->conf.lfsd_file;
3018 curproxy->conf.args.line = curproxy->conf.lfsd_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003019 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003020 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 +01003021 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003022 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
3023 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003024 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003025 cfgerr++;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003026 } else if (!add_to_logformat_list(NULL, NULL, LF_SEPARATOR, &curproxy->logformat_sd, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003027 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
3028 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003029 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003030 cfgerr++;
3031 }
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003032 curproxy->conf.args.file = NULL;
3033 curproxy->conf.args.line = 0;
3034 }
3035
Willy Tarreau62a61232013-04-12 18:13:46 +02003036 if (curproxy->conf.uniqueid_format_string) {
3037 curproxy->conf.args.ctx = ARGC_UIF;
3038 curproxy->conf.args.file = curproxy->conf.uif_file;
3039 curproxy->conf.args.line = curproxy->conf.uif_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003040 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003041 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 +01003042 (curproxy->cap & PR_CAP_FE) ? SMP_VAL_FE_HRQ_HDR : SMP_VAL_BE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003043 ha_alert("Parsing [%s:%d]: failed to parse unique-id : %s.\n",
3044 curproxy->conf.uif_file, curproxy->conf.uif_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003045 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003046 cfgerr++;
3047 }
Willy Tarreau62a61232013-04-12 18:13:46 +02003048 curproxy->conf.args.file = NULL;
3049 curproxy->conf.args.line = 0;
3050 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003051
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01003052 /* only now we can check if some args remain unresolved.
3053 * This must be done after the users and groups resolution.
3054 */
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003055 cfgerr += smp_resolve_args(curproxy);
3056 if (!cfgerr)
3057 cfgerr += acl_find_targets(curproxy);
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01003058
Willy Tarreau2738a142006-07-08 17:28:09 +02003059 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003060 (((curproxy->cap & PR_CAP_FE) && !curproxy->timeout.client) ||
Willy Tarreaud825eef2007-05-12 22:35:00 +02003061 ((curproxy->cap & PR_CAP_BE) && (curproxy->srv) &&
Willy Tarreauce887fd2012-05-12 12:50:00 +02003062 (!curproxy->timeout.connect ||
3063 (!curproxy->timeout.server && (curproxy->mode == PR_MODE_HTTP || !curproxy->timeout.tunnel)))))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003064 ha_warning("config : missing timeouts for %s '%s'.\n"
3065 " | While not properly invalid, you will certainly encounter various problems\n"
3066 " | with such a configuration. To fix this, please ensure that all following\n"
3067 " | timeouts are set to a non-zero value: 'client', 'connect', 'server'.\n",
3068 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003069 err_code |= ERR_WARN;
Willy Tarreau2738a142006-07-08 17:28:09 +02003070 }
Willy Tarreauf3c69202006-07-09 16:42:34 +02003071
Willy Tarreau1fa31262007-12-03 00:36:16 +01003072 /* Historically, the tarpit and queue timeouts were inherited from contimeout.
3073 * We must still support older configurations, so let's find out whether those
3074 * parameters have been set or must be copied from contimeouts.
3075 */
3076 if (curproxy != &defproxy) {
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003077 if (!curproxy->timeout.tarpit ||
3078 curproxy->timeout.tarpit == defproxy.timeout.tarpit) {
Willy Tarreau1fa31262007-12-03 00:36:16 +01003079 /* tarpit timeout not set. We search in the following order:
3080 * default.tarpit, curr.connect, default.connect.
3081 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003082 if (defproxy.timeout.tarpit)
Willy Tarreau1fa31262007-12-03 00:36:16 +01003083 curproxy->timeout.tarpit = defproxy.timeout.tarpit;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003084 else if (curproxy->timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003085 curproxy->timeout.tarpit = curproxy->timeout.connect;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003086 else if (defproxy.timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003087 curproxy->timeout.tarpit = defproxy.timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01003088 }
3089 if ((curproxy->cap & PR_CAP_BE) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003090 (!curproxy->timeout.queue ||
3091 curproxy->timeout.queue == defproxy.timeout.queue)) {
Willy Tarreau1fa31262007-12-03 00:36:16 +01003092 /* queue timeout not set. We search in the following order:
3093 * default.queue, curr.connect, default.connect.
3094 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003095 if (defproxy.timeout.queue)
Willy Tarreau1fa31262007-12-03 00:36:16 +01003096 curproxy->timeout.queue = defproxy.timeout.queue;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003097 else if (curproxy->timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003098 curproxy->timeout.queue = curproxy->timeout.connect;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003099 else if (defproxy.timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003100 curproxy->timeout.queue = defproxy.timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01003101 }
3102 }
3103
Willy Tarreau1620ec32011-08-06 17:05:02 +02003104 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_SSL3_CHK) {
Willy Tarreau137325d2010-02-01 16:38:17 +01003105 curproxy->check_len = sizeof(sslv3_client_hello_pkt) - 1;
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003106 curproxy->check_req = malloc(curproxy->check_len);
Willy Tarreau137325d2010-02-01 16:38:17 +01003107 memcpy(curproxy->check_req, sslv3_client_hello_pkt, curproxy->check_len);
Willy Tarreauf3c69202006-07-09 16:42:34 +02003108 }
3109
Willy Tarreau215663d2014-06-13 18:30:23 +02003110 if (!LIST_ISEMPTY(&curproxy->tcpcheck_rules) &&
3111 (curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_TCPCHK_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003112 ha_warning("config : %s '%s' uses tcp-check rules without 'option tcp-check', so the rules are ignored.\n",
3113 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau215663d2014-06-13 18:30:23 +02003114 err_code |= ERR_WARN;
3115 }
3116
Willy Tarreau193b8c62012-11-22 00:17:38 +01003117 /* ensure that cookie capture length is not too large */
3118 if (curproxy->capture_len >= global.tune.cookie_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003119 ha_warning("config : truncating capture length to %d bytes for %s '%s'.\n",
3120 global.tune.cookie_len - 1, proxy_type_str(curproxy), curproxy->id);
Willy Tarreau193b8c62012-11-22 00:17:38 +01003121 err_code |= ERR_WARN;
3122 curproxy->capture_len = global.tune.cookie_len - 1;
3123 }
3124
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003125 /* The small pools required for the capture lists */
Willy Tarreau9a54e132012-03-24 08:33:05 +01003126 if (curproxy->nb_req_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003127 curproxy->req_cap_pool = create_pool("ptrcap",
3128 curproxy->nb_req_cap * sizeof(char *),
3129 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003130 }
3131
3132 if (curproxy->nb_rsp_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003133 curproxy->rsp_cap_pool = create_pool("ptrcap",
3134 curproxy->nb_rsp_cap * sizeof(char *),
3135 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003136 }
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003137
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003138 switch (curproxy->load_server_state_from_file) {
3139 case PR_SRV_STATE_FILE_UNSPEC:
3140 curproxy->load_server_state_from_file = PR_SRV_STATE_FILE_NONE;
3141 break;
3142 case PR_SRV_STATE_FILE_GLOBAL:
3143 if (!global.server_state_file) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003144 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",
3145 curproxy->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003146 err_code |= ERR_WARN;
3147 }
3148 break;
3149 }
3150
Willy Tarreaubaaee002006-06-26 02:48:02 +02003151 /* first, we will invert the servers list order */
3152 newsrv = NULL;
3153 while (curproxy->srv) {
3154 struct server *next;
3155
3156 next = curproxy->srv->next;
3157 curproxy->srv->next = newsrv;
3158 newsrv = curproxy->srv;
3159 if (!next)
3160 break;
3161 curproxy->srv = next;
3162 }
3163
Willy Tarreau17edc812014-01-03 12:14:34 +01003164 /* Check that no server name conflicts. This causes trouble in the stats.
3165 * We only emit a warning for the first conflict affecting each server,
3166 * in order to avoid combinatory explosion if all servers have the same
3167 * name. We do that only for servers which do not have an explicit ID,
3168 * because these IDs were made also for distinguishing them and we don't
3169 * want to annoy people who correctly manage them.
3170 */
3171 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3172 struct server *other_srv;
3173
3174 if (newsrv->puid)
3175 continue;
3176
3177 for (other_srv = curproxy->srv; other_srv && other_srv != newsrv; other_srv = other_srv->next) {
3178 if (!other_srv->puid && strcmp(other_srv->id, newsrv->id) == 0) {
Willy Tarreaub01302f2019-05-27 19:31:06 +02003179 ha_alert("parsing [%s:%d] : %s '%s', another server named '%s' was already defined at line %d, please use distinct names.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01003180 newsrv->conf.file, newsrv->conf.line,
3181 proxy_type_str(curproxy), curproxy->id,
3182 newsrv->id, other_srv->conf.line);
Willy Tarreaub01302f2019-05-27 19:31:06 +02003183 cfgerr++;
Willy Tarreau17edc812014-01-03 12:14:34 +01003184 break;
3185 }
3186 }
3187 }
3188
Willy Tarreaudd701652010-05-25 23:03:02 +02003189 /* assign automatic UIDs to servers which don't have one yet */
3190 next_id = 1;
3191 newsrv = curproxy->srv;
3192 while (newsrv != NULL) {
3193 if (!newsrv->puid) {
3194 /* server ID not set, use automatic numbering with first
3195 * spare entry starting with next_svid.
3196 */
3197 next_id = get_next_id(&curproxy->conf.used_server_id, next_id);
3198 newsrv->conf.id.key = newsrv->puid = next_id;
3199 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Frédéric Lécaille84d60462019-05-17 14:29:15 +02003200 newsrv->conf.name.key = newsrv->id;
3201 ebis_insert(&curproxy->conf.used_server_name, &newsrv->conf.name);
Willy Tarreaudd701652010-05-25 23:03:02 +02003202 }
3203 next_id++;
3204 newsrv = newsrv->next;
3205 }
3206
Willy Tarreau20697042007-11-15 23:26:18 +01003207 curproxy->lbprm.wmult = 1; /* default weight multiplier */
Willy Tarreau5dc2fa62007-11-19 19:10:18 +01003208 curproxy->lbprm.wdiv = 1; /* default weight divider */
Willy Tarreaubaaee002006-06-26 02:48:02 +02003209
Willy Tarreau62c3be22012-01-20 13:12:32 +01003210 /*
3211 * If this server supports a maxconn parameter, it needs a dedicated
3212 * tasks to fill the emptied slots when a connection leaves.
3213 * Also, resolve deferred tracking dependency if needed.
3214 */
3215 newsrv = curproxy->srv;
3216 while (newsrv != NULL) {
3217 if (newsrv->minconn > newsrv->maxconn) {
3218 /* Only 'minconn' was specified, or it was higher than or equal
3219 * to 'maxconn'. Let's turn this into maxconn and clean it, as
3220 * this will avoid further useless expensive computations.
3221 */
3222 newsrv->maxconn = newsrv->minconn;
3223 } else if (newsrv->maxconn && !newsrv->minconn) {
3224 /* minconn was not specified, so we set it to maxconn */
3225 newsrv->minconn = newsrv->maxconn;
3226 }
3227
Willy Tarreau17d45382016-12-22 21:16:08 +01003228 /* this will also properly set the transport layer for prod and checks */
Christopher Faulet68d35ae2020-03-27 18:55:49 +01003229 if (newsrv->use_ssl == 1 || newsrv->check.use_ssl == 1 || (newsrv->proxy->options & PR_O_TCPCHK_SSL)) {
Willy Tarreau17d45382016-12-22 21:16:08 +01003230 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
3231 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(newsrv);
3232 }
Emeric Brun94324a42012-10-11 14:00:19 +02003233
Willy Tarreau034c88c2017-01-23 23:36:45 +01003234 if ((newsrv->flags & SRV_F_FASTOPEN) &&
3235 ((curproxy->retry_type & (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)) !=
3236 (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)))
3237 ha_warning("parsing [%s:%d] : %s '%s': server '%s' has tfo activated, the backend should be configured with at least 'conn-failure', 'empty-response' and 'response-timeout' or we wouldn't be able to retry the connection on failure.\n",
3238 newsrv->conf.file, newsrv->conf.line,
3239 proxy_type_str(curproxy), curproxy->id,
3240 newsrv->id);
3241
Willy Tarreau62c3be22012-01-20 13:12:32 +01003242 if (newsrv->trackit) {
3243 struct proxy *px;
Willy Tarreau32091232014-05-16 13:52:00 +02003244 struct server *srv, *loop;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003245 char *pname, *sname;
3246
3247 pname = newsrv->trackit;
3248 sname = strrchr(pname, '/');
3249
3250 if (sname)
3251 *sname++ = '\0';
3252 else {
3253 sname = pname;
3254 pname = NULL;
3255 }
3256
3257 if (pname) {
Willy Tarreau9e0bb102015-05-26 11:24:42 +02003258 px = proxy_be_by_name(pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003259 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003260 ha_alert("config : %s '%s', server '%s': unable to find required proxy '%s' for tracking.\n",
3261 proxy_type_str(curproxy), curproxy->id,
3262 newsrv->id, pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003263 cfgerr++;
3264 goto next_srv;
3265 }
3266 } else
3267 px = curproxy;
3268
3269 srv = findserver(px, sname);
3270 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003271 ha_alert("config : %s '%s', server '%s': unable to find required server '%s' for tracking.\n",
3272 proxy_type_str(curproxy), curproxy->id,
3273 newsrv->id, sname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003274 cfgerr++;
3275 goto next_srv;
3276 }
3277
Christopher Fauletc6e07702020-03-26 19:48:20 +01003278 if (!srv->do_check && !srv->do_agent && !srv->track && !srv->trackit) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003279 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for "
3280 "tracking as it does not have any check nor agent enabled.\n",
3281 proxy_type_str(curproxy), curproxy->id,
3282 newsrv->id, px->id, srv->id);
Willy Tarreau32091232014-05-16 13:52:00 +02003283 cfgerr++;
3284 goto next_srv;
3285 }
3286
3287 for (loop = srv->track; loop && loop != newsrv; loop = loop->track);
3288
Frédéric Lécaille2efc6492017-03-14 14:32:17 +01003289 if (newsrv == srv || loop) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003290 ha_alert("config : %s '%s', server '%s': unable to track %s/%s as it "
3291 "belongs to a tracking chain looping back to %s/%s.\n",
3292 proxy_type_str(curproxy), curproxy->id,
3293 newsrv->id, px->id, srv->id, px->id,
3294 newsrv == srv ? srv->id : loop->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003295 cfgerr++;
3296 goto next_srv;
3297 }
3298
3299 if (curproxy != px &&
3300 (curproxy->options & PR_O_DISABLE404) != (px->options & PR_O_DISABLE404)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003301 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for"
3302 "tracking: disable-on-404 option inconsistency.\n",
3303 proxy_type_str(curproxy), curproxy->id,
3304 newsrv->id, px->id, srv->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003305 cfgerr++;
3306 goto next_srv;
3307 }
3308
Willy Tarreau62c3be22012-01-20 13:12:32 +01003309 newsrv->track = srv;
Willy Tarreau1a53a3a2013-12-11 15:27:05 +01003310 newsrv->tracknext = srv->trackers;
3311 srv->trackers = newsrv;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003312
3313 free(newsrv->trackit);
3314 newsrv->trackit = NULL;
3315 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003316
Willy Tarreau62c3be22012-01-20 13:12:32 +01003317 next_srv:
3318 newsrv = newsrv->next;
3319 }
3320
Olivier Houchard4e694042017-03-14 20:01:29 +01003321 /*
3322 * Try to generate dynamic cookies for servers now.
3323 * It couldn't be done earlier, since at the time we parsed
3324 * the server line, we may not have known yet that we
3325 * should use dynamic cookies, or the secret key may not
3326 * have been provided yet.
3327 */
3328 if (curproxy->ck_opts & PR_CK_DYNAMIC) {
3329 newsrv = curproxy->srv;
3330 while (newsrv != NULL) {
3331 srv_set_dyncookie(newsrv);
3332 newsrv = newsrv->next;
3333 }
3334
3335 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003336 /* We have to initialize the server lookup mechanism depending
Joseph Herlanta14c03e2018-11-15 14:04:19 -08003337 * on what LB algorithm was chosen.
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003338 */
3339
3340 curproxy->lbprm.algo &= ~(BE_LB_LKUP | BE_LB_PROP_DYN);
3341 switch (curproxy->lbprm.algo & BE_LB_KIND) {
3342 case BE_LB_KIND_RR:
Willy Tarreau9757a382009-10-03 12:56:50 +02003343 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_STATIC) {
3344 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3345 init_server_map(curproxy);
Willy Tarreau760e81d2018-05-03 07:20:40 +02003346 } else if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_RANDOM) {
3347 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3348 chash_init_server_tree(curproxy);
Willy Tarreau9757a382009-10-03 12:56:50 +02003349 } else {
3350 curproxy->lbprm.algo |= BE_LB_LKUP_RRTREE | BE_LB_PROP_DYN;
3351 fwrr_init_server_groups(curproxy);
3352 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003353 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003354
Willy Tarreau3ebb1162012-02-13 16:57:44 +01003355 case BE_LB_KIND_CB:
Willy Tarreauf09c6602012-02-13 17:12:08 +01003356 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_CB_LC) {
3357 curproxy->lbprm.algo |= BE_LB_LKUP_LCTREE | BE_LB_PROP_DYN;
3358 fwlc_init_server_tree(curproxy);
3359 } else {
3360 curproxy->lbprm.algo |= BE_LB_LKUP_FSTREE | BE_LB_PROP_DYN;
3361 fas_init_server_tree(curproxy);
3362 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003363 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003364
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003365 case BE_LB_KIND_HI:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003366 if ((curproxy->lbprm.algo & BE_LB_HASH_TYPE) == BE_LB_HASH_CONS) {
3367 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3368 chash_init_server_tree(curproxy);
3369 } else {
3370 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3371 init_server_map(curproxy);
3372 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003373 break;
3374 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003375 HA_SPIN_INIT(&curproxy->lbprm.lock);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003376
3377 if (curproxy->options & PR_O_LOGASAP)
3378 curproxy->to_log &= ~LW_BYTES;
3379
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003380 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003381 (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->logsrvs) &&
3382 (!LIST_ISEMPTY(&curproxy->logformat) || !LIST_ISEMPTY(&curproxy->logformat_sd))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003383 ha_warning("config : log format ignored for %s '%s' since it has no log address.\n",
3384 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003385 err_code |= ERR_WARN;
3386 }
3387
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003388 if (curproxy->mode != PR_MODE_HTTP) {
3389 int optnum;
3390
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003391 if (curproxy->uri_auth) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003392 ha_warning("config : 'stats' statement ignored for %s '%s' as it requires HTTP mode.\n",
3393 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003394 err_code |= ERR_WARN;
3395 curproxy->uri_auth = NULL;
3396 }
3397
Willy Tarreaude7dc882017-03-10 11:49:21 +01003398 if (curproxy->capture_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003399 ha_warning("config : 'capture' statement ignored for %s '%s' as it requires HTTP mode.\n",
3400 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003401 err_code |= ERR_WARN;
3402 }
3403
3404 if (!LIST_ISEMPTY(&curproxy->http_req_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003405 ha_warning("config : 'http-request' rules ignored for %s '%s' as they require HTTP mode.\n",
3406 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003407 err_code |= ERR_WARN;
3408 }
3409
3410 if (!LIST_ISEMPTY(&curproxy->http_res_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003411 ha_warning("config : 'http-response' rules ignored for %s '%s' as they require HTTP mode.\n",
3412 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003413 err_code |= ERR_WARN;
3414 }
3415
3416 if (!LIST_ISEMPTY(&curproxy->block_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003417 ha_warning("config : 'block' rules ignored for %s '%s' as they require HTTP mode.\n",
3418 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003419 err_code |= ERR_WARN;
3420 }
3421
3422 if (!LIST_ISEMPTY(&curproxy->redirect_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003423 ha_warning("config : 'redirect' rules ignored for %s '%s' as they require HTTP mode.\n",
3424 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003425 err_code |= ERR_WARN;
3426 }
3427
Willy Tarreau87cf5142011-08-19 22:57:24 +02003428 if (curproxy->options & (PR_O_FWDFOR | PR_O_FF_ALWAYS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003429 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3430 "forwardfor", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003431 err_code |= ERR_WARN;
Willy Tarreau87cf5142011-08-19 22:57:24 +02003432 curproxy->options &= ~(PR_O_FWDFOR | PR_O_FF_ALWAYS);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003433 }
3434
3435 if (curproxy->options & PR_O_ORGTO) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003436 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3437 "originalto", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003438 err_code |= ERR_WARN;
3439 curproxy->options &= ~PR_O_ORGTO;
3440 }
3441
3442 for (optnum = 0; cfg_opts[optnum].name; optnum++) {
3443 if (cfg_opts[optnum].mode == PR_MODE_HTTP &&
3444 (curproxy->cap & cfg_opts[optnum].cap) &&
3445 (curproxy->options & cfg_opts[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003446 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3447 cfg_opts[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003448 err_code |= ERR_WARN;
3449 curproxy->options &= ~cfg_opts[optnum].val;
3450 }
3451 }
3452
3453 for (optnum = 0; cfg_opts2[optnum].name; optnum++) {
3454 if (cfg_opts2[optnum].mode == PR_MODE_HTTP &&
3455 (curproxy->cap & cfg_opts2[optnum].cap) &&
3456 (curproxy->options2 & cfg_opts2[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003457 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3458 cfg_opts2[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003459 err_code |= ERR_WARN;
3460 curproxy->options2 &= ~cfg_opts2[optnum].val;
3461 }
3462 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003463
Willy Tarreau29fbe512015-08-20 19:35:14 +02003464#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003465 if (curproxy->conn_src.bind_hdr_occ) {
3466 curproxy->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003467 ha_warning("config : %s '%s' : ignoring use of header %s as source IP in non-HTTP mode.\n",
3468 proxy_type_str(curproxy), curproxy->id, curproxy->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003469 err_code |= ERR_WARN;
3470 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003471#endif
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003472 }
3473
Willy Tarreaubaaee002006-06-26 02:48:02 +02003474 /*
Willy Tarreau21d2af32008-02-14 20:25:24 +01003475 * ensure that we're not cross-dressing a TCP server into HTTP.
3476 */
3477 newsrv = curproxy->srv;
3478 while (newsrv != NULL) {
Willy Tarreau0cec3312011-10-31 13:49:26 +01003479 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->rdr_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003480 ha_alert("config : %s '%s' : server cannot have cookie or redirect prefix in non-HTTP mode.\n",
3481 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003482 cfgerr++;
Willy Tarreau21d2af32008-02-14 20:25:24 +01003483 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003484
Willy Tarreau0cec3312011-10-31 13:49:26 +01003485 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->cklen) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003486 ha_warning("config : %s '%s' : ignoring cookie for server '%s' as HTTP mode is disabled.\n",
3487 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau0cec3312011-10-31 13:49:26 +01003488 err_code |= ERR_WARN;
3489 }
3490
Willy Tarreauc93cd162014-05-13 15:54:22 +02003491 if ((newsrv->flags & SRV_F_MAPPORTS) && (curproxy->options2 & PR_O2_RDPC_PRST)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003492 ha_warning("config : %s '%s' : RDP cookie persistence will not work for server '%s' because it lacks an explicit port number.\n",
3493 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau82ffa392013-08-13 17:19:08 +02003494 err_code |= ERR_WARN;
3495 }
3496
Willy Tarreau29fbe512015-08-20 19:35:14 +02003497#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003498 if (curproxy->mode != PR_MODE_HTTP && newsrv->conn_src.bind_hdr_occ) {
3499 newsrv->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003500 ha_warning("config : %s '%s' : server %s cannot use header %s as source IP in non-HTTP mode.\n",
3501 proxy_type_str(curproxy), curproxy->id, newsrv->id, newsrv->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003502 err_code |= ERR_WARN;
3503 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003504#endif
Willy Tarreau4c183462017-01-06 12:21:38 +01003505
Willy Tarreau46deab62018-04-28 07:18:15 +02003506 if ((curproxy->mode != PR_MODE_HTTP) && (curproxy->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR)
3507 curproxy->options &= ~PR_O_REUSE_MASK;
3508
Willy Tarreau21d2af32008-02-14 20:25:24 +01003509 newsrv = newsrv->next;
3510 }
3511
Willy Tarreaue42bd962014-09-16 16:21:19 +02003512 /* check if we have a frontend with "tcp-request content" looking at L7
3513 * with no inspect-delay
3514 */
3515 if ((curproxy->cap & PR_CAP_FE) && !curproxy->tcp_req.inspect_delay) {
Christopher Faulete4e830d2017-09-18 14:51:41 +02003516 list_for_each_entry(arule, &curproxy->tcp_req.inspect_rules, list) {
3517 if (arule->action == ACT_TCP_CAPTURE &&
3518 !(arule->arg.cap.expr->fetch->val & SMP_VAL_FE_SES_ACC))
Willy Tarreaue42bd962014-09-16 16:21:19 +02003519 break;
Christopher Faulete4e830d2017-09-18 14:51:41 +02003520 if ((arule->action >= ACT_ACTION_TRK_SC0 && arule->action <= ACT_ACTION_TRK_SCMAX) &&
3521 !(arule->arg.trk_ctr.expr->fetch->val & SMP_VAL_FE_SES_ACC))
Willy Tarreaue42bd962014-09-16 16:21:19 +02003522 break;
3523 }
3524
Christopher Faulete4e830d2017-09-18 14:51:41 +02003525 if (&arule->list != &curproxy->tcp_req.inspect_rules) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003526 ha_warning("config : %s '%s' : some 'tcp-request content' rules explicitly depending on request"
3527 " contents were found in a frontend without any 'tcp-request inspect-delay' setting."
3528 " This means that these rules will randomly find their contents. This can be fixed by"
3529 " setting the tcp-request inspect-delay.\n",
3530 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue42bd962014-09-16 16:21:19 +02003531 err_code |= ERR_WARN;
3532 }
3533 }
3534
Christopher Fauletd7c91962015-04-30 11:48:27 +02003535 /* Check filter configuration, if any */
3536 cfgerr += flt_check(curproxy);
3537
Willy Tarreauc1a21672009-08-16 22:37:44 +02003538 if (curproxy->cap & PR_CAP_FE) {
Willy Tarreau050536d2012-10-04 08:47:34 +02003539 if (!curproxy->accept)
3540 curproxy->accept = frontend_accept;
Willy Tarreau81f9aa32010-06-01 17:45:26 +02003541
Willy Tarreauc1a21672009-08-16 22:37:44 +02003542 if (curproxy->tcp_req.inspect_delay ||
3543 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
Willy Tarreaufb356202010-08-03 14:02:05 +02003544 curproxy->fe_req_ana |= AN_REQ_INSPECT_FE;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003545
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003546 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003547 curproxy->fe_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_PROCESS_FE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003548 curproxy->fe_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_FE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003549 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003550
William Lallemandcf62f7e2018-10-26 14:47:40 +02003551 if (curproxy->mode == PR_MODE_CLI) {
3552 curproxy->fe_req_ana |= AN_REQ_WAIT_CLI;
3553 curproxy->fe_rsp_ana |= AN_RES_WAIT_CLI;
3554 }
3555
Willy Tarreauc1a21672009-08-16 22:37:44 +02003556 /* both TCP and HTTP must check switching rules */
3557 curproxy->fe_req_ana |= AN_REQ_SWITCHING_RULES;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003558
3559 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003560 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003561 curproxy->fe_req_ana |= AN_REQ_FLT_START_FE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3562 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 +01003563 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003564 curproxy->fe_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3565 curproxy->fe_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003566 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003567 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003568 }
3569
3570 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreaufb356202010-08-03 14:02:05 +02003571 if (curproxy->tcp_req.inspect_delay ||
3572 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
3573 curproxy->be_req_ana |= AN_REQ_INSPECT_BE;
3574
Emeric Brun97679e72010-09-23 17:56:44 +02003575 if (!LIST_ISEMPTY(&curproxy->tcp_rep.inspect_rules))
3576 curproxy->be_rsp_ana |= AN_RES_INSPECT;
3577
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003578 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003579 curproxy->be_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_INNER | AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003580 curproxy->be_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_BE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003581 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003582
3583 /* If the backend does requires RDP cookie persistence, we have to
3584 * enable the corresponding analyser.
3585 */
3586 if (curproxy->options2 & PR_O2_RDPC_PRST)
3587 curproxy->be_req_ana |= AN_REQ_PRST_RDP_COOKIE;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003588
3589 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003590 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003591 curproxy->be_req_ana |= AN_REQ_FLT_START_BE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3592 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 +01003593 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003594 curproxy->be_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3595 curproxy->be_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003596 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003597 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003598 }
Christopher Fauleta717b992018-04-10 14:43:00 +02003599
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003600 /* Check the mux protocols, if any, for each listener and server
Christopher Fauleta717b992018-04-10 14:43:00 +02003601 * attached to the current proxy */
3602 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3603 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003604 const struct mux_proto_list *mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003605
Christopher Faulet49040582019-04-24 15:25:00 +02003606 /* Special case for HTX because legacy HTTP still exists */
3607 if (mode == PROTO_MODE_HTTP && (curproxy->options2 & PR_O2_USE_HTX))
Christopher Faulet7ff4f142018-11-20 11:23:52 +01003608 mode = PROTO_MODE_HTX;
3609
Christopher Fauleta717b992018-04-10 14:43:00 +02003610 if (!bind_conf->mux_proto)
3611 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003612
3613 /* it is possible that an incorrect mux was referenced
3614 * due to the proxy's mode not being taken into account
3615 * on first pass. Let's adjust it now.
3616 */
3617 mux_ent = conn_get_best_mux_entry(bind_conf->mux_proto->token, PROTO_SIDE_FE, mode);
3618
3619 if (!mux_ent || !isteq(mux_ent->token, bind_conf->mux_proto->token)) {
Christopher Fauleta717b992018-04-10 14:43:00 +02003620 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for 'bind %s' at [%s:%d].\n",
3621 proxy_type_str(curproxy), curproxy->id,
3622 (int)bind_conf->mux_proto->token.len,
3623 bind_conf->mux_proto->token.ptr,
3624 bind_conf->arg, bind_conf->file, bind_conf->line);
3625 cfgerr++;
3626 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003627
3628 /* update the mux */
3629 bind_conf->mux_proto = mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003630 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003631 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3632 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003633 const struct mux_proto_list *mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003634
Christopher Faulet49040582019-04-24 15:25:00 +02003635 /* Special case for HTX because legacy HTTP still exists */
3636 if (mode == PROTO_MODE_HTTP && (curproxy->options2 & PR_O2_USE_HTX))
Christopher Faulet7ff4f142018-11-20 11:23:52 +01003637 mode = PROTO_MODE_HTX;
3638
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003639 if (!newsrv->mux_proto)
3640 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003641
3642 /* it is possible that an incorrect mux was referenced
3643 * due to the proxy's mode not being taken into account
3644 * on first pass. Let's adjust it now.
3645 */
3646 mux_ent = conn_get_best_mux_entry(newsrv->mux_proto->token, PROTO_SIDE_BE, mode);
3647
3648 if (!mux_ent || !isteq(mux_ent->token, newsrv->mux_proto->token)) {
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003649 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for server '%s' at [%s:%d].\n",
3650 proxy_type_str(curproxy), curproxy->id,
3651 (int)newsrv->mux_proto->token.len,
3652 newsrv->mux_proto->token.ptr,
3653 newsrv->id, newsrv->conf.file, newsrv->conf.line);
3654 cfgerr++;
3655 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003656
3657 /* update the mux */
3658 newsrv->mux_proto = mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003659 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003660
Christopher Faulet6c9bbb22019-03-26 21:37:23 +01003661 /* the option "http-tunnel" is ignored when HTX is enabled and
3662 * only works with the legacy HTTP. So emit a warning if the
3663 * option is set on a HTX frontend. */
3664 if ((curproxy->cap & PR_CAP_FE) && curproxy->options2 & PR_O2_USE_HTX &&
3665 (curproxy->options & PR_O_HTTP_MODE) == PR_O_HTTP_TUN) {
3666 ha_warning("config : %s '%s' : the option 'http-tunnel' is ignored for HTX proxies.\n",
3667 proxy_type_str(curproxy), curproxy->id);
3668 curproxy->options &= ~PR_O_HTTP_MODE;
3669 }
3670
Willy Tarreau835daa12019-02-07 14:46:29 +01003671 /* initialize idle conns lists */
3672 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3673 int i;
3674
3675 newsrv->priv_conns = calloc(global.nbthread, sizeof(*newsrv->priv_conns));
3676 newsrv->idle_conns = calloc(global.nbthread, sizeof(*newsrv->idle_conns));
3677 newsrv->safe_conns = calloc(global.nbthread, sizeof(*newsrv->safe_conns));
3678
3679 if (!newsrv->priv_conns || !newsrv->idle_conns || !newsrv->safe_conns) {
Willy Tarreau980855b2019-02-07 14:59:29 +01003680 free(newsrv->safe_conns); newsrv->safe_conns = NULL;
3681 free(newsrv->idle_conns); newsrv->idle_conns = NULL;
3682 free(newsrv->priv_conns); newsrv->priv_conns = NULL;
Willy Tarreau835daa12019-02-07 14:46:29 +01003683 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
3684 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3685 cfgerr++;
3686 continue;
3687 }
3688
3689 for (i = 0; i < global.nbthread; i++) {
3690 LIST_INIT(&newsrv->priv_conns[i]);
3691 LIST_INIT(&newsrv->idle_conns[i]);
3692 LIST_INIT(&newsrv->safe_conns[i]);
3693 }
Willy Tarreau980855b2019-02-07 14:59:29 +01003694
3695 if (newsrv->max_idle_conns != 0) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003696 if (idle_conn_task == NULL) {
3697 idle_conn_task = task_new(MAX_THREADS_MASK);
3698 if (!idle_conn_task)
3699 goto err;
3700 idle_conn_task->process = srv_cleanup_idle_connections;
3701 idle_conn_task->context = NULL;
3702 for (i = 0; i < global.nbthread; i++) {
Willy Tarreau5fa7e732019-10-18 08:50:49 +02003703 idle_conn_cleanup[i] = task_new(1UL << i);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003704 if (!idle_conn_cleanup[i])
3705 goto err;
3706 idle_conn_cleanup[i]->process = srv_cleanup_toremove_connections;
3707 idle_conn_cleanup[i]->context = NULL;
Olivier Houchard0db0b042020-06-29 17:48:27 +02003708 HA_SPIN_INIT(&toremove_lock[i]);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003709 LIST_INIT(&toremove_connections[i]);
3710 }
3711 }
Willy Tarreauae7dbbf2020-01-24 11:19:13 +01003712 newsrv->idle_orphan_conns = calloc((unsigned short)global.nbthread, sizeof(*newsrv->idle_orphan_conns));
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003713 if (!newsrv->idle_orphan_conns)
Willy Tarreau980855b2019-02-07 14:59:29 +01003714 goto err;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003715 for (i = 0; i < global.nbthread; i++)
Willy Tarreau980855b2019-02-07 14:59:29 +01003716 LIST_INIT(&newsrv->idle_orphan_conns[i]);
Tim Duesterhusa57ea192020-02-22 16:39:05 +01003717 newsrv->curr_idle_thr = calloc(global.nbthread, sizeof(*newsrv->curr_idle_thr));
Olivier Houchardf1314812019-02-18 16:41:17 +01003718 if (!newsrv->curr_idle_thr)
3719 goto err;
Willy Tarreau980855b2019-02-07 14:59:29 +01003720 continue;
3721 err:
3722 ha_alert("parsing [%s:%d] : failed to allocate idle connection tasks for server '%s'.\n",
3723 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3724 cfgerr++;
3725 continue;
3726 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003727 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003728 }
3729
3730 /***********************************************************/
3731 /* At this point, target names have already been resolved. */
3732 /***********************************************************/
3733
3734 /* Check multi-process mode compatibility */
3735
3736 if (global.nbproc > 1 && global.stats_fe) {
3737 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3738 unsigned long mask;
3739
Willy Tarreau6daac192019-02-02 17:39:53 +01003740 mask = proc_mask(global.stats_fe->bind_proc) && all_proc_mask;
3741 mask &= proc_mask(bind_conf->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003742
3743 /* stop here if more than one process is used */
Willy Tarreau9504dd62018-10-15 09:37:03 +02003744 if (atleast2(mask))
Willy Tarreau419ead82014-09-16 13:41:21 +02003745 break;
3746 }
3747 if (&bind_conf->by_fe != &global.stats_fe->conf.bind) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003748 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 +02003749 }
3750 }
3751
3752 /* Make each frontend inherit bind-process from its listeners when not specified. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003753 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003754 if (curproxy->bind_proc)
3755 continue;
3756
3757 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3758 unsigned long mask;
3759
Willy Tarreau6daac192019-02-02 17:39:53 +01003760 mask = proc_mask(bind_conf->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003761 curproxy->bind_proc |= mask;
3762 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003763 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003764 }
3765
3766 if (global.stats_fe) {
3767 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3768 unsigned long mask;
3769
Cyril Bonté06181952016-02-24 00:14:54 +01003770 mask = bind_conf->bind_proc ? bind_conf->bind_proc : 0;
Willy Tarreau419ead82014-09-16 13:41:21 +02003771 global.stats_fe->bind_proc |= mask;
3772 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003773 global.stats_fe->bind_proc = proc_mask(global.stats_fe->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003774 }
3775
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003776 /* propagate bindings from frontends to backends. Don't do it if there
3777 * are any fatal errors as we must not call it with unresolved proxies.
3778 */
3779 if (!cfgerr) {
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003780 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003781 if (curproxy->cap & PR_CAP_FE)
3782 propagate_processes(curproxy, NULL);
3783 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003784 }
3785
3786 /* Bind each unbound backend to all processes when not specified. */
Willy Tarreau6daac192019-02-02 17:39:53 +01003787 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
3788 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003789
3790 /*******************************************************/
3791 /* At this step, all proxies have a non-null bind_proc */
3792 /*******************************************************/
3793
3794 /* perform the final checks before creating tasks */
3795
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003796 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003797 struct listener *listener;
3798 unsigned int next_id;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003799
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003800 /* Configure SSL for each bind line.
3801 * Note: if configuration fails at some point, the ->ctx member
3802 * remains NULL so that listeners can later detach.
3803 */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003804 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau55d37912016-12-21 23:38:39 +01003805 if (bind_conf->xprt->prepare_bind_conf &&
3806 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003807 cfgerr++;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003808 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003809
Willy Tarreaue6b98942007-10-29 01:09:36 +01003810 /* adjust this proxy's listeners */
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003811 next_id = 1;
Willy Tarreau4348fad2012-09-20 16:48:07 +02003812 list_for_each_entry(listener, &curproxy->conf.listeners, by_fe) {
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003813 int nbproc;
3814
3815 nbproc = my_popcountl(curproxy->bind_proc &
Cyril Bonté4920d702016-04-15 07:58:43 +02003816 (listener->bind_conf->bind_proc ? listener->bind_conf->bind_proc : curproxy->bind_proc) &
Willy Tarreaua38a7172019-02-02 17:11:28 +01003817 all_proc_mask);
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003818
3819 if (!nbproc) /* no intersection between listener and frontend */
3820 nbproc = 1;
3821
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003822 if (!listener->luid) {
3823 /* listener ID not set, use automatic numbering with first
3824 * spare entry starting with next_luid.
3825 */
3826 next_id = get_next_id(&curproxy->conf.used_listener_id, next_id);
3827 listener->conf.id.key = listener->luid = next_id;
3828 eb32_insert(&curproxy->conf.used_listener_id, &listener->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003829 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01003830 next_id++;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003831
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003832 /* enable separate counters */
3833 if (curproxy->options2 & PR_O2_SOCKSTAT) {
Willy Tarreauae9bea02016-11-25 14:44:52 +01003834 listener->counters = calloc(1, sizeof(*listener->counters));
Willy Tarreau19d14ef2012-10-29 16:51:55 +01003835 if (!listener->name)
3836 memprintf(&listener->name, "sock-%d", listener->luid);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003837 }
Willy Tarreau81796be2012-09-22 19:11:47 +02003838
Willy Tarreaue6b98942007-10-29 01:09:36 +01003839 if (curproxy->options & PR_O_TCP_NOLING)
3840 listener->options |= LI_O_NOLINGER;
Willy Tarreau16a21472012-11-19 12:39:59 +01003841 if (!listener->maxaccept)
3842 listener->maxaccept = global.tune.maxaccept ? global.tune.maxaccept : 64;
3843
3844 /* we want to have an optimal behaviour on single process mode to
3845 * maximize the work at once, but in multi-process we want to keep
3846 * some fairness between processes, so we target half of the max
3847 * number of events to be balanced over all the processes the proxy
3848 * is bound to. Rememeber that maxaccept = -1 must be kept as it is
3849 * used to disable the limit.
3850 */
Christopher Faulet02f3cf12019-04-30 14:08:41 +02003851 if (listener->maxaccept > 0 && nbproc > 1) {
3852 listener->maxaccept = (listener->maxaccept + 1) / 2;
Willy Tarreau16a21472012-11-19 12:39:59 +01003853 listener->maxaccept = (listener->maxaccept + nbproc - 1) / nbproc;
3854 }
3855
Willy Tarreau9903f0e2015-04-04 18:50:31 +02003856 listener->accept = session_accept_fd;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003857 listener->analysers |= curproxy->fe_req_ana;
Willy Tarreau10b688f2015-03-13 16:43:12 +01003858 listener->default_target = curproxy->default_target;
Willy Tarreau3bc13772008-12-07 11:50:35 +01003859
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003860 if (!LIST_ISEMPTY(&curproxy->tcp_req.l4_rules))
Willy Tarreau7d9736f2016-10-21 16:34:21 +02003861 listener->options |= LI_O_TCP_L4_RULES;
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003862
Willy Tarreau620408f2016-10-21 16:37:51 +02003863 if (!LIST_ISEMPTY(&curproxy->tcp_req.l5_rules))
3864 listener->options |= LI_O_TCP_L5_RULES;
3865
Willy Tarreaude3041d2010-05-31 10:56:17 +02003866 if (curproxy->mon_mask.s_addr)
3867 listener->options |= LI_O_CHK_MONNET;
3868
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003869 /* smart accept mode is automatic in HTTP mode */
3870 if ((curproxy->options2 & PR_O2_SMARTACC) ||
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003871 ((curproxy->mode == PR_MODE_HTTP || listener->bind_conf->is_ssl) &&
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003872 !(curproxy->no_options2 & PR_O2_SMARTACC)))
3873 listener->options |= LI_O_NOQUICKACK;
Willy Tarreaue6b98942007-10-29 01:09:36 +01003874 }
3875
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003876 /* Release unused SSL configs */
3877 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau795cdab2016-12-22 17:30:54 +01003878 if (!bind_conf->is_ssl && bind_conf->xprt->destroy_bind_conf)
3879 bind_conf->xprt->destroy_bind_conf(bind_conf);
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003880 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003881
Willy Tarreaua38a7172019-02-02 17:11:28 +01003882 if (atleast2(curproxy->bind_proc & all_proc_mask)) {
Willy Tarreau102df612014-05-07 23:56:38 +02003883 if (curproxy->uri_auth) {
Willy Tarreaueb791e02014-09-16 15:11:04 +02003884 int count, maxproc = 0;
3885
3886 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
David Carliere6c39412015-07-02 07:00:17 +00003887 count = my_popcountl(bind_conf->bind_proc);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003888 if (count > maxproc)
3889 maxproc = count;
3890 }
3891 /* backends have 0, frontends have 1 or more */
3892 if (maxproc != 1)
Christopher Faulet767a84b2017-11-24 16:50:31 +01003893 ha_warning("Proxy '%s': in multi-process mode, stats will be"
3894 " limited to process assigned to the current request.\n",
3895 curproxy->id);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003896
Willy Tarreau102df612014-05-07 23:56:38 +02003897 if (!LIST_ISEMPTY(&curproxy->uri_auth->admin_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003898 ha_warning("Proxy '%s': stats admin will not work correctly in multi-process mode.\n",
3899 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003900 }
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003901 }
Willy Tarreau102df612014-05-07 23:56:38 +02003902 if (!LIST_ISEMPTY(&curproxy->sticking_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003903 ha_warning("Proxy '%s': sticking rules will not work correctly in multi-process mode.\n",
3904 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003905 }
3906 }
Willy Tarreau918ff602011-07-25 16:33:49 +02003907
3908 /* create the task associated with the proxy */
Emeric Brunc60def82017-09-27 14:59:38 +02003909 curproxy->task = task_new(MAX_THREADS_MASK);
Willy Tarreau918ff602011-07-25 16:33:49 +02003910 if (curproxy->task) {
3911 curproxy->task->context = curproxy;
3912 curproxy->task->process = manage_proxy;
Willy Tarreau918ff602011-07-25 16:33:49 +02003913 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003914 ha_alert("Proxy '%s': no more memory when trying to allocate the management task\n",
3915 curproxy->id);
Willy Tarreau918ff602011-07-25 16:33:49 +02003916 cfgerr++;
3917 }
Willy Tarreaub369a042014-09-16 13:21:03 +02003918 }
3919
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003920 /*
3921 * Recount currently required checks.
3922 */
3923
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003924 for (curproxy=proxies_list; curproxy; curproxy=curproxy->next) {
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003925 int optnum;
3926
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003927 for (optnum = 0; cfg_opts[optnum].name; optnum++)
3928 if (curproxy->options & cfg_opts[optnum].val)
3929 global.last_checks |= cfg_opts[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003930
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003931 for (optnum = 0; cfg_opts2[optnum].name; optnum++)
3932 if (curproxy->options2 & cfg_opts2[optnum].val)
3933 global.last_checks |= cfg_opts2[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003934 }
3935
Willy Tarreau0fca4832015-05-01 19:12:05 +02003936 /* compute the required process bindings for the peers */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003937 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003938 if (curproxy->table && curproxy->table->peers.p)
3939 curproxy->table->peers.p->peers_fe->bind_proc |= curproxy->bind_proc;
Willy Tarreau0fca4832015-05-01 19:12:05 +02003940
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01003941 /* compute the required process bindings for the peers from <stktables_list>
3942 * for all the stick-tables, the ones coming with "peers" sections included.
3943 */
3944 for (t = stktables_list; t; t = t->next) {
3945 struct proxy *p;
3946
3947 for (p = t->proxies_list; p; p = p->next_stkt_ref) {
3948 if (t->peers.p && t->peers.p->peers_fe) {
3949 t->peers.p->peers_fe->bind_proc |= p->bind_proc;
3950 }
3951 }
3952 }
3953
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003954 if (cfg_peers) {
3955 struct peers *curpeers = cfg_peers, **last;
Willy Tarreau122541c2011-09-07 21:24:49 +02003956 struct peer *p, *pb;
3957
William Lallemand98235322020-03-24 16:02:48 +01003958 /* In the case the peers frontend was not initialized by a
3959 stick-table used in the configuration, set its bind_proc
3960 by default to the first process. */
3961 while (curpeers) {
William Lallemand0412f692020-03-24 16:42:15 +01003962 if (curpeers->peers_fe) {
3963 if (curpeers->peers_fe->bind_proc == 0)
3964 curpeers->peers_fe->bind_proc = 1;
3965 }
William Lallemand98235322020-03-24 16:02:48 +01003966 curpeers = curpeers->next;
3967 }
3968
3969 curpeers = cfg_peers;
Willy Tarreau1e273012015-05-01 19:15:17 +02003970 /* Remove all peers sections which don't have a valid listener,
3971 * which are not used by any table, or which are bound to more
3972 * than one process.
Willy Tarreau122541c2011-09-07 21:24:49 +02003973 */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003974 last = &cfg_peers;
Willy Tarreau122541c2011-09-07 21:24:49 +02003975 while (*last) {
Frédéric Lécaillea30b1d72020-03-24 20:08:30 +01003976 struct stktable *t;
Willy Tarreau122541c2011-09-07 21:24:49 +02003977 curpeers = *last;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003978
3979 if (curpeers->state == PR_STSTOPPED) {
3980 /* the "disabled" keyword was present */
3981 if (curpeers->peers_fe)
3982 stop_proxy(curpeers->peers_fe);
3983 curpeers->peers_fe = NULL;
3984 }
Frédéric Lécaille854079b2019-10-04 08:30:04 +02003985 else if (!curpeers->peers_fe || !curpeers->peers_fe->id) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003986 ha_warning("Removing incomplete section 'peers %s' (no peer named '%s').\n",
3987 curpeers->id, localpeer);
Frédéric Lécaillea30b1d72020-03-24 20:08:30 +01003988 if (curpeers->peers_fe)
3989 stop_proxy(curpeers->peers_fe);
3990 curpeers->peers_fe = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003991 }
Willy Tarreau9504dd62018-10-15 09:37:03 +02003992 else if (atleast2(curpeers->peers_fe->bind_proc)) {
Willy Tarreau1e273012015-05-01 19:15:17 +02003993 /* either it's totally stopped or too much used */
3994 if (curpeers->peers_fe->bind_proc) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003995 ha_alert("Peers section '%s': peers referenced by sections "
3996 "running in different processes (%d different ones). "
3997 "Check global.nbproc and all tables' bind-process "
3998 "settings.\n", curpeers->id, my_popcountl(curpeers->peers_fe->bind_proc));
Willy Tarreau1e273012015-05-01 19:15:17 +02003999 cfgerr++;
4000 }
4001 stop_proxy(curpeers->peers_fe);
4002 curpeers->peers_fe = NULL;
4003 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004004 else {
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01004005 /* Initializes the transport layer of the server part of all the peers belonging to
4006 * <curpeers> section if required.
4007 * Note that ->srv is used by the local peer of a new process to connect to the local peer
4008 * of an old process.
4009 */
Frédéric Lécaille1055e682018-04-26 14:35:21 +02004010 p = curpeers->remote;
4011 while (p) {
Frédéric Lécaille355b2032019-01-11 14:06:12 +01004012 if (p->srv) {
Christopher Faulet68d35ae2020-03-27 18:55:49 +01004013 if (p->srv->use_ssl == 1 && xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
Frédéric Lécaille355b2032019-01-11 14:06:12 +01004014 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(p->srv);
4015 }
Frédéric Lécaille1055e682018-04-26 14:35:21 +02004016 p = p->next;
4017 }
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01004018 /* Configure the SSL bindings of the local peer if required. */
4019 if (!LIST_ISEMPTY(&curpeers->peers_fe->conf.bind)) {
4020 struct list *l;
4021 struct bind_conf *bind_conf;
4022
4023 l = &curpeers->peers_fe->conf.bind;
4024 bind_conf = LIST_ELEM(l->n, typeof(bind_conf), by_fe);
4025 if (bind_conf->xprt->prepare_bind_conf &&
4026 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
4027 cfgerr++;
4028 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02004029 if (!peers_init_sync(curpeers) || !peers_alloc_dcache(curpeers)) {
Willy Tarreaud9443442018-10-15 11:18:03 +02004030 ha_alert("Peers section '%s': out of memory, giving up on peers.\n",
4031 curpeers->id);
4032 cfgerr++;
4033 break;
4034 }
Willy Tarreau122541c2011-09-07 21:24:49 +02004035 last = &curpeers->next;
4036 continue;
4037 }
4038
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004039 /* clean what has been detected above */
Willy Tarreau122541c2011-09-07 21:24:49 +02004040 p = curpeers->remote;
4041 while (p) {
4042 pb = p->next;
4043 free(p->id);
4044 free(p);
4045 p = pb;
4046 }
4047
4048 /* Destroy and unlink this curpeers section.
4049 * Note: curpeers is backed up into *last.
4050 */
4051 free(curpeers->id);
4052 curpeers = curpeers->next;
Frédéric Lécaillea30b1d72020-03-24 20:08:30 +01004053 /* Reset any refereance to this peers section in the list of stick-tables */
4054 for (t = stktables_list; t; t = t->next) {
4055 if (t->peers.p && t->peers.p == *last)
4056 t->peers.p = NULL;
4057 }
Willy Tarreau122541c2011-09-07 21:24:49 +02004058 free(*last);
4059 *last = curpeers;
4060 }
4061 }
4062
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004063 for (t = stktables_list; t; t = t->next) {
4064 if (t->proxy)
4065 continue;
4066 if (!stktable_init(t)) {
4067 ha_alert("Proxy '%s': failed to initialize stick-table.\n", t->id);
4068 cfgerr++;
4069 }
4070 }
4071
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004072 /* initialize stick-tables on backend capable proxies. This must not
4073 * be done earlier because the data size may be discovered while parsing
4074 * other proxies.
4075 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004076 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004077 if (curproxy->state == PR_STSTOPPED || !curproxy->table)
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004078 continue;
4079
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004080 if (!stktable_init(curproxy->table)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004081 ha_alert("Proxy '%s': failed to initialize stick-table.\n", curproxy->id);
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004082 cfgerr++;
4083 }
4084 }
4085
Simon Horman0d16a402015-01-30 11:22:58 +09004086 if (mailers) {
4087 struct mailers *curmailers = mailers, **last;
4088 struct mailer *m, *mb;
4089
4090 /* Remove all mailers sections which don't have a valid listener.
4091 * This can happen when a mailers section is never referenced.
4092 */
4093 last = &mailers;
4094 while (*last) {
4095 curmailers = *last;
4096 if (curmailers->users) {
4097 last = &curmailers->next;
4098 continue;
4099 }
4100
Christopher Faulet767a84b2017-11-24 16:50:31 +01004101 ha_warning("Removing incomplete section 'mailers %s'.\n",
4102 curmailers->id);
Simon Horman0d16a402015-01-30 11:22:58 +09004103
4104 m = curmailers->mailer_list;
4105 while (m) {
4106 mb = m->next;
4107 free(m->id);
4108 free(m);
4109 m = mb;
4110 }
4111
4112 /* Destroy and unlink this curmailers section.
4113 * Note: curmailers is backed up into *last.
4114 */
4115 free(curmailers->id);
4116 curmailers = curmailers->next;
4117 free(*last);
4118 *last = curmailers;
4119 }
4120 }
4121
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004122 /* Update server_state_file_name to backend name if backend is supposed to use
4123 * a server-state file locally defined and none has been provided */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004124 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004125 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_LOCAL &&
4126 curproxy->server_state_file_name == NULL)
4127 curproxy->server_state_file_name = strdup(curproxy->id);
4128 }
4129
Willy Tarreaubafbe012017-11-24 17:34:44 +01004130 pool_head_hdr_idx = create_pool("hdr_idx",
Willy Tarreauac1932d2011-10-24 19:14:41 +02004131 global.tune.max_http_hdr * sizeof(struct hdr_idx_elem),
Willy Tarreau34eb6712011-10-24 18:15:04 +02004132 MEM_F_SHARED);
4133
Ben Draut054fbee2018-04-13 15:43:04 -06004134 list_for_each_entry(curr_resolvers, &dns_resolvers, list) {
4135 if (LIST_ISEMPTY(&curr_resolvers->nameservers)) {
4136 ha_warning("config : resolvers '%s' [%s:%d] has no nameservers configured!\n",
4137 curr_resolvers->id, curr_resolvers->conf.file,
4138 curr_resolvers->conf.line);
4139 err_code |= ERR_WARN;
4140 }
4141 }
4142
William Lallemand48b4bb42017-10-23 14:36:34 +02004143 list_for_each_entry(postparser, &postparsers, list) {
4144 if (postparser->func)
4145 cfgerr += postparser->func();
4146 }
4147
Willy Tarreaubb925012009-07-23 13:36:36 +02004148 if (cfgerr > 0)
4149 err_code |= ERR_ALERT | ERR_FATAL;
4150 out:
4151 return err_code;
Willy Tarreaubaaee002006-06-26 02:48:02 +02004152}
4153
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004154/*
4155 * Registers the CFG keyword list <kwl> as a list of valid keywords for next
4156 * parsing sessions.
4157 */
4158void cfg_register_keywords(struct cfg_kw_list *kwl)
4159{
4160 LIST_ADDQ(&cfg_keywords.list, &kwl->list);
4161}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004162
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004163/*
4164 * Unregisters the CFG keyword list <kwl> from the list of valid keywords.
4165 */
4166void cfg_unregister_keywords(struct cfg_kw_list *kwl)
4167{
4168 LIST_DEL(&kwl->list);
4169 LIST_INIT(&kwl->list);
4170}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004171
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004172/* this function register new section in the haproxy configuration file.
4173 * <section_name> is the name of this new section and <section_parser>
4174 * is the called parser. If two section declaration have the same name,
4175 * only the first declared is used.
4176 */
4177int cfg_register_section(char *section_name,
William Lallemandd2ff56d2017-10-16 11:06:50 +02004178 int (*section_parser)(const char *, int, char **, int),
4179 int (*post_section_parser)())
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004180{
4181 struct cfg_section *cs;
4182
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004183 list_for_each_entry(cs, &sections, list) {
4184 if (strcmp(cs->section_name, section_name) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004185 ha_alert("register section '%s': already registered.\n", section_name);
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004186 return 0;
4187 }
4188 }
4189
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004190 cs = calloc(1, sizeof(*cs));
4191 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004192 ha_alert("register section '%s': out of memory.\n", section_name);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004193 return 0;
4194 }
4195
4196 cs->section_name = section_name;
4197 cs->section_parser = section_parser;
William Lallemandd2ff56d2017-10-16 11:06:50 +02004198 cs->post_section_parser = post_section_parser;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004199
4200 LIST_ADDQ(&sections, &cs->list);
4201
4202 return 1;
4203}
4204
William Lallemand48b4bb42017-10-23 14:36:34 +02004205/* this function register a new function which will be called once the haproxy
4206 * configuration file has been parsed. It's useful to check dependencies
4207 * between sections or to resolve items once everything is parsed.
4208 */
4209int cfg_register_postparser(char *name, int (*func)())
4210{
4211 struct cfg_postparser *cp;
4212
4213 cp = calloc(1, sizeof(*cp));
4214 if (!cp) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004215 ha_alert("register postparser '%s': out of memory.\n", name);
William Lallemand48b4bb42017-10-23 14:36:34 +02004216 return 0;
4217 }
4218 cp->name = name;
4219 cp->func = func;
4220
4221 LIST_ADDQ(&postparsers, &cp->list);
4222
4223 return 1;
4224}
4225
Willy Tarreaubaaee002006-06-26 02:48:02 +02004226/*
David Carlier845efb52015-09-25 11:49:18 +01004227 * free all config section entries
4228 */
4229void cfg_unregister_sections(void)
4230{
4231 struct cfg_section *cs, *ics;
4232
4233 list_for_each_entry_safe(cs, ics, &sections, list) {
4234 LIST_DEL(&cs->list);
4235 free(cs);
4236 }
4237}
4238
Christopher Faulet7110b402016-10-26 11:09:44 +02004239void cfg_backup_sections(struct list *backup_sections)
4240{
4241 struct cfg_section *cs, *ics;
4242
4243 list_for_each_entry_safe(cs, ics, &sections, list) {
4244 LIST_DEL(&cs->list);
4245 LIST_ADDQ(backup_sections, &cs->list);
4246 }
4247}
4248
4249void cfg_restore_sections(struct list *backup_sections)
4250{
4251 struct cfg_section *cs, *ics;
4252
4253 list_for_each_entry_safe(cs, ics, backup_sections, list) {
4254 LIST_DEL(&cs->list);
4255 LIST_ADDQ(&sections, &cs->list);
4256 }
4257}
4258
Willy Tarreaue6552512018-11-26 11:33:13 +01004259/* these are the config sections handled by default */
4260REGISTER_CONFIG_SECTION("listen", cfg_parse_listen, NULL);
4261REGISTER_CONFIG_SECTION("frontend", cfg_parse_listen, NULL);
4262REGISTER_CONFIG_SECTION("backend", cfg_parse_listen, NULL);
4263REGISTER_CONFIG_SECTION("defaults", cfg_parse_listen, NULL);
4264REGISTER_CONFIG_SECTION("global", cfg_parse_global, NULL);
4265REGISTER_CONFIG_SECTION("userlist", cfg_parse_users, NULL);
4266REGISTER_CONFIG_SECTION("peers", cfg_parse_peers, NULL);
4267REGISTER_CONFIG_SECTION("mailers", cfg_parse_mailers, NULL);
4268REGISTER_CONFIG_SECTION("namespace_list", cfg_parse_netns, NULL);
4269REGISTER_CONFIG_SECTION("resolvers", cfg_parse_resolvers, NULL);
Willy Tarreau659fbf02016-05-26 17:55:28 +02004270
David Carlier845efb52015-09-25 11:49:18 +01004271/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02004272 * Local variables:
4273 * c-indent-level: 8
4274 * c-basic-offset: 8
4275 * End:
4276 */