blob: 5bbad8292901be39ba2681f49bd3409fdfdcf23d [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Server management functions.
3 *
Willy Tarreau21faa912012-10-10 08:27:36 +02004 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +01005 * Copyright 2007-2008 Krzysztof Piotr Oledzki <ole@ans.pl>
Willy Tarreaubaaee002006-06-26 02:48:02 +02006 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 */
13
Willy Tarreau0a4b0ab2020-06-11 11:22:44 +020014#include <sys/types.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020015#include <netinet/tcp.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020016#include <ctype.h>
Baptiste Assmanne11cfcd2015-08-19 16:44:03 +020017#include <errno.h>
Willy Tarreau272adea2014-03-31 10:39:59 +020018
Willy Tarreau6be78492020-06-05 00:00:29 +020019#include <import/xxhash.h>
20
Willy Tarreaub2551052020-06-09 09:07:15 +020021#include <haproxy/api.h>
Willy Tarreau3f0f82e2020-06-04 19:42:41 +020022#include <haproxy/applet-t.h>
Willy Tarreau49801602020-06-04 22:50:02 +020023#include <haproxy/backend.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020024#include <haproxy/cfgparse.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020025#include <haproxy/check.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020026#include <haproxy/cli.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020027#include <haproxy/connection.h>
Willy Tarreau3afc4c42020-06-03 18:23:19 +020028#include <haproxy/dict-t.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020029#include <haproxy/errors.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020030#include <haproxy/global.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020031#include <haproxy/log.h>
Willy Tarreaucee013e2020-06-05 11:40:38 +020032#include <haproxy/mailers.h>
Willy Tarreau7a00efb2020-06-02 17:02:59 +020033#include <haproxy/namespace.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020034#include <haproxy/port_range.h>
35#include <haproxy/protocol.h>
Willy Tarreaua55c4542020-06-04 22:59:39 +020036#include <haproxy/queue.h>
Emeric Brunc9437992021-02-12 19:42:55 +010037#include <haproxy/resolvers.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020038#include <haproxy/sample.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020039#include <haproxy/server.h>
William Dauchyf6370442020-11-14 19:25:33 +010040#include <haproxy/ssl_sock.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020041#include <haproxy/stats-t.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020042#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020043#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020044#include <haproxy/task.h>
Willy Tarreau51cd5952020-06-05 12:25:38 +020045#include <haproxy/tcpcheck.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020046#include <haproxy/time.h>
Krzysztof Oledzki85130942007-10-22 16:21:10 +020047
Baptiste Assmannda29fe22019-06-13 13:24:29 +020048
Willy Tarreau3ff577e2018-08-02 11:48:52 +020049static void srv_update_status(struct server *s);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +010050static int srv_apply_lastaddr(struct server *srv, int *err_code);
William Dauchy6318d332020-05-02 21:52:36 +020051static void srv_cleanup_connections(struct server *srv);
Willy Tarreaubaaee002006-06-26 02:48:02 +020052
Willy Tarreau21faa912012-10-10 08:27:36 +020053/* List head of all known server keywords */
54static struct srv_kw_list srv_keywords = {
55 .list = LIST_HEAD_INIT(srv_keywords.list)
56};
Krzysztof Oledzki85130942007-10-22 16:21:10 +020057
Willy Tarreauaf613e82020-06-05 08:40:51 +020058__decl_thread(HA_SPINLOCK_T idle_conn_srv_lock);
Olivier Houchard9ea5d362019-02-14 18:29:09 +010059struct eb_root idle_conn_srv = EB_ROOT;
60struct task *idle_conn_task = NULL;
Olivier Houchard9ea5d362019-02-14 18:29:09 +010061
Frédéric Lécaille7da71292019-05-20 09:47:07 +020062/* The server names dictionary */
Thayne McCombs92149f92020-11-20 01:28:26 -070063struct dict server_key_dict = {
64 .name = "server keys",
Frédéric Lécaille7da71292019-05-20 09:47:07 +020065 .values = EB_ROOT_UNIQUE,
66};
67
Simon Hormana3608442013-11-01 16:46:15 +090068int srv_downtime(const struct server *s)
Willy Tarreau21faa912012-10-10 08:27:36 +020069{
Amaury Denoyellee6ba7912020-10-29 15:59:05 +010070 if ((s->cur_state != SRV_ST_STOPPED) || s->last_change >= now.tv_sec) // ignore negative time
Krzysztof Oledzki85130942007-10-22 16:21:10 +020071 return s->down_time;
72
73 return now.tv_sec - s->last_change + s->down_time;
74}
Willy Tarreaubaaee002006-06-26 02:48:02 +020075
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -050076int srv_lastsession(const struct server *s)
77{
78 if (s->counters.last_sess)
79 return now.tv_sec - s->counters.last_sess;
80
81 return -1;
82}
83
Simon Horman4a741432013-02-23 15:35:38 +090084int srv_getinter(const struct check *check)
Willy Tarreau21faa912012-10-10 08:27:36 +020085{
Simon Horman4a741432013-02-23 15:35:38 +090086 const struct server *s = check->server;
87
Willy Tarreauff5ae352013-12-11 20:36:34 +010088 if ((check->state & CHK_ST_CONFIGURED) && (check->health == check->rise + check->fall - 1))
Simon Horman4a741432013-02-23 15:35:38 +090089 return check->inter;
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010090
Emeric Brun52a91d32017-08-31 14:41:55 +020091 if ((s->next_state == SRV_ST_STOPPED) && check->health == 0)
Simon Horman4a741432013-02-23 15:35:38 +090092 return (check->downinter)?(check->downinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010093
Simon Horman4a741432013-02-23 15:35:38 +090094 return (check->fastinter)?(check->fastinter):(check->inter);
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +010095}
96
Olivier Houcharde9bad0a2018-01-17 17:39:34 +010097/*
98 * Check that we did not get a hash collision.
Willy Tarreau595e7672020-10-20 17:30:08 +020099 * Unlikely, but it can happen. The server's proxy must be at least
100 * read-locked.
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100101 */
102static inline void srv_check_for_dup_dyncookie(struct server *s)
Olivier Houchard4e694042017-03-14 20:01:29 +0100103{
104 struct proxy *p = s->proxy;
105 struct server *tmpserv;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100106
107 for (tmpserv = p->srv; tmpserv != NULL;
108 tmpserv = tmpserv->next) {
109 if (tmpserv == s)
110 continue;
111 if (tmpserv->next_admin & SRV_ADMF_FMAINT)
112 continue;
113 if (tmpserv->cookie &&
114 strcmp(tmpserv->cookie, s->cookie) == 0) {
115 ha_warning("We generated two equal cookies for two different servers.\n"
116 "Please change the secret key for '%s'.\n",
117 s->proxy->id);
118 }
119 }
120
121}
122
Willy Tarreau46b7f532018-08-21 11:54:26 +0200123/*
Willy Tarreau595e7672020-10-20 17:30:08 +0200124 * Must be called with the server lock held, and will read-lock the proxy.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200125 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100126void srv_set_dyncookie(struct server *s)
127{
128 struct proxy *p = s->proxy;
Olivier Houchard4e694042017-03-14 20:01:29 +0100129 char *tmpbuf;
130 unsigned long long hash_value;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100131 size_t key_len;
Olivier Houchard4e694042017-03-14 20:01:29 +0100132 size_t buffer_len;
133 int addr_len;
134 int port;
135
Willy Tarreau595e7672020-10-20 17:30:08 +0200136 HA_RWLOCK_RDLOCK(PROXY_LOCK, &p->lock);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200137
Olivier Houchard4e694042017-03-14 20:01:29 +0100138 if ((s->flags & SRV_F_COOKIESET) ||
139 !(s->proxy->ck_opts & PR_CK_DYNAMIC) ||
140 s->proxy->dyncookie_key == NULL)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200141 goto out;
Olivier Houchard2cb49eb2017-03-15 15:11:06 +0100142 key_len = strlen(p->dyncookie_key);
Olivier Houchard4e694042017-03-14 20:01:29 +0100143
144 if (s->addr.ss_family != AF_INET &&
145 s->addr.ss_family != AF_INET6)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200146 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100147 /*
148 * Buffer to calculate the cookie value.
149 * The buffer contains the secret key + the server IP address
150 * + the TCP port.
151 */
152 addr_len = (s->addr.ss_family == AF_INET) ? 4 : 16;
153 /*
154 * The TCP port should use only 2 bytes, but is stored in
155 * an unsigned int in struct server, so let's use 4, to be
156 * on the safe side.
157 */
158 buffer_len = key_len + addr_len + 4;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200159 tmpbuf = trash.area;
Olivier Houchard4e694042017-03-14 20:01:29 +0100160 memcpy(tmpbuf, p->dyncookie_key, key_len);
161 memcpy(&(tmpbuf[key_len]),
162 s->addr.ss_family == AF_INET ?
163 (void *)&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr :
164 (void *)&(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr),
165 addr_len);
166 /*
167 * Make sure it's the same across all the load balancers,
168 * no matter their endianness.
169 */
170 port = htonl(s->svc_port);
171 memcpy(&tmpbuf[key_len + addr_len], &port, 4);
172 hash_value = XXH64(tmpbuf, buffer_len, 0);
173 memprintf(&s->cookie, "%016llx", hash_value);
174 if (!s->cookie)
Willy Tarreau5e83d992019-07-30 11:59:34 +0200175 goto out;
Olivier Houchard4e694042017-03-14 20:01:29 +0100176 s->cklen = 16;
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100177
178 /* Don't bother checking if the dyncookie is duplicated if
179 * the server is marked as "disabled", maybe it doesn't have
180 * its real IP yet, but just a place holder.
Olivier Houchard4e694042017-03-14 20:01:29 +0100181 */
Olivier Houcharde9bad0a2018-01-17 17:39:34 +0100182 if (!(s->next_admin & SRV_ADMF_FMAINT))
183 srv_check_for_dup_dyncookie(s);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200184 out:
Willy Tarreau595e7672020-10-20 17:30:08 +0200185 HA_RWLOCK_RDUNLOCK(PROXY_LOCK, &p->lock);
Olivier Houchard4e694042017-03-14 20:01:29 +0100186}
187
Willy Tarreau21faa912012-10-10 08:27:36 +0200188/*
Thayne McCombs92149f92020-11-20 01:28:26 -0700189 * Must be called with the server lock held, and will write-lock the proxy.
190 */
191static void srv_set_addr_desc(struct server *s)
192{
193 struct proxy *p = s->proxy;
194 char *key;
195
196 key = sa2str(&s->addr, s->svc_port, s->flags & SRV_F_MAPPORTS);
197
198 if (s->addr_node.key) {
Thayne McCombs24da7e12021-01-05 23:10:09 -0700199 if (key && strcmp(key, s->addr_node.key) == 0) {
Thayne McCombs92149f92020-11-20 01:28:26 -0700200 free(key);
201 return;
202 }
203
204 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
205 ebpt_delete(&s->addr_node);
206 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
207
208 free(s->addr_node.key);
209 }
210
211 s->addr_node.key = key;
212
Thayne McCombs24da7e12021-01-05 23:10:09 -0700213 if (s->addr_node.key) {
214 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
215 ebis_insert(&p->used_server_addr, &s->addr_node);
216 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
217 }
Thayne McCombs92149f92020-11-20 01:28:26 -0700218}
219
220/*
Willy Tarreau21faa912012-10-10 08:27:36 +0200221 * Registers the server keyword list <kwl> as a list of valid keywords for next
222 * parsing sessions.
223 */
224void srv_register_keywords(struct srv_kw_list *kwl)
225{
226 LIST_ADDQ(&srv_keywords.list, &kwl->list);
227}
228
229/* Return a pointer to the server keyword <kw>, or NULL if not found. If the
230 * keyword is found with a NULL ->parse() function, then an attempt is made to
231 * find one with a valid ->parse() function. This way it is possible to declare
232 * platform-dependant, known keywords as NULL, then only declare them as valid
233 * if some options are met. Note that if the requested keyword contains an
234 * opening parenthesis, everything from this point is ignored.
235 */
236struct srv_kw *srv_find_kw(const char *kw)
237{
238 int index;
239 const char *kwend;
240 struct srv_kw_list *kwl;
241 struct srv_kw *ret = NULL;
242
243 kwend = strchr(kw, '(');
244 if (!kwend)
245 kwend = kw + strlen(kw);
246
247 list_for_each_entry(kwl, &srv_keywords.list, list) {
248 for (index = 0; kwl->kw[index].kw != NULL; index++) {
249 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
250 kwl->kw[index].kw[kwend-kw] == 0) {
251 if (kwl->kw[index].parse)
252 return &kwl->kw[index]; /* found it !*/
253 else
254 ret = &kwl->kw[index]; /* may be OK */
255 }
256 }
257 }
258 return ret;
259}
260
261/* Dumps all registered "server" keywords to the <out> string pointer. The
262 * unsupported keywords are only dumped if their supported form was not
263 * found.
264 */
265void srv_dump_kws(char **out)
266{
267 struct srv_kw_list *kwl;
268 int index;
269
Christopher Faulet784063e2020-05-18 12:14:18 +0200270 if (!out)
271 return;
272
Willy Tarreau21faa912012-10-10 08:27:36 +0200273 *out = NULL;
274 list_for_each_entry(kwl, &srv_keywords.list, list) {
275 for (index = 0; kwl->kw[index].kw != NULL; index++) {
276 if (kwl->kw[index].parse ||
277 srv_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
278 memprintf(out, "%s[%4s] %s%s%s%s\n", *out ? *out : "",
279 kwl->scope,
280 kwl->kw[index].kw,
281 kwl->kw[index].skip ? " <arg>" : "",
282 kwl->kw[index].default_ok ? " [dflt_ok]" : "",
283 kwl->kw[index].parse ? "" : " (not supported)");
284 }
285 }
286 }
287}
Krzysztof Piotr Oledzki5259dfe2008-01-21 01:54:06 +0100288
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100289/* Parse the "backup" server keyword */
290static int srv_parse_backup(char **args, int *cur_arg,
291 struct proxy *curproxy, struct server *newsrv, char **err)
292{
293 newsrv->flags |= SRV_F_BACKUP;
294 return 0;
295}
296
Alexander Liu2a54bb72019-05-22 19:44:48 +0800297
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +0100298/* Parse the "cookie" server keyword */
299static int srv_parse_cookie(char **args, int *cur_arg,
300 struct proxy *curproxy, struct server *newsrv, char **err)
301{
302 char *arg;
303
304 arg = args[*cur_arg + 1];
305 if (!*arg) {
306 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
307 return ERR_ALERT | ERR_FATAL;
308 }
309
310 free(newsrv->cookie);
311 newsrv->cookie = strdup(arg);
312 newsrv->cklen = strlen(arg);
313 newsrv->flags |= SRV_F_COOKIESET;
314 return 0;
315}
316
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100317/* Parse the "disabled" server keyword */
318static int srv_parse_disabled(char **args, int *cur_arg,
319 struct proxy *curproxy, struct server *newsrv, char **err)
320{
Emeric Brun52a91d32017-08-31 14:41:55 +0200321 newsrv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
322 newsrv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100323 newsrv->check.state |= CHK_ST_PAUSED;
324 newsrv->check.health = 0;
325 return 0;
326}
327
328/* Parse the "enabled" server keyword */
329static int srv_parse_enabled(char **args, int *cur_arg,
330 struct proxy *curproxy, struct server *newsrv, char **err)
331{
Emeric Brun52a91d32017-08-31 14:41:55 +0200332 newsrv->next_admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT;
333 newsrv->next_state = SRV_ST_RUNNING;
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +0100334 newsrv->check.state &= ~CHK_ST_PAUSED;
335 newsrv->check.health = newsrv->check.rise;
336 return 0;
337}
338
Willy Tarreau9c538e02019-01-23 10:21:49 +0100339static int srv_parse_max_reuse(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
340{
341 char *arg;
342
343 arg = args[*cur_arg + 1];
344 if (!*arg) {
345 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
346 return ERR_ALERT | ERR_FATAL;
347 }
348 newsrv->max_reuse = atoi(arg);
349
350 return 0;
351}
352
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100353static int srv_parse_pool_purge_delay(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100354{
355 const char *res;
356 char *arg;
357 unsigned int time;
358
359 arg = args[*cur_arg + 1];
360 if (!*arg) {
361 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
362 return ERR_ALERT | ERR_FATAL;
363 }
364 res = parse_time_err(arg, &time, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +0200365 if (res == PARSE_TIME_OVER) {
366 memprintf(err, "timer overflow in argument '%s' to '%s' (maximum value is 2147483647 ms or ~24.8 days)",
367 args[*cur_arg+1], args[*cur_arg]);
368 return ERR_ALERT | ERR_FATAL;
369 }
370 else if (res == PARSE_TIME_UNDER) {
371 memprintf(err, "timer underflow in argument '%s' to '%s' (minimum non-null value is 1 ms)",
372 args[*cur_arg+1], args[*cur_arg]);
373 return ERR_ALERT | ERR_FATAL;
374 }
375 else if (res) {
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100376 memprintf(err, "unexpected character '%c' in argument to <%s>.\n",
377 *res, args[*cur_arg]);
378 return ERR_ALERT | ERR_FATAL;
379 }
Olivier Houchardb7b3faa2018-12-14 18:15:36 +0100380 newsrv->pool_purge_delay = time;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +0100381
382 return 0;
383}
384
Willy Tarreau2f3f4d32020-07-01 07:43:51 +0200385static int srv_parse_pool_low_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
386{
387 char *arg;
388
389 arg = args[*cur_arg + 1];
390 if (!*arg) {
391 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
392 return ERR_ALERT | ERR_FATAL;
393 }
394
395 newsrv->low_idle_conns = atoi(arg);
396 return 0;
397}
398
Olivier Houchard006e3102018-12-10 18:30:32 +0100399static int srv_parse_pool_max_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
400{
401 char *arg;
402
403 arg = args[*cur_arg + 1];
404 if (!*arg) {
405 memprintf(err, "'%s' expects <value> as argument.\n", args[*cur_arg]);
406 return ERR_ALERT | ERR_FATAL;
407 }
Willy Tarreaucb923d52019-01-23 10:39:27 +0100408
Olivier Houchard006e3102018-12-10 18:30:32 +0100409 newsrv->max_idle_conns = atoi(arg);
Willy Tarreaucb923d52019-01-23 10:39:27 +0100410 if ((int)newsrv->max_idle_conns < -1) {
411 memprintf(err, "'%s' must be >= -1", args[*cur_arg]);
412 return ERR_ALERT | ERR_FATAL;
413 }
Olivier Houchard006e3102018-12-10 18:30:32 +0100414
415 return 0;
416}
417
Willy Tarreaudff55432012-10-10 17:51:05 +0200418/* parse the "id" server keyword */
419static int srv_parse_id(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
420{
421 struct eb32_node *node;
422
423 if (!*args[*cur_arg + 1]) {
424 memprintf(err, "'%s' : expects an integer argument", args[*cur_arg]);
425 return ERR_ALERT | ERR_FATAL;
426 }
427
428 newsrv->puid = atol(args[*cur_arg + 1]);
429 newsrv->conf.id.key = newsrv->puid;
430
431 if (newsrv->puid <= 0) {
432 memprintf(err, "'%s' : custom id has to be > 0", args[*cur_arg]);
433 return ERR_ALERT | ERR_FATAL;
434 }
435
436 node = eb32_lookup(&curproxy->conf.used_server_id, newsrv->puid);
437 if (node) {
438 struct server *target = container_of(node, struct server, conf.id);
439 memprintf(err, "'%s' : custom id %d already used at %s:%d ('server %s')",
440 args[*cur_arg], newsrv->puid, target->conf.file, target->conf.line,
441 target->id);
442 return ERR_ALERT | ERR_FATAL;
443 }
444
445 eb32_insert(&curproxy->conf.used_server_id, &newsrv->conf.id);
Baptiste Assmann7cc419a2015-07-07 22:02:20 +0200446 newsrv->flags |= SRV_F_FORCED_ID;
Willy Tarreaudff55432012-10-10 17:51:05 +0200447 return 0;
448}
449
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100450/* Parse the "namespace" server keyword */
451static int srv_parse_namespace(char **args, int *cur_arg,
452 struct proxy *curproxy, struct server *newsrv, char **err)
453{
Willy Tarreaue5733232019-05-22 19:24:06 +0200454#ifdef USE_NS
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100455 char *arg;
456
457 arg = args[*cur_arg + 1];
458 if (!*arg) {
459 memprintf(err, "'%s' : expects <name> as argument", args[*cur_arg]);
460 return ERR_ALERT | ERR_FATAL;
461 }
462
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100463 if (strcmp(arg, "*") == 0) {
Frédéric Lécaille22f41a22017-03-16 17:17:36 +0100464 /* Use the namespace associated with the connection (if present). */
465 newsrv->flags |= SRV_F_USE_NS_FROM_PP;
466 return 0;
467 }
468
469 /*
470 * As this parser may be called several times for the same 'default-server'
471 * object, or for a new 'server' instance deriving from a 'default-server'
472 * one with SRV_F_USE_NS_FROM_PP flag enabled, let's reset it.
473 */
474 newsrv->flags &= ~SRV_F_USE_NS_FROM_PP;
475
476 newsrv->netns = netns_store_lookup(arg, strlen(arg));
477 if (!newsrv->netns)
478 newsrv->netns = netns_store_insert(arg);
479
480 if (!newsrv->netns) {
481 memprintf(err, "Cannot open namespace '%s'", arg);
482 return ERR_ALERT | ERR_FATAL;
483 }
484
485 return 0;
486#else
487 memprintf(err, "'%s': '%s' option not implemented", args[0], args[*cur_arg]);
488 return ERR_ALERT | ERR_FATAL;
489#endif
490}
491
Frédéric Lécaillef5bf9032017-03-10 11:51:05 +0100492/* Parse the "no-backup" server keyword */
493static int srv_parse_no_backup(char **args, int *cur_arg,
494 struct proxy *curproxy, struct server *newsrv, char **err)
495{
496 newsrv->flags &= ~SRV_F_BACKUP;
497 return 0;
498}
499
Frédéric Lécaille25df8902017-03-10 14:04:31 +0100500
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100501/* Disable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200502static inline int srv_disable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100503{
504 srv->pp_opts &= ~flags;
505 return 0;
506}
507
508/* Parse the "no-send-proxy" server keyword */
509static int srv_parse_no_send_proxy(char **args, int *cur_arg,
510 struct proxy *curproxy, struct server *newsrv, char **err)
511{
512 return srv_disable_pp_flags(newsrv, SRV_PP_V1);
513}
514
515/* Parse the "no-send-proxy-v2" server keyword */
516static int srv_parse_no_send_proxy_v2(char **args, int *cur_arg,
517 struct proxy *curproxy, struct server *newsrv, char **err)
518{
519 return srv_disable_pp_flags(newsrv, SRV_PP_V2);
520}
521
Frédéric Lécaille1b9423d2019-07-04 14:19:06 +0200522/* Parse the "no-tfo" server keyword */
523static int srv_parse_no_tfo(char **args, int *cur_arg,
524 struct proxy *curproxy, struct server *newsrv, char **err)
525{
526 newsrv->flags &= ~SRV_F_FASTOPEN;
527 return 0;
528}
529
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100530/* Parse the "non-stick" server keyword */
531static int srv_parse_non_stick(char **args, int *cur_arg,
532 struct proxy *curproxy, struct server *newsrv, char **err)
533{
534 newsrv->flags |= SRV_F_NON_STICK;
535 return 0;
536}
537
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100538/* Enable server PROXY protocol flags. */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200539static inline int srv_enable_pp_flags(struct server *srv, unsigned int flags)
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100540{
541 srv->pp_opts |= flags;
542 return 0;
543}
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200544/* parse the "proto" server keyword */
545static int srv_parse_proto(char **args, int *cur_arg,
546 struct proxy *px, struct server *newsrv, char **err)
547{
548 struct ist proto;
549
550 if (!*args[*cur_arg + 1]) {
551 memprintf(err, "'%s' : missing value", args[*cur_arg]);
552 return ERR_ALERT | ERR_FATAL;
553 }
554 proto = ist2(args[*cur_arg + 1], strlen(args[*cur_arg + 1]));
555 newsrv->mux_proto = get_mux_proto(proto);
556 if (!newsrv->mux_proto) {
557 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[*cur_arg], args[*cur_arg+1]);
558 return ERR_ALERT | ERR_FATAL;
559 }
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +0200560 return 0;
561}
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100562
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100563/* parse the "proxy-v2-options" */
564static int srv_parse_proxy_v2_options(char **args, int *cur_arg,
565 struct proxy *px, struct server *newsrv, char **err)
566{
567 char *p, *n;
568 for (p = args[*cur_arg+1]; p; p = n) {
569 n = strchr(p, ',');
570 if (n)
571 *n++ = '\0';
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100572 if (strcmp(p, "ssl") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100573 newsrv->pp_opts |= SRV_PP_V2_SSL;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100574 } else if (strcmp(p, "cert-cn") == 0) {
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100575 newsrv->pp_opts |= SRV_PP_V2_SSL;
576 newsrv->pp_opts |= SRV_PP_V2_SSL_CN;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100577 } else if (strcmp(p, "cert-key") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100578 newsrv->pp_opts |= SRV_PP_V2_SSL;
579 newsrv->pp_opts |= SRV_PP_V2_SSL_KEY_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100580 } else if (strcmp(p, "cert-sig") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100581 newsrv->pp_opts |= SRV_PP_V2_SSL;
582 newsrv->pp_opts |= SRV_PP_V2_SSL_SIG_ALG;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100583 } else if (strcmp(p, "ssl-cipher") == 0) {
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +0100584 newsrv->pp_opts |= SRV_PP_V2_SSL;
585 newsrv->pp_opts |= SRV_PP_V2_SSL_CIPHER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100586 } else if (strcmp(p, "authority") == 0) {
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +0100587 newsrv->pp_opts |= SRV_PP_V2_AUTHORITY;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100588 } else if (strcmp(p, "crc32c") == 0) {
Emmanuel Hocdet4399c752018-02-05 15:26:43 +0100589 newsrv->pp_opts |= SRV_PP_V2_CRC32C;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100590 } else if (strcmp(p, "unique-id") == 0) {
Tim Duesterhuscf6e0c82020-03-13 12:34:24 +0100591 newsrv->pp_opts |= SRV_PP_V2_UNIQUE_ID;
Emmanuel Hocdetf643b802018-02-01 15:20:32 +0100592 } else
593 goto fail;
594 }
595 return 0;
596 fail:
597 if (err)
598 memprintf(err, "'%s' : proxy v2 option not implemented", p);
599 return ERR_ALERT | ERR_FATAL;
600}
601
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100602/* Parse the "observe" server keyword */
603static int srv_parse_observe(char **args, int *cur_arg,
604 struct proxy *curproxy, struct server *newsrv, char **err)
605{
606 char *arg;
607
608 arg = args[*cur_arg + 1];
609 if (!*arg) {
610 memprintf(err, "'%s' expects <mode> as argument.\n", args[*cur_arg]);
611 return ERR_ALERT | ERR_FATAL;
612 }
613
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100614 if (strcmp(arg, "none") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100615 newsrv->observe = HANA_OBS_NONE;
616 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100617 else if (strcmp(arg, "layer4") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100618 newsrv->observe = HANA_OBS_LAYER4;
619 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100620 else if (strcmp(arg, "layer7") == 0) {
Frédéric Lécaille547356e2017-03-15 08:55:39 +0100621 if (curproxy->mode != PR_MODE_HTTP) {
622 memprintf(err, "'%s' can only be used in http proxies.\n", arg);
623 return ERR_ALERT;
624 }
625 newsrv->observe = HANA_OBS_LAYER7;
626 }
627 else {
628 memprintf(err, "'%s' expects one of 'none', 'layer4', 'layer7' "
629 "but got '%s'\n", args[*cur_arg], arg);
630 return ERR_ALERT | ERR_FATAL;
631 }
632
633 return 0;
634}
635
Frédéric Lécaille16186232017-03-14 16:42:49 +0100636/* Parse the "redir" server keyword */
637static int srv_parse_redir(char **args, int *cur_arg,
638 struct proxy *curproxy, struct server *newsrv, char **err)
639{
640 char *arg;
641
642 arg = args[*cur_arg + 1];
643 if (!*arg) {
644 memprintf(err, "'%s' expects <prefix> as argument.\n", args[*cur_arg]);
645 return ERR_ALERT | ERR_FATAL;
646 }
647
648 free(newsrv->rdr_pfx);
649 newsrv->rdr_pfx = strdup(arg);
650 newsrv->rdr_len = strlen(arg);
651
652 return 0;
653}
654
Frédéric Lécaille31045e42017-03-10 16:40:00 +0100655/* Parse the "send-proxy" server keyword */
656static int srv_parse_send_proxy(char **args, int *cur_arg,
657 struct proxy *curproxy, struct server *newsrv, char **err)
658{
659 return srv_enable_pp_flags(newsrv, SRV_PP_V1);
660}
661
662/* Parse the "send-proxy-v2" server keyword */
663static int srv_parse_send_proxy_v2(char **args, int *cur_arg,
664 struct proxy *curproxy, struct server *newsrv, char **err)
665{
666 return srv_enable_pp_flags(newsrv, SRV_PP_V2);
667}
668
Frédéric Lécailledba97072017-03-17 15:33:50 +0100669
670/* Parse the "source" server keyword */
671static int srv_parse_source(char **args, int *cur_arg,
672 struct proxy *curproxy, struct server *newsrv, char **err)
673{
674 char *errmsg;
675 int port_low, port_high;
676 struct sockaddr_storage *sk;
Frédéric Lécailledba97072017-03-17 15:33:50 +0100677
678 errmsg = NULL;
679
680 if (!*args[*cur_arg + 1]) {
681 memprintf(err, "'%s' expects <addr>[:<port>[-<port>]], and optionally '%s' <addr>, "
682 "and '%s' <name> as argument.\n", args[*cur_arg], "usesrc", "interface");
683 goto err;
684 }
685
686 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200687 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
688 &errmsg, NULL, NULL,
689 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_RANGE | PA_O_STREAM | PA_O_CONNECT);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100690 if (!sk) {
691 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
692 goto err;
693 }
694
Frédéric Lécailledba97072017-03-17 15:33:50 +0100695 newsrv->conn_src.opts |= CO_SRC_BIND;
696 newsrv->conn_src.source_addr = *sk;
697
698 if (port_low != port_high) {
699 int i;
700
Frédéric Lécailledba97072017-03-17 15:33:50 +0100701 newsrv->conn_src.sport_range = port_range_alloc_range(port_high - port_low + 1);
702 for (i = 0; i < newsrv->conn_src.sport_range->size; i++)
703 newsrv->conn_src.sport_range->ports[i] = port_low + i;
704 }
705
706 *cur_arg += 2;
707 while (*(args[*cur_arg])) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100708 if (strcmp(args[*cur_arg], "usesrc") == 0) { /* address to use outside */
Frédéric Lécailledba97072017-03-17 15:33:50 +0100709#if defined(CONFIG_HAP_TRANSPARENT)
710 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100711 ha_alert("'usesrc' expects <addr>[:<port>], 'client', 'clientip', "
712 "or 'hdr_ip(name,#)' as argument.\n");
Frédéric Lécailledba97072017-03-17 15:33:50 +0100713 goto err;
714 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100715 if (strcmp(args[*cur_arg + 1], "client") == 0) {
Frédéric Lécailledba97072017-03-17 15:33:50 +0100716 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
717 newsrv->conn_src.opts |= CO_SRC_TPROXY_CLI;
718 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100719 else if (strcmp(args[*cur_arg + 1], "clientip") == 0) {
Frédéric Lécailledba97072017-03-17 15:33:50 +0100720 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
721 newsrv->conn_src.opts |= CO_SRC_TPROXY_CIP;
722 }
723 else if (!strncmp(args[*cur_arg + 1], "hdr_ip(", 7)) {
724 char *name, *end;
725
726 name = args[*cur_arg + 1] + 7;
Willy Tarreau90807112020-02-25 08:16:33 +0100727 while (isspace((unsigned char)*name))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100728 name++;
729
730 end = name;
Willy Tarreau90807112020-02-25 08:16:33 +0100731 while (*end && !isspace((unsigned char)*end) && *end != ',' && *end != ')')
Frédéric Lécailledba97072017-03-17 15:33:50 +0100732 end++;
733
734 newsrv->conn_src.opts &= ~CO_SRC_TPROXY_MASK;
735 newsrv->conn_src.opts |= CO_SRC_TPROXY_DYN;
736 free(newsrv->conn_src.bind_hdr_name);
737 newsrv->conn_src.bind_hdr_name = calloc(1, end - name + 1);
738 newsrv->conn_src.bind_hdr_len = end - name;
739 memcpy(newsrv->conn_src.bind_hdr_name, name, end - name);
740 newsrv->conn_src.bind_hdr_name[end - name] = '\0';
741 newsrv->conn_src.bind_hdr_occ = -1;
742
743 /* now look for an occurrence number */
Willy Tarreau90807112020-02-25 08:16:33 +0100744 while (isspace((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100745 end++;
746 if (*end == ',') {
747 end++;
748 name = end;
749 if (*end == '-')
750 end++;
Willy Tarreau90807112020-02-25 08:16:33 +0100751 while (isdigit((unsigned char)*end))
Frédéric Lécailledba97072017-03-17 15:33:50 +0100752 end++;
753 newsrv->conn_src.bind_hdr_occ = strl2ic(name, end - name);
754 }
755
756 if (newsrv->conn_src.bind_hdr_occ < -MAX_HDR_HISTORY) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100757 ha_alert("usesrc hdr_ip(name,num) does not support negative"
758 " occurrences values smaller than %d.\n", MAX_HDR_HISTORY);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100759 goto err;
760 }
761 }
762 else {
763 struct sockaddr_storage *sk;
764 int port1, port2;
765
766 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200767 sk = str2sa_range(args[*cur_arg + 1], NULL, &port1, &port2, NULL, NULL,
768 &errmsg, NULL, NULL,
769 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_STREAM | PA_O_CONNECT);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100770 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100771 ha_alert("'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100772 goto err;
773 }
774
Frédéric Lécailledba97072017-03-17 15:33:50 +0100775 newsrv->conn_src.tproxy_addr = *sk;
776 newsrv->conn_src.opts |= CO_SRC_TPROXY_ADDR;
777 }
778 global.last_checks |= LSTCHK_NETADM;
779 *cur_arg += 2;
780 continue;
781#else /* no TPROXY support */
Christopher Faulet767a84b2017-11-24 16:50:31 +0100782 ha_alert("'usesrc' not allowed here because support for TPROXY was not compiled in.\n");
Frédéric Lécailledba97072017-03-17 15:33:50 +0100783 goto err;
784#endif /* defined(CONFIG_HAP_TRANSPARENT) */
785 } /* "usesrc" */
786
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100787 if (strcmp(args[*cur_arg], "interface") == 0) { /* specifically bind to this interface */
Frédéric Lécailledba97072017-03-17 15:33:50 +0100788#ifdef SO_BINDTODEVICE
789 if (!*args[*cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100790 ha_alert("'%s' : missing interface name.\n", args[0]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100791 goto err;
792 }
793 free(newsrv->conn_src.iface_name);
794 newsrv->conn_src.iface_name = strdup(args[*cur_arg + 1]);
795 newsrv->conn_src.iface_len = strlen(newsrv->conn_src.iface_name);
796 global.last_checks |= LSTCHK_NETADM;
797#else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100798 ha_alert("'%s' : '%s' option not implemented.\n", args[0], args[*cur_arg]);
Frédéric Lécailledba97072017-03-17 15:33:50 +0100799 goto err;
800#endif
801 *cur_arg += 2;
802 continue;
803 }
804 /* this keyword in not an option of "source" */
805 break;
806 } /* while */
807
808 return 0;
809
810 err:
811 free(errmsg);
812 return ERR_ALERT | ERR_FATAL;
813}
814
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +0100815/* Parse the "stick" server keyword */
816static int srv_parse_stick(char **args, int *cur_arg,
817 struct proxy *curproxy, struct server *newsrv, char **err)
818{
819 newsrv->flags &= ~SRV_F_NON_STICK;
820 return 0;
821}
822
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100823/* Parse the "track" server keyword */
824static int srv_parse_track(char **args, int *cur_arg,
825 struct proxy *curproxy, struct server *newsrv, char **err)
826{
827 char *arg;
828
829 arg = args[*cur_arg + 1];
830 if (!*arg) {
831 memprintf(err, "'track' expects [<proxy>/]<server> as argument.\n");
832 return ERR_ALERT | ERR_FATAL;
833 }
834
835 free(newsrv->trackit);
836 newsrv->trackit = strdup(arg);
837
838 return 0;
Alexander Liu2a54bb72019-05-22 19:44:48 +0800839}
840
841/* Parse the "socks4" server keyword */
842static int srv_parse_socks4(char **args, int *cur_arg,
843 struct proxy *curproxy, struct server *newsrv, char **err)
844{
845 char *errmsg;
846 int port_low, port_high;
847 struct sockaddr_storage *sk;
Alexander Liu2a54bb72019-05-22 19:44:48 +0800848
849 errmsg = NULL;
850
851 if (!*args[*cur_arg + 1]) {
852 memprintf(err, "'%s' expects <addr>:<port> as argument.\n", args[*cur_arg]);
853 goto err;
854 }
855
856 /* 'sk' is statically allocated (no need to be freed). */
Willy Tarreau65ec4e32020-09-16 19:17:08 +0200857 sk = str2sa_range(args[*cur_arg + 1], NULL, &port_low, &port_high, NULL, NULL,
858 &errmsg, NULL, NULL,
859 PA_O_RESOLVE | PA_O_PORT_OK | PA_O_PORT_MAND | PA_O_STREAM | PA_O_CONNECT);
Alexander Liu2a54bb72019-05-22 19:44:48 +0800860 if (!sk) {
861 memprintf(err, "'%s %s' : %s\n", args[*cur_arg], args[*cur_arg + 1], errmsg);
862 goto err;
863 }
864
Alexander Liu2a54bb72019-05-22 19:44:48 +0800865 newsrv->flags |= SRV_F_SOCKS4_PROXY;
866 newsrv->socks4_addr = *sk;
867
Alexander Liu2a54bb72019-05-22 19:44:48 +0800868 return 0;
869
870 err:
871 free(errmsg);
872 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille67e0e612017-03-14 15:21:31 +0100873}
874
Frédéric Lécailledba97072017-03-17 15:33:50 +0100875
Willy Tarreau034c88c2017-01-23 23:36:45 +0100876/* parse the "tfo" server keyword */
877static int srv_parse_tfo(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
878{
879 newsrv->flags |= SRV_F_FASTOPEN;
880 return 0;
881}
882
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200883/* Shutdown all connections of a server. The caller must pass a termination
Willy Tarreaue7dff022015-04-03 01:14:29 +0200884 * code in <why>, which must be one of SF_ERR_* indicating the reason for the
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200885 * shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200886 *
887 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200888 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200889void srv_shutdown_streams(struct server *srv, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200890{
Willy Tarreau751153e2021-02-17 13:33:24 +0100891 struct stream *stream;
892 struct mt_list *elt1, elt2;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200893
Willy Tarreau751153e2021-02-17 13:33:24 +0100894 mt_list_for_each_entry_safe(stream, &srv->actconns, by_srv, elt1, elt2)
Willy Tarreau87b09662015-04-03 00:22:06 +0200895 if (stream->srv_conn == srv)
896 stream_shutdown(stream, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200897}
898
899/* Shutdown all connections of all backup servers of a proxy. The caller must
Willy Tarreaue7dff022015-04-03 01:14:29 +0200900 * pass a termination code in <why>, which must be one of SF_ERR_* indicating
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200901 * the reason for the shutdown.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200902 *
903 * Must be called with the server lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200904 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200905void srv_shutdown_backup_streams(struct proxy *px, int why)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200906{
907 struct server *srv;
908
909 for (srv = px->srv; srv != NULL; srv = srv->next)
910 if (srv->flags & SRV_F_BACKUP)
Willy Tarreau87b09662015-04-03 00:22:06 +0200911 srv_shutdown_streams(srv, why);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200912}
913
Willy Tarreaubda92272014-05-20 21:55:30 +0200914/* Appends some information to a message string related to a server going UP or
915 * DOWN. If both <forced> and <reason> are null and the server tracks another
916 * one, a "via" information will be provided to know where the status came from.
Emeric Brun5a133512017-10-19 14:42:30 +0200917 * If <check> is non-null, an entire string describing the check result will be
918 * appended after a comma and a space (eg: to report some information from the
919 * check that changed the state). In the other case, the string will be built
920 * using the check results stored into the struct server if present.
921 * If <xferred> is non-negative, some information about requeued sessions are
Willy Tarreaubda92272014-05-20 21:55:30 +0200922 * provided.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200923 *
924 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200925 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200926void srv_append_status(struct buffer *msg, struct server *s,
927 struct check *check, int xferred, int forced)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200928{
Emeric Brun5a133512017-10-19 14:42:30 +0200929 short status = s->op_st_chg.status;
930 short code = s->op_st_chg.code;
931 long duration = s->op_st_chg.duration;
932 char *desc = s->op_st_chg.reason;
933
934 if (check) {
935 status = check->status;
936 code = check->code;
937 duration = check->duration;
938 desc = check->desc;
939 }
940
941 if (status != -1) {
942 chunk_appendf(msg, ", reason: %s", get_check_status_description(status));
943
944 if (status >= HCHK_STATUS_L57DATA)
945 chunk_appendf(msg, ", code: %d", code);
946
947 if (desc && *desc) {
Willy Tarreau83061a82018-07-13 11:56:34 +0200948 struct buffer src;
Emeric Brun5a133512017-10-19 14:42:30 +0200949
950 chunk_appendf(msg, ", info: \"");
951
952 chunk_initlen(&src, desc, 0, strlen(desc));
953 chunk_asciiencode(msg, &src, '"');
954
955 chunk_appendf(msg, "\"");
956 }
957
958 if (duration >= 0)
959 chunk_appendf(msg, ", check duration: %ldms", duration);
960 }
961 else if (desc && *desc) {
962 chunk_appendf(msg, ", %s", desc);
963 }
964 else if (!forced && s->track) {
Willy Tarreaubda92272014-05-20 21:55:30 +0200965 chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id);
Emeric Brun5a133512017-10-19 14:42:30 +0200966 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200967
968 if (xferred >= 0) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200969 if (s->next_state == SRV_ST_STOPPED)
Willy Tarreaua0066dd2014-05-16 11:25:16 +0200970 chunk_appendf(msg, ". %d active and %d backup servers left.%s"
971 " %d sessions active, %d requeued, %d remaining in queue",
972 s->proxy->srv_act, s->proxy->srv_bck,
973 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
974 s->cur_sess, xferred, s->nbpend);
975 else
976 chunk_appendf(msg, ". %d active and %d backup servers online.%s"
977 " %d sessions requeued, %d total in queue",
978 s->proxy->srv_act, s->proxy->srv_bck,
979 (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
980 xferred, s->nbpend);
981 }
982}
983
Emeric Brun5a133512017-10-19 14:42:30 +0200984/* Marks server <s> down, regardless of its checks' statuses. The server is
985 * registered in a list to postpone the counting of the remaining servers on
986 * the proxy and transfers queued streams whenever possible to other servers at
987 * a sync point. Maintenance servers are ignored. It stores the <reason> if
988 * non-null as the reason for going down or the available data from the check
989 * struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +0200990 *
991 * Must be called with the server lock held.
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200992 */
Emeric Brun5a133512017-10-19 14:42:30 +0200993void srv_set_stopped(struct server *s, const char *reason, struct check *check)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200994{
995 struct server *srv;
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200996
Emeric Brun64cc49c2017-10-03 14:46:45 +0200997 if ((s->cur_admin & SRV_ADMF_MAINT) || s->next_state == SRV_ST_STOPPED)
Willy Tarreaue7d1ef12014-05-20 22:25:12 +0200998 return;
999
Emeric Brun52a91d32017-08-31 14:41:55 +02001000 s->next_state = SRV_ST_STOPPED;
Emeric Brun5a133512017-10-19 14:42:30 +02001001 *s->op_st_chg.reason = 0;
1002 s->op_st_chg.status = -1;
1003 if (reason) {
1004 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1005 }
1006 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001007 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001008 s->op_st_chg.code = check->code;
1009 s->op_st_chg.status = check->status;
1010 s->op_st_chg.duration = check->duration;
1011 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001012
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001013 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001014 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001015
Emeric Brun9f0b4582017-10-23 14:39:51 +02001016 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001017 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001018 srv_set_stopped(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001019 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001020 }
Willy Tarreaue7d1ef12014-05-20 22:25:12 +02001021}
1022
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001023/* Marks server <s> up regardless of its checks' statuses and provided it isn't
Emeric Brun5a133512017-10-19 14:42:30 +02001024 * in maintenance. The server is registered in a list to postpone the counting
1025 * of the remaining servers on the proxy and tries to grab requests from the
1026 * proxy at a sync point. Maintenance servers are ignored. It stores the
1027 * <reason> if non-null as the reason for going down or the available data
1028 * from the check struct to recompute this reason later.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001029 *
1030 * Must be called with the server lock held.
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001031 */
Emeric Brun5a133512017-10-19 14:42:30 +02001032void srv_set_running(struct server *s, const char *reason, struct check *check)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001033{
1034 struct server *srv;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001035
Emeric Brun64cc49c2017-10-03 14:46:45 +02001036 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001037 return;
1038
Emeric Brun52a91d32017-08-31 14:41:55 +02001039 if (s->next_state == SRV_ST_STARTING || s->next_state == SRV_ST_RUNNING)
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001040 return;
1041
Emeric Brun52a91d32017-08-31 14:41:55 +02001042 s->next_state = SRV_ST_STARTING;
Emeric Brun5a133512017-10-19 14:42:30 +02001043 *s->op_st_chg.reason = 0;
1044 s->op_st_chg.status = -1;
1045 if (reason) {
1046 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1047 }
1048 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001049 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001050 s->op_st_chg.code = check->code;
1051 s->op_st_chg.status = check->status;
1052 s->op_st_chg.duration = check->duration;
1053 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001054
Emeric Brun64cc49c2017-10-03 14:46:45 +02001055 if (s->slowstart <= 0)
1056 s->next_state = SRV_ST_RUNNING;
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001057
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001058 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001059 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001060
Emeric Brun9f0b4582017-10-23 14:39:51 +02001061 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001062 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001063 srv_set_running(srv, NULL, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001064 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001065 }
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001066}
1067
Willy Tarreau8eb77842014-05-21 13:54:57 +02001068/* Marks server <s> stopping regardless of its checks' statuses and provided it
Emeric Brun5a133512017-10-19 14:42:30 +02001069 * isn't in maintenance. The server is registered in a list to postpone the
1070 * counting of the remaining servers on the proxy and tries to grab requests
1071 * from the proxy. Maintenance servers are ignored. It stores the
1072 * <reason> if non-null as the reason for going down or the available data
1073 * from the check struct to recompute this reason later.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001074 * up. Note that it makes use of the trash to build the log strings, so <reason>
1075 * must not be placed there.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001076 *
1077 * Must be called with the server lock held.
Willy Tarreau8eb77842014-05-21 13:54:57 +02001078 */
Emeric Brun5a133512017-10-19 14:42:30 +02001079void srv_set_stopping(struct server *s, const char *reason, struct check *check)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001080{
1081 struct server *srv;
Willy Tarreau8eb77842014-05-21 13:54:57 +02001082
Emeric Brun64cc49c2017-10-03 14:46:45 +02001083 if (s->cur_admin & SRV_ADMF_MAINT)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001084 return;
1085
Emeric Brun52a91d32017-08-31 14:41:55 +02001086 if (s->next_state == SRV_ST_STOPPING)
Willy Tarreau8eb77842014-05-21 13:54:57 +02001087 return;
1088
Emeric Brun52a91d32017-08-31 14:41:55 +02001089 s->next_state = SRV_ST_STOPPING;
Emeric Brun5a133512017-10-19 14:42:30 +02001090 *s->op_st_chg.reason = 0;
1091 s->op_st_chg.status = -1;
1092 if (reason) {
1093 strlcpy2(s->op_st_chg.reason, reason, sizeof(s->op_st_chg.reason));
1094 }
1095 else if (check) {
Willy Tarreau358847f2017-11-20 21:33:21 +01001096 strlcpy2(s->op_st_chg.reason, check->desc, sizeof(s->op_st_chg.reason));
Emeric Brun5a133512017-10-19 14:42:30 +02001097 s->op_st_chg.code = check->code;
1098 s->op_st_chg.status = check->status;
1099 s->op_st_chg.duration = check->duration;
1100 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001101
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001102 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001103 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001104
Emeric Brun9f0b4582017-10-23 14:39:51 +02001105 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001106 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Emeric Brun5a133512017-10-19 14:42:30 +02001107 srv_set_stopping(srv, NULL, NULL);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001108 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001109 }
Willy Tarreau8eb77842014-05-21 13:54:57 +02001110}
Willy Tarreaudbd5e782014-05-20 22:46:35 +02001111
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001112/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1113 * enforce either maint mode or drain mode. It is not allowed to set more than
1114 * one flag at once. The equivalent "inherited" flag is propagated to all
1115 * tracking servers. Maintenance mode disables health checks (but not agent
1116 * checks). When either the flag is already set or no flag is passed, nothing
Willy Tarreau8b428482016-11-07 15:53:43 +01001117 * is done. If <cause> is non-null, it will be displayed at the end of the log
1118 * lines to justify the state change.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001119 *
1120 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001121 */
Willy Tarreau8b428482016-11-07 15:53:43 +01001122void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001123{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001124 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001125
1126 if (!mode)
1127 return;
1128
1129 /* stop going down as soon as we meet a server already in the same state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001130 if (s->next_admin & mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001131 return;
1132
Emeric Brun52a91d32017-08-31 14:41:55 +02001133 s->next_admin |= mode;
Emeric Brun64cc49c2017-10-03 14:46:45 +02001134 if (cause)
1135 strlcpy2(s->adm_st_chg_cause, cause, sizeof(s->adm_st_chg_cause));
1136
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001137 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001138 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001139
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001140 /* stop going down if the equivalent flag was already present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001141 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & ~mode & SRV_ADMF_MAINT)) ||
1142 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & ~mode & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001143 return;
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001144
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001145 /* compute the inherited flag to propagate */
1146 if (mode & SRV_ADMF_MAINT)
1147 mode = SRV_ADMF_IMAINT;
1148 else if (mode & SRV_ADMF_DRAIN)
1149 mode = SRV_ADMF_IDRAIN;
1150
Emeric Brun9f0b4582017-10-23 14:39:51 +02001151 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001152 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreau8b428482016-11-07 15:53:43 +01001153 srv_set_admin_flag(srv, mode, cause);
Christopher Faulet8d01fd62018-01-24 21:49:41 +01001154 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001155 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001156}
1157
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001158/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
1159 * stop enforcing either maint mode or drain mode. It is not allowed to set more
1160 * than one flag at once. The equivalent "inherited" flag is propagated to all
1161 * tracking servers. Leaving maintenance mode re-enables health checks. When
1162 * either the flag is already cleared or no flag is passed, nothing is done.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001163 *
1164 * Must be called with the server lock held.
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001165 */
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001166void srv_clr_admin_flag(struct server *s, enum srv_admin mode)
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001167{
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001168 struct server *srv;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001169
1170 if (!mode)
1171 return;
1172
1173 /* stop going down as soon as we see the flag is not there anymore */
Emeric Brun52a91d32017-08-31 14:41:55 +02001174 if (!(s->next_admin & mode))
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001175 return;
1176
Emeric Brun52a91d32017-08-31 14:41:55 +02001177 s->next_admin &= ~mode;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001178
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001179 /* propagate changes */
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001180 srv_update_status(s);
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001181
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001182 /* stop going down if the equivalent flag is still present (forced or inherited) */
Emeric Brun52a91d32017-08-31 14:41:55 +02001183 if (((mode & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) ||
1184 ((mode & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)))
Willy Tarreaueeba36b2018-08-21 08:22:26 +02001185 return;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001186
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001187 if (mode & SRV_ADMF_MAINT)
1188 mode = SRV_ADMF_IMAINT;
1189 else if (mode & SRV_ADMF_DRAIN)
1190 mode = SRV_ADMF_IDRAIN;
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001191
Emeric Brun9f0b4582017-10-23 14:39:51 +02001192 for (srv = s->trackers; srv; srv = srv->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001193 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Willy Tarreaubfc7b7a2014-05-22 16:14:34 +02001194 srv_clr_admin_flag(srv, mode);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001195 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02001196 }
Willy Tarreaua0066dd2014-05-16 11:25:16 +02001197}
1198
Willy Tarreau757478e2016-11-03 19:22:19 +01001199/* principle: propagate maint and drain to tracking servers. This is useful
1200 * upon startup so that inherited states are correct.
1201 */
1202static void srv_propagate_admin_state(struct server *srv)
1203{
1204 struct server *srv2;
1205
1206 if (!srv->trackers)
1207 return;
1208
1209 for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001210 HA_SPIN_LOCK(SERVER_LOCK, &srv2->lock);
Emeric Brun52a91d32017-08-31 14:41:55 +02001211 if (srv->next_admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT))
Willy Tarreau8b428482016-11-07 15:53:43 +01001212 srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL);
Willy Tarreau757478e2016-11-03 19:22:19 +01001213
Emeric Brun52a91d32017-08-31 14:41:55 +02001214 if (srv->next_admin & SRV_ADMF_DRAIN)
Willy Tarreau8b428482016-11-07 15:53:43 +01001215 srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001216 HA_SPIN_UNLOCK(SERVER_LOCK, &srv2->lock);
Willy Tarreau757478e2016-11-03 19:22:19 +01001217 }
1218}
1219
1220/* Compute and propagate the admin states for all servers in proxy <px>.
1221 * Only servers *not* tracking another one are considered, because other
1222 * ones will be handled when the server they track is visited.
1223 */
1224void srv_compute_all_admin_states(struct proxy *px)
1225{
1226 struct server *srv;
1227
1228 for (srv = px->srv; srv; srv = srv->next) {
1229 if (srv->track)
1230 continue;
1231 srv_propagate_admin_state(srv);
1232 }
1233}
1234
Willy Tarreaudff55432012-10-10 17:51:05 +02001235/* Note: must not be declared <const> as its list will be overwritten.
1236 * Please take care of keeping this list alphabetically sorted, doing so helps
1237 * all code contributors.
1238 * Optional keywords are also declared with a NULL ->parse() function so that
1239 * the config parser can report an appropriate error when a known keyword was
1240 * not enabled.
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001241 * Note: -1 as ->skip value means that the number of arguments are variable.
Willy Tarreaudff55432012-10-10 17:51:05 +02001242 */
1243static struct srv_kw_list srv_kws = { "ALL", { }, {
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001244 { "backup", srv_parse_backup, 0, 1 }, /* Flag as backup server */
Frédéric Lécaille9d1b95b2017-03-15 09:13:33 +01001245 { "cookie", srv_parse_cookie, 1, 1 }, /* Assign a cookie to the server */
Frédéric Lécaille2a0d0612017-03-21 11:53:54 +01001246 { "disabled", srv_parse_disabled, 0, 1 }, /* Start the server in 'disabled' state */
1247 { "enabled", srv_parse_enabled, 0, 1 }, /* Start the server in 'enabled' state */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001248 { "id", srv_parse_id, 1, 0 }, /* set id# of server */
Willy Tarreau9c538e02019-01-23 10:21:49 +01001249 { "max-reuse", srv_parse_max_reuse, 1, 1 }, /* Set the max number of requests on a connection, -1 means unlimited */
Frédéric Lécaille22f41a22017-03-16 17:17:36 +01001250 { "namespace", srv_parse_namespace, 1, 1 }, /* Namespace the server socket belongs to (if supported) */
Frédéric Lécaille1502cfd2017-03-10 15:36:14 +01001251 { "no-backup", srv_parse_no_backup, 0, 1 }, /* Flag as non-backup server */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001252 { "no-send-proxy", srv_parse_no_send_proxy, 0, 1 }, /* Disable use of PROXY V1 protocol */
1253 { "no-send-proxy-v2", srv_parse_no_send_proxy_v2, 0, 1 }, /* Disable use of PROXY V2 protocol */
Frédéric Lécaille1b9423d2019-07-04 14:19:06 +02001254 { "no-tfo", srv_parse_no_tfo, 0, 1 }, /* Disable use of TCP Fast Open */
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +01001255 { "non-stick", srv_parse_non_stick, 0, 1 }, /* Disable stick-table persistence */
Frédéric Lécaille547356e2017-03-15 08:55:39 +01001256 { "observe", srv_parse_observe, 1, 1 }, /* Enables health adjusting based on observing communication with the server */
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02001257 { "pool-low-conn", srv_parse_pool_low_conn, 1, 1 }, /* Set the min number of orphan idle connecbefore being allowed to pick from other threads */
Amaury Denoyelle18c68df2021-01-26 14:35:24 +01001258 { "pool-max-conn", srv_parse_pool_max_conn, 1, 1 }, /* Set the max number of orphan idle connections, -1 means unlimited */
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01001259 { "pool-purge-delay", srv_parse_pool_purge_delay, 1, 1 }, /* Set the time before we destroy orphan idle connections, defaults to 1s */
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001260 { "proto", srv_parse_proto, 1, 1 }, /* Set the proto to use for all outgoing connections */
Emmanuel Hocdetf643b802018-02-01 15:20:32 +01001261 { "proxy-v2-options", srv_parse_proxy_v2_options, 1, 1 }, /* options for send-proxy-v2 */
Frédéric Lécaille16186232017-03-14 16:42:49 +01001262 { "redir", srv_parse_redir, 1, 1 }, /* Enable redirection mode */
Frédéric Lécaille31045e42017-03-10 16:40:00 +01001263 { "send-proxy", srv_parse_send_proxy, 0, 1 }, /* Enforce use of PROXY V1 protocol */
1264 { "send-proxy-v2", srv_parse_send_proxy_v2, 0, 1 }, /* Enforce use of PROXY V2 protocol */
Frédéric Lécailledfacd692017-04-16 17:14:14 +02001265 { "source", srv_parse_source, -1, 1 }, /* Set the source address to be used to connect to the server */
Frédéric Lécaillef9bc1d62017-03-10 15:50:49 +01001266 { "stick", srv_parse_stick, 0, 1 }, /* Enable stick-table persistence */
Olivier Houchard8d82db72019-07-04 13:34:10 +02001267 { "tfo", srv_parse_tfo, 0, 1 }, /* enable TCP Fast Open of server */
Frédéric Lécaille67e0e612017-03-14 15:21:31 +01001268 { "track", srv_parse_track, 1, 1 }, /* Set the current state of the server, tracking another one */
Alexander Liu2a54bb72019-05-22 19:44:48 +08001269 { "socks4", srv_parse_socks4, 1, 1 }, /* Set the socks4 proxy of the server*/
Willy Tarreaudff55432012-10-10 17:51:05 +02001270 { NULL, NULL, 0 },
1271}};
1272
Willy Tarreau0108d902018-11-25 19:14:37 +01001273INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
Willy Tarreaudff55432012-10-10 17:51:05 +02001274
Willy Tarreau004e0452013-11-21 11:22:01 +01001275/* Recomputes the server's eweight based on its state, uweight, the current time,
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001276 * and the proxy's algorithm. To be used after updating sv->uweight. The warmup
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001277 * state is automatically disabled if the time is elapsed. If <must_update> is
1278 * not zero, the update will be propagated immediately.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001279 *
1280 * Must be called with the server lock held.
Willy Tarreau004e0452013-11-21 11:22:01 +01001281 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001282void server_recalc_eweight(struct server *sv, int must_update)
Willy Tarreau004e0452013-11-21 11:22:01 +01001283{
1284 struct proxy *px = sv->proxy;
1285 unsigned w;
1286
1287 if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) {
1288 /* go to full throttle if the slowstart interval is reached */
Emeric Brun52a91d32017-08-31 14:41:55 +02001289 if (sv->next_state == SRV_ST_STARTING)
1290 sv->next_state = SRV_ST_RUNNING;
Willy Tarreau004e0452013-11-21 11:22:01 +01001291 }
1292
1293 /* We must take care of not pushing the server to full throttle during slow starts.
1294 * It must also start immediately, at least at the minimal step when leaving maintenance.
1295 */
Emeric Brun52a91d32017-08-31 14:41:55 +02001296 if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
Willy Tarreau004e0452013-11-21 11:22:01 +01001297 w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart;
1298 else
1299 w = px->lbprm.wdiv;
1300
Emeric Brun52a91d32017-08-31 14:41:55 +02001301 sv->next_eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult;
Willy Tarreau004e0452013-11-21 11:22:01 +01001302
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001303 /* propagate changes only if needed (i.e. not recursively) */
Willy Tarreau49725a02018-08-21 19:54:09 +02001304 if (must_update)
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001305 srv_update_status(sv);
Willy Tarreau004e0452013-11-21 11:22:01 +01001306}
1307
Willy Tarreaubaaee002006-06-26 02:48:02 +02001308/*
Simon Horman7d09b9a2013-02-12 10:45:51 +09001309 * Parses weight_str and configures sv accordingly.
1310 * Returns NULL on success, error message string otherwise.
Willy Tarreau46b7f532018-08-21 11:54:26 +02001311 *
1312 * Must be called with the server lock held.
Simon Horman7d09b9a2013-02-12 10:45:51 +09001313 */
1314const char *server_parse_weight_change_request(struct server *sv,
1315 const char *weight_str)
1316{
1317 struct proxy *px;
Simon Hormanb796afa2013-02-12 10:45:53 +09001318 long int w;
1319 char *end;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001320
1321 px = sv->proxy;
1322
1323 /* if the weight is terminated with '%', it is set relative to
1324 * the initial weight, otherwise it is absolute.
1325 */
1326 if (!*weight_str)
1327 return "Require <weight> or <weight%>.\n";
1328
Simon Hormanb796afa2013-02-12 10:45:53 +09001329 w = strtol(weight_str, &end, 10);
1330 if (end == weight_str)
1331 return "Empty weight string empty or preceded by garbage";
1332 else if (end[0] == '%' && end[1] == '\0') {
Simon Horman58b5d292013-02-12 10:45:52 +09001333 if (w < 0)
Simon Horman7d09b9a2013-02-12 10:45:51 +09001334 return "Relative weight must be positive.\n";
Simon Horman58b5d292013-02-12 10:45:52 +09001335 /* Avoid integer overflow */
1336 if (w > 25600)
1337 w = 25600;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001338 w = sv->iweight * w / 100;
Simon Horman58b5d292013-02-12 10:45:52 +09001339 if (w > 256)
1340 w = 256;
Simon Horman7d09b9a2013-02-12 10:45:51 +09001341 }
1342 else if (w < 0 || w > 256)
1343 return "Absolute weight can only be between 0 and 256 inclusive.\n";
Simon Hormanb796afa2013-02-12 10:45:53 +09001344 else if (end[0] != '\0')
1345 return "Trailing garbage in weight string";
Simon Horman7d09b9a2013-02-12 10:45:51 +09001346
1347 if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
1348 return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
1349
1350 sv->uweight = w;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02001351 server_recalc_eweight(sv, 1);
Simon Horman7d09b9a2013-02-12 10:45:51 +09001352
1353 return NULL;
1354}
1355
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001356/*
Thierry Fournier09a91782016-02-24 08:25:39 +01001357 * Parses <addr_str> and configures <sv> accordingly. <from> precise
1358 * the source of the change in the associated message log.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001359 * Returns:
1360 * - error string on error
1361 * - NULL on success
Willy Tarreau46b7f532018-08-21 11:54:26 +02001362 *
1363 * Must be called with the server lock held.
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001364 */
1365const char *server_parse_addr_change_request(struct server *sv,
Thierry Fournier09a91782016-02-24 08:25:39 +01001366 const char *addr_str, const char *updater)
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001367{
1368 unsigned char ip[INET6_ADDRSTRLEN];
1369
1370 if (inet_pton(AF_INET6, addr_str, ip)) {
Christopher Faulet69beaa92021-02-16 12:07:47 +01001371 srv_update_addr(sv, ip, AF_INET6, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001372 return NULL;
1373 }
1374 if (inet_pton(AF_INET, addr_str, ip)) {
Christopher Faulet69beaa92021-02-16 12:07:47 +01001375 srv_update_addr(sv, ip, AF_INET, updater);
Baptiste Assmann3d8f8312015-04-13 22:54:33 +02001376 return NULL;
1377 }
1378
1379 return "Could not understand IP address format.\n";
1380}
1381
Willy Tarreau46b7f532018-08-21 11:54:26 +02001382/*
1383 * Must be called with the server lock held.
1384 */
Nenad Merdanovic174dd372016-04-24 23:10:06 +02001385const char *server_parse_maxconn_change_request(struct server *sv,
1386 const char *maxconn_str)
1387{
1388 long int v;
1389 char *end;
1390
1391 if (!*maxconn_str)
1392 return "Require <maxconn>.\n";
1393
1394 v = strtol(maxconn_str, &end, 10);
1395 if (end == maxconn_str)
1396 return "maxconn string empty or preceded by garbage";
1397 else if (end[0] != '\0')
1398 return "Trailing garbage in maxconn string";
1399
1400 if (sv->maxconn == sv->minconn) { // static maxconn
1401 sv->maxconn = sv->minconn = v;
1402 } else { // dynamic maxconn
1403 sv->maxconn = v;
1404 }
1405
1406 if (may_dequeue_tasks(sv, sv->proxy))
1407 process_srv_queue(sv);
1408
1409 return NULL;
1410}
1411
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001412#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001413static struct sample_expr *srv_sni_sample_parse_expr(struct server *srv, struct proxy *px,
1414 const char *file, int linenum, char **err)
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001415{
1416 int idx;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001417 const char *args[] = {
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001418 srv->sni_expr,
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001419 NULL,
1420 };
1421
1422 idx = 0;
Olivier Houchard7d8e6882017-04-20 18:21:17 +02001423 px->conf.args.ctx = ARGC_SRV;
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001424
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001425 return sample_parse_expr((char **)args, &idx, file, linenum, err, &px->conf.args, NULL);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001426}
1427
1428static int server_parse_sni_expr(struct server *newsrv, struct proxy *px, char **err)
1429{
1430 struct sample_expr *expr;
1431
1432 expr = srv_sni_sample_parse_expr(newsrv, px, px->conf.file, px->conf.line, err);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001433 if (!expr) {
1434 memprintf(err, "error detected while parsing sni expression : %s", *err);
1435 return ERR_ALERT | ERR_FATAL;
1436 }
1437
1438 if (!(expr->fetch->val & SMP_VAL_BE_SRV_CON)) {
1439 memprintf(err, "error detected while parsing sni expression : "
1440 " fetch method '%s' extracts information from '%s', "
1441 "none of which is available here.\n",
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001442 newsrv->sni_expr, sample_src_names(expr->fetch->use));
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001443 return ERR_ALERT | ERR_FATAL;
1444 }
1445
1446 px->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
1447 release_sample_expr(newsrv->ssl_ctx.sni);
1448 newsrv->ssl_ctx.sni = expr;
1449
1450 return 0;
1451}
1452#endif
1453
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001454static void display_parser_err(const char *file, int linenum, char **args, int cur_arg, int err_code, char **err)
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001455{
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001456 char *msg = "error encountered while processing ";
1457 char *quote = "'";
1458 char *token = args[cur_arg];
1459
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001460 if (err && *err) {
1461 indent_msg(err, 2);
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001462 msg = *err;
1463 quote = "";
1464 token = "";
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001465 }
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001466
1467 if (err_code & ERR_WARN && !(err_code & ERR_ALERT))
1468 ha_warning("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1469 file, linenum, args[0], args[1],
1470 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001471 else
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001472 ha_alert("parsing [%s:%d] : '%s %s' : %s%s%s%s.\n",
1473 file, linenum, args[0], args[1],
1474 msg, quote, token, quote);
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01001475}
1476
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001477static void srv_conn_src_sport_range_cpy(struct server *srv,
1478 struct server *src)
1479{
1480 int range_sz;
1481
1482 range_sz = src->conn_src.sport_range->size;
1483 if (range_sz > 0) {
1484 srv->conn_src.sport_range = port_range_alloc_range(range_sz);
1485 if (srv->conn_src.sport_range != NULL) {
1486 int i;
1487
1488 for (i = 0; i < range_sz; i++) {
1489 srv->conn_src.sport_range->ports[i] =
1490 src->conn_src.sport_range->ports[i];
1491 }
1492 }
1493 }
1494}
1495
1496/*
1497 * Copy <src> server connection source settings to <srv> server everything needed.
1498 */
1499static void srv_conn_src_cpy(struct server *srv, struct server *src)
1500{
1501 srv->conn_src.opts = src->conn_src.opts;
1502 srv->conn_src.source_addr = src->conn_src.source_addr;
1503
1504 /* Source port range copy. */
1505 if (src->conn_src.sport_range != NULL)
1506 srv_conn_src_sport_range_cpy(srv, src);
1507
1508#ifdef CONFIG_HAP_TRANSPARENT
1509 if (src->conn_src.bind_hdr_name != NULL) {
1510 srv->conn_src.bind_hdr_name = strdup(src->conn_src.bind_hdr_name);
1511 srv->conn_src.bind_hdr_len = strlen(src->conn_src.bind_hdr_name);
1512 }
1513 srv->conn_src.bind_hdr_occ = src->conn_src.bind_hdr_occ;
1514 srv->conn_src.tproxy_addr = src->conn_src.tproxy_addr;
1515#endif
1516 if (src->conn_src.iface_name != NULL)
1517 srv->conn_src.iface_name = strdup(src->conn_src.iface_name);
1518}
1519
1520/*
1521 * Copy <src> server SSL settings to <srv> server allocating
1522 * everything needed.
1523 */
1524#if defined(USE_OPENSSL)
1525static void srv_ssl_settings_cpy(struct server *srv, struct server *src)
1526{
1527 if (src->ssl_ctx.ca_file != NULL)
1528 srv->ssl_ctx.ca_file = strdup(src->ssl_ctx.ca_file);
1529 if (src->ssl_ctx.crl_file != NULL)
1530 srv->ssl_ctx.crl_file = strdup(src->ssl_ctx.crl_file);
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001531
1532 srv->ssl_ctx.verify = src->ssl_ctx.verify;
1533
1534 if (src->ssl_ctx.verify_host != NULL)
1535 srv->ssl_ctx.verify_host = strdup(src->ssl_ctx.verify_host);
1536 if (src->ssl_ctx.ciphers != NULL)
1537 srv->ssl_ctx.ciphers = strdup(src->ssl_ctx.ciphers);
Jerome Magnin2e8d52f2020-04-22 11:40:18 +02001538 if (src->ssl_ctx.options)
1539 srv->ssl_ctx.options = src->ssl_ctx.options;
1540 if (src->ssl_ctx.methods.flags)
1541 srv->ssl_ctx.methods.flags = src->ssl_ctx.methods.flags;
1542 if (src->ssl_ctx.methods.min)
1543 srv->ssl_ctx.methods.min = src->ssl_ctx.methods.min;
1544 if (src->ssl_ctx.methods.max)
1545 srv->ssl_ctx.methods.max = src->ssl_ctx.methods.max;
1546
Ilya Shipitsin2aa4b3a2021-01-07 11:55:45 +05001547#ifdef HAVE_SSL_CTX_SET_CIPHERSUITES
Dirkjan Bussink415150f2018-09-14 11:14:21 +02001548 if (src->ssl_ctx.ciphersuites != NULL)
1549 srv->ssl_ctx.ciphersuites = strdup(src->ssl_ctx.ciphersuites);
1550#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001551 if (src->sni_expr != NULL)
1552 srv->sni_expr = strdup(src->sni_expr);
Olivier Houchardc7566002018-11-20 23:33:50 +01001553
1554#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
1555 if (src->ssl_ctx.alpn_str) {
1556 srv->ssl_ctx.alpn_str = malloc(src->ssl_ctx.alpn_len);
1557 if (srv->ssl_ctx.alpn_str) {
1558 memcpy(srv->ssl_ctx.alpn_str, src->ssl_ctx.alpn_str,
1559 src->ssl_ctx.alpn_len);
1560 srv->ssl_ctx.alpn_len = src->ssl_ctx.alpn_len;
1561 }
1562 }
1563#endif
1564#ifdef OPENSSL_NPN_NEGOTIATED
1565 if (src->ssl_ctx.npn_str) {
1566 srv->ssl_ctx.npn_str = malloc(src->ssl_ctx.npn_len);
1567 if (srv->ssl_ctx.npn_str) {
1568 memcpy(srv->ssl_ctx.npn_str, src->ssl_ctx.npn_str,
1569 src->ssl_ctx.npn_len);
1570 srv->ssl_ctx.npn_len = src->ssl_ctx.npn_len;
1571 }
1572 }
1573#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001574}
1575#endif
1576
1577/*
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001578 * Prepare <srv> for hostname resolution.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001579 * May be safely called with a default server as <src> argument (without hostname).
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001580 * Returns -1 in case of any allocation failure, 0 if not.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001581 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01001582int srv_prepare_for_resolution(struct server *srv, const char *hostname)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001583{
Christopher Faulet67957bd2017-09-27 11:00:59 +02001584 char *hostname_dn;
1585 int hostname_len, hostname_dn_len;
1586
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001587 if (!hostname)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001588 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001589
Christopher Faulet67957bd2017-09-27 11:00:59 +02001590 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001591 hostname_dn = trash.area;
Emeric Brund30e9a12020-12-23 18:49:16 +01001592 hostname_dn_len = resolv_str_to_dn_label(hostname, hostname_len + 1,
1593 hostname_dn, trash.size);
Christopher Faulet67957bd2017-09-27 11:00:59 +02001594 if (hostname_dn_len == -1)
1595 goto err;
Baptiste Assmann81ed1a02017-05-03 10:11:44 +02001596
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001597
Christopher Faulet67957bd2017-09-27 11:00:59 +02001598 free(srv->hostname);
1599 free(srv->hostname_dn);
1600 srv->hostname = strdup(hostname);
1601 srv->hostname_dn = strdup(hostname_dn);
1602 srv->hostname_dn_len = hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001603 if (!srv->hostname || !srv->hostname_dn)
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001604 goto err;
1605
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001606 return 0;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001607
1608 err:
Christopher Faulet67957bd2017-09-27 11:00:59 +02001609 free(srv->hostname); srv->hostname = NULL;
1610 free(srv->hostname_dn); srv->hostname_dn = NULL;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02001611 return -1;
1612}
1613
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001614/*
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001615 * Copy <src> server settings to <srv> server allocating
1616 * everything needed.
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001617 * This function is not supposed to be called at any time, but only
1618 * during server settings parsing or during server allocations from
1619 * a server template, and just after having calloc()'ed a new server.
1620 * So, <src> may only be a default server (when parsing server settings)
1621 * or a server template (during server allocations from a server template).
1622 * <srv_tmpl> distinguishes these two cases (must be 1 if <srv> is a template,
1623 * 0 if not).
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001624 */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001625static void srv_settings_cpy(struct server *srv, struct server *src, int srv_tmpl)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001626{
1627 /* Connection source settings copy */
1628 srv_conn_src_cpy(srv, src);
1629
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001630 if (srv_tmpl) {
1631 srv->addr = src->addr;
1632 srv->svc_port = src->svc_port;
1633 }
1634
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001635 srv->pp_opts = src->pp_opts;
1636 if (src->rdr_pfx != NULL) {
1637 srv->rdr_pfx = strdup(src->rdr_pfx);
1638 srv->rdr_len = src->rdr_len;
1639 }
1640 if (src->cookie != NULL) {
1641 srv->cookie = strdup(src->cookie);
1642 srv->cklen = src->cklen;
1643 }
1644 srv->use_ssl = src->use_ssl;
Willy Tarreau24441082019-12-11 15:43:45 +01001645 srv->check.addr = src->check.addr;
1646 srv->agent.addr = src->agent.addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001647 srv->check.use_ssl = src->check.use_ssl;
1648 srv->check.port = src->check.port;
Olivier Houchard21944012018-12-21 19:42:01 +01001649 srv->check.sni = src->check.sni;
Olivier Houchard92150142018-12-21 19:47:01 +01001650 srv->check.alpn_str = src->check.alpn_str;
Ilya Shipitsin0c50b1e2019-04-30 21:21:28 +05001651 srv->check.alpn_len = src->check.alpn_len;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001652 /* Note: 'flags' field has potentially been already initialized. */
1653 srv->flags |= src->flags;
1654 srv->do_check = src->do_check;
1655 srv->do_agent = src->do_agent;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001656 srv->check.inter = src->check.inter;
1657 srv->check.fastinter = src->check.fastinter;
1658 srv->check.downinter = src->check.downinter;
1659 srv->agent.use_ssl = src->agent.use_ssl;
1660 srv->agent.port = src->agent.port;
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02001661
1662 if (src->agent.tcpcheck_rules) {
1663 srv->agent.tcpcheck_rules = calloc(1, sizeof(*srv->agent.tcpcheck_rules));
1664 if (srv->agent.tcpcheck_rules) {
1665 srv->agent.tcpcheck_rules->flags = src->agent.tcpcheck_rules->flags;
1666 srv->agent.tcpcheck_rules->list = src->agent.tcpcheck_rules->list;
1667 LIST_INIT(&srv->agent.tcpcheck_rules->preset_vars);
1668 dup_tcpcheck_vars(&srv->agent.tcpcheck_rules->preset_vars,
1669 &src->agent.tcpcheck_rules->preset_vars);
1670 }
1671 }
1672
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001673 srv->agent.inter = src->agent.inter;
1674 srv->agent.fastinter = src->agent.fastinter;
1675 srv->agent.downinter = src->agent.downinter;
1676 srv->maxqueue = src->maxqueue;
1677 srv->minconn = src->minconn;
1678 srv->maxconn = src->maxconn;
1679 srv->slowstart = src->slowstart;
1680 srv->observe = src->observe;
1681 srv->onerror = src->onerror;
1682 srv->onmarkeddown = src->onmarkeddown;
1683 srv->onmarkedup = src->onmarkedup;
1684 if (src->trackit != NULL)
1685 srv->trackit = strdup(src->trackit);
1686 srv->consecutive_errors_limit = src->consecutive_errors_limit;
1687 srv->uweight = srv->iweight = src->iweight;
1688
1689 srv->check.send_proxy = src->check.send_proxy;
1690 /* health: up, but will fall down at first failure */
1691 srv->check.rise = srv->check.health = src->check.rise;
1692 srv->check.fall = src->check.fall;
1693
1694 /* Here we check if 'disabled' is the default server state */
Emeric Brun52a91d32017-08-31 14:41:55 +02001695 if (src->next_admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) {
1696 srv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT;
1697 srv->next_state = SRV_ST_STOPPED;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001698 srv->check.state |= CHK_ST_PAUSED;
1699 srv->check.health = 0;
1700 }
1701
1702 /* health: up but will fall down at first failure */
1703 srv->agent.rise = srv->agent.health = src->agent.rise;
1704 srv->agent.fall = src->agent.fall;
1705
1706 if (src->resolvers_id != NULL)
1707 srv->resolvers_id = strdup(src->resolvers_id);
Emeric Brun21fbeed2020-12-23 18:01:04 +01001708 srv->resolv_opts.family_prio = src->resolv_opts.family_prio;
1709 srv->resolv_opts.accept_duplicate_ip = src->resolv_opts.accept_duplicate_ip;
1710 srv->resolv_opts.ignore_weight = src->resolv_opts.ignore_weight;
1711 if (srv->resolv_opts.family_prio == AF_UNSPEC)
1712 srv->resolv_opts.family_prio = AF_INET6;
1713 memcpy(srv->resolv_opts.pref_net,
1714 src->resolv_opts.pref_net,
1715 sizeof srv->resolv_opts.pref_net);
1716 srv->resolv_opts.pref_net_nb = src->resolv_opts.pref_net_nb;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001717
1718 srv->init_addr_methods = src->init_addr_methods;
1719 srv->init_addr = src->init_addr;
1720#if defined(USE_OPENSSL)
1721 srv_ssl_settings_cpy(srv, src);
1722#endif
1723#ifdef TCP_USER_TIMEOUT
1724 srv->tcp_ut = src->tcp_ut;
1725#endif
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001726 srv->mux_proto = src->mux_proto;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01001727 srv->pool_purge_delay = src->pool_purge_delay;
Willy Tarreau2f3f4d32020-07-01 07:43:51 +02001728 srv->low_idle_conns = src->low_idle_conns;
Olivier Houchard006e3102018-12-10 18:30:32 +01001729 srv->max_idle_conns = src->max_idle_conns;
Willy Tarreau9c538e02019-01-23 10:21:49 +01001730 srv->max_reuse = src->max_reuse;
Christopher Faulet8ed0a3e2018-04-10 14:45:45 +02001731
Olivier Houchard8da5f982017-08-04 18:35:36 +02001732 if (srv_tmpl)
1733 srv->srvrq = src->srvrq;
Alexander Liu2a54bb72019-05-22 19:44:48 +08001734
1735 srv->check.via_socks4 = src->check.via_socks4;
1736 srv->socks4_addr = src->socks4_addr;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001737}
1738
William Lallemand313bfd12018-10-26 14:47:32 +02001739struct server *new_server(struct proxy *proxy)
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001740{
1741 struct server *srv;
1742
1743 srv = calloc(1, sizeof *srv);
1744 if (!srv)
1745 return NULL;
1746
1747 srv->obj_type = OBJ_TYPE_SERVER;
1748 srv->proxy = proxy;
Willy Tarreau751153e2021-02-17 13:33:24 +01001749 MT_LIST_INIT(&srv->actconns);
Patrick Hemmer0355dab2018-05-11 12:52:31 -04001750 srv->pendconns = EB_ROOT;
Christopher Faulet40a007c2017-07-03 15:41:01 +02001751
Emeric Brun52a91d32017-08-31 14:41:55 +02001752 srv->next_state = SRV_ST_RUNNING; /* early server setup */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001753 srv->last_change = now.tv_sec;
1754
Christopher Faulet38290462020-04-21 11:46:40 +02001755 srv->check.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001756 srv->check.status = HCHK_STATUS_INI;
1757 srv->check.server = srv;
Olivier Houchardc98aa1f2019-01-11 18:17:17 +01001758 srv->check.proxy = proxy;
Christopher Faulet5d503fc2020-03-30 20:34:34 +02001759 srv->check.tcpcheck_rules = &proxy->tcpcheck_rules;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001760
Christopher Faulet38290462020-04-21 11:46:40 +02001761 srv->agent.obj_type = OBJ_TYPE_CHECK;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001762 srv->agent.status = HCHK_STATUS_INI;
1763 srv->agent.server = srv;
Willy Tarreau1ba32032019-01-21 07:48:26 +01001764 srv->agent.proxy = proxy;
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001765 srv->xprt = srv->check.xprt = srv->agent.xprt = xprt_get(XPRT_RAW);
Frédéric Lécaillef46c10c2020-11-23 14:29:28 +01001766#if defined(USE_QUIC)
1767 srv->cids = EB_ROOT_UNIQUE;
1768#endif
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001769
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01001770 srv->extra_counters = NULL;
William Lallemand3ce6eed2021-02-08 10:43:44 +01001771#ifdef USE_OPENSSL
1772 HA_RWLOCK_INIT(&srv->ssl_ctx.lock);
1773#endif
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +01001774
Willy Tarreau975b1552019-06-06 16:25:55 +02001775 /* please don't put default server settings here, they are set in
Willy Tarreau144289b2021-02-12 08:19:01 +01001776 * proxy_preset_defaults().
Willy Tarreau975b1552019-06-06 16:25:55 +02001777 */
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001778 return srv;
1779}
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001780
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001781#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1782static int server_sni_expr_init(const char *file, int linenum, char **args, int cur_arg,
1783 struct server *srv, struct proxy *proxy)
1784{
1785 int ret;
1786 char *err = NULL;
1787
1788 if (!srv->sni_expr)
1789 return 0;
1790
1791 ret = server_parse_sni_expr(srv, proxy, &err);
1792 if (!ret)
1793 return 0;
1794
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01001795 display_parser_err(file, linenum, args, cur_arg, ret, &err);
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001796 free(err);
1797
1798 return ret;
1799}
1800#endif
1801
1802/*
1803 * Server initializations finalization.
1804 * Initialize health check, agent check and SNI expression if enabled.
1805 * Must not be called for a default server instance.
1806 */
1807static int server_finalize_init(const char *file, int linenum, char **args, int cur_arg,
1808 struct server *srv, struct proxy *px)
1809{
Christopher Fauletb3b53522020-04-27 11:17:10 +02001810#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001811 int ret;
Christopher Fauletb3b53522020-04-27 11:17:10 +02001812#endif
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001813
Christopher Faulet8892e5d2020-03-26 19:48:20 +01001814 if (srv->do_check && srv->trackit) {
1815 ha_alert("parsing [%s:%d]: unable to enable checks and tracking at the same time!\n",
1816 file, linenum);
1817 return ERR_ALERT | ERR_FATAL;
1818 }
1819
1820 if (srv->do_agent && !srv->agent.port) {
1821 ha_alert("parsing [%s:%d] : server %s does not have agent port. Agent check has been disabled.\n",
1822 file, linenum, srv->id);
1823 return ERR_ALERT | ERR_FATAL;
Frédéric Lécaille759ea982017-03-30 17:32:36 +02001824 }
1825
1826#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1827 if ((ret = server_sni_expr_init(file, linenum, args, cur_arg, srv, px)) != 0)
1828 return ret;
1829#endif
1830
1831 if (srv->flags & SRV_F_BACKUP)
1832 px->srv_bck++;
1833 else
1834 px->srv_act++;
1835 srv_lb_commit_status(srv);
1836
1837 return 0;
1838}
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02001839
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001840/*
1841 * Parse as much as possible such a range string argument: low[-high]
1842 * Set <nb_low> and <nb_high> values so that they may be reused by this loop
1843 * for(int i = nb_low; i <= nb_high; i++)... with nb_low >= 1.
1844 * Fails if 'low' < 0 or 'high' is present and not higher than 'low'.
1845 * Returns 0 if succeeded, -1 if not.
1846 */
1847static int srv_tmpl_parse_range(struct server *srv, const char *arg, int *nb_low, int *nb_high)
1848{
1849 char *nb_high_arg;
1850
1851 *nb_high = 0;
1852 chunk_printf(&trash, "%s", arg);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001853 *nb_low = atoi(trash.area);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001854
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001855 if ((nb_high_arg = strchr(trash.area, '-'))) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001856 *nb_high_arg++ = '\0';
1857 *nb_high = atoi(nb_high_arg);
1858 }
1859 else {
1860 *nb_high += *nb_low;
1861 *nb_low = 1;
1862 }
1863
1864 if (*nb_low < 0 || *nb_high < *nb_low)
1865 return -1;
1866
1867 return 0;
1868}
1869
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001870static inline void srv_set_id_from_prefix(struct server *srv, const char *prefix, int nb)
1871{
1872 chunk_printf(&trash, "%s%d", prefix, nb);
1873 free(srv->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001874 srv->id = strdup(trash.area);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001875}
1876
1877/*
1878 * Initialize as much as possible servers from <srv> server template.
1879 * Note that a server template is a special server with
1880 * a few different parameters than a server which has
1881 * been parsed mostly the same way as a server.
Joseph Herlant44466822018-11-15 08:57:51 -08001882 * Returns the number of servers successfully allocated,
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001883 * 'srv' template included.
1884 */
1885static int server_template_init(struct server *srv, struct proxy *px)
1886{
1887 int i;
1888 struct server *newsrv;
1889
1890 for (i = srv->tmpl_info.nb_low + 1; i <= srv->tmpl_info.nb_high; i++) {
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001891 newsrv = new_server(px);
1892 if (!newsrv)
1893 goto err;
1894
Christopher Faulet75bef002020-11-02 22:04:55 +01001895 newsrv->conf.file = strdup(srv->conf.file);
1896 newsrv->conf.line = srv->conf.line;
1897
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001898 srv_settings_cpy(newsrv, srv, 1);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02001899 srv_prepare_for_resolution(newsrv, srv->hostname);
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001900#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1901 if (newsrv->sni_expr) {
1902 newsrv->ssl_ctx.sni = srv_sni_sample_parse_expr(newsrv, px, NULL, 0, NULL);
1903 if (!newsrv->ssl_ctx.sni)
1904 goto err;
1905 }
1906#endif
1907 /* Set this new server ID. */
1908 srv_set_id_from_prefix(newsrv, srv->tmpl_info.prefix, i);
1909
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02001910 /* Linked backwards first. This will be restablished after parsing. */
1911 newsrv->next = px->srv;
1912 px->srv = newsrv;
1913 }
1914 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1915
1916 return i - srv->tmpl_info.nb_low;
1917
1918 err:
1919 srv_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
1920 if (newsrv) {
1921#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1922 release_sample_expr(newsrv->ssl_ctx.sni);
1923#endif
1924 free_check(&newsrv->agent);
1925 free_check(&newsrv->check);
1926 }
1927 free(newsrv);
1928 return i - srv->tmpl_info.nb_low;
1929}
1930
Emeric Brund3db3842020-07-21 16:54:36 +02001931int parse_server(const char *file, int linenum, char **args, struct proxy *curproxy,
Willy Tarreaubb8669a2021-02-12 12:15:05 +01001932 const struct proxy *defproxy, int parse_addr, int in_peers_section, int initial_resolve)
Willy Tarreau272adea2014-03-31 10:39:59 +02001933{
1934 struct server *newsrv = NULL;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001935 const char *err = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02001936 char *errmsg = NULL;
1937 int err_code = 0;
1938 unsigned val;
Willy Tarreau07101d52015-09-08 16:16:35 +02001939 char *fqdn = NULL;
Willy Tarreau272adea2014-03-31 10:39:59 +02001940
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001941 if (strcmp(args[0], "server") == 0 ||
1942 strcmp(args[0], "peer") == 0 ||
1943 strcmp(args[0], "default-server") == 0 ||
1944 strcmp(args[0], "server-template") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02001945 int cur_arg;
Frédéric Lécaille6e0843c2017-03-21 16:39:15 +01001946 int defsrv = (*args[0] == 'd');
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001947 int srv = !defsrv && (*args[0] == 'p' || strcmp(args[0], "server") == 0);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001948 int srv_tmpl = !defsrv && !srv;
1949 int tmpl_range_low = 0, tmpl_range_high = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02001950
1951 if (!defsrv && curproxy == defproxy) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001952 ha_alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001953 err_code |= ERR_ALERT | ERR_FATAL;
1954 goto out;
1955 }
Christopher Faulete3bdc812021-01-13 13:14:13 +01001956 else if (failifnotcap(curproxy, PR_CAP_BE, file, linenum, args[0], NULL)) {
1957 err_code |= ERR_ALERT | ERR_FATAL;
1958 goto out;
1959 }
Willy Tarreau272adea2014-03-31 10:39:59 +02001960
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001961 /* There is no mandatory first arguments for default server. */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01001962 if (srv && parse_addr) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001963 if (!*args[2]) {
Frédéric Lécaille8ba10fe2020-04-03 09:43:47 +02001964 if (in_peers_section) {
1965 return 0;
1966 }
1967 else {
1968 /* 'server' line number of argument check. */
1969 ha_alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
1970 file, linenum, args[0]);
1971 err_code |= ERR_ALERT | ERR_FATAL;
1972 goto out;
1973 }
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001974 }
1975
1976 err = invalid_char(args[1]);
1977 }
1978 else if (srv_tmpl) {
1979 if (!*args[3]) {
1980 /* 'server-template' line number of argument check. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01001981 ha_alert("parsing [%s:%d] : '%s' expects <prefix> <nb | range> <addr>[:<port>] as arguments.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001982 file, linenum, args[0]);
1983 err_code |= ERR_ALERT | ERR_FATAL;
1984 goto out;
1985 }
1986
1987 err = invalid_prefix_char(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001988 }
1989
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001990 if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001991 ha_alert("parsing [%s:%d] : character '%c' is not permitted in %s %s '%s'.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001992 file, linenum, *err, args[0], srv ? "name" : "prefix", args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02001993 err_code |= ERR_ALERT | ERR_FATAL;
1994 goto out;
1995 }
1996
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02001997 cur_arg = 2;
1998 if (srv_tmpl) {
1999 /* Parse server-template <nb | range> arg. */
2000 if (srv_tmpl_parse_range(newsrv, args[cur_arg], &tmpl_range_low, &tmpl_range_high) < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002001 ha_alert("parsing [%s:%d] : Wrong %s number or range arg '%s'.\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002002 file, linenum, args[0], args[cur_arg]);
2003 err_code |= ERR_ALERT | ERR_FATAL;
2004 goto out;
2005 }
2006 cur_arg++;
2007 }
2008
Willy Tarreau272adea2014-03-31 10:39:59 +02002009 if (!defsrv) {
2010 struct sockaddr_storage *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002011 int port1, port2, port;
Willy Tarreau272adea2014-03-31 10:39:59 +02002012
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002013 newsrv = new_server(curproxy);
2014 if (!newsrv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002015 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
Willy Tarreau272adea2014-03-31 10:39:59 +02002016 err_code |= ERR_ALERT | ERR_ABORT;
2017 goto out;
2018 }
2019
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002020 if (srv_tmpl) {
2021 newsrv->tmpl_info.nb_low = tmpl_range_low;
2022 newsrv->tmpl_info.nb_high = tmpl_range_high;
2023 }
2024
Willy Tarreau272adea2014-03-31 10:39:59 +02002025 /* the servers are linked backwards first */
2026 newsrv->next = curproxy->srv;
2027 curproxy->srv = newsrv;
Willy Tarreau272adea2014-03-31 10:39:59 +02002028 newsrv->conf.file = strdup(file);
2029 newsrv->conf.line = linenum;
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002030 /* Note: for a server template, its id is its prefix.
2031 * This is a temporary id which will be used for server allocations to come
2032 * after parsing.
2033 */
2034 if (srv)
2035 newsrv->id = strdup(args[1]);
2036 else
2037 newsrv->tmpl_info.prefix = strdup(args[1]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002038
2039 /* several ways to check the port component :
2040 * - IP => port=+0, relative (IPv4 only)
2041 * - IP: => port=+0, relative
2042 * - IP:N => port=N, absolute
2043 * - IP:+N => port=+N, relative
2044 * - IP:-N => port=-N, relative
2045 */
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002046 if (!parse_addr)
2047 goto skip_addr;
2048
Willy Tarreau65ec4e32020-09-16 19:17:08 +02002049 sk = str2sa_range(args[cur_arg], &port, &port1, &port2, NULL, NULL,
2050 &errmsg, NULL, &fqdn,
2051 (initial_resolve ? PA_O_RESOLVE : 0) | PA_O_PORT_OK | PA_O_PORT_OFS | PA_O_STREAM | PA_O_XPRT | PA_O_CONNECT);
Willy Tarreau272adea2014-03-31 10:39:59 +02002052 if (!sk) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002053 ha_alert("parsing [%s:%d] : '%s %s' : %s\n", file, linenum, args[0], args[1], errmsg);
Willy Tarreau272adea2014-03-31 10:39:59 +02002054 err_code |= ERR_ALERT | ERR_FATAL;
2055 goto out;
2056 }
2057
Willy Tarreau272adea2014-03-31 10:39:59 +02002058 if (!port1 || !port2) {
2059 /* no port specified, +offset, -offset */
Willy Tarreauc93cd162014-05-13 15:54:22 +02002060 newsrv->flags |= SRV_F_MAPPORTS;
Willy Tarreau272adea2014-03-31 10:39:59 +02002061 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002062
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002063 /* save hostname and create associated name resolution */
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002064 if (fqdn) {
Christopher Faulet67957bd2017-09-27 11:00:59 +02002065 if (fqdn[0] == '_') { /* SRV record */
Olivier Houchard8da5f982017-08-04 18:35:36 +02002066 /* Check if a SRV request already exists, and if not, create it */
Christopher Faulet67957bd2017-09-27 11:00:59 +02002067 if ((newsrv->srvrq = find_srvrq_by_name(fqdn, curproxy)) == NULL)
Emeric Brun08622d32020-12-23 17:41:43 +01002068 newsrv->srvrq = new_resolv_srvrq(newsrv, fqdn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02002069 if (newsrv->srvrq == NULL) {
Olivier Houchard8da5f982017-08-04 18:35:36 +02002070 err_code |= ERR_ALERT | ERR_FATAL;
2071 goto out;
Christopher Faulet67957bd2017-09-27 11:00:59 +02002072 }
2073 }
2074 else if (srv_prepare_for_resolution(newsrv, fqdn) == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002075 ha_alert("parsing [%s:%d] : Can't create DNS resolution for server '%s'\n",
Christopher Faulet67957bd2017-09-27 11:00:59 +02002076 file, linenum, newsrv->id);
2077 err_code |= ERR_ALERT | ERR_FATAL;
2078 goto out;
Baptiste Assmann4f91f7e2017-05-03 12:09:54 +02002079 }
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002080 }
2081
Willy Tarreau272adea2014-03-31 10:39:59 +02002082 newsrv->addr = *sk;
Willy Tarreau6ecb10a2017-01-06 18:36:06 +01002083 newsrv->svc_port = port;
Thayne McCombs92149f92020-11-20 01:28:26 -07002084 // we don't need to lock the server here, because
2085 // we are in the process of initializing
2086 srv_set_addr_desc(newsrv);
Willy Tarreau272adea2014-03-31 10:39:59 +02002087
Olivier Houchard8da5f982017-08-04 18:35:36 +02002088 if (!newsrv->srvrq && !newsrv->hostname && !protocol_by_family(newsrv->addr.ss_family)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002089 ha_alert("parsing [%s:%d] : Unknown protocol family %d '%s'\n",
Frédéric Lécailleb82f7422017-04-13 18:24:23 +02002090 file, linenum, newsrv->addr.ss_family, args[cur_arg]);
Willy Tarreau272adea2014-03-31 10:39:59 +02002091 err_code |= ERR_ALERT | ERR_FATAL;
2092 goto out;
2093 }
Frédéric Lécaille5c3cd972017-03-15 16:36:09 +01002094
Frédéric Lécaille355b2032019-01-11 14:06:12 +01002095 cur_arg++;
2096 skip_addr:
Frédéric Lécaille58b207c2017-03-30 14:18:30 +02002097 /* Copy default server settings to new server settings. */
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002098 srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002099 HA_SPIN_INIT(&newsrv->lock);
Willy Tarreau272adea2014-03-31 10:39:59 +02002100 } else {
2101 newsrv = &curproxy->defsrv;
2102 cur_arg = 1;
Emeric Brun21fbeed2020-12-23 18:01:04 +01002103 newsrv->resolv_opts.family_prio = AF_INET6;
2104 newsrv->resolv_opts.accept_duplicate_ip = 0;
Willy Tarreau272adea2014-03-31 10:39:59 +02002105 }
2106
2107 while (*args[cur_arg]) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002108 if (strcmp(args[cur_arg], "init-addr") == 0) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002109 char *p, *end;
2110 int done;
Willy Tarreau4310d362016-11-02 15:05:56 +01002111 struct sockaddr_storage sa;
Baptiste Assmann25938272016-09-21 20:26:16 +02002112
2113 newsrv->init_addr_methods = 0;
2114 memset(&newsrv->init_addr, 0, sizeof(newsrv->init_addr));
2115
2116 for (p = args[cur_arg + 1]; *p; p = end) {
2117 /* cut on next comma */
2118 for (end = p; *end && *end != ','; end++);
2119 if (*end)
2120 *(end++) = 0;
2121
Willy Tarreau4310d362016-11-02 15:05:56 +01002122 memset(&sa, 0, sizeof(sa));
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002123 if (strcmp(p, "libc") == 0) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002124 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LIBC);
2125 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002126 else if (strcmp(p, "last") == 0) {
Baptiste Assmann25938272016-09-21 20:26:16 +02002127 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_LAST);
2128 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002129 else if (strcmp(p, "none") == 0) {
Willy Tarreau37ebe122016-11-04 15:17:58 +01002130 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_NONE);
2131 }
Willy Tarreau4310d362016-11-02 15:05:56 +01002132 else if (str2ip2(p, &sa, 0)) {
2133 if (is_addr(&newsrv->init_addr)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002134 ha_alert("parsing [%s:%d]: '%s' : initial address already specified, cannot add '%s'.\n",
Willy Tarreau4310d362016-11-02 15:05:56 +01002135 file, linenum, args[cur_arg], p);
2136 err_code |= ERR_ALERT | ERR_FATAL;
2137 goto out;
2138 }
2139 newsrv->init_addr = sa;
2140 done = srv_append_initaddr(&newsrv->init_addr_methods, SRV_IADDR_IP);
2141 }
Baptiste Assmann25938272016-09-21 20:26:16 +02002142 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002143 ha_alert("parsing [%s:%d]: '%s' : unknown init-addr method '%s', supported methods are 'libc', 'last', 'none'.\n",
Baptiste Assmann25938272016-09-21 20:26:16 +02002144 file, linenum, args[cur_arg], p);
2145 err_code |= ERR_ALERT | ERR_FATAL;
2146 goto out;
2147 }
2148 if (!done) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002149 ha_alert("parsing [%s:%d]: '%s' : too many init-addr methods when trying to add '%s'\n",
Baptiste Assmann25938272016-09-21 20:26:16 +02002150 file, linenum, args[cur_arg], p);
2151 err_code |= ERR_ALERT | ERR_FATAL;
2152 goto out;
2153 }
2154 }
2155 cur_arg += 2;
2156 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002157 else if (strcmp(args[cur_arg], "resolvers") == 0) {
Frédéric Lécailledaa2fe62017-04-20 12:17:50 +02002158 free(newsrv->resolvers_id);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002159 newsrv->resolvers_id = strdup(args[cur_arg + 1]);
2160 cur_arg += 2;
2161 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002162 else if (strcmp(args[cur_arg], "resolve-opts") == 0) {
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002163 char *p, *end;
2164
2165 for (p = args[cur_arg + 1]; *p; p = end) {
2166 /* cut on next comma */
2167 for (end = p; *end && *end != ','; end++);
2168 if (*end)
2169 *(end++) = 0;
2170
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002171 if (strcmp(p, "allow-dup-ip") == 0) {
Emeric Brun21fbeed2020-12-23 18:01:04 +01002172 newsrv->resolv_opts.accept_duplicate_ip = 1;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002173 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002174 else if (strcmp(p, "ignore-weight") == 0) {
Emeric Brun21fbeed2020-12-23 18:01:04 +01002175 newsrv->resolv_opts.ignore_weight = 1;
Daniel Corbettf8716912019-11-17 09:48:56 -05002176 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002177 else if (strcmp(p, "prevent-dup-ip") == 0) {
Emeric Brun21fbeed2020-12-23 18:01:04 +01002178 newsrv->resolv_opts.accept_duplicate_ip = 0;
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002179 }
2180 else {
Daniel Corbettf8716912019-11-17 09:48:56 -05002181 ha_alert("parsing [%s:%d]: '%s' : unknown resolve-opts option '%s', supported methods are 'allow-dup-ip', 'ignore-weight', and 'prevent-dup-ip'.\n",
Baptiste Assmann8e2d9432018-06-22 15:04:43 +02002182 file, linenum, args[cur_arg], p);
2183 err_code |= ERR_ALERT | ERR_FATAL;
2184 goto out;
2185 }
2186 }
2187
2188 cur_arg += 2;
2189 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002190 else if (strcmp(args[cur_arg], "resolve-prefer") == 0) {
2191 if (strcmp(args[cur_arg + 1], "ipv4") == 0)
Emeric Brun21fbeed2020-12-23 18:01:04 +01002192 newsrv->resolv_opts.family_prio = AF_INET;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002193 else if (strcmp(args[cur_arg + 1], "ipv6") == 0)
Emeric Brun21fbeed2020-12-23 18:01:04 +01002194 newsrv->resolv_opts.family_prio = AF_INET6;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002195 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002196 ha_alert("parsing [%s:%d]: '%s' expects either ipv4 or ipv6 as argument.\n",
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002197 file, linenum, args[cur_arg]);
2198 err_code |= ERR_ALERT | ERR_FATAL;
2199 goto out;
2200 }
2201 cur_arg += 2;
2202 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002203 else if (strcmp(args[cur_arg], "resolve-net") == 0) {
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002204 char *p, *e;
2205 unsigned char mask;
Emeric Brun21fbeed2020-12-23 18:01:04 +01002206 struct resolv_options *opt;
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002207
2208 if (!args[cur_arg + 1] || args[cur_arg + 1][0] == '\0') {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002209 ha_alert("parsing [%s:%d]: '%s' expects a list of networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002210 file, linenum, args[cur_arg]);
2211 err_code |= ERR_ALERT | ERR_FATAL;
2212 goto out;
2213 }
2214
Emeric Brun21fbeed2020-12-23 18:01:04 +01002215 opt = &newsrv->resolv_opts;
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002216
2217 /* Split arguments by comma, and convert it from ipv4 or ipv6
2218 * string network in in_addr or in6_addr.
2219 */
2220 p = args[cur_arg + 1];
2221 e = p;
2222 while (*p != '\0') {
Joseph Herlant44466822018-11-15 08:57:51 -08002223 /* If no room available, return error. */
David Carlierd10025c2016-04-08 10:26:44 +01002224 if (opt->pref_net_nb >= SRV_MAX_PREF_NET) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002225 ha_alert("parsing [%s:%d]: '%s' exceed %d networks.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002226 file, linenum, args[cur_arg], SRV_MAX_PREF_NET);
2227 err_code |= ERR_ALERT | ERR_FATAL;
2228 goto out;
2229 }
2230 /* look for end or comma. */
2231 while (*e != ',' && *e != '\0')
2232 e++;
2233 if (*e == ',') {
2234 *e = '\0';
2235 e++;
2236 }
2237 if (str2net(p, 0, &opt->pref_net[opt->pref_net_nb].addr.in4,
2238 &opt->pref_net[opt->pref_net_nb].mask.in4)) {
2239 /* Try to convert input string from ipv4 or ipv6 network. */
2240 opt->pref_net[opt->pref_net_nb].family = AF_INET;
2241 } else if (str62net(p, &opt->pref_net[opt->pref_net_nb].addr.in6,
2242 &mask)) {
2243 /* Try to convert input string from ipv6 network. */
2244 len2mask6(mask, &opt->pref_net[opt->pref_net_nb].mask.in6);
2245 opt->pref_net[opt->pref_net_nb].family = AF_INET6;
2246 } else {
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002247 /* All network conversions fail, return error. */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002248 ha_alert("parsing [%s:%d]: '%s': invalid network '%s'.\n",
Thierry Fournierac88cfe2016-02-17 22:05:30 +01002249 file, linenum, args[cur_arg], p);
2250 err_code |= ERR_ALERT | ERR_FATAL;
2251 goto out;
2252 }
2253 opt->pref_net_nb++;
2254 p = e;
2255 }
2256
2257 cur_arg += 2;
2258 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002259 else if (strcmp(args[cur_arg], "weight") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002260 int w;
2261 w = atol(args[cur_arg + 1]);
2262 if (w < 0 || w > SRV_UWGHT_MAX) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002263 ha_alert("parsing [%s:%d] : weight of server %s is not within 0 and %d (%d).\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002264 file, linenum, newsrv->id, SRV_UWGHT_MAX, w);
2265 err_code |= ERR_ALERT | ERR_FATAL;
2266 goto out;
2267 }
2268 newsrv->uweight = newsrv->iweight = w;
2269 cur_arg += 2;
2270 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002271 else if (strcmp(args[cur_arg], "log-proto") == 0) {
2272 if (strcmp(args[cur_arg + 1], "legacy") == 0)
Emeric Brun97556472020-05-30 01:42:45 +02002273 newsrv->log_proto = SRV_LOG_PROTO_LEGACY;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002274 else if (strcmp(args[cur_arg + 1], "octet-count") == 0)
Emeric Brun97556472020-05-30 01:42:45 +02002275 newsrv->log_proto = SRV_LOG_PROTO_OCTET_COUNTING;
2276 else {
2277 ha_alert("parsing [%s:%d]: '%s' expects one of 'legacy' or "
2278 "'octet-count' but got '%s'\n",
2279 file, linenum, args[cur_arg], args[cur_arg + 1]);
2280 err_code |= ERR_ALERT | ERR_FATAL;
2281 goto out;
2282 }
2283 cur_arg += 2;
2284 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002285 else if (strcmp(args[cur_arg], "minconn") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002286 newsrv->minconn = atol(args[cur_arg + 1]);
2287 cur_arg += 2;
2288 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002289 else if (strcmp(args[cur_arg], "maxconn") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002290 newsrv->maxconn = atol(args[cur_arg + 1]);
2291 cur_arg += 2;
2292 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002293 else if (strcmp(args[cur_arg], "maxqueue") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002294 newsrv->maxqueue = atol(args[cur_arg + 1]);
2295 cur_arg += 2;
2296 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002297 else if (strcmp(args[cur_arg], "slowstart") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002298 /* slowstart is stored in seconds */
2299 const char *err = parse_time_err(args[cur_arg + 1], &val, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02002300
2301 if (err == PARSE_TIME_OVER) {
2302 ha_alert("parsing [%s:%d]: timer overflow in argument <%s> to <%s> of server %s, maximum value is 2147483647 ms (~24.8 days).\n",
2303 file, linenum, args[cur_arg+1], args[cur_arg], newsrv->id);
2304 err_code |= ERR_ALERT | ERR_FATAL;
2305 goto out;
2306 }
2307 else if (err == PARSE_TIME_UNDER) {
2308 ha_alert("parsing [%s:%d]: timer underflow in argument <%s> to <%s> of server %s, minimum non-null value is 1 ms.\n",
2309 file, linenum, args[cur_arg+1], args[cur_arg], newsrv->id);
2310 err_code |= ERR_ALERT | ERR_FATAL;
2311 goto out;
2312 }
2313 else if (err) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002314 ha_alert("parsing [%s:%d] : unexpected character '%c' in 'slowstart' argument of server %s.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002315 file, linenum, *err, newsrv->id);
2316 err_code |= ERR_ALERT | ERR_FATAL;
2317 goto out;
2318 }
2319 newsrv->slowstart = (val + 999) / 1000;
2320 cur_arg += 2;
2321 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002322 else if (strcmp(args[cur_arg], "on-error") == 0) {
2323 if (strcmp(args[cur_arg + 1], "fastinter") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002324 newsrv->onerror = HANA_ONERR_FASTINTER;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002325 else if (strcmp(args[cur_arg + 1], "fail-check") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002326 newsrv->onerror = HANA_ONERR_FAILCHK;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002327 else if (strcmp(args[cur_arg + 1], "sudden-death") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002328 newsrv->onerror = HANA_ONERR_SUDDTH;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002329 else if (strcmp(args[cur_arg + 1], "mark-down") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002330 newsrv->onerror = HANA_ONERR_MARKDWN;
2331 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002332 ha_alert("parsing [%s:%d]: '%s' expects one of 'fastinter', "
Willy Tarreau272adea2014-03-31 10:39:59 +02002333 "'fail-check', 'sudden-death' or 'mark-down' but got '%s'\n",
2334 file, linenum, args[cur_arg], args[cur_arg + 1]);
2335 err_code |= ERR_ALERT | ERR_FATAL;
2336 goto out;
2337 }
2338
2339 cur_arg += 2;
2340 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002341 else if (strcmp(args[cur_arg], "on-marked-down") == 0) {
2342 if (strcmp(args[cur_arg + 1], "shutdown-sessions") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002343 newsrv->onmarkeddown = HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS;
2344 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002345 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002346 file, linenum, args[cur_arg], args[cur_arg + 1]);
2347 err_code |= ERR_ALERT | ERR_FATAL;
2348 goto out;
2349 }
2350
2351 cur_arg += 2;
2352 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002353 else if (strcmp(args[cur_arg], "on-marked-up") == 0) {
2354 if (strcmp(args[cur_arg + 1], "shutdown-backup-sessions") == 0)
Willy Tarreau272adea2014-03-31 10:39:59 +02002355 newsrv->onmarkedup = HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS;
2356 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002357 ha_alert("parsing [%s:%d]: '%s' expects 'shutdown-backup-sessions' but got '%s'\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002358 file, linenum, args[cur_arg], args[cur_arg + 1]);
2359 err_code |= ERR_ALERT | ERR_FATAL;
2360 goto out;
2361 }
2362
2363 cur_arg += 2;
2364 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002365 else if (strcmp(args[cur_arg], "error-limit") == 0) {
Willy Tarreau272adea2014-03-31 10:39:59 +02002366 if (!*args[cur_arg + 1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002367 ha_alert("parsing [%s:%d]: '%s' expects an integer argument.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002368 file, linenum, args[cur_arg]);
2369 err_code |= ERR_ALERT | ERR_FATAL;
2370 goto out;
2371 }
2372
2373 newsrv->consecutive_errors_limit = atoi(args[cur_arg + 1]);
2374
2375 if (newsrv->consecutive_errors_limit <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002376 ha_alert("parsing [%s:%d]: %s has to be > 0.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002377 file, linenum, args[cur_arg]);
2378 err_code |= ERR_ALERT | ERR_FATAL;
2379 goto out;
2380 }
2381 cur_arg += 2;
2382 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01002383 else if (strcmp(args[cur_arg], "usesrc") == 0) { /* address to use outside: needs "source" first */
Christopher Faulet767a84b2017-11-24 16:50:31 +01002384 ha_alert("parsing [%s:%d] : '%s' only allowed after a '%s' statement.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002385 file, linenum, "usesrc", "source");
2386 err_code |= ERR_ALERT | ERR_FATAL;
2387 goto out;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01002388 }
Willy Tarreau272adea2014-03-31 10:39:59 +02002389 else {
2390 static int srv_dumped;
2391 struct srv_kw *kw;
2392 char *err;
2393
2394 kw = srv_find_kw(args[cur_arg]);
2395 if (kw) {
2396 char *err = NULL;
2397 int code;
2398
2399 if (!kw->parse) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002400 ha_alert("parsing [%s:%d] : '%s %s' : '%s' option is not implemented in this version (check build options).\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002401 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002402 if (kw->skip != -1)
2403 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002404 err_code |= ERR_ALERT | ERR_FATAL;
2405 goto out;
2406 }
2407
2408 if (defsrv && !kw->default_ok) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002409 ha_alert("parsing [%s:%d] : '%s %s' : '%s' option is not accepted in default-server sections.\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002410 file, linenum, args[0], args[1], args[cur_arg]);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002411 if (kw->skip != -1)
2412 cur_arg += 1 + kw->skip ;
Willy Tarreau272adea2014-03-31 10:39:59 +02002413 err_code |= ERR_ALERT;
2414 continue;
2415 }
2416
2417 code = kw->parse(args, &cur_arg, curproxy, newsrv, &err);
2418 err_code |= code;
2419
2420 if (code) {
Gaetan Rivet10c4b4a2020-02-11 11:42:38 +01002421 display_parser_err(file, linenum, args, cur_arg, code, &err);
Willy Tarreau272adea2014-03-31 10:39:59 +02002422 if (code & ERR_FATAL) {
2423 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002424 if (kw->skip != -1)
2425 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002426 goto out;
2427 }
2428 }
2429 free(err);
Frédéric Lécailledfacd692017-04-16 17:14:14 +02002430 if (kw->skip != -1)
2431 cur_arg += 1 + kw->skip;
Willy Tarreau272adea2014-03-31 10:39:59 +02002432 continue;
2433 }
2434
2435 err = NULL;
2436 if (!srv_dumped) {
2437 srv_dump_kws(&err);
2438 indent_msg(&err, 4);
2439 srv_dumped = 1;
2440 }
2441
Christopher Faulet767a84b2017-11-24 16:50:31 +01002442 ha_alert("parsing [%s:%d] : '%s %s' unknown keyword '%s'.%s%s\n",
Willy Tarreau272adea2014-03-31 10:39:59 +02002443 file, linenum, args[0], args[1], args[cur_arg],
2444 err ? " Registered keywords :" : "", err ? err : "");
2445 free(err);
2446
2447 err_code |= ERR_ALERT | ERR_FATAL;
2448 goto out;
2449 }
2450 }
2451
Frédéric Lécaille759ea982017-03-30 17:32:36 +02002452 if (!defsrv)
2453 err_code |= server_finalize_init(file, linenum, args, cur_arg, newsrv, curproxy);
2454 if (err_code & ERR_FATAL)
2455 goto out;
Frédéric Lécaille72ed4752017-04-14 13:28:00 +02002456 if (srv_tmpl)
2457 server_template_init(newsrv, curproxy);
Willy Tarreau272adea2014-03-31 10:39:59 +02002458 }
Willy Tarreau07101d52015-09-08 16:16:35 +02002459 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002460 return 0;
2461
2462 out:
Willy Tarreau07101d52015-09-08 16:16:35 +02002463 free(fqdn);
Willy Tarreau272adea2014-03-31 10:39:59 +02002464 free(errmsg);
2465 return err_code;
2466}
2467
Baptiste Assmann19a106d2015-07-08 22:03:56 +02002468/* Returns a pointer to the first server matching either id <id>.
2469 * NULL is returned if no match is found.
2470 * the lookup is performed in the backend <bk>
2471 */
2472struct server *server_find_by_id(struct proxy *bk, int id)
2473{
2474 struct eb32_node *eb32;
2475 struct server *curserver;
2476
2477 if (!bk || (id ==0))
2478 return NULL;
2479
2480 /* <bk> has no backend capabilities, so it can't have a server */
2481 if (!(bk->cap & PR_CAP_BE))
2482 return NULL;
2483
2484 curserver = NULL;
2485
2486 eb32 = eb32_lookup(&bk->conf.used_server_id, id);
2487 if (eb32)
2488 curserver = container_of(eb32, struct server, conf.id);
2489
2490 return curserver;
2491}
2492
2493/* Returns a pointer to the first server matching either name <name>, or id
2494 * if <name> starts with a '#'. NULL is returned if no match is found.
2495 * the lookup is performed in the backend <bk>
2496 */
2497struct server *server_find_by_name(struct proxy *bk, const char *name)
2498{
2499 struct server *curserver;
2500
2501 if (!bk || !name)
2502 return NULL;
2503
2504 /* <bk> has no backend capabilities, so it can't have a server */
2505 if (!(bk->cap & PR_CAP_BE))
2506 return NULL;
2507
2508 curserver = NULL;
2509 if (*name == '#') {
2510 curserver = server_find_by_id(bk, atoi(name + 1));
2511 if (curserver)
2512 return curserver;
2513 }
2514 else {
2515 curserver = bk->srv;
2516
2517 while (curserver && (strcmp(curserver->id, name) != 0))
2518 curserver = curserver->next;
2519
2520 if (curserver)
2521 return curserver;
2522 }
2523
2524 return NULL;
2525}
2526
2527struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
2528{
2529 struct server *byname;
2530 struct server *byid;
2531
2532 if (!name && !id)
2533 return NULL;
2534
2535 if (diff)
2536 *diff = 0;
2537
2538 byname = byid = NULL;
2539
2540 if (name) {
2541 byname = server_find_by_name(bk, name);
2542 if (byname && (!id || byname->puid == id))
2543 return byname;
2544 }
2545
2546 /* remaining possibilities :
2547 * - name not set
2548 * - name set but not found
2549 * - name found but ID doesn't match
2550 */
2551 if (id) {
2552 byid = server_find_by_id(bk, id);
2553 if (byid) {
2554 if (byname) {
2555 /* use id only if forced by configuration */
2556 if (byid->flags & SRV_F_FORCED_ID) {
2557 if (diff)
2558 *diff |= 2;
2559 return byid;
2560 }
2561 else {
2562 if (diff)
2563 *diff |= 1;
2564 return byname;
2565 }
2566 }
2567
2568 /* remaining possibilities:
2569 * - name not set
2570 * - name set but not found
2571 */
2572 if (name && diff)
2573 *diff |= 2;
2574 return byid;
2575 }
2576
2577 /* id bot found */
2578 if (byname) {
2579 if (diff)
2580 *diff |= 1;
2581 return byname;
2582 }
2583 }
2584
2585 return NULL;
2586}
2587
Simon Horman7d09b9a2013-02-12 10:45:51 +09002588/*
Baptiste Assmann14e40142015-04-14 01:13:07 +02002589 * update a server's current IP address.
2590 * ip is a pointer to the new IP address, whose address family is ip_sin_family.
2591 * ip is in network format.
2592 * updater is a string which contains an information about the requester of the update.
2593 * updater is used if not NULL.
2594 *
2595 * A log line and a stderr warning message is generated based on server's backend options.
Willy Tarreau46b7f532018-08-21 11:54:26 +02002596 *
2597 * Must be called with the server lock held.
Baptiste Assmann14e40142015-04-14 01:13:07 +02002598 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002599int srv_update_addr(struct server *s, void *ip, int ip_sin_family, const char *updater)
Baptiste Assmann14e40142015-04-14 01:13:07 +02002600{
Christopher Fauletd6c6b5f2020-09-08 10:27:24 +02002601 /* save the new IP family & address if necessary */
2602 switch (ip_sin_family) {
2603 case AF_INET:
2604 if (s->addr.ss_family == ip_sin_family &&
2605 !memcmp(ip, &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, 4))
2606 return 0;
2607 break;
2608 case AF_INET6:
2609 if (s->addr.ss_family == ip_sin_family &&
2610 !memcmp(ip, &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, 16))
2611 return 0;
2612 break;
2613 };
2614
Baptiste Assmann14e40142015-04-14 01:13:07 +02002615 /* generates a log line and a warning on stderr */
2616 if (1) {
2617 /* book enough space for both IPv4 and IPv6 */
2618 char oldip[INET6_ADDRSTRLEN];
2619 char newip[INET6_ADDRSTRLEN];
2620
2621 memset(oldip, '\0', INET6_ADDRSTRLEN);
2622 memset(newip, '\0', INET6_ADDRSTRLEN);
2623
2624 /* copy old IP address in a string */
2625 switch (s->addr.ss_family) {
2626 case AF_INET:
2627 inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
2628 break;
2629 case AF_INET6:
2630 inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
2631 break;
Christopher Fauletb0b76072020-09-08 10:38:40 +02002632 default:
2633 strcpy(oldip, "(none)");
2634 break;
Baptiste Assmann14e40142015-04-14 01:13:07 +02002635 };
2636
2637 /* copy new IP address in a string */
2638 switch (ip_sin_family) {
2639 case AF_INET:
2640 inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
2641 break;
2642 case AF_INET6:
2643 inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
2644 break;
2645 };
2646
2647 /* save log line into a buffer */
2648 chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
2649 s->proxy->id, s->id, oldip, newip, updater);
2650
2651 /* write the buffer on stderr */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002652 ha_warning("%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002653
2654 /* send a log */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002655 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002656 }
2657
2658 /* save the new IP family */
2659 s->addr.ss_family = ip_sin_family;
2660 /* save the new IP address */
2661 switch (ip_sin_family) {
2662 case AF_INET:
Willy Tarreaueec1d382016-07-13 11:59:39 +02002663 memcpy(&((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, ip, 4);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002664 break;
2665 case AF_INET6:
2666 memcpy(((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, ip, 16);
2667 break;
2668 };
Olivier Houchard4e694042017-03-14 20:01:29 +01002669 srv_set_dyncookie(s);
Thayne McCombs92149f92020-11-20 01:28:26 -07002670 srv_set_addr_desc(s);
Baptiste Assmann14e40142015-04-14 01:13:07 +02002671
2672 return 0;
2673}
2674
William Dauchy7cabc062021-02-11 22:51:24 +01002675/* update agent health check address and port
2676 * addr can be ip4/ip6 or a hostname
2677 * if one error occurs, don't apply anything
2678 * must be called with the server lock held.
2679 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002680const char *srv_update_agent_addr_port(struct server *s, const char *addr, const char *port)
William Dauchy7cabc062021-02-11 22:51:24 +01002681{
2682 struct sockaddr_storage sk;
2683 struct buffer *msg;
2684 int new_port;
2685
2686 msg = get_trash_chunk();
2687 chunk_reset(msg);
2688
2689 if (!(s->agent.state & CHK_ST_ENABLED)) {
2690 chunk_strcat(msg, "agent checks are not enabled on this server");
2691 goto out;
2692 }
2693 if (addr) {
2694 memset(&sk, 0, sizeof(struct sockaddr_storage));
2695 if (str2ip(addr, &sk) == NULL) {
2696 chunk_appendf(msg, "invalid addr '%s'", addr);
2697 goto out;
2698 }
2699 }
2700 if (port) {
2701 if (strl2irc(port, strlen(port), &new_port) != 0) {
2702 chunk_appendf(msg, "provided port is not an integer");
2703 goto out;
2704 }
2705 if (new_port < 0 || new_port > 65535) {
2706 chunk_appendf(msg, "provided port is invalid");
2707 goto out;
2708 }
2709 }
2710out:
2711 if (msg->data)
2712 return msg->area;
2713 else {
2714 if (addr)
2715 set_srv_agent_addr(s, &sk);
2716 if (port)
2717 set_srv_agent_port(s, new_port);
2718 }
2719 return NULL;
2720}
2721
William Dauchyb456e1f2021-02-11 22:51:23 +01002722/* update server health check address and port
2723 * addr must be ip4 or ip6, it won't be resolved
2724 * if one error occurs, don't apply anything
2725 * must be called with the server lock held.
2726 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002727const char *srv_update_check_addr_port(struct server *s, const char *addr, const char *port)
William Dauchyb456e1f2021-02-11 22:51:23 +01002728{
2729 struct sockaddr_storage sk;
2730 struct buffer *msg;
2731 int new_port;
2732
2733 msg = get_trash_chunk();
2734 chunk_reset(msg);
2735
2736 if (!(s->check.state & CHK_ST_ENABLED)) {
2737 chunk_strcat(msg, "health checks are not enabled on this server");
2738 goto out;
2739 }
2740 if (addr) {
2741 memset(&sk, 0, sizeof(struct sockaddr_storage));
2742 if (str2ip2(addr, &sk, 0) == NULL) {
2743 chunk_appendf(msg, "invalid addr '%s'", addr);
2744 goto out;
2745 }
2746 }
2747 if (port) {
2748 if (strl2irc(port, strlen(port), &new_port) != 0) {
2749 chunk_appendf(msg, "provided port is not an integer");
2750 goto out;
2751 }
2752 if (new_port < 0 || new_port > 65535) {
2753 chunk_appendf(msg, "provided port is invalid");
2754 goto out;
2755 }
2756 /* prevent the update of port to 0 if MAPPORTS are in use */
2757 if ((s->flags & SRV_F_MAPPORTS) && new_port == 0) {
2758 chunk_appendf(msg, "can't unset 'port' since MAPPORTS is in use");
2759 goto out;
2760 }
2761 }
2762out:
2763 if (msg->data)
2764 return msg->area;
2765 else {
2766 if (addr)
2767 s->check.addr = sk;
2768 if (port)
2769 s->check.port = new_port;
2770 }
2771 return NULL;
2772}
2773
Baptiste Assmann14e40142015-04-14 01:13:07 +02002774/*
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002775 * This function update a server's addr and port only for AF_INET and AF_INET6 families.
2776 *
2777 * Caller can pass its name through <updater> to get it integrated in the response message
2778 * returned by the function.
2779 *
2780 * The function first does the following, in that order:
2781 * - validates the new addr and/or port
2782 * - checks if an update is required (new IP or port is different than current ones)
2783 * - checks the update is allowed:
2784 * - don't switch from/to a family other than AF_INET4 and AF_INET6
2785 * - allow all changes if no CHECKS are configured
2786 * - if CHECK is configured:
2787 * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their own ports
2788 * - applies required changes to both ADDR and PORT if both 'required' and 'allowed'
2789 * conditions are met
Willy Tarreau46b7f532018-08-21 11:54:26 +02002790 *
2791 * Must be called with the server lock held.
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002792 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01002793const char *srv_update_addr_port(struct server *s, const char *addr, const char *port, char *updater)
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002794{
2795 struct sockaddr_storage sa;
2796 int ret, port_change_required;
2797 char current_addr[INET6_ADDRSTRLEN];
David Carlier327298c2016-11-20 10:42:38 +00002798 uint16_t current_port, new_port;
Willy Tarreau83061a82018-07-13 11:56:34 +02002799 struct buffer *msg;
Olivier Houchard4e694042017-03-14 20:01:29 +01002800 int changed = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002801
2802 msg = get_trash_chunk();
2803 chunk_reset(msg);
2804
2805 if (addr) {
2806 memset(&sa, 0, sizeof(struct sockaddr_storage));
2807 if (str2ip2(addr, &sa, 0) == NULL) {
2808 chunk_printf(msg, "Invalid addr '%s'", addr);
2809 goto out;
2810 }
2811
2812 /* changes are allowed on AF_INET* families only */
2813 if ((sa.ss_family != AF_INET) && (sa.ss_family != AF_INET6)) {
2814 chunk_printf(msg, "Update to families other than AF_INET and AF_INET6 supported only through configuration file");
2815 goto out;
2816 }
2817
2818 /* collecting data currently setup */
2819 memset(current_addr, '\0', sizeof(current_addr));
2820 ret = addr_to_str(&s->addr, current_addr, sizeof(current_addr));
2821 /* changes are allowed on AF_INET* families only */
2822 if ((ret != AF_INET) && (ret != AF_INET6)) {
2823 chunk_printf(msg, "Update for the current server address family is only supported through configuration file");
2824 goto out;
2825 }
2826
2827 /* applying ADDR changes if required and allowed
2828 * ipcmp returns 0 when both ADDR are the same
2829 */
2830 if (ipcmp(&s->addr, &sa) == 0) {
2831 chunk_appendf(msg, "no need to change the addr");
2832 goto port;
2833 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002834 ipcpy(&sa, &s->addr);
Olivier Houchard4e694042017-03-14 20:01:29 +01002835 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002836
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002837 /* update report for caller */
2838 chunk_printf(msg, "IP changed from '%s' to '%s'", current_addr, addr);
2839 }
2840
2841 port:
2842 if (port) {
2843 char sign = '\0';
2844 char *endptr;
2845
2846 if (addr)
2847 chunk_appendf(msg, ", ");
2848
2849 /* collecting data currently setup */
Willy Tarreau04276f32017-01-06 17:41:29 +01002850 current_port = s->svc_port;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002851
2852 /* check if PORT change is required */
2853 port_change_required = 0;
2854
2855 sign = *port;
Ryabin Sergey77ee7522017-01-11 19:39:55 +04002856 errno = 0;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002857 new_port = strtol(port, &endptr, 10);
2858 if ((errno != 0) || (port == endptr)) {
2859 chunk_appendf(msg, "problem converting port '%s' to an int", port);
2860 goto out;
2861 }
2862
2863 /* check if caller triggers a port mapped or offset */
2864 if (sign == '-' || (sign == '+')) {
2865 /* check if server currently uses port map */
2866 if (!(s->flags & SRV_F_MAPPORTS)) {
2867 /* switch from fixed port to port map mandatorily triggers
2868 * a port change */
2869 port_change_required = 1;
2870 /* check is configured
2871 * we're switching from a fixed port to a SRV_F_MAPPORTS (mapped) port
2872 * prevent PORT change if check doesn't have it's dedicated port while switching
2873 * to port mapping */
William Dauchy69f118d2021-02-03 22:30:07 +01002874 if (!s->check.port) {
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002875 chunk_appendf(msg, "can't change <port> to port map because it is incompatible with current health check port configuration (use 'port' statement from the 'server' directive.");
2876 goto out;
2877 }
2878 }
2879 /* we're already using port maps */
2880 else {
2881 port_change_required = current_port != new_port;
2882 }
2883 }
2884 /* fixed port */
2885 else {
2886 port_change_required = current_port != new_port;
2887 }
2888
2889 /* applying PORT changes if required and update response message */
2890 if (port_change_required) {
2891 /* apply new port */
Willy Tarreau04276f32017-01-06 17:41:29 +01002892 s->svc_port = new_port;
Olivier Houchard4e694042017-03-14 20:01:29 +01002893 changed = 1;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002894
2895 /* prepare message */
2896 chunk_appendf(msg, "port changed from '");
2897 if (s->flags & SRV_F_MAPPORTS)
2898 chunk_appendf(msg, "+");
2899 chunk_appendf(msg, "%d' to '", current_port);
2900
2901 if (sign == '-') {
2902 s->flags |= SRV_F_MAPPORTS;
2903 chunk_appendf(msg, "%c", sign);
2904 /* just use for result output */
2905 new_port = -new_port;
2906 }
2907 else if (sign == '+') {
2908 s->flags |= SRV_F_MAPPORTS;
2909 chunk_appendf(msg, "%c", sign);
2910 }
2911 else {
2912 s->flags &= ~SRV_F_MAPPORTS;
2913 }
2914
2915 chunk_appendf(msg, "%d'", new_port);
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002916 }
2917 else {
2918 chunk_appendf(msg, "no need to change the port");
2919 }
2920 }
2921
2922out:
William Dauchy6318d332020-05-02 21:52:36 +02002923 if (changed) {
2924 /* force connection cleanup on the given server */
2925 srv_cleanup_connections(s);
Olivier Houchard4e694042017-03-14 20:01:29 +01002926 srv_set_dyncookie(s);
Thayne McCombs92149f92020-11-20 01:28:26 -07002927 srv_set_addr_desc(s);
William Dauchy6318d332020-05-02 21:52:36 +02002928 }
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002929 if (updater)
2930 chunk_appendf(msg, " by '%s'", updater);
2931 chunk_appendf(msg, "\n");
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002932 return msg->area;
Baptiste Assmannd458adc2016-08-02 08:18:55 +02002933}
2934
2935
2936/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002937 * update server status based on result of name resolution
2938 * returns:
2939 * 0 if server status is updated
2940 * 1 if server status has not changed
Willy Tarreau46b7f532018-08-21 11:54:26 +02002941 *
2942 * Must be called with the server lock held.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002943 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02002944int snr_update_srv_status(struct server *s, int has_no_ip)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002945{
Emeric Brun750fe792020-12-23 16:51:12 +01002946 struct resolvers *resolvers = s->resolvers;
Emeric Brun08622d32020-12-23 17:41:43 +01002947 struct resolv_resolution *resolution = s->resolv_requester->resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02002948 int exp;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002949
Jerome Magnin012261a2020-07-28 13:38:22 +02002950 /* If resolution is NULL we're dealing with SRV records Additional records */
2951 if (resolution == NULL) {
Baptiste Assmann87138c32020-08-04 10:57:21 +02002952 /* since this server has an IP, it can go back in production */
2953 if (has_no_ip == 0) {
2954 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
2955 return 1;
2956 }
2957
Jerome Magnin012261a2020-07-28 13:38:22 +02002958 if (s->next_admin & SRV_ADMF_RMAINT)
2959 return 1;
2960
2961 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "entry removed from SRV record");
2962 return 0;
2963 }
2964
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002965 switch (resolution->status) {
2966 case RSLV_STATUS_NONE:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02002967 /* status when HAProxy has just (re)started.
2968 * Nothing to do, since the task is already automatically started */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02002969 break;
2970
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01002971 case RSLV_STATUS_VALID:
2972 /*
2973 * resume health checks
2974 * server will be turned back on if health check is safe
2975 */
Olivier Houcharda8c6db82017-07-06 18:46:47 +02002976 if (has_no_ip) {
Emeric Brun52a91d32017-08-31 14:41:55 +02002977 if (s->next_admin & SRV_ADMF_RMAINT)
Olivier Houcharda8c6db82017-07-06 18:46:47 +02002978 return 1;
2979 srv_set_admin_flag(s, SRV_ADMF_RMAINT,
2980 "No IP for server ");
Christopher Faulet67957bd2017-09-27 11:00:59 +02002981 return 0;
Olivier Houcharda8c6db82017-07-06 18:46:47 +02002982 }
Christopher Faulet67957bd2017-09-27 11:00:59 +02002983
Emeric Brun52a91d32017-08-31 14:41:55 +02002984 if (!(s->next_admin & SRV_ADMF_RMAINT))
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01002985 return 1;
2986 srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
2987 chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer",
2988 s->proxy->id, s->id);
2989
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002990 ha_warning("%s.\n", trash.area);
2991 send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01002992 return 0;
2993
2994 case RSLV_STATUS_NX:
2995 /* stop server if resolution is NX for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02002996 exp = tick_add(resolution->last_valid, resolvers->hold.nx);
2997 if (!tick_is_expired(exp, now_ms))
2998 break;
2999
3000 if (s->next_admin & SRV_ADMF_RMAINT)
3001 return 1;
3002 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS NX status");
3003 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003004
3005 case RSLV_STATUS_TIMEOUT:
3006 /* stop server if resolution is TIMEOUT for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003007 exp = tick_add(resolution->last_valid, resolvers->hold.timeout);
3008 if (!tick_is_expired(exp, now_ms))
3009 break;
3010
3011 if (s->next_admin & SRV_ADMF_RMAINT)
3012 return 1;
3013 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS timeout status");
3014 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003015
3016 case RSLV_STATUS_REFUSED:
3017 /* stop server if resolution is REFUSED for a long enough period */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003018 exp = tick_add(resolution->last_valid, resolvers->hold.refused);
3019 if (!tick_is_expired(exp, now_ms))
3020 break;
3021
3022 if (s->next_admin & SRV_ADMF_RMAINT)
3023 return 1;
3024 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS refused status");
3025 return 0;
Baptiste Assmann3b9fe9f2016-11-02 22:58:18 +01003026
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003027 default:
Christopher Faulet67957bd2017-09-27 11:00:59 +02003028 /* stop server if resolution failed for a long enough period */
3029 exp = tick_add(resolution->last_valid, resolvers->hold.other);
3030 if (!tick_is_expired(exp, now_ms))
3031 break;
3032
3033 if (s->next_admin & SRV_ADMF_RMAINT)
3034 return 1;
3035 srv_set_admin_flag(s, SRV_ADMF_RMAINT, "unspecified DNS error");
3036 return 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003037 }
3038
3039 return 1;
3040}
3041
3042/*
3043 * Server Name Resolution valid response callback
3044 * It expects:
3045 * - <nameserver>: the name server which answered the valid response
3046 * - <response>: buffer containing a valid DNS response
3047 * - <response_len>: size of <response>
3048 * It performs the following actions:
3049 * - ignore response if current ip found and server family not met
3050 * - update with first new ip found if family is met and current IP is not found
3051 * returns:
3052 * 0 on error
3053 * 1 when no error or safe ignore
Olivier Houchard28381072017-11-06 17:30:28 +01003054 *
3055 * Must be called with server lock held
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003056 */
Emeric Brun08622d32020-12-23 17:41:43 +01003057int snr_resolution_cb(struct resolv_requester *requester, struct dns_counters *counters)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003058{
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003059 struct server *s = NULL;
Emeric Brun08622d32020-12-23 17:41:43 +01003060 struct resolv_resolution *resolution = NULL;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003061 void *serverip, *firstip;
3062 short server_sin_family, firstip_sin_family;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003063 int ret;
Willy Tarreau83061a82018-07-13 11:56:34 +02003064 struct buffer *chk = get_trash_chunk();
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003065 int has_no_ip = 0;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003066
Christopher Faulet67957bd2017-09-27 11:00:59 +02003067 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003068 if (!s)
3069 return 1;
3070
Emeric Brun08622d32020-12-23 17:41:43 +01003071 resolution = s->resolv_requester->resolution;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003072
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003073 /* initializing variables */
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003074 firstip = NULL; /* pointer to the first valid response found */
3075 /* it will be used as the new IP if a change is required */
3076 firstip_sin_family = AF_UNSPEC;
3077 serverip = NULL; /* current server IP address */
3078
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003079 /* initializing server IP pointer */
3080 server_sin_family = s->addr.ss_family;
3081 switch (server_sin_family) {
3082 case AF_INET:
3083 serverip = &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr;
3084 break;
3085
3086 case AF_INET6:
3087 serverip = &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr;
3088 break;
3089
Willy Tarreau3acfcd12017-01-06 19:18:32 +01003090 case AF_UNSPEC:
3091 break;
3092
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003093 default:
3094 goto invalid;
3095 }
3096
Emeric Brund30e9a12020-12-23 18:49:16 +01003097 ret = resolv_get_ip_from_response(&resolution->response, &s->resolv_opts,
3098 serverip, server_sin_family, &firstip,
3099 &firstip_sin_family, s);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003100
3101 switch (ret) {
Emeric Brun456de772020-12-23 18:17:31 +01003102 case RSLV_UPD_NO:
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003103 goto update_status;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003104
Emeric Brun456de772020-12-23 18:17:31 +01003105 case RSLV_UPD_SRVIP_NOT_FOUND:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003106 goto save_ip;
3107
Emeric Brun456de772020-12-23 18:17:31 +01003108 case RSLV_UPD_CNAME:
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003109 goto invalid;
3110
Emeric Brun456de772020-12-23 18:17:31 +01003111 case RSLV_UPD_NO_IP_FOUND:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003112 has_no_ip = 1;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003113 goto update_status;
Baptiste Assmann0453a1d2015-09-09 00:51:08 +02003114
Emeric Brun456de772020-12-23 18:17:31 +01003115 case RSLV_UPD_NAME_ERROR:
Baptiste Assmannfad03182015-10-28 02:03:32 +01003116 /* update resolution status to OTHER error type */
Christopher Faulet67957bd2017-09-27 11:00:59 +02003117 resolution->status = RSLV_STATUS_OTHER;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003118 goto update_status;
Baptiste Assmannfad03182015-10-28 02:03:32 +01003119
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003120 default:
3121 goto invalid;
3122
3123 }
3124
3125 save_ip:
Emeric Brun50c870e2021-01-04 10:40:46 +01003126 if (counters) {
3127 counters->update++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003128 /* save the first ip we found */
Emeric Brun50c870e2021-01-04 10:40:46 +01003129 chunk_printf(chk, "%s/%s", counters->pid, counters->id);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003130 }
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003131 else
3132 chunk_printf(chk, "DNS cache");
Christopher Faulet69beaa92021-02-16 12:07:47 +01003133 srv_update_addr(s, firstip, firstip_sin_family, (char *) chk->area);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003134
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003135 update_status:
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003136 snr_update_srv_status(s, has_no_ip);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003137 return 1;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003138
3139 invalid:
Emeric Brun50c870e2021-01-04 10:40:46 +01003140 if (counters) {
3141 counters->invalid++;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003142 goto update_status;
Christopher Faulet3bbd65b2017-09-15 11:55:45 +02003143 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003144 snr_update_srv_status(s, has_no_ip);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003145 return 0;
3146}
3147
3148/*
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003149 * SRV record error management callback
3150 * returns:
3151 * 0 on error
3152 * 1 when no error or safe ignore
3153 *
3154 * Grabs the server's lock.
3155 */
3156int srvrq_resolution_error_cb(struct resolv_requester *requester, int error_code)
3157{
3158 struct server *s;
3159 struct resolv_srvrq *srvrq;
3160 struct resolv_resolution *res;
3161 struct resolvers *resolvers;
3162 int exp;
3163
3164 /* SRV records */
3165 srvrq = objt_resolv_srvrq(requester->owner);
3166 if (!srvrq)
3167 return 1;
3168
3169 resolvers = srvrq->resolvers;
3170 res = requester->resolution;
3171
3172 switch (res->status) {
3173
3174 case RSLV_STATUS_NX:
3175 /* stop server if resolution is NX for a long enough period */
3176 exp = tick_add(res->last_valid, resolvers->hold.nx);
3177 if (!tick_is_expired(exp, now_ms))
3178 return 1;
3179 break;
3180
3181 case RSLV_STATUS_TIMEOUT:
3182 /* stop server if resolution is TIMEOUT for a long enough period */
3183 exp = tick_add(res->last_valid, resolvers->hold.timeout);
3184 if (!tick_is_expired(exp, now_ms))
3185 return 1;
3186 break;
3187
3188 case RSLV_STATUS_REFUSED:
3189 /* stop server if resolution is REFUSED for a long enough period */
3190 exp = tick_add(res->last_valid, resolvers->hold.refused);
3191 if (!tick_is_expired(exp, now_ms))
3192 return 1;
3193 break;
3194
3195 default:
3196 /* stop server if resolution failed for a long enough period */
3197 exp = tick_add(res->last_valid, resolvers->hold.other);
3198 if (!tick_is_expired(exp, now_ms))
3199 return 1;
3200 }
3201
3202 /* Remove any associated server */
3203 for (s = srvrq->proxy->srv; s != NULL; s = s->next) {
3204 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
3205 if (s->srvrq == srvrq) {
3206 snr_update_srv_status(s, 1);
3207 free(s->hostname);
3208 free(s->hostname_dn);
3209 s->hostname = NULL;
3210 s->hostname_dn = NULL;
3211 s->hostname_dn_len = 0;
Christopher Faulet52d4d302021-02-23 12:24:09 +01003212 memset(&s->addr, 0, sizeof(s->addr));
3213 s->svc_port = 0;
Baptiste Assmannb4badf72020-11-19 22:38:33 +01003214 resolv_unlink_resolution(s->resolv_requester);
3215 }
3216 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
3217 }
3218
3219 return 1;
3220}
3221
3222/*
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003223 * Server Name Resolution error management callback
3224 * returns:
3225 * 0 on error
3226 * 1 when no error or safe ignore
Willy Tarreau46b7f532018-08-21 11:54:26 +02003227 *
3228 * Grabs the server's lock.
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003229 */
Emeric Brun08622d32020-12-23 17:41:43 +01003230int snr_resolution_error_cb(struct resolv_requester *requester, int error_code)
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003231{
Christopher Faulet67957bd2017-09-27 11:00:59 +02003232 struct server *s;
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003233
Christopher Faulet67957bd2017-09-27 11:00:59 +02003234 s = objt_server(requester->owner);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003235 if (!s)
3236 return 1;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003237 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003238 snr_update_srv_status(s, 0);
Christopher Fauletd127ffa2021-02-23 12:33:17 +01003239 memset(&s->addr, 0, sizeof(s->addr));
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003240 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Baptiste Assmanna68ca962015-04-14 01:15:08 +02003241 return 1;
3242}
3243
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003244/*
3245 * Function to check if <ip> is already affected to a server in the backend
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003246 * which owns <srv> and is up.
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003247 * It returns a pointer to the first server found or NULL if <ip> is not yet
3248 * assigned.
Olivier Houchard28381072017-11-06 17:30:28 +01003249 *
3250 * Must be called with server lock held
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003251 */
3252struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family)
3253{
3254 struct server *tmpsrv;
3255 struct proxy *be;
3256
3257 if (!srv)
3258 return NULL;
3259
3260 be = srv->proxy;
3261 for (tmpsrv = be->srv; tmpsrv; tmpsrv = tmpsrv->next) {
Emeric Brune9fd6b52017-11-02 17:20:39 +01003262 /* we found the current server is the same, ignore it */
3263 if (srv == tmpsrv)
3264 continue;
3265
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003266 /* We want to compare the IP in the record with the IP of the servers in the
3267 * same backend, only if:
3268 * * DNS resolution is enabled on the server
3269 * * the hostname used for the resolution by our server is the same than the
3270 * one used for the server found in the backend
3271 * * the server found in the backend is not our current server
3272 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003273 HA_SPIN_LOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003274 if ((tmpsrv->hostname_dn == NULL) ||
3275 (srv->hostname_dn_len != tmpsrv->hostname_dn_len) ||
3276 (strcmp(srv->hostname_dn, tmpsrv->hostname_dn) != 0) ||
Emeric Brune9fd6b52017-11-02 17:20:39 +01003277 (srv->puid == tmpsrv->puid)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003278 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003279 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003280 }
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003281
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003282 /* If the server has been taken down, don't consider it */
Emeric Brune9fd6b52017-11-02 17:20:39 +01003283 if (tmpsrv->next_admin & SRV_ADMF_RMAINT) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003284 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003285 continue;
Emeric Brune9fd6b52017-11-02 17:20:39 +01003286 }
Olivier Houcharda8c6db82017-07-06 18:46:47 +02003287
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003288 /* At this point, we have 2 different servers using the same DNS hostname
3289 * for their respective resolution.
3290 */
3291 if (*ip_family == tmpsrv->addr.ss_family &&
3292 ((tmpsrv->addr.ss_family == AF_INET &&
3293 memcmp(ip, &((struct sockaddr_in *)&tmpsrv->addr)->sin_addr, 4) == 0) ||
3294 (tmpsrv->addr.ss_family == AF_INET6 &&
3295 memcmp(ip, &((struct sockaddr_in6 *)&tmpsrv->addr)->sin6_addr, 16) == 0))) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003296 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003297 return tmpsrv;
3298 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003299 HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003300 }
3301
Emeric Brune9fd6b52017-11-02 17:20:39 +01003302
Baptiste Assmannfb7091e2017-05-03 15:43:12 +02003303 return NULL;
3304}
3305
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003306/* Sets the server's address (srv->addr) from srv->hostname using the libc's
3307 * resolver. This is suited for initial address configuration. Returns 0 on
3308 * success otherwise a non-zero error code. In case of error, *err_code, if
3309 * not NULL, is filled up.
3310 */
3311int srv_set_addr_via_libc(struct server *srv, int *err_code)
3312{
3313 if (str2ip2(srv->hostname, &srv->addr, 1) == NULL) {
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003314 if (err_code)
Willy Tarreau465b6e52016-11-07 19:19:22 +01003315 *err_code |= ERR_WARN;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003316 return 1;
3317 }
3318 return 0;
3319}
3320
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003321/* Set the server's FDQN (->hostname) from <hostname>.
3322 * Returns -1 if failed, 0 if not.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003323 *
3324 * Must be called with the server lock held.
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003325 */
Emeric Brun08622d32020-12-23 17:41:43 +01003326int srv_set_fqdn(struct server *srv, const char *hostname, int resolv_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003327{
Emeric Brun08622d32020-12-23 17:41:43 +01003328 struct resolv_resolution *resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003329 char *hostname_dn;
3330 int hostname_len, hostname_dn_len;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003331
Frédéric Lécaille5afb3cf2018-08-21 15:04:23 +02003332 /* Note that the server lock is already held. */
3333 if (!srv->resolvers)
3334 return -1;
3335
Emeric Brun08622d32020-12-23 17:41:43 +01003336 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003337 HA_SPIN_LOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003338 /* run time DNS resolution was not active for this server
3339 * and we can't enable it at run time for now.
3340 */
Emeric Brun08622d32020-12-23 17:41:43 +01003341 if (!srv->resolv_requester)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003342 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003343
3344 chunk_reset(&trash);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003345 hostname_len = strlen(hostname);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003346 hostname_dn = trash.area;
Emeric Brund30e9a12020-12-23 18:49:16 +01003347 hostname_dn_len = resolv_str_to_dn_label(hostname, hostname_len + 1,
3348 hostname_dn, trash.size);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003349 if (hostname_dn_len == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003350 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003351
Emeric Brun08622d32020-12-23 17:41:43 +01003352 resolution = srv->resolv_requester->resolution;
Christopher Faulet67957bd2017-09-27 11:00:59 +02003353 if (resolution &&
3354 resolution->hostname_dn &&
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003355 strcmp(resolution->hostname_dn, hostname_dn) == 0)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003356 goto end;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003357
Emeric Brund30e9a12020-12-23 18:49:16 +01003358 resolv_unlink_resolution(srv->resolv_requester);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003359
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003360 free(srv->hostname);
3361 free(srv->hostname_dn);
Christopher Faulet67957bd2017-09-27 11:00:59 +02003362 srv->hostname = strdup(hostname);
3363 srv->hostname_dn = strdup(hostname_dn);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003364 srv->hostname_dn_len = hostname_dn_len;
3365 if (!srv->hostname || !srv->hostname_dn)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003366 goto err;
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003367
Baptiste Assmann13a92322019-06-07 09:40:55 +02003368 if (srv->flags & SRV_F_NO_RESOLUTION)
3369 goto end;
3370
Emeric Brund30e9a12020-12-23 18:49:16 +01003371 if (resolv_link_resolution(srv, OBJ_TYPE_SERVER, 1) == -1)
Christopher Fauletb2812a62017-10-04 16:17:58 +02003372 goto err;
3373
3374 end:
Emeric Brun08622d32020-12-23 17:41:43 +01003375 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003376 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Baptiste Assmann201c07f2017-05-22 15:17:15 +02003377 return 0;
Christopher Fauletb2812a62017-10-04 16:17:58 +02003378
3379 err:
Emeric Brun08622d32020-12-23 17:41:43 +01003380 if (!resolv_locked)
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003381 HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
Christopher Fauletb2812a62017-10-04 16:17:58 +02003382 return -1;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003383}
3384
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003385/* Sets the server's address (srv->addr) from srv->lastaddr which was filled
3386 * from the state file. This is suited for initial address configuration.
3387 * Returns 0 on success otherwise a non-zero error code. In case of error,
3388 * *err_code, if not NULL, is filled up.
3389 */
3390static int srv_apply_lastaddr(struct server *srv, int *err_code)
3391{
3392 if (!str2ip2(srv->lastaddr, &srv->addr, 0)) {
3393 if (err_code)
3394 *err_code |= ERR_WARN;
3395 return 1;
3396 }
3397 return 0;
3398}
3399
Willy Tarreau25e51522016-11-04 15:10:17 +01003400/* returns 0 if no error, otherwise a combination of ERR_* flags */
3401static int srv_iterate_initaddr(struct server *srv)
3402{
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003403 char *name = srv->hostname;
Willy Tarreau25e51522016-11-04 15:10:17 +01003404 int return_code = 0;
3405 int err_code;
3406 unsigned int methods;
3407
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003408 /* If no addr and no hostname set, get the name from the DNS SRV request */
3409 if (!name && srv->srvrq)
3410 name = srv->srvrq->name;
3411
Willy Tarreau25e51522016-11-04 15:10:17 +01003412 methods = srv->init_addr_methods;
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003413 if (!methods) {
3414 /* otherwise default to "last,libc" */
Willy Tarreau25e51522016-11-04 15:10:17 +01003415 srv_append_initaddr(&methods, SRV_IADDR_LAST);
3416 srv_append_initaddr(&methods, SRV_IADDR_LIBC);
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003417 if (srv->resolvers_id) {
3418 /* dns resolution is configured, add "none" to not fail on startup */
3419 srv_append_initaddr(&methods, SRV_IADDR_NONE);
3420 }
Willy Tarreau25e51522016-11-04 15:10:17 +01003421 }
3422
Willy Tarreau3eed10e2016-11-07 21:03:16 +01003423 /* "-dr" : always append "none" so that server addresses resolution
3424 * failures are silently ignored, this is convenient to validate some
3425 * configs out of their environment.
3426 */
3427 if (global.tune.options & GTUNE_RESOLVE_DONTFAIL)
3428 srv_append_initaddr(&methods, SRV_IADDR_NONE);
3429
Willy Tarreau25e51522016-11-04 15:10:17 +01003430 while (methods) {
3431 err_code = 0;
3432 switch (srv_get_next_initaddr(&methods)) {
3433 case SRV_IADDR_LAST:
3434 if (!srv->lastaddr)
3435 continue;
3436 if (srv_apply_lastaddr(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01003437 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01003438 return_code |= err_code;
3439 break;
3440
3441 case SRV_IADDR_LIBC:
3442 if (!srv->hostname)
3443 continue;
3444 if (srv_set_addr_via_libc(srv, &err_code) == 0)
Olivier Houchard4e694042017-03-14 20:01:29 +01003445 goto out;
Willy Tarreau25e51522016-11-04 15:10:17 +01003446 return_code |= err_code;
3447 break;
3448
Willy Tarreau37ebe122016-11-04 15:17:58 +01003449 case SRV_IADDR_NONE:
3450 srv_set_admin_flag(srv, SRV_ADMF_RMAINT, NULL);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003451 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003452 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', disabling server.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003453 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003454 }
Willy Tarreau37ebe122016-11-04 15:17:58 +01003455 return return_code;
3456
Willy Tarreau4310d362016-11-02 15:05:56 +01003457 case SRV_IADDR_IP:
3458 ipcpy(&srv->init_addr, &srv->addr);
3459 if (return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003460 ha_warning("parsing [%s:%d] : 'server %s' : could not resolve address '%s', falling back to configured address.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003461 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau4310d362016-11-02 15:05:56 +01003462 }
Olivier Houchard4e694042017-03-14 20:01:29 +01003463 goto out;
Willy Tarreau4310d362016-11-02 15:05:56 +01003464
Willy Tarreau25e51522016-11-04 15:10:17 +01003465 default: /* unhandled method */
3466 break;
3467 }
3468 }
3469
3470 if (!return_code) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003471 ha_alert("parsing [%s:%d] : 'server %s' : no method found to resolve address '%s'\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003472 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau25e51522016-11-04 15:10:17 +01003473 }
Willy Tarreau465b6e52016-11-07 19:19:22 +01003474 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003475 ha_alert("parsing [%s:%d] : 'server %s' : could not resolve address '%s'.\n",
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003476 srv->conf.file, srv->conf.line, srv->id, name);
Willy Tarreau465b6e52016-11-07 19:19:22 +01003477 }
Willy Tarreau25e51522016-11-04 15:10:17 +01003478
3479 return_code |= ERR_ALERT | ERR_FATAL;
3480 return return_code;
Olivier Houchard4e694042017-03-14 20:01:29 +01003481out:
3482 srv_set_dyncookie(srv);
Thayne McCombs92149f92020-11-20 01:28:26 -07003483 srv_set_addr_desc(srv);
Olivier Houchard4e694042017-03-14 20:01:29 +01003484 return return_code;
Willy Tarreau25e51522016-11-04 15:10:17 +01003485}
3486
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003487/*
3488 * This function parses all backends and all servers within each backend
3489 * and performs servers' addr resolution based on information provided by:
3490 * - configuration file
3491 * - server-state file (states provided by an 'old' haproxy process)
3492 *
3493 * Returns 0 if no error, otherwise, a combination of ERR_ flags.
3494 */
3495int srv_init_addr(void)
3496{
3497 struct proxy *curproxy;
3498 int return_code = 0;
3499
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003500 curproxy = proxies_list;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003501 while (curproxy) {
3502 struct server *srv;
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003503
3504 /* servers are in backend only */
Amaury Denoyellee3c41922021-01-06 14:28:50 +01003505 if (!(curproxy->cap & PR_CAP_BE) || curproxy->disabled)
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003506 goto srv_init_addr_next;
3507
Willy Tarreau25e51522016-11-04 15:10:17 +01003508 for (srv = curproxy->srv; srv; srv = srv->next)
Christopher Fauletac1c60fd2020-10-26 10:31:17 +01003509 if (srv->hostname || srv->srvrq)
Willy Tarreau3d609a72017-09-06 14:22:45 +02003510 return_code |= srv_iterate_initaddr(srv);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01003511
3512 srv_init_addr_next:
3513 curproxy = curproxy->next;
3514 }
3515
3516 return return_code;
3517}
3518
Willy Tarreau46b7f532018-08-21 11:54:26 +02003519/*
3520 * Must be called with the server lock held.
3521 */
Christopher Faulet69beaa92021-02-16 12:07:47 +01003522const char *srv_update_fqdn(struct server *server, const char *fqdn, const char *updater, int resolv_locked)
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003523{
3524
Willy Tarreau83061a82018-07-13 11:56:34 +02003525 struct buffer *msg;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003526
3527 msg = get_trash_chunk();
3528 chunk_reset(msg);
3529
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01003530 if (server->hostname && strcmp(fqdn, server->hostname) == 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003531 chunk_appendf(msg, "no need to change the FDQN");
3532 goto out;
3533 }
3534
3535 if (strlen(fqdn) > DNS_MAX_NAME_SIZE || invalid_domainchar(fqdn)) {
3536 chunk_appendf(msg, "invalid fqdn '%s'", fqdn);
3537 goto out;
3538 }
3539
3540 chunk_appendf(msg, "%s/%s changed its FQDN from %s to %s",
3541 server->proxy->id, server->id, server->hostname, fqdn);
3542
Emeric Brun08622d32020-12-23 17:41:43 +01003543 if (srv_set_fqdn(server, fqdn, resolv_locked) < 0) {
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003544 chunk_reset(msg);
3545 chunk_appendf(msg, "could not update %s/%s FQDN",
3546 server->proxy->id, server->id);
3547 goto out;
3548 }
3549
3550 /* Flag as FQDN set from stats socket. */
Emeric Brun52a91d32017-08-31 14:41:55 +02003551 server->next_admin |= SRV_ADMF_HMAINT;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003552
3553 out:
3554 if (updater)
3555 chunk_appendf(msg, " by '%s'", updater);
3556 chunk_appendf(msg, "\n");
3557
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003558 return msg->area;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003559}
3560
3561
Willy Tarreau21b069d2016-11-23 17:15:08 +01003562/* Expects to find a backend and a server in <arg> under the form <backend>/<server>,
3563 * and returns the pointer to the server. Otherwise, display adequate error messages
Willy Tarreau3b6e5472016-11-24 15:53:53 +01003564 * on the CLI, sets the CLI's state to CLI_ST_PRINT and returns NULL. This is only
Willy Tarreau21b069d2016-11-23 17:15:08 +01003565 * used for CLI commands requiring a server name.
3566 * Important: the <arg> is modified to remove the '/'.
3567 */
3568struct server *cli_find_server(struct appctx *appctx, char *arg)
3569{
3570 struct proxy *px;
3571 struct server *sv;
3572 char *line;
3573
3574 /* split "backend/server" and make <line> point to server */
3575 for (line = arg; *line; line++)
3576 if (*line == '/') {
3577 *line++ = '\0';
3578 break;
3579 }
3580
3581 if (!*line || !*arg) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003582 cli_err(appctx, "Require 'backend/server'.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01003583 return NULL;
3584 }
3585
3586 if (!get_backend_server(arg, line, &px, &sv)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003587 cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01003588 return NULL;
3589 }
3590
Willy Tarreauc3914d42020-09-24 08:39:22 +02003591 if (px->disabled) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003592 cli_err(appctx, "Proxy is disabled.\n");
Willy Tarreau21b069d2016-11-23 17:15:08 +01003593 return NULL;
3594 }
3595
3596 return sv;
3597}
3598
William Lallemand222baf22016-11-19 02:00:33 +01003599
Willy Tarreau46b7f532018-08-21 11:54:26 +02003600/* grabs the server lock */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003601static int cli_parse_set_server(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand222baf22016-11-19 02:00:33 +01003602{
3603 struct server *sv;
3604 const char *warning;
3605
3606 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3607 return 1;
3608
3609 sv = cli_find_server(appctx, args[2]);
3610 if (!sv)
3611 return 1;
3612
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003613 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Emeric Brun9f0b4582017-10-23 14:39:51 +02003614
William Lallemand222baf22016-11-19 02:00:33 +01003615 if (strcmp(args[3], "weight") == 0) {
3616 warning = server_parse_weight_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02003617 if (warning)
3618 cli_err(appctx, warning);
William Lallemand222baf22016-11-19 02:00:33 +01003619 }
3620 else if (strcmp(args[3], "state") == 0) {
3621 if (strcmp(args[4], "ready") == 0)
3622 srv_adm_set_ready(sv);
3623 else if (strcmp(args[4], "drain") == 0)
3624 srv_adm_set_drain(sv);
3625 else if (strcmp(args[4], "maint") == 0)
3626 srv_adm_set_maint(sv);
Willy Tarreau9d008692019-08-09 11:21:01 +02003627 else
3628 cli_err(appctx, "'set server <srv> state' expects 'ready', 'drain' and 'maint'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003629 }
3630 else if (strcmp(args[3], "health") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003631 if (sv->track)
3632 cli_err(appctx, "cannot change health on a tracking server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003633 else if (strcmp(args[4], "up") == 0) {
3634 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02003635 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003636 }
3637 else if (strcmp(args[4], "stopping") == 0) {
3638 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02003639 srv_set_stopping(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003640 }
3641 else if (strcmp(args[4], "down") == 0) {
3642 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02003643 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003644 }
Willy Tarreau9d008692019-08-09 11:21:01 +02003645 else
3646 cli_err(appctx, "'set server <srv> health' expects 'up', 'stopping', or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003647 }
3648 else if (strcmp(args[3], "agent") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003649 if (!(sv->agent.state & CHK_ST_ENABLED))
3650 cli_err(appctx, "agent checks are not enabled on this server.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003651 else if (strcmp(args[4], "up") == 0) {
3652 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02003653 srv_set_running(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003654 }
3655 else if (strcmp(args[4], "down") == 0) {
3656 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02003657 srv_set_stopped(sv, "changed from CLI", NULL);
William Lallemand222baf22016-11-19 02:00:33 +01003658 }
Willy Tarreau9d008692019-08-09 11:21:01 +02003659 else
3660 cli_err(appctx, "'set server <srv> agent' expects 'up' or 'down'.\n");
William Lallemand222baf22016-11-19 02:00:33 +01003661 }
Misiek2da082d2017-01-09 09:40:42 +01003662 else if (strcmp(args[3], "agent-addr") == 0) {
William Dauchy7cabc062021-02-11 22:51:24 +01003663 char *addr = NULL;
3664 char *port = NULL;
3665 if (strlen(args[4]) == 0) {
3666 cli_err(appctx, "set server <b>/<s> agent-addr requires"
3667 " an address and optionally a port.\n");
3668 goto out_unlock;
3669 }
3670 addr = args[4];
3671 if (strcmp(args[5], "port") == 0)
3672 port = args[6];
Christopher Faulet69beaa92021-02-16 12:07:47 +01003673 warning = srv_update_agent_addr_port(sv, addr, port);
William Dauchy7cabc062021-02-11 22:51:24 +01003674 if (warning)
3675 cli_msg(appctx, LOG_WARNING, warning);
3676 }
3677 else if (strcmp(args[3], "agent-port") == 0) {
3678 char *port = NULL;
3679 if (strlen(args[4]) == 0) {
3680 cli_err(appctx, "set server <b>/<s> agent-port requires"
3681 " a port.\n");
3682 goto out_unlock;
3683 }
3684 port = args[4];
Christopher Faulet69beaa92021-02-16 12:07:47 +01003685 warning = srv_update_agent_addr_port(sv, NULL, port);
William Dauchy7cabc062021-02-11 22:51:24 +01003686 if (warning)
3687 cli_msg(appctx, LOG_WARNING, warning);
Misiek2da082d2017-01-09 09:40:42 +01003688 }
3689 else if (strcmp(args[3], "agent-send") == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003690 if (!(sv->agent.state & CHK_ST_ENABLED))
3691 cli_err(appctx, "agent checks are not enabled on this server.\n");
3692 else {
Christopher Faulet0ae3d1d2020-04-06 17:54:24 +02003693 if (!set_srv_agent_send(sv, args[4]))
Willy Tarreau9d008692019-08-09 11:21:01 +02003694 cli_err(appctx, "cannot allocate memory for new string.\n");
Misiek2da082d2017-01-09 09:40:42 +01003695 }
3696 }
William Dauchyb456e1f2021-02-11 22:51:23 +01003697 else if (strcmp(args[3], "check-addr") == 0) {
3698 char *addr = NULL;
3699 char *port = NULL;
3700 if (strlen(args[4]) == 0) {
3701 cli_err(appctx, "set server <b>/<s> check-addr requires"
3702 " an address and optionally a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01003703 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01003704 }
William Dauchyb456e1f2021-02-11 22:51:23 +01003705 addr = args[4];
3706 if (strcmp(args[5], "port") == 0)
3707 port = args[6];
Christopher Faulet69beaa92021-02-16 12:07:47 +01003708 warning = srv_update_check_addr_port(sv, addr, port);
William Dauchyb456e1f2021-02-11 22:51:23 +01003709 if (warning)
3710 cli_msg(appctx, LOG_WARNING, warning);
3711 }
3712 else if (strcmp(args[3], "check-port") == 0) {
3713 char *port = NULL;
3714 if (strlen(args[4]) == 0) {
3715 cli_err(appctx, "set server <b>/<s> check-port requires"
3716 " a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01003717 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01003718 }
William Dauchyb456e1f2021-02-11 22:51:23 +01003719 port = args[4];
Christopher Faulet69beaa92021-02-16 12:07:47 +01003720 warning = srv_update_check_addr_port(sv, NULL, port);
William Dauchyb456e1f2021-02-11 22:51:23 +01003721 if (warning)
3722 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01003723 }
3724 else if (strcmp(args[3], "addr") == 0) {
3725 char *addr = NULL;
3726 char *port = NULL;
3727 if (strlen(args[4]) == 0) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003728 cli_err(appctx, "set server <b>/<s> addr requires an address and optionally a port.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01003729 goto out_unlock;
William Lallemand222baf22016-11-19 02:00:33 +01003730 }
3731 else {
3732 addr = args[4];
3733 }
3734 if (strcmp(args[5], "port") == 0) {
3735 port = args[6];
3736 }
Christopher Faulet69beaa92021-02-16 12:07:47 +01003737 warning = srv_update_addr_port(sv, addr, port, "stats socket command");
Willy Tarreau9d008692019-08-09 11:21:01 +02003738 if (warning)
3739 cli_msg(appctx, LOG_WARNING, warning);
William Lallemand222baf22016-11-19 02:00:33 +01003740 srv_clr_admin_flag(sv, SRV_ADMF_RMAINT);
3741 }
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003742 else if (strcmp(args[3], "fqdn") == 0) {
3743 if (!*args[4]) {
Willy Tarreau9d008692019-08-09 11:21:01 +02003744 cli_err(appctx, "set server <b>/<s> fqdn requires a FQDN.\n");
Willy Tarreau6ce38f32017-11-05 10:19:23 +01003745 goto out_unlock;
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003746 }
Baptiste Assmann13a92322019-06-07 09:40:55 +02003747 /* ensure runtime resolver will process this new fqdn */
3748 if (sv->flags & SRV_F_NO_RESOLUTION) {
3749 sv->flags &= ~SRV_F_NO_RESOLUTION;
3750 }
Christopher Faulet69beaa92021-02-16 12:07:47 +01003751 warning = srv_update_fqdn(sv, args[4], "stats socket command", 0);
Willy Tarreau9d008692019-08-09 11:21:01 +02003752 if (warning)
3753 cli_msg(appctx, LOG_WARNING, warning);
Frédéric Lécailleb418c122017-04-26 11:24:02 +02003754 }
William Dauchyf6370442020-11-14 19:25:33 +01003755 else if (strcmp(args[3], "ssl") == 0) {
3756#ifdef USE_OPENSSL
3757 if (sv->ssl_ctx.ctx == NULL) {
3758 cli_err(appctx, "'set server <srv> ssl' cannot be set. "
3759 " default-server should define ssl settings\n");
3760 goto out_unlock;
3761 } else if (strcmp(args[4], "on") == 0) {
3762 ssl_sock_set_srv(sv, 1);
3763 } else if (strcmp(args[4], "off") == 0) {
3764 ssl_sock_set_srv(sv, 0);
3765 } else {
3766 cli_err(appctx, "'set server <srv> ssl' expects 'on' or 'off'.\n");
3767 goto out_unlock;
3768 }
3769 srv_cleanup_connections(sv);
3770 cli_msg(appctx, LOG_NOTICE, "server ssl setting updated.\n");
3771#else
3772 cli_msg(appctx, LOG_NOTICE, "server ssl setting not supported.\n");
3773#endif
3774 } else {
Willy Tarreau9d008692019-08-09 11:21:01 +02003775 cli_err(appctx,
William Dauchy3f4ec7d2021-02-15 17:22:16 +01003776 "usage: set server <backend>/<server> "
3777 "addr | agent | agent-addr | agent-port | agent-send | "
3778 "check-addr | check-port | fqdn | health | ssl | "
3779 "state | weight\n");
William Lallemand222baf22016-11-19 02:00:33 +01003780 }
Willy Tarreau6ce38f32017-11-05 10:19:23 +01003781 out_unlock:
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003782 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
William Lallemand222baf22016-11-19 02:00:33 +01003783 return 1;
3784}
3785
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003786static int cli_parse_get_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01003787{
3788 struct stream_interface *si = appctx->owner;
3789 struct proxy *px;
3790 struct server *sv;
3791 char *line;
3792
3793
3794 /* split "backend/server" and make <line> point to server */
3795 for (line = args[2]; *line; line++)
3796 if (*line == '/') {
3797 *line++ = '\0';
3798 break;
3799 }
3800
Willy Tarreau9d008692019-08-09 11:21:01 +02003801 if (!*line)
3802 return cli_err(appctx, "Require 'backend/server'.\n");
William Lallemand6b160942016-11-22 12:34:35 +01003803
Willy Tarreau9d008692019-08-09 11:21:01 +02003804 if (!get_backend_server(args[2], line, &px, &sv))
3805 return cli_err(appctx, px ? "No such server.\n" : "No such backend.\n");
William Lallemand6b160942016-11-22 12:34:35 +01003806
3807 /* return server's effective weight at the moment */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003808 snprintf(trash.area, trash.size, "%d (initial %d)\n", sv->uweight,
3809 sv->iweight);
3810 if (ci_putstr(si_ic(si), trash.area) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01003811 si_rx_room_blk(si);
Christopher Faulet90b5abe2016-12-05 14:25:08 +01003812 return 0;
3813 }
William Lallemand6b160942016-11-22 12:34:35 +01003814 return 1;
3815}
3816
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003817/* Parse a "set weight" command.
3818 *
3819 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003820 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003821static int cli_parse_set_weight(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand6b160942016-11-22 12:34:35 +01003822{
3823 struct server *sv;
3824 const char *warning;
3825
3826 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3827 return 1;
3828
3829 sv = cli_find_server(appctx, args[2]);
3830 if (!sv)
3831 return 1;
3832
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003833 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
3834
William Lallemand6b160942016-11-22 12:34:35 +01003835 warning = server_parse_weight_change_request(sv, args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +02003836 if (warning)
3837 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003838
3839 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
3840
William Lallemand6b160942016-11-22 12:34:35 +01003841 return 1;
3842}
3843
Willy Tarreau46b7f532018-08-21 11:54:26 +02003844/* parse a "set maxconn server" command. It always returns 1.
3845 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003846 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003847 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003848static int cli_parse_set_maxconn_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreaub8026272016-11-23 11:26:56 +01003849{
3850 struct server *sv;
3851 const char *warning;
3852
3853 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3854 return 1;
3855
3856 sv = cli_find_server(appctx, args[3]);
3857 if (!sv)
3858 return 1;
3859
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003860 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
3861
Willy Tarreaub8026272016-11-23 11:26:56 +01003862 warning = server_parse_maxconn_change_request(sv, args[4]);
Willy Tarreau9d008692019-08-09 11:21:01 +02003863 if (warning)
3864 cli_err(appctx, warning);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003865
3866 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
3867
Willy Tarreaub8026272016-11-23 11:26:56 +01003868 return 1;
3869}
William Lallemand6b160942016-11-22 12:34:35 +01003870
Willy Tarreau46b7f532018-08-21 11:54:26 +02003871/* parse a "disable agent" command. It always returns 1.
3872 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003873 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003874 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003875static int cli_parse_disable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01003876{
3877 struct server *sv;
3878
3879 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3880 return 1;
3881
3882 sv = cli_find_server(appctx, args[2]);
3883 if (!sv)
3884 return 1;
3885
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003886 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01003887 sv->agent.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003888 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01003889 return 1;
3890}
3891
Willy Tarreau46b7f532018-08-21 11:54:26 +02003892/* parse a "disable health" command. It always returns 1.
3893 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003894 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003895 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003896static int cli_parse_disable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01003897{
3898 struct server *sv;
3899
3900 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3901 return 1;
3902
3903 sv = cli_find_server(appctx, args[2]);
3904 if (!sv)
3905 return 1;
3906
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003907 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01003908 sv->check.state &= ~CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003909 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01003910 return 1;
3911}
3912
Willy Tarreau46b7f532018-08-21 11:54:26 +02003913/* parse a "disable server" command. It always returns 1.
3914 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003915 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003916 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003917static int cli_parse_disable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01003918{
3919 struct server *sv;
3920
3921 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3922 return 1;
3923
3924 sv = cli_find_server(appctx, args[2]);
3925 if (!sv)
3926 return 1;
3927
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003928 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01003929 srv_adm_set_maint(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003930 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01003931 return 1;
3932}
3933
Willy Tarreau46b7f532018-08-21 11:54:26 +02003934/* parse a "enable agent" command. It always returns 1.
3935 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003936 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003937 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003938static int cli_parse_enable_agent(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau58d9cb72016-11-24 12:56:01 +01003939{
3940 struct server *sv;
3941
3942 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3943 return 1;
3944
3945 sv = cli_find_server(appctx, args[2]);
3946 if (!sv)
3947 return 1;
3948
Willy Tarreau9d008692019-08-09 11:21:01 +02003949 if (!(sv->agent.state & CHK_ST_CONFIGURED))
3950 return cli_err(appctx, "Agent was not configured on this server, cannot enable.\n");
Willy Tarreau58d9cb72016-11-24 12:56:01 +01003951
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003952 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01003953 sv->agent.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003954 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau58d9cb72016-11-24 12:56:01 +01003955 return 1;
3956}
3957
Willy Tarreau46b7f532018-08-21 11:54:26 +02003958/* parse a "enable health" command. It always returns 1.
3959 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003960 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003961 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003962static int cli_parse_enable_health(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau2c04eda2016-11-24 12:51:04 +01003963{
3964 struct server *sv;
3965
3966 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3967 return 1;
3968
3969 sv = cli_find_server(appctx, args[2]);
3970 if (!sv)
3971 return 1;
3972
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003973 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01003974 sv->check.state |= CHK_ST_ENABLED;
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003975 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau2c04eda2016-11-24 12:51:04 +01003976 return 1;
3977}
3978
Willy Tarreau46b7f532018-08-21 11:54:26 +02003979/* parse a "enable server" command. It always returns 1.
3980 *
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003981 * Grabs the server lock.
Willy Tarreau46b7f532018-08-21 11:54:26 +02003982 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003983static int cli_parse_enable_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreauffb4d582016-11-24 12:47:00 +01003984{
3985 struct server *sv;
3986
3987 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3988 return 1;
3989
3990 sv = cli_find_server(appctx, args[2]);
3991 if (!sv)
3992 return 1;
3993
Willy Tarreau3bcc2692018-08-21 15:35:31 +02003994 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01003995 srv_adm_set_ready(sv);
Olivier Houcharde9bad0a2018-01-17 17:39:34 +01003996 if (!(sv->flags & SRV_F_COOKIESET)
3997 && (sv->proxy->ck_opts & PR_CK_DYNAMIC) &&
3998 sv->cookie)
3999 srv_check_for_dup_dyncookie(sv);
Willy Tarreau3bcc2692018-08-21 15:35:31 +02004000 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreauffb4d582016-11-24 12:47:00 +01004001 return 1;
4002}
4003
William Lallemand222baf22016-11-19 02:00:33 +01004004/* register cli keywords */
4005static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004006 { { "disable", "agent", NULL }, "disable agent : disable agent checks (use 'set server' instead)", cli_parse_disable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004007 { { "disable", "health", NULL }, "disable health : disable health checks (use 'set server' instead)", cli_parse_disable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004008 { { "disable", "server", NULL }, "disable server : disable a server for maintenance (use 'set server' instead)", cli_parse_disable_server, NULL },
Willy Tarreau58d9cb72016-11-24 12:56:01 +01004009 { { "enable", "agent", NULL }, "enable agent : enable agent checks (use 'set server' instead)", cli_parse_enable_agent, NULL },
Willy Tarreau2c04eda2016-11-24 12:51:04 +01004010 { { "enable", "health", NULL }, "enable health : enable health checks (use 'set server' instead)", cli_parse_enable_health, NULL },
Willy Tarreauffb4d582016-11-24 12:47:00 +01004011 { { "enable", "server", NULL }, "enable server : enable a disabled server (use 'set server' instead)", cli_parse_enable_server, NULL },
Willy Tarreaub8026272016-11-23 11:26:56 +01004012 { { "set", "maxconn", "server", NULL }, "set maxconn server : change a server's maxconn setting", cli_parse_set_maxconn_server, NULL },
William Dauchyf6370442020-11-14 19:25:33 +01004013 { { "set", "server", NULL }, "set server : change a server's state, weight, address or ssl", cli_parse_set_server },
William Lallemand6b160942016-11-22 12:34:35 +01004014 { { "get", "weight", NULL }, "get weight : report a server's current weight", cli_parse_get_weight },
4015 { { "set", "weight", NULL }, "set weight : change a server's weight (deprecated)", cli_parse_set_weight },
4016
William Lallemand222baf22016-11-19 02:00:33 +01004017 {{},}
4018}};
4019
Willy Tarreau0108d902018-11-25 19:14:37 +01004020INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01004021
Emeric Brun64cc49c2017-10-03 14:46:45 +02004022/*
4023 * This function applies server's status changes, it is
4024 * is designed to be called asynchronously.
4025 *
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004026 * Must be called with the server lock held. This may also be called at init
4027 * time as the result of parsing the state file, in which case no lock will be
4028 * held, and the server's warmup task can be null.
Emeric Brun64cc49c2017-10-03 14:46:45 +02004029 */
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004030static void srv_update_status(struct server *s)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004031{
4032 struct check *check = &s->check;
4033 int xferred;
4034 struct proxy *px = s->proxy;
4035 int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
4036 int srv_was_stopping = (s->cur_state == SRV_ST_STOPPING) || (s->cur_admin & SRV_ADMF_DRAIN);
4037 int log_level;
Willy Tarreau83061a82018-07-13 11:56:34 +02004038 struct buffer *tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004039
Emeric Brun64cc49c2017-10-03 14:46:45 +02004040 /* If currently main is not set we try to apply pending state changes */
4041 if (!(s->cur_admin & SRV_ADMF_MAINT)) {
4042 int next_admin;
4043
4044 /* Backup next admin */
4045 next_admin = s->next_admin;
4046
4047 /* restore current admin state */
4048 s->next_admin = s->cur_admin;
4049
4050 if ((s->cur_state != SRV_ST_STOPPED) && (s->next_state == SRV_ST_STOPPED)) {
4051 s->last_change = now.tv_sec;
4052 if (s->proxy->lbprm.set_server_status_down)
4053 s->proxy->lbprm.set_server_status_down(s);
4054
4055 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4056 srv_shutdown_streams(s, SF_ERR_DOWN);
4057
4058 /* we might have streams queued on this server and waiting for
4059 * a connection. Those which are redispatchable will be queued
4060 * to another server or to the proxy itself.
4061 */
4062 xferred = pendconn_redistribute(s);
4063
4064 tmptrash = alloc_trash_chunk();
4065 if (tmptrash) {
4066 chunk_printf(tmptrash,
4067 "%sServer %s/%s is DOWN", s->flags & SRV_F_BACKUP ? "Backup " : "",
4068 s->proxy->id, s->id);
4069
Emeric Brun5a133512017-10-19 14:42:30 +02004070 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004071 ha_warning("%s.\n", tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004072
4073 /* we don't send an alert if the server was previously paused */
4074 log_level = srv_was_stopping ? LOG_NOTICE : LOG_ALERT;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004075 send_log(s->proxy, log_level, "%s.\n",
4076 tmptrash->area);
4077 send_email_alert(s, log_level, "%s",
4078 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004079 free_trash_chunk(tmptrash);
4080 tmptrash = NULL;
4081 }
4082 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4083 set_backend_down(s->proxy);
4084
4085 s->counters.down_trans++;
4086 }
4087 else if ((s->cur_state != SRV_ST_STOPPING) && (s->next_state == SRV_ST_STOPPING)) {
4088 s->last_change = now.tv_sec;
4089 if (s->proxy->lbprm.set_server_status_down)
4090 s->proxy->lbprm.set_server_status_down(s);
4091
4092 /* we might have streams queued on this server and waiting for
4093 * a connection. Those which are redispatchable will be queued
4094 * to another server or to the proxy itself.
4095 */
4096 xferred = pendconn_redistribute(s);
4097
4098 tmptrash = alloc_trash_chunk();
4099 if (tmptrash) {
4100 chunk_printf(tmptrash,
4101 "%sServer %s/%s is stopping", s->flags & SRV_F_BACKUP ? "Backup " : "",
4102 s->proxy->id, s->id);
4103
Emeric Brun5a133512017-10-19 14:42:30 +02004104 srv_append_status(tmptrash, s, NULL, xferred, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004105
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004106 ha_warning("%s.\n", tmptrash->area);
4107 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4108 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004109 free_trash_chunk(tmptrash);
4110 tmptrash = NULL;
4111 }
4112
4113 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4114 set_backend_down(s->proxy);
4115 }
4116 else if (((s->cur_state != SRV_ST_RUNNING) && (s->next_state == SRV_ST_RUNNING))
4117 || ((s->cur_state != SRV_ST_STARTING) && (s->next_state == SRV_ST_STARTING))) {
4118 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4119 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4120 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4121 s->proxy->last_change = now.tv_sec;
4122 }
4123
Amaury Denoyellefe2bf092020-10-29 15:59:04 +01004124 if (s->cur_state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times
Emeric Brun64cc49c2017-10-03 14:46:45 +02004125 s->down_time += now.tv_sec - s->last_change;
4126
4127 s->last_change = now.tv_sec;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004128 if (s->next_state == SRV_ST_STARTING && s->warmup)
Emeric Brun64cc49c2017-10-03 14:46:45 +02004129 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4130
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004131 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004132 /* now propagate the status change to any LB algorithms */
4133 if (px->lbprm.update_server_eweight)
4134 px->lbprm.update_server_eweight(s);
4135 else if (srv_willbe_usable(s)) {
4136 if (px->lbprm.set_server_status_up)
4137 px->lbprm.set_server_status_up(s);
4138 }
4139 else {
4140 if (px->lbprm.set_server_status_down)
4141 px->lbprm.set_server_status_down(s);
4142 }
4143
4144 /* If the server is set with "on-marked-up shutdown-backup-sessions",
4145 * and it's not a backup server and its effective weight is > 0,
4146 * then it can accept new connections, so we shut down all streams
4147 * on all backup servers.
4148 */
4149 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
4150 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
4151 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
4152
4153 /* check if we can handle some connections queued at the proxy. We
4154 * will take as many as we can handle.
4155 */
4156 xferred = pendconn_grab_from_px(s);
4157
4158 tmptrash = alloc_trash_chunk();
4159 if (tmptrash) {
4160 chunk_printf(tmptrash,
4161 "%sServer %s/%s is UP", s->flags & SRV_F_BACKUP ? "Backup " : "",
4162 s->proxy->id, s->id);
4163
Emeric Brun5a133512017-10-19 14:42:30 +02004164 srv_append_status(tmptrash, s, NULL, xferred, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004165 ha_warning("%s.\n", tmptrash->area);
4166 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4167 tmptrash->area);
4168 send_email_alert(s, LOG_NOTICE, "%s",
4169 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004170 free_trash_chunk(tmptrash);
4171 tmptrash = NULL;
4172 }
4173
4174 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4175 set_backend_down(s->proxy);
4176 }
4177 else if (s->cur_eweight != s->next_eweight) {
4178 /* now propagate the status change to any LB algorithms */
4179 if (px->lbprm.update_server_eweight)
4180 px->lbprm.update_server_eweight(s);
4181 else if (srv_willbe_usable(s)) {
4182 if (px->lbprm.set_server_status_up)
4183 px->lbprm.set_server_status_up(s);
4184 }
4185 else {
4186 if (px->lbprm.set_server_status_down)
4187 px->lbprm.set_server_status_down(s);
4188 }
4189
4190 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4191 set_backend_down(s->proxy);
4192 }
4193
4194 s->next_admin = next_admin;
4195 }
4196
Emeric Brun5a133512017-10-19 14:42:30 +02004197 /* reset operational state change */
4198 *s->op_st_chg.reason = 0;
4199 s->op_st_chg.status = s->op_st_chg.code = -1;
4200 s->op_st_chg.duration = 0;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004201
4202 /* Now we try to apply pending admin changes */
4203
4204 /* Maintenance must also disable health checks */
4205 if (!(s->cur_admin & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) {
4206 if (s->check.state & CHK_ST_ENABLED) {
4207 s->check.state |= CHK_ST_PAUSED;
4208 check->health = 0;
4209 }
4210
4211 if (s->cur_state == SRV_ST_STOPPED) { /* server was already down */
Olivier Houchard796a2b32017-10-24 17:42:47 +02004212 tmptrash = alloc_trash_chunk();
4213 if (tmptrash) {
4214 chunk_printf(tmptrash,
4215 "%sServer %s/%s was DOWN and now enters maintenance%s%s%s",
4216 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
4217 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
Emeric Brun64cc49c2017-10-03 14:46:45 +02004218
Olivier Houchard796a2b32017-10-24 17:42:47 +02004219 srv_append_status(tmptrash, s, NULL, -1, (s->next_admin & SRV_ADMF_FMAINT));
Emeric Brun64cc49c2017-10-03 14:46:45 +02004220
Olivier Houchard796a2b32017-10-24 17:42:47 +02004221 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004222 ha_warning("%s.\n", tmptrash->area);
4223 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4224 tmptrash->area);
Olivier Houchard796a2b32017-10-24 17:42:47 +02004225 }
4226 free_trash_chunk(tmptrash);
4227 tmptrash = NULL;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004228 }
Emeric Brun8f298292017-12-06 16:47:17 +01004229 /* commit new admin status */
4230
4231 s->cur_admin = s->next_admin;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004232 }
4233 else { /* server was still running */
4234 check->health = 0; /* failure */
4235 s->last_change = now.tv_sec;
Emeric Brune3114802017-12-21 14:42:26 +01004236
4237 s->next_state = SRV_ST_STOPPED;
Emeric Brun64cc49c2017-10-03 14:46:45 +02004238 if (s->proxy->lbprm.set_server_status_down)
4239 s->proxy->lbprm.set_server_status_down(s);
4240
Emeric Brun64cc49c2017-10-03 14:46:45 +02004241 if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
4242 srv_shutdown_streams(s, SF_ERR_DOWN);
4243
William Dauchy6318d332020-05-02 21:52:36 +02004244 /* force connection cleanup on the given server */
4245 srv_cleanup_connections(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004246 /* we might have streams queued on this server and waiting for
4247 * a connection. Those which are redispatchable will be queued
4248 * to another server or to the proxy itself.
4249 */
4250 xferred = pendconn_redistribute(s);
4251
4252 tmptrash = alloc_trash_chunk();
4253 if (tmptrash) {
4254 chunk_printf(tmptrash,
4255 "%sServer %s/%s is going DOWN for maintenance%s%s%s",
4256 s->flags & SRV_F_BACKUP ? "Backup " : "",
4257 s->proxy->id, s->id,
4258 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
4259
4260 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FMAINT));
4261
4262 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004263 ha_warning("%s.\n", tmptrash->area);
4264 send_log(s->proxy, srv_was_stopping ? LOG_NOTICE : LOG_ALERT, "%s.\n",
4265 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004266 }
4267 free_trash_chunk(tmptrash);
4268 tmptrash = NULL;
4269 }
4270 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4271 set_backend_down(s->proxy);
4272
4273 s->counters.down_trans++;
4274 }
4275 }
4276 else if ((s->cur_admin & SRV_ADMF_MAINT) && !(s->next_admin & SRV_ADMF_MAINT)) {
4277 /* OK here we're leaving maintenance, we have many things to check,
4278 * because the server might possibly be coming back up depending on
4279 * its state. In practice, leaving maintenance means that we should
4280 * immediately turn to UP (more or less the slowstart) under the
4281 * following conditions :
4282 * - server is neither checked nor tracked
4283 * - server tracks another server which is not checked
4284 * - server tracks another server which is already up
4285 * Which sums up as something simpler :
4286 * "either the tracking server is up or the server's checks are disabled
4287 * or up". Otherwise we only re-enable health checks. There's a special
4288 * case associated to the stopping state which can be inherited. Note
4289 * that the server might still be in drain mode, which is naturally dealt
4290 * with by the lower level functions.
4291 */
4292
4293 if (s->check.state & CHK_ST_ENABLED) {
4294 s->check.state &= ~CHK_ST_PAUSED;
4295 check->health = check->rise; /* start OK but check immediately */
4296 }
4297
4298 if ((!s->track || s->track->next_state != SRV_ST_STOPPED) &&
4299 (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) &&
4300 (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) {
4301 if (s->track && s->track->next_state == SRV_ST_STOPPING) {
4302 s->next_state = SRV_ST_STOPPING;
4303 }
4304 else {
4305 s->next_state = SRV_ST_STARTING;
Willy Tarreau1e690bb2020-10-22 11:30:59 +02004306 if (s->slowstart > 0) {
4307 if (s->warmup)
4308 task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))));
4309 }
Emeric Brun64cc49c2017-10-03 14:46:45 +02004310 else
4311 s->next_state = SRV_ST_RUNNING;
4312 }
4313
4314 }
4315
4316 tmptrash = alloc_trash_chunk();
4317 if (tmptrash) {
4318 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
4319 chunk_printf(tmptrash,
4320 "%sServer %s/%s is %s/%s (leaving forced maintenance)",
4321 s->flags & SRV_F_BACKUP ? "Backup " : "",
4322 s->proxy->id, s->id,
4323 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4324 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4325 }
4326 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
4327 chunk_printf(tmptrash,
4328 "%sServer %s/%s ('%s') is %s/%s (resolves again)",
4329 s->flags & SRV_F_BACKUP ? "Backup " : "",
4330 s->proxy->id, s->id, s->hostname,
4331 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4332 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4333 }
4334 if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
4335 chunk_printf(tmptrash,
4336 "%sServer %s/%s is %s/%s (leaving maintenance)",
4337 s->flags & SRV_F_BACKUP ? "Backup " : "",
4338 s->proxy->id, s->id,
4339 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP",
4340 (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY");
4341 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004342 ha_warning("%s.\n", tmptrash->area);
4343 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4344 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004345 free_trash_chunk(tmptrash);
4346 tmptrash = NULL;
4347 }
4348
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004349 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004350 /* now propagate the status change to any LB algorithms */
4351 if (px->lbprm.update_server_eweight)
4352 px->lbprm.update_server_eweight(s);
4353 else if (srv_willbe_usable(s)) {
4354 if (px->lbprm.set_server_status_up)
4355 px->lbprm.set_server_status_up(s);
4356 }
4357 else {
4358 if (px->lbprm.set_server_status_down)
4359 px->lbprm.set_server_status_down(s);
4360 }
4361
4362 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4363 set_backend_down(s->proxy);
4364
Willy Tarreau6a78e612018-08-07 10:14:53 +02004365 /* If the server is set with "on-marked-up shutdown-backup-sessions",
4366 * and it's not a backup server and its effective weight is > 0,
4367 * then it can accept new connections, so we shut down all streams
4368 * on all backup servers.
4369 */
4370 if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
4371 !(s->flags & SRV_F_BACKUP) && s->next_eweight)
4372 srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
4373
4374 /* check if we can handle some connections queued at the proxy. We
4375 * will take as many as we can handle.
4376 */
4377 xferred = pendconn_grab_from_px(s);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004378 }
4379 else if (s->next_admin & SRV_ADMF_MAINT) {
4380 /* remaining in maintenance mode, let's inform precisely about the
4381 * situation.
4382 */
4383 if (!(s->next_admin & SRV_ADMF_FMAINT) && (s->cur_admin & SRV_ADMF_FMAINT)) {
4384 tmptrash = alloc_trash_chunk();
4385 if (tmptrash) {
4386 chunk_printf(tmptrash,
4387 "%sServer %s/%s is leaving forced maintenance but remains in maintenance",
4388 s->flags & SRV_F_BACKUP ? "Backup " : "",
4389 s->proxy->id, s->id);
4390
4391 if (s->track) /* normally it's mandatory here */
4392 chunk_appendf(tmptrash, " via %s/%s",
4393 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004394 ha_warning("%s.\n", tmptrash->area);
4395 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4396 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004397 free_trash_chunk(tmptrash);
4398 tmptrash = NULL;
4399 }
4400 }
4401 if (!(s->next_admin & SRV_ADMF_RMAINT) && (s->cur_admin & SRV_ADMF_RMAINT)) {
4402 tmptrash = alloc_trash_chunk();
4403 if (tmptrash) {
4404 chunk_printf(tmptrash,
4405 "%sServer %s/%s ('%s') resolves again but remains in maintenance",
4406 s->flags & SRV_F_BACKUP ? "Backup " : "",
4407 s->proxy->id, s->id, s->hostname);
4408
4409 if (s->track) /* normally it's mandatory here */
4410 chunk_appendf(tmptrash, " via %s/%s",
4411 s->track->proxy->id, s->track->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004412 ha_warning("%s.\n", tmptrash->area);
4413 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4414 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004415 free_trash_chunk(tmptrash);
4416 tmptrash = NULL;
4417 }
4418 }
4419 else if (!(s->next_admin & SRV_ADMF_IMAINT) && (s->cur_admin & SRV_ADMF_IMAINT)) {
4420 tmptrash = alloc_trash_chunk();
4421 if (tmptrash) {
4422 chunk_printf(tmptrash,
4423 "%sServer %s/%s remains in forced maintenance",
4424 s->flags & SRV_F_BACKUP ? "Backup " : "",
4425 s->proxy->id, s->id);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004426 ha_warning("%s.\n", tmptrash->area);
4427 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4428 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004429 free_trash_chunk(tmptrash);
4430 tmptrash = NULL;
4431 }
4432 }
4433 /* don't report anything when leaving drain mode and remaining in maintenance */
4434
4435 s->cur_admin = s->next_admin;
4436 }
4437
4438 if (!(s->next_admin & SRV_ADMF_MAINT)) {
4439 if (!(s->cur_admin & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)) {
4440 /* drain state is applied only if not yet in maint */
4441
4442 s->last_change = now.tv_sec;
4443 if (px->lbprm.set_server_status_down)
4444 px->lbprm.set_server_status_down(s);
4445
4446 /* we might have streams queued on this server and waiting for
4447 * a connection. Those which are redispatchable will be queued
4448 * to another server or to the proxy itself.
4449 */
4450 xferred = pendconn_redistribute(s);
4451
4452 tmptrash = alloc_trash_chunk();
4453 if (tmptrash) {
4454 chunk_printf(tmptrash, "%sServer %s/%s enters drain state%s%s%s",
4455 s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id,
4456 *(s->adm_st_chg_cause) ? " (" : "", s->adm_st_chg_cause, *(s->adm_st_chg_cause) ? ")" : "");
4457
4458 srv_append_status(tmptrash, s, NULL, xferred, (s->next_admin & SRV_ADMF_FDRAIN));
4459
4460 if (!(global.mode & MODE_STARTING)) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004461 ha_warning("%s.\n", tmptrash->area);
4462 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4463 tmptrash->area);
4464 send_email_alert(s, LOG_NOTICE, "%s",
4465 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004466 }
4467 free_trash_chunk(tmptrash);
4468 tmptrash = NULL;
4469 }
4470
4471 if (prev_srv_count && s->proxy->srv_bck == 0 && s->proxy->srv_act == 0)
4472 set_backend_down(s->proxy);
4473 }
4474 else if ((s->cur_admin & SRV_ADMF_DRAIN) && !(s->next_admin & SRV_ADMF_DRAIN)) {
4475 /* OK completely leaving drain mode */
4476 if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
4477 if (s->proxy->last_change < now.tv_sec) // ignore negative times
4478 s->proxy->down_time += now.tv_sec - s->proxy->last_change;
4479 s->proxy->last_change = now.tv_sec;
4480 }
4481
4482 if (s->last_change < now.tv_sec) // ignore negative times
4483 s->down_time += now.tv_sec - s->last_change;
4484 s->last_change = now.tv_sec;
Willy Tarreau3ff577e2018-08-02 11:48:52 +02004485 server_recalc_eweight(s, 0);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004486
4487 tmptrash = alloc_trash_chunk();
4488 if (tmptrash) {
4489 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
4490 chunk_printf(tmptrash,
4491 "%sServer %s/%s is %s (leaving forced drain)",
4492 s->flags & SRV_F_BACKUP ? "Backup " : "",
4493 s->proxy->id, s->id,
4494 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
4495 }
4496 else {
4497 chunk_printf(tmptrash,
4498 "%sServer %s/%s is %s (leaving drain)",
4499 s->flags & SRV_F_BACKUP ? "Backup " : "",
4500 s->proxy->id, s->id,
4501 (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP");
4502 if (s->track) /* normally it's mandatory here */
4503 chunk_appendf(tmptrash, " via %s/%s",
4504 s->track->proxy->id, s->track->id);
4505 }
4506
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004507 ha_warning("%s.\n", tmptrash->area);
4508 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4509 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004510 free_trash_chunk(tmptrash);
4511 tmptrash = NULL;
4512 }
4513
4514 /* now propagate the status change to any LB algorithms */
4515 if (px->lbprm.update_server_eweight)
4516 px->lbprm.update_server_eweight(s);
4517 else if (srv_willbe_usable(s)) {
4518 if (px->lbprm.set_server_status_up)
4519 px->lbprm.set_server_status_up(s);
4520 }
4521 else {
4522 if (px->lbprm.set_server_status_down)
4523 px->lbprm.set_server_status_down(s);
4524 }
4525 }
4526 else if ((s->next_admin & SRV_ADMF_DRAIN)) {
4527 /* remaining in drain mode after removing one of its flags */
4528
4529 tmptrash = alloc_trash_chunk();
4530 if (tmptrash) {
4531 if (!(s->next_admin & SRV_ADMF_FDRAIN)) {
4532 chunk_printf(tmptrash,
4533 "%sServer %s/%s is leaving forced drain but remains in drain mode",
4534 s->flags & SRV_F_BACKUP ? "Backup " : "",
4535 s->proxy->id, s->id);
4536
4537 if (s->track) /* normally it's mandatory here */
4538 chunk_appendf(tmptrash, " via %s/%s",
4539 s->track->proxy->id, s->track->id);
4540 }
4541 else {
4542 chunk_printf(tmptrash,
4543 "%sServer %s/%s remains in forced drain mode",
4544 s->flags & SRV_F_BACKUP ? "Backup " : "",
4545 s->proxy->id, s->id);
4546 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004547 ha_warning("%s.\n", tmptrash->area);
4548 send_log(s->proxy, LOG_NOTICE, "%s.\n",
4549 tmptrash->area);
Emeric Brun64cc49c2017-10-03 14:46:45 +02004550 free_trash_chunk(tmptrash);
4551 tmptrash = NULL;
4552 }
4553
4554 /* commit new admin status */
4555
4556 s->cur_admin = s->next_admin;
4557 }
4558 }
4559
4560 /* Re-set log strings to empty */
Emeric Brun64cc49c2017-10-03 14:46:45 +02004561 *s->adm_st_chg_cause = 0;
4562}
Emeric Brun64cc49c2017-10-03 14:46:45 +02004563
Willy Tarreaud8aa21a2021-02-26 00:30:22 +01004564struct task *srv_cleanup_toremove_conns(struct task *task, void *context, unsigned short state)
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004565{
4566 struct connection *conn;
4567
Willy Tarreau4d82bf52020-06-28 00:19:17 +02004568 while ((conn = MT_LIST_POP(&idle_conns[tid].toremove_conns,
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004569 struct connection *, toremove_list)) != NULL) {
Christopher Faulet73c12072019-04-08 11:23:22 +02004570 conn->mux->destroy(conn->ctx);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004571 }
4572
4573 return task;
4574}
4575
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004576/* Move toremove_nb connections from idle_tree to toremove_list, -1 means
Olivier Houchardff1d0922020-06-29 20:15:59 +02004577 * moving them all.
4578 * Returns the number of connections moved.
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01004579 *
4580 * Must be called with idle_conns_lock held.
Olivier Houchardff1d0922020-06-29 20:15:59 +02004581 */
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004582static int srv_migrate_conns_to_remove(struct eb_root *idle_tree, struct mt_list *toremove_list, int toremove_nb)
Olivier Houchardff1d0922020-06-29 20:15:59 +02004583{
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004584 struct eb_node *node, *next;
Amaury Denoyelle8990b012021-02-19 15:29:16 +01004585 struct conn_hash_node *hash_node;
Olivier Houchardff1d0922020-06-29 20:15:59 +02004586 int i = 0;
4587
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004588 node = eb_first(idle_tree);
4589 while (node) {
4590 next = eb_next(node);
Olivier Houchardff1d0922020-06-29 20:15:59 +02004591 if (toremove_nb != -1 && i >= toremove_nb)
4592 break;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004593
Amaury Denoyelle8990b012021-02-19 15:29:16 +01004594 hash_node = ebmb_entry(node, struct conn_hash_node, node);
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004595 eb_delete(node);
Amaury Denoyelle8990b012021-02-19 15:29:16 +01004596 MT_LIST_ADDQ(toremove_list, &hash_node->conn->toremove_list);
Olivier Houchardff1d0922020-06-29 20:15:59 +02004597 i++;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004598
4599 node = next;
Olivier Houchardff1d0922020-06-29 20:15:59 +02004600 }
4601 return i;
4602}
William Dauchy6318d332020-05-02 21:52:36 +02004603/* cleanup connections for a given server
4604 * might be useful when going on forced maintenance or live changing ip/port
4605 */
William Dauchy707ad322020-05-04 13:52:40 +02004606static void srv_cleanup_connections(struct server *srv)
William Dauchy6318d332020-05-02 21:52:36 +02004607{
William Dauchy6318d332020-05-02 21:52:36 +02004608 int did_remove;
4609 int i;
William Dauchy6318d332020-05-02 21:52:36 +02004610
Amaury Denoyelle10d5c312021-01-06 14:28:51 +01004611 /* nothing to do if pool-max-conn is null */
4612 if (!srv->max_idle_conns)
4613 return;
4614
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02004615 /* check all threads starting with ours */
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02004616 for (i = tid;;) {
William Dauchy6318d332020-05-02 21:52:36 +02004617 did_remove = 0;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01004618 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004619 if (srv_migrate_conns_to_remove(&srv->idle_conns_tree[i], &idle_conns[i].toremove_conns, -1) > 0)
William Dauchy6318d332020-05-02 21:52:36 +02004620 did_remove = 1;
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004621 if (srv_migrate_conns_to_remove(&srv->safe_conns_tree[i], &idle_conns[i].toremove_conns, -1) > 0)
Olivier Houchardff1d0922020-06-29 20:15:59 +02004622 did_remove = 1;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01004623 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
William Dauchy6318d332020-05-02 21:52:36 +02004624 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02004625 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02004626
4627 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
4628 break;
William Dauchy6318d332020-05-02 21:52:36 +02004629 }
William Dauchy6318d332020-05-02 21:52:36 +02004630}
4631
Willy Tarreaud8aa21a2021-02-26 00:30:22 +01004632struct task *srv_cleanup_idle_conns(struct task *task, void *context, unsigned short state)
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01004633{
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004634 struct server *srv;
4635 struct eb32_node *eb;
4636 int i;
4637 unsigned int next_wakeup;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01004638
Willy Tarreau21b9ff52020-11-05 09:12:20 +01004639 next_wakeup = TICK_ETERNITY;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004640 HA_SPIN_LOCK(OTHER_LOCK, &idle_conn_srv_lock);
4641 while (1) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004642 int exceed_conns;
4643 int to_kill;
4644 int curr_idle;
Olivier Houchardb7b3faa2018-12-14 18:15:36 +01004645
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004646 eb = eb32_lookup_ge(&idle_conn_srv, now_ms - TIMER_LOOK_BACK);
4647 if (!eb) {
4648 /* we might have reached the end of the tree, typically because
4649 * <now_ms> is in the first half and we're first scanning the last
4650 * half. Let's loop back to the beginning of the tree now.
4651 */
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01004652
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004653 eb = eb32_first(&idle_conn_srv);
4654 if (likely(!eb))
4655 break;
4656 }
4657 if (tick_is_lt(now_ms, eb->key)) {
4658 /* timer not expired yet, revisit it later */
4659 next_wakeup = eb->key;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01004660 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004661 }
4662 srv = eb32_entry(eb, struct server, idle_node);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004663
4664 /* Calculate how many idle connections we want to kill :
4665 * we want to remove half the difference between the total
4666 * of established connections (used or idle) and the max
4667 * number of used connections.
4668 */
4669 curr_idle = srv->curr_idle_conns;
4670 if (curr_idle == 0)
4671 goto remove;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02004672 exceed_conns = srv->curr_used_conns + curr_idle - MAX(srv->max_used_conns, srv->est_need_conns);
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004673 exceed_conns = to_kill = exceed_conns / 2 + (exceed_conns & 1);
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02004674
Willy Tarreau21b9ff52020-11-05 09:12:20 +01004675 srv->est_need_conns = (srv->est_need_conns + srv->max_used_conns) / 2;
Willy Tarreaubdb86bd2020-06-29 15:56:35 +02004676 if (srv->est_need_conns < srv->max_used_conns)
4677 srv->est_need_conns = srv->max_used_conns;
4678
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004679 srv->max_used_conns = srv->curr_used_conns;
4680
Willy Tarreau18ed7892020-07-02 19:05:30 +02004681 if (exceed_conns <= 0)
4682 goto remove;
4683
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02004684 /* check all threads starting with ours */
4685 for (i = tid;;) {
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004686 int max_conn;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004687 int j;
4688 int did_remove = 0;
4689
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004690 max_conn = (exceed_conns * srv->curr_idle_thr[i]) /
4691 curr_idle + 1;
Olivier Houchardff1d0922020-06-29 20:15:59 +02004692
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01004693 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004694 j = srv_migrate_conns_to_remove(&srv->idle_conns_tree[i], &idle_conns[i].toremove_conns, max_conn);
Olivier Houchardff1d0922020-06-29 20:15:59 +02004695 if (j > 0)
4696 did_remove = 1;
4697 if (max_conn - j > 0 &&
Amaury Denoyellef232cb32021-01-06 16:14:12 +01004698 srv_migrate_conns_to_remove(&srv->safe_conns_tree[i], &idle_conns[i].toremove_conns, max_conn - j) > 0)
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004699 did_remove = 1;
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01004700 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[i].idle_conns_lock);
Olivier Houchardff1d0922020-06-29 20:15:59 +02004701
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004702 if (did_remove)
Willy Tarreau4d82bf52020-06-28 00:19:17 +02004703 task_wakeup(idle_conns[i].cleanup_task, TASK_WOKEN_OTHER);
Willy Tarreauc35bcfc2020-06-29 14:43:16 +02004704
4705 if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
4706 break;
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004707 }
Olivier Houchard079cb9a2020-03-30 00:23:57 +02004708remove:
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004709 eb32_delete(&srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01004710
4711 if (srv->curr_idle_conns) {
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004712 /* There are still more idle connections, add the
4713 * server back in the tree.
4714 */
Willy Tarreau21b9ff52020-11-05 09:12:20 +01004715 srv->idle_node.key = tick_add(srv->pool_purge_delay, now_ms);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004716 eb32_insert(&idle_conn_srv, &srv->idle_node);
Willy Tarreau21b9ff52020-11-05 09:12:20 +01004717 next_wakeup = tick_first(next_wakeup, srv->idle_node.key);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004718 }
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01004719 }
Olivier Houchard9ea5d362019-02-14 18:29:09 +01004720 HA_SPIN_UNLOCK(OTHER_LOCK, &idle_conn_srv_lock);
4721
Willy Tarreau21b9ff52020-11-05 09:12:20 +01004722 task->expire = next_wakeup;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +01004723 return task;
4724}
Olivier Houchard88698d92019-04-16 19:07:22 +02004725
Willy Tarreau76cc6992020-07-01 18:49:24 +02004726/* config parser for global "tune.idle-pool.shared", accepts "on" or "off" */
4727static int cfg_parse_idle_pool_shared(char **args, int section_type, struct proxy *curpx,
4728 struct proxy *defpx, const char *file, int line,
4729 char **err)
4730{
4731 if (too_many_args(1, args, err, NULL))
4732 return -1;
4733
4734 if (strcmp(args[1], "on") == 0)
4735 global.tune.options |= GTUNE_IDLE_POOL_SHARED;
4736 else if (strcmp(args[1], "off") == 0)
4737 global.tune.options &= ~GTUNE_IDLE_POOL_SHARED;
4738 else {
4739 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
4740 return -1;
4741 }
4742 return 0;
4743}
4744
Olivier Houchard88698d92019-04-16 19:07:22 +02004745/* config parser for global "tune.pool-{low,high}-fd-ratio" */
4746static int cfg_parse_pool_fd_ratio(char **args, int section_type, struct proxy *curpx,
4747 struct proxy *defpx, const char *file, int line,
4748 char **err)
4749{
4750 int arg = -1;
4751
4752 if (too_many_args(1, args, err, NULL))
4753 return -1;
4754
4755 if (*(args[1]) != 0)
4756 arg = atoi(args[1]);
4757
4758 if (arg < 0 || arg > 100) {
4759 memprintf(err, "'%s' expects an integer argument between 0 and 100.", args[0]);
4760 return -1;
4761 }
4762
4763 if (args[0][10] == 'h')
4764 global.tune.pool_high_ratio = arg;
4765 else
4766 global.tune.pool_low_ratio = arg;
4767 return 0;
4768}
4769
4770/* config keyword parsers */
4771static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau76cc6992020-07-01 18:49:24 +02004772 { CFG_GLOBAL, "tune.idle-pool.shared", cfg_parse_idle_pool_shared },
Olivier Houchard88698d92019-04-16 19:07:22 +02004773 { CFG_GLOBAL, "tune.pool-high-fd-ratio", cfg_parse_pool_fd_ratio },
4774 { CFG_GLOBAL, "tune.pool-low-fd-ratio", cfg_parse_pool_fd_ratio },
4775 { 0, NULL, NULL }
4776}};
4777
4778INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
4779
Baptiste Assmanna68ca962015-04-14 01:15:08 +02004780/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02004781 * Local variables:
4782 * c-indent-level: 8
4783 * c-basic-offset: 8
4784 * End:
4785 */