blob: 93faf4565a0adfcaa539e6c366ddf59654f0485a [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Configuration parser
3 *
Willy Tarreauff011f22011-01-06 17:51:27 +01004 * Copyright 2000-2011 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreaue5733232019-05-22 19:24:06 +020013#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +020014/* This is to have crypt() defined on Linux */
15#define _GNU_SOURCE
16
Willy Tarreaue5733232019-05-22 19:24:06 +020017#ifdef USE_CRYPT_H
Cyril Bonté1a0191d2014-08-29 20:20:02 +020018/* some platforms such as Solaris need this */
19#include <crypt.h>
20#endif
Willy Tarreaue5733232019-05-22 19:24:06 +020021#endif /* USE_LIBCRYPT */
Cyril Bonté1a0191d2014-08-29 20:20:02 +020022
Willy Tarreaubaaee002006-06-26 02:48:02 +020023#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <netdb.h>
27#include <ctype.h>
Willy Tarreau95c20ac2007-03-25 15:39:23 +020028#include <pwd.h>
29#include <grp.h>
Willy Tarreau0b4ed902007-03-26 00:18:40 +020030#include <errno.h>
Willy Tarreau3f49b302007-06-11 00:29:26 +020031#include <sys/types.h>
32#include <sys/stat.h>
33#include <fcntl.h>
34#include <unistd.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020035
Willy Tarreaudcc048a2020-06-04 19:11:43 +020036#include <haproxy/acl.h>
Willy Tarreau122eba92020-06-04 10:15:32 +020037#include <haproxy/action-t.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020038#include <haproxy/api.h>
Willy Tarreauac13aea2020-06-04 10:36:03 +020039#include <haproxy/auth.h>
Willy Tarreau49801602020-06-04 22:50:02 +020040#include <haproxy/backend.h>
Willy Tarreau278161c2020-06-04 11:18:28 +020041#include <haproxy/capture.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020042#include <haproxy/cfgparse.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020043#include <haproxy/channel.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020044#include <haproxy/check.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020045#include <haproxy/chunk.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020046#include <haproxy/connection.h>
Willy Tarreaueb92deb2020-06-04 10:53:16 +020047#include <haproxy/dns.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020048#include <haproxy/errors.h>
Willy Tarreauc7babd82020-06-04 21:29:29 +020049#include <haproxy/filters.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020050#include <haproxy/frontend.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020051#include <haproxy/global.h>
Willy Tarreauc2b1ff02020-06-04 21:21:03 +020052#include <haproxy/http_ana.h>
Willy Tarreauc761f842020-06-04 11:40:28 +020053#include <haproxy/http_rules.h>
Willy Tarreaufbe8da32020-06-04 14:34:27 +020054#include <haproxy/lb_chash.h>
Willy Tarreaub5fc3bf2020-06-04 14:37:38 +020055#include <haproxy/lb_fas.h>
Willy Tarreau02549412020-06-04 14:41:04 +020056#include <haproxy/lb_fwlc.h>
Willy Tarreau546ba422020-06-04 14:45:03 +020057#include <haproxy/lb_fwrr.h>
Willy Tarreau28671592020-06-04 20:22:59 +020058#include <haproxy/lb_map.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020059#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020060#include <haproxy/log.h>
Willy Tarreaucee013e2020-06-05 11:40:38 +020061#include <haproxy/mailers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020062#include <haproxy/namespace.h>
Willy Tarreau8efbdfb2020-06-04 11:29:21 +020063#include <haproxy/obj_type-t.h>
Willy Tarreau3c2a7c22020-06-04 18:38:21 +020064#include <haproxy/peers-t.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020065#include <haproxy/peers.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020066#include <haproxy/pool.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020067#include <haproxy/protocol.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020068#include <haproxy/proxy.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020069#include <haproxy/sample.h>
70#include <haproxy/server.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020071#include <haproxy/session.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020072#include <haproxy/stats-t.h>
Willy Tarreau872f2ea2020-06-04 18:46:44 +020073#include <haproxy/stick_table.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020074#include <haproxy/stream.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020075#include <haproxy/task.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020076#include <haproxy/tcp_rules.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020077#include <haproxy/thread.h>
78#include <haproxy/time.h>
79#include <haproxy/tools.h>
80#include <haproxy/uri_auth-t.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020081
82
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +010083/* Used to chain configuration sections definitions. This list
84 * stores struct cfg_section
85 */
86struct list sections = LIST_HEAD_INIT(sections);
87
William Lallemand48b4bb42017-10-23 14:36:34 +020088struct list postparsers = LIST_HEAD_INIT(postparsers);
89
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +010090char *cursection = NULL;
91struct proxy defproxy = { }; /* fake proxy used to assign default values on all instances */
Willy Tarreauc8d5b952019-02-27 17:25:52 +010092int cfg_maxpconn = 0; /* # of simultaneous connections per proxy (-N) */
Willy Tarreau5af24ef2009-03-15 15:23:16 +010093int cfg_maxconn = 0; /* # of simultaneous connections, (-n) */
Christopher Faulet79bdef32016-11-04 22:36:15 +010094char *cfg_scope = NULL; /* the current scope during the configuration parsing */
Willy Tarreaubaaee002006-06-26 02:48:02 +020095
Willy Tarreau5b2c3362008-07-09 19:39:06 +020096/* List head of all known configuration keywords */
Willy Tarreau36b9e222018-11-11 15:19:52 +010097struct cfg_kw_list cfg_keywords = {
Willy Tarreau5b2c3362008-07-09 19:39:06 +020098 .list = LIST_HEAD_INIT(cfg_keywords.list)
99};
100
Willy Tarreaubaaee002006-06-26 02:48:02 +0200101/*
102 * converts <str> to a list of listeners which are dynamically allocated.
103 * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
104 * - <addr> can be empty or "*" to indicate INADDR_ANY ;
105 * - <port> is a numerical port from 1 to 65535 ;
106 * - <end> indicates to use the range from <port> to <end> instead (inclusive).
107 * This can be repeated as many times as necessary, separated by a coma.
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200108 * Function returns 1 for success or 0 if error. In case of errors, if <err> is
109 * not NULL, it must be a valid pointer to either NULL or a freeable area that
110 * will be replaced with an error message.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200111 */
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200112int 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 +0200113{
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100114 char *next, *dupstr;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200115 int port, end;
116
117 next = dupstr = strdup(str);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200118
Willy Tarreaubaaee002006-06-26 02:48:02 +0200119 while (next && *next) {
William Lallemand75ea0a02017-11-15 19:02:58 +0100120 int inherited = 0;
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200121 struct sockaddr_storage *ss2;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100122 int fd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200123
124 str = next;
125 /* 1) look for the end of the first address */
Krzysztof Piotr Oledzki52d522b2009-01-27 16:57:08 +0100126 if ((next = strchr(str, ',')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200127 *next++ = 0;
128 }
129
Willy Tarreau48ef4c92017-01-06 18:32:38 +0100130 ss2 = str2sa_range(str, NULL, &port, &end, err,
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200131 curproxy == global.stats_fe ? NULL : global.unix_bind.prefix,
Thierry FOURNIER7fe3be72015-09-26 20:03:36 +0200132 NULL, 1);
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100133 if (!ss2)
134 goto fail;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200135
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100136 if (ss2->ss_family == AF_INET || ss2->ss_family == AF_INET6) {
Willy Tarreau6d03cc32013-02-20 17:26:02 +0100137 if (!port && !end) {
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200138 memprintf(err, "missing port number: '%s'\n", str);
Willy Tarreau2dff0c22011-03-04 15:43:13 +0100139 goto fail;
Emeric Bruned760922010-10-22 17:59:25 +0200140 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200141
Willy Tarreau6d03cc32013-02-20 17:26:02 +0100142 if (!port || !end) {
143 memprintf(err, "port offsets are not allowed in 'bind': '%s'\n", str);
144 goto fail;
145 }
146
Emeric Bruned760922010-10-22 17:59:25 +0200147 if (port < 1 || port > 65535) {
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200148 memprintf(err, "invalid port '%d' specified for address '%s'.\n", port, str);
Emeric Bruned760922010-10-22 17:59:25 +0200149 goto fail;
150 }
151
152 if (end < 1 || end > 65535) {
Willy Tarreau4fbb2282012-09-20 20:01:39 +0200153 memprintf(err, "invalid port '%d' specified for address '%s'.\n", end, str);
Emeric Bruned760922010-10-22 17:59:25 +0200154 goto fail;
155 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200156 }
Willy Tarreau40aa0702013-03-10 23:51:38 +0100157 else if (ss2->ss_family == AF_UNSPEC) {
158 socklen_t addr_len;
William Lallemand75ea0a02017-11-15 19:02:58 +0100159 inherited = 1;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100160
161 /* We want to attach to an already bound fd whose number
162 * is in the addr part of ss2 when cast to sockaddr_in.
163 * Note that by definition there is a single listener.
164 * We still have to determine the address family to
165 * register the correct protocol.
166 */
167 fd = ((struct sockaddr_in *)ss2)->sin_addr.s_addr;
168 addr_len = sizeof(*ss2);
169 if (getsockname(fd, (struct sockaddr *)ss2, &addr_len) == -1) {
170 memprintf(err, "cannot use file descriptor '%d' : %s.\n", fd, strerror(errno));
171 goto fail;
172 }
173
174 port = end = get_host_port(ss2);
William Lallemand2fe7dd02018-09-11 16:51:29 +0200175
176 } else if (ss2->ss_family == AF_CUST_SOCKPAIR) {
177 socklen_t addr_len;
178 inherited = 1;
179
180 fd = ((struct sockaddr_in *)ss2)->sin_addr.s_addr;
181 addr_len = sizeof(*ss2);
182 if (getsockname(fd, (struct sockaddr *)ss2, &addr_len) == -1) {
183 memprintf(err, "cannot use file descriptor '%d' : %s.\n", fd, strerror(errno));
184 goto fail;
185 }
186
187 ss2->ss_family = AF_CUST_SOCKPAIR; /* reassign AF_CUST_SOCKPAIR because of getsockname */
188 port = end = 0;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100189 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200190
Willy Tarreau12eb2a62013-03-06 15:45:03 +0100191 /* OK the address looks correct */
William Lallemand75ea0a02017-11-15 19:02:58 +0100192 if (!create_listeners(bind_conf, ss2, port, end, fd, inherited, err)) {
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200193 memprintf(err, "%s for address '%s'.\n", *err, str);
194 goto fail;
195 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200196 } /* end while(next) */
197 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200198 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200199 fail:
200 free(dupstr);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200201 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200202}
203
William Lallemand6e62fb62015-04-28 16:55:23 +0200204/*
Willy Tarreauece9b072016-12-21 22:41:44 +0100205 * Report an error in <msg> when there are too many arguments. This version is
206 * intended to be used by keyword parsers so that the message will be included
207 * into the general error message. The index is the current keyword in args.
208 * Return 0 if the number of argument is correct, otherwise build a message and
209 * return 1. Fill err_code with an ERR_ALERT and an ERR_FATAL if not null. The
210 * message may also be null, it will simply not be produced (useful to check only).
211 * <msg> and <err_code> are only affected on error.
212 */
213int too_many_args_idx(int maxarg, int index, char **args, char **msg, int *err_code)
214{
215 int i;
216
217 if (!*args[index + maxarg + 1])
218 return 0;
219
220 if (msg) {
221 *msg = NULL;
222 memprintf(msg, "%s", args[0]);
223 for (i = 1; i <= index; i++)
224 memprintf(msg, "%s %s", *msg, args[i]);
225
226 memprintf(msg, "'%s' cannot handle unexpected argument '%s'.", *msg, args[index + maxarg + 1]);
227 }
228 if (err_code)
229 *err_code |= ERR_ALERT | ERR_FATAL;
230
231 return 1;
232}
233
234/*
235 * same as too_many_args_idx with a 0 index
236 */
237int too_many_args(int maxarg, char **args, char **msg, int *err_code)
238{
239 return too_many_args_idx(maxarg, 0, args, msg, err_code);
240}
241
242/*
William Lallemand6e62fb62015-04-28 16:55:23 +0200243 * Report a fatal Alert when there is too much arguments
244 * The index is the current keyword in args
245 * Return 0 if the number of argument is correct, otherwise emit an alert and return 1
246 * Fill err_code with an ERR_ALERT and an ERR_FATAL
247 */
248int alertif_too_many_args_idx(int maxarg, int index, const char *file, int linenum, char **args, int *err_code)
249{
250 char *kw = NULL;
251 int i;
252
253 if (!*args[index + maxarg + 1])
254 return 0;
255
256 memprintf(&kw, "%s", args[0]);
257 for (i = 1; i <= index; i++) {
258 memprintf(&kw, "%s %s", kw, args[i]);
259 }
260
Christopher Faulet767a84b2017-11-24 16:50:31 +0100261 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 +0200262 free(kw);
263 *err_code |= ERR_ALERT | ERR_FATAL;
264 return 1;
265}
266
267/*
268 * same as alertif_too_many_args_idx with a 0 index
269 */
270int alertif_too_many_args(int maxarg, const char *file, int linenum, char **args, int *err_code)
271{
272 return alertif_too_many_args_idx(maxarg, 0, file, linenum, args, err_code);
273}
274
Willy Tarreau61d18892009-03-31 10:49:21 +0200275
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100276/* Report it if a request ACL condition uses some keywords that are incompatible
277 * with the place where the ACL is used. It returns either 0 or ERR_WARN so that
278 * its result can be or'ed with err_code. Note that <cond> may be NULL and then
279 * will be ignored.
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100280 */
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +0100281int warnif_cond_conflicts(const struct acl_cond *cond, unsigned int where, const char *file, int line)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100282{
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100283 const struct acl *acl;
Willy Tarreau93fddf12013-03-31 22:59:32 +0200284 const char *kw;
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100285
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100286 if (!cond)
Willy Tarreauf1e98b82010-01-28 17:59:39 +0100287 return 0;
288
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100289 acl = acl_cond_conflicts(cond, where);
290 if (acl) {
291 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100292 ha_warning("parsing [%s:%d] : acl '%s' will never match because it only involves keywords that are incompatible with '%s'\n",
293 file, line, acl->name, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100294 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100295 ha_warning("parsing [%s:%d] : anonymous acl will never match because it uses keyword '%s' which is incompatible with '%s'\n",
296 file, line, LIST_ELEM(acl->expr.n, struct acl_expr *, list)->kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100297 return ERR_WARN;
298 }
299 if (!acl_cond_kw_conflicts(cond, where, &acl, &kw))
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100300 return 0;
301
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100302 if (acl->name && *acl->name)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100303 ha_warning("parsing [%s:%d] : acl '%s' involves keywords '%s' which is incompatible with '%s'\n",
304 file, line, acl->name, kw, sample_ckp_names(where));
Willy Tarreaua91d0a52013-03-25 08:12:18 +0100305 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100306 ha_warning("parsing [%s:%d] : anonymous acl involves keyword '%s' which is incompatible with '%s'\n",
307 file, line, kw, sample_ckp_names(where));
Willy Tarreaufdb563c2010-01-31 15:43:27 +0100308 return ERR_WARN;
309}
310
Christopher Faulet62519022017-10-16 15:49:32 +0200311/* Parse a string representing a process number or a set of processes. It must
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100312 * be "all", "odd", "even", a number between 1 and <max> or a range with
Christopher Faulet5ab51772017-11-22 11:21:58 +0100313 * two such numbers delimited by a dash ('-'). On success, it returns
314 * 0. otherwise it returns 1 with an error message in <err>.
Christopher Faulet62519022017-10-16 15:49:32 +0200315 *
316 * Note: this function can also be used to parse a thread number or a set of
317 * threads.
318 */
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100319int parse_process_number(const char *arg, unsigned long *proc, int max, int *autoinc, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200320{
Christopher Faulet26028f62017-11-22 15:01:51 +0100321 if (autoinc) {
322 *autoinc = 0;
323 if (strncmp(arg, "auto:", 5) == 0) {
324 arg += 5;
325 *autoinc = 1;
326 }
327 }
328
Christopher Faulet62519022017-10-16 15:49:32 +0200329 if (strcmp(arg, "all") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100330 *proc |= ~0UL;
Christopher Faulet62519022017-10-16 15:49:32 +0200331 else if (strcmp(arg, "odd") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100332 *proc |= ~0UL/3UL; /* 0x555....555 */
Christopher Faulet62519022017-10-16 15:49:32 +0200333 else if (strcmp(arg, "even") == 0)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100334 *proc |= (~0UL/3UL) << 1; /* 0xAAA...AAA */
Christopher Faulet62519022017-10-16 15:49:32 +0200335 else {
Christopher Faulet18cca782019-02-07 16:29:41 +0100336 const char *p, *dash = NULL;
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100337 unsigned int low, high;
338
Christopher Faulet18cca782019-02-07 16:29:41 +0100339 for (p = arg; *p; p++) {
340 if (*p == '-' && !dash)
341 dash = p;
Willy Tarreau90807112020-02-25 08:16:33 +0100342 else if (!isdigit((unsigned char)*p)) {
Christopher Faulet18cca782019-02-07 16:29:41 +0100343 memprintf(err, "'%s' is not a valid number/range.", arg);
344 return -1;
345 }
Christopher Faulet5ab51772017-11-22 11:21:58 +0100346 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100347
348 low = high = str2uic(arg);
Christopher Faulet18cca782019-02-07 16:29:41 +0100349 if (dash)
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100350 high = ((!*(dash+1)) ? max : str2uic(dash + 1));
Christopher Fauletff4121f2017-11-22 16:38:49 +0100351
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100352 if (high < low) {
353 unsigned int swap = low;
354 low = high;
355 high = swap;
356 }
357
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100358 if (low < 1 || low > max || high > max) {
Christopher Fauletcb6a9452017-11-22 16:50:41 +0100359 memprintf(err, "'%s' is not a valid number/range."
360 " It supports numbers from 1 to %d.\n",
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100361 arg, max);
Christopher Faulet5ab51772017-11-22 11:21:58 +0100362 return 1;
363 }
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100364
365 for (;low <= high; low++)
Christopher Faulet5ab51772017-11-22 11:21:58 +0100366 *proc |= 1UL << (low-1);
Christopher Faulet62519022017-10-16 15:49:32 +0200367 }
Willy Tarreauc9a82e42019-01-26 13:25:14 +0100368 *proc &= ~0UL >> (LONGBITS - max);
Christopher Faulet1dcb9cb2017-11-22 10:24:40 +0100369
Christopher Faulet5ab51772017-11-22 11:21:58 +0100370 return 0;
Christopher Faulet62519022017-10-16 15:49:32 +0200371}
372
David Carlier7e351ee2017-12-01 09:14:02 +0000373#ifdef USE_CPU_AFFINITY
Christopher Faulet62519022017-10-16 15:49:32 +0200374/* Parse cpu sets. Each CPU set is either a unique number between 0 and
375 * <LONGBITS> or a range with two such numbers delimited by a dash
376 * ('-'). Multiple CPU numbers or ranges may be specified. On success, it
377 * returns 0. otherwise it returns 1 with an error message in <err>.
378 */
Willy Tarreau36b9e222018-11-11 15:19:52 +0100379unsigned long parse_cpu_set(const char **args, unsigned long *cpu_set, char **err)
Christopher Faulet62519022017-10-16 15:49:32 +0200380{
381 int cur_arg = 0;
382
383 *cpu_set = 0;
384 while (*args[cur_arg]) {
385 char *dash;
386 unsigned int low, high;
387
Willy Tarreau90807112020-02-25 08:16:33 +0100388 if (!isdigit((unsigned char)*args[cur_arg])) {
Christopher Faulet62519022017-10-16 15:49:32 +0200389 memprintf(err, "'%s' is not a CPU range.\n", args[cur_arg]);
390 return -1;
391 }
392
393 low = high = str2uic(args[cur_arg]);
394 if ((dash = strchr(args[cur_arg], '-')) != NULL)
Christopher Fauletff4121f2017-11-22 16:38:49 +0100395 high = ((!*(dash+1)) ? LONGBITS-1 : str2uic(dash + 1));
Christopher Faulet62519022017-10-16 15:49:32 +0200396
397 if (high < low) {
398 unsigned int swap = low;
399 low = high;
400 high = swap;
401 }
402
403 if (high >= LONGBITS) {
404 memprintf(err, "supports CPU numbers from 0 to %d.\n", LONGBITS - 1);
405 return 1;
406 }
407
408 while (low <= high)
409 *cpu_set |= 1UL << low++;
410
411 cur_arg++;
412 }
413 return 0;
414}
David Carlier7e351ee2017-12-01 09:14:02 +0000415#endif
416
Willy Tarreau915e1eb2009-06-22 15:48:36 +0200417void init_default_instance()
Willy Tarreaubaaee002006-06-26 02:48:02 +0200418{
Willy Tarreau97cb7802010-01-03 20:23:58 +0100419 init_new_proxy(&defproxy);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200420 defproxy.mode = PR_MODE_TCP;
421 defproxy.state = PR_STNEW;
422 defproxy.maxconn = cfg_maxpconn;
423 defproxy.conn_retries = CONN_RETRIES;
Joseph Lynch726ab712015-05-11 23:25:34 -0700424 defproxy.redispatch_after = 0;
Olivier Houchard86006a52018-12-14 19:37:49 +0100425 defproxy.options = PR_O_REUSE_SAFE;
Olivier Houcharda4d4fdf2018-12-14 19:27:06 +0100426 defproxy.max_out_conns = MAX_SRV_LIST;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100427
Simon Horman66183002013-02-23 10:16:43 +0900428 defproxy.defsrv.check.inter = DEF_CHKINTR;
429 defproxy.defsrv.check.fastinter = 0;
430 defproxy.defsrv.check.downinter = 0;
Simon Hormand60d6912013-11-25 10:46:36 +0900431 defproxy.defsrv.agent.inter = DEF_CHKINTR;
432 defproxy.defsrv.agent.fastinter = 0;
433 defproxy.defsrv.agent.downinter = 0;
Simon Horman58c32972013-11-25 10:46:38 +0900434 defproxy.defsrv.check.rise = DEF_RISETIME;
435 defproxy.defsrv.check.fall = DEF_FALLTIME;
436 defproxy.defsrv.agent.rise = DEF_AGENT_RISETIME;
437 defproxy.defsrv.agent.fall = DEF_AGENT_FALLTIME;
Willy Tarreau5b3a2022012-09-28 15:01:02 +0200438 defproxy.defsrv.check.port = 0;
Simon Hormand60d6912013-11-25 10:46:36 +0900439 defproxy.defsrv.agent.port = 0;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100440 defproxy.defsrv.maxqueue = 0;
441 defproxy.defsrv.minconn = 0;
442 defproxy.defsrv.maxconn = 0;
Willy Tarreau9c538e02019-01-23 10:21:49 +0100443 defproxy.defsrv.max_reuse = -1;
Olivier Houchard006e3102018-12-10 18:30:32 +0100444 defproxy.defsrv.max_idle_conns = -1;
Willy Tarreau975b1552019-06-06 16:25:55 +0200445 defproxy.defsrv.pool_purge_delay = 5000;
Krzysztof Piotr Oledzkic6df0662010-01-05 16:38:49 +0100446 defproxy.defsrv.slowstart = 0;
447 defproxy.defsrv.onerror = DEF_HANA_ONERR;
448 defproxy.defsrv.consecutive_errors_limit = DEF_HANA_ERRLIMIT;
449 defproxy.defsrv.uweight = defproxy.defsrv.iweight = 1;
Simon Horman64e34162015-02-06 11:11:57 +0900450
451 defproxy.email_alert.level = LOG_ALERT;
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +0200452 defproxy.load_server_state_from_file = PR_SRV_STATE_FILE_UNSPEC;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200453}
454
Frédéric Lécaille18251032019-01-11 11:07:15 +0100455/* Allocate and initialize the frontend of a "peers" section found in
456 * file <file> at line <linenum> with <id> as ID.
457 * Return 0 if succeeded, -1 if not.
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200458 * Note that this function may be called from "default-server"
459 * or "peer" lines.
Frédéric Lécaille18251032019-01-11 11:07:15 +0100460 */
461static int init_peers_frontend(const char *file, int linenum,
462 const char *id, struct peers *peers)
463{
464 struct proxy *p;
465
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200466 if (peers->peers_fe) {
467 p = peers->peers_fe;
468 goto out;
469 }
Frédéric Lécaille9492c4e2019-01-11 11:47:12 +0100470
Frédéric Lécaille18251032019-01-11 11:07:15 +0100471 p = calloc(1, sizeof *p);
472 if (!p) {
473 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
474 return -1;
475 }
476
477 init_new_proxy(p);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200478 peers_setup_frontend(p);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100479 p->parent = peers;
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200480 /* Finally store this frontend. */
481 peers->peers_fe = p;
482
483 out:
484 if (id && !p->id)
485 p->id = strdup(id);
Frédéric Lécaille1055e682018-04-26 14:35:21 +0200486 free(p->conf.file);
Frédéric Lécaille18251032019-01-11 11:07:15 +0100487 p->conf.args.file = p->conf.file = strdup(file);
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100488 if (linenum != -1)
489 p->conf.args.line = p->conf.line = linenum;
Frédéric Lécaille18251032019-01-11 11:07:15 +0100490
491 return 0;
492}
Willy Tarreauade5ec42010-01-28 19:33:49 +0100493
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100494/* Only change ->file, ->line and ->arg struct bind_conf member values
495 * if already present.
496 */
497static struct bind_conf *bind_conf_uniq_alloc(struct proxy *p,
498 const char *file, int line,
499 const char *arg, struct xprt_ops *xprt)
500{
501 struct bind_conf *bind_conf;
502
503 if (!LIST_ISEMPTY(&p->conf.bind)) {
504 bind_conf = LIST_ELEM((&p->conf.bind)->n, typeof(bind_conf), by_fe);
505 free(bind_conf->file);
506 bind_conf->file = strdup(file);
507 bind_conf->line = line;
508 if (arg) {
509 free(bind_conf->arg);
510 bind_conf->arg = strdup(arg);
511 }
512 }
513 else {
514 bind_conf = bind_conf_alloc(p, file, line, arg, xprt);
515 }
516
517 return bind_conf;
518}
519
520/*
521 * Allocate a new struct peer parsed at line <linenum> in file <file>
522 * to be added to <peers>.
523 * Returns the new allocated structure if succeeded, NULL if not.
524 */
525static struct peer *cfg_peers_add_peer(struct peers *peers,
526 const char *file, int linenum,
527 const char *id, int local)
528{
529 struct peer *p;
530
531 p = calloc(1, sizeof *p);
532 if (!p) {
533 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
534 return NULL;
535 }
536
537 /* the peers are linked backwards first */
538 peers->count++;
539 p->next = peers->remote;
540 peers->remote = p;
541 p->conf.file = strdup(file);
542 p->conf.line = linenum;
543 p->last_change = now.tv_sec;
544 p->xprt = xprt_get(XPRT_RAW);
545 p->sock_init_arg = NULL;
546 HA_SPIN_INIT(&p->lock);
547 if (id)
548 p->id = strdup(id);
549 if (local) {
550 p->local = 1;
551 peers->local = p;
552 }
553
554 return p;
555}
556
Willy Tarreaubaaee002006-06-26 02:48:02 +0200557/*
William Lallemand51097192015-04-14 16:35:22 +0200558 * Parse a line in a <listen>, <frontend> or <backend> section.
Willy Tarreau93893792009-07-23 13:19:11 +0200559 * Returns the error code, 0 if OK, or any combination of :
560 * - ERR_ABORT: must abort ASAP
561 * - ERR_FATAL: we can continue parsing but not start the service
562 * - ERR_WARN: a warning has been emitted
563 * - ERR_ALERT: an alert has been emitted
564 * Only the two first ones can stop processing, the two others are just
565 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200566 */
Emeric Brun32da3c42010-09-23 18:39:19 +0200567int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
568{
569 static struct peers *curpeers = NULL;
570 struct peer *newpeer = NULL;
571 const char *err;
Willy Tarreau4348fad2012-09-20 16:48:07 +0200572 struct bind_conf *bind_conf;
573 struct listener *l;
Emeric Brun32da3c42010-09-23 18:39:19 +0200574 int err_code = 0;
Willy Tarreau902636f2013-03-10 19:44:48 +0100575 char *errmsg = NULL;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100576 static int bind_line, peer_line;
577
578 if (strcmp(args[0], "bind") == 0 || strcmp(args[0], "default-bind") == 0) {
579 int cur_arg;
580 static int kws_dumped;
581 struct bind_conf *bind_conf;
582 struct bind_kw *kw;
Emeric Brun32da3c42010-09-23 18:39:19 +0200583
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100584 cur_arg = 1;
585
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200586 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
587 err_code |= ERR_ALERT | ERR_ABORT;
588 goto out;
589 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100590
591 bind_conf = bind_conf_uniq_alloc(curpeers->peers_fe, file, linenum,
592 NULL, xprt_get(XPRT_RAW));
593 if (*args[0] == 'b') {
594 struct listener *l;
595
596 if (peer_line) {
597 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
598 err_code |= ERR_ALERT | ERR_FATAL;
599 goto out;
600 }
601
602 if (!str2listener(args[1], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
603 if (errmsg && *errmsg) {
604 indent_msg(&errmsg, 2);
605 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
606 }
607 else
608 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
609 file, linenum, args[0], args[1], args[2]);
610 err_code |= ERR_FATAL;
611 goto out;
612 }
613 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
614 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100615 l->accept = session_accept_fd;
616 l->analysers |= curpeers->peers_fe->fe_req_ana;
617 l->default_target = curpeers->peers_fe->default_target;
618 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100619 global.maxsock++; /* for the listening socket */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100620
621 bind_line = 1;
622 if (cfg_peers->local) {
623 newpeer = cfg_peers->local;
624 }
625 else {
626 /* This peer is local.
627 * Note that we do not set the peer ID. This latter is initialized
628 * when parsing "peer" or "server" line.
629 */
630 newpeer = cfg_peers_add_peer(curpeers, file, linenum, NULL, 1);
631 if (!newpeer) {
632 err_code |= ERR_ALERT | ERR_ABORT;
633 goto out;
634 }
635 }
636 newpeer->addr = l->addr;
637 newpeer->proto = protocol_by_family(newpeer->addr.ss_family);
638 cur_arg++;
639 }
640
641 while (*args[cur_arg] && (kw = bind_find_kw(args[cur_arg]))) {
642 int ret;
643
644 ret = kw->parse(args, cur_arg, curpeers->peers_fe, bind_conf, &errmsg);
645 err_code |= ret;
646 if (ret) {
647 if (errmsg && *errmsg) {
648 indent_msg(&errmsg, 2);
649 ha_alert("parsing [%s:%d] : %s\n", file, linenum, errmsg);
650 }
651 else
652 ha_alert("parsing [%s:%d]: error encountered while processing '%s'\n",
653 file, linenum, args[cur_arg]);
654 if (ret & ERR_FATAL)
655 goto out;
656 }
657 cur_arg += 1 + kw->skip;
658 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100659 if (*args[cur_arg] != 0) {
Tim Duesterhus04bcaa12019-05-12 22:54:50 +0200660 char *kws = NULL;
661
662 if (!kws_dumped) {
663 kws_dumped = 1;
664 bind_dump_kws(&kws);
665 indent_msg(&kws, 4);
666 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100667 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section.%s%s\n",
668 file, linenum, args[cur_arg], cursection,
669 kws ? " Registered keywords :" : "", kws ? kws: "");
670 free(kws);
671 err_code |= ERR_ALERT | ERR_FATAL;
672 goto out;
673 }
674 }
675 else if (strcmp(args[0], "default-server") == 0) {
676 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
677 err_code |= ERR_ALERT | ERR_ABORT;
678 goto out;
679 }
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200680 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL, 0, 1);
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200681 }
Frédéric Lécailleb6f759b2019-11-05 09:57:45 +0100682 else if (strcmp(args[0], "log") == 0) {
683 if (init_peers_frontend(file, linenum, NULL, curpeers) != 0) {
684 err_code |= ERR_ALERT | ERR_ABORT;
685 goto out;
686 }
687 if (!parse_logsrv(args, &curpeers->peers_fe->logsrvs, (kwm == KWM_NO), &errmsg)) {
688 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
689 err_code |= ERR_ALERT | ERR_FATAL;
690 goto out;
691 }
692 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200693 else if (strcmp(args[0], "peers") == 0) { /* new peers section */
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100694 /* Initialize these static variables when entering a new "peers" section*/
695 bind_line = peer_line = 0;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100696 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100697 ha_alert("parsing [%s:%d] : missing name for peers section.\n", file, linenum);
Willy Tarreau54984722014-02-16 08:20:13 +0100698 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100699 goto out;
700 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200701
William Lallemand6e62fb62015-04-28 16:55:23 +0200702 if (alertif_too_many_args(1, file, linenum, args, &err_code))
703 goto out;
704
Emeric Brun32da3c42010-09-23 18:39:19 +0200705 err = invalid_char(args[1]);
706 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100707 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
708 file, linenum, *err, args[0], args[1]);
Willy Tarreau54984722014-02-16 08:20:13 +0100709 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreau0dbbf312013-03-05 11:31:55 +0100710 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200711 }
712
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200713 for (curpeers = cfg_peers; curpeers != NULL; curpeers = curpeers->next) {
Emeric Brun32da3c42010-09-23 18:39:19 +0200714 /*
715 * If there are two proxies with the same name only following
716 * combinations are allowed:
717 */
718 if (strcmp(curpeers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100719 ha_alert("Parsing [%s:%d]: peers section '%s' has the same name as another peers section declared at %s:%d.\n",
720 file, linenum, args[1], curpeers->conf.file, curpeers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +0200721 err_code |= ERR_ALERT | ERR_FATAL;
Emeric Brun32da3c42010-09-23 18:39:19 +0200722 }
723 }
724
Vincent Bernat02779b62016-04-03 13:48:43 +0200725 if ((curpeers = calloc(1, sizeof(*curpeers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100726 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Emeric Brun32da3c42010-09-23 18:39:19 +0200727 err_code |= ERR_ALERT | ERR_ABORT;
728 goto out;
729 }
730
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +0200731 curpeers->next = cfg_peers;
732 cfg_peers = curpeers;
Willy Tarreau8113a5d2012-10-04 08:01:43 +0200733 curpeers->conf.file = strdup(file);
Emeric Brun32da3c42010-09-23 18:39:19 +0200734 curpeers->conf.line = linenum;
735 curpeers->last_change = now.tv_sec;
736 curpeers->id = strdup(args[1]);
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200737 curpeers->state = PR_STNEW;
Emeric Brun32da3c42010-09-23 18:39:19 +0200738 }
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200739 else if (strcmp(args[0], "peer") == 0 ||
740 strcmp(args[0], "server") == 0) { /* peer or server definition */
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100741 int local_peer, peer;
Emeric Brun32da3c42010-09-23 18:39:19 +0200742
Frédéric Lécaille04636b72019-01-31 06:48:16 +0100743 peer = *args[0] == 'p';
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100744 local_peer = !strcmp(args[1], localpeer);
745 /* The local peer may have already partially been parsed on a "bind" line. */
746 if (*args[0] == 'p') {
747 if (bind_line) {
748 ha_alert("parsing [%s:%d] : mixing \"peer\" and \"bind\" line is forbidden\n", file, linenum);
749 err_code |= ERR_ALERT | ERR_FATAL;
750 goto out;
751 }
752 peer_line = 1;
753 }
754 if (cfg_peers->local && !cfg_peers->local->id && local_peer) {
755 /* The local peer has already been initialized on a "bind" line.
756 * Let's use it and store its ID.
757 */
758 newpeer = cfg_peers->local;
759 newpeer->id = strdup(localpeer);
760 }
761 else {
762 if (local_peer && cfg_peers->local) {
763 ha_alert("parsing [%s:%d] : '%s %s' : local peer name already referenced at %s:%d. %s\n",
764 file, linenum, args[0], args[1],
765 curpeers->peers_fe->conf.file, curpeers->peers_fe->conf.line, cfg_peers->local->id);
766 err_code |= ERR_FATAL;
767 goto out;
768 }
769 newpeer = cfg_peers_add_peer(curpeers, file, linenum, args[1], local_peer);
770 if (!newpeer) {
771 err_code |= ERR_ALERT | ERR_ABORT;
772 goto out;
773 }
774 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200775
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100776 /* Line number and peer ID are updated only if this peer is the local one. */
777 if (init_peers_frontend(file,
778 newpeer->local ? linenum: -1,
779 newpeer->local ? newpeer->id : NULL,
780 curpeers) != 0) {
Frédéric Lécaillec06b5d42018-04-26 10:06:41 +0200781 err_code |= ERR_ALERT | ERR_ABORT;
Willy Tarreaub36487e2013-03-10 18:37:42 +0100782 goto out;
783 }
Willy Tarreau2aa38802013-02-20 19:20:59 +0100784
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100785 /* This initializes curpeer->peers->peers_fe->srv.
786 * The server address is parsed only if we are parsing a "peer" line,
787 * or if we are parsing a "server" line and the current peer is not the local one.
788 */
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200789 err_code |= parse_server(file, linenum, args, curpeers->peers_fe, NULL, peer || !local_peer, 1);
790 if (!curpeers->peers_fe->srv) {
791 /* Remove the newly allocated peer. */
792 if (newpeer != curpeers->local) {
793 struct peer *p;
794
795 p = curpeers->remote;
796 curpeers->remote = curpeers->remote->next;
797 free(p->id);
798 free(p);
799 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200800 goto out;
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +0200801 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200802
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100803 /* If the peer address has just been parsed, let's copy it to <newpeer>
804 * and initializes ->proto.
805 */
806 if (peer || !local_peer) {
807 newpeer->addr = curpeers->peers_fe->srv->addr;
808 newpeer->proto = protocol_by_family(newpeer->addr.ss_family);
809 }
810
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100811 newpeer->xprt = xprt_get(XPRT_RAW);
Willy Tarreaud02394b2012-05-11 18:32:18 +0200812 newpeer->sock_init_arg = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100813 HA_SPIN_INIT(&newpeer->lock);
Willy Tarreau26d8c592012-05-07 18:12:14 +0200814
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +0100815 newpeer->srv = curpeers->peers_fe->srv;
816 if (!newpeer->local)
Frédéric Lécaille6617e762018-04-25 15:13:38 +0200817 goto out;
818
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100819 /* The lines above are reserved to "peer" lines. */
820 if (*args[0] == 's')
Frédéric Lécaille4ba51982018-04-25 15:32:18 +0200821 goto out;
Emeric Brun32da3c42010-09-23 18:39:19 +0200822
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100823 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 +0100824
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100825 if (!str2listener(args[2], curpeers->peers_fe, bind_conf, file, linenum, &errmsg)) {
826 if (errmsg && *errmsg) {
827 indent_msg(&errmsg, 2);
828 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 +0100829 }
Frédéric Lécaille91694d52019-01-11 11:43:53 +0100830 else
831 ha_alert("parsing [%s:%d] : '%s %s' : error encountered while parsing listening address %s.\n",
832 file, linenum, args[0], args[1], args[2]);
833 err_code |= ERR_FATAL;
834 goto out;
835 }
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100836
837 l = LIST_ELEM(bind_conf->listeners.n, typeof(l), by_bind);
838 l->maxaccept = 1;
Frédéric Lécaille355b2032019-01-11 14:06:12 +0100839 l->accept = session_accept_fd;
840 l->analysers |= curpeers->peers_fe->fe_req_ana;
841 l->default_target = curpeers->peers_fe->default_target;
842 l->options |= LI_O_UNLIMITED; /* don't make the peers subject to global limits */
Willy Tarreau18215cb2019-02-27 16:25:28 +0100843 global.maxsock++; /* for the listening socket */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100844 }
845 else if (!strcmp(args[0], "table")) {
846 struct stktable *t, *other;
847 char *id;
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100848 size_t prefix_len;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100849
850 /* Line number and peer ID are updated only if this peer is the local one. */
851 if (init_peers_frontend(file, -1, NULL, curpeers) != 0) {
852 err_code |= ERR_ALERT | ERR_ABORT;
853 goto out;
854 }
855
856 other = stktable_find_by_name(args[1]);
857 if (other) {
858 ha_alert("parsing [%s:%d] : stick-table name '%s' conflicts with table declared in %s '%s' at %s:%d.\n",
859 file, linenum, args[1],
860 other->proxy ? proxy_cap_str(other->proxy->cap) : "peers",
861 other->proxy ? other->id : other->peers.p->id,
862 other->conf.file, other->conf.line);
863 err_code |= ERR_ALERT | ERR_FATAL;
864 goto out;
865 }
866
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100867 /* Build the stick-table name, concatenating the "peers" section name
868 * followed by a '/' character and the table name argument.
869 */
870 chunk_reset(&trash);
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100871 if (!chunk_strcpy(&trash, curpeers->id)) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100872 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
873 file, linenum, args[0], args[1]);
874 err_code |= ERR_ALERT | ERR_FATAL;
875 goto out;
876 }
877
878 prefix_len = trash.data;
Frédéric Lécaille7fcc24d2019-03-20 15:09:45 +0100879 if (!chunk_memcat(&trash, "/", 1) || !chunk_strcat(&trash, args[1])) {
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100880 ha_alert("parsing [%s:%d]: '%s %s' : stick-table name too long.\n",
881 file, linenum, args[0], args[1]);
882 err_code |= ERR_ALERT | ERR_FATAL;
883 goto out;
884 }
885
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100886 t = calloc(1, sizeof *t);
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100887 id = strdup(trash.area);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100888 if (!t || !id) {
889 ha_alert("parsing [%s:%d]: '%s %s' : memory allocation failed\n",
890 file, linenum, args[0], args[1]);
891 err_code |= ERR_ALERT | ERR_FATAL;
892 goto out;
893 }
894
Frédéric Lécaillec02766a2019-03-20 15:06:55 +0100895 err_code |= parse_stick_table(file, linenum, args, t, id, id + prefix_len, curpeers);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +0100896 if (err_code & ERR_FATAL)
897 goto out;
898
899 stktable_store_name(t);
900 t->next = stktables_list;
901 stktables_list = t;
902 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +0200903 else if (!strcmp(args[0], "disabled")) { /* disables this peers section */
904 curpeers->state = PR_STSTOPPED;
905 }
906 else if (!strcmp(args[0], "enabled")) { /* enables this peers section (used to revert a disabled default) */
907 curpeers->state = PR_STNEW;
908 }
Emeric Brun32da3c42010-09-23 18:39:19 +0200909 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100910 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Emeric Brun32da3c42010-09-23 18:39:19 +0200911 err_code |= ERR_ALERT | ERR_FATAL;
912 goto out;
913 }
914
915out:
Willy Tarreau902636f2013-03-10 19:44:48 +0100916 free(errmsg);
Emeric Brun32da3c42010-09-23 18:39:19 +0200917 return err_code;
918}
919
Baptiste Assmann325137d2015-04-13 23:40:55 +0200920/*
921 * Parse a <resolvers> section.
922 * Returns the error code, 0 if OK, or any combination of :
923 * - ERR_ABORT: must abort ASAP
924 * - ERR_FATAL: we can continue parsing but not start the service
925 * - ERR_WARN: a warning has been emitted
926 * - ERR_ALERT: an alert has been emitted
927 * Only the two first ones can stop processing, the two others are just
928 * indicators.
929 */
930int cfg_parse_resolvers(const char *file, int linenum, char **args, int kwm)
931{
932 static struct dns_resolvers *curr_resolvers = NULL;
933 struct dns_nameserver *newnameserver = NULL;
934 const char *err;
935 int err_code = 0;
936 char *errmsg = NULL;
937
938 if (strcmp(args[0], "resolvers") == 0) { /* new resolvers section */
939 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100940 ha_alert("parsing [%s:%d] : missing name for resolvers section.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200941 err_code |= ERR_ALERT | ERR_ABORT;
942 goto out;
943 }
944
945 err = invalid_char(args[1]);
946 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100947 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
948 file, linenum, *err, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200949 err_code |= ERR_ALERT | ERR_ABORT;
950 goto out;
951 }
952
953 list_for_each_entry(curr_resolvers, &dns_resolvers, list) {
954 /* Error if two resolvers owns the same name */
955 if (strcmp(curr_resolvers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100956 ha_alert("Parsing [%s:%d]: resolvers '%s' has same name as another resolvers (declared at %s:%d).\n",
957 file, linenum, args[1], curr_resolvers->conf.file, curr_resolvers->conf.line);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200958 err_code |= ERR_ALERT | ERR_ABORT;
959 }
960 }
961
Vincent Bernat02779b62016-04-03 13:48:43 +0200962 if ((curr_resolvers = calloc(1, sizeof(*curr_resolvers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100963 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200964 err_code |= ERR_ALERT | ERR_ABORT;
965 goto out;
966 }
967
968 /* default values */
969 LIST_ADDQ(&dns_resolvers, &curr_resolvers->list);
970 curr_resolvers->conf.file = strdup(file);
971 curr_resolvers->conf.line = linenum;
972 curr_resolvers->id = strdup(args[1]);
973 curr_resolvers->query_ids = EB_ROOT;
Baptiste Assmann2af08fe2017-08-14 00:13:01 +0200974 /* default maximum response size */
975 curr_resolvers->accepted_payload_size = 512;
Baptiste Assmann987e16d2016-11-02 22:23:31 +0100976 /* default hold period for nx, other, refuse and timeout is 30s */
977 curr_resolvers->hold.nx = 30000;
978 curr_resolvers->hold.other = 30000;
979 curr_resolvers->hold.refused = 30000;
980 curr_resolvers->hold.timeout = 30000;
Baptiste Assmann686408b2017-08-18 10:15:42 +0200981 curr_resolvers->hold.obsolete = 0;
Baptiste Assmann325137d2015-04-13 23:40:55 +0200982 /* default hold period for valid is 10s */
Baptiste Assmann4c5490a2015-07-14 21:42:49 +0200983 curr_resolvers->hold.valid = 10000;
Christopher Faulet67957bd2017-09-27 11:00:59 +0200984 curr_resolvers->timeout.resolve = 1000;
985 curr_resolvers->timeout.retry = 1000;
Baptiste Assmann325137d2015-04-13 23:40:55 +0200986 curr_resolvers->resolve_retries = 3;
Christopher Faulet67957bd2017-09-27 11:00:59 +0200987 curr_resolvers->nb_nameservers = 0;
988 LIST_INIT(&curr_resolvers->nameservers);
989 LIST_INIT(&curr_resolvers->resolutions.curr);
990 LIST_INIT(&curr_resolvers->resolutions.wait);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100991 HA_SPIN_INIT(&curr_resolvers->lock);
Baptiste Assmann325137d2015-04-13 23:40:55 +0200992 }
993 else if (strcmp(args[0], "nameserver") == 0) { /* nameserver definition */
994 struct sockaddr_storage *sk;
995 int port1, port2;
996 struct protocol *proto;
997
998 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100999 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1000 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001001 err_code |= ERR_ALERT | ERR_FATAL;
1002 goto out;
1003 }
1004
1005 err = invalid_char(args[1]);
1006 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001007 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1008 file, linenum, *err, args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001009 err_code |= ERR_ALERT | ERR_FATAL;
1010 goto out;
1011 }
1012
Christopher Faulet67957bd2017-09-27 11:00:59 +02001013 list_for_each_entry(newnameserver, &curr_resolvers->nameservers, list) {
Baptiste Assmanna315c552015-11-02 22:55:49 +01001014 /* Error if two resolvers owns the same name */
1015 if (strcmp(newnameserver->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001016 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 -06001017 file, linenum, args[1], newnameserver->conf.file, newnameserver->conf.line);
Baptiste Assmanna315c552015-11-02 22:55:49 +01001018 err_code |= ERR_ALERT | ERR_FATAL;
1019 }
1020 }
1021
Vincent Bernat02779b62016-04-03 13:48:43 +02001022 if ((newnameserver = calloc(1, sizeof(*newnameserver))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001023 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001024 err_code |= ERR_ALERT | ERR_ABORT;
1025 goto out;
1026 }
1027
1028 /* the nameservers are linked backward first */
Christopher Faulet67957bd2017-09-27 11:00:59 +02001029 LIST_ADDQ(&curr_resolvers->nameservers, &newnameserver->list);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001030 newnameserver->resolvers = curr_resolvers;
1031 newnameserver->conf.file = strdup(file);
1032 newnameserver->conf.line = linenum;
1033 newnameserver->id = strdup(args[1]);
1034
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001035 sk = str2sa_range(args[2], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001036 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001037 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001038 err_code |= ERR_ALERT | ERR_FATAL;
1039 goto out;
1040 }
1041
1042 proto = protocol_by_family(sk->ss_family);
1043 if (!proto || !proto->connect) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001044 ha_alert("parsing [%s:%d] : '%s %s' : connect() not supported for this address family.\n",
Baptiste Assmann325137d2015-04-13 23:40:55 +02001045 file, linenum, args[0], args[1]);
1046 err_code |= ERR_ALERT | ERR_FATAL;
1047 goto out;
1048 }
1049
1050 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001051 ha_alert("parsing [%s:%d] : '%s %s' : port ranges and offsets are not allowed in '%s'\n",
1052 file, linenum, args[0], args[1], args[2]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001053 err_code |= ERR_ALERT | ERR_FATAL;
1054 goto out;
1055 }
1056
Baptiste Assmann7f43fa92016-01-21 00:59:46 +01001057 if (!port1 && !port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001058 ha_alert("parsing [%s:%d] : '%s %s' : no UDP port specified\n",
1059 file, linenum, args[0], args[1]);
Baptiste Assmann7f43fa92016-01-21 00:59:46 +01001060 err_code |= ERR_ALERT | ERR_FATAL;
1061 goto out;
1062 }
1063
Baptiste Assmann325137d2015-04-13 23:40:55 +02001064 newnameserver->addr = *sk;
1065 }
Ben Draut44e609b2018-05-29 15:40:08 -06001066 else if (strcmp(args[0], "parse-resolv-conf") == 0) {
1067 const char *whitespace = "\r\n\t ";
1068 char *resolv_line = NULL;
1069 int resolv_linenum = 0;
1070 FILE *f = NULL;
1071 char *address = NULL;
1072 struct sockaddr_storage *sk = NULL;
1073 struct protocol *proto;
1074 int duplicate_name = 0;
1075
1076 if ((resolv_line = malloc(sizeof(*resolv_line) * LINESIZE)) == NULL) {
1077 ha_alert("parsing [%s:%d] : out of memory.\n",
1078 file, linenum);
1079 err_code |= ERR_ALERT | ERR_FATAL;
1080 goto resolv_out;
1081 }
1082
1083 if ((f = fopen("/etc/resolv.conf", "r")) == NULL) {
1084 ha_alert("parsing [%s:%d] : failed to open /etc/resolv.conf.\n",
1085 file, linenum);
1086 err_code |= ERR_ALERT | ERR_FATAL;
1087 goto resolv_out;
1088 }
1089
1090 sk = calloc(1, sizeof(*sk));
1091 if (sk == NULL) {
1092 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n",
1093 resolv_linenum);
1094 err_code |= ERR_ALERT | ERR_FATAL;
1095 goto resolv_out;
1096 }
1097
1098 while (fgets(resolv_line, LINESIZE, f) != NULL) {
1099 resolv_linenum++;
1100 if (strncmp(resolv_line, "nameserver", 10) != 0)
1101 continue;
1102
1103 address = strtok(resolv_line + 10, whitespace);
1104 if (address == resolv_line + 10)
1105 continue;
1106
1107 if (address == NULL) {
1108 ha_warning("parsing [/etc/resolv.conf:%d] : nameserver line is missing address.\n",
1109 resolv_linenum);
1110 err_code |= ERR_WARN;
1111 continue;
1112 }
1113
1114 duplicate_name = 0;
1115 list_for_each_entry(newnameserver, &curr_resolvers->nameservers, list) {
1116 if (strcmp(newnameserver->id, address) == 0) {
1117 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",
1118 resolv_linenum, address, newnameserver->conf.file, newnameserver->conf.line);
1119 err_code |= ERR_WARN;
1120 duplicate_name = 1;
1121 }
1122 }
1123
1124 if (duplicate_name)
1125 continue;
1126
1127 memset(sk, 0, sizeof(*sk));
Willy Tarreau78675252020-05-28 18:07:10 +02001128 if (!str2ip2(address, sk, 1)) {
1129 ha_warning("parsing [/etc/resolv.conf:%d] : address '%s' could not be recognized, nameserver will be excluded.\n",
Ben Draut44e609b2018-05-29 15:40:08 -06001130 resolv_linenum, address);
1131 err_code |= ERR_WARN;
1132 continue;
1133 }
1134
1135 set_host_port(sk, 53);
1136
1137 proto = protocol_by_family(sk->ss_family);
1138 if (!proto || !proto->connect) {
1139 ha_warning("parsing [/etc/resolv.conf:%d] : '%s' : connect() not supported for this address family.\n",
1140 resolv_linenum, address);
1141 err_code |= ERR_WARN;
1142 continue;
1143 }
1144
1145 if ((newnameserver = calloc(1, sizeof(*newnameserver))) == NULL) {
1146 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1147 err_code |= ERR_ALERT | ERR_FATAL;
1148 goto resolv_out;
1149 }
1150
1151 newnameserver->conf.file = strdup("/etc/resolv.conf");
1152 if (newnameserver->conf.file == NULL) {
1153 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1154 err_code |= ERR_ALERT | ERR_FATAL;
1155 goto resolv_out;
1156 }
1157
1158 newnameserver->id = strdup(address);
1159 if (newnameserver->id == NULL) {
1160 ha_alert("parsing [/etc/resolv.conf:%d] : out of memory.\n", resolv_linenum);
1161 err_code |= ERR_ALERT | ERR_FATAL;
1162 goto resolv_out;
1163 }
1164
1165 newnameserver->resolvers = curr_resolvers;
1166 newnameserver->conf.line = resolv_linenum;
1167 newnameserver->addr = *sk;
1168
1169 LIST_ADDQ(&curr_resolvers->nameservers, &newnameserver->list);
1170 }
1171
1172resolv_out:
1173 free(sk);
1174 free(resolv_line);
1175 if (f != NULL)
1176 fclose(f);
1177 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001178 else if (strcmp(args[0], "hold") == 0) { /* hold periods */
1179 const char *res;
1180 unsigned int time;
1181
1182 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001183 ha_alert("parsing [%s:%d] : '%s' expects an <event> and a <time> as arguments.\n",
1184 file, linenum, args[0]);
1185 ha_alert("<event> can be either 'valid', 'nx', 'refused', 'timeout', or 'other'\n");
Baptiste Assmann325137d2015-04-13 23:40:55 +02001186 err_code |= ERR_ALERT | ERR_FATAL;
1187 goto out;
1188 }
1189 res = parse_time_err(args[2], &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001190 if (res == PARSE_TIME_OVER) {
1191 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s>, maximum value is 2147483647 ms (~24.8 days).\n",
1192 file, linenum, args[1], args[0]);
1193 err_code |= ERR_ALERT | ERR_FATAL;
1194 goto out;
1195 }
1196 else if (res == PARSE_TIME_UNDER) {
1197 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s>, minimum non-null value is 1 ms.\n",
1198 file, linenum, args[1], args[0]);
1199 err_code |= ERR_ALERT | ERR_FATAL;
1200 goto out;
1201 }
1202 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001203 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s>.\n",
1204 file, linenum, *res, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001205 err_code |= ERR_ALERT | ERR_FATAL;
1206 goto out;
1207 }
Baptiste Assmann987e16d2016-11-02 22:23:31 +01001208 if (strcmp(args[1], "nx") == 0)
1209 curr_resolvers->hold.nx = time;
1210 else if (strcmp(args[1], "other") == 0)
1211 curr_resolvers->hold.other = time;
1212 else if (strcmp(args[1], "refused") == 0)
1213 curr_resolvers->hold.refused = time;
1214 else if (strcmp(args[1], "timeout") == 0)
1215 curr_resolvers->hold.timeout = time;
1216 else if (strcmp(args[1], "valid") == 0)
Baptiste Assmann325137d2015-04-13 23:40:55 +02001217 curr_resolvers->hold.valid = time;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02001218 else if (strcmp(args[1], "obsolete") == 0)
1219 curr_resolvers->hold.obsolete = time;
Baptiste Assmann325137d2015-04-13 23:40:55 +02001220 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001221 ha_alert("parsing [%s:%d] : '%s' unknown <event>: '%s', expects either 'nx', 'timeout', 'valid', 'obsolete' or 'other'.\n",
1222 file, linenum, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001223 err_code |= ERR_ALERT | ERR_FATAL;
1224 goto out;
1225 }
1226
1227 }
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001228 else if (strcmp(args[0], "accepted_payload_size") == 0) {
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001229 int i = 0;
1230
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001231 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001232 ha_alert("parsing [%s:%d] : '%s' expects <nb> as argument.\n",
1233 file, linenum, args[0]);
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001234 err_code |= ERR_ALERT | ERR_FATAL;
1235 goto out;
1236 }
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001237
1238 i = atoi(args[1]);
Willy Tarreau0c219be2017-08-22 12:01:26 +02001239 if (i < DNS_HEADER_SIZE || i > DNS_MAX_UDP_MESSAGE) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001240 ha_alert("parsing [%s:%d] : '%s' must be between %d and %d inclusive (was %s).\n",
1241 file, linenum, args[0], DNS_HEADER_SIZE, DNS_MAX_UDP_MESSAGE, args[1]);
Baptiste Assmann9d8dbbc2017-08-18 23:35:08 +02001242 err_code |= ERR_ALERT | ERR_FATAL;
1243 goto out;
1244 }
1245
1246 curr_resolvers->accepted_payload_size = i;
Baptiste Assmann2af08fe2017-08-14 00:13:01 +02001247 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001248 else if (strcmp(args[0], "resolution_pool_size") == 0) {
Tim Duesterhus3506dae2019-05-14 20:57:56 +02001249 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 +01001250 file, linenum, args[0]);
Tim Duesterhus3506dae2019-05-14 20:57:56 +02001251 err_code |= ERR_ALERT | ERR_FATAL;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001252 goto out;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001253 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001254 else if (strcmp(args[0], "resolve_retries") == 0) {
1255 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001256 ha_alert("parsing [%s:%d] : '%s' expects <nb> as argument.\n",
1257 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001258 err_code |= ERR_ALERT | ERR_FATAL;
1259 goto out;
1260 }
1261 curr_resolvers->resolve_retries = atoi(args[1]);
1262 }
1263 else if (strcmp(args[0], "timeout") == 0) {
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001264 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001265 ha_alert("parsing [%s:%d] : '%s' expects 'retry' or 'resolve' and <time> as arguments.\n",
1266 file, linenum, args[0]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001267 err_code |= ERR_ALERT | ERR_FATAL;
1268 goto out;
1269 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001270 else if (strcmp(args[1], "retry") == 0 ||
1271 strcmp(args[1], "resolve") == 0) {
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001272 const char *res;
Christopher Faulet67957bd2017-09-27 11:00:59 +02001273 unsigned int tout;
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001274
1275 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001276 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1277 file, linenum, args[0], args[1]);
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001278 err_code |= ERR_ALERT | ERR_FATAL;
1279 goto out;
1280 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001281 res = parse_time_err(args[2], &tout, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001282 if (res == PARSE_TIME_OVER) {
1283 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1284 file, linenum, args[2], args[0], args[1]);
1285 err_code |= ERR_ALERT | ERR_FATAL;
1286 goto out;
1287 }
1288 else if (res == PARSE_TIME_UNDER) {
1289 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1290 file, linenum, args[2], args[0], args[1]);
1291 err_code |= ERR_ALERT | ERR_FATAL;
1292 goto out;
1293 }
1294 else if (res) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001295 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1296 file, linenum, *res, args[0], args[1]);
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001297 err_code |= ERR_ALERT | ERR_FATAL;
1298 goto out;
1299 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02001300 if (args[1][2] == 't')
1301 curr_resolvers->timeout.retry = tout;
1302 else
1303 curr_resolvers->timeout.resolve = tout;
Pieter Baauw7a91a0e2016-02-13 15:51:58 +01001304 }
1305 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001306 ha_alert("parsing [%s:%d] : '%s' expects 'retry' or 'resolve' and <time> as arguments got '%s'.\n",
1307 file, linenum, args[0], args[1]);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001308 err_code |= ERR_ALERT | ERR_FATAL;
1309 goto out;
1310 }
Baptiste Assmann325137d2015-04-13 23:40:55 +02001311 } /* neither "nameserver" nor "resolvers" */
1312 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001313 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Baptiste Assmann325137d2015-04-13 23:40:55 +02001314 err_code |= ERR_ALERT | ERR_FATAL;
1315 goto out;
1316 }
1317
1318 out:
1319 free(errmsg);
1320 return err_code;
1321}
Simon Horman0d16a402015-01-30 11:22:58 +09001322
1323/*
William Lallemand51097192015-04-14 16:35:22 +02001324 * Parse a line in a <listen>, <frontend> or <backend> section.
Simon Horman0d16a402015-01-30 11:22:58 +09001325 * Returns the error code, 0 if OK, or any combination of :
1326 * - ERR_ABORT: must abort ASAP
1327 * - ERR_FATAL: we can continue parsing but not start the service
1328 * - ERR_WARN: a warning has been emitted
1329 * - ERR_ALERT: an alert has been emitted
1330 * Only the two first ones can stop processing, the two others are just
1331 * indicators.
1332 */
1333int cfg_parse_mailers(const char *file, int linenum, char **args, int kwm)
1334{
1335 static struct mailers *curmailers = NULL;
1336 struct mailer *newmailer = NULL;
1337 const char *err;
1338 int err_code = 0;
1339 char *errmsg = NULL;
1340
1341 if (strcmp(args[0], "mailers") == 0) { /* new mailers section */
1342 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001343 ha_alert("parsing [%s:%d] : missing name for mailers section.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001344 err_code |= ERR_ALERT | ERR_ABORT;
1345 goto out;
1346 }
1347
1348 err = invalid_char(args[1]);
1349 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001350 ha_alert("parsing [%s:%d] : character '%c' is not permitted in '%s' name '%s'.\n",
1351 file, linenum, *err, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001352 err_code |= ERR_ALERT | ERR_ABORT;
1353 goto out;
1354 }
1355
1356 for (curmailers = mailers; curmailers != NULL; curmailers = curmailers->next) {
1357 /*
1358 * If there are two proxies with the same name only following
1359 * combinations are allowed:
1360 */
1361 if (strcmp(curmailers->id, args[1]) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001362 ha_alert("Parsing [%s:%d]: mailers section '%s' has the same name as another mailers section declared at %s:%d.\n",
1363 file, linenum, args[1], curmailers->conf.file, curmailers->conf.line);
Willy Tarreau911fa2e2015-05-26 10:35:50 +02001364 err_code |= ERR_ALERT | ERR_FATAL;
Simon Horman0d16a402015-01-30 11:22:58 +09001365 }
1366 }
1367
Vincent Bernat02779b62016-04-03 13:48:43 +02001368 if ((curmailers = calloc(1, sizeof(*curmailers))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001369 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001370 err_code |= ERR_ALERT | ERR_ABORT;
1371 goto out;
1372 }
1373
1374 curmailers->next = mailers;
1375 mailers = curmailers;
1376 curmailers->conf.file = strdup(file);
1377 curmailers->conf.line = linenum;
1378 curmailers->id = strdup(args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001379 curmailers->timeout.mail = DEF_MAILALERTTIME;/* XXX: Would like to Skip to the next alert, if any, ASAP.
1380 * But need enough time so that timeouts don't occur
1381 * during tcp procssing. For now just us an arbitrary default. */
Simon Horman0d16a402015-01-30 11:22:58 +09001382 }
1383 else if (strcmp(args[0], "mailer") == 0) { /* mailer definition */
1384 struct sockaddr_storage *sk;
1385 int port1, port2;
1386 struct protocol *proto;
1387
1388 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001389 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1390 file, linenum, args[0]);
Simon Horman0d16a402015-01-30 11:22:58 +09001391 err_code |= ERR_ALERT | ERR_FATAL;
1392 goto out;
1393 }
1394
1395 err = invalid_char(args[1]);
1396 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001397 ha_alert("parsing [%s:%d] : character '%c' is not permitted in server name '%s'.\n",
1398 file, linenum, *err, args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001399 err_code |= ERR_ALERT | ERR_FATAL;
1400 goto out;
1401 }
1402
Vincent Bernat02779b62016-04-03 13:48:43 +02001403 if ((newmailer = calloc(1, sizeof(*newmailer))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001404 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Simon Horman0d16a402015-01-30 11:22:58 +09001405 err_code |= ERR_ALERT | ERR_ABORT;
1406 goto out;
1407 }
1408
1409 /* the mailers are linked backwards first */
1410 curmailers->count++;
1411 newmailer->next = curmailers->mailer_list;
1412 curmailers->mailer_list = newmailer;
1413 newmailer->mailers = curmailers;
1414 newmailer->conf.file = strdup(file);
1415 newmailer->conf.line = linenum;
1416
1417 newmailer->id = strdup(args[1]);
1418
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001419 sk = str2sa_range(args[2], NULL, &port1, &port2, &errmsg, NULL, NULL, 1);
Simon Horman0d16a402015-01-30 11:22:58 +09001420 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001421 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Simon Horman0d16a402015-01-30 11:22:58 +09001422 err_code |= ERR_ALERT | ERR_FATAL;
1423 goto out;
1424 }
1425
1426 proto = protocol_by_family(sk->ss_family);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09001427 if (!proto || !proto->connect || proto->sock_prot != IPPROTO_TCP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001428 ha_alert("parsing [%s:%d] : '%s %s' : TCP not supported for this address family.\n",
1429 file, linenum, args[0], args[1]);
Simon Horman0d16a402015-01-30 11:22:58 +09001430 err_code |= ERR_ALERT | ERR_FATAL;
1431 goto out;
1432 }
1433
1434 if (port1 != port2) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001435 ha_alert("parsing [%s:%d] : '%s %s' : port ranges and offsets are not allowed in '%s'\n",
1436 file, linenum, args[0], args[1], args[2]);
Simon Horman0d16a402015-01-30 11:22:58 +09001437 err_code |= ERR_ALERT | ERR_FATAL;
1438 goto out;
1439 }
1440
1441 if (!port1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001442 ha_alert("parsing [%s:%d] : '%s %s' : missing or invalid port in '%s'\n",
1443 file, linenum, args[0], args[1], args[2]);
Simon Horman0d16a402015-01-30 11:22:58 +09001444 err_code |= ERR_ALERT | ERR_FATAL;
1445 goto out;
1446 }
1447
1448 newmailer->addr = *sk;
1449 newmailer->proto = proto;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01001450 newmailer->xprt = xprt_get(XPRT_RAW);
Simon Horman0d16a402015-01-30 11:22:58 +09001451 newmailer->sock_init_arg = NULL;
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001452 }
1453 else if (strcmp(args[0], "timeout") == 0) {
1454 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001455 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments.\n",
1456 file, linenum, args[0]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001457 err_code |= ERR_ALERT | ERR_FATAL;
1458 goto out;
1459 }
1460 else if (strcmp(args[1], "mail") == 0) {
1461 const char *res;
1462 unsigned int timeout_mail;
1463 if (!*args[2]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001464 ha_alert("parsing [%s:%d] : '%s %s' expects <time> as argument.\n",
1465 file, linenum, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001466 err_code |= ERR_ALERT | ERR_FATAL;
1467 goto out;
1468 }
1469 res = parse_time_err(args[2], &timeout_mail, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02001470 if (res == PARSE_TIME_OVER) {
1471 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s %s>, maximum value is 2147483647 ms (~24.8 days).\n",
1472 file, linenum, args[2], args[0], args[1]);
1473 err_code |= ERR_ALERT | ERR_FATAL;
1474 goto out;
1475 }
1476 else if (res == PARSE_TIME_UNDER) {
1477 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s %s>, minimum non-null value is 1 ms.\n",
1478 file, linenum, args[2], args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001479 err_code |= ERR_ALERT | ERR_FATAL;
1480 goto out;
1481 }
Willy Tarreau9faebe32019-06-07 19:00:37 +02001482 else if (res) {
1483 ha_alert("parsing [%s:%d]: unexpected character '%c' in argument to <%s %s>.\n",
1484 file, linenum, *res, args[0], args[1]);
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001485 err_code |= ERR_ALERT | ERR_FATAL;
1486 goto out;
1487 }
1488 curmailers->timeout.mail = timeout_mail;
1489 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001490 ha_alert("parsing [%s:%d] : '%s' expects 'mail' and <time> as arguments got '%s'.\n",
Pieter Baauw235fcfc2016-02-13 15:33:40 +01001491 file, linenum, args[0], args[1]);
1492 err_code |= ERR_ALERT | ERR_FATAL;
1493 goto out;
1494 }
1495 }
Simon Horman0d16a402015-01-30 11:22:58 +09001496 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001497 ha_alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], cursection);
Simon Horman0d16a402015-01-30 11:22:58 +09001498 err_code |= ERR_ALERT | ERR_FATAL;
1499 goto out;
1500 }
1501
1502out:
1503 free(errmsg);
1504 return err_code;
1505}
1506
Willy Tarreau3a1f5fd2018-11-11 15:40:36 +01001507void free_email_alert(struct proxy *p)
Simon Horman9dc49962015-01-30 11:22:59 +09001508{
1509 free(p->email_alert.mailers.name);
1510 p->email_alert.mailers.name = NULL;
1511 free(p->email_alert.from);
1512 p->email_alert.from = NULL;
1513 free(p->email_alert.to);
1514 p->email_alert.to = NULL;
1515 free(p->email_alert.myhostname);
1516 p->email_alert.myhostname = NULL;
1517}
1518
Willy Tarreaubaaee002006-06-26 02:48:02 +02001519
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001520int
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001521cfg_parse_netns(const char *file, int linenum, char **args, int kwm)
1522{
Willy Tarreaue5733232019-05-22 19:24:06 +02001523#ifdef USE_NS
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001524 const char *err;
1525 const char *item = args[0];
1526
1527 if (!strcmp(item, "namespace_list")) {
1528 return 0;
1529 }
1530 else if (!strcmp(item, "namespace")) {
1531 size_t idx = 1;
1532 const char *current;
1533 while (*(current = args[idx++])) {
1534 err = invalid_char(current);
1535 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001536 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1537 file, linenum, *err, item, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001538 return ERR_ALERT | ERR_FATAL;
1539 }
1540
1541 if (netns_store_lookup(current, strlen(current))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001542 ha_alert("parsing [%s:%d]: Namespace '%s' is already added.\n",
1543 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001544 return ERR_ALERT | ERR_FATAL;
1545 }
1546 if (!netns_store_insert(current)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001547 ha_alert("parsing [%s:%d]: Cannot open namespace '%s'.\n",
1548 file, linenum, current);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001549 return ERR_ALERT | ERR_FATAL;
1550 }
1551 }
1552 }
1553
1554 return 0;
1555#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001556 ha_alert("parsing [%s:%d]: namespace support is not compiled in.",
1557 file, linenum);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001558 return ERR_ALERT | ERR_FATAL;
1559#endif
1560}
1561
1562int
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001563cfg_parse_users(const char *file, int linenum, char **args, int kwm)
1564{
1565
1566 int err_code = 0;
1567 const char *err;
1568
1569 if (!strcmp(args[0], "userlist")) { /* new userlist */
1570 struct userlist *newul;
1571
1572 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001573 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1574 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001575 err_code |= ERR_ALERT | ERR_FATAL;
1576 goto out;
1577 }
William Lallemand6e62fb62015-04-28 16:55:23 +02001578 if (alertif_too_many_args(1, file, linenum, args, &err_code))
1579 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001580
1581 err = invalid_char(args[1]);
1582 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001583 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1584 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001585 err_code |= ERR_ALERT | ERR_FATAL;
1586 goto out;
1587 }
1588
1589 for (newul = userlist; newul; newul = newul->next)
1590 if (!strcmp(newul->name, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001591 ha_warning("parsing [%s:%d]: ignoring duplicated userlist '%s'.\n",
1592 file, linenum, args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001593 err_code |= ERR_WARN;
1594 goto out;
1595 }
1596
Vincent Bernat02779b62016-04-03 13:48:43 +02001597 newul = calloc(1, sizeof(*newul));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001598 if (!newul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001599 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001600 err_code |= ERR_ALERT | ERR_ABORT;
1601 goto out;
1602 }
1603
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001604 newul->name = strdup(args[1]);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001605 if (!newul->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001606 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001607 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier97880bb2016-04-08 10:35:26 +01001608 free(newul);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001609 goto out;
1610 }
1611
1612 newul->next = userlist;
1613 userlist = newul;
1614
1615 } else if (!strcmp(args[0], "group")) { /* new group */
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001616 int cur_arg;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001617 const char *err;
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001618 struct auth_groups *ag;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001619
1620 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001621 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1622 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001623 err_code |= ERR_ALERT | ERR_FATAL;
1624 goto out;
1625 }
1626
1627 err = invalid_char(args[1]);
1628 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001629 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
1630 file, linenum, *err, args[0], args[1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001631 err_code |= ERR_ALERT | ERR_FATAL;
1632 goto out;
1633 }
1634
William Lallemand4ac9f542015-05-28 18:03:51 +02001635 if (!userlist)
1636 goto out;
1637
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001638 for (ag = userlist->groups; ag; ag = ag->next)
1639 if (!strcmp(ag->name, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001640 ha_warning("parsing [%s:%d]: ignoring duplicated group '%s' in userlist '%s'.\n",
1641 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001642 err_code |= ERR_ALERT;
1643 goto out;
1644 }
1645
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001646 ag = calloc(1, sizeof(*ag));
1647 if (!ag) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001648 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001649 err_code |= ERR_ALERT | ERR_ABORT;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001650 goto out;
1651 }
1652
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001653 ag->name = strdup(args[1]);
David Carlier70d60452016-08-22 23:27:42 +01001654 if (!ag->name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001655 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001656 err_code |= ERR_ALERT | ERR_ABORT;
David Carlier70d60452016-08-22 23:27:42 +01001657 free(ag);
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001658 goto out;
1659 }
1660
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001661 cur_arg = 2;
1662
1663 while (*args[cur_arg]) {
1664 if (!strcmp(args[cur_arg], "users")) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001665 ag->groupusers = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001666 cur_arg += 2;
1667 continue;
1668 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001669 ha_alert("parsing [%s:%d]: '%s' only supports 'users' option.\n",
1670 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001671 err_code |= ERR_ALERT | ERR_FATAL;
David Carlier70d60452016-08-22 23:27:42 +01001672 free(ag->groupusers);
1673 free(ag->name);
1674 free(ag);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001675 goto out;
1676 }
1677 }
1678
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001679 ag->next = userlist->groups;
1680 userlist->groups = ag;
1681
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001682 } else if (!strcmp(args[0], "user")) { /* new user */
1683 struct auth_users *newuser;
1684 int cur_arg;
1685
1686 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001687 ha_alert("parsing [%s:%d]: '%s' expects <name> as arguments.\n",
1688 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001689 err_code |= ERR_ALERT | ERR_FATAL;
1690 goto out;
1691 }
William Lallemand4ac9f542015-05-28 18:03:51 +02001692 if (!userlist)
1693 goto out;
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001694
1695 for (newuser = userlist->users; newuser; newuser = newuser->next)
1696 if (!strcmp(newuser->user, args[1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001697 ha_warning("parsing [%s:%d]: ignoring duplicated user '%s' in userlist '%s'.\n",
1698 file, linenum, args[1], userlist->name);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001699 err_code |= ERR_ALERT;
1700 goto out;
1701 }
1702
Vincent Bernat02779b62016-04-03 13:48:43 +02001703 newuser = calloc(1, sizeof(*newuser));
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001704 if (!newuser) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001705 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001706 err_code |= ERR_ALERT | ERR_ABORT;
1707 goto out;
1708 }
1709
1710 newuser->user = strdup(args[1]);
1711
1712 newuser->next = userlist->users;
1713 userlist->users = newuser;
1714
1715 cur_arg = 2;
1716
1717 while (*args[cur_arg]) {
1718 if (!strcmp(args[cur_arg], "password")) {
Willy Tarreaue5733232019-05-22 19:24:06 +02001719#ifdef USE_LIBCRYPT
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001720 if (!crypt("", args[cur_arg + 1])) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001721 ha_alert("parsing [%s:%d]: the encrypted password used for user '%s' is not supported by crypt(3).\n",
1722 file, linenum, newuser->user);
Cyril Bonté1a0191d2014-08-29 20:20:02 +02001723 err_code |= ERR_ALERT | ERR_FATAL;
1724 goto out;
1725 }
1726#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001727 ha_warning("parsing [%s:%d]: no crypt(3) support compiled, encrypted passwords will not work.\n",
1728 file, linenum);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001729 err_code |= ERR_ALERT;
1730#endif
1731 newuser->pass = strdup(args[cur_arg + 1]);
1732 cur_arg += 2;
1733 continue;
1734 } else if (!strcmp(args[cur_arg], "insecure-password")) {
1735 newuser->pass = strdup(args[cur_arg + 1]);
1736 newuser->flags |= AU_O_INSECURE;
1737 cur_arg += 2;
1738 continue;
1739 } else if (!strcmp(args[cur_arg], "groups")) {
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01001740 newuser->u.groups_names = strdup(args[cur_arg + 1]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001741 cur_arg += 2;
1742 continue;
1743 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001744 ha_alert("parsing [%s:%d]: '%s' only supports 'password', 'insecure-password' and 'groups' options.\n",
1745 file, linenum, args[0]);
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01001746 err_code |= ERR_ALERT | ERR_FATAL;
1747 goto out;
1748 }
1749 }
1750 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001751 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 +01001752 err_code |= ERR_ALERT | ERR_FATAL;
1753 }
1754
1755out:
1756 return err_code;
1757}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001758
Christopher Faulet79bdef32016-11-04 22:36:15 +01001759int
1760cfg_parse_scope(const char *file, int linenum, char *line)
1761{
1762 char *beg, *end, *scope = NULL;
1763 int err_code = 0;
1764 const char *err;
1765
1766 beg = line + 1;
1767 end = strchr(beg, ']');
1768
1769 /* Detect end of scope declaration */
1770 if (!end || end == beg) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001771 ha_alert("parsing [%s:%d] : empty scope name is forbidden.\n",
1772 file, linenum);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001773 err_code |= ERR_ALERT | ERR_FATAL;
1774 goto out;
1775 }
1776
1777 /* Get scope name and check its validity */
1778 scope = my_strndup(beg, end-beg);
1779 err = invalid_char(scope);
1780 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001781 ha_alert("parsing [%s:%d] : character '%c' is not permitted in a scope name.\n",
1782 file, linenum, *err);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001783 err_code |= ERR_ALERT | ERR_ABORT;
1784 goto out;
1785 }
1786
1787 /* Be sure to have a scope declaration alone on its line */
1788 line = end+1;
1789 while (isspace((unsigned char)*line))
1790 line++;
1791 if (*line && *line != '#' && *line != '\n' && *line != '\r') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001792 ha_alert("parsing [%s:%d] : character '%c' is not permitted after scope declaration.\n",
1793 file, linenum, *line);
Christopher Faulet79bdef32016-11-04 22:36:15 +01001794 err_code |= ERR_ALERT | ERR_ABORT;
1795 goto out;
1796 }
1797
1798 /* We have a valid scope declaration, save it */
1799 free(cfg_scope);
1800 cfg_scope = scope;
1801 scope = NULL;
1802
1803 out:
1804 free(scope);
1805 return err_code;
1806}
1807
Frédéric Lécaillea41d5312018-01-29 12:05:07 +01001808int
1809cfg_parse_track_sc_num(unsigned int *track_sc_num,
1810 const char *arg, const char *end, char **errmsg)
1811{
1812 const char *p;
1813 unsigned int num;
1814
1815 p = arg;
1816 num = read_uint64(&arg, end);
1817
1818 if (arg != end) {
1819 memprintf(errmsg, "Wrong track-sc number '%s'", p);
1820 return -1;
1821 }
1822
1823 if (num >= MAX_SESS_STKCTR) {
1824 memprintf(errmsg, "%u track-sc number exceeding "
1825 "%d (MAX_SESS_STKCTR-1) value", num, MAX_SESS_STKCTR - 1);
1826 return -1;
1827 }
1828
1829 *track_sc_num = num;
1830 return 0;
1831}
1832
Willy Tarreaubaaee002006-06-26 02:48:02 +02001833/*
1834 * This function reads and parses the configuration file given in the argument.
Willy Tarreau058e9072009-07-20 09:30:05 +02001835 * Returns the error code, 0 if OK, or any combination of :
1836 * - ERR_ABORT: must abort ASAP
1837 * - ERR_FATAL: we can continue parsing but not start the service
1838 * - ERR_WARN: a warning has been emitted
1839 * - ERR_ALERT: an alert has been emitted
1840 * Only the two first ones can stop processing, the two others are just
1841 * indicators.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001842 */
Willy Tarreaub17916e2006-10-15 15:17:57 +02001843int readcfgfile(const char *file)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001844{
William Lallemand64e84512015-05-12 14:25:37 +02001845 char *thisline;
1846 int linesize = LINESIZE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001847 FILE *f;
1848 int linenum = 0;
Willy Tarreau058e9072009-07-20 09:30:05 +02001849 int err_code = 0;
William Lallemandd2ff56d2017-10-16 11:06:50 +02001850 struct cfg_section *cs = NULL, *pcs = NULL;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001851 struct cfg_section *ics;
William Lallemand64e84512015-05-12 14:25:37 +02001852 int readbytes = 0;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001853 char *outline = NULL;
1854 size_t outlen = 0;
1855 size_t outlinesize = 0;
Willy Tarreau32234e72020-06-16 17:14:33 +02001856 int fatal = 0;
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001857 int missing_lf = -1;
William Lallemand64e84512015-05-12 14:25:37 +02001858
1859 if ((thisline = malloc(sizeof(*thisline) * linesize)) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001860 ha_alert("parsing [%s] : out of memory.\n", file);
William Lallemand64e84512015-05-12 14:25:37 +02001861 return -1;
1862 }
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01001863
David Carlier97880bb2016-04-08 10:35:26 +01001864 if ((f=fopen(file,"r")) == NULL) {
1865 free(thisline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001866 return -1;
David Carlier97880bb2016-04-08 10:35:26 +01001867 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001868
William Lallemandb2f07452015-05-12 14:27:13 +02001869next_line:
William Lallemand64e84512015-05-12 14:25:37 +02001870 while (fgets(thisline + readbytes, linesize - readbytes, f) != NULL) {
Willy Tarreau3842f002009-06-14 11:39:52 +02001871 int arg, kwm = KWM_STD;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001872 char *end;
1873 char *args[MAX_LINE_ARGS + 1];
1874 char *line = thisline;
1875
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001876 if (missing_lf != -1) {
1877 ha_warning("parsing [%s:%d]: Stray NUL character at position %d. "
1878 "This will become a hard error in HAProxy 2.3.\n",
1879 file, linenum, (missing_lf + 1));
1880 err_code |= ERR_WARN;
1881 missing_lf = -1;
1882 }
1883
Willy Tarreaubaaee002006-06-26 02:48:02 +02001884 linenum++;
1885
Willy Tarreau32234e72020-06-16 17:14:33 +02001886 if (fatal >= 50) {
1887 ha_alert("parsing [%s:%d]: too many fatal errors (%d), stopping now.\n", file, linenum, fatal);
1888 break;
1889 }
1890
Willy Tarreaubaaee002006-06-26 02:48:02 +02001891 end = line + strlen(line);
1892
William Lallemand64e84512015-05-12 14:25:37 +02001893 if (end-line == linesize-1 && *(end-1) != '\n') {
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001894 /* Check if we reached the limit and the last char is not \n.
1895 * Watch out for the last line without the terminating '\n'!
1896 */
William Lallemand64e84512015-05-12 14:25:37 +02001897 char *newline;
1898 int newlinesize = linesize * 2;
1899
1900 newline = realloc(thisline, sizeof(*thisline) * newlinesize);
1901 if (newline == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001902 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1903 file, linenum);
William Lallemand64e84512015-05-12 14:25:37 +02001904 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001905 fatal++;
William Lallemand64e84512015-05-12 14:25:37 +02001906 continue;
1907 }
1908
1909 readbytes = linesize - 1;
1910 linesize = newlinesize;
1911 thisline = newline;
1912 continue;
Krzysztof Piotr Oledzkie6bbd742007-11-01 00:33:12 +01001913 }
1914
William Lallemand64e84512015-05-12 14:25:37 +02001915 readbytes = 0;
1916
Tim Duesterhus70f58992020-06-22 22:57:44 +02001917 if (*(end-1) == '\n') {
1918 /* kill trailing LF */
1919 *(end - 1) = 0;
1920 }
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02001921 else {
1922 /* mark this line as truncated */
1923 missing_lf = end - line;
1924 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001925
Willy Tarreaubaaee002006-06-26 02:48:02 +02001926 /* skip leading spaces */
Willy Tarreau8f8e6452007-06-17 21:51:38 +02001927 while (isspace((unsigned char)*line))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001928 line++;
William Lallemandf9873ba2015-05-05 17:37:14 +02001929
Joseph Herlanta14c03e2018-11-15 14:04:19 -08001930 if (*line == '[') {/* This is the beginning if a scope */
Christopher Faulet79bdef32016-11-04 22:36:15 +01001931 err_code |= cfg_parse_scope(file, linenum, line);
1932 goto next_line;
1933 }
1934
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001935 while (1) {
1936 uint32_t err;
1937 char *errptr;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001938
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001939 arg = MAX_LINE_ARGS;
1940 outlen = outlinesize;
1941 err = parse_line(line, outline, &outlen, args, &arg,
1942 PARSE_OPT_ENV | PARSE_OPT_DQUOTE | PARSE_OPT_SQUOTE |
1943 PARSE_OPT_BKSLASH | PARSE_OPT_SHARP, &errptr);
1944
1945 if (err & PARSE_ERR_QUOTE) {
1946 ha_alert("parsing [%s:%d]: unmatched quote below:\n"
1947 " %s\n %*s\n", file, linenum, line, (int)(errptr-line+1), "^");
1948 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001949 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001950 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001951 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001952
1953 if (err & PARSE_ERR_BRACE) {
1954 ha_alert("parsing [%s:%d]: unmatched brace in environment variable name below:\n"
1955 " %s\n %*s\n", file, linenum, line, (int)(errptr-line+1), "^");
1956 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001957 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001958 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001959 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001960
1961 if (err & PARSE_ERR_VARNAME) {
1962 ha_alert("parsing [%s:%d]: forbidden first char in environment variable name below:\n"
1963 " %s\n %*s\n", file, linenum, line, (int)(errptr-line+1), "^");
1964 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001965 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001966 goto next_line;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001967 }
William Lallemandb2f07452015-05-12 14:27:13 +02001968
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001969 if (err & PARSE_ERR_HEX) {
1970 ha_alert("parsing [%s:%d]: truncated or invalid hexadecimal sequence below:\n"
1971 " %s\n %*s\n", file, linenum, line, (int)(errptr-line+1), "^");
1972 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus9f658a52020-06-16 18:14:21 +02001973 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001974 goto next_line;
1975 }
William Lallemandb2f07452015-05-12 14:27:13 +02001976
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001977 if (err & PARSE_ERR_TOOMANY) {
1978 ha_alert("parsing [%s:%d]: too many words, truncating at word %d, position %ld: <%s>.\n",
Tim Duesterhusc17a5fa2020-06-23 18:56:10 +02001979 file, linenum, MAX_LINE_ARGS, (long)(args[MAX_LINE_ARGS-1] - outline + 1), args[MAX_LINE_ARGS-1]);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001980 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001981 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001982 goto next_line;
1983 }
William Lallemandb2f07452015-05-12 14:27:13 +02001984
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001985 if (err & (PARSE_ERR_TOOLARGE|PARSE_ERR_OVERLAP)) {
1986 outlinesize = (outlen + 1023) & -1024;
1987 outline = realloc(outline, outlinesize);
1988 if (outline == NULL) {
1989 ha_alert("parsing [%s:%d]: line too long, cannot allocate memory.\n",
1990 file, linenum);
William Lallemandb2f07452015-05-12 14:27:13 +02001991 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02001992 fatal++;
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001993 goto next_line;
William Lallemandb2f07452015-05-12 14:27:13 +02001994 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001995 /* try again */
1996 continue;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001997 }
Willy Tarreau9e1758e2020-06-16 16:32:59 +02001998 /* everything's OK */
1999 break;
William Lallemandf9873ba2015-05-05 17:37:14 +02002000 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002001
2002 /* empty line */
2003 if (!**args)
2004 continue;
2005
Willy Tarreau3842f002009-06-14 11:39:52 +02002006 /* check for keyword modifiers "no" and "default" */
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002007 if (!strcmp(args[0], "no")) {
William Lallemand0f99e342011-10-12 17:50:54 +02002008 char *tmp;
2009
Willy Tarreau3842f002009-06-14 11:39:52 +02002010 kwm = KWM_NO;
William Lallemand0f99e342011-10-12 17:50:54 +02002011 tmp = args[0];
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002012 for (arg=0; *args[arg+1]; arg++)
2013 args[arg] = args[arg+1]; // shift args after inversion
William Lallemand0f99e342011-10-12 17:50:54 +02002014 *tmp = '\0'; // fix the next arg to \0
2015 args[arg] = tmp;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002016 }
Willy Tarreau3842f002009-06-14 11:39:52 +02002017 else if (!strcmp(args[0], "default")) {
2018 kwm = KWM_DEF;
2019 for (arg=0; *args[arg+1]; arg++)
2020 args[arg] = args[arg+1]; // shift args after inversion
2021 }
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002022
William Dauchyec730982019-10-27 20:08:10 +01002023 if (kwm != KWM_STD && strcmp(args[0], "option") != 0 &&
2024 strcmp(args[0], "log") != 0 && strcmp(args[0], "busy-polling") != 0 &&
Willy Tarreaud96f1122019-12-03 07:07:36 +01002025 strcmp(args[0], "set-dumpable") != 0 && strcmp(args[0], "strict-limits") != 0 &&
2026 strcmp(args[0], "insecure-fork-wanted") != 0) {
William Dauchyec730982019-10-27 20:08:10 +01002027 ha_alert("parsing [%s:%d]: negation/default currently "
William Dauchy0fec3ab2019-10-27 20:08:11 +01002028 "supported only for options, log, busy-polling, "
Willy Tarreaud96f1122019-12-03 07:07:36 +01002029 "set-dumpable, strict-limits, and insecure-fork-wanted.\n", file, linenum);
Willy Tarreau058e9072009-07-20 09:30:05 +02002030 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02002031 fatal++;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01002032 }
2033
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002034 /* detect section start */
2035 list_for_each_entry(ics, &sections, list) {
2036 if (strcmp(args[0], ics->section_name) == 0) {
2037 cursection = ics->section_name;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002038 pcs = cs;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01002039 cs = ics;
2040 break;
2041 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002042 }
2043
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002044 if (pcs && pcs->post_section_parser) {
Willy Tarreau32234e72020-06-16 17:14:33 +02002045 int status;
2046
2047 status = pcs->post_section_parser();
2048 err_code |= status;
2049 if (status & ERR_FATAL)
2050 fatal++;
2051
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002052 if (err_code & ERR_ABORT)
2053 goto err;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002054 }
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002055 pcs = NULL;
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002056
William Lallemandd2ff56d2017-10-16 11:06:50 +02002057 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002058 ha_alert("parsing [%s:%d]: unknown keyword '%s' out of section.\n", file, linenum, args[0]);
Willy Tarreau058e9072009-07-20 09:30:05 +02002059 err_code |= ERR_ALERT | ERR_FATAL;
Willy Tarreau32234e72020-06-16 17:14:33 +02002060 fatal++;
William Lallemandd2ff56d2017-10-16 11:06:50 +02002061 } else {
Willy Tarreau32234e72020-06-16 17:14:33 +02002062 int status;
2063
2064 status = cs->section_parser(file, linenum, args, kwm);
2065 err_code |= status;
2066 if (status & ERR_FATAL)
2067 fatal++;
2068
William Lallemandd2ff56d2017-10-16 11:06:50 +02002069 if (err_code & ERR_ABORT)
2070 goto err;
2071 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002072 }
William Lallemandd2ff56d2017-10-16 11:06:50 +02002073
Tim Duesterhus2fd5bdb2020-06-22 22:57:45 +02002074 if (missing_lf != -1) {
2075 ha_warning("parsing [%s:%d]: Missing LF on last line, file might have been truncated at position %d. "
2076 "This will become a hard error in HAProxy 2.3.\n",
2077 file, linenum, (missing_lf + 1));
2078 err_code |= ERR_WARN;
2079 }
2080
Christopher Fauletbf7a9592018-12-02 09:37:38 +01002081 if (cs && cs->post_section_parser)
Christopher Faulet7805e2b2018-11-30 13:50:47 +01002082 err_code |= cs->post_section_parser();
William Lallemandd2ff56d2017-10-16 11:06:50 +02002083
2084err:
Christopher Faulet79bdef32016-11-04 22:36:15 +01002085 free(cfg_scope);
2086 cfg_scope = NULL;
Willy Tarreau6daf3432008-01-22 16:44:08 +01002087 cursection = NULL;
William Lallemand64e84512015-05-12 14:25:37 +02002088 free(thisline);
Willy Tarreau9e1758e2020-06-16 16:32:59 +02002089 free(outline);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002090 fclose(f);
Willy Tarreau058e9072009-07-20 09:30:05 +02002091 return err_code;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002092}
2093
Willy Tarreau64ab6072014-09-16 12:17:36 +02002094/* This function propagates processes from frontend <from> to backend <to> so
2095 * that it is always guaranteed that a backend pointed to by a frontend is
2096 * bound to all of its processes. After that, if the target is a "listen"
2097 * instance, the function recursively descends the target's own targets along
Willy Tarreau98d04852015-05-26 12:18:29 +02002098 * default_backend and use_backend rules. Since the bits are
Willy Tarreau64ab6072014-09-16 12:17:36 +02002099 * checked first to ensure that <to> is already bound to all processes of
2100 * <from>, there is no risk of looping and we ensure to follow the shortest
2101 * path to the destination.
2102 *
2103 * It is possible to set <to> to NULL for the first call so that the function
2104 * takes care of visiting the initial frontend in <from>.
2105 *
2106 * It is important to note that the function relies on the fact that all names
2107 * have already been resolved.
2108 */
2109void propagate_processes(struct proxy *from, struct proxy *to)
2110{
2111 struct switching_rule *rule;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002112
2113 if (to) {
2114 /* check whether we need to go down */
2115 if (from->bind_proc &&
2116 (from->bind_proc & to->bind_proc) == from->bind_proc)
2117 return;
2118
2119 if (!from->bind_proc && !to->bind_proc)
2120 return;
2121
2122 to->bind_proc = from->bind_proc ?
2123 (to->bind_proc | from->bind_proc) : 0;
2124
2125 /* now propagate down */
2126 from = to;
2127 }
2128
Willy Tarreau8a95d8c2014-12-18 13:56:26 +01002129 if (!(from->cap & PR_CAP_FE))
Willy Tarreau64ab6072014-09-16 12:17:36 +02002130 return;
2131
Willy Tarreauf6b70012014-12-18 14:00:43 +01002132 if (from->state == PR_STSTOPPED)
2133 return;
2134
Willy Tarreau64ab6072014-09-16 12:17:36 +02002135 /* default_backend */
2136 if (from->defbe.be)
2137 propagate_processes(from, from->defbe.be);
2138
2139 /* use_backend */
2140 list_for_each_entry(rule, &from->switching_rules, list) {
Cyril Bonté51639692014-10-02 19:56:25 +02002141 if (rule->dynamic)
2142 continue;
Willy Tarreau64ab6072014-09-16 12:17:36 +02002143 to = rule->be.backend;
2144 propagate_processes(from, to);
2145 }
Willy Tarreau64ab6072014-09-16 12:17:36 +02002146}
2147
Willy Tarreaubb925012009-07-23 13:36:36 +02002148/*
2149 * Returns the error code, 0 if OK, or any combination of :
2150 * - ERR_ABORT: must abort ASAP
2151 * - ERR_FATAL: we can continue parsing but not start the service
2152 * - ERR_WARN: a warning has been emitted
2153 * - ERR_ALERT: an alert has been emitted
2154 * Only the two first ones can stop processing, the two others are just
2155 * indicators.
2156 */
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002157int check_config_validity()
2158{
2159 int cfgerr = 0;
2160 struct proxy *curproxy = NULL;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002161 struct stktable *t;
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002162 struct server *newsrv = NULL;
Willy Tarreaubb925012009-07-23 13:36:36 +02002163 int err_code = 0;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002164 unsigned int next_pxid = 1;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002165 struct bind_conf *bind_conf;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002166 char *err;
William Lallemand48b4bb42017-10-23 14:36:34 +02002167 struct cfg_postparser *postparser;
Ben Draut054fbee2018-04-13 15:43:04 -06002168 struct dns_resolvers *curr_resolvers = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002169
Willy Tarreau2a65ff02012-09-13 17:54:29 +02002170 bind_conf = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002171 /*
2172 * Now, check for the integrity of all that we have collected.
2173 */
2174
2175 /* will be needed further to delay some tasks */
Willy Tarreaub0b37bc2008-06-23 14:00:57 +02002176 tv_update_date(0,1);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002177
Willy Tarreau193b8c62012-11-22 00:17:38 +01002178 if (!global.tune.max_http_hdr)
2179 global.tune.max_http_hdr = MAX_HTTP_HDR;
2180
2181 if (!global.tune.cookie_len)
2182 global.tune.cookie_len = CAPTURE_LEN;
2183
Stéphane Cottin23e9e932017-05-18 08:58:41 +02002184 if (!global.tune.requri_len)
2185 global.tune.requri_len = REQURI_LEN;
2186
Willy Tarreau149ab772019-01-26 14:27:06 +01002187 if (!global.nbthread) {
2188 /* nbthread not set, thus automatic. In this case, and only if
2189 * running on a single process, we enable the same number of
2190 * threads as the number of CPUs the process is bound to. This
2191 * allows to easily control the number of threads using taskset.
2192 */
2193 global.nbthread = 1;
2194#if defined(USE_THREAD)
2195 if (global.nbproc == 1)
2196 global.nbthread = thread_cpus_enabled_at_boot;
2197 all_threads_mask = nbits(global.nbthread);
2198#endif
2199 }
2200
Willy Tarreau26f6ae12019-02-02 12:56:15 +01002201 if (global.nbproc > 1 && global.nbthread > 1) {
2202 ha_alert("config : cannot enable multiple processes if multiple threads are configured. Please use either nbproc or nbthread but not both.\n");
2203 err_code |= ERR_ALERT | ERR_FATAL;
2204 goto out;
2205 }
2206
Willy Tarreaubafbe012017-11-24 17:34:44 +01002207 pool_head_requri = create_pool("requri", global.tune.requri_len , MEM_F_SHARED);
Emeric Brun96fd9262017-07-05 13:33:16 +02002208
Willy Tarreaubafbe012017-11-24 17:34:44 +01002209 pool_head_capture = create_pool("capture", global.tune.cookie_len, MEM_F_SHARED);
Willy Tarreau193b8c62012-11-22 00:17:38 +01002210
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002211 /* Post initialisation of the users and groups lists. */
2212 err_code = userlist_postinit();
2213 if (err_code != ERR_NONE)
2214 goto out;
2215
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002216 /* first, we will invert the proxy list order */
2217 curproxy = NULL;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002218 while (proxies_list) {
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002219 struct proxy *next;
2220
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002221 next = proxies_list->next;
2222 proxies_list->next = curproxy;
2223 curproxy = proxies_list;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002224 if (!next)
2225 break;
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002226 proxies_list = next;
Willy Tarreau55bc0f82009-03-15 14:51:53 +01002227 }
2228
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002229 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002230 struct switching_rule *rule;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002231 struct server_rule *srule;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002232 struct sticking_rule *mrule;
Christopher Faulete4e830d2017-09-18 14:51:41 +02002233 struct act_rule *arule;
Dragan Dosen1322d092015-09-22 16:05:32 +02002234 struct logsrv *tmplogsrv;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002235 unsigned int next_id;
Willy Tarreau16a21472012-11-19 12:39:59 +01002236 int nbproc;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002237
Willy Tarreau050536d2012-10-04 08:47:34 +02002238 if (curproxy->uuid < 0) {
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002239 /* proxy ID not set, use automatic numbering with first
2240 * spare entry starting with next_pxid.
2241 */
2242 next_pxid = get_next_id(&used_proxy_id, next_pxid);
2243 curproxy->conf.id.key = curproxy->uuid = next_pxid;
2244 eb32_insert(&used_proxy_id, &curproxy->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02002245 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01002246 next_pxid++;
2247
Willy Tarreau55ea7572007-06-17 19:56:27 +02002248
Willy Tarreaubaaee002006-06-26 02:48:02 +02002249 if (curproxy->state == PR_STSTOPPED) {
Willy Tarreauda250db2008-10-12 12:07:48 +02002250 /* ensure we don't keep listeners uselessly bound */
2251 stop_proxy(curproxy);
Dragan Dosen7d61a332019-05-07 14:16:18 +02002252 if (curproxy->table) {
2253 free((void *)curproxy->table->peers.name);
2254 curproxy->table->peers.p = NULL;
2255 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002256 continue;
2257 }
2258
Willy Tarreau102df612014-05-07 23:56:38 +02002259 /* Check multi-process mode compatibility for the current proxy */
2260
2261 if (curproxy->bind_proc) {
2262 /* an explicit bind-process was specified, let's check how many
2263 * processes remain.
2264 */
David Carliere6c39412015-07-02 07:00:17 +00002265 nbproc = my_popcountl(curproxy->bind_proc);
Willy Tarreau102df612014-05-07 23:56:38 +02002266
Willy Tarreaua38a7172019-02-02 17:11:28 +01002267 curproxy->bind_proc &= all_proc_mask;
Willy Tarreau102df612014-05-07 23:56:38 +02002268 if (!curproxy->bind_proc && nbproc == 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002269 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 +02002270 curproxy->bind_proc = 1;
2271 }
2272 else if (!curproxy->bind_proc && nbproc > 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002273 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 +02002274 curproxy->bind_proc = 0;
2275 }
2276 }
2277
Willy Tarreau3d209582014-05-09 17:06:11 +02002278 /* check and reduce the bind-proc of each listener */
2279 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
2280 unsigned long mask;
2281
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002282 /* HTTP frontends with "h2" as ALPN/NPN will work in
2283 * HTTP/2 and absolutely require buffers 16kB or larger.
2284 */
2285#ifdef USE_OPENSSL
2286 if (curproxy->mode == PR_MODE_HTTP && global.tune.bufsize < 16384) {
2287#ifdef OPENSSL_NPN_NEGOTIATED
2288 /* check NPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002289 if (bind_conf->ssl_conf.npn_str && strstr(bind_conf->ssl_conf.npn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002290 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",
2291 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002292 cfgerr++;
2293 }
2294#endif
2295#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
2296 /* check ALPN */
Willy Tarreau4db49c02018-11-11 10:36:25 +01002297 if (bind_conf->ssl_conf.alpn_str && strstr(bind_conf->ssl_conf.alpn_str, "\002h2")) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002298 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",
2299 curproxy->id, bind_conf->file, bind_conf->line, global.tune.bufsize);
Willy Tarreau45a66cc2017-11-24 11:28:00 +01002300 cfgerr++;
2301 }
2302#endif
2303 } /* HTTP && bufsize < 16384 */
2304#endif
2305
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002306 /* detect and address thread affinity inconsistencies */
Willy Tarreaua36b3242019-02-02 13:14:34 +01002307 mask = thread_mask(bind_conf->bind_thread);
Willy Tarreau3d957172019-02-02 18:00:17 +01002308 if (!(mask & all_threads_mask)) {
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002309 unsigned long new_mask = 0;
2310
2311 while (mask) {
Willy Tarreau0c026f42018-08-01 19:12:20 +02002312 new_mask |= mask & all_threads_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002313 mask >>= global.nbthread;
2314 }
2315
Willy Tarreaua36b3242019-02-02 13:14:34 +01002316 bind_conf->bind_thread = new_mask;
Willy Tarreauc477b6f2018-07-27 18:07:41 +02002317 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",
2318 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line, new_mask);
2319 }
2320
2321 /* detect process and nbproc affinity inconsistencies */
Willy Tarreaua36b3242019-02-02 13:14:34 +01002322 mask = proc_mask(bind_conf->bind_proc) & proc_mask(curproxy->bind_proc);
2323 if (!(mask & all_proc_mask)) {
2324 mask = proc_mask(curproxy->bind_proc) & all_proc_mask;
2325 nbproc = my_popcountl(bind_conf->bind_proc);
2326 bind_conf->bind_proc = proc_mask(bind_conf->bind_proc) & mask;
Willy Tarreau3d209582014-05-09 17:06:11 +02002327
Willy Tarreaua36b3242019-02-02 13:14:34 +01002328 if (!bind_conf->bind_proc && nbproc == 1) {
2329 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",
2330 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
2331 bind_conf->bind_proc = mask & ~(mask - 1);
2332 }
2333 else if (!bind_conf->bind_proc && nbproc > 1) {
2334 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",
2335 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
2336 bind_conf->bind_proc = 0;
2337 }
Willy Tarreau3d209582014-05-09 17:06:11 +02002338 }
2339 }
2340
Willy Tarreauff01a212009-03-15 13:46:16 +01002341 switch (curproxy->mode) {
2342 case PR_MODE_HEALTH:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002343 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002344 if (!(curproxy->cap & PR_CAP_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002345 ha_alert("config : %s '%s' cannot be in health mode as it has no frontend capability.\n",
2346 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +01002347 cfgerr++;
2348 }
2349
2350 if (curproxy->srv != NULL)
Christopher Faulet767a84b2017-11-24 16:50:31 +01002351 ha_warning("config : servers will be ignored for %s '%s'.\n",
2352 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauff01a212009-03-15 13:46:16 +01002353 break;
2354
2355 case PR_MODE_TCP:
Willy Tarreau915e1eb2009-06-22 15:48:36 +02002356 cfgerr += proxy_cfg_ensure_no_http(curproxy);
Willy Tarreauff01a212009-03-15 13:46:16 +01002357 break;
2358
2359 case PR_MODE_HTTP:
Willy Tarreau25320b22013-03-24 07:22:08 +01002360 curproxy->http_needed = 1;
Willy Tarreauff01a212009-03-15 13:46:16 +01002361 break;
William Lallemandcf62f7e2018-10-26 14:47:40 +02002362
2363 case PR_MODE_CLI:
2364 cfgerr += proxy_cfg_ensure_no_http(curproxy);
2365 break;
Willy Tarreauff01a212009-03-15 13:46:16 +01002366 }
2367
Willy Tarreau58aa5cc2018-02-08 09:55:09 +01002368 if (curproxy != global.stats_fe && (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->conf.listeners)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002369 ha_warning("config : %s '%s' has no 'bind' directive. Please declare it as a backend if this was intended.\n",
2370 proxy_type_str(curproxy), curproxy->id);
Willy Tarreauf3934b82015-08-11 11:36:45 +02002371 err_code |= ERR_WARN;
2372 }
2373
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002374 if ((curproxy->cap & PR_CAP_BE) && (curproxy->mode != PR_MODE_HEALTH)) {
Willy Tarreauf3e49f92009-10-03 12:21:20 +02002375 if (curproxy->lbprm.algo & BE_LB_KIND) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002376 if (curproxy->options & PR_O_TRANSP) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002377 ha_alert("config : %s '%s' cannot use both transparent and balance mode.\n",
2378 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002379 cfgerr++;
2380 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002381#ifdef WE_DONT_SUPPORT_SERVERLESS_LISTENERS
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002382 else if (curproxy->srv == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002383 ha_alert("config : %s '%s' needs at least 1 server in balance mode.\n",
2384 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002385 cfgerr++;
2386 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002387#endif
Willy Tarreau1620ec32011-08-06 17:05:02 +02002388 else if (curproxy->options & PR_O_DISPATCH) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002389 ha_warning("config : dispatch address of %s '%s' will be ignored in balance mode.\n",
2390 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002391 err_code |= ERR_WARN;
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002392 }
2393 }
Willy Tarreau1620ec32011-08-06 17:05:02 +02002394 else if (!(curproxy->options & (PR_O_TRANSP | PR_O_DISPATCH | PR_O_HTTP_PROXY))) {
Willy Tarreau3cd9af22009-03-15 14:06:41 +01002395 /* If no LB algo is set in a backend, and we're not in
2396 * transparent mode, dispatch mode nor proxy mode, we
2397 * want to use balance roundrobin by default.
2398 */
2399 curproxy->lbprm.algo &= ~BE_LB_ALGO;
2400 curproxy->lbprm.algo |= BE_LB_ALGO_RR;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002401 }
2402 }
Willy Tarreau193cf932007-09-17 10:17:23 +02002403
Willy Tarreau1620ec32011-08-06 17:05:02 +02002404 if (curproxy->options & PR_O_DISPATCH)
2405 curproxy->options &= ~(PR_O_TRANSP | PR_O_HTTP_PROXY);
2406 else if (curproxy->options & PR_O_HTTP_PROXY)
2407 curproxy->options &= ~(PR_O_DISPATCH | PR_O_TRANSP);
2408 else if (curproxy->options & PR_O_TRANSP)
2409 curproxy->options &= ~(PR_O_DISPATCH | PR_O_HTTP_PROXY);
Willy Tarreau82936582007-11-30 15:20:09 +01002410
Christopher Faulete5870d82020-04-15 11:32:03 +02002411 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_HTTP_RS)) {
2412 ha_warning("config : %s '%s' uses http-check rules without 'option httpchk', so the rules are ignored.\n",
2413 proxy_type_str(curproxy), curproxy->id);
2414 err_code |= ERR_WARN;
2415 }
2416
2417 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_TCPCHK_CHK &&
Christopher Fauletc0fcbe42020-06-03 19:00:42 +02002418 (curproxy->tcpcheck_rules.flags & TCPCHK_RULES_PROTO_CHK) != TCPCHK_RULES_HTTP_CHK) {
Willy Tarreau1620ec32011-08-06 17:05:02 +02002419 if (curproxy->options & PR_O_DISABLE404) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002420 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2421 "disable-on-404", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002422 err_code |= ERR_WARN;
2423 curproxy->options &= ~PR_O_DISABLE404;
2424 }
2425 if (curproxy->options2 & PR_O2_CHK_SNDST) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002426 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option httpchk').\n",
2427 "send-state", proxy_type_str(curproxy), curproxy->id);
Willy Tarreau1620ec32011-08-06 17:05:02 +02002428 err_code |= ERR_WARN;
2429 curproxy->options &= ~PR_O2_CHK_SNDST;
2430 }
Willy Tarreauef781042010-01-27 11:53:01 +01002431 }
2432
Simon Horman98637e52014-06-20 12:30:16 +09002433 if ((curproxy->options2 & PR_O2_CHK_ANY) == PR_O2_EXT_CHK) {
2434 if (!global.external_check) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002435 ha_alert("Proxy '%s' : '%s' unable to find required 'global.external-check'.\n",
2436 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002437 cfgerr++;
2438 }
2439 if (!curproxy->check_command) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002440 ha_alert("Proxy '%s' : '%s' unable to find required 'external-check command'.\n",
2441 curproxy->id, "option external-check");
Simon Horman98637e52014-06-20 12:30:16 +09002442 cfgerr++;
2443 }
Willy Tarreaud96f1122019-12-03 07:07:36 +01002444 if (!(global.tune.options & GTUNE_INSECURE_FORK)) {
2445 ha_warning("Proxy '%s' : 'insecure-fork-wanted' not enabled in the global section, '%s' will likely fail.\n",
2446 curproxy->id, "option external-check");
2447 err_code |= ERR_WARN;
2448 }
Simon Horman98637e52014-06-20 12:30:16 +09002449 }
2450
Simon Horman64e34162015-02-06 11:11:57 +09002451 if (curproxy->email_alert.set) {
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002452 if (!(curproxy->email_alert.mailers.name && curproxy->email_alert.from && curproxy->email_alert.to)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002453 ha_warning("config : 'email-alert' will be ignored for %s '%s' (the presence any of "
2454 "'email-alert from', 'email-alert level' 'email-alert mailers', "
2455 "'email-alert myhostname', or 'email-alert to' "
2456 "requires each of 'email-alert from', 'email-alert mailers' and 'email-alert to' "
2457 "to be present).\n",
2458 proxy_type_str(curproxy), curproxy->id);
Simon Horman0ba0e4a2015-01-30 11:23:00 +09002459 err_code |= ERR_WARN;
2460 free_email_alert(curproxy);
2461 }
2462 if (!curproxy->email_alert.myhostname)
Cyril Bontée22bfd62015-12-04 03:07:07 +01002463 curproxy->email_alert.myhostname = strdup(hostname);
Simon Horman9dc49962015-01-30 11:22:59 +09002464 }
2465
Simon Horman98637e52014-06-20 12:30:16 +09002466 if (curproxy->check_command) {
2467 int clear = 0;
2468 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002469 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2470 "external-check command", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002471 err_code |= ERR_WARN;
2472 clear = 1;
2473 }
2474 if (curproxy->check_command[0] != '/' && !curproxy->check_path) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002475 ha_alert("Proxy '%s': '%s' does not have a leading '/' and 'external-check path' is not set.\n",
2476 curproxy->id, "external-check command");
Simon Horman98637e52014-06-20 12:30:16 +09002477 cfgerr++;
2478 }
2479 if (clear) {
2480 free(curproxy->check_command);
2481 curproxy->check_command = NULL;
2482 }
2483 }
2484
2485 if (curproxy->check_path) {
2486 if ((curproxy->options2 & PR_O2_CHK_ANY) != PR_O2_EXT_CHK) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002487 ha_warning("config : '%s' will be ignored for %s '%s' (requires 'option external-check').\n",
2488 "external-check path", proxy_type_str(curproxy), curproxy->id);
Simon Horman98637e52014-06-20 12:30:16 +09002489 err_code |= ERR_WARN;
2490 free(curproxy->check_path);
2491 curproxy->check_path = NULL;
2492 }
2493 }
2494
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002495 /* if a default backend was specified, let's find it */
2496 if (curproxy->defbe.name) {
2497 struct proxy *target;
2498
Willy Tarreauafb39922015-05-26 12:04:09 +02002499 target = proxy_be_by_name(curproxy->defbe.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002500 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002501 ha_alert("Proxy '%s': unable to find required default_backend: '%s'.\n",
2502 curproxy->id, curproxy->defbe.name);
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002503 cfgerr++;
2504 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002505 ha_alert("Proxy '%s': loop detected for default_backend: '%s'.\n",
2506 curproxy->id, curproxy->defbe.name);
Willy Tarreaubb925012009-07-23 13:36:36 +02002507 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002508 } else if (target->mode != curproxy->mode &&
2509 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2510
Christopher Faulet767a84b2017-11-24 16:50:31 +01002511 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) as its default backend (see 'mode').\n",
2512 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2513 curproxy->conf.file, curproxy->conf.line,
2514 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2515 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002516 cfgerr++;
Willy Tarreau5fdfb912007-01-01 23:11:07 +01002517 } else {
2518 free(curproxy->defbe.name);
2519 curproxy->defbe.be = target;
Willy Tarreauff678132012-02-13 14:32:34 +01002520 /* Emit a warning if this proxy also has some servers */
2521 if (curproxy->srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002522 ha_warning("In proxy '%s', the 'default_backend' rule always has precedence over the servers, which will never be used.\n",
2523 curproxy->id);
Willy Tarreauff678132012-02-13 14:32:34 +01002524 err_code |= ERR_WARN;
2525 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002526 }
2527 }
2528
Willy Tarreau55ea7572007-06-17 19:56:27 +02002529 /* find the target proxy for 'use_backend' rules */
2530 list_for_each_entry(rule, &curproxy->switching_rules, list) {
Willy Tarreau55ea7572007-06-17 19:56:27 +02002531 struct proxy *target;
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002532 struct logformat_node *node;
2533 char *pxname;
2534
2535 /* Try to parse the string as a log format expression. If the result
2536 * of the parsing is only one entry containing a simple string, then
2537 * it's a standard string corresponding to a static rule, thus the
2538 * parsing is cancelled and be.name is restored to be resolved.
2539 */
2540 pxname = rule->be.name;
2541 LIST_INIT(&rule->be.expr);
Thierry FOURNIER / OZON.IO4ed1c952016-11-24 23:57:54 +01002542 curproxy->conf.args.ctx = ARGC_UBK;
2543 curproxy->conf.args.file = rule->file;
2544 curproxy->conf.args.line = rule->line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002545 err = NULL;
2546 if (!parse_logformat_string(pxname, curproxy, &rule->be.expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002547 ha_alert("Parsing [%s:%d]: failed to parse use_backend rule '%s' : %s.\n",
2548 rule->file, rule->line, pxname, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002549 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002550 cfgerr++;
2551 continue;
2552 }
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002553 node = LIST_NEXT(&rule->be.expr, struct logformat_node *, list);
2554
2555 if (!LIST_ISEMPTY(&rule->be.expr)) {
2556 if (node->type != LOG_FMT_TEXT || node->list.n != &rule->be.expr) {
2557 rule->dynamic = 1;
2558 free(pxname);
2559 continue;
2560 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02002561 /* Only one element in the list, a simple string: free the expression and
2562 * fall back to static rule
2563 */
2564 LIST_DEL(&node->list);
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01002565 free(node->arg);
2566 free(node);
2567 }
2568
2569 rule->dynamic = 0;
2570 rule->be.name = pxname;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002571
Willy Tarreauafb39922015-05-26 12:04:09 +02002572 target = proxy_be_by_name(rule->be.name);
Krzysztof Piotr Oledzki6eb730d2007-11-03 23:41:58 +01002573 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002574 ha_alert("Proxy '%s': unable to find required use_backend: '%s'.\n",
2575 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002576 cfgerr++;
2577 } else if (target == curproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002578 ha_alert("Proxy '%s': loop detected for use_backend: '%s'.\n",
2579 curproxy->id, rule->be.name);
Willy Tarreau55ea7572007-06-17 19:56:27 +02002580 cfgerr++;
Willy Tarreauafb39922015-05-26 12:04:09 +02002581 } else if (target->mode != curproxy->mode &&
2582 !(curproxy->mode == PR_MODE_TCP && target->mode == PR_MODE_HTTP)) {
2583
Christopher Faulet767a84b2017-11-24 16:50:31 +01002584 ha_alert("%s %s '%s' (%s:%d) tries to use incompatible %s %s '%s' (%s:%d) in a 'use_backend' rule (see 'mode').\n",
2585 proxy_mode_str(curproxy->mode), proxy_type_str(curproxy), curproxy->id,
2586 curproxy->conf.file, curproxy->conf.line,
2587 proxy_mode_str(target->mode), proxy_type_str(target), target->id,
2588 target->conf.file, target->conf.line);
Willy Tarreauafb39922015-05-26 12:04:09 +02002589 cfgerr++;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002590 } else {
2591 free((void *)rule->be.name);
2592 rule->be.backend = target;
2593 }
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002594 }
2595
Willy Tarreau64ab6072014-09-16 12:17:36 +02002596 /* find the target server for 'use_server' rules */
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002597 list_for_each_entry(srule, &curproxy->server_rules, list) {
Jerome Magnin824186b2020-03-29 09:37:12 +02002598 struct server *target;
2599 struct logformat_node *node;
2600 char *server_name;
2601
2602 /* We try to parse the string as a log format expression. If the result of the parsing
2603 * is only one entry containing a single string, then it's a standard string corresponding
2604 * to a static rule, thus the parsing is cancelled and we fall back to setting srv.ptr.
2605 */
2606 server_name = srule->srv.name;
2607 LIST_INIT(&srule->expr);
2608 curproxy->conf.args.ctx = ARGC_USRV;
2609 err = NULL;
2610 if (!parse_logformat_string(server_name, curproxy, &srule->expr, 0, SMP_VAL_FE_HRQ_HDR, &err)) {
2611 ha_alert("Parsing [%s:%d]; use-server rule failed to parse log-format '%s' : %s.\n",
2612 srule->file, srule->line, server_name, err);
2613 free(err);
2614 cfgerr++;
2615 continue;
2616 }
2617 node = LIST_NEXT(&srule->expr, struct logformat_node *, list);
2618
2619 if (!LIST_ISEMPTY(&srule->expr)) {
2620 if (node->type != LOG_FMT_TEXT || node->list.n != &srule->expr) {
2621 srule->dynamic = 1;
2622 free(server_name);
2623 continue;
2624 }
Christopher Fauletf82ea4a2020-05-07 15:59:33 +02002625 /* Only one element in the list, a simple string: free the expression and
2626 * fall back to static rule
2627 */
2628 LIST_DEL(&node->list);
Jerome Magnin824186b2020-03-29 09:37:12 +02002629 free(node->arg);
2630 free(node);
2631 }
2632
2633 srule->dynamic = 0;
2634 srule->srv.name = server_name;
2635 target = findserver(curproxy, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002636
2637 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002638 ha_alert("config : %s '%s' : unable to find server '%s' referenced in a 'use-server' rule.\n",
2639 proxy_type_str(curproxy), curproxy->id, srule->srv.name);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002640 cfgerr++;
2641 continue;
2642 }
2643 free((void *)srule->srv.name);
2644 srule->srv.ptr = target;
Willy Tarreau55ea7572007-06-17 19:56:27 +02002645 }
2646
Emeric Brunb982a3d2010-01-04 15:45:53 +01002647 /* find the target table for 'stick' rules */
2648 list_for_each_entry(mrule, &curproxy->sticking_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002649 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002650
Emeric Brun1d33b292010-01-04 15:47:17 +01002651 curproxy->be_req_ana |= AN_REQ_STICKING_RULES;
2652 if (mrule->flags & STK_IS_STORE)
2653 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2654
Emeric Brunb982a3d2010-01-04 15:45:53 +01002655 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002656 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002657 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002658 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002659
2660 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002661 ha_alert("Proxy '%s': unable to find stick-table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01002662 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002663 cfgerr++;
2664 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002665 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002666 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2667 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002668 cfgerr++;
2669 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002670 else if (target->proxy && curproxy->bind_proc & ~target->proxy->bind_proc) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002671 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2672 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002673 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002674 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002675 else {
2676 free((void *)mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002677 mrule->table.t = target;
2678 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Frédéric Lécailledb52d902019-05-17 10:12:52 +02002679 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_NAME, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02002680 if (!in_proxies_list(target->proxies_list, curproxy)) {
2681 curproxy->next_stkt_ref = target->proxies_list;
2682 target->proxies_list = curproxy;
2683 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002684 }
2685 }
2686
2687 /* find the target table for 'store response' rules */
2688 list_for_each_entry(mrule, &curproxy->storersp_rules, list) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002689 struct stktable *target;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002690
Emeric Brun1d33b292010-01-04 15:47:17 +01002691 curproxy->be_rsp_ana |= AN_RES_STORE_RULES;
2692
Emeric Brunb982a3d2010-01-04 15:45:53 +01002693 if (mrule->table.name)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002694 target = stktable_find_by_name(mrule->table.name);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002695 else
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002696 target = curproxy->table;
Emeric Brunb982a3d2010-01-04 15:45:53 +01002697
2698 if (!target) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002699 ha_alert("Proxy '%s': unable to find store table '%s'.\n",
Willy Tarreau508d2322020-01-24 07:19:34 +01002700 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002701 cfgerr++;
2702 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002703 else if (!stktable_compatible_sample(mrule->expr, target->type)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002704 ha_alert("Proxy '%s': type of fetch not usable with type of stick-table '%s'.\n",
2705 curproxy->id, mrule->table.name ? mrule->table.name : curproxy->id);
Emeric Brunb982a3d2010-01-04 15:45:53 +01002706 cfgerr++;
2707 }
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002708 else if (target->proxy && (curproxy->bind_proc & ~target->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002709 ha_alert("Proxy '%s': stick-table '%s' referenced 'stick-store' rule not present on all processes covered by proxy '%s'.\n",
2710 curproxy->id, target->id, curproxy->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01002711 cfgerr++;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01002712 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002713 else {
2714 free((void *)mrule->table.name);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002715 mrule->table.t = target;
2716 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_ID, NULL);
Frédéric Lécailledb52d902019-05-17 10:12:52 +02002717 stktable_alloc_data_type(target, STKTABLE_DT_SERVER_NAME, NULL);
Frédéric Lécaille9c3a0ce2019-09-02 14:02:28 +02002718 if (!in_proxies_list(target->proxies_list, curproxy)) {
2719 curproxy->next_stkt_ref = target->proxies_list;
2720 target->proxies_list = curproxy;
2721 }
Emeric Brunb982a3d2010-01-04 15:45:53 +01002722 }
2723 }
2724
Christopher Faulete4e830d2017-09-18 14:51:41 +02002725 /* check validity for 'tcp-request' layer 4 rules */
2726 list_for_each_entry(arule, &curproxy->tcp_req.l4_rules, list) {
2727 err = NULL;
2728 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002729 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002730 free(err);
Willy Tarreau5f53de72012-12-12 00:25:44 +01002731 cfgerr++;
2732 }
Willy Tarreaud1f96522010-08-03 19:34:32 +02002733 }
2734
Christopher Faulete4e830d2017-09-18 14:51:41 +02002735 /* check validity for 'tcp-request' layer 5 rules */
2736 list_for_each_entry(arule, &curproxy->tcp_req.l5_rules, list) {
2737 err = NULL;
2738 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002739 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002740 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002741 cfgerr++;
2742 }
2743 }
2744
Christopher Faulete4e830d2017-09-18 14:51:41 +02002745 /* check validity for 'tcp-request' layer 6 rules */
2746 list_for_each_entry(arule, &curproxy->tcp_req.inspect_rules, list) {
2747 err = NULL;
2748 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002749 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002750 free(err);
Baptiste Assmanne9544932015-11-03 23:31:35 +01002751 cfgerr++;
2752 }
2753 }
2754
Christopher Faulete4e830d2017-09-18 14:51:41 +02002755 /* check validity for 'http-request' layer 7 rules */
2756 list_for_each_entry(arule, &curproxy->http_req_rules, list) {
2757 err = NULL;
2758 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002759 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002760 free(err);
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002761 cfgerr++;
2762 }
Ruoshan Huange4edc6b2016-07-14 15:07:45 +08002763 }
2764
Christopher Faulete4e830d2017-09-18 14:51:41 +02002765 /* check validity for 'http-response' layer 7 rules */
2766 list_for_each_entry(arule, &curproxy->http_res_rules, list) {
2767 err = NULL;
2768 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002769 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulete4e830d2017-09-18 14:51:41 +02002770 free(err);
Willy Tarreau09448f72014-06-25 18:12:15 +02002771 cfgerr++;
2772 }
Willy Tarreau09448f72014-06-25 18:12:15 +02002773 }
2774
Christopher Faulet6d0c3df2020-01-22 09:26:35 +01002775 /* check validity for 'http-after-response' layer 7 rules */
2776 list_for_each_entry(arule, &curproxy->http_after_res_rules, list) {
2777 err = NULL;
2778 if (arule->check_ptr && !arule->check_ptr(arule, curproxy, &err)) {
2779 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
2780 free(err);
2781 cfgerr++;
2782 }
2783 }
2784
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002785 if (curproxy->table && curproxy->table->peers.name) {
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002786 struct peers *curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002787
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002788 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002789 if (strcmp(curpeers->id, curproxy->table->peers.name) == 0) {
2790 free((void *)curproxy->table->peers.name);
2791 curproxy->table->peers.p = curpeers;
Emeric Brun32da3c42010-09-23 18:39:19 +02002792 break;
2793 }
2794 }
2795
2796 if (!curpeers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002797 ha_alert("Proxy '%s': unable to find sync peers '%s'.\n",
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002798 curproxy->id, curproxy->table->peers.name);
2799 free((void *)curproxy->table->peers.name);
2800 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002801 cfgerr++;
2802 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002803 else if (curpeers->state == PR_STSTOPPED) {
2804 /* silently disable this peers section */
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002805 curproxy->table->peers.p = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02002806 }
Emeric Brun32da3c42010-09-23 18:39:19 +02002807 else if (!curpeers->peers_fe) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002808 ha_alert("Proxy '%s': unable to find local peer '%s' in peers section '%s'.\n",
2809 curproxy->id, localpeer, curpeers->id);
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01002810 curproxy->table->peers.p = NULL;
Emeric Brun32da3c42010-09-23 18:39:19 +02002811 cfgerr++;
2812 }
2813 }
2814
Simon Horman9dc49962015-01-30 11:22:59 +09002815
2816 if (curproxy->email_alert.mailers.name) {
2817 struct mailers *curmailers = mailers;
2818
2819 for (curmailers = mailers; curmailers; curmailers = curmailers->next) {
Christopher Faulet0108bb32017-10-20 21:34:32 +02002820 if (!strcmp(curmailers->id, curproxy->email_alert.mailers.name))
Simon Horman9dc49962015-01-30 11:22:59 +09002821 break;
Simon Horman9dc49962015-01-30 11:22:59 +09002822 }
Simon Horman9dc49962015-01-30 11:22:59 +09002823 if (!curmailers) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002824 ha_alert("Proxy '%s': unable to find mailers '%s'.\n",
2825 curproxy->id, curproxy->email_alert.mailers.name);
Simon Horman9dc49962015-01-30 11:22:59 +09002826 free_email_alert(curproxy);
2827 cfgerr++;
2828 }
Christopher Faulet0108bb32017-10-20 21:34:32 +02002829 else {
2830 err = NULL;
2831 if (init_email_alert(curmailers, curproxy, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002832 ha_alert("Proxy '%s': %s.\n", curproxy->id, err);
Christopher Faulet0108bb32017-10-20 21:34:32 +02002833 free(err);
2834 cfgerr++;
2835 }
2836 }
Simon Horman9dc49962015-01-30 11:22:59 +09002837 }
2838
Willy Tarreauee4f5f82019-10-09 09:59:22 +02002839 if (curproxy->uri_auth && curproxy->uri_auth != defproxy.uri_auth &&
Willy Tarreauff011f22011-01-06 17:51:27 +01002840 !LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules) &&
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002841 (curproxy->uri_auth->userlist || curproxy->uri_auth->auth_realm )) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002842 ha_alert("%s '%s': stats 'auth'/'realm' and 'http-request' can't be used at the same time.\n",
2843 "proxy", curproxy->id);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002844 cfgerr++;
2845 goto out_uri_auth_compat;
2846 }
2847
Willy Tarreauee4f5f82019-10-09 09:59:22 +02002848 if (curproxy->uri_auth && curproxy->uri_auth->userlist &&
2849 (curproxy->uri_auth != defproxy.uri_auth ||
2850 LIST_ISEMPTY(&curproxy->uri_auth->http_req_rules))) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002851 const char *uri_auth_compat_req[10];
Thierry FOURNIERa28a9422015-08-04 19:35:46 +02002852 struct act_rule *rule;
Willy Tarreau95fa4692010-02-01 13:05:50 +01002853 int i = 0;
Willy Tarreau95fa4692010-02-01 13:05:50 +01002854 /* build the ACL condition from scratch. We're relying on anonymous ACLs for that */
2855 uri_auth_compat_req[i++] = "auth";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002856
2857 if (curproxy->uri_auth->auth_realm) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002858 uri_auth_compat_req[i++] = "realm";
2859 uri_auth_compat_req[i++] = curproxy->uri_auth->auth_realm;
2860 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002861
Willy Tarreau95fa4692010-02-01 13:05:50 +01002862 uri_auth_compat_req[i++] = "unless";
2863 uri_auth_compat_req[i++] = "{";
2864 uri_auth_compat_req[i++] = "http_auth(.internal-stats-userlist)";
2865 uri_auth_compat_req[i++] = "}";
2866 uri_auth_compat_req[i++] = "";
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002867
Willy Tarreauff011f22011-01-06 17:51:27 +01002868 rule = parse_http_req_cond(uri_auth_compat_req, "internal-stats-auth-compat", 0, curproxy);
2869 if (!rule) {
Willy Tarreau95fa4692010-02-01 13:05:50 +01002870 cfgerr++;
2871 break;
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002872 }
2873
Willy Tarreauff011f22011-01-06 17:51:27 +01002874 LIST_ADDQ(&curproxy->uri_auth->http_req_rules, &rule->list);
Willy Tarreau95fa4692010-02-01 13:05:50 +01002875
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002876 if (curproxy->uri_auth->auth_realm) {
2877 free(curproxy->uri_auth->auth_realm);
2878 curproxy->uri_auth->auth_realm = NULL;
2879 }
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002880 }
2881out_uri_auth_compat:
2882
Dragan Dosen43885c72015-10-01 13:18:13 +02002883 /* check whether we have a log server that uses RFC5424 log format */
Dragan Dosen1322d092015-09-22 16:05:32 +02002884 list_for_each_entry(tmplogsrv, &curproxy->logsrvs, list) {
Dragan Dosen43885c72015-10-01 13:18:13 +02002885 if (tmplogsrv->format == LOG_FORMAT_RFC5424) {
2886 if (!curproxy->conf.logformat_sd_string) {
2887 /* set the default logformat_sd_string */
2888 curproxy->conf.logformat_sd_string = default_rfc5424_sd_log_format;
2889 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002890 break;
Dragan Dosen1322d092015-09-22 16:05:32 +02002891 }
Dragan Dosen1322d092015-09-22 16:05:32 +02002892 }
Dragan Dosen68d2e3a2015-09-19 22:35:44 +02002893
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002894 /* compile the log format */
2895 if (!(curproxy->cap & PR_CAP_FE)) {
Willy Tarreau62a61232013-04-12 18:13:46 +02002896 if (curproxy->conf.logformat_string != default_http_log_format &&
2897 curproxy->conf.logformat_string != default_tcp_log_format &&
2898 curproxy->conf.logformat_string != clf_http_log_format)
2899 free(curproxy->conf.logformat_string);
2900 curproxy->conf.logformat_string = NULL;
2901 free(curproxy->conf.lfs_file);
2902 curproxy->conf.lfs_file = NULL;
2903 curproxy->conf.lfs_line = 0;
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002904
2905 if (curproxy->conf.logformat_sd_string != default_rfc5424_sd_log_format)
2906 free(curproxy->conf.logformat_sd_string);
2907 curproxy->conf.logformat_sd_string = NULL;
2908 free(curproxy->conf.lfsd_file);
2909 curproxy->conf.lfsd_file = NULL;
2910 curproxy->conf.lfsd_line = 0;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002911 }
2912
Willy Tarreau62a61232013-04-12 18:13:46 +02002913 if (curproxy->conf.logformat_string) {
2914 curproxy->conf.args.ctx = ARGC_LOG;
2915 curproxy->conf.args.file = curproxy->conf.lfs_file;
2916 curproxy->conf.args.line = curproxy->conf.lfs_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002917 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002918 if (!parse_logformat_string(curproxy->conf.logformat_string, curproxy, &curproxy->logformat, LOG_OPT_MANDATORY,
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002919 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002920 ha_alert("Parsing [%s:%d]: failed to parse log-format : %s.\n",
2921 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002922 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002923 cfgerr++;
2924 }
Willy Tarreau62a61232013-04-12 18:13:46 +02002925 curproxy->conf.args.file = NULL;
2926 curproxy->conf.args.line = 0;
2927 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002928
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002929 if (curproxy->conf.logformat_sd_string) {
2930 curproxy->conf.args.ctx = ARGC_LOGSD;
2931 curproxy->conf.args.file = curproxy->conf.lfsd_file;
2932 curproxy->conf.args.line = curproxy->conf.lfsd_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002933 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002934 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 +01002935 SMP_VAL_FE_LOG_END, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002936 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
2937 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002938 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002939 cfgerr++;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002940 } else if (!add_to_logformat_list(NULL, NULL, LF_SEPARATOR, &curproxy->logformat_sd, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002941 ha_alert("Parsing [%s:%d]: failed to parse log-format-sd : %s.\n",
2942 curproxy->conf.lfs_file, curproxy->conf.lfs_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002943 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002944 cfgerr++;
2945 }
Dragan Dosen0b85ece2015-09-25 19:17:44 +02002946 curproxy->conf.args.file = NULL;
2947 curproxy->conf.args.line = 0;
2948 }
2949
Willy Tarreau62a61232013-04-12 18:13:46 +02002950 if (curproxy->conf.uniqueid_format_string) {
2951 curproxy->conf.args.ctx = ARGC_UIF;
2952 curproxy->conf.args.file = curproxy->conf.uif_file;
2953 curproxy->conf.args.line = curproxy->conf.uif_line;
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002954 err = NULL;
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002955 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 +01002956 (curproxy->cap & PR_CAP_FE) ? SMP_VAL_FE_HRQ_HDR : SMP_VAL_BE_HRQ_HDR, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002957 ha_alert("Parsing [%s:%d]: failed to parse unique-id : %s.\n",
2958 curproxy->conf.uif_file, curproxy->conf.uif_line, err);
Thierry FOURNIER / OZON.IO8a4e4422016-11-23 00:41:28 +01002959 free(err);
Thierry FOURNIER / OZON.IO59fd5112016-11-22 23:50:02 +01002960 cfgerr++;
2961 }
Willy Tarreau62a61232013-04-12 18:13:46 +02002962 curproxy->conf.args.file = NULL;
2963 curproxy->conf.args.line = 0;
2964 }
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002965
Thierry FOURNIER9eec0a62014-01-22 18:38:02 +01002966 /* only now we can check if some args remain unresolved.
2967 * This must be done after the users and groups resolution.
2968 */
Willy Tarreaua4312fa2013-04-02 16:34:32 +02002969 cfgerr += smp_resolve_args(curproxy);
2970 if (!cfgerr)
2971 cfgerr += acl_find_targets(curproxy);
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01002972
Willy Tarreau2738a142006-07-08 17:28:09 +02002973 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002974 (((curproxy->cap & PR_CAP_FE) && !curproxy->timeout.client) ||
Willy Tarreaud825eef2007-05-12 22:35:00 +02002975 ((curproxy->cap & PR_CAP_BE) && (curproxy->srv) &&
Willy Tarreauce887fd2012-05-12 12:50:00 +02002976 (!curproxy->timeout.connect ||
2977 (!curproxy->timeout.server && (curproxy->mode == PR_MODE_HTTP || !curproxy->timeout.tunnel)))))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002978 ha_warning("config : missing timeouts for %s '%s'.\n"
2979 " | While not properly invalid, you will certainly encounter various problems\n"
2980 " | with such a configuration. To fix this, please ensure that all following\n"
2981 " | timeouts are set to a non-zero value: 'client', 'connect', 'server'.\n",
2982 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02002983 err_code |= ERR_WARN;
Willy Tarreau2738a142006-07-08 17:28:09 +02002984 }
Willy Tarreauf3c69202006-07-09 16:42:34 +02002985
Willy Tarreau1fa31262007-12-03 00:36:16 +01002986 /* Historically, the tarpit and queue timeouts were inherited from contimeout.
2987 * We must still support older configurations, so let's find out whether those
2988 * parameters have been set or must be copied from contimeouts.
2989 */
2990 if (curproxy != &defproxy) {
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002991 if (!curproxy->timeout.tarpit ||
2992 curproxy->timeout.tarpit == defproxy.timeout.tarpit) {
Willy Tarreau1fa31262007-12-03 00:36:16 +01002993 /* tarpit timeout not set. We search in the following order:
2994 * default.tarpit, curr.connect, default.connect.
2995 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002996 if (defproxy.timeout.tarpit)
Willy Tarreau1fa31262007-12-03 00:36:16 +01002997 curproxy->timeout.tarpit = defproxy.timeout.tarpit;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02002998 else if (curproxy->timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01002999 curproxy->timeout.tarpit = curproxy->timeout.connect;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003000 else if (defproxy.timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003001 curproxy->timeout.tarpit = defproxy.timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01003002 }
3003 if ((curproxy->cap & PR_CAP_BE) &&
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003004 (!curproxy->timeout.queue ||
3005 curproxy->timeout.queue == defproxy.timeout.queue)) {
Willy Tarreau1fa31262007-12-03 00:36:16 +01003006 /* queue timeout not set. We search in the following order:
3007 * default.queue, curr.connect, default.connect.
3008 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003009 if (defproxy.timeout.queue)
Willy Tarreau1fa31262007-12-03 00:36:16 +01003010 curproxy->timeout.queue = defproxy.timeout.queue;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003011 else if (curproxy->timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003012 curproxy->timeout.queue = curproxy->timeout.connect;
Willy Tarreau0c303ee2008-07-07 00:09:58 +02003013 else if (defproxy.timeout.connect)
Willy Tarreaud7c30f92007-12-03 01:38:36 +01003014 curproxy->timeout.queue = defproxy.timeout.connect;
Willy Tarreau1fa31262007-12-03 00:36:16 +01003015 }
3016 }
3017
Christopher Faulete5870d82020-04-15 11:32:03 +02003018 if ((curproxy->tcpcheck_rules.flags & TCPCHK_RULES_UNUSED_TCP_RS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003019 ha_warning("config : %s '%s' uses tcp-check rules without 'option tcp-check', so the rules are ignored.\n",
3020 proxy_type_str(curproxy), curproxy->id);
Willy Tarreau215663d2014-06-13 18:30:23 +02003021 err_code |= ERR_WARN;
3022 }
3023
Willy Tarreau193b8c62012-11-22 00:17:38 +01003024 /* ensure that cookie capture length is not too large */
3025 if (curproxy->capture_len >= global.tune.cookie_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003026 ha_warning("config : truncating capture length to %d bytes for %s '%s'.\n",
3027 global.tune.cookie_len - 1, proxy_type_str(curproxy), curproxy->id);
Willy Tarreau193b8c62012-11-22 00:17:38 +01003028 err_code |= ERR_WARN;
3029 curproxy->capture_len = global.tune.cookie_len - 1;
3030 }
3031
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003032 /* The small pools required for the capture lists */
Willy Tarreau9a54e132012-03-24 08:33:05 +01003033 if (curproxy->nb_req_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003034 curproxy->req_cap_pool = create_pool("ptrcap",
3035 curproxy->nb_req_cap * sizeof(char *),
3036 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003037 }
3038
3039 if (curproxy->nb_rsp_cap) {
Willy Tarreaud9ed3d22014-06-13 12:23:06 +02003040 curproxy->rsp_cap_pool = create_pool("ptrcap",
3041 curproxy->nb_rsp_cap * sizeof(char *),
3042 MEM_F_SHARED);
Willy Tarreau9a54e132012-03-24 08:33:05 +01003043 }
Willy Tarreaucf7f3202007-05-13 22:46:04 +02003044
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003045 switch (curproxy->load_server_state_from_file) {
3046 case PR_SRV_STATE_FILE_UNSPEC:
3047 curproxy->load_server_state_from_file = PR_SRV_STATE_FILE_NONE;
3048 break;
3049 case PR_SRV_STATE_FILE_GLOBAL:
3050 if (!global.server_state_file) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003051 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",
3052 curproxy->id);
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003053 err_code |= ERR_WARN;
3054 }
3055 break;
3056 }
3057
Willy Tarreaubaaee002006-06-26 02:48:02 +02003058 /* first, we will invert the servers list order */
3059 newsrv = NULL;
3060 while (curproxy->srv) {
3061 struct server *next;
3062
3063 next = curproxy->srv->next;
3064 curproxy->srv->next = newsrv;
3065 newsrv = curproxy->srv;
3066 if (!next)
3067 break;
3068 curproxy->srv = next;
3069 }
3070
Willy Tarreau17edc812014-01-03 12:14:34 +01003071 /* Check that no server name conflicts. This causes trouble in the stats.
3072 * We only emit a warning for the first conflict affecting each server,
3073 * in order to avoid combinatory explosion if all servers have the same
3074 * name. We do that only for servers which do not have an explicit ID,
3075 * because these IDs were made also for distinguishing them and we don't
3076 * want to annoy people who correctly manage them.
3077 */
3078 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3079 struct server *other_srv;
3080
3081 if (newsrv->puid)
3082 continue;
3083
3084 for (other_srv = curproxy->srv; other_srv && other_srv != newsrv; other_srv = other_srv->next) {
3085 if (!other_srv->puid && strcmp(other_srv->id, newsrv->id) == 0) {
Willy Tarreaub01302f2019-05-27 19:31:06 +02003086 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 +01003087 newsrv->conf.file, newsrv->conf.line,
3088 proxy_type_str(curproxy), curproxy->id,
3089 newsrv->id, other_srv->conf.line);
Willy Tarreaub01302f2019-05-27 19:31:06 +02003090 cfgerr++;
Willy Tarreau17edc812014-01-03 12:14:34 +01003091 break;
3092 }
3093 }
3094 }
3095
Willy Tarreaudd701652010-05-25 23:03:02 +02003096 /* assign automatic UIDs to servers which don't have one yet */
3097 next_id = 1;
3098 newsrv = curproxy->srv;
3099 while (newsrv != NULL) {
3100 if (!newsrv->puid) {
3101 /* server ID not set, use automatic numbering with first
3102 * spare entry starting with next_svid.
3103 */
3104 next_id = get_next_id(&curproxy->conf.used_server_id, next_id);
3105 newsrv->conf.id.key = newsrv->puid = next_id;
3106 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Frédéric Lécaille84d60462019-05-17 14:29:15 +02003107 newsrv->conf.name.key = newsrv->id;
3108 ebis_insert(&curproxy->conf.used_server_name, &newsrv->conf.name);
Willy Tarreaudd701652010-05-25 23:03:02 +02003109 }
3110 next_id++;
3111 newsrv = newsrv->next;
3112 }
3113
Willy Tarreau20697042007-11-15 23:26:18 +01003114 curproxy->lbprm.wmult = 1; /* default weight multiplier */
Willy Tarreau5dc2fa62007-11-19 19:10:18 +01003115 curproxy->lbprm.wdiv = 1; /* default weight divider */
Willy Tarreaubaaee002006-06-26 02:48:02 +02003116
Willy Tarreau62c3be22012-01-20 13:12:32 +01003117 /*
3118 * If this server supports a maxconn parameter, it needs a dedicated
3119 * tasks to fill the emptied slots when a connection leaves.
3120 * Also, resolve deferred tracking dependency if needed.
3121 */
3122 newsrv = curproxy->srv;
3123 while (newsrv != NULL) {
3124 if (newsrv->minconn > newsrv->maxconn) {
3125 /* Only 'minconn' was specified, or it was higher than or equal
3126 * to 'maxconn'. Let's turn this into maxconn and clean it, as
3127 * this will avoid further useless expensive computations.
3128 */
3129 newsrv->maxconn = newsrv->minconn;
3130 } else if (newsrv->maxconn && !newsrv->minconn) {
3131 /* minconn was not specified, so we set it to maxconn */
3132 newsrv->minconn = newsrv->maxconn;
3133 }
3134
Willy Tarreau17d45382016-12-22 21:16:08 +01003135 /* this will also properly set the transport layer for prod and checks */
Christopher Fauletf61f33a2020-03-27 18:55:49 +01003136 if (newsrv->use_ssl == 1 || newsrv->check.use_ssl == 1 || (newsrv->proxy->options & PR_O_TCPCHK_SSL)) {
Willy Tarreau17d45382016-12-22 21:16:08 +01003137 if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
3138 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(newsrv);
3139 }
Emeric Brun94324a42012-10-11 14:00:19 +02003140
Willy Tarreau034c88c2017-01-23 23:36:45 +01003141 if ((newsrv->flags & SRV_F_FASTOPEN) &&
3142 ((curproxy->retry_type & (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)) !=
3143 (PR_RE_DISCONNECTED | PR_RE_TIMEOUT)))
3144 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",
3145 newsrv->conf.file, newsrv->conf.line,
3146 proxy_type_str(curproxy), curproxy->id,
3147 newsrv->id);
3148
Willy Tarreau62c3be22012-01-20 13:12:32 +01003149 if (newsrv->trackit) {
3150 struct proxy *px;
Willy Tarreau32091232014-05-16 13:52:00 +02003151 struct server *srv, *loop;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003152 char *pname, *sname;
3153
3154 pname = newsrv->trackit;
3155 sname = strrchr(pname, '/');
3156
3157 if (sname)
3158 *sname++ = '\0';
3159 else {
3160 sname = pname;
3161 pname = NULL;
3162 }
3163
3164 if (pname) {
Willy Tarreau9e0bb102015-05-26 11:24:42 +02003165 px = proxy_be_by_name(pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003166 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003167 ha_alert("config : %s '%s', server '%s': unable to find required proxy '%s' for tracking.\n",
3168 proxy_type_str(curproxy), curproxy->id,
3169 newsrv->id, pname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003170 cfgerr++;
3171 goto next_srv;
3172 }
3173 } else
3174 px = curproxy;
3175
3176 srv = findserver(px, sname);
3177 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003178 ha_alert("config : %s '%s', server '%s': unable to find required server '%s' for tracking.\n",
3179 proxy_type_str(curproxy), curproxy->id,
3180 newsrv->id, sname);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003181 cfgerr++;
3182 goto next_srv;
3183 }
3184
Christopher Faulet8892e5d2020-03-26 19:48:20 +01003185 if (!srv->do_check && !srv->do_agent && !srv->track && !srv->trackit) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003186 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for "
3187 "tracking as it does not have any check nor agent enabled.\n",
3188 proxy_type_str(curproxy), curproxy->id,
3189 newsrv->id, px->id, srv->id);
Willy Tarreau32091232014-05-16 13:52:00 +02003190 cfgerr++;
3191 goto next_srv;
3192 }
3193
3194 for (loop = srv->track; loop && loop != newsrv; loop = loop->track);
3195
Frédéric Lécaille2efc6492017-03-14 14:32:17 +01003196 if (newsrv == srv || loop) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003197 ha_alert("config : %s '%s', server '%s': unable to track %s/%s as it "
3198 "belongs to a tracking chain looping back to %s/%s.\n",
3199 proxy_type_str(curproxy), curproxy->id,
3200 newsrv->id, px->id, srv->id, px->id,
3201 newsrv == srv ? srv->id : loop->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003202 cfgerr++;
3203 goto next_srv;
3204 }
3205
3206 if (curproxy != px &&
3207 (curproxy->options & PR_O_DISABLE404) != (px->options & PR_O_DISABLE404)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003208 ha_alert("config : %s '%s', server '%s': unable to use %s/%s for"
3209 "tracking: disable-on-404 option inconsistency.\n",
3210 proxy_type_str(curproxy), curproxy->id,
3211 newsrv->id, px->id, srv->id);
Willy Tarreau62c3be22012-01-20 13:12:32 +01003212 cfgerr++;
3213 goto next_srv;
3214 }
3215
Willy Tarreau62c3be22012-01-20 13:12:32 +01003216 newsrv->track = srv;
Willy Tarreau1a53a3a2013-12-11 15:27:05 +01003217 newsrv->tracknext = srv->trackers;
3218 srv->trackers = newsrv;
Willy Tarreau62c3be22012-01-20 13:12:32 +01003219
3220 free(newsrv->trackit);
3221 newsrv->trackit = NULL;
3222 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003223
Willy Tarreau62c3be22012-01-20 13:12:32 +01003224 next_srv:
3225 newsrv = newsrv->next;
3226 }
3227
Olivier Houchard4e694042017-03-14 20:01:29 +01003228 /*
3229 * Try to generate dynamic cookies for servers now.
3230 * It couldn't be done earlier, since at the time we parsed
3231 * the server line, we may not have known yet that we
3232 * should use dynamic cookies, or the secret key may not
3233 * have been provided yet.
3234 */
3235 if (curproxy->ck_opts & PR_CK_DYNAMIC) {
3236 newsrv = curproxy->srv;
3237 while (newsrv != NULL) {
3238 srv_set_dyncookie(newsrv);
3239 newsrv = newsrv->next;
3240 }
3241
3242 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003243 /* We have to initialize the server lookup mechanism depending
Joseph Herlanta14c03e2018-11-15 14:04:19 -08003244 * on what LB algorithm was chosen.
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003245 */
3246
3247 curproxy->lbprm.algo &= ~(BE_LB_LKUP | BE_LB_PROP_DYN);
3248 switch (curproxy->lbprm.algo & BE_LB_KIND) {
3249 case BE_LB_KIND_RR:
Willy Tarreau9757a382009-10-03 12:56:50 +02003250 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_STATIC) {
3251 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3252 init_server_map(curproxy);
Willy Tarreau760e81d2018-05-03 07:20:40 +02003253 } else if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_RR_RANDOM) {
3254 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3255 chash_init_server_tree(curproxy);
Willy Tarreau9757a382009-10-03 12:56:50 +02003256 } else {
3257 curproxy->lbprm.algo |= BE_LB_LKUP_RRTREE | BE_LB_PROP_DYN;
3258 fwrr_init_server_groups(curproxy);
3259 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003260 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003261
Willy Tarreau3ebb1162012-02-13 16:57:44 +01003262 case BE_LB_KIND_CB:
Willy Tarreauf09c6602012-02-13 17:12:08 +01003263 if ((curproxy->lbprm.algo & BE_LB_PARM) == BE_LB_CB_LC) {
3264 curproxy->lbprm.algo |= BE_LB_LKUP_LCTREE | BE_LB_PROP_DYN;
3265 fwlc_init_server_tree(curproxy);
3266 } else {
3267 curproxy->lbprm.algo |= BE_LB_LKUP_FSTREE | BE_LB_PROP_DYN;
3268 fas_init_server_tree(curproxy);
3269 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003270 break;
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003271
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003272 case BE_LB_KIND_HI:
Willy Tarreau6b2e11b2009-10-01 07:52:15 +02003273 if ((curproxy->lbprm.algo & BE_LB_HASH_TYPE) == BE_LB_HASH_CONS) {
3274 curproxy->lbprm.algo |= BE_LB_LKUP_CHTREE | BE_LB_PROP_DYN;
3275 chash_init_server_tree(curproxy);
3276 } else {
3277 curproxy->lbprm.algo |= BE_LB_LKUP_MAP;
3278 init_server_map(curproxy);
3279 }
Willy Tarreauf3e49f92009-10-03 12:21:20 +02003280 break;
3281 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003282 HA_SPIN_INIT(&curproxy->lbprm.lock);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003283
3284 if (curproxy->options & PR_O_LOGASAP)
3285 curproxy->to_log &= ~LW_BYTES;
3286
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003287 if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
Dragan Dosen0b85ece2015-09-25 19:17:44 +02003288 (curproxy->cap & PR_CAP_FE) && LIST_ISEMPTY(&curproxy->logsrvs) &&
3289 (!LIST_ISEMPTY(&curproxy->logformat) || !LIST_ISEMPTY(&curproxy->logformat_sd))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003290 ha_warning("config : log format ignored for %s '%s' since it has no log address.\n",
3291 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue7ded1f2009-08-09 10:11:45 +02003292 err_code |= ERR_WARN;
3293 }
3294
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003295 if (curproxy->mode != PR_MODE_HTTP) {
3296 int optnum;
3297
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003298 if (curproxy->uri_auth) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003299 ha_warning("config : 'stats' statement ignored for %s '%s' as it requires HTTP mode.\n",
3300 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003301 err_code |= ERR_WARN;
3302 curproxy->uri_auth = NULL;
3303 }
3304
Willy Tarreaude7dc882017-03-10 11:49:21 +01003305 if (curproxy->capture_name) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003306 ha_warning("config : 'capture' statement ignored for %s '%s' as it requires HTTP mode.\n",
3307 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003308 err_code |= ERR_WARN;
3309 }
3310
3311 if (!LIST_ISEMPTY(&curproxy->http_req_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003312 ha_warning("config : 'http-request' rules ignored for %s '%s' as they require HTTP mode.\n",
3313 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003314 err_code |= ERR_WARN;
3315 }
3316
3317 if (!LIST_ISEMPTY(&curproxy->http_res_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003318 ha_warning("config : 'http-response' rules ignored for %s '%s' as they require HTTP mode.\n",
3319 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003320 err_code |= ERR_WARN;
3321 }
3322
Willy Tarreaude7dc882017-03-10 11:49:21 +01003323 if (!LIST_ISEMPTY(&curproxy->redirect_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003324 ha_warning("config : 'redirect' rules ignored for %s '%s' as they require HTTP mode.\n",
3325 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaude7dc882017-03-10 11:49:21 +01003326 err_code |= ERR_WARN;
3327 }
3328
Willy Tarreau87cf5142011-08-19 22:57:24 +02003329 if (curproxy->options & (PR_O_FWDFOR | PR_O_FF_ALWAYS)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003330 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3331 "forwardfor", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003332 err_code |= ERR_WARN;
Willy Tarreau87cf5142011-08-19 22:57:24 +02003333 curproxy->options &= ~(PR_O_FWDFOR | PR_O_FF_ALWAYS);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003334 }
3335
3336 if (curproxy->options & PR_O_ORGTO) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003337 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3338 "originalto", proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003339 err_code |= ERR_WARN;
3340 curproxy->options &= ~PR_O_ORGTO;
3341 }
3342
3343 for (optnum = 0; cfg_opts[optnum].name; optnum++) {
3344 if (cfg_opts[optnum].mode == PR_MODE_HTTP &&
3345 (curproxy->cap & cfg_opts[optnum].cap) &&
3346 (curproxy->options & cfg_opts[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003347 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3348 cfg_opts[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003349 err_code |= ERR_WARN;
3350 curproxy->options &= ~cfg_opts[optnum].val;
3351 }
3352 }
3353
3354 for (optnum = 0; cfg_opts2[optnum].name; optnum++) {
3355 if (cfg_opts2[optnum].mode == PR_MODE_HTTP &&
3356 (curproxy->cap & cfg_opts2[optnum].cap) &&
3357 (curproxy->options2 & cfg_opts2[optnum].val)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003358 ha_warning("config : 'option %s' ignored for %s '%s' as it requires HTTP mode.\n",
3359 cfg_opts2[optnum].name, proxy_type_str(curproxy), curproxy->id);
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003360 err_code |= ERR_WARN;
3361 curproxy->options2 &= ~cfg_opts2[optnum].val;
3362 }
3363 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003364
Willy Tarreau29fbe512015-08-20 19:35:14 +02003365#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003366 if (curproxy->conn_src.bind_hdr_occ) {
3367 curproxy->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003368 ha_warning("config : %s '%s' : ignoring use of header %s as source IP in non-HTTP mode.\n",
3369 proxy_type_str(curproxy), curproxy->id, curproxy->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003370 err_code |= ERR_WARN;
3371 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003372#endif
Willy Tarreaue24fdfb2010-03-25 07:22:56 +01003373 }
3374
Willy Tarreaubaaee002006-06-26 02:48:02 +02003375 /*
Willy Tarreau21d2af32008-02-14 20:25:24 +01003376 * ensure that we're not cross-dressing a TCP server into HTTP.
3377 */
3378 newsrv = curproxy->srv;
3379 while (newsrv != NULL) {
Willy Tarreau0cec3312011-10-31 13:49:26 +01003380 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->rdr_len) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003381 ha_alert("config : %s '%s' : server cannot have cookie or redirect prefix in non-HTTP mode.\n",
3382 proxy_type_str(curproxy), curproxy->id);
Willy Tarreaubb925012009-07-23 13:36:36 +02003383 cfgerr++;
Willy Tarreau21d2af32008-02-14 20:25:24 +01003384 }
Willy Tarreaubce70882009-09-07 11:51:47 +02003385
Willy Tarreau0cec3312011-10-31 13:49:26 +01003386 if ((curproxy->mode != PR_MODE_HTTP) && newsrv->cklen) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003387 ha_warning("config : %s '%s' : ignoring cookie for server '%s' as HTTP mode is disabled.\n",
3388 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau0cec3312011-10-31 13:49:26 +01003389 err_code |= ERR_WARN;
3390 }
3391
Willy Tarreauc93cd162014-05-13 15:54:22 +02003392 if ((newsrv->flags & SRV_F_MAPPORTS) && (curproxy->options2 & PR_O2_RDPC_PRST)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003393 ha_warning("config : %s '%s' : RDP cookie persistence will not work for server '%s' because it lacks an explicit port number.\n",
3394 proxy_type_str(curproxy), curproxy->id, newsrv->id);
Willy Tarreau82ffa392013-08-13 17:19:08 +02003395 err_code |= ERR_WARN;
3396 }
3397
Willy Tarreau29fbe512015-08-20 19:35:14 +02003398#if defined(CONFIG_HAP_TRANSPARENT)
Willy Tarreauef9a3602012-12-08 22:29:20 +01003399 if (curproxy->mode != PR_MODE_HTTP && newsrv->conn_src.bind_hdr_occ) {
3400 newsrv->conn_src.bind_hdr_occ = 0;
Christopher Faulet767a84b2017-11-24 16:50:31 +01003401 ha_warning("config : %s '%s' : server %s cannot use header %s as source IP in non-HTTP mode.\n",
3402 proxy_type_str(curproxy), curproxy->id, newsrv->id, newsrv->conn_src.bind_hdr_name);
Willy Tarreaubce70882009-09-07 11:51:47 +02003403 err_code |= ERR_WARN;
3404 }
Willy Tarreauefa5f512010-03-30 20:13:29 +02003405#endif
Willy Tarreau4c183462017-01-06 12:21:38 +01003406
Willy Tarreau46deab62018-04-28 07:18:15 +02003407 if ((curproxy->mode != PR_MODE_HTTP) && (curproxy->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR)
3408 curproxy->options &= ~PR_O_REUSE_MASK;
3409
Willy Tarreau21d2af32008-02-14 20:25:24 +01003410 newsrv = newsrv->next;
3411 }
3412
Christopher Fauletd7c91962015-04-30 11:48:27 +02003413 /* Check filter configuration, if any */
3414 cfgerr += flt_check(curproxy);
3415
Willy Tarreauc1a21672009-08-16 22:37:44 +02003416 if (curproxy->cap & PR_CAP_FE) {
Willy Tarreau050536d2012-10-04 08:47:34 +02003417 if (!curproxy->accept)
3418 curproxy->accept = frontend_accept;
Willy Tarreau81f9aa32010-06-01 17:45:26 +02003419
Willy Tarreauc1a21672009-08-16 22:37:44 +02003420 if (curproxy->tcp_req.inspect_delay ||
3421 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
Willy Tarreaufb356202010-08-03 14:02:05 +02003422 curproxy->fe_req_ana |= AN_REQ_INSPECT_FE;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003423
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003424 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003425 curproxy->fe_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_PROCESS_FE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003426 curproxy->fe_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_FE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003427 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003428
William Lallemandcf62f7e2018-10-26 14:47:40 +02003429 if (curproxy->mode == PR_MODE_CLI) {
3430 curproxy->fe_req_ana |= AN_REQ_WAIT_CLI;
3431 curproxy->fe_rsp_ana |= AN_RES_WAIT_CLI;
3432 }
3433
Willy Tarreauc1a21672009-08-16 22:37:44 +02003434 /* both TCP and HTTP must check switching rules */
3435 curproxy->fe_req_ana |= AN_REQ_SWITCHING_RULES;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003436
3437 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003438 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003439 curproxy->fe_req_ana |= AN_REQ_FLT_START_FE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3440 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 +01003441 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003442 curproxy->fe_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3443 curproxy->fe_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003444 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003445 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003446 }
3447
3448 if (curproxy->cap & PR_CAP_BE) {
Willy Tarreaufb356202010-08-03 14:02:05 +02003449 if (curproxy->tcp_req.inspect_delay ||
3450 !LIST_ISEMPTY(&curproxy->tcp_req.inspect_rules))
3451 curproxy->be_req_ana |= AN_REQ_INSPECT_BE;
3452
Emeric Brun97679e72010-09-23 17:56:44 +02003453 if (!LIST_ISEMPTY(&curproxy->tcp_rep.inspect_rules))
3454 curproxy->be_rsp_ana |= AN_RES_INSPECT;
3455
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003456 if (curproxy->mode == PR_MODE_HTTP) {
Willy Tarreauc1a21672009-08-16 22:37:44 +02003457 curproxy->be_req_ana |= AN_REQ_WAIT_HTTP | AN_REQ_HTTP_INNER | AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02003458 curproxy->be_rsp_ana |= AN_RES_WAIT_HTTP | AN_RES_HTTP_PROCESS_BE;
Willy Tarreau4e5b8282009-08-16 22:57:50 +02003459 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003460
3461 /* If the backend does requires RDP cookie persistence, we have to
3462 * enable the corresponding analyser.
3463 */
3464 if (curproxy->options2 & PR_O2_RDPC_PRST)
3465 curproxy->be_req_ana |= AN_REQ_PRST_RDP_COOKIE;
Christopher Fauletd7c91962015-04-30 11:48:27 +02003466
3467 /* Add filters analyzers if needed */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01003468 if (!LIST_ISEMPTY(&curproxy->filter_configs)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003469 curproxy->be_req_ana |= AN_REQ_FLT_START_BE | AN_REQ_FLT_XFER_DATA | AN_REQ_FLT_END;
3470 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 +01003471 if (curproxy->mode == PR_MODE_HTTP) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01003472 curproxy->be_req_ana |= AN_REQ_FLT_HTTP_HDRS;
3473 curproxy->be_rsp_ana |= AN_RES_FLT_HTTP_HDRS;
Christopher Faulet309c6412015-12-02 09:57:32 +01003474 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02003475 }
Willy Tarreauc1a21672009-08-16 22:37:44 +02003476 }
Christopher Fauleta717b992018-04-10 14:43:00 +02003477
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003478 /* Check the mux protocols, if any, for each listener and server
Christopher Fauleta717b992018-04-10 14:43:00 +02003479 * attached to the current proxy */
3480 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3481 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003482 const struct mux_proto_list *mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003483
3484 if (!bind_conf->mux_proto)
3485 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003486
3487 /* it is possible that an incorrect mux was referenced
3488 * due to the proxy's mode not being taken into account
3489 * on first pass. Let's adjust it now.
3490 */
3491 mux_ent = conn_get_best_mux_entry(bind_conf->mux_proto->token, PROTO_SIDE_FE, mode);
3492
3493 if (!mux_ent || !isteq(mux_ent->token, bind_conf->mux_proto->token)) {
Christopher Fauleta717b992018-04-10 14:43:00 +02003494 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for 'bind %s' at [%s:%d].\n",
3495 proxy_type_str(curproxy), curproxy->id,
3496 (int)bind_conf->mux_proto->token.len,
3497 bind_conf->mux_proto->token.ptr,
3498 bind_conf->arg, bind_conf->file, bind_conf->line);
3499 cfgerr++;
3500 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003501
3502 /* update the mux */
3503 bind_conf->mux_proto = mux_ent;
Christopher Fauleta717b992018-04-10 14:43:00 +02003504 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003505 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3506 int mode = (1 << (curproxy->mode == PR_MODE_HTTP));
Willy Tarreau76a551d2018-12-02 13:09:09 +01003507 const struct mux_proto_list *mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003508
3509 if (!newsrv->mux_proto)
3510 continue;
Willy Tarreau76a551d2018-12-02 13:09:09 +01003511
3512 /* it is possible that an incorrect mux was referenced
3513 * due to the proxy's mode not being taken into account
3514 * on first pass. Let's adjust it now.
3515 */
3516 mux_ent = conn_get_best_mux_entry(newsrv->mux_proto->token, PROTO_SIDE_BE, mode);
3517
3518 if (!mux_ent || !isteq(mux_ent->token, newsrv->mux_proto->token)) {
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003519 ha_alert("config : %s '%s' : MUX protocol '%.*s' is not usable for server '%s' at [%s:%d].\n",
3520 proxy_type_str(curproxy), curproxy->id,
3521 (int)newsrv->mux_proto->token.len,
3522 newsrv->mux_proto->token.ptr,
3523 newsrv->id, newsrv->conf.file, newsrv->conf.line);
3524 cfgerr++;
3525 }
Willy Tarreau76a551d2018-12-02 13:09:09 +01003526
3527 /* update the mux */
3528 newsrv->mux_proto = mux_ent;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02003529 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003530
3531 /* initialize idle conns lists */
3532 for (newsrv = curproxy->srv; newsrv; newsrv = newsrv->next) {
3533 int i;
3534
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003535 newsrv->available_conns = calloc((unsigned)global.nbthread, sizeof(*newsrv->available_conns));
Willy Tarreau835daa12019-02-07 14:46:29 +01003536
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003537 if (!newsrv->available_conns) {
Willy Tarreau835daa12019-02-07 14:46:29 +01003538 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003539 newsrv->conf.file, newsrv->conf.line, newsrv->id);
Willy Tarreau835daa12019-02-07 14:46:29 +01003540 cfgerr++;
3541 continue;
3542 }
3543
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003544 for (i = 0; i < global.nbthread; i++)
3545 LIST_INIT(&newsrv->available_conns[i]);
Willy Tarreau980855b2019-02-07 14:59:29 +01003546
3547 if (newsrv->max_idle_conns != 0) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003548 if (idle_conn_task == NULL) {
3549 idle_conn_task = task_new(MAX_THREADS_MASK);
3550 if (!idle_conn_task)
3551 goto err;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003552
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003553 idle_conn_task->process = srv_cleanup_idle_connections;
3554 idle_conn_task->context = NULL;
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003555
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003556 for (i = 0; i < global.nbthread; i++) {
Willy Tarreaubbb5f1d2019-10-18 08:50:49 +02003557 idle_conn_cleanup[i] = task_new(1UL << i);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003558 if (!idle_conn_cleanup[i])
3559 goto err;
3560 idle_conn_cleanup[i]->process = srv_cleanup_toremove_connections;
3561 idle_conn_cleanup[i]->context = NULL;
Olivier Houchard859dc802019-08-08 15:47:21 +02003562 MT_LIST_INIT(&toremove_connections[i]);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003563 }
3564 }
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003565
3566 newsrv->idle_conns = calloc((unsigned)global.nbthread, sizeof(*newsrv->idle_conns));
3567 if (!newsrv->idle_conns) {
3568 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
3569 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3570 cfgerr++;
3571 continue;
3572 }
3573
Olivier Houchard9ea5d362019-02-14 18:29:09 +01003574 for (i = 0; i < global.nbthread; i++)
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003575 MT_LIST_INIT(&newsrv->idle_conns[i]);
3576
3577 newsrv->safe_conns = calloc((unsigned)global.nbthread, sizeof(*newsrv->safe_conns));
3578 if (!newsrv->safe_conns) {
3579 ha_alert("parsing [%s:%d] : failed to allocate idle connections for server '%s'.\n",
3580 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3581 cfgerr++;
3582 continue;
3583 }
3584
3585 for (i = 0; i < global.nbthread; i++)
3586 MT_LIST_INIT(&newsrv->safe_conns[i]);
3587
3588 newsrv->curr_idle_thr = calloc(global.nbthread, sizeof(int));
Olivier Houchardf1314812019-02-18 16:41:17 +01003589 if (!newsrv->curr_idle_thr)
3590 goto err;
Willy Tarreau980855b2019-02-07 14:59:29 +01003591 continue;
3592 err:
3593 ha_alert("parsing [%s:%d] : failed to allocate idle connection tasks for server '%s'.\n",
3594 newsrv->conf.file, newsrv->conf.line, newsrv->id);
3595 cfgerr++;
3596 continue;
3597 }
Willy Tarreau835daa12019-02-07 14:46:29 +01003598 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003599 }
3600
3601 /***********************************************************/
3602 /* At this point, target names have already been resolved. */
3603 /***********************************************************/
3604
3605 /* Check multi-process mode compatibility */
3606
3607 if (global.nbproc > 1 && global.stats_fe) {
3608 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3609 unsigned long mask;
3610
Willy Tarreau6daac192019-02-02 17:39:53 +01003611 mask = proc_mask(global.stats_fe->bind_proc) && all_proc_mask;
3612 mask &= proc_mask(bind_conf->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003613
3614 /* stop here if more than one process is used */
Willy Tarreau9504dd62018-10-15 09:37:03 +02003615 if (atleast2(mask))
Willy Tarreau419ead82014-09-16 13:41:21 +02003616 break;
3617 }
3618 if (&bind_conf->by_fe != &global.stats_fe->conf.bind) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003619 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 +02003620 }
3621 }
3622
3623 /* Make each frontend inherit bind-process from its listeners when not specified. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003624 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003625 if (curproxy->bind_proc)
3626 continue;
3627
3628 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
3629 unsigned long mask;
3630
Willy Tarreau6daac192019-02-02 17:39:53 +01003631 mask = proc_mask(bind_conf->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003632 curproxy->bind_proc |= mask;
3633 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003634 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003635 }
3636
3637 if (global.stats_fe) {
3638 list_for_each_entry(bind_conf, &global.stats_fe->conf.bind, by_fe) {
3639 unsigned long mask;
3640
Cyril Bonté06181952016-02-24 00:14:54 +01003641 mask = bind_conf->bind_proc ? bind_conf->bind_proc : 0;
Willy Tarreau419ead82014-09-16 13:41:21 +02003642 global.stats_fe->bind_proc |= mask;
3643 }
Willy Tarreau6daac192019-02-02 17:39:53 +01003644 global.stats_fe->bind_proc = proc_mask(global.stats_fe->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003645 }
3646
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003647 /* propagate bindings from frontends to backends. Don't do it if there
3648 * are any fatal errors as we must not call it with unresolved proxies.
3649 */
3650 if (!cfgerr) {
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003651 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreauacbe8ab2014-10-01 20:50:17 +02003652 if (curproxy->cap & PR_CAP_FE)
3653 propagate_processes(curproxy, NULL);
3654 }
Willy Tarreau419ead82014-09-16 13:41:21 +02003655 }
3656
3657 /* Bind each unbound backend to all processes when not specified. */
Willy Tarreau6daac192019-02-02 17:39:53 +01003658 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
3659 curproxy->bind_proc = proc_mask(curproxy->bind_proc);
Willy Tarreau419ead82014-09-16 13:41:21 +02003660
3661 /*******************************************************/
3662 /* At this step, all proxies have a non-null bind_proc */
3663 /*******************************************************/
3664
3665 /* perform the final checks before creating tasks */
3666
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003667 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Willy Tarreau419ead82014-09-16 13:41:21 +02003668 struct listener *listener;
3669 unsigned int next_id;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003670
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003671 /* Configure SSL for each bind line.
3672 * Note: if configuration fails at some point, the ->ctx member
3673 * remains NULL so that listeners can later detach.
3674 */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003675 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau55d37912016-12-21 23:38:39 +01003676 if (bind_conf->xprt->prepare_bind_conf &&
3677 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003678 cfgerr++;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003679 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003680
Willy Tarreaue6b98942007-10-29 01:09:36 +01003681 /* adjust this proxy's listeners */
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003682 next_id = 1;
Willy Tarreau4348fad2012-09-20 16:48:07 +02003683 list_for_each_entry(listener, &curproxy->conf.listeners, by_fe) {
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003684 int nbproc;
3685
3686 nbproc = my_popcountl(curproxy->bind_proc &
Cyril Bonté4920d702016-04-15 07:58:43 +02003687 (listener->bind_conf->bind_proc ? listener->bind_conf->bind_proc : curproxy->bind_proc) &
Willy Tarreaua38a7172019-02-02 17:11:28 +01003688 all_proc_mask);
Willy Tarreau7c0ffd22016-04-14 11:47:38 +02003689
3690 if (!nbproc) /* no intersection between listener and frontend */
3691 nbproc = 1;
3692
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003693 if (!listener->luid) {
3694 /* listener ID not set, use automatic numbering with first
3695 * spare entry starting with next_luid.
3696 */
3697 next_id = get_next_id(&curproxy->conf.used_listener_id, next_id);
3698 listener->conf.id.key = listener->luid = next_id;
3699 eb32_insert(&curproxy->conf.used_listener_id, &listener->conf.id);
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003700 }
Krzysztof Piotr Oledzkidf5cb9f2010-02-05 20:58:27 +01003701 next_id++;
Willy Tarreau53fb4ae2009-10-04 23:04:08 +02003702
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003703 /* enable separate counters */
3704 if (curproxy->options2 & PR_O2_SOCKSTAT) {
Willy Tarreauae9bea02016-11-25 14:44:52 +01003705 listener->counters = calloc(1, sizeof(*listener->counters));
Willy Tarreau19d14ef2012-10-29 16:51:55 +01003706 if (!listener->name)
3707 memprintf(&listener->name, "sock-%d", listener->luid);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +02003708 }
Willy Tarreau81796be2012-09-22 19:11:47 +02003709
Willy Tarreaue6b98942007-10-29 01:09:36 +01003710 if (curproxy->options & PR_O_TCP_NOLING)
3711 listener->options |= LI_O_NOLINGER;
Willy Tarreau16a21472012-11-19 12:39:59 +01003712 if (!listener->maxaccept)
3713 listener->maxaccept = global.tune.maxaccept ? global.tune.maxaccept : 64;
3714
3715 /* we want to have an optimal behaviour on single process mode to
3716 * maximize the work at once, but in multi-process we want to keep
3717 * some fairness between processes, so we target half of the max
3718 * number of events to be balanced over all the processes the proxy
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05003719 * is bound to. Remember that maxaccept = -1 must be kept as it is
Willy Tarreau16a21472012-11-19 12:39:59 +01003720 * used to disable the limit.
3721 */
Christopher Faulet02f3cf12019-04-30 14:08:41 +02003722 if (listener->maxaccept > 0 && nbproc > 1) {
3723 listener->maxaccept = (listener->maxaccept + 1) / 2;
Willy Tarreau16a21472012-11-19 12:39:59 +01003724 listener->maxaccept = (listener->maxaccept + nbproc - 1) / nbproc;
3725 }
3726
Willy Tarreau9903f0e2015-04-04 18:50:31 +02003727 listener->accept = session_accept_fd;
Willy Tarreauc1a21672009-08-16 22:37:44 +02003728 listener->analysers |= curproxy->fe_req_ana;
Willy Tarreau10b688f2015-03-13 16:43:12 +01003729 listener->default_target = curproxy->default_target;
Willy Tarreau3bc13772008-12-07 11:50:35 +01003730
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003731 if (!LIST_ISEMPTY(&curproxy->tcp_req.l4_rules))
Willy Tarreau7d9736f2016-10-21 16:34:21 +02003732 listener->options |= LI_O_TCP_L4_RULES;
Willy Tarreaua5c0ab22010-05-31 10:30:33 +02003733
Willy Tarreau620408f2016-10-21 16:37:51 +02003734 if (!LIST_ISEMPTY(&curproxy->tcp_req.l5_rules))
3735 listener->options |= LI_O_TCP_L5_RULES;
3736
Willy Tarreaude3041d2010-05-31 10:56:17 +02003737 if (curproxy->mon_mask.s_addr)
3738 listener->options |= LI_O_CHK_MONNET;
3739
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003740 /* smart accept mode is automatic in HTTP mode */
3741 if ((curproxy->options2 & PR_O2_SMARTACC) ||
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003742 ((curproxy->mode == PR_MODE_HTTP || listener->bind_conf->is_ssl) &&
Willy Tarreau9ea05a72009-06-14 12:07:01 +02003743 !(curproxy->no_options2 & PR_O2_SMARTACC)))
3744 listener->options |= LI_O_NOQUICKACK;
Willy Tarreaue6b98942007-10-29 01:09:36 +01003745 }
3746
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003747 /* Release unused SSL configs */
3748 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
Willy Tarreau795cdab2016-12-22 17:30:54 +01003749 if (!bind_conf->is_ssl && bind_conf->xprt->destroy_bind_conf)
3750 bind_conf->xprt->destroy_bind_conf(bind_conf);
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003751 }
Willy Tarreauf5ae8f72012-09-07 16:58:00 +02003752
Willy Tarreaua38a7172019-02-02 17:11:28 +01003753 if (atleast2(curproxy->bind_proc & all_proc_mask)) {
Willy Tarreau102df612014-05-07 23:56:38 +02003754 if (curproxy->uri_auth) {
Willy Tarreaueb791e02014-09-16 15:11:04 +02003755 int count, maxproc = 0;
3756
3757 list_for_each_entry(bind_conf, &curproxy->conf.bind, by_fe) {
David Carliere6c39412015-07-02 07:00:17 +00003758 count = my_popcountl(bind_conf->bind_proc);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003759 if (count > maxproc)
3760 maxproc = count;
3761 }
3762 /* backends have 0, frontends have 1 or more */
3763 if (maxproc != 1)
Christopher Faulet767a84b2017-11-24 16:50:31 +01003764 ha_warning("Proxy '%s': in multi-process mode, stats will be"
3765 " limited to process assigned to the current request.\n",
3766 curproxy->id);
Willy Tarreaueb791e02014-09-16 15:11:04 +02003767
Willy Tarreau102df612014-05-07 23:56:38 +02003768 if (!LIST_ISEMPTY(&curproxy->uri_auth->admin_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003769 ha_warning("Proxy '%s': stats admin will not work correctly in multi-process mode.\n",
3770 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003771 }
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003772 }
Willy Tarreau102df612014-05-07 23:56:38 +02003773 if (!LIST_ISEMPTY(&curproxy->sticking_rules)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003774 ha_warning("Proxy '%s': sticking rules will not work correctly in multi-process mode.\n",
3775 curproxy->id);
Cyril Bonté02ff8ef2010-12-14 22:48:49 +01003776 }
3777 }
Willy Tarreau918ff602011-07-25 16:33:49 +02003778
3779 /* create the task associated with the proxy */
Emeric Brunc60def82017-09-27 14:59:38 +02003780 curproxy->task = task_new(MAX_THREADS_MASK);
Willy Tarreau918ff602011-07-25 16:33:49 +02003781 if (curproxy->task) {
3782 curproxy->task->context = curproxy;
3783 curproxy->task->process = manage_proxy;
Willy Tarreau918ff602011-07-25 16:33:49 +02003784 } else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003785 ha_alert("Proxy '%s': no more memory when trying to allocate the management task\n",
3786 curproxy->id);
Willy Tarreau918ff602011-07-25 16:33:49 +02003787 cfgerr++;
3788 }
Willy Tarreaub369a042014-09-16 13:21:03 +02003789 }
3790
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003791 /*
3792 * Recount currently required checks.
3793 */
3794
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003795 for (curproxy=proxies_list; curproxy; curproxy=curproxy->next) {
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003796 int optnum;
3797
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003798 for (optnum = 0; cfg_opts[optnum].name; optnum++)
3799 if (curproxy->options & cfg_opts[optnum].val)
3800 global.last_checks |= cfg_opts[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003801
Willy Tarreau66aa61f2009-01-18 21:44:07 +01003802 for (optnum = 0; cfg_opts2[optnum].name; optnum++)
3803 if (curproxy->options2 & cfg_opts2[optnum].val)
3804 global.last_checks |= cfg_opts2[optnum].checks;
Krzysztof Oledzki336d4752007-12-25 02:40:22 +01003805 }
3806
Willy Tarreau0fca4832015-05-01 19:12:05 +02003807 /* compute the required process bindings for the peers */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003808 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next)
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003809 if (curproxy->table && curproxy->table->peers.p)
3810 curproxy->table->peers.p->peers_fe->bind_proc |= curproxy->bind_proc;
Willy Tarreau0fca4832015-05-01 19:12:05 +02003811
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01003812 /* compute the required process bindings for the peers from <stktables_list>
3813 * for all the stick-tables, the ones coming with "peers" sections included.
3814 */
3815 for (t = stktables_list; t; t = t->next) {
3816 struct proxy *p;
3817
3818 for (p = t->proxies_list; p; p = p->next_stkt_ref) {
3819 if (t->peers.p && t->peers.p->peers_fe) {
3820 t->peers.p->peers_fe->bind_proc |= p->bind_proc;
3821 }
3822 }
3823 }
3824
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003825 if (cfg_peers) {
3826 struct peers *curpeers = cfg_peers, **last;
Willy Tarreau122541c2011-09-07 21:24:49 +02003827 struct peer *p, *pb;
3828
William Lallemanda2cfd7e2020-03-24 16:02:48 +01003829 /* In the case the peers frontend was not initialized by a
3830 stick-table used in the configuration, set its bind_proc
3831 by default to the first process. */
3832 while (curpeers) {
William Lallemand3ef2d562020-03-24 16:42:15 +01003833 if (curpeers->peers_fe) {
3834 if (curpeers->peers_fe->bind_proc == 0)
3835 curpeers->peers_fe->bind_proc = 1;
3836 }
William Lallemanda2cfd7e2020-03-24 16:02:48 +01003837 curpeers = curpeers->next;
3838 }
3839
3840 curpeers = cfg_peers;
Willy Tarreau1e273012015-05-01 19:15:17 +02003841 /* Remove all peers sections which don't have a valid listener,
3842 * which are not used by any table, or which are bound to more
3843 * than one process.
Willy Tarreau122541c2011-09-07 21:24:49 +02003844 */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003845 last = &cfg_peers;
Willy Tarreau122541c2011-09-07 21:24:49 +02003846 while (*last) {
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003847 struct stktable *t;
Willy Tarreau122541c2011-09-07 21:24:49 +02003848 curpeers = *last;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003849
3850 if (curpeers->state == PR_STSTOPPED) {
3851 /* the "disabled" keyword was present */
3852 if (curpeers->peers_fe)
3853 stop_proxy(curpeers->peers_fe);
3854 curpeers->peers_fe = NULL;
3855 }
Frédéric Lécaille5a4fe5a2019-10-04 08:30:04 +02003856 else if (!curpeers->peers_fe || !curpeers->peers_fe->id) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003857 ha_warning("Removing incomplete section 'peers %s' (no peer named '%s').\n",
3858 curpeers->id, localpeer);
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003859 if (curpeers->peers_fe)
3860 stop_proxy(curpeers->peers_fe);
3861 curpeers->peers_fe = NULL;
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003862 }
Willy Tarreau9504dd62018-10-15 09:37:03 +02003863 else if (atleast2(curpeers->peers_fe->bind_proc)) {
Willy Tarreau1e273012015-05-01 19:15:17 +02003864 /* either it's totally stopped or too much used */
3865 if (curpeers->peers_fe->bind_proc) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003866 ha_alert("Peers section '%s': peers referenced by sections "
3867 "running in different processes (%d different ones). "
3868 "Check global.nbproc and all tables' bind-process "
3869 "settings.\n", curpeers->id, my_popcountl(curpeers->peers_fe->bind_proc));
Willy Tarreau1e273012015-05-01 19:15:17 +02003870 cfgerr++;
3871 }
3872 stop_proxy(curpeers->peers_fe);
3873 curpeers->peers_fe = NULL;
3874 }
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003875 else {
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01003876 /* Initializes the transport layer of the server part of all the peers belonging to
3877 * <curpeers> section if required.
3878 * Note that ->srv is used by the local peer of a new process to connect to the local peer
3879 * of an old process.
3880 */
Frédéric Lécaille1055e682018-04-26 14:35:21 +02003881 p = curpeers->remote;
3882 while (p) {
Frédéric Lécaille355b2032019-01-11 14:06:12 +01003883 if (p->srv) {
Christopher Fauletf61f33a2020-03-27 18:55:49 +01003884 if (p->srv->use_ssl == 1 && xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->prepare_srv)
Frédéric Lécaille355b2032019-01-11 14:06:12 +01003885 cfgerr += xprt_get(XPRT_SSL)->prepare_srv(p->srv);
3886 }
Frédéric Lécaille1055e682018-04-26 14:35:21 +02003887 p = p->next;
3888 }
Frédéric Lécaille76d2cef2019-02-12 19:12:32 +01003889 /* Configure the SSL bindings of the local peer if required. */
3890 if (!LIST_ISEMPTY(&curpeers->peers_fe->conf.bind)) {
3891 struct list *l;
3892 struct bind_conf *bind_conf;
3893
3894 l = &curpeers->peers_fe->conf.bind;
3895 bind_conf = LIST_ELEM(l->n, typeof(bind_conf), by_fe);
3896 if (bind_conf->xprt->prepare_bind_conf &&
3897 bind_conf->xprt->prepare_bind_conf(bind_conf) < 0)
3898 cfgerr++;
3899 }
Frédéric Lécaille8d78fa72019-05-20 18:22:52 +02003900 if (!peers_init_sync(curpeers) || !peers_alloc_dcache(curpeers)) {
Willy Tarreaud9443442018-10-15 11:18:03 +02003901 ha_alert("Peers section '%s': out of memory, giving up on peers.\n",
3902 curpeers->id);
3903 cfgerr++;
3904 break;
3905 }
Willy Tarreau122541c2011-09-07 21:24:49 +02003906 last = &curpeers->next;
3907 continue;
3908 }
3909
Willy Tarreau77e4bd12015-05-01 20:02:17 +02003910 /* clean what has been detected above */
Willy Tarreau122541c2011-09-07 21:24:49 +02003911 p = curpeers->remote;
3912 while (p) {
3913 pb = p->next;
3914 free(p->id);
3915 free(p);
3916 p = pb;
3917 }
3918
3919 /* Destroy and unlink this curpeers section.
3920 * Note: curpeers is backed up into *last.
3921 */
3922 free(curpeers->id);
3923 curpeers = curpeers->next;
Frédéric Lécaille87eacbb2020-03-24 20:08:30 +01003924 /* Reset any refereance to this peers section in the list of stick-tables */
3925 for (t = stktables_list; t; t = t->next) {
3926 if (t->peers.p && t->peers.p == *last)
3927 t->peers.p = NULL;
3928 }
Willy Tarreau122541c2011-09-07 21:24:49 +02003929 free(*last);
3930 *last = curpeers;
3931 }
3932 }
3933
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003934 for (t = stktables_list; t; t = t->next) {
3935 if (t->proxy)
3936 continue;
3937 if (!stktable_init(t)) {
3938 ha_alert("Proxy '%s': failed to initialize stick-table.\n", t->id);
3939 cfgerr++;
3940 }
3941 }
3942
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003943 /* initialize stick-tables on backend capable proxies. This must not
3944 * be done earlier because the data size may be discovered while parsing
3945 * other proxies.
3946 */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003947 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003948 if (curproxy->state == PR_STSTOPPED || !curproxy->table)
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003949 continue;
3950
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01003951 if (!stktable_init(curproxy->table)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003952 ha_alert("Proxy '%s': failed to initialize stick-table.\n", curproxy->id);
Willy Tarreau6866f3f2015-05-01 19:09:08 +02003953 cfgerr++;
3954 }
3955 }
3956
Simon Horman0d16a402015-01-30 11:22:58 +09003957 if (mailers) {
3958 struct mailers *curmailers = mailers, **last;
3959 struct mailer *m, *mb;
3960
3961 /* Remove all mailers sections which don't have a valid listener.
3962 * This can happen when a mailers section is never referenced.
3963 */
3964 last = &mailers;
3965 while (*last) {
3966 curmailers = *last;
3967 if (curmailers->users) {
3968 last = &curmailers->next;
3969 continue;
3970 }
3971
Christopher Faulet767a84b2017-11-24 16:50:31 +01003972 ha_warning("Removing incomplete section 'mailers %s'.\n",
3973 curmailers->id);
Simon Horman0d16a402015-01-30 11:22:58 +09003974
3975 m = curmailers->mailer_list;
3976 while (m) {
3977 mb = m->next;
3978 free(m->id);
3979 free(m);
3980 m = mb;
3981 }
3982
3983 /* Destroy and unlink this curmailers section.
3984 * Note: curmailers is backed up into *last.
3985 */
3986 free(curmailers->id);
3987 curmailers = curmailers->next;
3988 free(*last);
3989 *last = curmailers;
3990 }
3991 }
3992
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003993 /* Update server_state_file_name to backend name if backend is supposed to use
3994 * a server-state file locally defined and none has been provided */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003995 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +02003996 if (curproxy->load_server_state_from_file == PR_SRV_STATE_FILE_LOCAL &&
3997 curproxy->server_state_file_name == NULL)
3998 curproxy->server_state_file_name = strdup(curproxy->id);
3999 }
4000
Ben Draut054fbee2018-04-13 15:43:04 -06004001 list_for_each_entry(curr_resolvers, &dns_resolvers, list) {
4002 if (LIST_ISEMPTY(&curr_resolvers->nameservers)) {
4003 ha_warning("config : resolvers '%s' [%s:%d] has no nameservers configured!\n",
4004 curr_resolvers->id, curr_resolvers->conf.file,
4005 curr_resolvers->conf.line);
4006 err_code |= ERR_WARN;
4007 }
4008 }
4009
William Lallemand48b4bb42017-10-23 14:36:34 +02004010 list_for_each_entry(postparser, &postparsers, list) {
4011 if (postparser->func)
4012 cfgerr += postparser->func();
4013 }
4014
Willy Tarreaubb925012009-07-23 13:36:36 +02004015 if (cfgerr > 0)
4016 err_code |= ERR_ALERT | ERR_FATAL;
4017 out:
4018 return err_code;
Willy Tarreaubaaee002006-06-26 02:48:02 +02004019}
4020
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004021/*
4022 * Registers the CFG keyword list <kwl> as a list of valid keywords for next
4023 * parsing sessions.
4024 */
4025void cfg_register_keywords(struct cfg_kw_list *kwl)
4026{
4027 LIST_ADDQ(&cfg_keywords.list, &kwl->list);
4028}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004029
Willy Tarreau5b2c3362008-07-09 19:39:06 +02004030/*
4031 * Unregisters the CFG keyword list <kwl> from the list of valid keywords.
4032 */
4033void cfg_unregister_keywords(struct cfg_kw_list *kwl)
4034{
4035 LIST_DEL(&kwl->list);
4036 LIST_INIT(&kwl->list);
4037}
Willy Tarreaubaaee002006-06-26 02:48:02 +02004038
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004039/* this function register new section in the haproxy configuration file.
4040 * <section_name> is the name of this new section and <section_parser>
4041 * is the called parser. If two section declaration have the same name,
4042 * only the first declared is used.
4043 */
4044int cfg_register_section(char *section_name,
William Lallemandd2ff56d2017-10-16 11:06:50 +02004045 int (*section_parser)(const char *, int, char **, int),
4046 int (*post_section_parser)())
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004047{
4048 struct cfg_section *cs;
4049
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004050 list_for_each_entry(cs, &sections, list) {
4051 if (strcmp(cs->section_name, section_name) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004052 ha_alert("register section '%s': already registered.\n", section_name);
Willy Tarreau5e4261b2016-05-17 16:16:09 +02004053 return 0;
4054 }
4055 }
4056
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004057 cs = calloc(1, sizeof(*cs));
4058 if (!cs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004059 ha_alert("register section '%s': out of memory.\n", section_name);
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004060 return 0;
4061 }
4062
4063 cs->section_name = section_name;
4064 cs->section_parser = section_parser;
William Lallemandd2ff56d2017-10-16 11:06:50 +02004065 cs->post_section_parser = post_section_parser;
Thierry FOURNIERfa45f1d2014-03-18 13:54:18 +01004066
4067 LIST_ADDQ(&sections, &cs->list);
4068
4069 return 1;
4070}
4071
William Lallemand48b4bb42017-10-23 14:36:34 +02004072/* this function register a new function which will be called once the haproxy
4073 * configuration file has been parsed. It's useful to check dependencies
4074 * between sections or to resolve items once everything is parsed.
4075 */
4076int cfg_register_postparser(char *name, int (*func)())
4077{
4078 struct cfg_postparser *cp;
4079
4080 cp = calloc(1, sizeof(*cp));
4081 if (!cp) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004082 ha_alert("register postparser '%s': out of memory.\n", name);
William Lallemand48b4bb42017-10-23 14:36:34 +02004083 return 0;
4084 }
4085 cp->name = name;
4086 cp->func = func;
4087
4088 LIST_ADDQ(&postparsers, &cp->list);
4089
4090 return 1;
4091}
4092
Willy Tarreaubaaee002006-06-26 02:48:02 +02004093/*
David Carlier845efb52015-09-25 11:49:18 +01004094 * free all config section entries
4095 */
4096void cfg_unregister_sections(void)
4097{
4098 struct cfg_section *cs, *ics;
4099
4100 list_for_each_entry_safe(cs, ics, &sections, list) {
4101 LIST_DEL(&cs->list);
4102 free(cs);
4103 }
4104}
4105
Christopher Faulet7110b402016-10-26 11:09:44 +02004106void cfg_backup_sections(struct list *backup_sections)
4107{
4108 struct cfg_section *cs, *ics;
4109
4110 list_for_each_entry_safe(cs, ics, &sections, list) {
4111 LIST_DEL(&cs->list);
4112 LIST_ADDQ(backup_sections, &cs->list);
4113 }
4114}
4115
4116void cfg_restore_sections(struct list *backup_sections)
4117{
4118 struct cfg_section *cs, *ics;
4119
4120 list_for_each_entry_safe(cs, ics, backup_sections, list) {
4121 LIST_DEL(&cs->list);
4122 LIST_ADDQ(&sections, &cs->list);
4123 }
4124}
4125
Willy Tarreaue6552512018-11-26 11:33:13 +01004126/* these are the config sections handled by default */
4127REGISTER_CONFIG_SECTION("listen", cfg_parse_listen, NULL);
4128REGISTER_CONFIG_SECTION("frontend", cfg_parse_listen, NULL);
4129REGISTER_CONFIG_SECTION("backend", cfg_parse_listen, NULL);
4130REGISTER_CONFIG_SECTION("defaults", cfg_parse_listen, NULL);
4131REGISTER_CONFIG_SECTION("global", cfg_parse_global, NULL);
4132REGISTER_CONFIG_SECTION("userlist", cfg_parse_users, NULL);
4133REGISTER_CONFIG_SECTION("peers", cfg_parse_peers, NULL);
4134REGISTER_CONFIG_SECTION("mailers", cfg_parse_mailers, NULL);
4135REGISTER_CONFIG_SECTION("namespace_list", cfg_parse_netns, NULL);
4136REGISTER_CONFIG_SECTION("resolvers", cfg_parse_resolvers, NULL);
Willy Tarreau659fbf02016-05-26 17:55:28 +02004137
David Carlier845efb52015-09-25 11:49:18 +01004138/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02004139 * Local variables:
4140 * c-indent-level: 8
4141 * c-basic-offset: 8
4142 * End:
4143 */