blob: 59bdb3bab49e3c7224c7e803ab7bdb1bfc764649 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Configuration parser
3 *
Willy Tarreauff011f22011-01-06 17:51:27 +01004 * Copyright 2000-2011 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreaue5733232019-05-22 19:24:06 +020013#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +020014/* This is to have crypt() defined on Linux */
15#define _GNU_SOURCE
16
Willy Tarreaue5733232019-05-22 19:24:06 +020017#ifdef USE_CRYPT_H
Cyril Bonté1a0191d2014-08-29 20:20:02 +020018/* some platforms such as Solaris need this */
19#include <crypt.h>
20#endif
Willy Tarreaue5733232019-05-22 19:24:06 +020021#endif /* USE_LIBCRYPT */
Cyril Bonté1a0191d2014-08-29 20:20:02 +020022
Willy Tarreaubaaee002006-06-26 02:48:02 +020023#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <netdb.h>
27#include <ctype.h>
Willy Tarreau95c20ac2007-03-25 15:39:23 +020028#include <pwd.h>
29#include <grp.h>
Willy Tarreau0b4ed902007-03-26 00:18:40 +020030#include <errno.h>
Willy Tarreau3f49b302007-06-11 00:29:26 +020031#include <sys/types.h>
32#include <sys/stat.h>
33#include <fcntl.h>
34#include <unistd.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020035
Willy Tarreau2dd0d472006-06-29 17:53:05 +020036#include <common/cfgparse.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020037#include <common/chunk.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020038#include <common/config.h>
Willy Tarreau058e9072009-07-20 09:30:05 +020039#include <common/errors.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020040#include <common/memory.h>
41#include <common/standard.h>
42#include <common/time.h>
43#include <common/uri_auth.h>
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +010044#include <common/namespace.h>
Emeric Brunc60def82017-09-27 14:59:38 +020045#include <common/hathreads.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020046
47#include <types/capture.h>
Christopher Fauletd7c91962015-04-30 11:48:27 +020048#include <types/filters.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020049#include <types/global.h>
Willy Tarreau3fdb3662012-11-12 00:42:33 +010050#include <types/obj_type.h>
Emeric Brun32da3c42010-09-23 18:39:19 +020051#include <types/peers.h>
Simon Horman0d16a402015-01-30 11:22:58 +090052#include <types/mailers.h>
Baptiste Assmann325137d2015-04-13 23:40:55 +020053#include <types/dns.h>
William Lallemand9ed62032016-11-21 17:49:11 +010054#include <types/stats.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020055
Willy Tarreaueb0c6142007-05-07 00:53:22 +020056#include <proto/acl.h>
Christopher Faulet4fce0d82017-09-18 11:57:31 +020057#include <proto/action.h>
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +010058#include <proto/auth.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020059#include <proto/backend.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020060#include <proto/channel.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020061#include <proto/checks.h>
Baptiste Assmann201c07f2017-05-22 15:17:15 +020062#include <proto/dns.h>
William Lallemand9ed62032016-11-21 17:49:11 +010063#include <proto/stats.h>
Christopher Fauletd7c91962015-04-30 11:48:27 +020064#include <proto/filters.h>
Willy Tarreaueb472682010-05-28 18:46:57 +020065#include <proto/frontend.h>
Willy Tarreau61c112a2018-10-02 16:43:32 +020066#include <proto/http_rules.h>
Willy Tarreau6b2e11b2009-10-01 07:52:15 +020067#include <proto/lb_chash.h>
Willy Tarreauf09c6602012-02-13 17:12:08 +010068#include <proto/lb_fas.h>
Willy Tarreauf89c1872009-10-01 11:19:37 +020069#include <proto/lb_fwlc.h>
70#include <proto/lb_fwrr.h>
71#include <proto/lb_map.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020072#include <proto/listener.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020073#include <proto/log.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020074#include <proto/protocol.h>
Christopher Fauletfc9cfe42019-07-16 14:54:53 +020075#include <proto/http_ana.h>
Willy Tarreau2b5652f2006-12-31 17:46:05 +010076#include <proto/proxy.h>
Emeric Brun32da3c42010-09-23 18:39:19 +020077#include <proto/peers.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020078#include <proto/sample.h>
Willy Tarreau9903f0e2015-04-04 18:50:31 +020079#include <proto/session.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020080#include <proto/server.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020081#include <proto/stream.h>
Emeric Brunb982a3d2010-01-04 15:45:53 +010082#include <proto/stick_table.h>
Willy Tarreau39713102016-11-25 15:49:32 +010083#include <proto/task.h>
84#include <proto/tcp_rules.h>
Olivier Houchard673867c2018-05-25 16:58:52 +020085#include <proto/connection.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020086
87
Willy Tarreauf3c69202006-07-09 16:42:34 +020088/* This is the SSLv3 CLIENT HELLO packet used in conjunction with the
89 * ssl-hello-chk option to ensure that the remote server speaks SSL.
90 *
91 * Check RFC 2246 (TLSv1.0) sections A.3 and A.4 for details.
92 */
93const char sslv3_client_hello_pkt[] = {
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +050094 "\x16" /* ContentType : 0x16 = Handshake */
Willy Tarreauf3c69202006-07-09 16:42:34 +020095 "\x03\x00" /* ProtocolVersion : 0x0300 = SSLv3 */
96 "\x00\x79" /* ContentLength : 0x79 bytes after this one */
97 "\x01" /* HanshakeType : 0x01 = CLIENT HELLO */
98 "\x00\x00\x75" /* HandshakeLength : 0x75 bytes after this one */
99 "\x03\x00" /* Hello Version : 0x0300 = v3 */
100 "\x00\x00\x00\x00" /* Unix GMT Time (s) : filled with <now> (@0x0B) */
101 "HAPROXYSSLCHK\nHAPROXYSSLCHK\n" /* Random : must be exactly 28 bytes */
102 "\x00" /* Session ID length : empty (no session ID) */
103 "\x00\x4E" /* Cipher Suite Length : 78 bytes after this one */
104 "\x00\x01" "\x00\x02" "\x00\x03" "\x00\x04" /* 39 most common ciphers : */
105 "\x00\x05" "\x00\x06" "\x00\x07" "\x00\x08" /* 0x01...0x1B, 0x2F...0x3A */
106 "\x00\x09" "\x00\x0A" "\x00\x0B" "\x00\x0C" /* This covers RSA/DH, */
107 "\x00\x0D" "\x00\x0E" "\x00\x0F" "\x00\x10" /* various bit lengths, */
108 "\x00\x11" "\x00\x12" "\x00\x13" "\x00\x14" /* SHA1/MD5, DES/3DES/AES... */
109 "\x00\x15" "\x00\x16" "\x00\x17" "\x00\x18"
110 "\x00\x19" "\x00\x1A" "\x00\x1B" "\x00\x2F"
111 "\x00\x30" "\x00\x31" "\x00\x32" "\x00\x33"
112 "\x00\x34" "\x00\x35" "\x00\x36" "\x00\x37"
113 "\x00\x38" "\x00\x39" "\x00\x3A"
114 "\x01" /* Compression Length : 0x01 = 1 byte for types */
115 "\x00" /* Compression Type : 0x00 = NULL compression */
116};
117
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +0100118/* Used to chain configuration sections definitions. This list
119 * stores struct cfg_section
120 */
121struct list sections = LIST_HEAD_INIT(sections);
122
William Lallemand48b4bb42017-10-23 14:36:34 +0200123struct list postparsers = LIST_HEAD_INIT(postparsers);
124
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100125char *cursection = NULL;
126struct proxy defproxy = { }; /* fake proxy used to assign default values on all instances */
Willy Tarreauc8d5b952019-02-27 17:25:52 +0100127int cfg_maxpconn = 0; /* # of simultaneous connections per proxy (-N) */
Willy Tarreau5af24ef2009-03-15 15:23:16 +0100128int cfg_maxconn = 0; /* # of simultaneous connections, (-n) */
Christopher Faulet79bdef32016-11-04 22:36:15 +0100129char *cfg_scope = NULL; /* the current scope during the configuration parsing */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200130
Willy Tarreau5b2c3362008-07-09 19:39:06 +0200131/* List head of all known configuration keywords */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100132struct cfg_kw_list cfg_keywords = {
Willy Tarreau5b2c3362008-07-09 19:39:06 +0200133 .list = LIST_HEAD_INIT(cfg_keywords.list)
134};
135
Willy Tarreaubaaee002006-06-26 02:48:02 +0200136/*
137 * converts <str> to a list of listeners which are dynamically allocated.
138 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
139 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
140 * - <port> is a numerical port from 1 to 65535 ;
141 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
142 * This can be repeated as many times as necessary, separated by a coma.
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200143 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
144 * not NULL, it must be a valid pointer to either NULL or a freeable area that
145 * will be replaced with an error message.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200146 */
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200147int 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 +0200148{
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100149 char *next, *dupstr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200150 int port, end;
151
152 next = dupstr = strdup(str);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200153
Willy Tarreaubaaee002006-06-26 02:48:02 +0200154 while (next && *next) {
William Lallemand75ea0a02017-11-15 19:02:58 +0100155 int inherited = 0;
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200156 struct sockaddr_storage *ss2;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100157 int fd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200158
159 str = next;
160 /* 1) look for the end of the first address */
Krzysztof Piotr Oledzki52d522b2009-01-27 16:57:08 +0100161 if ((next = strchr(str, ',')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200162 *next++ = 0;
163 }
164
Willy Tarreau48ef4c92017-01-06 18:32:38 +0100165 ss2 = str2sa_range(str, NULL, &port, &end, err,
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200166 curproxy == global.stats_fe ? NULL : global.unix_bind.prefix,
Thierry FOURNIER7fe3be72015-09-26 20:03:36 +0200167 NULL, 1);
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100168 if (!ss2)
169 goto fail;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200170
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100171 if (ss2->ss_family == AF_INET || ss2->ss_family == AF_INET6) {
Willy Tarreau6d03cc32013-02-20 17:26:02 +0100172 if (!port && !end) {
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200173 memprintf(err, "missing port number: '%s'\n", str);
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100174 goto fail;
Emeric Bruned760922010-10-22 17:59:25 +0200175 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200176
Willy Tarreau6d03cc32013-02-20 17:26:02 +0100177 if (!port || !end) {
178 memprintf(err, "port offsets are not allowed in 'bind': '%s'\n", str);
179 goto fail;
180 }
181
Emeric Bruned760922010-10-22 17:59:25 +0200182 if (port < 1 || port > 65535) {
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200183 memprintf(err, "invalid port '%d' specified for address '%s'.\n", port, str);
Emeric Bruned760922010-10-22 17:59:25 +0200184 goto fail;
185 }
186
187 if (end < 1 || end > 65535) {
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200188 memprintf(err, "invalid port '%d' specified for address '%s'.\n", end, str);
Emeric Bruned760922010-10-22 17:59:25 +0200189 goto fail;
190 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200191 }
Willy Tarreau40aa0702013-03-10 23:51:38 +0100192 else if (ss2->ss_family == AF_UNSPEC) {
193 socklen_t addr_len;
William Lallemand75ea0a02017-11-15 19:02:58 +0100194 inherited = 1;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100195
196 /* We want to attach to an already bound fd whose number
197 * is in the addr part of ss2 when cast to sockaddr_in.
198 * Note that by definition there is a single listener.
199 * We still have to determine the address family to
200 * register the correct protocol.
201 */
202 fd = ((struct sockaddr_in *)ss2)->sin_addr.s_addr;
203 addr_len = sizeof(*ss2);
204 if (getsockname(fd, (struct sockaddr *)ss2, &addr_len) == -1) {
205 memprintf(err, "cannot use file descriptor '%d' : %s.\n", fd, strerror(errno));
206 goto fail;
207 }
208
209 port = end = get_host_port(ss2);
William Lallemand2fe7dd02018-09-11 16:51:29 +0200210
211 } else if (ss2->ss_family == AF_CUST_SOCKPAIR) {
212 socklen_t addr_len;
213 inherited = 1;
214
215 fd = ((struct sockaddr_in *)ss2)->sin_addr.s_addr;
216 addr_len = sizeof(*ss2);
217 if (getsockname(fd, (struct sockaddr *)ss2, &addr_len) == -1) {
218 memprintf(err, "cannot use file descriptor '%d' : %s.\n", fd, strerror(errno));
219 goto fail;
220 }
221
222 ss2->ss_family = AF_CUST_SOCKPAIR; /* reassign AF_CUST_SOCKPAIR because of getsockname */
223 port = end = 0;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100224 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200225
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100226 /* OK the address looks correct */
William Lallemand75ea0a02017-11-15 19:02:58 +0100227 if (!create_listeners(bind_conf, ss2, port, end, fd, inherited, err)) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200228 memprintf(err, "%s for address '%s'.\n", *err, str);
229 goto fail;
230 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200231 } /* end while(next) */
232 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200233 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200234 fail:
235 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200236 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200237}
238
William Lallemand6e62fb62015-04-28 16:55:23 +0200239/*
Willy Tarreauece9b072016-12-21 22:41:44 +0100240 * Report an error in <msg> when there are too many arguments. This version is
241 * intended to be used by keyword parsers so that the message will be included
242 * into the general error message. The index is the current keyword in args.
243 * Return 0 if the number of argument is correct, otherwise build a message and
244 * return 1. Fill err_code with an ERR_ALERT and an ERR_FATAL if not null. The
245 * message may also be null, it will simply not be produced (useful to check only).
246 * <msg> and <err_code> are only affected on error.
247 */
248int too_many_args_idx(int maxarg, int index, char **args, char **msg, int *err_code)
249{
250 int i;
251
252 if (!*args[index + maxarg + 1])
253 return 0;
254
255 if (msg) {
256 *msg = NULL;
257 memprintf(msg, "%s", args[0]);
258 for (i = 1; i <= index; i++)
259 memprintf(msg, "%s %s", *msg, args[i]);
260
261 memprintf(msg, "'%s' cannot handle unexpected argument '%s'.", *msg, args[index + maxarg + 1]);
262 }
263 if (err_code)
264 *err_code |= ERR_ALERT | ERR_FATAL;
265
266 return 1;
267}
268
269/*
270 * same as too_many_args_idx with a 0 index
271 */
272int too_many_args(int maxarg, char **args, char **msg, int *err_code)
273{
274 return too_many_args_idx(maxarg, 0, args, msg, err_code);
275}
276
277/*
William Lallemand6e62fb62015-04-28 16:55:23 +0200278 * Report a fatal Alert when there is too much arguments
279 * The index is the current keyword in args
280 * Return 0 if the number of argument is correct, otherwise emit an alert and return 1
281 * Fill err_code with an ERR_ALERT and an ERR_FATAL
282 */
283int alertif_too_many_args_idx(int maxarg, int index, const char *file, int linenum, char **args, int *err_code)
284{
285 char *kw = NULL;
286 int i;
287
288 if (!*args[index + maxarg + 1])
289 return 0;
290
291 memprintf(&kw, "%s", args[0]);
292 for (i = 1; i <= index; i++) {
293 memprintf(&kw, "%s %s", kw, args[i]);
294 }
295
Christopher Faulet767a84b2017-11-24 16:50:31 +0100296 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 +0200297 free(kw);
298 *err_code |= ERR_ALERT | ERR_FATAL;
299 return 1;
300}
301
302/*
303 * same as alertif_too_many_args_idx with a 0 index
304 */
305int alertif_too_many_args(int maxarg, const char *file, int linenum, char **args, int *err_code)
306{
307 return alertif_too_many_args_idx(maxarg, 0, file, linenum, args, err_code);
308}
309
Willy Tarreau61d18892009-03-31 10:49:21 +0200310
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100311/* Report it if a request ACL condition uses some keywords that are incompatible
312 * with the place where the ACL is used. It returns either 0 or ERR_WARN so that
313 * its result can be or'ed with err_code. Note that <cond> may be NULL and then
314 * will be ignored.
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100315 */
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100316int warnif_cond_conflicts(const struct acl_cond *cond, unsigned int where, const char *file, int line)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100317{
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100318 const struct acl *acl;
Willy Tarreau93fddf12013-03-31 22:59:32 +0200319 const char *kw;
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100320
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100321 if (!cond)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100322 return 0;
323
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100324 acl = acl_cond_conflicts(cond, where);
325 if (acl) {
326 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100327 ha_warning("parsing [%s:%d] : acl '%s' will never match because it only involves keywords that are incompatible with '%s'\n",
328 file, line, acl->name, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100329 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100330 ha_warning("parsing [%s:%d] : anonymous acl will never match because it uses keyword '%s' which is incompatible with '%s'\n",
331 file, line, LIST_ELEM(acl->expr.n, struct acl_expr *, list)->kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100332 return ERR_WARN;
333 }
334 if (!acl_cond_kw_conflicts(cond, where, &acl, &kw))
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100335 return 0;
336
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100337 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100338 ha_warning("parsing [%s:%d] : acl '%s' involves keywords '%s' which is incompatible with '%s'\n",
339 file, line, acl->name, kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100340 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100341 ha_warning("parsing [%s:%d] : anonymous acl involves keyword '%s' which is incompatible with '%s'\n",
342 file, line, kw, sample_ckp_names(where));
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100343 return ERR_WARN;
344}
345
Christopher Faulet62519022017-10-16 15:49:32 +0200346/* Parse a string representing a process number or a set of processes. It must
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100347 * be "all", "odd", "even", a number between 1 and <max> or a range with
Christopher Faulet5ab51772017-11-22 11:21:58 +0100348 * two such numbers delimited by a dash ('-'). On success, it returns
349 * 0. otherwise it returns 1 with an error message in <err>.
Christopher Faulet62519022017-10-16 15:49:32 +0200350 *
351 * Note: this function can also be used to parse a thread number or a set of
352 * threads.
353 */
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100354int parse_process_number(const char *arg, unsigned long *proc, int max, int *autoinc, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200355{
Christopher Faulet26028f62017-11-22 15:01:51 +0100356 if (autoinc) {
357 *autoinc = 0;
358 if (strncmp(arg, "auto:", 5) == 0) {
359 arg += 5;
360 *autoinc = 1;
361 }
362 }
363
Christopher Faulet62519022017-10-16 15:49:32 +0200364 if (strcmp(arg, "all") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100365 *proc |= ~0UL;
Christopher Faulet62519022017-10-16 15:49:32 +0200366 else if (strcmp(arg, "odd") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100367 *proc |= ~0UL/3UL; /* 0x555....555 */
Christopher Faulet62519022017-10-16 15:49:32 +0200368 else if (strcmp(arg, "even") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100369 *proc |= (~0UL/3UL) << 1; /* 0xAAA...AAA */
Christopher Faulet62519022017-10-16 15:49:32 +0200370 else {
Christopher Faulet18cca782019-02-07 16:29:41 +0100371 const char *p, *dash = NULL;
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100372 unsigned int low, high;
373
Christopher Faulet18cca782019-02-07 16:29:41 +0100374 for (p = arg; *p; p++) {
375 if (*p == '-' && !dash)
376 dash = p;
Willy Tarreau90807112020-02-25 08:16:33 +0100377 else if (!isdigit((unsigned char)*p)) {
Christopher Faulet18cca782019-02-07 16:29:41 +0100378 memprintf(err, "'%s' is not a valid number/range.", arg);
379 return -1;
380 }
Christopher Faulet5ab51772017-11-22 11:21:58 +0100381 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100382
383 low = high = str2uic(arg);
Christopher Faulet18cca782019-02-07 16:29:41 +0100384 if (dash)
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100385 high = ((!*(dash+1)) ? max : str2uic(dash + 1));
Christopher Fauletff4121f2017-11-22 16:38:49 +0100386
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100387 if (high < low) {
388 unsigned int swap = low;
389 low = high;
390 high = swap;
391 }
392
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100393 if (low < 1 || low > max || high > max) {
Christopher Fauletcb6a9452017-11-22 16:50:41 +0100394 memprintf(err, "'%s' is not a valid number/range."
395 " It supports numbers from 1 to %d.\n",
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100396 arg, max);
Christopher Faulet5ab51772017-11-22 11:21:58 +0100397 return 1;
398 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100399
400 for (;low <= high; low++)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100401 *proc |= 1UL << (low-1);
Christopher Faulet62519022017-10-16 15:49:32 +0200402 }
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100403 *proc &= ~0UL >> (LONGBITS - max);
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100404
Christopher Faulet5ab51772017-11-22 11:21:58 +0100405 return 0;
Christopher Faulet62519022017-10-16 15:49:32 +0200406}
407
David Carlier7e351ee2017-12-01 09:14:02 +0000408#ifdef USE_CPU_AFFINITY
Christopher Faulet62519022017-10-16 15:49:32 +0200409/* Parse cpu sets. Each CPU set is either a unique number between 0 and
410 * <LONGBITS> or a range with two such numbers delimited by a dash
411 * ('-'). Multiple CPU numbers or ranges may be specified. On success, it
412 * returns 0. otherwise it returns 1 with an error message in <err>.
413 */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100414unsigned long parse_cpu_set(const char **args, unsigned long *cpu_set, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200415{
416 int cur_arg = 0;
417
418 *cpu_set = 0;
419 while (*args[cur_arg]) {
420 char *dash;
421 unsigned int low, high;
422
Willy Tarreau90807112020-02-25 08:16:33 +0100423 if (!isdigit((unsigned char)*args[cur_arg])) {
Christopher Faulet62519022017-10-16 15:49:32 +0200424 memprintf(err, "'%s' is not a CPU range.\n", args[cur_arg]);
425 return -1;
426 }
427
428 low = high = str2uic(args[cur_arg]);
429 if ((dash = strchr(args[cur_arg], '-')) != NULL)
Christopher Fauletff4121f2017-11-22 16:38:49 +0100430 high = ((!*(dash+1)) ? LONGBITS-1 : str2uic(dash + 1));
Christopher Faulet62519022017-10-16 15:49:32 +0200431
432 if (high < low) {
433 unsigned int swap = low;
434 low = high;
435 high = swap;
436 }
437
438 if (high >= LONGBITS) {
439 memprintf(err, "supports CPU numbers from 0 to %d.\n", LONGBITS - 1);
440 return 1;
441 }
442
443 while (low <= high)
444 *cpu_set |= 1UL << low++;
445
446 cur_arg++;
447 }
448 return 0;
449}
David Carlier7e351ee2017-12-01 09:14:02 +0000450#endif
451
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200452void init_default_instance()
Willy Tarreaubaaee002006-06-26 02:48:02 +0200453{
Willy Tarreau97cb7802010-01-03 20:23:58 +0100454 init_new_proxy(&defproxy);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200455 defproxy.mode = PR_MODE_TCP;
456 defproxy.state = PR_STNEW;
457 defproxy.maxconn = cfg_maxpconn;
458 defproxy.conn_retries = CONN_RETRIES;
Joseph Lynch726ab712015-05-11 23:25:34 -0700459 defproxy.redispatch_after = 0;
Olivier Houchard86006a52018-12-14 19:37:49 +0100460 defproxy.options = PR_O_REUSE_SAFE;
Olivier Houcharda4d4fdf2018-12-14 19:27:06 +0100461 defproxy.max_out_conns = MAX_SRV_LIST;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100462
Simon Horman66183002013-02-23 10:16:43 +0900463 defproxy.defsrv.check.inter = DEF_CHKINTR;
464 defproxy.defsrv.check.fastinter = 0;
465 defproxy.defsrv.check.downinter = 0;
Simon Hormand60d6912013-11-25 10:46:36 +0900466 defproxy.defsrv.agent.inter = DEF_CHKINTR;
467 defproxy.defsrv.agent.fastinter = 0;
468 defproxy.defsrv.agent.downinter = 0;
Simon Horman58c32972013-11-25 10:46:38 +0900469 defproxy.defsrv.check.rise = DEF_RISETIME;
470 defproxy.defsrv.check.fall = DEF_FALLTIME;
471 defproxy.defsrv.agent.rise = DEF_AGENT_RISETIME;
472 defproxy.defsrv.agent.fall = DEF_AGENT_FALLTIME;
Willy Tarreau5b3a2022012-09-28 15:01:02 +0200473 defproxy.defsrv.check.port = 0;
Simon Hormand60d6912013-11-25 10:46:36 +0900474 defproxy.defsrv.agent.port = 0;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100475 defproxy.defsrv.maxqueue = 0;
476 defproxy.defsrv.minconn = 0;
477 defproxy.defsrv.maxconn = 0;
Willy Tarreau9c538e02019-01-23 10:21:49 +0100478 defproxy.defsrv.max_reuse = -1;
Olivier Houchard006e3102018-12-10 18:30:32 +0100479 defproxy.defsrv.max_idle_conns = -1;
Willy Tarreau975b1552019-06-06 16:25:55 +0200480 defproxy.defsrv.pool_purge_delay = 5000;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100481 defproxy.defsrv.slowstart = 0;
482 defproxy.defsrv.onerror = DEF_HANA_ONERR;
483 defproxy.defsrv.consecutive_errors_limit = DEF_HANA_ERRLIMIT;
484 defproxy.defsrv.uweight = defproxy.defsrv.iweight = 1;
Simon Horman64e34162015-02-06 11:11:57 +0900485
486 defproxy.email_alert.level = LOG_ALERT;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +0200487 defproxy.load_server_state_from_file = PR_SRV_STATE_FILE_UNSPEC;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200488}
489
Frédéric Lécaille18251032019-01-11 11:07:15 +0100490/* Allocate and initialize the frontend of a "peers" section found in
491 * file <file> at line <linenum> with <id> as ID.
492 * Return 0 if succeeded, -1 if not.
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200493 * Note that this function may be called from "default-server"
494 * or "peer" lines.
Frédéric Lécaille18251032019-01-11 11:07:15 +0100495 */
496static int init_peers_frontend(const char *file, int linenum,
497 const char *id, struct peers *peers)
498{
499 struct proxy *p;
500
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200501 if (peers->peers_fe) {
502 p = peers->peers_fe;
503 goto out;
504 }
Frédéric Lécaille9492c4e2019-01-11 11:47:12 +0100505
Frédéric Lécaille18251032019-01-11 11:07:15 +0100506 p = calloc(1, sizeof *p);
507 if (!p) {
508 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
509 return -1;
510 }
511
512 init_new_proxy(p);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200513 peers_setup_frontend(p);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100514 p->parent = peers;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200515 /* Finally store this frontend. */
516 peers->peers_fe = p;
517
518 out:
519 if (id && !p->id)
520 p->id = strdup(id);
Frédéric Lécaille1055e682018-04-26 14:35:21 +0200521 free(p->conf.file);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100522 p->conf.args.file = p->conf.file = strdup(file);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100523 if (linenum != -1)
524 p->conf.args.line = p->conf.line = linenum;
Frédéric Lécaille18251032019-01-11 11:07:15 +0100525
526 return 0;
527}
Willy Tarreauade5ec42010-01-28 19:33:49 +0100528
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100529/* Only change ->file, ->line and ->arg struct bind_conf member values
530 * if already present.
531 */
532static struct bind_conf *bind_conf_uniq_alloc(struct proxy *p,
533 const char *file, int line,
534 const char *arg, struct xprt_ops *xprt)
535{
536 struct bind_conf *bind_conf;
537
538 if (!LIST_ISEMPTY(&p->conf.bind)) {
539 bind_conf = LIST_ELEM((&p->conf.bind)->n, typeof(bind_conf), by_fe);
540 free(bind_conf->file);
541 bind_conf->file = strdup(file);
542 bind_conf->line = line;
543 if (arg) {
544 free(bind_conf->arg);
545 bind_conf->arg = strdup(arg);
546 }
547 }
548 else {
549 bind_conf = bind_conf_alloc(p, file, line, arg, xprt);
550 }
551
552 return bind_conf;
553}
554
555/*
556 * Allocate a new struct peer parsed at line <linenum> in file <file>
557 * to be added to <peers>.
558 * Returns the new allocated structure if succeeded, NULL if not.
559 */
560static struct peer *cfg_peers_add_peer(struct peers *peers,
561 const char *file, int linenum,
562 const char *id, int local)
563{
564 struct peer *p;
565
566 p = calloc(1, sizeof *p);
567 if (!p) {
568 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
569 return NULL;
570 }
571
572 /* the peers are linked backwards first */
573 peers->count++;
574 p->next = peers->remote;
575 peers->remote = p;
576 p->conf.file = strdup(file);
577 p->conf.line = linenum;
578 p->last_change = now.tv_sec;
579 p->xprt = xprt_get(XPRT_RAW);
580 p->sock_init_arg = NULL;
581 HA_SPIN_INIT(&p->lock);
582 if (id)
583 p->id = strdup(id);
584 if (local) {
585 p->local = 1;
586 peers->local = p;
587 }
588
589 return p;
590}
591
Willy Tarreaubaaee002006-06-26 02:48:02 +0200592/*
William Lallemand51097192015-04-14 16:35:22 +0200593 * Parse a line in a <listen>, <frontend> or <backend> section.
Willy Tarreau93893792009-07-23 13:19:11 +0200594 * Returns the error code, 0 if OK, or any combination of :
595 * - ERR_ABORT: must abort ASAP
596 * - ERR_FATAL: we can continue parsing but not start the service
597 * - ERR_WARN: a warning has been emitted
598 * - ERR_ALERT: an alert has been emitted
599 * Only the two first ones can stop processing, the two others are just
600 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200601 */
Emeric Brun32da3c42010-09-23 18:39:19 +0200602int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
603{
604 static struct peers *curpeers = NULL;
605 struct peer *newpeer = NULL;
606 const char *err;
Willy Tarreau4348fad2012-09-20 16:48:07 +0200607 struct bind_conf *bind_conf;
608 struct listener *l;
Emeric Brun32da3c42010-09-23 18:39:19 +0200609 int err_code = 0;
Willy Tarreau902636f2013-03-10 19:44:48 +0100610 char *errmsg = NULL;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100611 static int bind_line, peer_line;
612
613 if (strcmp(args[0], "bind") == 0 || strcmp(args[0], "default-bind") == 0) {
614 int cur_arg;
615 static int kws_dumped;
616 struct bind_conf *bind_conf;
617 struct bind_kw *kw;
Emeric Brun32da3c42010-09-23 18:39:19 +0200618
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100619 cur_arg = 1;
620
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200621 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
622 err_code |= ERR_ALERT | ERR_ABORT;
623 goto out;
624 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100625
626 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum,
627 NULL, xprt_get(XPRT_RAW));
628 if (*args[0] == 'b') {
629 struct listener *l;
630
631 if (peer_line) {
632 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
633 err_code |= ERR_ALERT | ERR_FATAL;
634 goto out;
635 }
636
637 if (!str2listener(args[1], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
638 if (errmsg && *errmsg) {
639 indent_msg(&errmsg, 2);
640 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
641 }
642 else
643 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
644 file, linenum, args[0], args[1], args[2]);
645 err_code |= ERR_FATAL;
646 goto out;
647 }
648 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
649 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100650 l->accept = session_accept_fd;
651 l->analysers |= curpeers->peers_fe->fe_req_ana;
652 l->default_target = curpeers->peers_fe->default_target;
653 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100654 global.maxsock++; /* for the listening socket */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100655
656 bind_line = 1;
657 if (cfg_peers->local) {
658 newpeer = cfg_peers->local;
659 }
660 else {
661 /* This peer is local.
662 * Note that we do not set the peer ID. This latter is initialized
663 * when parsing "peer" or "server" line.
664 */
665 newpeer = cfg_peers_add_peer(curpeers, file, linenum, NULL, 1);
666 if (!newpeer) {
667 err_code |= ERR_ALERT | ERR_ABORT;
668 goto out;
669 }
670 }
671 newpeer->addr = l->addr;
672 newpeer->proto = protocol_by_family(newpeer->addr.ss_family);
673 cur_arg++;
674 }
675
676 while (*args[cur_arg] && (kw = bind_find_kw(args[cur_arg]))) {
677 int ret;
678
679 ret = kw->parse(args, cur_arg, curpeers->peers_fe, bind_conf, &errmsg);
680 err_code |= ret;
681 if (ret) {
682 if (errmsg && *errmsg) {
683 indent_msg(&errmsg, 2);
684 ha_alert("parsing [%s:%d] : %s\n", file, linenum, errmsg);
685 }
686 else
687 ha_alert("parsing [%s:%d]: error encountered while processing '%s'\n",
688 file, linenum, args[cur_arg]);
689 if (ret & ERR_FATAL)
690 goto out;
691 }
692 cur_arg += 1 + kw->skip;
693 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100694 if (*args[cur_arg] != 0) {
Tim Duesterhus04bcaa12019-05-12 22:54:50 +0200695 char *kws = NULL;
696
697 if (!kws_dumped) {
698 kws_dumped = 1;
699 bind_dump_kws(&kws);
700 indent_msg(&kws, 4);
701 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100702 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section.%s%s\n",
703 file, linenum, args[cur_arg], cursection,
704 kws ? " Registered keywords :" : "", kws ? kws: "");
705 free(kws);
706 err_code |= ERR_ALERT | ERR_FATAL;
707 goto out;
708 }
709 }
710 else if (strcmp(args[0], "default-server") == 0) {
711 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
712 err_code |= ERR_ALERT | ERR_ABORT;
713 goto out;
714 }
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200715 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL, 0, 1);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200716 }
Frédéric Lécailleb6f759b2019-11-05 09:57:45 +0100717 else if (strcmp(args[0], "log") == 0) {
718 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
719 err_code |= ERR_ALERT | ERR_ABORT;
720 goto out;
721 }
722 if (!parse_logsrv(args, &curpeers->peers_fe->logsrvs, (kwm == KWM_NO), &errmsg)) {
723 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
724 err_code |= ERR_ALERT | ERR_FATAL;
725 goto out;
726 }
727 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200728 else if (strcmp(args[0], "peers") == 0) { /* new peers section */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100729 /* Initialize these static variables when entering a new "peers" section*/
730 bind_line = peer_line = 0;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100731 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100732 ha_alert("parsing [%s:%d] : missing name for peers section.\n", file, linenum);
Willy Tarreau54984722014-02-16 08:20:13 +0100733 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100734 goto out;
735 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200736
William Lallemand6e62fb62015-04-28 16:55:23 +0200737 if (alertif_too_many_args(1, file, linenum, args, &err_code))
738 goto out;
739
Emeric Brun32da3c42010-09-23 18:39:19 +0200740 err = invalid_char(args[1]);
741 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100742 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
743 file, linenum, *err, args[0], args[1]);
Willy Tarreau54984722014-02-16 08:20:13 +0100744 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100745 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200746 }
747
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200748 for (curpeers = cfg_peers; curpeers != NULL; curpeers = curpeers->next) {
Emeric Brun32da3c42010-09-23 18:39:19 +0200749 /*
750 * If there are two proxies with the same name only following
751 * combinations are allowed:
752 */
753 if (strcmp(curpeers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100754 ha_alert("Parsing [%s:%d]: peers section '%s' has the same name as another peers section declared at %s:%d.\n",
755 file, linenum, args[1], curpeers->conf.file, curpeers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +0200756 err_code |= ERR_ALERT | ERR_FATAL;
Emeric Brun32da3c42010-09-23 18:39:19 +0200757 }
758 }
759
Vincent Bernat02779b62016-04-03 13:48:43 +0200760 if ((curpeers = calloc(1, sizeof(*curpeers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100761 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Emeric Brun32da3c42010-09-23 18:39:19 +0200762 err_code |= ERR_ALERT | ERR_ABORT;
763 goto out;
764 }
765
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200766 curpeers->next = cfg_peers;
767 cfg_peers = curpeers;
Willy Tarreau8113a5d2012-10-04 08:01:43 +0200768 curpeers->conf.file = strdup(file);
Emeric Brun32da3c42010-09-23 18:39:19 +0200769 curpeers->conf.line = linenum;
770 curpeers->last_change = now.tv_sec;
771 curpeers->id = strdup(args[1]);
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200772 curpeers->state = PR_STNEW;
Emeric Brun32da3c42010-09-23 18:39:19 +0200773 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200774 else if (strcmp(args[0], "peer") == 0 ||
775 strcmp(args[0], "server") == 0) { /* peer or server definition */
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100776 int local_peer, peer;
Emeric Brun32da3c42010-09-23 18:39:19 +0200777
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100778 peer = *args[0] == 'p';
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100779 local_peer = !strcmp(args[1], localpeer);
780 /* The local peer may have already partially been parsed on a "bind" line. */
781 if (*args[0] == 'p') {
782 if (bind_line) {
783 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
784 err_code |= ERR_ALERT | ERR_FATAL;
785 goto out;
786 }
787 peer_line = 1;
788 }
789 if (cfg_peers->local && !cfg_peers->local->id && local_peer) {
790 /* The local peer has already been initialized on a "bind" line.
791 * Let's use it and store its ID.
792 */
793 newpeer = cfg_peers->local;
794 newpeer->id = strdup(localpeer);
795 }
796 else {
797 if (local_peer && cfg_peers->local) {
798 ha_alert("parsing [%s:%d] : '%s %s' : local peer name already referenced at %s:%d. %s\n",
799 file, linenum, args[0], args[1],
800 curpeers->peers_fe->conf.file, curpeers->peers_fe->conf.line, cfg_peers->local->id);
801 err_code |= ERR_FATAL;
802 goto out;
803 }
804 newpeer = cfg_peers_add_peer(curpeers, file, linenum, args[1], local_peer);
805 if (!newpeer) {
806 err_code |= ERR_ALERT | ERR_ABORT;
807 goto out;
808 }
809 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200810
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100811 /* Line number and peer ID are updated only if this peer is the local one. */
812 if (init_peers_frontend(file,
813 newpeer->local ? linenum: -1,
814 newpeer->local ? newpeer->id : NULL,
815 curpeers) != 0) {
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200816 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreaub36487e2013-03-10 18:37:42 +0100817 goto out;
818 }
Willy Tarreau2aa38802013-02-20 19:20:59 +0100819
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100820 /* This initializes curpeer->peers->peers_fe->srv.
821 * The server address is parsed only if we are parsing a "peer" line,
822 * or if we are parsing a "server" line and the current peer is not the local one.
823 */
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200824 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL, peer || !local_peer, 1);
825 if (!curpeers->peers_fe->srv) {
826 /* Remove the newly allocated peer. */
827 if (newpeer != curpeers->local) {
828 struct peer *p;
829
830 p = curpeers->remote;
831 curpeers->remote = curpeers->remote->next;
832 free(p->id);
833 free(p);
834 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200835 goto out;
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200836 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200837
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100838 /* If the peer address has just been parsed, let's copy it to <newpeer>
839 * and initializes ->proto.
840 */
841 if (peer || !local_peer) {
842 newpeer->addr = curpeers->peers_fe->srv->addr;
843 newpeer->proto = protocol_by_family(newpeer->addr.ss_family);
844 }
845
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100846 newpeer->xprt = xprt_get(XPRT_RAW);
Willy Tarreaud02394b2012-05-11 18:32:18 +0200847 newpeer->sock_init_arg = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100848 HA_SPIN_INIT(&newpeer->lock);
Willy Tarreau26d8c592012-05-07 18:12:14 +0200849
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100850 newpeer->srv = curpeers->peers_fe->srv;
851 if (!newpeer->local)
Frédéric Lécaille6617e762018-04-25 15:13:38 +0200852 goto out;
853
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100854 /* The lines above are reserved to "peer" lines. */
855 if (*args[0] == 's')
Frédéric Lécaille4ba51982018-04-25 15:32:18 +0200856 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200857
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100858 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 +0100859
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100860 if (!str2listener(args[2], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
861 if (errmsg && *errmsg) {
862 indent_msg(&errmsg, 2);
863 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 +0100864 }
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100865 else
866 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
867 file, linenum, args[0], args[1], args[2]);
868 err_code |= ERR_FATAL;
869 goto out;
870 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100871
872 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
873 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100874 l->accept = session_accept_fd;
875 l->analysers |= curpeers->peers_fe->fe_req_ana;
876 l->default_target = curpeers->peers_fe->default_target;
877 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100878 global.maxsock++; /* for the listening socket */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100879 }
880 else if (!strcmp(args[0], "table")) {
881 struct stktable *t, *other;
882 char *id;
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100883 size_t prefix_len;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100884
885 /* Line number and peer ID are updated only if this peer is the local one. */
886 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
887 err_code |= ERR_ALERT | ERR_ABORT;
888 goto out;
889 }
890
891 other = stktable_find_by_name(args[1]);
892 if (other) {
893 ha_alert("parsing [%s:%d] : stick-table name '%s' conflicts with table declared in %s '%s' at %s:%d.\n",
894 file, linenum, args[1],
895 other->proxy ? proxy_cap_str(other->proxy->cap) : "peers",
896 other->proxy ? other->id : other->peers.p->id,
897 other->conf.file, other->conf.line);
898 err_code |= ERR_ALERT | ERR_FATAL;
899 goto out;
900 }
901
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100902 /* Build the stick-table name, concatenating the "peers" section name
903 * followed by a '/' character and the table name argument.
904 */
905 chunk_reset(&trash);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100906 if (!chunk_strcpy(&trash, curpeers->id)) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100907 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
908 file, linenum, args[0], args[1]);
909 err_code |= ERR_ALERT | ERR_FATAL;
910 goto out;
911 }
912
913 prefix_len = trash.data;
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100914 if (!chunk_memcat(&trash, "/", 1) || !chunk_strcat(&trash, args[1])) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100915 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
916 file, linenum, args[0], args[1]);
917 err_code |= ERR_ALERT | ERR_FATAL;
918 goto out;
919 }
920
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100921 t = calloc(1, sizeof *t);
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100922 id = strdup(trash.area);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100923 if (!t || !id) {
924 ha_alert("parsing [%s:%d]: '%s %s' : memory allocation failed\n",
925 file, linenum, args[0], args[1]);
926 err_code |= ERR_ALERT | ERR_FATAL;
927 goto out;
928 }
929
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100930 err_code |= parse_stick_table(file, linenum, args, t, id, id + prefix_len, curpeers);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100931 if (err_code & ERR_FATAL)
932 goto out;
933
934 stktable_store_name(t);
935 t->next = stktables_list;
936 stktables_list = t;
937 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200938 else if (!strcmp(args[0], "disabled")) { /* disables this peers section */
939 curpeers->state = PR_STSTOPPED;
940 }
941 else if (!strcmp(args[0], "enabled")) { /* enables this peers section (used to revert a disabled default) */
942 curpeers->state = PR_STNEW;
943 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200944 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100945 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Emeric Brun32da3c42010-09-23 18:39:19 +0200946 err_code |= ERR_ALERT | ERR_FATAL;
947 goto out;
948 }
949
950out:
Willy Tarreau902636f2013-03-10 19:44:48 +0100951 free(errmsg);
Emeric Brun32da3c42010-09-23 18:39:19 +0200952 return err_code;
953}
954
Baptiste Assmann325137d2015-04-13 23:40:55 +0200955/*
956 * Parse a <resolvers> section.
957 * Returns the error code, 0 if OK, or any combination of :
958 * - ERR_ABORT: must abort ASAP
959 * - ERR_FATAL: we can continue parsing but not start the service
960 * - ERR_WARN: a warning has been emitted
961 * - ERR_ALERT: an alert has been emitted
962 * Only the two first ones can stop processing, the two others are just
963 * indicators.
964 */
965int cfg_parse_resolvers(const char *file, int linenum, char **args, int kwm)
966{
967 static struct dns_resolvers *curr_resolvers = NULL;
968 struct dns_nameserver *newnameserver = NULL;
969 const char *err;
970 int err_code = 0;
971 char *errmsg = NULL;
972
973 if (strcmp(args[0], "resolvers") == 0) { /* new resolvers section */
974 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100975 ha_alert("parsing [%s:%d] : missing name for resolvers section.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200976 err_code |= ERR_ALERT | ERR_ABORT;
977 goto out;
978 }
979
980 err = invalid_char(args[1]);
981 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100982 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
983 file, linenum, *err, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200984 err_code |= ERR_ALERT | ERR_ABORT;
985 goto out;
986 }
987
988 list_for_each_entry(curr_resolvers, &dns_resolvers, list) {
989 /* Error if two resolvers owns the same name */
990 if (strcmp(curr_resolvers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100991 ha_alert("Parsing [%s:%d]: resolvers '%s' has same name as another resolvers (declared at %s:%d).\n",
992 file, linenum, args[1], curr_resolvers->conf.file, curr_resolvers->conf.line);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200993 err_code |= ERR_ALERT | ERR_ABORT;
994 }
995 }
996
Vincent Bernat02779b62016-04-03 13:48:43 +0200997 if ((curr_resolvers = calloc(1, sizeof(*curr_resolvers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100998 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200999 err_code |= ERR_ALERT | ERR_ABORT;
1000 goto out;
1001 }
1002
1003 /* default values */
1004 LIST_ADDQ(&dns_resolvers, &curr_resolvers->list);
1005 curr_resolvers->conf.file = strdup(file);
1006 curr_resolvers->conf.line = linenum;
1007 curr_resolvers->id = strdup(args[1]);
1008 curr_resolvers->query_ids = EB_ROOT;
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001009 /* default maximum response size */
1010 curr_resolvers->accepted_payload_size = 512;
Baptiste Assmann987e16d2016-11-02 22:23:31 +01001011 /* default hold period for nx, other, refuse and timeout is 30s */
1012 curr_resolvers->hold.nx = 30000;
1013 curr_resolvers->hold.other = 30000;
1014 curr_resolvers->hold.refused = 30000;
1015 curr_resolvers->hold.timeout = 30000;
Baptiste Assmann686408b2017-08-18 10:15:42 +02001016 curr_resolvers->hold.obsolete = 0;
Baptiste Assmann325137d2015-04-13 23:40:55 +02001017 /* default hold period for valid is 10s */
Baptiste Assmann4c5490a2015-07-14 21:42:49 +02001018 curr_resolvers->hold.valid = 10000;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001019 curr_resolvers->timeout.resolve = 1000;
1020 curr_resolvers->timeout.retry = 1000;
Baptiste Assmann325137d2015-04-13 23:40:55 +02001021 curr_resolvers->resolve_retries = 3;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001022 curr_resolvers->nb_nameservers = 0;
1023 LIST_INIT(&curr_resolvers->nameservers);
1024 LIST_INIT(&curr_resolvers->resolutions.curr);
1025 LIST_INIT(&curr_resolvers->resolutions.wait);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001026 HA_SPIN_INIT(&curr_resolvers->lock);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001027 }
1028 else if (strcmp(args[0], "nameserver") == 0) { /* nameserver definition */
1029 struct sockaddr_storage *sk;
1030 int port1, port2;
1031 struct protocol *proto;
1032
1033 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001034 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1035 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001036 err_code |= ERR_ALERT | ERR_FATAL;
1037 goto out;
1038 }
1039
1040 err = invalid_char(args[1]);
1041 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001042 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1043 file, linenum, *err, args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001044 err_code |= ERR_ALERT | ERR_FATAL;
1045 goto out;
1046 }
1047
Christopher Faulet67957bd2017-09-27 11:00:59 +02001048 list_for_each_entry(newnameserver, &curr_resolvers->nameservers, list) {
Baptiste Assmanna315c552015-11-02 22:55:49 +01001049 /* Error if two resolvers owns the same name */
1050 if (strcmp(newnameserver->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001051 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 -06001052 file, linenum, args[1], newnameserver->conf.file, newnameserver->conf.line);
Baptiste Assmanna315c552015-11-02 22:55:49 +01001053 err_code |= ERR_ALERT | ERR_FATAL;
1054 }
1055 }
1056
Vincent Bernat02779b62016-04-03 13:48:43 +02001057 if ((newnameserver = calloc(1, sizeof(*newnameserver))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001058 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001059 err_code |= ERR_ALERT | ERR_ABORT;
1060 goto out;
1061 }
1062
1063 /* the nameservers are linked backward first */
Christopher Faulet67957bd2017-09-27 11:00:59 +02001064 LIST_ADDQ(&curr_resolvers->nameservers, &newnameserver->list);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001065 newnameserver->resolvers = curr_resolvers;
1066 newnameserver->conf.file = strdup(file);
1067 newnameserver->conf.line = linenum;
1068 newnameserver->id = strdup(args[1]);
1069
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001070 sk = str2sa_range(args[2], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001071 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001072 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001073 err_code |= ERR_ALERT | ERR_FATAL;
1074 goto out;
1075 }
1076
1077 proto = protocol_by_family(sk->ss_family);
1078 if (!proto || !proto->connect) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001079 ha_alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
Baptiste Assmann325137d2015-04-13 23:40:55 +02001080 file, linenum, args[0], args[1]);
1081 err_code |= ERR_ALERT | ERR_FATAL;
1082 goto out;
1083 }
1084
1085 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001086 ha_alert("parsing [%s:%d] : '%s %s' : port ranges and offsets are not allowed in '%s'\n",
1087 file, linenum, args[0], args[1], args[2]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001088 err_code |= ERR_ALERT | ERR_FATAL;
1089 goto out;
1090 }
1091
Baptiste Assmann7f43fa92016-01-21 00:59:46 +01001092 if (!port1 && !port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001093 ha_alert("parsing [%s:%d] : '%s %s' : no UDP port specified\n",
1094 file, linenum, args[0], args[1]);
Baptiste Assmann7f43fa92016-01-21 00:59:46 +01001095 err_code |= ERR_ALERT | ERR_FATAL;
1096 goto out;
1097 }
1098
Baptiste Assmann325137d2015-04-13 23:40:55 +02001099 newnameserver->addr = *sk;
1100 }
Ben Draut44e609b2018-05-29 15:40:08 -06001101 else if (strcmp(args[0], "parse-resolv-conf") == 0) {
1102 const char *whitespace = "\r\n\t ";
1103 char *resolv_line = NULL;
1104 int resolv_linenum = 0;
1105 FILE *f = NULL;
1106 char *address = NULL;
1107 struct sockaddr_storage *sk = NULL;
1108 struct protocol *proto;
1109 int duplicate_name = 0;
1110
1111 if ((resolv_line = malloc(sizeof(*resolv_line) * LINESIZE)) == NULL) {
1112 ha_alert("parsing [%s:%d] : out of memory.\n",
1113 file, linenum);
1114 err_code |= ERR_ALERT | ERR_FATAL;
1115 goto resolv_out;
1116 }
1117
1118 if ((f = fopen("/etc/resolv.conf", "r")) == NULL) {
1119 ha_alert("parsing [%s:%d] : failed to open /etc/resolv.conf.\n",
1120 file, linenum);
1121 err_code |= ERR_ALERT | ERR_FATAL;
1122 goto resolv_out;
1123 }
1124
1125 sk = calloc(1, sizeof(*sk));
1126 if (sk == NULL) {
1127 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n",
1128 resolv_linenum);
1129 err_code |= ERR_ALERT | ERR_FATAL;
1130 goto resolv_out;
1131 }
1132
1133 while (fgets(resolv_line, LINESIZE, f) != NULL) {
1134 resolv_linenum++;
1135 if (strncmp(resolv_line, "nameserver", 10) != 0)
1136 continue;
1137
1138 address = strtok(resolv_line + 10, whitespace);
1139 if (address == resolv_line + 10)
1140 continue;
1141
1142 if (address == NULL) {
1143 ha_warning("parsing [/etc/resolv.conf:%d] : nameserver line is missing address.\n",
1144 resolv_linenum);
1145 err_code |= ERR_WARN;
1146 continue;
1147 }
1148
1149 duplicate_name = 0;
1150 list_for_each_entry(newnameserver, &curr_resolvers->nameservers, list) {
1151 if (strcmp(newnameserver->id, address) == 0) {
1152 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",
1153 resolv_linenum, address, newnameserver->conf.file, newnameserver->conf.line);
1154 err_code |= ERR_WARN;
1155 duplicate_name = 1;
1156 }
1157 }
1158
1159 if (duplicate_name)
1160 continue;
1161
1162 memset(sk, 0, sizeof(*sk));
1163 sk = str2ip2(address, sk, 1);
1164 if (!sk) {
1165 ha_warning("parsing [/etc/resolv.conf:%d] : address '%s' could not be recognized, namerserver will be excluded.\n",
1166 resolv_linenum, address);
1167 err_code |= ERR_WARN;
1168 continue;
1169 }
1170
1171 set_host_port(sk, 53);
1172
1173 proto = protocol_by_family(sk->ss_family);
1174 if (!proto || !proto->connect) {
1175 ha_warning("parsing [/etc/resolv.conf:%d] : '%s' : connect() not supported for this address family.\n",
1176 resolv_linenum, address);
1177 err_code |= ERR_WARN;
1178 continue;
1179 }
1180
1181 if ((newnameserver = calloc(1, sizeof(*newnameserver))) == NULL) {
1182 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1183 err_code |= ERR_ALERT | ERR_FATAL;
1184 goto resolv_out;
1185 }
1186
1187 newnameserver->conf.file = strdup("/etc/resolv.conf");
1188 if (newnameserver->conf.file == NULL) {
1189 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1190 err_code |= ERR_ALERT | ERR_FATAL;
1191 goto resolv_out;
1192 }
1193
1194 newnameserver->id = strdup(address);
1195 if (newnameserver->id == NULL) {
1196 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1197 err_code |= ERR_ALERT | ERR_FATAL;
1198 goto resolv_out;
1199 }
1200
1201 newnameserver->resolvers = curr_resolvers;
1202 newnameserver->conf.line = resolv_linenum;
1203 newnameserver->addr = *sk;
1204
1205 LIST_ADDQ(&curr_resolvers->nameservers, &newnameserver->list);
1206 }
1207
1208resolv_out:
1209 free(sk);
1210 free(resolv_line);
1211 if (f != NULL)
1212 fclose(f);
1213 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001214 else if (strcmp(args[0], "hold") == 0) { /* hold periods */
1215 const char *res;
1216 unsigned int time;
1217
1218 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001219 ha_alert("parsing [%s:%d] : '%s' expects an <event> and a <time> as arguments.\n",
1220 file, linenum, args[0]);
1221 ha_alert("<event> can be either 'valid', 'nx', 'refused', 'timeout', or 'other'\n");
Baptiste Assmann325137d2015-04-13 23:40:55 +02001222 err_code |= ERR_ALERT | ERR_FATAL;
1223 goto out;
1224 }
1225 res = parse_time_err(args[2], &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001226 if (res == PARSE_TIME_OVER) {
1227 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s>, maximum value is 2147483647 ms (~24.8 days).\n",
1228 file, linenum, args[1], args[0]);
1229 err_code |= ERR_ALERT | ERR_FATAL;
1230 goto out;
1231 }
1232 else if (res == PARSE_TIME_UNDER) {
1233 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s>, minimum non-null value is 1 ms.\n",
1234 file, linenum, args[1], args[0]);
1235 err_code |= ERR_ALERT | ERR_FATAL;
1236 goto out;
1237 }
1238 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001239 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s>.\n",
1240 file, linenum, *res, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001241 err_code |= ERR_ALERT | ERR_FATAL;
1242 goto out;
1243 }
Baptiste Assmann987e16d2016-11-02 22:23:31 +01001244 if (strcmp(args[1], "nx") == 0)
1245 curr_resolvers->hold.nx = time;
1246 else if (strcmp(args[1], "other") == 0)
1247 curr_resolvers->hold.other = time;
1248 else if (strcmp(args[1], "refused") == 0)
1249 curr_resolvers->hold.refused = time;
1250 else if (strcmp(args[1], "timeout") == 0)
1251 curr_resolvers->hold.timeout = time;
1252 else if (strcmp(args[1], "valid") == 0)
Baptiste Assmann325137d2015-04-13 23:40:55 +02001253 curr_resolvers->hold.valid = time;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02001254 else if (strcmp(args[1], "obsolete") == 0)
1255 curr_resolvers->hold.obsolete = time;
Baptiste Assmann325137d2015-04-13 23:40:55 +02001256 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001257 ha_alert("parsing [%s:%d] : '%s' unknown <event>: '%s', expects either 'nx', 'timeout', 'valid', 'obsolete' or 'other'.\n",
1258 file, linenum, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001259 err_code |= ERR_ALERT | ERR_FATAL;
1260 goto out;
1261 }
1262
1263 }
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001264 else if (strcmp(args[0], "accepted_payload_size") == 0) {
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001265 int i = 0;
1266
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001267 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001268 ha_alert("parsing [%s:%d] : '%s' expects <nb> as argument.\n",
1269 file, linenum, args[0]);
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001270 err_code |= ERR_ALERT | ERR_FATAL;
1271 goto out;
1272 }
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001273
1274 i = atoi(args[1]);
Willy Tarreau0c219be2017-08-22 12:01:26 +02001275 if (i < DNS_HEADER_SIZE || i > DNS_MAX_UDP_MESSAGE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001276 ha_alert("parsing [%s:%d] : '%s' must be between %d and %d inclusive (was %s).\n",
1277 file, linenum, args[0], DNS_HEADER_SIZE, DNS_MAX_UDP_MESSAGE, args[1]);
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001278 err_code |= ERR_ALERT | ERR_FATAL;
1279 goto out;
1280 }
1281
1282 curr_resolvers->accepted_payload_size = i;
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001283 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001284 else if (strcmp(args[0], "resolution_pool_size") == 0) {
Tim Duesterhus3506dae2019-05-14 20:57:56 +02001285 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 +01001286 file, linenum, args[0]);
Tim Duesterhus3506dae2019-05-14 20:57:56 +02001287 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001288 goto out;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001289 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001290 else if (strcmp(args[0], "resolve_retries") == 0) {
1291 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001292 ha_alert("parsing [%s:%d] : '%s' expects <nb> as argument.\n",
1293 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001294 err_code |= ERR_ALERT | ERR_FATAL;
1295 goto out;
1296 }
1297 curr_resolvers->resolve_retries = atoi(args[1]);
1298 }
1299 else if (strcmp(args[0], "timeout") == 0) {
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001300 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001301 ha_alert("parsing [%s:%d] : '%s' expects 'retry' or 'resolve' and <time> as arguments.\n",
1302 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001303 err_code |= ERR_ALERT | ERR_FATAL;
1304 goto out;
1305 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001306 else if (strcmp(args[1], "retry") == 0 ||
1307 strcmp(args[1], "resolve") == 0) {
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001308 const char *res;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001309 unsigned int tout;
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001310
1311 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001312 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1313 file, linenum, args[0], args[1]);
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001314 err_code |= ERR_ALERT | ERR_FATAL;
1315 goto out;
1316 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001317 res = parse_time_err(args[2], &tout, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001318 if (res == PARSE_TIME_OVER) {
1319 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1320 file, linenum, args[2], args[0], args[1]);
1321 err_code |= ERR_ALERT | ERR_FATAL;
1322 goto out;
1323 }
1324 else if (res == PARSE_TIME_UNDER) {
1325 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1326 file, linenum, args[2], args[0], args[1]);
1327 err_code |= ERR_ALERT | ERR_FATAL;
1328 goto out;
1329 }
1330 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001331 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1332 file, linenum, *res, args[0], args[1]);
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001333 err_code |= ERR_ALERT | ERR_FATAL;
1334 goto out;
1335 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001336 if (args[1][2] == 't')
1337 curr_resolvers->timeout.retry = tout;
1338 else
1339 curr_resolvers->timeout.resolve = tout;
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001340 }
1341 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001342 ha_alert("parsing [%s:%d] : '%s' expects 'retry' or 'resolve' and <time> as arguments got '%s'.\n",
1343 file, linenum, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001344 err_code |= ERR_ALERT | ERR_FATAL;
1345 goto out;
1346 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001347 } /* neither "nameserver" nor "resolvers" */
1348 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001349 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001350 err_code |= ERR_ALERT | ERR_FATAL;
1351 goto out;
1352 }
1353
1354 out:
1355 free(errmsg);
1356 return err_code;
1357}
Simon Horman0d16a402015-01-30 11:22:58 +09001358
1359/*
William Lallemand51097192015-04-14 16:35:22 +02001360 * Parse a line in a <listen>, <frontend> or <backend> section.
Simon Horman0d16a402015-01-30 11:22:58 +09001361 * Returns the error code, 0 if OK, or any combination of :
1362 * - ERR_ABORT: must abort ASAP
1363 * - ERR_FATAL: we can continue parsing but not start the service
1364 * - ERR_WARN: a warning has been emitted
1365 * - ERR_ALERT: an alert has been emitted
1366 * Only the two first ones can stop processing, the two others are just
1367 * indicators.
1368 */
1369int cfg_parse_mailers(const char *file, int linenum, char **args, int kwm)
1370{
1371 static struct mailers *curmailers = NULL;
1372 struct mailer *newmailer = NULL;
1373 const char *err;
1374 int err_code = 0;
1375 char *errmsg = NULL;
1376
1377 if (strcmp(args[0], "mailers") == 0) { /* new mailers section */
1378 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001379 ha_alert("parsing [%s:%d] : missing name for mailers section.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001380 err_code |= ERR_ALERT | ERR_ABORT;
1381 goto out;
1382 }
1383
1384 err = invalid_char(args[1]);
1385 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001386 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
1387 file, linenum, *err, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001388 err_code |= ERR_ALERT | ERR_ABORT;
1389 goto out;
1390 }
1391
1392 for (curmailers = mailers; curmailers != NULL; curmailers = curmailers->next) {
1393 /*
1394 * If there are two proxies with the same name only following
1395 * combinations are allowed:
1396 */
1397 if (strcmp(curmailers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001398 ha_alert("Parsing [%s:%d]: mailers section '%s' has the same name as another mailers section declared at %s:%d.\n",
1399 file, linenum, args[1], curmailers->conf.file, curmailers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +02001400 err_code |= ERR_ALERT | ERR_FATAL;
Simon Horman0d16a402015-01-30 11:22:58 +09001401 }
1402 }
1403
Vincent Bernat02779b62016-04-03 13:48:43 +02001404 if ((curmailers = calloc(1, sizeof(*curmailers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001405 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001406 err_code |= ERR_ALERT | ERR_ABORT;
1407 goto out;
1408 }
1409
1410 curmailers->next = mailers;
1411 mailers = curmailers;
1412 curmailers->conf.file = strdup(file);
1413 curmailers->conf.line = linenum;
1414 curmailers->id = strdup(args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001415 curmailers->timeout.mail = DEF_MAILALERTTIME;/* XXX: Would like to Skip to the next alert, if any, ASAP.
1416 * But need enough time so that timeouts don't occur
1417 * during tcp procssing. For now just us an arbitrary default. */
Simon Horman0d16a402015-01-30 11:22:58 +09001418 }
1419 else if (strcmp(args[0], "mailer") == 0) { /* mailer definition */
1420 struct sockaddr_storage *sk;
1421 int port1, port2;
1422 struct protocol *proto;
1423
1424 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001425 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1426 file, linenum, args[0]);
Simon Horman0d16a402015-01-30 11:22:58 +09001427 err_code |= ERR_ALERT | ERR_FATAL;
1428 goto out;
1429 }
1430
1431 err = invalid_char(args[1]);
1432 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001433 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1434 file, linenum, *err, args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001435 err_code |= ERR_ALERT | ERR_FATAL;
1436 goto out;
1437 }
1438
Vincent Bernat02779b62016-04-03 13:48:43 +02001439 if ((newmailer = calloc(1, sizeof(*newmailer))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001440 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001441 err_code |= ERR_ALERT | ERR_ABORT;
1442 goto out;
1443 }
1444
1445 /* the mailers are linked backwards first */
1446 curmailers->count++;
1447 newmailer->next = curmailers->mailer_list;
1448 curmailers->mailer_list = newmailer;
1449 newmailer->mailers = curmailers;
1450 newmailer->conf.file = strdup(file);
1451 newmailer->conf.line = linenum;
1452
1453 newmailer->id = strdup(args[1]);
1454
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001455 sk = str2sa_range(args[2], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
Simon Horman0d16a402015-01-30 11:22:58 +09001456 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001457 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Simon Horman0d16a402015-01-30 11:22:58 +09001458 err_code |= ERR_ALERT | ERR_FATAL;
1459 goto out;
1460 }
1461
1462 proto = protocol_by_family(sk->ss_family);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09001463 if (!proto || !proto->connect || proto->sock_prot != IPPROTO_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001464 ha_alert("parsing [%s:%d] : '%s %s' : TCP not supported for this address family.\n",
1465 file, linenum, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001466 err_code |= ERR_ALERT | ERR_FATAL;
1467 goto out;
1468 }
1469
1470 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001471 ha_alert("parsing [%s:%d] : '%s %s' : port ranges and offsets are not allowed in '%s'\n",
1472 file, linenum, args[0], args[1], args[2]);
Simon Horman0d16a402015-01-30 11:22:58 +09001473 err_code |= ERR_ALERT | ERR_FATAL;
1474 goto out;
1475 }
1476
1477 if (!port1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001478 ha_alert("parsing [%s:%d] : '%s %s' : missing or invalid port in '%s'\n",
1479 file, linenum, args[0], args[1], args[2]);
Simon Horman0d16a402015-01-30 11:22:58 +09001480 err_code |= ERR_ALERT | ERR_FATAL;
1481 goto out;
1482 }
1483
1484 newmailer->addr = *sk;
1485 newmailer->proto = proto;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01001486 newmailer->xprt = xprt_get(XPRT_RAW);
Simon Horman0d16a402015-01-30 11:22:58 +09001487 newmailer->sock_init_arg = NULL;
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001488 }
1489 else if (strcmp(args[0], "timeout") == 0) {
1490 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001491 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments.\n",
1492 file, linenum, args[0]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001493 err_code |= ERR_ALERT | ERR_FATAL;
1494 goto out;
1495 }
1496 else if (strcmp(args[1], "mail") == 0) {
1497 const char *res;
1498 unsigned int timeout_mail;
1499 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001500 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1501 file, linenum, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001502 err_code |= ERR_ALERT | ERR_FATAL;
1503 goto out;
1504 }
1505 res = parse_time_err(args[2], &timeout_mail, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001506 if (res == PARSE_TIME_OVER) {
1507 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1508 file, linenum, args[2], args[0], args[1]);
1509 err_code |= ERR_ALERT | ERR_FATAL;
1510 goto out;
1511 }
1512 else if (res == PARSE_TIME_UNDER) {
1513 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1514 file, linenum, args[2], args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001515 err_code |= ERR_ALERT | ERR_FATAL;
1516 goto out;
1517 }
Willy Tarreau9faebe32019-06-07 19:00:37 +02001518 else if (res) {
1519 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1520 file, linenum, *res, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001521 err_code |= ERR_ALERT | ERR_FATAL;
1522 goto out;
1523 }
1524 curmailers->timeout.mail = timeout_mail;
1525 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001526 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments got '%s'.\n",
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001527 file, linenum, args[0], args[1]);
1528 err_code |= ERR_ALERT | ERR_FATAL;
1529 goto out;
1530 }
1531 }
Simon Horman0d16a402015-01-30 11:22:58 +09001532 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001533 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Simon Horman0d16a402015-01-30 11:22:58 +09001534 err_code |= ERR_ALERT | ERR_FATAL;
1535 goto out;
1536 }
1537
1538out:
1539 free(errmsg);
1540 return err_code;
1541}
1542
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +01001543void free_email_alert(struct proxy *p)
Simon Horman9dc49962015-01-30 11:22:59 +09001544{
1545 free(p->email_alert.mailers.name);
1546 p->email_alert.mailers.name = NULL;
1547 free(p->email_alert.from);
1548 p->email_alert.from = NULL;
1549 free(p->email_alert.to);
1550 p->email_alert.to = NULL;
1551 free(p->email_alert.myhostname);
1552 p->email_alert.myhostname = NULL;
1553}
1554
Willy Tarreaubaaee002006-06-26 02:48:02 +02001555
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001556int
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001557cfg_parse_netns(const char *file, int linenum, char **args, int kwm)
1558{
Willy Tarreaue5733232019-05-22 19:24:06 +02001559#ifdef USE_NS
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001560 const char *err;
1561 const char *item = args[0];
1562
1563 if (!strcmp(item, "namespace_list")) {
1564 return 0;
1565 }
1566 else if (!strcmp(item, "namespace")) {
1567 size_t idx = 1;
1568 const char *current;
1569 while (*(current = args[idx++])) {
1570 err = invalid_char(current);
1571 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001572 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1573 file, linenum, *err, item, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001574 return ERR_ALERT | ERR_FATAL;
1575 }
1576
1577 if (netns_store_lookup(current, strlen(current))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001578 ha_alert("parsing [%s:%d]: Namespace '%s' is already added.\n",
1579 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001580 return ERR_ALERT | ERR_FATAL;
1581 }
1582 if (!netns_store_insert(current)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001583 ha_alert("parsing [%s:%d]: Cannot open namespace '%s'.\n",
1584 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001585 return ERR_ALERT | ERR_FATAL;
1586 }
1587 }
1588 }
1589
1590 return 0;
1591#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001592 ha_alert("parsing [%s:%d]: namespace support is not compiled in.",
1593 file, linenum);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001594 return ERR_ALERT | ERR_FATAL;
1595#endif
1596}
1597
1598int
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001599cfg_parse_users(const char *file, int linenum, char **args, int kwm)
1600{
1601
1602 int err_code = 0;
1603 const char *err;
1604
1605 if (!strcmp(args[0], "userlist")) { /* new userlist */
1606 struct userlist *newul;
1607
1608 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001609 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1610 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001611 err_code |= ERR_ALERT | ERR_FATAL;
1612 goto out;
1613 }
William Lallemand6e62fb62015-04-28 16:55:23 +02001614 if (alertif_too_many_args(1, file, linenum, args, &err_code))
1615 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001616
1617 err = invalid_char(args[1]);
1618 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001619 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1620 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001621 err_code |= ERR_ALERT | ERR_FATAL;
1622 goto out;
1623 }
1624
1625 for (newul = userlist; newul; newul = newul->next)
1626 if (!strcmp(newul->name, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001627 ha_warning("parsing [%s:%d]: ignoring duplicated userlist '%s'.\n",
1628 file, linenum, args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001629 err_code |= ERR_WARN;
1630 goto out;
1631 }
1632
Vincent Bernat02779b62016-04-03 13:48:43 +02001633 newul = calloc(1, sizeof(*newul));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001634 if (!newul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001635 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001636 err_code |= ERR_ALERT | ERR_ABORT;
1637 goto out;
1638 }
1639
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001640 newul->name = strdup(args[1]);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001641 if (!newul->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001642 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001643 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier97880bb2016-04-08 10:35:26 +01001644 free(newul);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001645 goto out;
1646 }
1647
1648 newul->next = userlist;
1649 userlist = newul;
1650
1651 } else if (!strcmp(args[0], "group")) { /* new group */
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001652 int cur_arg;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001653 const char *err;
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001654 struct auth_groups *ag;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001655
1656 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001657 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1658 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001659 err_code |= ERR_ALERT | ERR_FATAL;
1660 goto out;
1661 }
1662
1663 err = invalid_char(args[1]);
1664 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001665 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1666 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001667 err_code |= ERR_ALERT | ERR_FATAL;
1668 goto out;
1669 }
1670
William Lallemand4ac9f542015-05-28 18:03:51 +02001671 if (!userlist)
1672 goto out;
1673
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001674 for (ag = userlist->groups; ag; ag = ag->next)
1675 if (!strcmp(ag->name, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001676 ha_warning("parsing [%s:%d]: ignoring duplicated group '%s' in userlist '%s'.\n",
1677 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001678 err_code |= ERR_ALERT;
1679 goto out;
1680 }
1681
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001682 ag = calloc(1, sizeof(*ag));
1683 if (!ag) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001684 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001685 err_code |= ERR_ALERT | ERR_ABORT;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001686 goto out;
1687 }
1688
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001689 ag->name = strdup(args[1]);
David Carlier70d60452016-08-22 23:27:42 +01001690 if (!ag->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001691 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001692 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier70d60452016-08-22 23:27:42 +01001693 free(ag);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001694 goto out;
1695 }
1696
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001697 cur_arg = 2;
1698
1699 while (*args[cur_arg]) {
1700 if (!strcmp(args[cur_arg], "users")) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001701 ag->groupusers = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001702 cur_arg += 2;
1703 continue;
1704 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001705 ha_alert("parsing [%s:%d]: '%s' only supports 'users' option.\n",
1706 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001707 err_code |= ERR_ALERT | ERR_FATAL;
David Carlier70d60452016-08-22 23:27:42 +01001708 free(ag->groupusers);
1709 free(ag->name);
1710 free(ag);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001711 goto out;
1712 }
1713 }
1714
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001715 ag->next = userlist->groups;
1716 userlist->groups = ag;
1717
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001718 } else if (!strcmp(args[0], "user")) { /* new user */
1719 struct auth_users *newuser;
1720 int cur_arg;
1721
1722 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001723 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1724 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001725 err_code |= ERR_ALERT | ERR_FATAL;
1726 goto out;
1727 }
William Lallemand4ac9f542015-05-28 18:03:51 +02001728 if (!userlist)
1729 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001730
1731 for (newuser = userlist->users; newuser; newuser = newuser->next)
1732 if (!strcmp(newuser->user, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001733 ha_warning("parsing [%s:%d]: ignoring duplicated user '%s' in userlist '%s'.\n",
1734 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001735 err_code |= ERR_ALERT;
1736 goto out;
1737 }
1738
Vincent Bernat02779b62016-04-03 13:48:43 +02001739 newuser = calloc(1, sizeof(*newuser));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001740 if (!newuser) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001741 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001742 err_code |= ERR_ALERT | ERR_ABORT;
1743 goto out;
1744 }
1745
1746 newuser->user = strdup(args[1]);
1747
1748 newuser->next = userlist->users;
1749 userlist->users = newuser;
1750
1751 cur_arg = 2;
1752
1753 while (*args[cur_arg]) {
1754 if (!strcmp(args[cur_arg], "password")) {
Willy Tarreaue5733232019-05-22 19:24:06 +02001755#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001756 if (!crypt("", args[cur_arg + 1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001757 ha_alert("parsing [%s:%d]: the encrypted password used for user '%s' is not supported by crypt(3).\n",
1758 file, linenum, newuser->user);
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001759 err_code |= ERR_ALERT | ERR_FATAL;
1760 goto out;
1761 }
1762#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001763 ha_warning("parsing [%s:%d]: no crypt(3) support compiled, encrypted passwords will not work.\n",
1764 file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001765 err_code |= ERR_ALERT;
1766#endif
1767 newuser->pass = strdup(args[cur_arg + 1]);
1768 cur_arg += 2;
1769 continue;
1770 } else if (!strcmp(args[cur_arg], "insecure-password")) {
1771 newuser->pass = strdup(args[cur_arg + 1]);
1772 newuser->flags |= AU_O_INSECURE;
1773 cur_arg += 2;
1774 continue;
1775 } else if (!strcmp(args[cur_arg], "groups")) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001776 newuser->u.groups_names = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001777 cur_arg += 2;
1778 continue;
1779 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001780 ha_alert("parsing [%s:%d]: '%s' only supports 'password', 'insecure-password' and 'groups' options.\n",
1781 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001782 err_code |= ERR_ALERT | ERR_FATAL;
1783 goto out;
1784 }
1785 }
1786 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001787 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 +01001788 err_code |= ERR_ALERT | ERR_FATAL;
1789 }
1790
1791out:
1792 return err_code;
1793}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001794
Christopher Faulet79bdef32016-11-04 22:36:15 +01001795int
1796cfg_parse_scope(const char *file, int linenum, char *line)
1797{
1798 char *beg, *end, *scope = NULL;
1799 int err_code = 0;
1800 const char *err;
1801
1802 beg = line + 1;
1803 end = strchr(beg, ']');
1804
1805 /* Detect end of scope declaration */
1806 if (!end || end == beg) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001807 ha_alert("parsing [%s:%d] : empty scope name is forbidden.\n",
1808 file, linenum);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001809 err_code |= ERR_ALERT | ERR_FATAL;
1810 goto out;
1811 }
1812
1813 /* Get scope name and check its validity */
1814 scope = my_strndup(beg, end-beg);
1815 err = invalid_char(scope);
1816 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001817 ha_alert("parsing [%s:%d] : character '%c' is not permitted in a scope name.\n",
1818 file, linenum, *err);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001819 err_code |= ERR_ALERT | ERR_ABORT;
1820 goto out;
1821 }
1822
1823 /* Be sure to have a scope declaration alone on its line */
1824 line = end+1;
1825 while (isspace((unsigned char)*line))
1826 line++;
1827 if (*line && *line != '#' && *line != '\n' && *line != '\r') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001828 ha_alert("parsing [%s:%d] : character '%c' is not permitted after scope declaration.\n",
1829 file, linenum, *line);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001830 err_code |= ERR_ALERT | ERR_ABORT;
1831 goto out;
1832 }
1833
1834 /* We have a valid scope declaration, save it */
1835 free(cfg_scope);
1836 cfg_scope = scope;
1837 scope = NULL;
1838
1839 out:
1840 free(scope);
1841 return err_code;
1842}
1843
Frédéric Lécaillea41d5312018-01-29 12:05:07 +01001844int
1845cfg_parse_track_sc_num(unsigned int *track_sc_num,
1846 const char *arg, const char *end, char **errmsg)
1847{
1848 const char *p;
1849 unsigned int num;
1850
1851 p = arg;
1852 num = read_uint64(&arg, end);
1853
1854 if (arg != end) {
1855 memprintf(errmsg, "Wrong track-sc number '%s'", p);
1856 return -1;
1857 }
1858
1859 if (num >= MAX_SESS_STKCTR) {
1860 memprintf(errmsg, "%u track-sc number exceeding "
1861 "%d (MAX_SESS_STKCTR-1) value", num, MAX_SESS_STKCTR - 1);
1862 return -1;
1863 }
1864
1865 *track_sc_num = num;
1866 return 0;
1867}
1868
Willy Tarreaubaaee002006-06-26 02:48:02 +02001869/*
1870 * This function reads and parses the configuration file given in the argument.
Willy Tarreau058e9072009-07-20 09:30:05 +02001871 * Returns the error code, 0 if OK, or any combination of :
1872 * - ERR_ABORT: must abort ASAP
1873 * - ERR_FATAL: we can continue parsing but not start the service
1874 * - ERR_WARN: a warning has been emitted
1875 * - ERR_ALERT: an alert has been emitted
1876 * Only the two first ones can stop processing, the two others are just
1877 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001878 */
Willy Tarreaub17916e2006-10-15 15:17:57 +02001879int readcfgfile(const char *file)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001880{
William Lallemand64e84512015-05-12 14:25:37 +02001881 char *thisline;
1882 int linesize = LINESIZE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001883 FILE *f;
1884 int linenum = 0;
Willy Tarreau058e9072009-07-20 09:30:05 +02001885 int err_code = 0;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001886 struct cfg_section *cs = NULL, *pcs = NULL;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001887 struct cfg_section *ics;
William Lallemand64e84512015-05-12 14:25:37 +02001888 int readbytes = 0;
1889
1890 if ((thisline = malloc(sizeof(*thisline) * linesize)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001891 ha_alert("parsing [%s] : out of memory.\n", file);
William Lallemand64e84512015-05-12 14:25:37 +02001892 return -1;
1893 }
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001894
David Carlier97880bb2016-04-08 10:35:26 +01001895 if ((f=fopen(file,"r")) == NULL) {
1896 free(thisline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001897 return -1;
David Carlier97880bb2016-04-08 10:35:26 +01001898 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001899
William Lallemandb2f07452015-05-12 14:27:13 +02001900next_line:
William Lallemand64e84512015-05-12 14:25:37 +02001901 while (fgets(thisline + readbytes, linesize - readbytes, f) != NULL) {
Willy Tarreau3842f002009-06-14 11:39:52 +02001902 int arg, kwm = KWM_STD;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001903 char *end;
1904 char *args[MAX_LINE_ARGS + 1];
1905 char *line = thisline;
William Lallemandf9873ba2015-05-05 17:37:14 +02001906 int dquote = 0; /* double quote */
1907 int squote = 0; /* simple quote */
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001908
Willy Tarreaubaaee002006-06-26 02:48:02 +02001909 linenum++;
1910
1911 end = line + strlen(line);
1912
William Lallemand64e84512015-05-12 14:25:37 +02001913 if (end-line == linesize-1 && *(end-1) != '\n') {
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001914 /* Check if we reached the limit and the last char is not \n.
1915 * Watch out for the last line without the terminating '\n'!
1916 */
William Lallemand64e84512015-05-12 14:25:37 +02001917 char *newline;
1918 int newlinesize = linesize * 2;
1919
1920 newline = realloc(thisline, sizeof(*thisline) * newlinesize);
1921 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001922 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1923 file, linenum);
William Lallemand64e84512015-05-12 14:25:37 +02001924 err_code |= ERR_ALERT | ERR_FATAL;
1925 continue;
1926 }
1927
1928 readbytes = linesize - 1;
1929 linesize = newlinesize;
1930 thisline = newline;
1931 continue;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001932 }
1933
William Lallemand64e84512015-05-12 14:25:37 +02001934 readbytes = 0;
1935
Willy Tarreaubaaee002006-06-26 02:48:02 +02001936 /* skip leading spaces */
Willy Tarreau8f8e6452007-06-17 21:51:38 +02001937 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001938 line++;
William Lallemandf9873ba2015-05-05 17:37:14 +02001939
Christopher Faulet79bdef32016-11-04 22:36:15 +01001940
Joseph Herlanta14c03e2018-11-15 14:04:19 -08001941 if (*line == '[') {/* This is the beginning if a scope */
Christopher Faulet79bdef32016-11-04 22:36:15 +01001942 err_code |= cfg_parse_scope(file, linenum, line);
1943 goto next_line;
1944 }
1945
Willy Tarreaubaaee002006-06-26 02:48:02 +02001946 arg = 0;
1947 args[arg] = line;
1948
1949 while (*line && arg < MAX_LINE_ARGS) {
William Lallemandf9873ba2015-05-05 17:37:14 +02001950 if (*line == '"' && !squote) { /* double quote outside single quotes */
1951 if (dquote)
1952 dquote = 0;
1953 else
1954 dquote = 1;
William Lallemand3f415602015-05-12 14:01:09 +02001955 memmove(line, line + 1, end - line);
William Lallemandf9873ba2015-05-05 17:37:14 +02001956 end--;
1957 }
1958 else if (*line == '\'' && !dquote) { /* single quote outside double quotes */
1959 if (squote)
1960 squote = 0;
1961 else
1962 squote = 1;
William Lallemand3f415602015-05-12 14:01:09 +02001963 memmove(line, line + 1, end - line);
William Lallemandf9873ba2015-05-05 17:37:14 +02001964 end--;
1965 }
1966 else if (*line == '\\' && !squote) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001967 /* first, we'll replace \\, \<space>, \#, \r, \n, \t, \xXX with their
1968 * C equivalent value. Other combinations left unchanged (eg: \1).
1969 */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001970 int skip = 0;
1971 if (line[1] == ' ' || line[1] == '\\' || line[1] == '#') {
1972 *line = line[1];
1973 skip = 1;
1974 }
1975 else if (line[1] == 'r') {
1976 *line = '\r';
1977 skip = 1;
William Lallemandf9873ba2015-05-05 17:37:14 +02001978 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001979 else if (line[1] == 'n') {
1980 *line = '\n';
1981 skip = 1;
1982 }
1983 else if (line[1] == 't') {
1984 *line = '\t';
1985 skip = 1;
1986 }
1987 else if (line[1] == 'x') {
Emeric Brunb982a3d2010-01-04 15:45:53 +01001988 if ((line + 3 < end) && ishex(line[2]) && ishex(line[3])) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001989 unsigned char hex1, hex2;
1990 hex1 = toupper(line[2]) - '0';
1991 hex2 = toupper(line[3]) - '0';
1992 if (hex1 > 9) hex1 -= 'A' - '9' - 1;
1993 if (hex2 > 9) hex2 -= 'A' - '9' - 1;
1994 *line = (hex1<<4) + hex2;
1995 skip = 3;
1996 }
1997 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001998 ha_alert("parsing [%s:%d] : invalid or incomplete '\\x' sequence in '%s'.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02001999 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002000 }
William Lallemandf9873ba2015-05-05 17:37:14 +02002001 } else if (line[1] == '"') {
2002 *line = '"';
2003 skip = 1;
2004 } else if (line[1] == '\'') {
2005 *line = '\'';
2006 skip = 1;
William Lallemandb2f07452015-05-12 14:27:13 +02002007 } else if (line[1] == '$' && dquote) { /* escaping of $ only inside double quotes */
2008 *line = '$';
2009 skip = 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002010 }
2011 if (skip) {
Cyril Bontédd1b01d2009-12-06 13:43:42 +01002012 memmove(line + 1, line + 1 + skip, end - (line + skip));
Willy Tarreaubaaee002006-06-26 02:48:02 +02002013 end -= skip;
2014 }
2015 line++;
2016 }
William Lallemandf9873ba2015-05-05 17:37:14 +02002017 else if ((!squote && !dquote && *line == '#') || *line == '\n' || *line == '\r') {
Willy Tarreaubaaee002006-06-26 02:48:02 +02002018 /* end of string, end of loop */
2019 *line = 0;
2020 break;
2021 }
William Lallemandf9873ba2015-05-05 17:37:14 +02002022 else if (!squote && !dquote && isspace((unsigned char)*line)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02002023 /* a non-escaped space is an argument separator */
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01002024 *line++ = '\0';
Willy Tarreau8f8e6452007-06-17 21:51:38 +02002025 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02002026 line++;
2027 args[++arg] = line;
2028 }
William Lallemandb2f07452015-05-12 14:27:13 +02002029 else if (dquote && *line == '$') {
2030 /* environment variables are evaluated inside double quotes */
2031 char *var_beg;
2032 char *var_end;
2033 char save_char;
2034 char *value;
2035 int val_len;
2036 int newlinesize;
2037 int braces = 0;
2038
2039 var_beg = line + 1;
2040 var_end = var_beg;
2041
2042 if (*var_beg == '{') {
2043 var_beg++;
2044 var_end++;
2045 braces = 1;
2046 }
2047
Willy Tarreau90807112020-02-25 08:16:33 +01002048 if (!isalpha((unsigned char)*var_beg) && *var_beg != '_') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002049 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 +02002050 err_code |= ERR_ALERT | ERR_FATAL;
2051 goto next_line; /* skip current line */
2052 }
2053
Willy Tarreau90807112020-02-25 08:16:33 +01002054 while (isalnum((unsigned char)*var_end) || *var_end == '_')
William Lallemandb2f07452015-05-12 14:27:13 +02002055 var_end++;
2056
2057 save_char = *var_end;
2058 *var_end = '\0';
2059 value = getenv(var_beg);
2060 *var_end = save_char;
2061 val_len = value ? strlen(value) : 0;
2062
2063 if (braces) {
2064 if (*var_end == '}') {
2065 var_end++;
2066 braces = 0;
2067 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002068 ha_alert("parsing [%s:%d] : Variable expansion: Mismatched braces.\n", file, linenum);
William Lallemandb2f07452015-05-12 14:27:13 +02002069 err_code |= ERR_ALERT | ERR_FATAL;
2070 goto next_line; /* skip current line */
2071 }
2072 }
2073
2074 newlinesize = (end - thisline) - (var_end - line) + val_len + 1;
2075
2076 /* if not enough space in thisline */
2077 if (newlinesize > linesize) {
2078 char *newline;
2079
2080 newline = realloc(thisline, newlinesize * sizeof(*thisline));
2081 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002082 ha_alert("parsing [%s:%d] : Variable expansion: Not enough memory.\n", file, linenum);
William Lallemandb2f07452015-05-12 14:27:13 +02002083 err_code |= ERR_ALERT | ERR_FATAL;
2084 goto next_line; /* slip current line */
2085 }
2086 /* recompute pointers if realloc returns a new pointer */
2087 if (newline != thisline) {
2088 int i;
2089 int diff;
2090
2091 for (i = 0; i <= arg; i++) {
2092 diff = args[i] - thisline;
2093 args[i] = newline + diff;
2094 }
2095
2096 diff = var_end - thisline;
2097 var_end = newline + diff;
2098 diff = end - thisline;
2099 end = newline + diff;
2100 diff = line - thisline;
2101 line = newline + diff;
2102 thisline = newline;
2103 }
2104 linesize = newlinesize;
2105 }
2106
2107 /* insert value inside the line */
2108 memmove(line + val_len, var_end, end - var_end + 1);
2109 memcpy(line, value, val_len);
2110 end += val_len - (var_end - line);
2111 line += val_len;
2112 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002113 else {
2114 line++;
2115 }
2116 }
William Lallemandb2f07452015-05-12 14:27:13 +02002117
William Lallemandf9873ba2015-05-05 17:37:14 +02002118 if (dquote) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002119 ha_alert("parsing [%s:%d] : Mismatched double quotes.\n", file, linenum);
William Lallemandf9873ba2015-05-05 17:37:14 +02002120 err_code |= ERR_ALERT | ERR_FATAL;
2121 }
2122
2123 if (squote) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002124 ha_alert("parsing [%s:%d] : Mismatched simple quotes.\n", file, linenum);
William Lallemandf9873ba2015-05-05 17:37:14 +02002125 err_code |= ERR_ALERT | ERR_FATAL;
2126 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002127
2128 /* empty line */
2129 if (!**args)
2130 continue;
2131
Willy Tarreau7bb651e2009-11-09 21:16:53 +01002132 if (*line) {
2133 /* we had to stop due to too many args.
2134 * Let's terminate the string, print the offending part then cut the
2135 * last arg.
2136 */
2137 while (*line && *line != '#' && *line != '\n' && *line != '\r')
2138 line++;
2139 *line = '\0';
2140
Christopher Faulet767a84b2017-11-24 16:50:31 +01002141 ha_alert("parsing [%s:%d]: line too long, truncating at word %d, position %ld: <%s>.\n",
2142 file, linenum, arg + 1, (long)(args[arg] - thisline + 1), args[arg]);
Willy Tarreau7bb651e2009-11-09 21:16:53 +01002143 err_code |= ERR_ALERT | ERR_FATAL;
2144 args[arg] = line;
2145 }
2146
Willy Tarreau540abe42007-05-02 20:50:16 +02002147 /* zero out remaining args and ensure that at least one entry
2148 * is zeroed out.
2149 */
2150 while (++arg <= MAX_LINE_ARGS) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02002151 args[arg] = line;
2152 }
2153
Willy Tarreau3842f002009-06-14 11:39:52 +02002154 /* check for keyword modifiers "no" and "default" */
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002155 if (!strcmp(args[0], "no")) {
William Lallemand0f99e342011-10-12 17:50:54 +02002156 char *tmp;
2157
Willy Tarreau3842f002009-06-14 11:39:52 +02002158 kwm = KWM_NO;
William Lallemand0f99e342011-10-12 17:50:54 +02002159 tmp = args[0];
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002160 for (arg=0; *args[arg+1]; arg++)
2161 args[arg] = args[arg+1]; // shift args after inversion
William Lallemand0f99e342011-10-12 17:50:54 +02002162 *tmp = '\0'; // fix the next arg to \0
2163 args[arg] = tmp;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002164 }
Willy Tarreau3842f002009-06-14 11:39:52 +02002165 else if (!strcmp(args[0], "default")) {
2166 kwm = KWM_DEF;
2167 for (arg=0; *args[arg+1]; arg++)
2168 args[arg] = args[arg+1]; // shift args after inversion
2169 }
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002170
William Dauchyec730982019-10-27 20:08:10 +01002171 if (kwm != KWM_STD && strcmp(args[0], "option") != 0 &&
2172 strcmp(args[0], "log") != 0 && strcmp(args[0], "busy-polling") != 0 &&
Willy Tarreaud96f1122019-12-03 07:07:36 +01002173 strcmp(args[0], "set-dumpable") != 0 && strcmp(args[0], "strict-limits") != 0 &&
2174 strcmp(args[0], "insecure-fork-wanted") != 0) {
William Dauchyec730982019-10-27 20:08:10 +01002175 ha_alert("parsing [%s:%d]: negation/default currently "
William Dauchy0fec3ab2019-10-27 20:08:11 +01002176 "supported only for options, log, busy-polling, "
Willy Tarreaud96f1122019-12-03 07:07:36 +01002177 "set-dumpable, strict-limits, and insecure-fork-wanted.\n", file, linenum);
Willy Tarreau058e9072009-07-20 09:30:05 +02002178 err_code |= ERR_ALERT | ERR_FATAL;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002179 }
2180
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002181 /* detect section start */
2182 list_for_each_entry(ics, &sections, list) {
2183 if (strcmp(args[0], ics->section_name) == 0) {
2184 cursection = ics->section_name;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002185 pcs = cs;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002186 cs = ics;
2187 break;
2188 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002189 }
2190
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002191 if (pcs && pcs->post_section_parser) {
2192 err_code |= pcs->post_section_parser();
2193 if (err_code & ERR_ABORT)
2194 goto err;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002195 }
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002196 pcs = NULL;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002197
William Lallemandd2ff56d2017-10-16 11:06:50 +02002198 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002199 ha_alert("parsing [%s:%d]: unknown keyword '%s' out of section.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02002200 err_code |= ERR_ALERT | ERR_FATAL;
William Lallemandd2ff56d2017-10-16 11:06:50 +02002201 } else {
William Lallemandd2ff56d2017-10-16 11:06:50 +02002202 err_code |= cs->section_parser(file, linenum, args, kwm);
2203 if (err_code & ERR_ABORT)
2204 goto err;
2205 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002206 }
William Lallemandd2ff56d2017-10-16 11:06:50 +02002207
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002208 if (cs && cs->post_section_parser)
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002209 err_code |= cs->post_section_parser();
William Lallemandd2ff56d2017-10-16 11:06:50 +02002210
2211err:
Christopher Faulet79bdef32016-11-04 22:36:15 +01002212 free(cfg_scope);
2213 cfg_scope = NULL;
Willy Tarreau6daf3432008-01-22 16:44:08 +01002214 cursection = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02002215 free(thisline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002216 fclose(f);
Willy Tarreau058e9072009-07-20 09:30:05 +02002217 return err_code;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002218}
2219
Willy Tarreau64ab6072014-09-16 12:17:36 +02002220/* This function propagates processes from frontend <from> to backend <to> so
2221 * that it is always guaranteed that a backend pointed to by a frontend is
2222 * bound to all of its processes. After that, if the target is a "listen"
2223 * instance, the function recursively descends the target's own targets along
Willy Tarreau98d04852015-05-26 12:18:29 +02002224 * default_backend and use_backend rules. Since the bits are
Willy Tarreau64ab6072014-09-16 12:17:36 +02002225 * checked first to ensure that <to> is already bound to all processes of
2226 * <from>, there is no risk of looping and we ensure to follow the shortest
2227 * path to the destination.
2228 *
2229 * It is possible to set <to> to NULL for the first call so that the function
2230 * takes care of visiting the initial frontend in <from>.
2231 *
2232 * It is important to note that the function relies on the fact that all names
2233 * have already been resolved.
2234 */
2235void propagate_processes(struct proxy *from, struct proxy *to)
2236{
2237 struct switching_rule *rule;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002238
2239 if (to) {
2240 /* check whether we need to go down */
2241 if (from->bind_proc &&
2242 (from->bind_proc & to->bind_proc) == from->bind_proc)
2243 return;
2244
2245 if (!from->bind_proc && !to->bind_proc)
2246 return;
2247
2248 to->bind_proc = from->bind_proc ?
2249 (to->bind_proc | from->bind_proc) : 0;
2250
2251 /* now propagate down */
2252 from = to;
2253 }
2254
Willy Tarreau8a95d8c2014-12-18 13:56:26 +01002255 if (!(from->cap & PR_CAP_FE))
Willy Tarreau64ab6072014-09-16 12:17:36 +02002256 return;
2257
Willy Tarreauf6b70012014-12-18 14:00:43 +01002258 if (from->state == PR_STSTOPPED)
2259 return;
2260
Willy Tarreau64ab6072014-09-16 12:17:36 +02002261 /* default_backend */
2262 if (from->defbe.be)
2263 propagate_processes(from, from->defbe.be);
2264
2265 /* use_backend */
2266 list_for_each_entry(rule, &from->switching_rules, list) {
Cyril Bonté51639692014-10-02 19:56:25 +02002267 if (rule->dynamic)
2268 continue;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002269 to = rule->be.backend;
2270 propagate_processes(from, to);
2271 }
Willy Tarreau64ab6072014-09-16 12:17:36 +02002272}
2273
Willy Tarreaubb925012009-07-23 13:36:36 +02002274/*
2275 * Returns the error code, 0 if OK, or any combination of :
2276 * - ERR_ABORT: must abort ASAP
2277 * - ERR_FATAL: we can continue parsing but not start the service
2278 * - ERR_WARN: a warning has been emitted
2279 * - ERR_ALERT: an alert has been emitted
2280 * Only the two first ones can stop processing, the two others are just
2281 * indicators.
2282 */
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002283int check_config_validity()
2284{
2285 int cfgerr = 0;
2286 struct proxy *curproxy = NULL;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002287 struct stktable *t;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002288 struct server *newsrv = NULL;
Willy Tarreaubb925012009-07-23 13:36:36 +02002289 int err_code = 0;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002290 unsigned int next_pxid = 1;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002291 struct bind_conf *bind_conf;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002292 char *err;
William Lallemand48b4bb42017-10-23 14:36:34 +02002293 struct cfg_postparser *postparser;
Ben Draut054fbee2018-04-13 15:43:04 -06002294 struct dns_resolvers *curr_resolvers = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002295
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002296 bind_conf = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002297 /*
2298 * Now, check for the integrity of all that we have collected.
2299 */
2300
2301 /* will be needed further to delay some tasks */
Willy Tarreaub0b37bc2008-06-23 14:00:57 +02002302 tv_update_date(0,1);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002303
Willy Tarreau193b8c62012-11-22 00:17:38 +01002304 if (!global.tune.max_http_hdr)
2305 global.tune.max_http_hdr = MAX_HTTP_HDR;
2306
2307 if (!global.tune.cookie_len)
2308 global.tune.cookie_len = CAPTURE_LEN;
2309
Stéphane Cottin23e9e932017-05-18 08:58:41 +02002310 if (!global.tune.requri_len)
2311 global.tune.requri_len = REQURI_LEN;
2312
Willy Tarreau149ab772019-01-26 14:27:06 +01002313 if (!global.nbthread) {
2314 /* nbthread not set, thus automatic. In this case, and only if
2315 * running on a single process, we enable the same number of
2316 * threads as the number of CPUs the process is bound to. This
2317 * allows to easily control the number of threads using taskset.
2318 */
2319 global.nbthread = 1;
2320#if defined(USE_THREAD)
2321 if (global.nbproc == 1)
2322 global.nbthread = thread_cpus_enabled_at_boot;
2323 all_threads_mask = nbits(global.nbthread);
2324#endif
2325 }
2326
Willy Tarreau26f6ae12019-02-02 12:56:15 +01002327 if (global.nbproc > 1 && global.nbthread > 1) {
2328 ha_alert("config : cannot enable multiple processes if multiple threads are configured. Please use either nbproc or nbthread but not both.\n");
2329 err_code |= ERR_ALERT | ERR_FATAL;
2330 goto out;
2331 }
2332
Willy Tarreaubafbe012017-11-24 17:34:44 +01002333 pool_head_requri = create_pool("requri", global.tune.requri_len , MEM_F_SHARED);
Emeric Brun96fd9262017-07-05 13:33:16 +02002334
Willy Tarreaubafbe012017-11-24 17:34:44 +01002335 pool_head_capture = create_pool("capture", global.tune.cookie_len, MEM_F_SHARED);
Willy Tarreau193b8c62012-11-22 00:17:38 +01002336
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002337 /* Post initialisation of the users and groups lists. */
2338 err_code = userlist_postinit();
2339 if (err_code != ERR_NONE)
2340 goto out;
2341
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002342 /* first, we will invert the proxy list order */
2343 curproxy = NULL;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002344 while (proxies_list) {
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002345 struct proxy *next;
2346
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002347 next = proxies_list->next;
2348 proxies_list->next = curproxy;
2349 curproxy = proxies_list;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002350 if (!next)
2351 break;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002352 proxies_list = next;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002353 }
2354
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002355 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002356 struct switching_rule *rule;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002357 struct server_rule *srule;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002358 struct sticking_rule *mrule;
Christopher Faulete4e830d2017-09-18 14:51:41 +02002359 struct act_rule *arule;
Dragan Dosen1322d092015-09-22 16:05:32 +02002360 struct logsrv *tmplogsrv;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002361 unsigned int next_id;
Willy Tarreau16a21472012-11-19 12:39:59 +01002362 int nbproc;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002363
Willy Tarreau050536d2012-10-04 08:47:34 +02002364 if (curproxy->uuid < 0) {
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002365 /* proxy ID not set, use automatic numbering with first
2366 * spare entry starting with next_pxid.
2367 */
2368 next_pxid = get_next_id(&used_proxy_id, next_pxid);
2369 curproxy->conf.id.key = curproxy->uuid = next_pxid;
2370 eb32_insert(&used_proxy_id, &curproxy->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002371 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01002372 next_pxid++;
2373
Willy Tarreau55ea7572007-06-17 19:56:27 +02002374
Willy Tarreaubaaee002006-06-26 02:48:02 +02002375 if (curproxy->state == PR_STSTOPPED) {
Willy Tarreauda250db2008-10-12 12:07:48 +02002376 /* ensure we don't keep listeners uselessly bound */
2377 stop_proxy(curproxy);
Dragan Dosen7d61a332019-05-07 14:16:18 +02002378 if (curproxy->table) {
2379 free((void *)curproxy->table->peers.name);
2380 curproxy->table->peers.p = NULL;
2381 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002382 continue;
2383 }
2384
Willy Tarreau102df612014-05-07 23:56:38 +02002385 /* Check multi-process mode compatibility for the current proxy */
2386
2387 if (curproxy->bind_proc) {
2388 /* an explicit bind-process was specified, let's check how many
2389 * processes remain.
2390 */
David Carliere6c39412015-07-02 07:00:17 +00002391 nbproc = my_popcountl(curproxy->bind_proc);
Willy Tarreau102df612014-05-07 23:56:38 +02002392
Willy Tarreaua38a7172019-02-02 17:11:28 +01002393 curproxy->bind_proc &= all_proc_mask;
Willy Tarreau102df612014-05-07 23:56:38 +02002394 if (!curproxy->bind_proc && nbproc == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002395 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 +02002396 curproxy->bind_proc = 1;
2397 }
2398 else if (!curproxy->bind_proc && nbproc > 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002399 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 +02002400 curproxy->bind_proc = 0;
2401 }
2402 }
2403
Willy Tarreau3d209582014-05-09 17:06:11 +02002404 /* check and reduce the bind-proc of each listener */
2405 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
2406 unsigned long mask;
2407
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002408 /* HTTP frontends with "h2" as ALPN/NPN will work in
2409 * HTTP/2 and absolutely require buffers 16kB or larger.
2410 */
2411#ifdef USE_OPENSSL
2412 if (curproxy->mode == PR_MODE_HTTP && global.tune.bufsize < 16384) {
2413#ifdef OPENSSL_NPN_NEGOTIATED
2414 /* check NPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002415 if (bind_conf->ssl_conf.npn_str && strstr(bind_conf->ssl_conf.npn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002416 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",
2417 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002418 cfgerr++;
2419 }
2420#endif
2421#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
2422 /* check ALPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002423 if (bind_conf->ssl_conf.alpn_str && strstr(bind_conf->ssl_conf.alpn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002424 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",
2425 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002426 cfgerr++;
2427 }
2428#endif
2429 } /* HTTP && bufsize < 16384 */
2430#endif
2431
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002432 /* detect and address thread affinity inconsistencies */
Willy Tarreaua36b3242019-02-02 13:14:34 +01002433 mask = thread_mask(bind_conf->bind_thread);
Willy Tarreau3d957172019-02-02 18:00:17 +01002434 if (!(mask & all_threads_mask)) {
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002435 unsigned long new_mask = 0;
2436
2437 while (mask) {
Willy Tarreau0c026f42018-08-01 19:12:20 +02002438 new_mask |= mask & all_threads_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002439 mask >>= global.nbthread;
2440 }
2441
Willy Tarreaua36b3242019-02-02 13:14:34 +01002442 bind_conf->bind_thread = new_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002443 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",
2444 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line, new_mask);
2445 }
2446
2447 /* detect process and nbproc affinity inconsistencies */
Willy Tarreaua36b3242019-02-02 13:14:34 +01002448 mask = proc_mask(bind_conf->bind_proc) & proc_mask(curproxy->bind_proc);
2449 if (!(mask & all_proc_mask)) {
2450 mask = proc_mask(curproxy->bind_proc) & all_proc_mask;
2451 nbproc = my_popcountl(bind_conf->bind_proc);
2452 bind_conf->bind_proc = proc_mask(bind_conf->bind_proc) & mask;
Willy Tarreau3d209582014-05-09 17:06:11 +02002453
Willy Tarreaua36b3242019-02-02 13:14:34 +01002454 if (!bind_conf->bind_proc && nbproc == 1) {
2455 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",
2456 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
2457 bind_conf->bind_proc = mask & ~(mask - 1);
2458 }
2459 else if (!bind_conf->bind_proc && nbproc > 1) {
2460 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",
2461 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
2462 bind_conf->bind_proc = 0;
2463 }
Willy Tarreau3d209582014-05-09 17:06:11 +02002464 }
2465 }
2466
Willy Tarreauff01a212009-03-15 13:46:16 +01002467 switch (curproxy->mode) {
2468 case PR_MODE_HEALTH:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002469 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002470 if (!(curproxy->cap & PR_CAP_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002471 ha_alert("config : %s '%s' cannot be in health mode as it has no frontend capability.\n",
2472 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +01002473 cfgerr++;
2474 }
2475
2476 if (curproxy->srv != NULL)
Christopher Faulet767a84b2017-11-24 16:50:31 +01002477 ha_warning("config : servers will be ignored for %s '%s'.\n",
2478 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +01002479 break;
2480
2481 case PR_MODE_TCP:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002482 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002483 break;
2484
2485 case PR_MODE_HTTP:
Willy Tarreau25320b22013-03-24 07:22:08 +01002486 curproxy->http_needed = 1;
Willy Tarreauff01a212009-03-15 13:46:16 +01002487 break;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002488
2489 case PR_MODE_CLI:
2490 cfgerr += proxy_cfg_ensure_no_http(curproxy);
2491 break;
Willy Tarreauff01a212009-03-15 13:46:16 +01002492 }
2493
Willy Tarreau58aa5cc2018-02-08 09:55:09 +01002494 if (curproxy != global.stats_fe && (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->conf.listeners)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002495 ha_warning("config : %s '%s' has no 'bind' directive. Please declare it as a backend if this was intended.\n",
2496 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauf3934b82015-08-11 11:36:45 +02002497 err_code |= ERR_WARN;
2498 }
2499
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002500 if ((curproxy->cap & PR_CAP_BE) && (curproxy->mode != PR_MODE_HEALTH)) {
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002501 if (curproxy->lbprm.algo & BE_LB_KIND) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002502 if (curproxy->options & PR_O_TRANSP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002503 ha_alert("config : %s '%s' cannot use both transparent and balance mode.\n",
2504 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002505 cfgerr++;
2506 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002507#ifdef WE_DONT_SUPPORT_SERVERLESS_LISTENERS
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002508 else if (curproxy->srv == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002509 ha_alert("config : %s '%s' needs at least 1 server in balance mode.\n",
2510 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002511 cfgerr++;
2512 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002513#endif
Willy Tarreau1620ec32011-08-06 17:05:02 +02002514 else if (curproxy->options & PR_O_DISPATCH) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002515 ha_warning("config : dispatch address of %s '%s' will be ignored in balance mode.\n",
2516 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002517 err_code |= ERR_WARN;
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002518 }
2519 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02002520 else if (!(curproxy->options & (PR_O_TRANSP | PR_O_DISPATCH | PR_O_HTTP_PROXY))) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002521 /* If no LB algo is set in a backend, and we're not in
2522 * transparent mode, dispatch mode nor proxy mode, we
2523 * want to use balance roundrobin by default.
2524 */
2525 curproxy->lbprm.algo &= ~BE_LB_ALGO;
2526 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002527 }
2528 }
Willy Tarreau193cf932007-09-17 10:17:23 +02002529
Willy Tarreau1620ec32011-08-06 17:05:02 +02002530 if (curproxy->options & PR_O_DISPATCH)
2531 curproxy->options &= ~(PR_O_TRANSP | PR_O_HTTP_PROXY);
2532 else if (curproxy->options & PR_O_HTTP_PROXY)
2533 curproxy->options &= ~(PR_O_DISPATCH | PR_O_TRANSP);
2534 else if (curproxy->options & PR_O_TRANSP)
2535 curproxy->options &= ~(PR_O_DISPATCH | PR_O_HTTP_PROXY);
Willy Tarreau82936582007-11-30 15:20:09 +01002536
Willy Tarreau1620ec32011-08-06 17:05:02 +02002537 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_HTTP_CHK) {
2538 if (curproxy->options & PR_O_DISABLE404) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002539 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2540 "disable-on-404", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002541 err_code |= ERR_WARN;
2542 curproxy->options &= ~PR_O_DISABLE404;
2543 }
2544 if (curproxy->options2 & PR_O2_CHK_SNDST) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002545 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2546 "send-state", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002547 err_code |= ERR_WARN;
2548 curproxy->options &= ~PR_O2_CHK_SNDST;
2549 }
Willy Tarreauef781042010-01-27 11:53:01 +01002550 }
2551
Simon Horman98637e52014-06-20 12:30:16 +09002552 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_EXT_CHK) {
2553 if (!global.external_check) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002554 ha_alert("Proxy '%s' : '%s' unable to find required 'global.external-check'.\n",
2555 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002556 cfgerr++;
2557 }
2558 if (!curproxy->check_command) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002559 ha_alert("Proxy '%s' : '%s' unable to find required 'external-check command'.\n",
2560 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002561 cfgerr++;
2562 }
Willy Tarreaud96f1122019-12-03 07:07:36 +01002563 if (!(global.tune.options & GTUNE_INSECURE_FORK)) {
2564 ha_warning("Proxy '%s' : 'insecure-fork-wanted' not enabled in the global section, '%s' will likely fail.\n",
2565 curproxy->id, "option external-check");
2566 err_code |= ERR_WARN;
2567 }
Simon Horman98637e52014-06-20 12:30:16 +09002568 }
2569
Simon Horman64e34162015-02-06 11:11:57 +09002570 if (curproxy->email_alert.set) {
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002571 if (!(curproxy->email_alert.mailers.name && curproxy->email_alert.from && curproxy->email_alert.to)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002572 ha_warning("config : 'email-alert' will be ignored for %s '%s' (the presence any of "
2573 "'email-alert from', 'email-alert level' 'email-alert mailers', "
2574 "'email-alert myhostname', or 'email-alert to' "
2575 "requires each of 'email-alert from', 'email-alert mailers' and 'email-alert to' "
2576 "to be present).\n",
2577 proxy_type_str(curproxy), curproxy->id);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002578 err_code |= ERR_WARN;
2579 free_email_alert(curproxy);
2580 }
2581 if (!curproxy->email_alert.myhostname)
Cyril Bontée22bfd62015-12-04 03:07:07 +01002582 curproxy->email_alert.myhostname = strdup(hostname);
Simon Horman9dc49962015-01-30 11:22:59 +09002583 }
2584
Simon Horman98637e52014-06-20 12:30:16 +09002585 if (curproxy->check_command) {
2586 int clear = 0;
2587 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002588 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2589 "external-check command", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002590 err_code |= ERR_WARN;
2591 clear = 1;
2592 }
2593 if (curproxy->check_command[0] != '/' && !curproxy->check_path) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002594 ha_alert("Proxy '%s': '%s' does not have a leading '/' and 'external-check path' is not set.\n",
2595 curproxy->id, "external-check command");
Simon Horman98637e52014-06-20 12:30:16 +09002596 cfgerr++;
2597 }
2598 if (clear) {
2599 free(curproxy->check_command);
2600 curproxy->check_command = NULL;
2601 }
2602 }
2603
2604 if (curproxy->check_path) {
2605 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002606 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2607 "external-check path", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002608 err_code |= ERR_WARN;
2609 free(curproxy->check_path);
2610 curproxy->check_path = NULL;
2611 }
2612 }
2613
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002614 /* if a default backend was specified, let's find it */
2615 if (curproxy->defbe.name) {
2616 struct proxy *target;
2617
Willy Tarreauafb39922015-05-26 12:04:09 +02002618 target = proxy_be_by_name(curproxy->defbe.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002619 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002620 ha_alert("Proxy '%s': unable to find required default_backend: '%s'.\n",
2621 curproxy->id, curproxy->defbe.name);
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002622 cfgerr++;
2623 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002624 ha_alert("Proxy '%s': loop detected for default_backend: '%s'.\n",
2625 curproxy->id, curproxy->defbe.name);
Willy Tarreaubb925012009-07-23 13:36:36 +02002626 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002627 } else if (target->mode != curproxy->mode &&
2628 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2629
Christopher Faulet767a84b2017-11-24 16:50:31 +01002630 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) as its default backend (see 'mode').\n",
2631 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2632 curproxy->conf.file, curproxy->conf.line,
2633 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2634 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002635 cfgerr++;
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002636 } else {
2637 free(curproxy->defbe.name);
2638 curproxy->defbe.be = target;
Willy Tarreauff678132012-02-13 14:32:34 +01002639 /* Emit a warning if this proxy also has some servers */
2640 if (curproxy->srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002641 ha_warning("In proxy '%s', the 'default_backend' rule always has precedence over the servers, which will never be used.\n",
2642 curproxy->id);
Willy Tarreauff678132012-02-13 14:32:34 +01002643 err_code |= ERR_WARN;
2644 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002645 }
2646 }
2647
Willy Tarreau55ea7572007-06-17 19:56:27 +02002648 /* find the target proxy for 'use_backend' rules */
2649 list_for_each_entry(rule, &curproxy->switching_rules, list) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002650 struct proxy *target;
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002651 struct logformat_node *node;
2652 char *pxname;
2653
2654 /* Try to parse the string as a log format expression. If the result
2655 * of the parsing is only one entry containing a simple string, then
2656 * it's a standard string corresponding to a static rule, thus the
2657 * parsing is cancelled and be.name is restored to be resolved.
2658 */
2659 pxname = rule->be.name;
2660 LIST_INIT(&rule->be.expr);
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +01002661 curproxy->conf.args.ctx = ARGC_UBK;
2662 curproxy->conf.args.file = rule->file;
2663 curproxy->conf.args.line = rule->line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002664 err = NULL;
2665 if (!parse_logformat_string(pxname, curproxy, &rule->be.expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002666 ha_alert("Parsing [%s:%d]: failed to parse use_backend rule '%s' : %s.\n",
2667 rule->file, rule->line, pxname, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002668 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002669 cfgerr++;
2670 continue;
2671 }
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002672 node = LIST_NEXT(&rule->be.expr, struct logformat_node *, list);
2673
2674 if (!LIST_ISEMPTY(&rule->be.expr)) {
2675 if (node->type != LOG_FMT_TEXT || node->list.n != &rule->be.expr) {
2676 rule->dynamic = 1;
2677 free(pxname);
2678 continue;
2679 }
2680 /* simple string: free the expression and fall back to static rule */
2681 free(node->arg);
2682 free(node);
2683 }
2684
2685 rule->dynamic = 0;
2686 rule->be.name = pxname;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002687
Willy Tarreauafb39922015-05-26 12:04:09 +02002688 target = proxy_be_by_name(rule->be.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002689 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002690 ha_alert("Proxy '%s': unable to find required use_backend: '%s'.\n",
2691 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002692 cfgerr++;
2693 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002694 ha_alert("Proxy '%s': loop detected for use_backend: '%s'.\n",
2695 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002696 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002697 } else if (target->mode != curproxy->mode &&
2698 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2699
Christopher Faulet767a84b2017-11-24 16:50:31 +01002700 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) in a 'use_backend' rule (see 'mode').\n",
2701 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2702 curproxy->conf.file, curproxy->conf.line,
2703 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2704 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002705 cfgerr++;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002706 } else {
2707 free((void *)rule->be.name);
2708 rule->be.backend = target;
2709 }
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002710 }
2711
Willy Tarreau64ab6072014-09-16 12:17:36 +02002712 /* find the target server for 'use_server' rules */
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002713 list_for_each_entry(srule, &curproxy->server_rules, list) {
Jerome Magnin824186b2020-03-29 09:37:12 +02002714 struct server *target;
2715 struct logformat_node *node;
2716 char *server_name;
2717
2718 /* We try to parse the string as a log format expression. If the result of the parsing
2719 * is only one entry containing a single string, then it's a standard string corresponding
2720 * to a static rule, thus the parsing is cancelled and we fall back to setting srv.ptr.
2721 */
2722 server_name = srule->srv.name;
2723 LIST_INIT(&srule->expr);
2724 curproxy->conf.args.ctx = ARGC_USRV;
2725 err = NULL;
2726 if (!parse_logformat_string(server_name, curproxy, &srule->expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
2727 ha_alert("Parsing [%s:%d]; use-server rule failed to parse log-format '%s' : %s.\n",
2728 srule->file, srule->line, server_name, err);
2729 free(err);
2730 cfgerr++;
2731 continue;
2732 }
2733 node = LIST_NEXT(&srule->expr, struct logformat_node *, list);
2734
2735 if (!LIST_ISEMPTY(&srule->expr)) {
2736 if (node->type != LOG_FMT_TEXT || node->list.n != &srule->expr) {
2737 srule->dynamic = 1;
2738 free(server_name);
2739 continue;
2740 }
2741 free(node->arg);
2742 free(node);
2743 }
2744
2745 srule->dynamic = 0;
2746 srule->srv.name = server_name;
2747 target = findserver(curproxy, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002748
2749 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002750 ha_alert("config : %s '%s' : unable to find server '%s' referenced in a 'use-server' rule.\n",
2751 proxy_type_str(curproxy), curproxy->id, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002752 cfgerr++;
2753 continue;
2754 }
2755 free((void *)srule->srv.name);
2756 srule->srv.ptr = target;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002757 }
2758
Emeric Brunb982a3d2010-01-04 15:45:53 +01002759 /* find the target table for 'stick' rules */
2760 list_for_each_entry(mrule, &curproxy->sticking_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002761 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002762
Emeric Brun1d33b292010-01-04 15:47:17 +01002763 curproxy->be_req_ana |= AN_REQ_STICKING_RULES;
2764 if (mrule->flags & STK_IS_STORE)
2765 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2766
Emeric Brunb982a3d2010-01-04 15:45:53 +01002767 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002768 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002769 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002770 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002771
2772 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002773 ha_alert("Proxy '%s': unable to find stick-table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01002774 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002775 cfgerr++;
2776 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002777 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002778 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2779 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002780 cfgerr++;
2781 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002782 else if (target->proxy && curproxy->bind_proc & ~target->proxy->bind_proc) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002783 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2784 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002785 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002786 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002787 else {
2788 free((void *)mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002789 mrule->table.t = target;
2790 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Frédéric Lécailledb52d902019-05-17 10:12:52 +02002791 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_NAME, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02002792 if (!in_proxies_list(target->proxies_list, curproxy)) {
2793 curproxy->next_stkt_ref = target->proxies_list;
2794 target->proxies_list = curproxy;
2795 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002796 }
2797 }
2798
2799 /* find the target table for 'store response' rules */
2800 list_for_each_entry(mrule, &curproxy->storersp_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002801 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002802
Emeric Brun1d33b292010-01-04 15:47:17 +01002803 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2804
Emeric Brunb982a3d2010-01-04 15:45:53 +01002805 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002806 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002807 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002808 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002809
2810 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002811 ha_alert("Proxy '%s': unable to find store table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01002812 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002813 cfgerr++;
2814 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002815 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002816 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2817 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002818 cfgerr++;
2819 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002820 else if (target->proxy && (curproxy->bind_proc & ~target->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002821 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2822 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002823 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002824 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002825 else {
2826 free((void *)mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002827 mrule->table.t = target;
2828 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Frédéric Lécailledb52d902019-05-17 10:12:52 +02002829 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_NAME, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02002830 if (!in_proxies_list(target->proxies_list, curproxy)) {
2831 curproxy->next_stkt_ref = target->proxies_list;
2832 target->proxies_list = curproxy;
2833 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002834 }
2835 }
2836
Christopher Faulete4e830d2017-09-18 14:51:41 +02002837 /* check validity for 'tcp-request' layer 4 rules */
2838 list_for_each_entry(arule, &curproxy->tcp_req.l4_rules, list) {
2839 err = NULL;
2840 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002841 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002842 free(err);
Willy Tarreau5f53de72012-12-12 00:25:44 +01002843 cfgerr++;
2844 }
Willy Tarreaud1f96522010-08-03 19:34:32 +02002845 }
2846
Christopher Faulete4e830d2017-09-18 14:51:41 +02002847 /* check validity for 'tcp-request' layer 5 rules */
2848 list_for_each_entry(arule, &curproxy->tcp_req.l5_rules, list) {
2849 err = NULL;
2850 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002851 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002852 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002853 cfgerr++;
2854 }
2855 }
2856
Christopher Faulete4e830d2017-09-18 14:51:41 +02002857 /* check validity for 'tcp-request' layer 6 rules */
2858 list_for_each_entry(arule, &curproxy->tcp_req.inspect_rules, list) {
2859 err = NULL;
2860 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002861 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002862 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002863 cfgerr++;
2864 }
2865 }
2866
Christopher Faulete4e830d2017-09-18 14:51:41 +02002867 /* check validity for 'http-request' layer 7 rules */
2868 list_for_each_entry(arule, &curproxy->http_req_rules, list) {
2869 err = NULL;
2870 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002871 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002872 free(err);
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002873 cfgerr++;
2874 }
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002875 }
2876
Christopher Faulete4e830d2017-09-18 14:51:41 +02002877 /* check validity for 'http-response' layer 7 rules */
2878 list_for_each_entry(arule, &curproxy->http_res_rules, list) {
2879 err = NULL;
2880 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002881 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002882 free(err);
Willy Tarreau09448f72014-06-25 18:12:15 +02002883 cfgerr++;
2884 }
Willy Tarreau09448f72014-06-25 18:12:15 +02002885 }
2886
Christopher Faulet6d0c3df2020-01-22 09:26:35 +01002887 /* check validity for 'http-after-response' layer 7 rules */
2888 list_for_each_entry(arule, &curproxy->http_after_res_rules, list) {
2889 err = NULL;
2890 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
2891 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
2892 free(err);
2893 cfgerr++;
2894 }
2895 }
2896
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002897 if (curproxy->table && curproxy->table->peers.name) {
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002898 struct peers *curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002899
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002900 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002901 if (strcmp(curpeers->id, curproxy->table->peers.name) == 0) {
2902 free((void *)curproxy->table->peers.name);
2903 curproxy->table->peers.p = curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002904 break;
2905 }
2906 }
2907
2908 if (!curpeers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002909 ha_alert("Proxy '%s': unable to find sync peers '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002910 curproxy->id, curproxy->table->peers.name);
2911 free((void *)curproxy->table->peers.name);
2912 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002913 cfgerr++;
2914 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002915 else if (curpeers->state == PR_STSTOPPED) {
2916 /* silently disable this peers section */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002917 curproxy->table->peers.p = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002918 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002919 else if (!curpeers->peers_fe) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002920 ha_alert("Proxy '%s': unable to find local peer '%s' in peers section '%s'.\n",
2921 curproxy->id, localpeer, curpeers->id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002922 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002923 cfgerr++;
2924 }
2925 }
2926
Simon Horman9dc49962015-01-30 11:22:59 +09002927
2928 if (curproxy->email_alert.mailers.name) {
2929 struct mailers *curmailers = mailers;
2930
2931 for (curmailers = mailers; curmailers; curmailers = curmailers->next) {
Christopher Faulet0108bb32017-10-20 21:34:32 +02002932 if (!strcmp(curmailers->id, curproxy->email_alert.mailers.name))
Simon Horman9dc49962015-01-30 11:22:59 +09002933 break;
Simon Horman9dc49962015-01-30 11:22:59 +09002934 }
Simon Horman9dc49962015-01-30 11:22:59 +09002935 if (!curmailers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002936 ha_alert("Proxy '%s': unable to find mailers '%s'.\n",
2937 curproxy->id, curproxy->email_alert.mailers.name);
Simon Horman9dc49962015-01-30 11:22:59 +09002938 free_email_alert(curproxy);
2939 cfgerr++;
2940 }
Christopher Faulet0108bb32017-10-20 21:34:32 +02002941 else {
2942 err = NULL;
2943 if (init_email_alert(curmailers, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002944 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulet0108bb32017-10-20 21:34:32 +02002945 free(err);
2946 cfgerr++;
2947 }
2948 }
Simon Horman9dc49962015-01-30 11:22:59 +09002949 }
2950
Willy Tarreauee4f5f82019-10-09 09:59:22 +02002951 if (curproxy->uri_auth && curproxy->uri_auth != defproxy.uri_auth &&
Willy Tarreauff011f22011-01-06 17:51:27 +01002952 !LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules) &&
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002953 (curproxy->uri_auth->userlist || curproxy->uri_auth->auth_realm )) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002954 ha_alert("%s '%s': stats 'auth'/'realm' and 'http-request' can't be used at the same time.\n",
2955 "proxy", curproxy->id);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002956 cfgerr++;
2957 goto out_uri_auth_compat;
2958 }
2959
Willy Tarreauee4f5f82019-10-09 09:59:22 +02002960 if (curproxy->uri_auth && curproxy->uri_auth->userlist &&
2961 (curproxy->uri_auth != defproxy.uri_auth ||
2962 LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules))) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002963 const char *uri_auth_compat_req[10];
Thierry FOURNIERa28a9422015-08-04 19:35:46 +02002964 struct act_rule *rule;
Willy Tarreau95fa4692010-02-01 13:05:50 +01002965 int i = 0;
Willy Tarreau95fa4692010-02-01 13:05:50 +01002966 /* build the ACL condition from scratch. We're relying on anonymous ACLs for that */
2967 uri_auth_compat_req[i++] = "auth";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002968
2969 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002970 uri_auth_compat_req[i++] = "realm";
2971 uri_auth_compat_req[i++] = curproxy->uri_auth->auth_realm;
2972 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002973
Willy Tarreau95fa4692010-02-01 13:05:50 +01002974 uri_auth_compat_req[i++] = "unless";
2975 uri_auth_compat_req[i++] = "{";
2976 uri_auth_compat_req[i++] = "http_auth(.internal-stats-userlist)";
2977 uri_auth_compat_req[i++] = "}";
2978 uri_auth_compat_req[i++] = "";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002979
Willy Tarreauff011f22011-01-06 17:51:27 +01002980 rule = parse_http_req_cond(uri_auth_compat_req, "internal-stats-auth-compat", 0, curproxy);
2981 if (!rule) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002982 cfgerr++;
2983 break;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002984 }
2985
Willy Tarreauff011f22011-01-06 17:51:27 +01002986 LIST_ADDQ(&curproxy->uri_auth->http_req_rules, &rule->list);
Willy Tarreau95fa4692010-02-01 13:05:50 +01002987
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002988 if (curproxy->uri_auth->auth_realm) {
2989 free(curproxy->uri_auth->auth_realm);
2990 curproxy->uri_auth->auth_realm = NULL;
2991 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002992 }
2993out_uri_auth_compat:
2994
Dragan Dosen43885c72015-10-01 13:18:13 +02002995 /* check whether we have a log server that uses RFC5424 log format */
Dragan Dosen1322d092015-09-22 16:05:32 +02002996 list_for_each_entry(tmplogsrv, &curproxy->logsrvs, list) {
Dragan Dosen43885c72015-10-01 13:18:13 +02002997 if (tmplogsrv->format == LOG_FORMAT_RFC5424) {
2998 if (!curproxy->conf.logformat_sd_string) {
2999 /* set the default logformat_sd_string */
3000 curproxy->conf.logformat_sd_string = default_rfc5424_sd_log_format;
3001 }
Dragan Dosen1322d092015-09-22 16:05:32 +02003002 break;
Dragan Dosen1322d092015-09-22 16:05:32 +02003003 }
Dragan Dosen1322d092015-09-22 16:05:32 +02003004 }
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02003005
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003006 /* compile the log format */
3007 if (!(curproxy->cap & PR_CAP_FE)) {
Willy Tarreau62a61232013-04-12 18:13:46 +02003008 if (curproxy->conf.logformat_string != default_http_log_format &&
3009 curproxy->conf.logformat_string != default_tcp_log_format &&
3010 curproxy->conf.logformat_string != clf_http_log_format)
3011 free(curproxy->conf.logformat_string);
3012 curproxy->conf.logformat_string = NULL;
3013 free(curproxy->conf.lfs_file);
3014 curproxy->conf.lfs_file = NULL;
3015 curproxy->conf.lfs_line = 0;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003016
3017 if (curproxy->conf.logformat_sd_string != default_rfc5424_sd_log_format)
3018 free(curproxy->conf.logformat_sd_string);
3019 curproxy->conf.logformat_sd_string = NULL;
3020 free(curproxy->conf.lfsd_file);
3021 curproxy->conf.lfsd_file = NULL;
3022 curproxy->conf.lfsd_line = 0;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003023 }
3024
Willy Tarreau62a61232013-04-12 18:13:46 +02003025 if (curproxy->conf.logformat_string) {
3026 curproxy->conf.args.ctx = ARGC_LOG;
3027 curproxy->conf.args.file = curproxy->conf.lfs_file;
3028 curproxy->conf.args.line = curproxy->conf.lfs_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003029 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003030 if (!parse_logformat_string(curproxy->conf.logformat_string, curproxy, &curproxy->logformat, LOG_OPT_MANDATORY,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003031 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003032 ha_alert("Parsing [%s:%d]: failed to parse log-format : %s.\n",
3033 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003034 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003035 cfgerr++;
3036 }
Willy Tarreau62a61232013-04-12 18:13:46 +02003037 curproxy->conf.args.file = NULL;
3038 curproxy->conf.args.line = 0;
3039 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003040
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003041 if (curproxy->conf.logformat_sd_string) {
3042 curproxy->conf.args.ctx = ARGC_LOGSD;
3043 curproxy->conf.args.file = curproxy->conf.lfsd_file;
3044 curproxy->conf.args.line = curproxy->conf.lfsd_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003045 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003046 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 +01003047 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003048 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
3049 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003050 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003051 cfgerr++;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003052 } else if (!add_to_logformat_list(NULL, NULL, LF_SEPARATOR, &curproxy->logformat_sd, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003053 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
3054 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003055 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003056 cfgerr++;
3057 }
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003058 curproxy->conf.args.file = NULL;
3059 curproxy->conf.args.line = 0;
3060 }
3061
Willy Tarreau62a61232013-04-12 18:13:46 +02003062 if (curproxy->conf.uniqueid_format_string) {
3063 curproxy->conf.args.ctx = ARGC_UIF;
3064 curproxy->conf.args.file = curproxy->conf.uif_file;
3065 curproxy->conf.args.line = curproxy->conf.uif_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003066 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003067 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 +01003068 (curproxy->cap & PR_CAP_FE) ? SMP_VAL_FE_HRQ_HDR : SMP_VAL_BE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003069 ha_alert("Parsing [%s:%d]: failed to parse unique-id : %s.\n",
3070 curproxy->conf.uif_file, curproxy->conf.uif_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01003071 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01003072 cfgerr++;
3073 }
Willy Tarreau62a61232013-04-12 18:13:46 +02003074 curproxy->conf.args.file = NULL;
3075 curproxy->conf.args.line = 0;
3076 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003077
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01003078 /* only now we can check if some args remain unresolved.
3079 * This must be done after the users and groups resolution.
3080 */
Willy Tarreaua4312fa2013-04-02 16:34:32 +02003081 cfgerr += smp_resolve_args(curproxy);
3082 if (!cfgerr)
3083 cfgerr += acl_find_targets(curproxy);
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01003084
Willy Tarreau2738a142006-07-08 17:28:09 +02003085 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003086 (((curproxy->cap & PR_CAP_FE) && !curproxy->timeout.client) ||
Willy Tarreaud825eef2007-05-12 22:35:00 +02003087 ((curproxy->cap & PR_CAP_BE) && (curproxy->srv) &&
Willy Tarreauce887fd2012-05-12 12:50:00 +02003088 (!curproxy->timeout.connect ||
3089 (!curproxy->timeout.server && (curproxy->mode == PR_MODE_HTTP || !curproxy->timeout.tunnel)))))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003090 ha_warning("config : missing timeouts for %s '%s'.\n"
3091 " | While not properly invalid, you will certainly encounter various problems\n"
3092 " | with such a configuration. To fix this, please ensure that all following\n"
3093 " | timeouts are set to a non-zero value: 'client', 'connect', 'server'.\n",
3094 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003095 err_code |= ERR_WARN;
Willy Tarreau2738a142006-07-08 17:28:09 +02003096 }
Willy Tarreauf3c69202006-07-09 16:42:34 +02003097
Willy Tarreau1fa31262007-12-03 00:36:16 +01003098 /* Historically, the tarpit and queue timeouts were inherited from contimeout.
3099 * We must still support older configurations, so let's find out whether those
3100 * parameters have been set or must be copied from contimeouts.
3101 */
3102 if (curproxy != &defproxy) {
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003103 if (!curproxy->timeout.tarpit ||
3104 curproxy->timeout.tarpit == defproxy.timeout.tarpit) {
Willy Tarreau1fa31262007-12-03 00:36:16 +01003105 /* tarpit timeout not set. We search in the following order:
3106 * default.tarpit, curr.connect, default.connect.
3107 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003108 if (defproxy.timeout.tarpit)
Willy Tarreau1fa31262007-12-03 00:36:16 +01003109 curproxy->timeout.tarpit = defproxy.timeout.tarpit;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003110 else if (curproxy->timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003111 curproxy->timeout.tarpit = curproxy->timeout.connect;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003112 else if (defproxy.timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003113 curproxy->timeout.tarpit = defproxy.timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01003114 }
3115 if ((curproxy->cap & PR_CAP_BE) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003116 (!curproxy->timeout.queue ||
3117 curproxy->timeout.queue == defproxy.timeout.queue)) {
Willy Tarreau1fa31262007-12-03 00:36:16 +01003118 /* queue timeout not set. We search in the following order:
3119 * default.queue, curr.connect, default.connect.
3120 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003121 if (defproxy.timeout.queue)
Willy Tarreau1fa31262007-12-03 00:36:16 +01003122 curproxy->timeout.queue = defproxy.timeout.queue;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003123 else if (curproxy->timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003124 curproxy->timeout.queue = curproxy->timeout.connect;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003125 else if (defproxy.timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003126 curproxy->timeout.queue = defproxy.timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01003127 }
3128 }
3129
Willy Tarreau1620ec32011-08-06 17:05:02 +02003130 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_SSL3_CHK) {
Willy Tarreau137325d2010-02-01 16:38:17 +01003131 curproxy->check_len = sizeof(sslv3_client_hello_pkt) - 1;
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003132 curproxy->check_req = malloc(curproxy->check_len);
Willy Tarreau137325d2010-02-01 16:38:17 +01003133 memcpy(curproxy->check_req, sslv3_client_hello_pkt, curproxy->check_len);
Willy Tarreauf3c69202006-07-09 16:42:34 +02003134 }
3135
Willy Tarreau215663d2014-06-13 18:30:23 +02003136 if (!LIST_ISEMPTY(&curproxy->tcpcheck_rules) &&
3137 (curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_TCPCHK_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003138 ha_warning("config : %s '%s' uses tcp-check rules without 'option tcp-check', so the rules are ignored.\n",
3139 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau215663d2014-06-13 18:30:23 +02003140 err_code |= ERR_WARN;
3141 }
3142
Willy Tarreau193b8c62012-11-22 00:17:38 +01003143 /* ensure that cookie capture length is not too large */
3144 if (curproxy->capture_len >= global.tune.cookie_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003145 ha_warning("config : truncating capture length to %d bytes for %s '%s'.\n",
3146 global.tune.cookie_len - 1, proxy_type_str(curproxy), curproxy->id);
Willy Tarreau193b8c62012-11-22 00:17:38 +01003147 err_code |= ERR_WARN;
3148 curproxy->capture_len = global.tune.cookie_len - 1;
3149 }
3150
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003151 /* The small pools required for the capture lists */
Willy Tarreau9a54e132012-03-24 08:33:05 +01003152 if (curproxy->nb_req_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003153 curproxy->req_cap_pool = create_pool("ptrcap",
3154 curproxy->nb_req_cap * sizeof(char *),
3155 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003156 }
3157
3158 if (curproxy->nb_rsp_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003159 curproxy->rsp_cap_pool = create_pool("ptrcap",
3160 curproxy->nb_rsp_cap * sizeof(char *),
3161 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003162 }
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003163
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003164 switch (curproxy->load_server_state_from_file) {
3165 case PR_SRV_STATE_FILE_UNSPEC:
3166 curproxy->load_server_state_from_file = PR_SRV_STATE_FILE_NONE;
3167 break;
3168 case PR_SRV_STATE_FILE_GLOBAL:
3169 if (!global.server_state_file) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003170 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",
3171 curproxy->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003172 err_code |= ERR_WARN;
3173 }
3174 break;
3175 }
3176
Willy Tarreaubaaee002006-06-26 02:48:02 +02003177 /* first, we will invert the servers list order */
3178 newsrv = NULL;
3179 while (curproxy->srv) {
3180 struct server *next;
3181
3182 next = curproxy->srv->next;
3183 curproxy->srv->next = newsrv;
3184 newsrv = curproxy->srv;
3185 if (!next)
3186 break;
3187 curproxy->srv = next;
3188 }
3189
Willy Tarreau17edc812014-01-03 12:14:34 +01003190 /* Check that no server name conflicts. This causes trouble in the stats.
3191 * We only emit a warning for the first conflict affecting each server,
3192 * in order to avoid combinatory explosion if all servers have the same
3193 * name. We do that only for servers which do not have an explicit ID,
3194 * because these IDs were made also for distinguishing them and we don't
3195 * want to annoy people who correctly manage them.
3196 */
3197 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3198 struct server *other_srv;
3199
3200 if (newsrv->puid)
3201 continue;
3202
3203 for (other_srv = curproxy->srv; other_srv && other_srv != newsrv; other_srv = other_srv->next) {
3204 if (!other_srv->puid && strcmp(other_srv->id, newsrv->id) == 0) {
Willy Tarreaub01302f2019-05-27 19:31:06 +02003205 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 +01003206 newsrv->conf.file, newsrv->conf.line,
3207 proxy_type_str(curproxy), curproxy->id,
3208 newsrv->id, other_srv->conf.line);
Willy Tarreaub01302f2019-05-27 19:31:06 +02003209 cfgerr++;
Willy Tarreau17edc812014-01-03 12:14:34 +01003210 break;
3211 }
3212 }
3213 }
3214
Willy Tarreaudd701652010-05-25 23:03:02 +02003215 /* assign automatic UIDs to servers which don't have one yet */
3216 next_id = 1;
3217 newsrv = curproxy->srv;
3218 while (newsrv != NULL) {
3219 if (!newsrv->puid) {
3220 /* server ID not set, use automatic numbering with first
3221 * spare entry starting with next_svid.
3222 */
3223 next_id = get_next_id(&curproxy->conf.used_server_id, next_id);
3224 newsrv->conf.id.key = newsrv->puid = next_id;
3225 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Frédéric Lécaille84d60462019-05-17 14:29:15 +02003226 newsrv->conf.name.key = newsrv->id;
3227 ebis_insert(&curproxy->conf.used_server_name, &newsrv->conf.name);
Willy Tarreaudd701652010-05-25 23:03:02 +02003228 }
3229 next_id++;
3230 newsrv = newsrv->next;
3231 }
3232
Willy Tarreau20697042007-11-15 23:26:18 +01003233 curproxy->lbprm.wmult = 1; /* default weight multiplier */
Willy Tarreau5dc2fa62007-11-19 19:10:18 +01003234 curproxy->lbprm.wdiv = 1; /* default weight divider */
Willy Tarreaubaaee002006-06-26 02:48:02 +02003235
Willy Tarreau62c3be22012-01-20 13:12:32 +01003236 /*
3237 * If this server supports a maxconn parameter, it needs a dedicated
3238 * tasks to fill the emptied slots when a connection leaves.
3239 * Also, resolve deferred tracking dependency if needed.
3240 */
3241 newsrv = curproxy->srv;
3242 while (newsrv != NULL) {
3243 if (newsrv->minconn > newsrv->maxconn) {
3244 /* Only 'minconn' was specified, or it was higher than or equal
3245 * to 'maxconn'. Let's turn this into maxconn and clean it, as
3246 * this will avoid further useless expensive computations.
3247 */
3248 newsrv->maxconn = newsrv->minconn;
3249 } else if (newsrv->maxconn && !newsrv->minconn) {
3250 /* minconn was not specified, so we set it to maxconn */
3251 newsrv->minconn = newsrv->maxconn;
3252 }
3253
Willy Tarreau17d45382016-12-22 21:16:08 +01003254 /* this will also properly set the transport layer for prod and checks */
3255 if (newsrv->use_ssl || newsrv->check.use_ssl) {
3256 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
3257 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(newsrv);
3258 }
Emeric Brun94324a42012-10-11 14:00:19 +02003259
Willy Tarreau034c88c2017-01-23 23:36:45 +01003260 if ((newsrv->flags & SRV_F_FASTOPEN) &&
3261 ((curproxy->retry_type & (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)) !=
3262 (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)))
3263 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",
3264 newsrv->conf.file, newsrv->conf.line,
3265 proxy_type_str(curproxy), curproxy->id,
3266 newsrv->id);
3267
Willy Tarreau2f075e92013-12-03 11:11:34 +01003268 /* set the check type on the server */
3269 newsrv->check.type = curproxy->options2 & PR_O2_CHK_ANY;
3270
Willy Tarreau62c3be22012-01-20 13:12:32 +01003271 if (newsrv->trackit) {
3272 struct proxy *px;
Willy Tarreau32091232014-05-16 13:52:00 +02003273 struct server *srv, *loop;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003274 char *pname, *sname;
3275
3276 pname = newsrv->trackit;
3277 sname = strrchr(pname, '/');
3278
3279 if (sname)
3280 *sname++ = '\0';
3281 else {
3282 sname = pname;
3283 pname = NULL;
3284 }
3285
3286 if (pname) {
Willy Tarreau9e0bb102015-05-26 11:24:42 +02003287 px = proxy_be_by_name(pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003288 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003289 ha_alert("config : %s '%s', server '%s': unable to find required proxy '%s' for tracking.\n",
3290 proxy_type_str(curproxy), curproxy->id,
3291 newsrv->id, pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003292 cfgerr++;
3293 goto next_srv;
3294 }
3295 } else
3296 px = curproxy;
3297
3298 srv = findserver(px, sname);
3299 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003300 ha_alert("config : %s '%s', server '%s': unable to find required server '%s' for tracking.\n",
3301 proxy_type_str(curproxy), curproxy->id,
3302 newsrv->id, sname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003303 cfgerr++;
3304 goto next_srv;
3305 }
3306
Willy Tarreau32091232014-05-16 13:52:00 +02003307 if (!(srv->check.state & CHK_ST_CONFIGURED) &&
3308 !(srv->agent.state & CHK_ST_CONFIGURED) &&
3309 !srv->track && !srv->trackit) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003310 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for "
3311 "tracking as it does not have any check nor agent enabled.\n",
3312 proxy_type_str(curproxy), curproxy->id,
3313 newsrv->id, px->id, srv->id);
Willy Tarreau32091232014-05-16 13:52:00 +02003314 cfgerr++;
3315 goto next_srv;
3316 }
3317
3318 for (loop = srv->track; loop && loop != newsrv; loop = loop->track);
3319
Frédéric Lécaille2efc6492017-03-14 14:32:17 +01003320 if (newsrv == srv || loop) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003321 ha_alert("config : %s '%s', server '%s': unable to track %s/%s as it "
3322 "belongs to a tracking chain looping back to %s/%s.\n",
3323 proxy_type_str(curproxy), curproxy->id,
3324 newsrv->id, px->id, srv->id, px->id,
3325 newsrv == srv ? srv->id : loop->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003326 cfgerr++;
3327 goto next_srv;
3328 }
3329
3330 if (curproxy != px &&
3331 (curproxy->options & PR_O_DISABLE404) != (px->options & PR_O_DISABLE404)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003332 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for"
3333 "tracking: disable-on-404 option inconsistency.\n",
3334 proxy_type_str(curproxy), curproxy->id,
3335 newsrv->id, px->id, srv->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003336 cfgerr++;
3337 goto next_srv;
3338 }
3339
Willy Tarreau62c3be22012-01-20 13:12:32 +01003340 newsrv->track = srv;
Willy Tarreau1a53a3a2013-12-11 15:27:05 +01003341 newsrv->tracknext = srv->trackers;
3342 srv->trackers = newsrv;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003343
3344 free(newsrv->trackit);
3345 newsrv->trackit = NULL;
3346 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003347
Willy Tarreau62c3be22012-01-20 13:12:32 +01003348 next_srv:
3349 newsrv = newsrv->next;
3350 }
3351
Olivier Houchard4e694042017-03-14 20:01:29 +01003352 /*
3353 * Try to generate dynamic cookies for servers now.
3354 * It couldn't be done earlier, since at the time we parsed
3355 * the server line, we may not have known yet that we
3356 * should use dynamic cookies, or the secret key may not
3357 * have been provided yet.
3358 */
3359 if (curproxy->ck_opts & PR_CK_DYNAMIC) {
3360 newsrv = curproxy->srv;
3361 while (newsrv != NULL) {
3362 srv_set_dyncookie(newsrv);
3363 newsrv = newsrv->next;
3364 }
3365
3366 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003367 /* We have to initialize the server lookup mechanism depending
Joseph Herlanta14c03e2018-11-15 14:04:19 -08003368 * on what LB algorithm was chosen.
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003369 */
3370
3371 curproxy->lbprm.algo &= ~(BE_LB_LKUP | BE_LB_PROP_DYN);
3372 switch (curproxy->lbprm.algo & BE_LB_KIND) {
3373 case BE_LB_KIND_RR:
Willy Tarreau9757a382009-10-03 12:56:50 +02003374 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_STATIC) {
3375 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3376 init_server_map(curproxy);
Willy Tarreau760e81d2018-05-03 07:20:40 +02003377 } else if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_RANDOM) {
3378 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3379 chash_init_server_tree(curproxy);
Willy Tarreau9757a382009-10-03 12:56:50 +02003380 } else {
3381 curproxy->lbprm.algo |= BE_LB_LKUP_RRTREE | BE_LB_PROP_DYN;
3382 fwrr_init_server_groups(curproxy);
3383 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003384 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003385
Willy Tarreau3ebb1162012-02-13 16:57:44 +01003386 case BE_LB_KIND_CB:
Willy Tarreauf09c6602012-02-13 17:12:08 +01003387 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_CB_LC) {
3388 curproxy->lbprm.algo |= BE_LB_LKUP_LCTREE | BE_LB_PROP_DYN;
3389 fwlc_init_server_tree(curproxy);
3390 } else {
3391 curproxy->lbprm.algo |= BE_LB_LKUP_FSTREE | BE_LB_PROP_DYN;
3392 fas_init_server_tree(curproxy);
3393 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003394 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003395
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003396 case BE_LB_KIND_HI:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003397 if ((curproxy->lbprm.algo & BE_LB_HASH_TYPE) == BE_LB_HASH_CONS) {
3398 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3399 chash_init_server_tree(curproxy);
3400 } else {
3401 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3402 init_server_map(curproxy);
3403 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003404 break;
3405 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003406 HA_SPIN_INIT(&curproxy->lbprm.lock);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003407
3408 if (curproxy->options & PR_O_LOGASAP)
3409 curproxy->to_log &= ~LW_BYTES;
3410
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003411 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003412 (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->logsrvs) &&
3413 (!LIST_ISEMPTY(&curproxy->logformat) || !LIST_ISEMPTY(&curproxy->logformat_sd))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003414 ha_warning("config : log format ignored for %s '%s' since it has no log address.\n",
3415 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003416 err_code |= ERR_WARN;
3417 }
3418
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003419 if (curproxy->mode != PR_MODE_HTTP) {
3420 int optnum;
3421
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003422 if (curproxy->uri_auth) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003423 ha_warning("config : 'stats' statement ignored for %s '%s' as it requires HTTP mode.\n",
3424 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003425 err_code |= ERR_WARN;
3426 curproxy->uri_auth = NULL;
3427 }
3428
Willy Tarreaude7dc882017-03-10 11:49:21 +01003429 if (curproxy->capture_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003430 ha_warning("config : 'capture' statement ignored for %s '%s' as it requires HTTP mode.\n",
3431 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003432 err_code |= ERR_WARN;
3433 }
3434
3435 if (!LIST_ISEMPTY(&curproxy->http_req_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003436 ha_warning("config : 'http-request' rules ignored for %s '%s' as they require HTTP mode.\n",
3437 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003438 err_code |= ERR_WARN;
3439 }
3440
3441 if (!LIST_ISEMPTY(&curproxy->http_res_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003442 ha_warning("config : 'http-response' rules ignored for %s '%s' as they require HTTP mode.\n",
3443 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003444 err_code |= ERR_WARN;
3445 }
3446
Willy Tarreaude7dc882017-03-10 11:49:21 +01003447 if (!LIST_ISEMPTY(&curproxy->redirect_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003448 ha_warning("config : 'redirect' rules ignored for %s '%s' as they require HTTP mode.\n",
3449 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003450 err_code |= ERR_WARN;
3451 }
3452
Willy Tarreau87cf5142011-08-19 22:57:24 +02003453 if (curproxy->options & (PR_O_FWDFOR | PR_O_FF_ALWAYS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003454 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3455 "forwardfor", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003456 err_code |= ERR_WARN;
Willy Tarreau87cf5142011-08-19 22:57:24 +02003457 curproxy->options &= ~(PR_O_FWDFOR | PR_O_FF_ALWAYS);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003458 }
3459
3460 if (curproxy->options & PR_O_ORGTO) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003461 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3462 "originalto", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003463 err_code |= ERR_WARN;
3464 curproxy->options &= ~PR_O_ORGTO;
3465 }
3466
3467 for (optnum = 0; cfg_opts[optnum].name; optnum++) {
3468 if (cfg_opts[optnum].mode == PR_MODE_HTTP &&
3469 (curproxy->cap & cfg_opts[optnum].cap) &&
3470 (curproxy->options & cfg_opts[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003471 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3472 cfg_opts[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003473 err_code |= ERR_WARN;
3474 curproxy->options &= ~cfg_opts[optnum].val;
3475 }
3476 }
3477
3478 for (optnum = 0; cfg_opts2[optnum].name; optnum++) {
3479 if (cfg_opts2[optnum].mode == PR_MODE_HTTP &&
3480 (curproxy->cap & cfg_opts2[optnum].cap) &&
3481 (curproxy->options2 & cfg_opts2[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003482 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3483 cfg_opts2[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003484 err_code |= ERR_WARN;
3485 curproxy->options2 &= ~cfg_opts2[optnum].val;
3486 }
3487 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003488
Willy Tarreau29fbe512015-08-20 19:35:14 +02003489#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003490 if (curproxy->conn_src.bind_hdr_occ) {
3491 curproxy->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003492 ha_warning("config : %s '%s' : ignoring use of header %s as source IP in non-HTTP mode.\n",
3493 proxy_type_str(curproxy), curproxy->id, curproxy->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003494 err_code |= ERR_WARN;
3495 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003496#endif
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003497 }
3498
Willy Tarreaubaaee002006-06-26 02:48:02 +02003499 /*
Willy Tarreau21d2af32008-02-14 20:25:24 +01003500 * ensure that we're not cross-dressing a TCP server into HTTP.
3501 */
3502 newsrv = curproxy->srv;
3503 while (newsrv != NULL) {
Willy Tarreau0cec3312011-10-31 13:49:26 +01003504 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->rdr_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003505 ha_alert("config : %s '%s' : server cannot have cookie or redirect prefix in non-HTTP mode.\n",
3506 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003507 cfgerr++;
Willy Tarreau21d2af32008-02-14 20:25:24 +01003508 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003509
Willy Tarreau0cec3312011-10-31 13:49:26 +01003510 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->cklen) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003511 ha_warning("config : %s '%s' : ignoring cookie for server '%s' as HTTP mode is disabled.\n",
3512 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau0cec3312011-10-31 13:49:26 +01003513 err_code |= ERR_WARN;
3514 }
3515
Willy Tarreauc93cd162014-05-13 15:54:22 +02003516 if ((newsrv->flags & SRV_F_MAPPORTS) && (curproxy->options2 & PR_O2_RDPC_PRST)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003517 ha_warning("config : %s '%s' : RDP cookie persistence will not work for server '%s' because it lacks an explicit port number.\n",
3518 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau82ffa392013-08-13 17:19:08 +02003519 err_code |= ERR_WARN;
3520 }
3521
Willy Tarreau29fbe512015-08-20 19:35:14 +02003522#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003523 if (curproxy->mode != PR_MODE_HTTP && newsrv->conn_src.bind_hdr_occ) {
3524 newsrv->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003525 ha_warning("config : %s '%s' : server %s cannot use header %s as source IP in non-HTTP mode.\n",
3526 proxy_type_str(curproxy), curproxy->id, newsrv->id, newsrv->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003527 err_code |= ERR_WARN;
3528 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003529#endif
Willy Tarreau4c183462017-01-06 12:21:38 +01003530
Willy Tarreau46deab62018-04-28 07:18:15 +02003531 if ((curproxy->mode != PR_MODE_HTTP) && (curproxy->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR)
3532 curproxy->options &= ~PR_O_REUSE_MASK;
3533
Willy Tarreau21d2af32008-02-14 20:25:24 +01003534 newsrv = newsrv->next;
3535 }
3536
Christopher Fauletd7c91962015-04-30 11:48:27 +02003537 /* Check filter configuration, if any */
3538 cfgerr += flt_check(curproxy);
3539
Willy Tarreauc1a21672009-08-16 22:37:44 +02003540 if (curproxy->cap & PR_CAP_FE) {
Willy Tarreau050536d2012-10-04 08:47:34 +02003541 if (!curproxy->accept)
3542 curproxy->accept = frontend_accept;
Willy Tarreau81f9aa32010-06-01 17:45:26 +02003543
Willy Tarreauc1a21672009-08-16 22:37:44 +02003544 if (curproxy->tcp_req.inspect_delay ||
3545 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
Willy Tarreaufb356202010-08-03 14:02:05 +02003546 curproxy->fe_req_ana |= AN_REQ_INSPECT_FE;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003547
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003548 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003549 curproxy->fe_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_PROCESS_FE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003550 curproxy->fe_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_FE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003551 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003552
William Lallemandcf62f7e2018-10-26 14:47:40 +02003553 if (curproxy->mode == PR_MODE_CLI) {
3554 curproxy->fe_req_ana |= AN_REQ_WAIT_CLI;
3555 curproxy->fe_rsp_ana |= AN_RES_WAIT_CLI;
3556 }
3557
Willy Tarreauc1a21672009-08-16 22:37:44 +02003558 /* both TCP and HTTP must check switching rules */
3559 curproxy->fe_req_ana |= AN_REQ_SWITCHING_RULES;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003560
3561 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003562 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003563 curproxy->fe_req_ana |= AN_REQ_FLT_START_FE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3564 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 +01003565 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003566 curproxy->fe_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3567 curproxy->fe_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003568 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003569 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003570 }
3571
3572 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreaufb356202010-08-03 14:02:05 +02003573 if (curproxy->tcp_req.inspect_delay ||
3574 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
3575 curproxy->be_req_ana |= AN_REQ_INSPECT_BE;
3576
Emeric Brun97679e72010-09-23 17:56:44 +02003577 if (!LIST_ISEMPTY(&curproxy->tcp_rep.inspect_rules))
3578 curproxy->be_rsp_ana |= AN_RES_INSPECT;
3579
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003580 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003581 curproxy->be_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_INNER | AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003582 curproxy->be_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_BE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003583 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003584
3585 /* If the backend does requires RDP cookie persistence, we have to
3586 * enable the corresponding analyser.
3587 */
3588 if (curproxy->options2 & PR_O2_RDPC_PRST)
3589 curproxy->be_req_ana |= AN_REQ_PRST_RDP_COOKIE;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003590
3591 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003592 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003593 curproxy->be_req_ana |= AN_REQ_FLT_START_BE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3594 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 +01003595 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003596 curproxy->be_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3597 curproxy->be_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003598 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003599 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003600 }
Christopher Fauleta717b992018-04-10 14:43:00 +02003601
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003602 /* Check the mux protocols, if any, for each listener and server
Christopher Fauleta717b992018-04-10 14:43:00 +02003603 * attached to the current proxy */
3604 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3605 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003606 const struct mux_proto_list *mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003607
3608 if (!bind_conf->mux_proto)
3609 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003610
3611 /* it is possible that an incorrect mux was referenced
3612 * due to the proxy's mode not being taken into account
3613 * on first pass. Let's adjust it now.
3614 */
3615 mux_ent = conn_get_best_mux_entry(bind_conf->mux_proto->token, PROTO_SIDE_FE, mode);
3616
3617 if (!mux_ent || !isteq(mux_ent->token, bind_conf->mux_proto->token)) {
Christopher Fauleta717b992018-04-10 14:43:00 +02003618 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for 'bind %s' at [%s:%d].\n",
3619 proxy_type_str(curproxy), curproxy->id,
3620 (int)bind_conf->mux_proto->token.len,
3621 bind_conf->mux_proto->token.ptr,
3622 bind_conf->arg, bind_conf->file, bind_conf->line);
3623 cfgerr++;
3624 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003625
3626 /* update the mux */
3627 bind_conf->mux_proto = mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003628 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003629 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3630 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003631 const struct mux_proto_list *mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003632
3633 if (!newsrv->mux_proto)
3634 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003635
3636 /* it is possible that an incorrect mux was referenced
3637 * due to the proxy's mode not being taken into account
3638 * on first pass. Let's adjust it now.
3639 */
3640 mux_ent = conn_get_best_mux_entry(newsrv->mux_proto->token, PROTO_SIDE_BE, mode);
3641
3642 if (!mux_ent || !isteq(mux_ent->token, newsrv->mux_proto->token)) {
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003643 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for server '%s' at [%s:%d].\n",
3644 proxy_type_str(curproxy), curproxy->id,
3645 (int)newsrv->mux_proto->token.len,
3646 newsrv->mux_proto->token.ptr,
3647 newsrv->id, newsrv->conf.file, newsrv->conf.line);
3648 cfgerr++;
3649 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003650
3651 /* update the mux */
3652 newsrv->mux_proto = mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003653 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003654
3655 /* initialize idle conns lists */
3656 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3657 int i;
3658
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003659 newsrv->available_conns = calloc((unsigned)global.nbthread, sizeof(*newsrv->available_conns));
Willy Tarreau835daa12019-02-07 14:46:29 +01003660
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003661 if (!newsrv->available_conns) {
Willy Tarreau835daa12019-02-07 14:46:29 +01003662 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003663 newsrv->conf.file, newsrv->conf.line, newsrv->id);
Willy Tarreau835daa12019-02-07 14:46:29 +01003664 cfgerr++;
3665 continue;
3666 }
3667
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003668 for (i = 0; i < global.nbthread; i++)
3669 LIST_INIT(&newsrv->available_conns[i]);
Willy Tarreau980855b2019-02-07 14:59:29 +01003670
3671 if (newsrv->max_idle_conns != 0) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003672 if (idle_conn_task == NULL) {
3673 idle_conn_task = task_new(MAX_THREADS_MASK);
3674 if (!idle_conn_task)
3675 goto err;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003676
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003677 idle_conn_task->process = srv_cleanup_idle_connections;
3678 idle_conn_task->context = NULL;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003679
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003680 for (i = 0; i < global.nbthread; i++) {
Willy Tarreaubbb5f1d2019-10-18 08:50:49 +02003681 idle_conn_cleanup[i] = task_new(1UL << i);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003682 if (!idle_conn_cleanup[i])
3683 goto err;
3684 idle_conn_cleanup[i]->process = srv_cleanup_toremove_connections;
3685 idle_conn_cleanup[i]->context = NULL;
Olivier Houchard859dc802019-08-08 15:47:21 +02003686 MT_LIST_INIT(&toremove_connections[i]);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003687 }
3688 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003689
3690 newsrv->idle_conns = calloc((unsigned)global.nbthread, sizeof(*newsrv->idle_conns));
3691 if (!newsrv->idle_conns) {
3692 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
3693 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3694 cfgerr++;
3695 continue;
3696 }
3697
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003698 for (i = 0; i < global.nbthread; i++)
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003699 MT_LIST_INIT(&newsrv->idle_conns[i]);
3700
3701 newsrv->safe_conns = calloc((unsigned)global.nbthread, sizeof(*newsrv->safe_conns));
3702 if (!newsrv->safe_conns) {
3703 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
3704 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3705 cfgerr++;
3706 continue;
3707 }
3708
3709 for (i = 0; i < global.nbthread; i++)
3710 MT_LIST_INIT(&newsrv->safe_conns[i]);
3711
3712 newsrv->curr_idle_thr = calloc(global.nbthread, sizeof(int));
Olivier Houchardf1314812019-02-18 16:41:17 +01003713 if (!newsrv->curr_idle_thr)
3714 goto err;
Willy Tarreau980855b2019-02-07 14:59:29 +01003715 continue;
3716 err:
3717 ha_alert("parsing [%s:%d] : failed to allocate idle connection tasks for server '%s'.\n",
3718 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3719 cfgerr++;
3720 continue;
3721 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003722 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003723 }
3724
3725 /***********************************************************/
3726 /* At this point, target names have already been resolved. */
3727 /***********************************************************/
3728
3729 /* Check multi-process mode compatibility */
3730
3731 if (global.nbproc > 1 && global.stats_fe) {
3732 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3733 unsigned long mask;
3734
Willy Tarreau6daac192019-02-02 17:39:53 +01003735 mask = proc_mask(global.stats_fe->bind_proc) && all_proc_mask;
3736 mask &= proc_mask(bind_conf->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003737
3738 /* stop here if more than one process is used */
Willy Tarreau9504dd62018-10-15 09:37:03 +02003739 if (atleast2(mask))
Willy Tarreau419ead82014-09-16 13:41:21 +02003740 break;
3741 }
3742 if (&bind_conf->by_fe != &global.stats_fe->conf.bind) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003743 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 +02003744 }
3745 }
3746
3747 /* Make each frontend inherit bind-process from its listeners when not specified. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003748 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003749 if (curproxy->bind_proc)
3750 continue;
3751
3752 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3753 unsigned long mask;
3754
Willy Tarreau6daac192019-02-02 17:39:53 +01003755 mask = proc_mask(bind_conf->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003756 curproxy->bind_proc |= mask;
3757 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003758 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003759 }
3760
3761 if (global.stats_fe) {
3762 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3763 unsigned long mask;
3764
Cyril Bonté06181952016-02-24 00:14:54 +01003765 mask = bind_conf->bind_proc ? bind_conf->bind_proc : 0;
Willy Tarreau419ead82014-09-16 13:41:21 +02003766 global.stats_fe->bind_proc |= mask;
3767 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003768 global.stats_fe->bind_proc = proc_mask(global.stats_fe->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003769 }
3770
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003771 /* propagate bindings from frontends to backends. Don't do it if there
3772 * are any fatal errors as we must not call it with unresolved proxies.
3773 */
3774 if (!cfgerr) {
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003775 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003776 if (curproxy->cap & PR_CAP_FE)
3777 propagate_processes(curproxy, NULL);
3778 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003779 }
3780
3781 /* Bind each unbound backend to all processes when not specified. */
Willy Tarreau6daac192019-02-02 17:39:53 +01003782 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
3783 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003784
3785 /*******************************************************/
3786 /* At this step, all proxies have a non-null bind_proc */
3787 /*******************************************************/
3788
3789 /* perform the final checks before creating tasks */
3790
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003791 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003792 struct listener *listener;
3793 unsigned int next_id;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003794
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003795 /* Configure SSL for each bind line.
3796 * Note: if configuration fails at some point, the ->ctx member
3797 * remains NULL so that listeners can later detach.
3798 */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003799 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau55d37912016-12-21 23:38:39 +01003800 if (bind_conf->xprt->prepare_bind_conf &&
3801 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003802 cfgerr++;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003803 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003804
Willy Tarreaue6b98942007-10-29 01:09:36 +01003805 /* adjust this proxy's listeners */
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003806 next_id = 1;
Willy Tarreau4348fad2012-09-20 16:48:07 +02003807 list_for_each_entry(listener, &curproxy->conf.listeners, by_fe) {
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003808 int nbproc;
3809
3810 nbproc = my_popcountl(curproxy->bind_proc &
Cyril Bonté4920d702016-04-15 07:58:43 +02003811 (listener->bind_conf->bind_proc ? listener->bind_conf->bind_proc : curproxy->bind_proc) &
Willy Tarreaua38a7172019-02-02 17:11:28 +01003812 all_proc_mask);
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003813
3814 if (!nbproc) /* no intersection between listener and frontend */
3815 nbproc = 1;
3816
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003817 if (!listener->luid) {
3818 /* listener ID not set, use automatic numbering with first
3819 * spare entry starting with next_luid.
3820 */
3821 next_id = get_next_id(&curproxy->conf.used_listener_id, next_id);
3822 listener->conf.id.key = listener->luid = next_id;
3823 eb32_insert(&curproxy->conf.used_listener_id, &listener->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003824 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01003825 next_id++;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003826
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003827 /* enable separate counters */
3828 if (curproxy->options2 & PR_O2_SOCKSTAT) {
Willy Tarreauae9bea02016-11-25 14:44:52 +01003829 listener->counters = calloc(1, sizeof(*listener->counters));
Willy Tarreau19d14ef2012-10-29 16:51:55 +01003830 if (!listener->name)
3831 memprintf(&listener->name, "sock-%d", listener->luid);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003832 }
Willy Tarreau81796be2012-09-22 19:11:47 +02003833
Willy Tarreaue6b98942007-10-29 01:09:36 +01003834 if (curproxy->options & PR_O_TCP_NOLING)
3835 listener->options |= LI_O_NOLINGER;
Willy Tarreau16a21472012-11-19 12:39:59 +01003836 if (!listener->maxaccept)
3837 listener->maxaccept = global.tune.maxaccept ? global.tune.maxaccept : 64;
3838
3839 /* we want to have an optimal behaviour on single process mode to
3840 * maximize the work at once, but in multi-process we want to keep
3841 * some fairness between processes, so we target half of the max
3842 * number of events to be balanced over all the processes the proxy
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05003843 * is bound to. Remember that maxaccept = -1 must be kept as it is
Willy Tarreau16a21472012-11-19 12:39:59 +01003844 * used to disable the limit.
3845 */
Christopher Faulet02f3cf12019-04-30 14:08:41 +02003846 if (listener->maxaccept > 0 && nbproc > 1) {
3847 listener->maxaccept = (listener->maxaccept + 1) / 2;
Willy Tarreau16a21472012-11-19 12:39:59 +01003848 listener->maxaccept = (listener->maxaccept + nbproc - 1) / nbproc;
3849 }
3850
Willy Tarreau9903f0e2015-04-04 18:50:31 +02003851 listener->accept = session_accept_fd;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003852 listener->analysers |= curproxy->fe_req_ana;
Willy Tarreau10b688f2015-03-13 16:43:12 +01003853 listener->default_target = curproxy->default_target;
Willy Tarreau3bc13772008-12-07 11:50:35 +01003854
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003855 if (!LIST_ISEMPTY(&curproxy->tcp_req.l4_rules))
Willy Tarreau7d9736f2016-10-21 16:34:21 +02003856 listener->options |= LI_O_TCP_L4_RULES;
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003857
Willy Tarreau620408f2016-10-21 16:37:51 +02003858 if (!LIST_ISEMPTY(&curproxy->tcp_req.l5_rules))
3859 listener->options |= LI_O_TCP_L5_RULES;
3860
Willy Tarreaude3041d2010-05-31 10:56:17 +02003861 if (curproxy->mon_mask.s_addr)
3862 listener->options |= LI_O_CHK_MONNET;
3863
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003864 /* smart accept mode is automatic in HTTP mode */
3865 if ((curproxy->options2 & PR_O2_SMARTACC) ||
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003866 ((curproxy->mode == PR_MODE_HTTP || listener->bind_conf->is_ssl) &&
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003867 !(curproxy->no_options2 & PR_O2_SMARTACC)))
3868 listener->options |= LI_O_NOQUICKACK;
Willy Tarreaue6b98942007-10-29 01:09:36 +01003869 }
3870
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003871 /* Release unused SSL configs */
3872 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau795cdab2016-12-22 17:30:54 +01003873 if (!bind_conf->is_ssl && bind_conf->xprt->destroy_bind_conf)
3874 bind_conf->xprt->destroy_bind_conf(bind_conf);
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003875 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003876
Willy Tarreaua38a7172019-02-02 17:11:28 +01003877 if (atleast2(curproxy->bind_proc & all_proc_mask)) {
Willy Tarreau102df612014-05-07 23:56:38 +02003878 if (curproxy->uri_auth) {
Willy Tarreaueb791e02014-09-16 15:11:04 +02003879 int count, maxproc = 0;
3880
3881 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
David Carliere6c39412015-07-02 07:00:17 +00003882 count = my_popcountl(bind_conf->bind_proc);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003883 if (count > maxproc)
3884 maxproc = count;
3885 }
3886 /* backends have 0, frontends have 1 or more */
3887 if (maxproc != 1)
Christopher Faulet767a84b2017-11-24 16:50:31 +01003888 ha_warning("Proxy '%s': in multi-process mode, stats will be"
3889 " limited to process assigned to the current request.\n",
3890 curproxy->id);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003891
Willy Tarreau102df612014-05-07 23:56:38 +02003892 if (!LIST_ISEMPTY(&curproxy->uri_auth->admin_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003893 ha_warning("Proxy '%s': stats admin will not work correctly in multi-process mode.\n",
3894 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003895 }
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003896 }
Willy Tarreau102df612014-05-07 23:56:38 +02003897 if (!LIST_ISEMPTY(&curproxy->sticking_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003898 ha_warning("Proxy '%s': sticking rules will not work correctly in multi-process mode.\n",
3899 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003900 }
3901 }
Willy Tarreau918ff602011-07-25 16:33:49 +02003902
3903 /* create the task associated with the proxy */
Emeric Brunc60def82017-09-27 14:59:38 +02003904 curproxy->task = task_new(MAX_THREADS_MASK);
Willy Tarreau918ff602011-07-25 16:33:49 +02003905 if (curproxy->task) {
3906 curproxy->task->context = curproxy;
3907 curproxy->task->process = manage_proxy;
Willy Tarreau918ff602011-07-25 16:33:49 +02003908 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003909 ha_alert("Proxy '%s': no more memory when trying to allocate the management task\n",
3910 curproxy->id);
Willy Tarreau918ff602011-07-25 16:33:49 +02003911 cfgerr++;
3912 }
Willy Tarreaub369a042014-09-16 13:21:03 +02003913 }
3914
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003915 /*
3916 * Recount currently required checks.
3917 */
3918
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003919 for (curproxy=proxies_list; curproxy; curproxy=curproxy->next) {
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003920 int optnum;
3921
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003922 for (optnum = 0; cfg_opts[optnum].name; optnum++)
3923 if (curproxy->options & cfg_opts[optnum].val)
3924 global.last_checks |= cfg_opts[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003925
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003926 for (optnum = 0; cfg_opts2[optnum].name; optnum++)
3927 if (curproxy->options2 & cfg_opts2[optnum].val)
3928 global.last_checks |= cfg_opts2[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003929 }
3930
Willy Tarreau0fca4832015-05-01 19:12:05 +02003931 /* compute the required process bindings for the peers */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003932 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003933 if (curproxy->table && curproxy->table->peers.p)
3934 curproxy->table->peers.p->peers_fe->bind_proc |= curproxy->bind_proc;
Willy Tarreau0fca4832015-05-01 19:12:05 +02003935
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01003936 /* compute the required process bindings for the peers from <stktables_list>
3937 * for all the stick-tables, the ones coming with "peers" sections included.
3938 */
3939 for (t = stktables_list; t; t = t->next) {
3940 struct proxy *p;
3941
3942 for (p = t->proxies_list; p; p = p->next_stkt_ref) {
3943 if (t->peers.p && t->peers.p->peers_fe) {
3944 t->peers.p->peers_fe->bind_proc |= p->bind_proc;
3945 }
3946 }
3947 }
3948
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003949 if (cfg_peers) {
3950 struct peers *curpeers = cfg_peers, **last;
Willy Tarreau122541c2011-09-07 21:24:49 +02003951 struct peer *p, *pb;
3952
William Lallemanda2cfd7e2020-03-24 16:02:48 +01003953 /* In the case the peers frontend was not initialized by a
3954 stick-table used in the configuration, set its bind_proc
3955 by default to the first process. */
3956 while (curpeers) {
William Lallemand3ef2d562020-03-24 16:42:15 +01003957 if (curpeers->peers_fe) {
3958 if (curpeers->peers_fe->bind_proc == 0)
3959 curpeers->peers_fe->bind_proc = 1;
3960 }
William Lallemanda2cfd7e2020-03-24 16:02:48 +01003961 curpeers = curpeers->next;
3962 }
3963
3964 curpeers = cfg_peers;
Willy Tarreau1e273012015-05-01 19:15:17 +02003965 /* Remove all peers sections which don't have a valid listener,
3966 * which are not used by any table, or which are bound to more
3967 * than one process.
Willy Tarreau122541c2011-09-07 21:24:49 +02003968 */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003969 last = &cfg_peers;
Willy Tarreau122541c2011-09-07 21:24:49 +02003970 while (*last) {
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003971 struct stktable *t;
Willy Tarreau122541c2011-09-07 21:24:49 +02003972 curpeers = *last;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003973
3974 if (curpeers->state == PR_STSTOPPED) {
3975 /* the "disabled" keyword was present */
3976 if (curpeers->peers_fe)
3977 stop_proxy(curpeers->peers_fe);
3978 curpeers->peers_fe = NULL;
3979 }
Frédéric Lécaille5a4fe5a2019-10-04 08:30:04 +02003980 else if (!curpeers->peers_fe || !curpeers->peers_fe->id) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003981 ha_warning("Removing incomplete section 'peers %s' (no peer named '%s').\n",
3982 curpeers->id, localpeer);
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003983 if (curpeers->peers_fe)
3984 stop_proxy(curpeers->peers_fe);
3985 curpeers->peers_fe = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003986 }
Willy Tarreau9504dd62018-10-15 09:37:03 +02003987 else if (atleast2(curpeers->peers_fe->bind_proc)) {
Willy Tarreau1e273012015-05-01 19:15:17 +02003988 /* either it's totally stopped or too much used */
3989 if (curpeers->peers_fe->bind_proc) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003990 ha_alert("Peers section '%s': peers referenced by sections "
3991 "running in different processes (%d different ones). "
3992 "Check global.nbproc and all tables' bind-process "
3993 "settings.\n", curpeers->id, my_popcountl(curpeers->peers_fe->bind_proc));
Willy Tarreau1e273012015-05-01 19:15:17 +02003994 cfgerr++;
3995 }
3996 stop_proxy(curpeers->peers_fe);
3997 curpeers->peers_fe = NULL;
3998 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003999 else {
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01004000 /* Initializes the transport layer of the server part of all the peers belonging to
4001 * <curpeers> section if required.
4002 * Note that ->srv is used by the local peer of a new process to connect to the local peer
4003 * of an old process.
4004 */
Frédéric Lécaille1055e682018-04-26 14:35:21 +02004005 p = curpeers->remote;
4006 while (p) {
Frédéric Lécaille355b2032019-01-11 14:06:12 +01004007 if (p->srv) {
4008 if (p->srv->use_ssl && xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
4009 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(p->srv);
4010 }
Frédéric Lécaille1055e682018-04-26 14:35:21 +02004011 p = p->next;
4012 }
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01004013 /* Configure the SSL bindings of the local peer if required. */
4014 if (!LIST_ISEMPTY(&curpeers->peers_fe->conf.bind)) {
4015 struct list *l;
4016 struct bind_conf *bind_conf;
4017
4018 l = &curpeers->peers_fe->conf.bind;
4019 bind_conf = LIST_ELEM(l->n, typeof(bind_conf), by_fe);
4020 if (bind_conf->xprt->prepare_bind_conf &&
4021 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
4022 cfgerr++;
4023 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02004024 if (!peers_init_sync(curpeers) || !peers_alloc_dcache(curpeers)) {
Willy Tarreaud9443442018-10-15 11:18:03 +02004025 ha_alert("Peers section '%s': out of memory, giving up on peers.\n",
4026 curpeers->id);
4027 cfgerr++;
4028 break;
4029 }
Willy Tarreau122541c2011-09-07 21:24:49 +02004030 last = &curpeers->next;
4031 continue;
4032 }
4033
Willy Tarreau77e4bd12015-05-01 20:02:17 +02004034 /* clean what has been detected above */
Willy Tarreau122541c2011-09-07 21:24:49 +02004035 p = curpeers->remote;
4036 while (p) {
4037 pb = p->next;
4038 free(p->id);
4039 free(p);
4040 p = pb;
4041 }
4042
4043 /* Destroy and unlink this curpeers section.
4044 * Note: curpeers is backed up into *last.
4045 */
4046 free(curpeers->id);
4047 curpeers = curpeers->next;
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01004048 /* Reset any refereance to this peers section in the list of stick-tables */
4049 for (t = stktables_list; t; t = t->next) {
4050 if (t->peers.p && t->peers.p == *last)
4051 t->peers.p = NULL;
4052 }
Willy Tarreau122541c2011-09-07 21:24:49 +02004053 free(*last);
4054 *last = curpeers;
4055 }
4056 }
4057
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004058 for (t = stktables_list; t; t = t->next) {
4059 if (t->proxy)
4060 continue;
4061 if (!stktable_init(t)) {
4062 ha_alert("Proxy '%s': failed to initialize stick-table.\n", t->id);
4063 cfgerr++;
4064 }
4065 }
4066
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004067 /* initialize stick-tables on backend capable proxies. This must not
4068 * be done earlier because the data size may be discovered while parsing
4069 * other proxies.
4070 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004071 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004072 if (curproxy->state == PR_STSTOPPED || !curproxy->table)
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004073 continue;
4074
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01004075 if (!stktable_init(curproxy->table)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004076 ha_alert("Proxy '%s': failed to initialize stick-table.\n", curproxy->id);
Willy Tarreau6866f3f2015-05-01 19:09:08 +02004077 cfgerr++;
4078 }
4079 }
4080
Simon Horman0d16a402015-01-30 11:22:58 +09004081 if (mailers) {
4082 struct mailers *curmailers = mailers, **last;
4083 struct mailer *m, *mb;
4084
4085 /* Remove all mailers sections which don't have a valid listener.
4086 * This can happen when a mailers section is never referenced.
4087 */
4088 last = &mailers;
4089 while (*last) {
4090 curmailers = *last;
4091 if (curmailers->users) {
4092 last = &curmailers->next;
4093 continue;
4094 }
4095
Christopher Faulet767a84b2017-11-24 16:50:31 +01004096 ha_warning("Removing incomplete section 'mailers %s'.\n",
4097 curmailers->id);
Simon Horman0d16a402015-01-30 11:22:58 +09004098
4099 m = curmailers->mailer_list;
4100 while (m) {
4101 mb = m->next;
4102 free(m->id);
4103 free(m);
4104 m = mb;
4105 }
4106
4107 /* Destroy and unlink this curmailers section.
4108 * Note: curmailers is backed up into *last.
4109 */
4110 free(curmailers->id);
4111 curmailers = curmailers->next;
4112 free(*last);
4113 *last = curmailers;
4114 }
4115 }
4116
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004117 /* Update server_state_file_name to backend name if backend is supposed to use
4118 * a server-state file locally defined and none has been provided */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01004119 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02004120 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_LOCAL &&
4121 curproxy->server_state_file_name == NULL)
4122 curproxy->server_state_file_name = strdup(curproxy->id);
4123 }
4124
Ben Draut054fbee2018-04-13 15:43:04 -06004125 list_for_each_entry(curr_resolvers, &dns_resolvers, list) {
4126 if (LIST_ISEMPTY(&curr_resolvers->nameservers)) {
4127 ha_warning("config : resolvers '%s' [%s:%d] has no nameservers configured!\n",
4128 curr_resolvers->id, curr_resolvers->conf.file,
4129 curr_resolvers->conf.line);
4130 err_code |= ERR_WARN;
4131 }
4132 }
4133
William Lallemand48b4bb42017-10-23 14:36:34 +02004134 list_for_each_entry(postparser, &postparsers, list) {
4135 if (postparser->func)
4136 cfgerr += postparser->func();
4137 }
4138
Willy Tarreaubb925012009-07-23 13:36:36 +02004139 if (cfgerr > 0)
4140 err_code |= ERR_ALERT | ERR_FATAL;
4141 out:
4142 return err_code;
Willy Tarreaubaaee002006-06-26 02:48:02 +02004143}
4144
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004145/*
4146 * Registers the CFG keyword list <kwl> as a list of valid keywords for next
4147 * parsing sessions.
4148 */
4149void cfg_register_keywords(struct cfg_kw_list *kwl)
4150{
4151 LIST_ADDQ(&cfg_keywords.list, &kwl->list);
4152}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004153
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004154/*
4155 * Unregisters the CFG keyword list <kwl> from the list of valid keywords.
4156 */
4157void cfg_unregister_keywords(struct cfg_kw_list *kwl)
4158{
4159 LIST_DEL(&kwl->list);
4160 LIST_INIT(&kwl->list);
4161}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004162
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004163/* this function register new section in the haproxy configuration file.
4164 * <section_name> is the name of this new section and <section_parser>
4165 * is the called parser. If two section declaration have the same name,
4166 * only the first declared is used.
4167 */
4168int cfg_register_section(char *section_name,
William Lallemandd2ff56d2017-10-16 11:06:50 +02004169 int (*section_parser)(const char *, int, char **, int),
4170 int (*post_section_parser)())
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004171{
4172 struct cfg_section *cs;
4173
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004174 list_for_each_entry(cs, &sections, list) {
4175 if (strcmp(cs->section_name, section_name) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004176 ha_alert("register section '%s': already registered.\n", section_name);
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004177 return 0;
4178 }
4179 }
4180
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004181 cs = calloc(1, sizeof(*cs));
4182 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004183 ha_alert("register section '%s': out of memory.\n", section_name);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004184 return 0;
4185 }
4186
4187 cs->section_name = section_name;
4188 cs->section_parser = section_parser;
William Lallemandd2ff56d2017-10-16 11:06:50 +02004189 cs->post_section_parser = post_section_parser;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004190
4191 LIST_ADDQ(&sections, &cs->list);
4192
4193 return 1;
4194}
4195
William Lallemand48b4bb42017-10-23 14:36:34 +02004196/* this function register a new function which will be called once the haproxy
4197 * configuration file has been parsed. It's useful to check dependencies
4198 * between sections or to resolve items once everything is parsed.
4199 */
4200int cfg_register_postparser(char *name, int (*func)())
4201{
4202 struct cfg_postparser *cp;
4203
4204 cp = calloc(1, sizeof(*cp));
4205 if (!cp) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004206 ha_alert("register postparser '%s': out of memory.\n", name);
William Lallemand48b4bb42017-10-23 14:36:34 +02004207 return 0;
4208 }
4209 cp->name = name;
4210 cp->func = func;
4211
4212 LIST_ADDQ(&postparsers, &cp->list);
4213
4214 return 1;
4215}
4216
Willy Tarreaubaaee002006-06-26 02:48:02 +02004217/*
David Carlier845efb52015-09-25 11:49:18 +01004218 * free all config section entries
4219 */
4220void cfg_unregister_sections(void)
4221{
4222 struct cfg_section *cs, *ics;
4223
4224 list_for_each_entry_safe(cs, ics, &sections, list) {
4225 LIST_DEL(&cs->list);
4226 free(cs);
4227 }
4228}
4229
Christopher Faulet7110b402016-10-26 11:09:44 +02004230void cfg_backup_sections(struct list *backup_sections)
4231{
4232 struct cfg_section *cs, *ics;
4233
4234 list_for_each_entry_safe(cs, ics, &sections, list) {
4235 LIST_DEL(&cs->list);
4236 LIST_ADDQ(backup_sections, &cs->list);
4237 }
4238}
4239
4240void cfg_restore_sections(struct list *backup_sections)
4241{
4242 struct cfg_section *cs, *ics;
4243
4244 list_for_each_entry_safe(cs, ics, backup_sections, list) {
4245 LIST_DEL(&cs->list);
4246 LIST_ADDQ(&sections, &cs->list);
4247 }
4248}
4249
Willy Tarreaue6552512018-11-26 11:33:13 +01004250/* these are the config sections handled by default */
4251REGISTER_CONFIG_SECTION("listen", cfg_parse_listen, NULL);
4252REGISTER_CONFIG_SECTION("frontend", cfg_parse_listen, NULL);
4253REGISTER_CONFIG_SECTION("backend", cfg_parse_listen, NULL);
4254REGISTER_CONFIG_SECTION("defaults", cfg_parse_listen, NULL);
4255REGISTER_CONFIG_SECTION("global", cfg_parse_global, NULL);
4256REGISTER_CONFIG_SECTION("userlist", cfg_parse_users, NULL);
4257REGISTER_CONFIG_SECTION("peers", cfg_parse_peers, NULL);
4258REGISTER_CONFIG_SECTION("mailers", cfg_parse_mailers, NULL);
4259REGISTER_CONFIG_SECTION("namespace_list", cfg_parse_netns, NULL);
4260REGISTER_CONFIG_SECTION("resolvers", cfg_parse_resolvers, NULL);
Willy Tarreau659fbf02016-05-26 17:55:28 +02004261
David Carlier845efb52015-09-25 11:49:18 +01004262/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02004263 * Local variables:
4264 * c-indent-level: 8
4265 * c-basic-offset: 8
4266 * End:
4267 */